Plugins/features/pageResize/dataTables.pageResize.js

/*! © SpryMedia Ltd - datatables.net/license */

(function( factory ){
	if ( typeof define === 'function' && define.amd ) {
		// AMD
		define( ['jquery', 'datatables.net'], function ( $ ) {
			return factory( $, window, document );
		} );
	}
	else if ( typeof exports === 'object' ) {
		// CommonJS
		var jq = require('jquery');
		var cjsRequires = function (root, $) {
			if ( ! $.fn.dataTable ) {
				require('datatables.net')(root, $);
			}
		};

		if (typeof window === 'undefined') {
			module.exports = function (root, $) {
				if ( ! root ) {
					// CommonJS environments without a window global must pass a
					// root. This will give an error otherwise
					root = window;
				}

				if ( ! $ ) {
					$ = jq( root );
				}

				cjsRequires( root, $ );
				return factory( $, root, root.document );
			};
		}
		else {
			cjsRequires( window, jq );
			module.exports = factory( jq, window, window.document );
		}
	}
	else {
		// Browser
		factory( jQuery, window, document );
	}
}(function( $, window, document ) {
'use strict';
var DataTable = $.fn.dataTable;


/**
 * @summary     PageResize
 * @description Automatically alter the DataTables page length to fit the table
     into a container
 * @version     1.1.0
 * @author      SpryMedia Ltd (www.sprymedia.co.uk)
 *
 * This feature plug-in for DataTables will automatically change the DataTables
 * page length in order to fit inside its container. This can be particularly
 * useful for control panels and other interfaces which resize dynamically with
 * the user's browser window instead of scrolling.
 *
 * Page resizing in DataTables can be enabled by using any one of the following
 * options:
 *
 * * Adding the class `pageResize` to the HTML table
 * * Setting the `pageResize` parameter in the DataTables initialisation to
 *   be true - i.e. `pageResize: true`
 * * Setting the `pageResize` parameter to be true in the DataTables
 *   defaults (thus causing all tables to have this feature) - i.e.
 *   `DataTable.defaults.pageResize = true`.
 * * Creating a new instance: `new DataTable.PageResize( table );` where
 *   `table` is a DataTable's API instance.
 *
 * For more detailed information please see:
 *     http://datatables.net/blog/2015-04-10
 */
var PageResize = function (dt, pageResizeManualDelta) {
    var table = dt.table();
    this.s = {
        dt: dt,
        host: $(table.container()).parent(),
        header: $(table.header()),
        footer: $(table.footer()),
        body: $(table.body()),
        container: $(table.container()),
        table: $(table.node()),
        delta: pageResizeManualDelta,
    };
    this.sizes = {
        offsetTop: this._getOffsetTop(),
        tableHeight: this._getTableHeight(),
        containerHeight: this._getContainerHeight(),
        headerHeight: this._getHeaderHeight(),
        footerHeight: this._getFooterHeight(),
    };
    var host = this.s.host;
    if (host.css('position') === 'static') {
        host.css('position', 'relative');
    }
    var onDestroy = function () {
        dt.off('.pageResize', onDestroy);
        this.s.obj && this.s.obj.remove();
    }.bind(this);
    dt.on('destroy.pageResize', onDestroy);
    this._attach();
    // Delay the initial sizing until the table is fully initialized
    // such that the pagination element is also added and can be taken
    // into account.
    var initEvent = 'init.pageResize';
    dt.on(initEvent, function () {
        dt.off(initEvent);
        this._size();
    }.bind(this));
};
PageResize.prototype = {
    _size: function () {
        var settings = this.s;
        var dt = settings.dt;
        var t = dt.table();
        var rows = $('tr', settings.body);
        var rowHeight = rows.eq(rows.length > 1 ? 1 : 0).height(); // Attempt to use the second row if poss, for top and bottom border
        var availableHeight = settings.host.height();
        var scrolling = t.header().parentNode !== t.body().parentNode;
        var delta = settings.delta;
        var offsetTop = (this.sizes.offsetTop = this._getOffsetTop());
        var tableHeight = (this.sizes.tableHeight = this._getTableHeight());
        var containerHeight = (this.sizes.containerHeight =
            this._getContainerHeight());
        var headerHeight = (this.sizes.headerHeight = this._getHeaderHeight());
        var footerHeight = (this.sizes.footerHeight = this._getFooterHeight());
        // Subtract the height of the header, footer and the elements
        // surrounding the table
        if (!scrolling) {
            if (t.header()) {
                availableHeight -= headerHeight;
            }
            if (t.footer()) {
                availableHeight -= footerHeight;
            }
        }
        availableHeight -= offsetTop;
        availableHeight -= containerHeight - (offsetTop + tableHeight);
        if (!isNaN(parseFloat(delta)) && isFinite(delta)) {
            availableHeight -= delta;
        }
        var drawRows = Math.floor(availableHeight / rowHeight);
        if (drawRows !== Infinity &&
            drawRows !== -Infinity &&
            !isNaN(drawRows) &&
            drawRows > 0 &&
            drawRows !== dt.page.len()) {
            dt.page.len(drawRows).draw();
        }
    },
    _attach: function () {
        // There is no `resize` event for elements, so to trigger this effect,
        // create an empty HTML document using an <object> which will issue a
        // resize event inside itself when the document resizes. Since it is
        // 100% x 100% that will occur whenever the host element is resized.
        var that = this;
        var obj = $('<object/>')
            .css({
            position: 'absolute',
            top: 0,
            left: 0,
            height: '100%',
            width: '100%',
            zIndex: -1,
        })
            .attr('type', 'text/html');
        obj[0].onload = function () {
            var contentDocument = this.contentDocument;
            var body = contentDocument.body;
            var height = body.offsetHeight;
            contentDocument.defaultView.onresize = function () {
                var newHeight = body.clientHeight || body.offsetHeight;
                if (newHeight !== height) {
                    height = newHeight;
                    that._size();
                    return;
                }
                // Width changes might lead to layout changes, which might require
                // resizing the table
                if (that.sizes.offsetTop !== that._getOffsetTop() ||
                    that.sizes.containerHeight !== that._getContainerHeight() ||
                    that.sizes.tableHeight !== that._getTableHeight() ||
                    that.sizes.headerHeight !== that._getHeaderHeight() ||
                    that.sizes.footerHeight !== that._getFooterHeight()) {
                    that._size();
                    return;
                }
            };
        };
        obj.appendTo(this.s.host).attr('data', 'about:blank');
        this.s.obj = obj;
    },
    _getOffsetTop: function () {
        return $(this.s.table).offset().top;
    },
    _getTableHeight: function () {
        return this.s.table.height();
    },
    _getContainerHeight: function () {
        return this.s.container.height();
    },
    _getHeaderHeight: function () {
        return this.s.dt.table().header() ? this.s.header.height() : 0;
    },
    _getFooterHeight: function () {
        return this.s.dt.table().footer() ? this.s.footer.height() : 0;
    },
};
DataTable.PageResize = PageResize;
// Automatic initialisation listener
$(document).on('preInit.dt', function (e, settings) {
    if (e.namespace !== 'dt') {
        return;
    }
    var api = new DataTable.Api(settings);
    if ($(api.table().node()).hasClass('pageResize') ||
        settings.oInit.pageResize ||
        DataTable.defaults.pageResize) {
        new PageResize(api, settings.oInit.pageResizeManualDelta);
    }
});


return DataTable;
}));