https://www.msamb.com/PortalContent/Theme/js/jquery.mousewheel.js

1/*!
2 * jQuery Mousewheel 3.1.13
3 * Copyright OpenJS Foundation and other contributors
4 */
5
6( function( factory ) {
7    if ( typeof define === "function" && define.amd ) {
8
9        // AMD. Register as an anonymous module.
10        define( [ "jquery" ], factory );
11    } else if ( typeof exports === "object" ) {
12
13        // Node/CommonJS style for Browserify
14        module.exports = factory;
15    } else {
16
17        // Browser globals
18        factory( jQuery );
19    }
20} )( function( $ ) {
21
22    var toFix  = [ "wheel", "mousewheel", "DOMMouseScroll", "MozMousePixelScroll" ],
23        toBind = ( "onwheel" in window.document || window.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
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
60            // Clean up the data we added to the element
61            $.removeData( this, "mousewheel-line-height" );
62            $.removeData( this, "mousewheel-page-height" );
63        },
64
65        getLineHeight: function( elem ) {
66            var $elem = $( elem ),
67                $parent = $elem[ "offsetParent" in $.fn ? "offsetParent" : "parent" ]();
68            if ( !$parent.length ) {
69                $parent = $( "body" );
70            }
71            return parseInt( $parent.css( "fontSize" ), 10 ) ||
72                parseInt( $elem.css( "fontSize" ), 10 ) || 16;
73        },
74
75        getPageHeight: function( elem ) {
76            return $( elem ).height();
77        },
78
79        settings: {
80            adjustOldDeltas: true, // see shouldAdjustOldDeltas() below
81            normalizeOffset: true  // calls getBoundingClientRect for each event
82        }
83    };
84
85    $.fn.extend( {
86        mousewheel: function( fn ) {
87            return fn ? this.on( "mousewheel", fn ) : this.trigger( "mousewheel" );
88        },
89
90        unmousewheel: function( fn ) {
91            return this.off( "mousewheel", fn );
92        }
93    } );
94
95
96    function handler( event ) {
97        var orgEvent   = event || window.event,
98            args       = slice.call( arguments, 1 ),
99            delta      = 0,
100            deltaX     = 0,
101            deltaY     = 0,
102            absDelta   = 0;
103        event = $.event.fix( orgEvent );
104        event.type = "mousewheel";
105
106        // Old school scrollwheel delta
107        if ( "detail" in orgEvent ) {
108            deltaY = orgEvent.detail * -1;
109        }
110        if ( "wheelDelta" in orgEvent ) {
111            deltaY = orgEvent.wheelDelta;
112        }
113        if ( "wheelDeltaY" in orgEvent ) {
114            deltaY = orgEvent.wheelDeltaY;
115        }
116        if ( "wheelDeltaX" in orgEvent ) {
117            deltaX = orgEvent.wheelDeltaX * -1;
118        }
119
120        // Firefox < 17 horizontal scrolling related to DOMMouseScroll event
121        if ( "axis" in orgEvent && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) {
122            deltaX = deltaY * -1;
123            deltaY = 0;
124        }
125
126        // Set delta to be deltaY or deltaX if deltaY is 0 for backwards compatabilitiy
127        delta = deltaY === 0 ? deltaX : deltaY;
128
129        // New school wheel delta (wheel event)
130        if ( "deltaY" in orgEvent ) {
131            deltaY = orgEvent.deltaY * -1;
132            delta  = deltaY;
133        }
134        if ( "deltaX" in orgEvent ) {
135            deltaX = orgEvent.deltaX;
136            if ( deltaY === 0 ) {
137                delta  = deltaX * -1;
138            }
139        }
140
141        // No change actually happened, no reason to go any further
142        if ( deltaY === 0 && deltaX === 0 ) {
143            return;
144        }
145
146        // Need to convert lines and pages to pixels if we aren't already in pixels
147        // There are three delta modes:
148        //   * deltaMode 0 is by pixels, nothing to do
149        //   * deltaMode 1 is by lines
150        //   * deltaMode 2 is by pages
151        if ( orgEvent.deltaMode === 1 ) {
152            var lineHeight = $.data( this, "mousewheel-line-height" );
153            delta  *= lineHeight;
154            deltaY *= lineHeight;
155            deltaX *= lineHeight;
156        } else if ( orgEvent.deltaMode === 2 ) {
157            var pageHeight = $.data( this, "mousewheel-page-height" );
158            delta  *= pageHeight;
159            deltaY *= pageHeight;
160            deltaX *= pageHeight;
161        }
162
163        // Store lowest absolute delta to normalize the delta values
164        absDelta = Math.max( Math.abs( deltaY ), Math.abs( deltaX ) );
165
166        if ( !lowestDelta || absDelta < lowestDelta ) {
167            lowestDelta = absDelta;
168
169            // Adjust older deltas if necessary
170            if ( shouldAdjustOldDeltas( orgEvent, absDelta ) ) {
171                lowestDelta /= 40;
172            }
173        }
174
175        // Adjust older deltas if necessary
176        if ( shouldAdjustOldDeltas( orgEvent, absDelta ) ) {
177
178            // Divide all the things by 40!
179            delta  /= 40;
180            deltaX /= 40;
181            deltaY /= 40;
182        }
183
184        // Get a whole, normalized value for the deltas
185        delta  = Math[ delta  >= 1 ? "floor" : "ceil" ]( delta  / lowestDelta );
186        deltaX = Math[ deltaX >= 1 ? "floor" : "ceil" ]( deltaX / lowestDelta );
187        deltaY = Math[ deltaY >= 1 ? "floor" : "ceil" ]( deltaY / lowestDelta );
188
189        // Normalise offsetX and offsetY properties
190        if ( special.settings.normalizeOffset && this.getBoundingClientRect ) {
191            var boundingRect = this.getBoundingClientRect();
192            event.offsetX = event.clientX - boundingRect.left;
193            event.offsetY = event.clientY - boundingRect.top;
194        }
195
196        // Add information to the event object
197        event.deltaX = deltaX;
198        event.deltaY = deltaY;
199        event.deltaFactor = lowestDelta;
200
201        // Go ahead and set deltaMode to 0 since we converted to pixels
202        // Although this is a little odd since we overwrite the deltaX/Y
203        // properties with normalized deltas.
204        event.deltaMode = 0;
205
206        // Add event and delta to the front of the arguments
207        args.unshift( event, delta, deltaX, deltaY );
208
209        // Clearout lowestDelta after sometime to better
210        // handle multiple device types that give different
211        // a different lowestDelta
212        // Ex: trackpad = 3 and mouse wheel = 120