2015-03-26 15:48:43 +00:00
/*! Widget: filter - updated 3/26/2015 (v2.21.3) */ / *
2015-03-05 16:04:59 +00:00
* Requires tablesorter v2 . 8 + and jQuery 1.7 +
* by Rob Garrison
* /
2015-05-16 22:13:17 +00:00
; ( function ( $ ) {
2015-02-13 03:10:38 +00:00
'use strict' ;
2015-05-16 22:13:17 +00:00
var ts = $ . tablesorter || { } ,
2015-03-23 21:08:07 +00:00
tscss = ts . css ;
2015-02-13 03:10:38 +00:00
2015-05-16 22:13:17 +00:00
$ . extend ( tscss , {
2015-03-24 18:29:41 +00:00
filterRow : 'tablesorter-filter-row' ,
filter : 'tablesorter-filter' ,
filterDisabled : 'disabled' ,
filterRowHide : 'hideme'
2015-02-13 03:10:38 +00:00
} ) ;
ts . addWidget ( {
2015-05-16 22:13:17 +00:00
id : 'filter' ,
2015-02-13 03:10:38 +00:00
priority : 50 ,
options : {
filter _childRows : false , // if true, filter includes child row content in the search
2015-05-16 22:13:17 +00:00
filter _childByColumn : false , // ( filter_childRows must be true ) if true = search child rows by column; false = search all child row text grouped
2015-02-13 03:10:38 +00:00
filter _columnFilters : true , // if true, a filter will be added to the top of each table column
2015-05-16 22:13:17 +00:00
filter _columnAnyMatch : true , // if true, allows using '#:{query}' in AnyMatch searches ( column:query )
filter _cellFilter : '' , // css class name added to the filter cell ( string or array )
filter _cssFilter : '' , // css class name added to the filter row & each input in the row ( tablesorter-filter is ALWAYS added )
filter _defaultFilter : { } , // add a default column filter type '~{query}' to make fuzzy searches default; '{q1} AND {q2}' to make all searches use a logical AND.
2015-02-13 03:10:38 +00:00
filter _excludeFilter : { } , // filters to exclude, per column
2015-05-16 22:13:17 +00:00
filter _external : '' , // jQuery selector string ( or jQuery object ) of external filters
2015-02-13 03:10:38 +00:00
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
2015-05-16 22:13:17 +00:00
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 )
2015-02-13 03:10:38 +00:00
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 _searchFiltered : true , // allow searching through already filtered rows in special circumstances; will speed up searching in large tables if true
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
filter _selectSourceSeparator : '|' // filter_selectSource array text left of the separator is added to the option value, right into the option text
} ,
2015-05-16 22:13:17 +00:00
format : function ( table , c , wo ) {
if ( ! c . $table . hasClass ( 'hasFilters' ) ) {
ts . filter . init ( table , c , wo ) ;
2015-02-13 03:10:38 +00:00
}
} ,
2015-05-16 22:13:17 +00:00
remove : function ( table , c , wo , refreshing ) {
2015-02-13 03:10:38 +00:00
var tbodyIndex , $tbody ,
$table = c . $table ,
$tbodies = c . $tbodies ,
2015-05-16 22:13:17 +00:00
events = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '
. split ( ' ' ) . join ( c . namespace + 'filter ' ) ;
2015-02-13 03:10:38 +00:00
$table
2015-05-16 22:13:17 +00:00
. removeClass ( 'hasFilters' )
2015-02-13 03:10:38 +00:00
// add .tsfilter namespace to all BUT search
2015-05-16 22:13:17 +00:00
. unbind ( events . replace ( /\s+/g , ' ' ) )
2015-02-13 03:10:38 +00:00
// remove the filter row even if refreshing, because the column might have been moved
2015-05-16 22:13:17 +00:00
. find ( '.' + tscss . filterRow ) . remove ( ) ;
if ( refreshing ) { return ; }
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
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( wo . filter _reset ) {
$ ( document ) . undelegate ( wo . filter _reset , 'click.tsfilter' ) ;
2015-02-13 03:10:38 +00:00
}
}
} ) ;
ts . filter = {
2015-05-16 22:13:17 +00:00
// regex used in filter 'check' functions - not for general use and not documented
2015-02-13 03:10:38 +00:00
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
query : '(q|query)' // replace filter queries
} ,
// function( c, data ) { }
// c = table.config
2015-05-15 02:32:41 +00:00
// data.$row = jQuery object of the row currently being processed
// data.$cells = jQuery object of all cells within the current row
2015-05-16 22:13:17 +00:00
// data.filters = array of filters for all columns ( some may be undefined )
2015-05-15 02:32:41 +00:00
// data.filter = filter for the current column
2015-05-16 22:13:17 +00:00
// data.iFilter = same as data.filter, except lowercase ( if wo.filter_ignoreCase is true )
// data.exact = table cell text ( or parsed data if column parser enabled )
// data.iExact = same as data.exact, except lowercase ( if wo.filter_ignoreCase is true )
// data.cache = table cell text from cache, so it has been parsed ( & in all lower case if c.ignoreCase is true )
2015-05-15 02:32:41 +00:00
// data.cacheArray = An array of parsed content from each table cell in the row being processed
2015-05-16 22:13:17 +00:00
// data.index = column index; table = table element ( DOM )
// data.parsed = array ( by column ) of boolean values ( from filter_useParsedData or 'filter-parsed' class )
2015-02-13 03:10:38 +00:00
types : {
// Look for regex
regex : function ( c , data ) {
2015-05-16 22:13:17 +00:00
if ( ts . filter . regex . regex . test ( data . filter ) ) {
2015-02-13 03:10:38 +00:00
var matches ,
2015-05-06 03:17:14 +00:00
// cache regex per column for optimal speed
2015-05-15 02:32:41 +00:00
regex = data . filter _regexCache [ data . index ] || ts . filter . regex . regex . exec ( data . filter ) ,
2015-05-06 03:17:14 +00:00
isRegex = regex instanceof RegExp ;
2015-02-13 03:10:38 +00:00
try {
2015-05-16 22:13:17 +00:00
if ( ! isRegex ) {
2015-05-06 03:17:14 +00:00
// force case insensitive search if ignoreCase option set?
// if ( c.ignoreCase && !regex[2] ) { regex[2] = 'i'; }
2015-05-15 02:32:41 +00:00
data . filter _regexCache [ data . index ] = regex = new RegExp ( regex [ 1 ] , regex [ 2 ] ) ;
2015-05-06 03:17:14 +00:00
}
matches = regex . test ( data . exact ) ;
2015-05-16 22:13:17 +00:00
} catch ( error ) {
2015-02-13 03:10:38 +00:00
matches = false ;
}
return matches ;
}
return null ;
} ,
// Look for operators >, >=, < or <=
operators : function ( c , data ) {
2015-05-16 22:13:17 +00:00
// ignore empty strings... because '' < 10 is true
if ( /^[<>]=?/ . test ( data . iFilter ) && data . iExact !== '' ) {
var cachedValue , result , txt ,
2015-02-13 03:10:38 +00:00
table = c . table ,
index = data . index ,
parsed = data . parsed [ index ] ,
2015-05-16 22:13:17 +00:00
query = ts . formatFloat ( data . iFilter . replace ( ts . filter . regex . operators , '' ) , table ) ,
2015-02-13 03:10:38 +00:00
parser = c . parsers [ index ] ,
savedSearch = query ;
2015-05-16 22:13:17 +00:00
// parse filter value in case we're comparing numbers ( dates )
if ( parsed || parser . type === 'numeric' ) {
txt = $ . trim ( '' + data . iFilter . replace ( ts . filter . regex . operators , '' ) ) ;
result = ts . filter . parseFilter ( c , txt , index , true ) ;
query = ( typeof result === 'number' && result !== '' && ! isNaN ( result ) ) ? result : query ;
2015-02-13 03:10:38 +00:00
}
// iExact may be numeric - see issue #149;
2015-05-16 22:13:17 +00:00
// check if cached is defined, because sometimes j goes out of range? ( numeric columns )
if ( ( parsed || parser . type === 'numeric' ) && ! isNaN ( query ) &&
typeof data . cache !== 'undefined' ) {
cachedValue = data . cache ;
} else {
txt = isNaN ( data . iExact ) ? data . iExact . replace ( ts . filter . regex . nondigit , '' ) : data . iExact ;
cachedValue = ts . formatFloat ( txt , table ) ;
}
if ( />/ . test ( data . iFilter ) ) {
result = />=/ . test ( data . iFilter ) ? cachedValue >= query : cachedValue > query ;
} else if ( /</ . test ( data . iFilter ) ) {
result = /<=/ . test ( data . iFilter ) ? cachedValue <= query : cachedValue < query ;
}
2015-02-13 03:10:38 +00:00
// keep showing all rows if nothing follows the operator
2015-05-16 22:13:17 +00:00
if ( ! result && savedSearch === '' ) {
result = true ;
}
2015-02-13 03:10:38 +00:00
return result ;
}
return null ;
} ,
// Look for a not match
notMatch : function ( c , data ) {
2015-05-16 22:13:17 +00:00
if ( /^\!/ . test ( data . iFilter ) ) {
2015-02-13 03:10:38 +00:00
var indx ,
2015-05-16 22:13:17 +00:00
txt = data . iFilter . replace ( '!' , '' ) ,
filter = ts . filter . parseFilter ( c , txt , data . index , data . parsed [ data . index ] ) || '' ;
if ( ts . filter . regex . exact . test ( filter ) ) {
2015-02-13 03:10:38 +00:00
// look for exact not matches - see #628
2015-05-16 22:13:17 +00:00
filter = filter . replace ( ts . filter . regex . exact , '' ) ;
return filter === '' ? true : $ . trim ( filter ) !== data . iExact ;
2015-02-13 03:10:38 +00:00
} else {
2015-05-16 22:13:17 +00:00
indx = data . iExact . search ( $ . trim ( filter ) ) ;
return filter === '' ? true : ! ( c . widgetOptions . filter _startsWith ? indx === 0 : indx >= 0 ) ;
2015-02-13 03:10:38 +00:00
}
}
return null ;
} ,
// Look for quotes or equals to get an exact match; ignore type since iExact could be numeric
exact : function ( c , data ) {
/*jshint eqeqeq:false */
2015-05-16 22:13:17 +00:00
if ( ts . filter . regex . exact . test ( data . iFilter ) ) {
var txt = data . iFilter . replace ( ts . filter . regex . exact , '' ) ,
filter = ts . filter . parseFilter ( c , txt , data . index , data . parsed [ data . index ] ) || '' ;
return data . anyMatch ? $ . inArray ( filter , data . rowArray ) >= 0 : filter == data . iExact ;
2015-02-13 03:10:38 +00:00
}
return null ;
} ,
2015-05-16 22:13:17 +00:00
// Look for an AND or && operator ( logical and )
2015-02-13 03:10:38 +00:00
and : function ( c , data ) {
2015-05-16 22:13:17 +00:00
if ( ts . filter . regex . andTest . test ( data . filter ) ) {
2015-02-13 03:10:38 +00:00
var index = data . index ,
parsed = data . parsed [ index ] ,
query = data . iFilter . split ( ts . filter . regex . andSplit ) ,
2015-05-16 22:13:17 +00:00
result = data . iExact . search ( $ . trim ( ts . filter . parseFilter ( c , query [ 0 ] , index , parsed ) ) ) >= 0 ,
2015-02-13 03:10:38 +00:00
indx = query . length - 1 ;
2015-05-16 22:13:17 +00:00
while ( result && indx ) {
result = result &&
data . iExact . search ( $ . trim ( ts . filter . parseFilter ( c , query [ indx ] , index , parsed ) ) ) >= 0 ;
2015-02-13 03:10:38 +00:00
indx -- ;
}
return result ;
}
return null ;
} ,
2015-05-16 22:13:17 +00:00
// Look for a range ( using ' to ' or ' - ' ) - see issue #166; thanks matzhu!
2015-02-13 03:10:38 +00:00
range : function ( c , data ) {
2015-05-16 22:13:17 +00:00
if ( ts . filter . regex . toTest . test ( data . iFilter ) ) {
var result , tmp , range1 , range2 ,
2015-02-13 03:10:38 +00:00
table = c . table ,
index = data . index ,
parsed = data . parsed [ index ] ,
// make sure the dash is for a range and not indicating a negative number
2015-05-16 22:13:17 +00:00
query = data . iFilter . split ( ts . filter . regex . toSplit ) ;
tmp = query [ 0 ] . replace ( ts . filter . regex . nondigit , '' ) || '' ;
range1 = ts . formatFloat ( ts . filter . parseFilter ( c , tmp , index , parsed ) , table ) ;
tmp = query [ 1 ] . replace ( ts . filter . regex . nondigit , '' ) || '' ;
range2 = ts . formatFloat ( ts . filter . parseFilter ( c , tmp , index , parsed ) , table ) ;
// parse filter value in case we're comparing numbers ( dates )
if ( parsed || 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 ;
}
if ( ( parsed || c . parsers [ index ] . type === 'numeric' ) && ! isNaN ( range1 ) && ! isNaN ( range2 ) ) {
result = data . cache ;
} else {
tmp = isNaN ( data . iExact ) ? data . iExact . replace ( ts . filter . regex . nondigit , '' ) : data . iExact ;
result = ts . formatFloat ( tmp , table ) ;
}
if ( range1 > range2 ) {
tmp = range1 ; range1 = range2 ; range2 = tmp ; // swap
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
return ( result >= range1 && result <= range2 ) || ( range1 === '' || range2 === '' ) ;
2015-02-13 03:10:38 +00:00
}
return null ;
} ,
// Look for wild card: ? = single, * = multiple, or | = logical OR
wild : function ( c , data ) {
2015-05-16 22:13:17 +00:00
if ( /[\?\*\|]/ . test ( data . iFilter ) || ts . filter . regex . orReplace . test ( data . filter ) ) {
2015-02-13 03:10:38 +00:00
var index = data . index ,
2015-05-16 22:13:17 +00:00
parsed = data . parsed [ index ] ,
txt = data . iFilter . replace ( ts . filter . regex . orReplace , '|' ) ,
query = ts . filter . parseFilter ( c , txt , index , parsed ) || '' ;
// look for an exact match with the 'or' unless the 'filter-match' class is found
if ( ! c . $headerIndexed [ index ] . hasClass ( 'filter-match' ) && /\|/ . test ( query ) ) {
2015-02-13 03:10:38 +00:00
// show all results while using filter match. Fixes #727
2015-05-16 22:13:17 +00:00
if ( query [ query . length - 1 ] === '|' ) {
query += '*' ;
}
query = data . anyMatch && $ . isArray ( data . rowArray ) ?
'(' + query + ')' :
'^(' + query + ')$' ;
2015-02-13 03:10:38 +00:00
}
// parsing the filter may not work properly when using wildcards =/
2015-05-16 22:13:17 +00:00
return new RegExp ( query . replace ( /\?/g , '\\S{1}' ) . replace ( /\*/g , '\\S*' ) )
. test ( data . iExact ) ;
2015-02-13 03:10:38 +00:00
}
return null ;
} ,
2015-05-16 22:13:17 +00:00
// fuzzy text search; modified from https://github.com/mattyork/fuzzy ( MIT license )
2015-02-13 03:10:38 +00:00
fuzzy : function ( c , data ) {
2015-05-16 22:13:17 +00:00
if ( /^~/ . test ( data . iFilter ) ) {
2015-02-13 03:10:38 +00:00
var indx ,
patternIndx = 0 ,
len = data . iExact . length ,
2015-05-16 22:13:17 +00:00
txt = data . iFilter . slice ( 1 ) ,
pattern = ts . filter . parseFilter ( c , txt , data . index , data . parsed [ data . index ] ) || '' ;
for ( indx = 0 ; indx < len ; indx ++ ) {
if ( data . iExact [ indx ] === pattern [ patternIndx ] ) {
2015-02-13 03:10:38 +00:00
patternIndx += 1 ;
}
}
2015-05-16 22:13:17 +00:00
if ( patternIndx === pattern . length ) {
2015-02-13 03:10:38 +00:00
return true ;
}
return false ;
}
return null ;
}
} ,
2015-05-16 22:13:17 +00:00
init : function ( table , c , wo ) {
2015-02-13 03:10:38 +00:00
// filter language options
2015-05-16 22:13:17 +00:00
ts . language = $ . extend ( true , { } , {
2015-02-13 03:10:38 +00:00
to : 'to' ,
or : 'or' ,
and : 'and'
2015-05-16 22:13:17 +00:00
} , ts . language ) ;
2015-02-13 03:10:38 +00:00
var options , string , txt , $header , column , filters , val , fxn , noSelect ,
regex = ts . filter . regex ;
2015-05-16 22:13:17 +00:00
c . $table . addClass ( 'hasFilters' ) ;
2015-02-13 03:10:38 +00:00
// define timers so using clearTimeout won't cause an undefined error
wo . searchTimer = null ;
wo . filter _initTimer = null ;
wo . filter _formatterCount = 0 ;
wo . filter _formatterInit = [ ] ;
wo . filter _anyColumnSelector = '[data-column="all"],[data-column="any"]' ;
wo . filter _multipleColumnSelector = '[data-column*="-"],[data-column*=","]' ;
2015-05-16 22:13:17 +00:00
val = '\\{' + ts . filter . regex . query + '\\}' ;
2015-02-13 03:10:38 +00:00
$ . extend ( regex , {
2015-05-16 22:13:17 +00:00
child : new RegExp ( c . cssChildRow ) ,
filtered : new RegExp ( wo . filter _filteredRow ) ,
alreadyFiltered : new RegExp ( '(\\s+(' + ts . language . or + '|-|' + ts . language . to + ')\\s+)' , 'i' ) ,
toTest : new RegExp ( '\\s+(-|' + ts . language . to + ')\\s+' , 'i' ) ,
toSplit : new RegExp ( '(?:\\s+(?:-|' + ts . language . to + ')\\s+)' , 'gi' ) ,
andTest : new RegExp ( '\\s+(' + ts . language . and + '|&&)\\s+' , 'i' ) ,
andSplit : new RegExp ( '(?:\\s+(?:' + ts . language . and + '|&&)\\s+)' , 'gi' ) ,
orReplace : new RegExp ( '\\s+(' + ts . language . or + ')\\s+' , 'gi' ) ,
iQuery : new RegExp ( val , 'i' ) ,
igQuery : new RegExp ( val , 'ig' )
2015-02-13 03:10:38 +00:00
} ) ;
2015-05-16 22:13:17 +00:00
// don't build filter row if columnFilters is false or all columns are set to 'filter-false'
// see issue #156
val = c . $headers . filter ( '.filter-false, .parser-false' ) . length ;
if ( wo . filter _columnFilters !== false && val !== c . $headers . length ) {
2015-02-13 03:10:38 +00:00
// build filter row
2015-05-16 22:13:17 +00:00
ts . filter . buildRow ( table , c , wo ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
txt = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '
. split ( ' ' ) . join ( c . namespace + 'filter ' ) ;
c . $table . bind ( txt , function ( event , filter ) {
val = wo . filter _hideEmpty &&
$ . isEmptyObject ( c . cache ) &&
! ( c . delayInit && event . type === 'appendCache' ) ;
// hide filter row using the 'filtered' class name
c . $table . find ( '.' + tscss . filterRow ) . toggleClass ( wo . filter _filteredRow , val ) ; // fixes #450
if ( ! /(search|filter)/ . test ( event . type ) ) {
2015-02-13 03:10:38 +00:00
event . stopPropagation ( ) ;
2015-05-16 22:13:17 +00:00
ts . filter . buildDefault ( table , true ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( event . type === 'filterReset' ) {
c . $table . find ( '.' + tscss . filter ) . add ( wo . filter _$externalFilters ) . val ( '' ) ;
ts . filter . searching ( table , [ ] ) ;
} else if ( event . type === 'filterEnd' ) {
ts . filter . buildDefault ( table , true ) ;
2015-02-13 03:10:38 +00:00
} else {
2015-05-16 22:13:17 +00:00
// 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' ) {
2015-02-13 03:10:38 +00:00
// force a new search since content has changed
c . lastCombinedFilter = null ;
c . lastSearch = [ ] ;
}
2015-05-16 22:13:17 +00:00
// 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 ) ;
2015-02-13 03:10:38 +00:00
}
return false ;
} ) ;
// reset button/link
2015-05-16 22:13:17 +00:00
if ( wo . filter _reset ) {
if ( wo . filter _reset instanceof $ ) {
2015-02-13 03:10:38 +00:00
// reset contains a jQuery object, bind to it
2015-05-16 22:13:17 +00:00
wo . filter _reset . click ( function ( ) {
c . $table . trigger ( 'filterReset' ) ;
2015-02-13 03:10:38 +00:00
} ) ;
2015-05-16 22:13:17 +00:00
} else if ( $ ( wo . filter _reset ) . length ) {
2015-02-13 03:10:38 +00:00
// reset is a jQuery selector, use event delegation
2015-05-16 22:13:17 +00:00
$ ( document )
. undelegate ( wo . filter _reset , 'click.tsfilter' )
. delegate ( wo . filter _reset , 'click.tsfilter' , function ( ) {
// trigger a reset event, so other functions ( filter_formatter ) know when to reset
c . $table . trigger ( 'filterReset' ) ;
} ) ;
2015-02-13 03:10:38 +00:00
}
}
2015-05-16 22:13:17 +00:00
if ( wo . filter _functions ) {
for ( column = 0 ; column < c . columns ; column ++ ) {
2015-02-13 03:10:38 +00:00
fxn = ts . getColumnData ( table , wo . filter _functions , column ) ;
2015-05-16 22:13:17 +00:00
if ( fxn ) {
// remove 'filter-select' from header otherwise the options added here are replaced with
// all options
$header = c . $headerIndexed [ column ] . removeClass ( 'filter-select' ) ;
// don't build select if 'filter-false' or 'parser-false' set
noSelect = ! ( $header . hasClass ( 'filter-false' ) || $header . hasClass ( 'parser-false' ) ) ;
2015-02-13 03:10:38 +00:00
options = '' ;
if ( fxn === true && noSelect ) {
2015-05-16 22:13:17 +00:00
ts . filter . buildSelect ( table , column ) ;
2015-02-13 03:10:38 +00:00
} else if ( typeof fxn === 'object' && noSelect ) {
// add custom drop down list
2015-05-16 22:13:17 +00:00
for ( string in fxn ) {
if ( typeof string === 'string' ) {
2015-02-13 03:10:38 +00:00
options += options === '' ?
2015-05-16 22:13:17 +00:00
'<option value="">' +
( $header . data ( 'placeholder' ) ||
$header . attr ( 'data-placeholder' ) ||
wo . filter _placeholder . select ||
''
) +
'</option>' : '' ;
2015-02-13 03:10:38 +00:00
val = string ;
txt = string ;
2015-05-16 22:13:17 +00:00
if ( string . indexOf ( wo . filter _selectSourceSeparator ) >= 0 ) {
val = string . split ( wo . filter _selectSourceSeparator ) ;
2015-02-13 03:10:38 +00:00
txt = val [ 1 ] ;
val = val [ 0 ] ;
}
2015-05-16 22:13:17 +00:00
options += '<option ' +
( txt === val ? '' : 'data-function-name="' + string + '" ' ) +
'value="' + val + '">' + txt + '</option>' ;
2015-02-13 03:10:38 +00:00
}
}
2015-05-16 22:13:17 +00:00
c . $table
. find ( 'thead' )
. find ( 'select.' + tscss . filter + '[data-column="' + column + '"]' )
. append ( options ) ;
2015-04-08 03:12:53 +00:00
txt = wo . filter _selectSource ;
2015-05-16 22:13:17 +00:00
fxn = $ . isFunction ( txt ) ? true : ts . getColumnData ( table , txt , column ) ;
if ( fxn ) {
2015-04-08 03:12:53 +00:00
// updating so the extra options are appended
2015-05-16 22:13:17 +00:00
ts . filter . buildSelect ( c . table , column , '' , true , $header . hasClass ( wo . filter _onlyAvail ) ) ;
2015-04-08 03:12:53 +00:00
}
2015-02-13 03:10:38 +00:00
}
}
}
}
2015-05-16 22:13:17 +00:00
// 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 ) ;
2015-02-13 03:10:38 +00:00
2015-05-16 22:13:17 +00:00
ts . filter . bindSearch ( table , c . $table . find ( '.' + tscss . filter ) , true ) ;
if ( wo . filter _external ) {
2015-02-13 03:10:38 +00:00
ts . filter . bindSearch ( table , wo . filter _external ) ;
}
2015-05-16 22:13:17 +00:00
if ( wo . filter _hideFilters ) {
ts . filter . hideFilters ( table , c ) ;
2015-02-13 03:10:38 +00:00
}
// show processing icon
2015-05-16 22:13:17 +00:00
if ( c . showProcessing ) {
txt = 'filterStart filterEnd ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) ;
2015-02-13 03:10:38 +00:00
c . $table
2015-05-16 22:13:17 +00:00
. unbind ( txt . replace ( /\s+/g , ' ' ) )
. bind ( txt , function ( event , columns ) {
2015-02-13 03:10:38 +00:00
// only add processing to certain columns to all columns
2015-05-16 22:13:17 +00:00
$header = ( columns ) ?
c . $table
. find ( '.' + tscss . header )
. filter ( '[data-column]' )
. filter ( function ( ) {
return columns [ $ ( this ) . data ( 'column' ) ] !== '' ;
} ) : '' ;
ts . isProcessing ( table , event . type === 'filterStart' , columns ? $header : '' ) ;
2015-02-13 03:10:38 +00:00
} ) ;
}
2015-05-16 22:13:17 +00:00
// set filtered rows count ( intially unfiltered )
2015-02-13 03:10:38 +00:00
c . filteredRows = c . totalRows ;
// add default values
2015-05-16 22:13:17 +00:00
txt = 'tablesorter-initialized pagerBeforeInitialized ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) ;
2015-02-13 03:10:38 +00:00
c . $table
2015-05-16 22:13:17 +00:00
. unbind ( txt . replace ( /\s+/g , ' ' ) )
. bind ( txt , function ( ) {
// redefine 'wo' as it does not update properly inside this callback
2015-02-13 03:10:38 +00:00
var wo = this . config . widgetOptions ;
2015-05-16 22:13:17 +00:00
filters = ts . filter . setDefaults ( table , c , wo ) || [ ] ;
if ( filters . length ) {
2015-02-13 03:10:38 +00:00
// prevent delayInit from triggering a cache build if filters are empty
2015-05-16 22:13:17 +00:00
if ( ! ( c . delayInit && filters . join ( '' ) === '' ) ) {
ts . setFilters ( table , filters , true ) ;
2015-02-13 03:10:38 +00:00
}
}
2015-05-16 22:13:17 +00:00
c . $table . trigger ( 'filterFomatterUpdate' ) ;
2015-02-13 03:10:38 +00:00
// trigger init after setTimeout to prevent multiple filterStart/End/Init triggers
2015-05-16 22:13:17 +00:00
setTimeout ( function ( ) {
if ( ! wo . filter _initialized ) {
ts . filter . filterInitComplete ( c ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
} , 100 ) ;
2015-02-13 03:10:38 +00:00
} ) ;
// if filter widget is added after pager has initialized; then set filter init flag
2015-05-16 22:13:17 +00:00
if ( c . pager && c . pager . initialized && ! wo . filter _initialized ) {
c . $table . trigger ( 'filterFomatterUpdate' ) ;
setTimeout ( function ( ) {
ts . filter . filterInitComplete ( c ) ;
} , 100 ) ;
2015-02-13 03:10:38 +00:00
}
} ,
2015-05-16 22:13:17 +00:00
// $cell parameter, but not the config, is passed to the filter_formatters,
// so we have to work with it instead
formatterUpdated : function ( $cell , column ) {
var wo = $cell . closest ( 'table' ) [ 0 ] . config . widgetOptions ;
if ( ! wo . filter _initialized ) {
2015-02-13 03:10:38 +00:00
// add updates by column since this function
// may be called numerous times before initialization
2015-05-16 22:13:17 +00:00
wo . filter _formatterInit [ column ] = 1 ;
2015-02-13 03:10:38 +00:00
}
} ,
2015-05-16 22:13:17 +00:00
filterInitComplete : function ( c ) {
2015-02-26 00:43:59 +00:00
var indx , len ,
wo = c . widgetOptions ,
2015-02-13 03:10:38 +00:00
count = 0 ,
2015-05-16 22:13:17 +00:00
completed = function ( ) {
2015-02-13 03:10:38 +00:00
wo . filter _initialized = true ;
2015-05-16 22:13:17 +00:00
c . $table . trigger ( 'filterInit' , c ) ;
ts . filter . findRows ( c . table , c . $table . data ( 'lastSearch' ) || [ ] ) ;
2015-02-13 03:10:38 +00:00
} ;
if ( $ . isEmptyObject ( wo . filter _formatter ) ) {
completed ( ) ;
} else {
2015-02-26 00:43:59 +00:00
len = wo . filter _formatterInit . length ;
2015-05-16 22:13:17 +00:00
for ( indx = 0 ; indx < len ; indx ++ ) {
if ( wo . filter _formatterInit [ indx ] === 1 ) {
2015-02-13 03:10:38 +00:00
count ++ ;
}
2015-02-26 00:43:59 +00:00
}
2015-05-16 22:13:17 +00:00
clearTimeout ( wo . filter _initTimer ) ;
if ( ! wo . filter _initialized && count === wo . filter _formatterCount ) {
2015-02-13 03:10:38 +00:00
// filter widget initialized
completed ( ) ;
2015-05-16 22:13:17 +00:00
} else if ( ! wo . filter _initialized ) {
2015-02-13 03:10:38 +00:00
// fall back in case a filter_formatter doesn't call
2015-05-16 22:13:17 +00:00
// $.tablesorter.filter.formatterUpdated( $cell, column ), and the count is off
wo . filter _initTimer = setTimeout ( function ( ) {
2015-02-13 03:10:38 +00:00
completed ( ) ;
2015-05-16 22:13:17 +00:00
} , 500 ) ;
2015-02-13 03:10:38 +00:00
}
}
} ,
2015-05-16 22:13:17 +00:00
setDefaults : function ( table , c , wo ) {
2015-02-26 14:30:09 +00:00
var isArray , saved , indx , col , $filters ,
2015-05-16 22:13:17 +00:00
// get current ( default ) filters
filters = ts . getFilters ( table ) || [ ] ;
if ( wo . filter _saveFilters && ts . storage ) {
2015-02-13 03:10:38 +00:00
saved = ts . storage ( table , 'tablesorter-filters' ) || [ ] ;
2015-05-16 22:13:17 +00:00
isArray = $ . isArray ( saved ) ;
2015-02-13 03:10:38 +00:00
// make sure we're not just getting an empty array
2015-05-16 22:13:17 +00:00
if ( ! ( isArray && saved . join ( '' ) === '' || ! isArray ) ) {
filters = saved ;
}
2015-02-13 03:10:38 +00:00
}
// if no filters saved, then check default settings
2015-05-16 22:13:17 +00:00
if ( filters . join ( '' ) === '' ) {
2015-02-26 14:30:09 +00:00
// allow adding default setting to external filters
2015-05-16 22:13:17 +00:00
$filters = c . $headers . add ( wo . filter _$externalFilters )
. filter ( '[' + wo . filter _defaultAttrib + ']' ) ;
for ( indx = 0 ; indx <= c . columns ; indx ++ ) {
// include data-column='all' external filters
2015-02-26 14:30:09 +00:00
col = indx === c . columns ? 'all' : indx ;
2015-05-16 22:13:17 +00:00
filters [ indx ] = $filters
. filter ( '[data-column="' + col + '"]' )
. attr ( wo . filter _defaultAttrib ) || filters [ indx ] || '' ;
2015-02-13 03:10:38 +00:00
}
}
2015-05-16 22:13:17 +00:00
c . $table . data ( 'lastSearch' , filters ) ;
2015-02-13 03:10:38 +00:00
return filters ;
} ,
2015-05-13 12:44:58 +00:00
parseFilter : function ( c , filter , column , parsed ) {
return parsed ? c . parsers [ column ] . format ( filter , c . table , [ ] , column ) : filter ;
2015-02-13 03:10:38 +00:00
} ,
2015-05-16 22:13:17 +00:00
buildRow : function ( table , c , wo ) {
var col , column , $header , buildSelect , disabled , name , ffxn , tmp ,
2015-02-13 03:10:38 +00:00
// c.columns defined in computeThIndexes()
2015-05-16 22:13:17 +00:00
cellFilter = wo . filter _cellFilter ,
2015-02-13 03:10:38 +00:00
columns = c . columns ,
2015-05-16 22:13:17 +00:00
arry = $ . isArray ( cellFilter ) ,
2015-03-23 21:08:07 +00:00
buildFilter = '<tr role="row" class="' + tscss . filterRow + ' ' + c . cssIgnoreRow + '">' ;
2015-05-16 22:13:17 +00:00
for ( column = 0 ; column < columns ; column ++ ) {
buildFilter += '<td' ;
if ( arry ) {
buildFilter += ( cellFilter [ column ] ? ' class="' + cellFilter [ column ] + '"' : '' ) ;
2015-02-13 03:10:38 +00:00
} else {
2015-05-16 22:13:17 +00:00
buildFilter += ( cellFilter !== '' ? ' class="' + cellFilter + '"' : '' ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
buildFilter += '></td>' ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
c . $filters = $ ( buildFilter += '</tr>' )
. appendTo ( c . $table . children ( 'thead' ) . eq ( 0 ) )
. find ( 'td' ) ;
2015-02-13 03:10:38 +00:00
// build each filter input
2015-05-16 22:13:17 +00:00
for ( column = 0 ; column < columns ; column ++ ) {
2015-02-13 03:10:38 +00:00
disabled = false ;
// assuming last cell of a column is the main column
2015-05-16 22:13:17 +00:00
$header = c . $headerIndexed [ column ] ;
2015-02-13 03:10:38 +00:00
ffxn = ts . getColumnData ( table , wo . filter _functions , column ) ;
2015-05-16 22:13:17 +00:00
buildSelect = ( wo . filter _functions && ffxn && typeof ffxn !== 'function' ) ||
$header . hasClass ( 'filter-select' ) ;
2015-02-13 03:10:38 +00:00
// get data from jQuery data, metadata, headers option or header class name
col = ts . getColumnData ( table , c . headers , column ) ;
2015-05-16 22:13:17 +00:00
disabled = ts . getData ( $header [ 0 ] , col , 'filter' ) === 'false' ||
ts . getData ( $header [ 0 ] , col , 'parser' ) === 'false' ;
2015-02-13 03:10:38 +00:00
2015-05-16 22:13:17 +00:00
if ( buildSelect ) {
buildFilter = $ ( '<select>' ) . appendTo ( c . $filters . eq ( column ) ) ;
2015-02-13 03:10:38 +00:00
} else {
ffxn = ts . getColumnData ( table , wo . filter _formatter , column ) ;
2015-05-16 22:13:17 +00:00
if ( ffxn ) {
2015-02-13 03:10:38 +00:00
wo . filter _formatterCount ++ ;
2015-05-16 22:13:17 +00:00
buildFilter = ffxn ( c . $filters . eq ( column ) , column ) ;
2015-02-13 03:10:38 +00:00
// no element returned, so lets go find it
2015-05-16 22:13:17 +00:00
if ( buildFilter && buildFilter . length === 0 ) {
buildFilter = c . $filters . eq ( column ) . children ( 'input' ) ;
2015-02-13 03:10:38 +00:00
}
// element not in DOM, so lets attach it
2015-05-16 22:13:17 +00:00
if ( buildFilter && ( buildFilter . parent ( ) . length === 0 ||
( buildFilter . parent ( ) . length && buildFilter . parent ( ) [ 0 ] !== c . $filters [ column ] ) ) ) {
c . $filters . eq ( column ) . append ( buildFilter ) ;
2015-02-13 03:10:38 +00:00
}
} else {
2015-05-16 22:13:17 +00:00
buildFilter = $ ( '<input type="search">' ) . appendTo ( c . $filters . eq ( column ) ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( buildFilter ) {
tmp = $header . data ( 'placeholder' ) ||
$header . attr ( 'data-placeholder' ) ||
wo . filter _placeholder . search || '' ;
buildFilter . attr ( 'placeholder' , tmp ) ;
2015-02-13 03:10:38 +00:00
}
}
2015-05-16 22:13:17 +00:00
if ( buildFilter ) {
2015-02-13 03:10:38 +00:00
// add filter class name
2015-05-16 22:13:17 +00:00
name = ( $ . isArray ( wo . filter _cssFilter ) ?
( typeof wo . filter _cssFilter [ column ] !== 'undefined' ? wo . filter _cssFilter [ column ] || '' : '' ) :
2015-02-13 03:10:38 +00:00
wo . filter _cssFilter ) || '' ;
2015-05-16 22:13:17 +00:00
buildFilter . addClass ( tscss . filter + ' ' + name ) . attr ( 'data-column' , column ) ;
if ( disabled ) {
buildFilter . attr ( 'placeholder' , '' ) . addClass ( tscss . filterDisabled ) [ 0 ] . disabled = true ;
2015-02-13 03:10:38 +00:00
}
}
}
} ,
2015-05-16 22:13:17 +00:00
bindSearch : function ( table , $el , internal ) {
table = $ ( table ) [ 0 ] ;
$el = $ ( $el ) ; // allow passing a selector string
if ( ! $el . length ) { return ; }
var tmp ,
c = table . config ,
2015-02-13 03:10:38 +00:00
wo = c . widgetOptions ,
2015-05-16 22:13:17 +00:00
namespace = c . namespace + 'filter' ,
2015-02-13 03:10:38 +00:00
$ext = wo . filter _$externalFilters ;
2015-05-16 22:13:17 +00:00
if ( internal !== true ) {
2015-02-13 03:10:38 +00:00
// save anyMatch element
2015-05-16 22:13:17 +00:00
tmp = wo . filter _anyColumnSelector + ',' + wo . filter _multipleColumnSelector ;
wo . filter _$anyMatch = $el . filter ( tmp ) ;
if ( $ext && $ext . length ) {
2015-02-13 03:10:38 +00:00
wo . filter _$externalFilters = wo . filter _$externalFilters . add ( $el ) ;
} else {
wo . filter _$externalFilters = $el ;
}
2015-05-16 22:13:17 +00:00
// update values ( external filters added after table initialization )
ts . setFilters ( table , c . $table . data ( 'lastSearch' ) || [ ] , internal === false ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
// unbind events
tmp = ( 'keypress keyup search change ' . split ( ' ' ) . join ( namespace + ' ' ) ) ;
2015-02-13 03:10:38 +00:00
$el
2015-05-16 22:13:17 +00:00
// 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 ( /\s+/g , ' ' ) )
2015-02-13 03:10:38 +00:00
// include change for select - fixes #473
2015-05-16 22:13:17 +00:00
. bind ( 'keyup' + namespace , function ( event ) {
$ ( this ) . attr ( 'data-lastSearchTime' , new Date ( ) . getTime ( ) ) ;
2015-02-13 03:10:38 +00:00
// emulate what webkit does.... escape clears the filter
2015-05-16 22:13:17 +00:00
if ( event . which === 27 ) {
2015-02-13 03:10:38 +00:00
this . value = '' ;
// live search
} else if ( wo . filter _liveSearch === false ) {
return ;
2015-05-16 22:13:17 +00:00
// don't return if the search value is empty ( all rows need to be revealed )
2015-02-13 03:10:38 +00:00
} else if ( this . value !== '' && (
// liveSearch can contain a min value length; ignore arrow and meta keys, but allow backspace
( typeof wo . filter _liveSearch === 'number' && this . value . length < wo . filter _liveSearch ) ||
// let return & backspace continue on, but ignore arrows & non-valid characters
2015-05-16 22:13:17 +00:00
( event . which !== 13 && event . which !== 8 &&
( event . which < 32 || ( event . which >= 37 && event . which <= 40 ) ) ) ) ) {
2015-02-13 03:10:38 +00:00
return ;
}
// change event = no delay; last true flag tells getFilters to skip newest timed input
ts . filter . searching ( table , true , true ) ;
} )
2015-05-16 22:13:17 +00:00
. bind ( 'search change keypress ' . split ( ' ' ) . join ( namespace + ' ' ) , function ( event ) {
var column = $ ( this ) . data ( 'column' ) ;
// don't allow 'change' event to process if the input value is the same - fixes #685
if ( event . which === 13 || event . type === 'search' ||
event . type === 'change' && this . value !== c . lastSearch [ column ] ) {
2015-02-13 03:10:38 +00:00
event . preventDefault ( ) ;
// init search with no delay
2015-05-16 22:13:17 +00:00
$ ( this ) . attr ( 'data-lastSearchTime' , new Date ( ) . getTime ( ) ) ;
2015-02-13 03:10:38 +00:00
ts . filter . searching ( table , false , true ) ;
}
} ) ;
} ,
2015-05-16 22:13:17 +00:00
searching : function ( table , filter , skipFirst ) {
2015-02-13 03:10:38 +00:00
var wo = table . config . widgetOptions ;
2015-05-16 22:13:17 +00:00
clearTimeout ( wo . searchTimer ) ;
if ( typeof filter === 'undefined' || filter === true ) {
2015-02-13 03:10:38 +00:00
// delay filtering
2015-05-16 22:13:17 +00:00
wo . searchTimer = setTimeout ( function ( ) {
ts . filter . checkFilters ( table , filter , skipFirst ) ;
} , wo . filter _liveSearch ? wo . filter _searchDelay : 10 ) ;
2015-02-13 03:10:38 +00:00
} else {
// skip delay
2015-05-16 22:13:17 +00:00
ts . filter . checkFilters ( table , filter , skipFirst ) ;
2015-02-13 03:10:38 +00:00
}
} ,
2015-05-16 22:13:17 +00:00
checkFilters : function ( table , filter , skipFirst ) {
2015-02-13 03:10:38 +00:00
var c = table . config ,
wo = c . widgetOptions ,
2015-05-16 22:13:17 +00:00
filterArray = $ . isArray ( filter ) ,
filters = ( filterArray ) ? filter : ts . getFilters ( table , true ) ,
combinedFilters = ( filters || [ ] ) . join ( '' ) ; // combined filter values
2015-02-13 03:10:38 +00:00
// prevent errors if delay init is set
2015-05-16 22:13:17 +00:00
if ( $ . isEmptyObject ( c . cache ) ) {
// update cache if delayInit set & pager has initialized ( after user initiates a search )
if ( c . delayInit && c . pager && c . pager . initialized ) {
c . $table . trigger ( 'updateCache' , [ function ( ) {
ts . filter . checkFilters ( table , false , skipFirst ) ;
} ] ) ;
2015-02-13 03:10:38 +00:00
}
return ;
}
// add filter array back into inputs
2015-05-16 22:13:17 +00:00
if ( filterArray ) {
2015-02-13 03:10:38 +00:00
ts . setFilters ( table , filters , false , skipFirst !== true ) ;
2015-05-16 22:13:17 +00:00
if ( ! wo . filter _initialized ) { c . lastCombinedFilter = '' ; }
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( wo . filter _hideFilters ) {
2015-02-13 03:10:38 +00:00
// show/hide filter row as needed
2015-05-16 22:13:17 +00:00
c . $table
. find ( '.' + tscss . filterRow )
. trigger ( combinedFilters === '' ? 'mouseleave' : 'mouseenter' ) ;
2015-02-13 03:10:38 +00:00
}
// return if the last search is the same; but filter === false when updating the search
// see example-widget-filter.html filter toggle buttons
2015-05-16 22:13:17 +00:00
if ( c . lastCombinedFilter === combinedFilters && filter !== false ) {
2015-02-13 03:10:38 +00:00
return ;
2015-05-16 22:13:17 +00:00
} else if ( filter === false ) {
2015-02-13 03:10:38 +00:00
// force filter refresh
c . lastCombinedFilter = null ;
c . lastSearch = [ ] ;
}
2015-05-16 22:13:17 +00:00
if ( wo . filter _initialized ) {
c . $table . trigger ( 'filterStart' , [ filters ] ) ;
}
if ( c . showProcessing ) {
2015-02-13 03:10:38 +00:00
// give it time for the processing icon to kick in
2015-05-16 22:13:17 +00:00
setTimeout ( function ( ) {
ts . filter . findRows ( table , filters , combinedFilters ) ;
2015-02-13 03:10:38 +00:00
return false ;
2015-05-16 22:13:17 +00:00
} , 30 ) ;
2015-02-13 03:10:38 +00:00
} else {
2015-05-16 22:13:17 +00:00
ts . filter . findRows ( table , filters , combinedFilters ) ;
2015-02-13 03:10:38 +00:00
return false ;
}
} ,
2015-05-16 22:13:17 +00:00
hideFilters : function ( table , c ) {
2015-02-13 03:10:38 +00:00
var $filterRow , $filterRow2 , timer ;
2015-05-16 22:13:17 +00:00
$ ( table )
. find ( '.' + tscss . filterRow )
. addClass ( tscss . filterRowHide )
. bind ( 'mouseenter mouseleave' , function ( e ) {
2015-02-13 03:10:38 +00:00
// save event object - http://bugs.jquery.com/ticket/12140
var event = e ;
2015-05-16 22:13:17 +00:00
$filterRow = $ ( this ) ;
clearTimeout ( timer ) ;
timer = setTimeout ( function ( ) {
if ( /enter|over/ . test ( event . type ) ) {
$filterRow . removeClass ( tscss . filterRowHide ) ;
2015-02-13 03:10:38 +00:00
} else {
// don't hide if input has focus
2015-05-16 22:13:17 +00:00
// $( ':focus' ) needs jQuery 1.6+
if ( $ ( document . activeElement ) . closest ( 'tr' ) [ 0 ] !== $filterRow [ 0 ] ) {
2015-02-13 03:10:38 +00:00
// don't hide row if any filter has a value
2015-05-16 22:13:17 +00:00
if ( c . lastCombinedFilter === '' ) {
$filterRow . addClass ( tscss . filterRowHide ) ;
2015-02-13 03:10:38 +00:00
}
}
}
2015-05-16 22:13:17 +00:00
} , 200 ) ;
2015-02-13 03:10:38 +00:00
} )
2015-05-16 22:13:17 +00:00
. find ( 'input, select' ) . bind ( 'focus blur' , function ( e ) {
$filterRow2 = $ ( this ) . closest ( 'tr' ) ;
clearTimeout ( timer ) ;
2015-02-13 03:10:38 +00:00
var event = e ;
2015-05-16 22:13:17 +00:00
timer = setTimeout ( function ( ) {
2015-02-13 03:10:38 +00:00
// don't hide row if any filter has a value
2015-05-16 22:13:17 +00:00
if ( ts . getFilters ( c . $table ) . join ( '' ) === '' ) {
$filterRow2 . toggleClass ( tscss . filterRowHide , event . type === 'focus' ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
} , 200 ) ;
2015-02-13 03:10:38 +00:00
} ) ;
} ,
2015-05-16 22:13:17 +00:00
defaultFilter : function ( filter , mask ) {
if ( filter === '' ) { return filter ; }
2015-02-13 03:10:38 +00:00
var regex = ts . filter . regex . iQuery ,
maskLen = mask . match ( ts . filter . regex . igQuery ) . length ,
2015-05-16 22:13:17 +00:00
query = maskLen > 1 ? $ . trim ( filter ) . split ( /\s/ ) : [ $ . trim ( filter ) ] ,
2015-02-13 03:10:38 +00:00
len = query . length - 1 ,
indx = 0 ,
val = mask ;
if ( len < 1 && maskLen > 1 ) {
2015-05-16 22:13:17 +00:00
// only one 'word' in query but mask has >1 slots
2015-02-13 03:10:38 +00:00
query [ 1 ] = query [ 0 ] ;
}
// replace all {query} with query words...
2015-05-16 22:13:17 +00:00
// 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 ) ;
2015-02-13 03:10:38 +00:00
}
}
return val ;
} ,
getLatestSearch : function ( $input ) {
2015-05-16 22:13:17 +00:00
if ( $input ) {
return $input . sort ( function ( a , b ) {
return $ ( b ) . attr ( 'data-lastSearchTime' ) - $ ( a ) . attr ( 'data-lastSearchTime' ) ;
2015-02-20 20:16:42 +00:00
} ) ;
}
return $ ( ) ;
2015-02-13 03:10:38 +00:00
} ,
multipleColumns : function ( c , $input ) {
2015-05-16 22:13:17 +00:00
// look for multiple columns '1-3,4-6,8' in data-column
2015-02-26 00:43:59 +00:00
var temp , ranges , range , start , end , singles , i , indx , len ,
2015-02-13 03:10:38 +00:00
wo = c . widgetOptions ,
2015-05-16 22:13:17 +00:00
// 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 ,
2015-02-13 03:10:38 +00:00
columns = [ ] ,
2015-05-16 22:13:17 +00:00
val = $ . trim ( ts . filter . getLatestSearch ( $input ) . attr ( 'data-column' ) || '' ) ;
2015-02-13 03:10:38 +00:00
// process column range
if ( targets && /-/ . test ( val ) ) {
ranges = val . match ( /(\d+)\s*-\s*(\d+)/g ) ;
2015-02-26 00:43:59 +00:00
len = ranges . length ;
2015-05-16 22:13:17 +00:00
for ( indx = 0 ; indx < len ; indx ++ ) {
2015-02-26 00:43:59 +00:00
range = ranges [ indx ] . split ( /\s*-\s*/ ) ;
start = parseInt ( range [ 0 ] , 10 ) || 0 ;
end = parseInt ( range [ 1 ] , 10 ) || ( c . columns - 1 ) ;
2015-05-16 22:13:17 +00:00
if ( start > end ) {
temp = start ; start = end ; end = temp ; // swap
}
if ( end >= c . columns ) {
end = c . columns - 1 ;
}
2015-02-13 03:10:38 +00:00
for ( ; start <= end ; start ++ ) {
2015-05-16 22:13:17 +00:00
columns . push ( start ) ;
2015-02-13 03:10:38 +00:00
}
// remove processed range from val
2015-05-16 22:13:17 +00:00
val = val . replace ( ranges [ indx ] , '' ) ;
2015-02-26 00:43:59 +00:00
}
2015-02-13 03:10:38 +00:00
}
// process single columns
if ( targets && /,/ . test ( val ) ) {
singles = val . split ( /\s*,\s*/ ) ;
2015-02-26 00:43:59 +00:00
len = singles . length ;
2015-05-16 22:13:17 +00:00
for ( i = 0 ; i < len ; i ++ ) {
if ( singles [ i ] !== '' ) {
indx = parseInt ( singles [ i ] , 10 ) ;
2015-02-13 03:10:38 +00:00
if ( indx < c . columns ) {
columns . push ( indx ) ;
}
}
2015-02-26 00:43:59 +00:00
}
2015-02-13 03:10:38 +00:00
}
// return all columns
2015-05-16 22:13:17 +00:00
if ( ! columns . length ) {
2015-02-13 03:10:38 +00:00
for ( indx = 0 ; indx < c . columns ; indx ++ ) {
columns . push ( indx ) ;
}
}
return columns ;
} ,
2015-05-15 02:32:41 +00:00
processRow : function ( c , data , vars ) {
2015-05-16 22:13:17 +00:00
var $cell , columnIndex , hasSelect , matches , result , val , filterMatched , excludeMatch ,
fxn , ffxn , txt ,
2015-05-15 02:32:41 +00:00
regex = ts . filter . regex ,
wo = c . widgetOptions ,
showRow = true ;
data . $cells = data . $row . children ( ) ;
if ( data . anyMatchFlag ) {
2015-05-16 22:13:17 +00:00
// look for multiple columns '1-3,4-6,8'
2015-05-15 02:32:41 +00:00
columnIndex = ts . filter . multipleColumns ( c , wo . filter _$anyMatch ) ;
data . anyMatch = true ;
2015-05-16 22:13:17 +00:00
data . rowArray = data . $cells . map ( function ( i ) {
if ( $ . inArray ( i , columnIndex ) > - 1 ) {
if ( data . parsed [ i ] ) {
txt = data . cacheArray [ i ] ;
2015-05-15 02:32:41 +00:00
} else {
2015-05-16 22:13:17 +00:00
txt = data . rawArray [ i ] ;
2015-05-15 02:32:41 +00:00
txt = $ . trim ( wo . filter _ignoreCase ? txt . toLowerCase ( ) : txt ) ;
2015-05-16 22:13:17 +00:00
if ( c . sortLocaleCompare ) {
txt = ts . replaceAccents ( txt ) ;
2015-05-15 02:32:41 +00:00
}
}
return txt ;
}
} ) . get ( ) ;
data . filter = data . anyMatchFilter ;
data . iFilter = data . iAnyMatchFilter ;
2015-05-16 22:13:17 +00:00
data . exact = data . rowArray . join ( ' ' ) ;
2015-05-15 02:32:41 +00:00
data . iExact = wo . filter _ignoreCase ? data . exact . toLowerCase ( ) : data . exact ;
2015-05-16 22:13:17 +00:00
data . cache = data . cacheArray . slice ( 0 , - 1 ) . join ( ' ' ) ;
2015-05-15 02:32:41 +00:00
filterMatched = null ;
matches = null ;
2015-05-16 22:13:17 +00:00
for ( ffxn in ts . filter . types ) {
if ( $ . inArray ( ffxn , vars . noAnyMatch ) < 0 && matches === null ) {
2015-05-15 02:32:41 +00:00
matches = ts . filter . types [ ffxn ] ( c , data ) ;
2015-05-16 22:13:17 +00:00
if ( matches !== null ) {
2015-05-15 02:32:41 +00:00
filterMatched = matches ;
}
}
}
2015-05-16 22:13:17 +00:00
if ( filterMatched !== null ) {
2015-05-15 02:32:41 +00:00
showRow = filterMatched ;
} else {
if ( wo . filter _startsWith ) {
showRow = false ;
columnIndex = c . columns ;
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
excludeMatch = vars . excludeFilter [ columnIndex ] ;
// ignore if filter is empty or disabled
if ( data . filter ) {
data . cache = data . cacheArray [ columnIndex ] ;
// check if column data should be from the cell or from parsed data
if ( wo . filter _useParsedData || data . parsed [ columnIndex ] ) {
data . exact = data . cache ;
} else {
result = data . rawArray [ columnIndex ] || '' ;
data . exact = c . sortLocaleCompare ? ts . replaceAccents ( result ) : result ; // issue #405
}
data . iExact = ! regex . type . test ( typeof data . exact ) && wo . filter _ignoreCase ?
data . exact . toLowerCase ( ) : data . exact ;
result = showRow ; // if showRow is true, show that row
2015-05-16 22:13:17 +00:00
// in case select filter option has a different value vs text 'a - z|A through Z'
2015-05-15 02:32:41 +00:00
ffxn = wo . filter _columnFilters ?
c . $filters . add ( c . $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 ) ;
}
val = true ;
if ( wo . filter _defaultFilter && regex . iQuery . test ( vars . defaultColFilter [ columnIndex ] ) ) {
data . filter = ts . filter . defaultFilter ( data . filter , vars . defaultColFilter [ columnIndex ] ) ;
// val is used to indicate that a filter select is using a default filter;
// so we override the exact & partial matches
val = false ;
}
2015-05-16 22:13:17 +00:00
// data.iFilter = case insensitive ( if wo.filter_ignoreCase is true ),
// data.filter = case sensitive
2015-05-15 02:32:41 +00:00
data . iFilter = wo . filter _ignoreCase ? ( data . filter || '' ) . toLowerCase ( ) : data . filter ;
fxn = vars . functions [ columnIndex ] ;
$cell = c . $headerIndexed [ columnIndex ] ;
hasSelect = $cell . hasClass ( 'filter-select' ) ;
filterMatched = null ;
if ( fxn || ( hasSelect && val ) ) {
if ( fxn === true || hasSelect ) {
2015-05-16 22:13:17 +00:00
// default selector uses exact match unless 'filter-match' class is found
filterMatched = $cell . hasClass ( 'filter-match' ) ?
data . iExact . search ( data . iFilter ) >= 0 :
data . filter === data . exact ;
2015-05-15 02:32:41 +00:00
} else 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
2015-05-16 22:13:17 +00:00
txt = ffxn || data . filter ;
2015-05-15 02:32:41 +00:00
filterMatched =
2015-05-16 22:13:17 +00:00
fxn [ txt ] ( data . exact , data . cache , data . filter , columnIndex , data . $row , c , data ) ;
2015-05-15 02:32:41 +00:00
}
}
if ( filterMatched === null ) {
// cycle through the different filters
// filters return a boolean or null if nothing matches
matches = null ;
for ( ffxn in ts . filter . types ) {
if ( $ . inArray ( ffxn , excludeMatch ) < 0 && matches === null ) {
matches = ts . filter . types [ ffxn ] ( c , data ) ;
if ( matches !== null ) {
filterMatched = matches ;
}
}
}
if ( filterMatched !== null ) {
result = filterMatched ;
// Look for match, and add child row data for matching
} else {
txt = ( data . iExact + data . childRowText )
. indexOf ( ts . filter . parseFilter ( c , data . iFilter , columnIndex , data . parsed [ columnIndex ] ) ) ;
result = ( ( ! wo . filter _startsWith && txt >= 0 ) || ( wo . filter _startsWith && txt === 0 ) ) ;
}
} else {
result = filterMatched ;
}
showRow = ( result ) ? showRow : false ;
}
}
return showRow ;
} ,
findRows : function ( table , filters , combinedFilters ) {
if ( table . config . lastCombinedFilter === combinedFilters ||
! table . config . widgetOptions . filter _initialized ) {
return ;
}
var len , norm _rows , rowData , $rows , rowIndex , tbodyIndex , $tbody , columnIndex ,
isChild , childRow , lastSearch , showRow , time , val , indx ,
notFiltered , searchFiltered , query , injected , res , id , txt ,
2015-05-12 17:00:30 +00:00
storedFilters = $ . extend ( [ ] , filters ) ,
2015-02-13 03:10:38 +00:00
regex = ts . filter . regex ,
c = table . config ,
wo = c . widgetOptions ,
// data object passed to filters; anyMatch is a flag for the filters
2015-05-15 02:32:41 +00:00
data = {
anyMatch : false ,
filters : filters ,
// regex filter type cache
filter _regexCache : [ ] ,
} ,
vars = {
// anyMatch really screws up with these types of filters
noAnyMatch : [ 'range' , 'notMatch' , '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 ) || ''
} ;
2015-05-06 03:17:14 +00:00
2015-02-13 03:10:38 +00:00
// parse columns after formatter, in case the class is added at that point
2015-05-15 02:32:41 +00:00
data . parsed = c . $headers . map ( function ( columnIndex ) {
return c . parsers && c . parsers [ columnIndex ] &&
// force parsing if parser type is numeric
( c . parsers [ columnIndex ] . parsed || c . parsers [ columnIndex ] . type === 'numeric' ) ||
2015-05-16 22:13:17 +00:00
// getData won't return 'parsed' if other 'filter-' class names exist
// ( e.g. <th class="filter-select filter-parsed"> )
2015-05-15 02:32:41 +00:00
ts . getData && ts . getData ( c . $headerIndexed [ columnIndex ] ,
ts . getColumnData ( table , c . headers , columnIndex ) , 'filter' ) === 'parsed' ||
$ ( this ) . hasClass ( 'filter-parsed' ) ;
2015-02-13 03:10:38 +00:00
} ) . get ( ) ;
2015-04-07 16:25:40 +00:00
for ( columnIndex = 0 ; columnIndex < c . columns ; columnIndex ++ ) {
2015-05-16 22:13:17 +00:00
vars . functions [ columnIndex ] =
ts . getColumnData ( table , wo . filter _functions , columnIndex ) ;
vars . defaultColFilter [ columnIndex ] =
ts . getColumnData ( table , wo . filter _defaultFilter , columnIndex ) || '' ;
vars . excludeFilter [ columnIndex ] =
( ts . getColumnData ( table , wo . filter _excludeFilter , columnIndex , true ) || '' ) . split ( /\s+/ ) ;
2015-04-07 16:25:40 +00:00
}
2015-05-16 22:13:17 +00:00
if ( c . debug ) {
ts . log ( 'Filter: Starting filter widget search' , filters ) ;
2015-02-13 03:10:38 +00:00
time = new Date ( ) ;
}
// filtered rows count
c . filteredRows = 0 ;
c . totalRows = 0 ;
// combindedFilters are undefined on init
2015-05-16 22:13:17 +00:00
combinedFilters = ( storedFilters || [ ] ) . join ( '' ) ;
2015-02-13 03:10:38 +00:00
2015-05-16 22:13:17 +00:00
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 );
2015-02-13 03:10:38 +00:00
columnIndex = c . columns ;
// convert stored rows into a jQuery object
2015-05-16 22:13:17 +00:00
norm _rows = c . cache [ tbodyIndex ] . normalized ;
$rows = $ ( $ . map ( norm _rows , function ( el ) {
return el [ columnIndex ] . $row . get ( ) ;
} ) ) ;
2015-02-13 03:10:38 +00:00
2015-05-16 22:13:17 +00:00
if ( combinedFilters === '' || wo . filter _serversideFiltering ) {
$rows
. removeClass ( wo . filter _filteredRow )
. not ( '.' + c . cssChildRow )
. css ( 'display' , '' ) ;
2015-02-13 03:10:38 +00:00
} else {
// filter out child rows
2015-05-16 22:13:17 +00:00
$rows = $rows . not ( '.' + c . cssChildRow ) ;
2015-02-13 03:10:38 +00:00
len = $rows . length ;
2015-02-20 22:33:58 +00:00
2015-05-16 22:13:17 +00:00
if ( ( wo . filter _$anyMatch && wo . filter _$anyMatch . length ) ||
typeof filters [ c . columns ] !== 'undefined' ) {
2015-02-20 22:33:58 +00:00
data . anyMatchFlag = true ;
2015-05-16 22:13:17 +00:00
data . anyMatchFilter = '' + (
filters [ c . columns ] ||
wo . filter _$anyMatch && ts . filter . getLatestSearch ( wo . filter _$anyMatch ) . val ( ) ||
''
) ;
if ( wo . filter _columnAnyMatch ) {
2015-02-20 22:33:58 +00:00
// specific columns search
2015-05-15 02:32:41 +00:00
query = data . anyMatchFilter . split ( regex . andSplit ) ;
2015-02-20 22:33:58 +00:00
injected = false ;
2015-05-16 22:13:17 +00:00
for ( indx = 0 ; indx < query . length ; indx ++ ) {
res = query [ indx ] . split ( ':' ) ;
2015-02-20 22:33:58 +00:00
if ( res . length > 1 ) {
// make the column a one-based index ( non-developers start counting from one :P )
id = parseInt ( res [ 0 ] , 10 ) - 1 ;
if ( id >= 0 && id < c . columns ) { // if id is an integer
2015-05-16 22:13:17 +00:00
filters [ id ] = res [ 1 ] ;
query . splice ( indx , 1 ) ;
2015-02-20 22:33:58 +00:00
indx -- ;
injected = true ;
}
}
}
2015-05-16 22:13:17 +00:00
if ( injected ) {
data . anyMatchFilter = query . join ( ' && ' ) ;
2015-02-20 22:33:58 +00:00
}
}
}
2015-02-13 03:10:38 +00:00
// optimize searching only through already filtered rows - see #313
searchFiltered = wo . filter _searchFiltered ;
2015-05-16 22:13:17 +00:00
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 ++ ) {
2015-02-13 03:10:38 +00:00
val = filters [ indx ] || '' ;
// break out of loop if we've already determined not to search filtered rows
2015-05-16 22:13:17 +00:00
if ( ! searchFiltered ) { indx = columnIndex ; }
2015-02-13 03:10:38 +00:00
// search already filtered rows if...
searchFiltered = searchFiltered && lastSearch . length &&
// there are no changes from beginning of filter
2015-05-16 22:13:17 +00:00
val . indexOf ( lastSearch [ indx ] || '' ) === 0 &&
// if there is NOT a logical 'or', or range ( 'to' or '-' ) in the string
! regex . alreadyFiltered . test ( val ) &&
// if we are not doing exact matches, using '|' ( logical or ) or not '!'
! /[=\"\|!]/ . test ( val ) &&
// don't search only filtered if the value is negative
// ( '> -10' => '> -100' will ignore hidden rows )
! ( /(>=?\s*-\d)/ . test ( val ) || /(<=?\s*\d)/ . test ( val ) ) &&
// if filtering using a select without a 'filter-match' class ( exact match ) - fixes #593
! ( val !== '' && c . $filters && c . $filters . eq ( indx ) . find ( 'select' ) . length &&
! c . $headerIndexed [ indx ] . hasClass ( 'filter-match' ) ) ;
2015-02-13 03:10:38 +00:00
}
}
2015-05-16 22:13:17 +00:00
notFiltered = $rows . not ( '.' + wo . filter _filteredRow ) . length ;
2015-02-13 03:10:38 +00:00
// can't search when all rows are hidden - this happens when looking for exact matches
2015-05-16 22:13:17 +00:00
if ( searchFiltered && notFiltered === 0 ) { searchFiltered = false ; }
if ( c . debug ) {
ts . log ( 'Filter: Searching through ' +
( searchFiltered && notFiltered < len ? notFiltered : 'all' ) + ' rows' ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( data . anyMatchFlag ) {
if ( c . sortLocaleCompare ) {
2015-02-13 03:10:38 +00:00
// replace accents
2015-05-16 22:13:17 +00:00
data . anyMatchFilter = ts . replaceAccents ( data . anyMatchFilter ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-15 02:32:41 +00:00
if ( wo . filter _defaultFilter && regex . iQuery . test ( vars . defaultAnyFilter ) ) {
data . anyMatchFilter = ts . filter . defaultFilter ( data . anyMatchFilter , vars . defaultAnyFilter ) ;
2015-02-13 03:10:38 +00:00
// 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
2015-05-16 22:13:17 +00:00
data . iAnyMatchFilter = ! ( wo . filter _ignoreCase && c . ignoreCase ) ?
data . anyMatchFilter :
data . anyMatchFilter . toLowerCase ( ) ;
2015-02-13 03:10:38 +00:00
}
// loop through the rows
2015-05-16 22:13:17 +00:00
for ( rowIndex = 0 ; rowIndex < len ; rowIndex ++ ) {
2015-02-13 03:10:38 +00:00
2015-05-16 22:13:17 +00:00
txt = $rows [ rowIndex ] . className ;
2015-05-15 02:32:41 +00:00
// the first row can never be a child row
2015-05-16 22:13:17 +00:00
isChild = rowIndex && regex . child . test ( txt ) ;
2015-02-13 03:10:38 +00:00
// skip child rows & already filtered rows
2015-05-15 02:32:41 +00:00
if ( isChild || ( searchFiltered && regex . filtered . test ( txt ) ) ) {
continue ;
2015-02-13 03:10:38 +00:00
}
2015-05-15 02:32:41 +00:00
data . $row = $rows . eq ( rowIndex ) ;
data . cacheArray = norm _rows [ rowIndex ] ;
rowData = data . cacheArray [ c . columns ] ;
data . rawArray = rowData . raw ;
data . childRowText = '' ;
2015-02-13 03:10:38 +00:00
2015-05-15 02:32:41 +00:00
if ( ! wo . filter _childByColumn ) {
txt = '' ;
// child row cached text
childRow = rowData . child ;
2015-05-16 22:13:17 +00:00
// so, if 'table.config.widgetOptions.filter_childRows' is true and there is
2015-05-15 02:32:41 +00:00
// a match anywhere in the child row, then it will make the row visible
// checked here so the option can be changed dynamically
2015-05-16 22:13:17 +00:00
for ( indx = 0 ; indx < childRow . length ; indx ++ ) {
txt += ' ' + childRow [ indx ] . join ( '' ) || '' ;
2015-05-15 02:32:41 +00:00
}
data . childRowText = wo . filter _childRows ?
( wo . filter _ignoreCase ? txt . toLowerCase ( ) : txt ) :
'' ;
}
2015-02-13 03:10:38 +00:00
2015-05-15 02:32:41 +00:00
showRow = ts . filter . processRow ( c , data , vars ) ;
2015-05-16 22:13:17 +00:00
childRow = rowData . $row . filter ( ':gt( 0 )' ) ;
2015-02-13 03:10:38 +00:00
2015-05-15 02:32:41 +00:00
if ( wo . filter _childRows && childRow . length ) {
if ( wo . filter _childByColumn ) {
// 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 ;
// use OR comparison on child rows
showRow = showRow || ts . filter . processRow ( c , data , vars ) ;
2015-04-08 03:12:53 +00:00
}
2015-02-13 03:10:38 +00:00
}
2015-05-15 02:32:41 +00:00
childRow . toggleClass ( wo . filter _filteredRow , ! showRow ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-15 02:32:41 +00:00
rowData . $row
2015-05-16 22:13:17 +00:00
. toggleClass ( wo . filter _filteredRow , ! showRow ) [ 0 ]
2015-03-05 13:18:33 +00:00
. display = showRow ? '' : 'none' ;
2015-02-13 03:10:38 +00:00
}
}
2015-05-16 22:13:17 +00:00
c . filteredRows += $rows . not ( '.' + wo . filter _filteredRow ) . length ;
2015-02-13 03:10:38 +00:00
c . totalRows += $rows . length ;
2015-05-16 22:13:17 +00:00
ts . processTbody ( table , $tbody , false ) ;
2015-02-13 03:10:38 +00:00
}
c . lastCombinedFilter = combinedFilters ; // save last search
2015-05-16 22:13:17 +00:00
// don't save 'filters' directly since it may have altered ( AnyMatch column searches )
2015-05-12 17:00:30 +00:00
c . lastSearch = storedFilters ;
2015-05-16 22:13:17 +00:00
c . $table . data ( 'lastSearch' , storedFilters ) ;
if ( wo . filter _saveFilters && ts . storage ) {
2015-05-12 17:00:30 +00:00
ts . storage ( table , 'tablesorter-filters' , storedFilters ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( c . debug ) {
ts . benchmark ( 'Completed filter widget search' , time ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( wo . filter _initialized ) {
c . $table . trigger ( 'filterEnd' , c ) ;
}
setTimeout ( function ( ) {
c . $table . trigger ( 'applyWidgets' ) ; // make sure zebra widget is applied
} , 0 ) ;
2015-02-13 03:10:38 +00:00
} ,
2015-05-16 22:13:17 +00:00
getOptionSource : function ( table , column , onlyAvail ) {
table = $ ( table ) [ 0 ] ;
2015-02-26 00:43:59 +00:00
var cts , indx , len ,
2015-02-13 03:10:38 +00:00
c = table . config ,
wo = c . widgetOptions ,
parsed = [ ] ,
arry = false ,
source = wo . filter _selectSource ,
2015-05-16 22:13:17 +00:00
last = c . $table . data ( 'lastSearch' ) || [ ] ,
fxn = $ . isFunction ( source ) ? true : ts . getColumnData ( table , source , column ) ;
2015-02-13 03:10:38 +00:00
2015-05-16 22:13:17 +00:00
if ( onlyAvail && last [ column ] !== '' ) {
2015-02-13 03:10:38 +00:00
onlyAvail = false ;
}
// filter select source option
2015-05-16 22:13:17 +00:00
if ( fxn === true ) {
2015-02-13 03:10:38 +00:00
// OVERALL source
2015-05-16 22:13:17 +00:00
arry = source ( table , column , onlyAvail ) ;
} else if ( fxn instanceof $ || ( $ . type ( fxn ) === 'string' && fxn . indexOf ( '</option>' ) >= 0 ) ) {
2015-02-13 03:10:38 +00:00
// selectSource is a jQuery object or string of options
return fxn ;
2015-05-16 22:13:17 +00:00
} else if ( $ . isArray ( fxn ) ) {
2015-02-13 03:10:38 +00:00
arry = fxn ;
2015-05-16 22:13:17 +00:00
} else if ( $ . type ( source ) === 'object' && fxn ) {
2015-02-13 03:10:38 +00:00
// custom select source function for a SPECIFIC COLUMN
2015-05-16 22:13:17 +00:00
arry = fxn ( table , column , onlyAvail ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( arry === false ) {
2015-02-13 03:10:38 +00:00
// fall back to original method
2015-05-16 22:13:17 +00:00
arry = ts . filter . getOptions ( table , column , onlyAvail ) ;
2015-02-13 03:10:38 +00:00
}
// get unique elements and sort the list
2015-05-16 22:13:17 +00:00
// if $.tablesorter.sortText exists ( not in the original tablesorter ),
2015-02-13 03:10:38 +00:00
// then natural sort the list otherwise use a basic sort
2015-05-16 22:13:17 +00:00
arry = $ . grep ( arry , function ( value , indx ) {
return $ . inArray ( value , arry ) === indx ;
2015-02-13 03:10:38 +00:00
} ) ;
2015-05-16 22:13:17 +00:00
if ( c . $headerIndexed [ column ] . hasClass ( 'filter-select-nosort' ) ) {
2015-02-13 03:10:38 +00:00
// unsorted select options
return arry ;
} else {
2015-02-26 00:43:59 +00:00
len = arry . length ;
2015-02-13 03:10:38 +00:00
// parse select option values
2015-05-16 22:13:17 +00:00
for ( indx = 0 ; indx < len ; indx ++ ) {
2015-02-13 03:10:38 +00:00
// parse array data using set column parser; this DOES NOT pass the original
// table cell to the parser format function
2015-05-16 22:13:17 +00:00
parsed . push ( {
t : arry [ indx ] ,
p : c . parsers && c . parsers [ column ] . format ( arry [ indx ] , table , [ ] , column )
} ) ;
2015-02-26 00:43:59 +00:00
}
2015-02-13 03:10:38 +00:00
// sort parsed select options
cts = c . textSorter || '' ;
2015-05-16 22:13:17 +00:00
parsed . sort ( function ( a , b ) {
2015-02-13 03:10:38 +00:00
// sortNatural breaks if you don't pass it strings
2015-05-16 22:13:17 +00:00
var x = a . p . toString ( ) ,
y = b . p . toString ( ) ;
if ( $ . isFunction ( cts ) ) {
2015-02-13 03:10:38 +00:00
// custom OVERALL text sorter
2015-05-16 22:13:17 +00:00
return cts ( x , y , true , column , table ) ;
} else if ( typeof ( cts ) === 'object' && cts . hasOwnProperty ( column ) ) {
2015-02-13 03:10:38 +00:00
// custom text sorter for a SPECIFIC COLUMN
2015-05-16 22:13:17 +00:00
return cts [ column ] ( x , y , true , column , table ) ;
} else if ( ts . sortNatural ) {
2015-02-13 03:10:38 +00:00
// fall back to natural sort
2015-05-16 22:13:17 +00:00
return ts . sortNatural ( x , y ) ;
2015-02-13 03:10:38 +00:00
}
// using an older version! do a basic sort
return true ;
} ) ;
// rebuild arry from sorted parsed data
arry = [ ] ;
2015-02-26 00:43:59 +00:00
len = parsed . length ;
2015-05-16 22:13:17 +00:00
for ( indx = 0 ; indx < len ; indx ++ ) {
2015-02-26 00:43:59 +00:00
arry . push ( parsed [ indx ] . t ) ;
}
2015-02-13 03:10:38 +00:00
return arry ;
}
} ,
2015-05-16 22:13:17 +00:00
getOptions : function ( table , column , onlyAvail ) {
table = $ ( table ) [ 0 ] ;
2015-05-15 02:32:41 +00:00
var rowIndex , tbodyIndex , len , row , cache ,
2015-02-13 03:10:38 +00:00
c = table . config ,
wo = c . widgetOptions ,
arry = [ ] ;
2015-05-16 22:13:17 +00:00
for ( tbodyIndex = 0 ; tbodyIndex < c . $tbodies . length ; tbodyIndex ++ ) {
2015-02-20 20:32:36 +00:00
cache = c . cache [ tbodyIndex ] ;
len = c . cache [ tbodyIndex ] . normalized . length ;
// loop through the rows
2015-05-16 22:13:17 +00:00
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 ] ;
2015-02-20 20:32:36 +00:00
// check if has class filtered
2015-05-16 22:13:17 +00:00
if ( onlyAvail && row . className . match ( wo . filter _filteredRow ) ) {
continue ;
}
2015-02-20 20:32:36 +00:00
// get non-normalized cell content
2015-05-16 22:13:17 +00:00
if ( wo . filter _useParsedData ||
c . parsers [ column ] . parsed ||
c . $headerIndexed [ column ] . hasClass ( 'filter-parsed' ) ) {
arry . push ( '' + cache . normalized [ rowIndex ] [ column ] ) ;
2015-02-20 20:32:36 +00:00
} else {
2015-05-06 04:44:06 +00:00
// get raw cached data instead of content directly from the cells
2015-05-16 22:13:17 +00:00
arry . push ( cache . normalized [ rowIndex ] [ c . columns ] . raw [ column ] ) ;
2015-02-13 03:10:38 +00:00
}
}
}
return arry ;
} ,
2015-05-16 22:13:17 +00:00
buildSelect : function ( table , column , arry , updating , onlyAvail ) {
table = $ ( table ) [ 0 ] ;
column = parseInt ( column , 10 ) ;
if ( ! table . config . cache || $ . isEmptyObject ( table . config . cache ) ) {
return ;
}
2015-02-13 03:10:38 +00:00
var indx , val , txt , t , $filters , $filter ,
c = table . config ,
wo = c . widgetOptions ,
2015-05-16 22:13:17 +00:00
node = c . $headerIndexed [ column ] ,
// t.data( 'placeholder' ) won't work in jQuery older than 1.4.3
options = '<option value="">' +
( node . data ( 'placeholder' ) ||
node . attr ( 'data-placeholder' ) ||
wo . filter _placeholder . select || ''
) + '</option>' ,
2015-02-13 03:10:38 +00:00
// Get curent filter value
2015-05-16 22:13:17 +00:00
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 = ts . filter . getOptionSource ( table , column , onlyAvail ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( $ . isArray ( arry ) ) {
2015-02-13 03:10:38 +00:00
// build option list
2015-05-16 22:13:17 +00:00
for ( indx = 0 ; indx < arry . length ; indx ++ ) {
txt = arry [ indx ] = ( '' + arry [ indx ] ) . replace ( /\"/g , '"' ) ;
2015-02-13 03:10:38 +00:00
val = txt ;
// allow including a symbol in the selectSource array
2015-05-16 22:13:17 +00:00
// 'a-z|A through Z' so that 'a-z' becomes the option value
// and 'A through Z' becomes the option text
if ( txt . indexOf ( wo . filter _selectSourceSeparator ) >= 0 ) {
t = txt . split ( wo . filter _selectSourceSeparator ) ;
2015-02-13 03:10:38 +00:00
val = t [ 0 ] ;
txt = t [ 1 ] ;
}
2015-05-16 22:13:17 +00:00
// replace quotes - fixes #242 & ignore empty strings
// see http://stackoverflow.com/q/14990971/145346
options += arry [ indx ] !== '' ?
'<option ' +
( val === txt ? '' : 'data-function-name="' + arry [ indx ] + '" ' ) +
'value="' + val + '">' + txt +
'</option>' : '' ;
2015-02-13 03:10:38 +00:00
}
// clear arry so it doesn't get appended twice
arry = [ ] ;
}
2015-05-16 22:13:17 +00:00
// 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 ( '.' + tscss . filter ) ;
if ( wo . filter _$externalFilters ) {
$filters = $filters && $filters . length ?
$filters . add ( wo . filter _$externalFilters ) :
wo . filter _$externalFilters ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
$filter = $filters . filter ( 'select[data-column="' + column + '"]' ) ;
2015-02-13 03:10:38 +00:00
// make sure there is a select there!
2015-05-16 22:13:17 +00:00
if ( $filter . length ) {
$filter [ updating ? 'html' : 'append' ] ( options ) ;
if ( ! $ . isArray ( arry ) ) {
2015-02-13 03:10:38 +00:00
// append options if arry is provided externally as a string or jQuery object
2015-05-16 22:13:17 +00:00
// options ( default value ) was already added
$filter . append ( arry ) . val ( currentValue ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
$filter . val ( currentValue ) ;
2015-02-13 03:10:38 +00:00
}
} ,
2015-05-16 22:13:17 +00:00
buildDefault : function ( table , updating ) {
2015-02-13 03:10:38 +00:00
var columnIndex , $header , noSelect ,
c = table . config ,
wo = c . widgetOptions ,
columns = c . columns ;
// build default select dropdown
2015-05-16 22:13:17 +00:00
for ( columnIndex = 0 ; columnIndex < columns ; columnIndex ++ ) {
2015-02-27 20:26:16 +00:00
$header = c . $headerIndexed [ columnIndex ] ;
2015-05-16 22:13:17 +00:00
noSelect = ! ( $header . hasClass ( 'filter-false' ) || $header . hasClass ( 'parser-false' ) ) ;
2015-02-13 03:10:38 +00:00
// look for the filter-select class; build/update it if found
2015-05-16 22:13:17 +00:00
if ( ( $header . hasClass ( 'filter-select' ) ||
ts . getColumnData ( table , wo . filter _functions , columnIndex ) === true ) && noSelect ) {
ts . filter . buildSelect ( table , columnIndex , '' , updating , $header . hasClass ( wo . filter _onlyAvail ) ) ;
2015-02-13 03:10:38 +00:00
}
}
}
} ;
2015-05-16 22:13:17 +00:00
ts . getFilters = function ( table , getRaw , setFilters , skipFirst ) {
2015-02-13 03:10:38 +00:00
var i , $filters , $column , cols ,
filters = false ,
2015-05-16 22:13:17 +00:00
c = table ? $ ( table ) [ 0 ] . config : '' ,
2015-02-13 03:10:38 +00:00
wo = c ? c . widgetOptions : '' ;
2015-05-16 22:35:54 +00:00
if ( ( getRaw !== true && wo && ! wo . filter _columnFilters ) ||
// setFilters called, but last search is exactly the same as the current
// fixes issue #733 & #903 where calling update causes the input values to reset
( $ . isArray ( setFilters ) && setFilters . join ( '' ) === c . lastCombinedFilter ) ) {
2015-05-16 22:13:17 +00:00
return $ ( table ) . data ( 'lastSearch' ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( c ) {
if ( c . $filters ) {
$filters = c . $filters . find ( '.' + tscss . filter ) ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( wo . filter _$externalFilters ) {
$filters = $filters && $filters . length ?
$filters . add ( wo . filter _$externalFilters ) :
wo . filter _$externalFilters ;
2015-02-13 03:10:38 +00:00
}
2015-05-16 22:13:17 +00:00
if ( $filters && $filters . length ) {
2015-02-13 03:10:38 +00:00
filters = setFilters || [ ] ;
2015-05-16 22:13:17 +00:00
for ( i = 0 ; i < c . columns + 1 ; i ++ ) {
2015-02-13 03:10:38 +00:00
cols = ( i === c . columns ?
2015-05-16 22:13:17 +00:00
// 'all' columns can now include a range or set of columms ( data-column='0-2,4,6-7' )
2015-02-13 03:10:38 +00:00
wo . filter _anyColumnSelector + ',' + wo . filter _multipleColumnSelector :
'[data-column="' + i + '"]' ) ;
2015-05-16 22:13:17 +00:00
$column = $filters . filter ( cols ) ;
if ( $column . length ) {
2015-02-13 03:10:38 +00:00
// move the latest search to the first slot in the array
$column = ts . filter . getLatestSearch ( $column ) ;
2015-05-16 22:13:17 +00:00
if ( $ . isArray ( setFilters ) ) {
// skip first ( latest input ) to maintain cursor position while typing
if ( skipFirst ) {
$column . slice ( 1 ) ;
}
if ( i === c . columns ) {
// prevent data-column='all' from filling data-column='0,1' ( etc )
cols = $column . filter ( wo . filter _anyColumnSelector ) ;
2015-02-13 03:10:38 +00:00
$column = cols . length ? cols : $column ;
}
$column
2015-05-16 22:13:17 +00:00
. val ( setFilters [ i ] )
. trigger ( 'change.tsfilter' ) ;
2015-02-13 03:10:38 +00:00
} else {
filters [ i ] = $column . val ( ) || '' ;
// don't change the first... it will move the cursor
2015-05-16 22:13:17 +00:00
if ( i === c . columns ) {
// don't update range columns from 'all' setting
$column
. slice ( 1 )
. filter ( '[data-column*="' + $column . attr ( 'data-column' ) + '"]' )
. val ( filters [ i ] ) ;
2015-02-13 03:10:38 +00:00
} else {
2015-05-16 22:13:17 +00:00
$column
. slice ( 1 )
. val ( filters [ i ] ) ;
2015-02-13 03:10:38 +00:00
}
}
// save any match input dynamically
2015-05-16 22:13:17 +00:00
if ( i === c . columns && $column . length ) {
2015-02-13 03:10:38 +00:00
wo . filter _$anyMatch = $column ;
}
}
}
}
}
2015-05-16 22:13:17 +00:00
if ( filters . length === 0 ) {
2015-02-13 03:10:38 +00:00
filters = false ;
}
return filters ;
} ;
2015-05-16 22:13:17 +00:00
ts . setFilters = function ( table , filter , apply , skipFirst ) {
var c = table ? $ ( table ) [ 0 ] . config : '' ,
valid = ts . getFilters ( table , true , filter , skipFirst ) ;
if ( c && apply ) {
2015-02-13 03:10:38 +00:00
// ensure new set filters are applied, even if the search is the same
c . lastCombinedFilter = null ;
c . lastSearch = [ ] ;
2015-05-16 22:13:17 +00:00
ts . filter . searching ( c . table , filter , skipFirst ) ;
c . $table . trigger ( 'filterFomatterUpdate' ) ;
2015-02-13 03:10:38 +00:00
}
return ! ! valid ;
} ;
2015-05-16 22:13:17 +00:00
} ) ( jQuery ) ;