';
for ( column = 0; column < columns; column++ ) {
if ( c.$headerIndexed[ column ].length ) {
// account for entire column set with colspan. See #1047
tmp = c.$headerIndexed[ column ] && c.$headerIndexed[ column ][0].colSpan || 0;
if ( tmp > 1 ) {
buildFilter += '| ' ).appendTo( $filter );
} else {
ffxn = ts.getColumnData( table, wo.filter_formatter, column );
if ( ffxn ) {
wo.filter_formatterCount++;
buildFilter = ffxn( $filter, column );
// no element returned, so lets go find it
if ( buildFilter && buildFilter.length === 0 ) {
buildFilter = $filter.children( 'input' );
}
// element not in DOM, so lets attach it
if ( buildFilter && ( buildFilter.parent().length === 0 ||
( buildFilter.parent().length && buildFilter.parent()[0] !== $filter[0] ) ) ) {
$filter.append( buildFilter );
}
} else {
buildFilter = $( '' ).appendTo( $filter );
}
if ( buildFilter ) {
tmp = $header.data( 'placeholder' ) ||
$header.attr( 'data-placeholder' ) ||
wo.filter_placeholder.search || '';
buildFilter.attr( 'placeholder', tmp );
}
}
if ( buildFilter ) {
// add filter class name
name = ( $.isArray( wo.filter_cssFilter ) ?
( typeof wo.filter_cssFilter[column] !== 'undefined' ? wo.filter_cssFilter[column] || '' : '' ) :
wo.filter_cssFilter ) || '';
// copy data-column from table cell (it will include colspan)
buildFilter.addClass( tscss.filter + ' ' + name ).attr( 'data-column', $filter.attr( 'data-column' ) );
if ( disabled ) {
buildFilter.attr( 'placeholder', '' ).addClass( tscss.filterDisabled )[0].disabled = true;
}
}
}
}
},
bindSearch: function( table, $el, internal ) {
table = $( table )[0];
$el = $( $el ); // allow passing a selector string
if ( !$el.length ) { return; }
var tmp,
c = table.config,
wo = c.widgetOptions,
namespace = c.namespace + 'filter',
$ext = wo.filter_$externalFilters;
if ( internal !== true ) {
// save anyMatch element
tmp = wo.filter_anyColumnSelector + ',' + wo.filter_multipleColumnSelector;
wo.filter_$anyMatch = $el.filter( tmp );
if ( $ext && $ext.length ) {
wo.filter_$externalFilters = wo.filter_$externalFilters.add( $el );
} else {
wo.filter_$externalFilters = $el;
}
// update values ( external filters added after table initialization )
ts.setFilters( table, c.$table.data( 'lastSearch' ) || [], internal === false );
}
// unbind events
tmp = ( 'keypress keyup keydown search change input '.split( ' ' ).join( namespace + ' ' ) );
$el
// use data attribute instead of jQuery data since the head is cloned without including
// the data/binding
.attr( 'data-lastSearchTime', new Date().getTime() )
.unbind( tmp.replace( ts.regex.spaces, ' ' ) )
.bind( 'keydown' + namespace, function( event ) {
if ( event.which === tskeyCodes.escape && !table.config.widgetOptions.filter_resetOnEsc ) {
// prevent keypress event
return false;
}
})
.bind( 'keyup' + namespace, function( event ) {
wo = table.config.widgetOptions; // make sure "wo" isn't cached
var column = parseInt( $( this ).attr( 'data-column' ), 10 ),
liveSearch = typeof wo.filter_liveSearch === 'boolean' ? wo.filter_liveSearch :
ts.getColumnData( table, wo.filter_liveSearch, column );
if ( typeof liveSearch === 'undefined' ) {
liveSearch = wo.filter_liveSearch.fallback || false;
}
$( this ).attr( 'data-lastSearchTime', new Date().getTime() );
// emulate what webkit does.... escape clears the filter
if ( event.which === tskeyCodes.escape ) {
// make sure to restore the last value on escape
this.value = wo.filter_resetOnEsc ? '' : c.lastSearch[column];
// don't return if the search value is empty ( all rows need to be revealed )
} else if ( this.value !== '' && (
// liveSearch can contain a min value length; ignore arrow and meta keys, but allow backspace
( typeof liveSearch === 'number' && this.value.length < liveSearch ) ||
// let return & backspace continue on, but ignore arrows & non-valid characters
( event.which !== tskeyCodes.enter && event.which !== tskeyCodes.backSpace &&
( event.which < tskeyCodes.space || ( event.which >= tskeyCodes.left && event.which <= tskeyCodes.down ) ) ) ) ) {
return;
// live search
} else if ( liveSearch === false ) {
if ( this.value !== '' && event.which !== tskeyCodes.enter ) {
return;
}
}
// change event = no delay; last true flag tells getFilters to skip newest timed input
tsf.searching( table, true, true, column );
})
// include change for select - fixes #473
.bind( 'search change keypress input blur '.split( ' ' ).join( namespace + ' ' ), function( event ) {
// don't get cached data, in case data-column changes dynamically
var column = parseInt( $( this ).attr( 'data-column' ), 10 ),
eventType = event.type,
liveSearch = typeof wo.filter_liveSearch === 'boolean' ?
wo.filter_liveSearch :
ts.getColumnData( table, wo.filter_liveSearch, column );
if ( table.config.widgetOptions.filter_initialized &&
// immediate search if user presses enter
( event.which === tskeyCodes.enter ||
// immediate search if a "search" or "blur" is triggered on the input
( eventType === 'search' || eventType === 'blur' ) ||
// change & input events must be ignored if liveSearch !== true
( eventType === 'change' || eventType === 'input' ) &&
// prevent search if liveSearch is a number
( liveSearch === true || liveSearch !== true && event.target.nodeName !== 'INPUT' ) &&
// don't allow 'change' or 'input' event to process if the input value
// is the same - fixes #685
this.value !== c.lastSearch[column]
)
) {
event.preventDefault();
// init search with no delay
$( this ).attr( 'data-lastSearchTime', new Date().getTime() );
tsf.searching( table, eventType !== 'keypress', true, column );
}
});
},
searching: function( table, filter, skipFirst, column ) {
var liveSearch,
wo = table.config.widgetOptions;
if (typeof column === 'undefined') {
// no delay
liveSearch = false;
} else {
liveSearch = typeof wo.filter_liveSearch === 'boolean' ?
wo.filter_liveSearch :
// get column setting, or set to fallback value, or default to false
ts.getColumnData( table, wo.filter_liveSearch, column );
if ( typeof liveSearch === 'undefined' ) {
liveSearch = wo.filter_liveSearch.fallback || false;
}
}
clearTimeout( wo.filter_searchTimer );
if ( typeof filter === 'undefined' || filter === true ) {
// delay filtering
wo.filter_searchTimer = setTimeout( function() {
tsf.checkFilters( table, filter, skipFirst );
}, liveSearch ? wo.filter_searchDelay : 10 );
} else {
// skip delay
tsf.checkFilters( table, filter, skipFirst );
}
},
equalFilters: function (c, filter1, filter2) {
var indx,
f1 = [],
f2 = [],
len = c.columns + 1; // add one to include anyMatch filter
filter1 = $.isArray(filter1) ? filter1 : [];
filter2 = $.isArray(filter2) ? filter2 : [];
for (indx = 0; indx < len; indx++) {
f1[indx] = filter1[indx] || '';
f2[indx] = filter2[indx] || '';
}
return f1.join(',') === f2.join(',');
},
checkFilters: function( table, filter, skipFirst ) {
var c = table.config,
wo = c.widgetOptions,
filterArray = $.isArray( filter ),
filters = ( filterArray ) ? filter : ts.getFilters( table, true ),
currentFilters = filters || []; // current filter values
// prevent errors if delay init is set
if ( $.isEmptyObject( c.cache ) ) {
// update cache if delayInit set & pager has initialized ( after user initiates a search )
if ( c.delayInit && ( !c.pager || c.pager && c.pager.initialized ) ) {
ts.updateCache( c, function() {
tsf.checkFilters( table, false, skipFirst );
});
}
return;
}
// add filter array back into inputs
if ( filterArray ) {
ts.setFilters( table, filters, false, skipFirst !== true );
if ( !wo.filter_initialized ) {
c.lastSearch = [];
c.lastCombinedFilter = '';
}
}
if ( wo.filter_hideFilters ) {
// show/hide filter row as needed
c.$table
.find( '.' + tscss.filterRow )
.triggerHandler( tsf.hideFiltersCheck( c ) ? 'mouseleave' : 'mouseenter' );
}
// return if the last search is the same; but filter === false when updating the search
// see example-widget-filter.html filter toggle buttons
if ( tsf.equalFilters(c, c.lastSearch, currentFilters) && filter !== false ) {
return;
} else if ( filter === false ) {
// force filter refresh
c.lastCombinedFilter = '';
c.lastSearch = [];
}
// define filter inside it is false
filters = filters || [];
// convert filters to strings - see #1070
filters = Array.prototype.map ?
filters.map( String ) :
// for IE8 & older browsers - maybe not the best method
filters.join( '\ufffd' ).split( '\ufffd' );
if ( wo.filter_initialized ) {
c.$table.triggerHandler( 'filterStart', [ filters ] );
}
if ( c.showProcessing ) {
// give it time for the processing icon to kick in
setTimeout( function() {
tsf.findRows( table, filters, currentFilters );
return false;
}, 30 );
} else {
tsf.findRows( table, filters, currentFilters );
return false;
}
},
hideFiltersCheck: function( c ) {
if (typeof c.widgetOptions.filter_hideFilters === 'function') {
var val = c.widgetOptions.filter_hideFilters( c );
if (typeof val === 'boolean') {
return val;
}
}
return ts.getFilters( c.$table ).join( '' ) === '';
},
hideFilters: function( c, $table ) {
var timer;
( $table || c.$table )
.find( '.' + tscss.filterRow )
.addClass( tscss.filterRowHide )
.bind( 'mouseenter mouseleave', function( e ) {
// save event object - http://bugs.jquery.com/ticket/12140
var event = e,
$row = $( this );
clearTimeout( timer );
timer = setTimeout( function() {
if ( /enter|over/.test( event.type ) ) {
$row.removeClass( tscss.filterRowHide );
} else {
// don't hide if input has focus
// $( ':focus' ) needs jQuery 1.6+
if ( $( document.activeElement ).closest( 'tr' )[0] !== $row[0] ) {
// don't hide row if any filter has a value
$row.toggleClass( tscss.filterRowHide, tsf.hideFiltersCheck( c ) );
}
}
}, 200 );
})
.find( 'input, select' ).bind( 'focus blur', function( e ) {
var event = e,
$row = $( this ).closest( 'tr' );
clearTimeout( timer );
timer = setTimeout( function() {
clearTimeout( timer );
// don't hide row if any filter has a value
$row.toggleClass( tscss.filterRowHide, tsf.hideFiltersCheck( c ) && event.type !== 'focus' );
}, 200 );
});
},
defaultFilter: function( filter, mask ) {
if ( filter === '' ) { return filter; }
var regex = tsfRegex.iQuery,
maskLen = mask.match( tsfRegex.igQuery ).length,
query = maskLen > 1 ? $.trim( filter ).split( /\s/ ) : [ $.trim( filter ) ],
len = query.length - 1,
indx = 0,
val = mask;
if ( len < 1 && maskLen > 1 ) {
// only one 'word' in query but mask has >1 slots
query[1] = query[0];
}
// replace all {query} with query words...
// if query = 'Bob', then convert mask from '!{query}' to '!Bob'
// if query = 'Bob Joe Frank', then convert mask '{q} OR {q}' to 'Bob OR Joe OR Frank'
while ( regex.test( val ) ) {
val = val.replace( regex, query[indx++] || '' );
if ( regex.test( val ) && indx < len && ( query[indx] || '' ) !== '' ) {
val = mask.replace( regex, val );
}
}
return val;
},
getLatestSearch: function( $input ) {
if ( $input ) {
return $input.sort( function( a, b ) {
return $( b ).attr( 'data-lastSearchTime' ) - $( a ).attr( 'data-lastSearchTime' );
});
}
return $input || $();
},
findRange: function( c, val, ignoreRanges ) {
// look for multiple columns '1-3,4-6,8' in data-column
var temp, ranges, range, start, end, singles, i, indx, len,
columns = [];
if ( /^[0-9]+$/.test( val ) ) {
// always return an array
return [ parseInt( val, 10 ) ];
}
// process column range
if ( !ignoreRanges && /-/.test( val ) ) {
ranges = val.match( /(\d+)\s*-\s*(\d+)/g );
len = ranges ? ranges.length : 0;
for ( indx = 0; indx < len; indx++ ) {
range = ranges[indx].split( /\s*-\s*/ );
start = parseInt( range[0], 10 ) || 0;
end = parseInt( range[1], 10 ) || ( c.columns - 1 );
if ( start > end ) {
temp = start; start = end; end = temp; // swap
}
if ( end >= c.columns ) {
end = c.columns - 1;
}
for ( ; start <= end; start++ ) {
columns[ columns.length ] = start;
}
// remove processed range from val
val = val.replace( ranges[ indx ], '' );
}
}
// process single columns
if ( !ignoreRanges && /,/.test( val ) ) {
singles = val.split( /\s*,\s*/ );
len = singles.length;
for ( i = 0; i < len; i++ ) {
if ( singles[ i ] !== '' ) {
indx = parseInt( singles[ i ], 10 );
if ( indx < c.columns ) {
columns[ columns.length ] = indx;
}
}
}
}
// return all columns
if ( !columns.length ) {
for ( indx = 0; indx < c.columns; indx++ ) {
columns[ columns.length ] = indx;
}
}
return columns;
},
getColumnElm: function( c, $elements, column ) {
// data-column may contain multiple columns '1-3,5-6,8'
// replaces: c.$filters.filter( '[data-column="' + column + '"]' );
return $elements.filter( function() {
var cols = tsf.findRange( c, $( this ).attr( 'data-column' ) );
return $.inArray( column, cols ) > -1;
});
},
multipleColumns: function( c, $input ) {
// look for multiple columns '1-3,4-6,8' in data-column
var wo = c.widgetOptions,
// only target 'all' column inputs on initialization
// & don't target 'all' column inputs if they don't exist
targets = wo.filter_initialized || !$input.filter( wo.filter_anyColumnSelector ).length,
val = $.trim( tsf.getLatestSearch( $input ).attr( 'data-column' ) || '' );
return tsf.findRange( c, val, !targets );
},
processTypes: function( c, data, vars ) {
var ffxn,
filterMatched = null,
matches = null;
for ( ffxn in tsf.types ) {
if ( $.inArray( ffxn, vars.excludeMatch ) < 0 && matches === null ) {
matches = tsf.types[ffxn]( c, data, vars );
if ( matches !== null ) {
filterMatched = matches;
}
}
}
return filterMatched;
},
matchType: function( c, columnIndex ) {
var isMatch,
wo = c.widgetOptions,
$el = c.$headerIndexed[ columnIndex ];
// filter-exact > filter-match > filter_matchType for type
if ( $el.hasClass( 'filter-exact' ) ) {
isMatch = false;
} else if ( $el.hasClass( 'filter-match' ) ) {
isMatch = true;
} else {
// filter-select is not applied when filter_functions are used, so look for a select
if ( wo.filter_columnFilters ) {
$el = c.$filters
.find( '.' + tscss.filter )
.add( wo.filter_$externalFilters )
.filter( '[data-column="' + columnIndex + '"]' );
} else if ( wo.filter_$externalFilters ) {
$el = wo.filter_$externalFilters.filter( '[data-column="' + columnIndex + '"]' );
}
isMatch = $el.length ?
c.widgetOptions.filter_matchType[ ( $el[ 0 ].nodeName || '' ).toLowerCase() ] === 'match' :
// default to exact, if no inputs found
false;
}
return isMatch;
},
processRow: function( c, data, vars ) {
var result, filterMatched,
fxn, ffxn, txt,
wo = c.widgetOptions,
showRow = true,
hasAnyMatchInput = wo.filter_$anyMatch && wo.filter_$anyMatch.length,
// if wo.filter_$anyMatch data-column attribute is changed dynamically
// we don't want to do an "anyMatch" search on one column using data
// for the entire row - see #998
columnIndex = wo.filter_$anyMatch && wo.filter_$anyMatch.length ?
// look for multiple columns '1-3,4-6,8'
tsf.multipleColumns( c, wo.filter_$anyMatch ) :
[];
data.$cells = data.$row.children();
if ( data.anyMatchFlag && columnIndex.length > 1 || ( data.anyMatchFilter && !hasAnyMatchInput ) ) {
data.anyMatch = true;
data.isMatch = true;
data.rowArray = data.$cells.map( function( i ) {
if ( $.inArray( i, columnIndex ) > -1 || ( data.anyMatchFilter && !hasAnyMatchInput ) ) {
if ( data.parsed[ i ] ) {
txt = data.cacheArray[ i ];
} else {
txt = data.rawArray[ i ];
txt = $.trim( wo.filter_ignoreCase ? txt.toLowerCase() : txt );
if ( c.sortLocaleCompare ) {
txt = ts.replaceAccents( txt );
}
}
return txt;
}
}).get();
data.filter = data.anyMatchFilter;
data.iFilter = data.iAnyMatchFilter;
data.exact = data.rowArray.join( ' ' );
data.iExact = wo.filter_ignoreCase ? data.exact.toLowerCase() : data.exact;
data.cache = data.cacheArray.slice( 0, -1 ).join( ' ' );
vars.excludeMatch = vars.noAnyMatch;
filterMatched = tsf.processTypes( c, data, vars );
if ( filterMatched !== null ) {
showRow = filterMatched;
} else {
if ( wo.filter_startsWith ) {
showRow = false;
// data.rowArray may not contain all columns
columnIndex = Math.min( c.columns, data.rowArray.length );
while ( !showRow && columnIndex > 0 ) {
columnIndex--;
showRow = showRow || data.rowArray[ columnIndex ].indexOf( data.iFilter ) === 0;
}
} else {
showRow = ( data.iExact + data.childRowText ).indexOf( data.iFilter ) >= 0;
}
}
data.anyMatch = false;
// no other filters to process
if ( data.filters.join( '' ) === data.filter ) {
return showRow;
}
}
for ( columnIndex = 0; columnIndex < c.columns; columnIndex++ ) {
data.filter = data.filters[ columnIndex ];
data.index = columnIndex;
// filter types to exclude, per column
vars.excludeMatch = vars.excludeFilter[ columnIndex ];
// ignore if filter is empty or disabled
if ( data.filter ) {
data.cache = data.cacheArray[ columnIndex ];
result = data.parsed[ columnIndex ] ? data.cache : data.rawArray[ columnIndex ] || '';
data.exact = c.sortLocaleCompare ? ts.replaceAccents( result ) : result; // issue #405
data.iExact = !tsfRegex.type.test( typeof data.exact ) && wo.filter_ignoreCase ?
data.exact.toLowerCase() : data.exact;
data.isMatch = tsf.matchType( c, columnIndex );
result = showRow; // if showRow is true, show that row
// in case select filter option has a different value vs text 'a - z|A through Z'
ffxn = wo.filter_columnFilters ?
c.$filters.add( wo.filter_$externalFilters )
.filter( '[data-column="' + columnIndex + '"]' )
.find( 'select option:selected' )
.attr( 'data-function-name' ) || '' : '';
// replace accents - see #357
if ( c.sortLocaleCompare ) {
data.filter = ts.replaceAccents( data.filter );
}
// replace column specific default filters - see #1088
if ( wo.filter_defaultFilter && tsfRegex.iQuery.test( vars.defaultColFilter[ columnIndex ] ) ) {
data.filter = tsf.defaultFilter( data.filter, vars.defaultColFilter[ columnIndex ] );
}
// data.iFilter = case insensitive ( if wo.filter_ignoreCase is true ),
// data.filter = case sensitive
data.iFilter = wo.filter_ignoreCase ? ( data.filter || '' ).toLowerCase() : data.filter;
fxn = vars.functions[ columnIndex ];
filterMatched = null;
if ( fxn ) {
if ( typeof fxn === 'function' ) {
// filter callback( exact cell content, parser normalized content,
// filter input value, column index, jQuery row object )
filterMatched = fxn( data.exact, data.cache, data.filter, columnIndex, data.$row, c, data );
} else if ( typeof fxn[ ffxn || data.filter ] === 'function' ) {
// selector option function
txt = ffxn || data.filter;
filterMatched =
fxn[ txt ]( data.exact, data.cache, data.filter, columnIndex, data.$row, c, data );
}
}
if ( filterMatched === null ) {
// cycle through the different filters
// filters return a boolean or null if nothing matches
filterMatched = tsf.processTypes( c, data, vars );
if ( filterMatched !== null ) {
result = filterMatched;
// Look for match, and add child row data for matching
} else {
// check fxn (filter-select in header) after filter types are checked
// without this, the filter + jQuery UI selectmenu demo was breaking
if ( fxn === true ) {
// default selector uses exact match unless 'filter-match' class is found
result = data.isMatch ?
// data.iExact may be a number
( '' + data.iExact ).search( data.iFilter ) >= 0 :
data.filter === data.exact;
} else {
txt = ( data.iExact + data.childRowText ).indexOf( tsf.parseFilter( c, data.iFilter, data ) );
result = ( ( !wo.filter_startsWith && txt >= 0 ) || ( wo.filter_startsWith && txt === 0 ) );
}
}
} else {
result = filterMatched;
}
showRow = ( result ) ? showRow : false;
}
}
return showRow;
},
findRows: function( table, filters, currentFilters ) {
if (
tsf.equalFilters(table.config, table.config.lastSearch, currentFilters) ||
!table.config.widgetOptions.filter_initialized
) {
return;
}
var len, norm_rows, rowData, $rows, $row, rowIndex, tbodyIndex, $tbody, columnIndex,
isChild, childRow, lastSearch, showRow, showParent, time, val, indx,
notFiltered, searchFiltered, query, injected, res, id, txt,
storedFilters = $.extend( [], filters ),
c = table.config,
wo = c.widgetOptions,
// data object passed to filters; anyMatch is a flag for the filters
data = {
anyMatch: false,
filters: filters,
// regex filter type cache
filter_regexCache : []
},
vars = {
// anyMatch really screws up with these types of filters
noAnyMatch: [ 'range', 'operators' ],
// cache filter variables that use ts.getColumnData in the main loop
functions : [],
excludeFilter : [],
defaultColFilter : [],
defaultAnyFilter : ts.getColumnData( table, wo.filter_defaultFilter, c.columns, true ) || ''
};
// parse columns after formatter, in case the class is added at that point
data.parsed = [];
for ( columnIndex = 0; columnIndex < c.columns; columnIndex++ ) {
data.parsed[ columnIndex ] = wo.filter_useParsedData ||
// parser has a "parsed" parameter
( c.parsers && c.parsers[ columnIndex ] && c.parsers[ columnIndex ].parsed ||
// getData may not return 'parsed' if other 'filter-' class names exist
// ( e.g. | )
ts.getData && ts.getData( c.$headerIndexed[ columnIndex ],
ts.getColumnData( table, c.headers, columnIndex ), 'filter' ) === 'parsed' ||
c.$headerIndexed[ columnIndex ].hasClass( 'filter-parsed' ) );
vars.functions[ columnIndex ] =
ts.getColumnData( table, wo.filter_functions, columnIndex ) ||
c.$headerIndexed[ columnIndex ].hasClass( 'filter-select' );
vars.defaultColFilter[ columnIndex ] =
ts.getColumnData( table, wo.filter_defaultFilter, columnIndex ) || '';
vars.excludeFilter[ columnIndex ] =
( ts.getColumnData( table, wo.filter_excludeFilter, columnIndex, true ) || '' ).split( /\s+/ );
}
if ( c.debug ) {
console.log( 'Filter: Starting filter widget search', filters );
time = new Date();
}
// filtered rows count
c.filteredRows = 0;
c.totalRows = 0;
currentFilters = ( storedFilters || [] );
for ( tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++ ) {
$tbody = ts.processTbody( table, c.$tbodies.eq( tbodyIndex ), true );
// skip child rows & widget added ( removable ) rows - fixes #448 thanks to @hempel!
// $rows = $tbody.children( 'tr' ).not( c.selectorRemove );
columnIndex = c.columns;
// convert stored rows into a jQuery object
norm_rows = c.cache[ tbodyIndex ].normalized;
$rows = $( $.map( norm_rows, function( el ) {
return el[ columnIndex ].$row.get();
}) );
if ( currentFilters.join('') === '' || wo.filter_serversideFiltering ) {
$rows
.removeClass( wo.filter_filteredRow )
.not( '.' + c.cssChildRow )
.css( 'display', '' );
} else {
// filter out child rows
$rows = $rows.not( '.' + c.cssChildRow );
len = $rows.length;
if ( ( wo.filter_$anyMatch && wo.filter_$anyMatch.length ) ||
typeof filters[c.columns] !== 'undefined' ) {
data.anyMatchFlag = true;
data.anyMatchFilter = '' + (
filters[ c.columns ] ||
wo.filter_$anyMatch && tsf.getLatestSearch( wo.filter_$anyMatch ).val() ||
''
);
if ( wo.filter_columnAnyMatch ) {
// specific columns search
query = data.anyMatchFilter.split( tsfRegex.andSplit );
injected = false;
for ( indx = 0; indx < query.length; indx++ ) {
res = query[ indx ].split( ':' );
if ( res.length > 1 ) {
// make the column a one-based index ( non-developers start counting from one :P )
if ( isNaN( res[0] ) ) {
$.each( c.headerContent, function( i, txt ) {
// multiple matches are possible
if ( txt.toLowerCase().indexOf( res[0] ) > -1 ) {
id = i;
filters[ id ] = res[1];
}
});
} else {
id = parseInt( res[0], 10 ) - 1;
}
if ( id >= 0 && id < c.columns ) { // if id is an integer
filters[ id ] = res[1];
query.splice( indx, 1 );
indx--;
injected = true;
}
}
}
if ( injected ) {
data.anyMatchFilter = query.join( ' && ' );
}
}
}
// optimize searching only through already filtered rows - see #313
searchFiltered = wo.filter_searchFiltered;
lastSearch = c.lastSearch || c.$table.data( 'lastSearch' ) || [];
if ( searchFiltered ) {
// cycle through all filters; include last ( columnIndex + 1 = match any column ). Fixes #669
for ( indx = 0; indx < columnIndex + 1; indx++ ) {
val = filters[indx] || '';
// break out of loop if we've already determined not to search filtered rows
if ( !searchFiltered ) { indx = columnIndex; }
// search already filtered rows if...
searchFiltered = searchFiltered && lastSearch.length &&
// there are no changes from beginning of filter
val.indexOf( lastSearch[indx] || '' ) === 0 &&
// if there is NOT a logical 'or', or range ( 'to' or '-' ) in the string
!tsfRegex.alreadyFiltered.test( val ) &&
// if we are not doing exact matches, using '|' ( logical or ) or not '!'
!tsfRegex.exactTest.test( val ) &&
// don't search only filtered if the value is negative
// ( '> -10' => '> -100' will ignore hidden rows )
!( tsfRegex.isNeg1.test( val ) || tsfRegex.isNeg2.test( val ) ) &&
// if filtering using a select without a 'filter-match' class ( exact match ) - fixes #593
!( val !== '' && c.$filters && c.$filters.filter( '[data-column="' + indx + '"]' ).find( 'select' ).length &&
!tsf.matchType( c, indx ) );
}
}
notFiltered = $rows.not( '.' + wo.filter_filteredRow ).length;
// can't search when all rows are hidden - this happens when looking for exact matches
if ( searchFiltered && notFiltered === 0 ) { searchFiltered = false; }
if ( c.debug ) {
console.log( 'Filter: Searching through ' +
( searchFiltered && notFiltered < len ? notFiltered : 'all' ) + ' rows' );
}
if ( data.anyMatchFlag ) {
if ( c.sortLocaleCompare ) {
// replace accents
data.anyMatchFilter = ts.replaceAccents( data.anyMatchFilter );
}
if ( wo.filter_defaultFilter && tsfRegex.iQuery.test( vars.defaultAnyFilter ) ) {
data.anyMatchFilter = tsf.defaultFilter( data.anyMatchFilter, vars.defaultAnyFilter );
// clear search filtered flag because default filters are not saved to the last search
searchFiltered = false;
}
// make iAnyMatchFilter lowercase unless both filter widget & core ignoreCase options are true
// when c.ignoreCase is true, the cache contains all lower case data
data.iAnyMatchFilter = !( wo.filter_ignoreCase && c.ignoreCase ) ?
data.anyMatchFilter :
data.anyMatchFilter.toLowerCase();
}
// loop through the rows
for ( rowIndex = 0; rowIndex < len; rowIndex++ ) {
txt = $rows[ rowIndex ].className;
// the first row can never be a child row
isChild = rowIndex && tsfRegex.child.test( txt );
// skip child rows & already filtered rows
if ( isChild || ( searchFiltered && tsfRegex.filtered.test( txt ) ) ) {
continue;
}
data.$row = $rows.eq( rowIndex );
data.rowIndex = rowIndex;
data.cacheArray = norm_rows[ rowIndex ];
rowData = data.cacheArray[ c.columns ];
data.rawArray = rowData.raw;
data.childRowText = '';
if ( !wo.filter_childByColumn ) {
txt = '';
// child row cached text
childRow = rowData.child;
// so, if 'table.config.widgetOptions.filter_childRows' is true and there is
// a match anywhere in the child row, then it will make the row visible
// checked here so the option can be changed dynamically
for ( indx = 0; indx < childRow.length; indx++ ) {
txt += ' ' + childRow[indx].join( ' ' ) || '';
}
data.childRowText = wo.filter_childRows ?
( wo.filter_ignoreCase ? txt.toLowerCase() : txt ) :
'';
}
showRow = false;
showParent = tsf.processRow( c, data, vars );
$row = rowData.$row;
// don't pass reference to val
val = showParent ? true : false;
childRow = rowData.$row.filter( ':gt(0)' );
if ( wo.filter_childRows && childRow.length ) {
if ( wo.filter_childByColumn ) {
if ( !wo.filter_childWithSibs ) {
// hide all child rows
childRow.addClass( wo.filter_filteredRow );
// if only showing resulting child row, only include parent
$row = $row.eq( 0 );
}
// cycle through each child row
for ( indx = 0; indx < childRow.length; indx++ ) {
data.$row = childRow.eq( indx );
data.cacheArray = rowData.child[ indx ];
data.rawArray = data.cacheArray;
val = tsf.processRow( c, data, vars );
// use OR comparison on child rows
showRow = showRow || val;
if ( !wo.filter_childWithSibs && val ) {
childRow.eq( indx ).removeClass( wo.filter_filteredRow );
}
}
}
// keep parent row match even if no child matches... see #1020
showRow = showRow || showParent;
} else {
showRow = val;
}
$row
.toggleClass( wo.filter_filteredRow, !showRow )[0]
.display = showRow ? '' : 'none';
}
}
c.filteredRows += $rows.not( '.' + wo.filter_filteredRow ).length;
c.totalRows += $rows.length;
ts.processTbody( table, $tbody, false );
}
// lastCombinedFilter is no longer used internally
c.lastCombinedFilter = storedFilters.join(''); // save last search
// don't save 'filters' directly since it may have altered ( AnyMatch column searches )
c.lastSearch = storedFilters;
c.$table.data( 'lastSearch', storedFilters );
if ( wo.filter_saveFilters && ts.storage ) {
ts.storage( table, 'tablesorter-filters', tsf.processFilters( storedFilters, true ) );
}
if ( c.debug ) {
console.log( 'Completed filter widget search' + ts.benchmark(time) );
}
if ( wo.filter_initialized ) {
c.$table.triggerHandler( 'filterBeforeEnd', c );
c.$table.triggerHandler( 'filterEnd', c );
}
setTimeout( function() {
ts.applyWidget( c.table ); // make sure zebra widget is applied
}, 0 );
},
getOptionSource: function( table, column, onlyAvail ) {
table = $( table )[0];
var c = table.config,
wo = c.widgetOptions,
arry = false,
source = wo.filter_selectSource,
last = c.$table.data( 'lastSearch' ) || [],
fxn = typeof source === 'function' ? true : ts.getColumnData( table, source, column );
if ( onlyAvail && last[column] !== '' ) {
onlyAvail = false;
}
// filter select source option
if ( fxn === true ) {
// OVERALL source
arry = source( table, column, onlyAvail );
} else if ( fxn instanceof $ || ( $.type( fxn ) === 'string' && fxn.indexOf( '' ) >= 0 ) ) {
// selectSource is a jQuery object or string of options
return fxn;
} else if ( $.isArray( fxn ) ) {
arry = fxn;
} else if ( $.type( source ) === 'object' && fxn ) {
// custom select source function for a SPECIFIC COLUMN
arry = fxn( table, column, onlyAvail );
// abort - updating the selects from an external method
if (arry === null) {
return null;
}
}
if ( arry === false ) {
// fall back to original method
arry = tsf.getOptions( table, column, onlyAvail );
}
return tsf.processOptions( table, column, arry );
},
processOptions: function( table, column, arry ) {
if ( !$.isArray( arry ) ) {
return false;
}
table = $( table )[0];
var cts, txt, indx, len, parsedTxt, str,
c = table.config,
validColumn = typeof column !== 'undefined' && column !== null && column >= 0 && column < c.columns,
direction = validColumn ? c.$headerIndexed[ column ].hasClass( 'filter-select-sort-desc' ) : false,
parsed = [];
// get unique elements and sort the list
// if $.tablesorter.sortText exists ( not in the original tablesorter ),
// then natural sort the list otherwise use a basic sort
arry = $.grep( arry, function( value, indx ) {
if ( value.text ) {
return true;
}
return $.inArray( value, arry ) === indx;
});
if ( validColumn && c.$headerIndexed[ column ].hasClass( 'filter-select-nosort' ) ) {
// unsorted select options
return arry;
} else {
len = arry.length;
// parse select option values
for ( indx = 0; indx < len; indx++ ) {
txt = arry[ indx ];
// check for object
str = txt.text ? txt.text : txt;
// sortNatural breaks if you don't pass it strings
parsedTxt = ( validColumn && c.parsers && c.parsers.length &&
c.parsers[ column ].format( str, table, [], column ) || str ).toString();
parsedTxt = c.widgetOptions.filter_ignoreCase ? parsedTxt.toLowerCase() : parsedTxt;
// parse array data using set column parser; this DOES NOT pass the original
// table cell to the parser format function
if ( txt.text ) {
txt.parsed = parsedTxt;
parsed[ parsed.length ] = txt;
} else {
parsed[ parsed.length ] = {
text : txt,
// check parser length - fixes #934
parsed : parsedTxt
};
}
}
// sort parsed select options
cts = c.textSorter || '';
parsed.sort( function( a, b ) {
var x = direction ? b.parsed : a.parsed,
y = direction ? a.parsed : b.parsed;
if ( validColumn && typeof cts === 'function' ) {
// custom OVERALL text sorter
return cts( x, y, true, column, table );
} else if ( validColumn && typeof cts === 'object' && cts.hasOwnProperty( column ) ) {
// custom text sorter for a SPECIFIC COLUMN
return cts[column]( x, y, true, column, table );
} else if ( ts.sortNatural ) {
// fall back to natural sort
return ts.sortNatural( x, y );
}
// using an older version! do a basic sort
return true;
});
// rebuild arry from sorted parsed data
arry = [];
len = parsed.length;
for ( indx = 0; indx < len; indx++ ) {
arry[ arry.length ] = parsed[indx];
}
return arry;
}
},
getOptions: function( table, column, onlyAvail ) {
table = $( table )[0];
var rowIndex, tbodyIndex, len, row, cache, indx, child, childLen,
c = table.config,
wo = c.widgetOptions,
arry = [];
for ( tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++ ) {
cache = c.cache[tbodyIndex];
len = c.cache[tbodyIndex].normalized.length;
// loop through the rows
for ( rowIndex = 0; rowIndex < len; rowIndex++ ) {
// get cached row from cache.row ( old ) or row data object
// ( new; last item in normalized array )
row = cache.row ?
cache.row[ rowIndex ] :
cache.normalized[ rowIndex ][ c.columns ].$row[0];
// check if has class filtered
if ( onlyAvail && row.className.match( wo.filter_filteredRow ) ) {
continue;
}
// get non-normalized cell content
if ( wo.filter_useParsedData ||
c.parsers[column].parsed ||
c.$headerIndexed[column].hasClass( 'filter-parsed' ) ) {
arry[ arry.length ] = '' + cache.normalized[ rowIndex ][ column ];
// child row parsed data
if ( wo.filter_childRows && wo.filter_childByColumn ) {
childLen = cache.normalized[ rowIndex ][ c.columns ].$row.length - 1;
for ( indx = 0; indx < childLen; indx++ ) {
arry[ arry.length ] = '' + cache.normalized[ rowIndex ][ c.columns ].child[ indx ][ column ];
}
}
} else {
// get raw cached data instead of content directly from the cells
arry[ arry.length ] = cache.normalized[ rowIndex ][ c.columns ].raw[ column ];
// child row unparsed data
if ( wo.filter_childRows && wo.filter_childByColumn ) {
childLen = cache.normalized[ rowIndex ][ c.columns ].$row.length;
for ( indx = 1; indx < childLen; indx++ ) {
child = cache.normalized[ rowIndex ][ c.columns ].$row.eq( indx ).children().eq( column );
arry[ arry.length ] = '' + ts.getElementText( c, child, column );
}
}
}
}
}
return arry;
},
buildSelect: function( table, column, arry, updating, onlyAvail ) {
table = $( table )[0];
column = parseInt( column, 10 );
if ( !table.config.cache || $.isEmptyObject( table.config.cache ) ) {
return;
}
var indx, val, txt, t, $filters, $filter, option,
c = table.config,
wo = c.widgetOptions,
node = c.$headerIndexed[ column ],
// t.data( 'placeholder' ) won't work in jQuery older than 1.4.3
options = '',
// Get curent filter value
currentValue = c.$table
.find( 'thead' )
.find( 'select.' + tscss.filter + '[data-column="' + column + '"]' )
.val();
// nothing included in arry ( external source ), so get the options from
// filter_selectSource or column data
if ( typeof arry === 'undefined' || arry === '' ) {
arry = tsf.getOptionSource( table, column, onlyAvail );
// abort, selects are updated by an external method
if (arry === null) {
return;
}
}
if ( $.isArray( arry ) ) {
// build option list
for ( indx = 0; indx < arry.length; indx++ ) {
option = arry[ indx ];
if ( option.text ) {
// OBJECT!! add data-function-name in case the value is set in filter_functions
option['data-function-name'] = typeof option.value === 'undefined' ? option.text : option.value;
// support jQuery < v1.8, otherwise the below code could be shortened to
// options += $( ' |