2015-02-13 03:10:38 +00:00
/*! Widget: filter */
; ( function ( $ ) {
'use strict' ;
var ts = $ . tablesorter = $ . tablesorter || { } ;
$ . extend ( ts . css , {
filterRow : 'tablesorter-filter-row' ,
filter : 'tablesorter-filter'
} ) ;
ts . addWidget ( {
id : "filter" ,
priority : 50 ,
options : {
filter _childRows : false , // if true, filter includes child row content in the search
filter _columnFilters : true , // if true, a filter will be added to the top of each table column
2015-02-20 22:33:58 +00:00
filter _columnAnyMatch : true , // if true, allows using "#:{query}" in AnyMatch searches (column:query)
2015-02-13 03:10:38 +00:00
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.
filter _excludeFilter : { } , // filters to exclude, per column
filter _external : '' , // jQuery selector string (or jQuery object) of external filters
filter _filteredRow : 'filtered' , // class added to filtered rows; needed by pager plugin
filter _formatter : null , // add custom filter elements to the filter row
filter _functions : null , // add custom filter functions using this option
filter _hideEmpty : true , // hide filter row when table is empty
filter _hideFilters : false , // collapse filter row when mouse leaves the area
filter _ignoreCase : true , // if true, make all searches case-insensitive
filter _liveSearch : true , // if true, search column content while the user types (with a delay)
filter _onlyAvail : 'filter-onlyAvail' , // a header with a select dropdown & this class name will only show available (visible) options within the drop down
filter _placeholder : { search : '' , select : '' } , // default placeholder text (overridden by any header "data-placeholder" setting)
filter _reset : null , // jQuery selector string of an element used to reset the filters
filter _saveFilters : false , // Use the $.tablesorter.storage utility to save the most recent filters
filter _searchDelay : 300 , // typing delay in milliseconds before starting a search
filter _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
} ,
format : function ( table , c , wo ) {
if ( ! c . $table . hasClass ( 'hasFilters' ) ) {
ts . filter . init ( table , c , wo ) ;
}
} ,
remove : function ( table , c , wo , refreshing ) {
var tbodyIndex , $tbody ,
$table = c . $table ,
$tbodies = c . $tbodies ,
events = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) ;
$table
. removeClass ( 'hasFilters' )
// add .tsfilter namespace to all BUT search
2015-02-20 22:13:40 +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
. find ( '.' + ts . css . 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
}
if ( wo . filter _reset ) {
$ ( document ) . undelegate ( wo . filter _reset , 'click.tsfilter' ) ;
}
}
} ) ;
ts . filter = {
// regex used in filter "check" functions - not for general use and not documented
regex : {
regex : /^\/((?:\\\/|[^\/])+)\/([mig]{0,3})?$/ , // regex to test for regex
child : /tablesorter-childRow/ , // child row class name; this gets updated in the script
filtered : /filtered/ , // filtered (hidden) row class name; updated in the script
type : /undefined|number/ , // check type
exact : /(^[\"\'=]+)|([\"\'=]+$)/g , // exact match (allow '==')
nondigit : /[^\w,. \-()]/g , // replace non-digits (from digit & currency parser)
operators : /[<>=]/g , // replace operators
query : '(q|query)' // replace filter queries
} ,
// function( c, data ) { }
// c = table.config
// data.filter = array of filter input values;
// data.iFilter = same array, 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 config.ignoreCase is true)
// data.index = column index; table = table element (DOM)
// data.parsed = array (by column) of boolean values (from filter_useParsedData or "filter-parsed" class)
types : {
// Look for regex
regex : function ( c , data ) {
if ( ts . filter . regex . regex . test ( data . iFilter ) ) {
var matches ,
regex = ts . filter . regex . regex . exec ( data . iFilter ) ;
try {
matches = new RegExp ( regex [ 1 ] , regex [ 2 ] ) . test ( data . iExact ) ;
} catch ( error ) {
matches = false ;
}
return matches ;
}
return null ;
} ,
// Look for operators >, >=, < or <=
operators : function ( c , data ) {
if ( /^[<>]=?/ . test ( data . iFilter ) ) {
var cachedValue , result ,
table = c . table ,
index = data . index ,
parsed = data . parsed [ index ] ,
query = ts . formatFloat ( data . iFilter . replace ( ts . filter . regex . operators , '' ) , table ) ,
parser = c . parsers [ index ] ,
savedSearch = query ;
// parse filter value in case we're comparing numbers (dates)
if ( parsed || parser . type === 'numeric' ) {
result = ts . filter . parseFilter ( c , $ . trim ( '' + data . iFilter . replace ( ts . filter . regex . operators , '' ) ) , index , parsed , true ) ;
query = ( typeof result === "number" && result !== '' && ! isNaN ( result ) ) ? result : query ;
}
// iExact may be numeric - see issue #149;
// check if cached is defined, because sometimes j goes out of range? (numeric columns)
cachedValue = ( parsed || parser . type === 'numeric' ) && ! isNaN ( query ) && typeof data . cache !== 'undefined' ? data . cache :
isNaN ( data . iExact ) ? ts . formatFloat ( data . iExact . replace ( ts . filter . regex . nondigit , '' ) , table ) :
ts . formatFloat ( data . iExact , table ) ;
if ( />/ . test ( data . iFilter ) ) { result = />=/ . test ( data . iFilter ) ? cachedValue >= query : cachedValue > query ; }
if ( /</ . test ( data . iFilter ) ) { result = /<=/ . test ( data . iFilter ) ? cachedValue <= query : cachedValue < query ; }
// keep showing all rows if nothing follows the operator
if ( ! result && savedSearch === '' ) { result = true ; }
return result ;
}
return null ;
} ,
// Look for a not match
notMatch : function ( c , data ) {
if ( /^\!/ . test ( data . iFilter ) ) {
var indx ,
filter = ts . filter . parseFilter ( c , data . iFilter . replace ( '!' , '' ) , data . index , data . parsed [ data . index ] ) ;
if ( ts . filter . regex . exact . test ( filter ) ) {
// look for exact not matches - see #628
filter = filter . replace ( ts . filter . regex . exact , '' ) ;
return filter === '' ? true : $ . trim ( filter ) !== data . iExact ;
} else {
indx = data . iExact . search ( $ . trim ( filter ) ) ;
return filter === '' ? true : ! ( c . widgetOptions . filter _startsWith ? indx === 0 : indx >= 0 ) ;
}
}
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 */
if ( ts . filter . regex . exact . test ( data . iFilter ) ) {
var filter = ts . filter . parseFilter ( c , data . iFilter . replace ( ts . filter . regex . exact , '' ) , data . index , data . parsed [ data . index ] ) ;
return data . anyMatch ? $ . inArray ( filter , data . rowArray ) >= 0 : filter == data . iExact ;
}
return null ;
} ,
// Look for an AND or && operator (logical and)
and : function ( c , data ) {
if ( ts . filter . regex . andTest . test ( data . filter ) ) {
var index = data . index ,
parsed = data . parsed [ index ] ,
query = data . iFilter . split ( ts . filter . regex . andSplit ) ,
result = data . iExact . search ( $ . trim ( ts . filter . parseFilter ( c , query [ 0 ] , index , parsed ) ) ) >= 0 ,
indx = query . length - 1 ;
while ( result && indx ) {
result = result && data . iExact . search ( $ . trim ( ts . filter . parseFilter ( c , query [ indx ] , index , parsed ) ) ) >= 0 ;
indx -- ;
}
return result ;
}
return null ;
} ,
// Look for a range (using " to " or " - ") - see issue #166; thanks matzhu!
range : function ( c , data ) {
if ( ts . filter . regex . toTest . test ( data . iFilter ) ) {
var result , tmp ,
table = c . table ,
index = data . index ,
parsed = data . parsed [ index ] ,
// make sure the dash is for a range and not indicating a negative number
query = data . iFilter . split ( ts . filter . regex . toSplit ) ,
range1 = ts . formatFloat ( ts . filter . parseFilter ( c , query [ 0 ] . replace ( ts . filter . regex . nondigit , '' ) , index , parsed ) , table ) ,
range2 = ts . formatFloat ( ts . filter . parseFilter ( c , query [ 1 ] . replace ( ts . filter . regex . nondigit , '' ) , 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 ;
}
result = ( parsed || c . parsers [ index ] . type === 'numeric' ) && ! isNaN ( range1 ) && ! isNaN ( range2 ) ? data . cache :
isNaN ( data . iExact ) ? ts . formatFloat ( data . iExact . replace ( ts . filter . regex . nondigit , '' ) , table ) :
ts . formatFloat ( data . iExact , table ) ;
if ( range1 > range2 ) { tmp = range1 ; range1 = range2 ; range2 = tmp ; } // swap
return ( result >= range1 && result <= range2 ) || ( range1 === '' || range2 === '' ) ;
}
return null ;
} ,
// Look for wild card: ? = single, * = multiple, or | = logical OR
wild : function ( c , data ) {
if ( /[\?\*\|]/ . test ( data . iFilter ) || ts . filter . regex . orReplace . test ( data . filter ) ) {
var index = data . index ,
parsed = data . parsed [ index ] ,
query = ts . filter . parseFilter ( c , data . iFilter . replace ( ts . filter . regex . orReplace , "|" ) , index , parsed ) ;
// look for an exact match with the "or" unless the "filter-match" class is found
if ( ! c . $headers . filter ( '[data-column="' + index + '"]:last' ) . hasClass ( 'filter-match' ) && /\|/ . test ( query ) ) {
// show all results while using filter match. Fixes #727
if ( query [ query . length - 1 ] === '|' ) { query += '*' ; }
query = data . anyMatch && $ . isArray ( data . rowArray ) ? '(' + query + ')' : '^(' + query + ')$' ;
}
// parsing the filter may not work properly when using wildcards =/
return new RegExp ( query . replace ( /\?/g , '\\S{1}' ) . replace ( /\*/g , '\\S*' ) ) . test ( data . iExact ) ;
}
return null ;
} ,
// fuzzy text search; modified from https://github.com/mattyork/fuzzy (MIT license)
fuzzy : function ( c , data ) {
if ( /^~/ . test ( data . iFilter ) ) {
var indx ,
patternIndx = 0 ,
len = data . iExact . length ,
pattern = ts . filter . parseFilter ( c , data . iFilter . slice ( 1 ) , data . index , data . parsed [ data . index ] ) ;
for ( indx = 0 ; indx < len ; indx ++ ) {
if ( data . iExact [ indx ] === pattern [ patternIndx ] ) {
patternIndx += 1 ;
}
}
if ( patternIndx === pattern . length ) {
return true ;
}
return false ;
}
return null ;
}
} ,
init : function ( table , c , wo ) {
// filter language options
ts . language = $ . extend ( true , { } , {
to : 'to' ,
or : 'or' ,
and : 'and'
} , ts . language ) ;
var options , string , txt , $header , column , filters , val , fxn , noSelect ,
regex = ts . filter . regex ;
c . $table . addClass ( 'hasFilters' ) ;
// 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*=","]' ;
txt = '\\{' + ts . filter . regex . query + '\\}' ;
$ . extend ( regex , {
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 ( txt , 'i' ) ,
igQuery : new RegExp ( txt , 'ig' )
} ) ;
// don't build filter row if columnFilters is false or all columns are set to "filter-false" - issue #156
if ( wo . filter _columnFilters !== false && c . $headers . filter ( '.filter-false, .parser-false' ) . length !== c . $headers . length ) {
// build filter row
ts . filter . buildRow ( table , c , wo ) ;
}
txt = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) ;
2015-02-20 22:13:40 +00:00
c . $table . bind ( txt , function ( event , filter ) {
2015-02-13 03:10:38 +00:00
val = ( wo . filter _hideEmpty && $ . isEmptyObject ( c . cache ) && ! ( c . delayInit && event . type === 'appendCache' ) ) ;
// hide filter row using the "filtered" class name
c . $table . find ( '.' + ts . css . filterRow ) . toggleClass ( wo . filter _filteredRow , val ) ; // fixes #450
if ( ! /(search|filter)/ . test ( event . type ) ) {
event . stopPropagation ( ) ;
ts . filter . buildDefault ( table , true ) ;
}
if ( event . type === 'filterReset' ) {
c . $table . find ( '.' + ts . css . filter ) . add ( wo . filter _$externalFilters ) . val ( '' ) ;
ts . filter . searching ( table , [ ] ) ;
} else if ( event . type === 'filterEnd' ) {
ts . filter . buildDefault ( table , true ) ;
} else {
// send false argument to force a new search; otherwise if the filter hasn't changed, it will return
filter = event . type === 'search' ? filter : event . type === 'updateComplete' ? c . $table . data ( 'lastSearch' ) : '' ;
if ( /(update|add)/ . test ( event . type ) && event . type !== "updateComplete" ) {
// force a new search since content has changed
c . lastCombinedFilter = null ;
c . lastSearch = [ ] ;
}
// pass true (skipFirst) to prevent the tablesorter.setFilters function from skipping the first input
// ensures all inputs are updated when a search is triggered on the table $('table').trigger('search', [...]);
ts . filter . searching ( table , filter , true ) ;
}
return false ;
} ) ;
// reset button/link
if ( wo . filter _reset ) {
if ( wo . filter _reset instanceof $ ) {
// reset contains a jQuery object, bind to it
wo . filter _reset . click ( function ( ) {
c . $table . trigger ( 'filterReset' ) ;
} ) ;
} else if ( $ ( wo . filter _reset ) . length ) {
// reset is a jQuery selector, use event delegation
$ ( document )
. undelegate ( wo . filter _reset , 'click.tsfilter' )
. delegate ( wo . filter _reset , 'click.tsfilter' , function ( ) {
// trigger a reset event, so other functions (filter_formatter) know when to reset
c . $table . trigger ( 'filterReset' ) ;
} ) ;
}
}
if ( wo . filter _functions ) {
for ( column = 0 ; column < c . columns ; column ++ ) {
fxn = ts . getColumnData ( table , wo . filter _functions , column ) ;
if ( fxn ) {
// remove "filter-select" from header otherwise the options added here are replaced with all options
$header = c . $headers . filter ( '[data-column="' + column + '"]:last' ) . removeClass ( 'filter-select' ) ;
// don't build select if "filter-false" or "parser-false" set
noSelect = ! ( $header . hasClass ( 'filter-false' ) || $header . hasClass ( 'parser-false' ) ) ;
options = '' ;
if ( fxn === true && noSelect ) {
ts . filter . buildSelect ( table , column ) ;
} else if ( typeof fxn === 'object' && noSelect ) {
// add custom drop down list
for ( string in fxn ) {
if ( typeof string === 'string' ) {
options += options === '' ?
'<option value="">' + ( $header . data ( 'placeholder' ) || $header . attr ( 'data-placeholder' ) || wo . filter _placeholder . select || '' ) + '</option>' : '' ;
val = string ;
txt = string ;
if ( string . indexOf ( wo . filter _selectSourceSeparator ) >= 0 ) {
val = string . split ( wo . filter _selectSourceSeparator ) ;
txt = val [ 1 ] ;
val = val [ 0 ] ;
}
options += '<option ' + ( txt === val ? '' : 'data-function-name="' + string + '" ' ) + 'value="' + val + '">' + txt + '</option>' ;
}
}
c . $table . find ( 'thead' ) . find ( 'select.' + ts . css . filter + '[data-column="' + column + '"]' ) . append ( options ) ;
}
}
}
}
// not really updating, but if the column has both the "filter-select" class & filter_functions set to true,
// it would append the same options twice.
ts . filter . buildDefault ( table , true ) ;
ts . filter . bindSearch ( table , c . $table . find ( '.' + ts . css . filter ) , true ) ;
if ( wo . filter _external ) {
ts . filter . bindSearch ( table , wo . filter _external ) ;
}
if ( wo . filter _hideFilters ) {
ts . filter . hideFilters ( table , c ) ;
}
// show processing icon
if ( c . showProcessing ) {
c . $table
2015-02-20 22:13:40 +00:00
. unbind ( ( 'filterStart filterEnd ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) ) . replace ( /\s+/g , ' ' ) )
. bind ( 'filterStart filterEnd ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) , function ( event , columns ) {
2015-02-13 03:10:38 +00:00
// only add processing to certain columns to all columns
$header = ( columns ) ? c . $table . find ( '.' + ts . css . header ) . filter ( '[data-column]' ) . filter ( function ( ) {
return columns [ $ ( this ) . data ( 'column' ) ] !== '' ;
} ) : '' ;
ts . isProcessing ( table , event . type === 'filterStart' , columns ? $header : '' ) ;
} ) ;
}
// set filtered rows count (intially unfiltered)
c . filteredRows = c . totalRows ;
// add default values
c . $table
2015-02-20 22:13:40 +00:00
. unbind ( ( 'tablesorter-initialized pagerBeforeInitialized ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) ) . replace ( /\s+/g , ' ' ) )
. bind ( 'tablesorter-initialized pagerBeforeInitialized ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) , function ( ) {
2015-02-13 03:10:38 +00:00
// redefine "wo" as it does not update properly inside this callback
var wo = this . config . widgetOptions ;
filters = ts . filter . setDefaults ( table , c , wo ) || [ ] ;
if ( filters . length ) {
// prevent delayInit from triggering a cache build if filters are empty
if ( ! ( c . delayInit && filters . join ( '' ) === '' ) ) {
ts . setFilters ( table , filters , true ) ;
}
}
c . $table . trigger ( 'filterFomatterUpdate' ) ;
// trigger init after setTimeout to prevent multiple filterStart/End/Init triggers
setTimeout ( function ( ) {
if ( ! wo . filter _initialized ) {
ts . filter . filterInitComplete ( c ) ;
}
} , 100 ) ;
} ) ;
// if filter widget is added after pager has initialized; then set filter init flag
if ( c . pager && c . pager . initialized && ! wo . filter _initialized ) {
c . $table . trigger ( 'filterFomatterUpdate' ) ;
setTimeout ( function ( ) {
ts . filter . filterInitComplete ( c ) ;
} , 100 ) ;
}
} ,
// $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 ) {
// add updates by column since this function
// may be called numerous times before initialization
wo . filter _formatterInit [ column ] = 1 ;
}
} ,
filterInitComplete : function ( c ) {
var wo = c . widgetOptions ,
count = 0 ,
completed = function ( ) {
wo . filter _initialized = true ;
c . $table . trigger ( 'filterInit' , c ) ;
ts . filter . findRows ( c . table , c . $table . data ( 'lastSearch' ) || [ ] ) ;
} ;
if ( $ . isEmptyObject ( wo . filter _formatter ) ) {
completed ( ) ;
} else {
$ . each ( wo . filter _formatterInit , function ( i , val ) {
if ( val === 1 ) {
count ++ ;
}
} ) ;
clearTimeout ( wo . filter _initTimer ) ;
if ( ! wo . filter _initialized && count === wo . filter _formatterCount ) {
// filter widget initialized
completed ( ) ;
} else if ( ! wo . filter _initialized ) {
// fall back in case a filter_formatter doesn't call
// $.tablesorter.filter.formatterUpdated($cell, column), and the count is off
wo . filter _initTimer = setTimeout ( function ( ) {
completed ( ) ;
} , 500 ) ;
}
}
} ,
setDefaults : function ( table , c , wo ) {
var isArray , saved , indx ,
// get current (default) filters
filters = ts . getFilters ( table ) || [ ] ;
if ( wo . filter _saveFilters && ts . storage ) {
saved = ts . storage ( table , 'tablesorter-filters' ) || [ ] ;
isArray = $ . isArray ( saved ) ;
// make sure we're not just getting an empty array
if ( ! ( isArray && saved . join ( '' ) === '' || ! isArray ) ) { filters = saved ; }
}
// if no filters saved, then check default settings
if ( filters . join ( '' ) === '' ) {
for ( indx = 0 ; indx < c . columns ; indx ++ ) {
filters [ indx ] = c . $headers . filter ( '[data-column="' + indx + '"]:last' ) . attr ( wo . filter _defaultAttrib ) || filters [ indx ] ;
}
}
c . $table . data ( 'lastSearch' , filters ) ;
return filters ;
} ,
parseFilter : function ( c , filter , column , parsed , forceParse ) {
return forceParse || parsed ?
c . parsers [ column ] . format ( filter , c . table , [ ] , column ) :
filter ;
} ,
buildRow : function ( table , c , wo ) {
var col , column , $header , buildSelect , disabled , name , ffxn ,
// c.columns defined in computeThIndexes()
columns = c . columns ,
arry = $ . isArray ( wo . filter _cellFilter ) ,
buildFilter = '<tr role="row" class="' + ts . css . filterRow + '">' ;
for ( column = 0 ; column < columns ; column ++ ) {
if ( arry ) {
buildFilter += '<td' + ( wo . filter _cellFilter [ column ] ? ' class="' + wo . filter _cellFilter [ column ] + '"' : '' ) + '></td>' ;
} else {
buildFilter += '<td' + ( wo . filter _cellFilter !== '' ? ' class="' + wo . filter _cellFilter + '"' : '' ) + '></td>' ;
}
}
c . $filters = $ ( buildFilter += '</tr>' ) . appendTo ( c . $table . children ( 'thead' ) . eq ( 0 ) ) . find ( 'td' ) ;
// build each filter input
for ( column = 0 ; column < columns ; column ++ ) {
disabled = false ;
// assuming last cell of a column is the main column
$header = c . $headers . filter ( '[data-column="' + column + '"]:last' ) ;
ffxn = ts . getColumnData ( table , wo . filter _functions , column ) ;
buildSelect = ( wo . filter _functions && ffxn && typeof ffxn !== "function" ) ||
$header . hasClass ( 'filter-select' ) ;
// get data from jQuery data, metadata, headers option or header class name
col = ts . getColumnData ( table , c . headers , column ) ;
disabled = ts . getData ( $header [ 0 ] , col , 'filter' ) === 'false' || ts . getData ( $header [ 0 ] , col , 'parser' ) === 'false' ;
if ( buildSelect ) {
buildFilter = $ ( '<select>' ) . appendTo ( c . $filters . eq ( column ) ) ;
} else {
ffxn = ts . getColumnData ( table , wo . filter _formatter , column ) ;
if ( ffxn ) {
wo . filter _formatterCount ++ ;
buildFilter = ffxn ( c . $filters . eq ( column ) , column ) ;
// no element returned, so lets go find it
if ( buildFilter && buildFilter . length === 0 ) {
buildFilter = c . $filters . eq ( column ) . children ( 'input' ) ;
}
// element not in DOM, so lets attach it
if ( buildFilter && ( buildFilter . parent ( ) . length === 0 ||
( buildFilter . parent ( ) . length && buildFilter . parent ( ) [ 0 ] !== c . $filters [ column ] ) ) ) {
c . $filters . eq ( column ) . append ( buildFilter ) ;
}
} else {
buildFilter = $ ( '<input type="search">' ) . appendTo ( c . $filters . eq ( column ) ) ;
}
if ( buildFilter ) {
buildFilter . attr ( 'placeholder' , $header . data ( 'placeholder' ) || $header . attr ( 'data-placeholder' ) || wo . filter _placeholder . search || '' ) ;
}
}
if ( buildFilter ) {
// add filter class name
name = ( $ . isArray ( wo . filter _cssFilter ) ?
( typeof wo . filter _cssFilter [ column ] !== 'undefined' ? wo . filter _cssFilter [ column ] || '' : '' ) :
wo . filter _cssFilter ) || '' ;
buildFilter . addClass ( ts . css . filter + ' ' + name ) . attr ( 'data-column' , column ) ;
if ( disabled ) {
buildFilter . attr ( 'placeholder' , '' ) . addClass ( 'disabled' ) [ 0 ] . disabled = true ; // disabled!
}
}
}
} ,
bindSearch : function ( table , $el , internal ) {
table = $ ( table ) [ 0 ] ;
$el = $ ( $el ) ; // allow passing a selector string
if ( ! $el . length ) { return ; }
var c = table . config ,
wo = c . widgetOptions ,
$ext = wo . filter _$externalFilters ;
if ( internal !== true ) {
// save anyMatch element
wo . filter _$anyMatch = $el . filter ( wo . filter _anyColumnSelector + ',' + wo . filter _multipleColumnSelector ) ;
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 ) ;
}
$el
// use data attribute instead of jQuery data since the head is cloned without including the data/binding
. attr ( 'data-lastSearchTime' , new Date ( ) . getTime ( ) )
2015-02-20 22:13:40 +00:00
. unbind ( ( 'keypress keyup search change ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) ) . replace ( /\s+/g , ' ' ) )
2015-02-13 03:10:38 +00:00
// include change for select - fixes #473
. bind ( 'keyup' + c . namespace + 'filter' , function ( event ) {
$ ( this ) . attr ( 'data-lastSearchTime' , new Date ( ) . getTime ( ) ) ;
// emulate what webkit does.... escape clears the filter
if ( event . which === 27 ) {
this . value = '' ;
// live search
} else if ( wo . filter _liveSearch === false ) {
return ;
// 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 wo . filter _liveSearch === 'number' && this . value . length < wo . filter _liveSearch ) ||
// let return & backspace continue on, but ignore arrows & non-valid characters
( event . which !== 13 && event . which !== 8 && ( event . which < 32 || ( event . which >= 37 && event . which <= 40 ) ) ) ) ) {
return ;
}
// change event = no delay; last true flag tells getFilters to skip newest timed input
ts . filter . searching ( table , true , true ) ;
} )
2015-02-20 22:13:40 +00:00
. bind ( 'search change keypress ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) , function ( event ) {
2015-02-13 03:10:38 +00:00
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 ] ) {
event . preventDefault ( ) ;
// init search with no delay
$ ( this ) . attr ( 'data-lastSearchTime' , new Date ( ) . getTime ( ) ) ;
ts . filter . searching ( table , false , true ) ;
}
} ) ;
} ,
searching : function ( table , filter , skipFirst ) {
var wo = table . config . widgetOptions ;
clearTimeout ( wo . searchTimer ) ;
if ( typeof filter === 'undefined' || filter === true ) {
// delay filtering
wo . searchTimer = setTimeout ( function ( ) {
ts . filter . checkFilters ( table , filter , skipFirst ) ;
} , wo . filter _liveSearch ? wo . filter _searchDelay : 10 ) ;
} else {
// skip delay
ts . filter . checkFilters ( table , filter , skipFirst ) ;
}
} ,
checkFilters : function ( table , filter , skipFirst ) {
var c = table . config ,
wo = c . widgetOptions ,
filterArray = $ . isArray ( filter ) ,
filters = ( filterArray ) ? filter : ts . getFilters ( table , true ) ,
combinedFilters = ( filters || [ ] ) . join ( '' ) ; // combined 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 . initialized ) {
c . $table . trigger ( 'updateCache' , [ function ( ) {
ts . filter . 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 . lastCombinedFilter = '' ; }
}
if ( wo . filter _hideFilters ) {
// show/hide filter row as needed
c . $table . find ( '.' + ts . css . filterRow ) . trigger ( combinedFilters === '' ? '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 ( c . lastCombinedFilter === combinedFilters && filter !== false ) {
return ;
} else if ( filter === false ) {
// force filter refresh
c . lastCombinedFilter = null ;
c . lastSearch = [ ] ;
}
if ( wo . filter _initialized ) { c . $table . trigger ( 'filterStart' , [ filters ] ) ; }
if ( c . showProcessing ) {
// give it time for the processing icon to kick in
setTimeout ( function ( ) {
ts . filter . findRows ( table , filters , combinedFilters ) ;
return false ;
} , 30 ) ;
} else {
ts . filter . findRows ( table , filters , combinedFilters ) ;
return false ;
}
} ,
hideFilters : function ( table , c ) {
var $filterRow , $filterRow2 , timer ;
$ ( table )
. find ( '.' + ts . css . filterRow )
. addClass ( 'hideme' )
. bind ( 'mouseenter mouseleave' , function ( e ) {
// save event object - http://bugs.jquery.com/ticket/12140
var event = e ;
$filterRow = $ ( this ) ;
clearTimeout ( timer ) ;
timer = setTimeout ( function ( ) {
if ( /enter|over/ . test ( event . type ) ) {
$filterRow . removeClass ( 'hideme' ) ;
} else {
// don't hide if input has focus
// $(':focus') needs jQuery 1.6+
if ( $ ( document . activeElement ) . closest ( 'tr' ) [ 0 ] !== $filterRow [ 0 ] ) {
// don't hide row if any filter has a value
if ( c . lastCombinedFilter === '' ) {
$filterRow . addClass ( 'hideme' ) ;
}
}
}
} , 200 ) ;
} )
. find ( 'input, select' ) . bind ( 'focus blur' , function ( e ) {
$filterRow2 = $ ( this ) . closest ( 'tr' ) ;
clearTimeout ( timer ) ;
var event = e ;
timer = setTimeout ( function ( ) {
// don't hide row if any filter has a value
if ( ts . getFilters ( c . $table ) . join ( '' ) === '' ) {
$filterRow2 [ event . type === 'focus' ? 'removeClass' : 'addClass' ] ( 'hideme' ) ;
}
} , 200 ) ;
} ) ;
} ,
defaultFilter : function ( filter , mask ) {
if ( filter === '' ) { return filter ; }
var regex = ts . filter . regex . iQuery ,
maskLen = mask . match ( ts . filter . regex . 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 ) {
2015-02-20 20:16:42 +00:00
if ( $input ) {
return $input . sort ( function ( a , b ) {
return $ ( b ) . attr ( 'data-lastSearchTime' ) - $ ( a ) . attr ( 'data-lastSearchTime' ) ;
} ) ;
}
return $ ( ) ;
2015-02-13 03:10:38 +00:00
} ,
multipleColumns : function ( c , $input ) {
// look for multiple columns "1-3,4-6,8" in data-column
var ranges , singles , indx ,
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 ,
columns = [ ] ,
2015-02-20 20:16:42 +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 ) ;
$ . each ( ranges , function ( i , v ) {
var t ,
range = v . split ( /\s*-\s*/ ) ,
start = parseInt ( range [ 0 ] , 10 ) || 0 ,
end = parseInt ( range [ 1 ] , 10 ) || ( c . columns - 1 ) ;
if ( start > end ) { t = start ; start = end ; end = t ; } // swap
if ( end >= c . columns ) { end = c . columns - 1 ; }
for ( ; start <= end ; start ++ ) {
columns . push ( start ) ;
}
// remove processed range from val
val = val . replace ( v , '' ) ;
} ) ;
}
// process single columns
if ( targets && /,/ . test ( val ) ) {
singles = val . split ( /\s*,\s*/ ) ;
$ . each ( singles , function ( i , v ) {
if ( v !== '' ) {
indx = parseInt ( v , 10 ) ;
if ( indx < c . columns ) {
columns . push ( indx ) ;
}
}
} ) ;
}
// return all columns
if ( ! columns . length ) {
for ( indx = 0 ; indx < c . columns ; indx ++ ) {
columns . push ( indx ) ;
}
}
return columns ;
} ,
findRows : function ( table , filters , combinedFilters ) {
if ( table . config . lastCombinedFilter === combinedFilters || ! table . config . widgetOptions . filter _initialized ) { return ; }
2015-02-20 20:32:36 +00:00
var len , norm _rows , $rows , rowIndex , tbodyIndex , $tbody , $cells , $cell , columnIndex ,
2015-02-13 03:10:38 +00:00
childRow , lastSearch , hasSelect , matches , result , showRow , time , val , indx ,
notFiltered , searchFiltered , filterMatched , excludeMatch , fxn , ffxn ,
2015-02-20 22:33:58 +00:00
query , injected , res , id ,
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
data = { anyMatch : false } ,
// anyMatch really screws up with these types of filters
noAnyMatch = [ 'range' , 'notMatch' , 'operators' ] ;
// parse columns after formatter, in case the class is added at that point
data . parsed = c . $headers . map ( function ( columnIndex ) {
return c . parsers && c . parsers [ columnIndex ] && c . parsers [ columnIndex ] . parsed ||
// getData won't return "parsed" if other "filter-" class names exist (e.g. <th class="filter-select filter-parsed">)
ts . getData && ts . getData ( c . $headers . filter ( '[data-column="' + columnIndex + '"]:last' ) , ts . getColumnData ( table , c . headers , columnIndex ) , 'filter' ) === 'parsed' ||
$ ( this ) . hasClass ( 'filter-parsed' ) ;
} ) . get ( ) ;
if ( c . debug ) {
ts . log ( 'Starting filter widget search' , filters ) ;
time = new Date ( ) ;
}
// filtered rows count
c . filteredRows = 0 ;
c . totalRows = 0 ;
// combindedFilters are undefined on init
combinedFilters = ( filters || [ ] ) . join ( '' ) ;
2015-02-20 20:32:36 +00:00
for ( tbodyIndex = 0 ; tbodyIndex < c . $tbodies . length ; tbodyIndex ++ ) {
$tbody = ts . processTbody ( table , c . $tbodies . eq ( tbodyIndex ) , true ) ;
2015-02-13 03:10:38 +00:00
// 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
2015-02-20 20:32:36 +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
if ( combinedFilters === '' || wo . filter _serversideFiltering ) {
$rows . removeClass ( wo . filter _filteredRow ) . not ( '.' + c . cssChildRow ) . show ( ) ;
} else {
// filter out child rows
$rows = $rows . not ( '.' + c . cssChildRow ) ;
len = $rows . length ;
2015-02-20 22:33:58 +00:00
if ( ( wo . filter _$anyMatch && wo . filter _$anyMatch . length ) || ( '' + filters [ c . columns ] ) ) {
data . anyMatchFlag = true ;
data . anyMatchFilter = wo . filter _$anyMatch && ts . filter . getLatestSearch ( wo . filter _$anyMatch ) . val ( ) || ( '' + filters [ c . columns ] ) || '' ;
if ( wo . filter _columnAnyMatch ) {
// specific columns search
query = data . anyMatchFilter . split ( ts . filter . regex . 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 )
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 ( ' && ' ) ;
}
}
}
2015-02-13 03:10:38 +00:00
// 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
! 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 . $headers . filter ( '[data-column="' + indx + '"]:last' ) . hasClass ( 'filter-match' ) ) ;
}
}
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 ) {
ts . log ( "Searching through " + ( searchFiltered && notFiltered < len ? notFiltered : "all" ) + " rows" ) ;
}
2015-02-20 22:33:58 +00:00
if ( data . anyMatchFlag ) {
2015-02-13 03:10:38 +00:00
if ( c . sortLocaleCompare ) {
// replace accents
data . anyMatchFilter = ts . replaceAccents ( data . anyMatchFilter ) ;
}
if ( wo . filter _defaultFilter && regex . iQuery . test ( ts . getColumnData ( table , wo . filter _defaultFilter , c . columns , true ) || '' ) ) {
data . anyMatchFilter = ts . filter . defaultFilter ( data . anyMatchFilter , ts . getColumnData ( table , wo . filter _defaultFilter , c . columns , true ) ) ;
// 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 . toLocaleLowerCase ( ) ;
}
// loop through the rows
for ( rowIndex = 0 ; rowIndex < len ; rowIndex ++ ) {
2015-02-20 20:32:36 +00:00
data . cacheArray = norm _rows [ rowIndex ] ;
2015-02-13 03:10:38 +00:00
childRow = $rows [ rowIndex ] . className ;
// skip child rows & already filtered rows
if ( regex . child . test ( childRow ) || ( searchFiltered && regex . filtered . test ( childRow ) ) ) { continue ; }
showRow = true ;
// *** nextAll/nextUntil not supported by Zepto! ***
childRow = $rows . eq ( rowIndex ) . nextUntil ( 'tr:not(.' + c . cssChildRow + ')' ) ;
// 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
data . childRowText = ( childRow . length && wo . filter _childRows ) ? childRow . text ( ) : '' ;
data . childRowText = wo . filter _ignoreCase ? data . childRowText . toLocaleLowerCase ( ) : data . childRowText ;
$cells = $rows . eq ( rowIndex ) . children ( ) ;
if ( data . anyMatchFlag ) {
// look for multiple columns "1-3,4-6,8"
columnIndex = ts . filter . multipleColumns ( c , wo . filter _$anyMatch ) ;
data . anyMatch = true ;
data . rowArray = $cells . map ( function ( i ) {
if ( $ . inArray ( i , columnIndex ) > - 1 ) {
var txt ;
if ( data . parsed [ i ] ) {
txt = data . cacheArray [ i ] ;
} else {
txt = this ? this . getAttribute ( c . textAttribute ) || this . textContent || $ ( this ) . text ( ) : '' ;
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 ( ' ' ) ;
filterMatched = null ;
$ . each ( ts . filter . types , function ( type , typeFunction ) {
if ( $ . inArray ( type , noAnyMatch ) < 0 ) {
matches = typeFunction ( c , data ) ;
if ( matches !== null ) {
filterMatched = matches ;
return false ;
}
}
} ) ;
if ( filterMatched !== null ) {
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 ;
}
for ( columnIndex = 0 ; columnIndex < c . columns ; columnIndex ++ ) {
data . filter = filters [ columnIndex ] ;
data . index = columnIndex ;
// filter types to exclude, per column
excludeMatch = ( ts . getColumnData ( table , wo . filter _excludeFilter , columnIndex , true ) || '' ) . split ( /\s+/ ) ;
// 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 {
val = $cells [ columnIndex ] ;
result = val ? $ . trim ( val . getAttribute ( c . textAttribute ) || val . textContent || $cells . eq ( columnIndex ) . text ( ) ) : '' ;
data . exact = c . sortLocaleCompare ? ts . replaceAccents ( result ) : result ; // issue #405
}
data . iExact = ! regex . type . test ( typeof data . exact ) && wo . filter _ignoreCase ? data . exact . toLocaleLowerCase ( ) : data . exact ;
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 ( 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 ( ts . getColumnData ( table , wo . filter _defaultFilter , columnIndex ) || '' ) ) {
data . filter = ts . filter . defaultFilter ( data . filter , ts . getColumnData ( table , wo . filter _defaultFilter , columnIndex ) ) ;
// val is used to indicate that a filter select is using a default filter; so we override the exact & partial matches
val = false ;
}
// data.iFilter = case insensitive (if wo.filter_ignoreCase is true), data.filter = case sensitive
data . iFilter = wo . filter _ignoreCase ? ( data . filter || '' ) . toLocaleLowerCase ( ) : data . filter ;
fxn = ts . getColumnData ( table , wo . filter _functions , columnIndex ) ;
$cell = c . $headers . filter ( '[data-column="' + columnIndex + '"]:last' ) ;
hasSelect = $cell . hasClass ( 'filter-select' ) ;
if ( fxn || ( hasSelect && val ) ) {
if ( fxn === true || hasSelect ) {
// default selector uses exact match unless "filter-match" class is found
result = ( $cell . hasClass ( 'filter-match' ) ) ? data . iExact . search ( data . iFilter ) >= 0 : data . filter === data . exact ;
} else if ( typeof fxn === 'function' ) {
// filter callback( exact cell content, parser normalized content, filter input value, column index, jQuery row object )
result = fxn ( data . exact , data . cache , data . filter , columnIndex , $rows . eq ( rowIndex ) ) ;
} else if ( typeof fxn [ ffxn || data . filter ] === 'function' ) {
// selector option function
result = fxn [ ffxn || data . filter ] ( data . exact , data . cache , data . filter , columnIndex , $rows . eq ( rowIndex ) ) ;
}
} else {
filterMatched = null ;
// cycle through the different filters
// filters return a boolean or null if nothing matches
$ . each ( ts . filter . types , function ( type , typeFunction ) {
if ( $ . inArray ( type , excludeMatch ) < 0 ) {
matches = typeFunction ( c , data ) ;
if ( matches !== null ) {
filterMatched = matches ;
return false ;
}
}
} ) ;
if ( filterMatched !== null ) {
result = filterMatched ;
// Look for match, and add child row data for matching
} else {
data . exact = ( data . iExact + data . childRowText ) . indexOf ( ts . filter . parseFilter ( c , data . iFilter , columnIndex , data . parsed [ columnIndex ] ) ) ;
result = ( ( ! wo . filter _startsWith && data . exact >= 0 ) || ( wo . filter _startsWith && data . exact === 0 ) ) ;
}
}
showRow = ( result ) ? showRow : false ;
}
}
$rows . eq ( rowIndex )
. toggle ( showRow )
. toggleClass ( wo . filter _filteredRow , ! showRow ) ;
if ( childRow . length ) {
childRow . toggleClass ( wo . filter _filteredRow , ! showRow ) ;
}
}
}
c . filteredRows += $rows . not ( '.' + wo . filter _filteredRow ) . length ;
c . totalRows += $rows . length ;
ts . processTbody ( table , $tbody , false ) ;
}
c . lastCombinedFilter = combinedFilters ; // save last search
c . lastSearch = filters ;
c . $table . data ( 'lastSearch' , filters ) ;
if ( wo . filter _saveFilters && ts . storage ) {
ts . storage ( table , 'tablesorter-filters' , filters ) ;
}
if ( c . debug ) {
ts . benchmark ( "Completed filter widget search" , time ) ;
}
if ( wo . filter _initialized ) { c . $table . trigger ( 'filterEnd' , c ) ; }
setTimeout ( function ( ) {
c . $table . trigger ( 'applyWidgets' ) ; // make sure zebra widget is applied
} , 0 ) ;
} ,
getOptionSource : function ( table , column , onlyAvail ) {
table = $ ( table ) [ 0 ] ;
var cts ,
c = table . config ,
wo = c . widgetOptions ,
parsed = [ ] ,
arry = false ,
source = wo . filter _selectSource ,
last = c . $table . data ( 'lastSearch' ) || [ ] ,
fxn = $ . isFunction ( source ) ? 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 ( '</option>' ) >= 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 ) ;
}
if ( arry === false ) {
// fall back to original method
arry = ts . filter . getOptions ( table , column , onlyAvail ) ;
}
// 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 ) {
return $ . inArray ( value , arry ) === indx ;
} ) ;
if ( c . $headers . filter ( '[data-column="' + column + '"]:last' ) . hasClass ( 'filter-select-nosort' ) ) {
// unsorted select options
return arry ;
} else {
// parse select option values
$ . each ( arry , function ( i , v ) {
// parse array data using set column parser; this DOES NOT pass the original
// table cell to the parser format function
parsed . push ( { t : v , p : c . parsers && c . parsers [ column ] . format ( v , table , [ ] , column ) } ) ;
} ) ;
// sort parsed select options
cts = c . textSorter || '' ;
parsed . sort ( function ( a , b ) {
// sortNatural breaks if you don't pass it strings
var x = a . p . toString ( ) , y = b . p . toString ( ) ;
if ( $ . isFunction ( cts ) ) {
// custom OVERALL text sorter
return cts ( x , y , true , column , table ) ;
} else if ( 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 = [ ] ;
$ . each ( parsed , function ( i , v ) {
arry . push ( v . t ) ;
} ) ;
return arry ;
}
} ,
getOptions : function ( table , column , onlyAvail ) {
table = $ ( table ) [ 0 ] ;
var rowIndex , tbodyIndex , len , row , cache , cell ,
c = table . config ,
wo = c . widgetOptions ,
arry = [ ] ;
2015-02-20 20:32:36 +00:00
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 . $headers . filter ( '[data-column="' + column + '"]:last' ) . hasClass ( 'filter-parsed' ) ) {
arry . push ( '' + cache . normalized [ rowIndex ] [ column ] ) ;
} else {
cell = row . cells [ column ] ;
if ( cell ) {
arry . push ( $ . trim ( cell . getAttribute ( c . textAttribute ) || cell . textContent || $ ( cell ) . text ( ) ) ) ;
2015-02-13 03:10:38 +00:00
}
}
}
}
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 ,
c = table . config ,
wo = c . widgetOptions ,
node = c . $headers . filter ( '[data-column="' + column + '"]:last' ) ,
// 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>' ,
// Get curent filter value
currentValue = c . $table . find ( 'thead' ) . find ( 'select.' + ts . css . 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 ) ;
}
if ( $ . isArray ( arry ) ) {
// build option list
for ( indx = 0 ; indx < arry . length ; indx ++ ) {
txt = arry [ indx ] = ( '' + arry [ indx ] ) . replace ( /\"/g , """ ) ;
val = txt ;
// allow including a symbol in the selectSource array
// "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 ) ;
val = t [ 0 ] ;
txt = t [ 1 ] ;
}
// 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>' : '' ;
}
// clear arry so it doesn't get appended twice
arry = [ ] ;
}
// update all selects in the same column (clone thead in sticky headers & any external selects) - fixes 473
$filters = ( c . $filters ? c . $filters : c . $table . children ( 'thead' ) ) . find ( '.' + ts . css . filter ) ;
if ( wo . filter _$externalFilters ) {
$filters = $filters && $filters . length ? $filters . add ( wo . filter _$externalFilters ) : wo . filter _$externalFilters ;
}
$filter = $filters . filter ( 'select[data-column="' + column + '"]' ) ;
// make sure there is a select there!
if ( $filter . length ) {
$filter [ updating ? 'html' : 'append' ] ( options ) ;
if ( ! $ . isArray ( arry ) ) {
// append options if arry is provided externally as a string or jQuery object
// options (default value) was already added
$filter . append ( arry ) . val ( currentValue ) ;
}
$filter . val ( currentValue ) ;
}
} ,
buildDefault : function ( table , updating ) {
var columnIndex , $header , noSelect ,
c = table . config ,
wo = c . widgetOptions ,
columns = c . columns ;
// build default select dropdown
for ( columnIndex = 0 ; columnIndex < columns ; columnIndex ++ ) {
$header = c . $headers . filter ( '[data-column="' + columnIndex + '"]:last' ) ;
noSelect = ! ( $header . hasClass ( 'filter-false' ) || $header . hasClass ( 'parser-false' ) ) ;
// look for the filter-select class; build/update it if found
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 ) ) ;
}
}
}
} ;
ts . getFilters = function ( table , getRaw , setFilters , skipFirst ) {
var i , $filters , $column , cols ,
filters = false ,
c = table ? $ ( table ) [ 0 ] . config : '' ,
wo = c ? c . widgetOptions : '' ;
if ( getRaw !== true && wo && ! wo . filter _columnFilters ) {
return $ ( table ) . data ( 'lastSearch' ) ;
}
if ( c ) {
if ( c . $filters ) {
$filters = c . $filters . find ( '.' + ts . css . filter ) ;
}
if ( wo . filter _$externalFilters ) {
$filters = $filters && $filters . length ? $filters . add ( wo . filter _$externalFilters ) : wo . filter _$externalFilters ;
}
if ( $filters && $filters . length ) {
filters = setFilters || [ ] ;
for ( i = 0 ; i < c . columns + 1 ; i ++ ) {
cols = ( i === c . columns ?
// "all" columns can now include a range or set of columms (data-column="0-2,4,6-7")
wo . filter _anyColumnSelector + ',' + wo . filter _multipleColumnSelector :
'[data-column="' + i + '"]' ) ;
$column = $filters . filter ( cols ) ;
if ( $column . length ) {
// move the latest search to the first slot in the array
$column = ts . filter . getLatestSearch ( $column ) ;
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 ) ;
$column = cols . length ? cols : $column ;
}
$column
. val ( setFilters [ i ] )
. trigger ( 'change.tsfilter' ) ;
} else {
filters [ i ] = $column . val ( ) || '' ;
// don't change the first... it will move the cursor
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 ] ) ;
} else {
$column . slice ( 1 ) . val ( filters [ i ] ) ;
}
}
// save any match input dynamically
if ( i === c . columns && $column . length ) {
wo . filter _$anyMatch = $column ;
}
}
}
}
}
if ( filters . length === 0 ) {
filters = false ;
}
return filters ;
} ;
ts . setFilters = function ( table , filter , apply , skipFirst ) {
var c = table ? $ ( table ) [ 0 ] . config : '' ,
valid = ts . getFilters ( table , true , filter , skipFirst ) ;
if ( c && apply ) {
// ensure new set filters are applied, even if the search is the same
c . lastCombinedFilter = null ;
c . lastSearch = [ ] ;
ts . filter . searching ( c . table , filter , skipFirst ) ;
c . $table . trigger ( 'filterFomatterUpdate' ) ;
}
return ! ! valid ;
} ;
} ) ( jQuery ) ;