jquery-datatables-rails 1.12.2 → 2.1.10.0.0

data/app/assets/javascripts/dataTables/extras/{Scroller.js → dataTables.scroller.js}

@@ -1,23 +1,32 @@
+/*! Scroller 1.2.1
+ * 2011-2014 SpryMedia Ltd - datatables.net/license
+ */
+
 /**
  * @summary     Scroller
  * @description Virtual rendering for DataTables
- * @file        Scroller.js
- * @version     1.1.0
- * @author      Allan Jardine (www.sprymedia.co.uk)
- * @license     GPL v2 or BSD 3 point style
+ * @version     1.2.1
+ * @file        dataTables.scroller.js
+ * @author      SpryMedia Ltd (www.sprymedia.co.uk)
  * @contact     www.sprymedia.co.uk/contact
+ * @copyright   Copyright 2011-2014 SpryMedia Ltd.
+ *
+ * This source file is free software, available under the following license:
+ *   MIT license - http://datatables.net/license/mit
  *
- * @copyright Copyright 2011-2012 Allan Jardine, all rights reserved.
+ * This source file is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
  *
- * This source file is free software, under either the GPL v2 license or a
- * BSD style license, available at:
- *   http://datatables.net/license_gpl2
- *   http://datatables.net/license_bsd
+ * For details please refer to: http://www.datatables.net
  */
 
-(/** @lends <global> */function($, window, document) {
+(function(window, document, undefined){
 
 
+var factory = function( $, DataTable ) {
+"use strict";
+
 /**
  * Scroller is a virtual rendering plug-in for DataTables which allows large
  * datasets to be drawn on screen every quickly. What the virtual rendering means
@@ -34,34 +43,36 @@
  *
  * Scroller is initialised by simply including the letter 'S' in the sDom for the
  * table you want to have this feature enabled on. Note that the 'S' must come
- * AFTER the 't' parameter in sDom.
+ * AFTER the 't' parameter in `dom`.
  *
  * Key features include:
  *   <ul class="limit_length">
  *     <li>Speed! The aim of Scroller for DataTables is to make rendering large data sets fast</li>
  *     <li>Full compatibility with deferred rendering in DataTables 1.9 for maximum speed</li>
- *     <li>Correct visual scrolling implementation, similar to "infinite scrolling" in DataTable core</li>
+ *     <li>Display millions of rows</li>
  *     <li>Integration with state saving in DataTables (scrolling position is saved)</li>
  *     <li>Easy to use</li>
  *   </ul>
  *
  *  @class
  *  @constructor
+ *  @global
  *  @param {object} oDT DataTables settings object
- *  @param {object} [oOpts={}] Configuration object for FixedColumns. Options are defined by {@link Scroller.oDefaults}
+ *  @param {object} [oOpts={}] Configuration object for FixedColumns. Options 
+ *    are defined by {@link Scroller.defaults}
  *
- *  @requires jQuery 1.4+
+ *  @requires jQuery 1.7+
  *  @requires DataTables 1.9.0+
  *
  *  @example
- * 		$(document).ready(function() {
- * 			$('#example').dataTable( {
- * 				"sScrollY": "200px",
- * 				"sAjaxSource": "media/dataset/large.txt",
- * 				"sDom": "frtiS",
- * 				"bDeferRender": true
- * 			} );
- * 		} );
+ *    $(document).ready(function() {
+ *        $('#example').dataTable( {
+ *            "sScrollY": "200px",
+ *            "sAjaxSource": "media/dataset/large.txt",
+ *            "sDom": "frtiS",
+ *            "bDeferRender": true
+ *        } );
+ *    } );
  */
 var Scroller = function ( oDTSettings, oOpts ) {
 	/* Sanity check - you just know it will happen */
@@ -79,7 +90,8 @@ var Scroller = function ( oDTSettings, oOpts ) {
 	/**
 	 * Settings object which contains customisable information for the Scroller instance
 	 * @namespace
-	 * @extends Scroller.DEFAULTS
+	 * @private
+	 * @extends Scroller.defaults
 	 */
 	this.s = {
 		/**
@@ -122,13 +134,6 @@ var Scroller = function ( oDTSettings, oOpts ) {
 		 */
 		"redrawBottom": 0,
 
-		/**
-		 * Height of rows in the table
-		 *  @type     int
-		 *  @default  0
-		 */
-		"rowHeight": null,
-
 		/**
 		 * Auto row height or not indicator
 		 *  @type     bool
@@ -136,13 +141,6 @@ var Scroller = function ( oDTSettings, oOpts ) {
 		 */
 		"autoHeight": true,
 
-		/**
-		 * Pixel height of the viewport
-		 *  @type     int
-		 *  @default  0
-		 */
-		"viewportHeight": 0,
-
 		/**
 		 * Number of rows calculated as visible in the visible viewport
 		 *  @type     int
@@ -165,12 +163,43 @@ var Scroller = function ( oDTSettings, oOpts ) {
 		 *  @type     int
 		 *  @default  null
 		 */
-		"drawTO": null
+		"drawTO": null,
+
+		heights: {
+			jump: null,
+			page: null,
+			virtual: null,
+			scroll: null,
+
+			/**
+			 * Height of rows in the table
+			 *  @type     int
+			 *  @default  0
+			 */
+			row: null,
+
+			/**
+			 * Pixel height of the viewport
+			 *  @type     int
+			 *  @default  0
+			 */
+			viewport: null
+		},
+
+		topRowFloat: 0,
+		scrollDrawDiff: null
 	};
+
+	// @todo The defaults should extend a `c` property and the internal settings
+	// only held in the `s` property. At the moment they are mixed
 	this.s = $.extend( this.s, Scroller.oDefaults, oOpts );
 
+	// Workaround for row height being read from height object (see above comment)
+	this.s.heights.row = this.s.rowHeight;
+
 	/**
 	 * DOM elements used by the class instance
+	 * @private
 	 * @namespace
 	 *
 	 */
@@ -189,13 +218,14 @@ var Scroller = function ( oDTSettings, oOpts ) {
 
 
 
-Scroller.prototype = {
+Scroller.prototype = /** @lends Scroller.prototype */{
 	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 	 * Public methods
 	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 	/**
-	 * Calculate the pixel position from the top of the scrolling container for a given row
+	 * Calculate the pixel position from the top of the scrolling container for
+	 * a given row
 	 *  @param {int} iRow Row number to calculate the position of
 	 *  @returns {int} Pixels
 	 *  @example
@@ -212,15 +242,35 @@ Scroller.prototype = {
 	 *      } );
 	 *    } );
 	 */
-	"fnRowToPixels": function ( iRow )
+	"fnRowToPixels": function ( rowIdx, intParse, virtual )
 	{
-		return iRow * this.s.rowHeight;
+		var pixels;
+
+		if ( virtual ) {
+			pixels = this._domain( 'virtualToPhysical', rowIdx * this.s.heights.row );
+		}
+		else {
+			var diff = rowIdx - this.s.baseRowTop;
+			pixels = this.s.baseScrollTop + (diff * this.s.heights.row);
+		}
+
+		return intParse || intParse === undefined ?
+			parseInt( pixels, 10 ) :
+			pixels;
 	},
 
 
 	/**
-	 * Calculate the row number that will be found at the given pixel position (y-scroll)
-	 *  @param {int} iPixels Offset from top to caluclate the row number of
+	 * Calculate the row number that will be found at the given pixel position
+	 * (y-scroll).
+	 *
+	 * Please note that when the height of the full table exceeds 1 million
+	 * pixels, Scroller switches into a non-linear mode for the scrollbar to fit
+	 * all of the records into a finite area, but this function returns a linear
+	 * value (relative to the last non-linear positioning).
+	 *  @param {int} iPixels Offset from top to calculate the row number of
+	 *  @param {int} [intParse=true] If an integer value should be returned
+	 *  @param {int} [virtual=false] Perform the calculations in the virtual domain
 	 *  @returns {int} Row index
 	 *  @example
 	 *    $(document).ready(function() {
@@ -236,9 +286,16 @@ Scroller.prototype = {
 	 *      } );
 	 *    } );
 	 */
-	"fnPixelsToRow": function ( iPixels )
+	"fnPixelsToRow": function ( pixels, intParse, virtual )
 	{
-		return parseInt( iPixels / this.s.rowHeight, 10 );
+		var diff = pixels - this.s.baseScrollTop;
+		var row = virtual ?
+			this._domain( 'physicalToVirtual', pixels ) / this.s.heights.row :
+			( diff / this.s.heights.row ) + this.s.baseRowTop;
+
+		return intParse || intParse === undefined ?
+			parseInt( row, 10 ) :
+			row;
 	},
 
 
@@ -259,7 +316,7 @@ Scroller.prototype = {
 	 *          o.oScroller.fnScrollToRow( 1000 );
 	 *        }
 	 *      } );
-	 *
+	 *     
 	 *      // Sometime later on use the following to scroll to row 500...
 	 *          var oSettings = $('#example').dataTable().fnSettings();
 	 *      oSettings.oScroller.fnScrollToRow( 500 );
@@ -267,11 +324,37 @@ Scroller.prototype = {
 	 */
 	"fnScrollToRow": function ( iRow, bAnimate )
 	{
+		var that = this;
+		var ani = false;
 		var px = this.fnRowToPixels( iRow );
+
+		// We need to know if the table will redraw or not before doing the
+		// scroll. If it will not redraw, then we need to use the currently
+		// displayed table, and scroll with the physical pixels. Otherwise, we
+		// need to calculate the table's new position from the virtual
+		// transform.
+		var preRows = ((this.s.displayBuffer-1)/2) * this.s.viewportRows;
+		var drawRow = iRow - preRows;
+		if ( drawRow < 0 ) {
+			drawRow = 0;
+		}
+
+		if ( (px > this.s.redrawBottom || px < this.s.redrawTop) && this.s.dt._iDisplayStart !== drawRow ) {
+			ani = true;
+			px = this.fnRowToPixels( iRow, false, true );
+		}
+
 		if ( typeof bAnimate == 'undefined' || bAnimate )
 		{
+			this.s.ani = ani;
 			$(this.dom.scroller).animate( {
 				"scrollTop": px
+			}, function () {
+				// This needs to happen after the animation has completed and
+				// the final scroll event fired
+				setTimeout( function () {
+					that.s.ani = false;
+				}, 0 );
 			} );
 		}
 		else
@@ -282,9 +365,10 @@ Scroller.prototype = {
 
 
 	/**
-	 * Calculate and store information about how many rows are to be displayed in the scrolling
-	 * viewport, based on current dimensions in the browser's rendering. This can be particularly
-	 * useful if the table is initially drawn in a hidden element - for example in a tab.
+	 * Calculate and store information about how many rows are to be displayed
+	 * in the scrolling viewport, based on current dimensions in the browser's
+	 * rendering. This can be particularly useful if the table is initially
+	 * drawn in a hidden element - for example in a tab.
 	 *  @param {bool} [bRedraw=true] Redraw the table automatically after the recalculation, with
 	 *    the new dimentions forming the basis for the draw.
 	 *  @returns {void}
@@ -302,7 +386,7 @@ Scroller.prototype = {
 	 *          o.oScroller.fnScrollToRow( 1000 );
 	 *        }
 	 *      } );
-	 *
+	 *     
 	 *      setTimeout( function () {
 	 *        // Make the example container visible and recalculate the scroller sizes
 	 *        document.getElementById('container').style.display = "block";
@@ -316,19 +400,11 @@ Scroller.prototype = {
 			this._fnCalcRowHeight();
 		}
 
-		this.s.viewportHeight = $(this.dom.scroller).height();
-		this.s.viewportRows = parseInt( this.s.viewportHeight/this.s.rowHeight, 10 )+1;
-		this.s.dt._iDisplayLength = this.s.viewportRows * this.s.displayBuffer;
+		var heights = this.s.heights;
 
-		if ( this.s.trace )
-		{
-				console.log(
-					'Row height: '+this.s.rowHeight +' '+
-					'Viewport height: '+this.s.viewportHeight +' '+
-					'Viewport rows: '+ this.s.viewportRows +' '+
-					'Display rows: '+ this.s.dt._iDisplayLength
-				);
-		}
+		heights.viewport = $(this.dom.scroller).height();
+		this.s.viewportRows = parseInt( heights.viewport / heights.row, 10 )+1;
+		this.s.dt._iDisplayLength = this.s.viewportRows * this.s.displayBuffer;
 
 		if ( typeof bRedraw == 'undefined' || bRedraw )
 		{
@@ -351,6 +427,12 @@ Scroller.prototype = {
 	{
 		var that = this;
 
+		/* Sanity check */
+		if ( !this.s.dt.oFeatures.bPaginate ) {
+			this.s.dt.oApi._fnLog( this.s.dt, 0, 'Pagination must be enabled for Scroller' );
+			return;
+		}
+
 		/* Insert a div element that we can use to force the DT scrolling container to
 		 * the height that would be required if the whole table was being displayed
 		 */
@@ -380,21 +462,21 @@ Scroller.prototype = {
 		}
 
 		/* Initial size calculations */
-		if ( this.s.rowHeight && this.s.rowHeight != 'auto' )
+		if ( this.s.heights.row && this.s.heights.row != 'auto' )
 		{
 			this.s.autoHeight = false;
 		}
 		this.fnMeasure( false );
 
 		/* Scrolling callback to see if a page change is needed */
-		$(this.dom.scroller).scroll( function () {
+		$(this.dom.scroller).on( 'scroll.DTS', function () {
 			that._fnScroll.call( that );
 		} );
 
 		/* In iOS we catch the touchstart event incase the user tries to scroll
 		 * while the display is already scrolling
 		 */
-		$(this.dom.scroller).bind('touchstart', function () {
+		$(this.dom.scroller).on('touchstart.DTS', function () {
 			that._fnScroll.call( that );
 		} );
 
@@ -408,20 +490,49 @@ Scroller.prototype = {
 			"sName": "Scroller"
 		} );
 
+		/* On resize, update the information element, since the number of rows shown might change */
+		$(window).on( 'resize.DTS', function () {
+			that._fnInfo();
+		} );
+
 		/* Add a state saving parameter to the DT state saving so we can restore the exact
 		 * position of the scrolling
 		 */
+		var initialStateSave = true;
 		this.s.dt.oApi._fnCallbackReg( this.s.dt, 'aoStateSaveParams', function (oS, oData) {
-			oData.iScroller = that.dom.scroller.scrollTop;
+			/* Set iScroller to saved scroll position on initialization.
+			 */
+			if(initialStateSave && that.s.dt.oLoadedState){
+				oData.iScroller = that.s.dt.oLoadedState.iScroller;
+				initialStateSave = false;
+			} else {
+				oData.iScroller = that.dom.scroller.scrollTop;
+			}
 		}, "Scroller_State" );
+
+		/* Destructor */
+		this.s.dt.aoDestroyCallback.push( {
+			"sName": "Scroller",
+			"fn": function () {
+				$(window).off( 'resize.DTS' );
+				$(that.dom.scroller).off('touchstart.DTS scroll.DTS');
+				$(that.s.dt.nTableWrapper).removeClass('DTS');
+				$('div.DTS_Loading', that.dom.scroller.parentNode).remove();
+
+				that.dom.table.style.position = "";
+				that.dom.table.style.top = "";
+				that.dom.table.style.left = "";
+			}
+		} );
 	},
 
 
 	/**
-	 * Scrolling function - fired whenever the scrolling position is changed. This method needs
-	 * to use the stored values to see if the table should be redrawn as we are moving towards
-	 * the end of the information that is currently drawn or not. If needed, then it will redraw
-	 * the table based on the new position.
+	 * Scrolling function - fired whenever the scrolling position is changed.
+	 * This method needs to use the stored values to see if the table should be
+	 * redrawn as we are moving towards the end of the information that is
+	 * currently drawn or not. If needed, then it will redraw the table based on
+	 * the new position.
 	 *  @returns {void}
 	 *  @private
 	 */
@@ -429,33 +540,28 @@ Scroller.prototype = {
 	{
 		var
 			that = this,
+			heights = this.s.heights,
 			iScrollTop = this.dom.scroller.scrollTop,
 			iTopRow;
 
+		if ( this.s.skip ) {
+			return;
+		}
+
 		/* If the table has been sorted or filtered, then we use the redraw that
 		 * DataTables as done, rather than performing our own
 		 */
-		if ( this.s.dt.bFiltered || this.s.dt.bSorted )
-		{
+		if ( this.s.dt.bFiltered || this.s.dt.bSorted ) {
+			this.s.lastScrollTop = 0;
 			return;
 		}
 
-		if ( this.s.trace )
-		{
-			console.log(
-				'Scroll: '+iScrollTop+'px - boundaries: '+this.s.redrawTop+' / '+this.s.redrawBottom+'. '+
-				' Showing rows '+this.fnPixelsToRow(iScrollTop)+
-				' to '+this.fnPixelsToRow(iScrollTop+$(this.dom.scroller).height())+
-				' in the viewport, with rows '+this.s.dt._iDisplayStart+
-				' to '+(this.s.dt._iDisplayEnd)+' rendered by the DataTable'
-			);
-		}
-
 		/* Update the table's information display for what is now in the viewport */
 		this._fnInfo();
 
-		/* We dont' want to state save on every scroll event - that's heavy handed, so
-		 * use a timeout to update the state saving only when the scrolling has finished
+		/* We don't want to state save on every scroll event - that's heavy
+		 * handed, so use a timeout to update the state saving only when the
+		 * scrolling has finished
 		 */
 		clearTimeout( this.s.stateTO );
 		this.s.stateTO = setTimeout( function () {
@@ -465,60 +571,130 @@ Scroller.prototype = {
 		/* Check if the scroll point is outside the trigger boundary which would required
 		 * a DataTables redraw
 		 */
-		if ( iScrollTop < this.s.redrawTop || iScrollTop > this.s.redrawBottom )
-		{
-			var preRows = ((this.s.displayBuffer-1)/2) * this.s.viewportRows;
-			iTopRow = parseInt( iScrollTop / this.s.rowHeight, 10 ) - preRows;
-			if ( iTopRow < 0 )
-			{
+		if ( iScrollTop < this.s.redrawTop || iScrollTop > this.s.redrawBottom ) {
+			var preRows = Math.ceil( ((this.s.displayBuffer-1)/2) * this.s.viewportRows );
+
+			if ( Math.abs( iScrollTop - this.s.lastScrollTop ) > heights.viewport || this.s.ani ) {
+				iTopRow = parseInt(this._domain( 'physicalToVirtual', iScrollTop ) / heights.row, 10) - preRows;
+				this.s.topRowFloat = (this._domain( 'physicalToVirtual', iScrollTop ) / heights.row);
+			}
+			else {
+				iTopRow = this.fnPixelsToRow( iScrollTop ) - preRows;
+				this.s.topRowFloat = this.fnPixelsToRow( iScrollTop, false );
+			}
+
+			if ( iTopRow <= 0 ) {
 				/* At the start of the table */
 				iTopRow = 0;
 			}
-			else if ( iTopRow + this.s.dt._iDisplayLength > this.s.dt.fnRecordsDisplay() )
-			{
+			else if ( iTopRow + this.s.dt._iDisplayLength > this.s.dt.fnRecordsDisplay() ) {
 				/* At the end of the table */
 				iTopRow = this.s.dt.fnRecordsDisplay() - this.s.dt._iDisplayLength;
-				if ( iTopRow < 0 )
-				{
+				if ( iTopRow < 0 ) {
 					iTopRow = 0;
 				}
 			}
-			else if ( iTopRow % 2 !== 0 )
-			{
-				/* For the row-striping classes (odd/even) we want only to start on evens
-				 * otherwise the stripes will change between draws and look rubbish
-				 */
+			else if ( iTopRow % 2 !== 0 ) {
+				// For the row-striping classes (odd/even) we want only to start
+				// on evens otherwise the stripes will change between draws and
+				// look rubbish
 				iTopRow++;
 			}
 
-			if ( iTopRow != this.s.dt._iDisplayStart )
-			{
+			if ( iTopRow != this.s.dt._iDisplayStart ) {
 				/* Cache the new table position for quick lookups */
 				this.s.tableTop = $(this.s.dt.nTable).offset().top;
 				this.s.tableBottom = $(this.s.dt.nTable).height() + this.s.tableTop;
 
+				var draw =  function () {
+					if ( that.s.scrollDrawReq === null ) {
+						that.s.scrollDrawReq = iScrollTop;
+					}
+
+					that.s.dt._iDisplayStart = iTopRow;
+					if ( that.s.dt.oApi._fnCalculateEnd ) { // Removed in 1.10
+						that.s.dt.oApi._fnCalculateEnd( that.s.dt );
+					}
+					that.s.dt.oApi._fnDraw( that.s.dt );
+				};
+
 				/* Do the DataTables redraw based on the calculated start point - note that when
 				 * using server-side processing we introduce a small delay to not DoS the server...
 				 */
 				if ( this.s.dt.oFeatures.bServerSide ) {
 					clearTimeout( this.s.drawTO );
-					this.s.drawTO = setTimeout( function () {
-						that.s.dt._iDisplayStart = iTopRow;
-						that.s.dt.oApi._fnCalculateEnd( that.s.dt );
-						that.s.dt.oApi._fnDraw( that.s.dt );
-					}, this.s.serverWait );
+					this.s.drawTO = setTimeout( draw, this.s.serverWait );
 				}
-				else
-				{
-					this.s.dt._iDisplayStart = iTopRow;
-					this.s.dt.oApi._fnCalculateEnd( this.s.dt );
-					this.s.dt.oApi._fnDraw( this.s.dt );
+				else {
+					draw();
 				}
+			}
+		}
 
-				if ( this.s.trace )
-				{
-					console.log( 'Scroll forcing redraw - top DT render row: '+ iTopRow );
-				}
+		this.s.lastScrollTop = iScrollTop;
+	},
+
+
+	/**
+	 * Convert from one domain to another. The physical domain is the actual
+	 * pixel count on the screen, while the virtual is if we had browsers which
+	 * had scrolling containers of infinite height (i.e. the absolute value)
+	 *
+	 *  @param {string} dir Domain transform direction, `virtualToPhysical` or
+	 *    `physicalToVirtual` 
+	 *  @returns {number} Calculated transform
+	 *  @private
+	 */
+	_domain: function ( dir, val )
+	{
+		var heights = this.s.heights;
+		var coeff;
+
+		// If the virtual and physical height match, then we use a linear
+		// transform between the two, allowing the scrollbar to be linear
+		if ( heights.virtual === heights.scroll ) {
+			coeff = (heights.virtual-heights.viewport) / (heights.scroll-heights.viewport);
+
+			if ( dir === 'virtualToPhysical' ) {
+				return val / coeff;
+			}
+			else if ( dir === 'physicalToVirtual' ) {
+				return val * coeff;
+			}
+		}
+
+		// Otherwise, we want a non-linear scrollbar to take account of the
+		// redrawing regions at the start and end of the table, otherwise these
+		// can stutter badly - on large tables 30px (for example) scroll might
+		// be hundreds of rows, so the table would be redrawing every few px at
+		// the start and end. Use a simple quadratic to stop this. It does mean
+		// the scrollbar is non-linear, but with such massive data sets, the
+		// scrollbar is going to be a best guess anyway
+		var xMax = (heights.scroll - heights.viewport) / 2;
+		var yMax = (heights.virtual - heights.viewport) / 2;
+
+		coeff = yMax / ( xMax * xMax );
+
+		if ( dir === 'virtualToPhysical' ) {
+			if ( val < yMax ) {
+				return Math.pow(val / coeff, 0.5);
+			}
+			else {
+				val = (yMax*2) - val;
+				return val < 0 ?
+					heights.scroll :
+					(xMax*2) - Math.pow(val / coeff, 0.5);
+			}
+		}
+		else if ( dir === 'physicalToVirtual' ) {
+			if ( val < xMax ) {
+				return val * val * coeff;
+			}
+			else {
+				val = (xMax*2) - val;
+				return val < 0 ?
+					heights.virtual :
+					(yMax*2) - (val * val * coeff);
 			}
 		}
 	},
@@ -535,71 +711,121 @@ Scroller.prototype = {
 	{
 		var
 			that = this,
+			heights = this.s.heights,
 			iScrollTop = this.dom.scroller.scrollTop,
-			iScrollBottom = iScrollTop + this.s.viewportHeight;
+			iActualScrollTop = iScrollTop,
+			iScrollBottom = iScrollTop + heights.viewport,
+			iTableHeight = $(this.s.dt.nTable).height(),
+			displayStart = this.s.dt._iDisplayStart,
+			displayLen = this.s.dt._iDisplayLength,
+			displayEnd = this.s.dt.fnRecordsDisplay();
+
+		// Disable the scroll event listener while we are updating the DOM
+		this.s.skip = true;
+
+		// Resize the scroll forcing element
+		this._fnScrollForce();
+
+		// Reposition the scrolling for the updated virtual position if needed
+		if ( displayStart === 0 ) {
+			// Linear calculation at the top of the table
+			iScrollTop = this.s.topRowFloat * heights.row;
+		}
+		else if ( displayStart + displayLen >= displayEnd ) {
+			// Linear calculation that the bottom as well
+			iScrollTop = heights.scroll - ((displayEnd - this.s.topRowFloat) * heights.row);
+		}
+		else {
+			// Domain scaled in the middle
+			iScrollTop = this._domain( 'virtualToPhysical', this.s.topRowFloat * heights.row );
+		}
 
-		/* Set the height of the scrolling forcer to be suitable for the number of rows
-		 * in this draw
-		 */
-		this.dom.force.style.height = (this.s.rowHeight * this.s.dt.fnRecordsDisplay())+"px";
+		this.dom.scroller.scrollTop = iScrollTop;
 
-		/* Calculate the position that the top of the table should be at */
-		var iTableTop = (this.s.rowHeight*this.s.dt._iDisplayStart);
-		if ( this.s.dt._iDisplayStart === 0 )
-		{
-			iTableTop = 0;
+		// Store positional information so positional calculations can be based
+		// upon the current table draw position
+		this.s.baseScrollTop = iScrollTop;
+		this.s.baseRowTop = this.s.topRowFloat;
+
+		// Position the table in the virtual scroller
+		var tableTop = iScrollTop - ((this.s.topRowFloat - displayStart) * heights.row);
+		if ( displayStart === 0 ) {
+			tableTop = 0;
 		}
-		else if ( this.s.dt._iDisplayStart === this.s.dt.fnRecordsDisplay() - this.s.dt._iDisplayLength )
-		{
-			iTableTop = this.s.rowHeight * this.s.dt._iDisplayStart;
+		else if ( displayStart + displayLen >= displayEnd ) {
+			tableTop = heights.scroll - iTableHeight;
 		}
 
-		this.dom.table.style.top = iTableTop+"px";
+		this.dom.table.style.top = tableTop+'px';
 
 		/* Cache some information for the scroller */
-		this.s.tableTop = iTableTop;
-		this.s.tableBottom = $(this.s.dt.nTable).height() + this.s.tableTop;
+		this.s.tableTop = tableTop;
+		this.s.tableBottom = iTableHeight + this.s.tableTop;
 
-		this.s.redrawTop = iScrollTop - ( (iScrollTop - this.s.tableTop) * this.s.boundaryScale );
-		this.s.redrawBottom = iScrollTop + ( (this.s.tableBottom - iScrollBottom) * this.s.boundaryScale );
+		// Calculate the boundaries for where a redraw will be triggered by the
+		// scroll event listener
+		var boundaryPx = (iScrollTop - this.s.tableTop) * this.s.boundaryScale;
+		this.s.redrawTop = iScrollTop - boundaryPx;
+		this.s.redrawBottom = iScrollTop + boundaryPx;
 
-		if ( this.s.trace )
-		{
-			console.log(
-				"Table redraw. Table top: "+iTableTop+"px "+
-				"Table bottom: "+this.s.tableBottom+" "+
-				"Scroll boundary top: "+this.s.redrawTop+" "+
-				"Scroll boundary bottom: "+this.s.redrawBottom+" "+
-				"Rows drawn: "+this.s.dt._iDisplayLength);
-		}
+		this.s.skip = false;
 
-		/* Because of the order of the DT callbacks, the info update will
-		 * take precidence over the one we want here. So a 'thread' break is
-		 * needed
-		 */
+		// Because of the order of the DT callbacks, the info update will
+		// take precidence over the one we want here. So a 'thread' break is
+		// needed
 		setTimeout( function () {
 			that._fnInfo.call( that );
 		}, 0 );
 
-		/* Restore the scrolling position that was saved by DataTable's state saving
-		 * Note that this is done on the second draw when data is Ajax sourced, and the
-		 * first draw when DOM soured
-		 */
+		// Restore the scrolling position that was saved by DataTable's state
+		// saving Note that this is done on the second draw when data is Ajax
+		// sourced, and the first draw when DOM soured
 		if ( this.s.dt.oFeatures.bStateSave && this.s.dt.oLoadedState !== null &&
 			 typeof this.s.dt.oLoadedState.iScroller != 'undefined' )
 		{
-			if ( (this.s.dt.sAjaxSource !== null && this.s.dt.iDraw == 2) ||
-			     (this.s.dt.sAjaxSource === null && this.s.dt.iDraw == 1) )
+			var ajaxSourced = this.s.dt.sAjaxSource || that.s.dt.ajax ?
+				true :
+				false;
+
+			if ( ( ajaxSourced && this.s.dt.iDraw == 2) ||
+			     (!ajaxSourced && this.s.dt.iDraw == 1) )
 			{
 				setTimeout( function () {
 					$(that.dom.scroller).scrollTop( that.s.dt.oLoadedState.iScroller );
-					that.s.redrawTop = that.s.dt.oLoadedState.iScroller - (that.s.viewportHeight/2);
+					that.s.redrawTop = that.s.dt.oLoadedState.iScroller - (heights.viewport/2);
 				}, 0 );
 			}
 		}
 	},
 
 
+	/**
+	 * Force the scrolling container to have height beyond that of just the
+	 * table that has been drawn so the user can scroll the whole data set.
+	 *
+	 * Note that if the calculated required scrolling height exceeds a maximum
+	 * value (1 million pixels - hard-coded) the forcing element will be set
+	 * only to that maximum value and virtual / physical domain transforms will
+	 * be used to allow Scroller to display tables of any number of records.
+	 *  @returns {void}
+	 *  @private
+	 */
+	_fnScrollForce: function ()
+	{
+		var heights = this.s.heights;
+		var max = 1000000;
+
+		heights.virtual = heights.row * this.s.dt.fnRecordsDisplay();
+		heights.scroll = heights.virtual;
+
+		if ( heights.scroll > max ) {
+			heights.scroll = max;
+		}
+
+		this.dom.force.style.height = heights.scroll+"px";
+	},
+
+
 	/**
 	 * Automatic calculation of table row height. This is just a little tricky here as using
 	 * initialisation DataTables has tale the table out of the document, so we need to create
@@ -610,28 +836,29 @@ Scroller.prototype = {
 	 */
 	"_fnCalcRowHeight": function ()
 	{
-		var nTable = this.s.dt.nTable.cloneNode( false );
-		var nContainer = $(
+		var origTable = this.s.dt.nTable;
+		var nTable = origTable.cloneNode( false );
+		var tbody = $('<tbody/>').appendTo( nTable );
+		var container = $(
 			'<div class="'+this.s.dt.oClasses.sWrapper+' DTS">'+
 				'<div class="'+this.s.dt.oClasses.sScrollWrapper+'">'+
 					'<div class="'+this.s.dt.oClasses.sScrollBody+'"></div>'+
 				'</div>'+
 			'</div>'
-		)[0];
-
-		$(nTable).append(
-			'<tbody>'+
-				'<tr>'+
-					'<td>&nbsp;</td>'+
-				'</tr>'+
-			'</tbody>'
 		);
 
-		$('div.'+this.s.dt.oClasses.sScrollBody, nContainer).append( nTable );
+		// Want 3 rows in the sizing table so :first-child and :last-child
+		// CSS styles don't come into play - take the size of the middle row
+		$('tbody tr:lt(4)', origTable).clone().appendTo( tbody );
+		while( $('tr', tbody).length < 3 ) {
+			tbody.append( '<tr><td>&nbsp;</td></tr>' );
+		}
+
+		$('div.'+this.s.dt.oClasses.sScrollBody, container).append( nTable );
 
-		document.body.appendChild( nContainer );
-		this.s.rowHeight = $('tbody tr', nTable).outerHeight();
-		document.body.removeChild( nContainer );
+		container.appendTo( this.s.dt.nHolding );
+		this.s.heights.row = $('tr', tbody).eq(1).outerHeight();
+		container.remove();
 	},
 
 
@@ -652,10 +879,10 @@ Scroller.prototype = {
 		var
 			dt = this.s.dt,
 			iScrollTop = this.dom.scroller.scrollTop,
-			iStart = this.fnPixelsToRow(iScrollTop)+1,
+			iStart = Math.floor( this.fnPixelsToRow(iScrollTop, false, this.s.ani)+1 ),
 			iMax = dt.fnRecordsTotal(),
 			iTotal = dt.fnRecordsDisplay(),
-			iPossibleEnd = this.fnPixelsToRow(iScrollTop+$(this.dom.scroller).height()),
+			iPossibleEnd = Math.ceil( this.fnPixelsToRow(iScrollTop+this.s.heights.viewport, false, this.s.ani) ),
 			iEnd = iTotal < iPossibleEnd ? iTotal : iPossibleEnd,
 			sStart = dt.fnFormatNumber( iStart ),
 			sEnd = dt.fnFormatNumber( iEnd ),
@@ -718,9 +945,10 @@ Scroller.prototype = {
 /**
  * Scroller default settings for initialisation
  *  @namespace
+ *  @name Scroller.defaults
  *  @static
  */
-Scroller.oDefaults = {
+Scroller.defaults = /** @lends Scroller.defaults */{
 	/**
 	 * Indicate if Scroller show show trace information on the console or not. This can be
 	 * useful when debugging Scroller or if just curious as to what it is doing, but should
@@ -843,30 +1071,22 @@ Scroller.oDefaults = {
 	"loadingIndicator": false
 };
 
+Scroller.oDefaults = Scroller.defaults;
+
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * Constants
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-
-/**
- * Name of this class
- *  @type     String
- *  @default  Scroller
- *  @static
- */
-Scroller.prototype.CLASS = "Scroller";
-
-
 /**
  * Scroller version
  *  @type      String
  *  @default   See code
+ *  @name      Scroller.version
  *  @static
  */
-Scroller.VERSION = "1.1.0";
-Scroller.prototype.VERSION = Scroller.VERSION;
+Scroller.version = "1.2.1";
 
 
 
@@ -883,9 +1103,9 @@ if ( typeof $.fn.dataTable == "function" &&
 {
 	$.fn.dataTableExt.aoFeatures.push( {
 		"fnInit": function( oDTSettings ) {
-			var init = (typeof oDTSettings.oInit.oScroller == 'undefined') ?
-				{} : oDTSettings.oInit.oScroller;
-			var oScroller = new Scroller( oDTSettings, init );
+			var init = oDTSettings.oInit;
+			var opts = init.scroller || init.oScroller || {};
+			var oScroller = new Scroller( oDTSettings, opts );
 			return oScroller.dom.wrapper;
 		},
 		"cFeature": "S",
@@ -900,5 +1120,66 @@ else
 
 // Attach Scroller to DataTables so it can be accessed as an 'extra'
 $.fn.dataTable.Scroller = Scroller;
+$.fn.DataTable.Scroller = Scroller;
+
+
+// DataTables 1.10 API method aliases
+if ( $.fn.dataTable.Api ) {
+	var Api = $.fn.dataTable.Api;
+
+	Api.register( 'scroller().rowToPixels()', function ( rowIdx, intParse, virtual ) {
+		var ctx = this.context;
+
+		if ( ctx.length && ctx[0].oScroller ) {
+			return ctx[0].oScroller.fnRowToPixels( rowIdx, intParse, virtual );
+		}
+		// undefined
+	} );
+
+	Api.register( 'scroller().pixelsToRow()', function ( pixels, intParse, virtual ) {
+		var ctx = this.context;
+
+		if ( ctx.length && ctx[0].oScroller ) {
+			return ctx[0].oScroller.fnPixelsToRow( pixels, intParse, virtual );
+		}
+		// undefined
+	} );
+
+	Api.register( 'scroller().scrollToRow()', function ( row, ani ) {
+		this.iterator( 'table', function ( ctx ) {
+			if ( ctx.oScroller ) {
+				ctx.oScroller.fnScrollToRow( row, ani );
+			}
+		} );
+
+		return this;
+	} );
+
+	Api.register( 'scroller().measure()', function ( redraw ) {
+		this.iterator( 'table', function ( ctx ) {
+			if ( ctx.oScroller ) {
+				ctx.oScroller.fnMeasure( redraw );
+			}
+		} );
+
+		return this;
+	} );
+}
+
+
+return Scroller;
+}; // /factory
+
+
+// Define as an AMD module if possible
+if ( typeof define === 'function' && define.amd ) {
+	define( 'datatables-scroller', ['jquery', 'datatables'], factory );
+}
+else if ( jQuery && !jQuery.fn.dataTable.Scroller ) {
+	// Otherwise simply initialise as normal, stopping multiple evaluation
+	factory( jQuery, jQuery.fn.dataTable );
+}
+
+
+})(window, document);
 
-})(jQuery, window, document);