Add longpress support on mobile
This commit is contained in:
Petko Bordjukov
parent
09cda9f22a
commit
a251ecbb52
|
|
@ -12,4 +12,5 @@
|
|||
//
|
||||
//= require jquery
|
||||
//= require jquery_ujs
|
||||
//= require jquery_mobile_events
|
||||
//= require_tree .
|
||||
|
|
|
|||
|
|
@ -223,10 +223,8 @@
|
|||
|
||||
/* Apply attributes to sort events into calendar */
|
||||
// t.addClass(' room_' + item.room_id + ' duration_' + item.duration + ' day_'+day + ' time_' + (hour<10?'0':'') + hour + '' + (mins<10?'0':'') + mins);
|
||||
|
||||
t.click( function(event) {
|
||||
/* Transition for touch devices is highlighted => selected => highlighted ... */
|
||||
if( isTouch ) {
|
||||
if( isTouch ) {
|
||||
t.click( function(event) {
|
||||
if ( $( this ).hasClass('highlighted') ) {
|
||||
$( this ).toggleClass('selected');
|
||||
$('.info').addClass('hidden');
|
||||
|
|
@ -235,13 +233,23 @@
|
|||
$('.highlighted').removeClass('highlighted');
|
||||
$( this ).addClass('highlighted');
|
||||
}
|
||||
} else {
|
||||
event.stopPropagation();
|
||||
});
|
||||
|
||||
$(t).bind('taphold', function(event) {
|
||||
$( this ).toggleClass('selected');
|
||||
$('.info').addClass('hidden');
|
||||
$('.submit').click();
|
||||
}
|
||||
event.stopPropagation();
|
||||
});
|
||||
});
|
||||
} else {
|
||||
t.click( function(event) {
|
||||
$( this ).toggleClass('selected');
|
||||
$('.info').addClass('hidden');
|
||||
$('.submit').click();
|
||||
event.stopPropagation();
|
||||
});
|
||||
}
|
||||
|
||||
/* Put new event into DOM tree. Track defaults to 'Other' */
|
||||
var track = item.track_id.toString();
|
||||
var d = $( '#' + track );
|
||||
|
|
|
|||
|
|
@ -0,0 +1,865 @@
|
|||
/*
|
||||
* jQuery Mobile v1.4.5
|
||||
* http://jquerymobile.com
|
||||
*
|
||||
* Copyright 2010, 2014 jQuery Foundation, Inc. and other contributors
|
||||
* Released under the MIT license.
|
||||
* http://jquery.org/license
|
||||
*
|
||||
*/
|
||||
|
||||
(function ( root, doc, factory ) {
|
||||
if ( typeof define === "function" && define.amd ) {
|
||||
// AMD. Register as an anonymous module.
|
||||
define( [ "jquery" ], function ( $ ) {
|
||||
factory( $, root, doc );
|
||||
return $.mobile;
|
||||
});
|
||||
} else {
|
||||
// Browser globals
|
||||
factory( root.jQuery, root, doc );
|
||||
}
|
||||
}( this, document, function ( jQuery, window, document, undefined ) {
|
||||
// This plugin is an experiment for abstracting away the touch and mouse
|
||||
// events so that developers don't have to worry about which method of input
|
||||
// the device their document is loaded on supports.
|
||||
//
|
||||
// The idea here is to allow the developer to register listeners for the
|
||||
// basic mouse events, such as mousedown, mousemove, mouseup, and click,
|
||||
// and the plugin will take care of registering the correct listeners
|
||||
// behind the scenes to invoke the listener at the fastest possible time
|
||||
// for that device, while still retaining the order of event firing in
|
||||
// the traditional mouse environment, should multiple handlers be registered
|
||||
// on the same element for different events.
|
||||
//
|
||||
// The current version exposes the following virtual events to jQuery bind methods:
|
||||
// "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel"
|
||||
|
||||
(function( $, window, document, undefined ) {
|
||||
|
||||
var dataPropertyName = "virtualMouseBindings",
|
||||
touchTargetPropertyName = "virtualTouchID",
|
||||
virtualEventNames = "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel".split( " " ),
|
||||
touchEventProps = "clientX clientY pageX pageY screenX screenY".split( " " ),
|
||||
mouseHookProps = $.event.mouseHooks ? $.event.mouseHooks.props : [],
|
||||
mouseEventProps = $.event.props.concat( mouseHookProps ),
|
||||
activeDocHandlers = {},
|
||||
resetTimerID = 0,
|
||||
startX = 0,
|
||||
startY = 0,
|
||||
didScroll = false,
|
||||
clickBlockList = [],
|
||||
blockMouseTriggers = false,
|
||||
blockTouchTriggers = false,
|
||||
eventCaptureSupported = "addEventListener" in document,
|
||||
$document = $( document ),
|
||||
nextTouchID = 1,
|
||||
lastTouchID = 0, threshold,
|
||||
i;
|
||||
|
||||
$.vmouse = {
|
||||
moveDistanceThreshold: 10,
|
||||
clickDistanceThreshold: 10,
|
||||
resetTimerDuration: 1500
|
||||
};
|
||||
|
||||
function getNativeEvent( event ) {
|
||||
|
||||
while ( event && typeof event.originalEvent !== "undefined" ) {
|
||||
event = event.originalEvent;
|
||||
}
|
||||
return event;
|
||||
}
|
||||
|
||||
function createVirtualEvent( event, eventType ) {
|
||||
|
||||
var t = event.type,
|
||||
oe, props, ne, prop, ct, touch, i, j, len;
|
||||
|
||||
event = $.Event( event );
|
||||
event.type = eventType;
|
||||
|
||||
oe = event.originalEvent;
|
||||
props = $.event.props;
|
||||
|
||||
// addresses separation of $.event.props in to $.event.mouseHook.props and Issue 3280
|
||||
// https://github.com/jquery/jquery-mobile/issues/3280
|
||||
if ( t.search( /^(mouse|click)/ ) > -1 ) {
|
||||
props = mouseEventProps;
|
||||
}
|
||||
|
||||
// copy original event properties over to the new event
|
||||
// this would happen if we could call $.event.fix instead of $.Event
|
||||
// but we don't have a way to force an event to be fixed multiple times
|
||||
if ( oe ) {
|
||||
for ( i = props.length, prop; i; ) {
|
||||
prop = props[ --i ];
|
||||
event[ prop ] = oe[ prop ];
|
||||
}
|
||||
}
|
||||
|
||||
// make sure that if the mouse and click virtual events are generated
|
||||
// without a .which one is defined
|
||||
if ( t.search(/mouse(down|up)|click/) > -1 && !event.which ) {
|
||||
event.which = 1;
|
||||
}
|
||||
|
||||
if ( t.search(/^touch/) !== -1 ) {
|
||||
ne = getNativeEvent( oe );
|
||||
t = ne.touches;
|
||||
ct = ne.changedTouches;
|
||||
touch = ( t && t.length ) ? t[0] : ( ( ct && ct.length ) ? ct[ 0 ] : undefined );
|
||||
|
||||
if ( touch ) {
|
||||
for ( j = 0, len = touchEventProps.length; j < len; j++) {
|
||||
prop = touchEventProps[ j ];
|
||||
event[ prop ] = touch[ prop ];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
function getVirtualBindingFlags( element ) {
|
||||
|
||||
var flags = {},
|
||||
b, k;
|
||||
|
||||
while ( element ) {
|
||||
|
||||
b = $.data( element, dataPropertyName );
|
||||
|
||||
for ( k in b ) {
|
||||
if ( b[ k ] ) {
|
||||
flags[ k ] = flags.hasVirtualBinding = true;
|
||||
}
|
||||
}
|
||||
element = element.parentNode;
|
||||
}
|
||||
return flags;
|
||||
}
|
||||
|
||||
function getClosestElementWithVirtualBinding( element, eventType ) {
|
||||
var b;
|
||||
while ( element ) {
|
||||
|
||||
b = $.data( element, dataPropertyName );
|
||||
|
||||
if ( b && ( !eventType || b[ eventType ] ) ) {
|
||||
return element;
|
||||
}
|
||||
element = element.parentNode;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function enableTouchBindings() {
|
||||
blockTouchTriggers = false;
|
||||
}
|
||||
|
||||
function disableTouchBindings() {
|
||||
blockTouchTriggers = true;
|
||||
}
|
||||
|
||||
function enableMouseBindings() {
|
||||
lastTouchID = 0;
|
||||
clickBlockList.length = 0;
|
||||
blockMouseTriggers = false;
|
||||
|
||||
// When mouse bindings are enabled, our
|
||||
// touch bindings are disabled.
|
||||
disableTouchBindings();
|
||||
}
|
||||
|
||||
function disableMouseBindings() {
|
||||
// When mouse bindings are disabled, our
|
||||
// touch bindings are enabled.
|
||||
enableTouchBindings();
|
||||
}
|
||||
|
||||
function startResetTimer() {
|
||||
clearResetTimer();
|
||||
resetTimerID = setTimeout( function() {
|
||||
resetTimerID = 0;
|
||||
enableMouseBindings();
|
||||
}, $.vmouse.resetTimerDuration );
|
||||
}
|
||||
|
||||
function clearResetTimer() {
|
||||
if ( resetTimerID ) {
|
||||
clearTimeout( resetTimerID );
|
||||
resetTimerID = 0;
|
||||
}
|
||||
}
|
||||
|
||||
function triggerVirtualEvent( eventType, event, flags ) {
|
||||
var ve;
|
||||
|
||||
if ( ( flags && flags[ eventType ] ) ||
|
||||
( !flags && getClosestElementWithVirtualBinding( event.target, eventType ) ) ) {
|
||||
|
||||
ve = createVirtualEvent( event, eventType );
|
||||
|
||||
$( event.target).trigger( ve );
|
||||
}
|
||||
|
||||
return ve;
|
||||
}
|
||||
|
||||
function mouseEventCallback( event ) {
|
||||
var touchID = $.data( event.target, touchTargetPropertyName ),
|
||||
ve;
|
||||
|
||||
if ( !blockMouseTriggers && ( !lastTouchID || lastTouchID !== touchID ) ) {
|
||||
ve = triggerVirtualEvent( "v" + event.type, event );
|
||||
if ( ve ) {
|
||||
if ( ve.isDefaultPrevented() ) {
|
||||
event.preventDefault();
|
||||
}
|
||||
if ( ve.isPropagationStopped() ) {
|
||||
event.stopPropagation();
|
||||
}
|
||||
if ( ve.isImmediatePropagationStopped() ) {
|
||||
event.stopImmediatePropagation();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function handleTouchStart( event ) {
|
||||
|
||||
var touches = getNativeEvent( event ).touches,
|
||||
target, flags, t;
|
||||
|
||||
if ( touches && touches.length === 1 ) {
|
||||
|
||||
target = event.target;
|
||||
flags = getVirtualBindingFlags( target );
|
||||
|
||||
if ( flags.hasVirtualBinding ) {
|
||||
|
||||
lastTouchID = nextTouchID++;
|
||||
$.data( target, touchTargetPropertyName, lastTouchID );
|
||||
|
||||
clearResetTimer();
|
||||
|
||||
disableMouseBindings();
|
||||
didScroll = false;
|
||||
|
||||
t = getNativeEvent( event ).touches[ 0 ];
|
||||
startX = t.pageX;
|
||||
startY = t.pageY;
|
||||
|
||||
triggerVirtualEvent( "vmouseover", event, flags );
|
||||
triggerVirtualEvent( "vmousedown", event, flags );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function handleScroll( event ) {
|
||||
if ( blockTouchTriggers ) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ( !didScroll ) {
|
||||
triggerVirtualEvent( "vmousecancel", event, getVirtualBindingFlags( event.target ) );
|
||||
}
|
||||
|
||||
didScroll = true;
|
||||
startResetTimer();
|
||||
}
|
||||
|
||||
function handleTouchMove( event ) {
|
||||
if ( blockTouchTriggers ) {
|
||||
return;
|
||||
}
|
||||
|
||||
var t = getNativeEvent( event ).touches[ 0 ],
|
||||
didCancel = didScroll,
|
||||
moveThreshold = $.vmouse.moveDistanceThreshold,
|
||||
flags = getVirtualBindingFlags( event.target );
|
||||
|
||||
didScroll = didScroll ||
|
||||
( Math.abs( t.pageX - startX ) > moveThreshold ||
|
||||
Math.abs( t.pageY - startY ) > moveThreshold );
|
||||
|
||||
if ( didScroll && !didCancel ) {
|
||||
triggerVirtualEvent( "vmousecancel", event, flags );
|
||||
}
|
||||
|
||||
triggerVirtualEvent( "vmousemove", event, flags );
|
||||
startResetTimer();
|
||||
}
|
||||
|
||||
function handleTouchEnd( event ) {
|
||||
if ( blockTouchTriggers ) {
|
||||
return;
|
||||
}
|
||||
|
||||
disableTouchBindings();
|
||||
|
||||
var flags = getVirtualBindingFlags( event.target ),
|
||||
ve, t;
|
||||
triggerVirtualEvent( "vmouseup", event, flags );
|
||||
|
||||
if ( !didScroll ) {
|
||||
ve = triggerVirtualEvent( "vclick", event, flags );
|
||||
if ( ve && ve.isDefaultPrevented() ) {
|
||||
// The target of the mouse events that follow the touchend
|
||||
// event don't necessarily match the target used during the
|
||||
// touch. This means we need to rely on coordinates for blocking
|
||||
// any click that is generated.
|
||||
t = getNativeEvent( event ).changedTouches[ 0 ];
|
||||
clickBlockList.push({
|
||||
touchID: lastTouchID,
|
||||
x: t.clientX,
|
||||
y: t.clientY
|
||||
});
|
||||
|
||||
// Prevent any mouse events that follow from triggering
|
||||
// virtual event notifications.
|
||||
blockMouseTriggers = true;
|
||||
}
|
||||
}
|
||||
triggerVirtualEvent( "vmouseout", event, flags);
|
||||
didScroll = false;
|
||||
|
||||
startResetTimer();
|
||||
}
|
||||
|
||||
function hasVirtualBindings( ele ) {
|
||||
var bindings = $.data( ele, dataPropertyName ),
|
||||
k;
|
||||
|
||||
if ( bindings ) {
|
||||
for ( k in bindings ) {
|
||||
if ( bindings[ k ] ) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function dummyMouseHandler() {}
|
||||
|
||||
function getSpecialEventObject( eventType ) {
|
||||
var realType = eventType.substr( 1 );
|
||||
|
||||
return {
|
||||
setup: function(/* data, namespace */) {
|
||||
// If this is the first virtual mouse binding for this element,
|
||||
// add a bindings object to its data.
|
||||
|
||||
if ( !hasVirtualBindings( this ) ) {
|
||||
$.data( this, dataPropertyName, {} );
|
||||
}
|
||||
|
||||
// If setup is called, we know it is the first binding for this
|
||||
// eventType, so initialize the count for the eventType to zero.
|
||||
var bindings = $.data( this, dataPropertyName );
|
||||
bindings[ eventType ] = true;
|
||||
|
||||
// If this is the first virtual mouse event for this type,
|
||||
// register a global handler on the document.
|
||||
|
||||
activeDocHandlers[ eventType ] = ( activeDocHandlers[ eventType ] || 0 ) + 1;
|
||||
|
||||
if ( activeDocHandlers[ eventType ] === 1 ) {
|
||||
$document.bind( realType, mouseEventCallback );
|
||||
}
|
||||
|
||||
// Some browsers, like Opera Mini, won't dispatch mouse/click events
|
||||
// for elements unless they actually have handlers registered on them.
|
||||
// To get around this, we register dummy handlers on the elements.
|
||||
|
||||
$( this ).bind( realType, dummyMouseHandler );
|
||||
|
||||
// For now, if event capture is not supported, we rely on mouse handlers.
|
||||
if ( eventCaptureSupported ) {
|
||||
// If this is the first virtual mouse binding for the document,
|
||||
// register our touchstart handler on the document.
|
||||
|
||||
activeDocHandlers[ "touchstart" ] = ( activeDocHandlers[ "touchstart" ] || 0) + 1;
|
||||
|
||||
if ( activeDocHandlers[ "touchstart" ] === 1 ) {
|
||||
$document.bind( "touchstart", handleTouchStart )
|
||||
.bind( "touchend", handleTouchEnd )
|
||||
|
||||
// On touch platforms, touching the screen and then dragging your finger
|
||||
// causes the window content to scroll after some distance threshold is
|
||||
// exceeded. On these platforms, a scroll prevents a click event from being
|
||||
// dispatched, and on some platforms, even the touchend is suppressed. To
|
||||
// mimic the suppression of the click event, we need to watch for a scroll
|
||||
// event. Unfortunately, some platforms like iOS don't dispatch scroll
|
||||
// events until *AFTER* the user lifts their finger (touchend). This means
|
||||
// we need to watch both scroll and touchmove events to figure out whether
|
||||
// or not a scroll happenens before the touchend event is fired.
|
||||
|
||||
.bind( "touchmove", handleTouchMove )
|
||||
.bind( "scroll", handleScroll );
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
teardown: function(/* data, namespace */) {
|
||||
// If this is the last virtual binding for this eventType,
|
||||
// remove its global handler from the document.
|
||||
|
||||
--activeDocHandlers[ eventType ];
|
||||
|
||||
if ( !activeDocHandlers[ eventType ] ) {
|
||||
$document.unbind( realType, mouseEventCallback );
|
||||
}
|
||||
|
||||
if ( eventCaptureSupported ) {
|
||||
// If this is the last virtual mouse binding in existence,
|
||||
// remove our document touchstart listener.
|
||||
|
||||
--activeDocHandlers[ "touchstart" ];
|
||||
|
||||
if ( !activeDocHandlers[ "touchstart" ] ) {
|
||||
$document.unbind( "touchstart", handleTouchStart )
|
||||
.unbind( "touchmove", handleTouchMove )
|
||||
.unbind( "touchend", handleTouchEnd )
|
||||
.unbind( "scroll", handleScroll );
|
||||
}
|
||||
}
|
||||
|
||||
var $this = $( this ),
|
||||
bindings = $.data( this, dataPropertyName );
|
||||
|
||||
// teardown may be called when an element was
|
||||
// removed from the DOM. If this is the case,
|
||||
// jQuery core may have already stripped the element
|
||||
// of any data bindings so we need to check it before
|
||||
// using it.
|
||||
if ( bindings ) {
|
||||
bindings[ eventType ] = false;
|
||||
}
|
||||
|
||||
// Unregister the dummy event handler.
|
||||
|
||||
$this.unbind( realType, dummyMouseHandler );
|
||||
|
||||
// If this is the last virtual mouse binding on the
|
||||
// element, remove the binding data from the element.
|
||||
|
||||
if ( !hasVirtualBindings( this ) ) {
|
||||
$this.removeData( dataPropertyName );
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Expose our custom events to the jQuery bind/unbind mechanism.
|
||||
|
||||
for ( i = 0; i < virtualEventNames.length; i++ ) {
|
||||
$.event.special[ virtualEventNames[ i ] ] = getSpecialEventObject( virtualEventNames[ i ] );
|
||||
}
|
||||
|
||||
// Add a capture click handler to block clicks.
|
||||
// Note that we require event capture support for this so if the device
|
||||
// doesn't support it, we punt for now and rely solely on mouse events.
|
||||
if ( eventCaptureSupported ) {
|
||||
document.addEventListener( "click", function( e ) {
|
||||
var cnt = clickBlockList.length,
|
||||
target = e.target,
|
||||
x, y, ele, i, o, touchID;
|
||||
|
||||
if ( cnt ) {
|
||||
x = e.clientX;
|
||||
y = e.clientY;
|
||||
threshold = $.vmouse.clickDistanceThreshold;
|
||||
|
||||
// The idea here is to run through the clickBlockList to see if
|
||||
// the current click event is in the proximity of one of our
|
||||
// vclick events that had preventDefault() called on it. If we find
|
||||
// one, then we block the click.
|
||||
//
|
||||
// Why do we have to rely on proximity?
|
||||
//
|
||||
// Because the target of the touch event that triggered the vclick
|
||||
// can be different from the target of the click event synthesized
|
||||
// by the browser. The target of a mouse/click event that is synthesized
|
||||
// from a touch event seems to be implementation specific. For example,
|
||||
// some browsers will fire mouse/click events for a link that is near
|
||||
// a touch event, even though the target of the touchstart/touchend event
|
||||
// says the user touched outside the link. Also, it seems that with most
|
||||
// browsers, the target of the mouse/click event is not calculated until the
|
||||
// time it is dispatched, so if you replace an element that you touched
|
||||
// with another element, the target of the mouse/click will be the new
|
||||
// element underneath that point.
|
||||
//
|
||||
// Aside from proximity, we also check to see if the target and any
|
||||
// of its ancestors were the ones that blocked a click. This is necessary
|
||||
// because of the strange mouse/click target calculation done in the
|
||||
// Android 2.1 browser, where if you click on an element, and there is a
|
||||
// mouse/click handler on one of its ancestors, the target will be the
|
||||
// innermost child of the touched element, even if that child is no where
|
||||
// near the point of touch.
|
||||
|
||||
ele = target;
|
||||
|
||||
while ( ele ) {
|
||||
for ( i = 0; i < cnt; i++ ) {
|
||||
o = clickBlockList[ i ];
|
||||
touchID = 0;
|
||||
|
||||
if ( ( ele === target && Math.abs( o.x - x ) < threshold && Math.abs( o.y - y ) < threshold ) ||
|
||||
$.data( ele, touchTargetPropertyName ) === o.touchID ) {
|
||||
// XXX: We may want to consider removing matches from the block list
|
||||
// instead of waiting for the reset timer to fire.
|
||||
e.preventDefault();
|
||||
e.stopPropagation();
|
||||
return;
|
||||
}
|
||||
}
|
||||
ele = ele.parentNode;
|
||||
}
|
||||
}
|
||||
}, true);
|
||||
}
|
||||
})( jQuery, window, document );
|
||||
|
||||
(function( $ ) {
|
||||
$.mobile = {};
|
||||
}( jQuery ));
|
||||
|
||||
(function( $, undefined ) {
|
||||
var support = {
|
||||
touch: "ontouchend" in document
|
||||
};
|
||||
|
||||
$.mobile.support = $.mobile.support || {};
|
||||
$.extend( $.support, support );
|
||||
$.extend( $.mobile.support, support );
|
||||
}( jQuery ));
|
||||
|
||||
|
||||
(function( $, window, undefined ) {
|
||||
var $document = $( document ),
|
||||
supportTouch = $.mobile.support.touch,
|
||||
scrollEvent = "touchmove scroll",
|
||||
touchStartEvent = supportTouch ? "touchstart" : "mousedown",
|
||||
touchStopEvent = supportTouch ? "touchend" : "mouseup",
|
||||
touchMoveEvent = supportTouch ? "touchmove" : "mousemove";
|
||||
|
||||
// setup new event shortcuts
|
||||
$.each( ( "touchstart touchmove touchend " +
|
||||
"tap taphold " +
|
||||
"swipe swipeleft swiperight " +
|
||||
"scrollstart scrollstop" ).split( " " ), function( i, name ) {
|
||||
|
||||
$.fn[ name ] = function( fn ) {
|
||||
return fn ? this.bind( name, fn ) : this.trigger( name );
|
||||
};
|
||||
|
||||
// jQuery < 1.8
|
||||
if ( $.attrFn ) {
|
||||
$.attrFn[ name ] = true;
|
||||
}
|
||||
});
|
||||
|
||||
function triggerCustomEvent( obj, eventType, event, bubble ) {
|
||||
var originalType = event.type;
|
||||
event.type = eventType;
|
||||
if ( bubble ) {
|
||||
$.event.trigger( event, undefined, obj );
|
||||
} else {
|
||||
$.event.dispatch.call( obj, event );
|
||||
}
|
||||
event.type = originalType;
|
||||
}
|
||||
|
||||
// also handles scrollstop
|
||||
$.event.special.scrollstart = {
|
||||
|
||||
enabled: true,
|
||||
setup: function() {
|
||||
|
||||
var thisObject = this,
|
||||
$this = $( thisObject ),
|
||||
scrolling,
|
||||
timer;
|
||||
|
||||
function trigger( event, state ) {
|
||||
scrolling = state;
|
||||
triggerCustomEvent( thisObject, scrolling ? "scrollstart" : "scrollstop", event );
|
||||
}
|
||||
|
||||
// iPhone triggers scroll after a small delay; use touchmove instead
|
||||
$this.bind( scrollEvent, function( event ) {
|
||||
|
||||
if ( !$.event.special.scrollstart.enabled ) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ( !scrolling ) {
|
||||
trigger( event, true );
|
||||
}
|
||||
|
||||
clearTimeout( timer );
|
||||
timer = setTimeout( function() {
|
||||
trigger( event, false );
|
||||
}, 50 );
|
||||
});
|
||||
},
|
||||
teardown: function() {
|
||||
$( this ).unbind( scrollEvent );
|
||||
}
|
||||
};
|
||||
|
||||
// also handles taphold
|
||||
$.event.special.tap = {
|
||||
tapholdThreshold: 750,
|
||||
emitTapOnTaphold: true,
|
||||
setup: function() {
|
||||
var thisObject = this,
|
||||
$this = $( thisObject ),
|
||||
isTaphold = false;
|
||||
|
||||
$this.bind( "vmousedown", function( event ) {
|
||||
isTaphold = false;
|
||||
if ( event.which && event.which !== 1 ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
var origTarget = event.target,
|
||||
timer;
|
||||
|
||||
function clearTapTimer() {
|
||||
clearTimeout( timer );
|
||||
}
|
||||
|
||||
function clearTapHandlers() {
|
||||
clearTapTimer();
|
||||
|
||||
$this.unbind( "vclick", clickHandler )
|
||||
.unbind( "vmouseup", clearTapTimer );
|
||||
$document.unbind( "vmousecancel", clearTapHandlers );
|
||||
}
|
||||
|
||||
function clickHandler( event ) {
|
||||
clearTapHandlers();
|
||||
|
||||
// ONLY trigger a 'tap' event if the start target is
|
||||
// the same as the stop target.
|
||||
if ( !isTaphold && origTarget === event.target ) {
|
||||
triggerCustomEvent( thisObject, "tap", event );
|
||||
} else if ( isTaphold ) {
|
||||
event.preventDefault();
|
||||
}
|
||||
}
|
||||
|
||||
$this.bind( "vmouseup", clearTapTimer )
|
||||
.bind( "vclick", clickHandler );
|
||||
$document.bind( "vmousecancel", clearTapHandlers );
|
||||
|
||||
timer = setTimeout( function() {
|
||||
if ( !$.event.special.tap.emitTapOnTaphold ) {
|
||||
isTaphold = true;
|
||||
}
|
||||
triggerCustomEvent( thisObject, "taphold", $.Event( "taphold", { target: origTarget } ) );
|
||||
}, $.event.special.tap.tapholdThreshold );
|
||||
});
|
||||
},
|
||||
teardown: function() {
|
||||
$( this ).unbind( "vmousedown" ).unbind( "vclick" ).unbind( "vmouseup" );
|
||||
$document.unbind( "vmousecancel" );
|
||||
}
|
||||
};
|
||||
|
||||
// Also handles swipeleft, swiperight
|
||||
$.event.special.swipe = {
|
||||
|
||||
// More than this horizontal displacement, and we will suppress scrolling.
|
||||
scrollSupressionThreshold: 30,
|
||||
|
||||
// More time than this, and it isn't a swipe.
|
||||
durationThreshold: 1000,
|
||||
|
||||
// Swipe horizontal displacement must be more than this.
|
||||
horizontalDistanceThreshold: 30,
|
||||
|
||||
// Swipe vertical displacement must be less than this.
|
||||
verticalDistanceThreshold: 30,
|
||||
|
||||
getLocation: function ( event ) {
|
||||
var winPageX = window.pageXOffset,
|
||||
winPageY = window.pageYOffset,
|
||||
x = event.clientX,
|
||||
y = event.clientY;
|
||||
|
||||
if ( event.pageY === 0 && Math.floor( y ) > Math.floor( event.pageY ) ||
|
||||
event.pageX === 0 && Math.floor( x ) > Math.floor( event.pageX ) ) {
|
||||
|
||||
// iOS4 clientX/clientY have the value that should have been
|
||||
// in pageX/pageY. While pageX/page/ have the value 0
|
||||
x = x - winPageX;
|
||||
y = y - winPageY;
|
||||
} else if ( y < ( event.pageY - winPageY) || x < ( event.pageX - winPageX ) ) {
|
||||
|
||||
// Some Android browsers have totally bogus values for clientX/Y
|
||||
// when scrolling/zooming a page. Detectable since clientX/clientY
|
||||
// should never be smaller than pageX/pageY minus page scroll
|
||||
x = event.pageX - winPageX;
|
||||
y = event.pageY - winPageY;
|
||||
}
|
||||
|
||||
return {
|
||||
x: x,
|
||||
y: y
|
||||
};
|
||||
},
|
||||
|
||||
start: function( event ) {
|
||||
var data = event.originalEvent.touches ?
|
||||
event.originalEvent.touches[ 0 ] : event,
|
||||
location = $.event.special.swipe.getLocation( data );
|
||||
return {
|
||||
time: ( new Date() ).getTime(),
|
||||
coords: [ location.x, location.y ],
|
||||
origin: $( event.target )
|
||||
};
|
||||
},
|
||||
|
||||
stop: function( event ) {
|
||||
var data = event.originalEvent.touches ?
|
||||
event.originalEvent.touches[ 0 ] : event,
|
||||
location = $.event.special.swipe.getLocation( data );
|
||||
return {
|
||||
time: ( new Date() ).getTime(),
|
||||
coords: [ location.x, location.y ]
|
||||
};
|
||||
},
|
||||
|
||||
handleSwipe: function( start, stop, thisObject, origTarget ) {
|
||||
if ( stop.time - start.time < $.event.special.swipe.durationThreshold &&
|
||||
Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.horizontalDistanceThreshold &&
|
||||
Math.abs( start.coords[ 1 ] - stop.coords[ 1 ] ) < $.event.special.swipe.verticalDistanceThreshold ) {
|
||||
var direction = start.coords[0] > stop.coords[ 0 ] ? "swipeleft" : "swiperight";
|
||||
|
||||
triggerCustomEvent( thisObject, "swipe", $.Event( "swipe", { target: origTarget, swipestart: start, swipestop: stop }), true );
|
||||
triggerCustomEvent( thisObject, direction,$.Event( direction, { target: origTarget, swipestart: start, swipestop: stop } ), true );
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
||||
},
|
||||
|
||||
// This serves as a flag to ensure that at most one swipe event event is
|
||||
// in work at any given time
|
||||
eventInProgress: false,
|
||||
|
||||
setup: function() {
|
||||
var events,
|
||||
thisObject = this,
|
||||
$this = $( thisObject ),
|
||||
context = {};
|
||||
|
||||
// Retrieve the events data for this element and add the swipe context
|
||||
events = $.data( this, "mobile-events" );
|
||||
if ( !events ) {
|
||||
events = { length: 0 };
|
||||
$.data( this, "mobile-events", events );
|
||||
}
|
||||
events.length++;
|
||||
events.swipe = context;
|
||||
|
||||
context.start = function( event ) {
|
||||
|
||||
// Bail if we're already working on a swipe event
|
||||
if ( $.event.special.swipe.eventInProgress ) {
|
||||
return;
|
||||
}
|
||||
$.event.special.swipe.eventInProgress = true;
|
||||
|
||||
var stop,
|
||||
start = $.event.special.swipe.start( event ),
|
||||
origTarget = event.target,
|
||||
emitted = false;
|
||||
|
||||
context.move = function( event ) {
|
||||
if ( !start || event.isDefaultPrevented() ) {
|
||||
return;
|
||||
}
|
||||
|
||||
stop = $.event.special.swipe.stop( event );
|
||||
if ( !emitted ) {
|
||||
emitted = $.event.special.swipe.handleSwipe( start, stop, thisObject, origTarget );
|
||||
if ( emitted ) {
|
||||
|
||||
// Reset the context to make way for the next swipe event
|
||||
$.event.special.swipe.eventInProgress = false;
|
||||
}
|
||||
}
|
||||
// prevent scrolling
|
||||
if ( Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.scrollSupressionThreshold ) {
|
||||
event.preventDefault();
|
||||
}
|
||||
};
|
||||
|
||||
context.stop = function() {
|
||||
emitted = true;
|
||||
|
||||
// Reset the context to make way for the next swipe event
|
||||
$.event.special.swipe.eventInProgress = false;
|
||||
$document.off( touchMoveEvent, context.move );
|
||||
context.move = null;
|
||||
};
|
||||
|
||||
$document.on( touchMoveEvent, context.move )
|
||||
.one( touchStopEvent, context.stop );
|
||||
};
|
||||
$this.on( touchStartEvent, context.start );
|
||||
},
|
||||
|
||||
teardown: function() {
|
||||
var events, context;
|
||||
|
||||
events = $.data( this, "mobile-events" );
|
||||
if ( events ) {
|
||||
context = events.swipe;
|
||||
delete events.swipe;
|
||||
events.length--;
|
||||
if ( events.length === 0 ) {
|
||||
$.removeData( this, "mobile-events" );
|
||||
}
|
||||
}
|
||||
|
||||
if ( context ) {
|
||||
if ( context.start ) {
|
||||
$( this ).off( touchStartEvent, context.start );
|
||||
}
|
||||
if ( context.move ) {
|
||||
$document.off( touchMoveEvent, context.move );
|
||||
}
|
||||
if ( context.stop ) {
|
||||
$document.off( touchStopEvent, context.stop );
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
$.each({
|
||||
scrollstop: "scrollstart",
|
||||
taphold: "tap",
|
||||
swipeleft: "swipe.left",
|
||||
swiperight: "swipe.right"
|
||||
}, function( event, sourceEvent ) {
|
||||
|
||||
$.event.special[ event ] = {
|
||||
setup: function() {
|
||||
$( this ).bind( sourceEvent, $.noop );
|
||||
},
|
||||
teardown: function() {
|
||||
$( this ).unbind( sourceEvent );
|
||||
}
|
||||
};
|
||||
});
|
||||
|
||||
})( jQuery, this );
|
||||
|
||||
|
||||
}));
|
||||
Loading…
Reference in New Issue