/* charset-encoding="UTF-8" */

/*
 * Copyright 2013 Persis GmbH
 */

/**
 * [23.05.2007] lo: decimalToStr(): fmt kann nun auch Tausender-Trenner enthalten ","
 * [07.03.2008] la: checkEmptyField() ergänzt um Debug-Hinweis, wenn Feld nicht im IE zugreifbar ist, da der Firefox hier kein Problem hat, der IE aber schon!
 * [20.10.2008] lo: checkDateRangeValue() ergänzt. Prüft, ob ein Datum zwischen einem Zeitraum liegt
 * [21.10.2008] lo: checkEmptyHiddenField() erweitert, so dass wie bei den anderen Prüffunktionen das Feld im Fehlerfall eingefärbt wird.
 * [21.10.2008] lo: Korrektur der Wiederherstellung des class_sik-Attributes in checkEmptyField() und checkEmptyHiddenField().
 * [30.10.2008] kw: Funktion checkURLValidate hinzugefügt - Ausserdem die Datei wieder auf UTF-8 konvertiert
 * [02.06.2010] lo: setValidationErrorClass() ergänzt. Markiert ein Eingabefeld, wenn ein Validierungsfehler aufgetreten ist. 
 * [15.09.2010] lo: Namespace-Deklaration für persis.require() ergänzt (persis.old_scripts.parser_js). 
 * [06.06.2011] wb: Neue Funktion: checkEmptyFieldNoMsgElem
 * [06.06.2011] wb: Funktion checkEmptyFieldElem um Parameter msg und markfield ergänzt
 * [18.05.2012] lo: Verschachtelten Kommentar entfernt. Führte zu Problemen bei der Übersetzung.
 * [26.10.2012] sl: checkxxxField benutzen jetzt setValidationErrorClass() zum setzen der "mussfeld"-css-Klasse.
 * [07.11.2012] ps: checkDateFormat hinzugefügt, wird in der checkDateField() aufgerufen.| checkDateField speichert u. gibt Wert von Datumsfeld zurück.
 * [25.03.2013] lo: Abhängigkeiten manuell noch hier ergänzt, falls die Script-Datei direkt per <script>-Tag geladen wurde. 
 * [03.04.2013] ms: Funktion checkDecimalFieldElem hinzugefügt. checkDecimalField führte zu Problemen bei Elementen mit dem selben Namen.
 * [29.04.2013] bs: form.name ersetzt mit form.attributes["name"].value, da es hier zu Problemen mit gleichnamigen Inputfeldern kommen konnte.
 * [13.05.2013] la: Funktion checkCheckboxIsChecked() hatte nur mit Formular "form" und Checkboxen namens "refnr" funktioniert
 * [17.05.2013] la: Abfrage auf getDateFormat() in checkDateFormat()
 * [04.06.2013] la: convertDecimal() und checkDecimal() umgebaut, sodass sie Tausender-Trennzeichen berücksichtigen (benötigt neue format_settings_js)
 * [06.08.2013] la: convertDecimal() berücksichtigt jetzt Sonderfälle
 * [09.12.2013] la: convertDecimal() musste weiter angepasst werden
 * [30.12.2013] bs: var re mit regulärem Ausdruck zur Prüfung ergänzt um eine Eingabe wie "ab sofort" zu verhindern
 * [22.01.2014] ms: checkDecimalDot() lässt nur noch Zahlen und "," und "." zu 
 * [22.01.2014] la: Fix in consumeWs() betreffs "\s"
 * [10.03.2014] sts: Mussfeld-Anleuchtung in Funktion checkCheckboxIsChecked ergänzt
 * [17.03.2014] sts: Fallunterscheidung des Alert-Textes zwischen 1 und mehrfach-gleichnamiger Checkbox in checkCheckboxIsChecked
 * [17.12.2014] la:  checkEmptyField(formName, fieldName) Prüfung auf Feld vorhanden ergänzt/korrigiert
 * [23.03.2015] ae:  Beim Prüfen des Datumsformat die If-Bedingung "if (datum.length == 9 && datum.split(trennzeichen).length > 1 && datum.split(trennzeichen)[1].length == 1)" erweitert, da es hier Probleme beim Eingeben eines "/" gab.
 * [09.06.2015] sts: In Funktion "setValidationErrorClass" Prüfung auf Prüfung eventueller Trans-Spalte ergänzt
 * [25.09.2015] la:  checkEmptyField() geht defensiv vor bei nicht vorhandenen Feldern (macht weiter)
 */


/**
 * Namespace-Deklaration für persis.require()
 */
if(typeof persis != 'undefined') {
	persis.old_scripts = persis.old_scripts || {};
	persis.old_scripts.parser_js = true;
	
	persis.require('persis.old_scripts.form_js');
}

	/*
	' Parserfunktion zum "konsumieren" von Whitespaces.
	*/
	function consumeWs(text, pos) {
		var len = text.length;
		while(pos < len && (text.charAt(pos) == " " ||
			text.charAt(pos) == "\t" ||
			text.charAt(pos) == "\n" ||
			/* text.charAt(pos) == "\s" || */  // <-- Fehler: Buchstabe "s" wird als Leerzeichen interpretiert???
			text.charAt(pos) == "\r")) {
			pos++;
		}
		return pos;
	}

	/*
	' Parserfunktion zum "konsumieren" von Vorzeichen.
	*/
	function consumeSig(text, pos) {
		var len = text.length;
		if(pos < len && (text.charAt(pos) == "+" || text.charAt(pos) == "-")) {
			pos++;
		}
		return pos;
	}

	/*
	' Parserfunktion zum "konsumieren" von Ziffern.
	*/
	function consumeDig(text, pos) {
		var len = text.length;
		while(pos < len && (text.charAt(pos) >= "0" && text.charAt(pos) <= "9")) {
			pos++;
		}
		return pos;
	}

	/*
	' Parserfunktion zum "konsumieren" des Dezimalpunkts (oder Komma).
	*/
	function consumeDecimalDot(text, pos) {
		var len = text.length;
		var re = /[^,.0-9]/;
		if(pos < len && (text.search(re)) > 0) {
			return ('_Buchst_');
		}
		if(pos < len && (text.charAt(pos) == "." || text.charAt(pos) == ",")) {
			pos++;
		}
		return pos;
	}

	/*
	' Parserfunktion zum "konsumieren" des Punktes.
	*/
	function consumeDateDot(text, pos) {
		var len = text.length;
		if(pos < len && text.charAt(pos) == ".") {
			pos++;
		}
		return pos;
	}

	/*
	' Parserfunktion zum "konsumieren" eines bestimmten Zeichens.
	*/
	function consumeChar(text, ch, pos) {
		var len = text.length;
		if(pos < len && text.charAt(pos) == ch) {
			pos++;
		}
		return pos;
	}

	/*
	' Funktion zur Prüfung, ob ein String (abgesehen von Spaces) leer ist.
	' Rückgabe: [true], wenn leer
	' Beispiel: // liefert [true]
	'           return checkEmpty("    ");
	*/
	function checkEmpty(text) {
		var pos = consumeWs(text, 0);
		if(pos >= text.length) {
			return true;
		}
		return false;
	}
	
	//Funktion zur Prüfung ob bei einer Mehrfachauswahl durch Checkboxen mindestens eine markiert wurde.
	function checkCheckboxIsChecked(formName, refnr) {
		var form = getFormObject(formName);
		var len = form.elements.length;
		var elem = document.getElementById(refnr);
		var i;
		var searchstring = '-1';
		for(i = 0; i < len; i++) {

			if(form.elements[i].name == refnr) {
				if(form.elements[i].checked == true)
					searchstring = searchstring + ', ' + form.elements[i].value;
			}
		}

		if(searchstring == '-1') {
			if(form.elements[refnr].length > 1) {
				alert(/* persis-id="17255" */ 'Es muss mindestens ein Datensatz ausgewählt werden.');
			}
			else
			{
				alert(/* persis-id="55193" */ "Es wurde eine Checkbox nicht ausgewählt!");
			}
			
			if(typeof elem != "undefined" && elem != null)
				setValidationErrorClass(elem, true);
			return false;
		}
		
		if(typeof elem != "undefined" && elem != null)
			setValidationErrorClass(elem, false);
		return true;
	}

	//
	// Funktion zur Prüfung eines Strings, auf eine korrekte ganze Zahl.
	// Per Flag kann angegeben werden, ob der String (abgesehen von Spaces)
	// leer sein darf.
	// Rückgabe: [true], wenn korrekt
	// Beispiel: // Variable text überprüfen
	//           if(!checkInteger(text, false)) {
	//				alert( /* persis-id="6531" */ "Fehler");
	//				return false;
	//           }
	//
	function checkInteger(text, empty) {
		var len = text.length;
		var pos1 = consumeWs(text, 0);
		if(pos1 >= len) {
			if(!empty) {
				return false;
			}
			return true;
		}
		var pos2 = consumeSig(text, pos1);
		var pos3 = consumeWs(text, pos2);
		if(pos3 >= len) {
			return false;
		}
		var pos4 = consumeDig(text, pos3);
		var pos5 = consumeWs(text, pos4);

		if(pos5 < len) {
			return false;
		}
		return true;
	}

	//
	// Funktion zur Prüfung eines Strings, auf eine korrekte Dezimalzahl.
	// Per Flag kann angegeben werden, ob der String (abgesehen von Spaces)
	// leer sein darf.
	// Rückgabe: [true], wenn korrekt
	// Beispiel: // Variable text überprüfen
	//           if(!checkDecimal(text, false)) {
	//           	alert( /* persis-id="6531" */ "Fehler");
	//           	return false;
	//           }
	//
	function checkDecimal(text, empty) {
	
		var len = text.length;
		var pos1 = consumeWs(text, 0);
		if(pos1 >= len) {
			if(!empty) {
				return false;
			}
		}
		var pos2 = consumeSig(text, pos1);
		var pos4 = consumeDig(text, pos2);
		var pos5 = consumeDecimalDot(text, pos4);
		if(pos5 > len || pos5 == '_Buchst_') {
			return false;
		}	
		if(text != "")
		{ 
			return !isNaN(convertDecimal(text));
		}
		else
		{
			return true;
		}
	}

	//
	// Funktion zur Prüfung eines Strings, auf eine korrekte Uhrzeit.
	// Per Flag kann angegeben werden, ob der String (abgesehen von Spaces)
	// leer sein darf.
	// Rückgabe: [true], wenn korrekt
	// Beispiel: // Variable text überprüfen
	//           if(!checkInteger(text, false)) {
	//				alert( /* persis-id="6531" */ "Fehler");
	//				return false;
	//           }
	// Change:	20070917 | RJ
	//			Abfrage auf isNaN( num ) hinzugefügtgt, da Eingabe aa:bb möglich war
	function checkTime(text, empty) {
		var len = text.length;
		
		var i = consumeWs(text, 0);
		
		if(len==0)
			return true;
		
		if (len -i != 5) // hh:mm
			return false;

		var num = convertInteger(text.substr(i, 2));
		if (num > 23 || num < 0 || isNaN( num ))
			return false;

		i += 2;

		var s = text.substr(i++, 1);
		if (s != ":")
			return false;

		num = convertInteger(text.substr(i, 2));
		if (num > 59 || num < 0 || isNaN( num ))
			return false;

		i = consumeWs(text, i + 2);

		if (i != len)
			return false;

		return true;
	}

	/*
	' Diese Funktion wandelt die angegebene Ganzzahl in einen String um. Dabei
	' kann angegeben werden, wie lange die Ausgabe mindestens sein soll.
	' Ist die Ganzzahl kleiner, werden führende 0en eingesetzt.
	*/
	function intToStr(iInt, len) {
		var num = Math.floor(iInt);
		var str = String(num);
		var numLen = str.length;

		if(len != null && len > numLen) {
			var i;
			for(i = numLen; i < len; i++) {
				str = "0" + str;
			}
		}
		return str;
	}

	/*
	' Funktion zum Umwandeln eines Strings in eine ganze Zahl.
	' Der übergebene String muß eine gültige Zahl OHNE Whitespaces
	' UND OHNE Vorzeichen sein!
	' Rückgabe: Der umgewandelte Wert.
	' Beispiel: num = stringValue(text.substring(pos3, pos4));
	*/
	function stringValue(text) {
		var val = 0;
		var i;
		for(i = 0; i < text.length; i++) {
			val *= 10;
			switch(text.charAt(i)) {
			case "1": val += 1; break;
			case "2": val += 2; break;
			case "3": val += 3; break;
			case "4": val += 4; break;
			case "5": val += 5; break;
			case "6": val += 6; break;
			case "7": val += 7; break;
			case "8": val += 8; break;
			case "9": val += 9; break;
			}
		}
		return val;
	}

	/*
	' Funktion zum Konvertieren eines Strings in eine ganzen Zahl. Es wird zuvor
	' eine Syntaxprüfung wie in checkInteger() durchgeführt, jedoch wird hierbei
	' die entsprechende Zahl zurückgegeben.
	' Rückgabe: Die konvertierte Zahl, oder [Number.NaN] im Fehlerfalle. Ein Fehler
	'           liegt ebenfalls vor, wenn der String leer ist!
	' Beispiel: // gibt "-565" aus
	'           var x = convertInteger("   -  565 ");
	'           alert(x);
	*/
	function convertInteger(text) {
		var pos1 = consumeWs(text, 0);
		len = text.length;
		if(pos1 >= len) {
			return Number.NaN;
		}
		var pos2 = consumeSig(text, pos1);
		var sign = true;
		if(pos2 > pos1 && text.charAt(pos1) == "-")
			sign = false;
		var pos3 = consumeWs(text, pos2);
		if(pos3 >= len) {
			return Number.NaN;
		}
		var pos4 = consumeDig(text, pos3);
		var num = stringValue(text.substring(pos3, pos4));
		var pos5 = consumeWs(text, pos4);
		if(pos5 < text.length) {
			return Number.NaN;
		}
		if(!sign)
			num = -num;
		return num;
	}

	/*
	' Funktion zum Konvertieren eines Strings in eine Dezimalzahl. Es wird zuvor
	' eine Syntaxprüfung wie in checkDecimal() durchgeführt, jedoch wird hierbei
	' die entsprechende Zahl zurückgegeben.
	' Rückgabe: Die konvertierte Zahl, oder [Number.NaN] im Fehlerfalle. Ein Fehler
	'           liegt ebenfalls vor, wenn der String leer ist!
	' Beispiel: // gibt "-565.123" aus
	'           var x = convertDecimal("   -  565.123 ");
	'           alert(x);
	*/
	function convertDecimal(text) {
            /*
		var pos1 = consumeWs(text, 0);
		len = text.length;
		if(pos1 >= len) {
			return Number.NaN;
		}
  
		var pos2 = consumeSig(text, pos1);
		var sign = true;
		if(pos2 > pos1 && text.charAt(pos1) == "-")
			sign = false;
		var pos3 = consumeWs(text, pos2);
		if(pos3 >= len) {
			return Number.NaN;
		}
		var pos4 = consumeDig(text, pos3);
		var num = stringValue(text.substring(pos3, pos4));
		if(pos4 >= len) {
			if(!sign)
				num = -num;
			return num;
		}
		var pos5 = consumeDecimalDot(text, pos4);
		if(pos5 >= len) {
			return Number.NaN;
		}
		var pos6 = consumeDig(text, pos5);
		if(pos5 == pos6) {
			return Number.NaN;
		}
		var frac = stringValue(text.substring(pos5, pos6));
		frac /= Math.pow(10, pos6 - pos5);
		var pos7 = consumeWs(text, pos6);
		if(pos7 < text.length) {
			return Number.NaN;
		}
		num += frac;
		if(!sign)
			num = -num;
		return num;
            
            */
           
           var mytext = text;//.replace(/\s/g,'');      
           var decSep = ",";
           if(typeof getDecimalSeparator != "undefined") {
                decSep = getDecimalSeparator();
           }
           else if(typeof getDecimalChars != "undefined") {
                decSep = getDecimalChars().charAt(1);
           }
           
           // Fallback, wenn nur 1 Punkt vorkommt
           // damit auch das auf Deutsch geht: convertDecimal("0.45")
           if (mytext.indexOf(".") > -1 && mytext.indexOf(decSep) == -1)
           {
               decSep = ".";
           }
           // damit auch das auf Deutsch geht: convertDecimal("2.000") => 2000
           var suche = /\.[0-9]{3}$/g;
           if (suche.test(mytext))
           {
               decSep = ",";
           }
                  
           var t = mytext.split(decSep);           
           var res = t[0].replace(/[\,\.]/g,'');
           if (t.length > 2)
               return Number.NaN;
           if (t.length > 1)
               res += "." + t[1].replace(/[\,\.]/g,'');
           
           //if (console) console.log(res);           
           res = parseFloat(res);
           //if (console) console.log(res);
           
           return res;
	}

	/*
	' Funktion zum Überprüfen, ob die angegebene Zahl innerhalb des Intervalls liegt.
	' Rückgabe: [true], wenn innerhalb des Intervalls
	' Beispiel: // liefert [false]
	'           return checkRange(40, 0, 39);
	*/
	function checkRange(number, min, max) {
		if(min <= number && number <= max)
			return true;
		return false;
	}

	/*
	' Funktion zum Konvertieren eines Strings in ein Datum. Es wird zuvor
	' eine Syntaxprüfung wie in checkDate() durchgeführt, jedoch wird hierbei
	' das entsprechende Datum zurückgegeben.
	' Der Format-Parameter (fmt) wird verwendet, um das Datum entsprechend zu
	' parsen: d = Tag, M = Monat, y = Jahr ; mögliche Angaben sind z.B.
	' "dd.MM.yyyy", oder "MM/dd/yyyy". Ist kein Format angegeben, wird versucht
	' mit getDateFormat das aktuelle iPERSIS-Format zu ermitteln. Funktioniert
	' auch das nicht, wird "dd.MM.yyyy" angenommen.
	' Rückgabe: Das konvertierte Datum, oder [null] im Fehlerfalle. Ein Fehler
	'           liegt ebenfalls vor, wenn der String leer ist!
	' Beispiel:
	*/
	function convertDate(text, fmt) {

		// Leerzeichen überspringen
		var len = text.length;
		var pos = consumeWs(text, 0);
		if(pos >= len) {
			return null;
		}

		// Leerzeichen überspringen
		if(fmt == null) {
			if(typeof getDateFormat != "undefined") {
				fmt = getDateFormat();
			}
			if(fmt == null || fmt.length <= 0)
				fmt = "dd.MM.yyyy";
		}
		var fmtLen = fmt.length;
		var fmtPos = consumeWs(fmt, 0);
		if(fmtPos >= len) {
			return null;
		}

		var day = -1;
		var month = -1;
		var year = -1;

		//alert(text);
		//alert(fmt);

		// Formatstring untersuchen
		while(fmtPos < fmtLen) {
			var elem = fmt.charAt(fmtPos);

			//xalert("fmtPos="+fmtPos+"; elem="+elem);

			if(elem == 'd') {
				// Kennung für Tag
				// Anzahl der Zeichen wird ignoriert.
				while(fmt.charAt(fmtPos) == elem) {
					fmtPos ++;
				}

				// Ziffern auslesen
				var pos1 = consumeWs(text, pos);
				if(pos1 >= len) {
					return null;
				}
				var pos2 = consumeDig(text, pos1);
				if(pos1 == pos2) {
					return null;
				}

				// Wert setzen
				day = stringValue(text.substring(pos1, pos2));
				pos = pos2;
			}
			else if(elem == 'M') {
				// Kennung für Monat
				// Anzahl der Zeichen wird ignoriert.
				while(fmt.charAt(fmtPos) == elem) {
					fmtPos ++;
				}

				// Ziffern auslesen
				var pos1 = consumeWs(text, pos);
				if(pos1 >= len) {
					return null;
				}
				var pos2 = consumeDig(text, pos1);
				if(pos1 == pos2) {
					return null;
				}

				// Wert setzen
				month = stringValue(text.substring(pos1, pos2));
				pos = pos2;
			}
			else if(elem == 'y') {
				// Kennung für Jahr
				// Anzahl der Zeichen wird ignoriert.
				while(fmt.charAt(fmtPos) == elem) {
					fmtPos ++;
				}

				// Ziffern auslesen
				var pos1 = consumeWs(text, pos);
				if(pos1 >= len) {
					return null;
				}
				var pos2 = consumeDig(text, pos1);
				if(pos1 == pos2) {
					return null;
				}

				// Wert setzen
				year = stringValue(text.substring(pos1, pos2));
				pos = pos2;
			}
			else {
				// Trennzeichen
				fmtPos ++;

				// Trennzeichen in Eingabe verifizieren
				var pos1 = consumeWs(text, pos);
				if(pos1 >= len) {
					return null;
				}
				var pos2 = consumeChar(text, elem, pos1);
				if(pos1 == pos2) {
					return null;
				}
				pos = pos2;
			}

			// Leerzeichen überspringen
			fmtPos = consumeWs(fmt, fmtPos);
		}

		//xalert("day="+day+"; month="+month+"; year="+year);

		if(day == -1 || month == -1 || year == -1)
			return null;

		if(month < 1 || month > 12) {
			return null;
		}
		if(year < 1900 || year > 3000) {
			return null;
		}
		if((month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) && (day < 1 || day > 31)) {
			return null;
		}
		if((month == 4 || month == 6 || month == 9 || month == 11) && (day < 1 || day > 30)) {
			return null;
		}
		if(month == 2 && (day < 1 || day > 28)) {
			if(day < 1 || day > 29) {
				return null;
			}
			else {
				var num = year % 4;
				if(num != 0) {
					return null;
				}
				else {
					num = year % 100;
					if(num == 0) {
						num = year % 400;
						if(num != 0) {
							return null;
						}
					}
				}
			}
		}

		return new Date(year, month - 1, day);
	}

	/*
	' Funktion zum Konvertieren eines Strings in ein Datum. Es wird zuvor
	' eine Syntaxprüfung wie in checkDate() durchgeführt, jedoch wird hierbei
	' das entsprechende Datum zurückgegeben.
	' Rückgabe: Das konvertierte Datum, oder [null] im Fehlerfalle. Ein Fehler
	'           liegt ebenfalls vor, wenn der String leer ist!
	' Beispiel:
	*/
	/*function convertDate(text) {
		var len = text.length;
		var pos1 = consumeWs(text, 0);
		if(pos1 >= len) {
			return null;
		}
		var pos2 = consumeDig(text, pos1);
		if(pos2 >= len || pos1 == pos2) {
			return null;
		}
		var day = stringValue(text.substring(pos1, pos2));
		var pos3 = consumeDateDot(text, pos2);
		var pos4 = consumeWs(text, pos3);
		if(pos4 >= len || pos2 == pos3) {
			return null;
		}
		var pos5 = consumeDig(text, pos4);
		if(pos5 >= len || pos4 == pos5) {
			return null;
		}
		var month = stringValue(text.substring(pos4, pos5));
		var pos6 = consumeDateDot(text, pos5);
		var pos7 = consumeWs(text, pos6);
		if(pos7 >= len || pos5 == pos6) {
			return null;
		}
		var pos8 = consumeDig(text, pos7);
		if(pos7 == pos8) {
			return null;
		}
		var year = stringValue(text.substring(pos7, pos8));
		var pos9 = consumeWs(text, pos8);

		if(pos9 < len) {
			return null;
		}

		if(month < 1 || month > 12) {
			return null;
		}
		if(year < 1000) {
			return null;
		}
		if((month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) && (day < 1 || day > 31)) {
			return null;
		}
		if((month == 4 || month == 6 || month == 9 || month == 11) && (day < 1 || day > 30)) {
			return null;
		}
		if(month == 2 && (day < 1 || day > 28)) {
			if(day < 1 || day > 29) {
				return null;
			}
			else {
				var num = year % 4;
				if(num != 0) {
					return null;
				}
				else {
					num = year % 100;
					if(num == 0) {
						num = year % 400;
						if(num != 0) {
							return null;
						}
					}
				}
			}
		}

		return new Date(year, month - 1, day);
	}*/

	/*
	' Funktion zum Überprüfen, ob der angegebene String ein gültiges Datum enthält.
	' Als weiteren Parameter kann angegeben werden, ob ein leerer String zulässig
	' ist oder nicht.
	' Der Format-Parameter (fmt) wird verwendet, um das Datum entsprechend zu
	' parsen: d = Tag, M = Monat, y = Jahr ; mögliche Angaben sind z.B.
	' "dd.MM.yyyy", oder "MM/dd/yyyy". Ist kein Format angegeben, wird versucht
	' mit getDateFormat das aktuelle iPERSIS-Format zu ermitteln. Funktioniert
	' auch das nicht, wird "dd.MM.yyyy" angenommen.
	' Rückgabe: [true], wenn gültig
	' Beispiel: // liefert [false]
	'           return checkDate("29.2.1900", false);
	*/
	function checkDate(text, empty, fmt) {
		var len = text.length;
		var pos1 = consumeWs(text, 0);
		if(pos1 >= len) {
			if(!empty) {
				return false;
			}
			return true;
		}
		return (convertDate(text, fmt) != null);
		/*var pos2 = consumeDig(text, pos1);
		if(pos2 >= len || pos1 == pos2) {
			return false;
		}
		var day = stringValue(text.substring(pos1, pos2));
		var pos3 = consumeDateDot(text, pos2);
		var pos4 = consumeWs(text, pos3);
		if(pos4 >= len || pos2 == pos3) {
			return false;
		}
		var pos5 = consumeDig(text, pos4);
		if(pos5 >= len || pos4 == pos5) {
			return false;
		}
		var month = stringValue(text.substring(pos4, pos5));
		var pos6 = consumeDateDot(text, pos5);
		var pos7 = consumeWs(text, pos6);
		if(pos7 >= len || pos5 == pos6) {
			return false;
		}
		var pos8 = consumeDig(text, pos7);
		if(pos7 == pos8) {
			return false;
		}
		var year = stringValue(text.substring(pos7, pos8));
		var pos9 = consumeWs(text, pos8);

		if(pos9 < len) {
			return false;
		}

		if(month < 1 || month > 12) {
			return false;
		}
		if(year < 1000) {
			return false;
		}
		if((month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) && (day < 1 || day > 31)) {
			return false;
		}
		if((month == 4 || month == 6 || month == 9 || month == 11) && (day < 1 || day > 30)) {
			return false;
		}
		if(month == 2 && (day < 1 || day > 28)) {
			if(day < 1 || day > 29) {
				return false;
			}
			else {
				var num = year % 4;
				if(num != 0) {
					return false;
				}
				else {
					num = year % 100;
					if(num == 0) {
						num = year % 400;
						if(num != 0) {
							return false;
						}
					}
				}
			}
		}

		return true;*/
	}


	/*
	' Funktion zum Überprüfen, ob der angegebene String ein gültiges Datum enthält.
	' Als weiteren Parameter kann angegeben werden, ob ein leerer String zulässig
	' ist oder nicht und das Format in dem das Datum eingegeben wurde.
	' Rückgabe: [true], wenn gültig
	' Beispiel:
	'           return checkDateMF(formular, datum, "dd.mm.yyyy");
	*/

	function checkDateMF(formular, date, sDateFormat, empty){
	var form = getFormObject(formular);
    var elem = document.forms[formular].elements[date];
    sDate = elem.value;
    sDateFormat = sDateFormat.toLowerCase();

    if (empty && checkEmpty(sDate)) {
            return true;
    }
    else{

         if (sDate.length != sDateFormat.length){
			setValidationErrorClass(elem, true);
            alert( /* persis-id="6532" */ "Sie haben ein falsches Datum eingegeben.\nBitte geben Sie ein korrektes Datum an.");
            elem.focus();
            return false;
         }
		 setValidationErrorClass(elem, true);

         var posPic=0;
         var lastKey = '';
         var sDay = '',sMonth = '', sYear = '';
         var cDateKind = '';
         do {

           while((cDateKind = sDateFormat.charAt(posPic)) == lastKey)
                posPic++;

           lastKey = cDateKind;
           switch(cDateKind){
            case 'd':
                sDay = sDate.charAt(posPic)+sDate.charAt(posPic+1);
                if (sDay > 31){
					setValidationErrorClass(elem, true);
                    alert( /* persis-id="6533" */ "Sie haben bei der Eingabe des Datums den Tag falsch angegeben.\nBitte geben Sie ein korrektes Datum an.");
                    elem.focus();
                    return false;
                }
                break;
            case 'm':
                sMonth = sDate.charAt(posPic)+sDate.charAt(posPic+1);
                if (sMonth > 12){
					setValidationErrorClass(elem, true);
                    alert( /* persis-id="6534" */ "Sie haben bei der Eingabe des Datums den Monat falsch angegeben.\nBitte geben Sie ein korrektes Datum an.");
                    elem.focus();
                    return false;
                }
                break;
            case 'y':
                sYear = sDate.charAt(posPic)+sDate.charAt(posPic+1)+sDate.charAt(posPic+2)+sDate.charAt(posPic+3);
                if (sYear.length != 4){
					setValidationErrorClass(elem, true);
                    alert( /* persis-id="6535" */ "Sie haben bei der Eingabe des Datums das Jahr falsch angegeben.\nBitte geben Sie ein korrektes Datum an.");
                    elem.focus();
                    return false;
                }
                break;
            default:
                if (sDate.charAt(posPic) != sDateFormat.charAt(posPic)){
					setValidationErrorClass(elem, true);
                    alert( /* persis-id="6536" */ "Sie haben bei der Eingabe des Datums ein Trennzeichen falsch angegeben.\nBitte geben Sie ein korrektes Datum an.");
                    elem.focus();
                    return false;
                }
                break;
           }
           posPic++;
           cDateKind = '';
         }
         while(posPic < sDateFormat.length);

		setValidationErrorClass(elem, false);
		return true;
     }
    }


	/*
	' Funktion zur Validierung eines Ganzzahl-Feldes.
	' Rückgabe: [true], wenn ok
	' Beispiel: // Anzahl prüfen
	'           if(!checkIntegerField("Formular", "ANZ")) {
	'				return false;
	'           }
	*/
	function checkIntegerField(formName, fieldName) {
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		if(!checkInteger(elem.value, true)) {
			elem.focus();
			document.forms[formName].elements[fieldName].style.textAlign = 'right';
			setValidationErrorClass(elem, true);
			alert( /* persis-id="6537" */ "Bitte geben Sie eine gültige ganze Zahl an!");
			return false;
		}
		setValidationErrorClass(elem, false);
		return true;
	}

	/*
	' Funktion zur Validierung eines Ganzzahl-Feldes.
	' mit der Möglichkeit auf eine positive (Parameter pos=1)
	' od. auf negative (Parameter pos=2) zu prüfen.
	' Rückgabe: [true], wenn ok
	' Beispiel: // Anzahl prüfen
	'           if(!checkIntegerFieldPos("Formular", "ANZ", 1)) {
	'				return false;
	'           }
	*/
	function checkIntegerFieldPos(formName, fieldName, pos) {
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		if(!checkInteger(elem.value, true)) {
			elem.focus();
			setValidationErrorClass(elem, true);
			document.forms[formName].elements[fieldName].style.textAlign = 'right';
			alert( /* persis-id="6537" */ "Bitte geben Sie eine gültige ganze Zahl an!");
			return false;
		}
		if( pos == 1 ){
			if( elem.value < 0 ){
				alert(/* persis-id="36466" */  "Bitte geben Sie Zahl ohne Komma an die 0 oder größer ist!");
				setValidationErrorClass(elem, true);
				document.forms[formName].elements[fieldName].style.textAlign = 'right';
				return false;
			}
		}
		if( pos == 2 ){
			if( elem.value > 0 ){
				alert(/* persis-id="36467" */  "Bitte geben Sie eine gültige, negative Ganzzahl an!");
				setValidationErrorClass(elem, true);
				document.forms[formName].elements[fieldName].style.textAlign = 'right';
				return false;
			}
		}
		setValidationErrorClass(elem, false);
		return true;
	}

	/*
	' Funktion zur Validierung eines Dezimalzahl-Feldes
	' Zusätzlich ist es möglich, durch den Parameter pos (1=nur positiv, 2=nur negativ) zu Prüfen, ob die Zahl nur positiv oder negativ sein darf (optional)
	' Rückgabe: [true], wenn ok
	' Beispiel: // Einsparung DM
	'           if(!checkDecimalFieldRange("form", "FREIN0", 0, 99999999.99)) {
	'           if(!checkDecimalField("Formular", "VV_KLASS")) {
	'           	return false;
	'           }
	*/
	function checkDecimalField(formName, fieldName, fmt, chars, pos) {
		// formName wird nur noch aus Kompatibilitätsgründen benötigt. Nach Möglichkeit checkDecimalFieldElem verwenden!
		//var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		return checkDecimalFieldElem(elem, fmt, chars, pos);
	}
		
	function checkDecimalFieldElem(elem, fmt, chars, pos)
	{
		         
//		if(typeof getDecimalChars != "undefined")
//		{
//			var twert = elem.value;
//			var thousandChar = getDecimalChars().charAt(0);
//			if(twert.indexOf(thousandChar) != '-1')
//			{ 
//				setValidationErrorClass(elem, true);
//				elem.style.textAlign = 'right';
//				alert(/* persis-id="24055" */ "Bitte geben Sie den Wert ohne Tausendertrennzeichen an.");
//				return false;
//			}
//		}
//               
		
		if(!checkDecimal(elem.value, true)) {
			elem.focus();
			setValidationErrorClass(elem, true);
			elem.style.textAlign = 'right';
			alert( /* persis-id="6538" */ "Bitte geben Sie eine gültige Dezimalzahl an!");
			return false;
		}

		if(typeof pos != "undefined")
		{
			if( pos == 1 ){
				if( parseFloat(elem.value) < 0.00 ){
					alert(/* persis-id="40004" */ "Bitte geben Sie eine Zahl an, die 0 oder größer ist!");
					setValidationErrorClass(elem, true);
					elem.style.textAlign = 'right';
					return false;
				}
			}
			if( pos == 2 ){
				if( parseFloat(elem.value) > 0.00 ){
					alert(/* persis-id="40005" */ "Bitte geben Sie eine gültige, negative Zahl an!");
					setValidationErrorClass(elem, true);
					elem.style.textAlign = 'right';
					return false;
				}
			}
		}
		
		if(elem.type == "text") {
			var num = convertDecimal(elem.value);
			var str = decimalToStr(num, fmt, chars);
			elem.value = str;
		}
		
		setValidationErrorClass(elem, false);
		return true;

	}

	/*
	'Funktion zur Überprüfung von Datumsfeldern.
	'Falsche Formate werden angepasst.
	'z.B. 020202 --> 02.02.2002
	'z.B. 020203 --> 02/02/2003 (engl.)
	*/	
	
	/* Funktion benötigt format_settings_js */
	function checkDateFormat(formName, fieldName)
	 {
		
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		var trennzeichen = ".";
			if(typeof getDateFormat != "undefined") {
			   trennzeichen = getDateFormat().substring(2,3); // format_settings_js 
			}                
		var heute = new Date();
		var jetzt_year = heute.getFullYear();
		var datum = elem.value;
		var day = datum.split(trennzeichen)[0];
		var month = datum.split(trennzeichen)[1];
		
		setValidationErrorClass(elem, false);	

		var re = /[a-z\s]/gi;
                                                                                              
		if(!datum.search(re))
			{                                                                                            
				return false;
			}
		
		if (datum.length == 8)
		{
			if (datum.indexOf(trennzeichen) == -1)
			{
				// Für 02022002 --> 02.02.2002
				var day = datum.substring(0,2);
				var month = datum.substring(2,4);
				var year = datum.substring(4,8);
				elem.value = day + trennzeichen + month + trennzeichen + year;
			}
			else 
			{
				//fürs Format: 1.1.2002
				if (datum.split(trennzeichen)[2].length == 4) {
					elem.value = parseInt("0") + datum.split(trennzeichen)[0] +trennzeichen + parseInt("0") + datum.split(trennzeichen)[1] +trennzeichen + datum.split(trennzeichen)[2];
				} else {
					// Für 01.01.02
					var year = datum.split(trennzeichen)[2];
					if (year < 30) {
						var millenium_year = parseInt("20") + year;
					} else {
						var millenium_year = parseInt("19") + year;
					}
					elem.value = day + trennzeichen + month + trennzeichen + millenium_year;
				}
			}
		}
			
		if (datum.length == 4)
		{
			//Für z.B. 0202 --> 02.02.2012 UND 9.03 --> 09.03. / 09.3 --> 09.03.
			if (datum.indexOf(trennzeichen) == -1)
			{		
				var day = datum.substring(0,2);
				var month = datum.substring(2,4);
				elem.value = day + trennzeichen + month + trennzeichen + jetzt_year;
			}
			else {
				if (datum.split(trennzeichen)[0].length == 1)
				{
					elem.value = parseInt("0") + datum + trennzeichen + jetzt_year;					
				}
				else {
					elem.value = datum.split(trennzeichen)[0] + trennzeichen + parseInt("0") +  datum.split(trennzeichen)[1] + trennzeichen + jetzt_year;
				}
			}
		}

		if (datum.length == 5)
		{
			//Für z.B. 01.01 Und 1.1.1
			if (datum.split(trennzeichen)[0].length == 2)
			{
				elem.value = day + trennzeichen + month + trennzeichen + jetzt_year;
			}
			
			if (datum.split(trennzeichen)[0].length == 1)
			{
				elem.value = parseInt("0") + day + trennzeichen + parseInt("0") + month + trennzeichen + parseInt("200") + datum.split(trennzeichen)[2];
			}
		}
	
		//Handelt es sich entweder um: 03.03. ODER um: 030303 als Eingabe? (ist ein Trennzeichen vorhanden?)		
		if (datum.length == 6)
		{
			
			if (datum.indexOf(trennzeichen) == -1)
			{
				//aus 01 mache 2001; aus 98 mache 1998
				var day = datum.substring(0,2);
				var month = datum.substring(2,4);
				var year = datum.substring(4,6);
				if (year < 30)
				{
				var millenium_year = parseInt("20") + year;
				}else{
			
				var millenium_year = parseInt("19") + year;
				}
				elem.value = day + trennzeichen + month + trennzeichen + millenium_year;
			}
			else {
				//Für die Fälle: 03.03. und 1.1.02
				if (datum.split(trennzeichen)[0].length == 2)
				{
					elem.value = datum + jetzt_year;
				}
				else
				{
					var year = datum.split(trennzeichen)[2];
					if (year < 30)
					{
					var millenium_year = parseInt("20") + year;
					}else{
			
					var millenium_year = parseInt("19") + year;
					}
					elem.value = parseInt("0") + day + trennzeichen + parseInt("0") + month + trennzeichen + millenium_year;
				
				}
			}
			
		}
		//Für die Fälle: 1.01.2002 und 01.1.2002

		if (datum.length == 9 && datum.split(trennzeichen)[0].length == 1)
		{
			elem.value = parseInt("0") + elem.value;
		}
		
		if (datum.length == 9 && datum.split(trennzeichen).length > 1 && datum.split(trennzeichen)[1].length == 1)
		{
			elem.value = elem.value.split(trennzeichen)[0] + trennzeichen + parseInt("0") + elem.value.split(trennzeichen)[1] + trennzeichen + elem.value.split(trennzeichen)[2];
		}
	}

	
	/*
	' Funktion zur Validierung eines Datums-Feldes.
	' Rückgabe: [true], wenn ok
	' Beispiel: // Geburtsdatum
	'           if(!checkDateField("Formular", "GEBTAG")) {
	'           	return false;
	'           }
	*/
	function checkDateField(formName, fieldName, format) {
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		var savedDate = document.forms[formName].elements[fieldName].value;
		checkDateFormat(formName, fieldName);
		if(!checkDate(elem.value, true, format)) {
			elem.focus();
			setValidationErrorClass(elem, true);
			alert( /* persis-id="6539" */ "Bitte geben Sie ein gültiges Datum an!");
			elem.value = savedDate;
			return false;
		}
		setValidationErrorClass(elem, false);
		return true;
		
	}

	/*
	' Funktion zur Validierung eines Zeits-Feldes.
	' Rückgabe: [true], wenn ok
	' Beispiel: // Vorstellungszeit
	'           if(!checkTimeField("Formular", "VORST")) {
	'           	return false;
	'           }
	*/
	function checkTimeField(formName, fieldName) {
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		if(elem.value.length == '1') {
			elem.value = '0' + elem.value + ':00';
		}
				
		if(elem.value.length == '2') {
			elem.value = elem.value + ':00';
		}
		
		if(elem.value.length == '3') {
			elem.value = '0' + elem.value;
		}
		
		if(elem.value.match(/^\d{3}|\d{4}$/)) {
			elem.value = elem.value.replace(/(\d\d)$/,':$1')
		}
		
		if(!checkTime(elem.value, true)) {
			elem.focus();
			setValidationErrorClass(elem, true);
			alert( /* persis-id="6540" */ "Bitte geben Sie eine gültige Zeit im Format hh:mm an!");
			return false;
		}
		setValidationErrorClass(elem, false);
		return true;
	}

	/*
	' Funktion zur Überprüfung auf größeres VON-Datum
	
	' Rückgabe: [true], wenn ok
	' Beispiel: // Anzahl prüfen
	'           if(!checkDateRange("Formular", "DATUM_VON", "DATUM_BIS")) {
	'           	return false;
	'           }
	*/
	function checkDateRange(formName, von, bis) {
		var form = getFormObject(formName);
		var von_date = getElementObject(form, von);
		var bis_date = getElementObject(form, bis);
				
		if(bis_date.value != '' && (convertDate(von_date.value) > convertDate(bis_date.value))) {
			setValidationErrorClass(von_date, true);
			setValidationErrorClass(bis_date, true);
			alert(/* persis-id="28255" */ "Das Beginn Datum " + von_date.value + " darf nicht größer als das Ende Datum " + bis_date.value + " sein!");
			return false;
		}
		setValidationErrorClass(von_date, false);
		setValidationErrorClass(bis_date, false);
		return true;
	}

	/*
	' Funktion zur Überprüfung, dass ein Datum innerhalb eines Zeitraumes liegt.
	' Die Vergleichswerte müssen JavaScript Date-Variablen sein (convertDate()).
	' Zudem wird intern über checkDateField() das gültige Datumsformat sichergestellt.
	' Es müssen nicht minDate UND maxDate angegeben werden.
	' Benötigt "date.js"
	' Rückgabe: [true], wenn ok
	' Beispiel: // Anzahl prüfen
	'           if(!checkDateRangeValue("form", "DATUM", new Date())) {
	'           	return false;
	'           }
	*/
	function checkDateRangeValue(formName, elemName, minDate, maxDate, format) {
		if(!checkDateField(formName, elemName, format)) {
			return false;
		}
		var form = getFormObject(formName);
		var elem = getElementObject(form, elemName);
		if(!checkEmpty(elem.value)) {
			var dateValue = convertDate(elem.value, format);
			//alert(dateValue);
			//alert(minDate);
			if(typeof minDate != "undefined" && minDate != null) {
				if(compareDates(dateValue, minDate) < 0) {
					setValidationErrorClass(elem, true);
					alert(/* persis-id="38069" */ "Das Datum darf nicht vor dem " + dateToStr(minDate) + " liegen!");
					return false;
				}
			}
			//alert(maxDate);
			if(typeof maxDate != "undefined" && maxDate != null) {
				if(compareDates(dateValue, maxDate) > 0) {
					setValidationErrorClass(elem, true);
					alert(/* persis-id="38070" */ "Das Datum darf nicht nach dem " + dateToStr(maxDate) + " liegen!");
					return false;
				}
			}
			setValidationErrorClass(elem, false);
		}
		return true;
	}
	
	/*
	' Funktion zur Überprüfung auf eine größere Von-Zeit
	
	' Rückgabe: [true], wenn ok
	' Beispiel: // Anzahl prüfen
	'           if(!checkTimeRange("Formular", "ZEIT_VON", "ZEI_BIS")) {
	'           	return false;
	'           }
	' Benötigt date.js
	*/
	function checkTimeRange(formName, von, bis) {
		var form = getFormObject(formName);
		var von_time = getElementObject(form, von);
		var bis_time = getElementObject(form, bis);
			
		if(!checkTimeField(formName, von))
		{
			return false;
		}
		if(!checkTimeField(formName, bis))
		{
			return false;
		}
		
		if(von_time.value != '' && bis_time.value != '')
		{
			if(timeToInt(von_time.value) > timeToInt(bis_time.value))
			{
				setValidationErrorClass(von_time, true);
				setValidationErrorClass(bis_time, true);
				alert(/* persis-id="34082" */ "Uhrzeit von darf nicht größer als Uhrzeit bis sein!");
				return false;
			}
		}
		setValidationErrorClass(von_time, false);
		setValidationErrorClass(bis_time, false);
		return true;
	}
	
	/*
	' Funktion zur Validierung eines Ganzzahl-Feldes mit gleichzeitiger Überprüfung auf
	' gültigen Intervall.
	' Rückgabe: [true], wenn ok
	' Beispiel: // Anzahl prüfen
	'           if(!checkIntegerFieldRange("Formular", "ANZ", 0, 10)) {
	'           	return false;
	'           }
	*/
	function checkIntegerFieldRange(formName, fieldName, min, max) {
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		if(checkEmpty(elem.value)) {
			return true;
		}
		var num = convertInteger(elem.value);
		if(isNaN(num)) {
			elem.focus();
			setValidationErrorClass(elem, true);
			document.forms[formName].elements[fieldName].style.textAlign = 'right';
			alert( /* persis-id="6537" */ "Bitte geben Sie eine gültige ganze Zahl an!");
			return false;
		}
		if(!checkRange(num, min, max)) {
			elem.focus();
			setValidationErrorClass(elem, true);
			document.forms[formName].elements[fieldName].style.textAlign = 'right';
			alert( /* persis-id="6541" */ "Die Eingabe muß zwischen " + min + " und " + max + " liegen!");
			return false;
		}
		setValidationErrorClass(elem, false);
		return true;
	}

	/*
	' Funktion zur Validierung eines Dezimalzahl-Feldes mit gleichzeitiger Überprüfung auf
	' gültigen Intervall.
	' Rückgabe: [true], wenn ok
	' Beispiel: // Einsparung DM
	'           if(!checkDecimalFieldRange("Formular", "VV_KLASS", 0, 9.99)) {
	'           	return false;
	'           }
	*/
	function checkDecimalFieldRange(formName, fieldName, min, max, fmt, chars) {
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		if(checkEmpty(elem.value)) {
			return true;
		}

		if(typeof getDecimalChars != "undefined")
		{
			var twert = elem.value;
			var thousandChar = getDecimalChars().charAt(0);
			if(twert.indexOf(thousandChar) != '-1')
			{ 
				setValidationErrorClass(elem, true);
				document.forms[formName].elements[fieldName].style.textAlign = 'right';
				alert(/* persis-id="24055" */ "Bitte geben Sie den Wert ohne Tausendertrennzeichen an.");
				return false;
			}
		}
		
		var num = convertDecimal(elem.value);
		
		if(isNaN(num)) {
			elem.focus();
			setValidationErrorClass(elem, true);
			document.forms[formName].elements[fieldName].style.textAlign = 'right';
			alert( /* persis-id="6538" */ "Bitte geben Sie eine gültige Dezimalzahl an!");
			return false;
		}
		if(!checkRange(num, min, max)) {
			elem.focus();
			setValidationErrorClass(elem, true);
			document.forms[formName].elements[fieldName].style.textAlign = 'right';
			alert( /* persis-id="6541" */ "Die Eingabe muß zwischen " + min + " und " + max + " liegen!");
			return false;
		}
		if(elem.type == "text") {
			var str = decimalToStr(num, fmt, chars);
			elem.value = str;
		}
		setValidationErrorClass(elem, false);
		return true;
	}

	/*
	' Funktion zur eines Feldes auf leer.
	' Als leer gelten auch die Trennzeichen (Blank, Newline, Tab, ...).
	' Rückgabe: [false], wenn Feld leer ist
	' Beispiel: if(!checkEmptyField("Formular", "GEBTAG")) {
	'           	return false;
	'           }
	*/
	function checkEmptyField(formName, fieldName){
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
	
		if(typeof(elem) == "undefined")
		{
        		if(console && console.error) 
        			console.error(String(/* persis-id="58023" */ 'Das zu überprüfende Feld "' + fieldName + '" ist nicht vorhanden / nicht sichtbar / nicht zugreifbar !'));				
        		return true; // defensiv: Validierung fortsetzen lassen
		}
	
		return checkEmptyFieldElem(form, elem);
	}
	
	/**
	*	Prüfung eines Form-Elements auf leer.
	* 	@param {Object} form: Form-Element
	* 	@param {Object} elem: Feld-Element
	* 	@param {Boolean} msg: Gibt an ob Nachrichten ausgegeben werden sollen
	* 	@param {Boolean} markfield: Gibt an ob die Felder markiert werden sollen
	*/
	function checkEmptyFieldElem(form, elem, msg, markfield)
	{
		msg = typeof(msg) != 'undefined' ? msg : true;
		markfield = typeof(markfield) != 'undefined' ? markfield : true;
		
		if(typeof(elem) == "undefined")
		{
			if(msg && console) 
				console.log(String(/* persis-id="58023" */ 'Das zu überprüfende Feld ist nicht vorhanden / nicht sichtbar / nicht zugreifbar !'));				
			return true; // defensiv: Validierung fortsetzen lassen
		}
		var formName = form.attributes["name"].value; //form.getAttribute("name");
		var fieldName = elem.name;
		var fieldNameTrans = elem.name + '_TRANS';
		
		/*
		' Dieser kurze Codeblock stellt fest, welcher Browser gerade läuft.
		' Dementsprechend werden die Variablen "ie" bzw. "netscape" auf "true"
		' oder "false" gesetzt.
		*/
		var ie = false;
		var netscape = false;
		strAppName = window.navigator.appName;
		if(strAppName.indexOf("Netscape") >= 0)
			netscape = true;
		if(strAppName.indexOf("Explorer") >= 0)
			ie = true;
		
		if(checkEmpty(elem.value))
		{
			if(ie == true)
			{
				if(elem.getAttribute('type') != 'hidden' && elem.style.display != 'none' && elem.disabled == false)
				{
					elem.focus();
				}
			}
			else
			{
				elem.focus();
			}

			if(markfield) {
				setValidationErrorClass(elem, true);
				/*if(fieldExists(formName, fieldNameTrans)) {
					if (document.forms[formName].elements[fieldNameTrans].className != '')
					setValidationErrorClass(elem, true);
				}*/
			}
			
			if(fieldExists(formName, fieldName + "_FIELD")) {
				document.forms[formName].elements[fieldName + "_FIELD"].id = fieldName + "_FIELD_DISABLE";
			}
			if(fieldExists(formName, fieldName + "_NAME")) {
				document.forms[formName].elements[fieldName + "_NAME"].id = fieldName + "_NAME_DISABLE";
			}
			if (msg) { alert( /* persis-id="6542" */ "Bitte geben Sie einen Text bzw. einen gültigen Wert ein!"); }
			return false;
		
		}
		
		setValidationErrorClass(elem, false);
		
		if(fieldExists(formName, fieldName + "_FIELD_DISABLE")) {
			document.forms[formName].elements[fieldName + "_FIELD_DISABLE"].id = fieldName + "_FIELD";
			document.forms[formName].elements[fieldName + "_FIELD"].className = 'f1';
		}
		if(fieldExists(formName, fieldName + "_NAME_DISABLE")) {
			document.forms[formName].elements[fieldName + "_NAME_DISABLE"].id = fieldName + "_NAME";
			document.forms[formName].elements[fieldName + "_NAME"].className = 'f1';
		}
		
		return true;
	}

	/**
	 * Dekoriert ein INPUT-Feld mit der CSS-Klasse "mussfeld",
	 * wenn setClass [true] ist.
	 * Wenn setClass [false] ist, wird versucht die vorige
	 * CSS-Klasse wieder herzustellen (Attribut "class_sik").
	 * @param {Object} elem
	 * @param {Boolean} errorFlag
	 */
	function setValidationErrorClass(elem, setClass) {
		if(typeof elem.form != 'undefined')
		{
			var form = getFormObject(elem.form.name);
			var fieldNameTrans = elem.name + '_TRANS';
			var elemTrans = getElementObject(form, fieldNameTrans);
			
			if(setClass) {
				if(elem.className != '') {
					elem.setAttribute('class_sik', elem.className, 0);
				}
				elem.className = 'mussfeld';

				if(typeof elemTrans != 'undefined' && elemTrans.className != '')	{
					elemTrans.setAttribute('class_sik_trans', elemTrans.className, 0);
					setValidationErrorClass(elemTrans, true);
				}
				
			}
			else {
				var class_sik = elem.getAttribute('class_sik', 0);
				if (class_sik != '' && class_sik != null) {
					elem.className = class_sik;
					elem.removeAttribute('class_sik', 0);
				}
				else {
					removeClassName(elem, "mussfeld");
				}
				
				if(typeof elemTrans != 'undefined' && elemTrans.className != '')
				{
					var class_sik_trans = elemTrans.getAttribute('class_sik', 0);
					if (class_sik_trans != '' && class_sik_trans != null) 
					{
						elemTrans.className = class_sik_trans;
						elemTrans.removeAttribute('class_sik_trans', 0);
					}
					else 
					{
						removeClassName(elemTrans, "mussfeld");
					}
				}
			}
		}
	}
	
	function checkEmptyHiddenField(formName, fieldName, visibleFieldName) {
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		var visibleElem = getElementObject(form, visibleFieldName);
		var att_class = 'mussfeld';
		
		if(checkEmpty(elem.value)) {
			visibleElem.className = att_class;

			dhtmlScrollToElem(visibleElem);
			setValidationErrorClass(elem, true);
			alert( /* persis-id="6542" */ "Bitte geben Sie einen Text bzw. einen gültigen Wert ein!");
			return false;
		}
		var class_sik = visibleElem.getAttribute('class_sik', 0);
		if (class_sik != '' && class_sik != null) {
			setValidationErrorClass(elem, true);
		}
		else {
			setValidationErrorClass(elem, false);
		}
		return true;
	}	
	/*
	' Funktion zur eines Feldes auf leer. Gegenüber der ursprünglichen Funktion kommt hier keine Meldung
	' Als leer gelten auch die Trennzeichen (Blank, Newline, Tab, ...).
	' Rückgabe: [false], wenn Feld leer ist
	' Beispiel: if(!checkEmptyFieldomsg("Formular", "GEBTAG")) {
	'           	return false;
	'           }
	*/
	function checkEmptyFieldomsg(formName, fieldName) {
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		
		return checkEmptyFieldElem(form, elem, false);
	}

	/*
	' s. checkEmptyFieldomsg (20080716 [AB] RJ)
	' Beispiel: if(!checkEmptyFieldNoMsg("Formular", "GEBTAG")) { return false; }
	*/
	
	function checkEmptyFieldNoMsgElem(form, elem) {
	
		return checkEmptyFieldElem(form, elem, false);
	
	}
	
	function checkEmptyFieldNoMsg(formName, fieldName) {
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		if(checkEmpty(elem.value)) { return false; }
		return true;
	}

	/*
	' Diese Funktion wandelt die angegebene Kommazahl in das gebräuchliche Format
	' um: "9999,99"
	' [23.05.2007] lo: fmt kann nun auch Tausender-Trenner enthalten ","
	' Rückgabe: die Kommazahl als String
	' Beispiel:
	*/
	function decimalToStr(nDecimal, fmt, chars) {

		if(checkEmpty(nDecimal) || isNaN(nDecimal)) {
			return "";
		}

		if(fmt == null) {
			if(typeof getDecimalFormat != "undefined") {
				fmt = getDecimalFormat();
			}
			if(fmt == null || fmt.length <= 0)
				fmt = "0.00";
		}
		if(chars == null) {
			if(typeof getDecimalChars != "undefined") {
				chars = getDecimalChars();
			}
			if(chars == null || chars.length <= 0)
				chars = ".,";
		}

		var dot = fmt.indexOf(".");
		var nks = 0;
		if(dot >= 0) {
			nks = fmt.length - (dot + 1);
		}
		var nkf = Math.pow(10, nks);
		var tsd = (fmt.indexOf(",") > 0);

		var nGanzzahl;
		var nNachkomma;
		var bNeg;
		if(nDecimal < 0) {
			nGanzzahl = Math.abs(Math.ceil(nDecimal));
			//nNachkomma = Math.abs(Math.ceil(((nDecimal + nGanzzahl) * 100) - 0.5));
			nNachkomma = Math.abs(Math.ceil(((nDecimal + nGanzzahl) * nkf) - 0.5));
			if(nNachkomma >= nkf)
				nGanzzahl++;
			bNeg = true;
		}
		else {
			nGanzzahl = Math.abs(Math.floor(nDecimal));
			//nNachkomma = Math.abs(Math.floor(((nDecimal - nGanzzahl) * 100) + 0.5));
			nNachkomma = Math.abs(Math.floor(((nDecimal - nGanzzahl) * nkf) + 0.5));
			if(nNachkomma >= nkf)
				nGanzzahl++;
			bNeg = false;
		}

		var str = "";
		if(bNeg)
			str += "-";
		//str += nGanzzahl.toString() + ",";
		if(!tsd) {
			str += nGanzzahl.toString();
		}
		else {
			var rest = nGanzzahl;
			var block = 0;
			var vks = "";
			while(rest > 0) {
				block = rest % 1000;
				rest = Math.floor(rest / 1000);
				
				if(rest > 0) {
					var tmp = "00" + block;
					vks = chars.charAt(0) + tmp.substr(tmp.length - 3) + vks;
				}
				else {
					vks = block + vks;
				}
			}
			str += vks;
		}
		/*if(nNachkomma < 10)
			str += "0";
		str += nNachkomma.toString();*/
		if(nks > 0) {
			var i;
			var tmp = "";
			for(i = 0; i < nks; i++)
				tmp += "0";
			tmp += nNachkomma.toString();
			str += chars.charAt(1) + tmp.substr(tmp.length - nks, nks);
		}

		return str;
	}

	/*
	' Diese Funktion prüft, ob es sich beim übergebenen String um einen String
	' handelt, der mit der PERSIS Verschlüsselungsroutine verschlüsselt werden
	' kann.
	' Rückgabe: [true], wenn ja, oder String leer ist, ansonsten [false]
	' Beispiel:
	*/
	function checkEncValue(enc) {
		var len = enc.length;
		for(i = 0; i < len; i++) {
			var ch = enc.charAt(i);
			var code = enc.charCodeAt(i);
			if(code < 40 || code > 126) {
				return false;
			}
		}
		return true;
	}

	/*
	' Diese Funktion prüft, ob im angegebenen Feld ein String steht, der
	' der mit der PERSIS Verschlüsselungsroutine verschlüsselt werden
	' kann.
	' Rückgabe: [true], wenn ja, oder String leer ist, ansonsten [false]
	' Beispiel:
	'			function checkForm() {
	'				if(!checkEmptyField("formular", "ENC")) {
	'					return false;
	'				}
	'				if(!checkEncField("formular", "ENC")) {
	'					return false;
	'				}
	'				return true;
	'			}
	*/
	function checkEncField(formName, fieldName) {
		var form = getFormObject(formName);
		var elem = getElementObject(form, fieldName);
		var value = elem.value;
		if(!checkEncValue(value)) {
			elem.focus();
			setValidationErrorClass(elem, true);
			alert( /* persis-id="6543" */ "Ungültiges Zeichen in der zu verschlüsselnden Eingabe!\n"
					+ "Zulässige Zeichen sind nur Buchstaben und Zahlen "
					+ "(keine Umlaute, Sonderzeichen, etc.).");
			return false;
		}
		setValidationErrorClass(elem, false);
		return true;
	}


	/*
	' Diese Funktion gibt einen gerundeten Ganzzahlwert zurück.
	' Eingabewerte sind der zu rundende Wert (Ausgangswert: Ganzzahl oder Dezimalzahl mit Punkt) und
	' die Rundungsstufe (Ganzzahl). Die Rundung erfolgt NICHT kaufmännisch! Sondern jeglicher Kommawert
	' wird aufgerundet.
	' Beispiel:
	'	round(7.2, 5);  // ergibt 10
	'	round(7.2, 1);  // ergibt 8
	*/
	function round(zahl, stufe){

		var szahl = "";
		var stufe ;
		var nzahl ;
		var nszahl = "";

		if(stufe == 0 || stufe == "") {
			nzahl = zahl;
		}else{
			if ((zahl % stufe) == 0){
				return zahl;
			} else {
				szahl = decimalToStr(zahl, "0.0000000000", ",.");
				nzahl = Math.floor(szahl);
				//plert("zahl="+zahl+"\nszahl="+szahl+"\nnzahl="+nzahl+"\nMath.floor(szahl)="+Math.floor(szahl)+"\nMath.ceil(szahl)="+Math.ceil(szahl));
				if(Math.floor(szahl) < Math.ceil(szahl)) {
					nzahl++;
				}
				while (nzahl % stufe !=0){
					nzahl++;
				}
			}
		}
		szahl = szahl;
		
		return nzahl;
	}


	/*
	' Diese Funktion gibt eine gerundete Ganzzahl zurück.
	' Die Eingabewerte werden hier allerdings direkt aus Objekten im Formular geholt
	' Parameter sind (Formular, Objekt der zu rundenden Zahl, Objekt der Rundungsstufe)
	' Beispiel:
	'	roundField("form", "BETRAG", 5);  // rundet den Feldinhalt
	*/
	function roundField(formName, fieldName, stufe) {

		var strZahl = "";
		var strStufe = "";
		var wert;
		var rund;
		var neuwert;

		var field = getElement(formName, fieldName);
		strZahl = field.value;
		wert = convertDecimal(strZahl);
		neuwert = round(wert, stufe);
		field.value = neuwert;
		return neuwert;
	} 

	/*
	Diese Funktion rundet die übergebene Zahl entweder auf, ab oder kaufmännisch auf die übergebene Rundungsstufe
	Beispiel:
		roundmath(12.50, 1, 1) / ergibt 13.00;  roundmath(12.50, 2, 1) / ergibt 14.00;  roundmath(12.50, 0.5, 1) / ergibt 12.50;  roundmath(12.50, 0.4, 1) / ergibt 12.80
		roundmath(12.50, 1, 0) / ergibt 13.00;  roundmath(12.50, 2, 0) / ergibt 14.00;  roundmath(12.50, 0.5, 0) / ergibt 12.50;  roundmath(12.50, 0.4, 0) / ergibt 12.80
		roundmath(12.50, 1, 1) / ergibt 12.00;  roundmath(12.50, 2, -1) / ergibt 12.00;  roundmath(12.50, 0.5, -1) / ergibt 12.50;  roundmath(12.50, 0.4, -1) / ergibt 12.40
		roundmath(12,50, 0, 1) / ergibt 12.50 
		
	*/
	function roundmath(roundzahl, roundstufe, roundart) {

            var dzahl;
            var dstufe = 1;
            var roundMethod = 0;
			var value;
			
            if(roundzahl == null) {
                  return null;
            }
            dzahl = roundzahl;
            if(roundstufe != null) {
                  dstufe = roundstufe;
            }
            if(roundart != null) {
                  roundMethod = roundart;
            }

			//wenn die Rundungsstufe = 0, dann soll überhaupt nicht gerundet werden und die Zahl wird unbearbeitet zurück gegeben
			if(dstufe == 0){
				return dzahl;
			}
            value = dzahl / dstufe;

            if(roundMethod > 0) {
                  // immer aufrunden
                  value = Math.ceil(value);
            }
            else if(roundMethod < 0) {
                  // immer abrunden
                  value = Math.floor(value);
            }
            else {
                  // kaufmännisch runden
                  value = Math.round(value);
            }
            value = value * dstufe;
            return value;
      }
	
	/*
	' Funktion zur Validierung der E-Mailadresse.
	' Rückgabe: [true], wenn ok
	' Beispiel: 
	'	if(checkEmailNameValidate("form", "NAME", "VNAME", "EMAIL")) {
	'		return false;
	'	}
	*/
	function checkEmailNameValidate(formName, fieldName, fieldVName, fieldEmail) {
		var form = getFormObject(formName);
		var elemName = getElementObject(form, fieldName);
		var elemVName = getElementObject(form, fieldVName);
		
		var elemNameValue = elemName.value;
		var elemVNameValue = elemVName.value;
		
		if(!checkEmailValidate(formName, fieldEmail)) {
			return false;
		}
		return true;
	}
	
	
	/*
	' Funktion zur Validierung der E-Mailadresse.
	' Rückgabe: [true], wenn ok
	' Beispiel: 
	'	if(checkEmailValidate("form", "EMAIL")) {
	'		return false;
	'	}
	*/
	function checkEmailValidate(formName, fieldEmail) {
		var form = getFormObject(formName);
		var elemEmail = getElementObject(form, fieldEmail);
		
		var elemEmailValue = elemEmail.value;
		
		var count_at = 0;
		var point_at = -1;
		for(var a=0; a < elemEmailValue.length; a++)
		{
			if(elemEmailValue.charAt(a) == "@")
			{
				count_at = count_at + 1;
			}
			if(elemEmailValue.charAt(a) == ".")
			{
				point_at = a;
			}
		}
		
		if (elemEmailValue.length != '0')
		{
			if(elemEmailValue.indexOf(" ") != '-1')
			{ 
				setValidationErrorClass(elemEmail, true);
				alert(/* persis-id="36994" */ "Innerhalb der E-Mailadresse darf kein Leerzeichen vorhanden sein, es können sonst keine E-Mails an diese Person versendet werden.");
				return false;
			}
			if(count_at > 1)
			{
				setValidationErrorClass(elemEmail, true);
				alert(/* persis-id="36995" */ "Die E-Mailadresse darf nur ein @-Zeichen beinhalten, es können sonst keine E-Mails an diese Person versendet werden.");
				return false;
			}
			else if(count_at == 0)
			{
				setValidationErrorClass(elemEmail, true);
				alert(/* persis-id="36996" */ "Die E-Mailadresse muss ein @-Zeichen beinhalten, es können sonst keine E-Mails an diese Person versendet werden.");
				return false;
			}
			if(point_at < elemEmailValue.indexOf("@"))
			{ 
				setValidationErrorClass(elemEmail, true);
				alert(/* persis-id="36997" */ "Innerhalb der E-Mailadresse muss nach dem @-Zeichen mindestens ein Punkt folgen, es können sonst keine E-Mails an diese Person versendet werden.");
				return false;
			}
		}
		setValidationErrorClass(elemEmail, false);
		return true;
	}

	/* Funktion zur Prüfung des Formats einer URL, da in Persis der Aufur der URL ohne Protokoll zu einem Fehler führt.  
	 * Rückgabe [true], wenn die URL in das Muster des regulären Ausdrucks passt oder die URL nicht eingetragen wurde.
	 */
	function checkURLValidate(formName, fieldName) 
	{
		if (fieldExists(formName, fieldName))
		{
			var form = getFormObject(formName);
			var elemName = getElementObject(form, fieldName);
			
			var elemNameValue = elemName.value;
			
			// Leer ist zulässig und muss nicht geprüft werden
			if(elemNameValue == '')
			{
				setValidationErrorClass(elemName, false);
				return true;
			}
			
			var ausdruck = /^http(s)?\:\/\/[A-Za-z0-9_ ]+(\.[A-Za-z0-9_ ]+)+(\?.*)?/i;
	
			if (ausdruck.test(elemNameValue) == false)
			{
				if(elem.style.display == 'none' || elem.style.display == 'visible')
				{
					setValidationErrorClass(elemName, true);
					elemName.focus();
				}
				setValidationErrorClass(elemName, true);
				alert(/* persis-id="38261" */ 'Bitte geben Sie eine vollständige, gültige URL ein. (Beispiel: http://www.persis.de)');
				return false;				
			}
	
			if(elem.style.display == 'none' || elem.style.display == 'visible')
			{
				setValidationErrorClass(elemName, false);
			}
			return true;
		}
		return true;
	}