// ===============================================================================================================================
// Beginn Globale Deklaration
// ===============================================================================================================================

var DateFormat = "";
var aDayStr="";
var aDaysStr="";
var aHourStr="";
var aMinuteStr="";
var FInvalidValues = false;
var FEmptyDateField = false;
var AutoCompleteStr = "";
var AutoCompleteObj;
var AutoCompleteCallFunction = "";
var AutoCompleteLastPos = 0;
var AllowedAutoCompleteAction = false;
var FCommaSep = "";
var FSemicolonSep = "";
var FShowRTFHint = true;
var FClickDatePicker = false;
var FClickTimePicker = false;

dateForm = new Array (/(\d\d)\S(\d\d)\S(\d\d\d\d)/,/(\d)\S(\d\d)\S(\d\d\d\d)/,/(\d\d)\S(\d)\S(\d\d\d\d)/,/(\d)\S(\d)\S(\d\d\d\d)/,
                      /(\d\d)\S(\d\d)\S(\d\d\d)/,/(\d)\S(\d\d)\S(\d\d\d)/,/(\d\d)\S(\d)\S(\d\d\d)/,/(\d)\S(\d)\S(\d\d\d)/,
                      /(\d\d)\S(\d\d)\S(\d\d)/,/(\d)\S(\d\d)\S(\d\d)/,/(\d\d)\S(\d)\S(\d\d)/,/(\d)\S(\d)\S(\d\d)/,
                      /(\d\d)\S(\d\d)\S(\d)/,/(\d)\S(\d\d)\S(\d)/,/(\d\d)\S(\d)\S(\d)/,/(\d)\S(\d)\S(\d)/,
                      /(\d\d)\S(\d\d)/,/(\d)\S(\d\d)/,/(\d\d)\S(\d)/,/(\d)\S(\d)/);

timeForm = new Array (/(\d\d):(\d\d)/,/(\d):(\d\d)/,/(\d\d):(\d)/,/(\d):(\d)/,
                      /(\d\d\d\d)/,/(\d\d\d)/,/(\d\d)/,/(\d)/ );

// ===============================================================================================================================
// Ende Globale Deklaration
// ===============================================================================================================================

// ===============================================================================================================================
// Prüft, ob sich der SelectedIndex vom DefaultSelected-Wert unterscheidet, wenn ja, dann wird true zurückgeliefert
// ===============================================================================================================================
function isSubmitAllowed(aobj) {
  var isAllowed = false;
  var lDefaultSel = false;
	for(i = 0; i < aobj.length; i++) {
    if (aobj.options[i].defaultSelected == true) {
      lDefaultSel = true;
      if ( i != aobj.selectedIndex) {
        isAllowed = true;
        break;
      } 
    }
  }
  // es ist möglich, dass es keinen Default-Selected gibt. Dadurch wird das Versenden bei Vorauswahl per 
  // Buchstaben-Druck verhindert. Deswegen hier setzen des Defaultwertes auf den Index 0
  if (!lDefaultSel) {
		aobj.options[0].defaultSelected = true;
		isAllowed = isSubmitAllowed(aobj);
  }
  return isAllowed;
}

// ===============================================================================================================================
// Checked, ob die eingegebene Emailadresse gültig ist und schreibt demnach das entsprechende Email-Image raus
// ===============================================================================================================================
function SetAvailableImage(aobj, aImageID, aImgEmptyPath, aImgPath) {
  lvalue = aobj.value;

  var limages = new Array();

  limages[0] = aImgPath;
  limages[1] = aImgEmptyPath;

  var lpreloadedimages = new Array();
  for ( i = 0; i < limages.length; i++) {
    lpreloadedimages[i] = new Image();
    lpreloadedimages[i].src = limages[i];
  }

  limageobj = GetObjDiv(aImageID);

  lsearchpos = lvalue.search(/@/);
  if (lsearchpos > -1) {
    limageobj.src = limages[0];
  }
  else {
    limageobj.src = limages[1];
  }
}

// ===============================================================================================================================
// Erzeugt eine Javascript-Funktion die dynamisch MailAdressen aus einem Formular-Textfeld liest und den Email-Link verändert
// ===============================================================================================================================
function setCustomMailLink(aUrl, aValidMailMessage) {
  lsearchpos = aUrl.search(/@/);

  if ( (aUrl != 'mailto:') && ( lsearchpos != -1 ) ) {
    location.href = aUrl;
  }
  else if ( lsearchpos == -1 ) {
    alert(aValidMailMessage);
  }
}

// ===============================================================================================================================
// Erzeugt eine Javascript-Funktion die dynamisch Urls aus einem Formular-Textfeld liest 
// und den Link mit der eingetragenen Url verändert.
// ===============================================================================================================================
function getCustomLink(aUrl) {
  if ( aUrl != '') {
    var lsubstring = aUrl.substring(0,7);
    if(lsubstring != 'http://') {
      aUrl = 'http://' + aUrl;
    }
  }
  else {
    aUrl = 'about:blank';
  }
  return aUrl;
}

// ===============================================================================================================================
// Gibt einen Alert aus, wenn das StartDatum > Enddatum der Gültigkeit ist
// ===============================================================================================================================
function onErrorStartEndValidity(aObjInput, aStartDate, aEndDate, amessage) {
  var isValid = checkValidStartAndEnd(aObjInput, aStartDate, aEndDate);
  if ( isValid == false) {
    alert(amessage);
    aObjInput.value = "";
    aObjInput.focus();
  } 
  return isValid;
}


// ===============================================================================================================================
// Löscht den Auto-Vervollständigen Text, wenn dieser gleich dem übergebenen ist
// ===============================================================================================================================
function ClearAutoCompleteStr(aLastAutoCompleteStr) {
  if (aLastAutoCompleteStr == AutoCompleteStr) {
    AutoCompleteStr = "";
    AutoCompleteLastPos = 0;
  }
}

// ===============================================================================================================================
// PREPARE: Vervollständigt den Text in einer Select-OptionBox bei Textsuche
// aobj = input type textfeld, aselectobj = Option-SelectBox
// ===============================================================================================================================
function AutoCompleteWord(aselectobj) {
  if ( (aselectobj != null) && 
       (PortalKeyDownCode != 9) && 
       (PortalKeyDownCode != 13) ) {  

    if (aselectobj != AutoCompleteObj) {
      AutoCompleteStr = "";  
    }

    // Sonderbehandlung für Sonderzeichen ü, ö, ä 
    if ( PortalKeyDownCode == 186 ) { 
      lPortalKeyDownString = "ü";
    }
    else if ( PortalKeyDownCode == 192 ) { 
      lPortalKeyDownString = "ö";
    }
    else if ( PortalKeyDownCode == 222 ) { 
      lPortalKeyDownString = "ä";
    }
    else {
      lPortalKeyDownString = String.fromCharCode(PortalKeyDownCode);
    }

    // lsubstr extrahiert ein eingebenes Zeichen, wandelt es in einen String um 
    //und vervollständigt den AutoCompleteStr
    AutoCompleteStr = AutoCompleteStr + lPortalKeyDownString;
    AutoCompleteObj = aselectobj;

    AllowedAutoCompleteAction = true;
    window.setTimeout("AutoCompleteAction(AutoCompleteStr)",300);
  }
}

// ===============================================================================================================================
// ACTION: Vervollständigt den Text in einer Select-OptionBox bei Textsuche
// aobj = input type textfeld, aselectobj = Option-SelectBox
// ===============================================================================================================================
function AutoCompleteAction(aAutoCompleteStr) {
  if ( ( AutoCompleteStr.toLowerCase() == aAutoCompleteStr.toLowerCase() ) && (AllowedAutoCompleteAction == true) ) {
    AllowedAutoCompleteAction = false;
    aselectobj = AutoCompleteObj;
    lsubstr = AutoCompleteStr;
    lisfound = false;

    for ( var i = AutoCompleteLastPos; i < aselectobj.length; i++) {
      var ltext = aselectobj.options[i].text;
      var lsubpos = lsubstr.length;
      var lsubtext = ltext.substr(0, lsubpos);

      if (lsubstr.toLowerCase() == lsubtext.toLowerCase()) {
        // KeyCode 16 und 57402 = Shift-Taste; KeyCode 17 und 57401 = Strg-Taste
        if ( ( PortalKeyDownCode != 16 ) && ( PortalKeyDownCode != 17 ) &&
             ( PortalKeyDownCode != 40 ) && ( PortalKeyDownCode != 38 ) &&
             ( PortalKeyDownCode != 57386 ) && ( PortalKeyDownCode != 57385 ) &&
           ( PortalKeyDownCode != 57402 ) && ( PortalKeyDownCode != 57401 ) ) {
          // Wichtig für eine Multi-Selectauswahl, denn dann müssen alle Selektierten Werte zurückgesetzt werden
            aselectobj.selectedIndex = -1;
        }

        aselectobj.options[i].selected = true;   
        AutoCompleteLastPos = i;
		if (AutoCompleteCallFunction != '') {
			window.setTimeout(AutoCompleteCallFunction, 0);
		}
        break;
      }
    }

    // wurde nach 1500 ms kein Text eingegeben, so wird der Auto-Vervollständigen-Text zurückgesetzt
    window.setTimeout("ClearAutoCompleteStr(lsubstr)",1500);
  }
}

// ===============================================================================================================================
// Wenn bestimmte KeyCode gedrückt werden, dann wird true zurückgeliefert
// ===============================================================================================================================
function IsKeyCodeInSelectBox(aobj, aKeyCode) {
  if ( ( PortalKeyDownCode == aKeyCode ) && ( aobj.selectedIndex > -1 ) ) {
    return true;  
  }
  else {
    return false;
  }
}

// ===============================================================================================================================
// Verhindert ein Return in Formularfeldern
// ===============================================================================================================================
function DisableEnter() {
  if (window.event.keyCode == 13) { 
    return false;
  }
}



// ===============================================================================================================================
// Setzt eine gecheckte Radio- bzw. Checkbox zurück
// ===============================================================================================================================
function CheckedOff(aobjID) {
  lobj = GetObjDiv(aobjID);
  if ( lobj.checked == true ) {
    lobj.checked = false;    
  }
}

// ===============================================================================================================================
//
// ===============================================================================================================================
function setDurationStrings(lDayStr, lDaysStr, lHourStr, lMinuteStr){
	aDayStr = lDayStr;
	aDaysStr = lDaysStr;
	aHourStr = lHourStr;
	aMinuteStr = lMinuteStr;
}

// ===============================================================================================================================
//
// ===============================================================================================================================
function setDateFormat(aDateFormat){
  DateFormat = aDateFormat;
}

// ===============================================================================================================================
//
// ===============================================================================================================================
function onBlurDateField(objInput, InputForm, ErrorStr,ErrorStrActual,ErrorStrBirthday, AllowedEmptyDateField, ATagId){
  // objInput: zu prüfendes Datumsfeld
  // InputForm: Nur bei DatePicker; nach erfolgreicher Datumsprüfung document.InputForm.submit()
  
  // für die Datumsprüfung wird in dd.MM.yyyy umgewandelt, 
  // bei der Ausgabe wird wieder in das eingestellte Format zurück gewandelt 

  // AllowedEmptyDateField muss auf einen Defaultvalue gesetzt werden
  if ( (AllowedEmptyDateField == null) || (AllowedEmptyDateField == "") ) {
    AllowedEmptyDateField = "no";
  }

  FInvalidValues = false;
  if (DateFormat.toUpperCase() != 'DD.MM.YYYY'){
	var dateValueBeforeSubmit = formatDate(new Date(getDateFromFormat(objInput.value, DateFormat, ErrorStr, ErrorStrActual)),'dd.MM.yyyy', objInput);
  }
  else{
    var dateValueBeforeSubmit = objInput.value;
  }

  var DateString = dateValueBeforeSubmit.split(".");
  // bei Eingabe von nur einer Zahl, wird dies als Tag im aktuellen Monat und Jahr interpretiert
  if (DateString.length == 1 ) {
   
      if ( dateValueBeforeSubmit.lastIndexOf(".") != dateValueBeforeSubmit.length-1 ) {
        dateValueBeforeSubmit = dateValueBeforeSubmit + ".";
      }
      var today = new Date();
  	  dateValueBeforeSubmit = dateValueBeforeSubmit + (today.getMonth()+1) + "." + today.getYear();

      DateString = dateValueBeforeSubmit.split("."); 

  }				
  
  // Datum wurde nicht komplett eingegeben: Nur eine Zahl mit Punkt oder Eingabe von Monat und Tag...
  if (DateString.length == 2 ) {
  // fehlenden Punkt am Ende hinzufügen, wenn monat und Tag eingegeben wurde
    if (DateString[1] != ""){
		if ( dateValueBeforeSubmit.lastIndexOf(".") != dateValueBeforeSubmit.length-1 ) {
			dateValueBeforeSubmit = dateValueBeforeSubmit + ".";
			DateString = dateValueBeforeSubmit.split("."); 
		}
    }
  
  // bei Eingabe von nur einer Zahl mit Punkt, wird dies als Tag im aktuellen Monat und Jahr interpretiert
    else{
	    var today = new Date();
		dateValueBeforeSubmit = dateValueBeforeSubmit + (today.getMonth()+1) + "." + today.getYear();
		DateString = dateValueBeforeSubmit.split("."); 
    }
  }				

  // wenn FEmptyDateField=true, wird das Eingabefeld bei fehlerhaftem Datum geleert,
  // sonst immer aktuelles Datum setzen.
  if (FEmptyDateField){
	dtToday = "";
	FEmptyDateField = false;
  }
  else{
	var dtToday = new Date();
	dtToday = dateToString(dtToday);
  }
  
  //Wenn Array "Datumsstring weniger als 3 Elemente hat wurde das Datum nicht im korrekten Format eingegeben.
  if (DateString.length != 3 )				
  {
    // Summary: AllowedEmptyDateField erlaubt das Datumsfeld zu leeren, wenn ein Wert
    // vorhanden ist, ansonsten kommt ein Javascript-Alert Fenster, dass das DateField befüllt sein muss
    if ( AllowedEmptyDateField.toLowerCase() != "yes") {
      FInvalidValues = true;
      alert(ErrorStr);
      objInput.value = dtToday;
      objInput.focus();
      objInput.select();
    }

    return false;			  
  }

  //Enthält eines der drei Arrayelemente keinen gültigen Zahlenwert(Nummer), dann Function abrechen und zurück zur Eingabe
  if (isNaN(DateString[0]) || isNaN(DateString[1]) || isNaN(DateString[2])){
    FInvalidValues = true;
    alert(ErrorStr);
    objInput.value = dtToday;
    objInput.focus();
    objInput.select();
    return false;
  }

  var Year = DateString[2];
  var Month = DateString[1];
  var Day = DateString[0];

  if (Year.length > 4)		//Wenn Jahreszahl mehr als vierstellig, Function abbrechen
  {
    FInvalidValues = true;
    alert(ErrorStr);
    objInput.value = dtToday;
    objInput.focus();
    objInput.select();
    return false;
  }
  
  if ((Year.length == 4) && ((Year < 1753) || (Year > 9000))){
	FInvalidValues = true;
	alert(ErrorStrActual)
    objInput.value = dtToday;
	objInput.focus();
    objInput.select();
    return false;
  }

  if (Month < 1 || Month > 12 ) // Wenn Monat kleiner 1 oder größer 12 Function abbrechen
  {
    // Summary: AllowedEmptyDateField erlaubt das Datumsfeld zu leeren, wenn ein Wert
    // vorhanden ist, ansonsten kommt ein Javascript-Alert Fenster, dass das DateField befüllt sein muss
    if ( ( AllowedEmptyDateField.toLowerCase() == "no") || (objInput.value != "") ){
      FInvalidValues = true;
      alert(ErrorStr)
      objInput.value = dtToday;
      objInput.focus();
      objInput.select();
    }
    return false;
  }

  var MaxDay = 31;
  if(Month==4 ||Month==6 || Month==9 || Month==11 ) // gültigen Wert für Monate 4,6,9,11 auf 30 Tage setzen
  {  
    MaxDay=MaxDay-1;
  }
  
  if(Month==2)		//Februar auf 28 Tage setzen
  {
    MaxDay=28;
	if(Year%4==0)	//Jahreszahl glatt durch 4 teilbar , dann Februar auf 29 Tage setzen
	{
	  MaxDay=MaxDay+1;
	}
	if(Year%100==0) //Jahreszahl glatt durch 100 Teilbar, dann kein Schaltjahr, zurück auf 28 Tage
	{
	MaxDay=MaxDay-1;
	}
	if(Year%400==0) //Jahreszahl glatt durch 400 Teilbar, dann doch Schaltjahr, zurück auf 29 Tage
	{
	MaxDay=MaxDay+1;
	}
  }


  if (Day < 1 || Day > MaxDay)		// Tag kleiner 1 oder größer als max. Monatstag, Function beenden
  {
    FInvalidValues = true;
    alert(ErrorStr);
    objInput.value = dtToday;
    objInput.focus();
    objInput.select();
    return false;
  }

  var aDateValue = dateValueBeforeSubmit;
  
  var newDate = stringToDate(aDateValue);
  objInput.value=formatDate(newDate, DateFormat, objInput);
  	
  if (aIsDateValue == false){
	objInput.focus();
	objInput.select();
  }
  
  if ((InputForm != '') && (aIsDateValue == true)){
    setHiddenFields(InputForm, ATagId); 
    document.forms[InputForm].submit();
  }


// bei Geburtstagen Abfrage ob Datum in der Zukunft liegt, 
// dann Fehlermeldung und aktuelles Datum einfügen
  if (objInput.name.toUpperCase() == "TWF_BIRTHDAY"){
    var actualDate = new Date();
    if (actualDate < newDate) {
      FInvalidValues = true;
      alert(ErrorStrBirthday);
      objInput.value = dtToday;
	  objInput.focus();
      objInput.select();
      return false;
    }
  }

  // wieder auf true setzen, um Folgefehler zu vermeiden
  aIsDateValue = true;
}


// ===============================================================================================================================
//
// ===============================================================================================================================
function onBlurNullableDateField(objInput, ErrStr, ErrorStr, ErrorStrActual, ErrorStrBirthday, AllowedEmptyDateField)
{
  if (objInput.value != ''){
    onBlurDateField(objInput, '', ErrorStr, ErrorStrActual, ErrorStrBirthday, AllowedEmptyDateField, '');
  }
  else{
		FInvalidValues = false;
	}
}


// ===============================================================================================================================
//
// ===============================================================================================================================
function onBlurTimeField(objInput, ErrorStr, Fillout) {
  
  if ( (objInput.value != "") || (Fillout.toUpperCase() != "NO") ) {
	var aTimeValue = objInput.value;
	
	// Eingaben mit / oder , sollen auch möglich sein
	aTimeValue = aTimeValue.replace(/,/,":");
	aTimeValue = aTimeValue.replace(/\//,":");
	
	var newDate = stringToTime(aTimeValue);
	if (checkTime(aTimeValue)==false) {
	  alert(ErrorStr);
	  var TimeFieldName = objInput.name.toUpperCase();
	  if (TimeFieldName.indexOf("START_DT_TIME")>-1) {
		objInput.value = "00:00"
		}
		else if (TimeFieldName.indexOf("END_DT_TIME")>-1) {
		objInput.value = "23:59"
		}
		objInput.focus();
		objInput.select();
		return;
	}
	if ((aTimeValue == 24) || ( (aTimeValue+"") == "24:00") || ( (aTimeValue+"") == "24:0") || ( (aTimeValue) == 2400)) {
	    objInput.value="24:00";
	}
	else {
	    objInput.value=timeToString(newDate);
	}
  }
}

// ===============================================================================================================================
//
// ===============================================================================================================================
function checkTime(strTime) {
    var blCheckTime = true;
    if (strTime.indexOf(":")==-1) {
    //string wird durch -0 in eine Zahl umgewandelt
      strTime=strTime-0;
      if (isNaN(strTime)==true) {
        blCheckTime = false;
      }
      else {
        strTime = strTime+"";
        // damit Eingaben wie 615 auch wirklich das richtige Ergebnis liefert (6:15)
        if (strTime.length < 4){
					strTime = "0" + strTime;
        }
        var Hours = strTime.substring(0,2);   
        var Minutes = strTime.substring(2,4);
        if ((Hours > 24) || (Minutes >60)) {
          blCheckTime = false;
        }
      }
    }
    else {
      var strHour=strTime.substring(0,strTime.indexOf(":"))
      strHour=strHour-0;
      if ((strHour>=25) || (isNaN(strHour-0)==true))  {
        blCheckTime=false;
      }
      else {
        var strMinute=strTime.substring(strTime.indexOf(":")+1,strTime.length);
        strMinute=strMinute-0;
        if (((strHour==23)&&(strMinute>=60)) || ((isNaN(strMinute-0)==true)))  {
          blCheckTime=false;
        }
        if (((strHour==24)&&(strMinute>0)) || ((isNaN(strMinute-0)==true)) ) {
          blCheckTime=false;
        }
      }
    }
    return blCheckTime;
}

// ===============================================================================================================================
//
// ===============================================================================================================================
function stringToDate (aString)
{
var i=0;
while (( i < dateForm.length ) && ( aString.search( dateForm[i])== -1 )) i=i+1;
        if ( i < dateForm.length)
    {
      dateForm[i].exec(aString);
      newDay = parseInt(RegExp.$1, 10);
      newMonth = parseInt(RegExp.$2, 10)-1;
      newYear = parseInt(RegExp.$3, 10);

        if (isNaN(newYear))
        {
          newYear=(new Date()).getFullYear();
        }
        else
        {
          if (newYear<100)
          {
            thisYear = (new Date()).getFullYear();
            // add the actual century
            newYear = newYear + parseInt((thisYear/100), 10)*100;
            // if we are more tha 30 years in the future,
            // assume it's one hundred years earlier
            if (newYear-30>thisYear)
            {
              newYear= newYear-100;
            }
          }
        }
                newDate = new Date(newYear,newMonth,newDay,0,0,0);
                return newDate;
     }
     else
         {
       return "not a date";
         }
}


// ===============================================================================================================================
//
// ===============================================================================================================================
function stringToTime(aString) {
  var i=0;
  while ((i < timeForm.length) && (aString.search(timeForm[i])==-1)) i=i+1;
  switch (i) {
        case 0:
        case 1:
        case 2:
        case 3:
          newHour=parseInt(RegExp.$1, 10);
          newMinute=parseInt(RegExp.$2, 10);
          break;
        case 4:
          newHour=parseInt(RegExp.$1.substring(0,2), 10);
          newMinute=parseInt(RegExp.$1.substring(2,4), 10);
          break;
        case 5:
          help = parseInt(RegExp.$1, 10);
          newHour = Math.floor(help/100);
          newMinute = help-newHour*100;
          break;
        case 6:
        case 7:
          newHour = parseInt(RegExp.$1, 10);
                newMinute = 0;
                break;
          default:
                newHour=12;
                newMinute=0;
  }
  newDate = new Date(1900,0,1,newHour,newMinute,0);
  return newDate;
}



// ===============================================================================================================================
//
// ===============================================================================================================================
function dateToString (newDate)
{
  if (newDate.getDate()<10) strDate="0"+newDate.getDate();
  else strDate=newDate.getDate();
  if ((newDate.getMonth())+1<10) strMonth="0"+(newDate.getMonth()+1);
  else strMonth=(newDate.getMonth()+1);
  strYear=newDate.getFullYear();
  return strDate+"."+strMonth+"."+strYear
}


// ===============================================================================================================================
//
// ===============================================================================================================================
function timeToString(aTime)
{
  strHour=aTime.getHours();
  if (strHour<10) strHour="0"+strHour;
  strMinute=aTime.getMinutes();
  if (strMinute<10) strMinute="0"+strMinute;
  return strHour+":"+strMinute
}


// ===============================================================================================================================
// prüft ob ein Startdatum kleiner als Enddatum
// ===============================================================================================================================
function checkValidStartAndEnd(aObjInput, aStartDate, aEndDate) {
	// Prüfung nur, wenn beide Felder gefüllt sind
	if ((aStartDate.value != "") && (aEndDate.value != "")){
		// in richtiges datumsformat umwandeln
		if (DateFormat.toUpperCase() != 'DD.MM.YYYY'){
			var EndDateValue = formatDate(new Date(getDateFromFormat(aEndDate.value, DateFormat, '', '')),'dd.MM.yyyy', aObjInput);
			var StartDateValue = formatDate(new Date(getDateFromFormat(aStartDate.value, DateFormat, '', '')),'dd.MM.yyyy', aObjInput);
		}
		else{
			var EndDateValue = aEndDate.value;
			var StartDateValue = aStartDate.value;
		}

		var EndArray = EndDateValue.split(".");
		var EndDate = new Date(EndArray[2],EndArray[1]-1,EndArray[0]);
		var EndDate = EndDate.getTime();

		var StartArray = StartDateValue.split(".");
		var StartDate = new Date(StartArray[2],StartArray[1]-1,StartArray[0]);
		var StartDate = StartDate.getTime();

 
		if (StartDate > EndDate){
			return false;
		}
		else{
			return true;
		}
	}
	else
		return true;
}


// ===============================================================================================================================
// nimmt die eingegebenen Start- und Endzeiten und gibt sie an das durationiframe-Tag weiter, 
// welches die neue Dauer berechnet
// ===============================================================================================================================
function setDuration(objFormular, objInput, URL) {
  var DateFrom = objFormular.twf_start_dt.value;
	DateFrom = DateFrom.substring(DateFrom.indexOf(",")+1,DateFrom.length);
	var TimeFrom = objFormular.start_dt_time.value;

	var DateTo = objFormular.twf_end_dt.value;
	DateTo = DateTo.substring(DateTo.indexOf(",")+1,DateTo.length);
	var TimeTo = objFormular.end_dt_time.value;
	
	lDurationManual = "off";
	if (objFormular.twg_gwDurationManual != null){
		if (objFormular.twg_gwDurationManual.value == "on"){
			lDurationManual = "on";
		}
	}

	self.durationiframe.location.replace(URL + "?start_dt=" + DateFrom + "&start_dt_time=" + TimeFrom + "&end_dt=" + DateTo + "&end_dt_time=" + TimeTo + "&value_durationmanual=" + lDurationManual + "&fieldchange=" + objInput.name + "&OQS=" + durationiframe.ssid);
}


// ===============================================================================================================================
// war die berechnete Dauer < 0, wurden Start- und Endzeiten angepasst; diese Funktion füllt die 
// Formularfelder mit den entsprechend angepassten Werten
// ===============================================================================================================================
function setDateFields(aobjForm, aStartDtField, aStartDtValue, aEndDtField, aEndDtValue, aStartTimeField, aStartTimeValue, aEndTimeField, aEndTimeValue, aDurationField, aDurationValue){
 	aobjForm.elements[aStartDtField].value = aStartDtValue;
	aobjForm.elements[aEndDtField].value = aEndDtValue;
	if (aobjForm.elements[aStartTimeField] != null){
		aobjForm.elements[aStartTimeField].value = aStartTimeValue;
	}
	if (aobjForm.elements[aEndTimeField] != null){
		aobjForm.elements[aEndTimeField].value = aEndTimeValue;
	}
}

// ===============================================================================================================================
// befüllt das versteckte Dauerfeld im Formular mit dem berechneten Wert
// ===============================================================================================================================
function setDurationField(aobjForm, aDurationField, aDurationValue){
	aobjForm.elements[aDurationField].value = aDurationValue;
}

// ===============================================================================================================================
// sorgt dafür, dass das iFrame mit dem Dauer-Feld nur so groß wie das Feld selbst ist
// ===============================================================================================================================
function setFrameWidth(FrameId, DivId){
	var lHeight = durationiframe.document.getElementById(DivId).offsetHeight;
	var lWidth = durationiframe.document.getElementById(DivId).offsetWidth;
	document.getElementById(FrameId).style.height = lHeight; 
 	document.getElementById(FrameId).style.width = lWidth;
}


// ===============================================================================================================================
//	setzt das Dauerfeld von readonly auf beschreibbar, 
//	damit bei Urlaubsanträgen die Dauer in Sonderfällen von Hand eingegeben werden kann
// ===============================================================================================================================
function setDurationManual(iframecheckbox, durationmanual, objFormular, URL, HintStr) {
	if (iframecheckbox.checked) {
		durationmanual.value = "on";
	}
	else{
		alert(HintStr);
		durationmanual.value = "off";
	  var DateFrom = objFormular.twf_start_dt.value;
		DateFrom = DateFrom.substring(DateFrom.indexOf(",")+1,DateFrom.length);
		var TimeFrom = objFormular.start_dt_time.value;

		var DateTo = objFormular.twf_end_dt.value;
		DateTo = DateTo.substring(DateTo.indexOf(",")+1,DateTo.length);
		var TimeTo = objFormular.end_dt_time.value;
		self.durationiframe.location.replace(URL + "?start_dt=" + DateFrom + "&start_dt_time=" + TimeFrom + "&end_dt=" + DateTo + "&end_dt_time=" + TimeTo + "&fieldchange=" + iframecheckbox.name + "&value_durationmanual=off&OQS=" + durationiframe.ssid);	
	}
}



// ===============================================================================================================================
//	Wandelt die Dauer bei Fokuserhalt in eine Kommazahl um
// ===============================================================================================================================
function ConvertDurationOnFocus(AObjDuration, AObjDurationTWF, IsHoliday) {
	if (IsHoliday.toLowerCase() == "true"){
		AObjDuration.value = AObjDurationTWF.value;
		AObjDuration.select();
	}
	else{
		var lDuration = ((AObjDurationTWF.value).replace(/,/,"."))*24*60;
		// Stunden
		var lHours = parseInt(lDuration/60);
	
		// Minuten
		var lMinutes = Math.round(lDuration - (lHours*60));
	
		// mit 0 auffüllen
		lHours = fillZero(lHours);
		if (String(lMinutes).length == 1){
			lMinutes = "0" + lMinutes;
		}

		AObjDuration.value = lHours + ":" + lMinutes;
		AObjDuration.select();
	}
}

// ===============================================================================================================================
//	Wandelt die Dauer bei Fokuserhalt in eine Kommazahl um
// ===============================================================================================================================
function SendDurationOnBlur(AObjDuration, objFormular, URL, isDurationManual) {

	var DateFrom = objFormular.twf_start_dt.value;
	DateFrom = DateFrom.substring(DateFrom.indexOf(",")+1,DateFrom.length);
	var TimeFrom = objFormular.start_dt_time.value;
	
	lDurationManual = "off";
	if (isDurationManual != null) {
		if (isDurationManual.checked){
			lDurationManual = "on";
		}
	}
	durationiframe.location.replace(URL + "?start_dt=" + DateFrom + "&start_dt_time=" + TimeFrom + "&value_durationmanual=" + lDurationManual + "&duration=" + AObjDuration.value + "&fieldchange=" + AObjDuration.name + "&OQS=" + durationiframe.ssid);
}



// ===============================================================================================================================
//
// ===============================================================================================================================
function fillZero(aNumber) {
  if(aNumber<10) {
    return "0" + aNumber;
    }
  else {
    return aNumber;
  }
}


// ===============================================================================================================================
//	prüft auf eine gültige Kommazahl
// ===============================================================================================================================
function CheckFloat(objInput, Precision, Scale, ErrorStr, ErrorPrecision, ErrorScale){
  FInvalidValues = false;
  var lValue = objInput.value;
  lValue = (lValue).replace(/,/,".");
  if (isNaN(lValue)) {
    FInvalidValues = true;
    alert(ErrorStr);
    objInput.focus();
    objInput.select();
    return;
  }
  
	if (Scale != ""){
	  var lFloatArray = (lValue).split(".");
		// Precision überschritten
	  if (lFloatArray[0].length > parseInt(Precision)){
		  FInvalidValues = true;
			alert(ErrorPrecision);
	    objInput.focus();
		  objInput.select();
			return;
	  }
		// Scale überschritten
	  if (lFloatArray[1] != null){
			if (lFloatArray[1].length > parseInt(Scale)){
				FInvalidValues = true;
				alert(ErrorScale);
				objInput.focus();
				objInput.select();
		    return;
			}
		}
	}
}



//===========================================================================
// CompareNumbers
//===========================================================================
//
//  Description:
//    Vergleicht zwei Ganzzahlen beliebiger Größe
//
//  Parameters:
//    number1
//    number2
//      Die beiden Zahlen, die verglichen werden sollen.
//      Es können Strings übergeben werden.
//      Erlaubt sind ausschließlich ganze Zahlen.
//      Leere Parameter werden als 0 interpretiert.
//
//  Return value:
//    <0 num1 ist kleiner als num2 
//     0 num1 ist gleich num2 
//    >0 num1 ist größer als num2 
//
//===========================================================================
function CompareNumbers(number1, number2)
{
    var re = /^\s*([\+\-]?)0*(\d*)/;
    // Beide Nummern in Vorzeichen und eigentliche Zahl teilen
    res = re.exec(number1);
    if(!res) return 0;
    var num1_neg = (res[1] == "-");
    var num1 = res[2];
    if(num1 == "") num1 = "0";
    res = re.exec(number2);
    if(!res) return 0;
    var num2_neg = (res[1] == "-");
    var num2 = res[2];
    if(num2 == "") num2 = "0";
    if(!num1_neg && !num2_neg)
    {
        // Längere/kürzere Zahl muss größer/kleiner sein
        if(num1.length > num2.length)
            return 1;
        if(num1.length < num2.length)
            return -1;
        // Bei gleicher Länge können Zahlen
        // alphabetisch verglichen werden
        if(num1 > num2)
            return 1;
        if(num1 < num2)
            return -1;
        // Zahlen sind gleich
        return 0;
    }
    else if(num1_neg && !num2_neg)
    {
        // Negative Zahl ist kleiner
        return -1;
    }
    else if(!num1_neg && num2_neg)
    {
        // Negative Zahl ist kleiner
        return 1;
    }
    else
    {
        // Wie oben, nur ist die größere Zahl
        // diesmal kleiner, da sie negativ ist
        if(num1.length > num2.length)
            return -1;
        if(num1.length < num2.length)
            return 1;
        if(num1 > num2)
            return -1;
        if(num1 < num2)
            return 1;
        return 0;
    }
}

// ===============================================================================================================================
//	prüft auf einen gültigen Integer
// ===============================================================================================================================
function CheckNumber(objInput, lMinValue, lMaxValue, ErrorStr)
{
	FInvalidValues = false;
	if (isNaN(objInput.value)) {
	    FInvalidValues = true;
	    alert(ErrorStr);
	    objInput.focus();
	    objInput.select();
	    return;
	}
  
	if( (lMinValue != "") && (lMaxValue != "") ){
		if(CompareNumbers(objInput.value, lMinValue) < 0 ||
			CompareNumbers(objInput.value, lMaxValue) > 0)
		{
			FInvalidValues = true;
			alert(ErrorStr);
			objInput.focus();
			objInput.select();
			return;
		}
	}
}


// ===============================================================================================================================
//
// ===============================================================================================================================
function CheckWorkingPercent(objInput, ErrNotValidNumber, ErrValidBetween)
{
  FInvalidValues = false;
  var lValue = objInput.value;

  if (lValue == "") {
    FInvalidValues = true;
    alert(ErrNotValidNumber);
    objInput.value = "50";
    objInput.focus();
    return false;
  }
  else if (isNaN(lValue)) {
    FInvalidValues = true;
    alert(ErrNotValidNumber);
    objInput.focus();
    return false;
  }
  else if ( (lValue < 0) || (lValue > 100) || (lValue.indexOf(".") != -1) ) {
    FInvalidValues = true;
    alert(ErrValidBetween);
    objInput.focus();
    return false;
  }
  else {
    return true;
  }
}



// ===============================================================================================================================
//
// ===============================================================================================================================
function CheckDisplayModusFile(ASelectObj, AValue, lFileUpload, aObjInput, MsgNoFileUpload, NoRightMsg)
{
  var objDivUrl = GetObjDiv("fileUrl");
  var objDivArchive = GetObjDiv("fileArchive");
  AValue = AValue.toUpperCase();
  if (AValue.indexOf('ARCHIVE')>-1) {
    objDivUrl.style.display = "none";
    if (lFileUpload == "true"){
      objDivArchive.style.display = "inline";
    }
    // Es besteht keine Berechtigung für einen Dateiupload (portal.xml)
    else{
      objDivArchive.style.display = "none";
      alert(MsgNoFileUpload);
    }
    if (aObjInput != null){
	    aObjInput.value="";
	  }
  }
  else if (AValue.indexOf('URL')>-1) {
    if ((aObjInput != null) && (!aObjInput.readOnly)){
	    objDivUrl.style.display = "inline";
		  objDivArchive.style.display = "none";
	    aObjInput.value="http://";
	  }
	  else{
			alert(NoRightMsg);
			ASelectObj.options[0].selected = true;
			CheckDisplayModusFile(ASelectObj, ASelectObj.options[0].value, lFileUpload, aObjInput, MsgNoFileUpload, NoRightMsg);
	  }
  }
  else if (AValue.indexOf('MEMO')>-1) {
    objDivUrl.style.display = "none";
    objDivArchive.style.display = "none";
    if (aObjInput != null){
			aObjInput.value="";
		}
  }
}

//////// Öffnen des Div Windows mit Drag & Drop  für IE /////////

var dxDiv = 0, dyDiv = 0;
var currentDiv = null;
var objDiv = null;

// ===============================================================================================================================
//	Ansprache eines Objekts
// ===============================================================================================================================
function GetObjDiv( objName ) {
  if ( isW3C ) {
    var objDiv = document.getElementById(objName);
  }
  else if ( isIE ) {
    var objDiv = document.all[objName];
  }
  else {
    var objDiv = document.all[objName];
  }
  return objDiv;
}

// ===============================================================================================================================
//  
// ===============================================================================================================================
function OpenDivForm( objName, imgName, ImgPathOpen, ImgPathClose, divName, OpenStr, CloseStr ) {
     objDiv = GetObjDiv( objName );
     var objTextChange = GetObjDiv( divName );
     var imgChangeOpen = new Image();
     imgChangeOpen.src = ImgPathOpen;
     var imgChangeClose = new Image();
     imgChangeClose.src = ImgPathClose;

// wird nur gebraucht, wenn ein Feld ein, das andere Ausgeblendet wird
//     var TextFieldName = objName + "Textfield";
//     var objTextField = GetObjDiv( TextFieldName );

  if (isW3C)  {
     if (objDiv.style.display == "none") {
       objDiv.style.display = "inline";
     }
  }
  else {
     if (objDiv.style.display == "none") {
       objDiv.style.display = "inline";
       document.images[imgName].src = imgChangeClose.src;
       objTextChange.innerHTML = CloseStr;
     }
     else {
       objDiv.style.display = "none";
//       objTextField.style.display = "inline";
       document.images[imgName].src = imgChangeOpen.src;
       objTextChange.innerHTML = OpenStr;
     }
  }
}



// ===============================================================================================================================
// Benachrichtigungen aus der Liste löschen     /////////
// ===============================================================================================================================
function DeleteNotices( aDialogMsg, AUrl ) {
  Check = confirm(aDialogMsg);
  if(Check == true){
    location.href = AUrl + "&DeleteMessage=on";
  }
}


// ===============================================================================================================================
//  Macht die Datumsauswahl sichtbar
// ===============================================================================================================================
function ShowDatePicker( AURL, AobjInput, AobjFormular, ATablename, ASetDuration, Acommand, TagID, id) {
  var lURI = "";
  if (document.forms[AobjFormular] != null){
		if (document.forms[AobjFormular].elements !=  null){
			if (document.forms[AobjFormular].elements[AobjInput] != null){
				var ASelDate = eval("document." + AobjFormular + "." + AobjInput +".value");
				lURI = AURL + "?objInput="+ AobjInput + "&objFormular=" + AobjFormular + "&SetDuration=" + ASetDuration + "&command=" + Acommand + "&tablename=" + ATablename + "&dpsd=" + ASelDate + "&SelectDateedp=" + ASelDate + "&id=" + id + "&TagID=" + TagID;
			}
		}
	}
	return(lURI);
}


// ===============================================================================================================================
//
// ===============================================================================================================================
function ignoreErrors() {
  return true;
}

// ===============================================================================================================================
//
// ===============================================================================================================================
function setHiddenFields(FormName, MyTagId) {
  StartDate = "StartDate" + MyTagId;
  SelectDate = "SelectDate" + MyTagId;
  DatePicker_Startdt = "DatePicker_Startdt" + MyTagId;
  document.forms[FormName].elements[SelectDate].value = document.forms[FormName].elements[StartDate].value;
  document.forms[FormName].elements[DatePicker_Startdt].value = document.forms[FormName].elements[StartDate].value;
}


// ===============================================================================================================================
// Textarea Textlängenbegrenzung ////////////////////
// ===============================================================================================================================
function CheckLength(objTextArea, MaxLength)
{
  StrLength=objTextArea.value.length;
  if ( (StrLength == 1) && (objTextArea.value.substring(0,1)==" ") )
  {
    objTextArea.value = ""; 
    StrLength = 0;
  }
  if ( StrLength > MaxLength )
  {
  objTextArea.value = objTextArea.value.substring( 0, MaxLength );
  CharLeft=0;
  }
  else
  {
    CharLeft = MaxLength - StrLength;
  }
}


// ===============================================================================================================================
// Value der Checkbox setzen  ////////////////////////
// ===============================================================================================================================
function SetCheckboxValue(objCheckbox, objHidden){
  if (objCheckbox.checked){
    objHidden.value = 'on';
  }
  else{
    objHidden.value = 'off';
  }
}


// ===============================================================================================================================
//	SetPrivateStatus
// ===============================================================================================================================
function SetPrivateStatus(objCheckbox, objExternalAccess, objHidden) {
	// value der Checkbox muss in Hidden-Feld gesetzt werden, nur dieses wird beim Speichern ausgelesen
  if (objCheckbox.checked){
		objHidden.value = -1;
		if (objExternalAccess != null){
			for(i = 0; i < objExternalAccess.options.length; i++) {
				if(objExternalAccess.options[i].value == -1){
					objExternalAccess.options[i].selected;
					objExternalAccess.selectedIndex = i;	
					break;			
				}
			}
		}
  }
  else{
		objHidden.value = 65535;
		for(i = 0; i < objExternalAccess.options.length; i++) {
			if (objExternalAccess != null){
				if(objExternalAccess.options[i].value == 65535){
					objExternalAccess.options[i].selected;
					objExternalAccess.selectedIndex = i;		
					break;		
				}
			}
		}
  }
}


// ===============================================================================================================================
//	setExternalAcess
// ===============================================================================================================================
function setExternalAcess(objExternalAccess, objTeamArray, objHidden, ErrorStr){
	lTeamArray = '';
	if (objTeamArray != null){
		lTeamArray = (objTeamArray.value).toUpperCase();
	}
	// befindet sich der Teilnehmer "Alle (Öffentlich)" ist der Teilnehmerauswahl, 
	// darf vertraulich/persönlich nicht gesetzt werden
	if (lTeamArray.indexOf('0X00000000000000000000000000000000') > -1){
		if ((objExternalAccess.value == '-1') || (objExternalAccess.value == '0')){
			alert(ErrorStr);
			for(i = 0; i < objExternalAccess.options.length; i++) {
				// zurücksetzen auf vorherigen Wertd -> noch im Hiddenfeld gespeichert
				if(objExternalAccess.options[i].value == objHidden.value){
					objExternalAccess.options[i].selected;
					objExternalAccess.selectedIndex = i;	
					break;			
				}
			}
		}
		else{
			// Value ins Hidden-Feld setzen
			objHidden.value = objExternalAccess.value;
		}
	}
	// Value ins Hidden-Feld setzen
	objHidden.value = objExternalAccess.value;
}

// ===============================================================================================================================
// ///////////////////////  CheckTelephoneNumber  ////////////////////////
// ===============================================================================================================================
function CheckTelephoneNumber(lobjInput, ErrorStr)
{
  FInvalidValues = false;
  var ok = true;
  var aTelephoneValue = lobjInput.value;
  for(i = 0; i < aTelephoneValue.length; i++) {
    var SingleChar = aTelephoneValue.substring(i, i+1);
    if(isNaN(SingleChar) == true){
      if (SingleChar != "("  &&  SingleChar != ")"  &&  SingleChar != "/"  &&  SingleChar != "."  &&  SingleChar != "+"  &&  SingleChar != "-"){
        ok=false;       
      }
    }
  }
  if(ok==false){
    FInvalidValues = true;
    alert(ErrorStr);
    lobjInput.focus();
    lobjInput.select();
    return false;			  
  }
}


/////////////////////////  checkFillOut  ////////////////////////

// ===============================================================================================================================
// überprüft ob ein Pflichtfeld einen Wert hat.
// ===============================================================================================================================
function checkFillOut(objForm, lFields, lErrorMessage)
{
  var lReturn ="";
  var arrFields = new Array();
  arrFields = lFields.split(",");

  for(var i=0; i < arrFields.length-1; i++) {
    if ( objForm.elements[arrFields[i]] != null ) {
      var lValue = objForm.elements[arrFields[i]].value;
      if (lValue == "") {
        objForm.elements[arrFields[i]].focus();
        lReturn = lReturn + false;
      }
      else {
        lReturn = lReturn + true;
      }
    }
    else {
      lReturn = lReturn + false;
    }
  }

  if (lReturn.indexOf("false")> -1) {
    alert(lErrorMessage);
    return false;
  }
  else {
    return true;
  }
  
}


/////////////////////////  checkRTF  ////////////////////////

// ===============================================================================================================================
// überprüft ob rtf vorhanden war und der Text nun geändert werden soll
// ===============================================================================================================================
function checkRTF(objForm, aNotes2Name) {
  // handelt es ursprünglich sich um einen rtf-codierten Text
  if ( ( objForm.OriginalText != null ) && ( aNotes2Name != "" ) ) {
    lOriginalString = objForm.OriginalText.value;

    lTempString = GetObjDiv(aNotes2Name).value;
    // ChangeRTF = true: nur wenn Texte unterschiedlich, wird Notizfeld gespeichert
    if (lOriginalString != lTempString){
      objForm.ChangeRTF.value = "true";
    }
  }
}

// ===============================================================================================================================
// zeigt an, dass im Notizfeld rtf-Formatierungen vorhanden sind
// ===============================================================================================================================
function showRTFHint(DialogMsg){
	if (FShowRTFHint){
		alert(DialogMsg);
		// Hinweis soll nur einmal und nicht bei jedem Fokuserhalt angezeigt werden
		FShowRTFHint = false;
	}
}


// ===============================================================================================================================
// Macht die Schnelleingabe in den Listen sichtbar
// ===============================================================================================================================
function showQuickInputList(objDivInput, objDivString, objInput){
	if (GetObjDiv(objDivInput).style.display == "none") {
		GetObjDiv(objDivInput).style.display = "block";
		GetObjDiv(objDivString).style.display = "none";
	}
	objInput.focus();
}

// ===============================================================================================================================
// Urlaubsverwaltung: Setzt Filterjahr und sendet Formular ab
// ===============================================================================================================================
function setHolAllocationFilter(objForm, aValue){
	objForm.AllocationYear.value = aValue;
	objForm.submit();
}


// ===============================================================================================================================
// Benachrichtigungen: Wenn keine Benachrichtigungen erwünscht sind, werden alle Checkboxen disabled
// ===============================================================================================================================
function setDisabledFields(IsChecked, objForm, aActiveFields){
	// alle Formularfelder bis auf die erste Checkbox durchlaufen und disablen
	// length-2, da Buttons nicht disabled werden sollen
	var isActiveField = false;
	aActiveFieldsArr = aActiveFields.split(',');
	if (IsChecked){
		for (var i = 0; i < objForm.elements.length; i++) {
			for (var j = 0; j < aActiveFieldsArr.length;  j++){
				if (objForm.elements[i].name.toUpperCase() == aActiveFieldsArr[j].toUpperCase()){
					isActiveField = true;
					break;
				}
			}
			if (!isActiveField){
				objForm.elements[i].disabled = false;
			}
			else{
				isActiveField = false;
			}
		}
	}
	else{
		for (var i = 1; i < objForm.elements.length; i++) {
			for (var j = 0; j < aActiveFieldsArr.length;  j++){
				if (objForm.elements[i].name.toUpperCase() == aActiveFieldsArr[j].toUpperCase()){
					isActiveField = true;
					break;
				}
			}
			if (!isActiveField){
				objForm.elements[i].disabled = true;
			}
			else{
				isActiveField = false;
			}
		}
	}
}


// ===============================================================================================================================
// prüft, ob in einer eingegebenen eMail-Adresse das @ vorkommt
// ===============================================================================================================================
function checkValidEMail(aObj, aValidMailMessage) {
  if ( aObj.value.search(/@/) == -1 ) {
    alert(aValidMailMessage);
    aObj.focus();
    aObj.select();
  }
}


// ===============================================================================================================================
// prüft, ob die bei Benachrichtigungen eingegebene E-Mail-Adresse gültig ist
// Gilt nur, wenn Benachrichtigungen erwünscht sind
// ===============================================================================================================================
function checkValidEMailNotify(aObj, aCheckBox, aValidMailMessage) {
  if (aCheckBox.checked){
		checkValidEMail(aObj, aValidMailMessage)
	}
}

          

// ===============================================================================================================================
// !!!!! Sowohl Kategorien als auch Teilnehmer !!!!!
// Befüllt das Textfeld bei jeder Änderung in den SelectBoxen
// ===============================================================================================================================
function AddOptionValues( objSelectedValues, objTextArea, objForm, Fieldname, HintStr) {

  // ++++++++++++++++++++++++++++++++++++++
  // Deklarationen 
  var SelectedValues = '';
  var lFieldname = Fieldname.toUpperCase();
  var textAreaName = objTextArea;
  var teamString = "";
  // ++++++++++++++++++++++++++++++++++++++

  if (lFieldname.indexOf("PARTICIPANTS") == -1) {
    objTextArea.value = '';
    for ( var i=0; i < objSelectedValues.length; i++) {
      SelectedValues = SelectedValues + objSelectedValues.options[i].value + ', ';
    }
    SelectedValues = SelectedValues.substring(0, SelectedValues.length-2)
    objTextArea.value = SelectedValues;
  }
  else {
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // Teilnehmer und Resourcen aus drei Feldern zusammen abspeichern
    // Die Selectbox mit den ausgewählten Teilnehmern bzw. Ressourcen gibt es 3x im Formular
    // es reicht jedoch, nur eine (Users) zu prüfen, da alle drei mit den gleichen Werten befüllt sind
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	  var AllTeamsString = GetAllTeamsString(objForm);
    var objSelectedValuesUser = objForm.Participants1Selected;
    var SelectedValuesUser = '';

    if ( ( objSelectedValuesUser.length == 1) && (objSelectedValuesUser.options[0].value == '') ) {
      return;
    }
    else {
	    for ( var i=0; i < objSelectedValuesUser.length; i++) {
        SelectedValuesUser = SelectedValuesUser + objSelectedValuesUser.options[i].text + FCommaSep;

        var SelectedValueUser = objSelectedValuesUser.options[i].value;
        var SelectedTextUser = objSelectedValuesUser.options[i].text;
        var lGuid = objSelectedValuesUser.options[i].value.toUpperCase();

        if (IsUser(SelectedValueUser, objForm, AllTeamsString)) {
          teamString = teamString + SelectedValueUser + FCommaSep + SelectedTextUser + FCommaSep + "U" + FCommaSep + GetPermission(SelectedValueUser, 'U', objForm) + FSemicolonSep;
        }
        else if (IsInvitedUser(SelectedValueUser, objForm, AllTeamsString)) {
          teamString = teamString + SelectedValueUser + FCommaSep + SelectedTextUser + FCommaSep + "UI" + FCommaSep + GetPermission(SelectedValueUser, 'U', objForm) + FSemicolonSep;
        }
        else if (IsGroup(SelectedValueUser, objForm, AllTeamsString)) {
          teamString = teamString + SelectedValueUser + FCommaSep + SelectedTextUser + FCommaSep +"GU" + FCommaSep + GetPermission(SelectedValueUser, 'GU', objForm) + FSemicolonSep;
        }
        else if (IsRessourceGroup(SelectedValueUser,objForm, AllTeamsString)) {
          teamString = teamString + SelectedValueUser + FCommaSep + SelectedTextUser + FCommaSep + "GR" + FCommaSep + GetPermission(SelectedValueUser, 'GR', objForm) + FSemicolonSep;
        } 
        else if (IsRessource(SelectedValueUser, objForm, AllTeamsString)) {
          teamString = teamString + SelectedValueUser + FCommaSep + SelectedTextUser + FCommaSep + "R" + FCommaSep + "1" + FSemicolonSep;
        }
      }
    }

    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    //  hier wird das Inputfeld mit Werten befüllt
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    SelectedValues = SelectedValuesUser;
    if (SelectedValues != "") {
      SelectedValues = SelectedValues.substring(0, SelectedValues.length-3)
    }

    
    // Teilnehmer im Hiddenfeld speichern 
    objForm.elements[textAreaName + 'Hidden'].value = SelectedValues;

    // Teilnehmer zur Anzeige aufbereiten (kommasepariert)
    // Hat ein Teilnehmer ein Komma/Semikolon im Namen, wird der name in '' gesetzt
		var lSelectedArray = new Array();
    lSelectedArray = SelectedValues.split(FCommaSep);
    for (var i=0; i < lSelectedArray.length; i++){
			if ((lSelectedArray[i].indexOf(",") > -1) || (lSelectedArray[i].indexOf(";") > -1)) {
				lSelectedArray[i] = " '" + lSelectedArray[i] + "'";
			}
			else{
				lSelectedArray[i] = " " + lSelectedArray[i];
			}
    }
		
    objForm.elements[textAreaName].value = lSelectedArray;
    // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


    if (teamString != "") {
      teamString = teamString.substring(0, teamString.length-3);
    }
		objForm.twg_teamArray.value = teamString;
  }

  if (lFieldname.indexOf("PARTICIPANTS") > -1) {
	checkPartiOnPrivate(objForm, HintStr)
  }

}

// ===============================================================================================================================
//	setzt den Fokus in der aufklappbaren Combobox (Teilnehmer, Kategorien)
// ===============================================================================================================================
function setFocusOnSelOption( objAllValues, objForm, lInfoField ) {

  // In der Teilnehmerauswahl muss zuerst geprüft werden welches Div sichtbar ist
  // auf unsichtbare Elemente kann kein Fokus gesetzt werden und es kommt zum Fehler
  if ((lInfoField.name).toLowerCase().indexOf("participants") != -1){
    if(GetObjDiv('user').style.display == "inline") {
			objAllValues = objForm.Participants1All;
    }
    else if(GetObjDiv('group').style.display == "inline") {
			objAllValues = objForm.Participants2All;
    }
    else if(GetObjDiv('ressource').style.display == "inline") {
			objAllValues = objForm.Participants3All;
    }
  }
  
  if (objAllValues.options[0] != null) {
    if (lInfoField.value == "true"){
		objAllValues.options[0].selected = true;
		objAllValues.focus();
		lInfoField.value = "false";
	}
	else{
		lInfoField.value = "true";
	}
  }
}

// ===============================================================================================================================
// befüllt die Liste der selektierten Werte
// ===============================================================================================================================
function FillSelOptionList(objTextArea, objSelectedValues, objAllValues, objForm) {
  var SelText = objTextArea.value;
  var SelOptionValue = '';
  var i = 0;
  // Befüllen der linken Auswahlbox alle Kategorien
  FillAllOptionList( objForm, objAllValues, objSelectedValues );
  if (SelText == '' ) {
    return;
  }
  else if ( SelText.indexOf(',') == -1 ) {
    objSelectedValues.options[0] = new Option(SelText,SelText,false,true);
    return;
  }
  else {

    SelOptionValue = SelText.split(",");
    for ( var i=0; i < SelOptionValue.length; i++) {
      SelText = SelOptionValue[i];
      // Leerzeichen am Anfang des Strings entfernen
      if ( (SelText.charCodeAt(0) == 160 ) || (SelText.charCodeAt(0) == 32 )) {
        SelText = SelText.substring(1, SelText.length);
      }
      objSelectedValues.options[i] = new Option(SelText, SelText);
    }
    return;
  }
  
}


// ===============================================================================================================================
// befüllt die Liste mit allen Werte
// ===============================================================================================================================
function FillAllOptionList(objForm, objAllValues, objSelectedValues) {
  AllValueUpperCase = "";
  var SelCategory = "";

  // mehrere Kategorien gewählt
  if (objSelectedValues.length > 1) {
    for( var i=0; i<objSelectedValues.length; i++){
      SelCategory = SelCategory + objSelectedValues.options[i].value + ", ";
    }
  }
  // nur eine Kategorie gewählt
  else if (objSelectedValues.length == 1){
    SelCategory = objSelectedValues.value;
  }
  // bereits verausgewählte Kategorien bei vorhandenem Datensatz
  else {
    SelCategory = objForm.elements['CategorySelList'].value;
  }

  var AllCategories = objForm.elements['CategoryList'].value;
  var AllCategoryArray = AllCategories.split(",");

  SelCategory = SelCategory.toUpperCase();
  
  // damit beim Öffnen und Schließen nicht jedes mal die Kategorien hinzugefügt werden
  objAllValues.length = 0;
  
  for ( var i=0; i < AllCategoryArray.length; i++) {
    AllValueUpperCase = AllCategoryArray[i].toUpperCase();
    if ( SelCategory.indexOf(AllValueUpperCase) == -1 ) {
      CreateNewOptionEntry( objAllValues, AllCategoryArray[i], AllCategoryArray[i]);
    }  
  }
  // Wenn eine Multiauswahl in der SelectBox aktiviert wurde, dann muss der SelectedIndex der Box zurückgesetzt werden, sonst 
  // sind alle Werte in der SelectBox vorausgwählt.
  objAllValues.selectedIndex = -1;
}


// ===============================================================================================================================
// Bei neuen Terminen muss Periodenbeginn = Beginn sein
// gehört zwar zu periodscripts.js, der DatePicker nutzt diese Funktion jedoch auch, weiß aber 
// nicht, ob ein Wiederholungsschema auf dem Formular liegt
// ===============================================================================================================================
function setPeriodStart(objForm){
  if (objForm.twf_PeriodStart != null){
    objForm.twf_PeriodStart.value = objForm.twf_start_dt.value;
    objForm.twf_PeriodEnd.value = objForm.twf_start_dt.value;
  }
}



// ===============================================================================================================================
// setzt die Vorauswahl der Zeit-Selectbox im TimePicker 
// ===============================================================================================================================
function setSelectedTime(objForm, objInputName, objInputFrame, aID) {
	if (objForm != null){
		if (objForm.elements != null){
			if (objForm.elements[objInputName] != null){
				var lTimeValue = objForm.elements[objInputName].value;
				if (lTimeValue == "24:00"){
					Hours = 24;
					Minutes = fillZero(0);
				}
				else{
					var newDate = stringToTime(lTimeValue);
					var Hours = fillZero(newDate.getHours());   
					var Minutes = newDate.getMinutes();
	
					// auf 30 Minuten runden
					Minutes = fillZero((Math.round(Minutes/30)*30));
					if (Minutes == 60){
						Minutes = 30;
					}
				}
					var lValue = Hours + ":" +Minutes;
					for(var i=0; i < objInputFrame.length; i++) {
					if (objInputFrame.options[i].value == lValue){
						objInputFrame.options[i].selected;
						objInputFrame.selectedIndex = i;
						break;
					}
				}
			}
		}
	}
}