hjg
2024-07-09 30304784e82d4bba24121328da8eb8490aec4f4f
提交 | 用户 | 时间
58d006 1 /*!
A 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 }));