/*! Scroller 1.2.0
 * 2011-2014 SpryMedia Ltd - datatables.net/license
 */

/**
 * @summary     Scroller
 * @description Virtual rendering for DataTables
 * @version     1.2.0
 * @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 caluated 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
			};
			this.s = $.extend(this.s, Scroller.oDefaults, oOpts);

			/**
			 * DOM elements used by the class instance
			 * @private
			 * @namespace
			 *
			 */
			this.dom = {
				"force": document.createElement('div'),
				"scroller": null,
				"table": 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 transision 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;
						}, 0);
					});
				}
				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 dimentions 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 (typeof 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.scroller.parentNode)
						.css('position', 'relative')
						.append('<div class="DTS_Loading">' + this.s.dt.oLanguage.sLoadingRecords + '</div>');
				}

				/* 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 */
				$(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).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._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;
						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.
			 *  @returns {void}
			 *  @private
			 */
			"_fnScroll": function () {
				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) {
					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 = ((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();
						}
					}
				}

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


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

				// 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
				if (this.s.dt.oFeatures.bStateSave && this.s.dt.oLoadedState !== null &&
					typeof this.s.dt.oLoadedState.iScroller != 'undefined') {
					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 - (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
			 * 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 nTable = this.s.dt.nTable.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>'
				);

				// 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)', nTable).clone().appendTo(tbody);
				while ($('tr', tbody).length < 3) {
					tbody.append('<tr><td>&nbsp;</td></tr>');
				}

				$('div.' + this.s.dt.oClasses.sScrollBody, container).append(nTable);

				container.appendTo('body');
				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,
					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 = dt.oLanguage.sInfoEmpty + dt.oLanguage.sInfoPostFix;
				}
				else if (dt.fnRecordsDisplay() === 0) {
					/* Rmpty record set after filtering */
					sOut = dt.oLanguage.sInfoEmpty + ' ' +
						dt.oLanguage.sInfoFiltered.replace('_MAX_', sMax) +
						dt.oLanguage.sInfoPostFix;
				}
				else if (dt.fnRecordsDisplay() == dt.fnRecordsTotal()) {
					/* Normal record set */
					sOut = dt.oLanguage.sInfo.
						replace('_START_', sStart).
						replace('_END_', sEnd).
						replace('_TOTAL_', sTotal) +
						dt.oLanguage.sInfoPostFix;
				}
				else {
					/* Record set after filtering */
					sOut = dt.oLanguage.sInfo.
						replace('_START_', sStart).
						replace('_END_', sEnd).
						replace('_TOTAL_', sTotal) + ' ' +
						dt.oLanguage.sInfoFiltered.replace('_MAX_',
														   dt.fnFormatNumber(dt.fnRecordsTotal())) +
						dt.oLanguage.sInfoPostFix;
				}

				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 = {
			/**
			 * 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.0";


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


	factory(jQuery, jQuery.fn.dataTable);


})(window, document);

