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

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

     3  *

     4  * Version: 3.1.6

     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     $.event.special.mousewheel = {

    35         version: '3.1.6',

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

    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         event = $.event.fix(orgEvent);

    77         event.type = 'mousewheel';

    78 

    79         // Old school scrollwheel delta

    80         if ( 'detail'      in orgEvent ) { deltaY = orgEvent.detail * -1;      }

    81         if ( 'wheelDelta'  in orgEvent ) { deltaY = orgEvent.wheelDelta;       }

    82         if ( 'wheelDeltaY' in orgEvent ) { deltaY = orgEvent.wheelDeltaY;      }

    83         if ( 'wheelDeltaX' in orgEvent ) { deltaX = orgEvent.wheelDeltaX * -1; }

    84 

    85         // Firefox < 17 horizontal scrolling related to DOMMouseScroll event

    86         if ( 'axis' in orgEvent && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) {

    87             deltaX = deltaY * -1;

    88             deltaY = 0;

    89         }

    90 

    91         // Set delta to be deltaY or deltaX if deltaY is 0 for backwards compatabilitiy

    92         delta = deltaY === 0 ? deltaX : deltaY;

    93 

    94         // New school wheel delta (wheel event)

    95         if ( 'deltaY' in orgEvent ) {

    96           deltaY = orgEvent.deltaY * -1;

    97           delta  = deltaY;

    98         }

    99         if ( 'deltaX' in orgEvent ) {

   100           deltaX = orgEvent.deltaX;

   101           if ( deltaY === 0 ) { delta  = deltaX * -1; }

   102         }

   103 

   104         // No change actually happened, no reason to go any further

   105         if ( deltaY === 0 && deltaX === 0 ) { return; }

   106 

   107         // Store lowest absolute delta to normalize the delta values

   108         absDelta = Math.max( Math.abs(deltaY), Math.abs(deltaX) );

   109         if ( !lowestDelta || absDelta < lowestDelta ) {

   110           lowestDelta = absDelta;

   111         }

   112 

   113         // Get a whole, normalized value for the deltas

   114         delta  = Math[ delta  >= 1 ? 'floor' : 'ceil' ](delta  / lowestDelta);

   115         deltaX = Math[ deltaX >= 1 ? 'floor' : 'ceil' ](deltaX / lowestDelta);

   116         deltaY = Math[ deltaY >= 1 ? 'floor' : 'ceil' ](deltaY / lowestDelta);

   117 

   118         // Add information to the event object

   119         event.deltaX = deltaX;

   120         event.deltaY = deltaY;

   121         event.deltaFactor = lowestDelta;

   122 

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

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

   125 

   126         // Clearout lowestDelta after sometime to better

   127         // handle multiple device types that give different

   128         // a different lowestDelta

   129         // Ex: trackpad = 3 and mouse wheel = 120

   130         if (nullLowestDeltaTimeout) { clearTimeout(nullLowestDeltaTimeout); }

   131         nullLowestDeltaTimeout = setTimeout(nullLowestDelta, 200);

   132 

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

   134     }

   135 

   136     function nullLowestDelta() {

   137       lowestDelta = null;

   138     }

   139 

   140 }));