/************************************************************/
/*  formular_validation.js                                  */
/************************************************************/
/************************************************************/
/*   CUSTOMIZE AREA                                         */
/************************************************************/

    /**
     *  Initialisierung Tipp Array
     */
    var Tipp = new Array;
    
    /**
     * ID for tooltip divcontainer
     */
    var tooltipformid = "tooltipform";
    
    /**
     *  Globale Konstante mit dem Typ der MSGKONST
     *  wird verwendet fuer die Ausgabe von Meldungen
     */
    var TYPMSGKONST = "";
    
    /**
     *  Geotargeting: falls mehrere Orte zu einer PLZ bestehen wird die ausgewaehlte PLZ 
     *  in diese Variable abgespeichert
     */
    var chooseplz = "";
    
    /**
     *  Geotargeting: Standard Wert der in den Ort eingefügt wird falls keiner gefunden wird
     */
    var myplace = "Unbekannter Wohnort";
    
    
/************************************************************/
/* DON'T CHANGE ANY LINES BELLOW                            */
/************************************************************/



/**
 * Fehler Meldungen unterdruecken
 */
function oe()
{	return true;
}
window.onerror = oe;


/**
*   Methode:
*   LTrim =         Entfernt whitespaces am anfang des Textes
*
*   Params:
*   str =           Zu bereinigender String
*
*   Return:     
*   str =           Bereinigter String um whitespaces
*/
function LTrim(str)
{   var whitespace = new String(" \t\n\r");
    var s = new String(str);
    if (whitespace.indexOf(s.charAt(0)) != -1) 
    {   var j=0, i = s.length;
        while (j < i && whitespace.indexOf(s.charAt(j)) != -1)
        {   j++;
        }
        s = s.substring(j, i);
    }
    return s;
}
/**
*   Methode:
*   RTrim =         Entfernt whitespaces am ENDE des Textes
*
*   Params:
*   str =           Zu bereinigender String
*
*   Return:     
*   str =           Bereinigter String um whitespaces
*/

function RTrim(str)
{   var whitespace = new String(" \t\n\r");
    var s = new String(str);
    if (whitespace.indexOf(s.charAt(s.length-1)) != -1) 
    {   var i = s.length - 1;
        while (i >= 0 && whitespace.indexOf(s.charAt(i)) != -1)
        {   i--;
        }
        s = s.substring(0, i+1);
    }
    return s;
}

/**
*   Methode:
*   Trim =          Entfernt whitespaces am Anfang und Ende des Textes
*
*   Params:
*   str =           Zu bereinigender String
*
*   Return:     
*   str =           Bereinigter String um whitespaces
*/
function Trim(str)
{   return RTrim(LTrim(str));
}

/**
*   Methode:
*   isUrl =         Prueft ob übergebener String eine valide URL ist
*   
*   Params:
*   s =             Urls String
*   
*   Return:
*   boolean
*/

function isUrl(s)
{   if (s)
	{	var regexp = /(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?/
		return regexp.test(s);
	}
	return true;	
}

/**
*   Methode:
*   Validator =     Formlar Konstruktor
*
*   Params:
*   frmname =       Formularname
*   fcontainer =    Container fuer Quicktipps
*   msgfield =      Ausgabefeld fuer MSgfields
*
*   Return:     
*   null =          (Setzen der Formobjekte)
*/
function Validator(frmname, fcontainer, msgfield)
{
	this.formobj=document.forms[frmname];
	this.frmname=frmname;
	
    this.container = msgfield;
    
    if (!this.formobj)
	{  getMSG("E_OBJECT_FORM|"+frmname);
	   return;
	}
	
	if (this.formobj.onsubmit)
	{   this.formobj.old_onsubmit = this.formobj.onsubmit;
	    this.formobj.onsubmit=null;
	    
	    
	    
	}
	else
	{   this.formobj.old_onsubmit = null;
	}
	this.formobj.onsubmit=form_submit_handler;

	this.setFormMessage = setFormMessage;
	this.addValidation = add_validation;
	this.V2validateData = V2validateData;
	this.addDateValidation = add_datevalidation;
	this.setAddnlValidationFunction=set_addnl_vfunction;
	this.clearAllValidations = clear_all_validations;

    // Wenn Msgcontainer vorhanden sind, diese Standardmäßig ausblenden	
	if (document.getElementById(msgfield))
	{  var msgcontainer = document.getElementById(msgfield);
	   // Container ausblenden
	   msgcontainer.className = "msgfieldtext";
	   // Uebergeordneter Container ausblenden
	   if (document.getElementById(msgfield+"form"))
	   {   var msgcontainerform = document.getElementById(msgfield+"form");
           msgcontainerform.className = "msgfieldcontainer";
	   }    
	}

	/**
	 *	PHP Fehlerbehandlung
	 *
	 **/
	if (typeof( window[ 'PHP_FORM_MSG' ] ) != "undefined")
	{	if ((PHP_FORM_MSG != "") &&  isArray(PHP_ERRORFIELD))
		{   var msgcontainer = "";
			if (typeof( window[ 'PHP_FORM_MSGCONTAINER' ] ) != "undefined")
			{	msgcontainer = PHP_FORM_MSGCONTAINER;
			}
			getMSG(PHP_FORM_MSG,msgcontainer, PHP_ERRORFIELD);
			PHP_FORM_MSG = false;
		}
	}	
}

function set_addnl_vfunction(functionname)
{   this.formobj.addnlvalidation = functionname;
}

function clear_all_validations()
{	for(var itr=0;itr < this.formobj.elements.length;itr++)
	{   this.formobj.elements[itr].validationset = null;
	}
}

/*  im form submit handler werden die einzelnen objekte des formulars durchgegangen und falls 
 *  es eine property valdiationset geben sollte wirds validiert
 *
**/
function form_submit_handler()
{   
	/**
	 * Zusaetzliche Onsubmits abarbeiten falls im Header vorhanden
	 */
	if (typeof additionalonsubmit=="function")
	{	additionalonsubmit();
	}
	
	for(var itr=0;itr < this.elements.length;itr++)
	{  	if (this.elements[itr].validationset &&
	        !this.elements[itr].validationset.validate())
	    {   
		   	 return false;
		}
	}
	
	if (this.addnlvalidation)
	{  	str =" var ret = "+this.addnlvalidation+"()";
	    eval(str);
        if(!ret) return ret;
	}
	
	
	return true;
}

/**
*   Methode:
*   add_validation          = Validierungsobject hinzuf?gen
*
*   Params:
*   itemname                = FormFieldName (id)
*   descriptor              = Validierungstyp
*   errstr                  = Koennte hier die PHP Fehlermeldung kommen ??
*   fieldforerrormessage    = Id of Errorfield
*
*   DEBUG: alert("Funktion 1 " + itemname + " " +descriptor + " " + fieldforerrormessage);
*/
function add_validation(itemname,descriptor,errstr,fieldforerrormessage)
{	if (!this.formobj)
	{	getMSG("E_OBJECT_FORMPROPERLY");
		return;
	}//if
	var itemobj = this.formobj[itemname];
    if (!itemobj)
	{   getMSG("E_OBJECT_INPUT|"+itemname);
		return;
	}
	if (!itemobj.validationset)
	{   itemobj.validationset = new ValidationSet(itemobj, this.container, fieldforerrormessage);
	}
	itemobj.validationset.add(descriptor,errstr);
}
/**
 * Date Validierung hinzufuegen
 */
function add_datevalidation(itemname, errstr, fieldforerrormessage, isdatetime)
{	if (!this.formobj)
	{	getMSG("E_OBJECT_FORMPROPERLY");
		return;
	}//if
	var itemobj = this.formobj[itemname+"1"];
	itemobj.m = this.formobj[itemname+"2"];
	itemobj.y = this.formobj[itemname+"3"];
	if (!itemobj || !itemobj.m || !itemobj.y)
	{   getMSG("E_OBJECT_DATE");
		return;
	}
    if(isdatetime)
    {   itemobj.h = this.formobj[itemname+"4"];
        itemobj.i = this.formobj[itemname+"5"];
        if (!itemobj.h || !itemobj.i)
        {   getMSG("E_OBJECT_DATETIME");
		    return;
        }
    }
	
	if (!itemobj.validationset)
	{   itemobj.validationset = new ValidationSet(itemobj, this.container, fieldforerrormessage);
	}
    if (isdatetime)
    {   itemobj.validationset.add("datetime",errstr);	
    }
    else
    {   itemobj.validationset.add("date",errstr);	
    }
}

function ValidationSet(inputitem, container, fieldforerrormessage)
{   this.vSet=new Array();
	this.add = add_validationdesc;
	this.validate = vset_validate;
	this.itemobj = inputitem;
	this.container = container;
	this.fieldforerrormessage = fieldforerrormessage;
}

/**
*   DEBUG: alert("Funktion 3| desc:" + desc + " error:" +error)
*/
function add_validationdesc(desc,error)
{   this.vSet[this.vSet.length] = new ValidationDesc(this.itemobj,desc,error,this.container,this.fieldforerrormessage);
}


/**
*   DEBUG: alert("Funktion 4 inputitem:" + inputitem + " containter:" + container + " desc:" + desc + " error:"+error + " fieldforerrormessage:" + fieldforerrormessage);
*/
function ValidationDesc(inputitem,desc,error,container,fieldforerrormessage)
{   this.desc=desc;
	this.error=error;
	this.itemobj = inputitem;
	this.validate=vdesc_validate;
	this.container=container;
	this.fieldforerrormessage = fieldforerrormessage
}

// after submit


/**
*   DEBUG: alert("Funktion 5")
*/

function vset_validate()
{   for(var itr=0;itr<this.vSet.length;itr++)
    {  if (!this.vSet[itr].validate())
	   {   return false;
	   }
	}
	return true;
}


/**
*   DEBUG: alert("Funktion 6\n nach Ausf?hren des Formulars\n desc:"+this.desc+" itemobject: " + this.itemobj.name + " error:"+ this.error + " container:"+ this.container + " fieldforerrormessage: "+ this.fieldforerrormessage);
*/

function vdesc_validate()
{   
	if (!V2validateData(this.desc,this.itemobj,this.error,this.container,this.fieldforerrormessage))
    {   
    	//if it's not a hidden element
		this.itemobj.focus();
    	
    	return false;
    }
    return true;
}




function validateEmailv2(email)
{   // a very simple email validation checking. 
    // you can add more complex email checking if it helps 
    if (email.length <= 0)
	{   return true;
	}
    var splitted = email.match("^(.+)@(.+)$");
    if (splitted == null) return false;
    if (splitted[1] != null )
    {   var regexp_user=/^\"?[\w-_\.]*\"?$/;
        if(splitted[1].match(regexp_user) == null) return false;
    }
    if (splitted[2] != null)
    {   var regexp_domain=/^[\w-\.]*\.[A-Za-z]{2,4}$/;
        if (splitted[2].match(regexp_domain) == null) 
        {   var regexp_ip =/^\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\]$/;
	        if (splitted[2].match(regexp_ip) == null) return false;
        }// if
        return true;
    }
    return false;
}

function expand_date(name)
{   // 2 stelliges jahr wird erweitert auf 4 stellig
	// schwellwert 50
	if (document.getElementsByName(name)[0].value.length>0 && document.getElementsByName(name)[0].value.length<=2)
	{   var year = parseInt(document.getElementsByName(name)[0].value);
	    var uval= 1900;
        var oval = 2000;
        if (year>50)
            year = year+uval;
        else
    	    year = year+oval;
	    document.getElementsByName(name)[0].value = year;
	}
}

/**
 *
 * 1 Datum richtig
 * 2 tag falsch
 * 3 monat falsch 
 * 4 jahr falsch
 *
 */
function validate_date(day, month, year)
{   
	var schaltjahr = 0;
    var errorcode = 4;
    var tage = new Array( 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
    
    
    // führende 0'en entfernen
    if (day.substr(0,1) == 0)
    {   day = day.substr(1,day.length);
    }
    if (month.substr(0,1) == 0)
    {   month = month.substr(1,month.length);
    }
    
    if (day=="tt" && month=="mm" && year == "yyyy")
    {  	return 1;
    }
    
    
    year=parseInt(year);
    month=parseInt(month);
    day=parseInt(day);
    
    if (isNaN(year))
    {   errorcode = 4;
    }
    if (isNaN(month))
    {   errorcode = 3;
    }
    if (isNaN(day))
    {   errorcode = 2;
    }
    
    if (year>1900 && year<3000)
	{   // schaltjahr pruefen
		if ((year%4==0 && year%100!=0)||(year%400==0))
		{   tage[2]+=1;			
		}
		errorcode = 3;
		if (month>0 && month<=12)
		{	errorcode = 2;
		    if ((day>0 && day<=tage[month] ) || (day>31 && day<1))
		    {	errorcode = 1;	
		    }
		}
	}
	return errorcode;
}
/**
* 5 = stunde falsch
* 6 = minute falsch
*/

function validate_time(hour,minute)
{   var errorcode = 5;
    if(isNaN(minute) || minute=="")
    {   errorcode = 6;
        return errorcode;
    }
    if(isNaN(hour) || hour=="")
    {   errorcode = 5;
        return errorcode;
    }
    if (hour>=0 && hour<24)
    {   errorcode = 6;
        if (minute>=0 && minute<60)
        {   errorcode = 1;
        }
    }
    return errorcode;
}


/**
*   Methode:
*   V2validateData          = ?berpr?ft ob parameter ein Array Objekt ist
*
*   Params:
*   strValidateStr          = zu ?berpr?fender Array
*   objValue                =
*   strError                = Fehlermeldung
*   container               = Container for Errormessages
*   fieldforerrormessage    = Fieldname for errormessage
*   DEBUG: alert("Funktion 7: fieldforerrormessage: " + fieldforerrormessage)
*/

function V2validateData(strValidateStr,objValue,strError, container,fieldforerrormessage) 
{   var  epos = strValidateStr.search("="); 
    var  command  = ""; 
    var  cmdvalue = "";
    var  iserror = 0;
    var  msgstr = "";
    var  strError = "";
    
    // Target form fields als Array f?r Multiple Formatierung
    var targetfields = new Array();
    targetfields[0] = objValue.name
    
    
    if (epos >= 0) 
    {   command  = strValidateStr.substring(0,epos); 
        cmdvalue = strValidateStr.substr(epos+1); 
    } 
    else 
    {   command = strValidateStr; 
    }
    
    // Fehler existiert 
    if (strError && strError.length !=0)
    {   return false;
    }   
    switch(command) 
    {   case "requireddate":
        {   
        	if ((eval(objValue.value.length) == 0)) // Tag Pflichfeld
            {   strError = "E_FORMFIELD_REQ|"+fieldforerrormessage;
            }
            else if((eval(objValue.m.value.length) == 0)) // Monat Pflichfeld
            {   strError = "E_FORMFIELD_REQ|"+fieldforerrormessage;
                targetfields[0] = (objValue.m.name);
            }  
            else if((eval(objValue.y.value.length) == 0)) // Monat Pflichfeld
            {   strError = "E_FORMFIELD_REQ|"+fieldforerrormessage;
                targetfields[0] = (objValue.y.name);
            }
            else if( objValue.h && (eval(objValue.h.value.length) == 0)) // Stunde Pflichfeld
            {   strError = "E_FORMFIELD_REQ|"+fieldforerrormessage;
                targetfields[0] = (objValue.h.name);
            }
            else if(objValue.i && (eval(objValue.i.value.length) == 0)) // Minute Pflichfeld
            {   strError = "E_FORMFIELD_REQ|"+fieldforerrormessage;
                targetfields[0] = (objValue.i.name);
            }
            else
            {   break;
            }
            break;
        }       
    	
        case "datetime":
        {   
        	if (objValue.h.value!="" || objValue.i.value!="")
            {   var charpos = objValue.h.value.search("[^0-9]");
    	    	if (objValue.h.value.length == 0 ||  charpos >= 0)
    	    	{	strError = "E_DATE_ONLYNUMBERS";
    	    	}
    	    	charpos = objValue.i.value.search("[^0-9]");
    	    	if (objValue.i.value.length == 0 ||  charpos >= 0)
    	    	{	strError = "E_DATE_ONLYNUMBERS";
    	    	}
                var timeerrorcode = validate_time(objValue.h.value,objValue.i.value);
                
                if (timeerrorcode != 1)
                {   switch(timeerrorcode)
    	    	    {     case 5:
    	    	          {   strError = "E_DATE_HOURNOTVALID|"+fieldforerrormessage;
    	    	              targetfields[0] = (objValue.h.name);    
    	    	              break;
    	    	          }
    	    	          case 6:
    	    	          {   strError = "E_DATE_MINUTENOTVALID|"+fieldforerrormessage;
    	    	              targetfields[0] = (objValue.i.name);    
    	    	              break;
    	    	          }
    	    	          default:
    	    	          {   break;
    	    	          }
    	    	    }
                    
                }
               
            } 
          
        }
        case "date":
    	{  
    		// ueberpruefen ob ein legaler wert in den feldern vorhanden ist
    	    if (objValue.value!="" || objValue.m.value!="" || objValue.y.value!="")
    	    {   var charpos = objValue.value.search("[^0-9]");
    	    	if (objValue.value.length == 0 ||  charpos >= 0)
    	    	{	strError = "E_DATE_ONLYNUMBERS";
    	    	}
    	    	charpos = objValue.m.value.search("[^0-9]");
    	    	if (objValue.m.value.length == 0 ||  charpos >= 0)
    	    	{	strError = "E_DATE_ONLYNUMBERS";
    	    	}
    	    	charpos = objValue.y.value.search("[^0-9]");
    	    	if (objValue.y.value.length == 0 ||  charpos >= 0)
    	    	{	strError = "E_DATE_ONLYNUMBERS";
    	    	}
    	    	
    	    	var errorcode = validate_date(objValue.value, objValue.m.value, objValue.y.value);
    	    	
    	    	
    	    	if (errorcode != 1)
    	    	{   switch(errorcode)
    	    	    {     case 2:
    	    	          {   strError = "E_DATE_DAYNOTVALID|"+fieldforerrormessage;
    	    	            	targetfields[0] = (objValue.name);  
    	    	          		break;
    	    	          }
    	    	          case 3:
    	    	          {   strError = "E_DATE_MONTHNOTVALID|"+fieldforerrormessage;
    	    	              targetfields[0] = (objValue.m.name);    
    	    	              break;
    	    	          }
    	    	          case 4:
    	    	          {   strError = "E_DATE_YEARNOTVALID|"+fieldforerrormessage;
    	    	              targetfields[0] = (objValue.y.name);      
    	    	              break;
    	    	          }
    	    	          default:
    	    	          {   break;
    	    	          }
    	    	    }
    	    	}
    	    }
    		break;
    	}
    	case "plz":
    	{   if (document.getElementById(objValue.name+"input").value == "")
    	    {   strError = "E_FORMFIELD_NOCITY|" + fieldforerrormessage;
    	    }    
    	    break;   
    	}
    	case "url":
    	{   if (!isUrl(objValue.value))
    	    {  strError = "E_FORMFIELD_URL|" + fieldforerrormessage;
    	    }
    	    break;
    	}
    	case "nw":
        case "nowhitespace":
        {   if (Trim(objValue.value) == "")
            {   strError = "E_FORMFIELD_NW|" + fieldforerrormessage;
            }
            break;
        }
        case "req":
        case "required":
        {   //alert(objValue.type + " " + objValue.options.length)
        	/**
        	 * Wenn objValue vom Typ select ist muss geprueft werden ob min eine Value vorhanden ist
        	 */ 
        	if (objValue.type == "select-one" && objValue.options.length==0)
        	{	strError = "E_FORMFIELD_REQ|"+fieldforerrormessage;
        	}
        	else
        	{	if (eval(objValue.value.length) == 0 && !objValue.checked && !objValue.selected && objValue.type != "select-one")
	            {   strError = "E_FORMFIELD_REQ|"+fieldforerrormessage;
	            }
			}
            break;
         }
	 	 case "maxlength":
         case "maxlen":
         {   if (eval(objValue.value.length) >  eval(cmdvalue))
             {   strError = "E_FORMFIELD_MAXLEN|"+cmdvalue+";"+fieldforerrormessage + ";" + objValue.value.length;
             }
             break;
          }
          case "minlength":
          case "minlen":
          {   if (eval(objValue.value.length) <  eval(cmdvalue))
              {   strError = "E_FORMFIELD_MAXLEN|"+fieldforerrormessage+";"+cmdvalue+";"+objValue.value.length;
              }
              break;
          }
          case "alnum":
          case "alphanumeric":
          {   var charpos = objValue.value.search("[^A-Za-z0-9]");
              if (objValue.value.length > 0 &&  charpos >= 0) 
              {   strError = "E_FORMFIELD_ALNUM_JS|"+fieldforerrormessage+";"+ eval(charpos+1);
              }
              break;
          }
          case "num":
          case "numeric":
          {   if (objValue.value.length != 0)
          	  {	  var charpos = objValue.value.search("[^0-9]");
	              if (objValue.value.length > 0 &&  charpos >= 0)
	              {   strError = "E_FORMFIELD_NUM_JS|"+fieldforerrormessage+";"+ eval(charpos+1);
	              }
          	  }
          	  else
          	  {	  strError = "";
          	  }
              break;
           }
           
           case "geodata":
           {	var check = objValue.value.search("{2}[0-9]*+(.([0-9]))?$/");
				if (objValue.value.length > 0 &&  check)
				{   strError = "E_FORMFIELD_NOTVALIDGEODATA|"+fieldforerrormessage;
				}	
				break;
           }
           
           case "alphabetic":
           case "alpha":
           {   var charpos = objValue.value.search("[^A-Za-z]");
               if (objValue.value.length > 0 &&  charpos >= 0)
               {   strError = "E_FORMFIELD_ALPHA_JS|"+fieldforerrormessage+";"+ eval(charpos+1);
               }
               break;
           }
		   case "alnumhyphen":
		   {   var charpos = objValue.value.search("[^A-Za-z0-9\-_]"); 
               if (objValue.value.length > 0 &&  charpos >= 0) 
               {   strError = "E_FORMFIELD_ALNUMHYPHEN_JS|"+fieldforerrormessage+";"+ eval(charpos+1);
               }
			   break;
		   }
           case "email":
           {   if (!validateEmailv2(objValue.value))
               {   strError = "E_FORMFIELD_EMAIL|"+fieldforerrormessage;
               }
               break;
           }
           case "lt":
           case "lessthan":
           {   if ((objValue.value.length) >=  eval (parseInt(cmdvalue)))
               {   strError = "E_FORMFIELD_LT|"+fieldforerrormessage+";"+cmdvalue;
               }
               break;
           }
           // For Text
           case "gt":
           case "greaterthan":
           {   if ((objValue.value.length) <=  eval(parseInt(cmdvalue)))
               {   strError = "E_FORMFIELD_GT|"+fieldforerrormessage+";"+cmdvalue;
               }
               break;
           }
           case "price":
           {	var validprice = objValue.value.search("^[0-9]+[0-9,\.\-]*$"); 
               if (objValue.value.length > 0 &&  validprice) 
               {   strError = "E_FORMFIELD_PRICE|"+fieldforerrormessage;
               }
			   break;
           }
           case "regexp":
           {   if (objValue.value.length > 0)
			   {   if (!objValue.value.match(cmdvalue))
	               {   strError = "E_FORMFIELD_REGEXP|"+fieldforerrormessage;
	               }
			   }
               break;
           }
           case "dontselect":
           {   if (objValue.selectedIndex == null)
               {   strError = "E_FORMFIELD_NODONTSELECT|"+ fieldforerrormessage;
               }
               if (objValue.selectedIndex == eval(cmdvalue))
               {   strError = "E_FORMFIELD_DONTSELECT|"+ fieldforerrormessage;
               }
               break;
           }
           case "double":
           {   if (objValue.value != (document.getElementById(objValue.id+"1").value))
         	   {	  strError = "E_FORMFIELD_DOUBLE";
         	          targetfields[1] = (objValue.name+"1");
         	   }
         	   break;
           }
    }
    
    if (strError && strError.length!=0)
    {   if (objValue.name != "")
        {   getMSG((strError),container,targetfields);
        }
        else
        {   getMSG((strError),container,"");
        }
        return false;
    }
    return true;
    //return true;
}

/**
*   Methode:
*   MSGKonstReplace =   Ersetzung von Platzhaltern 
*                       in einer Message
*                       
*
*   Params:
*   nlsmsg          =   Message mit Clientvars oder ohne
*   clientvar       =   Clientvars mit Pipe getrennt
*                       (zb. "Feld1|Wert2|Feld2" )
*   Return:     
*   str             =   Ersetzter Messagestring
*/
function MSGKonstReplace(msg, clientvar)
{   
	var n, r, i,x;
    msg = msg.replace(/\%br/g, "\n"); 
    if (clientvar)
    {   var cvar = clientvar.split("|");
        for (n = 0; n < cvar.length; n++)
        {   r = new RegExp("%" + (n+1), "g");
            msg = msg.replace(r, cvar[n]);
        } // for
        // fehlende Platzhalter auf einen Leerstring setzen
        // to do 2 ersetzen dass m?glichst alle Leerstrings ersetzt werden
        for (i=0;i<10;i++)
        {   x = new RegExp("%" + (i+1), "g");
            msg = msg.replace(x, ""); 
        }
    } // if
    return msg;
} // MSGKonstReplace


/**
 * Setzen einer Messagekonstante fuer die Ausgabe von Messages ueber XAJAX
 */
function setTYPMSGKONST(konsttype)
{	TYPMSGKONST = konsttype;
}


/**
*   Methode:
*   getMSG          =   Message ermitteln 
*
*   Params:
*   MSGKONST        =   Messagekonstante mit Clientvars
*                       (z.B. "E_FORMFIELD_LT|Email;17")
*                       Eine Trennung der Clientvars muss
*                       mit ";" erfolgen
*	container		= 	wird durchgeschleift (optional)
*	targetfields	= 	wird durchgeschleift (optional)
*   Return:     
*   str             =   Message
*/
function getMSG(MSGKONST,container, targetfields)
{   if (MSGKONST != "")
    {   var clientvars = ""; 
        var Kpart = new Array;
        
        Kpart = MSGKONST.split("|");
        /**
         * Type der Message ermitteln
         * Erlaubte Typen:
         * E = Error
         * ? = Question
         * W = Warning
         * ! = Hint
         */
        var typearr = new Array;
        typearr = MSGKONST.split("_");
        if ( typearr[0] != "" && ( typearr[0] == "E" || typearr[0] == "?" || typearr[0] == "W" || typearr[0] == "!" ))
        {   // Globale Variable mit dem Typ der MSGKONST fuellen
            TYPMSGKONST = typearr[0];
        }
        else
        {   TYPMSGKONST = "";
        }
        if (Kpart[0] != "" && Kpart.length>0)
        {   xajax_retrievemsg(Kpart[0], Kpart[1], container, targetfields);
        }
    }
} //getMSG

/**
 *   Ajax Call
 */
function transferMSG(msg, parampart, container, targetfields)
{	
	var message = (msg);	
	if (parampart)
    {   clientvars = parampart.replace(/;/g,"|")
        message = MSGKonstReplace(message,clientvars);
    }  
    /**
     * wenn keine container und targetfields vorhanden sind
     * Fehlermeldung direkt durch einen Array ausgeben
     */
    if (container != "undefined")
    {	setFormMessage(container, message, targetfields); 
    }
    else
    {	//calert();
    	alert(message);
    }
}

/**
*   Methode:
*   SetTextboxFocus =  Setzt Focus in ein Textfeld oder Textarea 
*
*   Params:
*   formfield       =  Name Formularfeld
*
*   Return:     
*   null =          (setzt focus to formfield)
*/
function SetTextboxFocus(formfield)
{   // Funktioniert nicht im IE
    if (formfield != null && !(formfield.type == 'hidden'))
    {   var field = document.getElementById(formfield);
        field.focus();
    }
} //SetTextboxFocus


/**
*   Methode:
*   clearFormFieldStyles =  Bereinigt mit Stylesheets formatierte 
*                           Formularelemente     
*
*   Return:     
*   null =          (setzt fields to original style)
*/
function clearFormFieldStyles()
{   // Felder bereinigen
    var i,x,clearfield,typ ;
    for(i=0; i<document.forms.length; i++) 
    {   for(x=0; x<document.forms[i].length; x++)
        {   typ = document.forms[i].elements[x].type
            switch(typ)
            {   case "password":
            	case "text": clearFormFieldStyle (document.forms[i].elements[x].name); break;
                default:break;
            }
        }
    }
} //clearFormFieldStyles

/**
 * Leert ein Formularfeld
 * @param string fieldname
 */
function emptyFormField(buttonobj,fieldname)
{	var field = document.getElementById(fieldname);
	if (field)
	{	field.value = "";
	}
}

/**
 * Verlinkung aus einem Formfield heraus
 * @param string url
 * @param string formfieldname
 * @param string paramforfield (z.B. REFID)
 */
function formfieldlinkto(url,formfieldname,paramforfield)
{	var formfield = document.getElementById(formfieldname);
	if (url!="" && formfield)
	{	if (paramforfield!="")
		{	/**
			 * Anhand des Typs value setzen
			 */
			var value=""
			switch (formfield.type)
			{	case 'select-one':
				{	// selektieren wert als Value setzen
					value = "&"+paramforfield+"="+formfield.options[formfield.selectedIndex].value;
					break;
				}
				default:
				{	value = "&"+paramforfield+"="+formfield.value;
					break;
				}
			}
			url = url + value;
		}
		location.href = url;	
	}
	return null;	
}

/**
*   Methode:
*   Setzt beim onblur eines Formelements Felder, die keine Zahlen haben leer 
*   (z.B. tt.mm.yyyy bei Kalendern)
*
*   Params:
*   formelement = this (Aktuelles Formelement)
*
*   Return:
*   null = setzt übergebens Feld leer wenn nicht numerisch
*/
function emptynotnumeric(formelement)
{  	var formelementvalue = document.getElementById(formelement.value);
	if(!formelement.value.search("[^0-9]"))
	{   formelement.value = '';
	}
}


/**
*   Methode:
*   setFormMessage =    Ausgabe von Meldungen als Alert()
*                   bzw. in div.msgfield falls dieses
*                   vorhanden.
*
*   Params:
*   msgfield =      Ausgabe Div Container
*   str =           MSG Konstante, Meldung
*   fieldname =     Array("feld1","feld2") 
*                   oder einzelner Feldname als String z.B. 
*                   ("feld") Target formfield (obligate) for highlighting
*
*   Return:     
*   null =          (setzt msgfield Container mit Text)
*                   (alert() bei nicht vorhandenem msgfield Container)
*/
function setFormMessage(msgfield,str,fieldname)
{   clearFormFieldStyles();

	var fieldslength = fieldname.length;
    if (fieldslength>0)
    {   if (isArray(fieldname))
        {	for (var i=0; i<fieldname.length;i++)
            {   if (document.getElementById(fieldname[i]))
                {   //alert (fieldname[i])
                	setFormFieldStyle(fieldname[i]);
                    SetTextboxFocus(fieldname[0]);
                }
            }
        }
        else
        {   setFormFieldStyle(fieldname)
            SetTextboxFocus(fieldname);
        }    
    }   
    
    if (document.getElementById(msgfield)) // Errorcontainer vorhanden
    {   // umschließenden Container einblenden
        var containerdiv = document.getElementById(msgfield+"form");
        containerdiv.style.display = 'block';
        
        // Image anzeigen
        var img = "";
        var classname = "errorbox";
        var IMGKONSTTITLE = "";        

        switch(TYPMSGKONST)
        {   case "E":
            {   IMGKONST = "ERROR";
            	IMGKONSTTITLE = "Fehler";
                break;
            }
            case "W":
            {   IMGKONST = "WARNING";
            	IMGKONSTTITLE = "Warnung";
                break;
            }
            case "?":
            {   IMGKONST = "QUESTION";
            	IMGKONSTTITLE = "Sicher?";
                break;
            }
            default:
            {   IMGKONST = "OK";
            	IMGKONSTTITLE = "Aktion erfolgreich";
            	classname = "validbox";	
                break;
            }
	    }
    	
    	// Je nach Messagetype zusaetzlich css class setzen
    	containerdiv.className = 'clearfix '+classname;
    	
        // Nachricht einblenden
        var mydiv = document.getElementById(msgfield);
        mydiv.style.display = 'block';
        
        mydiv.innerHTML = "<span class=\"ICON "+IMGKONST+" ILF\" title=\""+IMGKONSTTITLE+"\"  ></span>" + str;
    }
    else    
    {  	alert(str);
    }
    return null;
}//setFormMessage



/**
*   ftipponload = Autoloader f?r Defaultmessage
*/
function ftipponload(formname)
{   
	if (typeof( window[ 'TOOLTIPFORM' ] ) == "undefined")
	{	ftipp(formname,"defaultmessage");
	}
}



/**
*   Methode:
*   ftipp = Tipp Meldung einblenden
*
*   Params:
*	formname = current form name
*   area = id des jeweiligen Tags (this)
*   fcontainer = Id des Ausgabe Containers  
*   descriptor = Fieldtyp 
*
*   Return:     
*   null ( Setzt quicktipp Container mit Text)
*
*   example for array
*   var Tipp = new Array;
*   Tipp['email'] = 'adsf';
*   Tipp['surname'] = 'adf adf';
*   Tipp['firstname'] = 'a dfasfd ';
*   Tipp['default'] = 'axxxa';
*/
function ftipp(formname,area,fcontainer,descriptor)
{	var tipp_id;

    
    // Wenn ein Formname nicht besteht Funktion verlassen
    if (!formname || formname == "" )
    {   return false;
    }
    
    /**
     *  Falls kein Container in der Formular XML angegeben wird wird falls vorhanden der Standard
     *  Container (id) quicktipp verwendet
     */
    if(!fcontainer)
    {   fcontainer = "quicktipp"+formname;
    }
	
   	/**
	 *	Wenn deaktiviert abbrechen
	 */
    if (typeof( window[ 'TOOLTIPFORM' ] ) != "undefined" && GC("dfttip") == 1)
    {	return false;
    }

    
    // Wenn kein Ausgabe Container vorhanden ist und keine Tooltip definiert ist Funktion verlassen
    if (!document.getElementById(fcontainer) && typeof( window[ 'TOOLTIPFORM' ] ) == "undefined")
    {   return false;
    }
    
    if (area == 'defaultmessage') 
	{	tipp_id = 'defaultmessage';		
	}
	else 
	{  switch(descriptor)
	   {   case "date":
	       {   var feldname = area.name;
	           tipp_id = feldname.substring(0,(feldname.length -1));
	           break;
	       }
	       case "double":
	       {   var feldname = area.name;
	           tipp_id = feldname.substring(0,(feldname.length -1));
	           break;
	       }
	       default:
	       {   if (area.id) 
		       {  tipp_id = area.id;				
		       }
		       else if (area.name) 
        	   {	tipp_id = area.name;
        	   } 
        	   else 
        	   {	
        	       return false;		
        	   }			
	           break;
	       }
	   }
	}

	// if Tipp is undefined, then empty				
    if (!Tipp[formname][tipp_id])
	{	tipp_id = 'defaultmessage';
	}

	
	// write tipp into layer			
	var quicktippheader = "";
	if (Tipp[formname][tipp_id] && Tipp[formname][tipp_id][0] != "")
	{   quicktippheader = Tipp[formname][tipp_id][0];
	}
	else
	{   quicktippheader = "Quicktipp!";
	}
	
	var quicktippcontent = "";
	if (Tipp[formname][tipp_id] && Tipp[formname][tipp_id][1] != "")
	{   quicktippcontent = Tipp[formname][tipp_id][1];
	}
	
	if (descriptor== "double" && Tipp[formname][tipp_id][4] != "")
	{   quicktippcontent = Tipp[formname][tipp_id][4];
	    
	}
	
	// Generate HTML for Quicktipp
	var htmloutput = "";
	if(Tipp[formname][tipp_id] && Tipp[formname][tipp_id][2] != "") // Tippimage
	{	htmloutput += "<div class='quicktippimage'><img src='"+Tipp[formname][tipp_id][2]+"' title='"+Tipp[formname][tipp_id][0]+"'/></div>";
	}
	htmloutput += "<div class='quicktippcontent'>"+quicktippcontent+"</div>";
	if(Tipp[formname][tipp_id] && Tipp[formname][tipp_id][3] != "") // Tipplink
	{   htmloutput += "<div class='quicktipplink'><a href='"+Tipp[formname][tipp_id][3]+"'>"+quicktippheader+"</a></div>";
	}

	/**
	 * Ausgabe des Tooltips. Wenn ein Ausgabecontainer vorhanden ist werden die Tooltips in diesem ausgegeben,
	 * ansontsten erscheint ein Layer mit der Message
	 */
	
	if (!document.getElementById(fcontainer))
	{	
		ttlayer(quicktippheader,htmloutput,tipp_id);
	}
	else
	{	
		if (document.getElementById("quicktipp"+formname+"header"))
		{   document.getElementById("quicktipp"+formname+"header").innerHTML = quicktippheader;
		}
		
		if(document.getElementById(fcontainer))
		{	document.getElementById(fcontainer).innerHTML = htmloutput;
		}
		else if(document.all && document.getElementById(fcontainer+formname) && document.getElementById(fcontainer+formname+"header"))
		{	document.all.fcontainer.innerHTML = htmloutput;
		}
	}
} //ftipp


/**
 * Tooltip fuer Formelemente
 */
var tsv = null;
var tlay = null;
function ttlayer(header,text,formfeld)
{	
	if (text!="")
    {	if (tlay != null)
	    {  cleartooltipform();
	    }
		
	    tlay = gEBI(tooltipformid);
	    tlay.style.display = "block";
	    
       	str  =  "<h1>" + header + "</h1>"
       	str += text;
		str += "<div class=\"ar ws\"><a href=\"javascript:;\"  onclick=\"deactt();\" class=\"ws\">ausblenden</a></div>";
        tlay.style.opacity = 85;
		tlay.style.filter = 'alpha(opacity=85)';
        
        var ffield = gEBI(formfeld);
        a = findPos(ffield);
        
        tlay.style.top = (  a[1] )  + p;
        tlay.style.left = ( a[0] + ffield.offsetWidth + 20 ) + p;

        // Box automatisch ausblenden nach angegebener Zeit
        if (menutimeoutolayer > 0)
        {   tsv = setTimeout(cleartooltipform,5000);
        }
        tlay.innerHTML = str ;
    }
}


/**
 * Formtooltip entfernen
 */
function cleartooltipform()
{	var Node = gEBI(tooltipformid);
	if (!Node)
   	{    return false;
   	}
   	Node.style.display = "none";
   	window.clearTimeout(tsv);
   	document.onmouseover = new Function("return true") ;
}
/**
 * Tooltips deaktivieren
 */
function deactt()
{	SC("dfttip",1,cookieexpires);
	cleartooltipform();
	
}
/**
 * Tooltip aktivieren
 */
function actt()
{	SC("dfttip",0,cookieexpires);
}


/**
 * Highlight von Formularelementen
 */
	var ns6=document.getElementById&&!document.all
	var previous=''
	var eventobj
	
	//Regular expression to highlight only form elements
	var intended=/INPUT|TEXTAREA|SELECT|OPTION/
	
	//Function to check whether element clicked is form element
	function checkel(which)
	{	if (which.style&&intended.test(which.tagName))
		{	if (ns6&&eventobj.nodeType==3)
				eventobj=eventobj.parentNode.parentNode
			return true
		}
		else
		{	return false
		}
	}
	
	//Function to highlight form element
	function highlight(e)
	{	eventobj=ns6? e.target : event.srcElement
		if(eventobj.type != "submit" && eventobj.type != "checkbox" && eventobj.type != "radio" && !eventobj.readOnly && eventobj.type != "select-one")
		{	if (previous!='')
			{	if (checkel(previous))
					previous.className="formfield"; 
					previous=eventobj
				if (checkel(eventobj))
					eventobj.className="highlight";
			}
			else
			{	if (checkel(eventobj))
				eventobj.className="highlight";
				previous=eventobj
			}
		}	
	}

/**
* counter fuer zeicheneingabe in textfelder
*/
function textCounter(field, countfield, maxlimit)
{	var sourcefield = gEBI(field);
	var targetfield = gEBI(countfield);
 	if (sourcefield && targetfield)
 	{ 	if (sourcefield.value.length > (maxlimit -1)) 
 		{	sourcefield.value = sourcefield.value.substring(0, maxlimit -1);  
 		}
 		else
 		{	targetfield.innerHTML = maxlimit - ( sourcefield.value.length +1);
 		}
 	}
}


/**
*   Methode:
*   setFormFieldStyle   =   Formatierung von Formularfeldern
*
*   Params:
*   changeField         =   Name des Formularfeldes
*   stylesheetclass     =   Name der Stylesheet Klasse 
*                           (Wenn keine vorhanden ist wird die 
*                           Standardklasse ".formfieldError" benutzt)
*
*   Return:     
*   null                =   (Entsprechendes Formularfeld wird formatiert)
*/
function setFormFieldStyle (changeField,stylesheetclass,clearouttime)   
{   if (document.getElementById(changeField))
    {   var square = document.getElementById(changeField)
        if (stylesheetclass)
        {   square.className = stylesheetclass;
        }
        else
        {   square.className = "formfieldError";
        }    
        
        if (clearouttime)
        {   setTimeout("clearFormFieldStyle ('"+changeField+"')", clearouttime)
        }
    } 
} //setFormFieldStyle

/**
*   clearFormFieldStyle =   Formatierungen bereinigen
*
*   Params:
*   changefield         =   Formular dessen Formatierung zur?ckgesetzt werden soll
*   
*   Return:
*   null                =   Formatierung wird zur?ckgesetzt
*/
function clearFormFieldStyle (changeField)
{   var square;
    if (document.getElementById(changeField))
    {   square = document.getElementById(changeField);
    	/**
    	 *	Felder mit einer Readonly Stylesheet Klasse nicht zuruecksetzen
    	 */
    	if (square.className != "readonly")
    	{	square.className = "formfield";     
    	}
    }
} 

/**
 * Highlighten von Ankern in Formfields
 */
addLoadEvent(highlightformanchor);
function highlightformanchor()	
{	var anchorname = self.document.location.hash.substring(1);
	var avar = ('c'+anchorname);
	var anchor = document.getElementById(avar);
	if (anchor)
	{	anchor.className='formanker clearfix';
	}
}

/**
*   closeMSGFieldContainer =   Msgfield Container schließen
*
*   Params:
*   msgfield         =   Name des MSGFIELDS
*/

function closeMSGFieldContainer(msgfield)
{	if (document.getElementById(msgfield+'form'))
	{	document.getElementById(msgfield+'form').style.display = "none";
	}
	return null;
}

/**
 *	Kopiert ein Formularwert vom Source ins targetfield
 */
function copyvalue(sourcefield,targetfield)
{	var source = document.getElementById(sourcefield);
	var target = document.getElementById(targetfield);
	if (source && target)
	{	target.value = source.value;
	}
	
}

/**
 *	Kopiert ein Datum vom Source ins targetfield
 */

function copydatevalue(sourcefield,targetfield)
{	var source1 = document.getElementById(sourcefield+"1");
	var source2 = document.getElementById(sourcefield+"2");
	var source3 = document.getElementById(sourcefield+"3");
	var target1 = document.getElementById(targetfield+"1");
	var target2 = document.getElementById(targetfield+"2");
	var target3 = document.getElementById(targetfield+"3");
	
	if (source1 && target1)
	{	target1.value = source1.value;
	}
	if (source2 && target2)
	{	target2.value = source2.value;
	}
	if (source3 && target3)
	{	target3.value = source3.value;
		
	}
}

/****************************************************************/
/*  Dyn. hinzufuegen von Formelementen                          */
/****************************************************************/

/**
 *	Clone Form Fields and extend the form input names
 *	@param string blockname (name of div block to clone)
 */
function moreFields(blockname)
{
	blockcounter[blockname]++;
	if (maxclonecount[blockname] && (blockcounter[blockname] > maxclonecount[blockname]))
	{	// Maximale Adds erreicht
		getMSG('E_FORMFIELD_MAXADD');
	}
	else
	{	var readbox = blockname+"read";
		var writebox = blockname+"write";
	
		var newFields = document.getElementById(readbox).cloneNode(true);
		newFields.id = '';
		newFields.style.display = 'block';
		var newField = newFields.childNodes;
		for (var i=0;i<newField.length;i++) {
			var theName = newField[i].name
			if (newField[i].childNodes.length > 0)
			{	for (x=0;x<newField[i].childNodes.length;x++)
				{	var theChild = newField[i].childNodes[x];
					if (!isUndefined(theChild.name))
					{	theChild.name = theChild.name + "|"+blockcounter[blockname];
					
					}
				}
			}
			else
			{	if (theName)
				{	newField[i].name = theName + "|" + blockcounter[blockname];
				}
			}		
		}
		var insertHere = document.getElementById(writebox);
		insertHere.parentNode.insertBefore(newFields,insertHere);
	}	
}

//maxclonecount