Update with more iOS details.
[pwl6.git] / src / ext / hammer.js
1 /*! Hammer.JS - v1.0.10 - 2014-03-28
2 * http://eightmedia.github.io/hammer.js
3 *
4 * Copyright (c) 2014 Jorik Tangelder <j.tangelder@gmail.com>;
5 * Licensed under the MIT license */
6
7 (function(window, undefined) {
8 'use strict';
9
10 /**
11 * Hammer
12 * use this to create instances
13 * @param {HTMLElement} element
14 * @param {Object} options
15 * @returns {Hammer.Instance}
16 * @constructor
17 */
18 var Hammer = function(element, options) {
19 return new Hammer.Instance(element, options || {});
20 };
21
22 Hammer.VERSION = '1.0.10';
23
24 // default settings
25 Hammer.defaults = {
26 // add styles and attributes to the element to prevent the browser from doing
27 // its native behavior. this doesnt prevent the scrolling, but cancels
28 // the contextmenu, tap highlighting etc
29 // set to false to disable this
30 stop_browser_behavior: {
31 // this also triggers onselectstart=false for IE
32 userSelect : 'none',
33 // this makes the element blocking in IE10>, you could experiment with the value
34 // see for more options this issue; https://github.com/EightMedia/hammer.js/issues/241
35 touchAction : 'none',
36 touchCallout : 'none',
37 contentZooming : 'none',
38 userDrag : 'none',
39 tapHighlightColor: 'rgba(0,0,0,0)'
40 }
41
42 //
43 // more settings are defined per gesture at /gestures
44 //
45 };
46
47
48 // detect touchevents
49 Hammer.HAS_POINTEREVENTS = window.navigator.pointerEnabled || window.navigator.msPointerEnabled;
50 Hammer.HAS_TOUCHEVENTS = ('ontouchstart' in window);
51
52 // dont use mouseevents on mobile devices
53 Hammer.MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android|silk/i;
54 Hammer.NO_MOUSEEVENTS = Hammer.HAS_TOUCHEVENTS && window.navigator.userAgent.match(Hammer.MOBILE_REGEX);
55
56 // eventtypes per touchevent (start, move, end)
57 // are filled by Event.determineEventTypes on setup
58 Hammer.EVENT_TYPES = {};
59
60 // interval in which Hammer recalculates current velocity in ms
61 Hammer.UPDATE_VELOCITY_INTERVAL = 16;
62
63 // hammer document where the base events are added at
64 Hammer.DOCUMENT = window.document;
65
66 // define these also as vars, for better minification
67 // direction defines
68 var DIRECTION_DOWN = Hammer.DIRECTION_DOWN = 'down';
69 var DIRECTION_LEFT = Hammer.DIRECTION_LEFT = 'left';
70 var DIRECTION_UP = Hammer.DIRECTION_UP = 'up';
71 var DIRECTION_RIGHT = Hammer.DIRECTION_RIGHT = 'right';
72
73 // pointer type
74 var POINTER_MOUSE = Hammer.POINTER_MOUSE = 'mouse';
75 var POINTER_TOUCH = Hammer.POINTER_TOUCH = 'touch';
76 var POINTER_PEN = Hammer.POINTER_PEN = 'pen';
77
78 // touch event defines
79 var EVENT_START = Hammer.EVENT_START = 'start';
80 var EVENT_MOVE = Hammer.EVENT_MOVE = 'move';
81 var EVENT_END = Hammer.EVENT_END = 'end';
82
83
84 // plugins and gestures namespaces
85 Hammer.plugins = Hammer.plugins || {};
86 Hammer.gestures = Hammer.gestures || {};
87
88
89 // if the window events are set...
90 Hammer.READY = false;
91
92
93 /**
94 * setup events to detect gestures on the document
95 */
96 function setup() {
97 if(Hammer.READY) {
98 return;
99 }
100
101 // find what eventtypes we add listeners to
102 Event.determineEventTypes();
103
104 // Register all gestures inside Hammer.gestures
105 Utils.each(Hammer.gestures, function(gesture){
106 Detection.register(gesture);
107 });
108
109 // Add touch events on the document
110 Event.onTouch(Hammer.DOCUMENT, EVENT_MOVE, Detection.detect);
111 Event.onTouch(Hammer.DOCUMENT, EVENT_END, Detection.detect);
112
113 // Hammer is ready...!
114 Hammer.READY = true;
115 }
116
117 var Utils = Hammer.utils = {
118 /**
119 * extend method,
120 * also used for cloning when dest is an empty object
121 * @param {Object} dest
122 * @param {Object} src
123 * @parm {Boolean} merge do a merge
124 * @returns {Object} dest
125 */
126 extend: function extend(dest, src, merge) {
127 for(var key in src) {
128 if(dest[key] !== undefined && merge) {
129 continue;
130 }
131 dest[key] = src[key];
132 }
133 return dest;
134 },
135
136
137 /**
138 * for each
139 * @param obj
140 * @param iterator
141 */
142 each: function each(obj, iterator, context) {
143 var i, o;
144 // native forEach on arrays
145 if ('forEach' in obj) {
146 obj.forEach(iterator, context);
147 }
148 // arrays
149 else if(obj.length !== undefined) {
150 for(i=-1; (o=obj[++i]);) {
151 if (iterator.call(context, o, i, obj) === false) {
152 return;
153 }
154 }
155 }
156 // objects
157 else {
158 for(i in obj) {
159 if(obj.hasOwnProperty(i) &&
160 iterator.call(context, obj[i], i, obj) === false) {
161 return;
162 }
163 }
164 }
165 },
166
167
168 /**
169 * find if a string contains the needle
170 * @param {String} src
171 * @param {String} needle
172 * @returns {Boolean} found
173 */
174 inStr: function inStr(src, needle) {
175 return src.indexOf(needle) > -1;
176 },
177
178
179 /**
180 * find if a node is in the given parent
181 * used for event delegation tricks
182 * @param {HTMLElement} node
183 * @param {HTMLElement} parent
184 * @returns {boolean} has_parent
185 */
186 hasParent: function hasParent(node, parent) {
187 while(node) {
188 if(node == parent) {
189 return true;
190 }
191 node = node.parentNode;
192 }
193 return false;
194 },
195
196
197 /**
198 * get the center of all the touches
199 * @param {Array} touches
200 * @returns {Object} center pageXY clientXY
201 */
202 getCenter: function getCenter(touches) {
203 var pageX = []
204 , pageY = []
205 , clientX = []
206 , clientY = []
207 , min = Math.min
208 , max = Math.max;
209
210 // no need to loop when only one touch
211 if(touches.length === 1) {
212 return {
213 pageX: touches[0].pageX,
214 pageY: touches[0].pageY,
215 clientX: touches[0].clientX,
216 clientY: touches[0].clientY
217 };
218 }
219
220 Utils.each(touches, function(touch) {
221 pageX.push(touch.pageX);
222 pageY.push(touch.pageY);
223 clientX.push(touch.clientX);
224 clientY.push(touch.clientY);
225 });
226
227 return {
228 pageX: (min.apply(Math, pageX) + max.apply(Math, pageX)) / 2,
229 pageY: (min.apply(Math, pageY) + max.apply(Math, pageY)) / 2,
230 clientX: (min.apply(Math, clientX) + max.apply(Math, clientX)) / 2,
231 clientY: (min.apply(Math, clientY) + max.apply(Math, clientY)) / 2
232 };
233 },
234
235
236 /**
237 * calculate the velocity between two points
238 * @param {Number} delta_time
239 * @param {Number} delta_x
240 * @param {Number} delta_y
241 * @returns {Object} velocity
242 */
243 getVelocity: function getVelocity(delta_time, delta_x, delta_y) {
244 return {
245 x: Math.abs(delta_x / delta_time) || 0,
246 y: Math.abs(delta_y / delta_time) || 0
247 };
248 },
249
250
251 /**
252 * calculate the angle between two coordinates
253 * @param {Touch} touch1
254 * @param {Touch} touch2
255 * @returns {Number} angle
256 */
257 getAngle: function getAngle(touch1, touch2) {
258 var x = touch2.clientX - touch1.clientX
259 , y = touch2.clientY - touch1.clientY;
260 return Math.atan2(y, x) * 180 / Math.PI;
261 },
262
263
264 /**
265 * angle to direction define
266 * @param {Touch} touch1
267 * @param {Touch} touch2
268 * @returns {String} direction constant, like DIRECTION_LEFT
269 */
270 getDirection: function getDirection(touch1, touch2) {
271 var x = Math.abs(touch1.clientX - touch2.clientX)
272 , y = Math.abs(touch1.clientY - touch2.clientY);
273 if(x >= y) {
274 return touch1.clientX - touch2.clientX > 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
275 }
276 return touch1.clientY - touch2.clientY > 0 ? DIRECTION_UP : DIRECTION_DOWN;
277 },
278
279
280 /**
281 * calculate the distance between two touches
282 * @param {Touch} touch1
283 * @param {Touch} touch2
284 * @returns {Number} distance
285 */
286 getDistance: function getDistance(touch1, touch2) {
287 var x = touch2.clientX - touch1.clientX
288 , y = touch2.clientY - touch1.clientY;
289 return Math.sqrt((x * x) + (y * y));
290 },
291
292
293 /**
294 * calculate the scale factor between two touchLists (fingers)
295 * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
296 * @param {Array} start
297 * @param {Array} end
298 * @returns {Number} scale
299 */
300 getScale: function getScale(start, end) {
301 // need two fingers...
302 if(start.length >= 2 && end.length >= 2) {
303 return this.getDistance(end[0], end[1]) / this.getDistance(start[0], start[1]);
304 }
305 return 1;
306 },
307
308
309 /**
310 * calculate the rotation degrees between two touchLists (fingers)
311 * @param {Array} start
312 * @param {Array} end
313 * @returns {Number} rotation
314 */
315 getRotation: function getRotation(start, end) {
316 // need two fingers
317 if(start.length >= 2 && end.length >= 2) {
318 return this.getAngle(end[1], end[0]) - this.getAngle(start[1], start[0]);
319 }
320 return 0;
321 },
322
323
324 /**
325 * boolean if the direction is vertical
326 * @param {String} direction
327 * @returns {Boolean} is_vertical
328 */
329 isVertical: function isVertical(direction) {
330 return direction == DIRECTION_UP || direction == DIRECTION_DOWN;
331 },
332
333
334 /**
335 * toggle browser default behavior with css props
336 * @param {HtmlElement} element
337 * @param {Object} css_props
338 * @param {Boolean} toggle
339 */
340 toggleDefaultBehavior: function toggleDefaultBehavior(element, css_props, toggle) {
341 if(!css_props || !element || !element.style) {
342 return;
343 }
344
345 // with css properties for modern browsers
346 Utils.each(['webkit', 'moz', 'Moz', 'ms', 'o', ''], function setStyle(vendor) {
347 Utils.each(css_props, function(value, prop) {
348 // vender prefix at the property
349 if(vendor) {
350 prop = vendor + prop.substring(0, 1).toUpperCase() + prop.substring(1);
351 }
352 // set the style
353 if(prop in element.style) {
354 element.style[prop] = !toggle && value;
355 }
356 });
357 });
358
359 var false_fn = function(){ return false; };
360
361 // also the disable onselectstart
362 if(css_props.userSelect == 'none') {
363 element.onselectstart = !toggle && false_fn;
364 }
365 // and disable ondragstart
366 if(css_props.userDrag == 'none') {
367 element.ondragstart = !toggle && false_fn;
368 }
369 }
370 };
371
372
373 /**
374 * create new hammer instance
375 * all methods should return the instance itself, so it is chainable.
376 * @param {HTMLElement} element
377 * @param {Object} [options={}]
378 * @returns {Hammer.Instance}
379 * @constructor
380 */
381 Hammer.Instance = function(element, options) {
382 var self = this;
383
384 // setup HammerJS window events and register all gestures
385 // this also sets up the default options
386 setup();
387
388 this.element = element;
389
390 // start/stop detection option
391 this.enabled = true;
392
393 // merge options
394 this.options = Utils.extend(
395 Utils.extend({}, Hammer.defaults),
396 options || {});
397
398 // add some css to the element to prevent the browser from doing its native behavoir
399 if(this.options.stop_browser_behavior) {
400 Utils.toggleDefaultBehavior(this.element, this.options.stop_browser_behavior, false);
401 }
402
403 // start detection on touchstart
404 this.eventStartHandler = Event.onTouch(element, EVENT_START, function(ev) {
405 if(self.enabled) {
406 Detection.startDetect(self, ev);
407 }
408 });
409
410 // keep a list of user event handlers which needs to be removed when calling 'dispose'
411 this.eventHandlers = [];
412
413 // return instance
414 return this;
415 };
416
417
418 Hammer.Instance.prototype = {
419 /**
420 * bind events to the instance
421 * @param {String} gesture
422 * @param {Function} handler
423 * @returns {Hammer.Instance}
424 */
425 on: function onEvent(gesture, handler) {
426 var gestures = gesture.split(' ');
427 Utils.each(gestures, function(gesture) {
428 this.element.addEventListener(gesture, handler, false);
429 this.eventHandlers.push({ gesture: gesture, handler: handler });
430 }, this);
431 return this;
432 },
433
434
435 /**
436 * unbind events to the instance
437 * @param {String} gesture
438 * @param {Function} handler
439 * @returns {Hammer.Instance}
440 */
441 off: function offEvent(gesture, handler) {
442 var gestures = gesture.split(' ')
443 , i, eh;
444 Utils.each(gestures, function(gesture) {
445 this.element.removeEventListener(gesture, handler, false);
446
447 // remove the event handler from the internal list
448 for(i=-1; (eh=this.eventHandlers[++i]);) {
449 if(eh.gesture === gesture && eh.handler === handler) {
450 this.eventHandlers.splice(i, 1);
451 }
452 }
453 }, this);
454 return this;
455 },
456
457
458 /**
459 * trigger gesture event
460 * @param {String} gesture
461 * @param {Object} [eventData]
462 * @returns {Hammer.Instance}
463 */
464 trigger: function triggerEvent(gesture, eventData) {
465 // optional
466 if(!eventData) {
467 eventData = {};
468 }
469
470 // create DOM event
471 var event = Hammer.DOCUMENT.createEvent('Event');
472 event.initEvent(gesture, true, true);
473 event.gesture = eventData;
474
475 // trigger on the target if it is in the instance element,
476 // this is for event delegation tricks
477 var element = this.element;
478 if(Utils.hasParent(eventData.target, element)) {
479 element = eventData.target;
480 }
481
482 element.dispatchEvent(event);
483 return this;
484 },
485
486
487 /**
488 * enable of disable hammer.js detection
489 * @param {Boolean} state
490 * @returns {Hammer.Instance}
491 */
492 enable: function enable(state) {
493 this.enabled = state;
494 return this;
495 },
496
497
498 /**
499 * dispose this hammer instance
500 * @returns {Hammer.Instance}
501 */
502 dispose: function dispose() {
503 var i, eh;
504
505 // undo all changes made by stop_browser_behavior
506 if(this.options.stop_browser_behavior) {
507 Utils.toggleDefaultBehavior(this.element, this.options.stop_browser_behavior, true);
508 }
509
510 // unbind all custom event handlers
511 for(i=-1; (eh=this.eventHandlers[++i]);) {
512 this.element.removeEventListener(eh.gesture, eh.handler, false);
513 }
514 this.eventHandlers = [];
515
516 // unbind the start event listener
517 Event.unbindDom(this.element, Hammer.EVENT_TYPES[EVENT_START], this.eventStartHandler);
518
519 return null;
520 }
521 };
522
523
524 /**
525 * this holds the last move event,
526 * used to fix empty touchend issue
527 * see the onTouch event for an explanation
528 * @type {Object}
529 */
530 var last_move_event = null;
531
532 /**
533 * when the mouse is hold down, this is true
534 * @type {Boolean}
535 */
536 var should_detect = false;
537
538 /**
539 * when touch events have been fired, this is true
540 * @type {Boolean}
541 */
542 var touch_triggered = false;
543
544
545 var Event = Hammer.event = {
546 /**
547 * simple addEventListener
548 * @param {HTMLElement} element
549 * @param {String} type
550 * @param {Function} handler
551 */
552 bindDom: function(element, type, handler) {
553 var types = type.split(' ');
554 Utils.each(types, function(type){
555 element.addEventListener(type, handler, false);
556 });
557 },
558
559
560 /**
561 * simple removeEventListener
562 * @param {HTMLElement} element
563 * @param {String} type
564 * @param {Function} handler
565 */
566 unbindDom: function(element, type, handler) {
567 var types = type.split(' ');
568 Utils.each(types, function(type){
569 element.removeEventListener(type, handler, false);
570 });
571 },
572
573
574 /**
575 * touch events with mouse fallback
576 * @param {HTMLElement} element
577 * @param {String} eventType like EVENT_MOVE
578 * @param {Function} handler
579 */
580 onTouch: function onTouch(element, eventType, handler) {
581 var self = this;
582
583
584 var bindDomOnTouch = function bindDomOnTouch(ev) {
585 var srcEventType = ev.type.toLowerCase();
586
587 // onmouseup, but when touchend has been fired we do nothing.
588 // this is for touchdevices which also fire a mouseup on touchend
589 if(Utils.inStr(srcEventType, 'mouse') && touch_triggered) {
590 return;
591 }
592
593 // mousebutton must be down or a touch event
594 else if(Utils.inStr(srcEventType, 'touch') || // touch events are always on screen
595 Utils.inStr(srcEventType, 'pointerdown') || // pointerevents touch
596 (Utils.inStr(srcEventType, 'mouse') && ev.which === 1) // mouse is pressed
597 ) {
598 should_detect = true;
599 }
600
601 // mouse isn't pressed
602 else if(Utils.inStr(srcEventType, 'mouse') && !ev.which) {
603 should_detect = false;
604 }
605
606
607 // we are in a touch event, set the touch triggered bool to true,
608 // this for the conflicts that may occur on ios and android
609 if(Utils.inStr(srcEventType, 'touch') || Utils.inStr(srcEventType, 'pointer')) {
610 touch_triggered = true;
611 }
612
613 // count the total touches on the screen
614 var count_touches = 0;
615
616 // when touch has been triggered in this detection session
617 // and we are now handling a mouse event, we stop that to prevent conflicts
618 if(should_detect) {
619 // update pointerevent
620 if(Hammer.HAS_POINTEREVENTS && eventType != EVENT_END) {
621 count_touches = PointerEvent.updatePointer(eventType, ev);
622 }
623 // touch
624 else if(Utils.inStr(srcEventType, 'touch')) {
625 count_touches = ev.touches.length;
626 }
627 // mouse
628 else if(!touch_triggered) {
629 count_touches = Utils.inStr(srcEventType, 'up') ? 0 : 1;
630 }
631
632
633 // if we are in a end event, but when we remove one touch and
634 // we still have enough, set eventType to move
635 if(count_touches > 0 && eventType == EVENT_END) {
636 eventType = EVENT_MOVE;
637 }
638 // no touches, force the end event
639 else if(!count_touches) {
640 eventType = EVENT_END;
641 }
642
643 // store the last move event
644 if(count_touches || last_move_event === null) {
645 last_move_event = ev;
646 }
647
648
649 // trigger the handler
650 handler.call(Detection, self.collectEventData(element, eventType,
651 self.getTouchList(last_move_event, eventType),
652 ev) );
653
654 // remove pointerevent from list
655 if(Hammer.HAS_POINTEREVENTS && eventType == EVENT_END) {
656 count_touches = PointerEvent.updatePointer(eventType, ev);
657 }
658 }
659
660 // on the end we reset everything
661 if(!count_touches) {
662 last_move_event = null;
663 should_detect = false;
664 touch_triggered = false;
665 PointerEvent.reset();
666 }
667 };
668
669 this.bindDom(element, Hammer.EVENT_TYPES[eventType], bindDomOnTouch);
670
671 // return the bound function to be able to unbind it later
672 return bindDomOnTouch;
673 },
674
675
676 /**
677 * we have different events for each device/browser
678 * determine what we need and set them in the Hammer.EVENT_TYPES constant
679 */
680 determineEventTypes: function determineEventTypes() {
681 // determine the eventtype we want to set
682 var types;
683
684 // pointerEvents magic
685 if(Hammer.HAS_POINTEREVENTS) {
686 types = PointerEvent.getEvents();
687 }
688 // on Android, iOS, blackberry, windows mobile we dont want any mouseevents
689 else if(Hammer.NO_MOUSEEVENTS) {
690 types = [
691 'touchstart',
692 'touchmove',
693 'touchend touchcancel'];
694 }
695 // for non pointer events browsers and mixed browsers,
696 // like chrome on windows8 touch laptop
697 else {
698 types = [
699 'touchstart mousedown',
700 'touchmove mousemove',
701 'touchend touchcancel mouseup'];
702 }
703
704 Hammer.EVENT_TYPES[EVENT_START] = types[0];
705 Hammer.EVENT_TYPES[EVENT_MOVE] = types[1];
706 Hammer.EVENT_TYPES[EVENT_END] = types[2];
707 },
708
709
710 /**
711 * create touchlist depending on the event
712 * @param {Object} ev
713 * @param {String} eventType used by the fakemultitouch plugin
714 */
715 getTouchList: function getTouchList(ev/*, eventType*/) {
716 // get the fake pointerEvent touchlist
717 if(Hammer.HAS_POINTEREVENTS) {
718 return PointerEvent.getTouchList();
719 }
720
721 // get the touchlist
722 if(ev.touches) {
723 return ev.touches;
724 }
725
726 // make fake touchlist from mouse position
727 ev.identifier = 1;
728 return [ev];
729 },
730
731
732 /**
733 * collect event data for Hammer js
734 * @param {HTMLElement} element
735 * @param {String} eventType like EVENT_MOVE
736 * @param {Object} eventData
737 */
738 collectEventData: function collectEventData(element, eventType, touches, ev) {
739 // find out pointerType
740 var pointerType = POINTER_TOUCH;
741 if(Utils.inStr(ev.type, 'mouse') || PointerEvent.matchType(POINTER_MOUSE, ev)) {
742 pointerType = POINTER_MOUSE;
743 }
744
745 return {
746 center : Utils.getCenter(touches),
747 timeStamp : Date.now(),
748 target : ev.target,
749 touches : touches,
750 eventType : eventType,
751 pointerType: pointerType,
752 srcEvent : ev,
753
754 /**
755 * prevent the browser default actions
756 * mostly used to disable scrolling of the browser
757 */
758 preventDefault: function() {
759 var srcEvent = this.srcEvent;
760 srcEvent.preventManipulation && srcEvent.preventManipulation();
761 srcEvent.preventDefault && srcEvent.preventDefault();
762 },
763
764 /**
765 * stop bubbling the event up to its parents
766 */
767 stopPropagation: function() {
768 this.srcEvent.stopPropagation();
769 },
770
771 /**
772 * immediately stop gesture detection
773 * might be useful after a swipe was detected
774 * @return {*}
775 */
776 stopDetect: function() {
777 return Detection.stopDetect();
778 }
779 };
780 }
781 };
782
783 var PointerEvent = Hammer.PointerEvent = {
784 /**
785 * holds all pointers
786 * @type {Object}
787 */
788 pointers: {},
789
790 /**
791 * get a list of pointers
792 * @returns {Array} touchlist
793 */
794 getTouchList: function getTouchList() {
795 var touchlist = [];
796 // we can use forEach since pointerEvents only is in IE10
797 Utils.each(this.pointers, function(pointer){
798 touchlist.push(pointer);
799 });
800
801 return touchlist;
802 },
803
804 /**
805 * update the position of a pointer
806 * @param {String} type EVENT_END
807 * @param {Object} pointerEvent
808 */
809 updatePointer: function updatePointer(type, pointerEvent) {
810 if(type == EVENT_END) {
811 delete this.pointers[pointerEvent.pointerId];
812 }
813 else {
814 pointerEvent.identifier = pointerEvent.pointerId;
815 this.pointers[pointerEvent.pointerId] = pointerEvent;
816 }
817
818 // it's save to use Object.keys, since pointerEvents are only in newer browsers
819 return Object.keys(this.pointers).length;
820 },
821
822 /**
823 * check if ev matches pointertype
824 * @param {String} pointerType POINTER_MOUSE
825 * @param {PointerEvent} ev
826 */
827 matchType: function matchType(pointerType, ev) {
828 if(!ev.pointerType) {
829 return false;
830 }
831
832 var pt = ev.pointerType
833 , types = {};
834
835 types[POINTER_MOUSE] = (pt === POINTER_MOUSE);
836 types[POINTER_TOUCH] = (pt === POINTER_TOUCH);
837 types[POINTER_PEN] = (pt === POINTER_PEN);
838 return types[pointerType];
839 },
840
841
842 /**
843 * get events
844 */
845 getEvents: function getEvents() {
846 return [
847 'pointerdown MSPointerDown',
848 'pointermove MSPointerMove',
849 'pointerup pointercancel MSPointerUp MSPointerCancel'
850 ];
851 },
852
853 /**
854 * reset the list
855 */
856 reset: function resetList() {
857 this.pointers = {};
858 }
859 };
860
861
862 var Detection = Hammer.detection = {
863 // contains all registred Hammer.gestures in the correct order
864 gestures: [],
865
866 // data of the current Hammer.gesture detection session
867 current : null,
868
869 // the previous Hammer.gesture session data
870 // is a full clone of the previous gesture.current object
871 previous: null,
872
873 // when this becomes true, no gestures are fired
874 stopped : false,
875
876
877 /**
878 * start Hammer.gesture detection
879 * @param {Hammer.Instance} inst
880 * @param {Object} eventData
881 */
882 startDetect: function startDetect(inst, eventData) {
883 // already busy with a Hammer.gesture detection on an element
884 if(this.current) {
885 return;
886 }
887
888 this.stopped = false;
889
890 // holds current session
891 this.current = {
892 inst : inst, // reference to HammerInstance we're working for
893 startEvent : Utils.extend({}, eventData), // start eventData for distances, timing etc
894 lastEvent : false, // last eventData
895 lastVelocityEvent : false, // last eventData for velocity.
896 velocity : false, // current velocity
897 name : '' // current gesture we're in/detected, can be 'tap', 'hold' etc
898 };
899
900 this.detect(eventData);
901 },
902
903
904 /**
905 * Hammer.gesture detection
906 * @param {Object} eventData
907 */
908 detect: function detect(eventData) {
909 if(!this.current || this.stopped) {
910 return;
911 }
912
913 // extend event data with calculations about scale, distance etc
914 eventData = this.extendEventData(eventData);
915
916 // hammer instance and instance options
917 var inst = this.current.inst,
918 inst_options = inst.options;
919
920 // call Hammer.gesture handlers
921 Utils.each(this.gestures, function triggerGesture(gesture) {
922 // only when the instance options have enabled this gesture
923 if(!this.stopped && inst_options[gesture.name] !== false && inst.enabled !== false ) {
924 // if a handler returns false, we stop with the detection
925 if(gesture.handler.call(gesture, eventData, inst) === false) {
926 this.stopDetect();
927 return false;
928 }
929 }
930 }, this);
931
932 // store as previous event event
933 if(this.current) {
934 this.current.lastEvent = eventData;
935 }
936
937 // end event, but not the last touch, so dont stop
938 if(eventData.eventType == EVENT_END && !eventData.touches.length - 1) {
939 this.stopDetect();
940 }
941
942 return eventData;
943 },
944
945
946 /**
947 * clear the Hammer.gesture vars
948 * this is called on endDetect, but can also be used when a final Hammer.gesture has been detected
949 * to stop other Hammer.gestures from being fired
950 */
951 stopDetect: function stopDetect() {
952 // clone current data to the store as the previous gesture
953 // used for the double tap gesture, since this is an other gesture detect session
954 this.previous = Utils.extend({}, this.current);
955
956 // reset the current
957 this.current = null;
958
959 // stopped!
960 this.stopped = true;
961 },
962
963
964 /**
965 * calculate velocity
966 * @param {Object} ev
967 * @param {Number} delta_time
968 * @param {Number} delta_x
969 * @param {Number} delta_y
970 */
971 getVelocityData: function getVelocityData(ev, delta_time, delta_x, delta_y) {
972 var cur = this.current
973 , velocityEv = cur.lastVelocityEvent
974 , velocity = cur.velocity;
975
976 // calculate velocity every x ms
977 if (velocityEv && ev.timeStamp - velocityEv.timeStamp > Hammer.UPDATE_VELOCITY_INTERVAL) {
978 velocity = Utils.getVelocity(ev.timeStamp - velocityEv.timeStamp,
979 ev.center.clientX - velocityEv.center.clientX,
980 ev.center.clientY - velocityEv.center.clientY);
981 cur.lastVelocityEvent = ev;
982 }
983 else if(!cur.velocity) {
984 velocity = Utils.getVelocity(delta_time, delta_x, delta_y);
985 cur.lastVelocityEvent = ev;
986 }
987
988 cur.velocity = velocity;
989
990 ev.velocityX = velocity.x;
991 ev.velocityY = velocity.y;
992 },
993
994
995 /**
996 * calculate interim angle and direction
997 * @param {Object} ev
998 */
999 getInterimData: function getInterimData(ev) {
1000 var lastEvent = this.current.lastEvent
1001 , angle
1002 , direction;
1003
1004 // end events (e.g. dragend) don't have useful values for interimDirection & interimAngle
1005 // because the previous event has exactly the same coordinates
1006 // so for end events, take the previous values of interimDirection & interimAngle
1007 // instead of recalculating them and getting a spurious '0'
1008 if(ev.eventType == EVENT_END) {
1009 angle = lastEvent && lastEvent.interimAngle;
1010 direction = lastEvent && lastEvent.interimDirection;
1011 }
1012 else {
1013 angle = lastEvent && Utils.getAngle(lastEvent.center, ev.center);
1014 direction = lastEvent && Utils.getDirection(lastEvent.center, ev.center);
1015 }
1016
1017 ev.interimAngle = angle;
1018 ev.interimDirection = direction;
1019 },
1020
1021
1022 /**
1023 * extend eventData for Hammer.gestures
1024 * @param {Object} evData
1025 * @returns {Object} evData
1026 */
1027 extendEventData: function extendEventData(ev) {
1028 var cur = this.current
1029 , startEv = cur.startEvent;
1030
1031 // if the touches change, set the new touches over the startEvent touches
1032 // this because touchevents don't have all the touches on touchstart, or the
1033 // user must place his fingers at the EXACT same time on the screen, which is not realistic
1034 // but, sometimes it happens that both fingers are touching at the EXACT same time
1035 if(ev.touches.length != startEv.touches.length || ev.touches === startEv.touches) {
1036 // extend 1 level deep to get the touchlist with the touch objects
1037 startEv.touches = [];
1038 Utils.each(ev.touches, function(touch) {
1039 startEv.touches.push(Utils.extend({}, touch));
1040 });
1041 }
1042
1043 var delta_time = ev.timeStamp - startEv.timeStamp
1044 , delta_x = ev.center.clientX - startEv.center.clientX
1045 , delta_y = ev.center.clientY - startEv.center.clientY;
1046
1047 this.getVelocityData(ev, delta_time, delta_x, delta_y);
1048 this.getInterimData(ev);
1049
1050 Utils.extend(ev, {
1051 startEvent: startEv,
1052
1053 deltaTime : delta_time,
1054 deltaX : delta_x,
1055 deltaY : delta_y,
1056
1057 distance : Utils.getDistance(startEv.center, ev.center),
1058 angle : Utils.getAngle(startEv.center, ev.center),
1059 direction : Utils.getDirection(startEv.center, ev.center),
1060
1061 scale : Utils.getScale(startEv.touches, ev.touches),
1062 rotation : Utils.getRotation(startEv.touches, ev.touches)
1063 });
1064
1065 return ev;
1066 },
1067
1068
1069 /**
1070 * register new gesture
1071 * @param {Object} gesture object, see gestures.js for documentation
1072 * @returns {Array} gestures
1073 */
1074 register: function register(gesture) {
1075 // add an enable gesture options if there is no given
1076 var options = gesture.defaults || {};
1077 if(options[gesture.name] === undefined) {
1078 options[gesture.name] = true;
1079 }
1080
1081 // extend Hammer default options with the Hammer.gesture options
1082 Utils.extend(Hammer.defaults, options, true);
1083
1084 // set its index
1085 gesture.index = gesture.index || 1000;
1086
1087 // add Hammer.gesture to the list
1088 this.gestures.push(gesture);
1089
1090 // sort the list by index
1091 this.gestures.sort(function(a, b) {
1092 if(a.index < b.index) { return -1; }
1093 if(a.index > b.index) { return 1; }
1094 return 0;
1095 });
1096
1097 return this.gestures;
1098 }
1099 };
1100
1101
1102 /**
1103 * Drag
1104 * Move with x fingers (default 1) around on the page. Blocking the scrolling when
1105 * moving left and right is a good practice. When all the drag events are blocking
1106 * you disable scrolling on that area.
1107 * @events drag, drapleft, dragright, dragup, dragdown
1108 */
1109 Hammer.gestures.Drag = {
1110 name : 'drag',
1111 index : 50,
1112 defaults : {
1113 drag_min_distance : 10,
1114
1115 // Set correct_for_drag_min_distance to true to make the starting point of the drag
1116 // be calculated from where the drag was triggered, not from where the touch started.
1117 // Useful to avoid a jerk-starting drag, which can make fine-adjustments
1118 // through dragging difficult, and be visually unappealing.
1119 correct_for_drag_min_distance: true,
1120
1121 // set 0 for unlimited, but this can conflict with transform
1122 drag_max_touches : 1,
1123
1124 // prevent default browser behavior when dragging occurs
1125 // be careful with it, it makes the element a blocking element
1126 // when you are using the drag gesture, it is a good practice to set this true
1127 drag_block_horizontal : false,
1128 drag_block_vertical : false,
1129
1130 // drag_lock_to_axis keeps the drag gesture on the axis that it started on,
1131 // It disallows vertical directions if the initial direction was horizontal, and vice versa.
1132 drag_lock_to_axis : false,
1133
1134 // drag lock only kicks in when distance > drag_lock_min_distance
1135 // This way, locking occurs only when the distance has become large enough to reliably determine the direction
1136 drag_lock_min_distance : 25
1137 },
1138
1139 triggered: false,
1140 handler : function dragGesture(ev, inst) {
1141 var cur = Detection.current;
1142
1143 // current gesture isnt drag, but dragged is true
1144 // this means an other gesture is busy. now call dragend
1145 if(cur.name != this.name && this.triggered) {
1146 inst.trigger(this.name + 'end', ev);
1147 this.triggered = false;
1148 return;
1149 }
1150
1151 // max touches
1152 if(inst.options.drag_max_touches > 0 &&
1153 ev.touches.length > inst.options.drag_max_touches) {
1154 return;
1155 }
1156
1157 switch(ev.eventType) {
1158 case EVENT_START:
1159 this.triggered = false;
1160 break;
1161
1162 case EVENT_MOVE:
1163 // when the distance we moved is too small we skip this gesture
1164 // or we can be already in dragging
1165 if(ev.distance < inst.options.drag_min_distance &&
1166 cur.name != this.name) {
1167 return;
1168 }
1169
1170 var startCenter = cur.startEvent.center;
1171
1172 // we are dragging!
1173 if(cur.name != this.name) {
1174 cur.name = this.name;
1175 if(inst.options.correct_for_drag_min_distance && ev.distance > 0) {
1176 // When a drag is triggered, set the event center to drag_min_distance pixels from the original event center.
1177 // Without this correction, the dragged distance would jumpstart at drag_min_distance pixels instead of at 0.
1178 // It might be useful to save the original start point somewhere
1179 var factor = Math.abs(inst.options.drag_min_distance / ev.distance);
1180 startCenter.pageX += ev.deltaX * factor;
1181 startCenter.pageY += ev.deltaY * factor;
1182 startCenter.clientX += ev.deltaX * factor;
1183 startCenter.clientY += ev.deltaY * factor;
1184
1185 // recalculate event data using new start point
1186 ev = Detection.extendEventData(ev);
1187 }
1188 }
1189
1190 // lock drag to axis?
1191 if(cur.lastEvent.drag_locked_to_axis ||
1192 ( inst.options.drag_lock_to_axis &&
1193 inst.options.drag_lock_min_distance <= ev.distance
1194 )) {
1195 ev.drag_locked_to_axis = true;
1196 }
1197 var last_direction = cur.lastEvent.direction;
1198 if(ev.drag_locked_to_axis && last_direction !== ev.direction) {
1199 // keep direction on the axis that the drag gesture started on
1200 if(Utils.isVertical(last_direction)) {
1201 ev.direction = (ev.deltaY < 0) ? DIRECTION_UP : DIRECTION_DOWN;
1202 }
1203 else {
1204 ev.direction = (ev.deltaX < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;
1205 }
1206 }
1207
1208 // first time, trigger dragstart event
1209 if(!this.triggered) {
1210 inst.trigger(this.name + 'start', ev);
1211 this.triggered = true;
1212 }
1213
1214 // trigger events
1215 inst.trigger(this.name, ev);
1216 inst.trigger(this.name + ev.direction, ev);
1217
1218 var is_vertical = Utils.isVertical(ev.direction);
1219
1220 // block the browser events
1221 if((inst.options.drag_block_vertical && is_vertical) ||
1222 (inst.options.drag_block_horizontal && !is_vertical)) {
1223 ev.preventDefault();
1224 }
1225 break;
1226
1227 case EVENT_END:
1228 // trigger dragend
1229 if(this.triggered) {
1230 inst.trigger(this.name + 'end', ev);
1231 }
1232
1233 this.triggered = false;
1234 break;
1235 }
1236 }
1237 };
1238
1239 /**
1240 * Hold
1241 * Touch stays at the same place for x time
1242 * @events hold
1243 */
1244 Hammer.gestures.Hold = {
1245 name : 'hold',
1246 index : 10,
1247 defaults: {
1248 hold_timeout : 500,
1249 hold_threshold: 2
1250 },
1251 timer : null,
1252
1253 handler : function holdGesture(ev, inst) {
1254 switch(ev.eventType) {
1255 case EVENT_START:
1256 // clear any running timers
1257 clearTimeout(this.timer);
1258
1259 // set the gesture so we can check in the timeout if it still is
1260 Detection.current.name = this.name;
1261
1262 // set timer and if after the timeout it still is hold,
1263 // we trigger the hold event
1264 this.timer = setTimeout(function() {
1265 if(Detection.current.name == 'hold') {
1266 inst.trigger('hold', ev);
1267 }
1268 }, inst.options.hold_timeout);
1269 break;
1270
1271 // when you move or end we clear the timer
1272 case EVENT_MOVE:
1273 if(ev.distance > inst.options.hold_threshold) {
1274 clearTimeout(this.timer);
1275 }
1276 break;
1277
1278 case EVENT_END:
1279 clearTimeout(this.timer);
1280 break;
1281 }
1282 }
1283 };
1284
1285 /**
1286 * Release
1287 * Called as last, tells the user has released the screen
1288 * @events release
1289 */
1290 Hammer.gestures.Release = {
1291 name : 'release',
1292 index : Infinity,
1293 handler: function releaseGesture(ev, inst) {
1294 if(ev.eventType == EVENT_END) {
1295 inst.trigger(this.name, ev);
1296 }
1297 }
1298 };
1299
1300 /**
1301 * Swipe
1302 * triggers swipe events when the end velocity is above the threshold
1303 * for best usage, set prevent_default (on the drag gesture) to true
1304 * @events swipe, swipeleft, swiperight, swipeup, swipedown
1305 */
1306 Hammer.gestures.Swipe = {
1307 name : 'swipe',
1308 index : 40,
1309 defaults: {
1310 swipe_min_touches: 1,
1311 swipe_max_touches: 1,
1312 swipe_velocity : 0.7
1313 },
1314 handler : function swipeGesture(ev, inst) {
1315 if(ev.eventType == EVENT_END) {
1316 // max touches
1317 if(ev.touches.length < inst.options.swipe_min_touches ||
1318 ev.touches.length > inst.options.swipe_max_touches) {
1319 return;
1320 }
1321
1322 // when the distance we moved is too small we skip this gesture
1323 // or we can be already in dragging
1324 if(ev.velocityX > inst.options.swipe_velocity ||
1325 ev.velocityY > inst.options.swipe_velocity) {
1326 // trigger swipe events
1327 inst.trigger(this.name, ev);
1328 inst.trigger(this.name + ev.direction, ev);
1329 }
1330 }
1331 }
1332 };
1333
1334 /**
1335 * Tap/DoubleTap
1336 * Quick touch at a place or double at the same place
1337 * @events tap, doubletap
1338 */
1339 Hammer.gestures.Tap = {
1340 name : 'tap',
1341 index : 100,
1342 defaults: {
1343 tap_max_touchtime : 250,
1344 tap_max_distance : 10,
1345 tap_always : true,
1346 doubletap_distance: 20,
1347 doubletap_interval: 300
1348 },
1349
1350 has_moved: false,
1351
1352 handler : function tapGesture(ev, inst) {
1353 var prev, since_prev, did_doubletap;
1354
1355 // reset moved state
1356 if(ev.eventType == EVENT_START) {
1357 this.has_moved = false;
1358 }
1359
1360 // Track the distance we've moved. If it's above the max ONCE, remember that (fixes #406).
1361 else if(ev.eventType == EVENT_MOVE && !this.moved) {
1362 this.has_moved = (ev.distance > inst.options.tap_max_distance);
1363 }
1364
1365 else if(ev.eventType == EVENT_END &&
1366 ev.srcEvent.type != 'touchcancel' &&
1367 ev.deltaTime < inst.options.tap_max_touchtime && !this.has_moved) {
1368
1369 // previous gesture, for the double tap since these are two different gesture detections
1370 prev = Detection.previous;
1371 since_prev = prev && prev.lastEvent && ev.timeStamp - prev.lastEvent.timeStamp;
1372 did_doubletap = false;
1373
1374 // check if double tap
1375 if(prev && prev.name == 'tap' &&
1376 (since_prev && since_prev < inst.options.doubletap_interval) &&
1377 ev.distance < inst.options.doubletap_distance) {
1378 inst.trigger('doubletap', ev);
1379 did_doubletap = true;
1380 }
1381
1382 // do a single tap
1383 if(!did_doubletap || inst.options.tap_always) {
1384 Detection.current.name = 'tap';
1385 inst.trigger(Detection.current.name, ev);
1386 }
1387 }
1388 }
1389 };
1390
1391 /**
1392 * Touch
1393 * Called as first, tells the user has touched the screen
1394 * @events touch
1395 */
1396 Hammer.gestures.Touch = {
1397 name : 'touch',
1398 index : -Infinity,
1399 defaults: {
1400 // call preventDefault at touchstart, and makes the element blocking by
1401 // disabling the scrolling of the page, but it improves gestures like
1402 // transforming and dragging.
1403 // be careful with using this, it can be very annoying for users to be stuck
1404 // on the page
1405 prevent_default : false,
1406
1407 // disable mouse events, so only touch (or pen!) input triggers events
1408 prevent_mouseevents: false
1409 },
1410 handler : function touchGesture(ev, inst) {
1411 if(inst.options.prevent_mouseevents &&
1412 ev.pointerType == POINTER_MOUSE) {
1413 ev.stopDetect();
1414 return;
1415 }
1416
1417 if(inst.options.prevent_default) {
1418 ev.preventDefault();
1419 }
1420
1421 if(ev.eventType == EVENT_START) {
1422 inst.trigger(this.name, ev);
1423 }
1424 }
1425 };
1426
1427
1428 /**
1429 * Transform
1430 * User want to scale or rotate with 2 fingers
1431 * @events transform, pinch, pinchin, pinchout, rotate
1432 */
1433 Hammer.gestures.Transform = {
1434 name : 'transform',
1435 index : 45,
1436 defaults : {
1437 // factor, no scale is 1, zoomin is to 0 and zoomout until higher then 1
1438 transform_min_scale : 0.01,
1439 // rotation in degrees
1440 transform_min_rotation : 1,
1441 // prevent default browser behavior when two touches are on the screen
1442 // but it makes the element a blocking element
1443 // when you are using the transform gesture, it is a good practice to set this true
1444 transform_always_block : false,
1445 // ensures that all touches occurred within the instance element
1446 transform_within_instance: false
1447 },
1448
1449 triggered: false,
1450
1451 handler : function transformGesture(ev, inst) {
1452 // current gesture isnt drag, but dragged is true
1453 // this means an other gesture is busy. now call dragend
1454 if(Detection.current.name != this.name && this.triggered) {
1455 inst.trigger(this.name + 'end', ev);
1456 this.triggered = false;
1457 return;
1458 }
1459
1460 // at least multitouch
1461 if(ev.touches.length < 2) {
1462 return;
1463 }
1464
1465 // prevent default when two fingers are on the screen
1466 if(inst.options.transform_always_block) {
1467 ev.preventDefault();
1468 }
1469
1470 // check if all touches occurred within the instance element
1471 if(inst.options.transform_within_instance) {
1472 for(var i=-1; ev.touches[++i];) {
1473 if(!Utils.hasParent(ev.touches[i].target, inst.element)) {
1474 return;
1475 }
1476 }
1477 }
1478
1479 switch(ev.eventType) {
1480 case EVENT_START:
1481 this.triggered = false;
1482 break;
1483
1484 case EVENT_MOVE:
1485 var scale_threshold = Math.abs(1 - ev.scale);
1486 var rotation_threshold = Math.abs(ev.rotation);
1487
1488 // when the distance we moved is too small we skip this gesture
1489 // or we can be already in dragging
1490 if(scale_threshold < inst.options.transform_min_scale &&
1491 rotation_threshold < inst.options.transform_min_rotation) {
1492 return;
1493 }
1494
1495 // we are transforming!
1496 Detection.current.name = this.name;
1497
1498 // first time, trigger dragstart event
1499 if(!this.triggered) {
1500 inst.trigger(this.name + 'start', ev);
1501 this.triggered = true;
1502 }
1503
1504 inst.trigger(this.name, ev); // basic transform event
1505
1506 // trigger rotate event
1507 if(rotation_threshold > inst.options.transform_min_rotation) {
1508 inst.trigger('rotate', ev);
1509 }
1510
1511 // trigger pinch event
1512 if(scale_threshold > inst.options.transform_min_scale) {
1513 inst.trigger('pinch', ev);
1514 inst.trigger('pinch' + (ev.scale<1 ? 'in' : 'out'), ev);
1515 }
1516 break;
1517
1518 case EVENT_END:
1519 // trigger dragend
1520 if(this.triggered) {
1521 inst.trigger(this.name + 'end', ev);
1522 }
1523
1524 this.triggered = false;
1525 break;
1526 }
1527 }
1528 };
1529
1530 // AMD export
1531 if(typeof define == 'function' && define.amd) {
1532 define(function(){
1533 return Hammer;
1534 });
1535 }
1536 // commonjs export
1537 else if(typeof module == 'object' && module.exports) {
1538 module.exports = Hammer;
1539 }
1540 // browser export
1541 else {
1542 window.Hammer = Hammer;
1543 }
1544
1545 })(window);