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 }));