function EscapePattern(strPattern) {
    /*---------------------------------------------------------------------------
	Interne Funktion
    Argumente:
	strPattern - Zu escapender String
	
	Funktion:
	Escaped Patternsonderzeichen aus einem String
	--------------------------------------------------------------------------- */
    var arrKeyChars = new Array("/", "!", ":", "=", "^", "$", ".", "[", "]", "|", "(", ")", "?", "*", "+", "{", "}");
    for(i=0; i<arrKeyChars.length; i++) {
        var pattern = arrKeyChars[i];
        var strPattern = strPattern.replace(pattern,  "\\" + arrKeyChars[i]);
    }
    return strPattern;
}

129
function IsValidT(frm, strText, strType, iMaxChars, strName, strLangKey) {
    /*---------------------------------------------------------------------------
	Argumente:
	frm - Objektverweis auf die Form, deren Felder überprüft werden
	strText - Name des Textfeldes, das überprüft wird (HTML-Attribut "name")
	strPattern - Gültige Zeichenklassen und Zeichen für das übergebene Feld
    iMaxChars - Maximale Zeichenanzahl für das übergebene Feld
    strName - (opt.) Bezeichnung des Feldes
    strLangKey - (opt.) Sprachschlüssel, "de" oder "en", default ist "de"

	Funktion:
	Prüft das Feld auf gültige Eingaben/Zeichen
	--------------------------------------------------------------------------- */
    
    txt = frm.elements[strText];
    
    // set strLanguageKey
    var strLanguageKey = "de"
    if(typeof strLangKey != "undefined") {
        if (strLangKey == "en") strLanguageKey = "en";
    }
    
    // leere Felder
    if(txt.value.length == 0)
        return true;
	
    // Max. Länge überprüfen
    if(txt.value.length > iMaxChars) {
        if (strLanguageKey == "de") strAlert = "Ihre Eingabe in diesem Feld besteht aus zu vielen Zeichen.\nBitte geben Sie maximal " + iMaxChars + " Zeichen ein.";
        if (strLanguageKey == "en") strAlert = "This field input consists of to many chars.\nPlease input a maximum of " + iMaxChars + " chars.";
        
        alert(strAlert);
        txt.focus();
        return false;
    }
    
    // RegExp
    strCharClass = strType.substr(0, 5);
    strSpecChars = strType.substr(5);
    var blnDefault = false;
    var pattern;
    
    switch(strCharClass) {
        case "alpha":
              eval("pattern = /^[a-zA-ZÀ-ÖØ-öø-ÿ" + EscapePattern(strSpecChars) + "]*$/i");
              if (strLanguageKey == "de") desc = "Buchstaben";
              if (strLanguageKey == "en") desc = "letters";
              break;
        case "digit":
              eval("pattern = /^[0-9" + EscapePattern(strSpecChars) + "]*$/i");
              if (strLanguageKey == "de") desc = "Ziffern";
              if (strLanguageKey == "en") desc = "digits";
              break;
        case "alnum":
              eval("pattern = /^[a-zA-ZÀ-ÖØ-öø-ÿ 0-9" + EscapePattern(strSpecChars) + "]*$/i");
              if (strLanguageKey == "de") desc = "Buchstaben und Ziffern";
              if (strLanguageKey == "en") desc = "letters and digits";
              break;
        case "texta":
              eval("pattern = /^[a-zA-ZÀ-ÖØ-öø-ÿ 0-9'\\?\\!\\.@\\:,\\(\\)\\/\\s" + EscapePattern(strSpecChars) + "_-]*$/i");
              if (strLanguageKey == "de") desc = "Buchstaben, Ziffern, Leerzeichen, ''', '?', '!', '.', '@', ':', ',', '(', ')', '/', '_', '-'";
              if (strLanguageKey == "en") desc = "letters, digits, spaces, ''', '?', '!', '.', '@', ':', ',', '(', ')', '/', '_', '-'";
              break;
        case "md5id":
              pattern = /^[0-9a-fA-F]{32}$/i;
              if (strLanguageKey == "de") desc = "Ziffern und die Buchstaben a-f";
              if (strLanguageKey == "en") desc = "digits and letters a-f";
              break;
        case "email":
              pattern = /^[a-zA-Z0-9\._-]+@[a-zA-Z0-9\._-]+\.[a-zA-Z]{2,4}$/i;
              if (strLanguageKey == "de") desc = "die Elemente einer Email-Adresse";
              if (strLanguageKey == "en") desc = "all elements of a valid email adress";
              break;
        case "regio":
              pattern = /^(AU|NZ|CA|US|SA|EU|SP|SAT){1}$/i;
              break;
        default:
              eval("pattern = /^[" + EscapePattern(strCharClass) + EscapePattern(strSpecChars) + "]*$/i");
              desc = strCharClass;
              blnDefault = true;
              break;
    }
    
    if(!pattern.test(txt.value)) {
        if(typeof strName == "undefined")
	        strName = "";
        else
            strName = "'" + strName + "' ";
        
        // Auflisten der Sonderzeichen
        if((strSpecChars.length > 0) || (blnDefault)) {
            if(blnDefault) {
                strSpecChars = strCharClass + strSpecChars;
            } else {
                if (strLanguageKey == "de") desc += " sowie ";
                if (strLanguageKey == "en") desc += " as well as ";
            }
                
            
            for(k = 0; k < strSpecChars.length; k++) {
                if(strSpecChars.substr(k, 1) == " ") {
                    if (strLanguageKey == "de") desc += 'Leerzeichen, ';
                    if (strLanguageKey == "en") desc += 'spaces, ';
                } else {
                    desc += "'" + strSpecChars.substr(k, 1) + "', ";
                }
            }
            
            desc = desc.substr(0, (desc.length-2));
        }
                
        if (strLanguageKey == "de") {
            msg  = "Das Feld " + strName + "enthält ungültige Zeichen.\n";
            msg += "Gültige Zeichen sind " + desc + ".\n";
            msg += "Bitte überprüfen Sie Ihre Eingabe!";
        }
        
        if (strLanguageKey == "en") {
            msg  = "The field " + strName + "contains invalid chars.\n";
            msg += "Valid chars are " + desc + ".\n";
            msg += "Please check your input!";
        }
            
        alert(msg);
        txt.focus();
        return false;
    } else {
        return true;
    }
}

function IsFilled(frm, strText, strError) {

	/*---------------------------------------------------------------------------
	Argumente:
	frm - Objektverweis auf die Form, deren Felder überprüft werden
	strText - Name des Textfeldes, das überprüft wird (HTML-Attribut "name")
	strError - (opt.) Fehlermeldung, die ausgegeben werden soll. Wird das
		Argument nicht angegeben, erscheint ein Defaulttext.

	Funktion:
	Prüft, ob in dem bezeichneten Textfeld ein Wert eingegeben ist. Falls nicht,
	wird eine Warnung angezeigt (der durch strError festgelegte Text),
	und die Funktion gibt False zurück.
	--------------------------------------------------------------------------- */

	txt = frm.elements[strText];
	if (txt.value == "") {
		if (typeof strError == "undefined")
			strError = "Bitte geben Sie einen Wert in das Feld ein.";
		alert(strError);
		txt.focus();
		return false;
	}

	return true;
}

function IsNumber(frm, strText, strError) {

	/*---------------------------------------------------------------------------
	Argumente:
	frm - Objektverweis auf die Form, deren Felder überprüft werden
	strText - Name des Textfeldes, das überprüft wird (HTML-Attribut "name")
	strError - (opt.) Fehlermeldung, die ausgegeben werden soll. Wird das
		Argument nicht angegeben, erscheint ein Defaulttext.

	Funktion:
	Prüft, ob in dem bezeichneten Textfeld ein Wert eingegeben ist, und ob dieser Wert
	eine ganze Zahl größer als 0 ist (dabei werden Blanks zwischen Zahlen entfernt).
	Falls nicht, wird eine Warnung angezeigt (der durch strError festgelegte Text),
	und die Funktion gibt False zurück.
	--------------------------------------------------------------------------- */

	if (!IsFilled(frm,strText))
	   return false;

	strNumeric = "1234567890 ";
	fld = frm.elements[strText];

	for (i=0; i < fld.value.length; i++) {
		if (strNumeric.indexOf(fld.value.charAt(i)) < 0) {
		   if (typeof strError == "undefined")
			  strError = "Bitte geben Sie in dieses Feld nur ganze Zahlen ein.";
		   fld.focus();
	   	   alert(strError);
		   return false;
		}
	}

	if (parseInt(fld.value) == 0) {
	   if (typeof strError == "undefined")
	   	  strError = "Bitte geben Sie in dieses Feld nur Zahlen > 0 ein.";
	   fld.focus();
	   alert(strError);
	   return false;
	}

	return true;
}

function IsSelected(frm, strList, intStart, strError) {

	/* ---------------------------------------------------------------------------
	Argumente:
	frm - Objektverweis auf die Form, deren Felder überprüft werden
	strList - Name der Listbox (SELECT), die überprüft wird (HTML-Attribut "name")
	intStart - Index des ersten akzeptierten Wertes in der Listbox. Falls z.B. die erste Zeile
		(Index = 0) nur eine Auswahlaufforderung enthält, hat der erste gültige Wert
		in der Listbox den Index 1
	strError - (opt.) Fehlermeldung, die ausgegeben werden soll. Wird das
		Argument nicht angegeben, erscheint ein Defaulttext.

	Funktion:
	Prüft, ob in der bezeichneten Listbox ein Wert ausgewählt ist. Falls nicht,
	wird eine Warnung angezeigt (der durch strError festgelegte Text),
	und die Funktion gibt False zurück.
	--------------------------------------------------------------------------- */

	lst = frm.elements[strList];
	if (lst.selectedIndex < intStart) {
		if (typeof strError == "undefined")
			strError = "Bitte wählen Sie einen Wert aus der Liste.";
		alert(strError);
		lst.focus();
		return false;
	}
	else
		return true;
}


function BuildDateFromText(frm, strTag, strMonat, strJahr)	{

	/*---------------------------------------------------------------------------
	Argumente:
	frm - Objektverweis auf die Form, deren Felder überprüft werden
	strTag - Name des Textfelds, in das der Tag eingegeben wird
	strMonat - Name des Textfelds, in das der Monat eingegeben wird
	strJahr - Name des Textfelds, in das das Jahr eingegeben wird

	Funktion:
	Prüft, ob die bezeichneten Textfelder einen gültigen Wert enthalten. Falls
	nicht, wird eine fehlerspezifische Warnung angezeigt (alert). Falls alle Felder
	gültige Werte enthalten, gibt die Funktion das entsprechende Datum als Date-
	Objekt zurück, sonst einen leeren Wert ("undefined").
	--------------------------------------------------------------------------- */

	/* Check for entries in all argument fields */

	fldTag = frm.elements[strTag];
	if (fldTag.value == "") {
	   fldTag.focus();
	   alert("Bitte geben Sie einen Wert für den Tag ein");
	   return;
	}
	
	fldMonat = frm.elements[strMonat];
	if (fldMonat.value == "") {
	   fldMonat.focus();
	   alert("Bitte geben Sie einen Wert für den Monat ein");
	   return;
	}

	fldJahr = frm.elements[strJahr];
	if (fldJahr.value == "") {
	   fldJahr.focus();
	   alert("Bitte geben Sie einen Wert für das Jahr ein");
	   return;
	}

	/* Check for numeric values in day, month and year fields */

	strNumeric = "1234567890";

	for (i=0; i < fldTag.value.length; i++) {
		if (strNumeric.indexOf(fldTag.value.charAt(i)) < 0) {
		   fldTag.focus();
	   	   alert("Bitte geben Sie für den Tag nur Ziffern ein");
		   return;
		}
	}

	for (i=0; i < fldMonat.value.length; i++) {
		if (strNumeric.indexOf(fldMonat.value.charAt(i)) < 0) {
		   fldMonat.focus();
	   	   alert("Bitte geben Sie für den Monat nur Ziffern ein");
		   return;
		}
	}

	for (i=0; i < fldJahr.value.length; i++) {
		if (strNumeric.indexOf(fldJahr.value.charAt(i)) < 0) {
		   fldJahr.focus();
	   	   alert("Bitte geben Sie für das Jahr nur Ziffern ein");
		   return;
		}
	}

	/* Check for proper values of day, month and year */

	strTag = fldTag.value;
	if (strTag.substr(0,1) == "0") strTag = strTag.substr(1);

	strMonat = fldMonat.value;
	if (strMonat.substr(0,1) == "0") strMonat = strMonat.substr(1);

	strJahr = fldJahr.value;
	if (strJahr.substr(0,1) == "0") strJahr = strJahr.substr(1);

	intTag = parseInt(strTag);
	intMonat = parseInt(strMonat);
	intJahr = parseInt(strJahr);

	if (intMonat > 12 || intMonat == 0) {
	   fldMonat.focus();
	   alert("Ungültiger Monat. Gültige Eingaben: 1-12");
	   return;
	}

	anzTage = 31;
	if  (intMonat==4 || intMonat==6 || intMonat==9 || intMonat==11)
		anzTage = 30;
	if  (intMonat==2) {
		if (intJahr % 4 == 0)
		   anzTage = 29;
		else
			anzTage = 28;
	}

	if (intTag==0 || intTag > anzTage) {
	   fldTag.focus();
	   alert("Ungültiger Tag. Gültige Eingaben: 1-" + anzTage);
	   return;
	}

	if (intJahr < 2000 || intJahr > 2100) {
	   fldTag.focus();
	   alert("Ungültiges Jahr. Gültig z.B.: 2001");
	   return;
	}

	/* Create new date object from field values */

	fldTag.value = intTag
	fldMonat.value = intMonat
	fldJahr.value = intJahr

	return new Date(intJahr, --intMonat, intTag);
}


function BuildDateFromList(frm, strTagListe, strMonatListe, strJahr)	{

	/*---------------------------------------------------------------------------
	Argumente:
	frm - Objektverweis auf die Form, deren Felder überprüft werden
	strTagListe - Name der Listbox zur Auswahl des Tages
	strMonatListe - Name der Listbox zur Auswahl des Monats
	strJahr - Name des Textfeldes, in das das Jahr eingegeben wird

	Funktion:
	Prüft, ob in den bezeichneten Listboxen gültige Werte ausgewählt wurden. Falls
	nicht, wird eine fehlerspezifische Warnung angezeigt (alert). Falls alle List-
	boxen gültige Werte enthalten, gibt die Funktion das entsprechende Datum als
	Date-Objekt zurück, sonst einen leeren Wert ("undefined").

	Bemerkung:
	Die Funktion geht davon aus, dass der erste gültige Wert aller Listen bei
	Index 0 (d.h. in der ersten Zeile) steht. Eine leere Zeile bzw. Eingabeauf-
	forderung in der ersten Zeile führt u.U. zu einem Fehler
	--------------------------------------------------------------------------- */

	/* Check for entries in date lists */

	lstTag = frm.elements[strTagListe];

	/* if (lstTag.selectedIndex < 1) {
	   lstTag.focus();
	   alert("Bitte wählen Sie einen Tag aus");
	   return;
	} */

	lstMonat = frm.elements[strMonatListe];

	/* if (lstMonat.selectedIndex < 1) {
	   lstMonat.focus();
	   alert("Bitte wählen Sie einen Monat aus");
	   return;
	} */

	txtJahr = frm.elements[strJahr];

	/* Check for proper values of day, month and year */

	intTag = parseInt(lstTag.options[lstTag.selectedIndex].value);
	intMonat = parseInt(lstMonat.options[lstMonat.selectedIndex].value);
	intJahr = parseInt(txtJahr.value);

	anzTage = 31;
	if  (intMonat==4 || intMonat==6 || intMonat==9 || intMonat==11)
		anzTage = 30;
	if  (intMonat==2) {
		if (intJahr % 4 == 0)
		   anzTage = 29;
		else
			anzTage = 28;
	}

	if (intTag > anzTage) {
	   lstTag.focus();
	   alert("Ungültiger Tag. Gültige Eingaben: 1-" + anzTage);
	   return;
	}

	/* Create new date object from field values */

	return new Date(intJahr, --intMonat, intTag);
}


function DateOrder(datStart, datEnd, strError)	{

	/* ---------------------------------------------------------------------------
	Argumente:
	datStart - Beginn der Mietdauer, als Date-Objekt
	datEnd - Ende der Mietdauer, als Date-Objekt
	strError - (opt.) Fehlermeldung, die ausgegeben werden soll. Wird das
		Argument nicht angegeben, erscheint ein Defaulttext.

	Funktion:
	Prüft, ob das Datum des Mietendes grösser als der Mietbeginn ist. Falls nicht,
	wird eine Warnung angezeigt (der durch strError festgelegte Text),
	und die Funktion gibt False zurück.
    Ausserdem wird die Mindestvorausbuchungsfrist überprüft und ggf. ein
    Hinweis ausgegeben.
	--------------------------------------------------------------------------- */
    //Hier habe ich zu Testzwecken die Mindestbuchungsfrist von 5 auf 0 gesetzt
    intMVBF = 5;   // Tage der MVBF
    
	if (datStart > datEnd) {
		if (typeof strError == "undefined")
			 strError = "Das Datum für den Mietbeginn ist grösser als das Datum für das Mietende";
		alert (strError);
		return false;
	} else {
//
//Hier rumgepfuscht zum Testen Tim
//
        //ORIGINAL 
dteNow = new Date();
	// EDITED dteNow = new Date(2005,04,04);

        
        intModMVBF = (intMVBF - 1) * 24 * 60 * 60 * 1000;   // konvertiere Tage in Millisekunden
        
        if ( (datStart.getTime() - intModMVBF) < dteNow.getTime() ) {
            alert('Aufgrund der Mindestvorausbuchungsfrist von ' + intMVBF + ' Tagen ist ein Fahrzeug online nicht mehr buchbar.\nFür eine kurzfristige Buchung rufen Sie uns bitte an. Tel: 07502 - 94086-0.\nMontag bis Freitag von 9.00 - 18.00 Uhr und  Samstags 9.00 bis 12.00 Uhr.');
            return false;
        } else {
            return true;
        }
        
    }
}


function IsWeekDay(datTest, strDay, strError) {

	/* ---------------------------------------------------------------------------
	Argumente:
	datTest - Datum, das auf Wochentag getestet wird, als Date-Objekt
	strDay - Name des Wochentages (deutsch), auf den getestet wird
	strError - (opt.) Fehlermeldung, die ausgegeben werden soll. Wird das
		Argument nicht angegeben, erscheint ein Defaulttext.

	Funktion:
	Prüft, ob das Datum auf den angegebenen Wochentag fällt. Falls ja,
	wird eine Warnung angezeigt (der durch strError festgelegte Text),
	und die Funktion gibt True zurück.
	--------------------------------------------------------------------------- */

	switch(strDay) {
	    case "Sonntag":
      	intTest = 0;
      	break;

		case "Samstag":
		intTest = 6;
		break;

		case "Sonnabend":
		intTest = 6;
      	break;

		case "Freitag":
		intTest = 5;
		break;

		case "Donnerstag":
		intTest = 4;
		break;

		case "Mittwoch":
		intTest = 3;
		break;

		case "Dienstag":
		intTest = 2;
		break;

		case "Montag":
		intTest = 1;
	}

	if (intTest == datTest.getDay()) {
		if (typeof strError == "undefined")
			strError = "Mietbeginn oder -ende können nicht " + strDay + "s erfolgen, da " +
			"der Vermieter an diesem Tag geschlossen hat";
		alert (strError);
		return true;
 	}
	else
		return false;
}


function MinMaxDays(datStart, datEnd, intMinDays, intMaxDays, strError) {

	/* ---------------------------------------------------------------------------
	Argumente:
	datStart - Beginn der Mietdauer, als Date-Objekt
	datEnd - Ende der Mietdauer, als Date-Objekt
	intMinDays - Mindestanzahl von Tagen für die Mietdauer
	intMaxDays - Maximalanzahl von Tagen für die Mietdauer
	strError - (opt.) Fehlermeldung, die ausgegeben werden soll. Wird das
		Argument nicht angegeben, erscheint ein Defaulttext.

	Funktion:
	Prüft, ob zwischen Mietbeginn und Mietende eine bestimmte Mindestanzahl von Tagen
	liegt, bzw. ob die Maximalmietdauer nicht überschritten ist. Falls nicht, wird
	eine Warnung angezeigt (der durch strError festgelegte Text), und die Funktion
	gibt False zurück.
	--------------------------------------------------------------------------- */

	if ((datEnd - datStart) / 86400000 < intMinDays) {
		if (typeof strError == "undefined")
			 strError = "Die Mietdauer muss mindestens " + intMinDays + " Tage betragen.";
		alert (strError);
		return false;
	}

	if ((datEnd - datStart) / 86400000 > intMaxDays) {
		if (typeof strError == "undefined")
			 strError = "Die Mietdauer kann maximal " + intMaxDays + " Tage betragen.";
		alert (strError);
		return false;
	}

   return true;
}


function MinMaxDaysNZ(datStart, datEnd, intMinDays, intMaxDays, strError) {

	/* ---------------------------------------------------------------------------
	Argumente:
	datStart - Beginn der Mietdauer, als Date-Objekt
	datEnd - Ende der Mietdauer, als Date-Objekt
	intMinDays - Mindestanzahl von Tagen für die Mietdauer
	intMaxDays - Maximalanzahl von Tagen für die Mietdauer
	strError - (opt.) Fehlermeldung, die ausgegeben werden soll. Wird das
		Argument nicht angegeben, erscheint ein Defaulttext.

	Funktion:
	Prüft, ob zwischen Mietbeginn und Mietende eine bestimmte Mindestanzahl von Tagen
	liegt, bzw. ob die Maximalmietdauer nicht überschritten ist. Falls nicht, wird
	eine Warnung angezeigt (der durch strError festgelegte Text), und die Funktion
	gibt False zurück.
	--------------------------------------------------------------------------- */

	if (((datEnd - datStart) / 86400000)+1 < intMinDays) {
		if (typeof strError == "undefined")
			 strError = "Die Mietdauer muss mindestens " + intMinDays + " Tage betragen.";
		alert (strError);
		return false;
	}

	if (((datEnd - datStart) / 86400000)+1 > intMaxDays) {
		if (typeof strError == "undefined")
			 strError = "Die Mietdauer kann maximal " + intMaxDays + " Tage betragen.";
		alert (strError);
		return false;
	}

   return true;
}


function IsValidPeriod(strPerStart, strPerEnd, datStart, datEnd, strError)	{

	/* ---------------------------------------------------------------------------
	Argumente:
	strPerStart - Beginn der gültigen Periode als Text, im Format YYYY/M/D
	strPerEnd - Ende der gültigen Periode als Text, im Format YYYY/M/D
	datStart - Beginn der Mietdauer, als Date-Objekt
	datEnd - Ende der Mietdauer, als Date-Objekt
	strError - (opt.) Fehlermeldung, die ausgegeben werden soll. Wird das
		Argument nicht angegeben, erscheint ein Defaulttext.

	Funktion:
	Prüft, ob Mietbeginn und Mietendes innerhalb der Gültigkeitsperiode
	(angegeben durch strPerStart und strPerEnd) liegen. Falls nicht, wird eine
	Warnung angezeigt (der durch strError festgelegte Text), und die Funktion
	gibt False zurück.
	--------------------------------------------------------------------------- */

	datPerStart = new Date(strPerStart);
	datPerEnd = new Date(strPerEnd);


	if (datStart < datPerStart || datEnd > datPerEnd) {
		if (typeof strError == "undefined")
			 strError = "Mietbeginn oder Mietende liegen ausserhalb der Gültigkeit der Preisliste";
		alert (strError);
		return false;
	}
	else
		return true;
}

function IsBusyDate(datCheck) {

	/* ---------------------------------------------------------------------------
	Argumente:
	datCheck - Datum, das überprüft werden soll (als Datum)

	Funktion:
	Prüft zunächst, ob die globalen Arrays, die regelmäßige und unregelmäßige
	Schließungstage enthalten, im erforderlichen Format vorliegen bzw. wandelt
	diese um.
	Das als Argument übergebene Datum wird überprüft, ob es innerhalb der Gültigkeit
	der Preisliste liegt, ob es auf einen Wochentag fällt, an dem der Vermieter 
	regelmäßig geschlossen hat, oder ob es auf einen Feiertag fällt, an dem der
	Vermieter geschlossen hat.
	
	Rückgabewert: False, wenn Vermieter geschlossen hat, oder Datum ausserhalb
	der Gültigkeit der Preisliste. True, wenn Datum ok ist.
	--------------------------------------------------------------------------- */


	// Array mit regelmäßigen Schließungstagen umwandeln in Format aus Date.getDay()  ******
	
	if (typeof araClosed != "undefined") {

		if (typeof araClosed[0] == "string") {		
			var araDays = new Array("So","Mo","Di","Mi","Do","Fr","Sa");
			for (var i = 0; i < araClosed.length; i++)
				for (var j = 0; j < araDays.length; j++) {
					if (araClosed[i] == araDays[j]) {
						araClosed[i] = j;
						break;
					}
				}
		}
	}

	// Array mit Feiertags-Schliessungen in Date-Objekte umwandeln  *************************

	if (typeof araHoliday != "undefined") {
		if (typeof araHoliday[0] == "string")
			for (var i = 0; i < araHoliday.length; i++)
				araHoliday[i] = new Date(araHoliday[i]);
	}
				
	// Datum innerhalb der Gültigkeit der Preisliste ?  *************************************
	
	if (datCheck < datBeginSch || datCheck > datEndSch) {
		alert ("Mietbeginn oder Mietende liegen ausserhalb der Gültigkeit der Preisliste");
		return false;
	}				


	// An diesem Wochentag geöffnet ?  ******************************************************
	
	if (typeof araClosed != "undefined") {
		var intDay = datCheck.getDay();
		for (i = 0; i < araClosed.length; i++) {
			if (intDay == araClosed[i]) {
				alert("An diesem Wochentag hat der Vermieter geschlossen")
				return false;
			}					
		}
	}
	
	// Ist das Datum ein Feiertag, an dem geschlossen ist ?  ********************************
	
	if (typeof araHoliday != "undefined")
		for (i = 0; i < araHoliday.length; i++)
			if (datCheck.toString() == araHoliday[i].toString()) {
				alert("An diesem Tag hat der Vermieter wegen Feiertag geschlossen");
				return false;
			}

	return true;
}

function IsHoliday(datTest, strHolStart, strHolEnd, strError) {

	/* ---------------------------------------------------------------------------
	Argumente:
	datTest - Datum, das überprüft werden soll
	strHolStart - Beginn der Feiertagsschliessung beim Vermieter als Text, im Format YYYY/M/D
	strHolEnd - (opt.) Ende der Feiertagsschliessung beim Vermieter. Wird das
		Argument nicht angegeben, wird es gleich datHolStart gesetzt ( Es wird
		also kein Zeitraum, sondern nur ein einzelner Tag geprüft).
	strError - (opt.) Fehlermeldung, die ausgegeben werden soll. Wird das
		Argument nicht angegeben, erscheint ein Defaulttext.

	Funktion:
	Prüft, ob ein Datum in die Feiertagsschliessung eines Vermieters fällt.
	Falls ja, wird eine Warnung angezeigt (der durch strError festgelegte
	Text), und die Funktion gibt True zurück.
	--------------------------------------------------------------------------- */

	if (typeof strHolEnd == "undefined")
	    strHolEnd = strHolStart

	datHolStart = new Date(strHolStart);
	datHolEnd = new Date(strHolEnd);

	if (datTest >= datHolStart && datTest <= datHolEnd) {
		if (typeof strError == "undefined")
			strError = "An diesem Tag hat der Vermieter wegen Feiertag(en) geschlossen";
		alert (strError);
		return true;
 	}
	else
		return false;
}

function SetKeyString(objTextbox) {

	/* ---------------------------------------------------------------------------
	Argumente:

	objTextbox - Objektverweis auf das Kennwort-Feld (INPUT-Element in HTML)

	Funktion:
	Prüft Existenz des Cookies "Kennwort", bzw. setzt das Cookie, wenn es nicht
	vorhanden ist.
	--------------------------------------------------------------------------- */

	/* Prüfen auf vorhandenen Wert, ggf. Wert auslesen */

	var blCreate = false;
	var strAll = document.cookie;

	if (strAll == "")
		blCreate = true;
	else {
		var start = strAll.indexOf("Kennwort=");
		if (start == -1)
			blCreate = true;
		else {
			start += 9;	// Länge des string "Kennwort"
			var end = strAll.indexOf(";", start)
			if (end == -1) end = strAll.length;
			var strKennwort = strAll.substring(start,end);
		}
	}

	/* Wert für Cookie erzeugen */

	if (blCreate) strKennwort = Math.random().toString().substring(2,12);

	/* Wert, Pfad und Geltungsdauer als Cookie schreiben */

	var datValid = new Date((new Date()).getTime() + 720*3600000);
	document.cookie = "Kennwort=" + strKennwort + "; path=/; expires=" + datValid.toGMTString();

	/* Wert für Kennwort in Textbox schreiben */

	objTextbox.value = strKennwort
	return true;
}


function ShowHelp(strNameEmpty, strURLstandard, strURLhelp) {

	strURLunten = window.parent.frames["Unten"].location.href;

	if (strURLunten.indexOf(strURLstandard) >= 0 || strURLunten.indexOf(strURLhelp) >= 0)
		return;

	if (strURLunten.indexOf(strNameEmpty) >= 0)
		window.parent.frames["Unten"].location.href = strURLstandard;
	else
		window.parent.frames["Unten"].location.href = strURLhelp;
}


/* -----------------------------------------------------------------------------------
   Die folgenden Funktionen waren bereits vorhanden und können ebenfalls
   in eine Skriptdatei ausgelagert werden:
----------------------------------------------------------------------------------- */

function Start(page) {
	OpenWin = this.open(page, "CtrlWindow", 	"toolbar=no,menubar=no,location=no,height=390,width=220,left=100,top=100");
	OpenWin.focus();
}

function Ibis(page) {
	OpenWin = this.open(page, "CtrlWindow", 	"toolbar=no,menubar=no,location=no,height=560,width=370,left=100,top=100");
	OpenWin.focus();
}

function Startflughilfe(page) {
	OpenWin = this.open(page, "CtrlWindow", 	"toolbar=no,menubar=no,location=no,height=560,width=480,left=100,top=100");
}

function Startpreishilfe(page) {
	OpenWin = this.open(page, "CtrlWindow", 	"toolbar=no,menubar=no,location=no,height=368,width=376,left=100,top=100");
}