/*----------------------------------------------------------------------------\
|                            Sortable Table 1.12                              |
|-----------------------------------------------------------------------------|
|                         Created by Erik Arvidsson                           |
|                  (http://webfx.eae.net/contact.html#erik)                   |
|                      For WebFX (http://webfx.eae.net/)                      |
|-----------------------------------------------------------------------------|
| A DOM 1 based script that allows an ordinary HTML table to be sortable.     |
|-----------------------------------------------------------------------------|
|                  Copyright (c) 1998 - 2004 Erik Arvidsson                   |
|-----------------------------------------------------------------------------|
| This software is provided "as is", without warranty of any kind, express or |
| implied, including  but not limited  to the warranties of  merchantability, |
| fitness for a particular purpose and noninfringement. In no event shall the |
| authors or  copyright  holders be  liable for any claim,  damages or  other |
| liability, whether  in an  action of  contract, tort  or otherwise, arising |
| from,  out of  or in  connection with  the software or  the  use  or  other |
| dealings in the software.                                                   |
| - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| This  software is  available under the  three different licenses  mentioned |
| below.  To use this software you must chose, and qualify, for one of those. |
| - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| The WebFX Non-Commercial License          http://webfx.eae.net/license.html |
| Permits  anyone the right to use the  software in a  non-commercial context |
| free of charge.                                                             |
| - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| The WebFX Commercial license           http://webfx.eae.net/commercial.html |
| Permits the  license holder the right to use  the software in a  commercial |
| context. Such license must be specifically obtained, however it's valid for |
| any number of  implementations of the licensed software.                    |
| - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| GPL - The GNU General Public License    http://www.gnu.org/licenses/gpl.txt |
| Permits anyone the right to use and modify the software without limitations |
| as long as proper  credits are given  and the original  and modified source |
| code are included. Requires  that the final product, software derivate from |
| the original  source or any  software  utilizing a GPL  component, such  as |
| this, is also licensed under the GPL license.                               |
|-----------------------------------------------------------------------------|
| 2003-01-10 | First version                                                  |
| 2003-01-19 | Minor changes to the date parsing                              |
| 2003-01-28 | JScript 5.0 fixes (no support for 'in' operator)               |
| 2003-02-01 | Sloppy typo like error fixed in getInnerText                   |
| 2003-07-04 | Added workaround for IE cellIndex bug.                         |
| 2003-11-09 | The bDescending argument to sort was not correctly working     |
|            | Using onclick DOM0 event if no support for addEventListener    |
|            | or attachEvent                                                 |
| 2004-01-13 | Adding addSortType and removeSortType which makes it a lot     |
|            | easier to add new, custom sort types.                          |
| 2004-01-27 | Switch to use descending = false as the default sort order.    |
|            | Change defaultDescending to suit your needs.                   |
| 2004-03-14 | Improved sort type None look and feel a bit                    |
| 2004-08-26 | Made the handling of tBody and tHead more flexible. Now you    |
|            | can use another tHead or no tHead, and you can chose some      |
|            | other tBody.                                                   |
|-----------------------------------------------------------------------------|
| Created 2003-01-10 | All changes are in the log above. | Updated 2004-08-26 |
\----------------------------------------------------------------------------*/


function SortableTable(oTable, oSortTypes) 
{
  this.sortTypes = oSortTypes || [];

  this.sortColumn = null;
  this.descending = null;

  var oThis = this;
  this._headerOnclick = function (e) {
    oThis.headerOnclick(e);
  };

  if (oTable) {
    this.setTable( oTable );
    this.document = oTable.ownerDocument || oTable.document;
  }
  else {
    this.document = document;
  }


  // only IE needs this
  var win = this.document.defaultView || this.document.parentWindow;
  this._onunload = function () {
    oThis.destroy();
  };
  if (win && typeof win.attachEvent != "undefined") {
    win.attachEvent("onunload", this._onunload);
  }
}

SortableTable.gecko = navigator.product == "Gecko";
SortableTable.msie = /msie/i.test(navigator.userAgent);
// Mozilla is faster when doing the DOM manipulations on
// an orphaned element. MSIE is not
SortableTable.removeBeforeSort = SortableTable.gecko;

SortableTable.prototype.onsort = function () {};

// default sort order. true -> descending, false -> ascending
SortableTable.prototype.defaultDescending = true;

// shared between all instances. This is intentional to allow external files
// to modify the prototype
SortableTable.prototype._sortTypeInfo = {};

SortableTable.prototype.setTable = function (oTable) 
{
  if ( this.tHead )
    this.uninitHeader();
  this.element = oTable;
  this.setTHead( oTable.tHead );
  this.setTBody( oTable.tBodies[0] );
};

SortableTable.prototype.setTHead = function (oTHead)
{
  if (this.tHead && this.tHead != oTHead )
    this.uninitHeader();
  this.tHead = oTHead;
  this.initHeader( this.sortTypes );
};

SortableTable.prototype.setTBody = function (oTBody)
{
  this.tBody = oTBody;
};

SortableTable.prototype.setSortTypes = function ( oSortTypes ) 
{
  if ( this.tHead )
    this.uninitHeader();
  this.sortTypes = oSortTypes || [];
  if ( this.tHead )
    this.initHeader( this.sortTypes );
};

// adds arrow containers and events
// also binds sort type to the header cells so that reordering columns does
// not break the sort types
SortableTable.prototype.initHeader = function (oSortTypes)
{
  if (!this.tHead) return;
  var cells = this.tHead.rows[0].cells;
  var doc = this.tHead.ownerDocument || this.tHead.document;
  this.sortTypes = oSortTypes || [];
  var l = cells.length;
  var img, c;
  for (var i = 0; i < l; i++) {
    c = cells[i];
    if (this.sortTypes[i] != null && this.sortTypes[i] != "None") {
      img = doc.createElement("IMG");
      img.src = "/images/blank.png";
      c.appendChild(img);
      if (this.sortTypes[i] != null)
	c._sortType = this.sortTypes[i];
      if (typeof c.addEventListener != "undefined")
	c.addEventListener("click", this._headerOnclick, false);
      else if (typeof c.attachEvent != "undefined")
	c.attachEvent("onclick", this._headerOnclick);
      else
	c.onclick = this._headerOnclick;
    }
    else
      {
	c.setAttribute( "_sortType", oSortTypes[i] );
	c._sortType = "None";
      }
  }
  this.updateHeaderArrows();

};

// remove arrows and events
SortableTable.prototype.uninitHeader = function ()
{
  if (!this.tHead) return;
  var cells = this.tHead.rows[0].cells;
  var l = cells.length;
  var c;
  for (var i = 0; i < l; i++) {
    c = cells[i];
    if (c._sortType != null && c._sortType != "None") {
      c.removeChild(c.lastChild);
      if (typeof c.removeEventListener != "undefined")
	c.removeEventListener("click", this._headerOnclick, false);
      else if (typeof c.detachEvent != "undefined")
	c.detachEvent("onclick", this._headerOnclick);
      c._sortType = null;
      c.removeAttribute( "_sortType" );
    }
  }
};

SortableTable.prototype.updateHeaderArrows = function () 
{
  if (!this.tHead) return;
  var cells = this.tHead.rows[0].cells;
  var l = cells.length;
  var img;
  for (var i = 0; i < l; i++) {
    if (cells[i]._sortType != null && cells[i]._sortType != "None") {
      img = cells[i].lastChild;
      if (i == this.sortColumn)
	img.className = "sort-arrow " + 
	  (this.descending ? "descending" : "ascending");
      else
	img.className = "sort-arrow";
    }
  }
};

SortableTable.prototype.headerOnclick = function (e) 
{
  // find TD element
  var el = e.target || e.srcElement;
  while (el.tagName != "TD")
    el = el.parentNode;

  this.sort(SortableTable.msie ? SortableTable.getCellIndex(el):el.cellIndex);
};

// IE returns wrong cellIndex when columns are hidden
SortableTable.getCellIndex = function (oTd) 
{
  var cells = oTd.parentNode.childNodes
  var l = cells.length;
  var i;
  for (i = 0; cells[i] != oTd && i < l; i++)
    ;
  return i;
};

SortableTable.prototype.getSortType = function (nColumn) 
{
  return this.sortTypes[nColumn] || "String";
};

// only nColumn is required
// if bDescending is left out the old value is taken into account
// if sSortType is left out the sort type is found from the sortTypes array

SortableTable.prototype.sort = function (nColumn, bDescending, sSortType)
{
  if (!this.tBody) return;
  if (sSortType == null)
    sSortType = this.getSortType(nColumn);

  // exit if None
  if (sSortType == "None")
    return;

  if (bDescending == null) {
    if (this.sortColumn != nColumn)
      this.descending = this.defaultDescending;
    else
      this.descending = !this.descending;
  }
  else
    this.descending = bDescending;

  this.sortColumn = nColumn;

  if (typeof this.onbeforesort == "function")
    this.onbeforesort();

  var f = this.getSortFunction(sSortType, nColumn);
  var a = this.getCache(sSortType, nColumn);
  var tBody = this.tBody;

  a.sort(f);

  if (this.descending)
    a.reverse();

  if (SortableTable.removeBeforeSort) {
    // remove from doc
    var nextSibling = tBody.nextSibling;
    var p = tBody.parentNode;
    p.removeChild(tBody);
  }

  // insert in the new order
  var l = a.length;
  for (var i = 0; i < l; i++)
    tBody.appendChild(a[i].element);

  if (SortableTable.removeBeforeSort) {
    // insert into doc
    p.insertBefore(tBody, nextSibling);
  }

  this.updateHeaderArrows();

  this.destroyCache(a);

  if (typeof this.onsort == "function")
    this.onsort();
};

SortableTable.prototype.asyncSort = function (nColumn, bDescending, sSortType)
{
  var oThis = this;
  this._asyncsort = function () {
    oThis.sort(nColumn, bDescending, sSortType);
  };
  window.setTimeout(this._asyncsort, 1);
};

SortableTable.prototype.getCache = function (sType, nColumn) 
{
  if (!this.tBody) return [];
  var rows = this.tBody.rows;
  var l = rows.length;
  var a = new Array(l);
  var r;
  for (var i = 0; i < l; i++) {
    r = rows[i];
    a[i] = {
      value:		this.getRowValue(r, sType, nColumn),
      element:	r
    };
  };
  return a;
};

SortableTable.prototype.destroyCache = function (oArray)
{
  var l = oArray.length;
  for (var i = 0; i < l; i++) {
    oArray[i].value = null;
    oArray[i].element = null;
    oArray[i] = null;
  }
};

SortableTable.prototype.getRowValue = function (oRow, sType, nColumn) 
{
  // if we have defined a custom getRowValue use that
  if (this._sortTypeInfo[sType] && this._sortTypeInfo[sType].getRowValue)
    return this._sortTypeInfo[sType].getRowValue(oRow, nColumn);

  var s;
  var c = oRow.cells[nColumn];
  if (typeof c.innerText != "undefined")
    s = c.innerText;
  else
    s = SortableTable.getInnerText(c);
  return this.getValueFromString(s, sType);
};

SortableTable.getInnerText = function (oNode) 
{
  var s = "";
  var cs = oNode.childNodes;
  var l = cs.length;
  for (var i = 0; i < l; i++) {
    switch (cs[i].nodeType) {
    case 1: //ELEMENT_NODE
      s += SortableTable.getInnerText(cs[i]);
      break;
    case 3:	//TEXT_NODE
      s += cs[i].nodeValue;
      break;
    }
  }
  return s;
};

SortableTable.prototype.getValueFromString = function (sText, sType)
{
  if (this._sortTypeInfo[sType])
    return this._sortTypeInfo[sType].getValueFromString( sText );
  return sText;
};

SortableTable.prototype.getSortFunction = function (sType, nColumn) 
{
  if (this._sortTypeInfo[sType])
    return this._sortTypeInfo[sType].compare;
  return SortableTable.basicCompare;
};

SortableTable.prototype.destroy = function () 
{
  this.uninitHeader();
  var win = this.document.parentWindow;
  if (win && typeof win.detachEvent != "undefined") {	// only IE needs this
    win.detachEvent("onunload", this._onunload);
  }
  this._onunload = null;
  this.element = null;
  this.tHead = null;
  this.tBody = null;
  this.document = null;
  this._headerOnclick = null;
  this.sortTypes = null;
  this._asyncsort = null;
  this.onsort = null;
};

// Adds a sort type to all instance of SortableTable
// sType : String - the identifier of the sort type
// fGetValueFromString : function ( s : string ) : T - A function that takes a
//    string and casts it to a desired format. If left out the string is just
//    returned
// fCompareFunction : function ( n1 : T, n2 : T ) : Number - A normal JS sort
//    compare function. Takes two values and compares them. If left out 
//    less than, <, compare is used
// fGetRowValue : function( oRow : HTMLTRElement, nColumn : int ) : T - A 
//    function that takes the row and the column index and returns the value 
//    used to compare. If left out then the innerText is first taken for the 
//    cell and then the fGetValueFromString is used to convert that string 
//    the desired value and type

SortableTable.prototype.addSortType = function (sType, fGetValueFromString,
						fCompareFunction, 
						fGetRowValue) 
{
  this._sortTypeInfo[sType] = {
    type:		sType,
    getValueFromString:	fGetValueFromString || SortableTable.idFunction,
    compare:		fCompareFunction || SortableTable.basicCompare,
    getRowValue:	fGetRowValue
  };
};

// this removes the sort type from all instances of SortableTable
SortableTable.prototype.removeSortType = function (sType)
{
  delete this._sortTypeInfo[sType];
};

SortableTable.basicCompare = function compare(n1, n2)
{
  if (n1.value < n2.value)
    return -1;
  if (n2.value < n1.value)
    return 1;
  return 0;
};

SortableTable.idFunction = function (x)
{
  return x;
};

SortableTable.toUpperCase = function (s)
{
  return s.toUpperCase();
};

SortableTable.toDate = function (s)
{
  var parts = s.split("-");
  var d = new Date(0);
  d.setFullYear(parts[0]);
  d.setDate(parts[2]);
  d.setMonth(parts[1] - 1);
  return d.valueOf();
};

function processNumber( s )
{
  var n = s;
  var i = s.indexOf( "," );
  if ( i != -1 ) {
    var p1 = s.substr( 0, i );
    var p2 = s.substr( i + 1, s.length );
    return processNumber( p1 + p2 );
  }

  return parseFloat( n );
}

function currencyConverter( s )
{
  var n = s;
  var i = s.indexOf( "$" );

  if ( i>=0 ) {
    n = s.substr( i+1 );
  }

  return processNumber( n );
}

/*
 * Example: 907980, 824.8k, 1.6G, 20.69M
 *
 */
function replace8a8(str)
{
  str = str.toUpperCase();
  var splitstr = "____";
  var ar = str.replace(/(([0-9]*\.)?[0-9]+([eE][-+]?[0-9]+)?)(.*)/,
		       "$1"+splitstr+"$4").split(splitstr);
  var num = Number(ar[0]).valueOf();
  var ml = ar[1].replace(/\s*([KMGB])\s*/, "$1");

  if (ml == "K") {
    num *= 1024;
  } else if(ml == "M") {
    num *= 1024 * 1024;
  } else if (ml == "G") {
    num *= 1024 * 1024 * 1024;
  } else if (ml == "T") {
    num *= 1024 * 1024 * 1024 * 1024;
  }
  // B and no prefix

  return num;
}

// add sort types
SortableTable.prototype.addSortType("CaseInsensitiveString", 
				    SortableTable.toUpperCase);
//SortableTable.prototype.addSortType("Date", SortableTable.toDate);
SortableTable.prototype.addSortType("String");
SortableTable.prototype.addSortType( "Currency", currencyConverter );
SortableTable.prototype.addSortType( "Number", processNumber );
SortableTable.prototype.addSortType( "NumberK", replace8a8 );

// None is a special case