crm.fsf.org/20131203/files/misc/jquery.mousewheel.js

   1 /*! Copyright (c) 2013 Brandon Aaron (http://brandon.aaron.sh)
   2  * Licensed under the MIT License (LICENSE.txt).
   3  *
   4  * Version: 3.1.10-pre
   5  *
   6  * Requires: jQuery 1.2.2+
   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.9',
  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         },
  59
  60         getLineHeight: function(elem) {
  61             var $parent = $(elem)['offsetParent' in $.fn ? 'offsetParent' : 'parent']();
  62             if (!$parent.length) {
  63                 $parent = $('body');
  64             }
  65             return parseInt($parent.css('fontSize'), 10);
  66         },
  67
  68         getPageHeight: function(elem) {
  69             return $(elem).height();
  70         },
  71
  72         settings: {
  73             adjustOldDeltas: true
  74         }
  75     };
  76
  77     $.fn.extend({
  78         mousewheel: function(fn) {
  79             return fn ? this.bind('mousewheel', fn) : this.trigger('mousewheel');
  80         },
  81
  82         unmousewheel: function(fn) {
  83             return this.unbind('mousewheel', fn);
  84         }
  85     });
  86
  87
  88     function handler(event) {
  89         var orgEvent   = event || window.event,
  90             args       = slice.call(arguments, 1),
  91             delta      = 0,
  92             deltaX     = 0,
  93             deltaY     = 0,
  94             absDelta   = 0;
  95         event = $.event.fix(orgEvent);
  96         event.type = 'mousewheel';
  97
  98         // Old school scrollwheel delta
  99         if ( 'detail'      in orgEvent ) { deltaY = orgEvent.detail * -1;      }
 100         if ( 'wheelDelta'  in orgEvent ) { deltaY = orgEvent.wheelDelta;       }
 101         if ( 'wheelDeltaY' in orgEvent ) { deltaY = orgEvent.wheelDeltaY;      }
 102         if ( 'wheelDeltaX' in orgEvent ) { deltaX = orgEvent.wheelDeltaX * -1; }
 103
 104         // Firefox < 17 horizontal scrolling related to DOMMouseScroll event
 105         if ( 'axis' in orgEvent && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) {
 106             deltaX = deltaY * -1;
 107             deltaY = 0;
 108         }
 109
 110         // Set delta to be deltaY or deltaX if deltaY is 0 for backwards compatabilitiy
 111         delta = deltaY === 0 ? deltaX : deltaY;
 112
 113         // New school wheel delta (wheel event)
 114         if ( 'deltaY' in orgEvent ) {
 115             deltaY = orgEvent.deltaY * -1;
 116             delta  = deltaY;
 117         }
 118         if ( 'deltaX' in orgEvent ) {
 119             deltaX = orgEvent.deltaX;
 120             if ( deltaY === 0 ) { delta  = deltaX * -1; }
 121         }
 122
 123         // No change actually happened, no reason to go any further
 124         if ( deltaY === 0 && deltaX === 0 ) { return; }
 125
 126         // Need to convert lines and pages to pixels if we aren't already in pixels
 127         // There are three delta modes:
 128         //   * deltaMode 0 is by pixels, nothing to do
 129         //   * deltaMode 1 is by lines
 130         //   * deltaMode 2 is by pages
 131         if ( orgEvent.deltaMode === 1 ) {
 132             var lineHeight = $.data(this, 'mousewheel-line-height');
 133             delta  *= lineHeight;
 134             deltaY *= lineHeight;
 135             deltaX *= lineHeight;
 136         } else if ( orgEvent.deltaMode === 2 ) {
 137             var pageHeight = $.data(this, 'mousewheel-page-height');
 138             delta  *= pageHeight;
 139             deltaY *= pageHeight;
 140             deltaX *= pageHeight;
 141         }
 142
 143         // Store lowest absolute delta to normalize the delta values
 144         absDelta = Math.max( Math.abs(deltaY), Math.abs(deltaX) );
 145
 146         if ( !lowestDelta || absDelta < lowestDelta ) {
 147             lowestDelta = absDelta;
 148
 149             // Adjust older deltas if necessary
 150             if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
 151                 lowestDelta /= 40;
 152             }
 153         }
 154
 155         // Adjust older deltas if necessary
 156         if ( shouldAdjustOldDeltas(orgEvent, absDelta) ) {
 157             // Divide all the things by 40!
 158             delta  /= 40;
 159             deltaX /= 40;
 160             deltaY /= 40;
 161         }
 162
 163         // Get a whole, normalized value for the deltas
 164         delta  = Math[ delta  >= 1 ? 'floor' : 'ceil' ](delta  / lowestDelta);
 165         deltaX = Math[ deltaX >= 1 ? 'floor' : 'ceil' ](deltaX / lowestDelta);
 166         deltaY = Math[ deltaY >= 1 ? 'floor' : 'ceil' ](deltaY / lowestDelta);
 167
 168         // Add information to the event object
 169         event.deltaX = deltaX;
 170         event.deltaY = deltaY;
 171         event.deltaFactor = lowestDelta;
 172         // Go ahead and set deltaMode to 0 since we converted to pixels
 173         // Although this is a little odd since we overwrite the deltaX/Y
 174         // properties with normalized deltas.
 175         event.deltaMode = 0;
 176
 177         // Add event and delta to the front of the arguments
 178         args.unshift(event, delta, deltaX, deltaY);
 179
 180         // Clearout lowestDelta after sometime to better
 181         // handle multiple device types that give different
 182         // a different lowestDelta
 183         // Ex: trackpad = 3 and mouse wheel = 120
 184         if (nullLowestDeltaTimeout) { clearTimeout(nullLowestDeltaTimeout); }
 185         nullLowestDeltaTimeout = setTimeout(nullLowestDelta, 200);
 186
 187         return ($.event.dispatch || $.event.handle).apply(this, args);
 188     }
 189
 190     function nullLowestDelta() {
 191         lowestDelta = null;
 192     }
 193
 194     function shouldAdjustOldDeltas(orgEvent, absDelta) {
 195         // If this is an older event and the delta is divisable by 120,
 196         // then we are assuming that the browser is treating this as an
 197         // older mouse wheel event and that we should divide the deltas
 198         // by 40 to try and get a more usable deltaFactor.
 199         // Side note, this actually impacts the reported scroll distance
 200         // in older browsers and can cause scrolling to be slower than native.
 201         // Turn this off by setting $.event.special.mousewheel.settings.adjustOldDeltas to false.
 202         return special.settings.adjustOldDeltas && orgEvent.type === 'mousewheel' && absDelta % 120 === 0;
 203     }
 204
 205 }));