Difference between revisions of "MediaWiki:Common.js"

From LIMSWiki
Jump to navigationJump to search
Line 1: Line 1:
/* Any JavaScript here will be loaded for all users on every page load. */
/* Any JavaScript here will be loaded for all users on every page load. */
/*
/*
SortTable
Table sorting script  by Joost de Valk, check it out at http://www.joostdevalk.nl/code/sortable-table/.
  version 2.1
Based on a script from http://www.kryogenix.org/code/browser/sorttable/.
  7th April 2007
Distributed under the MIT license: http://www.kryogenix.org/code/browser/licence.html .
  Stuart Langridge, http://www.kryogenix.org/code/browser/sorttable/


  19 Feb 2008
Copyright (c) 1997-2007 Stuart Langridge, Joost de Valk.
  Fixed some jslint errors to support DokuWiki (http://www.splitbrain.org) js compression


  function reinitsort()
Version 1.5.7
  sorttable.reinit
  added by Otto Vainio to allow sort tables updated with javascript.
  Otto Vainio (otto@valjakko.net)
 
  27.11.2008
  Changed line 77 document.getElementsByTagName('table') to div.getElementsByTagName('table')
  To allow multiple sortable tables in same page
  (Thanks to Hans Sampiemon)
 
  14.1.2009
  Added option for default sorting.
  Use dokuwiki event registration.
 
  27.1.2009
  Cleaned some jlint errors to make this workable, when css+js compress is set in dokuwiki
 
  10.5.2011
* version 2.5 Fixed problems with secionediting, footnotes and edittable
 
  Instructions:
  Used from dokuwiki
  Click on the headers to sort
 
  Thanks to many, many people for contributions and suggestions.
  Licenced as X11: http://www.kryogenix.org/code/browser/licence.html
  This basically means: do what you want with it.
*/
*/
var stIsIE = /*@cc_on!@*/false;
var tableid = 0;


sorttable = {
/* You can change these values */
  reinit: function() {
var image_path = "http://www.joostdevalk.nl/code/sortable-table/";
    arguments.callee.done = true;
var image_up = "arrow-up.gif";
    // kill the timer
var image_down = "arrow-down.gif";
    if (_timer) {clearInterval(_timer);}
var image_none = "arrow-none.gif";
   
var europeandate = false;
    if (!document.createElement || !document.getElementsByTagName) {return;}
var alternate_row_colors = true;
   
//    sorttable.DATE_RE = /^(\d\d?)[\/\.\-](\d\d?)[\/\.\-]((\d\d)?\d\d)$/;
    sorttable.DATE_RE = /^(\d\d?)[\/\.\-](\d\d?)[\/\.\-]((\d\d)?\d\d)( (\d\d?)[:\.]?(\d\d?))?$/;


   
/* Don't change anything below this unless you know what you're doing */
    forEach(document.getElementsByTagName('table'), function(table) {
addEvent(window, "load", sortables_init);
      if (table.className.search(/\bsortable\b/) != -1) {
        sorttable.makeSortable(table);
      }
    });
    forEach(document.getElementsByTagName('div'), function(div) {
      if (div.className.search(/\bsortable\b/) != -1) {
        sorttable.makeSortablediv(div);
      }
    });
  },


  init: function() {
var SORT_COLUMN_INDEX;
    // quit if this function has already been called
var thead = false;
    if (arguments.callee.done) {return;}
    // flag this function so we don't do the same thing twice
    arguments.callee.done = true;
    // kill the timer
    if (_timer) {clearInterval(_timer);}
   
    if (!document.createElement || !document.getElementsByTagName) {return;}
   
//    sorttable.DATE_RE = /^(\d\d?)[\/\.\-](\d\d?)[\/\.\-]((\d\d)?\d\d)$/;
    sorttable.DATE_RE = /^(\d\d?)[\/\.\-](\d\d?)[\/\.\-]((\d\d)?\d\d)( (\d\d?):?(\d\d?))?$/;
   
    forEach(document.getElementsByTagName('table'), function(table) {
      if (table.className.search(/\bsortable\b/) != -1) {
        sorttable.makeSortable(table);
      }
    });
    forEach(document.getElementsByTagName('div'), function(div) {
      if (div.className.search(/\bsortable\b/) != -1) {
        sorttable.makeSortablediv(div);
      }
    });
   
  },
  makeSortablediv: function(div) {
        if (div.getElementsByTagName('table').length === 0) {
        } else {
          forEach(div.getElementsByTagName('table'), function(table) {
            colid=div.className;
            overs = new Array();
            var patt1=/\bcol_\d_[a-z]+/gi;
            var overs = new Array();
            if (colid.search(patt1) != -1) {
              var overrides = new Array();
              overrides = colid.match(patt1);
              var xo="";
              for (xo in overrides)
              {
                if (xo == "")
                {
                } else {
                  try
                  {
                    var tmp = overrides[xo].split("_");
                    var ind = tmp[1];
                    var val = tmp[2];
                    overs[ind]=val;
                 
                  }
                  catch (e)
                  {
                  }
                }
              }
              colid = colid.replace(patt1,'');
            }
            sorttable.makeSortable(table,overs);
            if (colid.search(/\bsort/) != -1) {
              colid = colid.replace('sortable','');
              colid = colid.replace(' sort','');
              if (!colid != '')
              {
                colid = colid.trim();
              }
              revs=false;
              if (colid.search(/\br/) != -1) {
                revs=true;
                colid = colid.replace('r','');
              }
              sorttable.defaultSort(table,colid,revs);
            }
          });
        }
  },
  defaultSort: function(table, colid, revs) {
//    theadrow = table.tHead.rows[0].cells;
    theadrow = table.rows[0].cells;
    colid--;
    colname ="col"+colid;
    // remove sorttable_sorted classes
    var thiscell=false;
    forEach(theadrow, function(cell) {
      colclass=cell.className;             
      classname = colclass.split(" ");     
      if (classname[0]==colname)           
//      if (cell.className==colname)
      {
        thiscell=cell;
      }
//      if (cell.nodeType == 1) { // an element
//        cell.className = cell.className.replace('sorttable_sorted_reverse','');
//        cell.className = cell.className.replace('sorttable_sorted','');
//      }
    });
    if (thiscell===false) {return;}
    sortfwdind = document.getElementById('sorttable_sortfwdind');
    if (sortfwdind) { sortfwdind.parentNode.removeChild(sortfwdind); }
    sortrevind = document.getElementById('sorttable_sortrevind');
    if (sortrevind) { sortrevind.parentNode.removeChild(sortrevind); }
   
    thiscell.className += ' sorttable_sorted';
    sortfwdind = document.createElement('span');
    sortfwdind.id = "sorttable_sortfwdind";
    sortfwdind.innerHTML = stIsIE ? '&nbsp<font face="webdings">6</font>' : '&nbsp;&#x25BE;';
    thiscell.appendChild(sortfwdind);
    // build an array to sort. This is a Schwartzian transform thing,
    // i.e., we "decorate" each row with the actual sort key,
    // sort based on the sort keys, and then put the rows back in order
    // which is a lot faster because you only do getInnerText once per row
    row_array = [];
    col = thiscell.sorttable_columnindex;
    rows = thiscell.sorttable_tbody.rows;
    for (var j=1; j<rows.length; j++) {
      row_array[row_array.length] = [sorttable.getInnerText(rows[j].cells[col]), rows[j]];
    }
    /* If you want a stable sort, uncomment the following line */
    //sorttable.shaker_sort(row_array, this.sorttable_sortfunction);
    /* and comment out this one */
    row_array.sort(thiscell.sorttable_sortfunction);
   
    tb = thiscell.sorttable_tbody;
    for (var jj=0; jj<row_array.length; jj++) {
      tb.appendChild(row_array[jj][1]);
    }
   
    delete row_array;
    // If reverse sort wanted, then doit
    if (revs) {
      // reverse the table, which is quicker
      sorttable.reverse(thiscell.sorttable_tbody);
      thiscell.className = thiscell.className.replace('sorttable_sorted',
                                                      'sorttable_sorted_reverse');
      thiscell.removeChild(document.getElementById('sorttable_sortfwdind'));
      sortrevind = document.createElement('span');
      sortrevind.id = "sorttable_sortrevind";
      sortrevind.innerHTML = stIsIE ? '&nbsp<font face="webdings">5</font>' : '&nbsp;&#x25B4;';
      thiscell.appendChild(sortrevind);
    }


function sortables_init() {
// Find all tables with class sortable and make them sortable
if (!document.getElementsByTagName) return;
tbls = document.getElementsByTagName("table");
for (ti=0;ti<tbls.length;ti++) {
thisTbl = tbls[ti];
if (((' '+thisTbl.className+' ').indexOf("sortable") != -1) && (thisTbl.id)) {
ts_makeSortable(thisTbl);
}
}
}


function ts_makeSortable(t) {
if (t.rows && t.rows.length > 0) {
if (t.tHead && t.tHead.rows.length > 0) {
var firstRow = t.tHead.rows[t.tHead.rows.length-1];
thead = true;
} else {
var firstRow = t.rows[0];
}
}
if (!firstRow) return;
// We have a first row: assume it's the header, and make its contents clickable links
for (var i=0;i<firstRow.cells.length;i++) {
var cell = firstRow.cells[i];
var txt = ts_getInnerText(cell);
if (cell.className != "unsortable" && cell.className.indexOf("unsortable") == -1) {
cell.innerHTML = '<a href="#" class="sortheader" onclick="ts_resortTable(this, '+i+');return false;">'+txt+'<span class="sortarrow">&nbsp;&nbsp;<img src="'+ image_path + image_none + '" alt="&darr;"/></span></a>';
}
}
if (alternate_row_colors) {
alternate(t);
}
}


  },
function ts_getInnerText(el) {
if (typeof el == "string") return el;
if (typeof el == "undefined") { return el };
if (el.innerText) return el.innerText; //Not needed but it is faster
var str = "";
var cs = el.childNodes;
var l = cs.length;
for (var i = 0; i < l; i++) {
switch (cs[i].nodeType) {
case 1: //ELEMENT_NODE
str += ts_getInnerText(cs[i]);
break;
case 3: //TEXT_NODE
str += cs[i].nodeValue;
break;
}
}
return str;
}


  makeSortable: function(table,overrides) {
function ts_resortTable(lnk, clid) {
//    tableid++;
var span;
/*
for (var ci=0;ci<lnk.childNodes.length;ci++) {
    if (table.getElementsByTagName('thead').length === 0) {
if (lnk.childNodes[ci].tagName && lnk.childNodes[ci].tagName.toLowerCase() == 'span') span = lnk.childNodes[ci];
      // table doesn't have a tHead. Since it should have, create one and
}
      // put the first table row in it.
var spantext = ts_getInnerText(span);
      the = document.createElement('thead');
var td = lnk.parentNode;
      the.appendChild(table.rows[0]);
var column = clid || td.cellIndex;
      table.insertBefore(the,table.firstChild);
var t = getParent(td,'TABLE');
    }
// Work out a type for the column
*/
if (t.rows.length <= 1) return;
    // Safari doesn't support table.tHead, sigh
var itm = "";
/*
var i = 0;
    if (table.tHead === null) {table.tHead = table.getElementsByTagName('thead')[0];}
while (itm == "" && i < t.tBodies[0].rows.length) {
      
var itm = ts_getInnerText(t.tBodies[0].rows[i].cells[column]);
     if (table.tHead.rows.length != 1) {return;} // can't cope with two header rows
itm = trim(itm);
  */
if (itm.substr(0,4) == "<!--" || itm.length == 0) {
//    table.tHead.className += ' tableid'+tableid;
itm = "";
}
i++;
}
if (itm == "") return;
sortfn = ts_sort_caseinsensitive;
if (itm.match(/^\d\d[\/\.-][a-zA-z][a-zA-Z][a-zA-Z][\/\.-]\d\d\d\d$/)) sortfn = ts_sort_date;
if (itm.match(/^\d\d[\/\.-]\d\d[\/\.-]\d\d\d{2}?$/)) sortfn = ts_sort_date;
if (itm.match(/^-?[£$€Û¢´]\d/)) sortfn = ts_sort_numeric;
if (itm.match(/^-?(\d+[,\.]?)+(E[-+][\d]+)?%?$/)) sortfn = ts_sort_numeric;
SORT_COLUMN_INDEX = column;
var firstRow = new Array();
var newRows = new Array();
for (k=0;k<t.tBodies.length;k++) {
for (i=0;i<t.tBodies[k].rows[0].length;i++) {
firstRow[i] = t.tBodies[k].rows[0][i];  
}
}
for (k=0;k<t.tBodies.length;k++) {
if (!thead) {
// Skip the first row
for (j=1;j<t.tBodies[k].rows.length;j++) {
newRows[j-1] = t.tBodies[k].rows[j];
}
} else {
// Do NOT skip the first row
for (j=0;j<t.tBodies[k].rows.length;j++) {
newRows[j] = t.tBodies[k].rows[j];
}
}
}
newRows.sort(sortfn);
if (span.getAttribute("sortdir") == 'down') {
ARROW = '&nbsp;&nbsp;<img src="'+ image_path + image_down + '" alt="&darr;"/>';
newRows.reverse();
span.setAttribute('sortdir','up');
} else {
ARROW = '&nbsp;&nbsp;<img src="'+ image_path + image_up + '" alt="&uarr;"/>';
span.setAttribute('sortdir','down');
}
    // We appendChild rows that already exist to the tbody, so it moves them rather than creating new ones
    // don't do sortbottom rows
    for (i=0; i<newRows.length; i++) {
if (!newRows[i].className || (newRows[i].className && (newRows[i].className.indexOf('sortbottom') == -1))) {
t.tBodies[0].appendChild(newRows[i]);
}
}
     // do sortbottom rows only
     for (i=0; i<newRows.length; i++) {
if (newRows[i].className && (newRows[i].className.indexOf('sortbottom') != -1))
t.tBodies[0].appendChild(newRows[i]);
}
// Delete any other arrows there may be showing
var allspans = document.getElementsByTagName("span");
for (var ci=0;ci<allspans.length;ci++) {
if (allspans[ci].className == 'sortarrow') {
if (getParent(allspans[ci],"table") == getParent(lnk,"table")) { // in the same table as us?
allspans[ci].innerHTML = '&nbsp;&nbsp;<img src="'+ image_path + image_none + '" alt="&darr;"/>';
}
}
}
span.innerHTML = ARROW;
alternate(t);
}


    // Sorttable v1 put rows with a class of "sortbottom" at the bottom (as
function getParent(el, pTagName) {
    // "total" rows, for example). This is B&R, since what you're supposed
if (el == null) {
    // to do is put them in a tfoot. So, if there are sortbottom rows,
return null;
    // for backwards compatibility, move them to tfoot (creating it if needed).
} else if (el.nodeType == 1 && el.tagName.toLowerCase() == pTagName.toLowerCase()) {
    /*
return el;
    sortbottomrows = [];
} else {
    for (var i=0; i<table.rows.length; i++) {
return getParent(el.parentNode, pTagName);
      if (table.rows[i].className.search(/\bsortbottom\b/) != -1) {
}
        sortbottomrows[sortbottomrows.length] = table.rows[i];
}
      }
    }
    if (sortbottomrows) {
      if (table.tFoot === null) {
        // table doesn't have a tfoot. Create one.
        tfo = document.createElement('tfoot');
        table.appendChild(tfo);
      }
      for (var ii=0; ii<sortbottomrows.length; ii++) {
        tfo.appendChild(sortbottomrows[ii]);
      }
      delete sortbottomrows;
    }
    */
    // work through each column and calculate its type
//    headrow = table.tHead.rows[0].cells;
    headrow = table.rows[0].cells;
//    for (var i=0; i<headrow.length; i++) {
    for (i=0; i<headrow.length; i++) {
      // manually override the type with a sorttable_type attribute
      var colOptions="";
      if (overrides[i+1])
      {
        colOptions=overrides[i+1];
      }
      if (!colOptions.match(/\bnosort\b/)) { // skip this col
        mtch = colOptions.match(/\b[a-z0-9]+\b/);
        if (mtch) { override = mtch[0]; }
        if (mtch && typeof sorttable["sort_"+override] == 'function') {
          headrow[i].sorttable_sortfunction = sorttable["sort_"+override];
        } else {
          headrow[i].sorttable_sortfunction = sorttable.guessType(table,i);
        }
/*     
      if (!headrow[i].className.match(/\bsorttable_nosort\b/)) { // skip this col
        mtch = headrow[i].className.match(/\bsorttable_([a-z0-9]+)\b/);
        if (mtch) { override = mtch[1]; }
        if (mtch && typeof sorttable["sort_"+override] == 'function') {
          headrow[i].sorttable_sortfunction = sorttable["sort_"+override];
        } else {
          headrow[i].sorttable_sortfunction = sorttable.guessType(table,i);
        }
*/
        // make it clickable to sort
        headrow[i].sorttable_columnindex = i;
        headrow[i].sorttable_tbody = table.tBodies[0];
//        dean_addEvent(headrow[i],"click", function(e) {
        addEvent(headrow[i],"click", function(e) {


          theadrow = this.parentNode;
function sort_date(date) {
// y2k notes: two digit years less than 50 are treated as 20XX, greater than 50 are treated as 19XX
dt = "00000000";
if (date.length == 11) {
mtstr = date.substr(3,3);
mtstr = mtstr.toLowerCase();
switch(mtstr) {
case "jan": var mt = "01"; break;
case "feb": var mt = "02"; break;
case "mar": var mt = "03"; break;
case "apr": var mt = "04"; break;
case "may": var mt = "05"; break;
case "jun": var mt = "06"; break;
case "jul": var mt = "07"; break;
case "aug": var mt = "08"; break;
case "sep": var mt = "09"; break;
case "oct": var mt = "10"; break;
case "nov": var mt = "11"; break;
case "dec": var mt = "12"; break;
// default: var mt = "00";
}
dt = date.substr(7,4)+mt+date.substr(0,2);
return dt;
} else if (date.length == 10) {
if (europeandate == false) {
dt = date.substr(6,4)+date.substr(0,2)+date.substr(3,2);
return dt;
} else {
dt = date.substr(6,4)+date.substr(3,2)+date.substr(0,2);
return dt;
}
} else if (date.length == 8) {
yr = date.substr(6,2);
if (parseInt(yr) < 50) {
yr = '20'+yr;
} else {
yr = '19'+yr;
}
if (europeandate == true) {
dt = yr+date.substr(3,2)+date.substr(0,2);
return dt;
} else {
dt = yr+date.substr(0,2)+date.substr(3,2);
return dt;
}
}
return dt;
}


          if (this.className.search(/\bsorttable_sorted\b/) != -1) {
function ts_sort_date(a,b) {
            // if we're already sorted by this column, just
dt1 = sort_date(ts_getInnerText(a.cells[SORT_COLUMN_INDEX]));
            // reverse the table, which is quicker
dt2 = sort_date(ts_getInnerText(b.cells[SORT_COLUMN_INDEX]));
            sorttable.reverse(this.sorttable_tbody);
            this.className = this.className.replace('sorttable_sorted',
if (dt1==dt2) {
                                                    'sorttable_sorted_reverse');
return 0;
            sortfwdind = document.getElementById('sorttable_sortfwdind');
}
            if (sortfwdind) { sortfwdind.parentNode.removeChild(sortfwdind); }
if (dt1<dt2) {  
//            this.removeChild(document.getElementById('sorttable_sortfwdind'));
return -1;
            sortrevind = document.getElementById('sorttable_sortrevind');
}
            if (sortrevind) { sortrevind.parentNode.removeChild(sortrevind); }
return 1;
            sortrevind = document.createElement('span');
}
            sortrevind.id = "sorttable_sortrevind";
function ts_sort_numeric(a,b) {
            sortrevind.innerHTML = stIsIE ? '&nbsp<font face="webdings">5</font>' : '&nbsp;&#x25B4;';
var aa = ts_getInnerText(a.cells[SORT_COLUMN_INDEX]);
            this.appendChild(sortrevind);
aa = clean_num(aa);
            return;
var bb = ts_getInnerText(b.cells[SORT_COLUMN_INDEX]);
          }
bb = clean_num(bb);
          if (this.className.search(/\bsorttable_sorted_reverse\b/) != -1) {
return compare_numeric(aa,bb);
            // if we're already sorted by this column in reverse, just
}
            // re-reverse the table, which is quicker
function compare_numeric(a,b) {
            sorttable.reverse(this.sorttable_tbody);
var a = parseFloat(a);
            this.className = this.className.replace('sorttable_sorted_reverse',
a = (isNaN(a) ? 0 : a);
                                                    'sorttable_sorted');
var b = parseFloat(b);
            sortrevind = document.getElementById('sorttable_sortrevind');
b = (isNaN(b) ? 0 : b);
            if (sortrevind) { sortrevind.parentNode.removeChild(sortrevind); }
return a - b;
//            this.removeChild(document.getElementById('sorttable_sortrevind'));
}
            sortfwdind = document.getElementById('sorttable_sortfwdind');
function ts_sort_caseinsensitive(a,b) {
            if (sortfwdind) { sortfwdind.parentNode.removeChild(sortfwdind); }
aa = ts_getInnerText(a.cells[SORT_COLUMN_INDEX]).toLowerCase();
            sortfwdind = document.createElement('span');
bb = ts_getInnerText(b.cells[SORT_COLUMN_INDEX]).toLowerCase();
            sortfwdind.id = "sorttable_sortfwdind";
if (aa==bb) {
            sortfwdind.innerHTML = stIsIE ? '&nbsp<font face="webdings">6</font>' : '&nbsp;&#x25BE;';
return 0;
            this.appendChild(sortfwdind);
}
            return;
if (aa<bb) {
          }
return -1;
         
}
          // remove sorttable_sorted classes
return 1;
//          theadrow = this.parentNode;
}
          forEach(theadrow.childNodes, function(cell) {
function ts_sort_default(a,b) {
            if (cell.nodeType == 1) { // an element
aa = ts_getInnerText(a.cells[SORT_COLUMN_INDEX]);
              cell.className = cell.className.replace('sorttable_sorted_reverse','');
bb = ts_getInnerText(b.cells[SORT_COLUMN_INDEX]);
              cell.className = cell.className.replace('sorttable_sorted','');
if (aa==bb) {
            }
return 0;
          });
}
          sortfwdind = document.getElementById('sorttable_sortfwdind');
if (aa<bb) {
          if (sortfwdind) { sortfwdind.parentNode.removeChild(sortfwdind); }
return -1;
          sortrevind = document.getElementById('sorttable_sortrevind');
}
          if (sortrevind) { sortrevind.parentNode.removeChild(sortrevind); }
return 1;
         
}
          this.className += ' sorttable_sorted';
function addEvent(elm, evType, fn, useCapture)
          sortfwdind = document.createElement('span');
// addEvent and removeEvent
          sortfwdind.id = "sorttable_sortfwdind";
// cross-browser event handling for IE5+, NS6 and Mozilla
          sortfwdind.innerHTML = stIsIE ? '&nbsp<font face="webdings">6</font>' : '&nbsp;&#x25BE;';
// By Scott Andrew
          this.appendChild(sortfwdind);
{
 
if (elm.addEventListener){
          // build an array to sort. This is a Schwartzian transform thing,
elm.addEventListener(evType, fn, useCapture);
          // i.e., we "decorate" each row with the actual sort key,
return true;
          // sort based on the sort keys, and then put the rows back in order
} else if (elm.attachEvent){
          // which is a lot faster because you only do getInnerText once per row
var r = elm.attachEvent("on"+evType, fn);
          row_array = [];
return r;
          col = this.sorttable_columnindex;
} else {
          rows = this.sorttable_tbody.rows;
alert("Handler could not be removed");
          for (var j=1; j<rows.length; j++) {
}
            row_array[row_array.length] = [sorttable.getInnerText(rows[j].cells[col]), rows[j]];
}
          }
function clean_num(str) {
          /* If you want a stable sort, uncomment the following line */
str = str.replace(new RegExp(/[^-?0-9.]/g),"");
          //sorttable.shaker_sort(row_array, this.sorttable_sortfunction);
return str;
          /* and comment out this one */
}
          row_array.sort(this.sorttable_sortfunction);
function trim(s) {
         
return s.replace(/^\s+|\s+$/g, "");
          tb = this.sorttable_tbody;
          for (var j3=0; j3<row_array.length; j3++) {
            tb.appendChild(row_array[j3][1]);
          }
         
          delete row_array;
        });
      }
    }
  },
 
  guessType: function(table, column) {
    // guess the type of a column based on its first non-blank row
    sortfn = sorttable.sort_alpha;
    for (var i=0; i<table.tBodies[0].rows.length; i++) {
      text = sorttable.getInnerText(table.tBodies[0].rows[i].cells[column]);
      if (text !== '') {
        if (text.match(/^-?[£$¤]?[\d,.]+[%€]?$/)) {
          return sorttable.sort_numeric;
        }
        // check for a date: dd/mm/yyyy or dd/mm/yy
        // can have / or . or - as separator
        // can be mm/dd as well
        possdate = text.match(sorttable.DATE_RE);
        if (possdate) {
          // looks like a date
          first = parseInt(possdate[1]);
          second = parseInt(possdate[2]);
          if (first > 12) {
            // definitely dd/mm
            return sorttable.sort_ddmm;
          } else if (second > 12) {
            return sorttable.sort_mmdd;
          } else {
            // looks like a date, but we can't tell which, so assume
            // that it's dd/mm (English imperialism!) and keep looking
            sortfn = sorttable.sort_ddmm;
          }
        }
      }
    }
    return sortfn;
  },
 
  getInnerText: function(node) {
    // gets the text we want to use for sorting for a cell.
    // strips leading and trailing whitespace.
    // this is *not* a generic getInnerText function; it's special to sorttable.
    // for example, you can override the cell text with a customkey attribute.
    // it also gets .value for <input> fields.
   
    hasInputs = (typeof node.getElementsByTagName == 'function') &&
                node.getElementsByTagName('input').length;
   
    if (node.getAttribute("sorttable_customkey") !== null) {
      return node.getAttribute("sorttable_customkey");
    }
    else if (typeof node.textContent != 'undefined' && !hasInputs) {
      return node.textContent.replace(/^\s+|\s+$/g, '');
    }
    else if (typeof node.innerText != 'undefined' && !hasInputs) {
      return node.innerText.replace(/^\s+|\s+$/g, '');
    }
    else if (typeof node.text != 'undefined' && !hasInputs) {
      return node.text.replace(/^\s+|\s+$/g, '');
    }
    else {
      switch (node.nodeType) {
        case 3:
          if (node.nodeName.toLowerCase() == 'input') {
            return node.value.replace(/^\s+|\s+$/g, '');
          }
        case 4:
          return node.nodeValue.replace(/^\s+|\s+$/g, '');
          break;
        case 1:
        case 11:
          var innerText = '';
          for (var i = 0; i < node.childNodes.length; i++) {
            innerText += sorttable.getInnerText(node.childNodes[i]);
          }
          return innerText.replace(/^\s+|\s+$/g, '');
          break;
        default:
          return '';
      }
    }
  },
 
  reverse: function(tbody) {
    // reverse the rows in a tbody
    newrows = [];
    for (var i=0; i<tbody.rows.length; i++) {
      newrows[newrows.length] = tbody.rows[i];
    }
    for (var i=newrows.length-1; i>=1; i--) {
      tbody.appendChild(newrows[i]);
    }
    delete newrows;
  },
 
  /* sort functions
    each sort function takes two parameters, a and b
    you are comparing a[0] and b[0] */
  sort_numeric: function(a,b) {
    aa = parseFloat(a[0].replace(/[^0-9.\-]/g,''));
    if (isNaN(aa)) {aa = 0;}
    bb = parseFloat(b[0].replace(/[^0-9.\-]/g,''));  
    if (isNaN(bb)) {bb = 0;}
    return aa-bb;
  },
  sort_alpha: function(a,b) {
    if (a[0]==b[0]) {return 0;}
    if (a[0]<b[0]) {return -1;}
    return 1;
  },
  sort_ddmm: function(a,b) {
    mtch = a[0].match(sorttable.DATE_RE);
    y = mtch[3]; m = mtch[2]; d = mtch[1];
    t = mtch[5]+'';
    if (t.length < 1 ) {t = '';}
    if (m.length == 1) {m = '0'+m;}
    if (d.length == 1) {d = '0'+d;}
    dt1 = y+m+d+t;
    mtch = b[0].match(sorttable.DATE_RE);
    y = mtch[3]; m = mtch[2]; d = mtch[1];
    t = mtch[5]+'';
    if (t.length < 1 ) {t = '';}
    if (m.length == 1) {m = '0'+m;}
    if (d.length == 1) {d = '0'+d;}
    dt2 = y+m+d+t;
    if (dt1==dt2) {return 0;}
    if (dt1<dt2) {return -1;}
    return 1;
  },
  sort_mmdd: function(a,b) {
    mtch = a[0].match(sorttable.DATE_RE);
    y = mtch[3]; d = mtch[2]; m = mtch[1];
    t = mtch[5]+'';
    if (m.length == 1) {m = '0'+m;}
    if (d.length == 1) {d = '0'+d;}
    dt1 = y+m+d+t;
    mtch = b[0].match(sorttable.DATE_RE);
    y = mtch[3]; d = mtch[2]; m = mtch[1];
    t = mtch[5]+'';
    if (t.length < 1 ) {t = '';}
    if (m.length == 1) {m = '0'+m;}
    if (d.length == 1) {d = '0'+d;}
    dt2 = y+m+d+t;
    if (dt1==dt2) {return 0;}
    if (dt1<dt2) {return -1;}
    return 1;
  },
 
  shaker_sort: function(list, comp_func) {
    // A stable sort function to allow multi-level sorting of data
    // see: http://en.wikipedia.org/wiki/Cocktail_sort
    // thanks to Joseph Nahmias
    var b = 0;
    var t = list.length - 1;
    var swap = true;
 
    while(swap) {
        swap = false;
        for(var i = b; i < t; ++i) {
            if ( comp_func(list[i], list[i+1]) > 0 ) {
                var q = list[i]; list[i] = list[i+1]; list[i+1] = q;
                swap = true;
            }
        } // for
        t--;
 
        if (!swap) {break;}
 
        for(var i = t; i > b; --i) {
            if ( comp_func(list[i], list[i-1]) < 0 ) {
                var q = list[i]; list[i] = list[i-1]; list[i-1] = q;
                swap = true;
            }
        } // for
        b++;
 
    } // while(swap)
  }
 
 
};
/* ******************************************************************
  Supporting functions: bundled here to avoid depending on a library
  ****************************************************************** */
 
 
 
// Dean Edwards/Matthias Miller/John Resig
 
 
// Dean's forEach: http://dean.edwards.name/base/forEach.js
/*
  forEach, version 1.0
  Copyright 2006, Dean Edwards
  License: http://www.opensource.org/licenses/mit-license.php
*/
 
// array-like enumeration
if (!Array.forEach) { // mozilla already supports this
  Array.forEach = function(array, block, context) {
    for (var i = 0; i < array.length; i++) {
      block.call(context, array[i], i, array);
    }
  };
}
}
 
function alternate(table) {
// generic enumeration
// Take object table and get all it's tbodies.
Function.prototype.forEach = function(object, block, context) {
var tableBodies = table.getElementsByTagName("tbody");
  for (var key in object) {
// Loop through these tbodies
    if (typeof this.prototype[key] == "undefined") {
for (var i = 0; i < tableBodies.length; i++) {
      block.call(context, object[key], key, object);
// Take the tbody, and get all it's rows
    }
var tableRows = tableBodies[i].getElementsByTagName("tr");
  }
// Loop through these rows
};
// Start at 1 because we want to leave the heading row untouched
 
for (var j = 0; j < tableRows.length; j++) {
// character enumeration
// Check if j is even, and apply classes for both possible results
String.forEach = function(string, block, context) {
if ( (j % 2) == 0  ) {
  Array.forEach(string.split(""), function(chr, index) {
if ( !(tableRows[j].className.indexOf('odd') == -1) ) {
    block.call(context, chr, index, string);
tableRows[j].className = tableRows[j].className.replace('odd', 'even');
  });
} else {
};
if ( tableRows[j].className.indexOf('even') == -1 ) {
 
tableRows[j].className += " even";
// globally resolve forEach enumeration
}
var forEach = function(object, block, context) {
}
  if (object) {
} else {
    var resolve = Object; // default
if ( !(tableRows[j].className.indexOf('even') == -1) ) {
    if (object instanceof Function) {
tableRows[j].className = tableRows[j].className.replace('even', 'odd');
      // functions have a "length" property
} else {
      resolve = Function;
if ( tableRows[j].className.indexOf('odd') == -1 ) {
    } else if (object.forEach instanceof Function) {
tableRows[j].className += " odd";
      // the object implements a custom forEach method so use that
}
      object.forEach(block, context);
}
      return;
}
    } else if (typeof object == "string") {
}
      // the object is a string
}
      resolve = String;
    } else if (typeof object.length == "number") {
      // the object is array-like
      resolve = Array;
    }
    resolve.forEach(object, block, context);
  }
};
 
 
if ('undefined' != typeof(window.addEvent)) {
    window.addEvent(window, 'load', sorttable.init);
} // if
 
//sorttable.init;
 
function reinitsort() {
  sorttable.reinit();
}
}

Revision as of 23:49, 17 May 2011

/* Any JavaScript here will be loaded for all users on every page load. */
/*
Table sorting script  by Joost de Valk, check it out at http://www.joostdevalk.nl/code/sortable-table/.
Based on a script from http://www.kryogenix.org/code/browser/sorttable/.
Distributed under the MIT license: http://www.kryogenix.org/code/browser/licence.html .

Copyright (c) 1997-2007 Stuart Langridge, Joost de Valk.

Version 1.5.7
*/

/* You can change these values */
var image_path = "http://www.joostdevalk.nl/code/sortable-table/";
var image_up = "arrow-up.gif";
var image_down = "arrow-down.gif";
var image_none = "arrow-none.gif";
var europeandate = false;
var alternate_row_colors = true;

/* Don't change anything below this unless you know what you're doing */
addEvent(window, "load", sortables_init);

var SORT_COLUMN_INDEX;
var thead = false;

function sortables_init() {
	// Find all tables with class sortable and make them sortable
	if (!document.getElementsByTagName) return;
	tbls = document.getElementsByTagName("table");
	for (ti=0;ti<tbls.length;ti++) {
		thisTbl = tbls[ti];
		if (((' '+thisTbl.className+' ').indexOf("sortable") != -1) && (thisTbl.id)) {
			ts_makeSortable(thisTbl);
		}
	}
}

function ts_makeSortable(t) {
	if (t.rows && t.rows.length > 0) {
		if (t.tHead && t.tHead.rows.length > 0) {
			var firstRow = t.tHead.rows[t.tHead.rows.length-1];
			thead = true;
		} else {
			var firstRow = t.rows[0];
		}
	}
	if (!firstRow) return;
	
	// We have a first row: assume it's the header, and make its contents clickable links
	for (var i=0;i<firstRow.cells.length;i++) {
		var cell = firstRow.cells[i];
		var txt = ts_getInnerText(cell);
		if (cell.className != "unsortable" && cell.className.indexOf("unsortable") == -1) {
			cell.innerHTML = '<a href="#" class="sortheader" onclick="ts_resortTable(this, '+i+');return false;">'+txt+'<span class="sortarrow">&nbsp;&nbsp;<img src="'+ image_path + image_none + '" alt="&darr;"/></span></a>';
		}
	}
	if (alternate_row_colors) {
		alternate(t);
	}
}

function ts_getInnerText(el) {
	if (typeof el == "string") return el;
	if (typeof el == "undefined") { return el };
	if (el.innerText) return el.innerText;	//Not needed but it is faster
	var str = "";
	
	var cs = el.childNodes;
	var l = cs.length;
	for (var i = 0; i < l; i++) {
		switch (cs[i].nodeType) {
			case 1: //ELEMENT_NODE
				str += ts_getInnerText(cs[i]);
				break;
			case 3:	//TEXT_NODE
				str += cs[i].nodeValue;
				break;
		}
	}
	return str;
}

function ts_resortTable(lnk, clid) {
	var span;
	for (var ci=0;ci<lnk.childNodes.length;ci++) {
		if (lnk.childNodes[ci].tagName && lnk.childNodes[ci].tagName.toLowerCase() == 'span') span = lnk.childNodes[ci];
	}
	var spantext = ts_getInnerText(span);
	var td = lnk.parentNode;
	var column = clid || td.cellIndex;
	var t = getParent(td,'TABLE');
	// Work out a type for the column
	if (t.rows.length <= 1) return;
	var itm = "";
	var i = 0;
	while (itm == "" && i < t.tBodies[0].rows.length) {
		var itm = ts_getInnerText(t.tBodies[0].rows[i].cells[column]);
		itm = trim(itm);
		if (itm.substr(0,4) == "<!--" || itm.length == 0) {
			itm = "";
		}
		i++;
	}
	if (itm == "") return; 
	sortfn = ts_sort_caseinsensitive;
	if (itm.match(/^\d\d[\/\.-][a-zA-z][a-zA-Z][a-zA-Z][\/\.-]\d\d\d\d$/)) sortfn = ts_sort_date;
	if (itm.match(/^\d\d[\/\.-]\d\d[\/\.-]\d\d\d{2}?$/)) sortfn = ts_sort_date;
	if (itm.match(/^-?[£$€Û¢´]\d/)) sortfn = ts_sort_numeric;
	if (itm.match(/^-?(\d+[,\.]?)+(E[-+][\d]+)?%?$/)) sortfn = ts_sort_numeric;
	SORT_COLUMN_INDEX = column;
	var firstRow = new Array();
	var newRows = new Array();
	for (k=0;k<t.tBodies.length;k++) {
		for (i=0;i<t.tBodies[k].rows[0].length;i++) { 
			firstRow[i] = t.tBodies[k].rows[0][i]; 
		}
	}
	for (k=0;k<t.tBodies.length;k++) {
		if (!thead) {
			// Skip the first row
			for (j=1;j<t.tBodies[k].rows.length;j++) { 
				newRows[j-1] = t.tBodies[k].rows[j];
			}
		} else {
			// Do NOT skip the first row
			for (j=0;j<t.tBodies[k].rows.length;j++) { 
				newRows[j] = t.tBodies[k].rows[j];
			}
		}
	}
	newRows.sort(sortfn);
	if (span.getAttribute("sortdir") == 'down') {
			ARROW = '&nbsp;&nbsp;<img src="'+ image_path + image_down + '" alt="&darr;"/>';
			newRows.reverse();
			span.setAttribute('sortdir','up');
	} else {
			ARROW = '&nbsp;&nbsp;<img src="'+ image_path + image_up + '" alt="&uarr;"/>';
			span.setAttribute('sortdir','down');
	} 
    // We appendChild rows that already exist to the tbody, so it moves them rather than creating new ones
    // don't do sortbottom rows
    for (i=0; i<newRows.length; i++) { 
		if (!newRows[i].className || (newRows[i].className && (newRows[i].className.indexOf('sortbottom') == -1))) {
			t.tBodies[0].appendChild(newRows[i]);
		}
	}
    // do sortbottom rows only
    for (i=0; i<newRows.length; i++) {
		if (newRows[i].className && (newRows[i].className.indexOf('sortbottom') != -1)) 
			t.tBodies[0].appendChild(newRows[i]);
	}
	// Delete any other arrows there may be showing
	var allspans = document.getElementsByTagName("span");
	for (var ci=0;ci<allspans.length;ci++) {
		if (allspans[ci].className == 'sortarrow') {
			if (getParent(allspans[ci],"table") == getParent(lnk,"table")) { // in the same table as us?
				allspans[ci].innerHTML = '&nbsp;&nbsp;<img src="'+ image_path + image_none + '" alt="&darr;"/>';
			}
		}
	}		
	span.innerHTML = ARROW;
	alternate(t);
}

function getParent(el, pTagName) {
	if (el == null) {
		return null;
	} else if (el.nodeType == 1 && el.tagName.toLowerCase() == pTagName.toLowerCase()) {
		return el;
	} else {
		return getParent(el.parentNode, pTagName);
	}
}

function sort_date(date) {	
	// y2k notes: two digit years less than 50 are treated as 20XX, greater than 50 are treated as 19XX
	dt = "00000000";
	if (date.length == 11) {
		mtstr = date.substr(3,3);
		mtstr = mtstr.toLowerCase();
		switch(mtstr) {
			case "jan": var mt = "01"; break;
			case "feb": var mt = "02"; break;
			case "mar": var mt = "03"; break;
			case "apr": var mt = "04"; break;
			case "may": var mt = "05"; break;
			case "jun": var mt = "06"; break;
			case "jul": var mt = "07"; break;
			case "aug": var mt = "08"; break;
			case "sep": var mt = "09"; break;
			case "oct": var mt = "10"; break;
			case "nov": var mt = "11"; break;
			case "dec": var mt = "12"; break;
			// default: var mt = "00";
		}
		dt = date.substr(7,4)+mt+date.substr(0,2);
		return dt;
	} else if (date.length == 10) {
		if (europeandate == false) {
			dt = date.substr(6,4)+date.substr(0,2)+date.substr(3,2);
			return dt;
		} else {
			dt = date.substr(6,4)+date.substr(3,2)+date.substr(0,2);
			return dt;
		}
	} else if (date.length == 8) {
		yr = date.substr(6,2);
		if (parseInt(yr) < 50) { 
			yr = '20'+yr; 
		} else { 
			yr = '19'+yr; 
		}
		if (europeandate == true) {
			dt = yr+date.substr(3,2)+date.substr(0,2);
			return dt;
		} else {
			dt = yr+date.substr(0,2)+date.substr(3,2);
			return dt;
		}
	}
	return dt;
}

function ts_sort_date(a,b) {
	dt1 = sort_date(ts_getInnerText(a.cells[SORT_COLUMN_INDEX]));
	dt2 = sort_date(ts_getInnerText(b.cells[SORT_COLUMN_INDEX]));
	
	if (dt1==dt2) {
		return 0;
	}
	if (dt1<dt2) { 
		return -1;
	}
	return 1;
}
function ts_sort_numeric(a,b) {
	var aa = ts_getInnerText(a.cells[SORT_COLUMN_INDEX]);
	aa = clean_num(aa);
	var bb = ts_getInnerText(b.cells[SORT_COLUMN_INDEX]);
	bb = clean_num(bb);
	return compare_numeric(aa,bb);
}
function compare_numeric(a,b) {
	var a = parseFloat(a);
	a = (isNaN(a) ? 0 : a);
	var b = parseFloat(b);
	b = (isNaN(b) ? 0 : b);
	return a - b;
}
function ts_sort_caseinsensitive(a,b) {
	aa = ts_getInnerText(a.cells[SORT_COLUMN_INDEX]).toLowerCase();
	bb = ts_getInnerText(b.cells[SORT_COLUMN_INDEX]).toLowerCase();
	if (aa==bb) {
		return 0;
	}
	if (aa<bb) {
		return -1;
	}
	return 1;
}
function ts_sort_default(a,b) {
	aa = ts_getInnerText(a.cells[SORT_COLUMN_INDEX]);
	bb = ts_getInnerText(b.cells[SORT_COLUMN_INDEX]);
	if (aa==bb) {
		return 0;
	}
	if (aa<bb) {
		return -1;
	}
	return 1;
}
function addEvent(elm, evType, fn, useCapture)
// addEvent and removeEvent
// cross-browser event handling for IE5+,	NS6 and Mozilla
// By Scott Andrew
{
	if (elm.addEventListener){
		elm.addEventListener(evType, fn, useCapture);
		return true;
	} else if (elm.attachEvent){
		var r = elm.attachEvent("on"+evType, fn);
		return r;
	} else {
		alert("Handler could not be removed");
	}
}
function clean_num(str) {
	str = str.replace(new RegExp(/[^-?0-9.]/g),"");
	return str;
}
function trim(s) {
	return s.replace(/^\s+|\s+$/g, "");
}
function alternate(table) {
	// Take object table and get all it's tbodies.
	var tableBodies = table.getElementsByTagName("tbody");
	// Loop through these tbodies
	for (var i = 0; i < tableBodies.length; i++) {
		// Take the tbody, and get all it's rows
		var tableRows = tableBodies[i].getElementsByTagName("tr");
		// Loop through these rows
		// Start at 1 because we want to leave the heading row untouched
		for (var j = 0; j < tableRows.length; j++) {
			// Check if j is even, and apply classes for both possible results
			if ( (j % 2) == 0  ) {
				if ( !(tableRows[j].className.indexOf('odd') == -1) ) {
					tableRows[j].className = tableRows[j].className.replace('odd', 'even');
				} else {
					if ( tableRows[j].className.indexOf('even') == -1 ) {
						tableRows[j].className += " even";
					}
				}
			} else {
				if ( !(tableRows[j].className.indexOf('even') == -1) ) {
					tableRows[j].className = tableRows[j].className.replace('even', 'odd');
				} else {
					if ( tableRows[j].className.indexOf('odd') == -1 ) {
						tableRows[j].className += " odd";
					}
				}
			} 
		}
	}
}