mirror of
https://github.com/lidarr/lidarr.git
synced 2025-08-20 05:23:31 -07:00
Upgraded nuget packages, Ninject 3, SignalR 5
This commit is contained in:
Mark McDowall
parent
8f0d22e47d
commit
64468cd9ed
489 changed files with 293885 additions and 30058 deletions
|
|
@ -0,0 +1,904 @@
|
|||
/**
|
||||
* @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);
|
||||
Loading…
Add table
Add a link
Reference in a new issue