';
+ 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 += $( ' |