905 lines
27 KiB
JavaScript
905 lines
27 KiB
JavaScript
|
/**
|
||
|
|
* @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
|
||
|
|
* @contact www.sprymedia.co.uk/contact
|
||
|
|
*
|
||
|
|
* @copyright Copyright 2011-2012 Allan Jardine, all rights reserved.
|
||
|
|
*
|
||
|
|
* 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
|
||
|
|
*/
|
||
|
|
|
||
|
|
(/** @lends <global> */function($, window, document) {
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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 sDom.
|
||
|
|
*
|
||
|
|
* 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>Integration with state saving in DataTables (scrolling position is saved)</li>
|
||
|
|
* <li>Easy to use</li>
|
||
|
|
* </ul>
|
||
|
|
*
|
||
|
|
* @class
|
||
|
|
* @constructor
|
||
|
|
* @param {object} oDT DataTables settings object
|
||
|
|
* @param {object} [oOpts={}] Configuration object for FixedColumns. Options are defined by {@link Scroller.oDefaults}
|
||
|
|
*
|
||
|
|
* @requires jQuery 1.4+
|
||
|
|
* @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
|
||
|
|
* @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,
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Height of rows in the table
|
||
|
|
* @type int
|
||
|
|
* @default 0
|
||
|
|
*/
|
||
|
|
"rowHeight": null,
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Auto row height or not indicator
|
||
|
|
* @type bool
|
||
|
|
* @default 0
|
||
|
|
*/
|
||
|
|
"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
|
||
|
|
* @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
|
||
|
|
};
|
||
|
|
this.s = $.extend( this.s, Scroller.oDefaults, oOpts );
|
||
|
|
|
||
|
|
/**
|
||
|
|
* DOM elements used by the class instance
|
||
|
|
* @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 = {
|
||
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||
|
|
* 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 ( iRow )
|
||
|
|
{
|
||
|
|
return iRow * this.s.rowHeight;
|
||
|
|
},
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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
|
||
|
|
* @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 ( iPixels )
|
||
|
|
{
|
||
|
|
return parseInt( iPixels / this.s.rowHeight, 10 );
|
||
|
|
},
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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 px = this.fnRowToPixels( iRow );
|
||
|
|
if ( typeof bAnimate == 'undefined' || bAnimate )
|
||
|
|
{
|
||
|
|
$(this.dom.scroller).animate( {
|
||
|
|
"scrollTop": px
|
||
|
|
} );
|
||
|
|
}
|
||
|
|
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();
|
||
|
|
}
|
||
|
|
|
||
|
|
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;
|
||
|
|
|
||
|
|
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
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
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;
|
||
|
|
|
||
|
|
/* 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.rowHeight && this.s.rowHeight != 'auto' )
|
||
|
|
{
|
||
|
|
this.s.autoHeight = false;
|
||
|
|
}
|
||
|
|
this.fnMeasure( false );
|
||
|
|
|
||
|
|
/* Scrolling callback to see if a page change is needed */
|
||
|
|
$(this.dom.scroller).scroll( 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 () {
|
||
|
|
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"
|
||
|
|
} );
|
||
|
|
|
||
|
|
/* Add a state saving parameter to the DT state saving so we can restore the exact
|
||
|
|
* position of the scrolling
|
||
|
|
*/
|
||
|
|
this.s.dt.oApi._fnCallbackReg( this.s.dt, 'aoStateSaveParams', function (oS, oData) {
|
||
|
|
oData.iScroller = that.dom.scroller.scrollTop;
|
||
|
|
}, "Scroller_State" );
|
||
|
|
},
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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,
|
||
|
|
iScrollTop = this.dom.scroller.scrollTop,
|
||
|
|
iTopRow;
|
||
|
|
|
||
|
|
/* 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 )
|
||
|
|
{
|
||
|
|
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
|
||
|
|
*/
|
||
|
|
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;
|
||
|
|
iTopRow = parseInt( iScrollTop / this.s.rowHeight, 10 ) - preRows;
|
||
|
|
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;
|
||
|
|
|
||
|
|
/* 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 );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
this.s.dt._iDisplayStart = iTopRow;
|
||
|
|
this.s.dt.oApi._fnCalculateEnd( this.s.dt );
|
||
|
|
this.s.dt.oApi._fnDraw( this.s.dt );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( this.s.trace )
|
||
|
|
{
|
||
|
|
console.log( 'Scroll forcing redraw - top DT render row: '+ iTopRow );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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,
|
||
|
|
iScrollTop = this.dom.scroller.scrollTop,
|
||
|
|
iScrollBottom = iScrollTop + this.s.viewportHeight;
|
||
|
|
|
||
|
|
/* 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";
|
||
|
|
|
||
|
|
/* 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;
|
||
|
|
}
|
||
|
|
else if ( this.s.dt._iDisplayStart === this.s.dt.fnRecordsDisplay() - this.s.dt._iDisplayLength )
|
||
|
|
{
|
||
|
|
iTableTop = this.s.rowHeight * this.s.dt._iDisplayStart;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.dom.table.style.top = iTableTop+"px";
|
||
|
|
|
||
|
|
/* Cache some information for the scroller */
|
||
|
|
this.s.tableTop = iTableTop;
|
||
|
|
this.s.tableBottom = $(this.s.dt.nTable).height() + 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 );
|
||
|
|
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* 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' )
|
||
|
|
{
|
||
|
|
if ( (this.s.dt.sAjaxSource !== null && this.s.dt.iDraw == 2) ||
|
||
|
|
(this.s.dt.sAjaxSource === null && 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);
|
||
|
|
}, 0 );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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 nContainer = $(
|
||
|
|
'<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> </td>'+
|
||
|
|
'</tr>'+
|
||
|
|
'</tbody>'
|
||
|
|
);
|
||
|
|
|
||
|
|
$('div.'+this.s.dt.oClasses.sScrollBody, nContainer).append( nTable );
|
||
|
|
|
||
|
|
document.body.appendChild( nContainer );
|
||
|
|
this.s.rowHeight = $('tbody tr', nTable).outerHeight();
|
||
|
|
document.body.removeChild( nContainer );
|
||
|
|
},
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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 = this.fnPixelsToRow(iScrollTop)+1,
|
||
|
|
iMax = dt.fnRecordsTotal(),
|
||
|
|
iTotal = dt.fnRecordsDisplay(),
|
||
|
|
iPossibleEnd = this.fnPixelsToRow(iScrollTop+$(this.dom.scroller).height()),
|
||
|
|
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
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
Scroller.oDefaults = {
|
||
|
|
/**
|
||
|
|
* 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
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||
|
|
* Constants
|
||
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Name of this class
|
||
|
|
* @type String
|
||
|
|
* @default Scroller
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
Scroller.prototype.CLASS = "Scroller";
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Scroller version
|
||
|
|
* @type String
|
||
|
|
* @default See code
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
Scroller.VERSION = "1.1.0";
|
||
|
|
Scroller.prototype.VERSION = Scroller.VERSION;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||
|
|
* 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 = (typeof oDTSettings.oInit.oScroller == 'undefined') ?
|
||
|
|
{} : oDTSettings.oInit.oScroller;
|
||
|
|
var oScroller = new Scroller( oDTSettings, init );
|
||
|
|
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;
|
||
|
|
|
||
|
|
})(jQuery, window, document);
|