/*! Scroller 1.2.2


 * ©2011-2014 SpryMedia Ltd - datatables.net/license


 */





/**


 * @summary     Scroller


 * @description Virtual rendering for DataTables


 * @version     1.2.2


 * @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


 *


 * 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.


 *


 * For details please refer to: http://www.datatables.net


 */





(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


 * is that only the visible portion of the table (and a bit to either side to make


 * the scrolling smooth) is drawn, while the scrolling container gives the


 * visual impression that the whole table is visible. This is done by making use


 * of the pagination abilities of DataTables and moving the table around in the


 * scrolling container DataTables adds to the page. The scrolling container is


 * forced to the height it would be for the full table display using an extra


 * element.


 *


 * Note that rows in the table MUST all be the same height. Information in a cell


 * which expands on to multiple lines will cause some odd behaviour in the scrolling.


 *


 * 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 `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>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.defaults}


 *


 *  @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


 *        } );


 *    } );


 */


var Scroller = function ( oDTSettings, oOpts ) {


	/* Sanity check - you just know it will happen */


	if ( ! this instanceof Scroller )


	{


		alert( "Scroller warning: Scroller must be initialised with the 'new' keyword." );


		return;


	}





	if ( typeof oOpts == 'undefined' )


	{


		oOpts = {};


	}





	/**


	 * Settings object which contains customisable information for the Scroller instance


	 * @namespace


	 * @private


	 * @extends Scroller.defaults


	 */


	this.s = {


		/**


		 * DataTables settings object


		 *  @type     object


		 *  @default  Passed in as first parameter to constructor


		 */


		"dt": oDTSettings,





		/**


		 * Pixel location of the top of the drawn table in the viewport


		 *  @type     int


		 *  @default  0


		 */


		"tableTop": 0,





		/**


		 * Pixel location of the bottom of the drawn table in the viewport


		 *  @type     int


		 *  @default  0


		 */


		"tableBottom": 0,





		/**


		 * Pixel location of the boundary for when the next data set should be loaded and drawn


		 * when scrolling up the way.


		 *  @type     int


		 *  @default  0


		 *  @private


		 */


		"redrawTop": 0,





		/**


		 * Pixel location of the boundary for when the next data set should be loaded and drawn


		 * when scrolling down the way. Note that this is actually calculated as the offset from


		 * the top.


		 *  @type     int


		 *  @default  0


		 *  @private


		 */


		"redrawBottom": 0,





		/**


		 * Auto row height or not indicator


		 *  @type     bool


		 *  @default  0


		 */


		"autoHeight": true,





		/**


		 * Number of rows calculated as visible in the visible viewport


		 *  @type     int


		 *  @default  0


		 */


		"viewportRows": 0,





		/**


		 * setTimeout reference for state saving, used when state saving is enabled in the DataTable


		 * and when the user scrolls the viewport in order to stop the cookie set taking too much


		 * CPU!


		 *  @type     int


		 *  @default  0


		 */


		"stateTO": null,





		/**


		 * setTimeout reference for the redraw, used when server-side processing is enabled in the


		 * DataTables in order to prevent DoSing the server


		 *  @type     int


		 *  @default  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,


		loaderVisible: false


	};





	// @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


	 *


	 */


	this.dom = {


		"force":    document.createElement('div'),


		"scroller": null,


		"table":    null,


		"loader":   null


	};





	/* Attach the instance to the DataTables instance so it can be accessed */


	this.s.dt.oScroller = this;





	/* Let's do it */


	this._fnConstruct();


};











Scroller.prototype = /** @lends Scroller.prototype */{


	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *


	 * Public methods


	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */





	/**


	 * 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


	 *    $(document).ready(function() {


	 *      $('#example').dataTable( {


	 *        "sScrollY": "200px",


	 *        "sAjaxSource": "media/dataset/large.txt",


	 *        "sDom": "frtiS",


	 *        "bDeferRender": true,


	 *        "fnInitComplete": function (o) {


	 *          // Find where row 25 is


	 *          alert( o.oScroller.fnRowToPixels( 25 ) );


	 *        }


	 *      } );


	 *    } );


	 */


	"fnRowToPixels": function ( rowIdx, intParse, virtual )


	{


		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).


	 *


	 * 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() {


	 *      $('#example').dataTable( {


	 *        "sScrollY": "200px",


	 *        "sAjaxSource": "media/dataset/large.txt",


	 *        "sDom": "frtiS",


	 *        "bDeferRender": true,


	 *        "fnInitComplete": function (o) {


	 *          // Find what row number is at 500px


	 *          alert( o.oScroller.fnPixelsToRow( 500 ) );


	 *        }


	 *      } );


	 *    } );


	 */


	"fnPixelsToRow": function ( pixels, intParse, virtual )


	{


		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;


	},








	/**


	 * Calculate the row number that will be found at the given pixel position (y-scroll)


	 *  @param {int} iRow Row index to scroll to


	 *  @param {bool} [bAnimate=true] Animate the transition or not


	 *  @returns {void}


	 *  @example


	 *    $(document).ready(function() {


	 *      $('#example').dataTable( {


	 *        "sScrollY": "200px",


	 *        "sAjaxSource": "media/dataset/large.txt",


	 *        "sDom": "frtiS",


	 *        "bDeferRender": true,


	 *        "fnInitComplete": function (o) {


	 *          // Immediately scroll to row 1000


	 *          o.oScroller.fnScrollToRow( 1000 );


	 *        }


	 *      } );


	 *     


	 *      // Sometime later on use the following to scroll to row 500...


	 *          var oSettings = $('#example').dataTable().fnSettings();


	 *      oSettings.oScroller.fnScrollToRow( 500 );


	 *    } );


	 */


	"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;


				}, 25 );


			} );


		}


		else


		{


			$(this.dom.scroller).scrollTop( px );


		}


	},








	/**


	 * 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 dimensions forming the basis for the draw.


	 *  @returns {void}


	 *  @example


	 *    $(document).ready(function() {


	 *      // Make the example container hidden to throw off the browser's sizing


	 *      document.getElementById('container').style.display = "none";


	 *      var oTable = $('#example').dataTable( {


	 *        "sScrollY": "200px",


	 *        "sAjaxSource": "media/dataset/large.txt",


	 *        "sDom": "frtiS",


	 *        "bDeferRender": true,


	 *        "fnInitComplete": function (o) {


	 *          // Immediately scroll to row 1000


	 *          o.oScroller.fnScrollToRow( 1000 );


	 *        }


	 *      } );


	 *     


	 *      setTimeout( function () {


	 *        // Make the example container visible and recalculate the scroller sizes


	 *        document.getElementById('container').style.display = "block";


	 *        oTable.fnSettings().oScroller.fnMeasure();


	 *      }, 3000 );


	 */


	"fnMeasure": function ( bRedraw )


	{


		if ( this.s.autoHeight )


		{


			this._fnCalcRowHeight();


		}





		var heights = this.s.heights;





		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 ( bRedraw === undefined || bRedraw )


		{


			this.s.dt.oInstance.fnDraw();


		}


	},











	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *


	 * Private methods (they are of course public in JS, but recommended as private)


	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */





	/**


	 * Initialisation for Scroller


	 *  @returns {void}


	 *  @private


	 */


	"_fnConstruct": function ()


	{


		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


		 */


		this.dom.force.style.position = "absolute";


		this.dom.force.style.top = "0px";


		this.dom.force.style.left = "0px";


		this.dom.force.style.width = "1px";





		this.dom.scroller = $('div.'+this.s.dt.oClasses.sScrollBody, this.s.dt.nTableWrapper)[0];


		this.dom.scroller.appendChild( this.dom.force );


		this.dom.scroller.style.position = "relative";





		this.dom.table = $('>table', this.dom.scroller)[0];


		this.dom.table.style.position = "absolute";


		this.dom.table.style.top = "0px";


		this.dom.table.style.left = "0px";





		// Add class to 'announce' that we are a Scroller table


		$(this.s.dt.nTableWrapper).addClass('DTS');





		// Add a 'loading' indicator


		if ( this.s.loadingIndicator )


		{


			this.dom.loader = $('<div class="DTS_Loading">'+this.s.dt.oLanguage.sLoadingRecords+'</div>')


				.css('display', 'none');





			$(this.dom.scroller.parentNode)


				.css('position', 'relative')


				.append( this.dom.loader );


		}





		/* Initial size calculations */


		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 - use a throttled


		 * function for the save save callback so we aren't hitting it on every


		 * scroll


		 */


		this.s.ingnoreScroll = true;


		this.s.stateSaveThrottle = this.s.dt.oApi._fnThrottle( function () {


			that.s.dt.oApi._fnSaveState( that.s.dt );


		}, 500 );


		$(this.dom.scroller).on( 'scroll.DTS', function (e) {


			that._fnScroll.call( that );


		} );





		/* In iOS we catch the touchstart event in case the user tries to scroll


		 * while the display is already scrolling


		 */


		$(this.dom.scroller).on('touchstart.DTS', function () {


			that._fnScroll.call( that );


		} );





		/* Update the scroller when the DataTable is redrawn */


		this.s.dt.aoDrawCallback.push( {


			"fn": function () {


				if ( that.s.dt.bInitialised ) {


					that._fnDrawCallback.call( that );


				}


			},


			"sName": "Scroller"


		} );





		/* On resize, update the information element, since the number of rows shown might change */


		$(window).on( 'resize.DTS', function () {


			that.fnMeasure( false );


			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) {


			/* Set iScroller to saved scroll position on initialization.


			 */


			if(initialStateSave && that.s.dt.oLoadedState){


				oData.iScroller = that.s.dt.oLoadedState.iScroller;


				oData.iScrollerTopRow = that.s.dt.oLoadedState.iScrollerTopRow;


				initialStateSave = false;


			} else {


				oData.iScroller = that.dom.scroller.scrollTop;


				oData.iScrollerTopRow = that.s.topRowFloat;


			}


		}, "Scroller_State" );





		if ( this.s.dt.oLoadedState ) {


			this.s.topRowFloat = this.s.dt.oLoadedState.iScrollerTopRow || 0;


		}





		/* 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.


	 *  @returns {void}


	 *  @private


	 */


	"_fnScroll": function ()


	{


		var


			that = this,


			heights = this.s.heights,


			iScrollTop = this.dom.scroller.scrollTop,


			iTopRow;





		if ( this.s.skip ) {


			return;


		}





		if ( this.s.ingnoreScroll ) {


			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 ) {


			this.s.lastScrollTop = 0;


			return;


		}





		/* Update the table's information display for what is now in the viewport */


		this._fnInfo();





		/* 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 () {


			that.s.dt.oApi._fnSaveState( that.s.dt );


		}, 250 );





		/* 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 = 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() ) {


				/* At the end of the table */


				iTopRow = this.s.dt.fnRecordsDisplay() - this.s.dt._iDisplayLength;


				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


				iTopRow++;


			}





			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( draw, this.s.serverWait );


				}


				else {


					draw();


				}





				if ( this.dom.loader && ! this.s.loaderVisible ) {


					this.dom.loader.css( 'display', 'block' );


					this.s.loaderVisible = true;


				}


			}


		}





		this.s.lastScrollTop = iScrollTop;


		this.s.stateSaveThrottle();


	},








	/**


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


			}


		}


	},








	/**


	 * Draw callback function which is fired when the DataTable is redrawn. The main function of


	 * this method is to position the drawn table correctly the scrolling container for the rows


	 * that is displays as a result of the scrolling position.


	 *  @returns {void}


	 *  @private


	 */


	"_fnDrawCallback": function ()


	{


		var


			that = this,


			heights = this.s.heights,


			iScrollTop = this.dom.scroller.scrollTop,


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


		}





		this.dom.scroller.scrollTop = iScrollTop;





		// 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 ( displayStart + displayLen >= displayEnd ) {


			tableTop = heights.scroll - iTableHeight;


		}





		this.dom.table.style.top = tableTop+'px';





		/* Cache some information for the scroller */


		this.s.tableTop = tableTop;


		this.s.tableBottom = iTableHeight + this.s.tableTop;





		// 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;





		this.s.skip = false;





		// 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' )


		{


			// A quirk of DataTables is that the draw callback will occur on an


			// empty set if Ajax sourced, but not if server-side processing.


			var ajaxSourced = (this.s.dt.sAjaxSource || that.s.dt.ajax) && ! this.s.dt.oFeatures.bServerSide ?


				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 - (heights.viewport/2);





					// In order to prevent layout thrashing we need another


					// small delay


					setTimeout( function () {


						that.s.ingnoreScroll = false;


					}, 0 );


				}, 0 );


			}


		}


		else {


			that.s.ingnoreScroll = false;


		}





		// Because of the order of the DT callbacks, the info update will


		// take precedence over the one we want here. So a 'thread' break is


		// needed


		setTimeout( function () {


			that._fnInfo.call( that );


		}, 0 );





		// Hide the loading indicator


		if ( this.dom.loader && this.s.loaderVisible ) {


			this.dom.loader.css( 'display', 'none' );


			this.s.loaderVisible = false;


		}


	},








	/**


	 * 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


	 * a new table and insert it into the document, calculate the row height and then whip the


	 * table out.


	 *  @returns {void}


	 *  @private


	 */


	"_fnCalcRowHeight": function ()


	{


		var dt = this.s.dt;


		var origTable = dt.nTable;


		var nTable = origTable.cloneNode( false );


		var tbody = $('<tbody/>').appendTo( nTable );


		var container = $(


			'<div class="'+dt.oClasses.sWrapper+' DTS">'+


				'<div class="'+dt.oClasses.sScrollWrapper+'">'+


					'<div class="'+dt.oClasses.sScrollBody+'"></div>'+


				'</div>'+


			'</div>'


		);





		// 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.'+dt.oClasses.sScrollBody, container).append( nTable );





		var appendTo;


		if (dt._bInitComplete) {


			appendTo = origTable.parentNode;


		} else {


			if (!this.s.dt.nHolding) {


				this.s.dt.nHolding = $( '<div></div>' ).insertBefore( this.s.dt.nTable );


			}


			appendTo = this.s.dt.nHolding;


		}





		container.appendTo( appendTo );


		this.s.heights.row = $('tr', tbody).eq(1).outerHeight();


		container.remove();


	},








	/**


	 * Update any information elements that are controlled by the DataTable based on the scrolling


	 * viewport and what rows are visible in it. This function basically acts in the same way as


	 * _fnUpdateInfo in DataTables, and effectively replaces that function.


	 *  @returns {void}


	 *  @private


	 */


	"_fnInfo": function ()


	{


		if ( !this.s.dt.oFeatures.bInfo )


		{


			return;


		}





		var


			dt = this.s.dt,


			language = dt.oLanguage,


			iScrollTop = this.dom.scroller.scrollTop,


			iStart = Math.floor( this.fnPixelsToRow(iScrollTop, false, this.s.ani)+1 ),


			iMax = dt.fnRecordsTotal(),


			iTotal = dt.fnRecordsDisplay(),


			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 ),


			sMax = dt.fnFormatNumber( iMax ),


			sTotal = dt.fnFormatNumber( iTotal ),


			sOut;





		if ( dt.fnRecordsDisplay() === 0 &&


			   dt.fnRecordsDisplay() == dt.fnRecordsTotal() )


		{


			/* Empty record set */


			sOut = language.sInfoEmpty+ language.sInfoPostFix;


		}


		else if ( dt.fnRecordsDisplay() === 0 )


		{


			/* Empty record set after filtering */


			sOut = language.sInfoEmpty +' '+


				language.sInfoFiltered.replace('_MAX_', sMax)+


					language.sInfoPostFix;


		}


		else if ( dt.fnRecordsDisplay() == dt.fnRecordsTotal() )


		{


			/* Normal record set */


			sOut = language.sInfo.


					replace('_START_', sStart).


					replace('_END_',   sEnd).


					replace('_MAX_',   sMax).


					replace('_TOTAL_', sTotal)+


				language.sInfoPostFix;


		}


		else


		{


			/* Record set after filtering */


			sOut = language.sInfo.


					replace('_START_', sStart).


					replace('_END_',   sEnd).


					replace('_MAX_',   sMax).


					replace('_TOTAL_', sTotal) +' '+


				language.sInfoFiltered.replace(


					'_MAX_',


					dt.fnFormatNumber(dt.fnRecordsTotal())


				)+


				language.sInfoPostFix;


		}





		var callback = language.fnInfoCallback;


		if ( callback ) {


			sOut = callback.call( dt.oInstance,


				dt, iStart, iEnd, iMax, iTotal, sOut


			);


		}





		var n = dt.aanFeatures.i;


		if ( typeof n != 'undefined' )


		{


			for ( var i=0, iLen=n.length ; i<iLen ; i++ )


			{


				$(n[i]).html( sOut );


			}


		}


	}


};











/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *


 * Statics


 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */








/**


 * Scroller default settings for initialisation


 *  @namespace


 *  @name Scroller.defaults


 *  @static


 */


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


	 * be turned off for production.


	 *  @type     bool


	 *  @default  false


	 *  @static


	 *  @example


	 *    var oTable = $('#example').dataTable( {


	 *        "sScrollY": "200px",


	 *        "sDom": "frtiS",


	 *        "bDeferRender": true,


	 *        "oScroller": {


	 *          "trace": true


	 *        }


	 *    } );


	 */


	"trace": false,





	/**


	 * Scroller will attempt to automatically calculate the height of rows for it's internal


	 * calculations. However the height that is used can be overridden using this parameter.


	 *  @type     int|string


	 *  @default  auto


	 *  @static


	 *  @example


	 *    var oTable = $('#example').dataTable( {


	 *        "sScrollY": "200px",


	 *        "sDom": "frtiS",


	 *        "bDeferRender": true,


	 *        "oScroller": {


	 *          "rowHeight": 30


	 *        }


	 *    } );


	 */


	"rowHeight": "auto",





	/**


	 * When using server-side processing, Scroller will wait a small amount of time to allow


	 * the scrolling to finish before requesting more data from the server. This prevents


	 * you from DoSing your own server! The wait time can be configured by this parameter.


	 *  @type     int


	 *  @default  200


	 *  @static


	 *  @example


	 *    var oTable = $('#example').dataTable( {


	 *        "sScrollY": "200px",


	 *        "sDom": "frtiS",


	 *        "bDeferRender": true,


	 *        "oScroller": {


	 *          "serverWait": 100


	 *        }


	 *    } );


	 */


	"serverWait": 200,





	/**


	 * The display buffer is what Scroller uses to calculate how many rows it should pre-fetch


	 * for scrolling. Scroller automatically adjusts DataTables' display length to pre-fetch


	 * rows that will be shown in "near scrolling" (i.e. just beyond the current display area).


	 * The value is based upon the number of rows that can be displayed in the viewport (i.e.


	 * a value of 1), and will apply the display range to records before before and after the


	 * current viewport - i.e. a factor of 3 will allow Scroller to pre-fetch 1 viewport's worth


	 * of rows before the current viewport, the current viewport's rows and 1 viewport's worth


	 * of rows after the current viewport. Adjusting this value can be useful for ensuring


	 * smooth scrolling based on your data set.


	 *  @type     int


	 *  @default  7


	 *  @static


	 *  @example


	 *    var oTable = $('#example').dataTable( {


	 *        "sScrollY": "200px",


	 *        "sDom": "frtiS",


	 *        "bDeferRender": true,


	 *        "oScroller": {


	 *          "displayBuffer": 10


	 *        }


	 *    } );


	 */


	"displayBuffer": 9,





	/**


	 * Scroller uses the boundary scaling factor to decide when to redraw the table - which it


	 * typically does before you reach the end of the currently loaded data set (in order to


	 * allow the data to look continuous to a user scrolling through the data). If given as 0


	 * then the table will be redrawn whenever the viewport is scrolled, while 1 would not


	 * redraw the table until the currently loaded data has all been shown. You will want


	 * something in the middle - the default factor of 0.5 is usually suitable.


	 *  @type     float


	 *  @default  0.5


	 *  @static


	 *  @example


	 *    var oTable = $('#example').dataTable( {


	 *        "sScrollY": "200px",


	 *        "sDom": "frtiS",


	 *        "bDeferRender": true,


	 *        "oScroller": {


	 *          "boundaryScale": 0.75


	 *        }


	 *    } );


	 */


	"boundaryScale": 0.5,





	/**


	 * Show (or not) the loading element in the background of the table. Note that you should


	 * include the dataTables.scroller.css file for this to be displayed correctly.


	 *  @type     boolean


	 *  @default  false


	 *  @static


	 *  @example


	 *    var oTable = $('#example').dataTable( {


	 *        "sScrollY": "200px",


	 *        "sDom": "frtiS",


	 *        "bDeferRender": true,


	 *        "oScroller": {


	 *          "loadingIndicator": true


	 *        }


	 *    } );


	 */


	"loadingIndicator": false


};





Scroller.oDefaults = Scroller.defaults;











/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *


 * Constants


 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */





/**


 * Scroller version


 *  @type      String


 *  @default   See code


 *  @name      Scroller.version


 *  @static


 */


Scroller.version = "1.2.2";











/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *


 * Initialisation


 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */





/*


 * Register a new feature with DataTables


 */


if ( typeof $.fn.dataTable == "function" &&


     typeof $.fn.dataTableExt.fnVersionCheck == "function" &&


     $.fn.dataTableExt.fnVersionCheck('1.9.0') )


{


	$.fn.dataTableExt.aoFeatures.push( {


		"fnInit": function( oDTSettings ) {


			var init = oDTSettings.oInit;


			var opts = init.scroller || init.oScroller || {};


			var oScroller = new Scroller( oDTSettings, opts );


			return oScroller.dom.wrapper;


		},


		"cFeature": "S",


		"sFeature": "Scroller"


	} );


}


else


{


	alert( "Warning: Scroller requires DataTables 1.9.0 or greater - www.datatables.net/download");


}








// 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()', function () {


		return this;


	} );





	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( ['jquery', 'datatables'], factory );


}


else if ( typeof exports === 'object' ) {


    // Node/CommonJS


    factory( require('jquery'), require('datatables') );


}


else if ( jQuery && !jQuery.fn.dataTable.Scroller ) {


	// Otherwise simply initialise as normal, stopping multiple evaluation


	factory( jQuery, jQuery.fn.dataTable );


}








})(window, document);





