Vertical page fitting

In many web-apps and web based control panels it is often desirable to have the displayed layout and content automatically scale to fit the user's browser, allowing you to present a unified and slick interface. Responsive techniques are well developed for how to handle horizontal widths, but vertical resizing brings its own challenges.

In this post I will introduce a new plug-in for DataTables that will automatically change the page length of the table to fit within a given vertical area. The actual DataTables interface is very simple (using only the page.len() method and draw()), but knowing when to change the page length is quite interesting, so I will also discuss the technique used.

A demo using the plug-in is shown below. For the purposes of this demo I've created a resizeable box around the table that you can click and drag, resulting in the table's page length changing automatically to fit the box:

Use

Using the plug-in is very simple - include the page resizing plug-in from the DataTables CDN on your page:

Then select one of the following two options to enable this feature for your table:

Option 1: Add the pageResize option to your DataTables initialisation:

$('#example').DataTable( {
    pageResize: true
} );

Option 2: Add the class pageResize to your HTML table - e.g.:

<table id="myTable" class="display pageResize">
    <thead> ... </thead>
    <tbody> ... </tbody>
</table>

CSS

The page resize plug-in doesn't require any specific CSS, but you may wish to use CSS to hide the paging length control that DataTables displays by default:

div.dt-length {
    display: none;
}

The other option to hide the page length control is to make use of the layout option.

Additionally, in IE you will find that there is a border that simply cannot be removed using CSS. Unfortunately, the only way to address this is to use a solid colour in your wrapper element's background colour (i.e. the element that defines the height that DataTables should take up):

#myContainer {
    background-color: white;
}

Requirements

• Paging must be enabled (paging - it is by default in DataTables)
• Page length change must be enabled (lengthChange - again it is by default)
• Every row must be of equal height - add the class nowrap to your table if you are using the DataTables default stylesheet. This is to make the fitting calculation fast and efficient.
• The container element that the DataTable sits in must have a defined height that the table is to fill (the height can be flexible, e.g. vh CSS units).

How it works

The code for this plug-in is tiny - just 4K uncompressed, so you will be able to look through the code and understand how it works very quickly. As a quick run down: it calculates the hight available in the container, removes the heights for the table controls, header and footer and then works out how many rows can be shown in the space remaining based on the row height. Finally the table length is set using page.len() and drawn using draw().

The interesting part comes when we consider how the code knows when to resize. You'll notice in the demo above, a window resize isn't required to redraw the table and no API call is required to tell the component that it has resized.

As only the window object has a resize event we can't just listen for an event on the container element, but what we can do is use the object tag to create a new HTML document, insert it into the container element and then listen for its resize events! The object is setup to fit into the container, so any resize event it fires is a result of a change in size of the host node.

The code for this is also very simple:

var obj = $('<object/>')
    .css( {
        position: 'absolute',
        top: 0,
        left: 0,
        height: '100%',
        width: '100%',
        zIndex: -1
    } )
    .attr( 'type', 'text/html' )
    .attr( 'data', 'about:blank' );

obj[0].onload = function () {
    var body = this.contentDocument.body;
    var height = body.offsetHeight;

    this.contentDocument.defaultView.onresize = function () {
        var newHeight = body.offsetHeight;

        if ( newHeight !== height ) {
            height = newHeight;

            // Resize has occurred - do something!
        }
    }
};

obj.appendTo( host );

This idea is so useful that, if it proves to be a success in this plug-in, I will consider including it in DataTables core, as it would address problems such as being required to call columns.adjust() when a hidden scrolling table is made visible, updating FixedColumns manually on resize and other common gotchas.

Feedback welcome

As always, improvements and suggestions very welcome! The code for this plug-in is hosted on GitHub. If you have any thoughts on improvements, please send a pull request, or open a new discussion in the forums.

One shortcoming I'm particularly keen to address is full integration with Responsive. While Responsive will operate correctly with this plug-in enabled for the most part, child rows that are made visible will not be taken into account in the row count calculation causing vertical alignment problems. This will likely be addressed by introducing a new option to Responsive to show hidden information in a pop-up panel, rather than in a child row.