|
1 /*! |
|
2 * jQuery Mousewheel 3.1.13 |
|
3 * |
|
4 * Copyright jQuery Foundation and other contributors |
|
5 * Released under the MIT license |
|
6 * http://jquery.org/license |
|
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 })); |