/**
 * Allgemeine javascript funktionen
 */




///////////////////// submit-Funktionen /////////////////////

var isFirstSubmit = true;
var	isDelayedSubmit = false;

/*
 * Wie function submitWait(command, formname, waitLabel), 
 * nur das die Standart-Werte fuer das Label waitlabel und 
 * die Schaltflaechen sendButton und cancelButton automatisch gesetzt werden.
 */
function submitWait(command, formname) {
	submitWait(command, formname, 'waitlabel', 'sendButton', 'cancelButton');	
}

/*
 * Macht das uebergebene waitLabel sichtbar und setzt das submitCommand ab.
 * Hinter dem Argument 'waitLabel' koennen weiter Buttons uebergeben werden, welche dann
 * deaktiviert werden und als Mauscursor die Sanduhr zeigen.
 */
function submitWait(command, formname, waitlabel) {
  // submit funktioniert nur wenn es als erstes aufgerufen wird
  submitCommand(command);   
  document.getElementById(waitlabel).style.visibility = "visible";
  // Links auf disabled	 
  for ( var i = 3; i < submitWait.arguments.length; i++ ) {
	document.getElementById(submitWait.arguments[i]).blur();
	document.getElementById(submitWait.arguments[i]).onclick = function () { return false };      
    document.getElementById(submitWait.arguments[i]).disabled = true;     
    document.getElementById(submitWait.arguments[i]).style.cursor="wait";    		
  }
  // Reihenfolge nicht aendern, sonst erscheint das waitlabel nicht auf Netscape   
  setWaitPointer(formname);
  return false;
}


 /**
  * Uebertraegt die angebene Form und setzt dabei das angegebenen command.
  */
 function submitCommand(command) {
	// alert("submitCommand aufruf");
 	var form = document.forms[0];
 	if (isDelayedSubmit && form != null) {
 	  form.command.value=command;
 	  isDelayedSubmit = false;
  	  window.isButton = false;
 	  return false;
 	}

   // Verhindern von doppelsubmits bei doppelklicks vom user
   if (isFirstSubmit) {
     isFirstSubmit = false;
 		if (form == null) {
 		  return false;
 		}
     form.command.value = command;
     form.submit();
     return false;
   } else {
     return false;
   }
 } 
 
 
 /*
  * Setzt angegebenes Command in geeignete Form Form und sendet es ggf.(*) ab.
  * wird kein (optionales) formElem angegeben.
  * wenn anzahl d. formulare==1, wird das erste genommen, ansonsten keins.
  * 
  */
 function submitCommand2(command, formElem) {
	// alert("submitCommand2 aufruf");
 	var form = formElem;
 	if(!form && document.forms.length==1){
 		form = document.forms[0];
 	}
 	
 	if(!form || !form.command){
 		// falsch bedient => nix zu tun
 		return false;
 	}	
 	
 	if (isDelayedSubmit) {
 		form.command.value=command;
 		isDelayedSubmit = false;
 		window.isButton = false;
 		return false;
 	} else if (isFirstSubmit) {
 		// nur erstes submit behandeln
 		isFirstSubmit = false;
 		form.command.value = command;
 		form.submit();
 		return false;
 	}
 	return false;
 }

 /*
  * funktion ermittelt - wenn moeglich - aus optionalem 3. parameter e (ereignis) das passende formular-objekt.
  * ist dies gefunden, wird submitCommand2 damit aufgerufen.
  * 
  * Hinweis-1: wenn >1 Form auf der Seite sind ist der event-parameter noetig. 
  * Hinweis-2: beachten, dass das Form-Element auf dem Pfad der Eltern-Elemente ist.
  * Wenn das Form-Element z.B. zwischen TR und TABLE liegt, wird es nicht gefunden (!)
  */
 function dispatchCommand(command, saveScrollPos, e){
	//alert('dispatchCommand aufruf');
  var srcObj;
 	if(e){
 		srcObj = e.target || e.srcElement;
 	} 	 	
 	// sonst umgebendes formular suchen	
 	var formElem = null;
 	var stop = false;
 	var curElem = srcObj;
 	while(curElem && !formElem){
 		if(curElem){
 			if (curElem.nodeType==1) /* Element */{
 				//alert(curElem.tagName);
 				if(curElem.tagName=='FORM'){
 				 //alert("FOUND FORM");
 					formElem = curElem;
 				}
 			}
 			curElem = curElem.parentNode;
 		}
 	}
 	
 	if(!formElem && document.forms.length==1){
 	 //alert("nutze erste form, da kein zugehoeriges gefunden");
 		formElem = document.forms[0];
 	}
 	if(formElem && saveScrollPos){
 	 //alert("speichere pos vom element " + formElem.tagName);
 		saveXY(formElem); // pos speicherung
 	}
 	//alert("rufe dispatchCommand mit " + command + " und form " + formElem.action + " auf");
 	return submitCommand2(command, formElem);
 }
 	

/**
 * Dieses Submit Command ueberschreibt eventuelle onChange-Events und fuehrt den submit aus.
 * Eine ueberpruefung auf FirtSubmit erfolgt nicht, diese Funktion soll fuer Download-Fenster benutzt werden,
 * Welche auf der selben Seite bleiden, bei submitCommand waere nach dem Popup das firstSubmit gemacht und 
 * mann kann auf der Seite keine Submits mehr machen.
 */
function submitCommandPure(command) {
	var form = document.forms[0];
	if (isDelayedSubmit && form != null) {
	  form.command.value=command;
	  isDelayedSubmit = false;
 	  window.isButton = false;
	  return false;
	}

  if (form == null) {
	  return false;
	}
  form.command.value = command;
  form.submit();
  return false;
}

/**
 * Uebertraegt die angebene Form, setzt dabei das angegebenen command und
 * laed die Response im neuen Fenster. Loest einen zweiten Submit aus und
 * setzt dazu den command2 und laed diese Response im Hauptfenster.
 */
function submitCommandToPopUp(command, target, command2, width, height) {
  // Oeffne zuaechst leeres Fenster und behalte Focus auf aktuellem Fenster,
  // damit dieses im Vordergrund bleibt.
  openWindowWithDimension("about:blank",target,width,height);
  this.focus();
  	
  // Verhindern von doppelsubmits bei doppelklicks vom user
  if (isFirstSubmit) {
    isFirstSubmit = false;
	
  	//Formular des aktuellen Dokumentes ermitteln 
	  //und "target" sichern
	  var form = document.forms[0];
	  var target_old = form.target;
	
	  if (form == null) {
	    return false;
	  }
	
  	//erster Submit mit gesetztem Parameter "command" 
	  //und target neues fenster
    form.command.value = command;
    form.target = target;
    form.submit();
    
    //zweiter Submit mit gesetztem Parameter "command2" 
    //und target altes fenster
    form.command.value = command2;
    form.target = target_old;
    form.submit();
    return false;
  } else {
    return false;
  }
}



/**
 * Uebertraegt die angebene Form und setzt dabei das angegebenen command.
 */
function submitCommandByForm(command, formName) {
  // Verhindern von doppelsubmits bei doppelklicks vom user
  if (isFirstSubmit) {
    isFirstSubmit = false;
		var form = document.forms[formName];
	  if (form == null) {
	    return false;
	  }
    form.command.value = command;
    form.submit();
    return true;
  } else {
    return false;
  }
}


/**
 * Uebertraegt die angebene Form und setzt dabei das angegebenen command,
 * wobei die aktuelle XY-Position gespeichert wird, um sie spaeter wieder 
 * zu setzen. Sollte verwendet werden, wenn auf dem Form geblieben wird
 * nach dem submit.
 */
function submitCommandSaveXY(command) {
	// alert("submitCommandSaveXY aufruf");
	var form = document.forms[0];					
	if (isDelayedSubmit && form != null) {
	  form.command.value=command;
	  isDelayedSubmit = false;
 	  window.isButton = false;
	  return false;
	}
	
  if (isFirstSubmit) {
    isFirstSubmit = false;
		var form = document.forms[0];
	  if (form == null) {
	    return false;
	  }
    saveXY(form);    
    form.command.value = command;
    form.submit();
    return true;
  } else {
    return false;
  }
}


/**
 * Wie submitCommandSaveXY nur, dass die letzte Form einer Seite erwendet wird.
 */
function submitCommandOnLastFormSaveXY(command, formName) {
	var form = document.forms[document.forms.length-1];					
	if (isDelayedSubmit && form != null) {
	  form.command.value=command;
	  isDelayedSubmit = false;
 	  window.isButton = false;
	  return false;
	}
	
  if (isFirstSubmit) {
    isFirstSubmit = false;
		var form = document.forms[document.forms.length-1];
	  if (form == null) {
	    return false;
	  }
    saveXY(form);    
    form.command.value = command;
    form.submit();
    return true;
  } else {
    return false;
  }
}
 
/**
 * Wichtig fuer JWebUnit!
 */
function submitCommandSaveXYFocus(command, theFocusElement, switchFocus) {
	return submitCommandSaveXYFocus(command, theFocusElement, switchFocus, null);
}

/**
 * Uebertraegt die angebene Form und setzt dabei das angegebenen command,
 * wobei die aktuelle XY-Position gespeichert wird, um sie spaeter wieder 
 * zu setzen. Ausserdem wird die letzte Komponente gespeichert, die den 
 * Fokus hatte, um spaeter die naechste Komponente zu fokussieren.
 * Wenn 'switchFocus=false' uebergeben wird behaelt die angegebene Komponente 
 * den Fokus.
 * Sollte verwendet werden, wenn auf das Verlassen einer Komponente
 * etwas nachgeladen oder im Form veraendert werden muss, man aber will, 
 * dass beim Wiederanzeigen der Form der Fokus dann auf der naechsten 
 * Komponente steht.
 */
function submitCommandSaveXYFocus(command, theFocusElement, switchFocus, baseElement) {
  //alert("submitCommandSaveXYFocus aufruf, command: " + command);
  
  if (isFirstSubmit) {
    isFirstSubmit = false;
    var baseForm = document.forms[0];
    var form = baseForm
    if ( baseElement ) {
      var subform = getFormFromElement(baseElement);
      if ( subform ) {
    	  form = subform;
      }
    }
  	if (form == null) {
  	  return false;
  	}
  	if ( baseForm != null ) {
  		saveXY(form);
  		saveXY(baseForm);
  	}
    form.command.value = command;
    form.focusElement.value = theFocusElement;
    form.switchFocus.value = switchFocus;    
    if (window.isButton) {
      isDelayedSubmit = true;
      window.setTimeout("document.forms[0].submit()", 500);									
    } else {
      form.submit();
    }    
    return true;
  }
  return false;  
}

/**
 * Aktualisiert eine namentlich spezifizierte Textbox in einem festgelegten Formular 
 * mit dem Wert eines ebenfalls namentlich spezifizierten zweiten Formularelementes. Darueberhinaus
 * wird ein Command-Submit mit Fokus-Festlegung durchgefuehrt. 
 */
function updateTextBoxAndSubmitCommandXYFocus(formname,formElementName,formElementName2,command,formElementFocus,switchFocus) {
	document.forms[formname].elements[formElementName].value = document.forms[formname].elements[formElementName2].value;
	return submitCommandSaveXYFocus(command,formElementFocus,switchFocus);
}

/**
 * Aktualisiert eine namentlich spezifizierte Auswahlbox in einem festgelegten Formular 
 * mit dem Wert eines ebenfalls namentlich spezifizierten zweiten Formularelementes. Darueberhinaus
 * wird ein Command-Submit mit Fokus-Festlegung durchgefuehrt. 
 */
function updateSelectBoxAndSubmitCommandSaveXYFocus(formname,formElementName,formElementName2,command,formElementFocus,switchFocus) {
	var cBoxOptions = document.forms[formname].elements[formElementName].options;
	var textValue = document.forms[formname].elements[formElementName2].value;
	var found = false;
	for (var i=0; i<cBoxOptions.length; i++) {
		if (cBoxOptions[i].value == textValue) {
			document.forms[formname].elements[formElementName].value = cBoxOptions[i].value;
			found = true;
			break;
		}
	}
	return submitCommandSaveXYFocus(command,formElementFocus,switchFocus);
}

function saveXY(form) {
  if( typeof( window.pageYOffset ) == 'number' ) {
    //Netscape compliant
    form.pageYOffset.value = window.pageYOffset;
    form.pageXOffset.value = window.pageXOffset;
  } else if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) ) {
    //DOM compliant
    form.pageYOffset.value = document.body.scrollTop;
    form.pageXOffset.value = document.body.scrollLeft;
  } else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ) {
    //IE6 standards compliant mode
    form.pageYOffset.value = document.documentElement.scrollTop;
    form.pageXOffset.value = document.documentElement.scrollLeft;
  }
}

/**
 * Fokussiert die Komponente mit dem uebergebenen Namen.
 */
function setFocusTo(theFocusElement) {
  var form = document.forms[0];
  if (form == null) {
    return false;
  }
  var element = form[theFocusElement];
  if (element != null) {
		try {
      element.focus();
		} catch (e) {}  
  }
}
		


function submitOnEnter(command, event) {  
  return submitOnEnter(command, event, null, null);
}
/**
 * Uebertraegt die form nachdem in einem Feld <enter> gedrueckt wurde.
 * Benutzung: onkeypress="return submitOnEnter(...);".
 */
function submitOnEnter(command, event, theFocusElement, switchFocus) {  
  var form = document.forms[0];
  if (form == null) {
    	return false;
  }

  // Bei nicht-firefox-browsern wird der Event nicht per
  // Parameter uebergeben und muss window.event ausgelesen werden
  if (event == null) {
  	event = window.event;
  }
  
  // Wenn Enter (Taste 13) gedrueckt wurde, wird Formular weitergeleitet.
  if (enterPressed(event)) {		
  	event.cancelBubble = true;
  	if ( command != '' ) {
  		form.command.value = command;	  	
	}
  	saveXY(form);	    
  	if ( theFocusElement && switchFocus ) {
  		form.focusElement.value = theFocusElement;
  		form.switchFocus.value = switchFocus;
  	}
  	form.submit();
  	return false;
  }
}

/**
 * Returns true if enter key was pressed in a form.
 */
function enterPressed(event) {
  	if (event == null) {
  		event = window.event;
  	}
  	
    // MSIE kennt "keyCode", Firefox kennt "which"
    if ( (event.keyCode == 13) || (event.which == 13) ) {
        return true;
    }
    return false;
}

/**
 * Fokussiert das Element, was auf das zuletzt fokussierte Element folgt. 
 * Wenn kein altes fokussiertes Element gesetzt wurde wird der Fokus auf 
 * das defaultFocusElement gesetzt. 
 * Es wird immer das erste form der Seite genommen. Bei Seiten mit mehreren 
 * forms funktioniert das also nicht so. 
 */
function restoreXYFocus()
{
	var form = document.forms[0];
  if (form == null) {
    return false;
  }  
	//alert(form["pageXOffset"].value + "  -  " + form["pageYOffset"].value);
	// XY wiederherstellen  
	if (form["pageXOffset"] != null && form["pageYOffset"] != null) {
  	window.scrollTo(form["pageXOffset"].value, form["pageYOffset"].value);
	}  
		
	// Fokus wiederherstellen
	if (form["focusElement"] != null) {
		var lastFocusElement = form["focusElement"].value;			
		form["focusElement"].value = "";
	  
		var newFocusElement = null;
		if (form["defaultFocusElement"] != null) {		  		  
		  newFocusElement = form[form["defaultFocusElement"].value];      
		  if ( newFocusElement == null ) {
		    newFocusElement = form["value("+form["defaultFocusElement"].value+")"];
		  }
		}		
		if ( lastFocusElement != null ) {			  
		  // wenn schon vorher ein Element fokussiert war, dann entweder naechstes fokussieren
		  // oder wieder das gleiche fokussieren (abhaengig von 'switchFocus')
		  // sonst default nehmen
			var element = form[lastFocusElement];			
			if (element != null) {
			  if (form["switchFocus"] != null && form["switchFocus"].value == "true") {
				  newFocusElement = findNextInputField(element);
    		}	else {
			    newFocusElement = element;
			  }
			}			
		}				
		// eigentliches fokussieren
		if (newFocusElement != null) {
			try {
				newFocusElement.focus();				
				if (form["defaultSelectText"] != null) {
					if ( form["defaultSelectText"].value = "true" ) {
	  				newFocusElement.select();
	  			}
				}
			} catch (e) {}
		}	  
  }  
}

/** Gibt das Form-Element zurueck, welches das Element beinhaltet. **/
function getFormFromElement(element) {
  var parent = element.parentNode;
  if ( parent.nodeType==1 && parent.tagName == "FORM") {
    return parent;
  } else {
    return getFormFromElement(parent);
  }
}

/** 
 * Liefert das auf das uebergebene Element folgende Fokuselement 
 * entsprechend der Tabreihenfolge.
 */
function findNextInputField(elem) 
{	
	// Bei Radio_Buttons kann es dazu kommen, dass mann an dieser Stelle mehrere Elemente erhaelt (gleicher Name)
	// Deshalb immer das letzte nehmen:	
			
	var arr = [];	
	if ( typeof(elem) == typeof(arr) && elem.type == arr.type ) {
		elem = elem[elem.length-1];		
	}
	
	// Naechstes Element in der reihenfolge suchen
	var elems = elem.form.elements;
		
	var i=0;
	var nextInOrder = null;
	var nextBigger = null;
	var first = null;
	var pastElem = false;
	
	for ( i=0; i < elems.length; i++ ) {
		var e = elems[i];
		// dont focus fields that are hidden or disabled
		if ( e.disabled || e.readOnly || (e.type == "hidden") || (e.style.display == "none") 
			|| (e.style.visibility == "hidden") ) {
			continue;
		}
		
		// if we are past the original elem, find the next input with the same tabindex
		if ( pastElem && (e.tabIndex == elem.tabIndex) && (nextInOrder == null) ) {
			nextInOrder = e;
		}
		
		// find the input with the lowest tabindex that is bigger than elem.tabIndex
		if ( (e.tabIndex > elem.tabIndex) 
			 && ((nextBigger == null) || (e.tabIndex < nextBigger.tabIndex)) ) {
			 nextBigger = e;
		}
		
		// find the input with the lowest tabIndex
		if ( (e.tabIndex >= 0) && ((first == null) || (e.tabIndex < first.tabIndex)) ) {
			first = e;
		}
		
		if ( e == elem ) {
			pastElem = true; 
		}	
	}	
  
	// choose one of the found input fields 
	     if ( nextInOrder != null ) return nextInOrder;
	else if ( nextBigger != null ) return nextBigger;
	else return elem;
}



///////////////////// Datenpruef-Funktionen /////////////////////
function checkDate( fieldName, formName, allowPast, allowFuture ) 
{
	var currentDate = new Date;
	var currentYear = currentDate.getYear();
	var field       = document[formName][fieldName];
    if ( field == null ) {
      field = document.forms[document.forms.length-1][fieldName];
    }    
	var fieldValue  = field.value;
	var dayStr      = null;
	var monthStr    = null;
	var yearStr     = null;
	var message     = null;

	if ( (fieldValue == null) || (fieldValue == "") ) {
		// input field can be empty
		return true;
	}  
	if ( fieldValue.indexOf('.') >= 0 ) {
		// split the date into its components
		var fieldValues = fieldValue.split(".");
		dayStr   = fieldValues[0];
		monthStr = fieldValues[1];
		yearStr  = fieldValues[2];
	} else if (fieldValue.length >= 1 && fieldValue.length <= 2 ) {        
        dayStr = "1";
        monthStr = fieldValue;
        yearStr = ""+currentYear;
	} else {
		// date has been entered in numeric format
		dayStr   = fieldValue.substr( 0, 2 );
		monthStr = fieldValue.substr( 2, 2 );
		yearStr  = fieldValue.substr( 4, 4 );
	}
	
	var day   = Number(dayStr);
	var month = Number(monthStr);
	var year  = Number(yearStr);
	
	if ( (yearStr == null) || (yearStr == '') ) {
		year = currentYear;
	}
	else if ( !isNaN(year) ) {
		// allow for 2-digit years for 20xx [real currentyear is 1900+currentyear]
		if (year >= 0 && year <= 99) {
			year += 2000;
		}
	}

	var isInvalid = (dayStr == null) || (dayStr == '') || isNaN(day) || (day <= 0) || (day > 31)
				 || (monthStr == null) || (monthStr == '') || isNaN(month) || (month <= 0) || (month > 12)
				 || isNaN(year) || (year < 1900) || (year > 1900+currentYear + 100);
	
	if ( !isInvalid ) {
		// first check passed, now create a date with the user input. 
		// If the day is too big for a month, a wraparound occurs.
		var date = new Date( year, month-1, day );
		isInvalid = (date.getMonth() != month-1) || (date.getDate() != day);
		
		if ( !isInvalid && !allowFuture && (date.getTime() > currentDate.getTime()) ) {
			message = "Das Datum darf nicht in der Zukunft liegen!"
			        + "\nIhre Eingabe lautete: ''" + fieldValue + "''";
			isInvalid = true;
		}
		if ( !isInvalid && !allowPast && (date.getTime() + 24*60*60*10000 < currentDate.getTime()) ) {
			message = "Das Datum darf nicht in der Vergangenheit liegen!"
			        + "\nIhre Eingabe lautete: ''" + fieldValue + "''";
			isInvalid = true;
		}
	}

	if ( isInvalid ) {
/*		if ( message == null ) {
			message = "Bitte geben Sie ein gueltiges Datum ein (Format: TT.MM.JJJJ)"
			 		+ "\nIhre Eingabe lautete: ''" + fieldValue + "''";
		}
		alert( message );
		field.value = "";
		field.focus();*/
		return false;
	} else {
		// date is valid, reformat
		field.value = ((day < 10) ? "0" : "") + day + "."
					  + ((month < 10) ? "0" : "") + month + "." + year;
		return true;
	}
}

///////////////////// Datenpruef-Funktionen /////////////////////
function checkMoney( fieldName, formName, maxLength) {
	var field       = document[formName][fieldName];
  if ( field == null ) {
    field = document.forms[document.forms.length-1][fieldName];
  }
	var fieldValue  = field.value;
	var euroStr     = null;
	var centStr     = null;
	var message     = null;

	if (fieldValue == null || fieldValue == "") {
		// input field can be empty
		return true;
	}
	// Trimmen
	var i = 0;
	while ( fieldValue.charAt(i) == ' ' ) {
		fieldValue = fieldValue.substring(1);
		i++;
	}	
	
	// Ist der Betrag negativ
	var negativ = fieldValue.charAt(0) == '-';
	// Minus entfernen, wird spaeter wieder voran gesetzt
	if ( negativ ) {
		fieldValue = fieldValue.substring(1);
	}
	
	var sepPos = fieldValue.indexOf(',');
	if (sepPos >= 0) {
		// split the money into its components
		if (sepPos > 0) {
			euroStr = fieldValue.substr(0, sepPos);
		} else {
			euroStr = null;
		}
		if (sepPos+1 < fieldValue.length) {
			centStr = fieldValue.substr(sepPos+1);
		} else {
			centStr = null;
		}
	} else {
		euroStr = fieldValue;
		centStr = null;
	}

	var centValue = 0;
	if (centStr != null) {
		//centStr = String(centValue);
		if (centStr.length > 2) {
			centStr = centStr.substr(0, 2);
		} else if (centStr.length == 1) {
			centStr = centStr+"0";
		}
		centValue = Number(centStr);
		if (isNaN(centValue)) {
			return false;
		}
	}
	else {
		centStr = "00";
	}

	var euroValue = 0;
	if (euroStr != null) {
		var isFirstDigit = true;
		var isNegative = false;
		for (i=0; i<euroStr.length; i++) {
			var chr = euroStr.charAt(i);
			if (isFirstDigit && (chr == '+' || chr == '-')) {
				isNegative = (chr == '-');
				isFirstDigit = false;
			} else if (chr >= '0' && chr <= '9') {
				euroValue = euroValue*10 + Number(chr);
				isFirstDigit = false;
			} else if (chr == '.') {
				//Tausendertrenner ignorieren:
				isFirstDigit = false;
			} else if (chr == ' ') {
				//spaces komplett ignorieren:
			} else {
				return false;
			}
		}
		if (isNegative) {
			euroValue = -euroValue;
		}
	}
	euroStr = "";
	var digsTillDot = 3;
	while (euroValue > 0) {
		if (digsTillDot-- <= 0) {
			euroStr = "."+euroStr;
			digsTillDot = 2;
		}
		euroStr = String(euroValue%10) + euroStr;
		euroValue = (euroValue-(euroValue%10)) / 10;
	}
	
	if(euroStr == "" && centStr == "00") {
	  euroStr = "0";
	}
	
	fieldValue = euroStr+","+centStr;

	if (fieldValue.length > maxLength) {
		return false;
	}
	
	// Minus wieder voran setzen
	if ( negativ ) {
		fieldValue = "-"+fieldValue;
	}
	
	field.value = fieldValue;
	return true;
}

///////////////////// Window-Funktionen /////////////////////


/** 
 * java-script popup, das die angegebenen message auf den Schirm bringt und 
 * wenn der Benutzer 'Ja' drueckt, den angegebenen link laed.
 */
function confirmLink(link,message)
{
	if ( confirm(message) ) {
		location.href = link;
	}
}


/** 
 * oeffnet ein Popup in das die url geladen wird mit den angegebenen Groessen
 */
function openWindowWithDimensionAndPosition(url, target, width, height, left, top) {
  popupw = window.open(url,target,"height="+height+",width="+width+",status=yes,toolbar=no,menubar=no,location=no,scrollbars=yes,resizable=yes,left="+left+",top="+top);
  if (popupw) {
    popupw.focus();
  }
  return false;
}

/** 
 * oeffnet ein Browser Fenster in das die url geladen wird
 */
function openBrowserWindow(url) {
  window.open(url,'link','width=800,height=600,toolbar=yes, location=yes,directories=yes,status=yes,menubar=yes,scrollbars=yes,copyhistory=yes, resizable=yes');
  if (popupw) {
   popupw.focus();
  }
  return false;
}

/** 
 * oeffnet ein Popup in das die url geladen wird mit den angegebenen Groessen, keine Scrollbar, keine Menue, kein Resize
 */
function openWindowConfirmation(url, target, width, height) {
  popupw = window.open(url,target,"height="+height+",width="+width+",status=no,toolbar=no,menubar=no,location=no,scrollbars=no,resizable=no");
  if (popupw) {
    popupw.focus();
  }
  return false;
}


/** 
 * oeffnet ein Popup in das die url geladen wird mit den angegebenen Groessen
 */
function openWindowWithDimension(url, target, width, height) {
  popupw = window.open(url,target,"height="+height+",width="+width+",status=yes,toolbar=no,menubar=no,location=no,scrollbars=yes,resizable=yes");
  if (popupw) {
    popupw.focus();
  }
  return false;
}


/** 
 * oeffnet ein Popup in das die url geladen im Hintergrund wird mit den angegebenen groessen
 */
function openWindowInBackgroundWithDimension(url,target,width,height) {
  popupw = window.open(url,target,"height="+height+",width="+width+",status=yes,toolbar=no,menubar=no,location=no,scrollbars=yes,resizable=yes");
  this.focus();
  return false;
}

var helpwindow = null;
function showHelpWindow(helpUrl) {
	closeHelpWindow();
	helpwindow = window.open(helpUrl,"Hilfe","width=800, resizable=no,scrollBars=1,outerWidth=800, outerHeight=640");
	return false;
}

function showHelpWindow(helpUrl, width, height) {
	closeHelpWindow();
	if ( typeof width == 'undefined' ) {
		width = 800;
	}
	if ( typeof height == 'undefined' ) {
		height = 640;
	}
	helpwindow = window.open(helpUrl,"Hilfe","width="+width+",height="+height+",resizable,scrollBars=1");
	return false;
}

function closeHelpWindow() {
	if (helpwindow && helpwindow.open && !helpwindow.closed) {
		helpwindow.close();
	}
	return true;
} 

function makeNewWindow(url, target,width,height) {
	LeftPosition = (screen.width) ? (screen.width-width)/2 : 0;
	TopPosition = (screen.height) ? (screen.height-height)/2 : 0;
	settings = "width="+width+",height="+height+",top="+TopPosition+",left="+LeftPosition+",status=yes,toolbar=no,menubar=no,location=no,scrollbars=yes,resizable=no,screenX=150,screenY=80";
  	popupw = window.open(url,target, settings);
  	if (popupw) {
    	popupw.focus();
  	}
  	return false;
}

// oeffnet ein Fenster in der angegebenen Groeße und laedt den Inhalt der URL hinein.
function openDataWindowWithDimension(url, target,width,height) {
  popupw = window.open(url,target,"height="+height+",width="+width+",status=yes,toolbar=no,menubar=no,location=no,scrollbars=yes,resizable=yes");
  if (popupw) {
    popupw.focus();
  }
  return false;
}






///////////////////// Sonstige-Funktionen /////////////////////


// Setzt den Wait Pointer fuer die uebergebene form
// und setzt die form inaktiv, so dass nichts geaendert 
// werden kann.
function setWaitPointer(formname) {
  var form = eval("document." + formname);
  
  // setzte waitcursor fuer die form und alle formelemente
  if (form) {
    form.style.cursor = "wait";    
    for (i = 0; i < form.elements.length; i++) {
      form.elements[i].style.cursor="wait";
     //form.elements[i].disabled=true; // Gab Probleme, hat den Explorer zu 99% ausgelastet 
     																	 // und alles andere ausgebremst
    }
  }

  var browserName = navigator.appName;
  if (browserName.match(/Netscape/)) {
    window.captureEvents(Event.MOUSEDOWN);
    window.onMouseDown=lockMouseClick;
  } 

  return false;
}

function lockMouseClick(e) {
	// TODO ...
}


/////////////////// Formular-Funktionen ////////////////////////

/**
 * Setzt das angegebene Formularelement zurueck.
 */
function resetFormElement(formElement) {
  formElement.value='';
}
	
/**
 * Fuegt dem angegebenen Formularelement den uebergebenen Wert an.
 * Ist das Formularelement nicht leer, wird zuvor ein Leerzeichen
 * eingefuegt.
 */
function appendToFormElementValue(formElement,formElementValue) {
  var oldValue = formElement.value;
  if (oldValue.length == 0) {
    formElement.value = formElementValue;
  } else {
    formElement.value = oldValue + ' ' + formElementValue;
  }
}

//Diese Methode leitet den Webbrowser auf die uebergebene URL weiter.
function redirect(url) {
	self.location.href=url
}

/** Methoden fuer die Manipulation des DOM-Trees. **/
/** 
 * Setzt das Value des Feldes. 
 **/
function setValue(id, value) {  
  var obj = get(id);
  if ( obj ) {
    // Bei Checkboxen und Radio-Buttons ggf. eine toString-Konvertierung beruecksichtigen!
    var type = obj.type.toUpperCase();
    if ( type == "CHECKBOX" || type == "RADIO" ) {
      if ( value == true || value.toUpperCase() == "JA" ) { 
        obj.setAttribute("checked", "true");
      } else if ( value == false || value.toUpperCase() == "NEIN") {
        obj.removeAttribute("checked"); 
      }
    } else {
      // Wert setzen
      obj.value = value;
    } 
  }
  return obj;
}

/** 
 * Setzt das InnerHtml des Feldes. 
 **/
function setHtml(id, html) {  
  var obj = get(id);
  if ( obj ) {
    obj.innerHTML = html;
  }
  return obj;
}

/** 
 * Ersetzt das Feld mit der Id durch den Html-Code. 
 **/
function updateHtml(id, html) {  
  var obj = get(id);
  if ( obj ) {          
    var parent = obj.parentNode;
    // Elemente einfuegen    
    $(obj).before(html);
    // Altes Html loeschen  
    try {
      parent.removeChild(obj);
    } catch (e) {} // An dieser Stelle ist das Element eh bereits weg.
  }
}

/** 
 * Löscht das Element mit der Id. 
 **/
function removeHtml(id) {  
  var obj = get(id);
  if ( obj ) {          
    var parent = obj.parentNode;
    // Altes Html loeschen    
    parent.removeChild(obj);    
  }
}

/** 
 * Gibt das Element anhand seiner Id zurueck. 
 **/
function get(id) {
  return document.getElementById(id);
}

/** 
 * Setzt die Sichtbarkeit aller Element die durch den JQuery-Selektor beschrieben werden auf den gewuenschten Wert. 
 **/
function setVisible(id, visible) {
  var obj = get(id);  
  if ( obj ) {  
    obj.style.display = (visible?"":"none");
    if ( isInputElem(obj) ) {
      if ( visible ) {
        obj.removeAttribute("disabled");
      } else {
        obj.setAttribute("disabled", "true");
      }   
    }
  }
  return obj;
}

/** 
 * Methode fuer das Umsetzen der Sichtbarkeit.
 * Ist das Element sichtbar, wird es versteckt, andernfalls angezeigt.
 **/
function switchDisplay(id) {
  var input = get(id);
  if ( input ) {
    var visible = false;
    if ( input.style && input.style.display && input.style.display != 'none' && input.style.display != 'hidden' ) {
      visible = true;
    }
    setVisible(id, visible);
  }
    
}