ecomp-portal-FE/client/bower_components/jquery-mousewheel/jquery.mousewheel.js

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