' )
+ .css({ top : marginTop })
+ .insertBefore( $table );
+ // add container
+ for ( column = 0; column < c.columns; column++ ) {
+ $header = c.$headerIndexed[ column ];
+ tmp = ts.getColumnData( c.table, c.headers, column );
+ noResize = ts.getData( $header, tmp, 'resizable' ) === 'false';
+ if ( !noResize ) {
+ $( '
' )
+ .appendTo( wo.$resizable_container )
+ .attr({
+ 'data-column' : column,
+ 'unselectable' : 'on'
+ })
+ .data( 'header', $header )
+ .bind( 'selectstart', false );
+ }
+ }
+ $table.one('tablesorter-initialized', function() {
+ ts.resizable.setHandlePosition( c, wo );
+ ts.resizable.bindings( this.config, this.config.widgetOptions );
+ });
+ },
+
+ updateStoredSizes : function( c, wo ) {
+ var column, $header,
+ len = c.columns,
+ vars = wo.resizable_vars;
+ vars.storedSizes = [];
+ for ( column = 0; column < len; column++ ) {
+ $header = c.$headerIndexed[ column ];
+ vars.storedSizes[ column ] = $header.is(':visible') ? $header.width() : 0;
+ }
+ },
+
+ setWidth : function( $el, width, overflow ) {
+ // overflow tables need min & max width set as well
+ $el.css({
+ 'width' : width,
+ 'min-width' : overflow ? width : '',
+ 'max-width' : overflow ? width : ''
+ });
+ },
+
+ setWidths : function( c, wo, storedSizes ) {
+ var column, $temp,
+ vars = wo.resizable_vars,
+ $extra = $( c.namespace + '_extra_headers' ),
+ $col = c.$table.children( 'colgroup' ).children( 'col' );
+ storedSizes = storedSizes || vars.storedSizes || [];
+ // process only if table ID or url match
+ if ( storedSizes.length ) {
+ for ( column = 0; column < c.columns; column++ ) {
+ // set saved resizable widths
+ ts.resizable.setWidth( c.$headerIndexed[ column ], storedSizes[ column ], vars.overflow );
+ if ( $extra.length ) {
+ // stickyHeaders needs to modify min & max width as well
+ $temp = $extra.eq( column ).add( $col.eq( column ) );
+ ts.resizable.setWidth( $temp, storedSizes[ column ], vars.overflow );
+ }
+ }
+ $temp = $( c.namespace + '_extra_table' );
+ if ( $temp.length && !ts.hasWidget( c.table, 'scroller' ) ) {
+ ts.resizable.setWidth( $temp, c.$table.outerWidth(), vars.overflow );
+ }
+ }
+ },
+
+ setHandlePosition : function( c, wo ) {
+ var startPosition,
+ hasScroller = ts.hasWidget( c.table, 'scroller' ),
+ tableHeight = c.$table.height(),
+ $handles = wo.$resizable_container.children(),
+ handleCenter = Math.floor( $handles.width() / 2 );
+
+ if ( hasScroller ) {
+ tableHeight = 0;
+ c.$table.closest( '.' + ts.css.scrollerWrap ).children().each(function(){
+ var $this = $(this);
+ // center table has a max-height set
+ tableHeight += $this.filter('[style*="height"]').length ? $this.height() : $this.children('table').height();
+ });
+ }
+ // subtract out table left position from resizable handles. Fixes #864
+ startPosition = c.$table.position().left;
+ $handles.each( function() {
+ var $this = $(this),
+ column = parseInt( $this.attr( 'data-column' ), 10 ),
+ columns = c.columns - 1,
+ $header = $this.data( 'header' );
+ if ( !$header ) { return; } // see #859
+ if ( !$header.is(':visible') ) {
+ $this.hide();
+ } else if ( column < columns || column === columns && wo.resizable_addLastColumn ) {
+ $this.css({
+ display: 'inline-block',
+ height : tableHeight,
+ left : $header.position().left - startPosition + $header.outerWidth() - handleCenter
+ });
+ }
+ });
+ },
+
+ // prevent text selection while dragging resize bar
+ toggleTextSelection : function( c, toggle ) {
+ var namespace = c.namespace + 'tsresize';
+ c.widgetOptions.resizable_vars.disabled = toggle;
+ $( 'body' ).toggleClass( ts.css.resizableNoSelect, toggle );
+ if ( toggle ) {
+ $( 'body' )
+ .attr( 'unselectable', 'on' )
+ .bind( 'selectstart' + namespace, false );
+ } else {
+ $( 'body' )
+ .removeAttr( 'unselectable' )
+ .unbind( 'selectstart' + namespace );
+ }
+ },
+
+ bindings : function( c, wo ) {
+ var namespace = c.namespace + 'tsresize';
+ wo.$resizable_container.children().bind( 'mousedown', function( event ) {
+ // save header cell and mouse position
+ var column,
+ vars = wo.resizable_vars,
+ $extras = $( c.namespace + '_extra_headers' ),
+ $header = $( event.target ).data( 'header' );
+
+ column = parseInt( $header.attr( 'data-column' ), 10 );
+ vars.$target = $header = $header.add( $extras.filter('[data-column="' + column + '"]') );
+ vars.target = column;
+
+ // if table is not as wide as it's parent, then resize the table
+ vars.$next = event.shiftKey || wo.resizable_targetLast ?
+ $header.parent().children().not( '.resizable-false' ).filter( ':last' ) :
+ $header.nextAll( ':not(.resizable-false)' ).eq( 0 );
+
+ column = parseInt( vars.$next.attr( 'data-column' ), 10 );
+ vars.$next = vars.$next.add( $extras.filter('[data-column="' + column + '"]') );
+ vars.next = column;
+
+ vars.mouseXPosition = event.pageX;
+ ts.resizable.updateStoredSizes( c, wo );
+ ts.resizable.toggleTextSelection( c, true );
+ });
+
+ $( document )
+ .bind( 'mousemove' + namespace, function( event ) {
+ var vars = wo.resizable_vars;
+ // ignore mousemove if no mousedown
+ if ( !vars.disabled || vars.mouseXPosition === 0 || !vars.$target ) { return; }
+ if ( wo.resizable_throttle ) {
+ clearTimeout( vars.timer );
+ vars.timer = setTimeout( function() {
+ ts.resizable.mouseMove( c, wo, event );
+ }, isNaN( wo.resizable_throttle ) ? 5 : wo.resizable_throttle );
+ } else {
+ ts.resizable.mouseMove( c, wo, event );
+ }
+ })
+ .bind( 'mouseup' + namespace, function() {
+ if (!wo.resizable_vars.disabled) { return; }
+ ts.resizable.toggleTextSelection( c, false );
+ ts.resizable.stopResize( c, wo );
+ ts.resizable.setHandlePosition( c, wo );
+ });
+
+ // resizeEnd event triggered by scroller widget
+ $( window ).bind( 'resize' + namespace + ' resizeEnd' + namespace, function() {
+ ts.resizable.setHandlePosition( c, wo );
+ });
+
+ // right click to reset columns to default widths
+ c.$table
+ .bind( 'columnUpdate' + namespace, function() {
+ ts.resizable.setHandlePosition( c, wo );
+ })
+ .find( 'thead:first' )
+ .add( $( c.namespace + '_extra_table' ).find( 'thead:first' ) )
+ .bind( 'contextmenu' + namespace, function() {
+ // $.isEmptyObject() needs jQuery 1.4+; allow right click if already reset
+ var allowClick = wo.resizable_vars.storedSizes.length === 0;
+ ts.resizableReset( c.table );
+ ts.resizable.setHandlePosition( c, wo );
+ wo.resizable_vars.storedSizes = [];
+ return allowClick;
+ });
+
+ },
+
+ mouseMove : function( c, wo, event ) {
+ if ( wo.resizable_vars.mouseXPosition === 0 || !wo.resizable_vars.$target ) { return; }
+ // resize columns
+ var column,
+ total = 0,
+ vars = wo.resizable_vars,
+ $next = vars.$next,
+ tar = vars.storedSizes[ vars.target ],
+ leftEdge = event.pageX - vars.mouseXPosition;
+ if ( vars.overflow ) {
+ if ( tar + leftEdge > 0 ) {
+ vars.storedSizes[ vars.target ] += leftEdge;
+ ts.resizable.setWidth( vars.$target, vars.storedSizes[ vars.target ], true );
+ // update the entire table width
+ for ( column = 0; column < c.columns; column++ ) {
+ total += vars.storedSizes[ column ];
+ }
+ ts.resizable.setWidth( c.$table.add( $( c.namespace + '_extra_table' ) ), total );
+ }
+ if ( !$next.length ) {
+ // if expanding right-most column, scroll the wrapper
+ vars.$wrap[0].scrollLeft = c.$table.width();
+ }
+ } else if ( vars.fullWidth ) {
+ vars.storedSizes[ vars.target ] += leftEdge;
+ vars.storedSizes[ vars.next ] -= leftEdge;
+ ts.resizable.setWidths( c, wo );
+ } else {
+ vars.storedSizes[ vars.target ] += leftEdge;
+ ts.resizable.setWidths( c, wo );
+ }
+ vars.mouseXPosition = event.pageX;
+ // dynamically update sticky header widths
+ c.$table.trigger('stickyHeadersUpdate');
+ },
+
+ stopResize : function( c, wo ) {
+ var vars = wo.resizable_vars;
+ ts.resizable.updateStoredSizes( c, wo );
+ if ( vars.useStorage ) {
+ // save all column widths
+ ts.storage( c.table, ts.css.resizableStorage, vars.storedSizes );
+ ts.storage( c.table, 'tablesorter-table-resized-width', c.$table.width() );
+ }
+ vars.mouseXPosition = 0;
+ vars.$target = vars.$next = null;
+ // will update stickyHeaders, just in case, see #912
+ c.$table.trigger('stickyHeadersUpdate');
+ }
+ };
+
+ // this widget saves the column widths if
+ // $.tablesorter.storage function is included
+ // **************************
+ ts.addWidget({
+ id: 'resizable',
+ priority: 40,
+ options: {
+ resizable : true, // save column widths to storage
+ resizable_addLastColumn : false,
+ resizable_widths : [],
+ resizable_throttle : false, // set to true (5ms) or any number 0-10 range
+ resizable_targetLast : false,
+ resizable_fullWidth : null
+ },
+ init: function(table, thisWidget, c, wo) {
+ ts.resizable.init( c, wo );
+ },
+ remove: function( table, c, wo, refreshing ) {
+ if (wo.$resizable_container) {
+ var namespace = c.namespace + 'tsresize';
+ c.$table.add( $( c.namespace + '_extra_table' ) )
+ .removeClass('hasResizable')
+ .children( 'thead' )
+ .unbind( 'contextmenu' + namespace );
+
+ wo.$resizable_container.remove();
+ ts.resizable.toggleTextSelection( c, false );
+ ts.resizableReset( table, refreshing );
+ $( document ).unbind( 'mousemove' + namespace + ' mouseup' + namespace );
+ }
+ }
+ });
+
+ ts.resizableReset = function( table, refreshing ) {
+ $( table ).each(function(){
+ var index, $t,
+ c = this.config,
+ wo = c && c.widgetOptions,
+ vars = wo.resizable_vars;
+ if ( table && c && c.$headerIndexed.length ) {
+ // restore the initial table width
+ if ( vars.overflow && vars.tableWidth ) {
+ ts.resizable.setWidth( c.$table, vars.tableWidth, true );
+ if ( vars.useStorage ) {
+ ts.storage( table, 'tablesorter-table-resized-width', 'auto' );
+ }
+ }
+ for ( index = 0; index < c.columns; index++ ) {
+ $t = c.$headerIndexed[ index ];
+ if ( wo.resizable_widths && wo.resizable_widths[ index ] ) {
+ ts.resizable.setWidth( $t, wo.resizable_widths[ index ], vars.overflow );
+ } else if ( !$t.hasClass( 'resizable-false' ) ) {
+ // don't clear the width of any column that is not resizable
+ ts.resizable.setWidth( $t, '', vars.overflow );
+ }
+ }
+
+ // reset stickyHeader widths
+ c.$table.trigger( 'stickyHeadersUpdate' );
+ if ( ts.storage && !refreshing ) {
+ ts.storage( this, ts.css.resizableStorage, {} );
+ }
+ }
+ });
+ };
+
+})( jQuery, window );
+
+/*! Widget: saveSort */
+;(function ($) {
+ 'use strict';
+ var ts = $.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) {
+ console.log('saveSort widget: Saving last sort: ' + c.sortList + ts.benchmark(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) {
+ console.log('saveSort: Last sort loaded: "' + sortList + '"' + ts.benchmark(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);
+
+return $.tablesorter;
+}));
diff --git a/app/assets/javascripts/jquery.tablesorter.js b/app/assets/javascripts/jquery.tablesorter.js
deleted file mode 100644
index 4fb3075..0000000
--- a/app/assets/javascripts/jquery.tablesorter.js
+++ /dev/null
@@ -1,1759 +0,0 @@
-/**!
-* TableSorter 2.16.2 - Client-side table sorting with ease!
-* @requires jQuery v1.2.6+
-*
-* Copyright (c) 2007 Christian Bach
-* Examples and docs at: http://tablesorter.com
-* Dual licensed under the MIT and GPL licenses:
-* http://www.opensource.org/licenses/mit-license.php
-* http://www.gnu.org/licenses/gpl.html
-*
-* @type jQuery
-* @name tablesorter
-* @cat Plugins/Tablesorter
-* @author Christian Bach/christian.bach@polyester.se
-* @contributor Rob Garrison/https://github.com/Mottie/tablesorter
-*/
-/*jshint browser:true, jquery:true, unused:false, expr: true */
-/*global console:false, alert:false */
-!(function($) {
- "use strict";
- $.extend({
- /*jshint supernew:true */
- tablesorter: new function() {
-
- var ts = this;
-
- ts.version = "2.16.2";
-
- ts.parsers = [];
- ts.widgets = [];
- ts.defaults = {
-
- // *** appearance
- theme : 'default', // adds tablesorter-{theme} to the table for styling
- widthFixed : false, // adds colgroup to fix widths of columns
- showProcessing : false, // show an indeterminate timer icon in the header when the table is sorted or filtered.
-
- headerTemplate : '{content}',// header layout template (HTML ok); {content} = innerHTML, {icon} =
(class from cssIcon)
- onRenderTemplate : null, // function(index, template){ return template; }, (template is a string)
- onRenderHeader : null, // function(index){}, (nothing to return)
-
- // *** functionality
- cancelSelection : true, // prevent text selection in the header
- tabIndex : true, // add tabindex to header for keyboard accessibility
- dateFormat : 'mmddyyyy', // other options: "ddmmyyy" or "yyyymmdd"
- sortMultiSortKey : 'shiftKey', // key used to select additional columns
- sortResetKey : 'ctrlKey', // key used to remove sorting on a column
- usNumberFormat : true, // false for German "1.234.567,89" or French "1 234 567,89"
- delayInit : false, // if false, the parsed table contents will not update until the first sort
- serverSideSorting: false, // if true, server-side sorting should be performed because client-side sorting will be disabled, but the ui and events will still be used.
-
- // *** sort options
- headers : {}, // set sorter, string, empty, locked order, sortInitialOrder, filter, etc.
- ignoreCase : true, // ignore case while sorting
- sortForce : null, // column(s) first sorted; always applied
- sortList : [], // Initial sort order; applied initially; updated when manually sorted
- sortAppend : null, // column(s) sorted last; always applied
- sortStable : false, // when sorting two rows with exactly the same content, the original sort order is maintained
-
- sortInitialOrder : 'asc', // sort direction on first click
- sortLocaleCompare: false, // replace equivalent character (accented characters)
- sortReset : false, // third click on the header will reset column to default - unsorted
- sortRestart : false, // restart sort to "sortInitialOrder" when clicking on previously unsorted columns
-
- emptyTo : 'bottom', // sort empty cell to bottom, top, none, zero
- stringTo : 'max', // sort strings in numerical column as max, min, top, bottom, zero
- textExtraction : 'basic', // text extraction method/function - function(node, table, cellIndex){}
- textAttribute : 'data-text',// data-attribute that contains alternate cell text (used in textExtraction function)
- textSorter : null, // choose overall or specific column sorter function(a, b, direction, table, columnIndex) [alt: ts.sortText]
- numberSorter : null, // choose overall numeric sorter function(a, b, direction, maxColumnValue)
-
- // *** widget options
- widgets: [], // method to add widgets, e.g. widgets: ['zebra']
- widgetOptions : {
- zebra : [ 'even', 'odd' ] // zebra widget alternating row class names
- },
- initWidgets : true, // apply widgets on tablesorter initialization
-
- // *** callbacks
- initialized : null, // function(table){},
-
- // *** extra css class names
- tableClass : '',
- cssAsc : '',
- cssDesc : '',
- cssNone : '',
- cssHeader : '',
- cssHeaderRow : '',
- cssProcessing : '', // processing icon applied to header during sort/filter
-
- cssChildRow : 'tablesorter-childRow', // class name indiciating that a row is to be attached to the its parent
- cssIcon : 'tablesorter-icon', // if this class exists, a
will be added to the header automatically
- cssInfoBlock : 'tablesorter-infoOnly', // don't sort tbody with this class name (only one class name allowed here!)
-
- // *** selectors
- selectorHeaders : '> thead th, > thead td',
- selectorSort : 'th, td', // jQuery selector of content within selectorHeaders that is clickable to trigger a sort
- selectorRemove : '.remove-me',
-
- // *** advanced
- debug : false,
-
- // *** Internal variables
- headerList: [],
- empties: {},
- strings: {},
- parsers: []
-
- // deprecated; but retained for backwards compatibility
- // widgetZebra: { css: ["even", "odd"] }
-
- };
-
- // internal css classes - these will ALWAYS be added to
- // the table and MUST only contain one class name - fixes #381
- ts.css = {
- table : 'tablesorter',
- cssHasChild: 'tablesorter-hasChildRow',
- childRow : 'tablesorter-childRow',
- header : 'tablesorter-header',
- headerRow : 'tablesorter-headerRow',
- headerIn : 'tablesorter-header-inner',
- icon : 'tablesorter-icon',
- info : 'tablesorter-infoOnly',
- processing : 'tablesorter-processing',
- sortAsc : 'tablesorter-headerAsc',
- sortDesc : 'tablesorter-headerDesc',
- sortNone : 'tablesorter-headerUnSorted'
- };
-
- // labels applied to sortable headers for accessibility (aria) support
- ts.language = {
- sortAsc : 'Ascending sort applied, ',
- sortDesc : 'Descending sort applied, ',
- sortNone : 'No sort applied, ',
- nextAsc : 'activate to apply an ascending sort',
- nextDesc : 'activate to apply a descending sort',
- nextNone : 'activate to remove the sort'
- };
-
- /* debuging utils */
- function log() {
- var a = arguments[0],
- s = arguments.length > 1 ? Array.prototype.slice.call(arguments) : a;
- if (typeof console !== "undefined" && typeof console.log !== "undefined") {
- console[ /error/i.test(a) ? 'error' : /warn/i.test(a) ? 'warn' : 'log' ](s);
- } else {
- alert(s);
- }
- }
-
- function benchmark(s, d) {
- log(s + " (" + (new Date().getTime() - d.getTime()) + "ms)");
- }
-
- ts.log = log;
- ts.benchmark = benchmark;
-
- // $.isEmptyObject from jQuery v1.4
- function isEmptyObject(obj) {
- /*jshint forin: false */
- for (var name in obj) {
- return false;
- }
- return true;
- }
-
- function getElementText(table, node, cellIndex) {
- if (!node) { return ""; }
- var c = table.config,
- t = c.textExtraction || '',
- text = "";
- if (t === "basic") {
- // check data-attribute first
- text = $(node).attr(c.textAttribute) || node.textContent || node.innerText || $(node).text() || "";
- } else {
- if (typeof(t) === "function") {
- text = t(node, table, cellIndex);
- } else if (typeof(t) === "object" && t.hasOwnProperty(cellIndex)) {
- text = t[cellIndex](node, table, cellIndex);
- } else {
- // previous "simple" method
- text = node.textContent || node.innerText || $(node).text() || "";
- }
- }
- return $.trim(text);
- }
-
- function detectParserForColumn(table, rows, rowIndex, cellIndex) {
- var cur,
- i = ts.parsers.length,
- node = false,
- nodeValue = '',
- keepLooking = true;
- while (nodeValue === '' && keepLooking) {
- rowIndex++;
- if (rows[rowIndex]) {
- node = rows[rowIndex].cells[cellIndex];
- nodeValue = getElementText(table, node, cellIndex);
- if (table.config.debug) {
- log('Checking if value was empty on row ' + rowIndex + ', column: ' + cellIndex + ': "' + nodeValue + '"');
- }
- } else {
- keepLooking = false;
- }
- }
- while (--i >= 0) {
- cur = ts.parsers[i];
- // ignore the default text parser because it will always be true
- if (cur && cur.id !== 'text' && cur.is && cur.is(nodeValue, table, node)) {
- return cur;
- }
- }
- // nothing found, return the generic parser (text)
- return ts.getParserById('text');
- }
-
- function buildParserCache(table) {
- var c = table.config,
- // update table bodies in case we start with an empty table
- tb = c.$tbodies = c.$table.children('tbody:not(.' + c.cssInfoBlock + ')'),
- rows, list, l, i, h, ch, p, time,
- j = 0,
- parsersDebug = "",
- len = tb.length;
- if ( len === 0) {
- return c.debug ? log('Warning: *Empty table!* Not building a parser cache') : '';
- } else if (c.debug) {
- time = new Date();
- log('Detecting parsers for each column');
- }
- list = [];
- while (j < len) {
- rows = tb[j].rows;
- if (rows[j]) {
- l = rows[j].cells.length;
- for (i = 0; i < l; i++) {
- // tons of thanks to AnthonyM1229 for working out the following selector (issue #74) to make this work in IE8!
- // More fixes to this selector to work properly in iOS and jQuery 1.8+ (issue #132 & #174)
- h = c.$headers.filter(':not([colspan])');
- h = h.add( c.$headers.filter('[colspan="1"]') ) // ie8 fix
- .filter('[data-column="' + i + '"]:last');
- ch = c.headers[i];
- // get column parser
- p = ts.getParserById( ts.getData(h, ch, 'sorter') );
- // empty cells behaviour - keeping emptyToBottom for backwards compatibility
- c.empties[i] = ts.getData(h, ch, 'empty') || c.emptyTo || (c.emptyToBottom ? 'bottom' : 'top' );
- // text strings behaviour in numerical sorts
- c.strings[i] = ts.getData(h, ch, 'string') || c.stringTo || 'max';
- if (!p) {
- p = detectParserForColumn(table, rows, -1, i);
- }
- if (c.debug) {
- parsersDebug += "column:" + i + "; parser:" + p.id + "; string:" + c.strings[i] + '; empty: ' + c.empties[i] + "\n";
- }
- list.push(p);
- }
- }
- j += (list.length) ? len : 1;
- }
- if (c.debug) {
- log(parsersDebug ? parsersDebug : "No parsers detected");
- benchmark("Completed detecting parsers", time);
- }
- c.parsers = list;
- }
-
- /* utils */
- function buildCache(table) {
- var cc, t, v, i, j, k, $row, rows, cols, cacheTime,
- totalRows, rowData, colMax,
- c = table.config,
- $tb = c.$table.children('tbody'),
- parsers = c.parsers;
- c.cache = {};
- // if no parsers found, return - it's an empty table.
- if (!parsers) {
- return c.debug ? log('Warning: *Empty table!* Not building a cache') : '';
- }
- if (c.debug) {
- cacheTime = new Date();
- }
- // processing icon
- if (c.showProcessing) {
- ts.isProcessing(table, true);
- }
- for (k = 0; k < $tb.length; k++) {
- colMax = []; // column max value per tbody
- cc = c.cache[k] = {
- normalized: [] // array of normalized row data; last entry contains "rowData" above
- // colMax: # // added at the end
- };
-
- // ignore tbodies with class name from c.cssInfoBlock
- if (!$tb.eq(k).hasClass(c.cssInfoBlock)) {
- totalRows = ($tb[k] && $tb[k].rows.length) || 0;
- for (i = 0; i < totalRows; ++i) {
- rowData = {
- // order: original row order #
- // $row : jQuery Object[]
- child: [] // child row text (filter widget)
- };
- /** Add the table data to main data array */
- $row = $($tb[k].rows[i]);
- rows = [ new Array(c.columns) ];
- cols = [];
- // if this is a child row, add it to the last row's children and continue to the next row
- // ignore child row class, if it is the first row
- if ($row.hasClass(c.cssChildRow) && i !== 0) {
- t = cc.normalized.length - 1;
- cc.normalized[t][c.columns].$row = cc.normalized[t][c.columns].$row.add($row);
- // add "hasChild" class name to parent row
- if (!$row.prev().hasClass(c.cssChildRow)) {
- $row.prev().addClass(ts.css.cssHasChild);
- }
- // save child row content (un-parsed!)
- rowData.child[t] = $.trim( $row[0].textContent || $row[0].innerText || $row.text() || "" );
- // go to the next for loop
- continue;
- }
- rowData.$row = $row;
- rowData.order = i; // add original row position to rowCache
- for (j = 0; j < c.columns; ++j) {
- if (typeof parsers[j] === 'undefined') {
- if (c.debug) {
- log('No parser found for cell:', $row[0].cells[j], 'does it have a header?');
- }
- continue;
- }
- t = getElementText(table, $row[0].cells[j], j);
- // allow parsing if the string is empty, previously parsing would change it to zero,
- // in case the parser needs to extract data from the table cell attributes
- v = parsers[j].format(t, table, $row[0].cells[j], j);
- cols.push(v);
- if ((parsers[j].type || '').toLowerCase() === "numeric") {
- // determine column max value (ignore sign)
- colMax[j] = Math.max(Math.abs(v) || 0, colMax[j] || 0);
- }
- }
- // ensure rowData is always in the same location (after the last column)
- cols[c.columns] = rowData;
- cc.normalized.push(cols);
- }
- cc.colMax = colMax;
- }
- }
- if (c.showProcessing) {
- ts.isProcessing(table); // remove processing icon
- }
- if (c.debug) {
- benchmark("Building cache for " + totalRows + " rows", cacheTime);
- }
- }
-
- // init flag (true) used by pager plugin to prevent widget application
- function appendToTable(table, init) {
- var c = table.config,
- wo = c.widgetOptions,
- b = table.tBodies,
- rows = [],
- cc = c.cache,
- n, totalRows, $bk, $tb,
- i, k, appendTime;
- // empty table - fixes #206/#346
- if (isEmptyObject(cc)) {
- // run pager appender in case the table was just emptied
- return c.appender ? c.appender(table, rows) :
- table.isUpdating ? c.$table.trigger("updateComplete", table) : ''; // Fixes #532
- }
- if (c.debug) {
- appendTime = new Date();
- }
- for (k = 0; k < b.length; k++) {
- $bk = $(b[k]);
- if ($bk.length && !$bk.hasClass(c.cssInfoBlock)) {
- // get tbody
- $tb = ts.processTbody(table, $bk, true);
- n = cc[k].normalized;
- totalRows = n.length;
- for (i = 0; i < totalRows; i++) {
- rows.push(n[i][c.columns].$row);
- // removeRows used by the pager plugin; don't render if using ajax - fixes #411
- if (!c.appender || (c.pager && (!c.pager.removeRows || !wo.pager_removeRows) && !c.pager.ajax)) {
- $tb.append(n[i][c.columns].$row);
- }
- }
- // restore tbody
- ts.processTbody(table, $tb, false);
- }
- }
- if (c.appender) {
- c.appender(table, rows);
- }
- if (c.debug) {
- benchmark("Rebuilt table", appendTime);
- }
- // apply table widgets; but not before ajax completes
- if (!init && !c.appender) { ts.applyWidget(table); }
- if (table.isUpdating) {
- c.$table.trigger("updateComplete", table);
- }
- }
-
- function formatSortingOrder(v) {
- // look for "d" in "desc" order; return true
- return (/^d/i.test(v) || v === 1);
- }
-
- function buildHeaders(table) {
- var ch, $t,
- h, i, t, lock, time,
- c = table.config;
- c.headerList = [];
- c.headerContent = [];
- if (c.debug) {
- time = new Date();
- }
- // children tr in tfoot - see issue #196 & #547
- c.columns = ts.computeColumnIndex( c.$table.children('thead, tfoot').children('tr') );
- // add icon if cssIcon option exists
- i = c.cssIcon ? ''),
- overallWidth = $(table).width();
- // only add col for visible columns - fixes #371
- $(table.tBodies[0]).find("tr:first").children("td:visible").each(function() {
- colgroup.append($(' in the header
- sortNone : 'bootstrap-icon-unsorted',
- sortAsc : 'icon-chevron-up glyphicon glyphicon-chevron-up',
- sortDesc : 'icon-chevron-down glyphicon glyphicon-chevron-down',
- active : '', // applied when column is sorted
- hover : '', // use custom css here - bootstrap class may not override it
- filterRow : '', // filter row class
- even : '', // even row zebra striping
- odd : '' // odd row zebra striping
- },
- "jui" : {
- table : 'ui-widget ui-widget-content ui-corner-all', // table classes
- caption : 'ui-widget-content ui-corner-all',
- header : 'ui-widget-header ui-corner-all ui-state-default', // header classes
- footerRow : '',
- footerCells: '',
- icons : 'ui-icon', // icon class added to the in the header
- sortNone : 'ui-icon-carat-2-n-s',
- sortAsc : 'ui-icon-carat-1-n',
- sortDesc : 'ui-icon-carat-1-s',
- active : 'ui-state-active', // applied when column is sorted
- hover : 'ui-state-hover', // hover class
- filterRow : '',
- even : 'ui-widget-content', // even row zebra striping
- odd : 'ui-state-default' // odd row zebra striping
- }
-};
-
-$.extend(ts.css, {
- filterRow : 'tablesorter-filter-row', // filter
- filter : 'tablesorter-filter',
- wrapper : 'tablesorter-wrapper', // ui theme & resizable
- resizer : 'tablesorter-resizer', // resizable
- grip : 'tablesorter-resizer-grip',
- sticky : 'tablesorter-stickyHeader', // stickyHeader
- stickyVis : 'tablesorter-sticky-visible'
-});
-
-// *** Store data in local storage, with a cookie fallback ***
-/* IE7 needs JSON library for JSON.stringify - (http://caniuse.com/#search=json)
- if you need it, then include https://github.com/douglascrockford/JSON-js
-
- $.parseJSON is not available is jQuery versions older than 1.4.1, using older
- versions will only allow storing information for one page at a time
-
- // *** Save data (JSON format only) ***
- // val must be valid JSON... use http://jsonlint.com/ to ensure it is valid
- var val = { "mywidget" : "data1" }; // valid JSON uses double quotes
- // $.tablesorter.storage(table, key, val);
- $.tablesorter.storage(table, 'tablesorter-mywidget', val);
-
- // *** Get data: $.tablesorter.storage(table, key); ***
- v = $.tablesorter.storage(table, 'tablesorter-mywidget');
- // val may be empty, so also check for your data
- val = (v && v.hasOwnProperty('mywidget')) ? v.mywidget : '';
- alert(val); // "data1" if saved, or "" if not
-*/
-ts.storage = function(table, key, value, options) {
- table = $(table)[0];
- var cookieIndex, cookies, date,
- hasLocalStorage = false,
- values = {},
- c = table.config,
- $table = $(table),
- id = options && options.id || $table.attr(options && options.group ||
- 'data-table-group') || table.id || $('.tablesorter').index( $table ),
- url = options && options.url || $table.attr(options && options.page ||
- 'data-table-page') || c && c.fixedUrl || window.location.pathname;
- // https://gist.github.com/paulirish/5558557
- if ("localStorage" in window) {
- try {
- window.localStorage.setItem('_tmptest', 'temp');
- hasLocalStorage = true;
- window.localStorage.removeItem('_tmptest');
- } catch(error) {}
- }
- // *** get value ***
- if ($.parseJSON) {
- if (hasLocalStorage) {
- values = $.parseJSON(localStorage[key] || '{}');
- } else {
- // old browser, using cookies
- cookies = document.cookie.split(/[;\s|=]/);
- // add one to get from the key to the value
- cookieIndex = $.inArray(key, cookies) + 1;
- values = (cookieIndex !== 0) ? $.parseJSON(cookies[cookieIndex] || '{}') : {};
- }
- }
- // allow value to be an empty string too
- if ((value || value === '') && window.JSON && JSON.hasOwnProperty('stringify')) {
- // add unique identifiers = url pathname > table ID/index on page > data
- if (!values[url]) {
- values[url] = {};
- }
- values[url][id] = value;
- // *** set value ***
- if (hasLocalStorage) {
- localStorage[key] = JSON.stringify(values);
- } else {
- date = new Date();
- date.setTime(date.getTime() + (31536e+6)); // 365 days
- document.cookie = key + '=' + (JSON.stringify(values)).replace(/\"/g,'\"') + '; expires=' + date.toGMTString() + '; path=/';
- }
- } else {
- return values && values[url] ? values[url][id] : '';
- }
-};
-
-// Add a resize event to table headers
-// **************************
-ts.addHeaderResizeEvent = function(table, disable, settings) {
- 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);
-};
-
-// Widget: General UI theme
-// "uitheme" option in "widgetOptions"
-// **************************
-ts.addWidget({
- id: "uitheme",
- priority: 10,
- format: function(table, c, wo) {
- var i, time, classes, $header, $icon, $tfoot,
- themesAll = ts.themes,
- $table = c.$table,
- $headers = c.$headers,
- theme = c.theme || 'jui',
- themes = themesAll[theme] || themesAll.jui,
- remove = themes.sortNone + ' ' + themes.sortDesc + ' ' + themes.sortAsc;
- if (c.debug) { time = new Date(); }
- // initialization code - run once
- if (!$table.hasClass('tablesorter-' + theme) || c.theme === theme || !table.hasInitialized) {
- // update zebra stripes
- if (themes.even !== '') { wo.zebra[0] += ' ' + themes.even; }
- if (themes.odd !== '') { wo.zebra[1] += ' ' + themes.odd; }
- // add caption style
- $table.find('caption').addClass(themes.caption);
- // add table/footer class names
- $tfoot = $table
- // remove other selected themes
- .removeClass( c.theme === '' ? '' : 'tablesorter-' + c.theme )
- .addClass('tablesorter-' + theme + ' ' + themes.table) // add theme widget class name
- .find('tfoot');
- if ($tfoot.length) {
- $tfoot
- .find('tr').addClass(themes.footerRow)
- .children('th, td').addClass(themes.footerCells);
- }
- // update header classes
- $headers
- .addClass(themes.header)
- .not('.sorter-false')
- .bind('mouseenter.tsuitheme mouseleave.tsuitheme', function(event) {
- // toggleClass with switch added in jQuery 1.3
- $(this)[ event.type === 'mouseenter' ? 'addClass' : 'removeClass' ](themes.hover);
- });
- if (!$headers.find('.' + ts.css.wrapper).length) {
- // Firefox needs this inner div to position the resizer correctly
- $headers.wrapInner('
');
- }
- if (c.cssIcon) {
- // if c.cssIcon is '', then no is added to the header
- $headers.find('.' + ts.css.icon).addClass(themes.icons);
- }
- if ($table.hasClass('hasFilters')) {
- $headers.find('.' + ts.css.filterRow).addClass(themes.filterRow);
- }
- }
- for (i = 0; i < c.columns; i++) {
- $header = c.$headers.add(c.$extraHeaders).filter('[data-column="' + i + '"]');
- $icon = (ts.css.icon) ? $header.find('.' + ts.css.icon) : $header;
- if (c.$headers.filter('[data-column="' + i + '"]:last')[0].sortDisabled) {
- // no sort arrows for disabled columns!
- $header.removeClass(remove);
- $icon.removeClass(remove + ' ' + themes.icons);
- } else {
- classes = ($header.hasClass(ts.css.sortAsc)) ?
- themes.sortAsc :
- ($header.hasClass(ts.css.sortDesc)) ? themes.sortDesc :
- $header.hasClass(ts.css.header) ? themes.sortNone : '';
- $header[classes === themes.sortNone ? 'removeClass' : 'addClass'](themes.active);
- $icon.removeClass(remove).addClass(classes);
- }
- }
- if (c.debug) {
- ts.benchmark("Applying " + theme + " theme", time);
- }
- },
- remove: function(table, c, wo) {
- var $table = c.$table,
- theme = c.theme || 'jui',
- themes = ts.themes[ theme ] || ts.themes.jui,
- $headers = $table.children('thead').children(),
- remove = themes.sortNone + ' ' + themes.sortDesc + ' ' + themes.sortAsc;
- $table
- .removeClass('tablesorter-' + theme + ' ' + themes.table)
- .find(ts.css.header).removeClass(themes.header);
- $headers
- .unbind('mouseenter.tsuitheme mouseleave.tsuitheme') // remove hover
- .removeClass(themes.hover + ' ' + remove + ' ' + themes.active)
- .find('.' + ts.css.filterRow)
- .removeClass(themes.filterRow);
- $headers.find('.' + ts.css.icon).removeClass(themes.icons);
- }
-});
-
-// Widget: Column styles
-// "columns", "columns_thead" (true) and
-// "columns_tfoot" (true) options in "widgetOptions"
-// **************************
-ts.addWidget({
- id: "columns",
- priority: 30,
- options : {
- columns : [ "primary", "secondary", "tertiary" ]
- },
- format: function(table, c, wo) {
- var time, $tbody, tbodyIndex, $rows, rows, $row, $cells, remove, indx,
- $table = c.$table,
- $tbodies = c.$tbodies,
- sortList = c.sortList,
- len = sortList.length,
- // removed c.widgetColumns support
- css = wo && wo.columns || [ "primary", "secondary", "tertiary" ],
- last = css.length - 1;
- remove = css.join(' ');
- if (c.debug) {
- time = new Date();
- }
- // check if there is a sort (on initialization there may not be one)
- for (tbodyIndex = 0; tbodyIndex < $tbodies.length; tbodyIndex++ ) {
- $tbody = ts.processTbody(table, $tbodies.eq(tbodyIndex), true); // detach tbody
- $rows = $tbody.children('tr');
- // loop through the visible rows
- $rows.each(function() {
- $row = $(this);
- if (this.style.display !== 'none') {
- // remove all columns class names
- $cells = $row.children().removeClass(remove);
- // add appropriate column class names
- if (sortList && sortList[0]) {
- // primary sort column class
- $cells.eq(sortList[0][0]).addClass(css[0]);
- if (len > 1) {
- for (indx = 1; indx < len; indx++) {
- // secondary, tertiary, etc sort column classes
- $cells.eq(sortList[indx][0]).addClass( css[indx] || css[last] );
- }
- }
- }
- }
- });
- ts.processTbody(table, $tbody, false);
- }
- // add classes to thead and tfoot
- rows = wo.columns_thead !== false ? ['thead tr'] : [];
- if (wo.columns_tfoot !== false) {
- rows.push('tfoot tr');
- }
- if (rows.length) {
- $rows = $table.find( rows.join(',') ).children().removeClass(remove);
- if (len) {
- for (indx = 0; indx < len; indx++) {
- // add primary. secondary, tertiary, etc sort column classes
- $rows.filter('[data-column="' + sortList[indx][0] + '"]').addClass(css[indx] || css[last]);
- }
- }
- }
- if (c.debug) {
- ts.benchmark("Applying Columns widget", time);
- }
- },
- remove: function(table, c, wo) {
- var tbodyIndex, $tbody,
- $tbodies = c.$tbodies,
- remove = (wo.columns || [ "primary", "secondary", "tertiary" ]).join(' ');
- c.$headers.removeClass(remove);
- c.$table.children('tfoot').children('tr').children('th, td').removeClass(remove);
- for (tbodyIndex = 0; tbodyIndex < $tbodies.length; tbodyIndex++ ) {
- $tbody = ts.processTbody(table, $tbodies.eq(tbodyIndex), true); // remove tbody
- $tbody.children('tr').each(function() {
- $(this).children().removeClass(remove);
- });
- ts.processTbody(table, $tbody, false); // restore tbody
- }
- }
-});
-
-// Widget: filter
-// **************************
-ts.addWidget({
- id: "filter",
- priority: 50,
- options : {
- filter_childRows : false, // if true, filter includes child row content in the search
- filter_columnFilters : true, // if true, a filter will be added to the top of each table column
- filter_cssFilter : '', // css class name added to the filter row & each input in the row (tablesorter-filter is ALWAYS added)
- filter_external : '', // jQuery selector string (or jQuery object) of external filters
- filter_filteredRow : 'filtered', // class added to filtered rows; needed by pager plugin
- filter_formatter : null, // add custom filter elements to the filter row
- filter_functions : null, // add custom filter functions using this option
- filter_hideEmpty : true, // hide filter row when table is empty
- filter_hideFilters : false, // collapse filter row when mouse leaves the area
- filter_ignoreCase : true, // if true, make all searches case-insensitive
- filter_liveSearch : true, // if true, search column content while the user types (with a delay)
- filter_onlyAvail : 'filter-onlyAvail', // a header with a select dropdown & this class name will only show available (visible) options within the drop down
- filter_placeholder : { search : '', select : '' }, // default placeholder text (overridden by any header "data-placeholder" setting)
- filter_reset : null, // jQuery selector string of an element used to reset the filters
- filter_saveFilters : false, // Use the $.tablesorter.storage utility to save the most recent filters
- filter_searchDelay : 300, // typing delay in milliseconds before starting a search
- filter_selectSource : null, // include a function to return an array of values to be added to the column filter select
- filter_startsWith : false, // if true, filter start from the beginning of the cell contents
- filter_useParsedData : false, // filter all data using parsed content
- filter_serversideFiltering : false, // if true, server-side filtering should be performed because client-side filtering will be disabled, but the ui and events will still be used.
- filter_defaultAttrib : 'data-value' // data attribute in the header cell that contains the default filter value
- },
- format: function(table, c, wo) {
- if (!c.$table.hasClass('hasFilters')) {
- ts.filter.init(table, c, wo);
- }
- },
- remove: function(table, c, wo) {
- var tbodyIndex, $tbody,
- $table = c.$table,
- $tbodies = c.$tbodies;
- $table
- .removeClass('hasFilters')
- // add .tsfilter namespace to all BUT search
- .unbind('addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '.split(' ').join(c.namespace + 'filter '))
- .find('.' + ts.css.filterRow).remove();
- for (tbodyIndex = 0; tbodyIndex < $tbodies.length; tbodyIndex++ ) {
- $tbody = ts.processTbody(table, $tbodies.eq(tbodyIndex), true); // remove tbody
- $tbody.children().removeClass(wo.filter_filteredRow).show();
- ts.processTbody(table, $tbody, false); // restore tbody
- }
- if (wo.filter_reset) {
- $(document).undelegate(wo.filter_reset, 'click.tsfilter');
- }
- }
-});
-
-ts.filter = {
-
- // regex used in filter "check" functions - not for general use and not documented
- regex: {
- regex : /^\/((?:\\\/|[^\/])+)\/([mig]{0,3})?$/, // regex to test for regex
- child : /tablesorter-childRow/, // child row class name; this gets updated in the script
- filtered : /filtered/, // filtered (hidden) row class name; updated in the script
- type : /undefined|number/, // check type
- exact : /(^[\"|\'|=]+)|([\"|\'|=]+$)/g, // exact match (allow '==')
- nondigit : /[^\w,. \-()]/g, // replace non-digits (from digit & currency parser)
- operators : /[<>=]/g // replace operators
- },
- // function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed )
- // filter = array of filter input values; iFilter = same array, except lowercase
- // exact = table cell text (or parsed data if column parser enabled)
- // iExact = same as exact, except lowercase
- // cached = table cell text from cache, so it has been parsed
- // index = column index; table = table element (DOM)
- // wo = widget options (table.config.widgetOptions)
- // parsed = array (by column) of boolean values (from filter_useParsedData or "filter-parsed" class)
- types: {
- // Look for regex
- regex: function( filter, iFilter, exact, iExact ) {
- if ( ts.filter.regex.regex.test(iFilter) ) {
- var matches,
- regex = ts.filter.regex.regex.exec(iFilter);
- try {
- matches = new RegExp(regex[1], regex[2]).test( iExact );
- } catch (error) {
- matches = false;
- }
- return matches;
- }
- return null;
- },
- // Look for operators >, >=, < or <=
- operators: function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed ) {
- if ( /^[<>]=?/.test(iFilter) ) {
- var cachedValue, result,
- c = table.config,
- query = ts.formatFloat( iFilter.replace(ts.filter.regex.operators, ''), table ),
- parser = c.parsers[index],
- savedSearch = query;
- // parse filter value in case we're comparing numbers (dates)
- if (parsed[index] || parser.type === 'numeric') {
- cachedValue = parser.format( '' + iFilter.replace(ts.filter.regex.operators, ''), table, c.$headers.eq(index), index );
- query = ( typeof query === "number" && cachedValue !== '' && !isNaN(cachedValue) ) ? cachedValue : query;
- }
- // iExact may be numeric - see issue #149;
- // check if cached is defined, because sometimes j goes out of range? (numeric columns)
- cachedValue = ( parsed[index] || parser.type === 'numeric' ) && !isNaN(query) && cached ? cached :
- isNaN(iExact) ? ts.formatFloat( iExact.replace(ts.filter.regex.nondigit, ''), table) :
- ts.formatFloat( iExact, table );
- if ( />/.test(iFilter) ) { result = />=/.test(iFilter) ? cachedValue >= query : cachedValue > query; }
- if ( /= 0 : fltr == iExact;
- }
- return null;
- },
- // Look for a not match
- notMatch: function( filter, iFilter, exact, iExact, cached, index, table, wo ) {
- if ( /^\!/.test(iFilter) ) {
- iFilter = iFilter.replace('!', '');
- var indx = iExact.search( $.trim(iFilter) );
- return iFilter === '' ? true : !(wo.filter_startsWith ? indx === 0 : indx >= 0);
- }
- return null;
- },
- // Look for an AND or && operator (logical and)
- and : function( filter, iFilter, exact, iExact ) {
- if ( /\s+(AND|&&)\s+/g.test(filter) ) {
- var query = iFilter.split( /(?:\s+(?:and|&&)\s+)/g ),
- result = iExact.search( $.trim(query[0]) ) >= 0,
- indx = query.length - 1;
- while (result && indx) {
- result = result && iExact.search( $.trim(query[indx]) ) >= 0;
- indx--;
- }
- return result;
- }
- return null;
- },
- // Look for a range (using " to " or " - ") - see issue #166; thanks matzhu!
- range : function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed ) {
- if ( /\s+(-|to)\s+/.test(iFilter) ) {
- var result, tmp,
- c = table.config,
- query = iFilter.split(/(?: - | to )/), // make sure the dash is for a range and not indicating a negative number
- range1 = ts.formatFloat(query[0].replace(ts.filter.regex.nondigit, ''), table),
- range2 = ts.formatFloat(query[1].replace(ts.filter.regex.nondigit, ''), table);
- // parse filter value in case we're comparing numbers (dates)
- if (parsed[index] || c.parsers[index].type === 'numeric') {
- result = c.parsers[index].format('' + query[0], table, c.$headers.eq(index), index);
- range1 = (result !== '' && !isNaN(result)) ? result : range1;
- result = c.parsers[index].format('' + query[1], table, c.$headers.eq(index), index);
- range2 = (result !== '' && !isNaN(result)) ? result : range2;
- }
- result = ( parsed[index] || c.parsers[index].type === 'numeric' ) && !isNaN(range1) && !isNaN(range2) ? cached :
- isNaN(iExact) ? ts.formatFloat( iExact.replace(ts.filter.regex.nondigit, ''), table) :
- ts.formatFloat( iExact, table );
- if (range1 > range2) { tmp = range1; range1 = range2; range2 = tmp; } // swap
- return (result >= range1 && result <= range2) || (range1 === '' || range2 === '');
- }
- return null;
- },
- // Look for wild card: ? = single, * = multiple, or | = logical OR
- wild : function( filter, iFilter, exact, iExact, cached, index, table, wo, parsed, rowArray ) {
- if ( /[\?|\*]/.test(iFilter) || /\s+OR\s+/i.test(filter) ) {
- var c = table.config,
- query = iFilter.replace(/\s+OR\s+/gi,"|");
- // look for an exact match with the "or" unless the "filter-match" class is found
- if (!c.$headers.filter('[data-column="' + index + '"]:last').hasClass('filter-match') && /\|/.test(query)) {
- query = $.isArray(rowArray) ? '(' + query + ')' : '^(' + query + ')$';
- }
- return new RegExp( query.replace(/\?/g, '\\S{1}').replace(/\*/g, '\\S*') ).test(iExact);
- }
- return null;
- },
- // fuzzy text search; modified from https://github.com/mattyork/fuzzy (MIT license)
- fuzzy: function( filter, iFilter, exact, iExact ) {
- if ( /^~/.test(iFilter) ) {
- var indx,
- patternIndx = 0,
- len = iExact.length,
- pattern = iFilter.slice(1);
- for (indx = 0; indx < len; indx++) {
- if (iExact[indx] === pattern[patternIndx]) {
- patternIndx += 1;
- }
- }
- if (patternIndx === pattern.length) {
- return true;
- }
- return false;
- }
- return null;
- }
- },
- init: function(table, c, wo) {
- var options, string, $header, column, filters, time;
- if (c.debug) {
- time = new Date();
- }
- c.$table.addClass('hasFilters');
-
- ts.filter.regex.child = new RegExp(c.cssChildRow);
- ts.filter.regex.filtered = new RegExp(wo.filter_filteredRow);
-
- // don't build filter row if columnFilters is false or all columns are set to "filter-false" - issue #156
- if (wo.filter_columnFilters !== false && c.$headers.filter('.filter-false').length !== c.$headers.length) {
- // build filter row
- ts.filter.buildRow(table, c, wo);
- }
-
- c.$table.bind('addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '.split(' ').join(c.namespace + 'filter '), function(event, filter) {
- c.$table.find('.' + ts.css.filterRow).toggle( !(wo.filter_hideEmpty && $.isEmptyObject(c.cache)) ); // fixes #450
- if ( !/(search|filter)/.test(event.type) ) {
- event.stopPropagation();
- ts.filter.buildDefault(table, true);
- }
- if (event.type === 'filterReset') {
- ts.filter.searching(table, []);
- } else if (event.type === 'filterEnd') {
- ts.filter.buildDefault(table, true);
- } else {
- // send false argument to force a new search; otherwise if the filter hasn't changed, it will return
- filter = event.type === 'search' ? filter : event.type === 'updateComplete' ? c.$table.data('lastSearch') : '';
- if (/(update|add)/.test(event.type) && event.type !== "updateComplete") {
- // force a new search since content has changed
- c.lastCombinedFilter = null;
- }
- // pass true (skipFirst) to prevent the tablesorter.setFilters function from skipping the first input
- // ensures all inputs are updated when a search is triggered on the table $('table').trigger('search', [...]);
- ts.filter.searching(table, filter, true);
- }
- return false;
- });
-
- // reset button/link
- if (wo.filter_reset) {
- if (wo.filter_reset instanceof $) {
- // reset contains a jQuery object, bind to it
- wo.filter_reset.click(function(){
- c.$table.trigger('filterReset');
- });
- } else if ($(wo.filter_reset).length) {
- // reset is a jQuery selector, use event delegation
- $(document)
- .undelegate(wo.filter_reset, 'click.tsfilter')
- .delegate(wo.filter_reset, 'click.tsfilter', function() {
- // trigger a reset event, so other functions (filterFormatter) know when to reset
- c.$table.trigger('filterReset');
- });
- }
- }
- if (wo.filter_functions) {
- // column = column # (string)
- for (column in wo.filter_functions) {
- if (wo.filter_functions.hasOwnProperty(column) && typeof column === 'string') {
- $header = c.$headers.filter('[data-column="' + column + '"]:last');
- options = '';
- if (wo.filter_functions[column] === true && !$header.hasClass('filter-false')) {
- ts.filter.buildSelect(table, column);
- } else if (typeof column === 'string' && !$header.hasClass('filter-false')) {
- // add custom drop down list
- for (string in wo.filter_functions[column]) {
- if (typeof string === 'string') {
- options += options === '' ?
- '' + ($header.data('placeholder') || $header.attr('data-placeholder') || wo.filter_placeholder.select || '') + ' ' : '';
- options += '' + string + ' ';
- }
- }
- c.$table.find('thead').find('select.' + ts.css.filter + '[data-column="' + column + '"]').append(options);
- }
- }
- }
- }
- // not really updating, but if the column has both the "filter-select" class & filter_functions set to true,
- // it would append the same options twice.
- ts.filter.buildDefault(table, true);
-
- ts.filter.bindSearch( table, c.$table.find('.' + ts.css.filter), true );
- if (wo.filter_external) {
- ts.filter.bindSearch( table, wo.filter_external );
- }
-
- if (wo.filter_hideFilters) {
- ts.filter.hideFilters(table, c);
- }
-
- // show processing icon
- if (c.showProcessing) {
- c.$table.bind('filterStart' + c.namespace + 'filter filterEnd' + c.namespace + 'filter', function(event, columns) {
- // only add processing to certain columns to all columns
- $header = (columns) ? c.$table.find('.' + ts.css.header).filter('[data-column]').filter(function() {
- return columns[$(this).data('column')] !== '';
- }) : '';
- ts.isProcessing(table, event.type === 'filterStart', columns ? $header : '');
- });
- }
-
- if (c.debug) {
- ts.benchmark("Applying Filter widget", time);
- }
- // add default values
- c.$table.bind('tablesorter-initialized pagerInitialized', function() {
- filters = ts.filter.setDefaults(table, c, wo) || [];
- if (filters.length) {
- ts.setFilters(table, filters, true);
- }
- c.$table.trigger('filterFomatterUpdate');
- ts.filter.checkFilters(table, filters);
- });
- // filter widget initialized
- wo.filter_initialized = true;
- c.$table.trigger('filterInit');
- },
- setDefaults: function(table, c, wo) {
- var isArray, saved, indx,
- // get current (default) filters
- filters = ts.getFilters(table) || [];
- if (wo.filter_saveFilters && ts.storage) {
- saved = ts.storage( table, 'tablesorter-filters' ) || [];
- isArray = $.isArray(saved);
- // make sure we're not just getting an empty array
- if ( !(isArray && saved.join('') === '' || !isArray) ) { filters = saved; }
- }
- // if no filters saved, then check default settings
- if (filters.join('') === '') {
- for (indx = 0; indx < c.columns; indx++) {
- filters[indx] = c.$headers.filter('[data-column="' + indx + '"]:last').attr(wo.filter_defaultAttrib) || filters[indx];
- }
- }
- c.$table.data('lastSearch', filters);
- return filters;
- },
- buildRow: function(table, c, wo) {
- var column, $header, buildSelect, disabled, name,
- // c.columns defined in computeThIndexes()
- columns = c.columns,
- buildFilter = '';
- for (column = 0; column < columns; column++) {
- buildFilter += ' ').appendTo( c.$table.children('thead').eq(0) ).find('td');
- // build each filter input
- for (column = 0; column < columns; column++) {
- disabled = false;
- // assuming last cell of a column is the main column
- $header = c.$headers.filter('[data-column="' + column + '"]:last');
- buildSelect = (wo.filter_functions && wo.filter_functions[column] && typeof wo.filter_functions[column] !== 'function') ||
- $header.hasClass('filter-select');
- // get data from jQuery data, metadata, headers option or header class name
- if (ts.getData) {
- // get data from jQuery data, metadata, headers option or header class name
- disabled = ts.getData($header[0], c.headers[column], 'filter') === 'false';
- } else {
- // only class names and header options - keep this for compatibility with tablesorter v2.0.5
- disabled = (c.headers[column] && c.headers[column].hasOwnProperty('filter') && c.headers[column].filter === false) ||
- $header.hasClass('filter-false');
- }
- if (buildSelect) {
- buildFilter = $('').appendTo( c.$filters.eq(column) );
- } else {
- if (wo.filter_formatter && $.isFunction(wo.filter_formatter[column])) {
- buildFilter = wo.filter_formatter[column]( c.$filters.eq(column), column );
- // no element returned, so lets go find it
- if (buildFilter && buildFilter.length === 0) {
- buildFilter = c.$filters.eq(column).children('input');
- }
- // element not in DOM, so lets attach it
- if ( buildFilter && (buildFilter.parent().length === 0 ||
- (buildFilter.parent().length && buildFilter.parent()[0] !== c.$filters[column])) ) {
- c.$filters.eq(column).append(buildFilter);
- }
- } else {
- buildFilter = $('' + ( node.data('placeholder') || node.attr('data-placeholder') || wo.filter_placeholder.select || '' ) + ' ',
- arry = ts.filter.getOptionSource(table, column, onlyAvail),
- // Get curent filter value
- currentValue = c.$table.find('thead').find('select.' + ts.css.filter + '[data-column="' + column + '"]').val();
-
- // build option list
- for (indx = 0; indx < arry.length; indx++) {
- txt = arry[indx].replace(/\"/g, """);
- // replace quotes - fixes #242 & ignore empty strings - see http://stackoverflow.com/q/14990971/145346
- options += arry[indx] !== '' ? '' + arry[indx] + ' ' : '';
- }
- // update all selects in the same column (clone thead in sticky headers & any external selects) - fixes 473
- $filters = ( c.$filters ? c.$filters : c.$table.children('thead') ).find('.' + ts.css.filter);
- if (wo.filter_$externalFilters) {
- $filters = $filters && $filters.length ? $filters.add(wo.filter_$externalFilters) : wo.filter_$externalFilters;
- }
- $filters.filter('select[data-column="' + column + '"]')[ updating ? 'html' : 'append' ](options);
- },
- buildDefault: function(table, updating) {
- var columnIndex, $header,
- c = table.config,
- wo = c.widgetOptions,
- columns = c.columns;
- // build default select dropdown
- for (columnIndex = 0; columnIndex < columns; columnIndex++) {
- $header = c.$headers.filter('[data-column="' + columnIndex + '"]:last');
- // look for the filter-select class; build/update it if found
- if (($header.hasClass('filter-select') || wo.filter_functions && wo.filter_functions[columnIndex] === true) &&
- !$header.hasClass('filter-false')) {
- if (!wo.filter_functions) { wo.filter_functions = {}; }
- wo.filter_functions[columnIndex] = true; // make sure this select gets processed by filter_functions
- ts.filter.buildSelect(table, columnIndex, updating, $header.hasClass(wo.filter_onlyAvail));
- }
- }
- },
- searching: function(table, filter, skipFirst) {
- if (typeof filter === 'undefined' || filter === true) {
- var wo = table.config.widgetOptions;
- // delay filtering
- clearTimeout(wo.searchTimer);
- wo.searchTimer = setTimeout(function() {
- ts.filter.checkFilters(table, filter, skipFirst );
- }, wo.filter_liveSearch ? wo.filter_searchDelay : 10);
- } else {
- // skip delay
- ts.filter.checkFilters(table, filter, skipFirst);
- }
- }
-};
-
-ts.getFilters = function(table, getRaw, setFilters, skipFirst) {
- var i, $filters, $column,
- filters = false,
- c = table ? $(table)[0].config : '',
- wo = c ? c.widgetOptions : '';
- if (getRaw !== true && wo && !wo.filter_columnFilters) {
- return $(table).data('lastSearch');
- }
- if (c) {
- if (c.$filters) {
- $filters = c.$filters.find('.' + ts.css.filter);
- }
- if (wo.filter_$externalFilters) {
- $filters = $filters && $filters.length ? $filters.add(wo.filter_$externalFilters) : wo.filter_$externalFilters;
- }
- if ($filters && $filters.length) {
- filters = setFilters || [];
- for (i = 0; i < c.columns + 1; i++) {
- $column = $filters.filter('[data-column="' + (i === c.columns ? 'all' : i) + '"]');
- if ($column.length) {
- // move the latest search to the first slot in the array
- $column = $column.sort(function(a, b){
- return $(b).attr('data-lastSearchTime') - $(a).attr('data-lastSearchTime');
- });
- if ($.isArray(setFilters)) {
- // skip first (latest input) to maintain cursor position while typing
- (skipFirst ? $column.slice(1) : $column).val( setFilters[i] ).trigger('change.tsfilter');
- } else {
- filters[i] = $column.val() || '';
- // don't change the first... it will move the cursor
- $column.slice(1).val( filters[i] );
- }
- // save any match input dynamically
- if (i === c.columns && $column.length) {
- wo.filter_$anyMatch = $column;
- }
- }
- }
- }
- }
- if (filters.length === 0) {
- filters = false;
- }
- return filters;
-};
-
-ts.setFilters = function(table, filter, apply, skipFirst) {
- var c = table ? $(table)[0].config : '',
- valid = ts.getFilters(table, true, filter, skipFirst);
- if (c && apply) {
- // ensure new set filters are applied, even if the search is the same
- c.lastCombinedFilter = null;
- ts.filter.searching(c.$table[0], filter, skipFirst);
- c.$table.trigger('filterFomatterUpdate');
- }
- return !!valid;
-};
-
-// Widget: 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_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),
- $thead = $table.children('thead:first'),
- $win = $attach.length ? $attach : $(window),
- $header = $thead.children('tr').not('.sticky-false').children(),
- innerHeader = '.' + ts.css.headerIn,
- $tfoot = $table.find('tfoot'),
- $stickyOffset = isNaN(wo.stickyHeaders_offset) ? $(wo.stickyHeaders_offset) : '',
- stickyOffset = $attach.length ? 0 : $stickyOffset.length ?
- $stickyOffset.height() || 0 : parseInt(wo.stickyHeaders_offset, 10) || 0,
- $stickyTable = wo.$sticky = $table.clone()
- .addClass('containsStickyHeaders')
- .css({
- position : $attach.length ? 'absolute' : 'fixed',
- margin : 0,
- top : stickyOffset,
- left : 0,
- visibility : 'hidden',
- zIndex : wo.stickyHeaders_zIndex ? wo.stickyHeaders_zIndex : 2
- }),
- $stickyThead = $stickyTable.children('thead:first').addClass(ts.css.sticky + ' ' + wo.stickyHeaders),
- $stickyCells,
- laststate = '',
- spacing = 0,
- nonwkie = $table.css('border-collapse') !== 'collapse' && !/(webkit|msie)/i.test(navigator.userAgent),
- resizeHeader = function() {
- stickyOffset = $stickyOffset.length ? $stickyOffset.height() || 0 : parseInt(wo.stickyHeaders_offset, 10) || 0;
- spacing = 0;
- // yes, I dislike browser sniffing, but it really is needed here :(
- // webkit automatically compensates for border spacing
- if (nonwkie) {
- // Firefox & Opera use the border-spacing
- // update border-spacing here because of demos that switch themes
- spacing = parseInt($header.eq(0).css('border-left-width'), 10) * 2;
- }
- $stickyTable.css({
- left : $attach.length ? (parseInt($attach.css('padding-left'), 10) || 0) + parseInt(c.$table.css('padding-left'), 10) +
- parseInt(c.$table.css('margin-left'), 10) + parseInt($table.css('border-left-width'), 10) :
- $thead.offset().left - $win.scrollLeft() - spacing,
- width: $table.width()
- });
- $stickyCells.filter(':visible').each(function(i) {
- var $cell = $header.filter(':visible').eq(i),
- // some wibbly-wobbly... timey-wimey... stuff, to make columns line up in Firefox
- offset = nonwkie && $(this).attr('data-column') === ( '' + parseInt(c.columns/2, 10) ) ? 1 : 0;
- $(this)
- .css({
- width: $cell.width() - spacing,
- height: $cell.height()
- })
- .find(innerHeader).width( $cell.find(innerHeader).width() - offset );
- });
- };
- // 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();
- if (!wo.stickyHeaders_includeCaption) {
- $stickyTable.find('caption').remove();
- } else {
- $stickyTable.find('caption').css( 'margin-left', '-1px' );
- }
- // issue #172 - find td/th in sticky header
- $stickyCells = $stickyThead.children().children();
- $stickyTable.css({ height:0, width:0, padding:0, margin:0, border: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.tsSticky', 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( $stickyTable );
- // make it sticky!
- $win.bind('scroll.tsSticky resize.tsSticky', function(event) {
- if (!$table.is(':visible')) { return; } // fixes #278
- var prefix = 'tablesorter-sticky-',
- offset = $table.offset(),
- captionHeight = (wo.stickyHeaders_includeCaption ? 0 : $table.find('caption').outerHeight(true)),
- scrollTop = ($attach.length ? $attach.offset().top : $win.scrollTop()) + stickyOffset - captionHeight,
- tableHeight = $table.height() - ($stickyTable.height() + ($tfoot.height() || 0)),
- isVisible = (scrollTop > offset.top) && (scrollTop < offset.top + tableHeight) ? 'visible' : 'hidden',
- cssSettings = { visibility : isVisible };
- if ($attach.length) {
- cssSettings.top = $attach.scrollTop();
- } else {
- // adjust when scrolling horizontally - fixes issue #143
- cssSettings.left = $thead.offset().left - $win.scrollLeft() - spacing;
- }
- $stickyTable
- .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')) {
- // scroll table into view after filtering, if sticky header is active - #482
- $table.bind('filterEnd', 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 ($stickyTable.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) );
- }
-
- $table.trigger('stickyHeadersInit');
-
- },
- remove: function(table, c, wo) {
- c.$table
- .removeClass('hasStickyHeaders')
- .unbind('pagerComplete.tsSticky')
- .find('.' + ts.css.sticky).remove();
- if (wo.$sticky && wo.$sticky.length) { wo.$sticky.remove(); } // remove cloned table
- // don't unbind if any table on the page still has stickyheaders applied
- if (!$('.hasStickyHeaders').length) {
- $(window).unbind('scroll.tsSticky resize.tsSticky');
- }
- ts.addHeaderResizeEvent(table, false);
- }
-});
-
-// Add Column resizing widget
-// 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 : []
- },
- 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,
- storedSizes = {},
- $table = c.$table,
- mouseXPosition = 0,
- $target = null,
- $next = null,
- fullWidth = Math.abs($table.parent().width() - $table.width()) < 20,
- 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, 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('
');
- }
- // 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 grip
- $column
- .find('.' + ts.css.wrapper)
- .append('
');
- })
- .bind('mousemove.tsresize', function(event) {
- // ignore mousemove if no mousedown
- 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 );
- }
- mouseXPosition = event.pageX;
- })
- .bind('mouseup.tsresize', function() {
- stopResize();
- })
- .find('.' + ts.css.resizer + ',.' + ts.css.grip)
- .bind('mousedown', function(event) {
- // save header cell and mouse position; closest() not supported by jQuery v1.2.6
- $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;
- });
- $table.find('thead:first')
- .bind('mouseup.tsresize mouseleave.tsresize', function() {
- stopResize();
- })
- // right click to reset columns to default widths
- .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 + ',.' + ts.css.grip).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[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', {}); }
- }
- });
-};
-
-// Save table sort widget
-// 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) {
- // clear storage
- if (ts.storage) { ts.storage( table, 'tablesorter-savesort', '' ); }
- }
-});
-
-})(jQuery);
diff --git a/app/assets/javascripts/login.js b/app/assets/javascripts/login.js
index e694be6..3c6cf0b 100644
--- a/app/assets/javascripts/login.js
+++ b/app/assets/javascripts/login.js
@@ -1,5 +1,4 @@
$(function(){
-
//plugin check
if($(".login-error").length){
errorMsg = $(".login-error").text();
@@ -9,14 +8,4 @@ $(function(){
});
}
}
-
- //version check
- if($(".login-error").length){
- errorMsg = $(".login-error").text();
- if (errorMsg.match(/unsupport version/)) {
- $('#version-restrict-modal').modal({
- show: true,
- });
- }
- }
});
diff --git a/app/assets/javascripts/storage.js b/app/assets/javascripts/storage.js
index 18dcff7..b88906d 100644
--- a/app/assets/javascripts/storage.js
+++ b/app/assets/javascripts/storage.js
@@ -65,7 +65,7 @@ $(function(){
if (validate(port, true, true)) {
$('.snap-explanation').text('Please execute below command on your ROMA server');
$('.snap-command').css({"padding":"10px"});
- $('.snap-command').html("$ cd ${ROMA directory}/ruby/serverwaiting : Nothing to do (Default)
diff --git a/app/views/cluster/index.html.erb b/app/views/cluster/index.html.erb
index 1f9a765..645e7df 100644
--- a/app/views/cluster/index.html.erb
+++ b/app/views/cluster/index.html.erb
@@ -12,24 +12,10 @@
- <% if chk_roma_version(@stats_hash['others']['version']) <= Constants::VERSION_0_8_11 %>
-
-
- <% end %>
-
<% if short_vnodes?(@stats_hash) %>
- Recover is not supported with this ROMA version and this lost_action setting.
-
- <% else %>
- ROMA have short vnodes. You can solve by executing "Recover" button.
- <% end %>
+ ROMA have short vnodes. You can solve by executing "Recover" button.
<% end %>
@@ -83,13 +69,12 @@
ROMA version
- <% if past_version?(@stats_hash) %>
+ <% if chk_roma_version(@stats_hash['others']['version']) < Constants::VERSION_1_0_0 %>
<% end %>
<%= @stats_hash["others"]["version"] %>
- <% if past_version?(@stats_hash) %>Unsupport version <% end %>
- <% if eosl_expired?(@stats_hash) %>EOSL expired <% end %>
+ <% if chk_roma_version(@stats_hash['others']['version']) < Constants::VERSION_1_0_0 %>Unsupport version <% end %>
<% @routing_info.each do |instance, info| %>
<% if chk_main_version(info["version"]) %>
<%= "#{instance} using #{info["version"]}" %>
@@ -153,6 +138,25 @@
+
Storage Type
+
+ <% case @stats_hash['storages[roma]']['storage.st_class'] %>
+ <% when 'RubyHashStorage' %>
+ <%= image_tag 'ruby_logo.png', :width => '50' %>
+ Memory Mode
+ <% when 'TCStorage' %>
+ <%= image_tag 'tc_logo.png', :width => '200'%>
+ <% when 'GroongaStorage' %>
+ <%= image_tag 'groonga_logo.png', :width => '200' %>
+ <% else %>
+
others
+ <% end %>
+
+