jquery-tablesorter 1.17.1 → 1.17.2

data/vendor/assets/javascripts/jquery-tablesorter/widgets/widget-scroller.js

@@ -11,23 +11,22 @@
 
 	Resizable scroller widget for the jQuery tablesorter plugin
 
-	Version 2.0 - modified by Rob Garrison 4/12/2013; updated 3/5/2015 (v2.21.0)
+	Version 2.0 - modified by Rob Garrison 4/12/2013;
+	updated 3/5/2015 (v2.22.2) with lots of help from TheSin-
 	Requires jQuery v1.7+
 	Requires the tablesorter plugin, v2.8+, available at http://mottie.github.com/tablesorter/docs/
 
 	Usage:
-
 		$(function() {
-
 			$('table.tablesorter').tablesorter({
 				widgets: ['zebra', 'scroller'],
 				widgetOptions : {
 					scroller_height       : 300,  // height of scroll window
-					scroller_barWidth     : 18,   // scroll bar width
 					scroller_jumpToHeader : true, // header snap to browser top when scrolling the tbody
+					scroller_upAfterSort  : true, // scroll tbody to top after sorting
+					scroller_fixedColumns : 0     // set number of fixed columns
 				}
 			});
-
 		});
 
 	Website: www.tconnell.com
@@ -47,8 +46,15 @@ $.extend( ts.css, {
 	scrollerFixed       : 'tablesorter-scroller-fixed',
 	scrollerFixedPanel  : 'tablesorter-scroller-fixed-panel',
 	scrollerHasFix      : 'tablesorter-scroller-has-fixed-columns',
-	scrollerReset       : 'tablesorter-scroller-reset',
-	scrollerRtl         : 'tablesorter-scroller-rtl'
+	scrollerHideColumn  : 'tablesorter-scroller-hidden-column',
+	scrollerHideElement : 'tablesorter-scroller-hidden',
+	scrollerSpacerRow   : 'tablesorter-scroller-spacer',
+	scrollerBarSpacer   : 'tablesorter-scroller-bar-spacer',
+	scrollerAddedHeight : 'tablesorter-scroller-added-height',
+	scrollerHack        : 'tablesorter-scroller-scrollbar-hack',
+	// class name on table cannot start with 'tablesorter-' or the
+	// suffix "scroller-rtl" will match as a theme name
+	scrollerRtl         : 'ts-scroller-rtl'
 });
 
 ts.addWidget({
@@ -56,18 +62,21 @@ ts.addWidget({
 	priority : 60, // run after the filter widget
 	options : {
 		scroller_height : 300,
+		// pop table header into view while scrolling up the page
 		scroller_jumpToHeader : true,
+		// scroll tbody to top after sorting
 		scroller_upAfterSort : true,
-		// set number of columns to fix
+		// set number of fixed columns
 		scroller_fixedColumns : 0,
 		// add hover highlighting to the fixed column (disable if it causes slowing)
 		scroller_rowHighlight : 'hover',
 		// add a fixed column overlay for styling
 		scroller_addFixedOverlay : false,
-		// bar width is now calculated; set a value to override
+		// In tablesorter v2.19.0 the scroll bar width is auto-detected
+		// add a value here to override the auto-detected setting
 		scroller_barWidth : null
 	},
-	format: function( table, c, wo ) {
+	format : function( table, c, wo ) {
 		if ( !c.isScrolling ) {
 			// initialize here instead of in widget init to give the
 			// filter widget time to finish building the filter row
@@ -81,59 +90,52 @@ ts.addWidget({
 
 /* Add window resizeEnd event */
 ts.window_resize = function() {
-	if ( this.resize_timer ) {
-		clearTimeout( this.resize_timer );
+	if ( ts.timer_resize ) {
+		clearTimeout( ts.timer_resize );
 	}
-	this.resize_timer = setTimeout( function() {
-		$( this ).trigger( 'resizeEnd' );
+	ts.timer_resize = setTimeout( function() {
+		$( window ).trigger( 'resizeEnd' );
 	}, 250 );
 };
 
 // Add extra scroller css
 $( function() {
 	var style = '<style>' +
-		/* measure scroll bar width */
-		'.' + tscss.scrollerWrap + 'Measure { width: 100px; height: 100px; overflow: scroll; position: absolute; top: -9999px; }' +
-		/* reset width to get accurate measurements after window resize */
-		'.' + tscss.scrollerReset + ' { width: auto !important; min-width: auto !important; max-width: auto !important; }' +
 		/* overall wrapper & table section wrappers */
 		'.' + tscss.scrollerWrap + ' { position: relative; overflow: hidden; }' +
 		/* add border-box sizing to all scroller widget tables; see #135 */
 		'.' + tscss.scrollerWrap + ' * { box-sizing: border-box; }' +
-		'.' + tscss.scrollerHeader + ', .' + tscss.scrollerFooter + ' { overflow: hidden; }' +
+		'.' + tscss.scrollerHeader + ', .' + tscss.scrollerFooter + ' { position: relative; overflow: hidden; }' +
 		'.' + tscss.scrollerHeader + ' table.' + tscss.table + ' { margin-bottom: 0; }' +
-		'.' + tscss.scrollerFooter + ' table.' + tscss.table + ' thead { visibility: hidden, height: 0; overflow: hidden; }' +
-		/* always leave the scroll bar visible for tbody, or table overflows into the scrollbar when height < max height (filtering) */
-		'.' + tscss.scrollerTable + ' { overflow-y: scroll; }' +
-		'.' + tscss.scrollerTable + ' table.' + tscss.table + ' { border-top: 0; margin-top: 0; margin-bottom: 0; overflow-y: scroll; }' +
-		/* hide filter row in clones */
-		'.' + tscss.scrollerTable + ' .' + ( tscss.filterRow || 'tablesorter-filter-row' ) + ',.' + tscss.scrollerFooter + ' .' +
-			( tscss.filterRow || 'tablesorter-filter-row' ) + ',.' + tscss.scrollerTable + ' tfoot { display: none; }' +
-		/* visibly hide header rows in clones, so we can still set a width on it and still effect the rest of the column */
-		'.' + tscss.scrollerTable + ' table.' + tscss.table + ' thead tr.' + tscss.headerRow + ' *, .' + tscss.scrollerFooter +
-			' table.' + tscss.table + ' thead * { line-height: 0; height: 0; border: none; background-image: none; padding-top: 0;' +
-			' padding-bottom: 0; margin-top: 0; margin-bottom: 0; overflow: hidden; }' +
+		/* always leave the scroll bar visible for tbody, or table overflows into the scrollbar
+		when height < max height (filtering) */
+		'.' + tscss.scrollerTable + ' { position: relative; overflow: auto; }' +
+		'.' + tscss.scrollerTable + ' table.' + tscss.table +
+			' { border-top: 0; margin-top: 0; margin-bottom: 0; overflow: hidden; }' +
+		/* hide footer in original table */
+		'.' + tscss.scrollerTable + ' tfoot, .' + tscss.scrollerHideElement + ', .' + tscss.scrollerHideColumn +
+			' { display: none; }' +
 
 		/*** fixed column ***/
 		/* disable pointer-events on fixed column wrapper or the user can't interact with the horizontal scrollbar */
-		'.' + tscss.scrollerFixed + ', .' + tscss.scrollerFixed + ' .' + tscss.scrollerFixedPanel + ' { pointer-events: none; }' +
+		'.' + tscss.scrollerFixed + ', .' + tscss.scrollerFixed + ' .' + tscss.scrollerFixedPanel +
+			' { pointer-events: none; }' +
 		/* enable pointer-events for fixed column children; see #135 & #878 */
 		'.' + tscss.scrollerFixed + ' > div { pointer-events: all; }' +
 		'.' + tscss.scrollerWrap + ' .' + tscss.scrollerFixed + ' { position: absolute; top: 0; z-index: 1; left: 0 } ' +
 		'.' + tscss.scrollerWrap + ' .' + tscss.scrollerFixed + '.' + tscss.scrollerRtl + ' { left: auto; right: 0 } ' +
 		/* add horizontal scroll bar; set to "auto", see #135 */
-		'.' + tscss.scrollerWrap + '.' + tscss.scrollerHasFix + ' > .' + tscss.scrollerTable + ' { overflow-x: auto; }' +
-		/* need to position the tbody & tfoot absolutely to hide the scrollbar & move the footer below the horizontal scrollbar */
+		'.' + tscss.scrollerWrap + '.' + tscss.scrollerHasFix + ' > .' + tscss.scrollerTable + ' { overflow: auto; }' +
+		/* need to position the tbody & tfoot absolutely to hide the scrollbar & move the footer
+		below the horizontal scrollbar */
 		'.' + tscss.scrollerFixed + ' .' + tscss.scrollerFooter + ' { position: absolute; bottom: 0; }' +
-		/* hide fixed tbody scrollbar - see http://goo.gl/VsLe6n */
-		'.' + tscss.scrollerFixed + ' .' + tscss.scrollerTable + ' { position: relative; left: 0; overflow-x: hidden; overflow-y: scroll; -ms-overflow-style: none; }' +
+		/* hide fixed tbody scrollbar - see http://goo.gl/VsLe6n - set overflow to auto here for mousewheel scroll */
+		'.' + tscss.scrollerFixed + ' .' + tscss.scrollerTable +
+			' { position: relative; left: 0; overflow: auto; -ms-overflow-style: none; }' +
 		'.' + tscss.scrollerFixed + ' .' + tscss.scrollerTable + '::-webkit-scrollbar { display: none; }' +
-		/* remove right border of fixed header tables to hide the boundary */
-		'.' + tscss.scrollerWrap + ' .' + tscss.scrollerFixed + ' table { border-right-color: transparent; padding-right: 0; }' +
-		'.' + tscss.scrollerWrap + ' .' + tscss.scrollerFixed + '.' + tscss.scrollerRtl + ' table { border-left-color: transparent; padding-left: 0; }' +
-
 		/*** fixed column panel ***/
-		'.' + tscss.scrollerWrap + ' .' + tscss.scrollerFixedPanel + ' { position: absolute; top: 0; bottom: 0; z-index: 2; left: 0; right: 0; } ' +
+		'.' + tscss.scrollerWrap + ' .' + tscss.scrollerFixedPanel +
+			' { position: absolute; top: 0; bottom: 0; z-index: 2; left: 0; right: 0; } ' +
 		'</style>';
 	$( style ).appendTo( 'body' );
 });
@@ -144,9 +146,18 @@ ts.scroller = {
 	isFirefox : navigator.userAgent.toLowerCase().indexOf( 'firefox' ) > -1,
 	// old IE needs a wrap to hide the fixed column scrollbar; http://stackoverflow.com/a/24408672/145346
 	isOldIE : document.all && !window.atob,
-
-	hasScrollBar : function( $target ) {
-		return $target.get(0).scrollHeight > $target.height();
+	isIE : ( document.all && !window.atob ) || navigator.appVersion.indexOf( 'Trident/' ) > 0,
+	// http://stackoverflow.com/questions/7944460/detect-safari-browser - needed to position scrolling body
+	// when the table is set up in RTL direction
+	isSafari : navigator.userAgent.toLowerCase().indexOf( 'safari' ) > -1 &&
+		navigator.userAgent.toLowerCase().indexOf( 'chrome' ) === -1,
+
+	hasScrollBar : function( $target, checkWidth ) {
+		if ( checkWidth ) {
+			return $target.get(0).scrollWidth > $target.width();
+		} else {
+			return $target.get(0).scrollHeight > $target.height();
+		}
 	},
 
 	setWidth : function( $el, width ) {
@@ -159,39 +170,56 @@ ts.scroller = {
 
 	// modified from http://davidwalsh.name/detect-scrollbar-width
 	getBarWidth : function() {
-		var $scrollDiv = $( '<div class="' + tscss.scrollerWrap + 'Measure">' ).appendTo( 'body' ),
-			div = $scrollDiv[ 0 ],
-			barWidth = div.offsetWidth - div.clientWidth;
-		$scrollDiv.remove();
+		var $div = $( '<div>' ).css({
+			'position' : 'absolute',
+			'top' : '-9999px',
+			'left' : 0,
+			'width' : '100px',
+			'height' : '100px',
+			'overflow' : 'scroll',
+			'visibility' : 'hidden'
+		}).appendTo( 'body' ),
+		div = $div[0],
+		barWidth = div.offsetWidth - div.clientWidth;
+		$div.remove();
 		return barWidth;
 	},
 
 	setup : function( c, wo ) {
-		var maxHt, tbHt, $hdr, $t, $hCells, $fCells, $tableWrap,
+		var maxHt, tbHt, $hdr, $t, $hCells, $fCells, $tableWrap, events, tmp,
 			$win = $( window ),
+			tsScroller = ts.scroller,
 			namespace = c.namespace + 'tsscroller',
 			$foot = $(),
 			// c.namespace contains a unique tablesorter ID, per table
 			id = c.namespace.slice( 1 ) + 'tsscroller',
 			$table = c.$table;
 
-		// force developer to set fixedWidth to maintain column widths
+		// force config.widthFixed option - this helps maintain proper alignment across cloned tables
 		c.widthFixed = true;
+
+		wo.scroller_calcWidths = [];
+		wo.scroller_saved = [ 0, 0 ];
+		wo.scroller_isBusy = true;
+
+		// set scrollbar width & allow setting width to zero
+		wo.scroller_barSetWidth = wo.scroller_barWidth !== null ?
+			wo.scroller_barWidth :
+			( tsScroller.getBarWidth() || 15 );
+
 		maxHt = wo.scroller_height || 300;
-		tbHt = $table.children( 'tbody' ).height();
-		if ( tbHt !== 0 && maxHt > tbHt ) { maxHt = tbHt + 10; }  // Table is less than h px
 
-		wo.scroller_$header = $hdr = $( '<table class="' + $table.attr( 'class' ) + '" cellpadding=0 cellspacing=0>' +
-			$table.children( 'thead' )[0].outerHTML +
-			'</table>' )
-			.addClass( c.namespace.slice(1) + '_extra_table' );
+		$hdr = $( '<table class="' + $table.attr( 'class' ) + '" cellpadding=0 cellspacing=0>' +
+			$table.children( 'thead' )[ 0 ].outerHTML + '</table>' );
+		wo.scroller_$header = $hdr.addClass( c.namespace.slice( 1 ) + '_extra_table' );
 
 		$t = $table.children( 'tfoot' );
 		if ( $t.length ) {
-			$foot = $( '<table class="' + $table.attr('class') + '" cellpadding=0 cellspacing=0 style="margin-top:0"></table>' )
-				.addClass( c.namespace.slice(1) + '_extra_table' )
-				.append( $t.clone( true ) ) // maintain any bindings on the tfoot cells
-				.append( $table.children( 'thead' )[ 0 ].outerHTML )
+			$foot = $( '<table class="' + $table.attr( 'class' ) +
+				'" cellpadding=0 cellspacing=0 style="margin-top:0"></table>' )
+				.addClass( c.namespace.slice( 1 ) + '_extra_table' )
+				// maintain any bindings on the tfoot cells
+				.append( $t.clone( true ) )
 				.wrap( '<div class="' + tscss.scrollerFooter + '"/>' );
 			$fCells = $foot.children( 'tfoot' ).eq( 0 ).children( 'tr' ).children();
 		}
@@ -201,7 +229,8 @@ ts.scroller = {
 			.wrap( '<div id="' + id + '" class="' + tscss.scrollerWrap + '" />' )
 			.before( $hdr )
 			// shrink filter row but don't completely hide it because the inputs/selectors may distort the columns
-			.find( '.' + tscss.filterRow ).addClass( tscss.filterRowHide );
+			.find( '.' + tscss.filterRow )
+			.addClass( tscss.filterRowHide );
 
 		wo.scroller_$container = $table.parent();
 
@@ -223,19 +252,12 @@ ts.scroller = {
 
 		// look for filter widget
 		if ( $table.hasClass( 'hasFilters' ) ) {
-			ts.filter.bindSearch( $table, $hdr.find('.' + tscss.filter) );
-		}
-
-		// remove any previous fixed columns ( in case we're updating )
-		wo.scroller_$container.find( '.' + tscss.scrollerFixed ).remove();
-
-		if ( wo.scroller_fixedColumns > 0 ) {
-			ts.scroller.setupFixed( c, wo );
+			ts.filter.bindSearch( $table, $hdr.find( '.' + tscss.filter ) );
 		}
 
-		ts.scroller.resize( c, wo );
-
-		$table.find( 'thead' ).css( 'visibility', 'hidden' );
+		$table
+			.find( 'thead' )
+			.addClass( tscss.scrollerHideElement );
 
 		tbHt = $tableWrap.parent().height();
 
@@ -249,33 +271,60 @@ ts.scroller = {
 						$win.scrollTop( $hdr.offset().top );
 					}
 				}
-				$hdr.parent().add( $foot.parent() ).scrollLeft( $( this ).scrollLeft() );
+				$hdr
+					.parent()
+					.add( $foot.parent() )
+					.scrollLeft( $( this ).scrollLeft() );
 			});
 
-		// Sorting, so scroll to top
+		// resize/update events
+		events = ( ( ts.hasWidget( c.table, 'filter' ) ? 'filterEnd' : 'tablesorter-initialized' ) +
+				' updateComplete pagerComplete columnUpdate ' ).split( ' ' ).join( namespace + ' ' );
+
 		$table
-			.off( 'sortEnd setFixedColumnSize updateComplete '.split( ' ' ).join( namespace + ' ' ) )
-			.on( 'sortEnd' + namespace, function() {
-				if ( wo.scroller_upAfterSort ) {
-					$table.parent().animate({ scrollTop: 0 }, 'fast' );
+			.off( namespace )
+			.on( 'sortEnd filterEnd'.split( ' ' ).join( namespace + ' ' ), function( event ) {
+				// Sorting, so scroll to top
+				if ( event.type === 'sortEnd' && wo.scroller_upAfterSort ) {
+					$tableWrap.animate({
+						scrollTop : 0
+					}, 'fast' );
+				} else if ( wo.scroller_fixedColumns ) {
+					setTimeout( function() {
+						// restore previous scroll position
+						$tableWrap
+							.scrollTop( wo.scroller_saved[1] )
+							.scrollLeft( wo.scroller_saved[0] );
+						tsScroller.updateFixed( c, wo, false );
+					}, 0 );
 				}
 			})
 			.on( 'setFixedColumnSize' + namespace, function( event, size ) {
+				var $wrap = wo.scroller_$container;
 				if ( typeof size !== 'undefined' && !isNaN( size ) ) {
 					wo.scroller_fixedColumns = parseInt( size, 10 );
 				}
 				// remove fixed columns
-				wo.scroller_$container.find( '.' + tscss.scrollerFixed ).remove();
+				tsScroller.removeFixed( c, wo );
 				size = wo.scroller_fixedColumns;
 				if ( size > 0 && size < c.columns - 1 ) {
-					ts.scroller.setupFixed( c, wo );
-				} else {
-					wo.scroller_$container.removeClass( tscss.scrollerHasFix );
+					tsScroller.updateFixed( c, wo );
+				} else if ( $wrap.hasClass( tscss.scrollerHasFix ) ) {
+					$wrap.removeClass( tscss.scrollerHasFix );
+					// resize needed to make tables full width
+					tsScroller.resize( c, wo );
 				}
 			})
-			.on( 'updateComplete' + namespace, function() {
+			.on( events, function( event ) {
+				// Stop from running twice with pager
+				if ( ts.hasWidget( 'pager' ) && event.type === 'updateComplete' ) {
+					return;
+				}
+				if ( wo.scroller_fixedColumns > 0 ) {
+					tsScroller.updateFixed( c, wo, false );
+				}
 				// adjust column sizes after an update
-				ts.scroller.resize( c, wo );
+				tsScroller.resize( c, wo );
 			});
 
 		// Setup window.resizeEnd event
@@ -286,110 +335,128 @@ ts.scroller = {
 				// IE calls resize when you modify content, so we have to unbind the resize event
 				// so we don't end up with an infinite loop. we can rebind after we're done.
 				$win.off( 'resize' + namespace, ts.window_resize );
-				ts.scroller.resize( c, wo );
+				tsScroller.resize( c, wo );
 				$win.on( 'resize' + namespace, ts.window_resize );
+				$tableWrap.trigger( 'scroll' + namespace );
 			});
 
 		// initialization flag
 		c.isScrolling = true;
 
+		tsScroller.updateFixed( c, wo );
+
 	},
 
 	resize : function( c, wo ) {
-		var index, borderWidth, setWidth, $hCells, $bCells, $fCells, $headers, $this,
+		if ( wo.scroller_isBusy ) { return; }
+		var index, borderWidth, setWidth, $hCells, $bCells, $fCells, $headers, $this, temp,
+			tsScroller = ts.scroller,
+			$container = wo.scroller_$container,
 			$table = c.$table,
 			$tableWrap = $table.parent(),
 			$hdr = wo.scroller_$header,
 			$foot = wo.scroller_$footer,
 			id = c.namespace.slice( 1 ) + 'tsscroller',
 			// Hide other scrollers so we can resize
-			$div = $( 'div.' + tscss.scrollerWrap + '[id != "' + id + '"]' ).hide();
+			$div = $( 'div.' + tscss.scrollerWrap + '[id!="' + id + '"]' )
+				.addClass( tscss.scrollerHideElement ),
+			row = '<tr class="' + tscss.scrollerSpacerRow + ' ' + c.selectorRemove.slice(1) + '">';
 
-		$table.children( 'thead' ).show();
-		// only remove colgroup if it was added by the plugin
-		// the $.tablesorter.fixColumnWidth() function already does this (v2.19.0)
-		// but we need to get "accurate" resized measurements here - see issue #680
-		$table.add( $hdr ).add( $foot ).children( 'colgroup' ).remove();
+		wo.scroller_calcWidths = [];
 
-		// Reset sizes so parent can resize.
+		// Remove fixed so we get proper widths and heights
+		tsScroller.removeFixed( c, wo );
+		$container.find( '.' + tscss.scrollerSpacerRow ).remove();
+		// remove ts added colgroups
+		$container.find( '.' + ts.css.colgroup ).remove();
+
+		// show original table elements to get proper alignment
 		$table
-			.addClass( tscss.scrollerReset )
-			.children( 'thead' )
-			.find( '.' + tscss.headerIn ).addClass( tscss.scrollerReset ).end()
-			.find( '.' + tscss.filterRow ).show();
-		$tableWrap.addClass( tscss.scrollerReset );
+			.find( '.' + tscss.scrollerHideElement )
+			.removeClass( tscss.scrollerHideElement );
 
 		// include left & right border widths
 		borderWidth = parseInt( $table.css( 'border-left-width' ), 10 );
 
-		// Shrink a bit to accommodate scrollbar
-		wo.scroller_barSetWidth = ( wo.scroller_barWidth || ts.scroller.getBarWidth() || 18 ) + borderWidth;
+		$headers = c.$headerIndexed;
 
-		$tableWrap.width( $tableWrap.parent().innerWidth() - ( ts.scroller.hasScrollBar( $tableWrap.parent() ) ? wo.scroller_barSetWidth : 0 ) );
-		setWidth = $tableWrap.innerWidth() - ( ts.scroller.hasScrollBar( $tableWrap ) ? wo.scroller_barSetWidth : 0 ) + borderWidth;
-		$hdr.parent().add( $foot.parent() ).width( setWidth );
-
-		$hCells = $hdr.children( 'thead' ).children().children( 'th, td' ).filter( ':visible' );
-		$bCells = $table.children('tbody').eq( 0 ).children().eq( 0 ).children( 'th, td' ).filter( ':visible' );
-		$fCells = $foot.children( 'tfoot' ).children().children( 'th, td' ).filter( ':visible' );
-
-		ts.scroller.setWidth( $hCells.add( $bCells ).add( $fCells ), '' );
-		$headers = $table.children( 'thead' ).children().eq( 0 ).children( 'th, td' );
-		for ( index = 0; index < $headers.length; index++ ) {
-			$this = $headers.eq( index );
+		for ( index = 0; index < c.columns; index++ ) {
+			$this = $headers[ index ];
 			// code from https://github.com/jmosbech/StickyTableHeaders
 			if ( $this.css( 'box-sizing' ) === 'border-box' ) {
 				setWidth = $this.outerWidth();
 			} else {
 				if ( $hCells.eq( index ).css( 'border-collapse' ) === 'collapse' ) {
 					if ( $this.length && window.getComputedStyle ) {
-						setWidth = parseFloat( window.getComputedStyle( $this[0], null ).width );
+						setWidth = parseFloat( window.getComputedStyle( $this[ 0 ], null ).width );
 					} else {
 						// ie8 only
-						borderWidth = parseFloat( $this.css( 'border-width' ) ) || 0;
-						setWidth = $this.outerWidth() - parseFloat( $this.css( 'padding-left' ) ) - parseFloat( $this.css( 'padding-right' ) ) - borderWidth;
+						setWidth = $this.outerWidth() - parseFloat( $this.css( 'padding-left' ) ) -
+							parseFloat( $this.css( 'padding-right' ) ) -
+							( parseFloat( $this.css( 'border-width' ) ) || 0 );
 					}
 				} else {
 					setWidth = $this.width();
 				}
 			}
-			ts.scroller.setWidth( $hCells.eq( index ).add( $bCells.eq( index ) ).add( $fCells.eq( index ) ), setWidth );
-		}
+			row += '<td data-column="' + index + '" style="padding:0;margin:0;border:0;height:0;max-height:0;' +
+				'min-height:0;width:' + setWidth + 'px;min-width:' + setWidth + 'px;max-width:' + setWidth + 'px"></td>';
 
-		wo.scroller_$container
-			.find( '.' + tscss.scrollerReset )
-			.removeClass( tscss.scrollerReset );
+			// save current widths
+			wo.scroller_calcWidths[ index ] = setWidth;
+		}
+		row += '</tr>';
+		c.$tbodies.eq(0).prepend( row ); // tbody
+		$hdr.children( 'thead' ).append( row );
+		$foot.children( 'tfoot' ).append( row );
 
-		// refresh colgroup & copy to cloned header
+		// include colgroup or alignment is off
 		ts.fixColumnWidth( c.table );
+		row = c.$table.children( 'colgroup' )[0].outerHTML;
+		$hdr.prepend( row );
+		$foot.prepend( row );
 
-		// add colgroup to all clones
-		$hCells = $table.children( 'colgroup' );
-		if ( $hCells.length ) {
-			$bCells = $hCells[0].outerHTML;
-			$hdr.prepend( $bCells );
-			if ( $foot.length ) {
-				$foot.prepend( $bCells );
-			}
-		}
+		temp = $tableWrap.parent().innerWidth() -
+			( tsScroller.hasScrollBar( $tableWrap ) ? wo.scroller_barSetWidth : 0 );
+		$tableWrap.width( temp );
+
+		temp = ( tsScroller.hasScrollBar( $tableWrap ) ? wo.scroller_barSetWidth : 0 ) + borderWidth;
+		setWidth = $tableWrap.innerWidth() - temp;
+
+		$hdr
+			.parent()
+			.add( $foot.parent() )
+			.width( setWidth );
+
+		$tableWrap
+			.width( setWidth + temp );
+
+		// hide original table thead
+		$table.children( 'thead' ).addClass( tscss.scrollerHideElement );
 
 		// update fixed column sizes
-		if ( wo.scroller_fixedColumns > 0 ) {
-			ts.scroller.updateFixed( c, wo, true );
-		}
+		tsScroller.updateFixed( c, wo );
 
-		// hide filter row because filterEnd event fires
-		$table.children( 'thead' ).find( '.' + tscss.filterRow ).hide();
+		$div.removeClass( tscss.scrollerHideElement );
+
+		// restore scrollTop - fixes #926
+		$tableWrap.scrollTop( wo.scroller_saved[1] );
+		wo.scroller_$container
+			.find( '.' + tscss.scrollerFixed )
+			.find( '.' + tscss.scrollerTable )
+			.scrollTop( wo.scroller_saved[1] );
 
-		$div.show();
+		// update resizable widget handles
+		setTimeout( function() {
+			c.$table.trigger( 'resizableUpdate' );
+		}, 100 );
 
 	},
 
-	// Add fixed (frozen) columns
+	// Add fixed (frozen) columns (Do not call directly, use updateFixed)
 	setupFixed : function( c, wo ) {
-		var index, index2, $el, len, temp, $fixedColumn, $fixedTbody, $fixedContainer,
+		var index, index2, $el, len, temp, $fixedColumn, $fixedTbody,
 			$table = c.$table,
-			namespace = c.namespace + 'tsscrollerFixed',
 			$wrapper = wo.scroller_$container,
 			fixedColumns = wo.scroller_fixedColumns;
 
@@ -399,14 +466,18 @@ ts.scroller = {
 			.addClass( tscss.scrollerFixed )
 			.removeClass( tscss.scrollerWrap )
 			.attr( 'id', '' );
+
 		if ( wo.scroller_addFixedOverlay ) {
 			$fixedColumn.append( '<div class="' + tscss.scrollerFixedPanel + '">' );
 		}
+
 		$fixedTbody = $fixedColumn.find( '.' + tscss.scrollerTable );
-		$fixedTbody.find( 'table' )
-			.addClass( c.namespace.slice(1) + '_extra_table' )
-			.attr( 'id', '' );
-		$fixedContainer = $fixedTbody.find( 'tbody' );
+		$fixedTbody
+			.children( 'table' )
+			.addClass( c.namespace.slice( 1 ) + '_extra_table' )
+			.attr( 'id', '' )
+			.children( 'thead, tfoot' )
+			.remove();
 
 		wo.scroller_$fixedColumns = $fixedColumn;
 
@@ -420,13 +491,22 @@ ts.scroller = {
 		for ( index = 0; index < len; index++ ) {
 			$el.eq( index ).children( ':gt(' + ( fixedColumns - 1 ) + ')' ).remove();
 		}
-		$fixedColumn.hide().prependTo( $wrapper );
+		$fixedColumn
+			.addClass( tscss.scrollerHideElement )
+			.prependTo( $wrapper );
 
 		// look for filter widget
 		if ( c.$table.hasClass( 'hasFilters' ) ) {
+			// make sure fixed column filters aren't disabled
+			$el = $fixedColumn
+				.find( '.' + tscss.filter )
+				.not( '.' + tscss.filterDisabled )
+				.prop( 'disabled', false );
 			ts.filter.bindSearch( $table, $fixedColumn.find( '.' + tscss.filter ) );
 			// disable/enable filters behind fixed column
-			$el = $wrapper.children( '.' + tscss.scrollerHeader ).find( '.' + tscss.filter );
+			$el = $wrapper
+				.children( '.' + tscss.scrollerHeader )
+				.find( '.' + tscss.filter );
 			len = $el.length;
 			for ( index = 0; index < len; index++ ) {
 				// previously disabled filter; don't mess with it! filterDisabled class added by filter widget
@@ -441,10 +521,14 @@ ts.scroller = {
 		c.$table
 			.add( '.' + tscss.scrollerFooter + ' table' )
 			.children( 'thead' )
-			.children( 'tr.' + tscss.headerRow ).children().attr( 'tabindex', -1 );
+			.children( 'tr.' + tscss.headerRow )
+			.children()
+			.attr( 'tabindex', -1 );
+
 		$el = wo.scroller_$header
 			.add( $fixedColumn.find( '.' + tscss.scrollerTable + ' table' ) )
-			.children( 'thead' ).children( 'tr.' + tscss.headerRow );
+			.children( 'thead' )
+			.children( 'tr.' + tscss.headerRow );
 		len = $el.length;
 		for ( index = 0; index < len; index++ ) {
 			temp = $el.eq( index ).children();
@@ -454,179 +538,363 @@ ts.scroller = {
 		}
 
 		ts.bindEvents( c.table, $fixedColumn.find( '.' + tscss.header ) );
+		ts.scroller.bindFixedColumnEvents( c, wo );
+
+		/*** Scrollbar hack! Since we can't hide the scrollbar with css ***/
+		if ( ts.scroller.isFirefox || ts.scroller.isOldIE ) {
+			$fixedTbody.wrap( '<div class="' + tscss.scrollerHack + '" style="overflow:hidden;">' );
+		}
+
+	},
 
+	bindFixedColumnEvents : function( c, wo ) {
 		// update thead & tbody in fixed column
-		temp = ( 'tablesorter-initialized sortEnd filterEnd ' ).split( ' ' ).join( namespace + ' ' );
+		var tsScroller = ts.scroller,
+			namespace = c.namespace + 'tsscrollerFixed',
+			events = 'scroll' + namespace,
+			$fixedTbody = wo.scroller_$fixedColumns.find( '.' + tscss.scrollerTable ),
+			fixedScroll = true,
+			tableScroll = true;
+
 		c.$table
-			.off( temp )
-			.on( temp, function( event, size ) {
-				ts.scroller.updateFixed( c, wo, false );
-			})
 			.parent()
 			// *** SCROLL *** scroll fixed column along with main
-			.off( 'scroll' + namespace )
-			.on( 'scroll' + namespace, function() {
-				$fixedTbody.scrollTop( $( this ).scrollTop() );
+			.off( events )
+			.on( events, function() {
+				if ( wo.scroller_isBusy ) { return; }
+				// using flags to prevent firing the scroll event excessively leading to slow scrolling in Firefox
+				if ( !wo.scroller_isBusy && ( fixedScroll || !( tsScroller.isFirefox || tsScroller.isIE ) ) ) {
+					tableScroll = false;
+					var $this = $( this );
+					$fixedTbody[0].scrollTop = wo.scroller_saved[1] = $this.scrollTop();
+					wo.scroller_saved[0] = $this.scrollLeft();
+					setTimeout( function() {
+						tableScroll = true;
+					}, 20 );
+				}
 			});
 		// scroll main along with fixed column
 		$fixedTbody
-			.off( 'scroll' + namespace )
-			.on( 'scroll' + namespace, function() {
-				c.$table.parent().scrollTop( $fixedTbody.scrollTop() );
+			.off( events )
+			.on( events, function() {
+				// using flags to prevent firing the scroll event excessively leading to slow scrolling in Firefox
+				if ( !wo.scroller_isBusy && ( tableScroll || !( tsScroller.isFirefox || tsScroller.isIE ) ) ) {
+					fixedScroll = false;
+					var $this = $( this );
+					c.$table.parent()[0].scrollTop = wo.scroller_saved[1] = $this.scrollTop();
+					setTimeout( function() {
+						fixedScroll = true;
+					}, 20 );
+				}
 			})
 			.scroll();
 
 		// *** ROW HIGHLIGHT ***
 		if ( wo.scroller_rowHighlight !== '' ) {
-			temp = 'mouseover mouseleave '.split( ' ' ).join( namespace + ' ' );
+			events = 'mouseover mouseleave '.split( ' ' ).join( namespace + ' ' );
+			// can't use c.$tbodies because it doesn't include info-only tbodies
 			c.$table
-				.off( temp, 'tr' )
-				.on( temp, 'tr', function( event ) {
-					var indx = $( this ).index();
-					$fixedContainer.children().eq( indx )
+				.off( events, 'tbody > tr' )
+				.on( events, 'tbody > tr', function( event ) {
+					var indx = c.$table.children( 'tbody' ).children( 'tr' ).index( this );
+					$fixedTbody
+						.children( 'table' )
+						.children( 'tbody' )
+						.children( 'tr' )
+						.eq( indx )
 						.add( this )
 						.toggleClass( wo.scroller_rowHighlight, event.type === 'mouseover' );
 				});
-			$fixedTbody.find( 'table' )
-				.off( temp, 'tr' )
-				.on( temp, 'tr', function( event ) {
-					var indx = $( this ).index();
-					c.$tbodies.children().eq( indx )
+			$fixedTbody
+				.find( 'table' )
+				.off( events, 'tbody > tr' )
+				.on( events, 'tbody > tr', function( event ) {
+					var $fixed = $fixedTbody.children( 'table' ).children( 'tbody' ).children( 'tr' ),
+						indx = $fixed.index( this );
+					c.$table
+						.children( 'tbody' )
+						.children( 'tr' )
+						.eq( indx )
 						.add( this )
 						.toggleClass( wo.scroller_rowHighlight, event.type === 'mouseover' );
 				});
 		}
+	},
 
-		/*** Scrollbar hack! Since we can't hide the scrollbar with css ***/
-		if ( ts.scroller.isFirefox || ts.scroller.isOldIE ) {
-			$fixedTbody.wrap( '<div class="scroller-scrollbar-hack" style="overflow:hidden;">' );
-		}
-
-		ts.scroller.updateFixed( c, wo, true );
+	adjustWidth : function( c, wo, totalWidth, adj, dir ) {
+		var $wrapper = wo.scroller_$container;
 
+		// RTL support (fixes column on right)
+		$wrapper
+			.children( '.' + tscss.scrollerTable )
+			.css( dir ? 'right' : 'left', totalWidth );
+		$wrapper
+			.children( '.' + tscss.scrollerHeader + ', .' + tscss.scrollerFooter )
+			// Safari needs a scrollbar width of extra adjusment to align the fixed & scrolling columns
+			.css( dir ? 'right' : 'left', totalWidth + ( dir && ts.scroller.isSafari ? adj : 0 ) );
 	},
 
 	updateFixed : function( c, wo ) {
-		if ( !c.isScrolling ) { return; }
+		var temp, adj,
+			$wrapper = wo.scroller_$container,
+			$hdr = wo.scroller_$header,
+			$foot = wo.scroller_$footer,
+			$table = c.$table,
+			$tableWrap = $table.parent(),
+			scrollBarWidth = wo.scroller_barSetWidth,
+			dir = $table.hasClass( tscss.scrollerRtl );
+
+		if ( wo.scroller_fixedColumns === 0 ) {
+			wo.scroller_isBusy = false;
+			ts.scroller.removeFixed( c, wo );
+			temp = $wrapper.width();
+			$tableWrap.width( temp );
+			adj = ts.scroller.hasScrollBar( $tableWrap ) ? scrollBarWidth : 0;
+			$hdr
+				.parent()
+				.add( $foot.parent() )
+				.width( temp - adj );
+			return;
+		}
+
+		if ( !c.isScrolling ) {
+			return;
+		}
+
+		wo.scroller_isBusy = true;
 
-		// no idea why this happens, but sometimes the main table wrapper gets the scrollbar width
-		// subtracted from it on load and on theme change - it can be very sporatic; this fixes it.
-		c.$table.parent().width( wo.scroller_$container.width() );
+		// Make sure the wo.scroller_$fixedColumns container exists, if not build it
+		if ( !$wrapper.find( '.' + tscss.scrollerFixed ).length ) {
+			ts.scroller.setupFixed( c, wo );
+		}
 
 		// scroller_fixedColumns
-		var index, tbodyIndex, rowIndex, $tbody, $adjCol, $fb, totalRows, widths,
-			$table = c.$table,
-			$wrapper = wo.scroller_$container,
+		var index, tbodyIndex, rowIndex, $tbody, $adjCol, $fb, $fixHead, $fixBody, $fixFoot,
+			totalRows, row,
 
 			// source cells for measurement
-			$mainTbodies = wo.scroller_$container.children( '.' + tscss.scrollerTable ).children( 'table' ).children( 'tbody' ),
-			$rows =  wo.scroller_$header.children( 'thead' ).children( '.' + tscss.headerRow ), // variable gets redefined
+			$mainTbodies = wo.scroller_$container
+				.children( '.' + tscss.scrollerTable )
+				.children( 'table' )
+				.children( 'tbody' ),
+			// variable gets redefined
+			$rows = wo.scroller_$header
+				.children( 'thead' )
+				.children( '.' + tscss.headerRow ),
 
 			// hide fixed column during resize, or we get a FOUC
-			$fixedColumn = wo.scroller_$fixedColumns.hide(),
+			$fixedColumn = wo.scroller_$fixedColumns
+				.addClass( tscss.scrollerHideElement ),
 
 			// target cells
-			$fixedTbodiesTable = $fixedColumn.find( '.' + tscss.scrollerTable ).children( 'table' ),
-			$fixedTbodies = $fixedTbodiesTable.children( 'tbody' ),
-			$fixedHeader = $fixedColumn.find( '.' + tscss.scrollerHeader ).children( 'table' ).children( 'thead' ),
+			$fixedTbodiesTable = $fixedColumn
+				.find( '.' + tscss.scrollerTable )
+				.children( 'table' ),
+			$fixedTbodies = $fixedTbodiesTable
+				.children( 'tbody' ),
 			// variables
 			tsScroller = ts.scroller,
-			scrollBarWidth = wo.scroller_barSetWidth,
 			fixedColumns = wo.scroller_fixedColumns,
 			// get dimensions
 			$temp = $table.find( 'tbody td' ),
 			borderRightWidth = parseInt( $temp.css( 'border-right-width' ), 10 ) || 1,
-			borderBottomWidth = parseInt( $temp.css( 'border-bottom-width' ), 10 ) || 1,
-			borderSpacing = parseInt( $temp.css( 'border-spacing' ).split( /\s/ )[ 0 ], 10 ) / 2 || 0,
-			totalWidth = parseInt( $table.css( 'padding-left' ), 10 ) +  parseInt( $table.css( 'padding-right' ), 10 ) - borderRightWidth;
-
-		// fixed header cell height
-		$temp = $fixedHeader.children( '.' + tscss.headerRow );
-		for ( index = 0; index < $temp.length; index++ ) {
-			$temp.eq( index ).height( $rows.eq( index ).outerHeight() );
-		}
+			borderSpacing = parseInt( ( $temp.css( 'border-spacing' ) || '' ).split( /\s/ )[ 0 ], 10 ) / 2 || 0,
+			totalWidth = parseInt( $table.css( 'padding-left' ), 10 ) +
+				parseInt( $table.css( 'padding-right' ), 10 ) -
+				borderRightWidth,
+			widths = wo.scroller_calcWidths;
 
-		// body cell dimensions seem to be more accurate *shrug*
-		$rows = ( c.filteredRows > 0 ? c.$tbodies : $table.children( 'thead' ) ).children( 'tr:visible' );
-		// recalculate widths
-		widths = $rows.children( ':lt(' + fixedColumns + ')' ).map( function() {
-			totalWidth += $( this ).outerWidth() + borderSpacing;
-			return $( this ).outerWidth();
-		}).get();
-
-		// set fixed column width
-		tsScroller.setWidth( $fixedColumn.add( $fixedColumn.children() ), totalWidth + borderRightWidth * 2 - borderSpacing );
-		tsScroller.setWidth( $fixedColumn.find( 'table' ), totalWidth + borderRightWidth );
-
-		// set fixed column height ( changes with filtering )
-		$fixedColumn.height( $wrapper.height() );
+		ts.scroller.removeFixed( c, wo, false );
 
-		if ( wo.scroller_$footer.length ) {
-			// adjust footer row heights (text could wrap on resize)
-			$temp = $wrapper.children( '.' + tscss.scrollerFooter ).find( 'tfoot tr' );
-			$rows = $fixedColumn.find( '.' + tscss.scrollerFooter + ' tfoot tr' );
-			for ( index = 0; index < $rows.length; index++ ) {
-				$rows.eq( index ).height( $temp.eq( index ).height() );
-			}
+		// calculate fixed column width
+		for ( index = 0; index < fixedColumns; index++ ) {
+			totalWidth += widths[ index ] + borderSpacing;
 		}
-		// leave a gap under the tbody for the horizontal scrollbar
-		$fixedColumn.find( '.' + tscss.scrollerTable )
-			.height( $table.parent().height() - scrollBarWidth + borderBottomWidth );
 
-		// update fixed column tbody content, set row height & set cell widths for first row
+		// set fixed column width
+		totalWidth = totalWidth + borderRightWidth * 2 - borderSpacing;
+		tsScroller.setWidth( $fixedColumn.add( $fixedColumn.children() ), totalWidth );
+		tsScroller.setWidth( $fixedColumn.children().children( 'table' ), totalWidth );
+
+		// update fixed column tbody content, set cell widths on hidden row
 		for ( tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++ ) {
 			$tbody = $mainTbodies.eq( tbodyIndex );
 			if ( $tbody.length ) {
 				// get tbody
 				$rows = $tbody.children();
 				totalRows = $rows.length;
-				$fb = ts.processTbody( $fixedTbodiesTable, $fixedTbodies.eq( tbodyIndex ), true);
+				$fb = ts.processTbody( $fixedTbodiesTable, $fixedTbodies.eq( tbodyIndex ), true );
 				$fb.empty();
 				// update tbody cells after sort/filtering
 				for ( rowIndex = 0; rowIndex < totalRows; rowIndex++ ) {
 					$adjCol = $( $rows[ rowIndex ].outerHTML );
-					$adjCol.children( 'td, th' ).slice( fixedColumns ).remove();
-					// set row height
-					$adjCol.children().eq( 0 ).height( $rows.eq( rowIndex ).outerHeight() - ( tsScroller.isFirefox ? borderBottomWidth * 2 : 0 ) );
-					// still need to adjust tbody cell widths ( the previous row may now be filtered )
-					if ( rowIndex === 0 ) {
-						tsScroller.setWidth( $adjCol.children().eq( 0 ), widths[ 0 ] );
-					}
+					$adjCol
+						.children( 'td, th' )
+						.slice( fixedColumns )
+						.remove();
 					$fb.append( $adjCol );
 				}
 
-				// adjust fixed header cell widths
-				$temp = $fixedColumn.find( 'thead' ).children( 'tr.' + tscss.headerRow );
-				for ( index = 0; index < fixedColumns; index++ ) {
-					tsScroller.setWidth( $temp.children( ':eq(' + index + ')' ), widths[ index ] );
-				}
-
 				// restore tbody
 				ts.processTbody( $fixedTbodiesTable, $fb, false );
 			}
 		}
 
+		adj = ts.scroller.hasScrollBar( $tableWrap ) ? scrollBarWidth : 0;
+
 		/*** scrollbar HACK! Since we can't hide the scrollbar with css ***/
 		if ( tsScroller.isFirefox || tsScroller.isOldIE ) {
-			$fixedTbodiesTable.parent().css({
-				'width' : totalWidth + scrollBarWidth + borderRightWidth
-			});
+			$fixedTbodiesTable
+				.css( 'width', totalWidth )
+				.parent()
+				.css( 'width', totalWidth + adj );
 		}
 
-		$fixedColumn.show();
+		$fixedColumn.removeClass( tscss.scrollerHideElement );
+		for ( index = 0; index < fixedColumns; index++ ) {
+			$wrapper
+				.children( 'div' )
+				.children( 'table' )
+				.find( 'th:nth-child(' + ( index + 1 ) + '), td:nth-child(' + ( index + 1 ) + ')' )
+				.addClass( tscss.scrollerHideColumn );
+		}
+
+		totalWidth = totalWidth - borderRightWidth;
+		temp = $tableWrap.parent().innerWidth() - totalWidth;
+		$tableWrap.width( temp );
+		// RTL support (fixes column on right)
+		$wrapper
+			.children( '.' + tscss.scrollerTable )
+			.css( dir ? 'right' : 'left', totalWidth );
+		$wrapper
+			.children( '.' + tscss.scrollerHeader + ', .' + tscss.scrollerFooter )
+			// Safari needs a scrollbar width of extra adjusment to align the fixed & scrolling columns
+			.css( dir ? 'right' : 'left', totalWidth + ( dir && ts.scroller.isSafari ? adj : 0 ) );
+
+		$hdr
+			.parent()
+			.add( $foot.parent() )
+			.width( temp - adj );
+
+		// fix gap under the tbody for the horizontal scrollbar
+		temp = ts.scroller.hasScrollBar( $tableWrap, true );
+		adj = temp ? scrollBarWidth : 0;
+		if ( !$fixedColumn.find( '.' + tscss.scrollerBarSpacer ).length && temp ) {
+			$temp = $( '<div class="' + tscss.scrollerBarSpacer + '">' )
+				.css( 'height', adj + 'px' );
+			$fixedColumn.find( '.' + tscss.scrollerTable ).append( $temp );
+		} else if ( !temp ) {
+			$fixedColumn.find( '.' + tscss.scrollerBarSpacer ).remove();
+		}
+
+		ts.scroller.updateRowHeight( c, wo );
+		// set fixed column height (changes with filtering)
+		$fixedColumn.height( $wrapper.height() );
+
+		$fixedColumn.removeClass( tscss.scrollerHideElement );
+
+		wo.scroller_isBusy = false;
+	},
+
+	fixHeight : function( $rows, $fixedRows ) {
+		var index, heightRow, heightFixed, $r, $f,
+			len = $rows.length;
+		for ( index = 0; index < len; index++ ) {
+			$r = $rows.eq( index );
+			$f = $fixedRows.eq( index );
+			heightRow = $r.height();
+			heightFixed = $f.height();
+			if ( heightRow > heightFixed ) {
+				$f.addClass( tscss.scrollerAddedHeight ).height( heightRow );
+			} else if ( heightRow < heightFixed ) {
+				$r.addClass( tscss.scrollerAddedHeight ).height( heightFixed );
+			}
+		}
+	},
+
+	updateRowHeight : function( c, wo ) {
+		var $rows, $fixed,
+			$fixedColumns = wo.scroller_$fixedColumns;
+
+		wo.scroller_$container
+			.find( '.' + tscss.scrollerAddedHeight )
+			.removeClass( tscss.scrollerAddedHeight )
+			.height( '' );
+
+		$rows = wo.scroller_$header
+			.children( 'thead' )
+			.children( 'tr' );
+		$fixed = $fixedColumns
+			.children( '.' + tscss.scrollerHeader )
+			.children( 'table' )
+			.children( 'thead' )
+			.children( 'tr' );
+		ts.scroller.fixHeight( $rows, $fixed );
+
+		$rows = wo.scroller_$footer
+			.children( 'tfoot' )
+			.children( 'tr' );
+		$fixed = $fixedColumns
+			.children( '.' + tscss.scrollerFooter )
+			.children( 'table' )
+			.children( 'tfoot' )
+			.children( 'tr' );
+		ts.scroller.fixHeight( $rows, $fixed );
+
+		if ( ts.scroller.isFirefox || ts.scroller.isOldIE ) {
+			// Firefox/Old IE scrollbar hack (wraps table to hide the scrollbar)
+			$fixedColumns = $fixedColumns.find( '.' + tscss.scrollerHack );
+		}
+		$rows = c.$table
+			.children( 'tbody' )
+			.children( 'tr' );
+		$fixed = $fixedColumns
+			.children( '.' + tscss.scrollerTable )
+			.children( 'table' )
+			.children( 'tbody' )
+			.children( 'tr' );
+		ts.scroller.fixHeight( $rows, $fixed );
 
 	},
 
+	removeFixed : function( c, wo, removeIt ) {
+		var $table = c.$table,
+			$wrapper = wo.scroller_$container,
+			dir = $table.hasClass( tscss.scrollerRtl );
+
+		// remove fixed columns
+		if ( removeIt || typeof removeIt === 'undefined' ) {
+			$wrapper.find( '.' + tscss.scrollerFixed ).remove();
+		}
+
+		$wrapper
+			.find( '.' + tscss.scrollerHideColumn )
+			.removeClass( tscss.scrollerHideColumn );
+
+		// RTL support ( fixes column on right )
+		$wrapper
+			.children( ':not(.' + tscss.scrollerFixed + ')' )
+			.css( dir ? 'right' : 'left', 0 );
+	},
+
 	remove : function( c, wo ) {
 		var $wrap = wo.scroller_$container,
 			namespace = c.namespace + 'tsscroller';
 		c.$table
 			.off( namespace )
 			.insertBefore( $wrap )
-			.find( 'thead' ).show().css( 'visibility', 'visible' )
-			.children( 'tr.' + tscss.headerRow ).children().attr( 'tabindex', 0 )
+			.find( 'thead' )
+			.removeClass( tscss.scrollerHideElement )
+			.children( 'tr.' + tscss.headerRow )
+			.children()
+			.attr( 'tabindex', 0 )
 			.end()
-			.find( '.' + tscss.filterRow ).show().removeClass( tscss.filterRowHide );
+			.find( '.' + tscss.filterRow )
+			.removeClass( tscss.scrollerHideElement + ' ' + tscss.filterRowHide );
+		c.$table
+			.find( '.' + tscss.filter )
+			.not( '.' + tscss.filterDisabled )
+			.prop( 'disabled', false );
 		$wrap.remove();
 		$( window ).off( namespace );
 		c.isScrolling = false;