      1 /*! Copyright (c) 2013 Brandon Aaron (http://brandon.aaron.sh)
      2  * Licensed under the MIT License (LICENSE.txt).
      3  *
      4  * Version: 3.1.12
      5  *
      6  * Requires: jQuery 1.2.2+
      7  */
      8
      9 (function (factory) {
     10     if ( typeof define === 'function' && define.amd ) {
     11         // AMD. Register as an anonymous module.
     12         define(['jquery'], factory);
     13     } else if (typeof exports === 'object') {
     14         // Node/CommonJS style for Browserify
     15         module.exports = factory;
     16     } else {
     17         // Browser globals
     18         factory(jQuery);
     19     }
     20 }(function ($) {
     21
     22     var toFix  = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll'],
     23         toBind = ( 'onwheel' in document || document.documentMode >= 9 ) ?
     24                     ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll'],
     25         slice  = Array.prototype.slice,
     26         nullLowestDeltaTimeout, lowestDelta;
     27
     28     if ( $.event.fixHooks ) {
     29         for ( var i = toFix.length; i; ) {
     30             $.event.fixHooks[ toFix[--i] ] = $.event.mouseHooks;
     31         }
     32     }
     33
     34     var special = $.event.special.mousewheel = {
     35         version: '3.1.12',
     36
     37         setup: function() {
     38             if ( this.addEventListener ) {
     39                 for ( var i = toBind.length; i; ) {
     40                     this.addEventListener( toBind[--i], handler, false );
     41                 }
     42             } else {
     43                 this.onmousewheel = handler;
     44             }
     45             // Store the line height and page height for this particular element
     46             $.data(this, 'mousewheel-line-height', special.getLineHeight(this));
     47             $.data(this, 'mousewheel-page-height', special.getPageHeight(this));
     48         },
     49
     50         teardown: function() {
     51             if ( this.removeEventListener ) {
     52                 for ( var i = toBind.length; i; ) {
     53                     this.removeEventListener( toBind[--i], handler, false );
     54                 }
     55             } else {
     56                 this.onmousewheel = null;
     57             }
     58             // Clean up the data we added to the element
     59             $.removeData(this, 'mousewheel-line-height');
     60             $.removeData(this, 'mousewheel-page-height');
     61         },
     62
     63         getLineHeight: function(elem) {
     64             var $elem = $(elem),
     65                 $parent = $elem['offsetParent' in $.fn ? 'offsetParent' : 'parent']();
     66             if (!$parent.length) {
     67                 $parent = $('body');
     68             }
     69             return parseInt($parent.css('fontSize'), 10) || parseInt($elem.css('fontSize'), 10) || 16;
     70         },
     71
     72         getPageHeight: function(elem) {
     73             return $(elem).height();
     74         },
     75
     76         settings: {
     77             adjustOldDeltas: true, // see shouldAdjustOldDeltas() below
     78             normalizeOffset: true  // calls getBoundingClientRect for each event
     79         }
     80     };
     81
     82     $.fn.extend({
     83         mousewheel: function(fn) {
     84             return fn ? this.bind('mousewheel', fn) : this.trigger('mousewheel');
     85         },
     86
     87         unmousewheel: function(fn) {
     88             return this.unbind('mousewheel', fn);
     89         }
     90     });
     91
     92
     93     function handler(event) {
     94         var orgEvent   = event || window.event,
     95             args       = slice.call(arguments, 1),
     96             delta      = 0,
     97             deltaX     = 0,
     98             deltaY     = 0,
     99             absDelta   = 0,
    100             offsetX    = 0,
    101             offsetY    = 0;
    102         event = $.event.fix(orgEvent);
    103         event.type = 'mousewheel';
    104
    105         // Old school scrollwheel delta
    106         if ( 'detail'      in orgEvent ) { deltaY = orgEvent.detail * -1;      }
    107         if ( 'wheelDelta'  in orgEvent ) { deltaY = orgEvent.wheelDelta;       }
    108         if ( 'wheelDeltaY' in orgEvent ) { deltaY = orgEvent.wheelDeltaY;      }
    109         if ( 'wheelDeltaX' in orgEvent ) { deltaX = orgEvent.wheelDeltaX * -1; }
    110
    111         // Firefox < 17 horizontal scrolling related to DOMMouseScroll event
    112         if ( 'axis' in orgEvent && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) {
    113             deltaX = deltaY * -1;
    114             deltaY = 0;
    115         }
    116
    117         // Set delta to be deltaY or deltaX if deltaY is 0 for backwards compatabilitiy
    118         delta = deltaY === 0 ? deltaX : deltaY;
    119
    120         // New school wheel delta (wheel event)
    121         if ( 'deltaY' in orgEvent ) {
    122             deltaY = orgEvent.deltaY * -1;
    123             delta  = deltaY;
    124         }
    125         if ( 'deltaX' in orgEvent ) {
    126             deltaX = orgEvent.deltaX;
    127             if ( deltaY === 0 ) { delta  = deltaX * -1; }
    128         }
    129
    130         // No change actually happened, no reason to go any further
    131         if ( deltaY === 0 && deltaX === 0 ) { return; }
    132
    133         // Need to convert lines and pages to pixels if we aren't already in pixels
    134         // There are three delta modes:
    135         //   * deltaMode 0 is by pixels, nothing to do
    136         //   * deltaMode 1 is by lines
    137         //   * deltaMode 2 is by pages
    138         if ( orgEvent.deltaMode === 1 ) {
    139             var lineHeight = $.data(this, 'mousewheel-line-height');
    140             delta  *= lineHeight;
    141             deltaY *= lineHeight;
    142             deltaX *= lineHeight;
    143         } else if ( orgEvent.deltaMode === 2 ) {
    144             var pageHeight = $.data(this, 'mousewheel-page-height');
    145             delta  *= pageHeight;
    146             deltaY *= pageHeight;
    147             deltaX *= pageHeight;
    148         }
    149
    150         // Store lowest absolute delta to normalize the delta values
    151         absDelta = Math.max( Math.abs(deltaY), Math.abs(deltaX) );
    152
    153         if ( !lowestDelta || absDelta < lowestDelta ) {
    154             lowestDelta = absDelta;
    155
    156             // Adjust older deltas if necessary
    157             if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
    158                 lowestDelta /= 40;
    159             }
    160         }
    161
    162         // Adjust older deltas if necessary
    163         if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
    164             // Divide all the things by 40!
    165             delta  /= 40;
    166             deltaX /= 40;
    167             deltaY /= 40;
    168         }
    169
    170         // Get a whole, normalized value for the deltas
    171         delta  = Math[ delta  >= 1 ? 'floor' : 'ceil' ](delta  / lowestDelta);
    172         deltaX = Math[ deltaX >= 1 ? 'floor' : 'ceil' ](deltaX / lowestDelta);
    173         deltaY = Math[ deltaY >= 1 ? 'floor' : 'ceil' ](deltaY / lowestDelta);
    174
    175         // Normalise offsetX and offsetY properties
    176         if ( special.settings.normalizeOffset && this.getBoundingClientRect ) {
    177             var boundingRect = this.getBoundingClientRect();
    178             offsetX = event.clientX - boundingRect.left;
    179             offsetY = event.clientY - boundingRect.top;
    180         }
    181
    182         // Add information to the event object
    183         event.deltaX = deltaX;
    184         event.deltaY = deltaY;
    185         event.deltaFactor = lowestDelta;
    186         event.offsetX = offsetX;
    187         event.offsetY = offsetY;
    188         // Go ahead and set deltaMode to 0 since we converted to pixels
    189         // Although this is a little odd since we overwrite the deltaX/Y
    190         // properties with normalized deltas.
    191         event.deltaMode = 0;
    192
    193         // Add event and delta to the front of the arguments
    194         args.unshift(event, delta, deltaX, deltaY);
    195
    196         // Clearout lowestDelta after sometime to better
    197         // handle multiple device types that give different
    198         // a different lowestDelta
    199         // Ex: trackpad = 3 and mouse wheel = 120
    200         if (nullLowestDeltaTimeout) { clearTimeout(nullLowestDeltaTimeout); }
    201         nullLowestDeltaTimeout = setTimeout(nullLowestDelta, 200);
    202
    203         return ($.event.dispatch || $.event.handle).apply(this, args);
    204     }
    205
    206     function nullLowestDelta() {
    207         lowestDelta = null;
    208     }
    209
    210     function shouldAdjustOldDeltas(orgEvent, absDelta) {
    211         // If this is an older event and the delta is divisable by 120,
    212         // then we are assuming that the browser is treating this as an
    213         // older mouse wheel event and that we should divide the deltas
    214         // by 40 to try and get a more usable deltaFactor.
    215         // Side note, this actually impacts the reported scroll distance
    216         // in older browsers and can cause scrolling to be slower than native.
    217         // Turn this off by setting $.event.special.mousewheel.settings.adjustOldDeltas to false.
    218         return special.settings.adjustOldDeltas && orgEvent.type === 'mousewheel' && absDelta % 120 === 0;
    219     }
    220
    221 }));