2 * Hammer.JS - v1.0.5 - 2013-04-07
\r
3 * http://eightmedia.github.com/hammer.js
\r
4 * Jorik Tangelder <j.tangelder@gmail.com>, MIT license
\r
7 ( function( Math, window, document, undefined ){
\r
9 var ELEENT_LIST = [],
\r
12 ABS = new Function( 'v', 'return v<0?-v:v' );
\r
14 X.UI.Gesture = Hammer;
\r
16 function Hammer( uinodeRoot, uinode, type ){
\r
17 this.uinode = uinode;
\r
18 this.enabled = true;
\r
20 Hammer.startup && Hammer.startup( uinodeRoot );
\r
22 this.options = Hammer.defaults;
\r
24 // start detection on touchstart
\r
25 Utils.addEvents( uinode, Hammer.EVENT_TYPES_START, this );
\r
27 this.listen( type );
\r
30 Hammer.defaults = {};
\r
32 Hammer.prototype.handleEvent = function( e ){
\r
33 //var sourceEventType = e.type.toLowerCase();
\r
35 var type = IdToGestureID[ e.type ],
\r
36 gestures = Detection.gestures,
\r
37 numTouches = 0,// count the total touches on the screen
\r
38 pointerType, i, l, touches, ret, active, gesture, startEv,
\r
39 hammer, deltaTime, deltaX, deltaY, velocity;
\r
41 //console.log( 'Hammer@handleEvent ' + X.UI.Event.IdToName[ e.type ] + ' ' + e.pointerType );
\r
44 if( e.pointerType ){
\r
46 switch( e.pointerType ){
\r
48 case 2 : //e.MSPOINTER_TYPE_TOUCH :
\r
49 type |= TOUCH; break;
\r
51 case 3 : //e.MSPOINTER_TYPE_PEN :
\r
54 case 4 : //e.MSPOINTER_TYPE_MOUSE :
\r
55 type |= MOUSE; break;
\r
62 //alert( 'Hammer@handleEvent ' + X.UI.Event.IdToName[ e.type ] + ' ' + e.touches.length );
\r
65 //alert( 'Hammer@handleEvent ' + X.UI.Event.IdToName[ e.type ] + ' mouse!' );
\r
68 // onmouseup, but when touchend has been fired we do nothing.
\r
69 // this is for touchdevices which also fire a mouseup on touchend
\r
70 if( type & MOUSE && touch_triggered ){
\r
71 return X.Callback.STOP_NOW | X.Callback.PREVENT_DEFAULT;
\r
73 // mousebutton must be down or a touch event
\r
75 type & TOUCH || //sourceEventType.match(/touch/) || // touch events are always on screen
\r
76 ( type & POINTER && type & START ) || //sourceEventType.match(/pointerdown/) || // pointerevents touch
\r
77 ( type & MOUSE && e.which === 1 ) //(sourceEventType.match(/mouse/) && e.which === 1) // mouse is pressed
\r
79 enable_detect = true;
\r
82 // we are in a touch event, set the touch triggered bool to true,
\r
83 // this for the conflicts that may occur on ios and android
\r
84 type & ( TOUCH | POINTER ) && ( touch_triggered = true );
\r
85 //if (sourceEventType.match(/touch|pointer/)) { touch_triggered = true;}
\r
87 // when touch has been triggered in this detection session
\r
88 // and we are now handling a mouse event, we stop that to prevent conflicts
\r
89 if( enable_detect ){
\r
90 // update pointerevent
\r
91 if( Hammer.HAS_POINTEREVENTS ){ //eventType !== Hammer.EVENT_END ){
\r
92 POINTERS[ e.identifier = e.pointerId ] = type & END ? null : e;
\r
94 // we can use forEach since pointerEvents only is in IE10
\r
95 for( i = 0, l = POINTERS.length; i < l; ++i ){
\r
96 POINTERS[ i ] && ( touches[ touches.length ] = POINTERS[ i ] );
\r
98 numTouches = touches.length;
\r
101 if ( type & TOUCH ){ //sourceEventType.match(/touch/)) {
\r
102 touches = Hammer.DO_TOUCHES_FIX && type & END ? [] : e.touches;
\r
103 numTouches = touches.length;
\r
106 if( !touch_triggered ){
\r
107 numTouches = ( type & END ) ? 0 : 1;
\r
108 touches = numTouches === 0 ? [] : [{
\r
115 // if we are in a end event, but when we remove one touch and
\r
116 // we still have enough, set eventType to move
\r
117 if( 0 < numTouches && type & END ){ // eventType === Hammer.EVENT_END ){
\r
118 type = type & POINTER_TYPE_MASK | MOVE;
\r
119 //eventType = Hammer.EVENT_MOVE;
\r
120 } else if( !numTouches ){
\r
121 // no touches, force the end event
\r
122 type = type & POINTER_TYPE_MASK | END;
\r
123 //eventType = Hammer.EVENT_END;
\r
126 // because touchend has no touches, and we often want to use these in our gestures,
\r
127 // we send the last move event as our eventData in touchend
\r
128 ( !numTouches && last_move_event !== null ) ?
\r
129 ( e = last_move_event ):
\r
130 ( last_move_event = e ); // store the last move event
\r
133 center : Utils.getCenter( touches ),
\r
134 timeStamp : Date.now ? Date.now() : +new Date,
\r
137 eventType : type & EVENT_TYPE_MASK,
\r
138 pointerType : type & POINTER_TYPE_MASK
\r
141 if( type & START ){
\r
142 if( !this.enabled ) return;
\r
143 // already busy with a Hammer.gesture detection on an element
\r
144 if( Detection.current ) return;
\r
145 Detection.current = {
\r
146 hammer : this, // reference to HammerInstance we're working for
\r
147 startEvent : Utils.extend( {}, e ), // start eventData for distances, timing etc
\r
148 lastEvent : false, // last eventData
\r
149 name : '' // current gesture we're in/detected, can be 'tap', 'hold' etc
\r
151 Detection.stopped = false;
\r
153 active = hammer.activeGesture;
\r
155 if( !Detection.current || Detection.stopped ){
\r
158 hammer = Detection.current.hammer;
\r
159 active = hammer.activeGesture;
\r
162 // ----------------------------------------------------------------------------------------------------------------
\r
163 // ret = Detection.detect( e );
\r
165 // ----------------------------------------------------------------------------------------------------------------
\r
166 // extend event data with calculations about scale, distance etc
\r
167 // e = Detection.extendEventData( e );
\r
168 startEv = Detection.current.startEvent;
\r
171 // if the touches change, set the new touches over the startEvent touches
\r
172 // this because touchevents don't have all the touches on touchstart, or the
\r
173 // user must place his fingers at the EXACT same time on the screen, which is not realistic
\r
174 // but, sometimes it happens that both fingers are touching at the EXACT same time
\r
175 if( startEv && ( numTouches !== startEv.touches.length || touches === startEv.touches ) ){
\r
176 // extend 1 level deep to get the touchlist with the touch objects
\r
177 startEv.touches.length = i = 0;
\r
178 for( ; i < numTouches; ++i ){
\r
179 startEv.touches[ startEv.touches.length ] = Utils.extend( {}, touches[ i ] );
\r
183 deltaTime = e.timeStamp - startEv.timeStamp;
\r
184 deltaX = center.pageX - startEv.center.pageX;
\r
185 deltaY = center.pageY - startEv.center.pageY;
\r
186 velocity = Utils.getVelocity( deltaTime, deltaX, deltaY );
\r
189 deltaTime : deltaTime,
\r
194 velocityX : velocity.x,
\r
195 velocityY : velocity.y,
\r
197 distance : Utils.getDistance( startEv.center, center ),
\r
198 angle : Utils.getAngle( startEv.center, center ),
\r
199 direction : Utils.getDirection( startEv.center, center ),
\r
201 scale : Utils.getScale( startEv.touches, touches ),
\r
202 rotation : Utils.getRotation( startEv.touches, touches ),
\r
204 startEvent : startEv
\r
207 // store as previous event event
\r
208 Detection.current.lastEvent = e;
\r
210 // call Hammer.gesture handlers
\r
211 for( i = 0, l = gestures.length; i < l; ++i ){
\r
212 gesture = gestures[ i ];
\r
213 if( Detection.stopped ) break;
\r
214 //if( active[ gesture.name ] ) console.log( gesture.name );
\r
215 // only when the instance options have enabled this gesture
\r
216 active[ gesture.name ] &&
\r
217 // if a handler returns false, we stop with the detection
\r
218 ( ret |= ( gesture.handler( e, hammer ) || X.Callback.NONE ) );
\r
221 // endevent, but not the last touch, so dont stop
\r
222 type & END && numTouches === 0 && Detection.stopDetect();
\r
224 // ----------------------------------------------------------------------------------------------------------------
\r
225 // trigger the handler
\r
226 //handler.call( context, HamEvent.collectEventData( element, eventType, e ) );
\r
228 // remove pointerevent from list
\r
229 if( Hammer.HAS_POINTEREVENTS && type & END ){ // eventType === Hammer.EVENT_END ){
\r
234 //debug(sourceEventType +" "+ eventType);
\r
236 // on the end we reset everything
\r
237 if( numTouches === 0 ){
\r
238 last_move_event = null;
\r
239 enable_detect = false;
\r
240 touch_triggered = false;
\r
241 POINTERS.length = 0;
\r
247 Hammer.startup = function( uinodeRoot ){
\r
248 // find what eventtypes we add listeners to
\r
250 * we have different events for each device/browser
\r
251 * determine what we need and set them in the Hammer.EVENT_TYPES constant
\r
253 // determine the eventtype we want to set
\r
254 // for non pointer events browsers and mixed browsers,
\r
255 // like chrome on windows8 touch laptop
\r
258 // Register all gestures inside Gestures
\r
259 for( name in Gestures ){
\r
260 //Gestures.hasOwnProperty( name ) &&
\r
261 Detection.register( Gestures[ name ] );
\r
264 if( X.Dom.EVENT_POINTER ){
\r
265 Hammer.EVENT_TYPES_START = [ X.UI.Event._POINTER_DOWN ];
\r
266 types = [ X.UI.Event._POINTER_MOVE, X.UI.Event._POINTER_UP, X.UI.Event._POINTER_CANCEL ];
\r
268 if( X.Dom.EVENT_TOUCH ){
\r
269 Hammer.EVENT_TYPES_START = [ X.UI.Event._TOUCH_START, X.UI.Event._MOUSE_DOWN ];
\r
270 types = [ X.UI.Event._MOUSE_MOVE, X.UI.Event._MOUSE_UP, X.UI.Event._MOUSE_CANCEL,
\r
271 X.UI.Event._TOUCH_MOVE, X.UI.Event._TOUCH_END, X.UI.Event._TOUCH_CANCEL ];
\r
273 Hammer.EVENT_TYPES_START = [ X.UI.Event._MOUSE_DOWN ];
\r
274 types = [ X.UI.Event._MOUSE_MOVE, X.UI.Event._MOUSE_UP, X.UI.Event._MOUSE_CANCEL ];
\r
277 // Add touch events on the document
\r
278 Utils.addEvents( uinodeRoot, types, Hammer.prototype.handleEvent );
\r
280 // Hammer is ready...!
\r
281 delete Hammer.startup;
\r
284 Hammer.prototype.trigger = function( type, gesture ){
\r
285 if( !this.types[ type ] ) return;
\r
286 var e = Utils.extend( {}, gesture );
\r
288 return this.uinode.dispatch( e );
\r
291 Hammer.prototype.listen = function( type ){
\r
292 var gestures = Detection.gestures,
\r
293 i = gestures.length, g;
\r
295 g = gestures[ --i ];
\r
296 if( g.startID <= type && type <= g.endID ){
\r
297 if( !this.activeGesture ) this.activeGesture = {};
\r
298 if( !this.types ) this.types = {};
\r
299 this.activeGesture[ g.name ] = this.types[ type ] = 1;
\r
305 Hammer.prototype.unlisten = function( type ){
\r
306 var gestures = Detection.gestures,
\r
307 i = gestures.length, g;
\r
308 if( !this.activeGesture ) return;
\r
310 g = gestures[ --i ];
\r
311 if( g.startID <= type && type <= g.endID ){
\r
312 if( this.activeGesture[ g.name ] ){
\r
313 if( this.types[ type ] ) delete this.types[ type ];
\r
314 for( i = g.startID; i <= g.endID; ++i ){
\r
315 if( this.types[ i ] ) return;
\r
317 delete this.activeGesture[ g.name ];
\r
325 * "Android version < 2.2" return ev.touches.length === 1 when touchend, others return ev.touches.length === 0
\r
327 Hammer.DO_TOUCHES_FIX = Hammer.HAS_TOUCHEVENTS && X.UA.Android < 2.2;
\r
329 // detect touchevents
\r
330 Hammer.HAS_POINTEREVENTS = navigator.pointerEnabled || navigator.msPointerEnabled;
\r
331 Hammer.HAS_POINTEREVENTS && console.log( 'Hammer.HAS_POINTEREVENTS : true' );
\r
334 // eventtypes per touchevent (start, move, end)
\r
335 // are filled by HamEvent.determineEventTypes on setup
\r
336 Hammer.EVENT_TYPES_START = null;
\r
338 // direction defines
\r
339 Hammer.DIRECTION_DOWN = 'down';
\r
340 Hammer.DIRECTION_LEFT = 'left';
\r
341 Hammer.DIRECTION_UP = 'up';
\r
342 Hammer.DIRECTION_RIGHT = 'right';
\r
344 // plugins namespace
\r
345 Hammer.plugins = {};
\r
355 EVENT_TYPE_MASK = START | MOVE | END,
\r
356 POINTER_TYPE_MASK = POINTER | TOUCH | MOUSE | PEN,
\r
357 IdToGestureID = {};
\r
358 IdToGestureID[ X.UI.Event._POINTER_DOWN ] = START;
\r
359 IdToGestureID[ X.UI.Event._POINTER_MOVE ] = MOVE;
\r
360 IdToGestureID[ X.UI.Event._POINTER_UP ] = END;
\r
361 IdToGestureID[ X.UI.Event._POINTER_CANCEL ] = END;
\r
363 IdToGestureID[ X.UI.Event._TOUCH_START ] = START;
\r
364 IdToGestureID[ X.UI.Event._TOUCH_MOVE ] = MOVE;
\r
365 IdToGestureID[ X.UI.Event._TOUCH_END ] = END;
\r
366 IdToGestureID[ X.UI.Event._TOUCH_CANCEL ] = END;
\r
368 IdToGestureID[ X.UI.Event._MOUSE_DOWN ] = START;
\r
369 IdToGestureID[ X.UI.Event._MOUSE_MOVE ] = MOVE;
\r
370 IdToGestureID[ X.UI.Event._MOUSE_UP ] = END;
\r
371 IdToGestureID[ X.UI.Event._MOUSE_CANCEL ] = END;
\r
376 * touch events with mouse fallback
\r
377 * @param {HTMLElement} element
\r
378 * @param {String} eventType like Hammer.EVENT_MOVE
\r
379 * @param {Function} handler
\r
381 addEvents : function( uinode, types, context ){
\r
382 for( var i = 0; i < types.length; ++i ){
\r
383 uinode.listen( types[ i ], context );
\r
389 * also used for cloning when dest is an empty object
\r
390 * @param {Object} dest
\r
391 * @param {Object} src
\r
392 * @parm {Boolean} merge do a merge
\r
393 * @returns {Object} dest
\r
395 extend : function extend( dest, src, merge ){
\r
396 for( var key in src ){
\r
397 if( dest[ key ] !== undefined && merge ) continue;
\r
398 dest[ key ] = src[ key ];
\r
404 * find if a node is in the given parent
\r
405 * used for event delegation tricks
\r
406 * @param {HTMLElement} node
\r
407 * @param {HTMLElement} parent
\r
408 * @returns {boolean} has_parent
\r
410 hasParent : function( node, parent ){
\r
411 while( node && node.tagName ){ /* tagName for ie */
\r
412 if( node === parent ) return true;
\r
413 node = node.parentNode;
\r
419 * get the center of all the touches
\r
420 * @param {Array} touches
\r
421 * @returns {Object} center
\r
423 getCenter : function getCenter(touches) {
\r
425 l = touches.length,
\r
432 pageX : touches[ 0 ].pageX,
\r
433 pageY : touches[ 0 ].pageY
\r
437 pageX : ( touches[ 0 ].pageX + touches[ 1 ].pageX ) / 2,
\r
438 pageY : ( touches[ 0 ].pageY + touches[ 1 ].pageY ) / 2
\r
443 for( ; i < l; ++i ){
\r
444 valuesX[ valuesX.length ] = touches[ i ].pageX;
\r
445 valuesY[ valuesY.length ] = touches[ i ].pageY;
\r
448 pageX : ( ( Math.min.apply( null, valuesX ) + Math.max.apply( null, valuesX ) ) / 2 ),
\r
449 pageY : ( ( Math.min.apply( null, valuesY ) + Math.max.apply( null, valuesY ) ) / 2 )
\r
454 * calculate the velocity between two points
\r
455 * @param {Number} deltaTime
\r
456 * @param {Number} deltaX
\r
457 * @param {Number} deltaY
\r
458 * @returns {Object} velocity
\r
460 getVelocity : function getVelocity( deltaTime, deltaX, deltaY ) {
\r
462 x : ABS( deltaX / deltaTime ) || 0,
\r
463 y : ABS( deltaY / deltaTime ) || 0
\r
468 * calculate the angle between two coordinates
\r
469 * @param {Touch} touch1
\r
470 * @param {Touch} touch2
\r
471 * @returns {Number} angle
\r
473 getAngle : function getAngle(touch1, touch2) {
\r
474 var y = touch2.pageY - touch1.pageY,
\r
475 x = touch2.pageX - touch1.pageX;
\r
476 return Math.atan2( y, x ) * 180 / Math.PI;
\r
480 * angle to direction define
\r
481 * @param {Touch} touch1
\r
482 * @param {Touch} touch2
\r
483 * @returns {String} direction constant, like Hammer.DIRECTION_LEFT
\r
485 getDirection : function getDirection( touch1, touch2 ){
\r
486 var x = touch1.pageX - touch2.pageX,
\r
487 y = touch1.pageY - touch2.pageY;
\r
488 return ABS( y ) <= ABS( x ) ?
\r
489 ( x > 0 ? Hammer.DIRECTION_LEFT : Hammer.DIRECTION_RIGHT ) :
\r
490 ( y > 0 ? Hammer.DIRECTION_UP : Hammer.DIRECTION_DOWN );
\r
494 * calculate the distance between two touches
\r
495 * @param {Touch} touch1
\r
496 * @param {Touch} touch2
\r
497 * @returns {Number} distance
\r
499 getDistance : function getDistance( touch1, touch2 ){
\r
500 var x = touch2.pageX - touch1.pageX,
\r
501 y = touch2.pageY - touch1.pageY;
\r
502 return Math.sqrt( ( x * x ) + ( y * y ) );
\r
506 * calculate the scale factor between two touchLists (fingers)
\r
507 * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
\r
508 * @param {Array} start
\r
509 * @param {Array} end
\r
510 * @returns {Number} scale
\r
512 getScale : function getScale( start, end ){
\r
513 // need two fingers...
\r
514 return ( 2 <= start.length && 2 <= end.length ) ?
\r
515 Utils.getDistance( end[ 0 ], end[ 1 ] ) / Utils.getDistance( start[ 0 ], start[ 1 ] ) :
\r
520 * calculate the rotation degrees between two touchLists (fingers)
\r
521 * @param {Array} start
\r
522 * @param {Array} end
\r
523 * @returns {Number} rotation
\r
525 getRotation : function getRotation( start, end ){
\r
526 // need two fingers
\r
527 return ( 2 <= start.length && 2 <= end.length ) ?
\r
528 Utils.getAngle( end[ 1 ], end[ 0 ] ) - Utils.getAngle( start[ 1 ], start[ 0 ] ) :
\r
533 * boolean if the direction is vertical
\r
534 * @param {String} direction
\r
535 * @returns {Boolean} is_vertical
\r
537 isVertical : function isVertical( direction ){
\r
538 return direction === Hammer.DIRECTION_UP || direction === Hammer.DIRECTION_DOWN;
\r
543 * this holds the last move event,
\r
544 * used to fix empty touchend issue
\r
545 * see the onTouch event for an explanation
\r
548 var last_move_event = null;
\r
551 * when the mouse is hold down, this is true
\r
554 var enable_detect = false;
\r
557 * when touch events have been fired, this is true
\r
560 var touch_triggered = false;
\r
563 // contains all registred Gestures in the correct order
\r
566 // data of the current Hammer.gesture detection session
\r
569 // the previous Hammer.gesture session data
\r
570 // is a full clone of the previous gesture.current object
\r
573 // when this becomes true, no gestures are fired
\r
577 * clear the Hammer.gesture vars
\r
578 * this is called on endDetect, but can also be used when a final Hammer.gesture has been detected
\r
579 * to stop other Gestures from being fired
\r
581 stopDetect : function stopDetect() {
\r
582 // clone current data to the store as the previous gesture
\r
583 // used for the double tap gesture, since this is an other gesture detect session
\r
584 Detection.previous = Utils.extend( {}, Detection.current );
\r
586 // reset the current
\r
587 Detection.current = null;
\r
590 Detection.stopped = true;
\r
594 * register new gesture
\r
595 * @param {Object} gesture object, see gestures.js for documentation
\r
596 * @returns {Array} gestures
\r
598 register : function( gesture ){
\r
599 // add an enable gesture options if there is no given
\r
600 var options = gesture.defaults || {},
\r
601 list = Detection.gestures,
\r
602 _index, i = 0, l = list.length, index;
\r
603 if( options[ gesture.name ] === undefined ) options[ gesture.name ] = true;
\r
605 // extend Hammer default options with the Hammer.gesture options
\r
606 Utils.extend( Hammer.defaults, options, true );
\r
609 gesture.index = gesture.index || 1000;
\r
611 // add Hammer.gesture to the list
\r
612 //Detection.gestures.push( gesture );
\r
614 // sort the list by index
\r
615 //Detection.gestures.sort( function( a, b ){
\r
617 // a.index < b.index ? -1 :
\r
618 // a.index > b.index ? 1 : 0;
\r
621 list[ 0 ] = gesture;
\r
624 _index = gesture.index;
\r
625 for( i = 0; i < l; ++i ){
\r
626 index = list[ i ].index;
\r
627 if( i === 0 && _index < index ){
\r
628 list.unshift( gesture );
\r
632 list[ l ] = gesture;
\r
635 if( index <= _index && _index < list[ i + 1 ].index ){
\r
636 list.splice( i, 0, gesture );
\r
643 var Gestures = Gestures || {};
\r
647 * ==============================
\r
650 * --------------------
\r
651 * The object structure of a gesture:
\r
653 * { name: 'mygesture',
\r
656 * mygesture_option: true
\r
658 * handler: function(type, e, inst) {
\r
659 * // trigger gesture event
\r
660 * inst.trigger(this.name, e );
\r
664 * @param {String} name
\r
665 * this should be the name of the gesture, lowercase
\r
666 * it is also being used to disable/enable the gesture per instance config.
\r
668 * @param {Number} [index=1000]
\r
669 * the index of the gesture, where it is going to be in the stack of gestures detection
\r
670 * like when you build an gesture that depends on the drag gesture, it is a good
\r
671 * idea to place it after the index of the drag gesture.
\r
673 * @param {Object} [defaults={}]
\r
674 * the default settings of the gesture. these are added to the instance settings,
\r
675 * and can be overruled per instance. you can also add the name of the gesture,
\r
676 * but this is also added by default (and set to true).
\r
678 * @param {Function} handler
\r
679 * this handles the gesture detection of your custom gesture and receives the
\r
680 * following arguments:
\r
682 * @param {Object} eventData
\r
683 * event data containing the following properties:
\r
684 * timeStamp {Number} time the event occurred
\r
685 * target {HTMLElement} target element
\r
686 * touches {Array} touches (fingers, pointers, mouse) on the screen
\r
687 * pointerType {String} kind of pointer that was used. matches Hammer.POINTER_MOUSE|TOUCH
\r
688 * center {Object} center position of the touches. contains pageX and pageY
\r
689 * deltaTime {Number} the total time of the touches in the screen
\r
690 * deltaX {Number} the delta on x axis we haved moved
\r
691 * deltaY {Number} the delta on y axis we haved moved
\r
692 * velocityX {Number} the velocity on the x
\r
693 * velocityY {Number} the velocity on y
\r
694 * angle {Number} the angle we are moving
\r
695 * direction {String} the direction we are moving. matches Hammer.DIRECTION_UP|DOWN|LEFT|RIGHT
\r
696 * distance {Number} the distance we haved moved
\r
697 * scale {Number} scaling of the touches, needs 2 touches
\r
698 * rotation {Number} rotation of the touches, needs 2 touches *
\r
699 * eventType {String} matches Hammer.EVENT_START|MOVE|END
\r
700 * srcEvent {Object} the source event, like TouchStart or MouseDown *
\r
701 * startEvent {Object} contains the same properties as above,
\r
702 * but from the first touch. this is used to calculate
\r
703 * distances, deltaTime, scaling etc
\r
705 * @param {Hammer.Instance} inst
\r
706 * the instance we are doing the detection for. you can get the options from
\r
707 * the inst.options object and trigger the gesture event by calling inst.trigger
\r
711 * --------------------
\r
712 * inside the handler you can get/set Detection.current. This is the current
\r
713 * detection session. It has the following properties
\r
714 * @param {String} name
\r
715 * contains the name of the gesture we have detected. it has not a real function,
\r
716 * only to check in other gestures if something is detected.
\r
717 * like in the drag gesture we set it to 'drag' and in the swipe gesture we can
\r
718 * check if the current gesture is 'drag' by accessing Detection.current.name
\r
721 * @param {Hammer.Instance} inst
\r
722 * the instance we do the detection for
\r
725 * @param {Object} startEvent
\r
726 * contains the properties of the first gesture detection in this session.
\r
727 * Used for calculations about timing, distance, etc.
\r
730 * @param {Object} lastEvent
\r
731 * contains all the properties of the last gesture detect in this session.
\r
733 * after the gesture detection session has been completed (user has released the screen)
\r
734 * the Detection.current object is copied into Detection.previous,
\r
735 * this is usefull for gestures like doubletap, where you need to know if the
\r
736 * previous gesture was a tap
\r
738 * options that have been set by the instance can be received by calling inst.options
\r
740 * You can trigger a gesture event by calling inst.trigger("mygesture", event).
\r
741 * The first param is the name of your gesture, the second the event argument
\r
744 * Register gestures
\r
745 * --------------------
\r
746 * When an gesture is added to the Gestures object, it is auto registered
\r
747 * at the setup of the first Hammer instance. You can also call Detection.register
\r
748 * manually and pass your gesture object as a param
\r
754 * Touch stays at the same place for x time
\r
755 * @events hold holdend
\r
760 startID : X.UI.Event.HOLD,
\r
761 endID : X.UI.Event.HOLD_END,
\r
763 hold_timeout : 500,
\r
768 handler : function holdGesture( e, hammer ){
\r
769 switch( e.eventType ){
\r
771 // clear any running timers
\r
772 this.timerID && X.Timer.remove( this.timerID );
\r
774 // set the gesture so we can check in the timeout if it still is
\r
775 Detection.current.name = this.name;
\r
776 Gestures.Hold.holding = false;
\r
778 // set timer and if after the timeout it still is hold,
\r
779 // we trigger the hold event
\r
780 this.timerID = X.Timer.add( hammer.options.hold_timeout, 1, Gestures.Hold._onTimer, [ e, hammer ] );
\r
783 // when you move or end we clear the timer
\r
785 if( e.distance <= hammer.options.hold_threshold ) return;
\r
787 this.timerID && X.Timer.remove( this.timerID );
\r
788 if( Gestures.Hold.holding === true ){
\r
789 Gestures.Hold.holding = false;
\r
790 return hammer.trigger( X.UI.Event.HOLD_END, e );
\r
795 _onTimer : function( e, hammer ){
\r
796 if( Detection.current.name === 'hold' ){
\r
797 hammer.trigger( X.UI.Event.HOLD, e );
\r
798 Gestures.Hold.holding = true;
\r
805 * Quick touch at a place or double at the same place
\r
806 * @events tap, doubletap
\r
811 startID : X.UI.Event.TAP,
\r
812 endID : X.UI.Event.DOUBLE_TAP,
\r
814 tap_max_touchtime : 250,
\r
815 tap_max_distance : 10,
\r
817 doubletap_distance : 20,
\r
818 doubletap_interval : 300
\r
820 handler : function tapGesture( e, hammer ){
\r
821 // previous gesture, for the double tap since these are two different gesture detections
\r
822 var prev = Detection.previous;
\r
823 if( e.eventType === END ){
\r
824 // when the touchtime is higher then the max touch time
\r
825 // or when the moving distance is too much
\r
826 if( hammer.options.tap_max_touchtime < e.deltaTime || hammer.options.tap_max_distance < e.distance ) return;
\r
828 // check if double tap
\r
829 if( prev && prev.name === 'tap' && ( e.timeStamp - prev.lastEvent.timeStamp ) < hammer.options.doubletap_interval && e.distance < hammer.options.doubletap_distance ){
\r
830 return hammer.trigger( X.UI.Event.DOUBLE_TAP, e );
\r
833 if( hammer.options.tap_always && Detection.current.name !== 'tap' ){ // EventFire中にalert すると mouseleave で再び呼ばれるのを防ぐ
\r
834 Detection.current.name = 'tap';
\r
835 return hammer.trigger( X.UI.Event.TAP, e );
\r
843 * triggers swipe events when the end velocity is above the threshold
\r
844 * @events swipe, swipeleft, swiperight, swipeup, swipedown
\r
849 startID : X.UI.Event.SWIP,
\r
850 endID : X.UI.Event.SWIP_DOWN,
\r
852 // set 0 for unlimited, but this can conflict with transform
\r
853 swipe_max_touches : 1,
\r
854 swipe_velocity : 0.7
\r
856 handler : function swipeGesture(e, hammer) {
\r
857 if( e.eventType === END ){
\r
859 if( 0 < hammer.options.swipe_max_touches && hammer.options.swipe_max_touches < e.touches.length ) return;
\r
861 // when the distance we moved is too small we skip this gesture
\r
862 // or we can be already in dragging
\r
863 if( hammer.options.swipe_velocity < e.velocityX || hammer.options.swipe_velocity < e.velocityY ){
\r
864 // trigger swipe events
\r
865 hammer.trigger( X.UI.Event.SWIP, e );
\r
867 e.direction === Hammer.DIRECTION_UP ?
\r
868 X.UI.Event.SWIP_UP :
\r
869 e.direction === Hammer.DIRECTION_DOWN ?
\r
870 X.UI.Event.SWIP_DOWN :
\r
871 e.direction === Hammer.DIRECTION_LEFT ?
\r
872 X.UI.Event.SWIP_LEFT :
\r
873 X.UI.Event.SWIP_RIGHT,
\r
883 * Move with x fingers (default 1) around on the page. Blocking the scrolling when
\r
884 * moving left and right is a good practice. When all the drag events are blocking
\r
885 * you disable scrolling on that area.
\r
886 * @events drag, dragstart, dragend, drapleft, dragright, dragup, dragdown
\r
891 startID : X.UI.Event.DRAG,
\r
892 endID : X.UI.Event.DRAG_DOWN,
\r
894 drag_min_distance : 10,
\r
895 // set 0 for unlimited, but this can conflict with transform
\r
896 drag_max_touches : 1,
\r
897 // prevent default browser behavior when dragging occurs
\r
898 // be careful with it, it makes the element a blocking element
\r
899 // when you are using the drag gesture, it is a good practice to set this true
\r
900 drag_block_horizontal : false,
\r
901 drag_block_vertical : false,
\r
902 // drag_lock_to_axis keeps the drag gesture on the axis that it started on,
\r
903 // It disallows vertical directions if the initial direction was horizontal, and vice versa.
\r
904 drag_lock_to_axis : false,
\r
905 // drag lock only kicks in when distance > drag_lock_min_distance
\r
906 // This way, locking occurs only when the distance has become large enough to reliably determine the direction
\r
907 drag_lock_min_distance : 25
\r
910 handler : function dragGesture( e, hammer ){
\r
911 var last_direction;
\r
912 // current gesture isnt drag, but dragged is true
\r
913 // this means an other gesture is busy. now call dragend
\r
914 if( Detection.current.name !== this.name && this.triggered ){
\r
915 hammer.trigger( X.UI.Event.DRAG_END, e );
\r
916 this.triggered = false;
\r
921 if( 0 < hammer.options.drag_max_touches && hammer.options.drag_max_touches < e.touches.length ) return;
\r
923 switch( e.eventType ){
\r
925 this.triggered = false;
\r
929 // when the distance we moved is too small we skip this gesture
\r
930 // or we can be already in dragging
\r
931 if( e.distance < hammer.options.drag_min_distance && Detection.current.name !== this.name ) return;
\r
933 // we are dragging!
\r
934 Detection.current.name = this.name;
\r
936 // lock drag to axis?
\r
937 if( Detection.current.lastEvent.drag_locked_to_axis || ( hammer.options.drag_lock_to_axis && hammer.options.drag_lock_min_distance <= e.distance ) ){
\r
938 e.drag_locked_to_axis = true;
\r
940 last_direction = Detection.current.lastEvent.direction;
\r
941 if( e.drag_locked_to_axis && last_direction !== e.direction ){
\r
942 // keep direction on the axis that the drag gesture started on
\r
943 e.direction = Utils.isVertical( last_direction ) ?
\r
944 ( e.deltaY < 0 ? Hammer.DIRECTION_UP : Hammer.DIRECTION_DOWN ) :
\r
945 ( e.deltaX < 0 ? Hammer.DIRECTION_LEFT : Hammer.DIRECTION_RIGHT );
\r
948 // first time, trigger dragstart event
\r
949 if( !this.triggered ){
\r
950 hammer.trigger( X.UI.Event.DRAG_START, e );
\r
951 this.triggered = true;
\r
954 // trigger normal event
\r
955 hammer.trigger( X.UI.Event.DRAG, e );
\r
957 // direction event, like dragdown
\r
959 e.direction === Hammer.DIRECTION_UP ?
\r
960 X.UI.Event.DRAG_UP :
\r
961 e.direction === Hammer.DIRECTION_DOWN ?
\r
962 X.UI.Event.DRAG_DOWN :
\r
963 e.direction === Hammer.DIRECTION_LEFT ?
\r
964 X.UI.Event.DRAG_LEFT :
\r
965 X.UI.Event.DRAG_RIGHT,
\r
969 // block the browser events
\r
971 ( hammer.options.drag_block_vertical && Utils.isVertical( e.direction ) ) ||
\r
972 ( hammer.options.drag_block_horizontal && !Utils.isVertical( e.direction ) )
\r
973 ) && e.preventDefault();
\r
978 this.triggered && hammer.trigger( X.UI.Event.DRAG_END, e );
\r
979 this.triggered = false;
\r
987 * User want to scale or rotate with 2 fingers
\r
988 * @events transform, transformstart, transformend, pinch, pinchin, pinchout, rotate
\r
990 Gestures.Transform = {
\r
991 name : 'transform',
\r
993 startID : X.UI.Event.TRANSFORM,
\r
994 endID : X.UI.Event.ROTATE,
\r
996 // factor, no scale is 1, zoomin is to 0 and zoomout until higher then 1
\r
997 transform_min_scale : 0.01,
\r
998 // rotation in degrees
\r
999 transform_min_rotation : 1,
\r
1000 // prevent default browser behavior when two touches are on the screen
\r
1001 // but it makes the element a blocking element
\r
1002 // when you are using the transform gesture, it is a good practice to set this true
\r
1003 transform_always_block : false
\r
1005 triggered : false,
\r
1006 handler : function transformGesture( e, hammer ){
\r
1007 // current gesture isnt drag, but dragged is true
\r
1008 // this means an other gesture is busy. now call dragend
\r
1009 if( Detection.current.name !== this.name && this.triggered ){
\r
1010 hammer.trigger( X.UI.Event.TRANSFORM_END, e );
\r
1011 this.triggered = false;
\r
1015 // atleast multitouch
\r
1016 if( e.touches.length < 2 ) return;
\r
1018 // prevent default when two fingers are on the screen
\r
1019 hammer.options.transform_always_block && e.preventDefault();
\r
1021 switch(e.eventType) {
\r
1023 this.triggered = false;
\r
1027 var scale_threshold = ABS( 1 - e.scale ),
\r
1028 rotation_threshold = ABS( e.rotation );
\r
1030 // when the distance we moved is too small we skip this gesture
\r
1031 // or we can be already in dragging
\r
1032 if( scale_threshold < hammer.options.transform_min_scale && rotation_threshold < hammer.options.transform_min_rotation ) return;
\r
1034 // we are transforming!
\r
1035 Detection.current.name = this.name;
\r
1037 // first time, trigger dragstart event
\r
1038 if( !this.triggered ){
\r
1039 hammer.trigger( X.UI.Event.TRANSFORM_START, e );
\r
1040 this.triggered = true;
\r
1043 hammer.trigger( X.UI.Event.TRANSFORM, e );
\r
1044 // basic transform event
\r
1046 // trigger rotate event
\r
1047 hammer.options.transform_min_rotation < rotation_threshold && hammer.trigger( X.UI.Event.ROTATE, e );
\r
1049 // trigger pinch event
\r
1050 if( scale_threshold > hammer.options.transform_min_scale ){
\r
1051 hammer.trigger( X.UI.Event.PINCH, e );
\r
1052 hammer.trigger( e.scale < 1 ? X.UI.Event.PINCH_IN : X.UI.Event.PINCH_OUT, e );
\r
1057 // trigger dragend
\r
1058 this.triggered && hammer.trigger( X.UI.Event.TRANSFORM_END, e );
\r
1059 this.triggered = false;
\r
1067 * Called as first, tells the user has touched the screen
\r
1070 Gestures.Touch = {
\r
1072 index : -Infinity,
\r
1074 // call preventDefault at touchstart, and makes the element blocking by
\r
1075 // disabling the scrolling of the page, but it improves gestures like
\r
1076 // transforming and dragging.
\r
1077 // be careful with using this, it can be very annoying for users to be stuck
\r
1079 prevent_default : false,
\r
1081 // disable mouse events, so only touch (or pen!) input triggers events
\r
1082 prevent_mouseevents : false
\r
1084 handler : function touchGesture( e, hammer ){
\r
1085 if( hammer.options.prevent_mouseevents && e.pointerType === MOUSE ){
\r
1086 Detection.stopDetect();
\r
1090 hammer.options.prevent_default && e.preventDefault();
\r
1092 e.eventType === START && hammer.trigger( this.name, e );
\r
1098 * Called as last, tells the user has released the screen
\r
1101 Gestures.Release = {
\r
1104 handler : function releaseGesture( e, hammer ){
\r
1105 e.eventType === END && hammer.trigger( this.name, e );
\r
1109 })( Math, window, document );