function trim(st)
{	
	return rTrim(lTrim(st));
}

function lTrim(st)
{	
	var tempSt = st;
	tempSt = tempSt.replace(/^\s+/,'');
	return tempSt;
}

function rTrim(st)
{
	var tempSt = st;
	tempSt = tempSt.replace(/\s+$/, '');
	return tempSt;
}

function transform(st, tp, arg1, arg2)
{
	while (st.indexOf(String.fromCharCode(160)) != -1) st = st.replace(String.fromCharCode(160), '') // ALT-255

	//pre: st is correct
	if (arg1!=null) arg1=parseInt(arg1);
	if (arg2!=null) arg2=parseInt(arg2);
	if(tp != null)
	switch(tp.toUpperCase())
    {
  	case "D":
  	st = st.replace(/^(\d{1})-$/,"0$1-");
	st = st.replace(/^(\d{2})-(\d{1})-$/,"$1-0$2-");

  	st = st.replace(/^(\d{2})(\d)/,"$1-$2");
  	st = st.replace(/^(\d{2}-\d{2})(\d)/,"$1-$2");
  	break;
  	case "IP4":
  	// Zet puntjes neer als gebruiker nul intypt
  	st = st.replace(/^([0])(\d)$/, "$1.$2");
  	st = st.replace(/^(\d{1,3}\.[0]{1})(\d)$/, "$1.$2");
  	st = st.replace(/^(\d{1,3}\.\d{1,3}\.[0]{1})(\d)$/, "$1.$2");

  	// Zet puntjes neer na drie getallen
  	st = st.replace(/^(\d{3})(\d)$/, "$1.$2");
  	st = st.replace(/^(\d{1,3}\.\d{3})(\d)$/, "$1.$2");
  	st = st.replace(/^(\d{1,3}\.\d{1,3}\.\d{3})(\d)$/, "$1.$2");

  	st = st.replace(/(\d{3})(\d{1,15})/, "$1");      // Vervang blokken van meer dan drie getallen
  	st = st.replace(/(\.)\./, "$1");                 // Vervang twee puntjes na elkaar
  	st = st.replace(/(0)(0{1,15})/, "$1");           // Vervang meerdere nullen in het laatste blok
  	st = st.replace(/(\.[0]{1,3})(\d{1,3})/, ".$2"); // Vervang nullen voor getallen
  	st = st.replace(/^0(\d{1,3})/, "$1");            // Vervang nullen voor getallen (eerste blok)
  	break;
  	case "A":
  		break;
  	case "A1":
  	//alles
  	//niets doen dus
  	break;
  	case "A2":
  	st = st.toUpperCase();
  	break;
  	case "A3":
  	var first = st.substr(0,1);
  	var tail = st.substr(1);
  	st = first.toUpperCase(first) + tail;
  	break;
  	case "A4":
  	st = st.toUpperCase();
  	break;
  	case "A5":
  	// Niets
  	break;
  	case "A6":
  	st = st.toLowerCase();
  	break;
  	case "PW2":
  	st = st.toUpperCase();
  	break;  	
  	case "N":
  	case "NL":
  	if (arg2>0)
  	{
  		var re1 = new RegExp("^(\\d{" + (arg1 - arg2 - 1).toString() +  "})(\\d)","g");
  		st = st.replace(re1, "$1,$2");
  	    st = st.replace(/^(\,|\.)(\d*)/,"0,$2");
  		st = st.replace(/\./,",");
    }
    break
    case "N2":
  	if (arg2>0)
  	{
  		var re1 = new RegExp("^(-?\\d{" + (arg1 - arg2 - 1).toString() +  "})(\\d)","g");
  		st = st.replace(re1, "$1,$2");
  	    st = st.replace(/^(\,|\.)(\d*)/,"0,$2");
  		st = st.replace(/\./,",");
    }
    break
  	case "N3":
    break
    case "N4":
  	if (arg2>0)
  	{
  		var re1 = new RegExp("^(-\\d{" + (arg1 - arg2 - 1).toString() +  "})(\\d)","g");
  		st = st.replace(re1, "$1,$2");
  	    st = st.replace(/^(\,|\.)(\d*)/,"0,$2");
  		st = st.replace(/\./,",");
    }
    break
  	case "NE":
  	if (arg2>0)
  	{
  		var re1 = new RegExp("^(\\d{" + (arg1 - arg2 - 1).toString() +  "})(\\d)","g");
  		st = st.replace(re1, "$1,$2");
  	    st = st.replace(/^(\,|\.)(\d*)/,"0,$2");
  		st = st.replace(/\./,",");
    }
    break
    case "NE2":
  	if (arg2>0)
  	{
  		var re1 = new RegExp("^(-?\\d{" + (arg1 - arg2 - 1).toString() +  "})(\\d)","g");
  		st = st.replace(re1, "$1,$2");
  	    st = st.replace(/^(\,|\.)(\d*)/,"0,$2");
  		st = st.replace(/\./,",");
    }
    break
    case "P":
 	if (arg2>0)
  	{
  		var re1 = new RegExp("^(\\d{" + (arg1 - arg2 - 1).toString() +  "})(\\d)","g");
  		st = st.replace(re1, "$1,$2");
  	    st = st.replace(/^(\,|\.)(\d*)/,"0,$2");
  		st = st.replace(/\./,",");
    }
    break;
    case "P2":
  	if (arg2>0)
  	{
  		var re1 = new RegExp("^(-?\\d{" + (arg1 - arg2 - 1).toString() +  "})(\\d)","g");
  		st = st.replace(re1, "$1,$2");
  	    st = st.replace(/^(\,|\.)(\d*)/,"0,$2");
  		st = st.replace(/\./,",");
    }
    case "P3":
 	if (arg2>0)
  	{
  		var re1 = new RegExp("^(\\d{" + (arg1 - arg2 - 1).toString() +  "})(\\d)","g");
  		st = st.replace(re1, "$1,$2");
  	    st = st.replace(/^(\,|\.)(\d*)/,"0,$2");
  		st = st.replace(/\./,",");
    }
    break;
    case "P4":
  	if (arg2>0)
  	{
  		var re1 = new RegExp("^(-?\\d{" + (arg1 - arg2 - 1).toString() +  "})(\\d)","g");
  		st = st.replace(re1, "$1,$2");
  	    st = st.replace(/^(\,|\.)(\d*)/,"0,$2");
  		st = st.replace(/\./,",");
    }
    break;
    case "B":
    break;
    case "S":
    break;
    case "EM":
  	break;
  	case "WS":
  	break;
  	case "CB":
  	break;
    case "K":
    st = st.toUpperCase();
  	st = st.replace(/^(\w{2})(\w)/,"$1-$2");
  	st = st.replace(/^(\w{2}-\w{3})(\w)/,"$1-$2");
  	break;
  	case "T":
  	st = st.replace(/^(\d{1}):$/,"0$1:");
	st = st.replace(/^(\d{2})(\d)/,"$1:$2");
	st = st.replace(/^(\d{2}):(\d{2}$)/,"$1:$2:00");
  	break;

    }
  if (st.length>arg1 && tp !="M" && tp != "M2" && tp != "M3") st = st.substr(0, arg1);
  return st;
}

function isValid(st, tp, arg1, arg2)
{
	var reSt="";

    if (arg1!=null) arg1=parseInt(arg1);
	if (arg2!=null) arg2=parseInt(arg2);

	switch(tp.toUpperCase())
  {
  	case "D":
  	reSt = "(\\d{1,2}-\\d{1,2}-\\d{0,4})|(\\d{1,2}-\\d{0,3})|(\\d{0,3})";
  	break;
  	case "IP4":
  	reSt = "(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})|(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.)|(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})|(\\d{1,3}\\.\\d{1,3}\\.)|(\\d{1,3}\\.\\d{1,3})|(\\d{1,3}\\.)|(\\d{1,3})";
  	break;
  	case "A":
  	reSt = "([a-zA-Z]){0," + arg1 + "}";
  	break;
  	case "A1":
  	reSt = "(\\w|\\s|\\W){0," + arg1 + "}";
  	break;
  	case "A2":
  	reSt = "(\\w|\\s|\\W){0," + arg1 + "}";
  	break;
  	case "A3":
  	reSt = "(\\w|\\s|\\W){0," + arg1 + "}";
  	break;
  	case "A4":
  	reSt = "(\\w|\\s|\\W){0," + arg1 + "}";
  	break;
  	case "A5":
  	reSt = "^([a-zA-Z0-9_]|-)*";
  	break;
  	case "A6":
  	reSt = "(\\w|\\s|\\W){0," + arg1 + "}";
  	break;
  	case "PW2":
  	reSt = "(\\w|\\s|\\W){0," + arg1 + "}";
  	break;
  	case "N":
  	case "NL":
  	if (arg2>0) reSt = "((\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "})(\\,|\\.)(\\d{0," + arg2 + "}))|(\\d{0," + (arg1 + 1).toString() + "}(\\.|\\,)*)";
  	else reSt = "\\d{0," + arg1 + "}";
  	break;
 	case "N2":
  	if (arg2>0) reSt = "((-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "})(\\,|\\.)(\\d{0," + arg2 + "}))|(-?\\d{0," + (arg1 + 1).toString() + "}(\\.|\\,)*)";
  	else reSt = "-?\\d{0," + arg1 + "}";
  	break;
  	case "N3":
  	if (arg2>0) reSt = "((\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "})(\\,|\\.)(\\d{0," + arg2 + "}))|(\\d{0," + (arg1 + 1).toString() + "}(\\.|\\,)*)";
  	else reSt = "\\d{0," + arg1 + "}";
  	break;
	case "N4":
  	if (arg2>0) reSt = "((-\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "})(\\,|\\.)(\\d{0," + arg2 + "}))|(-?\\d{0," + (arg1 + 1).toString() + "}(\\.|\\,)*)";
  	else reSt = "-?\\d{0," + arg1 + "}";
  	break;
  	case "NE":
  	if (arg2>0) reSt = "((\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "})(\\,|\\.)(\\d{0," + arg2 + "}))|(\\d{0," + (arg1 + 1).toString() + "}(\\.|\\,)*)";
  	else reSt = "\\d{0," + arg1 + "}";
  	break;
 	case "NE2":
  	if (arg2>0) reSt = "((-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "})(\\,|\\.)(\\d{0," + arg2 + "}))|(-?\\d{0," + (arg1 + 1).toString() + "}(\\.|\\,)*)";
  	else reSt = "-?\\d{0," + arg1 + "}";
  	break;
  	case "M":
  	reSt = "(\\w|\\s|\\W)*";
  	break;
  	case "M2":
  	reSt = "(\\w|\\s|\\W)*";
  	break;
  	case "B":
  	reSt = "^j$|^J$|^n$|^N$";
  	break;
  	case "K":
  	reSt = "(\\w{2}-\\w{2,3}-\\w{0,2})|(\\w{2}-\\w{0,3})|(\\w{0,2})";
  	break;
  	case "S":
  	reSt = "\\d{0,9}";
  	break;
  	case "EM":
   	reSt = "(\\w|\\s|\\W)*";
   	break;
   	case "WS":
   	reSt = "(\\w|\\s|\\W)*";
   	break;
   	case "CB":
   	reSt = "(\\w|\\s|\\W)*";
   	break;
  	case "P":
 	if (arg2>0) reSt = "((\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "})(\\,|\\.)(\\d{0," + arg2 + "}))|(\\d{0," + (arg1 + 1).toString() + "}(\\.|\\,)*)";
  	else reSt = "\\d{0," + arg1 + "}";
  	break;
  	case "P2":
  	if (arg2>0) reSt = "((-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "})(\\,|\\.)(\\d{0," + arg2 + "}))|(-?\\d{0," + (arg1 + 1).toString() + "}(\\.|\\,)*)";
  	else reSt = "-?\\d{0," + arg1 + "}";
	break;
  	case "P3":
 	if (arg2>0) reSt = "((\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "})(\\,|\\.)(\\d{0," + arg2 + "}))|(\\d{0," + (arg1 + 1).toString() + "}(\\.|\\,)*)";
  	else reSt = "\\d{0," + arg1 + "}";
  	break;
  	case "P4":
  	if (arg2>0) reSt = "((-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "})(\\,|\\.)(\\d{0," + arg2 + "}))|(-?\\d{0," + (arg1 + 1).toString() + "}(\\.|\\,)*)";
  	else reSt = "-?\\d{0," + arg1 + "}";
	break;
  	case "T":
  	reSt = "(\\d{1,2}:\\d{1,2}:\\d{0,3})|(\\d{1,2}:\\d{1,2})|(\\d{1,2}:\\d{0,3})|(\\d{0,3})|(\\d{1,2}:\\d{1,2}:\\d{0,3})";
  	break;
  }
  try
  {
	  var re = new RegExp(reSt,"g");
	  result = re.exec(st);
  
  }
  catch(e){alert(e.message);}
  
  return (result!=null && result[0]==st) ;
}

function isCorrectType(st, tp, arg1, arg2)
{
	var reSt="";
	if (arg1!=null) arg1=parseInt(arg1);
	if (arg2!=null) arg2=parseInt(arg2);
	var b = true;

	switch(tp.toUpperCase())
  {
  	case "D":
  	if (trim(st)!="")
  	{
  		st = st.replace(/^(\d{1})-/,"0$1-");
		st = st.replace(/^(\d{2})-(\d{1})-/,"$1-0$2-");
  	  	reSt = "\\d{2}-\\d{2}-\\d{4}";
  	  	b = isProperDate(st);
  	}
  	else reSt = "\\d{0,1}";
  	break;
  	case "IP4":
  	reSt = "(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})|(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.)|(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})|(\\d{1,3}\\.\\d{1,3}\\.)|(\\d{1,3}\\.\\d{1,3})|(\\d{1,3}\\.)|(\\d{1,3})";
  	var iptemp = st.split(".");
  	if (iptemp.length != 4)
  		b = false;
  	else
  	{
  		b = true;
  		try
  		{
  			var temp;
	  		for(var i = 0 ; i < 4 ; i++)
	  		{
	  			temp = parseInt(iptemp[i]);
	  			if (temp < 0 || temp > 255) b = false;
	  		}
	  	}
	  	catch (e) { b = false; }
  	}
  	break;
  	case "A":
  	reSt = "([a-zA-Z])*";
  	break;
  	case "A1":
  	reSt = "(\\w|\\W|\\s)*";
  	break;
  	case "A2":
  	reSt = "[^a-z]*";
  	break;
  	case "A3":
  	reSt = "(^[^a-z]+(\\w|\\s|\\W)*)|(^[^a-z]?)";
  	break;
  	case "A4":
  	reSt = "[^a-z]*";
  	break;
  	case "A5":
  	reSt = "^([a-zA-Z0-9_]|-)*";
  	break;
  	case "A6":
  	reSt = "(\\w|\\W|\\s)*";
  	break;
  	case "PW2":
  	reSt = "[^a-z]*";
  	break;
  	case "N":
  	case "NL":
  	if (arg2>0) reSt="^((\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\,|\\.)\\d{1," + arg2 + "})|(\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\.|\\,)?))";
  	else reSt = "\\d{0," + arg1 + "}";
  	break;
   	case "N2":
  	if (arg2>0) reSt="^((-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\,|\\.)\\d{1," + arg2 + "})|(-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\.|\\,)?))";
  	else reSt = "-?\\d{0," + arg1 + "}";
  	break;
  	case "N3":
  	if (arg2>0) reSt="^((\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\,|\\.)\\d{0," + arg2 + "})|(\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\.|\\,)?))";
  	else reSt = "\\d{0," + arg1 + "}";
  	break;
   	case "N4":
   	if (trim(st) != "")
   	{
   		var f = parseFloat(st);
   		if (isNaN(f) || f != 0)
   		{
  			if (arg2>0) reSt="^((-\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\,|\\.)\\d{1," + arg2 + "})|(-\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\.|\\,)?))";
  			else reSt = "-\\d{0," + arg1 + "}";
  		}
  		else
  		{
  			reSt = "(\\w|\\W|\\s)*";
  		}
  	}
  	else
  	{
  		reSt = "(\\w|\\W|\\s)*";
  	}
  	break;
  	case "NE":
  	if (arg2>0) reSt="^((\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\,|\\.)\\d{1," + arg2 + "})|(\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\.|\\,)?))";
  	else reSt = "\\d{0," + arg1 + "}";
  	break;
   	case "NE2":
  	if (arg2>0) reSt="^((-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\,|\\.)\\d{1," + arg2 + "})|(-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\.|\\,)?))";
  	else reSt = "-?\\d{0," + arg1 + "}";
  	break;
  	case "M":
  	reSt = "(\\w|\\W|\\s)*";
  	break;
  	case "M2":
  	reSt = "(\\w|\\W|\\s)*";
  	break;
  	case "B":
  	reSt = "^j$|^J$|^n$|^N$";
  	break;
 	case "S":
	if (trim(st)!="")
	{
	  	reSt = "\\d{9}";
	  	b = bValidateSofinummer(st)
	}
  	break;
  	case "EM":
  		reSt = "(\\w+(((\\-\\w+)|(\\.\\w+))*|(\\w+))@(\\w)+(((\\-\\w+)|(\\.\\w+))*|(\\w+))\\.(\\w)+(\\.*\\w+)*){0,255}";
   	break;
   	case "WS":
   	reSt = "(\\w|\\W|\\s)*";
   	break;
   	case "CB":
   	reSt = "(\\w|\\W|\\s)*";
   	break;
  	case "K":
  	if (trim(st)!="")
  	{
  		reSt = "(\\w{2}-\\w{2,3}-\\w{1,2})";
  	}
  	else reSt = "\\w{0,1}";
  	break;
  	case "P":
    if (arg2>0) reSt="^((\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\,|\\.)\\d{1," + arg2 + "})|(\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\.|\\,)?))";
  	else reSt = "\\d{0," + arg1 + "}";
  	if (trim(st)!="") {i = parseFloat(st.replace(/,/,'.')); b = (i>=0 && i<=100);}
  	break;
  	case "P2":
    if (arg2>0) reSt="^((-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\,|\\.)\\d{1," + arg2 + "})|(-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\.|\\,)?))";
  	else reSt = "-?\\d{0," + arg1 + "}";
  	if (trim(st)!="")
  	{
  		if (st == "-") i = 0;
  		else i = parseFloat(st.replace(/,/,'.'));
  		b = (i>=-100 && i<=100);
  	}
  	break;
  	case "P3":
    if (arg2>0) reSt="^((\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\,|\\.)\\d{1," + arg2 + "})|(\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\.|\\,)?))";
  	else reSt = "\\d{0," + arg1 + "}";
  	if (trim(st)!="") {i = parseFloat(st.replace(/,/,'.')); b = (i>=0 && i<=1000);}
  	break;
  	case "P4":
    if (arg2>0) reSt="^((-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\,|\\.)\\d{1," + arg2 + "})|(-?\\d{0," + (parseInt(arg1) - parseInt(arg2)).toString() + "}(\\.|\\,)?))";
  	else reSt = "-?\\d{0," + arg1 + "}";
  	if (trim(st)!="")
  	{
  		if (st == "-") i = 0;
  		else i = parseFloat(st.replace(/,/,'.'));
  		b = (i>=-1000 && i<=1000);
  	}
  	break;
  	case "T":
  	if (trim(st)!="")
  	{
  	  	reSt = "\\d{2}:\\d{2}(:\\d{2})?";
  	  	b = isProperTime(st);
  	}
  	else reSt = "\\d{0,1}";
  	break;

  }
  var re = new RegExp(reSt,"g");
  result = re.exec(st);

  b = b && (result!=null && result[0]==st);

  return  b;
}

function isProperTime(st)
{
	var time = st.split(":");
	var hours = parseInt(time[0]);
	var minutes = parseInt(time[1]);
	var seconds = parseInt(time[2]);
	var b = true;
	if(hours > 23) b = false;
	if(minutes > 59) b = false;
	if(seconds > 59) b = false;
	return b;
}

function bValidateSofinummer(obj)
{
	var reSofi = /(\d)(\d)(\d)(\d)(\d)(\d)(\d)(\d)(\d)/;
	var bValid = false;
	var array;
	var lSom = 0;
	if ((obj.length == 0) || (obj == null)) bValid = true;
	else
	{
		bValid = (reSofi.test(obj));
		if (bValid)
		{
			// 11 proef
			array = (obj.match(reSofi));
			for (i=1;i<9;i+=1) lSom += (array[i] * (9-(i-1)));
			bValid = (((lSom -= array[9]) % 11) == 0)
		}
	}

	return (bValid);
}

function validateBankRek(rek)
{
	var s 		= "" + rek;
	var total 	= 0;
	var j 		= s.length;
	
	if (j  > 10 && j <= 34) // iban nr
	{
		//var landcod			= getAttribute(document.getElementById("landcod"), "value");
		//BOY: volgens wikipedia moeten de eerste twee posities van het iban nr gelijk zijn aan de landcode
		//maar dat laten we nu nog even achterwege omdat mensen bijvoorbeeld in nederland kunnen wonen en in
		//belgie een bankrekening hebben
		var ibanlandcod			= s.substring(0,2);
		var controlegetal		= s.substring(2,4); // BOY: controle getal moet 2 cijferig zijn
		if (isValid(ibanlandcod, "A", 2) && isValid(controlegetal, "N", 2, 2))
			return true;
		else
			return false;
	}
	else if (j == 9 || j == 10) // banken
	{	
		for (var i = 0; i < s.length; i++ ) 
		{
			total 	= total + (s.charAt(i) * j);
			j 		= j - 1;
		}
	
		return ((total % 11) == 0)
	}
	else if (j <= 7) return true;	// postbank
	else return false;
}

function transformOnBlur(st, tp, arg1, arg2)
{
	if (arg1!=null) arg1=parseInt(arg1);
	if (arg2!=null) arg2=parseInt(arg2);

  	if ( st!="" && (tp == "N" || tp == "N2" || tp == "P") && arg2!=null && arg2>0)
  	{
  		//nullen en/of komma toevoegen.
  		i = st.indexOf(",") + 1;
  		if (i==0) {st = st + ","; i = st.length;}
  		st = st + generateZero(arg2 - (st.length - i));
    }
  return st;
}

function generateZero(n)
{
	var z ="";
	for(i=0;i<n;i++) z = z + "0";
	return z;
}

function twoDecimals(s)
{
	if (s == "") s = "0,00";
	else if (s.indexOf(",") == -1) s = s + ",00";
	else if (s.indexOf(",") == s.length - 2) s = s + "0";
	return s;
}

String.prototype.left = function(str)
{
	var i = this.indexOf(str);
	if (i > -1) return this.substring(0, i);
	else        return this;
}

String.prototype.right = function(str)
{
	var i = this.indexOf(str);
	if (i > -1) return this.substring(i + str.length);
	else        return this;
}

String.prototype.endsWith = function(str) 
{
	return (this.match(str + "$") == str);
}

String.prototype.startsWith = function(str) 
{
	return (this.match(str) == str);
}

String.prototype.trim = function(str) 
{
	return (trim(this));
}

function validateZIPCode(zipcodeitem, countrycodeitem)
{
	var zipcode					= zipcodeitem.value;
	var countrycode				= countrycodeitem.value;
	var mask					= "";
	var maskmsg					= "";
	var valid 					= true;
	
	if (zipcode != "")
	{
		if (countrycode == "NL" || countrycode == "NEDERLAND")
		{
			mask				= "\\d{4}\\s\\w{2}";
			maskmsg				= "0000 AA";
		}
		
		if (mask != "")
		{
			var re 				= new RegExp(mask, "g");
		  	var result			= re.exec(zipcode);
	
	 	 	valid				= (result != null && result[0] == zipcode);
		}
	
		if (!valid)
		{
			zipcodeitem.setAttribute("valid", "false");
			zipcodeitem.errmsg	= "Postcode moet van de vorm \"" + maskmsg + "\" zijn.";
		}
		else zipcodeitem.setAttribute("valid", "true");
	
		setErrorClass(zipcodeitem);
	}

	return valid;
}