www/datatables/jquery.dataTables.yadcf.js

   1 /*!
   2 * Yet Another DataTables Column Filter - (yadcf)
   3 *
   4 * File:        jquery.dataTables.yadcf.js
   5 * Version:     0.9.3
   6 *
   7 * Author:      Daniel Reznick
   8 * Info:        https://github.com/vedmack/yadcf
   9 * Contact:     vedmack@gmail.com
  10 * Twitter:     @danielreznick
  11 * Q&A          http://stackoverflow.com/questions/tagged/yadcf
  12 *
  13 * Copyright 2015 Daniel Reznick, all rights reserved.
  14 * Copyright 2015 Released under the MIT License
  15 *
  16 * This source file is distributed in the hope that it will be useful, but
  17 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  18 * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
  19 */
  20 /*
  21 * Parameters:
  22 *
  23 *
  24 * -------------
  25
  26 * column_number
  27                 Required:           true
  28                 Type:               int
  29                 Description:        The number of the column to which the filter will be applied
  30
  31 * filter_type
  32                 Required:           false
  33                 Type:               String
  34                 Default value:      'select'
  35                 Possible values:    select / multi_select / auto_complete / text / date / range_number / range_number_slider / range_date / custom_func / multi_select_custom_func / date_custom_func
  36                 Description:        The type of the filter to be used in the column
  37
  38 * custom_func
  39                 Required:           true (when filter_type is custom_func / multi_select_custom_func / date_custom_func)
  40                 Type:               function
  41                 Default value:      undefined
  42                 Description:        should be pointing to a function with the following signature myCustomFilterFunction(filterVal, columnVal, rowValues, stateVal) , where `filterVal` is the value from the select box,
  43                                     `columnVal` is the value from the relevant row column, `rowValues` is an array that holds the values of the entire row and `stateVal` which holds the current state of the table row DOM
  44                                     , stateVal is perfect to handle situations in which you placing radiobuttons / checkbox inside table column. This function should return true if the row matches your condition and the row should be displayed) and false otherwise
  45                 Note:               When using multi_select_custom_func as filter_type filterVal will hold an array of selected values from the multi select element
  46
  47 * data
  48                 Required:           false
  49                 Type:               Array (of string or objects)
  50                 Description:        When the need of predefined data for filter is needed just use an array of strings ["value1","value2"....] (supported in select / multi_select / auto_complete filters) or
  51                                     array of objects [{value: 'Some Data 1', label: 'One'}, {value: 'Some Data 3', label: 'Three'}] (supported in select / multi_select filters)
  52                 Note:               that when filter_type is custom_func / multi_select_custom_func this array will populate the custom filter select element
  53
  54 * data_as_is
  55                 Required:           false
  56                 Type:               boolean
  57                 Default value:      false
  58                 Description:        When set to true, the value of the data attribute will be fed into the filter as is (without any modification/decoration).
  59                                     Perfect to use when you want to define your own <option></option> for the filter
  60                 Note:               Currently supported by the select / multi_select filters
  61
  62 * append_data_to_table_data
  63                 Required:           false
  64                 Type:               String
  65                 Default value:      undefined
  66                 Possible values:    before / sorted
  67                 Description:        Use 'before' to place your data array before the values that yadcf grabs from the table
  68                                     use 'sorted' to place the data array sorted along with the values that yadcf grabs from the table
  69                 Note:               'sorted' option will have affect only if you data is an array of primitives (not objects)
  70
  71 * column_data_type
  72                 Required:           false
  73                 Type:               String
  74                 Default value:      'text'
  75                 Possible values:    text / html / rendered_html
  76                 Description:        The type of data in column , use "html" when you have some html code in the column (support parsing of multiple elements per cell),
  77                                     use rendered_html when you are using render function of columnDefs or similar, that produces a html code, note that both types rendered_html and html have a fallback for simple text parsing
  78
  79 * text_data_delimiter
  80                 Required:           false
  81                 Type:               String
  82                 Description:        Delimiter that seperates text in table column, for example text_data_delimiter: ","
  83
  84 * html_data_type
  85                 Required:           false
  86                 Type:               String
  87                 Default value:      'text'
  88                 Possible values:    text / value / id / selector
  89                 Description:        When using "html" for column_data_type argument you can choose how exactly to parse your html element/s in column , for example use "text" for the following <span class="someClass">Some text</span>
  90                 Special notes:      when using selector you must provide a valid selector string for the html_data_selector property
  91
  92 * html_data_selector
  93                 Required:           false
  94                 Type:               String
  95                 Default value:      undefined
  96                 Possible values:    any valid selector string, for example 'li:eq(1)'
  97                 Description:        allows for advanced text value selection within the html located in the td element
  98                 Special notes:      know that the selector string "begin is search" from (and not outside) the first element of the html inside the td
  99                                     (supported by range_number_slider / select / auto_complete)
 100
 101 * html5_data
 102                 Required:           false
 103                 Type:               String
 104                 Default value:      undefined
 105                 Possible values:    data-filter / data-search / anything that is supported by datatables
 106                 Description:        Allows to filter based on data-filter / data-search attributes of the <td> element, read more: http://www.datatables.net/examples/advanced_init/html5-data-attributes.html
 107
 108 * filter_container_id
 109                 Required:           false
 110                 Type:               String
 111                 Description:        In case that user don't want to place the filter in column header , he can pass an id of the desired container for the column filter
 112
 113 * filter_container_selector
 114                 Required:           false
 115                 Type:               String
 116                 Description:        In case that user don't want to place the filter in column header , he can pass a (jquery) selector of the desired container for the column filter
 117
 118 * filter_default_label
 119                 Required:           false
 120                 Type:               String / Array of string in case of range_number filter (first entry is for the first input and the second entry is for the second input
 121                 Default value:      'Select value'
 122                 Description:        The label that will appear in the select menu filter when no value is selected from the filter
 123
 124 * omit_default_label
 125                 Required:           false
 126                 Type:               boolean
 127                 Default value:      false
 128                 Description:        Prevent yadcf from adding "default_label" (Select value / Select values)
 129                 Note                Currently supported in select / multi_select / custom_func / multi_select_custom_func
 130
 131 * filter_reset_button_text
 132                 Required:           false
 133                 Type:               String / boolean
 134                 Default value:      'x'
 135                 Description:        The text that will appear inside the reset button next to the select drop down (set this to false (boolean) in order to hide it from that column filter)
 136
 137 * enable_auto_complete (this attribute is deprecated , and will become obsolete in the future , so you better start using filter_type: "auto_complete")
 138                 Required:           false
 139                 Type:               boolean
 140                 Default value:      false
 141                 Description:        Turns the filter into an autocomplete input - make use of the jQuery UI Autocomplete widget (with some enhancements)
 142
 143 * sort_as
 144                 Required:           false
 145                 Type:               String
 146                 Default value:      'alpha'
 147                 Possible values:    alpha / num / alphaNum / none
 148                 Description:        Defines how the values in the filter will be sorted, alphabetically / numerically / alphanumeric / custom / not sorted at all (none is useful to preserve
 149                                     the order of the data attribute as is)
 150                 Note:               When custom value is set you must provide a custom sorting function for the sort_as_custom_func property
 151
 152 * sort_as_custom_func
 153                 Required:           false
 154                 Type:               function
 155                 Default value:      undefined
 156                 Description:        Allows to provide a custom sorting function for the filter elements
 157
 158 * sort_order
 159                 Required:           false
 160                 Type:               String
 161                 Default value:      'asc'
 162                 Possible values:    asc / desc
 163                 Description:        Defines the order in which the values in the filter will be sorted, ascending or descending
 164
 165 * date_format
 166                 Required:           false
 167                 Type:               String
 168                 Default value:      'mm/dd/yyyy'
 169                 Possible values:    mm/dd/yyyy / dd/mm/yyyy / hh:mm (when using datepicker_type: 'bootstrap-datetimepicker')
 170                 Description:        Defines the format in which the date values are being parsed into Date object
 171                 Note:               You can replace the / separator with other one , for example mm-dd-yy
 172
 173 * moment_date_format
 174                 Required:           false
 175                 Type:               String
 176                 Default value:      undefined
 177                 Possible values:    Any format accepted by momentjs
 178                 Description:        Defines the format in which the date values are being parsed into Date object by momentjs library
 179                 Note:               Currently relevant only when using datepicker_type: 'bootstrap-datetimepicker')
 180
 181 * ignore_char
 182                 Required:           false
 183                 Type:               String
 184                 Description:        Tells the range_number and range_number_slide to ignore specific char while filtering (that char can used as number separator)
 185                 Note:               Use double escape for regex chars , e.g \\$ , also you can use multiple ignore chars with | , e.g '_|\\.|\\$'
 186
 187 * filter_match_mode
 188                 Required:           false
 189                 Type:               String
 190                 Default value:      contains
 191                 Possible values:    contains / exact / startsWith / regex
 192                 Description:        Allows to control the matching mode of the filter (supported in select / auto_complete / text filters)
 193
 194 * exclude
 195                 Required:           false
 196                 Type:               boolean
 197                 Default value:      undefined
 198                 Description:        Adds a checkbox next to the filter that allows to do a "not/exclude" filtering (acts the same  all filter_match_mode)
 199                 Note:               Currently available for the text filter
 200
 201 * exclude_label
 202                 Required:           false
 203                 Type:               String
 204                 Default value:      'exclude'
 205                 Description:        The label that will appear above the exclude checkbox
 206
 207 * select_type
 208                 Required:           false
 209                 Type:               String
 210                 Default value:      undefined
 211                 Possible values:    chosen / select2 / custom_select
 212                 Description:        Turns the simple select element into Chosen / Select2 (make use of the Chosen / Select2 select jQuery plugins)
 213                 Note:               When using custom_select , make sure to call the initSelectPluginCustomTriggers,
 214                                     before calling yadcf constructor / init function
 215
 216 * select_type_options
 217                 Required:           false
 218                 Type:               Object
 219                 Default value:      {}
 220                 Description:        This parameter will be passed "as is" to the Chosen/Select2 plugin constructor
 221
 222 * filter_plugin_options
 223                 Required:           false
 224                 Type:               Object
 225                 Default value:      undefined
 226                 Description:        This parameter will be passed to the jQuery Autocomplete / jQuery Slider / Bootstrap Datetimepicker
 227
 228 * case_insensitive
 229                 Required:           false
 230                 Type:               boolean
 231                 Default value:      true
 232                 Description:        Do case-insensitive filtering (supported in select / auto_complete / text filters)
 233
 234
 235 * filter_delay
 236                 Required:           false
 237                 Type:               integer
 238                 Default value:      undefined
 239                 Description:        Delay filter execution for a XXX milliseconds - filter will fire XXX milliseconds after the last keyup.
 240                 Special notes:      Currently supported in text / range_number / range_date filters / range_number_slider
 241
 242 * datepicker_type
 243                 Required:           false
 244                 Type:               String
 245                 Default value:      'jquery-ui'
 246                 Possible values:    'jquery-ui' / 'bootstrap-datetimepicker' / bootstrap-datepicker
 247                 Description:        You can choose datapicker library from defined in special notes
 248                 Special notes:      Currently supported only jQueryUI datepicker (datepicker) and Bootstrap datepicker (eonasdan-bootstrap-datetimepicker)
 249                                     Bootstrap datepicker depends moment library. This plugin depends moment too.
 250
 251 * style_class
 252                 Required:           false
 253                 Type:               String
 254                 Description:        Allows adding additional class/classes to filter - available for the following filters:
 255                                     select / multi_select / text / custom_func / multi_select_custom_func / range_number / range_number_slider / range_date
 256
 257 * reset_button_style_class
 258                 Required:           false
 259                 Type:               String
 260                 Description:        Allows adding additional class/classes to filter reset button
 261
 262
 263 * Global Parameters (per table rather than per column)
 264 *
 265 * Usage example yadcf.init(oTable,[{column_number : 0}, {column_number: 3}],{cumulative_filtering: true});
 266 * -------------
 267
 268 * externally_triggered
 269                 Required:           false
 270                 Type:               boolean
 271                 Default value:      false
 272                 Description:        Filters will filter only when yadcf.exFilterExternallyTriggered(table_arg) is called
 273                 Special notes:      Useful when you want to build some form with filters and you want to trigger the filter when that form
 274                                     "submit" button is clicked (instead of filtering per filter input change)
 275
 276 * cumulative_filtering
 277                 Required:           false
 278                 Type:               boolean
 279                 Default value:      false
 280                 Description:        Change the default behaviour of the filters so its options will be populated from the filtered rows (remaining
 281                                     table data after filtering) only, unlike the normal behaviour in which the options of the filters are from all the table data
 282
 283
 284 * filters_position
 285                 Required:           false
 286                 Type:               String
 287                 Default value:      header
 288                 Possible values:    'header' / 'footer'
 289                 Description:        Filters can be placed in the header (thead) or in the footer (tfoot) of the table,
 290                 Note:               When 'footer' you must provide a valid tfoot elemet in your table
 291
 292
 293 * filters_tr_index
 294                 Required:           false
 295                 Type:               integer
 296                 Default value:      undefined
 297                 Description:        Allow to control the index of the <tr> inside the thead of the table, e.g when one <tr> is used for headers/sort and
 298                                     another <tr> is used for filters
 299
 300
 301 * onInitComplete
 302                 Required:           false
 303                 Type:               function
 304                 Default value:      undefined
 305                 Description:        Calls the provided callback function in the end of the yadcf init function
 306                                 Note:               This callback function will run before datatables fires its event such as draw/xhr/etc., migth be usefull for call some
 307                                                                         third parties init / loading code
 308 *
 309 *
 310 *
 311 *
 312 * External API functions:
 313 *
 314 *
 315 * -------------
 316
 317 * exFilterColumn
 318                 Description:        Allows to trigger filter/s externally/programmatically (support ALL filter types!!!) , perfect for showing table with pre filtered columns
 319                 Arguments:          table_arg: (variable of the datatable),
 320                                     array of pairs: column number String/Object with from and to, filter_value (the actual string value that we want to filter by)
 321                 Usage example:      yadcf.exFilterColumn(oTable, [[0, 'Some Data 2']]); //pre filter one column
 322                                     yadcf.exFilterColumn(oTable, [[0, 'Some Data 1'], [1, {from: 111, to: 1110}], [2, {from: "", to: "11/25/2014"}]]); //pre filter several columns
 323                                     yadcf.exFilterColumn(oTable, [[0, ['Some Data 1','Some Data 2']]]); // for pre filtering multi select filter you should use array with values (or an array with single value)
 324
 325 * exGetColumnFilterVal
 326                 Description:        Allows to retrieve  column current filtered value (support ALL filter types!!!)
 327                 Arguments:          table_arg: (variable of the datatable),
 328                                     column number:  column number from which we want the value
 329                 Usage example:      yadcf.exGetColumnFilterVal(oTable,1);
 330                 Return value:       String (for simple filter) / Object (for range filter) with from and to properties / Array of strings for multi_select filter
 331
 332
 333 * exResetAllFilters
 334                 Description:        Allows to reset all filters externally/programmatically (support ALL filter types!!!) , perfect for adding a "reset all" button to your page!
 335                 Arguments:          table_arg: (variable of the datatable)
 336                                     noRedraw:   (boolean) , use it if you don't want your table to be reloaded after the filter reset,
 337                                                 for example if you planning to call exFilterColumn function right after the exResetAllFilters (to avoid two AJAX requests)
 338                 Usage example:      yadcf.exResetAllFilters(oTable);
 339
 340 * exResetFilters
 341                 Description:        Allows to reset specific filters externally/programmatically (support ALL filter types!!!) , can be used for resetting one or more filters
 342                 Arguments:          table_arg: (variable of the datatable)
 343                                     array with columns numbers
 344                                     noRedraw:   (boolean) , use it if you don't want your table to be reloaded after the filter reset,
 345                                                 for example if you planning to call exFilterColumn function right after the exResetFilters (to avoid two AJAX requests)
 346                 Usage example:      yadcf.exResetAllFilters(oTable, [1,2]);
 347
 348 * initSelectPluginCustomTriggers
 349                 Description:        Allows to set any select jquery plugin initialize and refresh functions. jQuery selector will be passed to the user defined function to initialize and refresh the plugin.
 350                                     Great for integrating any jquey select plugin  (Selectize / MultiSelect / etc)
 351                 Arguments:          initFunc  : function which will initialize the plugin
 352                                     refreshFunc : function that will refresh the plugin.
 353                                     destroyFunc : function that will destroy the plugin (upon table destroy even trigger).
 354                 Usage example:      yadcf.initSelectPluginCustomTriggers(function ($filterSelector){$filterSelector.multiselect({});}, function ($filterSelector){$filterSelector.multiselect("refresh")}, , function ($filterSelector){$filterSelector.multiselect("destroy")});
 355
 356 * exFilterExternallyTriggered
 357                 Description:        Triggers all the available filters, should be used only when the externally_triggered option used
 358                 Arguments:          table_arg: (variable of the datatable)
 359                 Usage example:      yadcf.exResetAllFilters(table_arg);
 360 *
 361 *
 362 *
 363 * Server-side processing API (see more on showcase):
 364 *
 365 * From server to client:
 366 * In order to populate the filters with data from server (select / auto_complete / range_number_slider (min and max values), you should add to your current json respond the following properties:
 367 * lets say for first column you add yadcf_data_0 filled with array of values, for column second column yadcf_data_1 and so on...
 368 *
 369 * From client to server:
 370 * Read the filtered value like this (for first column) req.getParameter("columns[0][search][value]"); <- java code , php/.Net/etc you just need to get it from the request
 371 * Range filter value will arrive delimited by  -yadcf_delim- , so just split it into an array or something like this: String[] minMax = sSearch_0.split("-yadcf_delim-");
 372 *
 373 *
 374
 375
 376 *
 377 *
 378 *
 379 * Working with filters for multiple tables:
 380 *
 381 *
 382 * -------------
 383
 384 * initMultipleTables
 385                 Description:        Allows to create filter that will affect multiple tables / multiple column(s) in multiple tables
 386                 Arguments:          Array of tables,
 387                                     Array of objects with properties for each filter
 388                 Usage example:      yadcf.initMultipleTables([oTable, oTable2], [{
 389                                         column_number: [0, 1], filter_container_id: 'multi-table-filter-0', filter_default_label: 'Filter all tables columns 1 and 2!'
 390                                     },
 391                                     {
 392                                         column_number: [2], filter_container_id: 'multi-table-filter-1', filter_default_label: 'Filter all tables column 3!'
 393                                     }]);
 394                 Valid properties:   filter_type: 'text' (default) / 'select' / 'multi_select',
 395                                     column_number: not required (in that case the filter will be global)
 396                                                    can be either number(single column filter) or array of numbers(multiple columns filter)
 397                                     filter_container_id: '' (required),
 398                 Note:               All the usual properties of yadcf should be supported in initMultipleTables too!
 399
 400 * initMultipleColumns
 401                 Description:        Allows to create filter that will affect multiple column(s) in in a particular table
 402                 Arguments:          Table variable,
 403                                     Array of objects with properties for each filter
 404                 Usage example:      yadcf.initMultipleColumns(oTable, [{
 405                                         column_number: [0, 1], filter_container_id: 'multi-table-filter-0', filter_default_label: 'Filter columns 1 and 2!'
 406                                     },
 407                                     {
 408                                         column_number: [2, 3], filter_container_id: 'multi-table-filter-1', filter_default_label: 'Filter column 3 and 4!'
 409                                     }]);
 410                 Valid properties:   filter_type: 'text' (default) / 'select' / 'multi_select',
 411                                     column_number: not required (in that case the filter will be global)
 412                                                    can be either number(single column filter) or array of numbers(multiple columns filter)
 413                                     filter_container_id: '' (required),
 414                 Note:               All the usual properties of yadcf should be supported in initMultipleColumns too!
 415 */
 416 //Polyfills
 417 if (window.NodeList && !NodeList.prototype.forEach) {
 418     NodeList.prototype.forEach = function (callback, thisArg) {
 419         thisArg = thisArg || window;
 420         for (var i = 0; i < this.length; i++) {
 421             callback.call(thisArg, this[i], i, this);
 422         }
 423     };
 424 }
 425 if (!Object.entries) {
 426   Object.entries = function(obj) {
 427     var ownProps = Object.keys(obj),
 428       i = ownProps.length,
 429       resArray = new Array(i); // preallocate the Array
 430     while (i--)
 431       resArray[i] = [ownProps[i], obj[ownProps[i]]];
 432
 433     return resArray;
 434   };
 435 }
 436 (function (factory) {
 437   'use strict';
 438
 439   if (typeof define === 'function' && define.amd) {
 440     // AMD
 441     define(['jquery'], function ($) {
 442       return factory($, window, document);
 443     });
 444   } else if (typeof module === 'object') {
 445     // CommonJS
 446     module.exports = function (root, $) {
 447       if (!root) {
 448         // CommonJS environments without a window global must pass a
 449         // root. This will give an error otherwise
 450         root = window;
 451       }
 452
 453       if (!$) {
 454         $ = typeof window !== 'undefined' ? // jQuery's factory checks for a global window
 455           require('jquery') :
 456           require('jquery')(root);
 457       }
 458
 459       return factory($, root, root.document);
 460     };
 461   } else {
 462     // Browser
 463     factory(jQuery, window, document);
 464   }
 465 }
 466 (function ($, window, document, undefined) {
 467         var yadcf = (function () {
 468                 'use strict';
 469
 470                 var tablesDT = {},
 471                         oTables = {},
 472                         oTablesIndex = {},
 473                         options = {},
 474                         plugins = {},
 475                         exFilterColumnQueue = [],
 476                         yadcfDelay,
 477                         selectElementCustomInitFunc,
 478                         selectElementCustomRefreshFunc,
 479                         selectElementCustomDestroyFunc,
 480                         placeholderLang = {
 481                                 select: 'Select value',
 482                                 select_multi: 'Select values',
 483                                 filter: 'Type to filter',
 484                                 range: ['From', 'To'],
 485                                 date: 'Select a date'
 486                         },
 487                         settingsMap = {};
 488
 489                 let closeBootstrapDatepicker = false;
 490                 let     closeBootstrapDatepickerRange = false;
 491                 let     closeSelect2 = false;
 492
 493                 //From ColReorder (SpryMedia Ltd (www.sprymedia.co.uk))
 494                 function getSettingsObjFromTable(dt) {
 495                         var oDTSettings;
 496                         if ($.fn.dataTable.Api) {
 497                                 oDTSettings = new $.fn.dataTable.Api(dt).settings()[0];
 498                         } else if (dt.fnSettings) { // 1.9 compatibility
 499                                 // DataTables object, convert to the settings object
 500                                 oDTSettings = dt.fnSettings();
 501                         } else if (typeof dt === 'string') { // jQuery selector
 502                                 if ($.fn.dataTable.fnIsDataTable($(dt)[0])) {
 503                                         oDTSettings = $(dt).eq(0).dataTable().fnSettings();
 504                                 }
 505                         } else if (dt.nodeName && dt.nodeName.toLowerCase() === 'table') {
 506                                 // Table node
 507                                 if ($.fn.dataTable.fnIsDataTable(dt.nodeName)) {
 508                                         oDTSettings = $(dt.nodeName).dataTable().fnSettings();
 509                                 }
 510                         } else if (dt instanceof jQuery) {
 511                                 // jQuery object
 512                                 if ($.fn.dataTable.fnIsDataTable(dt[0])) {
 513                                         oDTSettings = dt.eq(0).dataTable().fnSettings();
 514                                 }
 515                         } else {
 516                                 // DataTables settings object
 517                                 oDTSettings = dt;
 518                         }
 519                         return oDTSettings;
 520                 }
 521
 522                 function arraySwapValueWithIndex(pArray) {
 523                         var tmp = [],
 524                                 i;
 525                         for (i = 0; i < pArray.length; i++) {
 526                                 tmp[pArray[i]] = i;
 527                         }
 528                         return tmp;
 529                 }
 530
 531                 function arraySwapValueWithIndex2(pArray) {
 532                         var tmp = [],
 533                                 i;
 534                         for (i = 0; i < pArray.length; i++) {
 535                                 tmp[pArray[i]._ColReorder_iOrigCol] = i;
 536                         }
 537                         return tmp;
 538                 }
 539
 540                 function initColReorder2(settingsDt, table_selector_jq_friendly) {
 541                         if (settingsDt.oSavedState && settingsDt.oSavedState.ColReorder !== undefined) {
 542                                 if (plugins[table_selector_jq_friendly] === undefined) {
 543                                         plugins[table_selector_jq_friendly] = {};
 544                                         plugins[table_selector_jq_friendly].ColReorder = arraySwapValueWithIndex(settingsDt.oSavedState.ColReorder);
 545                                 }
 546                         } else if (settingsDt.aoColumns[0]._ColReorder_iOrigCol !== undefined) {
 547                                 if (plugins[table_selector_jq_friendly] === undefined) {
 548                                         plugins[table_selector_jq_friendly] = {};
 549                                         plugins[table_selector_jq_friendly].ColReorder = arraySwapValueWithIndex2(settingsDt.aoColumns);
 550                                 }
 551                         }
 552                 }
 553
 554                 function initColReorderFromEvent(table_selector_jq_friendly) {
 555                         plugins[table_selector_jq_friendly] = undefined;
 556                 }
 557
 558                 function columnsArrayToString(column_number) {
 559                         var column_number_obj = {};
 560                         if (column_number !== undefined) {
 561                                 if (column_number instanceof Array) {
 562                                         column_number_obj.column_number_str = column_number.join('_');
 563                                 } else {
 564                                         column_number_obj.column_number_str = column_number;
 565                                         column_number = [];
 566                                         column_number.push(column_number_obj.column_number_str);
 567                                 }
 568                         } else {
 569                                 column_number_obj.column_number_str = 'global';
 570                         }
 571                         column_number_obj.column_number = column_number;
 572                         return column_number_obj;
 573                 }
 574
 575                 function getOptions(selector) {
 576                         return options[selector];
 577                 }
 578
 579                 function getAllOptions() {
 580                         return options;
 581                 }
 582
 583                 function eventTargetFixUp(pEvent) {
 584                         if (pEvent.target === undefined) {
 585                                 pEvent.target = pEvent.srcElement;
 586                         }
 587                         return pEvent;
 588                 }
 589
 590                 function dot2obj(tmpObj, dot_refs) {
 591                         var i = 0;
 592                         dot_refs = dot_refs.split(".");
 593                         for (i = 0; i < dot_refs.length; i++) {
 594                                 tmpObj = tmpObj[dot_refs[i]];
 595                         }
 596                         return tmpObj;
 597                 }
 598
 599                 function setOptions(selector_arg, options_arg, params) {
 600                         var tmpOptions = {},
 601                                 i,
 602                                 col_num_as_int,
 603                                 default_options = {
 604                                         filter_type: "select",
 605                                         enable_auto_complete: false,
 606                                         sort_as: "alpha",
 607                                         sort_order: "asc",
 608                                         date_format: "mm/dd/yyyy",
 609                                         ignore_char: undefined,
 610                                         filter_match_mode: "contains",
 611                                         select_type: undefined,
 612                                         select_type_options: {},
 613                                         case_insensitive: true,
 614                                         column_data_type: 'text',
 615                                         html_data_type: 'text',
 616                                         exclude_label: 'exclude',
 617                                         style_class: '',
 618                                         reset_button_style_class: '',
 619                                         datepicker_type: 'jquery-ui',
 620                                         range_data_type: 'single',
 621                                         range_data_type_delim: '-',
 622                                         omit_default_label: false
 623                                 };
 624                                 //adaptContainerCssClassImpl = function (dummy) { return ''; };
 625
 626                         $.extend(true, default_options, params);
 627
 628                         if (options_arg.length === undefined) {
 629                                 options[selector_arg] = options_arg;
 630                                 return;
 631                         }
 632                         for (i = 0; i < options_arg.length; i++) {
 633                                 if (options_arg[i].date_format !== undefined && options_arg[i].moment_date_format === undefined) {
 634                                         options_arg[i].moment_date_format = options_arg[i].date_format;
 635                                 }
 636                                 if (options_arg[i].select_type === 'select2') {
 637                                         default_options.select_type_options = {
 638                                                 //adaptContainerCssClass: adaptContainerCssClassImpl
 639                                         };
 640                                 }
 641                                 //no individual reset button for externally_triggered mode
 642                                 if (default_options.externally_triggered === true) {
 643                                         options_arg[i].filter_reset_button_text = false;
 644                                 }
 645                                 //validate custom function required attributes
 646                                 if (options_arg[i].filter_type !== undefined && options_arg[i].filter_type.indexOf('custom_func') !== -1) {
 647                                         if (options_arg[i].custom_func === undefined) {
 648                                                 console.log('Error: You are trying to use filter_type: "custom_func / multi_select_custom_func" for column ' + options_arg[i].column_number + ' but there is no such custom_func attribute provided (custom_func: \"function reference goes here...\")');
 649                                                 return;
 650                                         }
 651                                 }
 652                                 col_num_as_int = +options_arg[i].column_number;
 653                                 if (isNaN(col_num_as_int)) {
 654                                         tmpOptions[options_arg[i].column_number_str] = $.extend(true, {}, default_options, options_arg[i]);
 655                                 } else {
 656                                         tmpOptions[col_num_as_int] = $.extend(true, {}, default_options, options_arg[i]);
 657                                 }
 658                         }
 659                         options[selector_arg] = tmpOptions;
 660
 661                         check3rdPPluginsNeededClose();
 662                 }
 663
 664                 function check3rdPPluginsNeededClose() {
 665                         Object.entries(getAllOptions()).forEach(function(tableEntry) {
 666                                 Object.entries(tableEntry[1]).forEach(function(columnEntry) {
 667                                         if (columnEntry[1].datepicker_type === 'bootstrap-datepicker') {
 668                                                 if (columnEntry[1].filter_type === 'range_date') {
 669                                                         closeBootstrapDatepickerRange = true;
 670                                                 } else {
 671                                                         closeBootstrapDatepicker = true;
 672                                                 }
 673                                         } else if (columnEntry[1].select_type === 'select2') {
 674                                                 closeSelect2 = true;
 675                                         }
 676                                 });
 677                         });
 678                 }
 679
 680                 //taken and modified from DataTables 1.10.0-beta.2 source
 681                 function yadcfVersionCheck(version) {
 682                         var aThis = $.fn.dataTable.ext.sVersion.split('.'),
 683                                 aThat = version.split('.'),
 684                                 iThis,
 685                                 iThat,
 686                                 i,
 687                                 iLen;
 688
 689                         for (i = 0, iLen = aThat.length; i < iLen; i++) {
 690                                 iThis = parseInt(aThis[i], 10) || 0;
 691                                 iThat = parseInt(aThat[i], 10) || 0;
 692
 693                                 // Parts are the same, keep comparing
 694                                 if (iThis === iThat) {
 695                                         continue;
 696                                 }
 697
 698                                 // Parts are different, return immediately
 699                                 return iThis > iThat;
 700                         }
 701
 702                         return true;
 703                 }
 704
 705                 function resetIApiIndex() {
 706                         $.fn.dataTableExt.iApiIndex = 0;
 707
 708                 }
 709
 710                 function escapeRegExp(string) {
 711                         return string.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
 712                 }
 713
 714                 function escapeRegExpInArray(arr) {
 715                         var i;
 716                         for (i = 0; i < arr.length; i++) {
 717                                 arr[i] = arr[i].replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
 718                         }
 719                         return arr;
 720                 }
 721
 722                 function replaceAll(string, find, replace) {
 723                         return string.replace(new RegExp(escapeRegExp(find), 'g'), replace);
 724                 }
 725
 726                 function getTableId(obj) {
 727                         var tableId;
 728                         if (obj.table !== undefined) {
 729                                 tableId = obj.table().node().id;
 730                         } else {
 731                                 tableId = getSettingsObjFromTable(obj).sTableId;
 732                         }
 733                         return tableId;
 734                 }
 735
 736                 function generateTableSelectorJQFriendly2(obj) {
 737                         var tmpStr;
 738                         if (obj.oInstance !== undefined && obj.oInstance.selector !== undefined) {
 739                                 tmpStr = obj.oInstance.selector;
 740                         } else if (obj.selector !== undefined) {
 741                                 tmpStr = obj.selector;
 742                         } else if (obj.table !== undefined) {
 743                                 tmpStr = obj.table().node().id;
 744                         } else {
 745                                 return '';
 746                         }
 747                         tmpStr = replaceAll(tmpStr, ".", "-");
 748                         tmpStr = replaceAll(tmpStr, ' ', '');
 749                         return tmpStr.replace(":", "-").replace("(", "").replace(")", "").replace("#", "-");
 750                 }
 751
 752                 function generateTableSelectorJQFriendlyNew(tmpStr) {
 753                         tmpStr = replaceAll(tmpStr, ":", "-");
 754                         tmpStr = replaceAll(tmpStr, "(", "");
 755                         tmpStr = replaceAll(tmpStr, ")", "");
 756                         tmpStr = replaceAll(tmpStr, ",", "");
 757                         tmpStr = replaceAll(tmpStr, ".", "-");
 758                         tmpStr = replaceAll(tmpStr, "#", "-");
 759                         tmpStr = replaceAll(tmpStr, ' ', '');
 760                         return tmpStr;
 761                 }
 762
 763                 yadcfDelay = (function () {
 764                         var timer = 0;
 765                         return function (callback, ms, param) {
 766                                 clearTimeout(timer);
 767                                 timer = setTimeout(function () {
 768                                         callback(param);
 769                                 }, ms);
 770                                 return timer;
 771                         };
 772                 }());
 773
 774                 function initializeSelectPlugin(selectType, $selectObject, select_type_options) {
 775                         if (selectType === 'chosen') {
 776                                 $selectObject.chosen(select_type_options);
 777                                 $selectObject.next().attr("onclick", "yadcf.stopPropagation(event);").attr("onmousedown", "yadcf.stopPropagation(event);");
 778                                 refreshSelectPlugin({
 779                                         select_type: selectType,
 780                                         select_type_options: select_type_options
 781                                 }, $selectObject);
 782                         } else if (selectType === 'select2') {
 783                                 if (!$selectObject.data('select2')) {
 784                                         $selectObject.select2(select_type_options);
 785                                 }
 786                                 if ($selectObject.next().hasClass('select2-container')) {
 787                                         $selectObject.next().attr("onclick", "yadcf.stopPropagation(event);").attr("onmousedown", "yadcf.stopPropagation(event);");
 788                                 }
 789                         } else if (selectType === 'custom_select') {
 790                                 selectElementCustomInitFunc($selectObject);
 791                                 $selectObject.next().attr("onclick", "yadcf.stopPropagation(event);").attr("onmousedown", "yadcf.stopPropagation(event);");
 792                         }
 793                 }
 794
 795                 function refreshSelectPlugin(columnObj, $selectObject, val) {
 796                         var selectType = columnObj.select_type,
 797                                 select_type_options = columnObj.select_type_options;
 798                         if (selectType === 'chosen') {
 799                                 $selectObject.trigger("chosen:updated");
 800                         } else if (selectType === 'select2') {
 801                                 if (!$selectObject.data('select2')) {
 802                                         $selectObject.select2(select_type_options);
 803                                 }
 804                                 if (val !== undefined) {
 805                                         $selectObject.val(val);
 806                                 }
 807                                 $selectObject.trigger('change');
 808                         } else if (selectType === 'custom_select') {
 809                                 selectElementCustomRefreshFunc($selectObject);
 810                         }
 811                 }
 812
 813                 function initSelectPluginCustomTriggers(initFunc, refreshFunc, destroyFunc) {
 814                         selectElementCustomInitFunc = initFunc;
 815                         selectElementCustomRefreshFunc = refreshFunc;
 816                         selectElementCustomDestroyFunc = destroyFunc;
 817                 }
 818
 819                 //Used by exFilterColumn for translating readable search value into proper search string for datatables filtering
 820                 function yadcfMatchFilterString(table_arg, column_number, selected_value, filter_match_mode, multiple, exclude) {
 821                         var case_insensitive = yadcf.getOptions(table_arg.selector)[column_number].case_insensitive,
 822                                 ret_val;
 823
 824                         if (!selected_value) {
 825                                 return '';
 826                         }
 827
 828                         table_arg.fnSettings().aoPreSearchCols[column_number].bSmart = false;
 829                         table_arg.fnSettings().aoPreSearchCols[column_number].bRegex = true;
 830                         table_arg.fnSettings().aoPreSearchCols[column_number].bCaseInsensitive = case_insensitive;
 831
 832                         if (multiple === undefined || multiple === false) {
 833                                 if (exclude !== true) {
 834                                         if (filter_match_mode === "contains") {
 835                                                 table_arg.fnSettings().aoPreSearchCols[column_number].bSmart = true;
 836                                                 table_arg.fnSettings().aoPreSearchCols[column_number].bRegex = false;
 837                                                 ret_val = selected_value;
 838                                         } else if (filter_match_mode === "exact") {
 839                                                 ret_val = "^" + selected_value + "$";
 840                                         } else if (filter_match_mode === "startsWith") {
 841                                                 ret_val = "^" + selected_value;
 842                                         } else if (filter_match_mode === "regex") {
 843                                                 ret_val = selected_value;
 844                                         }
 845                                 } else {
 846                                         ret_val = "^((?!" + selected_value + ").)*$";
 847                                 }
 848                         } else {
 849                                 if (filter_match_mode !== 'regex') {
 850                                         if (!(selected_value instanceof Array)) {
 851                                                 selected_value = [selected_value];
 852                                         }
 853                                         selected_value = escapeRegExpInArray(selected_value);
 854                                 }
 855                                 if (filter_match_mode === "contains") {
 856                                         ret_val = selected_value.join("|");
 857                                 } else if (filter_match_mode === "exact") {
 858                                         ret_val = "^(" + selected_value.join("|") + ")$";
 859                                 } else if (filter_match_mode === "startsWith") {
 860                                         ret_val = "^(" + selected_value.join("|") + ")";
 861                                 } else if (filter_match_mode === "regex") {
 862                                         ret_val = selected_value;
 863                                 }
 864                         }
 865                         return ret_val;
 866                 }
 867
 868                 function yadcfMatchFilter(oTable, selected_value, filter_match_mode, column_number, exclude, original_column_number) {
 869                         var case_insensitive = yadcf.getOptions(oTable.selector)[original_column_number].case_insensitive;
 870                         if (exclude !== true) {
 871                                 if (filter_match_mode === "contains") {
 872                                         oTable.fnFilter(selected_value, column_number, false, true, true, case_insensitive);
 873                                 } else if (filter_match_mode === "exact") {
 874                                         selected_value = escapeRegExp(selected_value);
 875                                         oTable.fnFilter("^" + selected_value + "$", column_number, true, false, true, case_insensitive);
 876                                 } else if (filter_match_mode === "startsWith") {
 877                                         selected_value = escapeRegExp(selected_value);
 878                                         oTable.fnFilter("^" + selected_value, column_number, true, false, true, case_insensitive);
 879                                 } else if (filter_match_mode === "regex") {
 880                                         try {
 881                                                 //validate regex, only call fnFilter if valid
 882                                                 new RegExp(selected_value);
 883                                         } catch (error) {
 884                                                 return;
 885                                         }
 886                                         oTable.fnFilter(selected_value, column_number, true, false, true, case_insensitive);
 887                                 }
 888                         } else {
 889                                 oTable.fnFilter("^((?!" + selected_value + ").)*$", column_number, true, false, true, case_insensitive);
 890                         }
 891                 }
 892                 function yadcfParseMatchFilter(tmpStr, filter_match_mode) {
 893                         var retVal;
 894                         if (filter_match_mode === "contains") {
 895                                 retVal = tmpStr;
 896                         } else if (filter_match_mode === "exact") {
 897                                 retVal = tmpStr.substring(1, tmpStr.length - 1);
 898                                 retVal = retVal.replace(/([\\])/g, '');
 899                         } else if (filter_match_mode === "startsWith") {
 900                                 retVal = tmpStr.substring(1, tmpStr.length);
 901                                 retVal = retVal.replace(/([\\])/g, '');
 902                         } else if (filter_match_mode === "regex") {
 903                                 retVal = tmpStr;
 904                         }
 905                         return retVal;
 906                 }
 907
 908                 function doFilterCustomDateFunc(arg, table_selector_jq_friendly, column_number) {
 909                         var oTable = oTables[table_selector_jq_friendly],
 910                                 yadcfState,
 911                                 columnObj = getOptions(oTable.selector)[column_number];
 912
 913                         if (arg === 'clear' && exGetColumnFilterVal(oTable, column_number) === '') {
 914                                 return;
 915                         }
 916
 917                         if (arg.value !== undefined && arg.value !== "-1") {
 918                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).addClass("inuse");
 919                         } else {
 920                                 //wehn arg === 'clear' or arg.value === '-1'
 921                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).val('-1').focus();
 922                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).removeClass("inuse");
 923                                 refreshSelectPlugin(columnObj, $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number), '-1');
 924                         }
 925
 926                         if (!oTable.fnSettings().oLoadedState) {
 927                                 oTable.fnSettings().oLoadedState = {};
 928                                 oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
 929                         }
 930                         if (oTable.fnSettings().oFeatures.bStateSave === true) {
 931                                 if (oTable.fnSettings().oLoadedState.yadcfState !== undefined && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] !== undefined) {
 932                                         oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number] =
 933                                                 {
 934                                                         from: arg.value
 935                                                 };
 936                                 } else {
 937                                         yadcfState = {};
 938                                         yadcfState[table_selector_jq_friendly] = [];
 939                                         yadcfState[table_selector_jq_friendly][column_number] = {
 940                                                 from: arg.value
 941                                         };
 942                                         oTable.fnSettings().oLoadedState.yadcfState = yadcfState;
 943                                 }
 944                                 oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
 945                         }
 946
 947                         oTable.fnDraw();
 948                 }
 949
 950                 function calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly) {
 951                         var column_number_filter;
 952                         if ((settingsDt.oSavedState && settingsDt.oSavedState.ColReorder !== undefined) ||
 953                                 settingsDt._colReorder ||
 954                                 (plugins[table_selector_jq_friendly] !== undefined && plugins[table_selector_jq_friendly].ColReorder !== undefined)) {
 955                                 initColReorder2(settingsDt, table_selector_jq_friendly);
 956                                 column_number_filter = plugins[table_selector_jq_friendly].ColReorder[column_number];
 957                         } else {
 958                                 column_number_filter = column_number;
 959                         }
 960                         return column_number_filter;
 961                 }
 962
 963                 function doFilter(arg, table_selector_jq_friendly, column_number, filter_match_mode) {
 964                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
 965
 966                         var oTable = oTables[table_selector_jq_friendly],
 967                                 selected_value,
 968                                 column_number_filter,
 969                                 columnObj,
 970                                 settingsDt = getSettingsObjFromTable(oTable);
 971
 972                         column_number_filter = calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly);
 973
 974                         columnObj = getOptions(oTable.selector)[column_number];
 975                         if (arg === "clear") {
 976                                 if (exGetColumnFilterVal(oTable, column_number) === '') {
 977                                         return;
 978                                 }
 979                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).val("-1").focus();
 980                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).removeClass("inuse");
 981                                 $(document).data("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val", "-1");
 982                                 oTable.fnFilter("", column_number_filter);
 983                                 resetIApiIndex();
 984
 985                                 refreshSelectPlugin(columnObj, $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number), '-1');
 986                                 return;
 987                         }
 988
 989                         $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).addClass("inuse");
 990
 991                         $(document).data("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val", arg.value);
 992
 993                         selected_value = $.trim($(arg).find('option:selected').val());
 994
 995                         if (arg.value !== "-1") {
 996                                 yadcfMatchFilter(oTable, selected_value, filter_match_mode, column_number_filter, false, column_number);
 997                         } else {
 998                                 oTable.fnFilter("", column_number_filter);
 999                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).removeClass("inuse");
1000                         }
1001                         resetIApiIndex();
1002                 }
1003
1004                 function doFilterMultiSelect(arg, table_selector_jq_friendly, column_number, filter_match_mode) {
1005                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
1006                         var oTable = oTables[table_selector_jq_friendly],
1007                                 selected_values = $(arg).val(),
1008                                 selected_values_trimmed = [],
1009                                 i,
1010                                 stringForSearch,
1011                                 column_number_filter,
1012                                 settingsDt = getSettingsObjFromTable(oTable);
1013
1014                         column_number_filter = calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly);
1015                         $(document).data("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val", selected_values);
1016
1017                         if (selected_values !== null) {
1018                                 for (i = selected_values.length - 1; i >= 0; i--) {
1019                                         if (selected_values[i] === "-1") {
1020                                                 selected_values.splice(i, 1);
1021                                                 break;
1022                                         }
1023                                 }
1024                                 for (i = 0; i < selected_values.length; i++) {
1025                                         selected_values_trimmed.push($.trim(selected_values[i]));
1026                                 }
1027                                 if (selected_values_trimmed.length !== 0) {
1028                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).addClass("inuse");
1029                                         if (filter_match_mode !== "regex") {
1030                                                 stringForSearch = selected_values_trimmed.join('narutouzomaki');
1031                                                 stringForSearch = stringForSearch.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
1032                                                 stringForSearch = stringForSearch.split('narutouzomaki').join('|');
1033                                                 if (filter_match_mode === "contains") {
1034                                                         oTable.fnFilter(stringForSearch, column_number_filter, true, false, true);
1035                                                 } else if (filter_match_mode === "exact") {
1036                                                         oTable.fnFilter("^(" + stringForSearch + ")$", column_number_filter, true, false, true);
1037                                                 } else if (filter_match_mode === "startsWith") {
1038                                                         oTable.fnFilter("^(" + stringForSearch + ")", column_number_filter, true, false, true);
1039                                                 }
1040                                         } else {
1041                                                 stringForSearch = selected_values_trimmed.join('|');
1042                                                 oTable.fnFilter(stringForSearch, column_number_filter, true, false, true);
1043                                         }
1044                                 } else {
1045                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).removeClass("inuse");
1046                                         oTable.fnFilter("", column_number_filter);
1047                                 }
1048                         } else {
1049                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).removeClass("inuse");
1050                                 oTable.fnFilter("", column_number_filter);
1051                         }
1052                         resetIApiIndex();
1053                 }
1054
1055                 function yadcfParseMatchFilterMultiSelect(tmpStr, filter_match_mode) {
1056                         var retVal;
1057                         if (filter_match_mode === "contains") {
1058                                 retVal = tmpStr;
1059                         } else if (filter_match_mode === "exact") {
1060                                 retVal = tmpStr.substring(1, tmpStr.length - 1);
1061                                 retVal = retVal.substring(1, retVal.length - 1);
1062                         } else if (filter_match_mode === "startsWith") {
1063                                 retVal = tmpStr.substring(1, tmpStr.length);
1064                                 retVal = retVal.substring(1, retVal.length - 1);
1065                         } else if (filter_match_mode === "regex") {
1066                                 retVal = tmpStr;
1067                         }
1068                         return retVal;
1069                 }
1070
1071                 function doFilterAutocomplete(arg, table_selector_jq_friendly, column_number, filter_match_mode) {
1072                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
1073                         var oTable = oTables[table_selector_jq_friendly],
1074                                 column_number_filter,
1075                                 settingsDt = getSettingsObjFromTable(oTable);
1076
1077                         column_number_filter = calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly);
1078
1079                         if (arg === "clear") {
1080                                 if (exGetColumnFilterVal(oTable, column_number) === '') {
1081                                         return;
1082                                 }
1083                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).val("").focus();
1084                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).removeClass("inuse");
1085                                 $(document).removeData("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val");
1086                                 oTable.fnFilter("", column_number_filter);
1087                                 resetIApiIndex();
1088                                 return;
1089                         }
1090
1091                         $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).addClass("inuse");
1092
1093                         $(document).data("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val", arg.value);
1094
1095                         yadcfMatchFilter(oTable, arg.value, filter_match_mode, column_number_filter, false, column_number);
1096
1097                         resetIApiIndex();
1098                 }
1099
1100                 function autocompleteSelect(event, ui) {
1101                         var table_column,
1102                                 dashIndex,
1103                                 table_selector_jq_friendly,
1104                                 col_num,
1105                                 filter_match_mode;
1106
1107                         event = eventTargetFixUp(event);
1108                         table_column = event.target.id.replace("yadcf-filter-", "");
1109                         dashIndex = table_column.lastIndexOf("-");
1110                         table_selector_jq_friendly = table_column.substring(0, dashIndex);
1111                         col_num = parseInt(table_column.substring(dashIndex + 1), 10);
1112                         filter_match_mode = $(event.target).attr("filter_match_mode");
1113
1114                         doFilterAutocomplete(ui.item, table_selector_jq_friendly, col_num, filter_match_mode);
1115                 }
1116
1117                 function sortNumAsc(a, b) {
1118                         return a - b;
1119                 }
1120
1121                 function sortNumDesc(a, b) {
1122                         return b - a;
1123                 }
1124
1125                 function findMinInArray(array, columnObj) {
1126                         var narray = [],
1127                                 i,
1128                                 num,
1129                                 min;
1130                         for (i = 0; i < array.length; i++) {
1131                                 if (array[i] !== null) {
1132                                         if (columnObj.ignore_char !== undefined) {
1133                                                 array[i] = array[i].toString().replace(columnObj.ignore_char, "");
1134                                         }
1135                                         if (columnObj.range_data_type === 'single') {
1136                                                 num = +array[i];
1137                                         } else {
1138                                                 num = array[i].split(columnObj.range_data_type_delim);
1139                                                 num = num[0];
1140                                         }
1141                                         if (!isNaN(num)) {
1142                                                 narray.push(num);
1143                                         }
1144                                 }
1145                         }
1146                         min = Math.min.apply(Math, narray);
1147                         if (!isFinite(min)) {
1148                                 min = 0;
1149                         } else if (min !== 0) {
1150                                 if (min > 0) {
1151                                         min = Math.floor(min);
1152                                 } else {
1153                                         min = -1 * Math.ceil(min * -1);
1154                                 }
1155                         }
1156
1157                         return min;
1158                 }
1159
1160                 function findMaxInArray(array, columnObj) {
1161                         var narray = [],
1162                                 i,
1163                                 num,
1164                                 max;
1165                         for (i = 0; i < array.length; i++) {
1166                                 if (array[i] !== null) {
1167                                         if (columnObj.ignore_char !== undefined) {
1168                                                 array[i] = array[i].toString().replace(columnObj.ignore_char, "");
1169                                         }
1170                                         if (columnObj.range_data_type === 'single') {
1171                                                 num = +array[i];
1172                                         } else {
1173                                                 num = array[i].split(columnObj.range_data_type_delim);
1174                                                 num = num[1];
1175                                         }
1176                                         if (!isNaN(num)) {
1177                                                 narray.push(num);
1178                                         }
1179                                 }
1180                         }
1181                         max = Math.max.apply(Math, narray);
1182                         if (!isFinite(max)) {
1183                                 max = 0;
1184                         } else {
1185                                 max = Math.ceil(max);
1186                         }
1187                         return max;
1188                 }
1189
1190                 function addRangeNumberAndSliderFilterCapability(table_selector_jq_friendly, fromId, toId, col_num, ignore_char, sliderMaxMin) {
1191
1192                         $.fn.dataTableExt.afnFiltering.push(
1193                                 function (settingsDt, aData, iDataIndex, rowData) {
1194                                         var min,
1195                                                 max,
1196                                                 val,
1197                                                 retVal = false,
1198                                                 table_selector_jq_friendly_local = table_selector_jq_friendly,
1199                                                 current_table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendly2(settingsDt),
1200                                                 ignore_char_local = ignore_char,
1201                                                 column_data_type,
1202                                                 html_data_type,
1203                                                 columnObj,
1204                                                 column_number_filter,
1205                                                 valFrom,
1206                                                 valTo;
1207
1208                                         if (table_selector_jq_friendly_local !== current_table_selector_jq_friendly) {
1209                                                 return true;
1210                                         }
1211                                         columnObj = getOptions(settingsDt.oInstance.selector)[col_num];
1212                                         if (columnObj.filter_type === 'range_number_slider') {
1213                                                 min = $('#' + fromId).text();
1214                                                 max = $('#' + toId).text();
1215                                         } else {
1216                                                 min = $('#' + fromId).val();
1217                                                 max = $('#' + toId).val();
1218                                         }
1219
1220                                         column_number_filter = calcColumnNumberFilter(settingsDt, col_num, table_selector_jq_friendly);
1221
1222                                         if (rowData !== undefined) {
1223                                                 aData = rowData;
1224                                                 if (columnObj.column_number_data !== undefined) {
1225                                                         column_number_filter = columnObj.column_number_data;
1226                                                         val = dot2obj(aData, column_number_filter);
1227                                                 } else {
1228                                                         val = aData[column_number_filter];
1229                                                 }
1230                                         } else {
1231                                                 val = aData[column_number_filter];
1232                                         }
1233                                         if (!isFinite(min) || !isFinite(max)) {
1234                                                 return true;
1235                                         }
1236                                         column_data_type = columnObj.column_data_type;
1237                                         html_data_type = columnObj.html_data_type;
1238
1239                                         if (column_data_type === "html" || column_data_type === "rendered_html") {
1240                                                 if (html_data_type === undefined) {
1241                                                         html_data_type = "text";
1242                                                 }
1243                                                 if ($(val).length !== 0) {
1244                                                         switch (html_data_type) {
1245                                                         case "text":
1246                                                                 val = $(val).text();
1247                                                                 break;
1248                                                         case "value":
1249                                                                 val = $(val).val();
1250                                                                 break;
1251                                                         case "id":
1252                                                                 val = val.id;
1253                                                                 break;
1254                                                         case "selector":
1255                                                                 val = $(val).find(columnObj.html_data_selector).text();
1256                                                                 break;
1257                                                         }
1258                                                 }
1259                                         } else {
1260                                                 if (typeof val === 'object') {
1261                                                         if (columnObj.html5_data !== undefined) {
1262                                                                 val = val['@' + columnObj.html5_data];
1263                                                         }
1264                                                 }
1265                                         }
1266                                         if (ignore_char_local !== undefined) {
1267                                                 min = min.replace(ignore_char_local, "");
1268                                                 max = max.replace(ignore_char_local, "");
1269                                                 if (val) {
1270                                                         val = val.toString().replace(ignore_char_local, "");
1271                                                 } else {
1272                                                         val = "";
1273                                                 }
1274                                         }
1275                                         //omit empty rows when filtering
1276                                         if (columnObj.filter_type === 'range_number_slider') {
1277                                                 if (val === '' && ((+min) !== sliderMaxMin.min || (+max) !== sliderMaxMin.max)) {
1278                                                         return false;
1279                                                 }
1280                                         } else {
1281                                                 if (val === '' && (min !== '' || max !== '')) {
1282                                                         return false;
1283                                                 }
1284                                         }
1285                                         min = (min !== "") ? (+min) : min;
1286                                         max = (max !== "") ? (+max) : max;
1287                                         if (columnObj.range_data_type === 'single') {
1288                                                 val = (val !== "") ? (+val) : val;
1289                                                 if (min === "" && max === "") {
1290                                                         retVal = true;
1291                                                 } else if (min === "" && val <= max) {
1292                                                         retVal = true;
1293                                                 } else if (min <= val && "" === max) {
1294                                                         retVal = true;
1295                                                 } else if (min <= val && val <= max) {
1296                                                         retVal = true;
1297                                                 } else if (val === '' || isNaN(val)) {
1298                                                         retVal = true;
1299                                                 }
1300                                         } else if (columnObj.range_data_type === 'range') {
1301                                                 val = val.split(columnObj.range_data_type_delim);
1302                                                 valFrom = (val[0] !== "") ? (+val[0]) : val[0];
1303                                                 valTo = (val[1] !== "") ? (+val[1]) : val[1];
1304                                                 if (min === "" && max === "") {
1305                                                         retVal = true;
1306                                                 } else if (min === "" && valTo <= max) {
1307                                                         retVal = true;
1308                                                 } else if (min <= valFrom && "" === max) {
1309                                                         retVal = true;
1310                                                 } else if (min <= valFrom && valTo <= max) {
1311                                                         retVal = true;
1312                                                 } else if ((valFrom === '' || isNaN(valFrom)) && (valTo === '' || isNaN(valTo))) {
1313                                                         retVal = true;
1314                                                 }
1315                                         }
1316                                         return retVal;
1317                                 }
1318                         );
1319                 }
1320
1321                 function addCustomFunctionFilterCapability(table_selector_jq_friendly, filterId, col_num) {
1322
1323                         $.fn.dataTableExt.afnFiltering.push(
1324                                 function (settingsDt, aData, iDataIndex, stateVal) {
1325                                         var filterVal = $('#' + filterId).val(),
1326                                                 columnVal,
1327                                                 retVal = false,
1328                                                 table_selector_jq_friendly_local = table_selector_jq_friendly,
1329                                                 current_table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendly2(settingsDt),
1330                                                 custom_func,
1331                                                 column_number_filter;
1332
1333                                         if (table_selector_jq_friendly_local !== current_table_selector_jq_friendly || filterVal === '-1') {
1334                                                 return true;
1335                                         }
1336
1337                                         column_number_filter = calcColumnNumberFilter(settingsDt, col_num, table_selector_jq_friendly);
1338
1339                                         columnVal = aData[column_number_filter] === "-" ? 0 : aData[column_number_filter];
1340
1341                                         custom_func = getOptions(settingsDt.oInstance.selector)[col_num].custom_func;
1342
1343                                         retVal = custom_func(filterVal, columnVal, aData, stateVal);
1344
1345                                         return retVal;
1346                                 }
1347                         );
1348                 }
1349                 function addRangeDateFilterCapability(table_selector_jq_friendly, fromId, toId, col_num, date_format) {
1350
1351                         $.fn.dataTableExt.afnFiltering.push(
1352                                 function (settingsDt, aData, iDataIndex, rowData) {
1353                                         var min = document.getElementById(fromId) !== null ? document.getElementById(fromId).value : "",
1354                                                 max = document.getElementById(toId) !== null ? document.getElementById(toId).value : "",
1355                                                 val,
1356                                                 retVal = false,
1357                                                 table_selector_jq_friendly_local = table_selector_jq_friendly,
1358                                                 current_table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendly2(settingsDt),
1359                                                 column_data_type,
1360                                                 html_data_type,
1361                                                 columnObj,
1362                                                 column_number_filter,
1363                                                 min_time,
1364                                                 max_time,
1365                                                 dataRenderFunc,
1366                                                 dpg;
1367
1368                                         if (table_selector_jq_friendly_local !== current_table_selector_jq_friendly) {
1369                                                 return true;
1370                                         }
1371                                         columnObj = getOptions(settingsDt.oInstance.selector)[col_num];
1372                                         if (columnObj.datepicker_type === 'bootstrap-datepicker') {
1373                                                 dpg = $.fn.datepicker.DPGlobal;
1374                                         }
1375                                         column_number_filter = calcColumnNumberFilter(settingsDt, col_num, table_selector_jq_friendly);
1376                                         if (typeof columnObj.column_number_data === 'function' || typeof columnObj.column_number_render === 'function') {
1377                                                 dataRenderFunc = true;
1378                                         }
1379                                         if (rowData !== undefined && dataRenderFunc !== true) {
1380                                                 if (columnObj.column_number_data !== undefined) {
1381                                                         column_number_filter = columnObj.column_number_data;
1382                                                         val = dot2obj(rowData, column_number_filter);
1383                                                 } else {
1384                                                         val = rowData[column_number_filter];
1385                                                 }
1386                                         } else {
1387                                                 val = aData[column_number_filter];
1388                                         }
1389
1390                                         column_data_type = columnObj.column_data_type;
1391                                         html_data_type = columnObj.html_data_type;
1392
1393                                         if (column_data_type === "html" || column_data_type === "rendered_html") {
1394                                                 if (html_data_type === undefined) {
1395                                                         html_data_type = "text";
1396                                                 }
1397                                                 if ($(val).length !== 0) {
1398                                                         switch (html_data_type) {
1399                                                         case "text":
1400                                                                 val = $(val).text();
1401                                                                 break;
1402                                                         case "value":
1403                                                                 val = $(val).val();
1404                                                                 break;
1405                                                         case "id":
1406                                                                 val = val.id;
1407                                                                 break;
1408                                                         case "selector":
1409                                                                 val = $(val).find(columnObj.html_data_selector).text();
1410                                                                 break;
1411                                                         }
1412                                                 }
1413                                         } else if (typeof val === 'object') {
1414                                                 if (columnObj.html5_data !== undefined) {
1415                                                         val = val['@' + columnObj.html5_data];
1416                                                 }
1417                                         }
1418
1419                                         //omit empty rows when filtering
1420                                         if (val === '' && (min !== '' || max !== '')) {
1421                                                 return false;
1422                                         }
1423                                         try {
1424                                                 if (min.length === (date_format.length + 2) || columnObj.datepicker_type.indexOf('bootstrap') !== -1) {
1425                                                         if (columnObj.datepicker_type === 'jquery-ui') {
1426                                                                 min = (min !== "") ? $.datepicker.parseDate(date_format, min) : min;
1427                                                         } else if (columnObj.datepicker_type === 'bootstrap-datetimepicker') {
1428                                                                 min = (min !== "") ? moment(min, columnObj.moment_date_format).toDate() : min;
1429                                                         } else if (columnObj.datepicker_type === 'bootstrap-datepicker') {
1430                                                                 min = (min !== "") ? dpg.parseDate(min, dpg.parseFormat(columnObj.date_format)) : min;
1431                                                         }
1432                                                 }
1433                                         } catch (err1) {}
1434                                         try {
1435                                                 if (max.length === (date_format.length + 2) || columnObj.datepicker_type.indexOf('bootstrap') !== -1) {
1436                                                         if (columnObj.datepicker_type === 'jquery-ui') {
1437                                                                 max = (max !== "") ? $.datepicker.parseDate(date_format, max) : max;
1438                                                         } else if (columnObj.datepicker_type === 'bootstrap-datetimepicker') {
1439                                                                 max = (max !== "") ? moment(max, columnObj.moment_date_format).toDate() : max;
1440                                                         } else if (columnObj.datepicker_type === 'bootstrap-datepicker') {
1441                                                                 max = (max !== "") ? dpg.parseDate(max, dpg.parseFormat(columnObj.date_format)) : max;
1442                                                         }
1443                                                 }
1444                                         } catch (err2) {}
1445                                         try {
1446                                                 if (columnObj.datepicker_type === 'jquery-ui') {
1447                                                         val = (val !== "") ? $.datepicker.parseDate(date_format, val) : val;
1448                                                 } else if (columnObj.datepicker_type === 'bootstrap-datetimepicker') {
1449                                                         val = (val !== "") ? moment(val, columnObj.moment_date_format).toDate() : val;
1450                                                 } else if (columnObj.datepicker_type === 'bootstrap-datepicker') {
1451                                                         val = (val !== "") ? dpg.parseDate(val, dpg.parseFormat(columnObj.date_format)) : val;
1452                                                 }
1453                                         } catch (err3) {}
1454
1455                                         if (date_format.toLowerCase() !== 'hh:mm') {
1456                                                 if ((min === "" || !(min instanceof Date)) && (max === "" || !(max instanceof Date))) {
1457                                                         retVal = true;
1458                                                 } else if (min === "" && val <= max) {
1459                                                         retVal = true;
1460                                                 } else if (min <= val && "" === max) {
1461                                                         retVal = true;
1462                                                 } else if (min <= val && val <= max) {
1463                                                         retVal = true;
1464                                                 }
1465                                         } else {
1466                                                 min_time = moment(min);
1467                                                 min_time = min_time.minutes() + min_time.hours() * 60;
1468                                                 if (isNaN(min_time)) {
1469                                                         min_time = '';
1470                                                 }
1471                                                 max_time = moment(max);
1472                                                 max_time = max_time.minutes() + max_time.hours() * 60;
1473                                                 if (isNaN(max_time)) {
1474                                                         max_time = '';
1475                                                 }
1476                                                 val = moment(val);
1477                                                 val = val.minutes() + val.hours() * 60;
1478
1479                                                 if ((min === "" || !(moment(min, date_format).isValid())) && (max === "" || !(moment(max, date_format).isValid()))) {
1480                                                         retVal = true;
1481                                                 } else if (min_time === "" && val <= max_time) {
1482                                                         retVal = true;
1483                                                 } else if (min_time <= val && "" === max_time) {
1484                                                         retVal = true;
1485                                                 } else if (min_time <= val && val <= max_time) {
1486                                                         retVal = true;
1487                                                 }
1488                                         }
1489                                         return retVal;
1490                                 }
1491                         );
1492                 }
1493
1494                 function addRangeNumberFilter(filter_selector_string, table_selector_jq_friendly, column_number, filter_reset_button_text, filter_default_label, ignore_char) {
1495                         var fromId = "yadcf-filter-" + table_selector_jq_friendly + "-from-" + column_number,
1496                                 toId = "yadcf-filter-" + table_selector_jq_friendly + "-to-" + column_number,
1497                                 filter_selector_string_tmp,
1498                                 filter_wrapper_id,
1499                                 oTable,
1500                                 columnObj,
1501                                 filterActionStr;
1502
1503                         filter_wrapper_id = "yadcf-filter-wrapper-" + table_selector_jq_friendly + "-" + column_number;
1504
1505                         if ($("#" + filter_wrapper_id).length > 0) {
1506                                 return;
1507                         }
1508                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
1509                         oTable = oTables[table_selector_jq_friendly];
1510                         columnObj = getOptions(oTable.selector)[column_number];
1511
1512                         //add a wrapper to hold both filter and reset button
1513                         $(filter_selector_string).append("<div onmousedown=\"yadcf.stopPropagation(event);\" onclick=\"yadcf.stopPropagation(event);\"  id=\"" + filter_wrapper_id + "\" class=\"yadcf-filter-wrapper " + columnObj.style_class + "\"></div>");
1514                         filter_selector_string += " div.yadcf-filter-wrapper";
1515                         filter_selector_string_tmp = filter_selector_string;
1516
1517                         $(filter_selector_string).append("<div id=\"yadcf-filter-wrapper-inner-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter-wrapper-inner" + " -" + table_selector_jq_friendly + "-" + column_number + "\"></div>");
1518                         filter_selector_string += " div.yadcf-filter-wrapper-inner";
1519
1520                         filterActionStr = 'onkeyup="yadcf.rangeNumberKeyUP(\'' + table_selector_jq_friendly + '\',event);"';
1521                         if (columnObj.externally_triggered === true) {
1522                                 filterActionStr = '';
1523                         }
1524
1525                         $(filter_selector_string).append("<input onkeydown=\"yadcf.preventDefaultForEnter(event);\" placeholder=\"" + filter_default_label[0] + "\" id=\"" + fromId + "\" class=\"yadcf-filter-range-number yadcf-filter-range\" " + filterActionStr + "></input>");
1526                         $(filter_selector_string).append("<span class=\"yadcf-filter-range-number-seperator\" >" +
1527                                 "</span>");
1528                         $(filter_selector_string).append("<input onkeydown=\"yadcf.preventDefaultForEnter(event);\" placeholder=\"" + filter_default_label[1] + "\" id=\"" + toId + "\" class=\"yadcf-filter-range-number yadcf-filter-range\" " + filterActionStr + "></input>");
1529
1530                         if (filter_reset_button_text !== false) {
1531                                 $(filter_selector_string_tmp).append("<button type=\"button\" onmousedown=\"yadcf.stopPropagation(event);\" " +
1532                                         "onclick=\"yadcf.stopPropagation(event);yadcf.rangeClear('" + table_selector_jq_friendly + "',event," + column_number + "); return false;\" class=\"yadcf-filter-reset-button " + columnObj.reset_button_style_class + "\">" + filter_reset_button_text + "</button>");
1533                         }
1534
1535                         if (oTable.fnSettings().oFeatures.bStateSave === true && oTable.fnSettings().oLoadedState) {
1536                                 if (oTable.fnSettings().oLoadedState.yadcfState && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number]) {
1537                                         $('#' + fromId).val(oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from);
1538                                         if (oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from !== "") {
1539                                                 $('#' + fromId).addClass("inuse");
1540                                         }
1541                                         $('#' + toId).val(oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number].to);
1542                                         if (oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number].to !== "") {
1543                                                 $('#' + toId).addClass("inuse");
1544                                         }
1545                                 }
1546                         }
1547                         resetIApiIndex();
1548
1549                         if (oTable.fnSettings().oFeatures.bServerSide !== true) {
1550                                 addRangeNumberAndSliderFilterCapability(table_selector_jq_friendly, fromId, toId, column_number, ignore_char);
1551                         }
1552
1553                 }
1554
1555                 function dateSelectSingle(pDate, pEvent, clear) {
1556                         var oTable,
1557                                 date,
1558                                 event,
1559                                 column_number,
1560                                 dashIndex,
1561                                 table_selector_jq_friendly,
1562                                 column_number_filter,
1563                                 settingsDt,
1564                                 columnObj;
1565
1566                         if (pDate.type === 'dp') {
1567                                 event = pDate.target;
1568                         } else if (pDate.type === 'changeDate') {
1569                                 event = pDate.currentTarget;
1570                         } else {
1571                                 date = pDate;
1572                                 event = pEvent;
1573                         }
1574
1575                         column_number = $(event).attr('id').replace('yadcf-filter-', '').replace('-date', '').replace('-reset', '');
1576                         dashIndex = column_number.lastIndexOf("-");
1577                         table_selector_jq_friendly = column_number.substring(0, dashIndex);
1578
1579                         column_number = column_number.substring(dashIndex + 1);
1580                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
1581                         oTable = oTables[table_selector_jq_friendly];
1582                         settingsDt = getSettingsObjFromTable(oTable);
1583                         columnObj = getOptions(oTable.selector)[column_number];
1584
1585                         if (pDate.type === 'dp') {
1586                                 if (moment($(event).val(), columnObj.date_format).isValid()) {
1587                                         date = $(event).val();
1588                                 } else {
1589                                         clear = 'clear';
1590                                 }
1591                                 $(event).blur();
1592                         } else if (columnObj.datepicker_type === 'bootstrap-datepicker') {
1593                                 if (pDate.dates) {
1594                                         date = pDate.format(0, columnObj.date_format);
1595                                 }
1596                         }
1597
1598                         column_number_filter = calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly);
1599
1600                         if (clear === undefined) {
1601                                 if (columnObj.filter_type !== 'date_custom_func') {
1602                                         oTable.fnFilter(date, column_number_filter);
1603                                 } else {
1604                                         doFilterCustomDateFunc({ value: date }, table_selector_jq_friendly, column_number);
1605                                 }
1606                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).addClass("inuse");
1607                         } else if (clear === 'clear') {
1608                                 if (exGetColumnFilterVal(oTable, column_number) === '') {
1609                                         return;
1610                                 }
1611                                 if (columnObj.filter_type === 'date_custom_func') {
1612                                         //handle state saving
1613                                         if (oTable.fnSettings().oFeatures.bStateSave === true && oTable.fnSettings().oLoadedState) {
1614                                                 if (!oTable.fnSettings().oLoadedState) {
1615                                                         oTable.fnSettings().oLoadedState = {};
1616                                                         oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
1617                                                 }
1618                                                 if (oTable.fnSettings().oFeatures.bStateSave === true) {
1619                                                         if (oTable.fnSettings().oLoadedState.yadcfState !== undefined && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] !== undefined) {
1620                                                                 oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number] =
1621                                                                         {
1622                                                                                 from: ""
1623                                                                         };
1624                                                         } else {
1625                                                                 yadcfState = {};
1626                                                                 yadcfState[table_selector_jq_friendly] = [];
1627                                                                 yadcfState[table_selector_jq_friendly][column_number] = {
1628                                                                         from: ""
1629                                                                 };
1630                                                                 oTable.fnSettings().oLoadedState.yadcfState = yadcfState;
1631                                                         }
1632                                                         oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
1633                                                 }
1634                                         }
1635                                 }
1636                                 oTable.fnFilter('', column_number_filter);
1637                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val('').removeClass("inuse");
1638                                 if (columnObj.datepicker_type === 'bootstrap-datepicker') {
1639                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).datepicker('update');
1640                                 }
1641                         }
1642
1643                         resetIApiIndex();
1644                 }
1645
1646                 function dateSelect(pDate, pEvent) {
1647                         var oTable,
1648                                 column_number,
1649                                 dashIndex,
1650                                 table_selector_jq_friendly,
1651                                 yadcfState,
1652                                 from,
1653                                 to,
1654                                 event,
1655                                 columnObj,
1656                                 column_number_filter,
1657                                 settingsDt;
1658
1659                         if (pDate.type === 'dp') {
1660                                 event = pDate.target;
1661                         } else if (pDate.type === 'changeDate') {
1662                                 event = pDate.currentTarget;
1663                         } else {
1664                                 event = pEvent;
1665                         }
1666
1667                         column_number = $(event).attr("id").replace("yadcf-filter-", "").replace("-from-date", "").replace("-to-date", "");
1668                         dashIndex = column_number.lastIndexOf("-");
1669                         table_selector_jq_friendly = column_number.substring(0, dashIndex);
1670
1671                         column_number = column_number.substring(dashIndex + 1);
1672
1673
1674                         oTable = oTables[table_selector_jq_friendly];
1675                         settingsDt = getSettingsObjFromTable(oTable);
1676                         column_number_filter = calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly);
1677
1678                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
1679
1680                         columnObj = getOptions(oTable.selector)[column_number];
1681
1682                         if (pDate.type === 'dp') {
1683                                 event = pDate.target;
1684                                 if (pDate.date === false || !moment($(event).val(), columnObj.date_format).isValid()) {
1685                                         $(event).removeClass("inuse");
1686                                         $(event).data("DateTimePicker").minDate(false);
1687                                 } else {
1688                                         $(event).addClass("inuse");
1689                                 }
1690                                 $(event).blur();
1691                         } else if (pDate.type === 'changeDate') {
1692                                 if (pDate.date !== undefined) {
1693                                         $(event).addClass("inuse");
1694                                 } else {
1695                                         $(event).removeClass("inuse");
1696                                 }
1697                         } else {
1698                                 $(event).addClass("inuse");
1699                         }
1700
1701                         if ($(event).attr("id").indexOf("-from-") !== -1) {
1702                                 from = document.getElementById($(event).attr("id")).value;
1703                                 to = document.getElementById($(event).attr("id").replace("-from-", "-to-")).value;
1704                         } else {
1705                                 to = document.getElementById($(event).attr("id")).value;
1706                                 from = document.getElementById($(event).attr("id").replace("-to-", "-from-")).value;
1707                         }
1708
1709                         if (oTable.fnSettings().oFeatures.bServerSide !== true) {
1710                                 oTable.fnDraw();
1711                         } else {
1712                                 oTable.fnFilter(from + '-yadcf_delim-' + to, column_number_filter);
1713                         }
1714
1715                         if (!oTable.fnSettings().oLoadedState) {
1716                                 oTable.fnSettings().oLoadedState = {};
1717                                 oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
1718                         }
1719                         if (oTable.fnSettings().oFeatures.bStateSave === true) {
1720                                 if (oTable.fnSettings().oLoadedState.yadcfState !== undefined && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] !== undefined) {
1721                                         oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number] =
1722                                                 {
1723                                                         from: from,
1724                                                         to: to
1725                                                 };
1726                                 } else {
1727                                         yadcfState = {};
1728                                         yadcfState[table_selector_jq_friendly] = [];
1729                                         yadcfState[table_selector_jq_friendly][column_number] = {
1730                                                 from: from,
1731                                                 to: to
1732                                         };
1733                                         oTable.fnSettings().oLoadedState.yadcfState = yadcfState;
1734                                 }
1735                                 oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
1736                         }
1737
1738                         resetIApiIndex();
1739                 }
1740
1741                 function addRangeDateFilter(filter_selector_string, table_selector_jq_friendly, column_number, filter_reset_button_text, filter_default_label, date_format) {
1742                         var fromId = "yadcf-filter-" + table_selector_jq_friendly + "-from-date-" + column_number,
1743                                 toId = "yadcf-filter-" + table_selector_jq_friendly + "-to-date-" + column_number,
1744                                 filter_selector_string_tmp,
1745                                 filter_wrapper_id,
1746                                 oTable,
1747                                 columnObj,
1748                                 datepickerObj = {},
1749                                 filterActionStr,
1750                                 $fromInput,
1751                                 $toInput,
1752                                 innerWrapperAdditionalClass = '';
1753
1754                         filter_wrapper_id = "yadcf-filter-wrapper-" + table_selector_jq_friendly + "-" + column_number;
1755
1756                         if ($("#" + filter_wrapper_id).length > 0) {
1757                                 return;
1758                         }
1759                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
1760                         oTable = oTables[table_selector_jq_friendly];
1761                         columnObj = getOptions(oTable.selector)[column_number];
1762                         if (columnObj.datepicker_type === 'bootstrap-datepicker') {
1763                                 innerWrapperAdditionalClass = 'input-daterange';
1764                         }
1765                         //add a wrapper to hold both filter and reset button
1766                         $(filter_selector_string).append("<div onmousedown=\"yadcf.stopPropagation(event);\" onclick=\"yadcf.stopPropagation(event);\"  id=\"" + filter_wrapper_id + "\" class=\"yadcf-filter-wrapper " + columnObj.style_class + "\"></div>");
1767                         filter_selector_string += " div.yadcf-filter-wrapper";
1768                         filter_selector_string_tmp = filter_selector_string;
1769
1770                         $(filter_selector_string).append("<div id=\"yadcf-filter-wrapper-inner-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter-wrapper-inner " + innerWrapperAdditionalClass + "\"></div>");
1771                         filter_selector_string += " div.yadcf-filter-wrapper-inner";
1772
1773                         filterActionStr = 'onkeyup="yadcf.rangeDateKeyUP(\'' + table_selector_jq_friendly + '\',\'' + date_format + '\',event);"';
1774                         if (columnObj.externally_triggered === true) {
1775                                 filterActionStr = '';
1776                         }
1777
1778                         $(filter_selector_string).append("<input onkeydown=\"yadcf.preventDefaultForEnter(event);\" placeholder=\"" + filter_default_label[0] + "\" id=\"" + fromId + "\" class=\"yadcf-filter-range-date yadcf-filter-range yadcf-filter-range-start\" " + filterActionStr + "></input>");
1779                         $(filter_selector_string).append("<span class=\"yadcf-filter-range-date-seperator\" >" + "</span>");
1780                         $(filter_selector_string).append("<input onkeydown=\"yadcf.preventDefaultForEnter(event);\" placeholder=\"" + filter_default_label[1] + "\" id=\"" + toId + "\" class=\"yadcf-filter-range-date yadcf-filter-range yadcf-filter-range-end\" " + filterActionStr + "></input>");
1781
1782                         $fromInput = $("#" + fromId);
1783                         $toInput = $("#" + toId);
1784
1785                         if (filter_reset_button_text !== false) {
1786                                 $(filter_selector_string_tmp).append("<button type=\"button\" onmousedown=\"yadcf.stopPropagation(event);\" " +
1787                                         "onclick=\"yadcf.stopPropagation(event);yadcf.rangeClear('" + table_selector_jq_friendly + "',event," + column_number + "); return false;\" class=\"yadcf-filter-reset-button " + columnObj.reset_button_style_class + "\">" + filter_reset_button_text + "</button>");
1788                         }
1789
1790                         if (columnObj.datepicker_type === 'jquery-ui') {
1791                                 datepickerObj.dateFormat = date_format;
1792                         } else if (columnObj.datepicker_type === 'bootstrap-datetimepicker') {
1793                                 datepickerObj.format = date_format;
1794                         }
1795
1796                         if (columnObj.externally_triggered !== true) {
1797                                 if (columnObj.datepicker_type === 'jquery-ui') {
1798                                         datepickerObj.onSelect = dateSelect;
1799                                 }
1800                                 // for 'bootstrap-datetimepicker' its implemented below...
1801                         }
1802
1803                         datepickerObj = $.extend({}, datepickerObj, columnObj.filter_plugin_options);
1804
1805                         if (columnObj.datepicker_type === 'jquery-ui') {
1806                                 $fromInput.datepicker($.extend(datepickerObj, {onClose: function (selectedDate) {
1807                                         $toInput.datepicker('option', 'minDate', selectedDate);
1808                                 }  }));
1809                                 $toInput.datepicker($.extend(datepickerObj, {onClose: function (selectedDate) {
1810                                         $fromInput.datepicker('option', 'maxDate', selectedDate);
1811                                 }  }));
1812
1813                         } else if (columnObj.datepicker_type === 'bootstrap-datetimepicker') {
1814                                 datepickerObj.useCurrent = false;
1815                                 $fromInput.datetimepicker(datepickerObj);
1816                                 $toInput.datetimepicker(datepickerObj);
1817                                 if (columnObj.externally_triggered !== true) {
1818                                         $fromInput.add($toInput).on('dp.hide', dateSelect);
1819                                 }
1820                         } else if (columnObj.datepicker_type === 'bootstrap-datepicker') {
1821                                 if (date_format) {
1822                                         $.extend(datepickerObj, { format: date_format });
1823                                 }
1824                                 $fromInput.datepicker(datepickerObj).on('changeDate', function (e) {
1825                                         dateSelect(e);
1826                                         $(this).datepicker('hide');
1827                                 });
1828                                 $toInput.datepicker(datepickerObj).on('changeDate', function (e) {
1829                                         dateSelect(e);
1830                                         $(this).datepicker('hide');
1831                                 });
1832                         }
1833
1834                         if (oTable.fnSettings().oFeatures.bStateSave === true && oTable.fnSettings().oLoadedState) {
1835                                 if (oTable.fnSettings().oLoadedState.yadcfState && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number]) {
1836                                         $('#' + fromId).val(oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from);
1837                                         if (oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from !== "") {
1838                                                 $('#' + fromId).addClass("inuse");
1839                                         }
1840                                         $('#' + toId).val(oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number].to);
1841                                         if (oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number].to !== "") {
1842                                                 $('#' + toId).addClass("inuse");
1843                                         }
1844                                 }
1845                         }
1846
1847                         if (oTable.fnSettings().oFeatures.bServerSide !== true) {
1848                                 addRangeDateFilterCapability(table_selector_jq_friendly, fromId, toId, column_number, date_format);
1849                         }
1850
1851                         resetIApiIndex();
1852                 }
1853
1854                 function addDateFilter(filter_selector_string, table_selector_jq_friendly, column_number, filter_reset_button_text, filter_default_label, date_format) {
1855                         var dateId = "yadcf-filter-" + table_selector_jq_friendly + "-" + column_number,
1856                                 filter_selector_string_tmp,
1857                                 filter_wrapper_id,
1858                                 oTable,
1859                                 columnObj,
1860                                 datepickerObj = {},
1861                                 filterActionStr,
1862                                 settingsDt;
1863
1864                         filter_wrapper_id = "yadcf-filter-wrapper-" + table_selector_jq_friendly + "-" + column_number;
1865
1866                         if ($("#" + filter_wrapper_id).length > 0) {
1867                                 return;
1868                         }
1869                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
1870                         oTable = oTables[table_selector_jq_friendly];
1871                         columnObj = getOptions(oTable.selector)[column_number];
1872
1873                         //add a wrapper to hold both filter and reset button
1874                         $(filter_selector_string).append("<div onmousedown=\"yadcf.stopPropagation(event);\" onclick=\"yadcf.stopPropagation(event);\" id=\"" + filter_wrapper_id + "\" class=\"yadcf-filter-wrapper\"></div>");
1875                         filter_selector_string += " div.yadcf-filter-wrapper";
1876                         filter_selector_string_tmp = filter_selector_string;
1877
1878                         filterActionStr = 'onkeyup="yadcf.dateKeyUP(\'' + table_selector_jq_friendly + '\',\'' + date_format + '\',event);"';
1879                         if (columnObj.externally_triggered === true) {
1880                                 filterActionStr = '';
1881                         }
1882
1883                         $(filter_selector_string).append("<input onkeydown=\"yadcf.preventDefaultForEnter(event);\" placeholder=\"" + filter_default_label + "\" id=\"" + dateId + "\" class=\"yadcf-filter-date\" " + filterActionStr + "></input>");
1884
1885                         if (filter_reset_button_text !== false) {
1886                                 $(filter_selector_string_tmp).append('<button type="button" id="' + dateId + '-reset" ' + 'onmousedown="yadcf.stopPropagation(event);" ' +
1887                                         'onclick="yadcf.stopPropagation(event);yadcf.dateSelectSingle(\'' + table_selector_jq_friendly + '\',yadcf.eventTargetFixUp(event).target, \'clear\'); return false;" class="yadcf-filter-reset-button ' + columnObj.reset_button_style_class + '">' + filter_reset_button_text + '</button>');
1888                         }
1889
1890                         if (columnObj.datepicker_type === 'jquery-ui') {
1891                                 datepickerObj.dateFormat = date_format;
1892                         } else if (columnObj.datepicker_type.indexOf('bootstrap') !== -1) {
1893                                 datepickerObj.format = date_format;
1894                         }
1895
1896                         if (columnObj.externally_triggered !== true) {
1897                                 if (columnObj.datepicker_type === 'jquery-ui') {
1898                                         datepickerObj.onSelect = dateSelectSingle;
1899                                 }
1900                         }
1901
1902                         datepickerObj = $.extend({}, datepickerObj, columnObj.filter_plugin_options);
1903
1904                         if (columnObj.datepicker_type === 'jquery-ui') {
1905                                 $("#" + dateId).datepicker(datepickerObj);
1906                         } else if (columnObj.datepicker_type === 'bootstrap-datetimepicker') {
1907                                 datepickerObj.useCurrent = false;
1908                                 $("#" + dateId).datetimepicker(datepickerObj);
1909                                 if (columnObj.externally_triggered !== true) {
1910                                         if (datepickerObj.format.toLowerCase() !== 'hh:mm') {
1911                                                 $("#" + dateId).on('dp.change', dateSelectSingle);
1912                                         } else {
1913                                                 $("#" + dateId).on('dp.hide', dateSelectSingle);
1914                                         }
1915                                 }
1916                         } else if (columnObj.datepicker_type === 'bootstrap-datepicker') {
1917                                 $("#" + dateId).datepicker(datepickerObj).on('changeDate', function (e) {
1918                                         dateSelectSingle(e);
1919                                         $(this).datepicker('hide');
1920                                 });
1921                         }
1922
1923                         if (oTable.fnSettings().aoPreSearchCols[column_number].sSearch !== '') {
1924                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(oTable.fnSettings().aoPreSearchCols[column_number].sSearch).addClass("inuse");
1925                         }
1926
1927                         if (columnObj.filter_type === 'date_custom_func') {
1928                                 settingsDt = getSettingsObjFromTable(oTable);
1929
1930                                 if (oTable.fnSettings().oFeatures.bStateSave === true && oTable.fnSettings().oLoadedState) {
1931                                         if (oTable.fnSettings().oLoadedState.yadcfState && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number]) {
1932                                                 $('#' + dateId).val(oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from);
1933                                                 if (oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from !== "") {
1934                                                         $('#' + dateId).addClass("inuse");
1935                                                 }
1936                                         }
1937                                 }
1938
1939                                 if (settingsDt.oFeatures.bServerSide !== true) {
1940                                         addCustomFunctionFilterCapability(table_selector_jq_friendly, "yadcf-filter-" + table_selector_jq_friendly + "-" + column_number, column_number);
1941                                 }
1942                         }
1943
1944                         resetIApiIndex();
1945                 }
1946
1947                 function rangeNumberSldierDrawTips(min_tip_val, max_tip_val, min_tip_id, max_tip_id, table_selector_jq_friendly, column_number) {
1948                         var first_handle = $(".yadcf-number-slider-filter-wrapper-inner.-" + table_selector_jq_friendly + "-" + column_number), // + " .ui-slider-handle:first"),
1949                                 last_handle = $(".yadcf-number-slider-filter-wrapper-inner.-" + table_selector_jq_friendly + "-" + column_number), // + " .ui-slider-handle:last"),
1950                                 min_tip_inner,
1951                                 max_tip_inner;
1952
1953                         min_tip_inner = "<div id=\"" + min_tip_id + "\" class=\"yadcf-filter-range-number-slider-min-tip-inner\">" + min_tip_val + "</div>";
1954                         max_tip_inner = "<div id=\"" + max_tip_id + "\" class=\"yadcf-filter-range-number-slider-max-tip-inner\">" + max_tip_val + "</div>";
1955
1956                         if (first_handle.length === 1) {
1957                                 first_handle = $(".yadcf-number-slider-filter-wrapper-inner.-" + table_selector_jq_friendly + "-" + column_number + " .ui-slider-handle:first");
1958                                 $(first_handle).addClass("yadcf-filter-range-number-slider-min-tip").html(min_tip_inner);
1959
1960                                 last_handle = $(".yadcf-number-slider-filter-wrapper-inner.-" + table_selector_jq_friendly + "-" + column_number + " .ui-slider-handle:last");
1961                                 $(last_handle).addClass("yadcf-filter-range-number-slider-max-tip").html(max_tip_inner);
1962                         } else {
1963                                 //migth happen when scrollX is used or when filter row is being duplicated by DT
1964                                 $($(first_handle)[0]).find('.ui-slider-handle:first').addClass("yadcf-filter-range-number-slider-min-tip").html(min_tip_inner);
1965                                 $($(last_handle)[0]).find('.ui-slider-handle:last').addClass("yadcf-filter-range-number-slider-max-tip").html(max_tip_inner);
1966
1967                                 $($(first_handle)[1]).find('.ui-slider-handle:first').addClass("yadcf-filter-range-number-slider-min-tip").html(min_tip_inner);
1968                                 $($(last_handle)[1]).find('.ui-slider-handle:last').addClass("yadcf-filter-range-number-slider-max-tip").html(max_tip_inner);
1969                         }
1970                 }
1971
1972                 function rangeNumberSliderChange(table_selector_jq_friendly, event, ui) {
1973                         var oTable,
1974                                 min_val,
1975                                 max_val,
1976                                 slider_inuse,
1977                                 yadcfState,
1978                                 column_number,
1979                                 columnObj,
1980                                 keyUp,
1981                                 settingsDt,
1982                                 column_number_filter;
1983
1984                         event = eventTargetFixUp(event);
1985                         column_number = $(event.target).attr('id').replace("yadcf-filter-", "").replace(table_selector_jq_friendly, "").replace("-slider-", "");
1986
1987                         oTable = oTables[table_selector_jq_friendly];
1988                         settingsDt = getSettingsObjFromTable(oTable);
1989                         column_number_filter = calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly);
1990
1991                         columnObj = getOptions(oTable.selector)[column_number];
1992
1993                         keyUp = function () {
1994
1995                                 $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
1996
1997                                 if (oTable.fnSettings().oFeatures.bServerSide !== true) {
1998                                         oTable.fnDraw();
1999                                 } else {
2000                                         oTable.fnFilter(ui.values[0] + '-yadcf_delim-' + ui.values[1], column_number_filter);
2001                                 }
2002                                 min_val = +$($(event.target).parent().find(".yadcf-filter-range-number-slider-min-tip-hidden")).text();
2003                                 max_val = +$($(event.target).parent().find(".yadcf-filter-range-number-slider-max-tip-hidden")).text();
2004
2005                                 if (min_val !== ui.values[0]) {
2006                                         $($(event.target).find(".ui-slider-handle")[0]).addClass("inuse");
2007                                         slider_inuse = true;
2008                                 } else {
2009                                         $($(event.target).find(".ui-slider-handle")[0]).removeClass("inuse");
2010                                 }
2011                                 if (max_val !== ui.values[1]) {
2012                                         $($(event.target).find(".ui-slider-handle")[1]).addClass("inuse");
2013                                         slider_inuse = true;
2014                                 } else {
2015                                         $($(event.target).find(".ui-slider-handle")[1]).removeClass("inuse");
2016                                 }
2017
2018                                 if (slider_inuse === true) {
2019                                         $(event.target).find(".ui-slider-range").addClass("inuse");
2020                                 } else {
2021                                         $(event.target).find(".ui-slider-range").removeClass("inuse");
2022                                 }
2023
2024                                 if (!oTable.fnSettings().oLoadedState) {
2025                                         oTable.fnSettings().oLoadedState = {};
2026                                         oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
2027                                 }
2028                                 if (oTable.fnSettings().oFeatures.bStateSave === true) {
2029                                         if (oTable.fnSettings().oLoadedState.yadcfState !== undefined && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] !== undefined) {
2030                                                 oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number] =
2031                                                         {
2032                                                                 from: ui.values[0],
2033                                                                 to: ui.values[1]
2034                                                         };
2035                                         } else {
2036                                                 yadcfState = {};
2037                                                 yadcfState[table_selector_jq_friendly] = [];
2038                                                 yadcfState[table_selector_jq_friendly][column_number] = {
2039                                                         from: ui.values[0],
2040                                                         to: ui.values[1]
2041                                                 };
2042                                                 oTable.fnSettings().oLoadedState.yadcfState = yadcfState;
2043                                         }
2044                                         oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
2045                                 }
2046
2047                                 resetIApiIndex();
2048                         };
2049
2050                         if (columnObj.filter_delay === undefined) {
2051                                 keyUp();
2052                         } else {
2053                                 yadcfDelay(function () {
2054                                         keyUp();
2055                                 }, columnObj.filter_delay);
2056                         }
2057                 }
2058
2059                 function addRangeNumberSliderFilter(filter_selector_string, table_selector_jq_friendly, column_number, filter_reset_button_text, min_val, max_val, ignore_char) {
2060                         var sliderId = "yadcf-filter-" + table_selector_jq_friendly + "-slider-" + column_number,
2061                                 min_tip_id = "yadcf-filter-" + table_selector_jq_friendly + "-min_tip-" + column_number,
2062                                 max_tip_id = "yadcf-filter-" + table_selector_jq_friendly + "-max_tip-" + column_number,
2063                                 filter_selector_string_tmp,
2064                                 filter_wrapper_id,
2065                                 oTable,
2066                                 min_state_val = min_val,
2067                                 max_state_val = max_val,
2068                                 columnObj,
2069                                 slideFunc,
2070                                 changeFunc,
2071                                 sliderObj,
2072                                 sliderMaxMin = {
2073                                         min: min_val,
2074                                         max: max_val
2075                                 },
2076                                 settingsDt,
2077                                 currSliderMin = $("#" + sliderId).slider("option", "min"),
2078                                 currSliderMax = $("#" + sliderId).slider("option", "max"),
2079                                 redrawTable;
2080
2081                         filter_wrapper_id = "yadcf-filter-wrapper-" + table_selector_jq_friendly + "-" + column_number;
2082
2083                         if ($("#" + filter_wrapper_id).length > 0 && (currSliderMin === min_val && currSliderMax === max_val)) {
2084                                 return;
2085                         }
2086
2087                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
2088                         oTable = oTables[table_selector_jq_friendly];
2089                         settingsDt = settingsMap[generateTableSelectorJQFriendly2(oTable)];
2090
2091                         if ($("#" + filter_wrapper_id).length > 0) {
2092                                 $("#" + sliderId).slider("destroy");
2093                                 $("#" + filter_wrapper_id).remove();
2094                                 redrawTable = true;
2095                         }
2096
2097                         columnObj = getOptions(oTable.selector)[column_number];
2098
2099                         if (settingsDt.oFeatures.bStateSave === true && settingsDt.oLoadedState) {
2100                                 if (settingsDt.oLoadedState.yadcfState && settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly] && settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number]) {
2101                                         if (min_val !== settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from) {
2102                                                 min_state_val = settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from;
2103                                         }
2104                                         if (max_val !== settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number].to) {
2105                                                 max_state_val = settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number].to;
2106                                         }
2107                                 }
2108                         }
2109
2110                         if (isFinite(min_val) && isFinite(max_val) && isFinite(min_state_val) && isFinite(max_state_val)) {
2111
2112                                 //add a wrapper to hold both filter and reset button
2113                                 $(filter_selector_string).append("<div onmousedown=\"yadcf.stopPropagation(event);\" onclick=\"yadcf.stopPropagation(event);\"  id=\"" + filter_wrapper_id + "\" class=\"yadcf-filter-wrapper " + columnObj.style_class + "\"></div>");
2114                                 filter_selector_string += " div.yadcf-filter-wrapper";
2115                                 filter_selector_string_tmp = filter_selector_string;
2116
2117                                 $(filter_selector_string).append("<div id=\"yadcf-filter-wrapper-inner-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-number-slider-filter-wrapper-inner" + " -" + table_selector_jq_friendly + "-" + column_number + "\"></div>");
2118                                 filter_selector_string += " div.yadcf-number-slider-filter-wrapper-inner";
2119
2120                                 $(filter_selector_string).append("<div id=\"" + sliderId + "\" class=\"yadcf-filter-range-number-slider\"></div>");
2121                                 filter_selector_string += " #" + sliderId;
2122
2123                                 $(filter_selector_string).append("<span class=\"yadcf-filter-range-number-slider-min-tip-hidden hide\">" + min_val + "</span>");
2124                                 $(filter_selector_string).append("<span class=\"yadcf-filter-range-number-slider-max-tip-hidden hide\">" + max_val + "</span>");
2125
2126                                 if (columnObj.externally_triggered !== true) {
2127                                         slideFunc = function (event, ui) {
2128                                                 rangeNumberSldierDrawTips(ui.values[0], ui.values[1], min_tip_id, max_tip_id, table_selector_jq_friendly, column_number);
2129                                                 rangeNumberSliderChange(table_selector_jq_friendly, event, ui);
2130                                         };
2131                                         changeFunc = function (event, ui) {
2132                                                 rangeNumberSldierDrawTips(ui.values[0], ui.values[1], min_tip_id, max_tip_id, table_selector_jq_friendly, column_number);
2133                                                 if (event.originalEvent || $(event.target).slider("option", "yadcf-reset") === true) {
2134                                                         $(event.target).slider("option", "yadcf-reset", false);
2135                                                         rangeNumberSliderChange(table_selector_jq_friendly, event, ui);
2136                                                 }
2137                                         };
2138                                 } else {
2139                                         slideFunc = function (event, ui) {
2140                                                 rangeNumberSldierDrawTips(ui.values[0], ui.values[1], min_tip_id, max_tip_id, table_selector_jq_friendly, column_number);
2141                                         };
2142                                         changeFunc = function (event, ui) {
2143                                                 rangeNumberSldierDrawTips(ui.values[0], ui.values[1], min_tip_id, max_tip_id, table_selector_jq_friendly, column_number);
2144                                         };
2145                                 }
2146                                 sliderObj = {
2147                                         range: true,
2148                                         min: min_val,
2149                                         max: max_val,
2150                                         values: [min_state_val, max_state_val],
2151                                         create: function (event, ui) {
2152                                                 rangeNumberSldierDrawTips(min_state_val, max_state_val, min_tip_id, max_tip_id, table_selector_jq_friendly, column_number);
2153                                         },
2154                                         slide: slideFunc,
2155                                         change: changeFunc
2156                                 };
2157
2158                                 if (columnObj.filter_plugin_options !== undefined) {
2159                                         $.extend(sliderObj, columnObj.filter_plugin_options);
2160                                 }
2161
2162                                 $("#" + sliderId).slider(sliderObj);
2163
2164                                 if (filter_reset_button_text !== false) {
2165                                         $(filter_selector_string_tmp).append("<button type=\"button\" onmousedown=\"yadcf.stopPropagation(event);\" " +
2166                                                 "onclick=\"yadcf.stopPropagation(event);yadcf.rangeNumberSliderClear('" + table_selector_jq_friendly + "',event); return false;\" class=\"yadcf-filter-reset-button range-number-slider-reset-button " + columnObj.reset_button_style_class + "\">" + filter_reset_button_text + "</button>");
2167                                 }
2168                         }
2169
2170                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
2171                         oTable = oTables[table_selector_jq_friendly];
2172                         if (settingsDt.oFeatures.bStateSave === true && settingsDt.oLoadedState) {
2173                                 if (settingsDt.oLoadedState.yadcfState && settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly] && settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number]) {
2174                                         if (isFinite(min_val) && min_val !== settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from) {
2175                                                 $($(filter_selector_string).find(".ui-slider-handle")[0]).addClass("inuse");
2176                                         }
2177                                         if (isFinite(max_val) && max_val !== settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number].to) {
2178                                                 $($(filter_selector_string).find(".ui-slider-handle")[1]).addClass("inuse");
2179                                         }
2180                                         if ((isFinite(min_val) && isFinite(max_val)) && (min_val !== settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from || max_val !== settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number].to)) {
2181                                                 $($(filter_selector_string).find(".ui-slider-range")).addClass("inuse");
2182                                         }
2183                                 }
2184                         }
2185                         resetIApiIndex();
2186
2187                         if (settingsDt.oFeatures.bServerSide !== true) {
2188                                 addRangeNumberAndSliderFilterCapability(table_selector_jq_friendly, min_tip_id, max_tip_id, column_number, ignore_char, sliderMaxMin);
2189                         }
2190                         if (redrawTable === true) {
2191                                 oTable.fnDraw(false);
2192                         }
2193                 }
2194
2195                 function destroyThirdPartyPlugins(table_arg) {
2196
2197                         var tableOptions,
2198                                 table_selector_jq_friendly,
2199                                 columnObjKey,
2200                                 column_number,
2201                                 optionsObj,
2202                                 fromId,
2203                                 toId;
2204
2205                         //check if the table arg is from new datatables API (capital "D")
2206                         if (table_arg.settings !== undefined) {
2207                                 table_arg = table_arg.settings()[0].oInstance;
2208                         }
2209                         tableOptions = getOptions(table_arg.selector);
2210                         table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendly2(table_arg);
2211
2212                         for (columnObjKey in tableOptions) {
2213                                 if (tableOptions.hasOwnProperty(columnObjKey)) {
2214                                         optionsObj = tableOptions[columnObjKey];
2215                                         column_number = optionsObj.column_number;
2216
2217                                         switch (optionsObj.filter_type) {
2218                                         case 'multi_select':
2219                                         case 'multi_select_custom_func':
2220                                         case 'select':
2221                                         case 'custom_func':
2222                                                 switch (optionsObj.select_type) {
2223                                                 case 'chosen':
2224                                                         $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).chosen('destroy');
2225                                                         break;
2226                                                 case 'select2':
2227                                                         $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).select2('destroy');
2228                                                         break;
2229                                                 case 'custom_select':
2230                                                         if (selectElementCustomDestroyFunc !== undefined) {
2231                                                                 selectElementCustomDestroyFunc($("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number));
2232                                                         }
2233                                                         break;
2234                                                 }
2235                                                 break;
2236                                         case 'auto_complete':
2237                                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).autocomplete("destroy");
2238                                                 break;
2239                                         case 'date':
2240                                                 switch (optionsObj.select_type) {
2241                                                 case 'jquery-ui':
2242                                                         $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).datepicker("destroy");
2243                                                         break;
2244                                                 case 'bootstrap-datetimepicker':
2245                                                         $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).destroy();
2246                                                         break;
2247                                                 }
2248                                                 break;
2249                                         case 'range_date':
2250                                                 fromId = "yadcf-filter-" + table_selector_jq_friendly + "-from-date-" + column_number;
2251                                                 toId = "yadcf-filter-" + table_selector_jq_friendly + "-to-date-" + column_number;
2252                                                 switch (optionsObj.select_type) {
2253                                                 case 'jquery-ui':
2254                                                         $("#" + fromId).datepicker("destroy");
2255                                                         $("#" + toId).datepicker("destroy");
2256                                                         break;
2257                                                 case 'bootstrap-datetimepicker':
2258                                                         $("#" + fromId).destroy();
2259                                                         $("#" + toId).destroy();
2260                                                         break;
2261                                                 }
2262                                                 break;
2263                                         case 'range_number_slider':
2264                                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-slider-" + column_number).slider("destroy");
2265                                                 break;
2266                                         }
2267                                 }
2268                         }
2269                 }
2270
2271                 function removeFilters(oTable) {
2272                         var tableId = getTableId(oTable);
2273                         $('#' + tableId + ' .yadcf-filter-wrapper').remove();
2274                         if (yadcfVersionCheck('1.10')) {
2275                                 $(document).off('draw.dt', oTable.selector);
2276                                 $(document).off('xhr.dt', oTable.selector);
2277                                 $(document).off('column-visibility.dt', oTable.selector);
2278                                 $(document).off('destroy.dt', oTable.selector);
2279                         } else {
2280                                 $(document).off('draw', oTable.selector);
2281                                 $(document).off('destroy', oTable.selector);
2282                         }
2283                         destroyThirdPartyPlugins(oTable);
2284                 }
2285
2286                 /* alphanum.js (C) Brian Huisman
2287                    Based on the Alphanum Algorithm by David Koelle
2288                    The Alphanum Algorithm is discussed at http://www.DaveKoelle.com
2289                 */
2290                 function sortAlphaNum(a, b) {
2291                         function chunkify(t) {
2292                                 var tz = [];
2293                                 var x = 0, y = -1, n = 0, i, j;
2294
2295                                 while (i = (j = t.charAt(x++)).charCodeAt(0)) {
2296                                   var m = (i == 46 || (i >=48 && i <= 57));
2297                                   if (m !== n) {
2298                                         tz[++y] = "";
2299                                         n = m;
2300                                   }
2301                                   tz[y] += j;
2302                                 }
2303                                 return tz;
2304                         }
2305
2306                         if (typeof a === 'object' && typeof a.label === 'string') {
2307                                 a = a.label;
2308                         }
2309                         if (typeof b === 'object' && typeof b.label === 'string') {
2310                                 b = b.label;
2311                         }
2312
2313                         var aa = chunkify(a.toLowerCase());
2314                         var bb = chunkify(b.toLowerCase());
2315
2316                         for (var x = 0; aa[x] && bb[x]; x++) {
2317                                 if (aa[x] !== bb[x]) {
2318                                         var c = Number(aa[x]), d = Number(bb[x]);
2319                                         if (c == aa[x] && d == bb[x]) {
2320                                         return c - d;
2321                                         } else return (aa[x] > bb[x]) ? 1 : -1;
2322                                 }
2323                         }
2324                         return aa.length - bb.length;
2325                 }
2326
2327                 function sortColumnData(column_data, columnObj) {
2328                         if (columnObj.filter_type === "select" || columnObj.filter_type === "auto_complete" || columnObj.filter_type === "multi_select" || columnObj.filter_type === 'multi_select_custom_func' || columnObj.filter_type === "custom_func") {
2329                                 if (columnObj.sort_as === "alpha") {
2330                                         if (columnObj.sort_order === "asc") {
2331                                                 column_data.sort();
2332                                         } else if (columnObj.sort_order === "desc") {
2333                                                 column_data.sort();
2334                                                 column_data.reverse();
2335                                         }
2336                                 } else if (columnObj.sort_as === "num") {
2337                                         if (columnObj.sort_order === "asc") {
2338                                                 column_data.sort(sortNumAsc);
2339                                         } else if (columnObj.sort_order === "desc") {
2340                                                 column_data.sort(sortNumDesc);
2341                                         }
2342                                 } else if (columnObj.sort_as === "alphaNum") {
2343                                         if (columnObj.sort_order === "asc") {
2344                                                 column_data.sort(sortAlphaNum);
2345                                         } else if (columnObj.sort_order === "desc") {
2346                                                 column_data.sort(sortAlphaNum);
2347                                                 column_data.reverse();
2348                                         }
2349                                 } else if (columnObj.sort_as === "custom") {
2350                                         column_data.sort(columnObj.sort_as_custom_func);
2351                                 }
2352                         }
2353                         return column_data;
2354                 }
2355                 function getFilteredRows(table) {
2356                         var dataTmp,
2357                                 data = [],
2358                                 i;
2359                         if (yadcfVersionCheck('1.10')) {
2360                                 dataTmp = table._('tr', { filter: 'applied' });
2361                         } else {
2362                                 dataTmp = table.rows({ filter: 'applied'}).data().toArray();
2363                         }
2364                         for (i = 0; i < dataTmp.length; i++) {
2365                                 data.push({
2366                                         _aData: dataTmp[i]
2367                                 });
2368                         }
2369                         return data;
2370                 }
2371
2372                 function parseTableColumn(pTable, columnObj, table_selector_jq_friendly, pSettings) {
2373                         var col_inner_elements,
2374                                 col_inner_data,
2375                                 col_inner_data_helper,
2376                                 j,
2377                                 k,
2378                                 col_filter_array = {},
2379                                 column_data = [],
2380                                 data,
2381                                 data_length,
2382                                 settingsDt,
2383                                 column_number_filter;
2384
2385                         if (pSettings !== undefined) {
2386                                 settingsDt = pSettings;
2387                         } else {
2388                                 settingsDt = getSettingsObjFromTable(pTable);
2389                         }
2390
2391                         if (columnObj.cumulative_filtering !== true) {
2392                                 data = settingsDt.aoData;
2393                                 data_length = data.length;
2394                         } else {
2395                                 data = getFilteredRows(pTable);
2396                                 data_length = data.length;
2397                         }
2398                         if (columnObj.col_filter_array !== undefined) {
2399                                 col_filter_array = columnObj.col_filter_array;
2400                         }
2401                         column_number_filter = calcColumnNumberFilter(settingsDt, columnObj.column_number, table_selector_jq_friendly);
2402                         if (isNaN(settingsDt.aoColumns[column_number_filter].mData) && typeof settingsDt.aoColumns[column_number_filter].mData !== 'object') {
2403                                 columnObj.column_number_data = settingsDt.aoColumns[column_number_filter].mData;
2404                         }
2405                         if (isNaN(settingsDt.aoColumns[column_number_filter].mRender) && typeof settingsDt.aoColumns[column_number_filter].mRender !== 'object') {
2406                                 columnObj.column_number_render = settingsDt.aoColumns[column_number_filter].mRender;
2407                         }
2408
2409                         for (j = 0; j < data_length; j++) {
2410                                 if (columnObj.column_data_type === "html") {
2411                                         if (columnObj.column_number_data === undefined) {
2412                                                 col_inner_elements = $(data[j]._aData[column_number_filter]);
2413                                         } else {
2414                                                 col_inner_elements = dot2obj(data[j]._aData, columnObj.column_number_data);
2415                                                 col_inner_elements = $(col_inner_elements);
2416                                         }
2417                                         if (col_inner_elements.length > 0) {
2418                                                 for (k = 0; k < col_inner_elements.length; k++) {
2419                                                         col_inner_data = null;
2420                                                         col_inner_data_helper = null;
2421
2422                                                         switch (columnObj.html_data_type) {
2423                                                                 case "text":
2424                                                                         col_inner_data = $(col_inner_elements[k]).text();
2425                                                                         break;
2426                                                                 case "value":
2427                                                                         col_inner_data = $(col_inner_elements[k]).val();
2428                                                                         break;
2429                                                                 case "id":
2430                                                                         col_inner_data = col_inner_elements[k].id;
2431                                                                         break;
2432                                                                 case "selector": {
2433                                                                         const len = $(col_inner_elements[k]).find(columnObj.html_data_selector).length;
2434                                                                         if (len === 1) {
2435                                                                                 col_inner_data = $(col_inner_elements[k]).find(columnObj.html_data_selector).text();
2436                                                                         } else if (len > 1) {
2437                                                                                 col_inner_data_helper = $(col_inner_elements[k]).find(columnObj.html_data_selector);
2438                                                                         }
2439                                                                         break;
2440                                                                 }
2441                                                         }
2442
2443                                                         if (col_inner_data || col_inner_data_helper) {
2444                                                                 if (!col_inner_data_helper) {
2445                                                                         if ($.trim(col_inner_data) !== '' && !(col_filter_array.hasOwnProperty(col_inner_data))) {
2446                                                                                 col_filter_array[col_inner_data] = col_inner_data;
2447                                                                                 column_data.push(col_inner_data);
2448                                                                         }
2449                                                                 } else {
2450                                                                         col_inner_data = col_inner_data_helper;
2451                                                                         col_inner_data_helper.each(function (index) {
2452                                                                                 var elm = $(col_inner_data[index]).text();
2453                                                                                 if ($.trim(elm) !== '' && !(col_filter_array.hasOwnProperty(elm))) {
2454                                                                                         col_filter_array[elm] = elm;
2455                                                                                         column_data.push(elm);
2456                                                                                 }
2457                                                                         });
2458                                                                 }
2459                                                         }
2460                                                 }
2461                                         } else {
2462                                                 if (col_inner_elements.selector) {
2463                                                         col_inner_data = col_inner_elements.selector;
2464                                                 } else {
2465                                                         col_inner_data = data[j]._aData[column_number_filter];
2466                                                 }
2467                                                 if ($.trim(col_inner_data) !== '' && !(col_filter_array.hasOwnProperty(col_inner_data))) {
2468                                                         col_filter_array[col_inner_data] = col_inner_data;
2469                                                         column_data.push(col_inner_data);
2470                                                 }
2471                                         }
2472
2473                                 } else if (columnObj.column_data_type === "text") {
2474                                         if (columnObj.text_data_delimiter !== undefined) {
2475                                                 if (columnObj.column_number_data === undefined) {
2476                                                         col_inner_elements = data[j]._aData[column_number_filter].split(columnObj.text_data_delimiter);
2477                                                 } else {
2478                                                         col_inner_elements = dot2obj(data[j]._aData, columnObj.column_number_data);
2479                                                         col_inner_elements = (col_inner_elements + '').split(columnObj.text_data_delimiter);
2480                                                 }
2481                                                 for (k = 0; k < col_inner_elements.length; k++) {
2482                                                         col_inner_data = col_inner_elements[k];
2483                                                         if ($.trim(col_inner_data) !== '' && !(col_filter_array.hasOwnProperty(col_inner_data))) {
2484                                                                 col_filter_array[col_inner_data] = col_inner_data;
2485                                                                 column_data.push(col_inner_data);
2486                                                         }
2487                                                 }
2488                                         } else {
2489                                                 if (columnObj.column_number_data === undefined) {
2490                                                         col_inner_data = data[j]._aData[column_number_filter];
2491                                                         if (typeof col_inner_data === 'object') {
2492                                                                 if (columnObj.html5_data !== undefined) {
2493                                                                         col_inner_data = col_inner_data['@' + columnObj.html5_data];
2494                                                                 } else if (col_inner_data && col_inner_data.display) {
2495                                                                         col_inner_data = col_inner_data.display;
2496                                                                 } else {
2497                                                                         console.log('Warning: Looks like you have forgot to define the html5_data attribute for the ' + columnObj.column_number + ' column');
2498                                                                         return;
2499                                                                 }
2500                                                         }
2501                                                 } else if (data[j]._aFilterData !== undefined && data[j]._aFilterData !== null) {
2502                                                         col_inner_data = data[j]._aFilterData[column_number_filter];
2503                                                 } else {
2504                                                         col_inner_data = dot2obj(data[j]._aData, columnObj.column_number_data);
2505                                                 }
2506                                                 if ($.trim(col_inner_data) !== '' && !(col_filter_array.hasOwnProperty(col_inner_data))) {
2507                                                         col_filter_array[col_inner_data] = col_inner_data;
2508                                                         column_data.push(col_inner_data);
2509                                                 }
2510                                         }
2511                                 } else if (columnObj.column_data_type === "rendered_html") {
2512                                         col_inner_elements = data[j]._aFilterData[column_number_filter];
2513                                         if (typeof col_inner_elements !== 'string') {
2514                                                 col_inner_elements = $(col_inner_elements);
2515                                                 if (col_inner_elements.length > 0) {
2516                                                         for (k = 0; k < col_inner_elements.length; k++) {
2517                                                                 switch (columnObj.html_data_type) {
2518                                                                 case "text":
2519                                                                         col_inner_data = $(col_inner_elements[k]).text();
2520                                                                         break;
2521                                                                 case "value":
2522                                                                         col_inner_data = $(col_inner_elements[k]).val();
2523                                                                         break;
2524                                                                 case "id":
2525                                                                         col_inner_data = col_inner_elements[k].id;
2526                                                                         break;
2527                                                                 case "selector":
2528                                                                         col_inner_data = $(col_inner_elements[k]).find(columnObj.html_data_selector).text();
2529                                                                         break;
2530                                                                 }
2531                                                         }
2532                                                 } else {
2533                                                         col_inner_data = col_inner_elements.selector;
2534                                                 }
2535                                         } else {
2536                                                 col_inner_data = col_inner_elements;
2537                                         }
2538                                         if ($.trim(col_inner_data) !== '' && !(col_filter_array.hasOwnProperty(col_inner_data))) {
2539                                                 col_filter_array[col_inner_data] = col_inner_data;
2540                                                 column_data.push(col_inner_data);
2541                                         }
2542                                 }
2543                         }
2544                         columnObj.col_filter_array = col_filter_array;
2545                         return column_data;
2546                 }
2547
2548                 function appendFilters(oTable, args, table_selector, pSettings) {
2549                         var $filter_selector,
2550                                 filter_selector_string,
2551                                 data,
2552                                 filter_container_id,
2553                                 column_number_data,
2554                                 column_number,
2555                                 column_position,
2556                                 filter_default_label,
2557                                 filter_reset_button_text,
2558                                 enable_auto_complete,
2559                                 date_format,
2560                                 ignore_char,
2561                                 filter_match_mode,
2562                                 column_data,
2563                                 column_data_temp,
2564                                 options_tmp,
2565                                 ii,
2566                                 table_selector_jq_friendly,
2567                                 min_val,
2568                                 max_val,
2569                                 col_num_visible,
2570                                 col_num_visible_iter,
2571                                 tmpStr,
2572                                 columnObjKey,
2573                                 columnObj,
2574                                 filters_position,
2575                                 unique_th,
2576                                 settingsDt,
2577                                 filterActionStr,
2578                                 custom_func_filter_value_holder,
2579                                 exclude_str;
2580
2581                         if (pSettings === undefined) {
2582                                 settingsDt = getSettingsObjFromTable(oTable);
2583                         } else {
2584                                 settingsDt = pSettings;
2585                         }
2586                         settingsMap[generateTableSelectorJQFriendly2(oTable)] = settingsDt;
2587
2588                         table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendly2(oTable);
2589
2590                         initColReorder2(settingsDt, table_selector_jq_friendly);
2591
2592                         filters_position = $(document).data(table_selector + "_filters_position");
2593                         if (settingsDt.oScroll.sX !== '' || settingsDt.oScroll.sY !== '') {
2594                                 table_selector = '.yadcf-datatables-table-' + table_selector_jq_friendly;
2595                                 if ($(table_selector).length === 0) {
2596                                         scrollXYHandler(oTable, '#' + getTableId(oTable));
2597                                 }
2598                         }
2599                         if (settingsDt.oApi._fnGetUniqueThs !== undefined) {
2600                                 unique_th = settingsDt.oApi._fnGetUniqueThs(settingsDt);
2601                         }
2602                         for (columnObjKey in args) {
2603                                 if (args.hasOwnProperty(columnObjKey)) {
2604                                         columnObj = args[columnObjKey];
2605
2606                                         options_tmp = '';
2607                                         tmpStr = '';
2608                                         data = columnObj.data;
2609                                         column_data = [];
2610                                         column_data_temp = [];
2611                                         filter_container_id = columnObj.filter_container_id;
2612                                         column_number = columnObj.column_number;
2613                                         column_number = +column_number;
2614                                         column_position = column_number;
2615
2616                                         if (plugins[table_selector_jq_friendly] !== undefined && (plugins[table_selector_jq_friendly] !== undefined && plugins[table_selector_jq_friendly].ColReorder !== undefined)) {
2617                                                 column_position = plugins[table_selector_jq_friendly].ColReorder[column_number];
2618                                         }
2619
2620                                         columnObj.column_number = column_number;
2621                                         column_number_data = undefined;
2622                                         if (isNaN(settingsDt.aoColumns[column_position].mData) && typeof settingsDt.aoColumns[column_position].mData !== 'object') {
2623                                                 column_number_data = settingsDt.aoColumns[column_position].mData;
2624                                                 columnObj.column_number_data = column_number_data;
2625                                         }
2626                                         if (isNaN(settingsDt.aoColumns[column_position].mRender) && typeof settingsDt.aoColumns[column_position].mRender !== 'object') {
2627                                                 columnObj.column_number_render = settingsDt.aoColumns[column_position].mRender;
2628                                         }
2629                                         filter_default_label = columnObj.filter_default_label;
2630                                         filter_reset_button_text = columnObj.filter_reset_button_text;
2631                                         enable_auto_complete = columnObj.enable_auto_complete;
2632                                         date_format = columnObj.date_format;
2633                                         if (columnObj.datepicker_type === 'jquery-ui') {
2634                                                 date_format = date_format.replace("yyyy", "yy");
2635                                         }
2636                                         if (columnObj.datepicker_type === 'bootstrap-datetimepicker' && columnObj.filter_plugin_options !== undefined && columnObj.filter_plugin_options.format !== undefined) {
2637                                                 date_format = columnObj.filter_plugin_options.format;
2638                                         }
2639                                         columnObj.date_format = date_format;
2640
2641                                         if (columnObj.ignore_char !== undefined && !(columnObj.ignore_char instanceof RegExp)) {
2642                                                 ignore_char = new RegExp(columnObj.ignore_char, "g");
2643                                                 columnObj.ignore_char = ignore_char;
2644                                         }
2645                                         filter_match_mode = columnObj.filter_match_mode;
2646
2647                                         if (column_number === undefined) {
2648                                                 alert("You must specify column number");
2649                                                 return;
2650                                         }
2651
2652                                         if (enable_auto_complete === true) {
2653                                                 columnObj.filter_type = "auto_complete";
2654                                         }
2655
2656                                         if (filter_default_label === undefined) {
2657                                                 if (columnObj.filter_type === "select" || columnObj.filter_type === 'custom_func') {
2658                                                         filter_default_label = placeholderLang.select;
2659                                                 } else if (columnObj.filter_type === "multi_select" || columnObj.filter_type === 'multi_select_custom_func') {
2660                                                         filter_default_label = placeholderLang.select_multi;
2661                                                 } else if (columnObj.filter_type === "auto_complete" || columnObj.filter_type === "text") {
2662                                                         filter_default_label = placeholderLang.filter;
2663                                                 } else if (columnObj.filter_type === "range_number" || columnObj.filter_type === "range_date") {
2664                                                         filter_default_label = placeholderLang.range;
2665                                                 } else if (columnObj.filter_type === "date" || columnObj.filter_type === 'date_custom_func') {
2666                                                         filter_default_label = placeholderLang.date;
2667                                                 }
2668                                                 columnObj.filter_default_label = filter_default_label;
2669                                         }
2670
2671                                         if (filter_reset_button_text === undefined) {
2672                                                 filter_reset_button_text = "x";
2673                                         }
2674
2675                                         if (data !== undefined) {
2676                                                 for (ii = 0; ii < data.length; ii++) {
2677                                                         column_data.push(data[ii]);
2678                                                 }
2679                                         }
2680                                         if (data === undefined || columnObj.append_data_to_table_data !== undefined) {
2681                                                 columnObj.col_filter_array = undefined;
2682                                                 column_data_temp = parseTableColumn(oTable, columnObj, table_selector_jq_friendly, settingsDt);
2683                                                 if (columnObj.append_data_to_table_data !== 'before') {
2684                                                         column_data = column_data.concat(column_data_temp);
2685                                                 } else {
2686                                                         column_data_temp = sortColumnData(column_data_temp, columnObj);
2687                                                         column_data = column_data.concat(column_data_temp);
2688                                                 }
2689                                         }
2690
2691                                         if (columnObj.append_data_to_table_data === undefined || columnObj.append_data_to_table_data === 'sorted') {
2692                                                 column_data = sortColumnData(column_data, columnObj);
2693                                         }
2694
2695                                         if (columnObj.filter_type === "range_number_slider") {
2696                                                 min_val = findMinInArray(column_data, columnObj);
2697                                                 max_val = findMaxInArray(column_data, columnObj);
2698                                         }
2699
2700                                         if (filter_container_id === undefined && columnObj.filter_container_selector === undefined) {
2701                                                 //Can't show filter inside a column for a hidden one (place it outside using filter_container_id)
2702                                                 if (settingsDt.aoColumns[column_position].bVisible === false) {
2703                                                         //console.log('Yadcf warning: Can\'t show filter inside a column N#' + column_number + ' for a hidden one (place it outside using filter_container_id)');
2704                                                         continue;
2705                                                 }
2706
2707                                                 if (filters_position !== 'thead') {
2708                                                         if (unique_th === undefined) {
2709                                                                 //handle hidden columns
2710                                                                 col_num_visible = column_position;
2711                                                                 for (col_num_visible_iter = 0; col_num_visible_iter < settingsDt.aoColumns.length && col_num_visible_iter < column_position; col_num_visible_iter++) {
2712                                                                         if (settingsDt.aoColumns[col_num_visible_iter].bVisible === false) {
2713                                                                                 col_num_visible--;
2714                                                                         }
2715                                                                 }
2716                                                                 column_position = col_num_visible;
2717                                                                 filter_selector_string = table_selector + ' ' + filters_position + ' th:eq(' + column_position + ')';
2718                                                         } else {
2719                                                                 filter_selector_string = table_selector + ' ' + filters_position + ' th:eq(' + $(unique_th[column_position]).index() + ')';
2720                                                         }
2721                                                 } else {
2722                                                         if (columnObj.filters_tr_index === undefined) {
2723                                                                 filter_selector_string = table_selector + ' ' + filters_position + ' tr:eq(' + $(unique_th[column_position]).parent().index() + ') th:eq(' + $(unique_th[column_position]).index() + ')';
2724                                                         } else {
2725                                                                 filter_selector_string = table_selector + ' ' + filters_position + ' tr:eq(' + columnObj.filters_tr_index + ') th:eq(' + $(unique_th[column_position]).index() + ')';
2726                                                         }
2727                                                 }
2728                                                 $filter_selector = $(filter_selector_string).find(".yadcf-filter");
2729                                                 if (columnObj.select_type === 'select2') {
2730                                                         $filter_selector = $(filter_selector_string).find("select.yadcf-filter");
2731                                                 }
2732                                         } else {
2733                                                 if (filter_container_id !== undefined) {
2734                                                         columnObj.filter_container_selector = "#" + filter_container_id;
2735                                                 }
2736                                                 if ($(columnObj.filter_container_selector).length === 0) {
2737                                                         console.log("ERROR: Filter container could not be found, columnObj.filter_container_selector: " + columnObj.filter_container_selector);
2738                                                         continue;
2739                                                 }
2740                                                 filter_selector_string = columnObj.filter_container_selector;
2741                                                 $filter_selector = $(filter_selector_string).find(".yadcf-filter");
2742                                         }
2743
2744                                         if (columnObj.filter_type === "select" || columnObj.filter_type === 'custom_func' || columnObj.filter_type === "multi_select" || columnObj.filter_type === 'multi_select_custom_func') {
2745                                                 if (columnObj.data_as_is !== true) {
2746                                                         if (columnObj.omit_default_label !== true) {
2747                                                                 if (columnObj.filter_type === "select" || columnObj.filter_type === 'custom_func') {
2748                                                                         options_tmp = "<option value=\"" + "-1" + "\">" + filter_default_label + "</option>";
2749
2750                                                                         if (columnObj.select_type === 'select2' && columnObj.select_type_options.placeholder !== undefined && columnObj.select_type_options.allowClear === true) {
2751                                                                                 options_tmp = "<option value=\"\"></option>";
2752                                                                         }
2753                                                                 } else if (columnObj.filter_type === "multi_select" || columnObj.filter_type === 'multi_select_custom_func') {
2754                                                                         if (columnObj.select_type === undefined) {
2755                                                                                 options_tmp = "<option data-placeholder=\"true\" value=\"" + "-1" + "\">" + filter_default_label + "</option>";
2756                                                                         } else {
2757                                                                                 options_tmp = "";
2758                                                                         }
2759                                                                 }
2760                                                         }
2761
2762                                                         if (columnObj.append_data_to_table_data === undefined) {
2763                                                                 if (typeof column_data[0] === 'object') {
2764                                                                         for (ii = 0; ii < column_data.length; ii++) {
2765                                                                                 options_tmp += "<option value=\"" + (column_data[ii].value + '').replace(/"/g, '&quot;') + "\">" + column_data[ii].label + "</option>";
2766                                                                         }
2767                                                                 } else {
2768                                                                         for (ii = 0; ii < column_data.length; ii++) {
2769                                                                                 options_tmp += "<option value=\"" + (column_data[ii] + '').replace(/"/g, '&quot;') + "\">" + column_data[ii] + "</option>";
2770                                                                         }
2771                                                                 }
2772                                                         } else {
2773                                                                 for (ii = 0; ii < column_data.length; ii++) {
2774                                                                         if (typeof column_data[ii] === 'object') {
2775                                                                                 options_tmp += "<option value=\"" + (column_data[ii].value + '').replace(/"/g, '&quot;') + "\">" + column_data[ii].label + "</option>";
2776                                                                         } else {
2777                                                                                 options_tmp += "<option value=\"" + (column_data[ii] + '').replace(/"/g, '&quot;') + "\">" + column_data[ii] + "</option>";
2778                                                                         }
2779                                                                 }
2780                                                         }
2781                                                 } else {
2782                                                         options_tmp = columnObj.data;
2783                                                 }
2784                                                 column_data = options_tmp;
2785                                         }
2786                                         if ($filter_selector.length === 1) {
2787                                                 if (columnObj.filter_type === "select" || columnObj.filter_type === "multi_select" || columnObj.filter_type === 'custom_func' || columnObj.filter_type === 'multi_select_custom_func') {
2788                                                         if (columnObj.filter_type === 'custom_func' || columnObj.filter_type === 'multi_select_custom_func') {
2789                                                                 custom_func_filter_value_holder = $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val();
2790                                                         }
2791                                                         $filter_selector.empty();
2792                                                         $filter_selector.append(column_data);
2793                                                         if (settingsDt.aoPreSearchCols[column_position].sSearch !== '') {
2794                                                                 tmpStr = settingsDt.aoPreSearchCols[column_position].sSearch;
2795                                                                 if (columnObj.filter_type === "select") {
2796                                                                         tmpStr = yadcfParseMatchFilter(tmpStr, getOptions(oTable.selector)[column_number].filter_match_mode);
2797                                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr).addClass("inuse");
2798                                                                 } else if (columnObj.filter_type === "multi_select") {
2799                                                                         tmpStr = yadcfParseMatchFilterMultiSelect(tmpStr, getOptions(oTable.selector)[column_number].filter_match_mode);
2800                                                                         tmpStr = tmpStr.replace(/\\/g, "");
2801                                                                         tmpStr = tmpStr.split("|");
2802                                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr);
2803                                                                 }
2804                                                         }
2805                                                         if (columnObj.filter_type === 'custom_func' || columnObj.filter_type === 'multi_select_custom_func') {
2806                                                                 tmpStr = custom_func_filter_value_holder;
2807                                                                 if (tmpStr === '-1' || tmpStr === undefined) {
2808                                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr);
2809                                                                 } else {
2810                                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr).addClass("inuse");
2811                                                                 }
2812                                                         }
2813
2814                                                         initializeSelectPlugin(columnObj.select_type, $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number), columnObj.select_type_options);
2815                                                         if (columnObj.cumulative_filtering === true && columnObj.select_type === 'chosen') {
2816                                                                 refreshSelectPlugin(columnObj, $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number));
2817                                                         }
2818                                                 } else if (columnObj.filter_type === "auto_complete") {
2819                                                         $(document).data("yadcf-filter-" + table_selector_jq_friendly + "-" + column_number, column_data);
2820                                                 }
2821                                         } else {
2822                                                 if (filter_container_id === undefined && columnObj.filter_container_selector === undefined) {
2823                                                         if ($(filter_selector_string + " div.DataTables_sort_wrapper").length > 0) {
2824                                                                 $(filter_selector_string + " div.DataTables_sort_wrapper").css("display", "inline-block");
2825                                                         }
2826                                                 } else {
2827                                                         if (filter_container_id !== undefined) {
2828                                                                 columnObj.filter_container_selector = "#" + filter_container_id;
2829                                                         }
2830                                                         if ($("#yadcf-filter-wrapper-" + generateTableSelectorJQFriendlyNew(columnObj.filter_container_selector)).length === 0) {
2831                                                                 $(columnObj.filter_container_selector).append("<div id=\"yadcf-filter-wrapper-" + generateTableSelectorJQFriendlyNew(columnObj.filter_container_selector) + "\"></div>");
2832                                                         }
2833                                                         filter_selector_string = "#yadcf-filter-wrapper-" + generateTableSelectorJQFriendlyNew(columnObj.filter_container_selector);
2834                                                 }
2835
2836                                                 if (columnObj.filter_type === "select" || columnObj.filter_type === 'custom_func') {
2837
2838                                                         //add a wrapper to hold both filter and reset button
2839                                                         $(filter_selector_string).append("<div id=\"yadcf-filter-wrapper-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter-wrapper\"></div>");
2840                                                         filter_selector_string += " div.yadcf-filter-wrapper";
2841
2842                                                         if (columnObj.filter_type === "select") {
2843                                                                 filterActionStr = 'onchange="yadcf.doFilter(this, \'' + table_selector_jq_friendly + '\', ' + column_number + ', \'' + filter_match_mode + '\');"';
2844                                                                 if (columnObj.externally_triggered === true) {
2845                                                                         filterActionStr = '';
2846                                                                 }
2847                                                                 $(filter_selector_string).append("<select id=\"yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter " + columnObj.style_class + "\" " +
2848                                                                         filterActionStr + " onkeydown=\"yadcf.preventDefaultForEnter(event);\" onmousedown=\"yadcf.stopPropagation(event);\" onclick='yadcf.stopPropagation(event);'>" + column_data + "</select>");
2849                                                                 if (filter_reset_button_text !== false) {
2850                                                                         $(filter_selector_string).find(".yadcf-filter").after("<button type=\"button\" " +
2851                                                                                 "id=\"yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "-reset\" onmousedown=\"yadcf.stopPropagation(event);\" onclick=\"yadcf.stopPropagation(event);yadcf.doFilter('clear', '" + table_selector_jq_friendly + "', " + column_number + "); return false;\" class=\"yadcf-filter-reset-button " + columnObj.reset_button_style_class + "\">" + filter_reset_button_text + "</button>");
2852                                                                 }
2853                                                         } else {
2854                                                                 filterActionStr = 'onchange="yadcf.doFilterCustomDateFunc(this, \'' + table_selector_jq_friendly  + '\', ' +  column_number + ');"';
2855                                                                 if (columnObj.externally_triggered === true) {
2856                                                                         filterActionStr = '';
2857                                                                 }
2858                                                                 $(filter_selector_string).append("<select id=\"yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter " + columnObj.style_class + "\" " +
2859                                                                         filterActionStr + " onkeydown=\"yadcf.preventDefaultForEnter(event);\" onmousedown=\"yadcf.stopPropagation(event);\" onclick='yadcf.stopPropagation(event);'>" + column_data + "</select>");
2860                                                                 if (filter_reset_button_text !== false) {
2861                                                                         $(filter_selector_string).find(".yadcf-filter").after("<button type=\"button\" onmousedown=\"yadcf.stopPropagation(event);\" " +
2862                                                                                 "onclick=\"yadcf.stopPropagation(event);yadcf.doFilterCustomDateFunc('clear', '" + table_selector_jq_friendly + "', " + column_number + "); return false;\" class=\"yadcf-filter-reset-button " + columnObj.reset_button_style_class + "\">" + filter_reset_button_text + "</button>");
2863                                                                 }
2864
2865                                                                 if (settingsDt.oFeatures.bStateSave === true && settingsDt.oLoadedState) {
2866                                                                         if (settingsDt.oLoadedState.yadcfState && settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly] && settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number]) {
2867                                                                                 tmpStr = settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from;
2868                                                                                 if (tmpStr === '-1' || tmpStr === undefined) {
2869                                                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr);
2870                                                                                 } else {
2871                                                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr).addClass("inuse");
2872                                                                                 }
2873                                                                         }
2874                                                                 }
2875                                                                 if (settingsDt.oFeatures.bServerSide !== true) {
2876                                                                         addCustomFunctionFilterCapability(table_selector_jq_friendly, "yadcf-filter-" + table_selector_jq_friendly + "-" + column_number, column_number);
2877                                                                 }
2878                                                         }
2879
2880                                                         if (settingsDt.aoPreSearchCols[column_position].sSearch !== '') {
2881                                                                 tmpStr = settingsDt.aoPreSearchCols[column_position].sSearch;
2882                                                                 tmpStr = yadcfParseMatchFilter(tmpStr, getOptions(oTable.selector)[column_number].filter_match_mode);
2883                                                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr).addClass("inuse");
2884                                                         }
2885
2886                                                         if (columnObj.select_type !== undefined) {
2887                                                                 initializeSelectPlugin(columnObj.select_type, $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number), columnObj.select_type_options);
2888                                                                 if (columnObj.cumulative_filtering === true && columnObj.select_type === 'chosen') {
2889                                                                         refreshSelectPlugin(columnObj, $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number));
2890                                                                 }
2891                                                         }
2892                                                 } else if (columnObj.filter_type === "multi_select" || columnObj.filter_type === 'multi_select_custom_func') {
2893
2894                                                         //add a wrapper to hold both filter and reset button
2895                                                         $(filter_selector_string).append("<div id=\"yadcf-filter-wrapper-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter-wrapper\"></div>");
2896                                                         filter_selector_string += " div.yadcf-filter-wrapper";
2897
2898                                                         if (columnObj.filter_type === "multi_select") {
2899                                                                 filterActionStr = 'onchange="yadcf.doFilterMultiSelect(this, \'' + table_selector_jq_friendly + '\', ' + column_number + ', \'' + filter_match_mode + '\');"';
2900                                                                 if (columnObj.externally_triggered === true) {
2901                                                                         filterActionStr = '';
2902                                                                 }
2903                                                                 $(filter_selector_string).append("<select multiple data-placeholder=\"" + filter_default_label + "\" id=\"yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter " + columnObj.style_class + "\" " +
2904                                                                         filterActionStr + " onkeydown=\"yadcf.preventDefaultForEnter(event);\" onmousedown=\"yadcf.stopPropagation(event);\" onclick='yadcf.stopPropagation(event);'>" + column_data + "</select>");
2905
2906                                                                 if (filter_reset_button_text !== false) {
2907                                                                         $(filter_selector_string).find(".yadcf-filter").after("<button type=\"button\" onmousedown=\"yadcf.stopPropagation(event);\" " +
2908                                                                                 "onclick=\"yadcf.stopPropagation(event);yadcf.doFilter('clear', '" + table_selector_jq_friendly + "', " + column_number + "); return false;\" class=\"yadcf-filter-reset-button " + columnObj.reset_button_style_class + "\">" + filter_reset_button_text + "</button>");
2909                                                                 }
2910
2911                                                                 if (settingsDt.aoPreSearchCols[column_position].sSearch !== '') {
2912                                                                         tmpStr = settingsDt.aoPreSearchCols[column_position].sSearch;
2913                                                                         tmpStr = yadcfParseMatchFilterMultiSelect(tmpStr, getOptions(oTable.selector)[column_number].filter_match_mode);
2914                                                                         tmpStr = tmpStr.replace(/\\/g, "");
2915                                                                         tmpStr = tmpStr.split("|");
2916                                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr);
2917                                                                 }
2918                                                         } else {
2919                                                                 filterActionStr = 'onchange="yadcf.doFilterCustomDateFunc(this, \'' + table_selector_jq_friendly + '\', ' + column_number + ');"';
2920                                                                 if (columnObj.externally_triggered === true) {
2921                                                                         filterActionStr = '';
2922                                                                 }
2923                                                                 $(filter_selector_string).append("<select multiple data-placeholder=\"" + filter_default_label + "\" id=\"yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter " + columnObj.style_class + "\" " +
2924                                                                         filterActionStr + " onkeydown=\"yadcf.preventDefaultForEnter(event);\" onmousedown=\"yadcf.stopPropagation(event);\" onclick='yadcf.stopPropagation(event);'>" + column_data + "</select>");
2925
2926                                                                 if (filter_reset_button_text !== false) {
2927                                                                         $(filter_selector_string).find(".yadcf-filter").after("<button type=\"button\" onmousedown=\"yadcf.stopPropagation(event);\" " +
2928                                                                                 "onclick=\"yadcf.stopPropagation(event);yadcf.doFilterCustomDateFunc('clear', '" + table_selector_jq_friendly + "', " + column_number + "); return false;\" class=\"yadcf-filter-reset-button " + columnObj.reset_button_style_class + "\">" + filter_reset_button_text + "</button>");
2929                                                                 }
2930
2931                                                                 if (settingsDt.oFeatures.bStateSave === true && settingsDt.oLoadedState) {
2932                                                                         if (settingsDt.oLoadedState.yadcfState && settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly] && settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number]) {
2933                                                                                 tmpStr = settingsDt.oLoadedState.yadcfState[table_selector_jq_friendly][column_number].from;
2934                                                                                 if (tmpStr === '-1' || tmpStr === undefined) {
2935                                                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr);
2936                                                                                 } else {
2937                                                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr).addClass("inuse");
2938                                                                                 }
2939                                                                         }
2940                                                                 }
2941                                                                 if (settingsDt.oFeatures.bServerSide !== true) {
2942                                                                         addCustomFunctionFilterCapability(table_selector_jq_friendly, "yadcf-filter-" + table_selector_jq_friendly + "-" + column_number, column_number);
2943                                                                 }
2944                                                         }
2945
2946                                                         if (columnObj.filter_container_selector === undefined && columnObj.select_type_options.width === undefined) {
2947                                                                 columnObj.select_type_options = $.extend(columnObj.select_type_options, {width: $(filter_selector_string).closest("th").width() + "px"});
2948                                                         }
2949                                                         if (columnObj.filter_container_selector !== undefined && columnObj.select_type_options.width === undefined) {
2950                                                                 columnObj.select_type_options = $.extend(columnObj.select_type_options, {width: $(filter_selector_string).closest(columnObj.filter_container_selector).width() + "px"});
2951                                                         }
2952
2953                                                         if (columnObj.select_type !== undefined) {
2954                                                                 initializeSelectPlugin(columnObj.select_type, $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number), columnObj.select_type_options);
2955                                                                 if (columnObj.cumulative_filtering === true && columnObj.select_type === 'chosen') {
2956                                                                         refreshSelectPlugin(columnObj, $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number));
2957                                                                 }
2958                                                         }
2959                                                 } else if (columnObj.filter_type === "auto_complete") {
2960
2961                                                         //add a wrapper to hold both filter and reset button
2962                                                         $(filter_selector_string).append("<div id=\"yadcf-filter-wrapper-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter-wrapper\"></div>");
2963                                                         filter_selector_string += " div.yadcf-filter-wrapper";
2964
2965                                                         filterActionStr = 'onkeyup="yadcf.autocompleteKeyUP(\'' + table_selector_jq_friendly + '\',event);"';
2966                                                         if (columnObj.externally_triggered === true) {
2967                                                                 filterActionStr = '';
2968                                                         }
2969                                                         $(filter_selector_string).append("<input onkeydown=\"yadcf.preventDefaultForEnter(event);\" id=\"yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter\" onmousedown=\"yadcf.stopPropagation(event);\" onclick='yadcf.stopPropagation(event);" +
2970                                                         "' placeholder='" + filter_default_label + "'" + " filter_match_mode='" + filter_match_mode + "' " + filterActionStr + "></input>");
2971                                                         $(document).data("yadcf-filter-" + table_selector_jq_friendly + "-" + column_number, column_data);
2972
2973                                                         if (filter_reset_button_text !== false) {
2974                                                                 $(filter_selector_string).find(".yadcf-filter").after("<button type=\"button\" onmousedown=\"yadcf.stopPropagation(event);\" " +
2975                                                                         "onclick=\"yadcf.stopPropagation(event);yadcf.doFilterAutocomplete('clear', '" + table_selector_jq_friendly + "', " + column_number + "); return false;\" class=\"yadcf-filter-reset-button " + columnObj.reset_button_style_class + "\">" + filter_reset_button_text + "</button>");
2976                                                         }
2977                                                 } else if (columnObj.filter_type === "text") {
2978
2979                                                         //add a wrapper to hold both filter and reset button
2980                                                         $(filter_selector_string).append("<div id=\"yadcf-filter-wrapper-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter-wrapper\"></div>");
2981                                                         filter_selector_string += " div.yadcf-filter-wrapper";
2982
2983                                                         filterActionStr = 'onkeyup="yadcf.textKeyUP(event,\'' + table_selector_jq_friendly + '\', ' + column_number + ');"';
2984                                                         if (columnObj.externally_triggered === true) {
2985                                                                 filterActionStr = '';
2986                                                         }
2987
2988                                                         exclude_str = '';
2989                                                         if (columnObj.exclude === true) {
2990                                                                 if (columnObj.externally_triggered !== true) {
2991                                                                         exclude_str = '<span class="yadcf-exclude-wrapper" onmousedown="yadcf.stopPropagation(event);" onclick="yadcf.stopPropagation(event);">' +
2992                                                                                 '<div class="yadcf-label small">' + columnObj.exclude_label + '</div><input type="checkbox" title="' + columnObj.exclude_label + '" onclick="yadcf.stopPropagation(event);yadcf.textKeyUP(event,\'' + table_selector_jq_friendly + '\',' + column_number + ');"></span>';
2993                                                                 } else {
2994                                                                         exclude_str = '<span class="yadcf-exclude-wrapper" onmousedown="yadcf.stopPropagation(event);" onclick="yadcf.stopPropagation(event);">' +
2995                                                                                 '<div class="yadcf-label small">' + columnObj.exclude_label + '</div><input type="checkbox" title="' + columnObj.exclude_label + '" onclick="yadcf.stopPropagation(event);"></span>';
2996                                                                 }
2997                                                         }
2998
2999                                                         $(filter_selector_string).append(exclude_str + "<input type=\"text\" onkeydown=\"yadcf.preventDefaultForEnter(event);\" id=\"yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "\" class=\"yadcf-filter " + columnObj.style_class + "\" onmousedown=\"yadcf.stopPropagation(event);\" onclick='yadcf.stopPropagation(event);" +
3000                                                         "' placeholder='" + filter_default_label + "'" + " filter_match_mode='" + filter_match_mode + "' " + filterActionStr + "></input>");
3001
3002                                                         if (filter_reset_button_text !== false) {
3003                                                                 $(filter_selector_string).find(".yadcf-filter").after("<button type=\"button\" " + " id=\"yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "-reset\" onmousedown=\"yadcf.stopPropagation(event);\" " +
3004                                                                         "onclick=\"yadcf.stopPropagation(event);yadcf.textKeyUP(event,'" + table_selector_jq_friendly + "', '" + column_number + "', 'clear'); return false;\" class=\"yadcf-filter-reset-button " + columnObj.reset_button_style_class + "\">" + filter_reset_button_text + "</button>");
3005                                                         }
3006
3007                                                         if (settingsDt.aoPreSearchCols[column_position].sSearch !== '') {
3008                                                                 tmpStr = settingsDt.aoPreSearchCols[column_position].sSearch;
3009                                                                 if (columnObj.exclude === true) {
3010                                                                         if (tmpStr.indexOf('^((?!') !== -1) {
3011                                                                                 $('#yadcf-filter-wrapper-' + table_selector_jq_friendly + '-' + column_number).find(':checkbox').prop('checked', true);
3012                                                                         }
3013                                                                         tmpStr = tmpStr.substring(5, tmpStr.indexOf(').)'));
3014                                                                 }
3015                                                                 tmpStr = yadcfParseMatchFilter(tmpStr, getOptions(oTable.selector)[column_number].filter_match_mode);
3016                                                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr).addClass("inuse");
3017                                                         }
3018
3019                                                 } else if (columnObj.filter_type === "date" || columnObj.filter_type === 'date_custom_func') {
3020
3021                                                         addDateFilter(filter_selector_string, table_selector_jq_friendly, column_number, filter_reset_button_text, filter_default_label, date_format);
3022
3023                                                 } else if (columnObj.filter_type === "range_number") {
3024
3025                                                         addRangeNumberFilter(filter_selector_string, table_selector_jq_friendly, column_number, filter_reset_button_text, filter_default_label, ignore_char);
3026
3027                                                 } else if (columnObj.filter_type === "range_number_slider") {
3028
3029                                                         addRangeNumberSliderFilter(filter_selector_string, table_selector_jq_friendly, column_number, filter_reset_button_text, min_val, max_val, ignore_char);
3030
3031                                                 } else if (columnObj.filter_type === "range_date") {
3032
3033                                                         addRangeDateFilter(filter_selector_string, table_selector_jq_friendly, column_number, filter_reset_button_text, filter_default_label, date_format);
3034
3035                                                 }
3036                                         }
3037
3038                                         if ($(document).data("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val") !== undefined && $(document).data("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val") !== "-1") {
3039                                                 $(filter_selector_string).find(".yadcf-filter").val($(document).data("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val"));
3040                                         }
3041                                         if (columnObj.filter_type === "auto_complete") {
3042                                                 columnObj.filter_plugin_options = {
3043                                                         source: $(document).data("yadcf-filter-" + table_selector_jq_friendly + "-" + column_number),
3044                                                         select: autocompleteSelect
3045                                                 };
3046                                                 if (columnObj.externally_triggered === true) {
3047                                                         delete columnObj.filter_plugin_options.select;
3048                                                 }
3049                                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).autocomplete(columnObj.filter_plugin_options);
3050                                                 if (settingsDt.aoPreSearchCols[column_position].sSearch !== '') {
3051                                                         tmpStr = settingsDt.aoPreSearchCols[column_position].sSearch;
3052                                                         tmpStr = yadcfParseMatchFilter(tmpStr, getOptions(oTable.selector)[column_number].filter_match_mode);
3053                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(tmpStr).addClass("inuse");
3054                                                 }
3055                                         }
3056                                 }
3057                         }
3058                         if (exFilterColumnQueue.length > 0) {
3059                                 (exFilterColumnQueue.shift())();
3060                         }
3061                 }
3062
3063                 function rangeClear(table_selector_jq_friendly, event, column_number) {
3064                         var oTable = oTables[table_selector_jq_friendly],
3065                                 yadcfState,
3066                                 settingsDt,
3067                                 column_number_filter,
3068                                 currentFilterValues,
3069                                 columnObj,
3070                                 fromId = "yadcf-filter-" + table_selector_jq_friendly + "-from-date-" + column_number,
3071                                 toId = "yadcf-filter-" + table_selector_jq_friendly + "-to-date-" + column_number,
3072                                 $fromInput,
3073                                 $toInput;
3074
3075                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
3076                         event = eventTargetFixUp(event);
3077                         settingsDt = getSettingsObjFromTable(oTable);
3078
3079                         column_number_filter = calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly);
3080
3081                         currentFilterValues = exGetColumnFilterVal(oTable, column_number);
3082                         if (currentFilterValues.from === '' && currentFilterValues.to === '') {
3083                                 return;
3084                         }
3085
3086                         columnObj = getOptions(oTable.selector)[column_number];
3087
3088                         $(event.target).parent().find(".yadcf-filter-range").val("");
3089                         if ($(event.target).parent().find(".yadcf-filter-range-number").length > 0) {
3090                                 $($(event.target).parent().find(".yadcf-filter-range")[0]).focus();
3091                         }
3092
3093                         if (oTable.fnSettings().oFeatures.bServerSide !== true) {
3094                                 saveStateSave(oTable, column_number, table_selector_jq_friendly, '', '');
3095                                 oTable.fnDraw();
3096                         } else {
3097                                 oTable.fnFilter('', column_number_filter);
3098                         }
3099
3100                         if (!oTable.fnSettings().oLoadedState) {
3101                                 oTable.fnSettings().oLoadedState = {};
3102                                 oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
3103                         }
3104                         if (oTable.fnSettings().oFeatures.bStateSave === true) {
3105                                 if (oTable.fnSettings().oLoadedState.yadcfState !== undefined && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] !== undefined) {
3106                                         oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number] =
3107                                                 {
3108                                                         from: '',
3109                                                         to: ''
3110                                                 };
3111                                 } else {
3112                                         yadcfState = {};
3113                                         yadcfState[table_selector_jq_friendly] = [];
3114                                         yadcfState[table_selector_jq_friendly][column_number] = {
3115                                                 from: '',
3116                                                 to: ''
3117                                         };
3118                                         oTable.fnSettings().oLoadedState.yadcfState = yadcfState;
3119                                 }
3120                                 oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
3121                         }
3122                         resetIApiIndex();
3123
3124                         $(event.target).parent().find(".yadcf-filter-range").removeClass("inuse");
3125                         if (columnObj.datepicker_type === 'bootstrap-datepicker') {
3126                                 $fromInput = $("#" + fromId);
3127                                 $toInput = $("#" + toId);
3128                                 $fromInput.datepicker('update');
3129                                 $toInput.datepicker('update');
3130                         }
3131
3132                         return;
3133                 }
3134
3135                 function rangeNumberSliderClear(table_selector_jq_friendly, event) {
3136                         var oTable = oTables[table_selector_jq_friendly],
3137                                 min_val,
3138                                 max_val,
3139                                 currentFilterValues,
3140                                 column_number;
3141
3142                         event = eventTargetFixUp(event);
3143                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
3144
3145                         column_number = parseInt($(event.target).prev().find(".yadcf-filter-range-number-slider").attr("id").replace("yadcf-filter-" + table_selector_jq_friendly + "-slider-", ""), 10);
3146
3147                         min_val = +$($(event.target).parent().find(".yadcf-filter-range-number-slider-min-tip-hidden")).text();
3148                         max_val = +$($(event.target).parent().find(".yadcf-filter-range-number-slider-max-tip-hidden")).text();
3149
3150                         currentFilterValues = exGetColumnFilterVal(oTable, column_number);
3151                         if (+currentFilterValues.from === min_val && +currentFilterValues.to === max_val) {
3152                                 return;
3153                         }
3154
3155                         $(event.target).prev().find(".yadcf-filter-range-number-slider").slider("option", "yadcf-reset", true);
3156                         $(event.target).prev().find(".yadcf-filter-range-number-slider").slider("option", "values", [min_val, max_val]);
3157
3158                         $($(event.target).prev().find(".ui-slider-handle")[0]).attr("tabindex", -1).focus();
3159
3160                         $($(event.target).prev().find(".ui-slider-handle")[0]).removeClass("inuse");
3161                         $($(event.target).prev().find(".ui-slider-handle")[1]).removeClass("inuse");
3162                         $(event.target).prev().find(".ui-slider-range").removeClass("inuse");
3163
3164                         oTable.fnDraw();
3165                         resetIApiIndex();
3166
3167                         return;
3168                 }
3169
3170                 function dateKeyUP(table_selector_jq_friendly, date_format, event) {
3171                         var oTable,
3172                                 date,
3173                                 dateId,
3174                                 column_number,
3175                                 columnObj;
3176
3177                         event = eventTargetFixUp(event);
3178
3179                         dateId = event.target.id;
3180                         date = document.getElementById(dateId).value;
3181
3182                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
3183                         oTable = oTables[table_selector_jq_friendly];
3184                         column_number = parseInt(dateId.replace("yadcf-filter-" + table_selector_jq_friendly + "-", ""), 10);
3185                         columnObj = getOptions(oTable.selector)[column_number];
3186
3187                         try {
3188                                 if (columnObj.datepicker_type === 'jquery-ui') {
3189                                         if (date.length === (date_format.length + 2)) {
3190                                                 date = (date !== "") ? $.datepicker.parseDate(date_format, date) : date;
3191                                         }
3192                                 }
3193                         } catch (err1) {}
3194
3195                         if (date instanceof Date || moment(date, columnObj.date_format).isValid()) {
3196                                 $("#" + dateId).addClass('inuse');
3197                                 if (columnObj.filter_type !== 'date_custom_func') {
3198                                         oTable.fnFilter(document.getElementById(dateId).value, column_number);
3199                                         resetIApiIndex();
3200                                 } else {
3201                                         doFilterCustomDateFunc({ value: date }, table_selector_jq_friendly, column_number);
3202                                 }
3203                         } else if (date === "" || $.trim(event.target.value) === '') {
3204                                 $("#" + dateId).removeClass('inuse');
3205                                 $('#' + event.target.id).removeClass('inuse');
3206                                 oTable.fnFilter('', column_number);
3207                                 resetIApiIndex();
3208                         }
3209                 }
3210
3211                 function rangeDateKeyUP(table_selector_jq_friendly, date_format, event) {
3212                         var oTable,
3213                                 min,
3214                                 max,
3215                                 fromId,
3216                                 toId,
3217                                 column_number,
3218                                 columnObj,
3219                                 keyUp,
3220                                 settingsDt,
3221                                 column_number_filter,
3222                                 dpg,
3223                                 minTmp,
3224                                 maxTmp;
3225
3226                         event = eventTargetFixUp(event);
3227                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
3228
3229                         oTable = oTables[table_selector_jq_friendly];
3230
3231                         column_number = parseInt($(event.target).attr("id").replace('-from-date-', '').replace('-to-date-', '').replace('yadcf-filter-' + table_selector_jq_friendly, ''), 10);
3232                         columnObj = getOptions(oTable.selector)[column_number];
3233                         settingsDt = getSettingsObjFromTable(oTable);
3234                         column_number_filter = calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly);
3235
3236                         if (columnObj.datepicker_type === 'bootstrap-datepicker') {
3237                                 dpg = $.fn.datepicker.DPGlobal;
3238                         }
3239
3240                         keyUp = function () {
3241                                 if (event.target.id.indexOf("-from-") !== -1) {
3242                                         fromId = event.target.id;
3243                                         toId = event.target.id.replace("-from-", "-to-");
3244                                 } else {
3245                                         toId = event.target.id;
3246                                         fromId = event.target.id.replace("-to-", "-from-");
3247                                 }
3248
3249                                 min = document.getElementById(fromId).value;
3250                                 max = document.getElementById(toId).value;
3251
3252                                 if (columnObj.datepicker_type === 'jquery-ui') {
3253                                         try {
3254                                                 if (min.length === (date_format.length + 2)) {
3255                                                         min = (min !== "") ? $.datepicker.parseDate(date_format, min) : min;
3256                                                 }
3257                                         } catch (err) {}
3258                                         try {
3259                                                 if (max.length === (date_format.length + 2)) {
3260                                                         max = (max !== "") ? $.datepicker.parseDate(date_format, max) : max;
3261                                                 }
3262                                         } catch (err) {}
3263                                 } else if (columnObj.datepicker_type === 'bootstrap-datetimepicker') {
3264                                         try {
3265                                                 min = moment(min, columnObj.moment_date_format).toDate();
3266                                                 if (isNaN(min.getTime())) {
3267                                                         min = '';
3268                                                 }
3269                                         } catch (err) {}
3270                                         try {
3271                                                 max = moment(max, columnObj.moment_date_format).toDate();
3272                                                 if (isNaN(max.getTime())) {
3273                                                         max = '';
3274                                                 }
3275                                         } catch (err) {}
3276                                 } else if (columnObj.datepicker_type === 'bootstrap-datepicker') {
3277                                         try {
3278                                                 min = dpg.parseDate(min, dpg.parseFormat(columnObj.date_format));
3279                                                 if (isNaN(min.getTime())) {
3280                                                         min = '';
3281                                                 }
3282                                         } catch (err) {}
3283                                         try {
3284                                                 max = dpg.parseDate(max, dpg.parseFormat(columnObj.date_format));
3285                                                 if (isNaN(max.getTime())) {
3286                                                         max = '';
3287                                                 }
3288                                         } catch (err) {}
3289                                 }
3290
3291                                 if (((max instanceof Date) && (min instanceof Date) && (max >= min)) || !min || !max) {
3292
3293                                         if (oTable.fnSettings().oFeatures.bServerSide !== true) {
3294                                                 minTmp = document.getElementById(fromId).value;
3295                                                 maxTmp = document.getElementById(toId).value;
3296                                                 saveStateSave(oTable, column_number, table_selector_jq_friendly, !min ? '' : minTmp , !max ? '' : maxTmp);
3297                                                 oTable.fnDraw();
3298                                         } else {
3299                                                 oTable.fnFilter(document.getElementById(fromId).value + '-yadcf_delim-' + document.getElementById(toId).value, column_number_filter);
3300                                         }
3301
3302                                         if (min instanceof Date) {
3303                                                 $("#" + fromId).addClass("inuse");
3304                                         } else {
3305                                                 $("#" + fromId).removeClass("inuse");
3306                                         }
3307                                         if (max instanceof Date) {
3308                                                 $("#" + toId).addClass("inuse");
3309                                         } else {
3310                                                 $("#" + toId).removeClass("inuse");
3311                                         }
3312
3313                                         if ($.trim(event.target.value) === "" && $(event.target).hasClass("inuse")) {
3314                                                 $("#" + event.target.id).removeClass("inuse");
3315                                         }
3316
3317                                 }
3318                                 resetIApiIndex();
3319                         };
3320
3321                         if (columnObj.filter_delay === undefined) {
3322                                 keyUp(table_selector_jq_friendly, event);
3323                         } else {
3324                                 yadcfDelay(function () {
3325                                         keyUp(table_selector_jq_friendly, event);
3326                                 }, columnObj.filter_delay);
3327                         }
3328                 }
3329
3330                 function rangeNumberKeyUP(table_selector_jq_friendly, event) {
3331                         var oTable = oTables[table_selector_jq_friendly],
3332                                 min,
3333                                 max,
3334                                 fromId,
3335                                 toId,
3336                                 yadcfState,
3337                                 column_number,
3338                                 columnObj,
3339                                 keyUp,
3340                                 settingsDt,
3341                                 column_number_filter;
3342
3343                         event = eventTargetFixUp(event);
3344                         $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
3345
3346                         column_number = parseInt($(event.target).attr("id").replace('-from-', '').replace('-to-', '').replace('yadcf-filter-' + table_selector_jq_friendly, ''), 10);
3347                         columnObj = getOptions(oTable.selector)[column_number];
3348                         settingsDt = getSettingsObjFromTable(oTable);
3349                         column_number_filter = calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly);
3350
3351                         keyUp = function () {
3352                                 if (event.target.id.indexOf("-from-") !== -1) {
3353                                         fromId = event.target.id;
3354                                         toId = event.target.id.replace("-from-", "-to-");
3355
3356                                         min = document.getElementById(fromId).value;
3357                                         max = document.getElementById(toId).value;
3358                                 } else {
3359                                         toId = event.target.id;
3360                                         fromId = event.target.id.replace("-to-", "-from-");
3361
3362                                         max = document.getElementById(toId).value;
3363                                         min = document.getElementById(fromId).value;
3364                                 }
3365
3366                                 min = (min !== "") ? (+min) : min;
3367                                 max = (max !== "") ? (+max) : max;
3368
3369                                 if ((!isNaN(max) && !isNaN(min) && (max >= min)) || min === "" || max === "") {
3370
3371                                         if (oTable.fnSettings().oFeatures.bServerSide !== true) {
3372                                                 oTable.fnDraw();
3373                                         } else {
3374                                                 oTable.fnFilter(min + '-yadcf_delim-' + max, column_number_filter);
3375                                         }
3376                                         if (document.getElementById(fromId).value !== "") {
3377                                                 $("#" + fromId).addClass("inuse");
3378                                         }
3379                                         if (document.getElementById(toId).value !== "") {
3380                                                 $("#" + toId).addClass("inuse");
3381                                         }
3382
3383                                         if ($.trim(event.target.value) === "" && $(event.target).hasClass("inuse")) {
3384                                                 $("#" + event.target.id).removeClass("inuse");
3385                                         }
3386                                         if (!oTable.fnSettings().oLoadedState) {
3387                                                 oTable.fnSettings().oLoadedState = {};
3388                                                 oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
3389                                         }
3390                                         if (oTable.fnSettings().oFeatures.bStateSave === true) {
3391                                                 if (oTable.fnSettings().oLoadedState.yadcfState !== undefined && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] !== undefined) {
3392                                                         oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number] =
3393                                                                 {
3394                                                                         from: min,
3395                                                                         to: max
3396                                                                 };
3397                                                 } else {
3398                                                         yadcfState = {};
3399                                                         yadcfState[table_selector_jq_friendly] = [];
3400                                                         yadcfState[table_selector_jq_friendly][column_number] = {
3401                                                                 from: min,
3402                                                                 to: max
3403                                                         };
3404                                                         oTable.fnSettings().oLoadedState.yadcfState = yadcfState;
3405                                                 }
3406                                                 oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
3407                                         }
3408                                 }
3409                                 resetIApiIndex();
3410                         };
3411
3412                         if (columnObj.filter_delay === undefined) {
3413                                 keyUp();
3414                         } else {
3415                                 yadcfDelay(function () {
3416                                         keyUp();
3417                                 }, columnObj.filter_delay);
3418                         }
3419                 }
3420
3421                 function doFilterMultiTablesMultiSelect(tablesSelectors, event, column_number_str, clear) {
3422
3423                         var columnsObj = getOptions(tablesSelectors + '_' + column_number_str)[column_number_str],
3424                                 regex = false,
3425                                 smart = true,
3426                                 caseInsen = true,
3427                                 tablesAsOne,
3428                                 tablesArray = oTables[tablesSelectors],
3429                                 selected_values = $(event.target).val(),
3430                                 i;
3431
3432                         event = eventTargetFixUp(event);
3433                         tablesAsOne = new $.fn.dataTable.Api(tablesArray);
3434
3435                         if (clear !== undefined || !selected_values || selected_values.length === 0) {
3436                                 if (clear !== undefined) {
3437                                         $(event.target).parent().find('select').val('-1').focus();
3438                                         $(event.target).parent().find('selectn ').removeClass("inuse");
3439                                 }
3440                                 if (columnsObj.column_number instanceof Array) {
3441                                         tablesAsOne.columns(columnsObj.column_number).search('').draw();
3442                                 } else {
3443                                         tablesAsOne.search('').draw();
3444                                 }
3445
3446                                 refreshSelectPlugin(columnsObj, $('#' + columnsObj.filter_container_id + ' select'), '-1');
3447                                 return;
3448                         }
3449
3450                         $(event.target).addClass("inuse");
3451
3452                         regex = true;
3453                         smart = false;
3454                         caseInsen = columnsObj.case_insensitive;
3455
3456                         if (selected_values !== null) {
3457                                 for (i = selected_values.length - 1; i >= 0; i--) {
3458                                         if (selected_values[i] === "-1") {
3459                                                 selected_values.splice(i, 1);
3460                                                 break;
3461                                         }
3462                                 }
3463                                 if (selected_values.length !== 0) {
3464                                         selected_values = selected_values.join('narutouzomaki');
3465                                         selected_values = selected_values.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
3466                                         selected_values = selected_values.split('narutouzomaki').join('|');
3467                                 }
3468                         }
3469                         if (columnsObj.filter_match_mode === "exact") {
3470                                 selected_values = "^" + selected_values + "$";
3471                         } else if (columnsObj.filter_match_mode === "startsWith") {
3472                                 selected_values = "^" + selected_values;
3473                         }
3474                         if (columnsObj.column_number instanceof Array) {
3475                                 tablesAsOne.columns(columnsObj.column_number).search(selected_values, regex, smart, caseInsen).draw();
3476                         } else {
3477                                 tablesAsOne.search(selected_values, regex, smart, caseInsen).draw();
3478                         }
3479                 }
3480
3481                 function doFilterMultiTables(tablesSelectors, event, column_number_str, clear) {
3482
3483                         var columnsObj = getOptions(tablesSelectors + '_' + column_number_str)[column_number_str],
3484                                 regex = false,
3485                                 smart = true,
3486                                 caseInsen = true,
3487                                 serachVal,
3488                                 tablesAsOne,
3489                                 tablesArray = oTables[tablesSelectors];
3490
3491                         event = eventTargetFixUp(event);
3492                         tablesAsOne = new $.fn.dataTable.Api(tablesArray);
3493
3494                         if (clear !== undefined || event.target.value === '-1') {
3495                                 if (clear !== undefined) {
3496                                         $(event.target).parent().find('select').val('-1').focus();
3497                                         $(event.target).parent().find('select').removeClass("inuse");
3498                                 }
3499                                 if (columnsObj.column_number instanceof Array) {
3500                                         tablesAsOne.columns(columnsObj.column_number).search('').draw();
3501                                 } else {
3502                                         tablesAsOne.search('').draw();
3503                                 }
3504
3505                                 refreshSelectPlugin(columnsObj, $('#' + columnsObj.filter_container_id + ' select'), '-1');
3506
3507                                 return;
3508                         }
3509
3510                         $(event.target).addClass("inuse");
3511
3512                         serachVal = event.target.value;
3513                         smart = false;
3514                         caseInsen = columnsObj.case_insensitive;
3515         /*
3516                         if (columnsObj.filter_match_mode === "contains") {
3517                                 regex = false;
3518                         } else if (columnsObj.filter_match_mode === "exact") {
3519                                 regex = true;
3520                                 serachVal = "^" + serachVal + "$";
3521                         } else if (columnsObj.filter_match_mode === "startsWith") {
3522                                 regex = true;
3523                                 serachVal = "^" + serachVal;
3524                         }*/
3525                         if (columnsObj.column_number instanceof Array) {
3526                                 tablesAsOne.columns(columnsObj.column_number).search(serachVal, regex, smart, caseInsen).draw();
3527                         } else {
3528                                 tablesAsOne.search(serachVal, regex, smart, caseInsen).draw();
3529                         }
3530                 }
3531
3532                 function textKeyUpMultiTables(tablesSelectors, event, column_number_str, clear) {
3533
3534                         var keyUp,
3535                                 columnsObj = getOptions(tablesSelectors + '_' + column_number_str)[column_number_str],
3536                                 regex = false,
3537                                 smart = true,
3538                                 caseInsen = true,
3539                                 serachVal,
3540                                 tablesAsOne,
3541                                 tablesArray = oTables[tablesSelectors];
3542
3543                         event = eventTargetFixUp(event);
3544                         tablesAsOne = new $.fn.dataTable.Api(tablesArray);
3545
3546                         keyUp = function (tablesAsOne, event, clear) {
3547
3548                                 if (clear !== undefined || event.target.value === '') {
3549                                         if (clear !== undefined) {
3550                                                 $(event.target).prev().val("").focus();
3551                                                 $(event.target).prev().removeClass("inuse");
3552                                         } else {
3553                                                 $(event.target).val("").focus();
3554                                                 $(event.target).removeClass("inuse");
3555                                         }
3556                                         if (columnsObj.column_number instanceof Array) {
3557                                                 tablesAsOne.columns(columnsObj.column_number).search('').draw();
3558                                         } else {
3559                                                 tablesAsOne.search('').draw();
3560                                         }
3561                                         return;
3562                                 }
3563
3564                                 $(event.target).addClass("inuse");
3565
3566                                 serachVal = event.target.value;
3567                                 smart = false;
3568                                 caseInsen = columnsObj.case_insensitive;
3569         /*
3570                                 if (columnsObj.filter_match_mode === "contains") {
3571                                         regex = false;
3572                                 } else if (columnsObj.filter_match_mode === "exact") {
3573                                         regex = true;
3574                                         serachVal = "^" + serachVal + "$";
3575                                 } else if (columnsObj.filter_match_mode === "startsWith") {
3576                                         regex = true;
3577                                         serachVal = "^" + serachVal;
3578                                 }
3579         */
3580                                 if (columnsObj.column_number instanceof Array) {
3581                                         tablesAsOne.columns(columnsObj.column_number).search(serachVal, regex, smart, caseInsen).draw();
3582                                 } else {
3583                                         tablesAsOne.search(serachVal, regex, smart, caseInsen).draw();
3584                                 }
3585
3586                         };
3587
3588                         if (columnsObj.filter_delay === undefined) {
3589                                 keyUp(tablesAsOne, event, clear);
3590                         } else {
3591                                 yadcfDelay(function () {
3592                                         keyUp(tablesAsOne, event, clear);
3593                                 }, columnsObj.filter_delay);
3594                         }
3595                 }
3596
3597                 function textKeyUP(ev, table_selector_jq_friendly, column_number, clear) {
3598                         var column_number_filter,
3599                                 oTable = oTables[table_selector_jq_friendly],
3600                                 keyUp,
3601                                 columnObj,
3602                                 settingsDt = getSettingsObjFromTable(oTable),
3603                                 exclude,
3604                                 keyCodes = [37, 38, 39, 40];
3605
3606                         if (keyCodes.indexOf(ev.keyCode) !== -1) {
3607                                 return;
3608                         }
3609                         column_number_filter = calcColumnNumberFilter(settingsDt, column_number, table_selector_jq_friendly);
3610
3611                         columnObj = getOptions(oTable.selector)[column_number];
3612
3613                         keyUp = function (table_selector_jq_friendly, column_number, clear) {
3614                                 var fixedPrefix = '';
3615                                 if (settingsDt._fixedHeader !== undefined && $('.fixedHeader-floating').is(":visible")) {
3616                                         fixedPrefix = '.fixedHeader-floating ';
3617                                 }
3618                                 if (columnObj.filters_position === 'tfoot' && settingsDt.nScrollFoot) {
3619                                         fixedPrefix = '.' + settingsDt.nScrollFoot.className + ' ';
3620                                 }
3621                                 $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
3622
3623                                 if (clear === 'clear' || $(fixedPrefix + "#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).val() === '') {
3624                                         if (clear === 'clear' && exGetColumnFilterVal(oTable, column_number) === '') {
3625                                                 return;
3626                                         }
3627
3628                                         $(fixedPrefix + "#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).val("").focus();
3629                                         $(fixedPrefix + "#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).removeClass("inuse");
3630                                         oTable.fnFilter("", column_number_filter);
3631                                         resetIApiIndex();
3632                                         return;
3633                                 }
3634
3635                                 if (columnObj.exclude === true) {
3636                                         exclude = $(fixedPrefix + "#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).closest('.yadcf-filter-wrapper').find('.yadcf-exclude-wrapper :checkbox').prop('checked');
3637                                 }
3638                                 $(fixedPrefix + "#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).addClass("inuse");
3639
3640                                 yadcfMatchFilter(oTable, $(fixedPrefix + "#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).val(), columnObj.filter_match_mode, column_number_filter, exclude, column_number);
3641
3642                                 resetIApiIndex();
3643                         };
3644
3645                         if (columnObj.filter_delay === undefined) {
3646                                 keyUp(table_selector_jq_friendly, column_number, clear);
3647                         } else {
3648                                 yadcfDelay(function () {
3649                                         keyUp(table_selector_jq_friendly, column_number, clear);
3650                                 }, columnObj.filter_delay);
3651                         }
3652                 }
3653
3654                 function autocompleteKeyUP(table_selector_jq_friendly, event) {
3655                         var oTable,
3656                                 column_number,
3657                                 keyCodes = [37, 38, 39, 40];
3658
3659                         event = eventTargetFixUp(event);
3660
3661                         if (keyCodes.indexOf(event.keyCode) !== -1) {
3662                                 return;
3663                         }
3664
3665                         if (event.target.value === "" && event.keyCode === 8 && $(event.target).hasClass("inuse")) {
3666                                 $.fn.dataTableExt.iApiIndex = oTablesIndex[table_selector_jq_friendly];
3667                                 oTable = oTables[table_selector_jq_friendly];
3668                                 column_number = parseInt($(event.target).attr("id").replace("yadcf-filter-" + table_selector_jq_friendly + "-", ""), 10);
3669
3670                                 $("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number).removeClass("inuse");
3671                                 $(document).removeData("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val");
3672                                 oTable.fnFilter("", column_number);
3673                                 resetIApiIndex();
3674                         }
3675                 }
3676
3677                 function isDOMSource(tableVar) {
3678                         var settingsDt;
3679                         settingsDt = getSettingsObjFromTable(tableVar);
3680                         if (!settingsDt.sAjaxSource && !settingsDt.ajax && settingsDt.oFeatures.bServerSide !== true) {
3681                                 return true;
3682                         }
3683                         return false;
3684                 }
3685
3686                 function scrollXYHandler(oTable, table_selector) {
3687                         var $tmpSelector,
3688                                 filters_position = $(document).data(table_selector + "_filters_position"),
3689                                 table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendly2(oTable);
3690
3691                         if (filters_position === 'thead') {
3692                                 filters_position = '.dataTables_scrollHead';
3693                         } else {
3694                                 filters_position = '.dataTables_scrollFoot';
3695                         }
3696                         if (oTable.fnSettings().oScroll.sX !== '' || oTable.fnSettings().oScroll.sY !== '') {
3697                                 $tmpSelector = $(table_selector).closest('.dataTables_scroll').find(filters_position + ' table');
3698                                 $tmpSelector.addClass('yadcf-datatables-table-' + table_selector_jq_friendly);
3699                         }
3700                 }
3701
3702                 function firstFromObject(obj) {
3703                         var key;
3704                         for (key in obj) {
3705                                 if (obj.hasOwnProperty(key)) {
3706                                         return key;
3707                                 }
3708                         }
3709                 }
3710
3711                 function initAndBindTable(oTable, table_selector, index, pTableDT) {
3712
3713                         var table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendly2(oTable),
3714                                 table_selector_tmp;
3715                         oTables[table_selector_jq_friendly] = oTable;
3716                         tablesDT[table_selector_jq_friendly] = pTableDT;
3717                         oTablesIndex[table_selector_jq_friendly] = index;
3718
3719                         scrollXYHandler(oTable, table_selector);
3720
3721                         if (isDOMSource(oTable)) {
3722                                 table_selector_tmp = table_selector;
3723                                 if (table_selector.indexOf(":eq") !== -1) {
3724                                         table_selector_tmp = table_selector.substring(0, table_selector.lastIndexOf(":eq"));
3725                                 }
3726                                 appendFilters(oTable, getOptions(table_selector_tmp), table_selector);
3727                                 if (getOptions(table_selector_tmp)[firstFromObject(getOptions(table_selector_tmp))].cumulative_filtering === true) {
3728                                         //when filters should be populated only from visible rows (non filtered)
3729                                         $(document).off('search.dt', oTable.selector).on('search.dt', oTable.selector, function (e, settings, json) {
3730                                                 var table_selector_tmp = oTable.selector;
3731                                                 if (table_selector.indexOf(":eq") !== -1) {
3732                                                         table_selector_tmp = table_selector.substring(0, table_selector.lastIndexOf(":eq"));
3733                                                 }
3734                                                 appendFilters(oTable, getOptions(table_selector_tmp), oTable.selector, settings);
3735                                         });
3736                                 }
3737                         } else {
3738                                 appendFilters(oTable, getOptions(table_selector), table_selector);
3739                                 if (yadcfVersionCheck('1.10')) {
3740                                         $(document).off('xhr.dt', oTable.selector).on('xhr.dt', oTable.selector, function (e, settings, json) {
3741                                                 var col_num,
3742                                                         column_number_filter,
3743                                                         table_selector_jq_friendly = generateTableSelectorJQFriendly2(oTable);
3744                                                 if (!json) {
3745                                                         console.log('datatables xhr.dt event came back with null as data (nothing for yadcf to do with it).');
3746                                                         return;
3747                                                 }
3748                                                 if (settings.oSavedState !== null) {
3749                                                         initColReorder2(settings, table_selector_jq_friendly);
3750                                                 }
3751                                                 for (col_num in yadcf.getOptions(settings.oInstance.selector)) {
3752                                                         if (yadcf.getOptions(settings.oInstance.selector).hasOwnProperty(col_num)) {
3753                                                                 if (json['yadcf_data_' + col_num] !== undefined) {
3754                                                                         column_number_filter = col_num;
3755                                                                         if (settings.oSavedState !== null && plugins[table_selector_jq_friendly] !== undefined) {
3756                                                                                 column_number_filter = plugins[table_selector_jq_friendly].ColReorder[col_num];
3757                                                                         }
3758                                                                         yadcf.getOptions(settings.oInstance.selector)[col_num].data = json['yadcf_data_' + column_number_filter];
3759                                                                 }
3760                                                         }
3761                                                 }
3762                                         });
3763                                 }
3764                         }
3765                         //events that affects both DOM and Ajax
3766                         if (yadcfVersionCheck('1.10')) {
3767                                 $(document).off('draw.dt', oTable.selector).on('draw.dt', oTable.selector, function (event, settings) {
3768                                         appendFilters(oTable, yadcf.getOptions(settings.oInstance.selector), settings.oInstance.selector, settings);
3769                                 });
3770                                 $(document).off('column-visibility.dt', oTable.selector).on('column-visibility.dt', oTable.selector, function (e, settings, col_num, state) {
3771                                         var obj = {},
3772                                                 columnsObj = getOptions(settings.oInstance.selector);
3773                                         if (state === true && settings._oFixedColumns === undefined) {
3774                                                 if ((plugins[table_selector_jq_friendly] !== undefined && plugins[table_selector_jq_friendly].ColReorder !== undefined)) {
3775                                                         col_num = plugins[table_selector_jq_friendly].ColReorder[col_num];
3776                                                 } else if (settings.oSavedState && settings.oSavedState.ColReorder !== undefined) {
3777                                                         col_num = settings.oSavedState.ColReorder[col_num];
3778                                                 }
3779                                                 obj[col_num] = yadcf.getOptions(settings.oInstance.selector)[col_num];
3780                                                 if (obj[col_num] !== undefined) {
3781                                                         obj[col_num].column_number = col_num;
3782                                                         if (obj[col_num] !== undefined) {
3783                                                                 appendFilters(oTables[yadcf.generateTableSelectorJQFriendly2(settings)],
3784                                                                         obj,
3785                                                                         settings.oInstance.selector, settings);
3786                                                         }
3787                                                 }
3788                                         } else if (settings._oFixedColumns !== undefined) {
3789                                                 appendFilters(oTables[yadcf.generateTableSelectorJQFriendly2(settings)],
3790                                                         columnsObj,
3791                                                         settings.oInstance.selector, settings);
3792                                         }
3793                                 });
3794                                 $(document).off('column-reorder.dt', oTable.selector).on('column-reorder.dt', oTable.selector, function (e, settings, json) {
3795                                         var table_selector_jq_friendly = generateTableSelectorJQFriendly2(oTable);
3796                                         initColReorderFromEvent(table_selector_jq_friendly);
3797                                 });
3798                                 $(document).off('destroy.dt', oTable.selector).on('destroy.dt', oTable.selector, function (event, ui) {
3799                                         removeFilters(oTable, yadcf.getOptions(ui.oInstance.selector), ui.oInstance.selector);
3800                                 });
3801                         } else {
3802                                 $(document).off('draw', oTable.selector).on('draw', oTable.selector, function (event, settings) {
3803                                         appendFilters(oTable, yadcf.getOptions(settings.oInstance.selector), settings.oInstance.selector, settings);
3804                                 });
3805                                 $(document).off('destroy', oTable.selector).on('destroy', oTable.selector, function (event, ui) {
3806                                         removeFilters(oTable, yadcf.getOptions(ui.oInstance.selector), ui.oInstance.selector);
3807                                 });
3808                         }
3809                         if (oTable.fnSettings().oFeatures.bStateSave === true) {
3810                                 if (yadcfVersionCheck('1.10')) {
3811                                         $(oTable.selector).off('stateSaveParams.dt').on('stateSaveParams.dt', function (e, settings, data) {
3812                                                 if (settings.oLoadedState && settings.oLoadedState.yadcfState !== undefined) {
3813                                                         data.yadcfState = settings.oLoadedState.yadcfState;
3814                                                 } else {
3815                                                         data.naruto = 'kurama';
3816                                                 }
3817                                         });
3818                                 } else {
3819                                         $(oTable.selector).off('stateSaveParams').on('stateSaveParams', function (e, settings, data) {
3820                                                 if (settings.oLoadedState && settings.oLoadedState.yadcfState !== undefined) {
3821                                                         data.yadcfState = settings.oLoadedState.yadcfState;
3822                                                 } else {
3823                                                         data.naruto = 'kurama';
3824                                                 }
3825                                         });
3826                                 }
3827                                 //when using DOM source
3828                                 if (isDOMSource(oTable)) {
3829                                         //we need to make sure that the yadcf state will be saved after page reload
3830                                         oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
3831                                         //redraw the table in order to apply the filters
3832                                         oTable.fnDraw(false);
3833                                 }
3834                         }
3835                 }
3836
3837                 $.fn.yadcf = function (options_arg, params) {
3838
3839                         var tmpParams,
3840                                 i = 0,
3841                                 selector,
3842                                 tableSelector = '#' + this.fnSettings().sTableId;
3843
3844                         //in case that instance.selector will be undefined (jQuery 3)
3845                         if (this.selector === undefined) {
3846                                 this.selector = tableSelector;
3847                         }
3848
3849                         if (params === undefined) {
3850                                 params = {};
3851                         }
3852
3853                         if (typeof params === 'string') {
3854                                 tmpParams = params;
3855                                 params = {};
3856                                 params.filters_position = tmpParams;
3857                         }
3858                         if (params.filters_position === undefined || params.filters_position === 'header') {
3859                                 params.filters_position = 'thead';
3860                         } else {
3861                                 params.filters_position = 'tfoot';
3862                         }
3863                         if (params.language !== undefined) {
3864                                 for (tmpParams in placeholderLang) {
3865                                         if (placeholderLang.hasOwnProperty(tmpParams)) {
3866                                                 if (params.language[tmpParams] !== undefined) {
3867                                                         placeholderLang[tmpParams] = params.language[tmpParams];
3868                                                 }
3869                                         }
3870                                 }
3871                         }
3872                         $(document).data(this.selector + "_filters_position", params.filters_position);
3873
3874                         if ($(this.selector).length === 1) {
3875                                 setOptions(this.selector, options_arg, params);
3876                                 initAndBindTable(this, this.selector, 0);
3877                         } else {
3878                                 for (i; i < $(this.selector).length; i++) {
3879                                         $.fn.dataTableExt.iApiIndex = i;
3880                                         selector = this.selector + ":eq(" + i + ")";
3881                                         setOptions(this.selector, options_arg, params);
3882                                         initAndBindTable(this, selector, i);
3883                                 }
3884                                 $.fn.dataTableExt.iApiIndex = 0;
3885                         }
3886
3887                         if (params !== undefined && params.onInitComplete !== undefined) {
3888                                 params.onInitComplete();
3889                         }
3890                         return this;
3891                 };
3892
3893                 function init(oTable, options_arg, params) {
3894                         var instance = oTable.settings()[0].oInstance,
3895                                 i = 0,
3896                                 selector,
3897                                 tmpParams,
3898                                 tableSelector = '#' + oTable.table().node().id;
3899
3900                         //in case that instance.selector will be undefined (jQuery 3)
3901                         if (!instance.selector) {
3902                                 instance.selector = tableSelector;
3903                         }
3904
3905                         if (params === undefined) {
3906                                 params = {};
3907                         }
3908
3909                         if (typeof params === 'string') {
3910                                 tmpParams = params;
3911                                 params = {};
3912                                 params.filters_position = tmpParams;
3913                         }
3914                         if (params.filters_position === undefined || params.filters_position === 'header') {
3915                                 params.filters_position = 'thead';
3916                         } else {
3917                                 params.filters_position = 'tfoot';
3918                         }
3919                         if (params.language !== undefined) {
3920                                 for (tmpParams in placeholderLang) {
3921                                         if (placeholderLang.hasOwnProperty(tmpParams)) {
3922                                                 if (params.language[tmpParams] !== undefined) {
3923                                                         placeholderLang[tmpParams] = params.language[tmpParams];
3924                                                 }
3925                                         }
3926                                 }
3927                         }
3928                         $(document).data(instance.selector + "_filters_position", params.filters_position);
3929
3930                         if ($(instance.selector).length === 1) {
3931                                 setOptions(instance.selector, options_arg, params);
3932                                 initAndBindTable(instance, instance.selector, 0, oTable);
3933                         } else {
3934                                 for (i; i < $(instance.selector).length; i++) {
3935                                         $.fn.dataTableExt.iApiIndex = i;
3936                                         selector = instance.selector + ":eq(" + i + ")";
3937                                         setOptions(instance.selector, options_arg, params);
3938                                         initAndBindTable(instance, selector, i, oTable);
3939                                 }
3940                                 $.fn.dataTableExt.iApiIndex = 0;
3941                         }
3942
3943                         if (params !== undefined && params.onInitComplete !== undefined) {
3944                                 params.onInitComplete();
3945                         }
3946                 }
3947
3948                 function appendFiltersMultipleTables(tablesArray, tablesSelectors, colObjDummy) {
3949                         var filter_selector_string = "#" + colObjDummy.filter_container_id,
3950                                 table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendlyNew(tablesSelectors),
3951                                 options_tmp,
3952                                 ii,
3953                                 column_number_str = columnsArrayToString(colObjDummy.column_number).column_number_str,
3954                                 tableTmp,
3955                                 tableTmpArr,
3956                                 tableTmpArrIndex,
3957                                 filterOptions = getOptions(tablesSelectors + '_' + column_number_str)[column_number_str],
3958                                 column_number_index,
3959                                 columnsTmpArr,
3960                                 settingsDt,
3961                                 tmpStr,
3962                                 columnForStateSaving;
3963
3964                         //add a wrapper to hold both filter and reset button
3965                         $(filter_selector_string).append("<div id=\"yadcf-filter-wrapper-" + table_selector_jq_friendly + '-' + column_number_str + "\" class=\"yadcf-filter-wrapper\"></div>");
3966                         filter_selector_string += " div.yadcf-filter-wrapper";
3967                         if (column_number_str.indexOf('_') !== -1) {
3968                                 columnForStateSaving = column_number_str.split('_')[0];
3969                         } else {
3970                                 columnForStateSaving = column_number_str;
3971                         }
3972
3973                         switch (filterOptions.filter_type) {
3974                         case 'text':
3975                                 $(filter_selector_string).append("<input type=\"text\" id=\"yadcf-filter-" + table_selector_jq_friendly + '-' + column_number_str + "\" class=\"yadcf-filter\" onmousedown=\"yadcf.stopPropagation(event);\" onclick='yadcf.stopPropagation(event);" +
3976                                 "' placeholder='" + filterOptions.filter_default_label + "'" + " onkeyup=\"yadcf.textKeyUpMultiTables('" + tablesSelectors + "',event,'" + column_number_str + "');\"></input>");
3977                                 if (filterOptions.filter_reset_button_text !== false) {
3978                                         $(filter_selector_string).find(".yadcf-filter").after("<button type=\"button\" " + " id=\"yadcf-filter-" + table_selector_jq_friendly + '-' + column_number_str + "-reset\" onmousedown=\"yadcf.stopPropagation(event);\" " +
3979                                                 "onclick=\"yadcf.stopPropagation(event);yadcf.textKeyUpMultiTables('" + tablesSelectors + "', event,'" + column_number_str + "','clear'); return false;\" class=\"yadcf-filter-reset-button " + filterOptions.reset_button_style_class + "\">" + filterOptions.filter_reset_button_text + "</button>");
3980                                 }
3981                                 if (tablesArray[0].table !== undefined) {
3982                                         tableTmp = $('#' + tablesArray[0].table().node().id).dataTable();
3983                                 } else {
3984                                         tableTmp = tablesArray[0];
3985                                 }
3986                                 settingsDt = getSettingsObjFromTable(tableTmp);
3987                                 if (settingsDt.aoPreSearchCols[columnForStateSaving].sSearch !== '') {
3988                                         tmpStr = settingsDt.aoPreSearchCols[columnForStateSaving].sSearch;
3989                                         tmpStr = yadcfParseMatchFilter(tmpStr, filterOptions.filter_match_mode);
3990                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number_str).val(tmpStr).addClass("inuse");
3991                                 }
3992                                 break;
3993                         case 'select':
3994                         case 'multi_select':
3995                                 if (filterOptions.select_type === undefined) {
3996                                         options_tmp = "<option data-placeholder=\"true\" value=\"" + "-1" + "\">" + filterOptions.filter_default_label + "</option>";
3997                                 } else {
3998                                         options_tmp = "";
3999                                 }
4000                                 if (filterOptions.select_type === 'select2' && filterOptions.select_type_options.placeholder !== undefined && filterOptions.select_type_options.allowClear === true) {
4001                                         options_tmp = "<option value=\"\"></option>";
4002                                 }
4003                                 if (filterOptions.data === undefined) {
4004                                         filterOptions.data = [];
4005                                         tableTmpArr = tablesSelectors.split(',');
4006                                         for (tableTmpArrIndex = 0; tableTmpArrIndex < tableTmpArr.length; tableTmpArrIndex++) {
4007                                                 if (tablesArray[tableTmpArrIndex].table !== undefined) {
4008                                                         tableTmp = $('#' + tablesArray[tableTmpArrIndex].table().node().id).dataTable();
4009                                                 } else {
4010                                                         tableTmp = tablesArray[tableTmpArrIndex];
4011                                                 }
4012                                                 if (isDOMSource(tableTmp)) {
4013                                                         //check if ajax source, if so, listen for dt.draw
4014                                                         columnsTmpArr = filterOptions.column_number;
4015                                                         for (column_number_index = 0; column_number_index < columnsTmpArr.length; column_number_index++) {
4016                                                                 filterOptions.column_number = columnsTmpArr[column_number_index];
4017                                                                 filterOptions.data = filterOptions.data.concat(parseTableColumn(tableTmp, filterOptions, table_selector_jq_friendly));
4018                                                         }
4019                                                         filterOptions.column_number = columnsTmpArr;
4020                                                 } else {
4021                                                         $(document).off('draw.dt', '#' + tablesArray[tableTmpArrIndex].table().node().id).on('draw.dt', '#' + tablesArray[tableTmpArrIndex].table().node().id, function (event, ui) {
4022                                                                 var options_tmp = '',
4023                                                                         ii;
4024                                                                 columnsTmpArr = filterOptions.column_number;
4025                                                                 for (column_number_index = 0; column_number_index < columnsTmpArr.length; column_number_index++) {
4026                                                                         filterOptions.column_number = columnsTmpArr[column_number_index];
4027                                                                         filterOptions.data = filterOptions.data.concat(parseTableColumn(tableTmp, filterOptions, table_selector_jq_friendly, ui));
4028                                                                 }
4029                                                                 filterOptions.column_number = columnsTmpArr;
4030                                                                 filterOptions.data = sortColumnData(filterOptions.data, filterOptions);
4031                                                                 for (ii = 0; ii < filterOptions.data.length; ii++) {
4032                                                                         options_tmp += "<option value=\"" + filterOptions.data[ii] + "\">" + filterOptions.data[ii] + "</option>";
4033                                                                 }
4034                                                                 $('#' + filterOptions.filter_container_id + ' select').empty().append(options_tmp);
4035
4036                                                                 if (filterOptions.select_type !== undefined) {
4037                                                                         initializeSelectPlugin(filterOptions.select_type, $('#' + filterOptions.filter_container_id + ' select'), filterOptions.select_type_options);
4038                                                                         if (filterOptions.cumulative_filtering === true && filterOptions.select_type === 'chosen') {
4039                                                                                 refreshSelectPlugin(filterOptions, $('#' + filterOptions.filter_container_id + ' select'));
4040                                                                         }
4041                                                                 }
4042                                                         });
4043                                                 }
4044                                         }
4045                                 }
4046
4047                                 filterOptions.data = sortColumnData(filterOptions.data, filterOptions);
4048
4049                                 if (tablesArray[0].table !== undefined) {
4050                                         tableTmp = $('#' + tablesArray[0].table().node().id).dataTable();
4051                                 } else {
4052                                         tableTmp = tablesArray[0];
4053                                 }
4054                                 settingsDt = getSettingsObjFromTable(tableTmp);
4055
4056                                 if (typeof filterOptions.data[0] === 'object') {
4057                                         for (ii = 0; ii < filterOptions.data.length; ii++) {
4058                                                 options_tmp += "<option value=\"" + filterOptions.data[ii].value + "\">" + filterOptions.data[ii].label + "</option>";
4059                                         }
4060                                 } else {
4061                                         for (ii = 0; ii < filterOptions.data.length; ii++) {
4062                                                 options_tmp += "<option value=\"" + filterOptions.data[ii] + "\">" + filterOptions.data[ii] + "</option>";
4063                                         }
4064                                 }
4065                                 if (filterOptions.filter_type === 'select') {
4066                                         $(filter_selector_string).append("<select id=\"yadcf-filter-" + table_selector_jq_friendly + '-' + column_number_str + "\" class=\"yadcf-filter\" " +
4067                                                 "onchange=\"yadcf.doFilterMultiTables('" + tablesSelectors + "',event,'" + column_number_str + "')\" onmousedown=\"yadcf.stopPropagation(event);\" onclick='yadcf.stopPropagation(event);'>" + options_tmp + "</select>");
4068                                         if (settingsDt.aoPreSearchCols[columnForStateSaving].sSearch !== '') {
4069                                                 tmpStr = settingsDt.aoPreSearchCols[columnForStateSaving].sSearch;
4070                                                 tmpStr = yadcfParseMatchFilter(tmpStr, filterOptions.filter_match_mode);
4071                                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number_str).val(tmpStr).addClass("inuse");
4072                                         }
4073                                 } else if (filterOptions.filter_type === 'multi_select') {
4074                                         $(filter_selector_string).append("<select multiple data-placeholder=\"" + filterOptions.filter_default_label + "\" id=\"yadcf-filter-" + table_selector_jq_friendly + '-' + column_number_str + "\" class=\"yadcf-filter\" " +
4075                                                 "onchange=\"yadcf.doFilterMultiTablesMultiSelect('" + tablesSelectors + "',event,'" + column_number_str + "')\" onmousedown=\"yadcf.stopPropagation(event);\" onclick='yadcf.stopPropagation(event);'>" + options_tmp + "</select>");
4076                                         if (settingsDt.aoPreSearchCols[columnForStateSaving].sSearch !== '') {
4077                                                 tmpStr = settingsDt.aoPreSearchCols[columnForStateSaving].sSearch;
4078                                                 tmpStr = yadcfParseMatchFilterMultiSelect(tmpStr, filterOptions.filter_match_mode);
4079                                                 tmpStr = tmpStr.replace(/\\/g, "");
4080                                                 tmpStr = tmpStr.split("|");
4081                                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number_str).val(tmpStr);
4082                                         }
4083                                 }
4084                                 if (filterOptions.filter_type === 'select') {
4085                                         if (filterOptions.filter_reset_button_text !== false) {
4086                                                 $(filter_selector_string).find(".yadcf-filter").after("<button type=\"button\" " + " id=\"yadcf-filter-" + table_selector_jq_friendly  + '-' + column_number_str + "-reset\" onmousedown=\"yadcf.stopPropagation(event);\" " +
4087                                                         "onclick=\"yadcf.stopPropagation(event);yadcf.doFilterMultiTables('" + tablesSelectors + "', event,'" + column_number_str + "','clear'); return false;\" class=\"yadcf-filter-reset-button " + filterOptions.reset_button_style_class + "\">" + filterOptions.filter_reset_button_text + "</button>");
4088                                         }
4089                                 } else if (filterOptions.filter_type === 'multi_select') {
4090                                         if (filterOptions.filter_reset_button_text !== false) {
4091                                                 $(filter_selector_string).find(".yadcf-filter").after("<button type=\"button\" " + " id=\"yadcf-filter-" + table_selector_jq_friendly + '-' + column_number_str + "-reset\" onmousedown=\"yadcf.stopPropagation(event);\" " +
4092                                                         "onclick=\"yadcf.stopPropagation(event);yadcf.doFilterMultiTablesMultiSelect('" + tablesSelectors + "', event,'" + column_number_str + "','clear'); return false;\" class=\"yadcf-filter-reset-button " + filterOptions.reset_button_style_class + "\">" + filterOptions.filter_reset_button_text + "</button>");
4093                                         }
4094                                 }
4095
4096                                 if (filterOptions.select_type !== undefined) {
4097                                         initializeSelectPlugin(filterOptions.select_type, $("#yadcf-filter-" + table_selector_jq_friendly + '-' + column_number_str), filterOptions.select_type_options);
4098                                         if (filterOptions.cumulative_filtering === true && filterOptions.select_type === 'chosen') {
4099                                                 refreshSelectPlugin(filterOptions, $("#yadcf-filter-" + table_selector_jq_friendly + '-' + column_number_str));
4100                                         }
4101                                 }
4102                                 break;
4103                         default:
4104                                 alert('Filters Multiple Tables does not support ' + filterOptions.filter_type);
4105                         }
4106                 }
4107
4108                 function initMultipleTables(tablesArray, filtersOptions) {
4109                         var i,
4110                                 tablesSelectors = '',
4111                                 default_options = {
4112                                         filter_type: "text",
4113                                         filter_container_id: '',
4114                                         filter_reset_button_text: 'x',
4115                                         case_insensitive: true
4116                                 },
4117                                 columnsObjKey,
4118                                 columnsObj,
4119                                 columnsArrIndex,
4120                                 column_number_str,
4121                                 dummyArr;
4122
4123                         for (columnsArrIndex = 0; columnsArrIndex < filtersOptions.length; columnsArrIndex++) {
4124                                 dummyArr = [];
4125                                 columnsObj = filtersOptions[columnsArrIndex];
4126                                 if (columnsObj.filter_default_label === undefined) {
4127                                         if (columnsObj.filter_type === "select" || columnsObj.filter_type === 'custom_func') {
4128                                                 columnsObj.filter_default_label = "Select value";
4129                                         } else if (columnsObj.filter_type === "multi_select" || columnsObj.filter_type === 'multi_select_custom_func') {
4130                                                 columnsObj.filter_default_label = "Select values";
4131                                         } else if (columnsObj.filter_type === "auto_complete" || columnsObj.filter_type === "text") {
4132                                                 columnsObj.filter_default_label = 'Type to filter';
4133                                         } else if (columnsObj.filter_type === "range_number" || columnsObj.filter_type === "range_date") {
4134                                                 columnsObj.filter_default_label = ["from", "to"];
4135                                         } else if (columnsObj.filter_type === "date") {
4136                                                 columnsObj.filter_default_label = "Select a date";
4137                                         }
4138                                 }
4139                                 columnsObj = $.extend({}, default_options, columnsObj);
4140
4141                                 column_number_str = columnsArrayToString(columnsObj.column_number).column_number_str;
4142                                 columnsObj.column_number_str = column_number_str;
4143
4144                                 dummyArr.push(columnsObj);
4145                                 tablesSelectors = '';
4146                                 for (i = 0; i < tablesArray.length; i++) {
4147                                         if (tablesArray[i].table !== undefined) {
4148                                                 tablesSelectors += tablesArray[i].table().node().id + ',';
4149                                         } else {
4150                                                 tablesSelectors += getSettingsObjFromTable(tablesArray[i]).sTableId;
4151                                         }
4152                                 }
4153                                 tablesSelectors = tablesSelectors.substring(0, tablesSelectors.length - 1);
4154
4155                                 setOptions(tablesSelectors + '_' + column_number_str, dummyArr);
4156                                 oTables[tablesSelectors] = tablesArray;
4157                                 appendFiltersMultipleTables(tablesArray, tablesSelectors, columnsObj);
4158                         }
4159                 }
4160
4161                 function initMultipleColumns(table, filtersOptions) {
4162                         var tablesArray = [];
4163                         tablesArray.push(table);
4164                         initMultipleTables(tablesArray, filtersOptions);
4165                 }
4166
4167                 function close3rdPPluginsNeededClose(evt) {
4168                         if (closeBootstrapDatepickerRange) {
4169                                 $('.yadcf-filter-range-date').not($(evt.target)).datepicker('hide');
4170                         }
4171                         if (closeBootstrapDatepicker) {
4172                                 $('.yadcf-filter-date').not($(evt.target)).datepicker('hide');
4173                         }
4174                         if (closeSelect2) {
4175                                 let currentSelect2;
4176                                 if (evt.target.className.indexOf('yadcf-filter-reset-button') !== -1) {
4177                                         $('select.yadcf-filter').select2('close');
4178                                 } else {
4179                                         currentSelect2 = $($(evt.target).closest('.yadcf-filter-wrapper').find('select'));
4180                                         $('select.yadcf-filter').not(currentSelect2).select2('close');
4181                                 }
4182                         }
4183                 }
4184
4185                 function stopPropagation(evt) {
4186                         close3rdPPluginsNeededClose(evt);
4187                         if (evt.stopPropagation !== undefined) {
4188                                 evt.stopPropagation();
4189                         } else {
4190                                 evt.cancelBubble = true;
4191                         }
4192                 }
4193
4194                 function preventDefaultForEnter(evt) {
4195                         if (evt.keyCode === 13) {
4196                                 if (evt.preventDefault) {
4197                                         evt.preventDefault();
4198                                 } else {
4199                                         evt.returnValue = false;
4200                                 }
4201                         }
4202                 }
4203
4204                 //--------------------------------------------------------
4205                 function exInternalFilterColumnAJAXQueue(table_arg, col_filter_arr) {
4206                         return function () {
4207                                 exFilterColumn(table_arg, col_filter_arr, true);
4208                         };
4209                 }
4210
4211                 function exFilterColumn(table_arg, col_filter_arr, ajaxSource) {
4212                         var table_selector_jq_friendly,
4213                                 j,
4214                                 tmpStr,
4215                                 column_number,
4216                                 column_position,
4217                                 filter_value,
4218                                 fromId,
4219                                 toId,
4220                                 sliderId,
4221                                 optionsObj,
4222                                 min,
4223                                 max,
4224                                 exclude = false;
4225                         //check if the table arg is from new datatables API (capital "D")
4226                         if (table_arg.settings !== undefined) {
4227                                 table_arg = table_arg.settings()[0].oInstance;
4228                         }
4229                         table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendly2(table_arg);
4230                         if (isDOMSource(table_arg) || ajaxSource === true) {
4231                                 for (j = 0; j < col_filter_arr.length; j++) {
4232                                         column_number = col_filter_arr[j][0];
4233                                         column_position = column_number;
4234                                         exclude = false;
4235                                         if (plugins[table_selector_jq_friendly] !== undefined && (plugins[table_selector_jq_friendly] !== undefined && plugins[table_selector_jq_friendly].ColReorder !== undefined)) {
4236                                                 column_position = plugins[table_selector_jq_friendly].ColReorder[column_number];
4237                                         }
4238                                         optionsObj = getOptions(table_arg.selector)[column_number];
4239                                         filter_value = col_filter_arr[j][1];
4240
4241                                         switch (optionsObj.filter_type) {
4242                                         case 'auto_complete':
4243                                         case 'text':
4244                                         case 'date':
4245                                                 if (filter_value !== undefined && filter_value.indexOf('_exclude_') !== -1) {
4246                                                         exclude = true;
4247                                                         filter_value = filter_value.replace('_exclude_', '');
4248                                                 }
4249                                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(filter_value);
4250                                                 if (filter_value !== '') {
4251                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).addClass('inuse');
4252                                                 } else {
4253                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).removeClass('inuse');
4254                                                 }
4255                                                 tmpStr = yadcfMatchFilterString(table_arg, column_position, filter_value, optionsObj.filter_match_mode, false, exclude);
4256                                                 table_arg.fnSettings().aoPreSearchCols[column_position].sSearch = tmpStr;
4257                                                 break;
4258                                         case 'select':
4259                                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(filter_value);
4260                                                 if (filter_value !== '') {
4261                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).addClass('inuse');
4262                                                 } else {
4263                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).removeClass('inuse');
4264                                                 }
4265                                                 tmpStr = yadcfMatchFilterString(table_arg, column_position, filter_value, optionsObj.filter_match_mode, false);
4266                                                 table_arg.fnSettings().aoPreSearchCols[column_position].sSearch = tmpStr;
4267                                                 if (optionsObj.select_type !== undefined) {
4268                                                         refreshSelectPlugin(optionsObj, $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number));
4269                                                 }
4270                                                 break;
4271                                         case 'multi_select':
4272                                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(filter_value);
4273                                                 tmpStr = yadcfMatchFilterString(table_arg, column_position, filter_value, optionsObj.filter_match_mode, true);
4274                                                 table_arg.fnSettings().aoPreSearchCols[column_position].sSearch = tmpStr;
4275                                                 if (optionsObj.select_type !== undefined) {
4276                                                         refreshSelectPlugin(optionsObj, $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number));
4277                                                 }
4278                                                 break;
4279                                         case 'range_date':
4280                                                 fromId = 'yadcf-filter-' + table_selector_jq_friendly + '-from-date-' + column_number;
4281                                                 toId = 'yadcf-filter-' + table_selector_jq_friendly + '-to-date-' + column_number;
4282                                                 $('#' + fromId).val(filter_value.from);
4283                                                 if (filter_value.from !== '') {
4284                                                         $('#' + fromId).addClass('inuse');
4285                                                 } else {
4286                                                         $('#' + fromId).removeClass('inuse');
4287                                                 }
4288                                                 $('#' + toId).val(filter_value.to);
4289                                                 if (filter_value.to !== '') {
4290                                                         $('#' + toId).addClass('inuse');
4291                                                 } else {
4292                                                         $('#' + toId).removeClass('inuse');
4293                                                 }
4294                                                 if (table_arg.fnSettings().oFeatures.bServerSide === true) {
4295                                                         min = filter_value.from;
4296                                                         max = filter_value.to;
4297                                                         table_arg.fnSettings().aoPreSearchCols[column_position].sSearch = min + '-yadcf_delim-' + max;
4298                                                 }
4299                                                 saveStateSave(table_arg, column_number, table_selector_jq_friendly, filter_value.from, filter_value.to);
4300                                                 break;
4301                                         case 'range_number':
4302                                                 fromId = 'yadcf-filter-' + table_selector_jq_friendly + '-from-' + column_number;
4303                                                 toId = 'yadcf-filter-' + table_selector_jq_friendly + '-to-' + column_number;
4304                                                 $('#' + fromId).val(filter_value.from);
4305                                                 if (filter_value.from !== '') {
4306                                                         $('#' + fromId).addClass('inuse');
4307                                                 } else {
4308                                                         $('#' + fromId).removeClass('inuse');
4309                                                 }
4310                                                 $('#' + toId).val(filter_value.to);
4311                                                 if (filter_value.to !== '') {
4312                                                         $('#' + toId).addClass('inuse');
4313                                                 } else {
4314                                                         $('#' + toId).removeClass('inuse');
4315                                                 }
4316                                                 if (table_arg.fnSettings().oFeatures.bServerSide === true) {
4317                                                         table_arg.fnSettings().aoPreSearchCols[column_position].sSearch = filter_value.from + '-yadcf_delim-' + filter_value.to;
4318                                                 }
4319                                                 saveStateSave(table_arg, column_number, table_selector_jq_friendly, filter_value.from, filter_value.to);
4320                                                 break;
4321                                         case 'range_number_slider':
4322                                                 sliderId = 'yadcf-filter-' + table_selector_jq_friendly + '-slider-' + column_number;
4323                                                 fromId = 'yadcf-filter-' + table_selector_jq_friendly + '-min_tip-' + column_number;
4324                                                 toId = 'yadcf-filter-' + table_selector_jq_friendly + '-max_tip-' + column_number;
4325                                                 if (filter_value.from !== '') {
4326                                                         min = $('#' + fromId).closest('.yadcf-filter-range-number-slider').find(".yadcf-filter-range-number-slider-min-tip-hidden").text();
4327                                                         max = $('#' + fromId).closest('.yadcf-filter-range-number-slider').find(".yadcf-filter-range-number-slider-max-tip-hidden").text();
4328                                                         $('#' + fromId).text(filter_value.from);
4329                                                         if (min !== filter_value.from) {
4330                                                                 $('#' + fromId).parent().addClass('inuse');
4331                                                                 $('#' + fromId).parent().parent().find('ui-slider-range').addClass('inuse');
4332                                                         } else {
4333                                                                 $('#' + fromId).parent().removeClass('inuse');
4334                                                                 $('#' + fromId).parent().parent().find('ui-slider-range').removeClass('inuse');
4335                                                         }
4336                                                         $('#' + sliderId).slider('values', 0, filter_value.from);
4337                                                 }
4338                                                 if (filter_value.to !== '') {
4339                                                         $('#' + toId).text(filter_value.to);
4340                                                         if (max !== filter_value.to) {
4341                                                                 $('#' + toId).parent().addClass('inuse');
4342                                                                 $('#' + toId).parent().parent().find('.ui-slider-range').addClass('inuse');
4343                                                         } else {
4344                                                                 $('#' + toId).parent().removeClass('inuse');
4345                                                                 $('#' + toId).parent().parent().find('.ui-slider-range').removeClass('inuse');
4346                                                         }
4347                                                         $('#' + sliderId).slider('values', 1, filter_value.to);
4348                                                 }
4349                                                 if (table_arg.fnSettings().oFeatures.bServerSide === true) {
4350                                                         table_arg.fnSettings().aoPreSearchCols[column_position].sSearch = filter_value.from + '-yadcf_delim-' + filter_value.to;
4351                                                 }
4352                                                 saveStateSave(table_arg, column_number, table_selector_jq_friendly, filter_value.from, filter_value.to);
4353                                                 break;
4354                                         case 'custom_func':
4355                                         case 'multi_select_custom_func':
4356                                                 $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).val(filter_value);
4357                                                 if (filter_value !== '') {
4358                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).addClass('inuse');
4359                                                 } else {
4360                                                         $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number).removeClass('inuse');
4361                                                 }
4362                                                 if (table_arg.fnSettings().oFeatures.bServerSide === true) {
4363                                                         table_arg.fnSettings().aoPreSearchCols[column_position].sSearch = filter_value;
4364                                                 }
4365                                                 if (optionsObj.select_type !== undefined) {
4366                                                         refreshSelectPlugin(optionsObj, $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number), filter_value);
4367                                                 }
4368                                                 saveStateSave(table_arg, column_number, table_selector_jq_friendly, filter_value, '');
4369                                                 break;
4370                                         }
4371                                 }
4372                                 if (table_arg.fnSettings().oFeatures.bServerSide !== true) {
4373                                         table_arg.fnDraw();
4374                                 } else {
4375                                         setTimeout(function () {
4376                                                 table_arg.fnDraw();
4377                                         }, 10);
4378                                 }
4379                         } else {
4380                                 exFilterColumnQueue.push(exInternalFilterColumnAJAXQueue(table_arg, col_filter_arr));
4381                         }
4382                 }
4383
4384                 function exGetColumnFilterVal(table_arg, column_number) {
4385                         var retVal,
4386                                 fromId,
4387                                 toId,
4388                                 table_selector_jq_friendly,
4389                                 optionsObj,
4390                                 $filterElement;
4391
4392                         //check if the table arg is from new datatables API (capital "D")
4393                         if (table_arg.settings !== undefined) {
4394                                 table_arg = table_arg.settings()[0].oInstance;
4395                         }
4396
4397                         optionsObj = getOptions(table_arg.selector)[column_number];
4398                         table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendly2(table_arg);
4399
4400                         $filterElement = $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number);
4401                         switch (optionsObj.filter_type) {
4402                         case 'select':
4403                         case 'custom_func':
4404                                 retVal = $filterElement.val();
4405                                 if (retVal === '-1') {
4406                                         retVal = '';
4407                                 }
4408                                 break;
4409                         case 'auto_complete':
4410                         case 'text':
4411                         case 'date':
4412                         case 'date_custom_func':
4413                                 retVal = $filterElement.val();
4414                                 if ($filterElement.prev().hasClass('yadcf-exclude-wrapper') && $filterElement.prev().find('input').prop('checked') === true) {
4415                                         retVal = '_exclude_' + retVal;
4416                                 }
4417                                 break;
4418                         case 'multi_select':
4419                                 retVal = $filterElement.val();
4420                                 if (retVal === null) {
4421                                         retVal = '';
4422                                 }
4423                                 break;
4424                         case 'range_date':
4425                                 retVal = {};
4426                                 fromId = 'yadcf-filter-' + table_selector_jq_friendly + '-from-date-' + column_number;
4427                                 toId = 'yadcf-filter-' + table_selector_jq_friendly + '-to-date-' + column_number;
4428
4429                                 retVal.from = $('#' + fromId).val();
4430                                 retVal.to = $('#' + toId).val();
4431                                 break;
4432                         case 'range_number':
4433                                 retVal = {};
4434                                 fromId = 'yadcf-filter-' + table_selector_jq_friendly + '-from-' + column_number;
4435                                 toId = 'yadcf-filter-' + table_selector_jq_friendly + '-to-' + column_number;
4436
4437                                 retVal.from = $('#' + fromId).val();
4438                                 retVal.to = $('#' + toId).val();
4439                                 break;
4440                         case 'range_number_slider':
4441                                 retVal = {};
4442                                 fromId = 'yadcf-filter-' + table_selector_jq_friendly + '-min_tip-' + column_number;
4443                                 toId = 'yadcf-filter-' + table_selector_jq_friendly + '-max_tip-' + column_number;
4444
4445                                 retVal.from = $('#' + fromId).text();
4446                                 retVal.to = $('#' + toId).text();
4447
4448                                 break;
4449                         default:
4450                                 console.log('exGetColumnFilterVal error: no such filter_type: ' + optionsObj.filter_type);
4451                         }
4452                         return retVal;
4453                 }
4454
4455                 function clearStateSave(oTable, column_number, table_selector_jq_friendly) {
4456                         var yadcfState;
4457                         if (oTable.fnSettings().oFeatures.bStateSave === true) {
4458                                 if (!oTable.fnSettings().oLoadedState) {
4459                                         oTable.fnSettings().oLoadedState = {};
4460                                         oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
4461                                 }
4462                                 if (oTable.fnSettings().oLoadedState.yadcfState !== undefined && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] !== undefined) {
4463                                         oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number] = undefined;
4464                                 } else {
4465                                         yadcfState = {};
4466                                         yadcfState[table_selector_jq_friendly] = [];
4467                                         yadcfState[table_selector_jq_friendly][column_number] = undefined;
4468                                         oTable.fnSettings().oLoadedState.yadcfState = yadcfState;
4469                                 }
4470                                 oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
4471                         }
4472                 }
4473
4474                 function saveStateSave(oTable, column_number, table_selector_jq_friendly, from, to) {
4475                         var yadcfState;
4476                         if (oTable.fnSettings().oFeatures.bStateSave === true) {
4477                                 if (!oTable.fnSettings().oLoadedState) {
4478                                         oTable.fnSettings().oLoadedState = {};
4479                                 }
4480                                 if (oTable.fnSettings().oLoadedState.yadcfState !== undefined && oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly] !== undefined) {
4481                                         oTable.fnSettings().oLoadedState.yadcfState[table_selector_jq_friendly][column_number] = {
4482                                                 from: from,
4483                                                 to: to
4484                                         };
4485                                 } else {
4486                                         yadcfState = {};
4487                                         yadcfState[table_selector_jq_friendly] = [];
4488                                         yadcfState[table_selector_jq_friendly][column_number] = {
4489                                                 from: from,
4490                                                 to: to
4491                                         };
4492                                         oTable.fnSettings().oLoadedState.yadcfState = yadcfState;
4493                                 }
4494                                 oTable.fnSettings().oApi._fnSaveState(oTable.fnSettings());
4495                         }
4496                 }
4497
4498                 function exResetAllFilters(table_arg, noRedraw, columns) {
4499                         var table_selector_jq_friendly,
4500                                 column_number,
4501                                 fromId,
4502                                 toId,
4503                                 sliderId,
4504                                 tableOptions,
4505                                 optionsObj,
4506                                 columnObjKey,
4507                                 settingsDt = getSettingsObjFromTable(table_arg),
4508                                 i,
4509                                 $filterElement;
4510
4511                         //check if the table arg is from new datatables API (capital "D")
4512                         if (table_arg.settings !== undefined) {
4513                                 table_arg = table_arg.settings()[0].oInstance;
4514                         }
4515                         tableOptions = getOptions(table_arg.selector);
4516                         table_selector_jq_friendly = yadcf.generateTableSelectorJQFriendly2(table_arg);
4517                         settingsDt = getSettingsObjFromTable(table_arg);
4518
4519                         for (columnObjKey in tableOptions) {
4520                                 if (tableOptions.hasOwnProperty(columnObjKey)) {
4521                                         optionsObj = tableOptions[columnObjKey];
4522                                         column_number = optionsObj.column_number;
4523
4524                                         if (columns !== undefined && $.inArray(column_number, columns) === -1) {
4525                                                 continue;
4526                                         }
4527                                         $(document).removeData("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val");
4528
4529                                         $filterElement = $('#yadcf-filter-' + table_selector_jq_friendly + '-' + column_number);
4530
4531                                         switch (optionsObj.filter_type) {
4532                                         case 'select':
4533                                         case 'custom_func':
4534                                                 $filterElement.val('-1').removeClass('inuse');
4535                                                 table_arg.fnSettings().aoPreSearchCols[column_number].sSearch = '';
4536                                                 if (optionsObj.select_type !== undefined) {
4537                                                         refreshSelectPlugin(optionsObj, $filterElement, '-1');
4538                                                 }
4539                                                 break;
4540                                         case 'auto_complete':
4541                                         case 'text':
4542                                         case 'date':
4543                                                 $filterElement.val('').removeClass('inuse');
4544                                                 table_arg.fnSettings().aoPreSearchCols[column_number].sSearch = '';
4545                                                 if ($filterElement.prev().hasClass('yadcf-exclude-wrapper')) {
4546                                                         $filterElement.prev().find('input').prop('checked', false);
4547                                                 }
4548                                                 break;
4549                                         case 'multi_select':
4550                                         case 'multi_select_custom_func':
4551                                                 $filterElement.val('-1');
4552                                                 $(document).data("#yadcf-filter-" + table_selector_jq_friendly + "-" + column_number + "_val", undefined);
4553                                                 table_arg.fnSettings().aoPreSearchCols[column_number].sSearch = '';
4554                                                 if (optionsObj.select_type !== undefined) {
4555                                                         refreshSelectPlugin(optionsObj, $filterElement, '-1');
4556                                                 }
4557                                                 break;
4558                                         case 'range_date':
4559                                                 fromId = 'yadcf-filter-' + table_selector_jq_friendly + '-from-date-' + column_number;
4560                                                 toId = 'yadcf-filter-' + table_selector_jq_friendly + '-to-date-' + column_number;
4561                                                 $('#' + fromId).val('');
4562                                                 $('#' + fromId).removeClass('inuse');
4563                                                 $('#' + toId).val('');
4564                                                 $('#' + toId).removeClass('inuse');
4565                                                 if (table_arg.fnSettings().oFeatures.bServerSide === true) {
4566                                                         table_arg.fnSettings().aoPreSearchCols[column_number].sSearch = '';
4567                                                 }
4568                                                 clearStateSave(table_arg, column_number, table_selector_jq_friendly);
4569                                                 break;
4570                                         case 'range_number':
4571                                                 fromId = 'yadcf-filter-' + table_selector_jq_friendly + '-from-' + column_number;
4572                                                 toId = 'yadcf-filter-' + table_selector_jq_friendly + '-to-' + column_number;
4573                                                 $('#' + fromId).val('');
4574                                                 $('#' + fromId).removeClass('inuse');
4575                                                 $('#' + toId).val('');
4576                                                 $('#' + toId).removeClass('inuse');
4577                                                 if (table_arg.fnSettings().oFeatures.bServerSide === true) {
4578                                                         table_arg.fnSettings().aoPreSearchCols[column_number].sSearch = '';
4579                                                 }
4580                                                 clearStateSave(table_arg, column_number, table_selector_jq_friendly);
4581                                                 break;
4582                                         case 'range_number_slider':
4583                                                 sliderId = 'yadcf-filter-' + table_selector_jq_friendly + '-slider-' + column_number;
4584                                                 fromId = 'yadcf-filter-' + table_selector_jq_friendly + '-min_tip-' + column_number;
4585                                                 toId = 'yadcf-filter-' + table_selector_jq_friendly + '-max_tip-' + column_number;
4586                                                 $('#' + fromId).text('');
4587                                                 $('#' + fromId).parent().removeClass('inuse');
4588                                                 $('#' + fromId).parent().parent().find('ui-slider-range').removeClass('inuse');
4589                                                 $('#' + toId).text('');
4590                                                 $('#' + toId).parent().removeClass('inuse');
4591                                                 $('#' + toId).parent().parent().find('.ui-slider-range').removeClass('inuse');
4592                                                 $('#' + sliderId).slider("option", "values", [$('#' + fromId).parent().parent().find('.yadcf-filter-range-number-slider-min-tip-hidden').text(), $('#' + fromId).parent().parent().find('.yadcf-filter-range-number-slider-max-tip-hidden').text()]);
4593                                                 if (table_arg.fnSettings().oFeatures.bServerSide === true) {
4594                                                         table_arg.fnSettings().aoPreSearchCols[column_number].sSearch = '';
4595                                                 }
4596                                                 clearStateSave(table_arg, column_number, table_selector_jq_friendly);
4597                                                 break;
4598                                         }
4599
4600                                 }
4601                         }
4602                         if (noRedraw !== true) {
4603                                 //clear global filter
4604                                 settingsDt.oPreviousSearch.sSearch = '';
4605                                 if (settingsDt.aanFeatures.f !== undefined) {
4606                                         for (i = 0; i < settingsDt.aanFeatures.f.length; i++) {
4607                                                 $('input', settingsDt.aanFeatures.f[i]).val('');
4608                                         }
4609                                 }
4610                                 //end of clear global filter
4611                                 table_arg.fnDraw(settingsDt);
4612                         }
4613                 }
4614
4615                 function exResetFilters(table_arg, columns, noRedraw) {
4616                         exResetAllFilters(table_arg, noRedraw, columns);
4617                 }
4618
4619                 function exFilterExternallyTriggered(table_arg) {
4620                         var columnsObj,
4621                                 columnObjKey,
4622                                 columnObj,
4623                                 filterValue,
4624                                 filtersValuesSingleElem,
4625                                 filtersValuesArr = [];
4626
4627                         //check if the table arg is from new datatables API (capital "D")
4628                         if (table_arg.settings !== undefined) {
4629                                 table_arg = table_arg.settings()[0].oInstance;
4630                         }
4631                         columnsObj = getOptions(table_arg.selector);
4632
4633                         for (columnObjKey in columnsObj) {
4634                                 if (columnsObj.hasOwnProperty(columnObjKey)) {
4635                                         columnObj = columnsObj[columnObjKey];
4636                                         filterValue = exGetColumnFilterVal(table_arg, columnObj.column_number);
4637                                         filtersValuesSingleElem = [];
4638                                         filtersValuesSingleElem.push(columnObj.column_number);
4639                                         filtersValuesSingleElem.push(filterValue);
4640                                         filtersValuesArr.push(filtersValuesSingleElem);
4641                                 }
4642                         }
4643                         exFilterColumn(table_arg, filtersValuesArr, true);
4644                 }
4645
4646                 return {
4647                         init: init,
4648                         doFilter: doFilter,
4649                         doFilterMultiSelect: doFilterMultiSelect,
4650                         doFilterAutocomplete: doFilterAutocomplete,
4651                         autocompleteKeyUP: autocompleteKeyUP,
4652                         getOptions: getOptions,
4653                         rangeNumberKeyUP: rangeNumberKeyUP,
4654                         rangeDateKeyUP: rangeDateKeyUP,
4655                         rangeClear: rangeClear,
4656                         rangeNumberSliderClear: rangeNumberSliderClear,
4657                         stopPropagation: stopPropagation,
4658                         exFilterColumn: exFilterColumn,
4659                         exGetColumnFilterVal: exGetColumnFilterVal,
4660                         exResetAllFilters: exResetAllFilters,
4661                         dateKeyUP: dateKeyUP,
4662                         dateSelectSingle: dateSelectSingle,
4663                         textKeyUP: textKeyUP,
4664                         doFilterCustomDateFunc: doFilterCustomDateFunc,
4665                         eventTargetFixUp: eventTargetFixUp,
4666                         initMultipleTables: initMultipleTables,
4667                         initMultipleColumns: initMultipleColumns,
4668                         textKeyUpMultiTables: textKeyUpMultiTables,
4669                         doFilterMultiTables: doFilterMultiTables,
4670                         doFilterMultiTablesMultiSelect: doFilterMultiTablesMultiSelect,
4671                         generateTableSelectorJQFriendlyNew: generateTableSelectorJQFriendlyNew,
4672                         exFilterExternallyTriggered: exFilterExternallyTriggered,
4673                         exResetFilters: exResetFilters,
4674                         initSelectPluginCustomTriggers: initSelectPluginCustomTriggers,
4675                         preventDefaultForEnter: preventDefaultForEnter,
4676                         generateTableSelectorJQFriendly2: generateTableSelectorJQFriendly2
4677                 };
4678
4679         }());
4680         if (window) {
4681                 window.yadcf = yadcf;
4682         }
4683         return yadcf;
4684 }));