1 /*! Copyright (c) 2013 Brandon Aaron (http://brandon.aaron.sh)

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

     3  *

     4  * Version: 3.1.4

     5  *

     6  * Requires: 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     var toBind = 'onwheel' in document || document.documentMode >= 9 ? ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll'];

    24     var lowestDelta, lowestDeltaXY;

    25 

    26     if ( $.event.fixHooks ) {

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

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

    29         }

    30     }

    31 

    32     $.event.special.mousewheel = {

    33         setup: function() {

    34             if ( this.addEventListener ) {

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

    36                     this.addEventListener( toBind[--i], handler, false );

    37                 }

    38             } else {

    39                 this.onmousewheel = handler;

    40             }

    41         },

    42 

    43         teardown: function() {

    44             if ( this.removeEventListener ) {

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

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

    47                 }

    48             } else {

    49                 this.onmousewheel = null;

    50             }

    51         }

    52     };

    53 

    54     $.fn.extend({

    55         mousewheel: function(fn) {

    56             return fn ? this.bind('mousewheel', fn) : this.trigger('mousewheel');

    57         },

    58 

    59         unmousewheel: function(fn) {

    60             return this.unbind('mousewheel', fn);

    61         }

    62     });

    63 

    64 

    65     function handler(event) {

    66         var orgEvent   = event || window.event,

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

    68             delta      = 0,

    69             deltaX     = 0,

    70             deltaY     = 0,

    71             absDelta   = 0,

    72             absDeltaXY = 0,

    73             fn;

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

    75         event.type = 'mousewheel';

    76 

    77         // Old school scrollwheel delta

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

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

    80 

    81         // At a minimum, setup the deltaY to be delta

    82         deltaY = delta;

    83 

    84         // Firefox < 17 related to DOMMouseScroll event

    85         if ( orgEvent.axis !== undefined && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) {

    86             deltaY = 0;

    87             deltaX = delta * -1;

    88         }

    89 

    90         // New school wheel delta (wheel event)

    91         if ( orgEvent.deltaY ) {

    92             deltaY = orgEvent.deltaY * -1;

    93             delta  = deltaY;

    94         }

    95         if ( orgEvent.deltaX ) {

    96             deltaX = orgEvent.deltaX;

    97             delta  = deltaX * -1;

    98         }

    99 

   100         // Webkit

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

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

   103 

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

   105         absDelta = Math.abs(delta);

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

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

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

   109 

   110         // Get a whole value for the deltas

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

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

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

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

   115 

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

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

   118 

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

   120     }

   121 

   122 }));