+++ /dev/null
-/*! Scroller 1.2.2
- * ©2011-2014 SpryMedia Ltd - datatables.net/license
- */
-
-/**
- * @summary Scroller
- * @description Virtual rendering for DataTables
- * @version 1.2.2
- * @file dataTables.scroller.js
- * @author SpryMedia Ltd (www.sprymedia.co.uk)
- * @contact www.sprymedia.co.uk/contact
- * @copyright Copyright 2011-2014 SpryMedia Ltd.
- *
- * This source file is free software, available under the following license:
- * MIT license - http://datatables.net/license/mit
- *
- * This source file is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
- *
- * For details please refer to: http://www.datatables.net
- */
-
-(function(window, document, undefined){
-
-
-var factory = function( $, DataTable ) {
-"use strict";
-
-/**
- * Scroller is a virtual rendering plug-in for DataTables which allows large
- * datasets to be drawn on screen every quickly. What the virtual rendering means
- * is that only the visible portion of the table (and a bit to either side to make
- * the scrolling smooth) is drawn, while the scrolling container gives the
- * visual impression that the whole table is visible. This is done by making use
- * of the pagination abilities of DataTables and moving the table around in the
- * scrolling container DataTables adds to the page. The scrolling container is
- * forced to the height it would be for the full table display using an extra
- * element.
- *
- * Note that rows in the table MUST all be the same height. Information in a cell
- * which expands on to multiple lines will cause some odd behaviour in the scrolling.
- *
- * Scroller is initialised by simply including the letter 'S' in the sDom for the
- * table you want to have this feature enabled on. Note that the 'S' must come
- * AFTER the 't' parameter in `dom`.
- *
- * Key features include:
- * <ul class="limit_length">
- * <li>Speed! The aim of Scroller for DataTables is to make rendering large data sets fast</li>
- * <li>Full compatibility with deferred rendering in DataTables 1.9 for maximum speed</li>
- * <li>Display millions of rows</li>
- * <li>Integration with state saving in DataTables (scrolling position is saved)</li>
- * <li>Easy to use</li>
- * </ul>
- *
- * @class
- * @constructor
- * @global
- * @param {object} oDT DataTables settings object
- * @param {object} [oOpts={}] Configuration object for FixedColumns. Options
- * are defined by {@link Scroller.defaults}
- *
- * @requires jQuery 1.7+
- * @requires DataTables 1.9.0+
- *
- * @example
- * $(document).ready(function() {
- * $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sAjaxSource": "media/dataset/large.txt",
- * "sDom": "frtiS",
- * "bDeferRender": true
- * } );
- * } );
- */
-var Scroller = function ( oDTSettings, oOpts ) {
- /* Sanity check - you just know it will happen */
- if ( ! this instanceof Scroller )
- {
- alert( "Scroller warning: Scroller must be initialised with the 'new' keyword." );
- return;
- }
-
- if ( typeof oOpts == 'undefined' )
- {
- oOpts = {};
- }
-
- /**
- * Settings object which contains customisable information for the Scroller instance
- * @namespace
- * @private
- * @extends Scroller.defaults
- */
- this.s = {
- /**
- * DataTables settings object
- * @type object
- * @default Passed in as first parameter to constructor
- */
- "dt": oDTSettings,
-
- /**
- * Pixel location of the top of the drawn table in the viewport
- * @type int
- * @default 0
- */
- "tableTop": 0,
-
- /**
- * Pixel location of the bottom of the drawn table in the viewport
- * @type int
- * @default 0
- */
- "tableBottom": 0,
-
- /**
- * Pixel location of the boundary for when the next data set should be loaded and drawn
- * when scrolling up the way.
- * @type int
- * @default 0
- * @private
- */
- "redrawTop": 0,
-
- /**
- * Pixel location of the boundary for when the next data set should be loaded and drawn
- * when scrolling down the way. Note that this is actually calculated as the offset from
- * the top.
- * @type int
- * @default 0
- * @private
- */
- "redrawBottom": 0,
-
- /**
- * Auto row height or not indicator
- * @type bool
- * @default 0
- */
- "autoHeight": true,
-
- /**
- * Number of rows calculated as visible in the visible viewport
- * @type int
- * @default 0
- */
- "viewportRows": 0,
-
- /**
- * setTimeout reference for state saving, used when state saving is enabled in the DataTable
- * and when the user scrolls the viewport in order to stop the cookie set taking too much
- * CPU!
- * @type int
- * @default 0
- */
- "stateTO": null,
-
- /**
- * setTimeout reference for the redraw, used when server-side processing is enabled in the
- * DataTables in order to prevent DoSing the server
- * @type int
- * @default null
- */
- "drawTO": null,
-
- heights: {
- jump: null,
- page: null,
- virtual: null,
- scroll: null,
-
- /**
- * Height of rows in the table
- * @type int
- * @default 0
- */
- row: null,
-
- /**
- * Pixel height of the viewport
- * @type int
- * @default 0
- */
- viewport: null
- },
-
- topRowFloat: 0,
- scrollDrawDiff: null,
- loaderVisible: false
- };
-
- // @todo The defaults should extend a `c` property and the internal settings
- // only held in the `s` property. At the moment they are mixed
- this.s = $.extend( this.s, Scroller.oDefaults, oOpts );
-
- // Workaround for row height being read from height object (see above comment)
- this.s.heights.row = this.s.rowHeight;
-
- /**
- * DOM elements used by the class instance
- * @private
- * @namespace
- *
- */
- this.dom = {
- "force": document.createElement('div'),
- "scroller": null,
- "table": null,
- "loader": null
- };
-
- /* Attach the instance to the DataTables instance so it can be accessed */
- this.s.dt.oScroller = this;
-
- /* Let's do it */
- this._fnConstruct();
-};
-
-
-
-Scroller.prototype = /** @lends Scroller.prototype */{
- /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Public methods
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
- /**
- * Calculate the pixel position from the top of the scrolling container for
- * a given row
- * @param {int} iRow Row number to calculate the position of
- * @returns {int} Pixels
- * @example
- * $(document).ready(function() {
- * $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sAjaxSource": "media/dataset/large.txt",
- * "sDom": "frtiS",
- * "bDeferRender": true,
- * "fnInitComplete": function (o) {
- * // Find where row 25 is
- * alert( o.oScroller.fnRowToPixels( 25 ) );
- * }
- * } );
- * } );
- */
- "fnRowToPixels": function ( rowIdx, intParse, virtual )
- {
- var pixels;
-
- if ( virtual ) {
- pixels = this._domain( 'virtualToPhysical', rowIdx * this.s.heights.row );
- }
- else {
- var diff = rowIdx - this.s.baseRowTop;
- pixels = this.s.baseScrollTop + (diff * this.s.heights.row);
- }
-
- return intParse || intParse === undefined ?
- parseInt( pixels, 10 ) :
- pixels;
- },
-
-
- /**
- * Calculate the row number that will be found at the given pixel position
- * (y-scroll).
- *
- * Please note that when the height of the full table exceeds 1 million
- * pixels, Scroller switches into a non-linear mode for the scrollbar to fit
- * all of the records into a finite area, but this function returns a linear
- * value (relative to the last non-linear positioning).
- * @param {int} iPixels Offset from top to calculate the row number of
- * @param {int} [intParse=true] If an integer value should be returned
- * @param {int} [virtual=false] Perform the calculations in the virtual domain
- * @returns {int} Row index
- * @example
- * $(document).ready(function() {
- * $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sAjaxSource": "media/dataset/large.txt",
- * "sDom": "frtiS",
- * "bDeferRender": true,
- * "fnInitComplete": function (o) {
- * // Find what row number is at 500px
- * alert( o.oScroller.fnPixelsToRow( 500 ) );
- * }
- * } );
- * } );
- */
- "fnPixelsToRow": function ( pixels, intParse, virtual )
- {
- var diff = pixels - this.s.baseScrollTop;
- var row = virtual ?
- this._domain( 'physicalToVirtual', pixels ) / this.s.heights.row :
- ( diff / this.s.heights.row ) + this.s.baseRowTop;
-
- return intParse || intParse === undefined ?
- parseInt( row, 10 ) :
- row;
- },
-
-
- /**
- * Calculate the row number that will be found at the given pixel position (y-scroll)
- * @param {int} iRow Row index to scroll to
- * @param {bool} [bAnimate=true] Animate the transition or not
- * @returns {void}
- * @example
- * $(document).ready(function() {
- * $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sAjaxSource": "media/dataset/large.txt",
- * "sDom": "frtiS",
- * "bDeferRender": true,
- * "fnInitComplete": function (o) {
- * // Immediately scroll to row 1000
- * o.oScroller.fnScrollToRow( 1000 );
- * }
- * } );
- *
- * // Sometime later on use the following to scroll to row 500...
- * var oSettings = $('#example').dataTable().fnSettings();
- * oSettings.oScroller.fnScrollToRow( 500 );
- * } );
- */
- "fnScrollToRow": function ( iRow, bAnimate )
- {
- var that = this;
- var ani = false;
- var px = this.fnRowToPixels( iRow );
-
- // We need to know if the table will redraw or not before doing the
- // scroll. If it will not redraw, then we need to use the currently
- // displayed table, and scroll with the physical pixels. Otherwise, we
- // need to calculate the table's new position from the virtual
- // transform.
- var preRows = ((this.s.displayBuffer-1)/2) * this.s.viewportRows;
- var drawRow = iRow - preRows;
- if ( drawRow < 0 ) {
- drawRow = 0;
- }
-
- if ( (px > this.s.redrawBottom || px < this.s.redrawTop) && this.s.dt._iDisplayStart !== drawRow ) {
- ani = true;
- px = this.fnRowToPixels( iRow, false, true );
- }
-
- if ( typeof bAnimate == 'undefined' || bAnimate )
- {
- this.s.ani = ani;
- $(this.dom.scroller).animate( {
- "scrollTop": px
- }, function () {
- // This needs to happen after the animation has completed and
- // the final scroll event fired
- setTimeout( function () {
- that.s.ani = false;
- }, 25 );
- } );
- }
- else
- {
- $(this.dom.scroller).scrollTop( px );
- }
- },
-
-
- /**
- * Calculate and store information about how many rows are to be displayed
- * in the scrolling viewport, based on current dimensions in the browser's
- * rendering. This can be particularly useful if the table is initially
- * drawn in a hidden element - for example in a tab.
- * @param {bool} [bRedraw=true] Redraw the table automatically after the recalculation, with
- * the new dimensions forming the basis for the draw.
- * @returns {void}
- * @example
- * $(document).ready(function() {
- * // Make the example container hidden to throw off the browser's sizing
- * document.getElementById('container').style.display = "none";
- * var oTable = $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sAjaxSource": "media/dataset/large.txt",
- * "sDom": "frtiS",
- * "bDeferRender": true,
- * "fnInitComplete": function (o) {
- * // Immediately scroll to row 1000
- * o.oScroller.fnScrollToRow( 1000 );
- * }
- * } );
- *
- * setTimeout( function () {
- * // Make the example container visible and recalculate the scroller sizes
- * document.getElementById('container').style.display = "block";
- * oTable.fnSettings().oScroller.fnMeasure();
- * }, 3000 );
- */
- "fnMeasure": function ( bRedraw )
- {
- if ( this.s.autoHeight )
- {
- this._fnCalcRowHeight();
- }
-
- var heights = this.s.heights;
-
- heights.viewport = $(this.dom.scroller).height();
- this.s.viewportRows = parseInt( heights.viewport / heights.row, 10 )+1;
- this.s.dt._iDisplayLength = this.s.viewportRows * this.s.displayBuffer;
-
- if ( bRedraw === undefined || bRedraw )
- {
- this.s.dt.oInstance.fnDraw();
- }
- },
-
-
-
- /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Private methods (they are of course public in JS, but recommended as private)
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
- /**
- * Initialisation for Scroller
- * @returns {void}
- * @private
- */
- "_fnConstruct": function ()
- {
- var that = this;
-
- /* Sanity check */
- if ( !this.s.dt.oFeatures.bPaginate ) {
- this.s.dt.oApi._fnLog( this.s.dt, 0, 'Pagination must be enabled for Scroller' );
- return;
- }
-
- /* Insert a div element that we can use to force the DT scrolling container to
- * the height that would be required if the whole table was being displayed
- */
- this.dom.force.style.position = "absolute";
- this.dom.force.style.top = "0px";
- this.dom.force.style.left = "0px";
- this.dom.force.style.width = "1px";
-
- this.dom.scroller = $('div.'+this.s.dt.oClasses.sScrollBody, this.s.dt.nTableWrapper)[0];
- this.dom.scroller.appendChild( this.dom.force );
- this.dom.scroller.style.position = "relative";
-
- this.dom.table = $('>table', this.dom.scroller)[0];
- this.dom.table.style.position = "absolute";
- this.dom.table.style.top = "0px";
- this.dom.table.style.left = "0px";
-
- // Add class to 'announce' that we are a Scroller table
- $(this.s.dt.nTableWrapper).addClass('DTS');
-
- // Add a 'loading' indicator
- if ( this.s.loadingIndicator )
- {
- this.dom.loader = $('<div class="DTS_Loading">'+this.s.dt.oLanguage.sLoadingRecords+'</div>')
- .css('display', 'none');
-
- $(this.dom.scroller.parentNode)
- .css('position', 'relative')
- .append( this.dom.loader );
- }
-
- /* Initial size calculations */
- if ( this.s.heights.row && this.s.heights.row != 'auto' )
- {
- this.s.autoHeight = false;
- }
- this.fnMeasure( false );
-
- /* Scrolling callback to see if a page change is needed - use a throttled
- * function for the save save callback so we aren't hitting it on every
- * scroll
- */
- this.s.ingnoreScroll = true;
- this.s.stateSaveThrottle = this.s.dt.oApi._fnThrottle( function () {
- that.s.dt.oApi._fnSaveState( that.s.dt );
- }, 500 );
- $(this.dom.scroller).on( 'scroll.DTS', function (e) {
- that._fnScroll.call( that );
- } );
-
- /* In iOS we catch the touchstart event in case the user tries to scroll
- * while the display is already scrolling
- */
- $(this.dom.scroller).on('touchstart.DTS', function () {
- that._fnScroll.call( that );
- } );
-
- /* Update the scroller when the DataTable is redrawn */
- this.s.dt.aoDrawCallback.push( {
- "fn": function () {
- if ( that.s.dt.bInitialised ) {
- that._fnDrawCallback.call( that );
- }
- },
- "sName": "Scroller"
- } );
-
- /* On resize, update the information element, since the number of rows shown might change */
- $(window).on( 'resize.DTS', function () {
- that.fnMeasure( false );
- that._fnInfo();
- } );
-
- /* Add a state saving parameter to the DT state saving so we can restore the exact
- * position of the scrolling
- */
- var initialStateSave = true;
- this.s.dt.oApi._fnCallbackReg( this.s.dt, 'aoStateSaveParams', function (oS, oData) {
- /* Set iScroller to saved scroll position on initialization.
- */
- if(initialStateSave && that.s.dt.oLoadedState){
- oData.iScroller = that.s.dt.oLoadedState.iScroller;
- oData.iScrollerTopRow = that.s.dt.oLoadedState.iScrollerTopRow;
- initialStateSave = false;
- } else {
- oData.iScroller = that.dom.scroller.scrollTop;
- oData.iScrollerTopRow = that.s.topRowFloat;
- }
- }, "Scroller_State" );
-
- if ( this.s.dt.oLoadedState ) {
- this.s.topRowFloat = this.s.dt.oLoadedState.iScrollerTopRow || 0;
- }
-
- /* Destructor */
- this.s.dt.aoDestroyCallback.push( {
- "sName": "Scroller",
- "fn": function () {
- $(window).off( 'resize.DTS' );
- $(that.dom.scroller).off('touchstart.DTS scroll.DTS');
- $(that.s.dt.nTableWrapper).removeClass('DTS');
- $('div.DTS_Loading', that.dom.scroller.parentNode).remove();
-
- that.dom.table.style.position = "";
- that.dom.table.style.top = "";
- that.dom.table.style.left = "";
- }
- } );
- },
-
-
- /**
- * Scrolling function - fired whenever the scrolling position is changed.
- * This method needs to use the stored values to see if the table should be
- * redrawn as we are moving towards the end of the information that is
- * currently drawn or not. If needed, then it will redraw the table based on
- * the new position.
- * @returns {void}
- * @private
- */
- "_fnScroll": function ()
- {
- var
- that = this,
- heights = this.s.heights,
- iScrollTop = this.dom.scroller.scrollTop,
- iTopRow;
-
- if ( this.s.skip ) {
- return;
- }
-
- if ( this.s.ingnoreScroll ) {
- return;
- }
-
- /* If the table has been sorted or filtered, then we use the redraw that
- * DataTables as done, rather than performing our own
- */
- if ( this.s.dt.bFiltered || this.s.dt.bSorted ) {
- this.s.lastScrollTop = 0;
- return;
- }
-
- /* Update the table's information display for what is now in the viewport */
- this._fnInfo();
-
- /* We don't want to state save on every scroll event - that's heavy
- * handed, so use a timeout to update the state saving only when the
- * scrolling has finished
- */
- clearTimeout( this.s.stateTO );
- this.s.stateTO = setTimeout( function () {
- that.s.dt.oApi._fnSaveState( that.s.dt );
- }, 250 );
-
- /* Check if the scroll point is outside the trigger boundary which would required
- * a DataTables redraw
- */
- if ( iScrollTop < this.s.redrawTop || iScrollTop > this.s.redrawBottom ) {
- var preRows = Math.ceil( ((this.s.displayBuffer-1)/2) * this.s.viewportRows );
-
- if ( Math.abs( iScrollTop - this.s.lastScrollTop ) > heights.viewport || this.s.ani ) {
- iTopRow = parseInt(this._domain( 'physicalToVirtual', iScrollTop ) / heights.row, 10) - preRows;
- this.s.topRowFloat = (this._domain( 'physicalToVirtual', iScrollTop ) / heights.row);
- }
- else {
- iTopRow = this.fnPixelsToRow( iScrollTop ) - preRows;
- this.s.topRowFloat = this.fnPixelsToRow( iScrollTop, false );
- }
-
- if ( iTopRow <= 0 ) {
- /* At the start of the table */
- iTopRow = 0;
- }
- else if ( iTopRow + this.s.dt._iDisplayLength > this.s.dt.fnRecordsDisplay() ) {
- /* At the end of the table */
- iTopRow = this.s.dt.fnRecordsDisplay() - this.s.dt._iDisplayLength;
- if ( iTopRow < 0 ) {
- iTopRow = 0;
- }
- }
- else if ( iTopRow % 2 !== 0 ) {
- // For the row-striping classes (odd/even) we want only to start
- // on evens otherwise the stripes will change between draws and
- // look rubbish
- iTopRow++;
- }
-
- if ( iTopRow != this.s.dt._iDisplayStart ) {
- /* Cache the new table position for quick lookups */
- this.s.tableTop = $(this.s.dt.nTable).offset().top;
- this.s.tableBottom = $(this.s.dt.nTable).height() + this.s.tableTop;
-
- var draw = function () {
- if ( that.s.scrollDrawReq === null ) {
- that.s.scrollDrawReq = iScrollTop;
- }
-
- that.s.dt._iDisplayStart = iTopRow;
- if ( that.s.dt.oApi._fnCalculateEnd ) { // Removed in 1.10
- that.s.dt.oApi._fnCalculateEnd( that.s.dt );
- }
- that.s.dt.oApi._fnDraw( that.s.dt );
- };
-
- /* Do the DataTables redraw based on the calculated start point - note that when
- * using server-side processing we introduce a small delay to not DoS the server...
- */
- if ( this.s.dt.oFeatures.bServerSide ) {
- clearTimeout( this.s.drawTO );
- this.s.drawTO = setTimeout( draw, this.s.serverWait );
- }
- else {
- draw();
- }
-
- if ( this.dom.loader && ! this.s.loaderVisible ) {
- this.dom.loader.css( 'display', 'block' );
- this.s.loaderVisible = true;
- }
- }
- }
-
- this.s.lastScrollTop = iScrollTop;
- this.s.stateSaveThrottle();
- },
-
-
- /**
- * Convert from one domain to another. The physical domain is the actual
- * pixel count on the screen, while the virtual is if we had browsers which
- * had scrolling containers of infinite height (i.e. the absolute value)
- *
- * @param {string} dir Domain transform direction, `virtualToPhysical` or
- * `physicalToVirtual`
- * @returns {number} Calculated transform
- * @private
- */
- _domain: function ( dir, val )
- {
- var heights = this.s.heights;
- var coeff;
-
- // If the virtual and physical height match, then we use a linear
- // transform between the two, allowing the scrollbar to be linear
- if ( heights.virtual === heights.scroll ) {
- coeff = (heights.virtual-heights.viewport) / (heights.scroll-heights.viewport);
-
- if ( dir === 'virtualToPhysical' ) {
- return val / coeff;
- }
- else if ( dir === 'physicalToVirtual' ) {
- return val * coeff;
- }
- }
-
- // Otherwise, we want a non-linear scrollbar to take account of the
- // redrawing regions at the start and end of the table, otherwise these
- // can stutter badly - on large tables 30px (for example) scroll might
- // be hundreds of rows, so the table would be redrawing every few px at
- // the start and end. Use a simple quadratic to stop this. It does mean
- // the scrollbar is non-linear, but with such massive data sets, the
- // scrollbar is going to be a best guess anyway
- var xMax = (heights.scroll - heights.viewport) / 2;
- var yMax = (heights.virtual - heights.viewport) / 2;
-
- coeff = yMax / ( xMax * xMax );
-
- if ( dir === 'virtualToPhysical' ) {
- if ( val < yMax ) {
- return Math.pow(val / coeff, 0.5);
- }
- else {
- val = (yMax*2) - val;
- return val < 0 ?
- heights.scroll :
- (xMax*2) - Math.pow(val / coeff, 0.5);
- }
- }
- else if ( dir === 'physicalToVirtual' ) {
- if ( val < xMax ) {
- return val * val * coeff;
- }
- else {
- val = (xMax*2) - val;
- return val < 0 ?
- heights.virtual :
- (yMax*2) - (val * val * coeff);
- }
- }
- },
-
-
- /**
- * Draw callback function which is fired when the DataTable is redrawn. The main function of
- * this method is to position the drawn table correctly the scrolling container for the rows
- * that is displays as a result of the scrolling position.
- * @returns {void}
- * @private
- */
- "_fnDrawCallback": function ()
- {
- var
- that = this,
- heights = this.s.heights,
- iScrollTop = this.dom.scroller.scrollTop,
- iActualScrollTop = iScrollTop,
- iScrollBottom = iScrollTop + heights.viewport,
- iTableHeight = $(this.s.dt.nTable).height(),
- displayStart = this.s.dt._iDisplayStart,
- displayLen = this.s.dt._iDisplayLength,
- displayEnd = this.s.dt.fnRecordsDisplay();
-
- // Disable the scroll event listener while we are updating the DOM
- this.s.skip = true;
-
- // Resize the scroll forcing element
- this._fnScrollForce();
-
- // Reposition the scrolling for the updated virtual position if needed
- if ( displayStart === 0 ) {
- // Linear calculation at the top of the table
- iScrollTop = this.s.topRowFloat * heights.row;
- }
- else if ( displayStart + displayLen >= displayEnd ) {
- // Linear calculation that the bottom as well
- iScrollTop = heights.scroll - ((displayEnd - this.s.topRowFloat) * heights.row);
- }
- else {
- // Domain scaled in the middle
- iScrollTop = this._domain( 'virtualToPhysical', this.s.topRowFloat * heights.row );
- }
-
- this.dom.scroller.scrollTop = iScrollTop;
-
- // Store positional information so positional calculations can be based
- // upon the current table draw position
- this.s.baseScrollTop = iScrollTop;
- this.s.baseRowTop = this.s.topRowFloat;
-
- // Position the table in the virtual scroller
- var tableTop = iScrollTop - ((this.s.topRowFloat - displayStart) * heights.row);
- if ( displayStart === 0 ) {
- tableTop = 0;
- }
- else if ( displayStart + displayLen >= displayEnd ) {
- tableTop = heights.scroll - iTableHeight;
- }
-
- this.dom.table.style.top = tableTop+'px';
-
- /* Cache some information for the scroller */
- this.s.tableTop = tableTop;
- this.s.tableBottom = iTableHeight + this.s.tableTop;
-
- // Calculate the boundaries for where a redraw will be triggered by the
- // scroll event listener
- var boundaryPx = (iScrollTop - this.s.tableTop) * this.s.boundaryScale;
- this.s.redrawTop = iScrollTop - boundaryPx;
- this.s.redrawBottom = iScrollTop + boundaryPx;
-
- this.s.skip = false;
-
- // Restore the scrolling position that was saved by DataTable's state
- // saving Note that this is done on the second draw when data is Ajax
- // sourced, and the first draw when DOM soured
- if ( this.s.dt.oFeatures.bStateSave && this.s.dt.oLoadedState !== null &&
- typeof this.s.dt.oLoadedState.iScroller != 'undefined' )
- {
- // A quirk of DataTables is that the draw callback will occur on an
- // empty set if Ajax sourced, but not if server-side processing.
- var ajaxSourced = (this.s.dt.sAjaxSource || that.s.dt.ajax) && ! this.s.dt.oFeatures.bServerSide ?
- true :
- false;
-
- if ( ( ajaxSourced && this.s.dt.iDraw == 2) ||
- (!ajaxSourced && this.s.dt.iDraw == 1) )
- {
- setTimeout( function () {
- $(that.dom.scroller).scrollTop( that.s.dt.oLoadedState.iScroller );
- that.s.redrawTop = that.s.dt.oLoadedState.iScroller - (heights.viewport/2);
-
- // In order to prevent layout thrashing we need another
- // small delay
- setTimeout( function () {
- that.s.ingnoreScroll = false;
- }, 0 );
- }, 0 );
- }
- }
- else {
- that.s.ingnoreScroll = false;
- }
-
- // Because of the order of the DT callbacks, the info update will
- // take precedence over the one we want here. So a 'thread' break is
- // needed
- setTimeout( function () {
- that._fnInfo.call( that );
- }, 0 );
-
- // Hide the loading indicator
- if ( this.dom.loader && this.s.loaderVisible ) {
- this.dom.loader.css( 'display', 'none' );
- this.s.loaderVisible = false;
- }
- },
-
-
- /**
- * Force the scrolling container to have height beyond that of just the
- * table that has been drawn so the user can scroll the whole data set.
- *
- * Note that if the calculated required scrolling height exceeds a maximum
- * value (1 million pixels - hard-coded) the forcing element will be set
- * only to that maximum value and virtual / physical domain transforms will
- * be used to allow Scroller to display tables of any number of records.
- * @returns {void}
- * @private
- */
- _fnScrollForce: function ()
- {
- var heights = this.s.heights;
- var max = 1000000;
-
- heights.virtual = heights.row * this.s.dt.fnRecordsDisplay();
- heights.scroll = heights.virtual;
-
- if ( heights.scroll > max ) {
- heights.scroll = max;
- }
-
- this.dom.force.style.height = heights.scroll+"px";
- },
-
-
- /**
- * Automatic calculation of table row height. This is just a little tricky here as using
- * initialisation DataTables has tale the table out of the document, so we need to create
- * a new table and insert it into the document, calculate the row height and then whip the
- * table out.
- * @returns {void}
- * @private
- */
- "_fnCalcRowHeight": function ()
- {
- var dt = this.s.dt;
- var origTable = dt.nTable;
- var nTable = origTable.cloneNode( false );
- var tbody = $('<tbody/>').appendTo( nTable );
- var container = $(
- '<div class="'+dt.oClasses.sWrapper+' DTS">'+
- '<div class="'+dt.oClasses.sScrollWrapper+'">'+
- '<div class="'+dt.oClasses.sScrollBody+'"></div>'+
- '</div>'+
- '</div>'
- );
-
- // Want 3 rows in the sizing table so :first-child and :last-child
- // CSS styles don't come into play - take the size of the middle row
- $('tbody tr:lt(4)', origTable).clone().appendTo( tbody );
- while( $('tr', tbody).length < 3 ) {
- tbody.append( '<tr><td> </td></tr>' );
- }
-
- $('div.'+dt.oClasses.sScrollBody, container).append( nTable );
-
- var appendTo;
- if (dt._bInitComplete) {
- appendTo = origTable.parentNode;
- } else {
- if (!this.s.dt.nHolding) {
- this.s.dt.nHolding = $( '<div></div>' ).insertBefore( this.s.dt.nTable );
- }
- appendTo = this.s.dt.nHolding;
- }
-
- container.appendTo( appendTo );
- this.s.heights.row = $('tr', tbody).eq(1).outerHeight();
- container.remove();
- },
-
-
- /**
- * Update any information elements that are controlled by the DataTable based on the scrolling
- * viewport and what rows are visible in it. This function basically acts in the same way as
- * _fnUpdateInfo in DataTables, and effectively replaces that function.
- * @returns {void}
- * @private
- */
- "_fnInfo": function ()
- {
- if ( !this.s.dt.oFeatures.bInfo )
- {
- return;
- }
-
- var
- dt = this.s.dt,
- language = dt.oLanguage,
- iScrollTop = this.dom.scroller.scrollTop,
- iStart = Math.floor( this.fnPixelsToRow(iScrollTop, false, this.s.ani)+1 ),
- iMax = dt.fnRecordsTotal(),
- iTotal = dt.fnRecordsDisplay(),
- iPossibleEnd = Math.ceil( this.fnPixelsToRow(iScrollTop+this.s.heights.viewport, false, this.s.ani) ),
- iEnd = iTotal < iPossibleEnd ? iTotal : iPossibleEnd,
- sStart = dt.fnFormatNumber( iStart ),
- sEnd = dt.fnFormatNumber( iEnd ),
- sMax = dt.fnFormatNumber( iMax ),
- sTotal = dt.fnFormatNumber( iTotal ),
- sOut;
-
- if ( dt.fnRecordsDisplay() === 0 &&
- dt.fnRecordsDisplay() == dt.fnRecordsTotal() )
- {
- /* Empty record set */
- sOut = language.sInfoEmpty+ language.sInfoPostFix;
- }
- else if ( dt.fnRecordsDisplay() === 0 )
- {
- /* Empty record set after filtering */
- sOut = language.sInfoEmpty +' '+
- language.sInfoFiltered.replace('_MAX_', sMax)+
- language.sInfoPostFix;
- }
- else if ( dt.fnRecordsDisplay() == dt.fnRecordsTotal() )
- {
- /* Normal record set */
- sOut = language.sInfo.
- replace('_START_', sStart).
- replace('_END_', sEnd).
- replace('_MAX_', sMax).
- replace('_TOTAL_', sTotal)+
- language.sInfoPostFix;
- }
- else
- {
- /* Record set after filtering */
- sOut = language.sInfo.
- replace('_START_', sStart).
- replace('_END_', sEnd).
- replace('_MAX_', sMax).
- replace('_TOTAL_', sTotal) +' '+
- language.sInfoFiltered.replace(
- '_MAX_',
- dt.fnFormatNumber(dt.fnRecordsTotal())
- )+
- language.sInfoPostFix;
- }
-
- var callback = language.fnInfoCallback;
- if ( callback ) {
- sOut = callback.call( dt.oInstance,
- dt, iStart, iEnd, iMax, iTotal, sOut
- );
- }
-
- var n = dt.aanFeatures.i;
- if ( typeof n != 'undefined' )
- {
- for ( var i=0, iLen=n.length ; i<iLen ; i++ )
- {
- $(n[i]).html( sOut );
- }
- }
- }
-};
-
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Statics
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-
-/**
- * Scroller default settings for initialisation
- * @namespace
- * @name Scroller.defaults
- * @static
- */
-Scroller.defaults = /** @lends Scroller.defaults */{
- /**
- * Indicate if Scroller show show trace information on the console or not. This can be
- * useful when debugging Scroller or if just curious as to what it is doing, but should
- * be turned off for production.
- * @type bool
- * @default false
- * @static
- * @example
- * var oTable = $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sDom": "frtiS",
- * "bDeferRender": true,
- * "oScroller": {
- * "trace": true
- * }
- * } );
- */
- "trace": false,
-
- /**
- * Scroller will attempt to automatically calculate the height of rows for it's internal
- * calculations. However the height that is used can be overridden using this parameter.
- * @type int|string
- * @default auto
- * @static
- * @example
- * var oTable = $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sDom": "frtiS",
- * "bDeferRender": true,
- * "oScroller": {
- * "rowHeight": 30
- * }
- * } );
- */
- "rowHeight": "auto",
-
- /**
- * When using server-side processing, Scroller will wait a small amount of time to allow
- * the scrolling to finish before requesting more data from the server. This prevents
- * you from DoSing your own server! The wait time can be configured by this parameter.
- * @type int
- * @default 200
- * @static
- * @example
- * var oTable = $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sDom": "frtiS",
- * "bDeferRender": true,
- * "oScroller": {
- * "serverWait": 100
- * }
- * } );
- */
- "serverWait": 200,
-
- /**
- * The display buffer is what Scroller uses to calculate how many rows it should pre-fetch
- * for scrolling. Scroller automatically adjusts DataTables' display length to pre-fetch
- * rows that will be shown in "near scrolling" (i.e. just beyond the current display area).
- * The value is based upon the number of rows that can be displayed in the viewport (i.e.
- * a value of 1), and will apply the display range to records before before and after the
- * current viewport - i.e. a factor of 3 will allow Scroller to pre-fetch 1 viewport's worth
- * of rows before the current viewport, the current viewport's rows and 1 viewport's worth
- * of rows after the current viewport. Adjusting this value can be useful for ensuring
- * smooth scrolling based on your data set.
- * @type int
- * @default 7
- * @static
- * @example
- * var oTable = $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sDom": "frtiS",
- * "bDeferRender": true,
- * "oScroller": {
- * "displayBuffer": 10
- * }
- * } );
- */
- "displayBuffer": 9,
-
- /**
- * Scroller uses the boundary scaling factor to decide when to redraw the table - which it
- * typically does before you reach the end of the currently loaded data set (in order to
- * allow the data to look continuous to a user scrolling through the data). If given as 0
- * then the table will be redrawn whenever the viewport is scrolled, while 1 would not
- * redraw the table until the currently loaded data has all been shown. You will want
- * something in the middle - the default factor of 0.5 is usually suitable.
- * @type float
- * @default 0.5
- * @static
- * @example
- * var oTable = $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sDom": "frtiS",
- * "bDeferRender": true,
- * "oScroller": {
- * "boundaryScale": 0.75
- * }
- * } );
- */
- "boundaryScale": 0.5,
-
- /**
- * Show (or not) the loading element in the background of the table. Note that you should
- * include the dataTables.scroller.css file for this to be displayed correctly.
- * @type boolean
- * @default false
- * @static
- * @example
- * var oTable = $('#example').dataTable( {
- * "sScrollY": "200px",
- * "sDom": "frtiS",
- * "bDeferRender": true,
- * "oScroller": {
- * "loadingIndicator": true
- * }
- * } );
- */
- "loadingIndicator": false
-};
-
-Scroller.oDefaults = Scroller.defaults;
-
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Constants
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-/**
- * Scroller version
- * @type String
- * @default See code
- * @name Scroller.version
- * @static
- */
-Scroller.version = "1.2.2";
-
-
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Initialisation
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-/*
- * Register a new feature with DataTables
- */
-if ( typeof $.fn.dataTable == "function" &&
- typeof $.fn.dataTableExt.fnVersionCheck == "function" &&
- $.fn.dataTableExt.fnVersionCheck('1.9.0') )
-{
- $.fn.dataTableExt.aoFeatures.push( {
- "fnInit": function( oDTSettings ) {
- var init = oDTSettings.oInit;
- var opts = init.scroller || init.oScroller || {};
- var oScroller = new Scroller( oDTSettings, opts );
- return oScroller.dom.wrapper;
- },
- "cFeature": "S",
- "sFeature": "Scroller"
- } );
-}
-else
-{
- alert( "Warning: Scroller requires DataTables 1.9.0 or greater - www.datatables.net/download");
-}
-
-
-// Attach Scroller to DataTables so it can be accessed as an 'extra'
-$.fn.dataTable.Scroller = Scroller;
-$.fn.DataTable.Scroller = Scroller;
-
-
-// DataTables 1.10 API method aliases
-if ( $.fn.dataTable.Api ) {
- var Api = $.fn.dataTable.Api;
-
- Api.register( 'scroller()', function () {
- return this;
- } );
-
- Api.register( 'scroller().rowToPixels()', function ( rowIdx, intParse, virtual ) {
- var ctx = this.context;
-
- if ( ctx.length && ctx[0].oScroller ) {
- return ctx[0].oScroller.fnRowToPixels( rowIdx, intParse, virtual );
- }
- // undefined
- } );
-
- Api.register( 'scroller().pixelsToRow()', function ( pixels, intParse, virtual ) {
- var ctx = this.context;
-
- if ( ctx.length && ctx[0].oScroller ) {
- return ctx[0].oScroller.fnPixelsToRow( pixels, intParse, virtual );
- }
- // undefined
- } );
-
- Api.register( 'scroller().scrollToRow()', function ( row, ani ) {
- this.iterator( 'table', function ( ctx ) {
- if ( ctx.oScroller ) {
- ctx.oScroller.fnScrollToRow( row, ani );
- }
- } );
-
- return this;
- } );
-
- Api.register( 'scroller().measure()', function ( redraw ) {
- this.iterator( 'table', function ( ctx ) {
- if ( ctx.oScroller ) {
- ctx.oScroller.fnMeasure( redraw );
- }
- } );
-
- return this;
- } );
-}
-
-
-return Scroller;
-}; // /factory
-
-
-// Define as an AMD module if possible
-if ( typeof define === 'function' && define.amd ) {
- define( ['jquery', 'datatables'], factory );
-}
-else if ( typeof exports === 'object' ) {
- // Node/CommonJS
- factory( require('jquery'), require('datatables') );
-}
-else if ( jQuery && !jQuery.fn.dataTable.Scroller ) {
- // Otherwise simply initialise as normal, stopping multiple evaluation
- factory( jQuery, jQuery.fn.dataTable );
-}
-
-
-})(window, document);
-
Code Review / stor4nfv.git / blobdiff