1 /*! Copyright (c) 2013 Brandon Aaron (http://brandonaaron.net)

     2  * Licensed under the MIT License (LICENSE.txt).

     3  *

     4  * Thanks to: http://adomas.org/javascript-mouse-wheel/ for some pointers.

     5  * Thanks to: Mathias Bank(http://www.mathias-bank.de) for a scope bug fix.

     6  * Thanks to: Seamus Leahy for adding deltaX and deltaY

     7  *

     8  * Version: 3.1.3

     9  *

    10  * Requires: 1.2.2+

    11  */

    12 

    13 (function (factory) {

    14     if ( typeof define === 'function' && define.amd ) {

    15         // AMD. Register as an anonymous module.

    16         define(['jquery'], factory);

    17     } else if (typeof exports === 'object') {

    18         // Node/CommonJS style for Browserify

    19         module.exports = factory;

    20     } else {

    21         // Browser globals

    22         factory(jQuery);

    23     }

    24 }(function ($) {

    25 

    26     var toFix = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll'];

    27     var toBind = 'onwheel' in document || document.documentMode >= 9 ? ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll'];

    28     var lowestDelta, lowestDeltaXY;

    29 

    30     if ( $.event.fixHooks ) {

    31         for ( var i = toFix.length; i; ) {

    32             $.event.fixHooks[ toFix[--i] ] = $.event.mouseHooks;

    33         }

    34     }

    35 

    36     $.event.special.mousewheel = {

    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         },

    46 

    47         teardown: function() {

    48             if ( this.removeEventListener ) {

    49                 for ( var i = toBind.length; i; ) {

    50                     this.removeEventListener( toBind[--i], handler, false );

    51                 }

    52             } else {

    53                 this.onmousewheel = null;

    54             }

    55         }

    56     };

    57 

    58     $.fn.extend({

    59         mousewheel: function(fn) {

    60             return fn ? this.bind("mousewheel", fn) : this.trigger("mousewheel");

    61         },

    62 

    63         unmousewheel: function(fn) {

    64             return this.unbind("mousewheel", fn);

    65         }

    66     });

    67 

    68 

    69     function handler(event) {

    70         var orgEvent = event || window.event,

    71             args = [].slice.call(arguments, 1),

    72             delta = 0,

    73             deltaX = 0,

    74             deltaY = 0,

    75             absDelta = 0,

    76             absDeltaXY = 0,

    77             fn;

    78         event = $.event.fix(orgEvent);

    79         event.type = "mousewheel";

    80 

    81         // Old school scrollwheel delta

    82         if ( orgEvent.wheelDelta ) { delta = orgEvent.wheelDelta; }

    83         if ( orgEvent.detail )     { delta = orgEvent.detail * -1; }

    84 

    85         // New school wheel delta (wheel event)

    86         if ( orgEvent.deltaY ) {

    87             deltaY = orgEvent.deltaY * -1;

    88             delta  = deltaY;

    89         }

    90         if ( orgEvent.deltaX ) {

    91             deltaX = orgEvent.deltaX;

    92             delta  = deltaX * -1;

    93         }

    94 

    95         // Webkit

    96         if ( orgEvent.wheelDeltaY !== undefined ) { deltaY = orgEvent.wheelDeltaY; }

    97         if ( orgEvent.wheelDeltaX !== undefined ) { deltaX = orgEvent.wheelDeltaX * -1; }

    98 

    99         // Look for lowest delta to normalize the delta values

   100         absDelta = Math.abs(delta);

   101         if ( !lowestDelta || absDelta < lowestDelta ) { lowestDelta = absDelta; }

   102         absDeltaXY = Math.max(Math.abs(deltaY), Math.abs(deltaX));

   103         if ( !lowestDeltaXY || absDeltaXY < lowestDeltaXY ) { lowestDeltaXY = absDeltaXY; }

   104 

   105         // Get a whole value for the deltas

   106         fn = delta > 0 ? 'floor' : 'ceil';

   107         delta  = Math[fn](delta / lowestDelta);

   108         deltaX = Math[fn](deltaX / lowestDeltaXY);

   109         deltaY = Math[fn](deltaY / lowestDeltaXY);

   110 

   111         // Add event and delta to the front of the arguments

   112         args.unshift(event, delta, deltaX, deltaY);

   113 

   114         return ($.event.dispatch || $.event.handle).apply(this, args);

   115     }

   116 

   117 }));