/bower_components/swiper/src/js/mousewheel.js |
@@ -0,0 +1,313 @@ |
/*========================= |
Mousewheel Control |
===========================*/ |
s.mousewheel = { |
event: false, |
lastScrollTime: (new window.Date()).getTime() |
}; |
function isEventSupported() { |
var eventName = 'onwheel'; |
var isSupported = eventName in document; |
|
if (!isSupported) { |
var element = document.createElement('div'); |
element.setAttribute(eventName, 'return;'); |
isSupported = typeof element[eventName] === 'function'; |
} |
|
if (!isSupported && |
document.implementation && |
document.implementation.hasFeature && |
// always returns true in newer browsers as per the standard. |
// @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature |
document.implementation.hasFeature('', '') !== true ) { |
// This is the only way to test support for the `wheel` event in IE9+. |
isSupported = document.implementation.hasFeature('Events.wheel', '3.0'); |
} |
|
return isSupported; |
} |
/** |
* Mouse wheel (and 2-finger trackpad) support on the web sucks. It is |
* complicated, thus this doc is long and (hopefully) detailed enough to answer |
* your questions. |
* |
* If you need to react to the mouse wheel in a predictable way, this code is |
* like your bestest friend. * hugs * |
* |
* As of today, there are 4 DOM event types you can listen to: |
* |
* 'wheel' -- Chrome(31+), FF(17+), IE(9+) |
* 'mousewheel' -- Chrome, IE(6+), Opera, Safari |
* 'MozMousePixelScroll' -- FF(3.5 only!) (2010-2013) -- don't bother! |
* 'DOMMouseScroll' -- FF(0.9.7+) since 2003 |
* |
* So what to do? The is the best: |
* |
* normalizeWheel.getEventType(); |
* |
* In your event callback, use this code to get sane interpretation of the |
* deltas. This code will return an object with properties: |
* |
* spinX -- normalized spin speed (use for zoom) - x plane |
* spinY -- " - y plane |
* pixelX -- normalized distance (to pixels) - x plane |
* pixelY -- " - y plane |
* |
* Wheel values are provided by the browser assuming you are using the wheel to |
* scroll a web page by a number of lines or pixels (or pages). Values can vary |
* significantly on different platforms and browsers, forgetting that you can |
* scroll at different speeds. Some devices (like trackpads) emit more events |
* at smaller increments with fine granularity, and some emit massive jumps with |
* linear speed or acceleration. |
* |
* This code does its best to normalize the deltas for you: |
* |
* - spin is trying to normalize how far the wheel was spun (or trackpad |
* dragged). This is super useful for zoom support where you want to |
* throw away the chunky scroll steps on the PC and make those equal to |
* the slow and smooth tiny steps on the Mac. Key data: This code tries to |
* resolve a single slow step on a wheel to 1. |
* |
* - pixel is normalizing the desired scroll delta in pixel units. You'll |
* get the crazy differences between browsers, but at least it'll be in |
* pixels! |
* |
* - positive value indicates scrolling DOWN/RIGHT, negative UP/LEFT. This |
* should translate to positive value zooming IN, negative zooming OUT. |
* This matches the newer 'wheel' event. |
* |
* Why are there spinX, spinY (or pixels)? |
* |
* - spinX is a 2-finger side drag on the trackpad, and a shift + wheel turn |
* with a mouse. It results in side-scrolling in the browser by default. |
* |
* - spinY is what you expect -- it's the classic axis of a mouse wheel. |
* |
* - I dropped spinZ/pixelZ. It is supported by the DOM 3 'wheel' event and |
* probably is by browsers in conjunction with fancy 3D controllers .. but |
* you know. |
* |
* Implementation info: |
* |
* Examples of 'wheel' event if you scroll slowly (down) by one step with an |
* average mouse: |
* |
* OS X + Chrome (mouse) - 4 pixel delta (wheelDelta -120) |
* OS X + Safari (mouse) - N/A pixel delta (wheelDelta -12) |
* OS X + Firefox (mouse) - 0.1 line delta (wheelDelta N/A) |
* Win8 + Chrome (mouse) - 100 pixel delta (wheelDelta -120) |
* Win8 + Firefox (mouse) - 3 line delta (wheelDelta -120) |
* |
* On the trackpad: |
* |
* OS X + Chrome (trackpad) - 2 pixel delta (wheelDelta -6) |
* OS X + Firefox (trackpad) - 1 pixel delta (wheelDelta N/A) |
* |
* On other/older browsers.. it's more complicated as there can be multiple and |
* also missing delta values. |
* |
* The 'wheel' event is more standard: |
* |
* http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents |
* |
* The basics is that it includes a unit, deltaMode (pixels, lines, pages), and |
* deltaX, deltaY and deltaZ. Some browsers provide other values to maintain |
* backward compatibility with older events. Those other values help us |
* better normalize spin speed. Example of what the browsers provide: |
* |
* | event.wheelDelta | event.detail |
* ------------------+------------------+-------------- |
* Safari v5/OS X | -120 | 0 |
* Safari v5/Win7 | -120 | 0 |
* Chrome v17/OS X | -120 | 0 |
* Chrome v17/Win7 | -120 | 0 |
* IE9/Win7 | -120 | undefined |
* Firefox v4/OS X | undefined | 1 |
* Firefox v4/Win7 | undefined | 3 |
* |
*/ |
function normalizeWheel( /*object*/ event ) /*object*/ { |
// Reasonable defaults |
var PIXEL_STEP = 10; |
var LINE_HEIGHT = 40; |
var PAGE_HEIGHT = 800; |
|
var sX = 0, sY = 0, // spinX, spinY |
pX = 0, pY = 0; // pixelX, pixelY |
|
// Legacy |
if( 'detail' in event ) { |
sY = event.detail; |
} |
if( 'wheelDelta' in event ) { |
sY = -event.wheelDelta / 120; |
} |
if( 'wheelDeltaY' in event ) { |
sY = -event.wheelDeltaY / 120; |
} |
if( 'wheelDeltaX' in event ) { |
sX = -event.wheelDeltaX / 120; |
} |
|
// side scrolling on FF with DOMMouseScroll |
if( 'axis' in event && event.axis === event.HORIZONTAL_AXIS ) { |
sX = sY; |
sY = 0; |
} |
|
pX = sX * PIXEL_STEP; |
pY = sY * PIXEL_STEP; |
|
if( 'deltaY' in event ) { |
pY = event.deltaY; |
} |
if( 'deltaX' in event ) { |
pX = event.deltaX; |
} |
|
if( (pX || pY) && event.deltaMode ) { |
if( event.deltaMode === 1 ) { // delta in LINE units |
pX *= LINE_HEIGHT; |
pY *= LINE_HEIGHT; |
} else { // delta in PAGE units |
pX *= PAGE_HEIGHT; |
pY *= PAGE_HEIGHT; |
} |
} |
|
// Fall-back if spin cannot be determined |
if( pX && !sX ) { |
sX = (pX < 1) ? -1 : 1; |
} |
if( pY && !sY ) { |
sY = (pY < 1) ? -1 : 1; |
} |
|
return { |
spinX: sX, |
spinY: sY, |
pixelX: pX, |
pixelY: pY |
}; |
} |
if (s.params.mousewheelControl) { |
/** |
* The best combination if you prefer spinX + spinY normalization. It favors |
* the older DOMMouseScroll for Firefox, as FF does not include wheelDelta with |
* 'wheel' event, making spin speed determination impossible. |
*/ |
s.mousewheel.event = (navigator.userAgent.indexOf('firefox') > -1) ? |
'DOMMouseScroll' : |
isEventSupported() ? |
'wheel' : 'mousewheel'; |
} |
function handleMousewheel(e) { |
if (e.originalEvent) e = e.originalEvent; //jquery fix |
var delta = 0; |
var rtlFactor = s.rtl ? -1 : 1; |
|
var data = normalizeWheel( e ); |
|
if (s.params.mousewheelForceToAxis) { |
if (s.isHorizontal()) { |
if (Math.abs(data.pixelX) > Math.abs(data.pixelY)) delta = data.pixelX * rtlFactor; |
else return; |
} |
else { |
if (Math.abs(data.pixelY) > Math.abs(data.pixelX)) delta = data.pixelY; |
else return; |
} |
} |
else { |
delta = Math.abs(data.pixelX) > Math.abs(data.pixelY) ? - data.pixelX * rtlFactor : - data.pixelY; |
} |
|
if (delta === 0) return; |
|
if (s.params.mousewheelInvert) delta = -delta; |
|
if (!s.params.freeMode) { |
if ((new window.Date()).getTime() - s.mousewheel.lastScrollTime > 60) { |
if (delta < 0) { |
if ((!s.isEnd || s.params.loop) && !s.animating) { |
s.slideNext(); |
s.emit('onScroll', s, e); |
} |
else if (s.params.mousewheelReleaseOnEdges) return true; |
} |
else { |
if ((!s.isBeginning || s.params.loop) && !s.animating) { |
s.slidePrev(); |
s.emit('onScroll', s, e); |
} |
else if (s.params.mousewheelReleaseOnEdges) return true; |
} |
} |
s.mousewheel.lastScrollTime = (new window.Date()).getTime(); |
|
} |
else { |
//Freemode or scrollContainer: |
var position = s.getWrapperTranslate() + delta * s.params.mousewheelSensitivity; |
var wasBeginning = s.isBeginning, |
wasEnd = s.isEnd; |
|
if (position >= s.minTranslate()) position = s.minTranslate(); |
if (position <= s.maxTranslate()) position = s.maxTranslate(); |
|
s.setWrapperTransition(0); |
s.setWrapperTranslate(position); |
s.updateProgress(); |
s.updateActiveIndex(); |
|
if (!wasBeginning && s.isBeginning || !wasEnd && s.isEnd) { |
s.updateClasses(); |
} |
|
if (s.params.freeModeSticky) { |
clearTimeout(s.mousewheel.timeout); |
s.mousewheel.timeout = setTimeout(function () { |
s.slideReset(); |
}, 300); |
} |
else { |
if (s.params.lazyLoading && s.lazy) { |
s.lazy.load(); |
} |
} |
// Emit event |
s.emit('onScroll', s, e); |
|
// Stop autoplay |
if (s.params.autoplay && s.params.autoplayDisableOnInteraction) s.stopAutoplay(); |
|
// Return page scroll on edge positions |
if (position === 0 || position === s.maxTranslate()) return; |
} |
|
if (e.preventDefault) e.preventDefault(); |
else e.returnValue = false; |
return false; |
} |
s.disableMousewheelControl = function () { |
if (!s.mousewheel.event) return false; |
var target = s.container; |
if (s.params.mousewheelEventsTarged !== 'container') { |
target = $(s.params.mousewheelEventsTarged); |
} |
target.off(s.mousewheel.event, handleMousewheel); |
s.params.mousewheelControl = false; |
return true; |
}; |
|
s.enableMousewheelControl = function () { |
if (!s.mousewheel.event) return false; |
var target = s.container; |
if (s.params.mousewheelEventsTarged !== 'container') { |
target = $(s.params.mousewheelEventsTarged); |
} |
target.on(s.mousewheel.event, handleMousewheel); |
s.params.mousewheelControl = true; |
return true; |
}; |