/**
 * Erweiterungen der Klasse String
 */

String.prototype.trimLeft = function(sSign){
	var sRet;
	var sRet = this.toString();
	while( sRet.charAt(0) == ' ' ){
		sRet = sRet.slice(1);
	}
	while( sRet.charAt(0) == sSign ){
		sRet = sRet.slice(1);
	}
	return sRet;
}


/**
 * Erweiterungen der Klasse Date
 */
Date.prototype.parseTime = function(sTime){
	// sTime liegt im Format " HH:MM" vor
	sTime = sTime.trimLeft(' ');
	var aTime = sTime.split(':');
	var sH = aTime[0].trimLeft('0'); // F?hrende Nullen k?nnen nicht geparst werden
	var sM = aTime[1].trimLeft('0'); // F?hrende Nullen k?nnen nicht geparst werden
	var iH = 0;
	var iM = 0;
	if(sH.length > 0){
		iH = parseInt(sH);
	}
	if(sM.length > 0){
		iM = parseInt(sM);
	}
	return iH*60*60*1000 + iM*60*1000;
}

Date.prototype.parseGerDate = function(sDate){
	    var aKomp = sDate.split('.');					
	    var oDate = null;
		if( sDate == 'heute'){
			oDate = new Date();
		}else if ( sDate == 'gestern' ){
			oDate = new Date(new Date().getTime()-24*60*60*1000);
		}else if ( sDate == 'morgen' ){
			oDate = new Date(new Date().getTime()+24*60*60*1000);
		}else {
			var sEnglDate = aKomp[1]+'/'+aKomp[0]+'/'+aKomp[2];
			oDate = new Date(Date.parse(sEnglDate));
		}
		return oDate;
}


/**
 * Diese Klasse dient zum Sortieren von Tabellenspalten.
 * 
 * Es kann momentan nach den folgenden Datentype sortiert 
 * werden:
 * 
 * string   : eine ganz "normale" String-Sortierung
 * number   : Interpretation der Spalte als Integer-Zahlen
 *            interpretiert und nach Gr??e sortiert.
 * datetime : Hier werden die Spalten als Datum mit Zeitangabe
 *            interpretiert und sortiert.
 * 
 * Ferner wird im Kopf der Tabelle (neben der ?berschrift) 
 * mittels eines Pfeils die aktuell zu sortierende Spalte 
 * und die Richtung der Sortierung angezeigt.
 *
 */
function SortTable (){
	XPlatform.call(this);
	this.SORTIMG_EMPTY = "imgs/sp.gif";
	this.IMGPATH       = "imgs/icons";
	this.SORTIMG_UP    = "imgs/icons/sortu.gif";
	this.SORTIMG_DOWN  = "imgs/icons/sortd.gif";
	this.UP   = 1;
	this.DOWN = -1;
	this._linkActive = false;
	
	if( typeof SortTable._initialized == "undefined" ){
	
		/**
		 * Methode zur Sortierung einer Tabelle.
		 *
		 * @param iColnum - integer mit Spaltenangabe, nach 
		 *                  welcher Spalte sortiert werden soll.
		 * @param sId     - string mit dem Namen der Tag-ID der
		 *                  Tabelle, die sortiert werden soll. 
		 * @param sType   - string, der den Typ der Sortierung 
		 *                  angibt.
		 */
		SortTable.prototype.sort = function(iColnum, sId, sType, oCell){
			var oTab     = this.getElementById(sId);
			var oTabBody = oTab.tBodies[0];
			var oTabRows = oTabBody.rows;
			var aRows   = new Array();
				
			for(var i=0; i<oTabRows.length; i++){
				aRows.push(oTabRows[i]);
			}

			aRows.sort(this.getCompareFunction(sType, iColnum));
			if(this.handleSortOrder(oTab, iColnum) == this.DOWN)
				aRows.reverse();
			aRows.reverse();
			
			var oNewBody = document.createDocumentFragment();
			for(var i = aRows.length-1; i>=0; i--){
				if(i%2==0)
					aRows[i].setAttribute("class", "row_odd");
				else
					aRows[i].setAttribute("class", "row_even");
				oNewBody.appendChild(aRows[i]);
			}
			oTabBody.appendChild(oNewBody);
		}
		/** 
		 *  Methode zur Verifikation der Sortierreihenfolge
		 *  (Aufsteigen UP, Absteigend DOWN). Auch das Toggeln 
		 *  einer auf einer Spalte festgelegten Reihenfolge 
		 *  wird in dieser Methode ber?cksichtigt.
		 *  Ferner wird hier auch das passend Symbol der Sortieranzeige
		 *  in die Kopfspalte eingef?gt.
		 *
		 */
		SortTable.prototype.handleSortOrder = function(oTable, iColnum){
			
			// Emitteln der vorherigen Sortierung
			var oHeadRow    = oTable.tHead.rows[0];
			var oCell       = oHeadRow.cells[iColnum];
			var sImgSrc     = this.SORTIMG_EMPTY;
			var sNewImgSrc  = this.SORTIMG_EMPTY;
			var iRet        = this.UP;
			if (oCell.childNodes.length == 2){ // Es ist schon ein img-Tag vorhanden.
				sImgSrc = oCell.lastChild.getAttribute('src');
				var aImgSrcPart = sImgSrc.split('/');
				sImgSrc = this.IMGPATH + "/" + aImgSrcPart[aImgSrcPart.length-1];
			}
			
			// Auswertun ggf. Toggeln
		    if( sImgSrc == this.SORTIMG_UP ){
				sNewImgSrc = this.SORTIMG_DOWN;
				iRet = this.DOWN;
			}else if( sImgSrc == this.SORTIMG_DOWN ){
				sNewImgSrc = this.SORTIMG_UP;
				iRet = this.UP;
			}else{
				sNewImgSrc = this.SORTIMG_UP;
				iRet = this.UP;
			}
			
			for(var i=0; i<oHeadRow.cells.length; i++){
				var sName = oHeadRow.cells[i].firstChild.nodeValue.toString();
				if(i==iColnum){
					oHeadRow.cells[i].innerHTML = sName + "<img src=\""+sNewImgSrc+"\"/>";   			    
				}else{
					oHeadRow.cells[i].innerHTML = sName;   			    
				}
			}
			return iRet;			
		}

		/**
		 * Methode liefert die Vergleichsfunktionen zur Sortierung der 
		 * verschiedenen Typen zur?ck.
		 */		
		SortTable.prototype.getCompareFunction = function(type, iColnum){
	    	//
	    	// Sortierung nach Strings:
	    	//
			if(type == "string"){
				return function(oRow1, oRow2){
					var sVal1 = oRow1.cells[iColnum].firstChild.nodeValue.toString().toLowerCase();
					var sVal2 = oRow2.cells[iColnum].firstChild.nodeValue.toString().toLowerCase();
	    			if(sVal1 > sVal2)
	    				return 1;
	    			else if(sVal1 < sVal2)
	    				return -1;
		    		else 
		    		    return 0;
	    		} 
	    	//
	    	// Sortierung nach Integerwerten:
	    	//
			}else if (type == "number"){
				return function(oRow1, oRow2){
					var iVal1 = parseInt(oRow1.cells[iColnum].firstChild.nodeValue);
	    			var iVal2 = parseInt(oRow2.cells[iColnum].firstChild.nodeValue);
	    			if(iVal1 > iVal2)
	    				return 1;
	    			else if(iVal1 < iVal2)
	    				return -1;
		    		else 
		    		    return 0;
	    		} // Ende des Number-Vergleichers
	    	//
	    	// Sortierung nach Daten:
	    	//
			}else if (type == "datetime"){
				return function(oRow1, oRow2){
					var sDate1 = oRow1.cells[iColnum].firstChild.nodeValue.toString();
					var sDate2 = oRow2.cells[iColnum].firstChild.nodeValue.toString();
					// Einfassung in einen Try-Catch-Block, da evtl. "schmutzige" 
					// daten in den Zeilen stehen.
					try{
						// datum in Zahl konvertieren
						var aDate1 = sDate1.split(',');
						var aDate2 = sDate2.split(',');
						var oDate1 = null;
						var oDate2 = null;
						var iTime1 = 0;
						var iTime2 = 0;
						
						oDate1 = new Date().parseGerDate(aDate1[0]);
						oDate2 = new Date().parseGerDate(aDate2[0]);
						iTime1 = oDate1.parseTime(aDate1[1]);
						iTime2 = oDate2.parseTime(aDate2[1]);
											
						if(oDate1.getTime() > oDate2.getTime()){
							return 1;
						}else if(oDate1.getTime() < oDate2.getTime()){
							return -1;
						}else{
							if(iTime1 > iTime2) return -1;
							else if (iTime1 < iTime2) return 1;
							else return 0;
						}
					}catch(e){
						return 0;
					}
	    		    return 0;
	    		}
			}
			return null;
		}
		
		/**
		 * Methode wird aufgerufen, wenn mit der Maus ?ber eine 
		 * Tabellenzeile "gefahren" wird.
		 */
		SortTable.prototype.mouseOver = function(oRow){
			var sClass = oRow.getAttribute('class');
			if(sClass == 'row_odd'){
				oRow.setAttribute('class', 'row_odd_over');
			}else{
  			    oRow.setAttribute('class', 'row_even_over');
			}
		}
		
		/**
		 * Methode wird aufgerufen, wenn die Maus eine
		 * Tabellenzeile verl?sst.
		 */
		SortTable.prototype.mouseOut = function(oRow){
			var sClass = oRow.getAttribute('class');
			if(sClass == 'row_odd_over'){
				oRow.setAttribute('class', 'row_odd');
			}else{
			    oRow.setAttribute('class', 'row_even');
			}
		}
		
		SortTable.prototype.setLinkActive = function(){
			this._linkActive = true;
		}
		
		SortTable.prototype.resetLinkActive = function(){
			this._linkActive = false;
		}
		
		SortTable._initialized = true;
	}

}

SortTable.prototype = new XPlatform();
oSortTable = new SortTable();