Changeset 7701 in spip-zone


Ignore:
Timestamp:
Dec 1, 2006, 11:21:33 AM (12 years ago)
Author:
cedric@…
Message:

tablesorter du 26/11 (plus d'implementation de filter, attendons que ca revienne)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/_stable_/forms/forms_et_tables_1_9_1/javascript/jquery.tablesorter.dev.js

    r7289 r7701  
    44 *
    55 * Copyright (c) 2006 Christian Bach (http://motherrussia.polyester.se)
    6  * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
     6 * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
    77 * and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
    8  * 
    9  * $Date: 2006-08-21 14:43:23 +0000 (Mon, 21 Aug 2006) $
    10  * $Author: Christian $
    11  * 
     8 *
     9 * jQueryDate: 2006-08-21 14:43:23 +0000 (Mon, 21 Aug 2006) jQuery
     10 * jQueryAuthor: Christian jQuery
     11 *
    1212 */
    13 $.fn.tableSorter = function(o) {
    14        
     13jQuery.fn.tableSorter = function(o) {
     14
    1515        var defaults =  {
    1616                sortDir: 0,
     
    2323                rowLimit: 0,
    2424                minRowsForWaitingMsg: 0,
    25                 disableHeader: false,
     25                disableHeader: -1,
    2626                stripRowsOnStartUp: false,
    2727                columnParser: false,
    2828                rowHighlightClass: true,
     29                useCache: true,
     30                debug: false,
     31                textExtraction: 'simple',
    2932                features: {
    30                
     33
    3134                },
    3235                styles: {
    33                
    34                 },
    35                                
     36
     37                },
     38
     39
    3640                // text extraction stuff
    3741                /**
    3842                * @param textExtraction
    3943                * @type string
    40                 * @example textExtraction: 'simple'             
     44                * @example textExtraction: 'simple'
    4145                */
    42                 textExtraction: 'simple',
     46
    4347                /**
    4448                * @param textExtractionCustom
    4549                * @type object
    46                 * @example textExtractionCustom: { 1:function(o) { return o.innerHTML;} }               
     50                * @example textExtractionCustom: { 1:function(o) { return o.innerHTML;} }
    4751                */
    4852                textExtractionCustom: false,
    49                
     53                bind: false,
     54                addHeaderLink: false,
    5055                dateFormat: 'mm/dd/yyyy' /** us default, uk dd/mm/yyyy */
    51         };             
    52        
     56        };
     57
    5358        return this.each(function(){
    54                
     59
     60
     61
     62
     63                /** merge default with custom options */
     64                jQuery.extend(defaults, o);
     65
    5566                /** Private vars */
    5667                var COLUMN_DATA = [];                   /** array for storing columns */
     
    6374                var ROW_LAST_HIGHLIGHT_OBJ = false;
    6475                var COLUMN_LAST_INDEX = -1;
    65                
    66                 /** merge default with custom options */
    67                 jQuery.extend(defaults, o);
    68                
     76                var COLUMN_LAST_DIR = defaults.sortDir;
     77
    6978                /** table object holder.*/
    70                 var oTable = this;                             
    71                
     79                var oTable = this;
     80
    7281                if(defaults.stripRowsOnStartUp && defaults.stripingRowClass) {
    73                         $.tableSorter.utils.stripRows(oTable,defaults);
    74                 }
    75                
    76                 /** Store lenght of table rows. */
    77                 var tableRowLength = oTable.rows.length-1;
    78                
    79                 /** Index column data. */                       
     82                        jQuery.tableSorter.utils.stripRows(oTable,defaults);
     83                }
     84
     85                if(defaults.bind) {
     86                        //var fn = ;
     87                        jQuery(this).bind(defaults.bind,doSorting);
     88                }
     89
     90                /** Store length of table rows. */
     91                var tableRowLength = oTable.tBodies[0].rows.length-1;
     92
     93                /** Index column data. */
    8094                buildColumnDataIndex();
    81                
    82                
     95
     96
    8397                function buildColumnHeaders() {
    8498                        var oFirstTableRow = oTable.rows[0];
    8599                        var oDataSampleRow = oTable.rows[1];
    86100                        /** store column length */
    87                         COLUMN_HEADER_LENGTH = oFirstTableRow.cells.length;     
     101                        COLUMN_HEADER_LENGTH = oFirstTableRow.cells.length;
    88102                        /** loop column headers */
    89                         for( var i=0; i < COLUMN_HEADER_LENGTH; i++ ) { 
     103                        for( var i=0; i < COLUMN_HEADER_LENGTH; i++ ) {
    90104                                var oCell = oFirstTableRow.cells[i];
    91                                 if(!$.tableSorter.utils.isHeaderDisabled(oCell,defaults.disableHeader,i)) {     
     105
     106                                if(oDataSampleRow && !jQuery.tableSorter.utils.isHeaderDisabled(oCell,defaults.disableHeader,i)) {
    92107                                        /** get current cell from columns headers */
    93                                         var oCellValue = $.tableSorter.utils.getElementText(oDataSampleRow.cells[i],'columns',i);
     108                                        jQuery.tableSorter.utils.setParams(defaults);
     109                                        var oCellValue = jQuery.tableSorter.utils.getElementText(oDataSampleRow.cells[i],'columns',i);
    94110                                        /** check for default column. */
    95111                                        if(typeof(defaults.sortColumn) == "string") {
    96                                                 if(defaults.sortColumn.toLowerCase() == $.tableSorter.utils.getElementText(oCell,'header',i).toLowerCase()) {
     112                                                if(defaults.sortColumn.toLowerCase() == jQuery.tableSorter.utils.getElementText(oCell,'header',i).toLowerCase()) {
    97113                                                        defaults.sortColumn = i;
    98114                                                }
    99115                                        }
    100                                        
     116
    101117                                        /** get sorting method for column. */
    102                                         COLUMN_SORTER_CACHE[i] = $.tableSorter.analyzer.analyseString(oCellValue,defaults);
    103                                        
    104                                         //console.log('column sorter:', COLUMN_SORTER_CACHE[i].id);
    105                                          
     118                                        COLUMN_SORTER_CACHE[i] = jQuery.tableSorter.analyzer.analyseString(oCellValue,defaults);
     119
    106120                                        /** if we have a column parser, set it manual. */
    107121                                        if(defaults.columnParser) {
     
    110124                                                for(var j=0; j < l; j++) {
    111125                                                        if(i == a[j][0]) {
    112                                                                 COLUMN_SORTER_CACHE[i] = $.tableSorter.analyzer.getById(a[j][1]);
     126                                                                COLUMN_SORTER_CACHE[i] = jQuery.tableSorter.analyzer.getById(a[j][1]);
     127
    113128                                                                continue;
    114                                                         } 
    115                                                 }       
    116                                         }
    117                                        
     129                                                        }
     130                                                }
     131                                        }
     132
     133
    118134                                        if(defaults.headerClass) {
    119                                                 $(oCell).addClass(defaults.headerClass);
    120                                         }
    121                                        
    122                                         $(oCell).wrapInner({element: '<span>', name: 'span', className: 'sorter'});
    123                                         $(oCell).append('<div class="filterIcon">&nbsp;</div>');
    124                                
    125                                         //console.log('left:' , $(oCell).left());
     135                                                jQuery(oCell).addClass(defaults.headerClass);
     136                                        }
     137                                        if(defaults.addHeaderLink) {
     138                                                jQuery(oCell).wrapInner({element: '<a href="#">', name: 'a', className: 'sorter'});
     139
     140                                                jQuery(".sorter",oCell).click(function(e) {
     141                                                        sortOnColumn( jQuery(this).parent(), (jQuery(this).parent()[0].count++) % 2, jQuery(this).parent()[0].index );
     142                                                        return false;
     143                                                });
     144                                        } else {
     145                                                jQuery(oCell).click(function(e) {
     146                                                        sortOnColumn( jQuery(this), (jQuery(this)[0].count++) % 2, jQuery(this)[0].index );
     147                                                        return false;
     148                                                });
     149                                        }
     150
     151
     152                                        //jQuery(oCell).append('<div class="filterIcon">&nbsp;</div>');
     153
    126154                                        oCell.index = i;
    127155                                        oCell.count = defaults.sortDir;
    128                                        
    129                                         $(".filterIcon",oCell).click(function(e) {
    130                                                 //console.log('p:',$(this).parent()[0].index);
    131                                                 filterColumn($(this).parent(),$(this).parent()[0].index);
     156
     157                                        /*
     158                                        jQuery(".filterIcon",oCell).click(function(e) {
     159                                                filterColumn(jQuery(this).parent(),jQuery(this).parent()[0].index);
    132160                                                //e.preventDefault();
    133161                                        });
    134                                        
    135                                        
    136                                         $(".sorter",oCell).click(function(e) {
    137                                                 sortOnColumn( $(this).parent(), ($(this).parent()[0].count++) % 2, $(this).parent()[0].index );
    138                                                 //e.stopPropagation();
    139                                         });
    140                                          
     162                                        */
     163
     164
     165
    141166                                }
    142167                        }
     
    146171                        /** if we have a init sorting, fire it! */
    147172                        if(defaults.sortColumn != null) {
    148                                 $(oFirstTableRow.cells[defaults.sortColumn]).trigger("click"); 
    149                         }
    150                        
     173                                jQuery(oFirstTableRow.cells[defaults.sortColumn]).trigger("click");
     174                        }
     175
    151176                        if(defaults.rowHighlightClass) {
    152                                 $("tbody/tr",oTable).click(function() {
     177                                jQuery("> tbody:first/tr",oTable).click(function() {
    153178                                        if(ROW_LAST_HIGHLIGHT_OBJ) {
    154                                                 ROW_LAST_HIGHLIGHT_OBJ.removeClass(defaults.rowHighlightClass); 
    155                                         }
    156                                         ROW_LAST_HIGHLIGHT_OBJ = $(this).addClass(defaults.rowHighlightClass);
     179                                                ROW_LAST_HIGHLIGHT_OBJ.removeClass(defaults.rowHighlightClass);
     180                                        }
     181                                        ROW_LAST_HIGHLIGHT_OBJ = jQuery(this).addClass(defaults.rowHighlightClass);
    157182                                });
    158183                        }
    159184                }
    160                 /** break out and put i $.tableSorter? */
     185                /** break out and put i jQuery.tableSorter? */
    161186                function buildColumnDataIndex() {
    162187                        /** make colum data. */
    163                         var l = oTable.rows.length;
    164                         for (var i=1;i < l; i++) {
     188                        var l = oTable.tBodies[0].rows.length;
     189                        for (var i=0;i < l; i++) {
    165190                                /** Add the table data to main data array */
    166                                 COLUMN_DATA.push(oTable.rows[i]);
     191                                COLUMN_DATA.push(oTable.tBodies[0].rows[i]);
    167192                        }
    168193                        /** when done, build headers. */
     
    173198                        /** adjust header to the sample rows */
    174199                        for(var i=0; i < COLUMN_HEADER_LENGTH; i++) {
    175                                 $(columnsHeader.cells[i]).css("width",oSampleTableRow.cells[i].clientWidth + "px");
    176                         }
    177                 }
    178                
     200                                if(oSampleTableRow && oSampleTableRow.cells[i])
     201                                        jQuery(columnsHeader.cells[i]).css("width",oSampleTableRow.cells[i].clientWidth + "px");
     202                        }
     203                }
     204
    179205                function filterColumn(oCell,index) {
    180                
     206
    181207                        COLUMN_INDEX = index;
    182                        
    183                         //console.log('flat data:',$.tableSorter.data.flatten(COLUMN_DATA,COLUMN_SORTER_CACHE,index));
    184                        
    185                         //var parser = COLUMN_SORTER_CACHE[index].id;
    186                        
    187                         var flatData = $.tableSorter.data.flatten(COLUMN_DATA,COLUMN_SORTER_CACHE,index);
     208
     209                        var flatData = jQuery.tableSorter.data.flatten(COLUMN_DATA,COLUMN_SORTER_CACHE,index);
    188210                        var l = flatData.length;
    189211                        var p = COLUMN_SORTER_CACHE[COLUMN_INDEX];
    190                         var f = $.tableSorter.filter[p.filter];
    191                         var o = $("#filter");
     212                        var f = jQuery.tableSorter.filter[p.filter];
     213                        var o = jQuery("#filter");
    192214                        o.show().empty();
    193215                        // sort to get min and max values.
    194216                        flatData.sort(p.sorter);
    195                        
     217
    196218                        f.render(o,flatData[0][1],flatData[l-1][1]);
    197                        
     219
    198220                        // add buttons.
    199                         // CM ajout variable pour trad
    200221                        o.append('<div class="spip_bouton"><input type="submit" value="'+apply_string+'" class="fondo"/><input type="reset" value="'+clear_string+'" class="fondl"/></div>');
    201                                
    202                         $('input[@type="submit"]',o).click(function() {
    203                                 var min = $('input[@name="min"]',o).val();
    204                                 var max = $('input[@name="max"]',o).val();
    205                                 //console.log('value:', min,max);
    206                                 $.tableSorter.filter.applyFilter(min,max);
     222                        jQuery('input[@type="submit"]',o).click(function() {
     223                                var min = jQuery('input[@name="min"]',o).val();
     224                                var max = jQuery('input[@name="max"]',o).val();
     225                                jQuery.tableSorter.filter.applyFilter(min,max);
    207226                        });
    208                        
    209                         $('input[@type="reset"]',o).click(function() {
    210                                 $.tableSorter.filter.resetFilter();
     227
     228                        jQuery('input[@type="reset"]',o).click(function() {
     229                                jQuery.tableSorter.filter.resetFilter();
    211230                                o.hide();
    212231                        });
    213                        
     232
    214233                        var d = {
    215234                                oTable: oTable,
     
    222241                                lastIndex: COLUMN_LAST_INDEX
    223242                        }
    224                        
    225                         $.tableSorter.filter.setData(d);
    226                        
     243
     244                        jQuery.tableSorter.filter.setData(d);
     245
    227246                }
    228247                function sortOnColumn(oCell,dir,index) {
    229248                        /** trigger event sort start. */
    230249                        if(tableRowLength > defaults.minRowsForWaitingMsg) {
    231                                 $.event.trigger( "sortStart");
     250                                jQuery.event.trigger( "sortStart");
    232251                        }
    233252                        /** define globals for current sorting. */
     
    236255                        COLUMN_DIR = dir;
    237256                        /** clear all classes, need to be optimized. */
    238                         $("th."+defaults.sortClassAsc,oTable).removeClass(defaults.sortClassAsc);
    239                         $("th."+defaults.sortClassDesc,oTable).removeClass(defaults.sortClassDesc);
     257                        jQuery("th."+defaults.sortClassAsc,oTable).removeClass(defaults.sortClassAsc);
     258                        jQuery("th."+defaults.sortClassDesc,oTable).removeClass(defaults.sortClassDesc);
    240259                        /**add active class and append image. */
    241                         $(COLUMN_CELL).addClass((dir % 2 ? defaults.sortClassAsc : defaults.sortClassDesc));
     260                        jQuery(COLUMN_CELL).addClass((dir % 2 ? defaults.sortClassAsc : defaults.sortClassDesc));
    242261                        /** remove highlighting */
    243262                        if(defaults.highlightClass) {
    244263                                if(COLUMN_LAST_INDEX != COLUMN_INDEX && COLUMN_LAST_INDEX > -1) {
    245                                         $("tbody/tr",o).find("td:eq(" + COLUMN_LAST_INDEX + ")").removeClass(defaults.highlightClass).end();
    246                                 }
    247                         }       
     264                                        jQuery("> tbody:first/tr",o).find("> td:eq(" + COLUMN_LAST_INDEX + ")").removeClass(defaults.highlightClass).end();
     265                                }
     266                        }
    248267                        /** if this is fired, with a straight call, sortStart / Stop would never be fired. */
    249268                        setTimeout(doSorting,0);
    250269                }
    251270                function doSorting() {
    252                         /** array for storing sorted data. */
    253                         var columns;
    254                         /** sorting exist in cache, get it. */
    255                         if($.tableSorter.cache.exist(COLUMN_CACHE,COLUMN_INDEX)) {
    256                                 /** get from cache */
    257                                 var cache = $.tableSorter.cache.get(COLUMN_CACHE,COLUMN_INDEX);
    258                                 /** figure out the way to sort. */
    259                                 if(cache.dir == COLUMN_DIR) {
    260                                         columns = cache.data;
    261                                         cache.dir = COLUMN_DIR;
     271                        /** added check to see if COLUMN_INDEX is set */
     272                        if(COLUMN_INDEX >= 0) {
     273                                /** array for storing sorted data. */
     274                                var columns;
     275                                /** sorting exist in cache, get it. */
     276                                if(jQuery.tableSorter.cache.exist(COLUMN_CACHE,COLUMN_INDEX) && defaults.useCache) {
     277                                        /** get from cache */
     278                                        var cache = jQuery.tableSorter.cache.get(COLUMN_CACHE,COLUMN_INDEX);
     279                                        /** figure out the way to sort. */
     280                                        if(cache.dir == COLUMN_DIR) {
     281                                                columns = cache.data;
     282                                                cache.dir = COLUMN_DIR;
     283                                        } else {
     284                                                columns = cache.data.reverse();
     285                                                cache.dir = COLUMN_DIR;
     286                                        }
     287                                /** sort and cache */
    262288                                } else {
    263                                         columns = cache.data.reverse();
    264                                         cache.dir = COLUMN_DIR;
    265                                 }
    266                         /** sort and cache */
    267                         } else {               
    268                                 /** return flat data, and then sort it. */
    269                                 var flatData = $.tableSorter.data.flatten(COLUMN_DATA,COLUMN_SORTER_CACHE,COLUMN_INDEX);
    270                                 /** do sorting, only onces per column. */
    271                                 flatData.sort(COLUMN_SORTER_CACHE[COLUMN_INDEX].sorter);
    272                                 /** if we have a sortDir, reverse the damn thing. */
    273                                 if(defaults.sortDir) { flatData.reverse();}
    274                                 /** rebuild data from flat. */
    275                                 columns = $.tableSorter.data.rebuild(COLUMN_DATA,flatData,COLUMN_INDEX,COLUMN_LAST_INDEX);
    276                                 /** append to table cache. */
    277                                 $.tableSorter.cache.add(COLUMN_CACHE,COLUMN_INDEX,COLUMN_DIR,columns);
    278                                 /** good practise */
    279                                 flatData = null;
    280                         }
    281                         /** append to table > tbody */
    282                         $.tableSorter.utils.appendToTable(oTable,columns,defaults,COLUMN_INDEX,COLUMN_LAST_INDEX);
    283                         /**defaults.tableAppender(oTable,columns,defaults,COLUMN_INDEX,COLUMN_LAST_INDEX); */
    284                        
    285                         /** good practise i guess */
    286                         columns = null;
    287                         /** trigger stop event. */
    288                         if(tableRowLength > defaults.minRowsForWaitingMsg) {
    289                                 $.event.trigger("sortStop",[COLUMN_INDEX]);
    290                         }
    291                         COLUMN_LAST_INDEX = COLUMN_INDEX;
    292                        
     289                                        /** return flat data, and then sort it. */
     290                                        var flatData = jQuery.tableSorter.data.flatten(COLUMN_DATA,COLUMN_SORTER_CACHE,COLUMN_INDEX);
     291                                        /** do sorting, only onces per column. */
     292                                        flatData.sort(COLUMN_SORTER_CACHE[COLUMN_INDEX].sorter);
     293                                        /** if we have a sortDir, reverse the damn thing. */
     294                                        if(COLUMN_LAST_DIR != COLUMN_DIR) {
     295
     296                                                flatData.reverse();
     297
     298                                        }
     299                                        /** rebuild data from flat. */
     300                                        columns = jQuery.tableSorter.data.rebuild(COLUMN_DATA,flatData,COLUMN_INDEX,COLUMN_LAST_INDEX);
     301                                        /** append to table cache. */
     302                                        jQuery.tableSorter.cache.add(COLUMN_CACHE,COLUMN_INDEX,COLUMN_DIR,columns);
     303                                        /** good practise */
     304                                        flatData = null;
     305                                }
     306                                /** append to table > tbody */
     307                                jQuery.tableSorter.utils.appendToTable(oTable,columns,defaults,COLUMN_INDEX,COLUMN_LAST_INDEX);
     308                                /**defaults.tableAppender(oTable,columns,defaults,COLUMN_INDEX,COLUMN_LAST_INDEX); */
     309
     310                                /** good practise i guess */
     311                                columns = null;
     312                                /** trigger stop event. */
     313                                if(tableRowLength > defaults.minRowsForWaitingMsg) {
     314                                        jQuery.event.trigger("sortStop",[COLUMN_INDEX]);
     315                                }
     316                                COLUMN_LAST_INDEX = COLUMN_INDEX;
     317                        }
    293318                }
    294319        });
    295320};
    296321
    297 $.fn.sortStart = function(fn) {
     322jQuery.fn.sortStart = function(fn) {
    298323        return this.bind("sortStart",fn);
    299324};
    300 $.fn.sortStop = function(fn) {
     325jQuery.fn.sortReload = function(fn) {
     326        return this.bind("sortStart",fn);
     327};
     328
     329jQuery.fn.sortStop = function(fn) {
    301330        return this.bind("sortStop",fn);
    302331};
     
    304333
    305334
    306 $.tableSorter = {
     335jQuery.tableSorter = {
    307336        params: {},
    308337        /** cache functions, okey for now. */
     
    315344                },
    316345                get: function (cache,index) {
    317                         return cache[index]; 
     346                        return cache[index];
    318347                },
    319348                exist: function(cache,index) {
     
    332361                        var l = columnData.length;
    333362                        for (var i=0;i < l; i++) {
    334                                 flatData.push([i,columnCache[columnIndex].format($.tableSorter.utils.getElementText(columnData[i].cells[columnIndex],'columns',columnIndex))]);
     363                                flatData.push([i,columnCache[columnIndex].format(jQuery.tableSorter.utils.getElementText(columnData[i].cells[columnIndex],'columns',columnIndex))]);
    335364                        }
    336365                        return flatData;
     
    347376
    348377        sorters: {},
    349        
     378
    350379        parsers: {},
    351        
     380
    352381        analyzer: {
    353        
     382
    354383                analyzers: [],
    355384                add: function(analyzer) {
    356385                        this.analyzers.push(analyzer);
    357386                },
     387                add_to_front: function(analyzer) {
     388                        this.analyzers.unshift(analyzer);
     389                },
    358390                analyseString: function(s,params) {
    359391                        /** set defaults params. */
    360                         $.tableSorter.utils.setParams(params);
     392                        jQuery.tableSorter.utils.setParams(params);
    361393                        var l=this.analyzers.length;
    362394                        var foundAnalyzer = false;
    363395                        for(var i=0; i < l; i++) {
    364                                
    365                                 var analyzer = this.analyzers[i];       
    366                                
     396
     397                                var analyzer = this.analyzers[i];
     398
    367399                                if(analyzer.is(s)) {
    368400                                        foundAnalyzer = true;
     
    372404                        }
    373405                        if(!foundAnalyzer) {
    374                                 return $.tableSorter.parsers.generic;
     406                                return jQuery.tableSorter.parsers.generic;
    375407                        }
    376408                },
     
    378410                        var l=this.analyzers.length;
    379411                        for(var i=0; i < l; i++) {
    380                                 var analyzer = this.analyzers[i];       
     412                                var analyzer = this.analyzers[i];
    381413                                if(analyzer.id == s) {
    382414                                        return analyzer;
    383415                                        continue;
    384                                 }       
    385                         }
    386                 }       
     416                                }
     417                        }
     418                }
    387419        },
    388420        utils: {
    389421                setParams: function(o) {
    390                          $.tableSorter.params = o;
     422                         jQuery.tableSorter.params = o;
    391423                },
    392424                getParams: function() {
    393                         return $.tableSorter.params;
     425                        return jQuery.tableSorter.params;
    394426                },
    395427                getElementText: function(o,type,index) {
    396                        
    397                         var defaults = $.tableSorter.utils.getParams();
     428                        if(!o) return "";
     429                        var defaults = jQuery.tableSorter.utils.getParams();
    398430                        var elementText = "";
    399                        
     431
    400432                        if(type == 'header') {
    401                                 elementText = $(o).text();     
    402                         } else if(type == 'columns') {
    403                                 if(typeof(defaults.textExtractionCustom) == "object" && typeof(defaults.textExtractionCustom[index]) == "function") {
     433                                elementText = jQuery(o).text();
     434                        } else if(type == 'columns') {
     435
     436                                if(defaults.textExtractionCustom && typeof(defaults.textExtractionCustom[index]) == "function") {
    404437                                        elementText = defaults.textExtractionCustom[index](o);
    405438                                } else {
    406                                         if(defaults.textExtraction == 'simple') {       
    407                                                 if(o.childNodes[0].hasChildNodes()) {
     439                                        if(defaults.textExtraction == 'simple') {
     440                                                if(o.childNodes[0] && o.childNodes[0].hasChildNodes()) {
    408441                                                        elementText = o.childNodes[0].innerHTML;
    409442                                                } else {
    410443                                                        elementText = o.innerHTML;
    411444                                                }
     445
    412446                                        } else if(defaults.textExtraction == 'complex') {
    413447                                                // make a jquery object, this will take forever with large tables.
    414                                                 elementText = $(o).text();
    415                                         }
    416                                 }
     448                                                elementText = jQuery(o).text();
     449                                        }
     450
     451                                }
     452
    417453                        }
    418454                        return elementText;
     
    420456                appendToTable: function(o,c,defaults,index,lastIndex) {
    421457                        var l = c.length;
    422                         $("tbody",o).empty().append(c);
    423                         /** jquery way, need to bench mark! */
     458                        jQuery("> tbody:first",o).empty().append(c);
     459                        /** jquery way, need to be benched mark! */
    424460                        if(defaults.stripingRowClass) {
    425461                                /** remove old! */
    426                                 $("tbody/tr",o).removeClass(defaults.stripingRowClass[0]).removeClass(defaults.stripingRowClass[1]);
     462                                jQuery("> tbody:first/tr",o).removeClass(defaults.stripingRowClass[0]).removeClass(defaults.stripingRowClass[1]);
    427463                                /** add new! */
    428                                 $.tableSorter.utils.stripRows(o,defaults);
     464                                jQuery.tableSorter.utils.stripRows(o,defaults);
    429465                        }
    430466                        if(defaults.highlightClass) {
    431467                                /**
    432468                                if(lastIndex != index && lastIndex > -1) {
    433                                         $("tbody/tr",o).find("td:eq(" + lastIndex + ")").removeClass(defaults.highlightClass).end();
     469                                        jQuery("tbody:first/tr",o).find("td:eq(" + lastIndex + ")").removeClass(defaults.highlightClass).end();
    434470                                }
    435471                                */
    436                                 $("tbody/tr",o).find("td:eq(" + index + ")").addClass(defaults.highlightClass).end();
     472                                jQuery("> tbody:first/tr",o).find("> td:eq(" + index + ")").addClass(defaults.highlightClass).end();
    437473                        }
    438474                        /** empty object, good practice! */
     
    440476                },
    441477                stripRows: function(o,defaults) {
    442                         $("tbody/tr:even",o).addClass(defaults.stripingRowClass[0]);
    443                         $("tbody/tr:odd",o).addClass(defaults.stripingRowClass[1]);
     478                        jQuery("> tbody:first/tr:visible:even",o).addClass(defaults.stripingRowClass[0]);
     479                        jQuery("> tbody:first/tr:visible:odd",o).addClass(defaults.stripingRowClass[1]);
    444480                },
    445481                isHeaderDisabled: function(o,arg,index) {
     
    447483                                return (arg == index)? true : false;
    448484                        } else if(typeof(arg) == "string") {
    449                                 return (arg.toLowerCase() == $.tableSorter.utils.getElementText(o,'header',index).toLowerCase()) ? true : false;
     485                                return (arg.toLowerCase() == jQuery.tableSorter.utils.getElementText(o,'header',index).toLowerCase()) ? true : false;
     486                        } else if(arg.parentNode) {
     487       return (o == arg) ? true : false
    450488                        } else if(typeof(arg) == "object") {
    451489                                var l = arg.length;
    452490                                if(!this.lastFound) { this.lastFound = -1; }
    453491                                for(var i=0; i < l; i++) {
    454                                         var val = $.tableSorter.utils.isHeaderDisabled(o,arg[i],index);
     492                                        var val = jQuery.tableSorter.utils.isHeaderDisabled(o,arg[i],index);
    455493                                        if(this.lastFound != i && val) {
    456494                                                this.lastFound = i;
     
    459497                                }
    460498                        } else {
    461                                 return false   
     499                                return false
    462500                        }
    463501                }
     
    467505                        return ((a[1] < b[1]) ? -1 : ((a[1] > b[1]) ? 1 : 0));
    468506                },
    469                 numeric: function(a,b) { 
     507                numeric: function(a,b) {
    470508                        return a[1]-b[1];
    471                 }               
     509                }
    472510        }
    473511};
    474512
    475 $.fn.wrapInner = function(o) {
     513jQuery.fn.wrapInner = function(o) {
    476514    return this.each(function(){
    477                  var jQ = $(this);
     515                 var jQ = jQuery(this);
    478516                 var c = jQ.html();
    479517                 jQ.empty().append(o.element).find(o.name).html(c).addClass(o.className).end();
    480518    });
    481 }; 
     519};
    482520
    483521/**
     
    489527}
    490528
    491 $.tableSorter.sorters.generic = function(a,b) {
     529jQuery.tableSorter.sorters.generic = function(a,b) {
    492530        return ((a[1] < b[1]) ? -1 : ((a[1] > b[1]) ? 1 : 0));
    493531};
    494 $.tableSorter.sorters.numeric = function(a,b) {
     532jQuery.tableSorter.sorters.numeric = function(a,b) {
    495533        return a[1]-b[1];
    496534};
    497 */$.tableSorter.parsers.generic = {
     535*/
     536
     537jQuery.tableSorter.parsers.generic = {
    498538        id: 'generic',
    499539        is: function(s) {
     
    504544        },
    505545        filter: 'text',
    506         sorter: $.tableSorter.sorters.generic
    507 };
    508 
    509 
    510 $.tableSorter.parsers.currency = {
     546        sorter: jQuery.tableSorter.sorters.generic
     547};
     548
     549jQuery.tableSorter.parsers.currency = {
    511550        id: 'currency',
    512551        is: function(s) {
     
    517556        },
    518557        filter: 'numeric',
    519         sorter: $.tableSorter.sorters.numeric
    520 };
    521 $.tableSorter.parsers.numeric = {
    522         id: 'numeric',
    523         is: function(s) {
    524                 return s.match(new RegExp(/^\b\d+\b$/));
    525         },
    526         format: function(s) {
    527                 return parseFloat(s);
     558        sorter: jQuery.tableSorter.sorters.numeric
     559};
     560jQuery.tableSorter.parsers.integer = {
     561        id: 'integer',
     562        is: function(s) {
     563                return s.match(new RegExp(/^\b\d+\d\b$/));
     564        },
     565        format: function(s) {
     566                return parseInt(s);
    528567        },
    529568        filter: 'numeric',
    530         sorter: $.tableSorter.sorters.numeric
    531 };
    532 $.tableSorter.parsers.ipAddress = {
     569        sorter: jQuery.tableSorter.sorters.numeric
     570};
     571jQuery.tableSorter.parsers.floating = {
     572        id: 'floating',
     573        is: function(s) {
     574                return s.match(new RegExp(/(\+|-)?[0-9]+\.[0-9]+((E|e)(\+|-)?[0-9]+)?/));
     575        },
     576        format: function(s) {
     577                return parseFloat(s.replace(new RegExp(/,/),''));
     578        },
     579        filter: 'numeric',
     580        sorter: jQuery.tableSorter.sorters.numeric
     581};
     582
     583jQuery.tableSorter.parsers.ipAddress = {
    533584        id: 'ipAddress',
    534585        is: function(s) {
     
    544595                                r += item;
    545596                   }
    546                 }       
     597                }
    547598                return parseFloat(r);
    548599        },
    549600        filter: 'numeric',
    550         sorter: $.tableSorter.sorters.numeric
    551 };
    552 $.tableSorter.parsers.url = {
     601        sorter: jQuery.tableSorter.sorters.numeric
     602};
     603jQuery.tableSorter.parsers.url = {
    553604        id: 'url',
    554605        is: function(s) {
     
    559610        },
    560611        filter: 'text',
    561         sorter: $.tableSorter.sorters.generic
    562 };
    563 $.tableSorter.parsers.isoDate = {
     612        sorter: jQuery.tableSorter.sorters.generic
     613};
     614jQuery.tableSorter.parsers.isoDate = {
    564615        id: 'isoDate',
    565616        is: function(s) {
    566                 return s.match(new RegExp(/^\d{4}[/-]\d{1,2}[/-]\d{1,2}$/));
     617                return s.match(new RegExp(/^\d{4}[\/-]\d{1,2}[\/-]\d{1,2}$/));
    567618        },
    568619        format: function(s) {
     
    570621        },
    571622        filter: 'date',
    572         sorter: $.tableSorter.sorters.numeric
    573 };
    574 $.tableSorter.parsers.usLongDate = {
     623        sorter: jQuery.tableSorter.sorters.numeric
     624};
     625jQuery.tableSorter.parsers.usLongDate = {
    575626        id: 'usLongDate',
    576627        is: function(s) {
     
    581632        },
    582633        filter: 'date',
    583         sorter: $.tableSorter.sorters.numeric
    584 }; 
    585 $.tableSorter.parsers.shortDate = {
     634        sorter: jQuery.tableSorter.sorters.numeric
     635};
     636jQuery.tableSorter.parsers.shortDate = {
    586637        id: 'shortDate',
    587638        is: function(s) {
    588                 return s.match(new RegExp(/^\d{1,2}[/-]\d{1,2}[/-]\d{4}$/));
     639                return s.match(new RegExp(/\d{1,2}[\/-]\d{1,2}[\/-]\d{2,4}/));
    589640        },
    590641        format: function(s) {
    591642                s = s.replace(new RegExp(/-/g),'/');
    592                 var defaults = $.tableSorter.utils.getParams();
     643                var defaults = jQuery.tableSorter.utils.getParams();
    593644                if(defaults.dateFormat == "mm/dd/yyyy" || defaults.dateFormat == "mm-dd-yyyy") {
    594645                        /** reformat the string in ISO format */
    595                         s = s.replace(new RegExp(/(\d{1,2})[/-](\d{1,2})[/-](\d{4})/), '$3/$1/$2');
     646                        s = s.replace(new RegExp(/(\d{1,2})[\/-](\d{1,2})[\/-](\d{4})/), '$3/$1/$2');
    596647                } else if(defaults.dateFormat == "dd/mm/yyyy" || defaults.dateFormat == "dd-mm-yyyy") {
    597648                        /** reformat the string in ISO format */
    598                         s = s.replace(new RegExp(/(\d{1,2})[/-](\d{1,2})[/-](\d{4})/), '$3/$2/$1');
     649                        s = s.replace(new RegExp(/(\d{1,2})[\/-](\d{1,2})[\/-](\d{4})/), '$3/$2/$1');
    599650                }
    600651                return parseFloat((new Date(s)).getTime());
    601652        },
    602653        filter: 'date',
    603         sorter: $.tableSorter.sorters.numeric
    604 };
    605 $.tableSorter.parsers.time = {
     654        sorter: jQuery.tableSorter.sorters.numeric
     655};
     656jQuery.tableSorter.parsers.time = {
    606657    id: 'time',
    607658    is: function(s) {
     
    612663    },
    613664    filter: 'date',
    614     sorter: $.tableSorter.sorters.numeric
    615 };
     665    sorter: jQuery.tableSorter.sorters.numeric
     666};
     667jQuery.tableSorter.parsers.checkbox = {
     668    id: 'input',
     669    is: function(s) {
     670        return s.toLowerCase().match(/<input[^>]*checkbox[^>]*/i);;
     671    },
     672    format: function(s) {
     673        var integer = 0;
     674        if(s.toLowerCase().match(/<input[^>]*checked*/i)) {
     675                integer = 1;
     676        }
     677        return integer;
     678    },
     679    filter: 'checkbox',
     680    sorter: jQuery.tableSorter.sorters.numeric
     681};
    616682
    617683/** add parsers */
    618 $.tableSorter.analyzer.add($.tableSorter.parsers.currency);
    619 $.tableSorter.analyzer.add($.tableSorter.parsers.numeric);
    620 $.tableSorter.analyzer.add($.tableSorter.parsers.isoDate);
    621 $.tableSorter.analyzer.add($.tableSorter.parsers.shortDate);
    622 $.tableSorter.analyzer.add($.tableSorter.parsers.usLongDate);
    623 $.tableSorter.analyzer.add($.tableSorter.parsers.ipAddress);
    624 $.tableSorter.analyzer.add($.tableSorter.parsers.url);
    625 $.tableSorter.analyzer.add($.tableSorter.parsers.time);
    626 $.tableSorter.filter = {
    627         data: {},
    628         setData: function(o) {
    629                 $.tableSorter.filter.data = o;
    630                
    631         },
    632         getData: function() {
    633                 return $.tableSorter.filter.data;
    634         },
    635         applyFilter: function(min,max) {
    636                 /**
    637                 var d = {
    638                                 f: f,
    639                                 data: flatData,
    640                                 type: p.filter,
    641                                 columnData: COLUMN_DATA,
    642                                 index: COLUMN_INDEX,
    643                                 lastIndex: COLUMN_LAST_INDEX
    644                         }
    645                 */
    646                 var opt = $.tableSorter.filter.getData();
    647                 //console.log('apply filter', opt.data);
    648                 if(opt.type == 'text') {
    649                         var filterData = opt.f.filter(opt.data,min);
    650                 } else if(opt.type == 'numeric' || opt.type == 'date') {
    651                         var filterData = opt.f.filter(opt.data,parseFloat(min),parseFloat(max));
    652                 }
    653                
    654                 //console.log('filterd:', filterData);
    655                 //var filterData = $.tableSorter.filter.numeric(flatData,600,700.0);
    656                 var columns = $.tableSorter.data.rebuild(opt.columnData,filterData,opt.index,opt.lastIndex);   
    657                 $.tableSorter.utils.appendToTable(opt.oTable,columns,opt.defaults,opt.index,opt.lastIndex);
    658                                
    659         },
    660         resetFilter: function() {
    661                 var opt = $.tableSorter.filter.getData();
    662                 var columns = $.tableSorter.data.rebuild(opt.columnData,opt.data,opt.index,opt.lastIndex);     
    663                 $.tableSorter.utils.appendToTable(opt.oTable,columns,opt.defaults,opt.index,opt.lastIndex);
    664         },
    665         numeric: {
    666                 render: function (o, min,max) {
    667                         o.append('<p>Enter starting range:</p>');
    668                         o.append('<div><input name="min" type="text" value="' + min + '"/></div>');
    669                         o.append('<p>Enter ending range:</p>');
    670                         o.append('<div><input name="max" type="text" value="' + max + '"/></div>');
    671                        
    672                 },
    673                 filter: function(data,min,max) {
    674         //console.log('inside filter! with data:', data);
    675                         var a = [];
    676                         var l = data.length;
    677                         //console.log('data length: ', l);
    678                        
    679                         for(var i=0; i < l; i++) {
    680                                 if(data[i][1] >= min && data[i][1] <= max) {
    681                                         a.push(data[i]);
    682                                 } 
    683                         }
    684                         return a;
    685                 }
    686         },
    687         date: {
    688                 render: function (o, min,max) {
    689                         var dMin = new Date(min);
    690                         var dMax = new Date(max);
    691                         o.append('<p>Select starting date:</p>');
    692                         o.append('<div>' + $.tableSorter.filter.utils.buildDate(dMin.getFullYear(),dMax.getFullYear(),'first') + '</div>');
    693                         o.append('<p>Select ending date:</p>');
    694                         o.append('<div>' + $.tableSorter.filter.utils.buildDate(dMin.getFullYear(),dMax.getFullYear(),'last') + '</div>');
    695                         o.append('<input type="hidden" name="min" value="' + min + '"/>');
    696                         o.append('<input type="hidden" name="max" value="' + max + '"/>');
    697                          
    698                 },
    699                 filter: function(data,min,max) {
    700        
    701                         var a = [];
    702                         var l = data.length;
    703                        
    704                         for(var i=0; i < l; i++) {
    705                                 if(data[i][1] >= min && data[i][1] <= max) {
    706                                         a.push(data[i]);
    707                                 } 
    708                         }
    709                         return a;
    710                 }
    711         },
    712         text: {
    713                 render: function (o,min,max) {
    714                         o.append('<p>'+search_string+'</p>');
    715                         o.append('<div><input type="text" name="min" value=""/></div>');
    716                        
    717                 },     
    718                 filter: function(data,value) {
    719                 //console.log('value:',value);
    720                         var a = [];
    721                         var l = data.length;
    722                         var s =  new RegExp(value.toLowerCase());
    723                         for(var i=0; i < l; i++) {
    724                                 if(data[i][1].match(s)) {
    725                                         a.push(data[i]);
    726                                 } 
    727                         }
    728                         return a;
    729                 }
    730         },
    731         utils: {
    732                 buildDate: function(start, end, selected) {
    733                         var html = "";
    734                         html += $.tableSorter.filter.utils.renderSelect(start,end,selected);
    735                         html += $.tableSorter.filter.utils.renderSelect(1,12);
    736                         html += $.tableSorter.filter.utils.renderSelect(1,31);
    737                         return html;
    738                        
    739                
    740                 },
    741                 renderSelect: function(s,e,selected) {
    742                         var html = "";
    743                         html +="<select>";
    744                         if(selected) {
    745                                
    746                         }
    747                         for(var i=s; i <= e; i++) {
    748                                
    749                                 if(i == e && selected == 'last') {
    750                                         html +="<option selected='selected'>" + i + "</option>";
    751                                 } else if(i == 0 && selected == 'first') {
    752                                         html +="<option selected='selected'>" + i + "</option>";
    753                                 }else {
    754                                         html +="<option>" + i + "</option>";
    755                                 }
    756                         }
    757                         html +="</select>";
    758                         return html;
    759                 }
    760         }
    761 };
     684jQuery.tableSorter.analyzer.add(jQuery.tableSorter.parsers.currency);
     685jQuery.tableSorter.analyzer.add(jQuery.tableSorter.parsers.integer);
     686jQuery.tableSorter.analyzer.add(jQuery.tableSorter.parsers.floating);
     687jQuery.tableSorter.analyzer.add(jQuery.tableSorter.parsers.isoDate);
     688jQuery.tableSorter.analyzer.add(jQuery.tableSorter.parsers.shortDate);
     689jQuery.tableSorter.analyzer.add(jQuery.tableSorter.parsers.usLongDate);
     690jQuery.tableSorter.analyzer.add(jQuery.tableSorter.parsers.ipAddress);
     691jQuery.tableSorter.analyzer.add(jQuery.tableSorter.parsers.url);
     692jQuery.tableSorter.analyzer.add(jQuery.tableSorter.parsers.time);
     693jQuery.tableSorter.analyzer.add(jQuery.tableSorter.parsers.checkbox);
Note: See TracChangeset for help on using the changeset viewer.