/*******************************************************************************
*        _
*     __(_)    Alexander Mlynski-Wiese
*    /  /\__
*      /\      52159 Roetgen, Germany
*   __/  \
*         |    alexander.mlynski-wiese@tv-roetgen.de
*
********************************************************************************
*  SortTable
*  version 2
*  7th April 2007
*  Stuart Langridge, http://www.kryogenix.org/code/browser/sorttable/
*
*  Instructions:
*  Download this file
*  Add <script src="sorttable.js"></script> to your HTML
*  Add class="sortable" to any table you'd like to make sortable
*  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.
********************************************************************************
*  am, 07.03.2009:
*  I really like this code, because - as the author Stuart Langridge correctly
*  states - it is very *very* unobstrusive, i.e. minimal modifications to the
*  HTML code are needed (just add class="sortable" to the <table>) to enable
*  sorting of a table.
*
*  There are, however, a few things I liked more in the BrainJar example
*  (http://www.brainjar.com/dhtml/tablesort/):
*  - the cursor switches to a pointer when over a sortable column's header
*  - the table is colorized.
*
*  I decided to add these features to Stuart Langridge's code.
*  The following style classes are available now (shown here with only minimal
*  attributes):
*
*  th.sortable 	 { color: #000080; cursor:pointer; }
*			// add "class=sortable" to <th> to get this decoration
*  th.sortable:hover 	{ text-decoration: underline; }	// if you like it ;-)
*  tr.tsRow0 	 { background-color: #f0f0f0; }		/* odd  rows
*  tr.tsRow1 	 { background-color: #e0e0e0; }		/* even rows
*  td.tsRow0sort { background-color: #d0d0d0; }	  /* odd  rows, sorted column
*  td.tsRow1sort { background-color: #c0c0c0; }	  /* even rows, sorted column
*  span.tsInd	 { } 				  /* sorting indicator
********************************************************************************
*  Advanced Usage Notes:
*
*  - put totals to <tfoot> to exclude them from sorting:
*	<tfoot><tr><td>TOTAL</td><td>£45,000</td></tr></tfoot>
*
*  - use attribute "tsCustomkey" to fine-tune sorting:
*	<tr><th>Number (spelled)</th><th>Person</th></tr>
*	<tr><td tsCustomkey="2">two</td><td>Jan</td></tr>
*	<tr><td tsCustomkey="3">three</td><td>Bruce</td></tr>
*	<tr><td tsCustomkey="20080211131900">February 11th 2008, 1:19pm...
*
*  - specify sorting type as needed:
*	<th class="sortable sort_numeric">, sort_alpha, ...
*
*  - sorting is case-insensitiv (sort_iaplha) by default.
*    	Use <th class="sortable sort_alpha"> for case-sensitive sorting
*
*  - for stable sorting, add "tsStable" to the table's classname
********************************************************************************
*  $Log: tablesort.js,v $
*  Revision 1.6  2009/03/09 11:41:55  am
*  - class tsRow0/1: add ' ' before adding to className
*  - disabled colorizing of sort-column
*
*  Revision 1.5  2009/03/08 10:22:44  am
*  - formatting
*  - changed 'sorttable' (which was hard to pronounce and led to confusion
*    with sortable) to 'tablesort'
*  - changed internal classnames accordingly
*
*  Revision 1.4  2009/03/08 10:05:05  am
*  - use a permanent <span> to display the sort indicator
*  - provide a 3rd sort indicator for 'sortable / unsorted'
*
*  Revision 1.3  2009/03/08 10:00:00  am
*  - make shaker_sort optional (<table classname="sortable tsStable">)
*  - change classnames for sort-functions to "sort_xxx"
*  - default sorting to sort_ialpha
*  - global vars for charUp/charDn
*  - added Notes
*
*  Revision 1.2  2009/03/08 09:53:25  am
*  - add DSA CVS header
*  - add code to colorize table
*
*  Revision 1.1  2009/03/08 am
*  - original version by
*	Stuart Langridge, http://www.kryogenix.org/code/browser/sorttable/
*******************************************************************************/

var stIsIE = /*@cc_on!@*/false;

// http://www.unicode.org/charts/PDF/U25A0.pdf:
if ( 1 ) {
    var charUp = '&nbsp;<code>&#x25B2;</code>&nbsp;';
    var charDn = '&nbsp;<code>&#x25BC;</code>&nbsp;';
    var charNo = '&nbsp;<code>&#x25C7;</code>&nbsp;';
} else {
    var charUp = /* stIsIE ? '&nbsp<font face="webdings">6</font>' : */ '&nbsp;&#x25B4;';
    var charDn = /* stIsIE ? '&nbsp<font face="webdings">5</font>' : */ '&nbsp;&#x25BE;';
    var charNo = /* stIsIE ? '&nbsp<font face="webdings">5</font>' : */ '&nbsp;&#x25CA;';
}

tablesort = {
    //----------------------------------------------------------------------------
    init: function() {
	// quit if this function has already been called
	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;

	tablesort.DATE_RE = /^(\d\d?)[\/\.-](\d\d?)[\/\.-]((\d\d)?\d\d)$/;

	/* collect all tables with classname "sortable" */
	forEach(document.getElementsByTagName('table'), function(table) {
	    if (table.className.search(/\bsortable\b/) != -1) {
	  	tablesort.makeSortable(table);
	    }
	});
    },

    //----------------------------------------------------------------------------
    makeSortable: function(table) {
        if (table.getElementsByTagName('thead').length == 0) {
            // table doesn't have a tHead. Since it should have, create one and
            // put the first table row in it.
            the = document.createElement('thead');
            the.appendChild(table.rows[0]);
            table.insertBefore(the,table.firstChild);
        }
        // Safari doesn't support table.tHead, sigh
        if (table.tHead == null) table.tHead = table.getElementsByTagName('thead')[0];

        if (table.tHead.rows.length != 1) return; // can't cope with two header rows

        // work through each column and calculate its type
        headrow = table.tHead.rows[0].cells;

        for (var i=0; i<headrow.length; i++) {
            // manually override the type with a sort_<type> attribute
            if (headrow[i].className.match(/\bsortable\b/)) { 	// sort by this col
                if (table.className.match(/\btsStable\b/)) {
                    headrow[i].className += ' tsStable';
          	}
                mtch = headrow[i].className.match(/\bsort_([a-z0-9]+)\b/);
                if (mtch) { override = mtch[1]; }
                if (mtch && typeof tablesort["sort_"+override] == 'function') {
                    headrow[i].tablesort_sortfunction = tablesort["sort_"+override];
                } else {
                    headrow[i].tablesort_sortfunction = tablesort.guessType(table,i);
                }
                // make it clickable to sort
                headrow[i].tablesort_columnindex = i;
                headrow[i].tablesort_tbody = table.tBodies[0];

                // A.Mlynski: create the span with the sort-indicator.
                // We do this only once and later change the indicator's
                // innerHTML, instead of removing and recreating it every time.
                // This adds the additional feature of having an indicator
                // for unsorted (but sortable) columns.
        	sortind = document.createElement('span');
        	sortind.id = "tablesort_col" + i;
        	sortind.innerHTML = charNo;
        	sortind.className = "tsInd";
        	headrow[i].appendChild(sortind);


          //------------------------------------------------>
          //-----> install Event handler function here: ---->
          dean_addEvent(headrow[i],"click", function(e) {

              sortCol = this.cellIndex;

              if (this.className.search(/\btablesort_sorted\b/) != -1) {
        	  // if we're already sorted by this column, just
        	  // reverse the table, which is quicker
        	  tablesort.reverse(this.tablesort_tbody);
        	  this.className = this.className.replace('tablesort_sorted',
        	      'tablesort_sorted_reverse');
        	  sortind = document.getElementById("tablesort_col" + sortCol);
        	  sortind.innerHTML = charDn;
        	  return;
              }
              if (this.className.search(/\btablesort_sorted_reverse\b/) != -1) {
        	  // if we're already sorted by this column in reverse, just
        	  // re-reverse the table, which is quicker
        	  tablesort.reverse(this.tablesort_tbody);
        	  this.className = this.className.replace('tablesort_sorted_reverse',
        	      'tablesort_sorted');
        	  sortind = document.getElementById("tablesort_col" + sortCol);
        	  sortind.innerHTML = charUp;
        	  return;
              }

              // remove tablesort_sorted classes from head row cells
              theadrow = this.parentNode;

              var col=0;
              forEach(theadrow.childNodes, function(cell) {
        	  if (cell.nodeType == 1) { // an element
        	      cell.className = cell.className.replace('tablesort_sorted_reverse','');
        	      cell.className = cell.className.replace('tablesort_sorted','');
        	      sortind = document.getElementById("tablesort_col" + col);
        	      if (sortind) {
        	      	   if (col==sortCol) {
        	      	       sortind.innerHTML = charUp;
        	      	   } else {
        	      	       sortind.innerHTML = charNo;
        	      	   }
        	      }
        	      col = col + 1;
        	  }
              });

              this.className += ' tablesort_sorted';

              // 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 = this.tablesort_columnindex;
              rows = this.tablesort_tbody.rows;
              for (var j=0; j<rows.length; j++) {
        	  row_array[row_array.length] = [tablesort.getInnerText(rows[j].cells[col]), rows[j]];
              }

              /* If you want a stable sort, add "tsStable" to the table's classname! */
              if (this.className.match(/\btsStable\b/)) {
        	  tablesort.shaker_sort(row_array, this.tablesort_sortfunction);
              } else {
        	  row_array.sort(this.tablesort_sortfunction);
              }

              tb = this.tablesort_tbody;
              for (var j=0; j<row_array.length; j++) {
        	  tb.appendChild(row_array[j][1]);
              }

              //----> A.Mlynski: colorize table
              var even_odd = 1;
              forEach (this.tablesort_tbody.rows, function(row) {
        	  even_odd = 1 - even_odd;
        	  row.className = row.className.replace('tsRow0','');
        	  row.className = row.className.replace('tsRow1','');
        	  var row_name = 'tsRow' + even_odd;
        	  row.className += ' ' + row_name;

/*        	  forEach(row.getElementsByTagName("td"), function(cell) {
        	      cell.className = cell.className.replace('tsRow0sort','');
        	      cell.className = cell.className.replace('tsRow1sort','');
        	      if (cell.cellIndex == sortCol) {
        		  var cell_name = row_name + 'sort';
        		  cell.className = cell_name + ' ' + cell.className;
        	      }
        	  } );	*/
              } );
              // <---- A.Mlynski

              delete row_array;
              }		/* <--- end of event handler function <-- */ );
           }
        }
    },

    //----------------------------------------------------------------------------
    guessType: function(table, column) {
        // guess the type of a column based on its first non-blank row
        sortfn = tablesort.sort_ialpha;
        for (var i=0; i<table.tBodies[0].rows.length; i++) {
	    text = tablesort.getInnerText(table.tBodies[0].rows[i].cells[column]);
	    if (text != '') {
	        if (text.match(/^-?[£$¤]?[\d,.]+%?$/)) {
	  	  return tablesort.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(tablesort.DATE_RE)
	  	  if (possdate) {
	  	      // looks like a date
	  	      first = parseInt(possdate[1]);
	  	      second = parseInt(possdate[2]);
	  	      if (first > 12) {
	  		  // definitely dd/mm
	  		  return tablesort.sort_dmy;
	  	      } else if (second > 12) {
	  		  return tablesort.sort_mdy;
	  	      } else {
	  		  // looks like a date, but we can't tell which, so assume
	  		  // that it's dd/mm (English imperialism!) and keep looking
	  		  sortfn = tablesort.sort_dmy;
	  	      }
	  	  }
	    }
        }
        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 tablesort.
        // 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("tsCustomkey") != null) {
	    return node.getAttribute("tsCustomkey");
        }
        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) {
	        // http://de.selfhtml.org/javascript/objekte/node.htm#node_type:
	    case 3:			// Textknoten
	        if (node.nodeName.toLowerCase() == 'input') {
	  	  return node.value.replace(/^\s+|\s+$/g, '');
	        }
	    case 4:			// Knoten für CDATA-Bereich
	        return node.nodeValue.replace(/^\s+|\s+$/g, '');
	        break;
	    case 1:  		// Elementknoten
	    case 11:		// Dokumentfragment-Knoten
	        var innerText = '';
	        for (var i = 0; i < node.childNodes.length; i++) {
	  	  innerText += tablesort.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>=0; 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] */
    //  add "sort_xxx" to <th> classname
    //--------------------------------------------------------------------------
    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_ialpha: function(a,b) {		// alpha ignoring case
        if (a[0].toLowerCase()==b[0].toLowerCase()) return 0;
        if (a[0].toLowerCase()<b[0].toLowerCase()) return -1;
        return 1;
    },
    //--------------------------------------------------------------------------
    sort_dmy: function(a,b) {
        mtch = a[0].match(tablesort.DATE_RE);
        d = mtch[1]; m = mtch[2]; y = mtch[3];
        if (m.length == 1) m = '0'+m;
        if (d.length == 1) d = '0'+d;
        dt1 = y+m+d;
        mtch = b[0].match(tablesort.DATE_RE);
        y = mtch[3]; m = mtch[2]; d = mtch[1];
        if (m.length == 1) m = '0'+m;
        if (d.length == 1) d = '0'+d;
        dt2 = y+m+d;
        if (dt1==dt2) return 0;
        if (dt1<dt2) return -1;
        return 1;
    },
    //--------------------------------------------------------------------------
    sort_mdy: function(a,b) {
        mtch = a[0].match(tablesort.DATE_RE);
        m = mtch[1]; d = mtch[2]; y = mtch[3];
        if (m.length == 1) m = '0'+m;
        if (d.length == 1) d = '0'+d;
        dt1 = y+m+d;
        mtch = b[0].match(tablesort.DATE_RE);
        y = mtch[3]; d = mtch[2]; m = mtch[1];
        if (m.length == 1) m = '0'+m;
        if (d.length == 1) d = '0'+d;
        dt2 = y+m+d;
        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)
    }
}
//------------------------------------------------------------------------------
//  end of tablesort
//------------------------------------------------------------------------------


//******************************************************************************
//  Supporting functions: bundled here to avoid depending on a library
//******************************************************************************

// Dean Edwards/Matthias Miller/John Resig

/* for Mozilla/Opera9 */
if (document.addEventListener) {
    document.addEventListener("DOMContentLoaded", tablesort.init, false);
}

/* for Internet Explorer */
/*@cc_on @*/
/*@if (@_win32)
document.write("<script id=__ie_onload defer src=javascript:void(0)><\/script>");
var script = document.getElementById("__ie_onload");
script.onreadystatechange = function() {
if (this.readyState == "complete") {
tablesort.init(); // call the onload handler
}
};
/*@end @*/

/* for Safari */
if (/WebKit/i.test(navigator.userAgent)) { 		// sniff
    var _timer = setInterval(function() {
        if (/loaded|complete/.test(document.readyState)) {
            tablesort.init(); // call the onload handler
        }
    }, 10);
}

/* for other browsers */
window.onload = tablesort.init;

//------------------------------------------------------------------------------
// event handling
// written by Dean Edwards, 2005
// with input from Tino Zijdel, Matthias Miller, Diego Perini
// http://dean.edwards.name/weblog/2005/10/add-event/
//------------------------------------------------------------------------------
function dean_addEvent(element, type, handler) {
    if (element.addEventListener) {
	element.addEventListener(type, handler, false);
    } else {
	// assign each event handler a unique ID
	if (!handler.$$guid) handler.$$guid = dean_addEvent.guid++;
	// create a hash table of event types for the element
	if (!element.events) element.events = {};
	// create a hash table of event handlers for each element/event pair
	var handlers = element.events[type];
	if (!handlers) {
	    handlers = element.events[type] = {};
	    // store the existing event handler (if there is one)
	    if (element["on" + type]) {
		handlers[0] = element["on" + type];
	    }
	}
	// store the event handler in the hash table
	handlers[handler.$$guid] = handler;
	// assign a global event handler to do all the work
	element["on" + type] = handleEvent;
    }
};
// a counter used to create unique IDs
dean_addEvent.guid = 1;

function removeEvent(element, type, handler) {
    if (element.removeEventListener) {
	element.removeEventListener(type, handler, false);
    } else {
	// delete the event handler from the hash table
	if (element.events && element.events[type]) {
	    delete element.events[type][handler.$$guid];
	}
    }
};

function handleEvent(event) {
    var returnValue = true;
    // grab the event object (IE uses a global event object)
    event = event || fixEvent(((this.ownerDocument || this.document || this).parentWindow || window).event);
    // get a reference to the hash table of event handlers
    var handlers = this.events[event.type];
    // execute each event handler
    for (var i in handlers) {
	this.$$handleEvent = handlers[i];
	if (this.$$handleEvent(event) === false) {
	    returnValue = false;
	}
    }
    return returnValue;
};

function fixEvent(event) {
    // add W3C standard event methods
    event.preventDefault = fixEvent.preventDefault;
    event.stopPropagation = fixEvent.stopPropagation;
    return event;
};
fixEvent.preventDefault = function() {
    this.returnValue = false;
};
fixEvent.stopPropagation = function() {
    this.cancelBubble = true;
}

//------------------------------------------------------------------------------
// 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);
	}
    };
}

// generic enumeration
Function.prototype.forEach = function(object, block, context) {
    for (var key in object) {
	if (typeof this.prototype[key] == "undefined") {
	    block.call(context, object[key], key, object);
	}
    }
};

// character enumeration
String.forEach = function(string, block, context) {
    Array.forEach(string.split(""), function(chr, index) {
	block.call(context, chr, index, string);
    });
};

// globally resolve forEach enumeration
var forEach = function(object, block, context) {
    if (object) {
	var resolve = Object; // default
	if (object instanceof Function) {
	    // functions have a "length" property
	    resolve = Function;
	} else if (object.forEach instanceof Function) {
	    // 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);
    }
};

//------------------------------------------------------------------------------
//  end of file
//------------------------------------------------------------------------------