https://imuzik.com.vn/js/mousewheel.js

1// JavaScript Document
2/*!
3 * jQuery Mousewheel 3.1.12
4 *
5 * Copyright 2014 jQuery Foundation and other contributors
6 * Released under the MIT license.
7 * http://jquery.org/license
8 */
9
10(function (factory) {
11    if ( typeof define === 'function' && define.amd ) {
12        // AMD. Register as an anonymous module.
13        define(['jquery'], factory);
14    } else if (typeof exports === 'object') {
15        // Node/CommonJS style for Browserify
16        module.exports = factory;
17    } else {
18        // Browser globals
19        factory(jQuery);
20    }
21}(function ($) {
22
23    var toFix  = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll'],
24        toBind = ( 'onwheel' in document || document.documentMode >= 9 ) ?
25                    ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll'],
26        slice  = Array.prototype.slice,
27        nullLowestDeltaTimeout, lowestDelta;
28
29    if ( $.event.fixHooks ) {
30        for ( var i = toFix.length; i; ) {
31            $.event.fixHooks[ toFix[--i] ] = $.event.mouseHooks;
32        }
33    }
34
35    var special = $.event.special.mousewheel = {
36        version: '3.1.12',
37
38        setup: function() {
39            if ( this.addEventListener ) {
40                for ( var i = toBind.length; i; ) {
41                    this.addEventListener( toBind[--i], handler, false );
42                }
43            } else {
44                this.onmousewheel = handler;
45            }
46            // Store the line height and page height for this particular element
47            $.data(this, 'mousewheel-line-height', special.getLineHeight(this));
48            $.data(this, 'mousewheel-page-height', special.getPageHeight(this));
49        },
50
51        teardown: function() {
52            if ( this.removeEventListener ) {
53                for ( var i = toBind.length; i; ) {
54                    this.removeEventListener( toBind[--i], handler, false );
55                }
56            } else {
57                this.onmousewheel = null;
58            }
59            // Clean up the data we added to the element
60            $.removeData(this, 'mousewheel-line-height');
61            $.removeData(this, 'mousewheel-page-height');
62        },
63
64        getLineHeight: function(elem) {
65            var $elem = $(elem),
66                $parent = $elem['offsetParent' in $.fn ? 'offsetParent' : 'parent']();
67            if (!$parent.length) {
68                $parent = $('body');
69            }
70            return parseInt($parent.css('fontSize'), 10) || parseInt($elem.css('fontSize'), 10) || 16;
71        },
72
73        getPageHeight: function(elem) {
74            return $(elem).height();
75        },
76
77        settings: {
78            adjustOldDeltas: true, // see shouldAdjustOldDeltas() below
79            normalizeOffset: true  // calls getBoundingClientRect for each event
80        }
81    };
82
83    $.fn.extend({
84        mousewheel: function(fn) {
85            return fn ? this.bind('mousewheel', fn) : this.trigger('mousewheel');
86        },
87
88        unmousewheel: function(fn) {
89            return this.unbind('mousewheel', fn);
90        }
91    });
92
93
94    function handler(event) {
95        var orgEvent   = event || window.event,
96            args       = slice.call(arguments, 1),
97            delta      = 0,
98            deltaX     = 0,
99            deltaY     = 0,
100            absDelta   = 0,
101            offsetX    = 0,
102            offsetY    = 0;
103        event = $.event.fix(orgEvent);
104        event.type = 'mousewheel';
105
106        // Old school scrollwheel delta
107        if ( 'detail'      in orgEvent ) { deltaY = orgEvent.detail * -1;      }
108        if ( 'wheelDelta'  in orgEvent ) { deltaY = orgEvent.wheelDelta;       }
109        if ( 'wheelDeltaY' in orgEvent ) { deltaY = orgEvent.wheelDeltaY;      }
110        if ( 'wheelDeltaX' in orgEvent ) { deltaX = orgEvent.wheelDeltaX * -1; }
111
112        // Firefox < 17 horizontal scrolling related to DOMMouseScroll event
113        if ( 'axis' in orgEvent && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) {
114            deltaX = deltaY * -1;
115            deltaY = 0;
116        }
117
118        // Set delta to be deltaY or deltaX if deltaY is 0 for backwards compatabilitiy
119        delta = deltaY === 0 ? deltaX : deltaY;
120
121        // New school wheel delta (wheel event)
122        if ( 'deltaY' in orgEvent ) {
123            deltaY = orgEvent.deltaY * -1;
124            delta  = deltaY;
125        }
126        if ( 'deltaX' in orgEvent ) {
127            deltaX = orgEvent.deltaX;
128            if ( deltaY === 0 ) { delta  = deltaX * -1; }
129        }
130
131        // No change actually happened, no reason to go any further
132        if ( deltaY === 0 && deltaX === 0 ) { return; }
133
134        // Need to convert lines and pages to pixels if we aren't already in pixels
135        // There are three delta modes:
136        //   * deltaMode 0 is by pixels, nothing to do
137        //   * deltaMode 1 is by lines
138        //   * deltaMode 2 is by pages
139        if ( orgEvent.deltaMode === 1 ) {
140            var lineHeight = $.data(this, 'mousewheel-line-height');
141            delta  *= lineHeight;
142            deltaY *= lineHeight;
143            deltaX *= lineHeight;
144        } else if ( orgEvent.deltaMode === 2 ) {
145            var pageHeight = $.data(this, 'mousewheel-page-height');
146            delta  *= pageHeight;
147            deltaY *= pageHeight;
148            deltaX *= pageHeight;
149        }
150
151        // Store lowest absolute delta to normalize the delta values
152        absDelta = Math.max( Math.abs(deltaY), Math.abs(deltaX) );
153
154        if ( !lowestDelta || absDelta < lowestDelta ) {
155            lowestDelta = absDelta;
156
157            // Adjust older deltas if necessary
158            if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
159                lowestDelta /= 40;
160            }
161        }
162
163        // Adjust older deltas if necessary
164        if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
165            // Divide all the things by 40!
166            delta  /= 40;
167            deltaX /= 40;
168            deltaY /= 40;
169        }
170
171        // Get a whole, normalized value for the deltas
172        delta  = Math[ delta  >= 1 ? 'floor' : 'ceil' ](delta  / lowestDelta);
173        deltaX = Math[ deltaX >= 1 ? 'floor' : 'ceil' ](deltaX / lowestDelta);
174        deltaY = Math[ deltaY >= 1 ? 'floor' : 'ceil' ](deltaY / lowestDelta);
175
176        // Normalise offsetX and offsetY properties
177        if ( special.settings.normalizeOffset && this.getBoundingClientRect ) {
178            var boundingRect = this.getBoundingClientRect();
179            offsetX = event.clientX - boundingRect.left;
180            offsetY = event.clientY - boundingRect.top;
181        }
182
183        // Add information to the event object
184        event.deltaX = deltaX;
185        event.deltaY = deltaY;
186        event.deltaFactor = lowestDelta;
187        event.offsetX = offsetX;
188        event.offsetY = offsetY

188;
189        // Go ahead and set deltaMode to 0 since we converted to pixels
190        // Although this is a little odd since we overwrite the deltaX/Y
191        // properties with normalized deltas.
192        event.deltaMode = 0;
193
194        // Add event and delta to the front of the arguments
195        args.unshift(event, delta, deltaX, deltaY);
196
197        // Clearout lowestDelta after sometime to better
198        // handle multiple device types that give different
199        // a different lowestDelta
200        // Ex: trackpad = 3 and mouse wheel = 120
201        if (nullLowestDeltaTimeout) { clearTimeout(nullLowestDeltaTimeout); }
202        nullLowestDeltaTimeout = setTimeout(nullLowestDelta, 200);
203
204        return ($.event.dispatch || $.event.handle).apply(this, args);
205    }
206
207    function nullLowestDelta() {
208        lowestDelta = null;
209    }
210
211    function shouldAdjustOldDeltas(orgEvent, absDelta) {
212        // If this is an older event and the delta is divisable by 120,
213        // then we are assuming that the browser is treating this as an
214        // older mouse wheel event and that we should divide the deltas
215        // by 40 to try and get a more usable deltaFactor.
216        // Side note, this actually impacts the reported scroll distance
217        // in older browsers and can cause scrolling to be slower than native.
218        // Turn this off by setting $.event.special.mousewheel.settings.adjustOldDeltas to false.
219        return special.settings.adjustOldDeltas && orgEvent.type === 'mousewheel' && absDelta % 120 === 0;
220    }
221
222}));