jquery-tablesorter 1.14.1 → 1.15.0

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

@@ -10,11 +10,11 @@
 
 	ts.formatter = {
 		init : function( c ) {
-			var events = $.trim( c.widgetOptions.formatter_event ) +
+			var events = c.widgetOptions.formatter_event +
 				' pagerComplete updateComplete '.split(' ').join('.tsformatter ');
 			c.$table
-				.off( $.trim(events) )
-				.on( $.trim(events), function() {
+				.off( events.replace(/\s+/g, ' ') )
+				.on( events, function() {
 					ts.formatter.setup( c );
 				});
 			ts.formatter.setup( c );

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

@@ -54,7 +54,7 @@ ts.grouping = {
 
 	update : function(table, c, wo){
 		if ($.isEmptyObject(c.cache)) { return; }
-		var rowIndex, tbodyIndex, currentGroup, $rows, groupClass, grouping, cache, saveName, direction,
+		var rowIndex, tbodyIndex, currentGroup, $rows, groupClass, grouping, norm_rows, saveName, direction,
 			lang = wo.grouping_language,
 			group = '',
 			savedGroup = false,
@@ -89,15 +89,15 @@ ts.grouping = {
 				}
 			}
 			for (tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++) {
-				cache = c.cache[tbodyIndex].normalized;
+				norm_rows = c.cache[tbodyIndex].normalized;
 				group = ''; // clear grouping across tbodies
 				$rows = c.$tbodies.eq(tbodyIndex).children('tr').not('.' + c.cssChildRow);
 				for (rowIndex = 0; rowIndex < $rows.length; rowIndex++) {
 					if ( $rows.eq(rowIndex).is(':visible') ) {
 						// fixes #438
 						if (ts.grouping.types[grouping[1]]) {
-							currentGroup = cache[rowIndex] ? 
-								ts.grouping.types[grouping[1]]( c, c.$headers.filter('[data-column="' + column + '"]:last'), cache[rowIndex][column], /date/.test(groupClass) ?
+							currentGroup = norm_rows[rowIndex] ? 
+								ts.grouping.types[grouping[1]]( c, c.$headers.filter('[data-column="' + column + '"]:last'), norm_rows[rowIndex][column], /date/.test(groupClass) ?
 								grouping[2] : parseInt(grouping[2] || 1, 10) || 1, group, lang ) : currentGroup;
 							if (group !== currentGroup) {
 								group = currentGroup;

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

@@ -393,8 +393,8 @@
 		},
 		init : function(table, thisWidget, c, wo){
 			c.$table
-				.off( $.trim(math.events) + ' ' + $.trim('updateComplete.tsmath ' + wo.math_event) )
-				.on( $.trim(math.events) + ' ' + wo.math_event, function(e){
+				.off( (math.events + ' updateComplete.tsmath ' + wo.math_event).replace(/\s+/g, ' ') )
+				.on(math.events + ' ' + wo.math_event, function(e){
 					var init = e.type === 'tablesorter-initialized';
 					if (e.type === 'updateAll') {
 						// redo data-column indexes in case columns were rearranged
@@ -415,7 +415,7 @@
 		remove: function(table, c, wo, refreshing){
 			if (refreshing) { return; }
 			$(table)
-				.off( $.trim(math.events) + ' ' + $.trim('updateComplete.tsmath ' + wo.math_event) )
+				.off( (math.events + ' updateComplete.tsmath ' + wo.math_event).replace(/\s+/g, ' ') )
 				.find('[data-' + wo.math_data + ']').empty();
 		}
 	});

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

@@ -167,7 +167,7 @@ tsp = ts.pager = {
 		p.initializing = true;
 		if (wo.pager_savePages && ts.storage) {
 			t = ts.storage(table, wo.pager_storageKey) || {}; // fixes #387
-			p.page = ( isNaN(t.page) ? p.page : t.page ) || p.setPage || 1;
+			p.page = ( isNaN(t.page) ? p.page : t.page ) || p.setPage || 0;
 			p.size = ( isNaN(t.size) ? p.size : t.size ) || p.setSize || 10;
 			$.data(table, 'pagerLastSize', p.size);
 		}
@@ -371,8 +371,7 @@ tsp = ts.pager = {
 	},
 
 	calcFilters: function(table, c) {
-		var tbodyIndex,
-			wo = c.widgetOptions,
+		var wo = c.widgetOptions,
 			p = c.pager,
 			hasFilters = c.$table.hasClass('hasFilters');
 		if (hasFilters && !wo.pager_ajaxUrl) {
@@ -380,10 +379,8 @@ tsp = ts.pager = {
 				// delayInit: true so nothing is in the cache
 				p.filteredRows = p.totalRows = c.$tbodies.eq(0).children('tr').not( wo.pager_countChildRows ? '' : '.' + c.cssChildRow ).length;
 			} else {
-				// just in case the pager tbody isn't the first tbody
-				tbodyIndex = c.$table.children('tbody').index( c.$tbodies.eq(0) );
 				p.filteredRows = 0;
-				$.each(c.cache[tbodyIndex].normalized, function(i, el) {
+				$.each(c.cache[0].normalized, function(i, el) {
 					p.filteredRows += p.regexRows.test(el[c.columns].$row[0].className) ? 0 : 1;
 				});
 			}
@@ -898,8 +895,7 @@ tsp = ts.pager = {
 			if ( !$.isEmptyObject(table.config.cache) ) {
 				var i,
 					rows = [],
-					tbodyIndex = c.$table.children('tbody').index( c.$tbodies.eq(0) ),
-					n = table.config.cache[tbodyIndex].normalized;
+					n = table.config.cache[0].normalized;
 				p.totalRows = n.length;
 				for (i = 0; i < p.totalRows; i++) {
 					rows.push(n[i][c.columns].$row);

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

@@ -0,0 +1,176 @@
+/*! Widget: resizable */
+;(function ($, window) {
+'use strict';
+var ts = $.tablesorter = $.tablesorter || {};
+
+$.extend(ts.css, {
+	resizer : 'tablesorter-resizer' // resizable
+});
+
+// this widget saves the column widths if
+// $.tablesorter.storage function is included
+// **************************
+ts.addWidget({
+	id: "resizable",
+	priority: 40,
+	options: {
+		resizable : true,
+		resizable_addLastColumn : false,
+		resizable_widths : [],
+		resizable_throttle : false // set to true (5ms) or any number 0-10 range
+	},
+	format: function(table, c, wo) {
+		if (c.$table.hasClass('hasResizable')) { return; }
+		c.$table.addClass('hasResizable');
+		ts.resizableReset(table, true); // set default widths
+		var $rows, $columns, $column, column, timer,
+			storedSizes = {},
+			$table = c.$table,
+			$wrap = $table.parent(),
+			overflow = $table.parent().css('overflow') === 'auto',
+			mouseXPosition = 0,
+			$target = null,
+			$next = null,
+			fullWidth = Math.abs($table.parent().width() - $table.width()) < 20,
+			mouseMove = function(event){
+				if (mouseXPosition === 0 || !$target) { return; }
+				// resize columns
+				var leftEdge = event.pageX - mouseXPosition,
+					targetWidth = $target.width();
+				$target.width( targetWidth + leftEdge );
+				if ($target.width() !== targetWidth && fullWidth) {
+					$next.width( $next.width() - leftEdge );
+				} else if (overflow) {
+					$table.width(function(i, w){
+						return w + leftEdge;
+					});
+					if (!$next.length) {
+						// if expanding right-most column, scroll the wrapper
+						$wrap[0].scrollLeft = $table.width();
+					}
+				}
+				mouseXPosition = event.pageX;
+			},
+			stopResize = function() {
+				if (ts.storage && $target && $next) {
+					storedSizes = {};
+					storedSizes[$target.index()] = $target.width();
+					storedSizes[$next.index()] = $next.width();
+					$target.width( storedSizes[$target.index()] );
+					$next.width( storedSizes[$next.index()] );
+					if (wo.resizable !== false) {
+						// save all column widths
+						ts.storage(table, 'tablesorter-resizable', c.$headers.map(function(){ return $(this).width(); }).get() );
+					}
+				}
+				mouseXPosition = 0;
+				$target = $next = null;
+				$(window).trigger('resize'); // will update stickyHeaders, just in case
+			};
+		storedSizes = (ts.storage && wo.resizable !== false) ? ts.storage(table, 'tablesorter-resizable') : {};
+		// process only if table ID or url match
+		if (storedSizes) {
+			for (column in storedSizes) {
+				if (!isNaN(column) && column < c.$headers.length) {
+					c.$headers.eq(column).width(storedSizes[column]); // set saved resizable widths
+				}
+			}
+		}
+		$rows = $table.children('thead:first').children('tr');
+		// add resizable-false class name to headers (across rows as needed)
+		$rows.children().each(function() {
+			var canResize,
+				$column = $(this);
+			column = $column.attr('data-column');
+			canResize = ts.getData( $column, ts.getColumnData( table, c.headers, column ), 'resizable') === "false";
+			$rows.children().filter('[data-column="' + column + '"]')[canResize ? 'addClass' : 'removeClass']('resizable-false');
+		});
+		// add wrapper inside each cell to allow for positioning of the resizable target block
+		$rows.each(function() {
+			$column = $(this).children().not('.resizable-false');
+			if (!$(this).find('.' + ts.css.wrapper).length) {
+				// Firefox needs this inner div to position the resizer correctly
+				$column.wrapInner('<div class="' + ts.css.wrapper + '" style="position:relative;height:100%;width:100%"></div>');
+			}
+			// don't include the last column of the row
+			if (!wo.resizable_addLastColumn) { $column = $column.slice(0,-1); }
+			$columns = $columns ? $columns.add($column) : $column;
+		});
+		$columns
+		.each(function() {
+			var $column = $(this),
+				padding = parseInt($column.css('padding-right'), 10) + 10; // 10 is 1/2 of the 20px wide resizer
+			$column
+				.find('.' + ts.css.wrapper)
+				.append('<div class="' + ts.css.resizer + '" style="cursor:w-resize;position:absolute;z-index:1;right:-' +
+					padding + 'px;top:0;height:100%;width:20px;"></div>');
+		})
+		.find('.' + ts.css.resizer)
+		.bind('mousedown', function(event) {
+			// save header cell and mouse position
+			$target = $(event.target).closest('th');
+			var $header = c.$headers.filter('[data-column="' + $target.attr('data-column') + '"]');
+			if ($header.length > 1) { $target = $target.add($header); }
+			// if table is not as wide as it's parent, then resize the table
+			$next = event.shiftKey ? $target.parent().find('th').not('.resizable-false').filter(':last') : $target.nextAll(':not(.resizable-false)').eq(0);
+			mouseXPosition = event.pageX;
+		});
+		$(document)
+		.bind('mousemove.tsresize', function(event) {
+			// ignore mousemove if no mousedown
+			if (mouseXPosition === 0 || !$target) { return; }
+			if (wo.resizable_throttle) {
+				clearTimeout(timer);
+				timer = setTimeout(function(){
+					mouseMove(event);
+				}, isNaN(wo.resizable_throttle) ? 5 : wo.resizable_throttle );
+			} else {
+				mouseMove(event);
+			}
+		})
+		.bind('mouseup.tsresize', function() {
+			stopResize();
+		});
+
+		// right click to reset columns to default widths
+		$table.find('thead:first').bind('contextmenu.tsresize', function() {
+			ts.resizableReset(table);
+			// $.isEmptyObject() needs jQuery 1.4+; allow right click if already reset
+			var allowClick = $.isEmptyObject ? $.isEmptyObject(storedSizes) : true;
+			storedSizes = {};
+			return allowClick;
+		});
+	},
+	remove: function(table, c) {
+		c.$table
+			.removeClass('hasResizable')
+			.children('thead')
+			.unbind('mouseup.tsresize mouseleave.tsresize contextmenu.tsresize')
+			.children('tr').children()
+			.unbind('mousemove.tsresize mouseup.tsresize')
+			// don't remove "tablesorter-wrapper" as uitheme uses it too
+			.find('.' + ts.css.resizer).remove();
+		ts.resizableReset(table);
+	}
+});
+ts.resizableReset = function(table, nosave) {
+	$(table).each(function(){
+		var $t,
+			c = this.config,
+			wo = c && c.widgetOptions;
+		if (table && c) {
+			c.$headers.each(function(i){
+				$t = $(this);
+				if (wo.resizable_widths && wo.resizable_widths[i]) {
+					$t.css('width', wo.resizable_widths[i]);
+				} else if (!$t.hasClass('resizable-false')) {
+					// don't clear the width of any column that is not resizable
+					$t.css('width','');
+				}
+			});
+			if (ts.storage && !nosave) { ts.storage(this, 'tablesorter-resizable', {}); }
+		}
+	});
+};
+
+})(jQuery, window);

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

@@ -0,0 +1,68 @@
+/*! Widget: saveSort */
+;(function ($) {
+'use strict';
+var ts = $.tablesorter = $.tablesorter || {};
+
+// this widget saves the last sort only if the
+// saveSort widget option is true AND the
+// $.tablesorter.storage function is included
+// **************************
+ts.addWidget({
+	id: 'saveSort',
+	priority: 20,
+	options: {
+		saveSort : true
+	},
+	init: function(table, thisWidget, c, wo) {
+		// run widget format before all other widgets are applied to the table
+		thisWidget.format(table, c, wo, true);
+	},
+	format: function(table, c, wo, init) {
+		var stored, time,
+			$table = c.$table,
+			saveSort = wo.saveSort !== false, // make saveSort active/inactive; default to true
+			sortList = { "sortList" : c.sortList };
+		if (c.debug) {
+			time = new Date();
+		}
+		if ($table.hasClass('hasSaveSort')) {
+			if (saveSort && table.hasInitialized && ts.storage) {
+				ts.storage( table, 'tablesorter-savesort', sortList );
+				if (c.debug) {
+					ts.benchmark('saveSort widget: Saving last sort: ' + c.sortList, time);
+				}
+			}
+		} else {
+			// set table sort on initial run of the widget
+			$table.addClass('hasSaveSort');
+			sortList = '';
+			// get data
+			if (ts.storage) {
+				stored = ts.storage( table, 'tablesorter-savesort' );
+				sortList = (stored && stored.hasOwnProperty('sortList') && $.isArray(stored.sortList)) ? stored.sortList : '';
+				if (c.debug) {
+					ts.benchmark('saveSort: Last sort loaded: "' + sortList + '"', time);
+				}
+				$table.bind('saveSortReset', function(event) {
+					event.stopPropagation();
+					ts.storage( table, 'tablesorter-savesort', '' );
+				});
+			}
+			// init is true when widget init is run, this will run this widget before all other widgets have initialized
+			// this method allows using this widget in the original tablesorter plugin; but then it will run all widgets twice.
+			if (init && sortList && sortList.length > 0) {
+				c.sortList = sortList;
+			} else if (table.hasInitialized && sortList && sortList.length > 0) {
+				// update sort change
+				$table.trigger('sorton', [sortList]);
+			}
+		}
+	},
+	remove: function(table, c) {
+		c.$table.removeClass('hasSaveSort');
+		// clear storage
+		if (ts.storage) { ts.storage( table, 'tablesorter-savesort', '' ); }
+	}
+});
+
+})(jQuery);

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

@@ -59,8 +59,8 @@ ts.addWidget({
 		addIndexes(table);
 		// refresh static rows after updates
 		c.$table
-			.unbind( $.trim('updateComplete.tsstaticrows ' + wo.staticRow_event) )
-			.bind( $.trim('updateComplete.tsstaticrows ' + wo.staticRow_event), function(){
+			.unbind( ('updateComplete.tsstaticrows ' + wo.staticRow_event).replace(/\s+/g, ' ') )
+			.bind('updateComplete.tsstaticrows ' + wo.staticRow_event, function(){
 				addIndexes(table);
 				c.$table.trigger('applyWidgets');
 			});
@@ -113,7 +113,7 @@ ts.addWidget({
 	},
 
 	remove : function(table, c, wo){
-		c.$table.unbind( $.trim('updateComplete.tsstaticrows ' + wo.staticRow_event) );
+		c.$table.unbind( ('updateComplete.tsstaticrows ' + wo.staticRow_event).replace(/\s+/g, ' ') );
 	}
 
 });

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

@@ -0,0 +1,269 @@
+/*! Widget: stickyHeaders */
+;(function ($, window) {
+'use strict';
+var ts = $.tablesorter = $.tablesorter || {};
+
+$.extend(ts.css, {
+	sticky    : 'tablesorter-stickyHeader', // stickyHeader
+	stickyVis : 'tablesorter-sticky-visible',
+	stickyWrap: 'tablesorter-sticky-wrapper'
+});
+
+// Add a resize event to table headers
+ts.addHeaderResizeEvent = function(table, disable, settings) {
+	table = $(table)[0]; // make sure we're using a dom element
+	var headers,
+		defaults = {
+			timer : 250
+		},
+		options = $.extend({}, defaults, settings),
+		c = table.config,
+		wo = c.widgetOptions,
+		checkSizes = function(triggerEvent) {
+			wo.resize_flag = true;
+			headers = [];
+			c.$headers.each(function() {
+				var $header = $(this),
+					sizes = $header.data('savedSizes') || [0,0], // fixes #394
+					width = this.offsetWidth,
+					height = this.offsetHeight;
+				if (width !== sizes[0] || height !== sizes[1]) {
+					$header.data('savedSizes', [ width, height ]);
+					headers.push(this);
+				}
+			});
+			if (headers.length && triggerEvent !== false) {
+				c.$table.trigger('resize', [ headers ]);
+			}
+			wo.resize_flag = false;
+		};
+	checkSizes(false);
+	clearInterval(wo.resize_timer);
+	if (disable) {
+		wo.resize_flag = false;
+		return false;
+	}
+	wo.resize_timer = setInterval(function() {
+		if (wo.resize_flag) { return; }
+		checkSizes();
+	}, options.timer);
+};
+
+// Sticky headers based on this awesome article:
+// http://css-tricks.com/13465-persistent-headers/
+// and https://github.com/jmosbech/StickyTableHeaders by Jonas Mosbech
+// **************************
+ts.addWidget({
+	id: "stickyHeaders",
+	priority: 60, // sticky widget must be initialized after the filter widget!
+	options: {
+		stickyHeaders : '',       // extra class name added to the sticky header row
+		stickyHeaders_attachTo : null, // jQuery selector or object to attach sticky header to
+		stickyHeaders_xScroll : null, // jQuery selector or object to monitor horizontal scroll position (defaults: xScroll > attachTo > window)
+		stickyHeaders_yScroll : null, // jQuery selector or object to monitor vertical scroll position (defaults: yScroll > attachTo > window)
+		stickyHeaders_offset : 0, // number or jquery selector targeting the position:fixed element
+		stickyHeaders_filteredToTop: true, // scroll table top into view after filtering
+		stickyHeaders_cloneId : '-sticky', // added to table ID, if it exists
+		stickyHeaders_addResizeEvent : true, // trigger "resize" event on headers
+		stickyHeaders_includeCaption : true, // if false and a caption exist, it won't be included in the sticky header
+		stickyHeaders_zIndex : 2 // The zIndex of the stickyHeaders, allows the user to adjust this to their needs
+	},
+	format: function(table, c, wo) {
+		// filter widget doesn't initialize on an empty table. Fixes #449
+		if ( c.$table.hasClass('hasStickyHeaders') || ($.inArray('filter', c.widgets) >= 0 && !c.$table.hasClass('hasFilters')) ) {
+			return;
+		}
+		var $table = c.$table,
+			$attach = $(wo.stickyHeaders_attachTo),
+			namespace = c.namespace + 'stickyheaders ',
+			// element to watch for the scroll event
+			$yScroll = $(wo.stickyHeaders_yScroll || wo.stickyHeaders_attachTo || window),
+			$xScroll = $(wo.stickyHeaders_xScroll || wo.stickyHeaders_attachTo || window),
+			$thead = $table.children('thead:first'),
+			$header = $thead.children('tr').not('.sticky-false').children(),
+			$tfoot = $table.children('tfoot'),
+			$stickyOffset = isNaN(wo.stickyHeaders_offset) ? $(wo.stickyHeaders_offset) : '',
+			stickyOffset = $attach.length ? 0 : $stickyOffset.length ?
+				$stickyOffset.height() || 0 : parseInt(wo.stickyHeaders_offset, 10) || 0,
+			// is this table nested? If so, find parent sticky header wrapper (div, not table)
+			$nestedSticky = $table.parent().closest('.' + ts.css.table).hasClass('hasStickyHeaders') ?
+				$table.parent().closest('table.tablesorter')[0].config.widgetOptions.$sticky.parent() : [],
+			nestedStickyTop = $nestedSticky.length ? $nestedSticky.height() : 0,
+			// clone table, then wrap to make sticky header
+			$stickyTable = wo.$sticky = $table.clone()
+				.addClass('containsStickyHeaders ' + ts.css.sticky + ' ' + wo.stickyHeaders)
+				.wrap('<div class="' + ts.css.stickyWrap + '">'),
+			$stickyWrap = $stickyTable.parent().css({
+				position   : $attach.length ? 'absolute' : 'fixed',
+				padding    : parseInt( $stickyTable.parent().parent().css('padding-left'), 10 ),
+				top        : stickyOffset + nestedStickyTop,
+				left       : 0,
+				visibility : 'hidden',
+				zIndex     : wo.stickyHeaders_zIndex || 2
+			}),
+			$stickyThead = $stickyTable.children('thead:first'),
+			$stickyCells,
+			laststate = '',
+			spacing = 0,
+			setWidth = function($orig, $clone){
+				$orig.filter(':visible').each(function(i) {
+					var width, border,
+						$cell = $clone.filter(':visible').eq(i),
+						$this = $(this);
+					// code from https://github.com/jmosbech/StickyTableHeaders
+					if ($this.css('box-sizing') === 'border-box') {
+						width = $this.outerWidth();
+					} else {
+						if ($cell.css('border-collapse') === 'collapse') {
+							if (window.getComputedStyle) {
+								width = parseFloat( window.getComputedStyle(this, null).width );
+							} else {
+								// ie8 only
+								border = parseFloat( $this.css('border-width') );
+								width = $this.outerWidth() - parseFloat( $this.css('padding-left') ) - parseFloat( $this.css('padding-right') ) - border;
+							}
+						} else {
+							width = $this.width();
+						}
+					}
+					$cell.css({
+						'min-width': width,
+						'max-width': width
+					});
+				});
+			},
+			resizeHeader = function() {
+				stickyOffset = $stickyOffset.length ? $stickyOffset.height() || 0 : parseInt(wo.stickyHeaders_offset, 10) || 0;
+				spacing = 0;
+				$stickyWrap.css({
+					left : $attach.length ? parseInt($attach.css('padding-left'), 10) || 0 :
+							$table.offset().left - parseInt($table.css('margin-left'), 10) - $xScroll.scrollLeft() - spacing,
+					width: $table.outerWidth()
+				});
+				setWidth( $table, $stickyTable );
+				setWidth( $header, $stickyCells );
+			};
+		// save stickyTable element to config
+		// it is also saved to wo.$sticky
+		if (c.$extraTables && c.$extraTables.length) {
+			c.$extraTables.add($stickyTable);
+		} else {
+			c.$extraTables = $stickyTable;
+		}
+		// fix clone ID, if it exists - fixes #271
+		if ($stickyTable.attr('id')) { $stickyTable[0].id += wo.stickyHeaders_cloneId; }
+		// clear out cloned table, except for sticky header
+		// include caption & filter row (fixes #126 & #249) - don't remove cells to get correct cell indexing
+		$stickyTable.find('thead:gt(0), tr.sticky-false').hide();
+		$stickyTable.find('tbody, tfoot').remove();
+		$stickyTable.find('caption').toggle(wo.stickyHeaders_includeCaption);
+		// issue #172 - find td/th in sticky header
+		$stickyCells = $stickyThead.children().children();
+		$stickyTable.css({ height:0, width:0, margin: 0 });
+		// remove resizable block
+		$stickyCells.find('.' + ts.css.resizer).remove();
+		// update sticky header class names to match real header after sorting
+		$table
+			.addClass('hasStickyHeaders')
+			.bind('pagerComplete' + namespace, function() {
+				resizeHeader();
+			});
+
+		ts.bindEvents(table, $stickyThead.children().children('.tablesorter-header'));
+
+		// add stickyheaders AFTER the table. If the table is selected by ID, the original one (first) will be returned.
+		$table.after( $stickyWrap );
+
+		// onRenderHeader is defined, we need to do something about it (fixes #641)
+		if (c.onRenderHeader) {
+			$stickyThead.children('tr').children().each(function(index){
+				// send second parameter
+				c.onRenderHeader.apply( $(this), [ index, c, $stickyTable ] );
+			});
+		}
+
+		// make it sticky!
+		$xScroll.add($yScroll)
+		.unbind( ('scroll resize '.split(' ').join( namespace )).replace(/\s+/g, ' ') )
+		.bind('scroll resize '.split(' ').join( namespace ), function(event) {
+			if (!$table.is(':visible')) { return; } // fixes #278
+			// Detect nested tables - fixes #724
+			nestedStickyTop = $nestedSticky.length ? $nestedSticky.offset().top - $yScroll.scrollTop() + $nestedSticky.height() : 0;
+			var prefix = 'tablesorter-sticky-',
+				offset = $table.offset(),
+				yWindow = $.isWindow( $yScroll[0] ), // $.isWindow needs jQuery 1.4.3
+				xWindow = $.isWindow( $xScroll[0] ),
+				// scrollTop = ( $attach.length ? $attach.offset().top : $yScroll.scrollTop() ) + stickyOffset + nestedStickyTop,
+				scrollTop = ( $attach.length ? ( yWindow ? $yScroll.scrollTop() : $yScroll.offset().top ) : $yScroll.scrollTop() ) + stickyOffset + nestedStickyTop,
+				tableHeight = $table.height() - ($stickyWrap.height() + ($tfoot.height() || 0)),
+				isVisible = ( scrollTop > offset.top ) && ( scrollTop < offset.top + tableHeight ) ? 'visible' : 'hidden',
+				cssSettings = { visibility : isVisible };
+
+			if ($attach.length) {
+				cssSettings.top = yWindow ? scrollTop : $attach.scrollTop();
+			}
+			if (xWindow) {
+				// adjust when scrolling horizontally - fixes issue #143
+				cssSettings.left = $table.offset().left - parseInt($table.css('margin-left'), 10) - $xScroll.scrollLeft() - spacing;
+			}
+			if ($nestedSticky.length) {
+				cssSettings.top = ( cssSettings.top || 0 ) + stickyOffset + nestedStickyTop;
+			}
+			$stickyWrap
+				.removeClass(prefix + 'visible ' + prefix + 'hidden')
+				.addClass(prefix + isVisible)
+				.css(cssSettings);
+			if (isVisible !== laststate || event.type === 'resize') {
+				// make sure the column widths match
+				resizeHeader();
+				laststate = isVisible;
+			}
+		});
+		if (wo.stickyHeaders_addResizeEvent) {
+			ts.addHeaderResizeEvent(table);
+		}
+
+		// look for filter widget
+		if ($table.hasClass('hasFilters') && wo.filter_columnFilters) {
+			// scroll table into view after filtering, if sticky header is active - #482
+			$table.bind('filterEnd' + namespace, function() {
+				// $(':focus') needs jQuery 1.6+
+				var $td = $(document.activeElement).closest('td'),
+					column = $td.parent().children().index($td);
+				// only scroll if sticky header is active
+				if ($stickyWrap.hasClass(ts.css.stickyVis) && wo.stickyHeaders_filteredToTop) {
+					// scroll to original table (not sticky clone)
+					window.scrollTo(0, $table.position().top);
+					// give same input/select focus; check if c.$filters exists; fixes #594
+					if (column >= 0 && c.$filters) {
+						c.$filters.eq(column).find('a, select, input').filter(':visible').focus();
+					}
+				}
+			});
+			ts.filter.bindSearch( $table, $stickyCells.find('.' + ts.css.filter) );
+			// support hideFilters
+			if (wo.filter_hideFilters) {
+				ts.filter.hideFilters($stickyTable, c);
+			}
+		}
+
+		$table.trigger('stickyHeadersInit');
+
+	},
+	remove: function(table, c, wo) {
+		var namespace = c.namespace + 'stickyheaders ';
+		c.$table
+			.removeClass('hasStickyHeaders')
+			.unbind( ('pagerComplete filterEnd '.split(' ').join(namespace)).replace(/\s+/g, ' ') )
+			.next('.' + ts.css.stickyWrap).remove();
+		if (wo.$sticky && wo.$sticky.length) { wo.$sticky.remove(); } // remove cloned table
+		$(window)
+			.add(wo.stickyHeaders_xScroll)
+			.add(wo.stickyHeaders_yScroll)
+			.add(wo.stickyHeaders_attachTo)
+			.unbind( ('scroll resize '.split(' ').join(namespace)).replace(/\s+/g, ' ') );
+		ts.addHeaderResizeEvent(table, false);
+	}
+});
+
+})(jQuery, window);