/**
check a given form, any element with 'ultrarequired' must have a value or selection
any element with 'ultraoptional' will be checked if a value has been entered
ultrarequired='true' must be checked, selected or have a value
ultrarequired='integer' checks wether value is an integer
ultrarequired='postcode_nl' checks wether value is a valid dutch zipcode
ultrarequired='number' checks wether value is a number
ultrarequired='email' checks for valid e-mail
ultrarequired='date' checks wether date is valid
ultrarequired='website' checks wether it is a valid url
ultrarequired='ucfirst' will set first cahr as capital, the others lowercase
ultrarequired='uppercase' will set all chars to uppercase
ultrarequired='lowercase' will set all chars to lowercase
ultrarequired='geboortejaar' checks if a numer is between given parameters
ultrarequired='equal_[fieldname]' checks its value against value of [fieldname]
ultrarequired='notequal_[fieldname]' checks its value against value of [fieldname]

other attributes are:
minval="1"
maxval="9"
minlength="2"
maxlength="4"


*/

var ffAlert = '';
var ffwarn = '';
function formValidator(form, meldingStart){
	var frm;
	switch(typeof form){
		case 'string':
			if (frm = eval('document.'+form)){
				//firefox ie8
			}else{
				//ie
				for(var i=0;i<document.forms.length;i++) {
					//alert(document.forms[i].name + ' ' + frm);
					if (document.forms[i].name == form) {
						frm = document.forms[i];

					}
				}
			}

			break;
		case 'object':
			frm = form;
			break;
	}
	var els = frm.elements
	//var valid;
	ffvalidateElement.radioGroepGecontroleerd = new Array();
	//loop door alle form elementen
	for (var i=0; i<els.length; i++){
		//disbaled en FIELDSET overslaan
		if (els[i].disabled || els[i].tagName == 'FIELDSET' ){
			continue;
		}
		//ultraform2 hidden panels overslaan
		if (frm.ultraForm){
			var formPanel = frm.ultraForm.getFormPanel(els[i]);
			if (formPanel && formPanel.offsetWidth == 0 && formPanel.offsetHeight == 0){
					continue
			}
		}
		//|| (getAttributeWaarde(els[i], 'type') != 'hidden' && els[i].offsetWidth == 0 && els[i].offsetHeight == 0  )
		ffvalidateElement(els[i]);
	}


	//focus param reset
	ffvalidateElement.focus = false;

	if (ffAlert != ''){

		alert((meldingStart?meldingStart+'\n':'')+ffAlert);
		ffAlert = '';
		return false;
	}else if (ffwarn != ''){
		var ok = confirm(T_FFLETOP + "\n" + ffwarn + T_FFDOORGAAN);
		ffwarn = '';
		return ok;
	}else{
		// custom validatie functie? (o.a. eduroute persoongrd)
		try {
			eval('var validateExists = typeof('+form.id+'Validate)');
			if (validateExists == 'function') {
				eval('var customFormValidate = '+form.id+'Validate');
//			if (typeof(customFormValidate) == 'function'){
				return customFormValidate(frm);
			}
		} catch(err) {
		}

		// custom validate functie?
		if (typeof(customValidate) == 'function'){
			return customValidate(frm.elements);
		}
		return true;
	}
}

function ffvalidateElement(element){
	var result;



	var checks = getChecks(element);
	//attributen = attributen[0];

	//voer de check uit
	switch(getAttributeWaarde(element, 'type')){
		case 'checkbox':
		case 'checkBox':
		case 'radio':
			//bepaal de groep waar dit component bij
			var groepArr = ffgetelementGroep(element);
			var groepNaam = groepArr[0];
			var groep = groepArr[1];
			if (!getAttributeWaarde(element, 'titel') ){element.namedAttributes['titel'] = groepNaam;}
			if (ffvalidateElement.radioGroepGecontroleerd[groepNaam]){
				//deze is al eens gecontroleerd

			}else{
				var warn = (typeof(checks['ultrawarn']) == 'undefined' ? false : true);
				result = ffValidateGroep(groepNaam, groep, checks);
			}
			break;
		case 'textarea':
		case 'text':
		case 'password':
		case 'hidden':
		case 'select':
			//trim (kan niet bij file want daar kunnen we de value niet zetten
			element.value = element.value.replace(/^\s+/,'');
			element.value = element.value.replace(/\s+$/,'');
		case 'file':
			//ultrarequired of ultraoptional met waarde ingevuld  of ultrawarn
			if (checks['ultrarequired'] || (checks['ultraoptional'] && element.value != '') || checks['ultrawarn']) {
				var functie;
				var warn = false;
				if (checks['ultrarequired'] ){
					functie = checks['ultrarequired']
				}else if (checks['ultraoptional']){
					functie = checks['ultraoptional']
				}else{
					functie = checks['ultrawarn'];
					warn = true;
				}
				
				var param;
				if(functie.substring(0,6) == 'equal_'){
					param = functie.substring(6);
					functie='equal';
				} else if(functie.substring(0,9) == 'notequal_'){
					param = functie.substring(9);
					functie='notequal';
				}else{
					param = undefined;
				}
				if (functie != "" && functie != false){
					try {
						eval('runfunctie = ffvalidate_'+functie);
					} catch (exception) {
						runfunctie = 'error';
					}

					if (typeof runfunctie == 'function'){
						result = runfunctie(element, param);
					} else {
						if (base == "http://localhost/test.iddink.nl/"){
							alert('Warning: formavalidator functie "ffvalidate_'+functie+'" bestaat niet (deze melding verschijnt alleen op localhost)');
						}
						result = ffvalidate_true(element);
					}
				}
			}
			if (result == undefined || result === true){
				//hij is nog valid rest van de checks minval maxval enz
				var checkresult;
				for (var key in checks){
					if (key != 'ultrarequired' && key != 'ultraoptional'&& key != 'ultrawarn'){ // deze zijn al gechekt
						if (eval('typeof(ffvalidate_'+key+')') == 'function' ){
							checkresult = eval('ffvalidate_'+key+'(element, checks[key])');
						}
						if (checkresult !==true){
							result = checkresult;
							//important hij kan anders weer true worden!
							break; //break uit de for loop
							//checks = undefined;
						}
					}
				}

			}
			break;

	}
	if (result != undefined && result !== true){
		
		if (warn){
			ffwarn += getWarnMelding(element);
		}else{
			ffAlert += getErrorMelding(result, element);
		}
		if (!ffvalidateElement.focus){
			if( element.type != 'hidden' && element.style.display != 'none'  && !element.disabled ){
				element.focus();
				ffvalidateElement.focus = true;
			}
		}
	}
}

function ffValidateGroep(groepNaam, groep, checks){
	var aantalChecked = 0;
	var result;
	if (groep.length == undefined){
		//er is maar 1 element
		if (groep.checked == true) {
			aantalChecked = 1

		}
	}else{
		for(var q=0; q<groep.length; q++){
			if (groep[q].style.display == 'none') continue;
			if((groep[q].type == 'text' && groep[q].value != '') || (groep[q].checked == true)){
				aantalChecked++;
			}
		}
	}

	if ((typeof(checks['minaantal']) != 'undefined') && (aantalChecked < checks['minaantal'])){
		result = T_FFGROEPMIN.replace('[-checkwaarde-]', checks['minaantal']);
	}else if((typeof(checks['maxaantal']) != 'undefined')  && aantalChecked > checks['maxaantal']){
		result = T_FFGROEPMAX.replace('[-checkwaarde-]', checks['maxaantal']);
	}else if (typeof(checks['ultrarequired']) != 'undefined' || typeof(checks['ultrawarn']) != 'undefined'){
		var	functie = (typeof(checks['ultrarequired']) != 'undefined' ? checks['ultrarequired'] : checks['ultrawarn']);
		if (functie == 'true' && aantalChecked <=0){
			result = T_FFGROEPTRUE;
		}else if (eval('typeof(ffvalidate_'+functie+')') == 'function' ){
			result = eval('ffvalidate_'+functie+'(groepNaam, groep, checks);');
		}else{
			if (base == "http://localhost/test.iddink.nl/"){
				alert('Warning: formavalidator functie "ffvalidate_'+functie+'" bestaat niet (deze melding verschijnt alleen op localhost)');
			}
		}
	}

	ffvalidateElement.radioGroepGecontroleerd[groepNaam] = true;
	return result;
}
function getErrorMelding(validatorResult, element){
	var errorMelding;
	if (getAttributeWaarde(element, 'error')){
		 errorMelding = getAttributeWaarde(element, 'error') + "\n";
	}else{
		var naam = getVeldNaam(element);
		errorMelding = validatorResult.replace('[-naam-]', naam) + "\n";
	}
	return errorMelding;

}
function getWarnMelding(element){
	var errorMelding;
	if (getAttributeWaarde(element, 'warning')){
		 errorMelding = getAttributeWaarde(element, 'warning') + "\n";
	}else{
		errorMelding = 'warning niet gezet'+ "\n";
	}
	return errorMelding;

}

function getChecks(element){
	var checks = new Array()
	setNamedAttributes(element);
	for (var property in element.namedAttributes){
		if ('ultrarequired, ultraoptional, ultrawarn, minval, maxval, minlength, maxlength, minaantal, maxaantal'.indexOf(property) !== -1){
			checks[property] = element.namedAttributes[property];
		}
	}
	return checks;
}
function getAttributeWaarde(element, property){
	setNamedAttributes(element);
	if (typeof element.namedAttributes[property] != 'undefined') {
		return element.namedAttributes[property];
	} else {
		return false;
	}
}
function setNamedAttributes(element){
	if (typeof element.namedAttributes == 'undefined'){
		element.namedAttributes = new Array();
		for (var i=0; i<element.attributes.length; i++){
			element.namedAttributes[element.attributes[i].nodeName.toLowerCase()] = element.attributes[i].nodeValue;
		}
		if (element.tagName.toLowerCase() == 'select') {
			element.namedAttributes['type'] = 'select';
		}
		if (element.tagName.toLowerCase() == 'textarea') {
			element.namedAttributes['type'] = 'textarea';
		}
		}
}

function getVeldNaam(element){
	return (getAttributeWaarde(element, 'titel')? getAttributeWaarde(element, 'titel') : (getAttributeWaarde(element, 'caption')? getAttributeWaarde(element, 'caption') : element.name));
}
function ffvalidate_notequal(element, equalVeld){
	try{
		equalVeld = eval('element.form.'+equalVeld);
	}catch(ex){
		equalVeld = new Object;
		equalVeld.value = 'error: veld niet gevonden';

	}
	if (element.value != equalVeld.value){
		return true;
	}else{
		return T_FFNOTEQUAL.replace('[-naam2-]', getVeldNaam(equalVeld));
	}
}
function ffvalidate_equal(element, equalVeld){
	try{
		equalVeld = eval('element.form.'+equalVeld);
	}catch(ex){
		equalVeld = new Object;
		equalVeld.value = 'error: veld niet gevonden';

	}
	if (element.value == equalVeld.value){
		return true;
	}else{
		return T_FFEQUAL.replace('[-naam2-]', getVeldNaam(equalVeld));
	}
}
function ffvalidate_minval(element, checkwaarde){
	if (ffvalidate_true(element) === true && ffvalidate_integer(element) == true && parseInt(element.value, 10) >=  checkwaarde){
		return true;
	}else{
		return T_FFMINVAL.replace('[-checkwaarde-]', checkwaarde);
	}
}
function ffvalidate_maxval(element, checkwaarde){
	if (ffvalidate_true(element) === true && ffvalidate_integer(element) == true && parseInt(element.value, 10) <=  checkwaarde){
		return true;
	}else{
		return T_FFMAXVAL.replace('[-checkwaarde-]', checkwaarde);
	}
}
function ffvalidate_minlength(element, checkwaarde){
	if (element.value.length >=  checkwaarde){
		return true;
	}else{
		return T_FFMINLENGTH.replace('[-checkwaarde-]', checkwaarde);
	}
}
function ffvalidate_maxlength(element, checkwaarde){
	var waardeLengte;
	// uitzondering maken voor textarea
	if (getAttributeWaarde(element, 'type') == 'textarea'){
		// om het daadwerkelijke aantal tekens dat in de database wordt geplaatst te bepalen, worden de linebreaks vervangen, in html/javascript wordt dit niet goed berekend
		waardeLengte = element.value.replace(/\n/g, "\n\r").length;
	} else {
		waardeLengte = element.value.length;
	}
	
	if (waardeLengte <= checkwaarde){
		return true;
	}else{
		return T_FFMAXLENGTH.replace('[-checkwaarde-]', checkwaarde);
	}
}
function ffvalidate_true(element){
	if ((element.value != '')){
		return true;
	}else{
		if (element.tagName == 'SELECT'){
			return T_FFGROEPTRUE;
		} else {
			return T_FFTRUE;
		}
	}
}
function ffvalidate_integer(element){
	if (ffvalidate_true(element)===true && ffis_int(element.value, true) === true){
		return true;
	}else{
		return T_FFINTEGER;
	}
}

function ffvalidate_number(element){
	if (ffvalidate_true(element)===true &&  !isNaN(element.value.replace(',', '.') * 1)){
		return true;
	}else{
		return T_FFNUMBER;
	}
}

function ffvalidate_postcode(element, land){
	var landcode = bepaalLandCode(element, land);

	switch (landcode){
		case 'NL':
			return ffvalidate_postcode_NL(element);
			break;
		case 'BE':
			return ffvalidate_postcode_BE(element);
			break;
		case 'DE':
			return ffvalidate_postcode_DE(element);

			break;
		case 'ES':
			return ffvalidate_postcode_ES(element);

			break;
	}


}

function ffvalidate_postcode_NL(element){
	var postcode = element.value;
	if (postcode.length == 7){
		var cijfers  = postcode.substr(0, 4);
		var spatie = postcode.substr(4, 1);
		var letters = postcode.substr(5, 2)
		var alphaExp = /^[a-zA-Z]+$/;
		if (!isNaN(cijfers) && cijfers >= 1000 && spatie == ' ' && letters.match(alphaExp)){
			return true;
		}
	}
	return T_FFPOSTCODE;
}

function ffvalidate_postcode_BE(element){
	// 4 cijfers 1000 t/m 9999
	var postcode = element.value;
	if (postcode.length == 4){
		if (!isNaN(postcode) && postcode >= 1000){
			return true;
		}
	}
	return T_FFPOSTCODE;
}

function ffvalidate_postcode_DE(element){
	// 5 cijfers van 01001 t/m 97999
	var postcode = element.value;
	if (postcode.length == 5){
		if (!isNaN(postcode) && postcode >= 01001 && postcode <= 97999){
			return true;
		}
	}
	return T_FFPOSTCODE;
}

function ffvalidate_postcode_ES(element){
	 // 5 cijfers van 01001 t/m 52999
	var postcode = element.value;
	if (postcode.length == 5){
		if (!isNaN(postcode) && postcode >= 01001 && postcode <= 52999){
			return true;
		}
	}
	return T_FFPOSTCODE;
}

function ffvalidate_email(element) {
	var emailStr = element.value;
	/* The following is the list of known TLDs that an e-mail address must end with. */
	var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;

	/* The following pattern is used to check if the entered e-mail address
	fits the user@domain format.  It also is used to separate the username
	from the domain. */
	var emailPat=/^(.+)@(.+)$/;

	/* The following string represents the pattern for matching all special
	characters.  We don't want to allow special characters in the address.
	These characters include ( ) < > @ , ; : \ " . [ ] */
	var specialChars="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";

	/* The following string represents the range of characters allowed in a
	username or domainname.  It really states which chars aren't allowed.*/
	var validChars="\[^\\s" + specialChars + "\]";

	/* The following pattern applies if the "user" is a quoted string (in
	which case, there are no rules about which characters are allowed
	and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com
	is a legal e-mail address. */
	var quotedUser="(\"[^\"]*\")";

	/* The following pattern applies for domains that are IP addresses,
	rather than symbolic names.  E.g. joe@[123.124.233.4] is a legal
	e-mail address. NOTE: The square brackets are required. */
	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;

	/* The following string represents an atom (basically a series of non-special characters.) */
	var atom=validChars + '+';

	/* The following string represents one word in the typical username.
	For example, in john.doe@somewhere.com, john and doe are words.
	Basically, a word is either an atom or quoted string. */
	var word="(" + atom + "|" + quotedUser + ")";

	// The following pattern describes the structure of the user
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$");

	/* The following pattern describes the structure of a normal symbolic
	domain, as opposed to ipDomainPat, shown above. */
	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");

	/* Finally, let's start trying to figure out if the supplied address is valid. */

	/* Begin with the coarse pattern to simply break up user@domain into
	different pieces that are easy to analyze. */
	var matchArray=emailStr.match(emailPat);

	if (matchArray==null) {
		/* Too many/few @'s or something; basically, this address doesn't
		even fit the general mould of a valid e-mail address. */
		//alert("Email address seems incorrect (check @ and .'s)");
		return T_FFEMAIL;
	}
	var user=matchArray[1];
	var domain=matchArray[2];

	// Start by checking that only basic ASCII characters are in the strings (0-127).
	for (i=0; i<user.length; i++) {
		if (user.charCodeAt(i)>127) {
			//alert("Ths username contains invalid characters.");
			return T_FFEMAIL;
		}
	}
	for (i=0; i<domain.length; i++) {
		if (domain.charCodeAt(i)>127) {
			//alert("Ths domain name contains invalid characters.");
			return T_FFEMAIL;
		}
	}

	// See if "user" is valid
	if (user.match(userPat)==null) {
		// user is not valid
		//alert("The username doesn't seem to be valid.");
		return T_FFEMAIL;
	}

	/* if the e-mail address is at an IP address (as opposed to a symbolic
	host name) make sure the IP address is valid. */
	var IPArray=domain.match(ipDomainPat);
	if (IPArray!=null) {
		// this is an IP address
		for (var i=1;i<=4;i++) {
			if (IPArray[i]>255) {
				//alert("Destination IP address is invalid!");
				return T_FFEMAIL;
			}
		}
		return true;
	}

	// Domain is symbolic name.  Check if it's valid.
	var atomPat=new RegExp("^" + atom + "$");
	var domArr=domain.split(".");
	var len=domArr.length;
	for (i=0;i<len;i++) {
		if (domArr[i].search(atomPat)==-1) {
			//alert("The domain name does not seem to be valid.");
			return T_FFEMAIL;
		}
	}

	// Make sure there's a host name preceding the domain.
	if (len<2) {
		//alert("This address is missing a hostname!");
		return T_FFEMAIL;
	}

	// If we've gotten this far, everything's valid!
	return true;
}

function ffvalidate_date(element){

	var minMax = getDatepickerMinMaxDatum(element);
	var datumArr;

	if (element.value.indexOf('-') != -1) datumArr = element.value.split('-');
	//if (element.value.indexOf(' ') != -1) datumArr = element.value.split(' ');
	//if (element.value.indexOf('.') != -1) datumArr = element.value.split('.');
	//if (element.value.indexOf('/') != -1) datumArr = element.value.split('/');

	if(datumArr && datumArr.length==3 &&
		(ffvalidate_dag(datumArr[0], minMax, datumArr[1], datumArr[2]))===true &&
		(ffvalidate_maand(datumArr[1], minMax, datumArr[2]))===true &&
		(ffvalidate_jaar(datumArr[2], minMax))===true
		){
		return true;
	}else{
		return T_FFDATE;
	}
}
/*kan alleen het formaat 14:23  (H:i) aan */
function ffvalidate_tijd(element){
	var valid = false;
	var startTijd = element.attributes.getNamedItem("startTijd");
	if (startTijd) {
		startTijd = startTijd.nodeValue.split(':');
		// Geef het 10tallig talstelsel mee, anders ziet JS een octaal getal
		startTijd[0] = parseInt(startTijd[0], 10);
		startTijd[1] = parseInt(startTijd[1], 10);
	}else{
		startTijd = new Array(00, 00);
	}
	var eindTijd = element.attributes.getNamedItem("eindTijd")
	if (eindTijd) {
		eindTijd = eindTijd.nodeValue.split(':');
		// Geef het 10tallig talstelsel mee, anders ziet JS een octaal getal
		eindTijd[0] = parseInt(eindTijd[0], 10);
		eindTijd[1] = parseInt(eindTijd[1], 10);
	}else{
		eindTijd = new Array(23, 59);
	}

	var tijdArr = element.value.split(':');
	// Geef het 10tallig talstelsel mee, anders ziet JS een octaal getal
	tijdArr[0] = parseInt(tijdArr[0], 10);
	tijdArr[1] = parseInt(tijdArr[1], 10);
	//check uren
	if (tijdArr[0] > startTijd[0] && tijdArr[0] < eindTijd[0]){
		if (tijdArr[1] >= 0 && tijdArr[1] <= 59 ){
			valid = true;
		}
	}else if (tijdArr[0] == startTijd[0]){
		//start uur dus start check
		if (tijdArr[1] >= startTijd[1] && tijdArr[1] <= 59){
			valid = true;
		}
	}else if (tijdArr[0] == eindTijd[0]){
		//eind uur dus eind check
		if (tijdArr[1] >= 0 && tijdArr[1] <= eindTijd[1]){
			valid = true;
		}
	}
	if (valid){
		return true;
	}else{
		return T_FFIME;
	}
}
function ffvalidate_dateTime(element){
	var valid = false;
	var dateTimeArr = element.value.split(' ');
	if (dateTimeArr.length == 2){
		//datum controleren
		var GUID = element.name.substring(1);
		eval('var dateComp = element.form.Date'+GUID+';');
		if (ffvalidate_date(dateComp)===true){
			//tijd controleren
			eval('var tijdComp = element.form.Tijd'+GUID+';');
			if (ffvalidate_tijd(tijdComp)===true){
				valid = true;
			}

		}


	}
	if (valid){
		return true;
	}else{
		return T_FFDATETIME;
	}
}

function ffvalidate_dag(dag, minMax, maand, jaar, deelControle){
	if (typeof dag == 'object') dag = dag.value;
	//if deelControle dan is als 0 ook valid (deelcontrole is voor check tijdens typen)
	var maandDagen, maxDagen;

	var maandInt = parseInt(maand, 10);
	if (!maand  || maandInt == 1 || maandInt == 3 || maandInt == 5 ||maandInt == 7 ||maandInt == 8 ||maandInt == 10 ||maandInt == 12){
		maandDagen = 31
	}else if (maandInt == 2) {
		var isSchrikkel = false;
		if (!jaar || jaar.length != 4){
			//jaar niet compleet dus niet te checken
			isSchrikkel = true;
		}else if (jaar/4 == parseInt(jaar/4, 10)){
			isSchrikkel = true;
			if(jaar/100 == parseInt(jaar/100, 10)){
				isSchrikkel = false;
				if(jaar/400 == parseInt(jaar/400, 10)) {
					isSchrikkel = true;
				}
			}
		}
		if(isSchrikkel){
			maandDagen = 29;
		}else{
			maandDagen = 28;
		}
	}else{
		maandDagen = 30;
	}

	//bepaal de max dag
	if (((jaar && jaar == minMax.max.jaar) || minMax.min.jaar == minMax.max.jaar) && ((maand && maand == minMax.max.maand) || (minMax.min.maand == minMax.max.maand && minMax.min.jaar == minMax.max.jaar))){
		maxDagen = minMax.max.dag;
	}else{
		maxDagen = maandDagen;
	}
	//bepaal de min dag
	var minDagen;
	if (((jaar && jaar == minMax.min.jaar) || minMax.min.jaar == minMax.max.jaar) && ((maand && maand == minMax.min.maand) || (minMax.min.maand == minMax.max.maand && minMax.min.jaar == minMax.max.jaar))){
		minDagen = minMax.min.dag;
	}else{
		minDagen = "01";
	}

	/*maxDagen = ((((jaar && jaar == minMax.min.jaar) || minMax.min.jaar == minMax.max.jaar) &&
			((maand && maand == minMax.min.maand) || minMax.min.maand == minMax.max.maand)) ? minMax.min.dag : maandDagen);*/
	if (isNaN(dag) ||
			(dag.length > 2) ||
			(deelControle && dag < parseInt(minDagen.toString().substr(0, dag.toString().length), 10) ) ||
			(deelControle && dag > parseInt(maxDagen.toString().substr(0, dag.toString().length), 10) ) ||
			(!deelControle && dag < parseInt(minDagen, 10))  ||
			(!deelControle && dag > parseInt(maxDagen, 10))
		){

		return T_FFDAG;
	}else{
		return true;
	}
}

function ffvalidate_maand(element, minMax, jaar, deelControle){
	if (typeof element == 'object') {
		var maand = element.value;
		if (minMax == undefined) {minMax = getDatepickerMinMaxDatum(element)};
	}else{
		var maand  = element;
		if (!minMax) return 'Error 1 : Maand';
	}
	//if deelControle dan is als 0 ook valid (deelcontrole is voor check tijdens typen)
	var minMaand = (((jaar && jaar == minMax.min.jaar) || minMax.min.jaar == minMax.max.jaar) ? minMax.min.maand : 1);
	var maxMaand = (((jaar && jaar == minMax.max.jaar) || minMax.min.jaar == minMax.max.jaar) ? minMax.max.maand : 12);
	if (isNaN(maand) ||
			(maand.length > 2) ||
			(deelControle && maand < parseInt(minMaand.toString().substr(0, maand.toString().length), 10)) ||
			(deelControle && maand > parseInt(maxMaand.toString().substr(0, maand.toString().length), 10)) ||
			(!deelControle && maand < parseInt(minMaand, 10)) ||
			(!deelControle && maand > parseInt(maxMaand, 10))
		){
		return T_FFMAAND;
	}else{
		return true;
	}
}

function ffvalidate_jaar(element, minMax, deelControle){
	if (typeof element == 'object') {
		var jaar = element.value;
		if (minMax == undefined) {minMax = getDatepickerMinMaxDatum(element)};
	}else{
		var jaar  = element;
		if (!minMax) return 'Error 2 : Jaar';
	}

	if (isNaN(jaar) ||
			(jaar.length > 4) ||
			(deelControle && jaar < parseInt(minMax.min.jaar.toString().substr(0, jaar.toString().length), 10)) ||
			(deelControle && jaar > parseInt(minMax.max.jaar.toString().substr(0, jaar.toString().length), 10)) ||
			(!deelControle && jaar < parseInt(minMax.min.jaar, 10)) ||
			(!deelControle && jaar > parseInt(minMax.max.jaar, 10))
		){
		return T_FFJAAR;
	}else{
		return true;
	}
}

function ffvalidate_phone(element){
	return ffvalidate_telefoonnr(element);
}

function ffvalidate_telefoonnr(element, landElement){
	if(ffvalidate_true(element) === true){
		var landcode;
		var telNr = element.value;
		telNr = telNr.replace(' ', '');
		telNr = telNr.replace(/[,.-]/g, '')//replace spatie en . -
		var intMelding = ffvalidate_integer({value : telNr});
		if (intMelding  === true){

			landcode = bepaalLandCode(element, landElement);
			switch(landcode){
				case 'NL':
					if (telNr.length ==10){
						return true;
					}
					break;
				case 'BE':
				case 'DE':
					//TODO
					return true;
					break;
				case 'ES':
					// 0 begint 10 cijfera
					//anders 9
					if ((telNr.substr(0,1) == 0 && telNr.length ==10) || telNr.length == 9){
						return true;
					}
					break;
			}
		}
	}
	return T_FFTELEFOONNR;
}

function ffvalidate_bankrekeningnr(element, landElement){
	if(ffvalidate_true(element)===true){
		var landcode;
		var bankNr = element.value;
		var result = false;
		bankNr = bankNr.replace(' ', '');
		bankNr = bankNr.replace(/[,.-]/g, '')//replace spatie en . -
		var intMelding = ffvalidate_integer({value : bankNr});
		if (intMelding  !== true){
			return intMelding;
		}
		landcode = bepaalLandCode(element, landElement);
		switch(landcode){
			case 'BE':
				//test nr 9796-499188-96
				nummer = bankNr.toString();
				if (nummer.length == 12){
					var nummer = bankNr.substr(0, 10);
					var controle = bankNr.substr(10, 2);
					var rest = (nummer % 97);
					rest = (rest==97 ? 0 : rest);
					if (rest == controle){
						result = true;
						//return true;
					}
				}
				break;
			case 'DE':
				// formaat: XXXXXX-YY-ZZZZZZZZZZZZZ (X = 6 getallen, Y = 2 getallen, Z = 2-13 getallen)
				var bankrekeningArr = element.value.split('-');
				if (typeof bankrekeningArr[0] != 'undefined' && typeof bankrekeningArr[1] != 'undefined' && typeof bankrekeningArr[2] != 'undefined'){
					
				if (ffis_int(bankrekeningArr[0]+bankrekeningArr[1]+bankrekeningArr[2], true) && 
						bankrekeningArr[0].length == 6 && bankrekeningArr[1].length == 2 && bankrekeningArr[3].length >= 2 && bankrekeningArr[3].length <= 13){ 
						result = true;
					}						
				}							
				break;
			case 'ES':
				nummer = bankNr.toString();
				if (nummer.length > 10 &&  nummer.length <= 20) {
					var bank = nummer.substr(0,4);
					var branch = nummer.substr(4,4);
					var digits = nummer.substr(8,2);
					var account = nummer.substr(10);

					var d = ffbepaalBakrekNrSpanjeDigit(bank + branch);
					//d = d * 10;
					d = d.toString() + ffbepaalBakrekNrSpanjeDigit(account).toString();

					result = (d == digits);
					//return (d == digits);
				}
				//return false;
				break;
			case 'NL':
				switch(bankNr.length){
					case 9:
						bankNr = '0'+bankNr;
						//geen break
					case 10:
						var j = 10;
						var i = 0;
						var totaal = 0;
						var nummer = 0;
						if (bankNr.length == 10){
							for (i=1; i<=10; i++){
								nummer = parseInt(bankNr.substring(i-1,i),10);
								totaal += (nummer*j);
								j = j - 1;
							}
							if ((totaal / 11) != Math.round(totaal / 11)) {
							}else{
								result = true;
								//return true;
							}
						}

						break;
					default:
						if (bankNr.length >= 1 && bankNr.length <= 7){
							//postbank
							result = true;
							//return true;
						}
				}
				break;
		}
	}
	if (result) {
		// banknummer zonder format in het component zetten
		element.value = bankNr;

		return result;
	} else {
		return T_FFBANKREKENINGNR;
	}
}

function ffvalidate_IBAN(element){
	var nummerStr = '', nummer, i;
	var charToIBANIntStr = function(c){
		if (c >= 0 && c <= 9){
			return c;
		}else{
			var result = ("0" + ((c.charCodeAt(0) - 'A'.charCodeAt(0))+10)).toString();
			return result.substr((result.length-2));
		}
	}
	var strModInt = function(s, i){
		var tmpString = '';
		while (s.length >0 ){
			tmpString = tmpString + s.substr(0, 1);
			s = s.substr(1);
			tmpString = parseInt(tmpString, 10) % i;
		}
		return parseInt(tmpString, 10);
	}
	var IBAN = element.value.replace(/ /gi, '').replace(/-/g, '');
	var controlegetal = IBAN.substr(2, 2);
	IBAN = IBAN.substr(4) + IBAN.substr(0, 2)+'00';
	for (i=0; i<IBAN.length; i++){
		nummerStr = nummerStr + charToIBANIntStr(IBAN.substr(i, 1));
	}
	nummer = strModInt(nummerStr, 97);
	if ((98-nummer) == controlegetal){
		return true;
	}else{
		return T_FFIBAN;
	}
}

function ffbepaalBakrekNrSpanjeDigit(nummer){
	var toevoegen = (10 - nummer.length)
	for (var i = 0; i<toevoegen; i++){
		nummer = "0"+nummer;
	}

	var weights = new Array( 1 , 2 , 4 , 8 , 5 , 10 , 9 , 7 , 3 , 6 );
	var s = 0, d

	for (i=0; i<10; i++){
		d = parseInt(nummer.substr(i, 1),10);
		s += d * weights[i];
	}

	var result = (11 - (s% 11));
	if (result == 10) {
		result = 1;
	}else if (result == 11) {
		result = 0;
	}
	return result;
}

function ffvalidate_website(element){
	var waarde = element.value;
	if (waarde.substr(0, 7) == 'http://'){
		waarde = waarde.substr(7);
	} else if (waarde.substr(0, 8) == 'https://'){
		waarde = waarde.substr(8);
	} else {
		return T_FFWEBSITE;
	}
	var waardeArray = waarde.split('/');

	/*Regular Expression voor het gedeelte tussen http(s):// en de eerst volgende slash (/)*/
	var regexp = /^([a-zA-Z0-9]+)(([\-]*)([a-zA-Z0-9]+))*(([\.]?)([a-zA-Z0-9]+))*([\-]*)([a-zA-Z0-9]+)([\.])([a-zA-Z0-9]{2,6})$/;
	var result = regexp.test(waardeArray[0]);
	if (result){
		return true;
	}else{
		return T_FFWEBSITE;
	}
}
function ffvalidate_ucfirst(element){
	var res = ffvalidate_true(element);
	if (res === true){
		element.value = element.value.charAt(0).toUpperCase()+element.value.substring(1,(element.value.length)).toLowerCase();
		return true;
	}else{
		return res;
	}
}

function ffvalidate_ucWoorden(element){
	var res = ffvalidate_true(element);
	if (res === true){
		element.value = element.value.toLowerCase();
		element.value = element.value.replace(/^(.)|\s(.)/g, function ( $1 ) {
			return $1.toUpperCase ( );
		});
		return true;
	}else{
		return res;
	}
}

function ffvalidate_lowercase(element){
	var res = ffvalidate_true(element);
	if (res === true){
		element.value = element.value.toLowerCase();
		return true;
	}else{
		return res;
	}
}

function ffvalidate_uppercase(element){
	var res = ffvalidate_true(element);
	if (res === true){
		element.value = element.value.toUpperCase();
		return true;
	}else{
		return res;
	}
}

function ffvalidate_password(element){
	return ffvalidate_true(element);
}

function getDatepickerMinMaxDatum(element){
	//haal de min en maxdate uit de datepicker
	var min = new Object, max = new Object();
	if ($$.datepicker){

		//element.focus(); //zodat de curInst goed staat
		var inst = $$.data(element, 'datepicker');

		if (inst){
			min.date = $$.datepicker._getMinMaxDate(inst, "min", true);
			max.date = $$.datepicker._getMinMaxDate(inst, "max");
		}
	}
	if (min.date){
		min.jaar = min.date.getFullYear().toString();
		min.maand = min.date.getMonth()+1;// in js begint maand bij 0
		min.maand = min.maand.toString();
		min.dag = min.date.getDate().toString();
		//set voorloopnullen
		if (min.dag.length ==1) min.dag = "0"+min.dag;
		if (min.maand.length ==1) min.maand = "0"+min.maand;
	}else{
		min.jaar = "1800"
		min.maand = "01";
		min.dag = "01";
	}

	if (max.date){
		max.jaar = max.date.getFullYear().toString();
		max.maand = max.date.getMonth()+1; // in js begint maand bij 0
		max.maand = max.maand.toString();
		max.dag = max.date.getDate().toString();
		if (max.dag.length ==1) max.dag = "0"+max.dag;
		if (max.maand.length ==1) max.maand = "0"+max.maand;
	}else{
		max.jaar = "2999"
		max.maand = "12";
		max.dag = "31";
	}
	return {min: min, max : max}
}
function ffis_int(value, allowString){
	if (allowString && typeof value === 'string') {
		var intval = parseInt(value, 10);
		if (intval != value){ //string integer compore lever true op
			return false;
		}else{
			value= intval;
		}
	}
	if (typeof value !== 'number') {
		return false;
	}
	if (parseFloat(value) != parseInt(value, 10)) {
			return false;
	}
	return true;
}

function ffFormatWebsite(websiteElement){
	var waarde = websiteElement.value;
	if (waarde && waarde.substr(0, 7) != 'http://' && waarde.substr(0, 8) != 'https://'){
		websiteElement.value = 'http://'+websiteElement.value;
	}
}

function ffFormatPostcode(postcodeElement, landElement){
	var landcode
	var postcode = postcodeElement.value;
	if(postcode != ''){
		landcode = bepaalLandCode(postcodeElement, landElement);

		//check de postcode
		//format
		switch(landcode){
			case 'BE':
			case 'DE':
			case 'ES':
				//geen spaties
				postcode = postcode.split(' ').join('');
				break;
			case 'NL':
				//4 karakters spatie 2(rest) karakters
				postcode = postcode.toUpperCase().split(' ').join('');
				//spatie op juiste plaats terug zetten
				postcode = postcode.substring(0,4) + ' ' + postcode.substr(4, (postcode.length-4));
				break;
		}
		if (ffvalidate_postcode({value : postcode}, landcode)===true){
			postcodeElement.value = postcode;
			//bij ultraform2 niet automatisch
			if (postcodeElement.form && !postcodeElement.form.ultraForm){
				getStraatWoonplaats(postcodeElement);
			}
		}
	}
}


function getStraatWoonplaats(element){
	var form = element.form;
	if (form.ultraForm){
		//ultraform2
		localeID = getAttributeWaarde(element, 'localeid');
		var locale = form.ultraForm.config.locale[localeID];
		var postcodeObject = $('C'+locale.postcodeGUID);
		var huisnummerObject = $('C'+locale.huisnummerGUID);
		var straatObject = $('C'+locale.straatGUID);
		var woonplaatsObject = $('C'+locale.woonplaatsGUID);
		var landObject = $('C'+locale.landGUID);
		var landcode = locale.land;
		var formGUID = form.ultraForm.config.formGUID;
	}else{
		//ultraform1
		var localeID = undefined;
		var postcodeObject = form.postcodeObject;
		var huisnummerObject = form.huisnummerObject;
		var straatObject = form.straatObject;
		var woonplaatsObject =form.woonplaatsObject;
		var landcode = undefined;
		var landObject = undefined;
		var formGUID = form.formGUID.value;
		if (!postcodeObject){
			// Hier eruit gaan, in ultraform1 is niet altijd getStraatWoonplaats gevuld, terwijl de functie daar wel vanuit gaat
			return;
		}
	}
	if (!landcode) {
		var landcode = bepaalLandCode(postcodeObject, landObject);
	}
	if (postcodeObject && ffvalidate_postcode(postcodeObject, landcode)===true && huisnummerObject && (straatObject || woonplaatsObject)){
		var parameters = '';
		switch(landcode){
			case 'NL':
				if (ffvalidate_integer(huisnummerObject) === true){
					parameters += 'localeID='+localeID+'&landcode='+landcode+'&postcode='+postcodeObject.value+'&huisnummer='+huisnummerObject.value+'&formGUID='+formGUID;
				}
				break;
			case 'BE':
				if (element == huisnummerObject){
					return;
				}
				woonplaatsObject.disabled = 'disabled';
				straatObject.disabled = 'disabled';
				woonplaatsObject.options.length = 0;

				if (woonplaatsObject.onchange){
					woonplaatsObject.onchange(woonplaatsObject);
				}
				straatObject.options.length = 0;
				if (straatObject.onchange){
					straatObject.onchange(straatObject);
				}
				parameters += 'localeID='+localeID+'&landcode='+landcode+'&postcode='+postcodeObject.value+'&formGUID='+formGUID;
				break;
			default:
				break;
		}
		if (parameters != ''){
			var ajax = new ajaxObject();
			ajax.onReady = function(result){
				switch(landcode){
					default:
						if (result.straat != undefined){
							straatObject.value = result.straat;
						}
						if (result.woonplaats != undefined){
							woonplaatsObject.value = result.woonplaats;
						}
						break;
					case 'BE':

						for (var i in result.woonplaats){
							addOptionToSelect(woonplaatsObject, i, result.woonplaats[i]);
						}
						for (var i in result.straat){
							addOptionToSelect(straatObject, i, result.straat[i]);
						}
						if (woonplaatsObject.options.length > 0){
							woonplaatsObject.disabled = '';
							straatObject.disabled = '';
							woonplaatsObject.focus();
						}else{
							var naam = getVeldNaam(postcodeObject);
							alert(T_FFPOSTCODE.replace('[-naam-]', naam));
							postcodeObject.focus();
						}
						break;
				}

			}
			ajax.load({
				actie : 'getStraatWoonplaats',
				parameters : parameters,
				validReturn : 'json',
				asynchroon : false
			});
		}
	}
}

function bepaalLandCode(element, landElement){

	var landcode;
	if (landElement != undefined && landElement.selectedIndex){
		// haal land van meegegeven element
		var land = landElement.options[landElement.selectedIndex].text;
		landcode = getLandCode(land);
	}else if (landcode =  getLandCode(landElement)){
		//landelemnt is een string met de landnaam
		//hij is al in de if gezet
	}else if (element.form && element.form.ultraForm){
		var localeID = getAttributeWaarde(element, 'localeid');
		if (!localeID){
			localeID = 0;
		}
		var locale = element.form.ultraForm.config.locale[localeID];
		if (locale.land){
			land  = locale.land;
		}else{
			var landObject = $('C'+locale.landGUID);
			var land = landObject.options[landObject.selectedIndex].text;
		}
		landcode = getLandCode(land);
	}else	if (landcode = getLandcodeFromElement(element)){
		//land bepaald via formulier
		//hij is al in de if gezet
	} /*else {
		landcode = 'NL'; //NL
	}*/
	if (landcode == false){
		landcode = 'NL';
	}
	return landcode;

}

function getLandcodeFromElement(element){

	//land kan een compGUID zijn of een string met het land
	// probeer dit
	var land;


	if (land = getLandCode(getAttributeWaarde(element, 'land'))){
		return land;
	}else if (element.form && element.form.landObject){
		try {
			var land = element.form.landObject.options[element.form.landObject.selectedIndex].text;
		} catch (exception) {
			//gaat fout dus land is gewoon landElement(string)
			land = element.form.landObject;
		}
		return getLandCode(land);
	}else{
		return false;
	}
}
/**
 * bepaalt de landcode op basis van een parameter
 * LET OP!! geen Default en geen stam ID bijvoegen gebruik dan de waarde via land = (element.selectedIndex?element.options[element.selectedIndex].value:'');
 */
function getLandCode(string){
	switch (string){
		case 'NL':
		case 'nl':
		case 'Nederland':
		case 'Nederland':
			return 'NL';
			break;
		case 'DE':
		case 'D':
		case 'Duitsland':
		case 'Germany':
			return 'DE';
			break;
		case 'BE':
		case 'be':
		case 'B':
		case 'Belgie':
		case 'België':
		case 'Belgium':
			return 'BE';
			break;
		case 'ES':
		case 'es':
		case 'E':
		case 'Spanje':
		case 'Spain':
		case 'Espaņa':
			return 'ES';
			break;
	}
	return false;
}

function ffgetelementGroep(element){
	var groep, groepNaam;
	switch(element.type){
		case 'radio':
			/*groep = eval('element.form.'+element.name);
			groepNaam = element.name;
			break;*/
		case 'checkbox':
			groep = new Array();
			var pos = element.name.lastIndexOf('[')
			if (pos != -1){
				groepNaam = element.name.substr(0,pos);
			}else{
				groepNaam = element.name;
			}
			var q=0;
			if (typeof(eval("element.form."+groepNaam)) != 'undefined'){
				groep = eval("element.form."+groepNaam)
			}else{
				var els = element.form.elements;
				for (var j=0; j<els.length; j++){
					if (els[j].name && els[j].name.substr(0, (pos+1)) == groepNaam+'['){
						groep[q] = els[j];
						q++;
					}
				}
			}
			break;
	}
	return Array(groepNaam, groep);
}

function numbersonly(e){
  var unicode=e.charCode? e.charCode : e.keyCode
	if ((unicode>=48 && unicode<=57) || 
		(unicode==8) || // backspace
		(unicode==9) || // tab
		(unicode==127) || // del
		(unicode == 46) || // komma
		(unicode == 44)|| // punt
		(unicode == 35)|| // end
		(unicode == 36)|| // home
		(unicode == 37)|| // left
		(unicode == 39)) // right
	{ 
    return true 
  } else {
    	alert(unicode);
    return false
  }
}