//var formSubmitted = false;

//function ResetFormSubmitted() {
//   formSubmitted=false;
//}


function SaveForm(theForm) {
// if (!formSubmitted)  {
		if (ValidateForm(theForm)) {
//			formSubmitted = true;
//    	setTimeout("ResetFormSubmitted()",5000);
 		//	SaveFormContent(theForm);
			SubmitForm(theForm);
		}
// }
}


function ValidateAndSubmit(objForm)
/* Deze functie valideert en submit een formulier.  */
/* strForm           => Het te valideren formulier. */
/* ValidateAndSubmit <= void.                       */
{
   if(ValidateForm(objForm)==true) objForm.submit()
}

function ValidateForm(objForm)
/* Deze functie valideert een formulier.                              */
/* objForm      => Het te valideren formulier.                        */
/* ValidateForm <= false: ongeldig formulier, true: geldig formulier. */
{
   var intIndex, strName, strNameprevious=""
   /* process form elements */
   for(intIndex=0;intIndex<=objForm.elements.length-1;intIndex++)
   {
      strName=objForm.elements[intIndex].name
      if(strName!="" && strName!=strNameprevious)
      {
         if(ValidateElement(objForm[objForm.elements[intIndex].name])==false) return(false)
         strNameprevious=strName
      }
   }
   return(true);
}

function SubmitForm(objForm) {
   /* remove validation parameters from element names */
   for(intIndex=0;intIndex<=objForm.elements.length-1;intIndex++)
   {
      /* check if validation is needed */
      if(objForm.elements[intIndex].name.indexOf("name=")!=-1)
      {
         /* parse 'name' attribute for element name */
         strName=Parse(objForm.elements[intIndex].name,"name")
         if(strName!="") objForm.elements[intIndex].name=strName
      }
   }
   objForm.submit();
   return(true)
}

function ValidateElement(objElement)
/* Deze functie valideert een formulierelement.                                                   */
/* objElement => Het te valideren formulierelement. Per formulierelement kunnen de validatie-     */
/*               parameters als volgt bij de elementnaam worden opgegeven:                        */
/*               <input type="..." name="name=naam datatype=type min=x max=y required=yesno" ...> */
/*               naam: de naam van het element (wordt in het name attribute teruggezet)           */
/*               type: date, time, email, float, integer, telephone, zipcode                            */
/*               x: minimale integer/numerieke waarde, y: maximale integer/numerieke waarde       */
/*               yesno: yes=veld invullen verplicht, no=veld invullen optioneel.                  */
/* ValidateElement <= false: ongeldig formulierelement, true: geldig formulierelement.            */
{
   var strName, strValue="", fltMin, fltMax, intMin, intMax, intIndex
   /* check element type */
   if(objElement[0] && (objElement[0].type=="radio" || objElement[0].type=="checkbox")) /* radio/checkbox elementgroup */
   {

      strName=objElement[0].name
      strLabel=Parse(strName,"label");
      if (strLabel.length <=0)
         strLabel=Parse(strName,"name");

      /* check if validation is needed */
      if(objElement[0].name.indexOf("name=")!=-1)
      {
         for(intIndex=0;intIndex<objElement.length;intIndex++)
            if(objElement[intIndex].checked) strValue+=objElement[intIndex].value
         /* validate 'value' attribute on requirement */
         if(strValue.match(/^[ \t]*$/)!=null)
         {
            ("U heeft geen '"+strLabel+"'  ingevuld.")
            objElement[0].focus()
            return(false)
         }
      }
   }
   else if(objElement.type.indexOf("select")!=-1) /* select element */
   {
      strName=objElement.name
      strLabel=Parse(strName,"label");
      if (strLabel.length <=0)
         strLabel=Parse(strName,"name");

      /* check if validation is needed */
      if(objElement.name.indexOf("name=")!=-1)
      {
         if(objElement.selectedIndex!=-1) strValue=objElement.options[objElement.selectedIndex].value
         /* validate 'value' attribute on requirement */
         if(strValue.match(/^[ \t]*$/)!=null)
         {
            alert("U heeft geen '"+strLabel+"'  ingevuld.")
            objElement.focus()
            return(false)
         }
      }
   }
   else /* text element */
   {
      /* check if validation is needed */
      if(objElement.name.indexOf("name=")!=-1)
      {
         /* parse 'name' attribute for validation parameters */
         strName=objElement.name
         strValue=objElement.value
         strLabel=Parse(strName,"label");
         if (strLabel.length <=0)
            strLabel=Parse(strName,"name");


         /* validate 'value' attribute on requirement */
         if(Parse(strName,"required")=="yes" && strValue.match(/^[ \t]*$/)!=null)
         {
            alert("U heeft geen '"+strLabel+"'  ingevuld.")
            objElement.focus()
            return(false)
         }
         /* validate 'value' attribute on datatype */
         if(strValue!="") switch(Parse(strName,"datatype"))
         {
            case "date":
               if(ValidateDate(strValue)==false)
               {
                  alert("Incorrecte "+strLabel+" ingevuld. Gebruik het formaat \"DD-MM-JJJJ\".")
                  objElement.focus()
                  return(false)
               }
               else
                  objElement.value = CalcDate(strValue);
               break
            case "time":
               if(ValidateTime(strValue)==false)
               {
                  alert("Incorrecte "+strLabel+" ingevuld. Gebruik het formaat \"UU:MM\".")
                  objElement.focus()
                  return(false)
               }
               break
            case "email":
               if(ValidateEmail(strValue)==false)
               {
                  alert("Incorrect e-mail adres ingevuld.")
                  objElement.focus()
                  return(false)
               }
               break
            case "float":
               fltMin=parseFloat(Parse(strName,"min"))
               fltMax=parseFloat(Parse(strName,"max"))
               if(isNaN(fltMin)||isNaN(fltMax))
               {
                  alert("error: float min/max value not coded.")
                  return(false)
               }
               if(ValidateFloat(strValue,fltMin,fltMax)==false)
               {
                  alert("Incorrect getal ingevuld. Alstublieft een numeriek getal invullen van "+Parse(strName,"min")+" t/m "+Parse(strName,"max")+".")
                  objElement.focus()
                  return(false)
               }
               break
            case "integer":
               intMin=StringToInt(Parse(strName,"min"))
               intMax=StringToInt(Parse(strName,"max"))
               if(isNaN(intMin)||isNaN(intMax))
               {
                  alert("error: integer min/max value not coded.")
                  return(false)
               }
               if(ValidateInteger(strValue,intMin,intMax)==false)
               {
                  alert("Incorrect getal ingevuld. Alstublieft een geheel getal invullen van "+intMin+" t/m "+intMax+".")
                  objElement.focus()
                  return(false)
               }
               break
            case "telephone":
               if(ValidateTelephone(strValue)==false)
               {
                  alert("Incorrect telefoonnummer ingevuld. Alstublieft een 10 cijferig telefoonnummer invullen van het formaat \"netnummer - abonneenummer\". B.v. 034-1234567 of 06-12345678")
                  objElement.focus()
                  return(false)
               }
               break
            case "zipcode":
               if(ValidateZipcode(objElement)==false)
               {
                  alert("Incorrecte postcode ingevuld. Alstublieft een postcode invullen van het formaat \"1234 AB\".")
                  objElement.focus()
                  return(false)
               }
               break
            default: break
         }
      }
   }
   return(true)
}

function Parse(strLine, strParameter)
/* Deze functie zoekt in een string een parameternaam en retourneert de     */
/* bijbehorende parameterwaarde.                                            */
/* strLine      => de te parsen string                                      */
/*                (formaat: "par1naam=par1waarde par2naam=par2waarde ...")  */
/* strParameter => de naam van de parameter                                 */
/* Parse        <= de waarde van de parameter, "": parameter niet gevonden. */
{
   var intIndex, strParameterValue=""
   if(strParameter!="" && (intIndex=strLine.indexOf(strParameter+"="))!=-1)
   {
      intIndex+=strParameter.length+1
      if (strLine.charAt(intIndex) == "'") {
         intIndex++;
         while(intIndex<strLine.length && strLine.charAt(intIndex)!="'")
            strParameterValue+=strLine.charAt(intIndex++)
      }
      else {
         while(intIndex<strLine.length && strLine.charAt(intIndex)!=" ")
            strParameterValue+=strLine.charAt(intIndex++)
      }
   }
   return(strParameterValue)
}

function StringToInt(strString)
/* Deze functie converteert een string naar een integer.                     */
/* (parseInt converteerd voornullen niet en niet-cijfers vaag)               */
/* strString   => de te converteren string                                   */
/* StringToInt <= NaN: string bestaat niet alleen uit cijfers, int: integer. */
{
   var arrMatch=new RegExp("^([-]?)0*([0-9]+)$").exec(strString)
   if(arrMatch) return(parseInt(arrMatch[1]+arrMatch[2])); else return(NaN)
}

function ValidateDate(strValue)
/* Deze functie valideert een nederlandse datum.                */
/* Bij een tweecijferig jaartal is het bereik 1920-2019.        */
/* strValue     => string die de te valideren datum bevat       */
/* ValidateDate <= false: ongeldige datum, true: geldige datum. */
{
   var arrMatch=new RegExp("^([0-9]{1,2})[/-]([0-9]{1,2})[/-]([0-9]{2}|[0-9]{4})$").exec(strValue)
   var intDay, intMonth, intYear
   /* Getallen */
   if(!arrMatch) return(false)
   intDay=StringToInt(arrMatch[1])
   intMonth=StringToInt(arrMatch[2])
   intYear=StringToInt(arrMatch[3])
   if(arrMatch[3].length==2) if(intYear<20) intYear+=2000; else intYear+=1900
   /* Geldige datum */
   if(isNaN(intDay) || intDay<1 || intDay>31) return(false)
   if(isNaN(intMonth) || intMonth<1 || intMonth>12) return(false)
   if(intDay>29 && intMonth==2) return(false)
   if(intDay==31 && (intMonth==4 || intMonth==6 || intMonth==9 || intMonth==11)) return(false)
   if(isNaN(intYear) || intYear<1000 || intYear>9999) return(false)
   if(intDay==29 && intMonth==2 && (intYear%4!=0 || (intYear%100==0 && intYear%400!=0))) return(false)
   return(true)
}

function CalcDate(strValue)
/* Deze functie zet een nederlandse datum in het formaat .                */
/* Bij een tweecijferig jaartal is het bereik 1920-2019.        */
/* strValue     => string die de te valideren datum bevat       */
/* ValidateDate <= false: ongeldige datum, true: geldige datum. */
{
   var arrMatch=new RegExp("^([0-9]{1,2})[/-]([0-9]{1,2})[/-]([0-9]{2}|[0-9]{4})$").exec(strValue)
   var intDay, intMonth, intYear
   /* Getallen */
   if(!arrMatch) return(false)
   intDay=StringToInt(arrMatch[1])
   intMonth=StringToInt(arrMatch[2])
   intYear=StringToInt(arrMatch[3])
   if(arrMatch[3].length==2)
      if(intYear<20) intYear+=2000; else intYear+=1900

   return(arrMatch[1]+"-"+arrMatch[2]+"-"+intYear)
}

function ValidateTime(strValue)
/* Deze functie valideert een tijd.                */
/* strValue     => string die de te valideren datum bevat       */
/* ValidateDate <= false: ongeldige datum, true: geldige datum. */
{
   var arrMatch=new RegExp("^([0-9]{1,2})[:-]([0-9]{1,2})$").exec(strValue)
   var intDay, intMonth, intYear
   /* Getallen */
   if(!arrMatch) return(false)
   intHours=StringToInt(arrMatch[1])
   intMinutes=StringToInt(arrMatch[2])
   if(isNaN(intHours) || intHours<0 || intHours>23) return(false)
   if(isNaN(intMinutes) || intMinutes<0 || intMinutes>59) return(false)
   return(true)
}

function ValidateEmail(strValue)
/* Deze functie valideert een e-mail adres.                                  */
/* strValue      => string die het te valideren e-mail adres bevat           */
/* ValidateEmail <= false: ongeldig e-mail adres, true: geldig e-mail adres. */
{
   var arrMatch=new RegExp("^[A-Za-z0-9_-]+([.][A-Za-z0-9_-]+){0,4}[@][A-Za-z0-9_-]+([.][A-Za-z0-9_-]+){1,3}$").exec(strValue)
   if(!arrMatch) return(false); else return(true)
}

function ValidateFloat(strValue, fltMin, fltMax)
/* Deze functie valideert een numeriek getal.                                    */
/* strValue      => string die het te valideren numerieke getal bevat            */
/* fltMin        => minimale waarde van het numerieke getal                      */
/* fltMax        => maximale waarde van het numerieke getal                      */
/* ValidateFloat <= false: ongeldig numeriek getal, true: geldig numeriek getal. */
{
   var arrMatch=new RegExp("^([-]?[0-9]+([.][0-9]+)?)$").exec(strValue)

   if(!arrMatch || parseFloat(arrMatch[1])<fltMin || parseFloat(arrMatch[1])>fltMax) return(false)
   else return(true)
}

function ValidateInteger(strValue, intMin, intMax)
/* Deze functie valideert een geheel getal.                                    */
/* strValue        => string die het te valideren gehele getal bevat           */
/* intMin          => minimale waarde van het gehele getal                     */
/* intMax          => maximale waarde van het gehele getal                     */
/* ValidateInteger <= false: ongeldig geheel getal, true: geldig geheel getal. */
{
   var arrMatch=new RegExp("^([-]?[0-9]+)$").exec(strValue)
   if(!arrMatch || StringToInt(arrMatch[1])<intMin || StringToInt(arrMatch[1])>intMax) return(false)
   else return(true)
}

function ValidateTelephone(strValue)
/* Deze functie valideert een nederlands telefoonnummer.                             */
/* strValue          => string die het te valideren telefoonnummer bevat             */
/* ValidateTelephone <= false: ongeldig telefoonnummer, true: geldig telefoonnummer. */
{
   var arrMatch=new RegExp("^[0][0-9](([-][0-9][0-9])|([0-9][-][0-9])|([0-9][0-9][-]))[0-9]{6}$").exec(strValue)
   var arrMatch=new RegExp("^[0-9\-\+\(\) ]{10,15}$").exec(strValue)
   if(!arrMatch) return(false); else return(true)
}

function ValidateZipcode(objElement)
/* Deze functie valideert een postcode.                                  */
/* strValue        => string die de te valideren postcode bevat          */
/* ValidateZipcode <= false: ongeldige postcode, true: geldige postcode. */
{
   // oude reg >> var arrMatch=new RegExp("^[1-9][0-9]{3}[ ]*[A-Za-z]{2}$").exec(strValue)

   	//alert(objElement.name)
   	strValue = objElement.value

   	var parts = new Array();

	parts[0] = strValue.substring(0,4)
	parts[1] = strValue.substring(4,6)

	if(parts[0].match(/^[1-9][0-9]{3}$/) && parts[1].match(/^[A-Za-z]{2}$/)){
		//eval("document.theForm."+objElement.name+".value = parts[0]+" "+parts[1]
		objElement.value = parts[0]+" "+parts[1]
		arrMatch = true
	}
	else
		var arrMatch=new RegExp("^[1-9][0-9]{3}[ ][A-Za-z]{2}$").exec(strValue)



   //alert(tmp1.substring(0,4));

   //var arrMatch=new RegExp("^[1-9][0-9]{3}[ ][A-Za-z]{2}$").exec(strValue)


   if(!arrMatch) return(false); else return(true)
}