/*----------------------------------------------------------------------------\
|                            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 - 2006 Erik Arvidsson                   |
|-----------------------------------------------------------------------------|
| Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| use this file except in compliance with the License.  You may obtain a copy |
| of the License at http://www.apache.org/licenses/LICENSE-2.0                |
| - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
| Unless  required  by  applicable law or  agreed  to  in  writing,  software |
| distributed under the License is distributed on an  "AS IS" BASIS,  WITHOUT |
| WARRANTIES OR  CONDITIONS OF ANY KIND,  either express or implied.  See the |
| License  for the  specific language  governing permissions  and limitations |
| under the 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.                                                   |
| 2006-04-25 | Changed license to Apache Software License 2.0                 |  
|-----------------------------------------------------------------------------|
| Created 2003-01-10 | All changes are in the log above. | Updated 2006-04-25 |
\----------------------------------------------------------------------------*/

//hq tableBody 只对锁定表头的表格有效，因为锁定表头时表格的 head 和 body是分离在两个表格中的
function SortableTable(oTable, tableBody, oSortTypes,isFirstSort) {

	this.sortTypes = oSortTypes || [];

	this.sortColumn = null;
	this.descending = null;
	
	this.first = null;//the first row data
	this.isFirstSort = isFirstSort;
	
	this.fixhead = tableBody == null ? false : true;
	
	var oThis = this;
	this._headerOnclick = function (e) {
		oThis.headerOnclick(e);
	};

	if (oTable) {
		this.setTable( oTable, tableBody );
		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, tableBody) {
	if ( this.tHead )
		this.uninitHeader();
	this.element = oTable;
	this.setTHead( oTable.tHead );
//	this.setTBody( oTable.tBodies[0] );
	if(tableBody == null){
		this.setTBody( oTable.tBodies[oTable.tBodies.length-1] );
	}else{
		this.setTBody( tableBody.tBodies[tableBody.tBodies.length-1] );
	}
};

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;
	// zhaogy : for all tHead's rows
	var jRowCount=this.tHead.rows.length;
	for(var jNdx=0;jNdx<jRowCount;jNdx++){
		var cells = this.tHead.rows[jNdx].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];
			__setSortable(c);
			if('true'!=c._sortable)
				continue;
			//liushimin for colspan and rowspan
			var _metaIndex=this.getMetaCellIndex(c),sortType=this.sortTypes[_metaIndex];
			//if (this.sortTypes[i] != null && this.sortTypes[i] != "None") {
			if (sortType != null && sortType!= "None") {
				if('y'!=c.sortImgOk){
					img = doc.createElement("IMG");
					img.src = "../ext-res/image/s.gif";
					img.width=7;
					img.hegiht=8;
					if(this.fixhead){
						$(c).find("div").append(img);
					}else{
						c.appendChild(img);
					}
					c.sortImgOk='y';
				}

				//if (this.sortTypes[i] != null)
				//	c._sortType = this.sortTypes[i];
				if (sortType != null)
					c._sortType = sortType;
				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;
				c.style.cursor='pointer';
			}
			else
			{
				//c.setAttribute( "_sortType", oSortTypes[i] );
				c.setAttribute( "_sortType", oSortTypes[_metaIndex] );
				c._sortType = "None";
			}
		}
	}

	this.updateHeaderArrows();
};

//zhaogy
function __setSortable(oTd){
	if(oTd._sortable)
		return;
	var thead=oTd.parentNode.parentNode;
	var rowcount=thead.rows.length;
	for(var i=0;i<rowcount;i++){
		var cs=thead.rows[i].cells;
		for(var j=0;j<cs.length;j++){
			if(cs[j]==oTd && (oTd.rowSpan+i==rowcount)){
				oTd._sortable='true';
				return;
			}
		}
	}
	oTd._sortable='false';
}

// remove arrows and events
SortableTable.prototype.uninitHeader = function () {
	if (!this.tHead) return;
	// zhaogy : for all tHead's rows
	var jRowCount=this.tHead.rows.length;
	for(var jNdx=0;jNdx<jRowCount;jNdx++){
		var cells = this.tHead.rows[jNdx].cells;
		var l = cells.length;
		var c;
		for (var i = 0; i < l; i++) {
			c = cells[i];
			if('true'!=c._sortable)
				continue;
			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;
	// zhaogy : for all tHead's rows
	var jRowCount=this.tHead.rows.length;
	for(var jNdx=0;jNdx<jRowCount;jNdx++){
		var cells = this.tHead.rows[jNdx].cells;
		var l = cells.length;
		var img;
		for (var i = 0; i < l; i++) {
			if('true'!=cells[i]._sortable)
				continue;
			if (cells[i]._sortType != null && cells[i]._sortType != "None") {
				if(this.fixhead){
					img = cells[i].lastChild.lastChild;
				}else{
					img = cells[i].lastChild;
				}
				//if (i == this.sortColumn){
				if (this.sortColumn!=null && cells[i]._jCellIndex == this.sortColumn){
					img.src=(this.descending ? "../ext-res/image/sort_desc.gif" : "../ext-res/image/sort_asc.gif");
					img.width=7;
					img.height=8;
					img.style.display="";
				}
				else if (this.sortColumn==null){
					img.src=("../ext-res/image/sortdef.png");
					img.width=7;
					img.height=8;
					img.style.display="";
				}
				else{
					img.style.display="none";
				}
			}
		}
	}
};

SortableTable.prototype.headerOnclick = function (e) {
	// find TD element
	var el = e.target || e.srcElement;
	while (el.tagName != "TD"&&el.tagName != "TH")
		el = el.parentNode;
	this.sort(this.getMetaCellIndex(el));
	//this.sort(SortableTable.msie ? SortableTable.getCellIndex(el) : el.cellIndex);
};

SortableTable.prototype.getMetaCellIndex=function(el){
	if(el._mcellIndex){
		return el._mcellIndex;
	}
	var mcols=this._mcols;
	var head=el.parentNode.parentNode.rows;
	if(!!!mcols){
		//init  current meta cell length
		var h0=head[0].cells;
		mcols=0;
		for(var i=0;i<h0.length;i++){
		 	mcols+=h0[i].colSpan;
		}
		this._mcols=mcols;
	}
	//init a meta array
	var meta=[];
	for(var i=0;i<head.length;i++){
		meta.push(new Array(mcols));
	}
	/**find current row null position*/
	function findNullIndex(array){
		if(array){
			for(var i=0;i<array.length;i++){
				if(array[i]!==1)
					return i;
			}
		}
	}
	for(var r=0;r<head.length;r++){
		var cells=head[r].cells;
		for(var c=0;c<cells.length;c++){
			var ind=findNullIndex(meta[r]),cell=cells[c];
			if(cell==el){
				return el._mcellIndex=el._jCellIndex=ind;
			}
			var colspan=cell.colSpan,rowspan=cell.rowSpan;
			for (var i=0;i<rowspan;i++){
				for (var j = 0; j < colspan; j++) {
					meta[r+i][ind+j]=1;
				}
			}
		}
	}
	
}

// IE returns wrong cellIndex when columns are hidden
// zhaogy modified this to return right index when rowspan exists
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;
	if(oTd._jCellIndex)
		return oTd._jCellIndex;
	var rows=getOuterTable(oTd).tHead.rows;
	var maxLen=0;
	var parentLen=null;
	var selfNdx=null;
	for(var i=0;i<rows.length;i++){
		var ths=rows[i].cells;
		var tLen=0;
		for(var j=0;j<ths.length;j++){
			if(ths[j]==oTd){
				selfNdx=j;
			}
			tLen+= (ths[j].colSpan ? ths[j].colSpan:1);
		}
		if(tLen>maxLen)
			maxLen=tLen;
		if(parentLen==null && selfNdx!=null){
			parentLen=tLen;
		}
	}
	return oTd._jCellIndex=selfNdx+maxLen-parentLen;
};

function getOuterTable(o){
	if(o.tagName=='TABLE')
		return o;
	else if (!o){
		return null;
	}
	else{
		return getOuterTable(o.parentNode);
	}
}


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);
	
	this.first = a[0];
	
	var tBody = this.tBody;

	a.sort(f);
	
	if (this.descending)
	{
		a.reverse();
		
		if(this.isFirstSort)
		{
				if(!this.first.value) a.pop();//a.unshift(this.first);
		}
	}

	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++)
	{
		//if it is first order
		if(this.isFirstSort)
		{
			if(a[i].flag == 0 && a[i].value == this.first.value) continue;
		}
		
		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,
				flag: i==0? 0:1//flag this the first
			};
	}
	
	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;
	/*
	switch (sType) {
		case "Number":
			return Number(sText);
		case "CaseInsensitiveString":
			return sText.toUpperCase();
		case "Date":
			var parts = sText.split("-");
			var d = new Date(0);
			d.setFullYear(parts[0]);
			d.setDate(parts[2]);
			d.setMonth(parts[1] - 1);
			return d.valueOf();
	}
	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();
};

SortableTable.grepNumber = function (s) {
	if(s.indexOf('--')!=-1){
		return Number.NEGATIVE_INFINITY;
	}
	else if(s.length>0 && s.substring(s.length-1)=='%')
		return Number(s.substring(0,s.length-1));
	else if(s.indexOf(',')>-1){
		return Number(s.replace(/,/g,''));
	}
	return Number(s);
};



// add sort types
//SortableTable.prototype.addSortType("Number", Number);
SortableTable.prototype.addSortType("Number", SortableTable.grepNumber);
SortableTable.prototype.addSortType("CaseInsensitiveString", SortableTable.toUpperCase);
SortableTable.prototype.addSortType("Date", SortableTable.toDate);
SortableTable.prototype.addSortType("String");
// None is a special case