var phone_field_length=0;
		function TabNext(obj,event,len,next_field) {
			if (event == "down") {
				phone_field_length=obj.value.length;
				}
			else if (event == "up") {
				if (obj.value.length != phone_field_length) {
					phone_field_length=obj.value.length;
					if (phone_field_length == len) {
						next_field.focus();
						}
					}
				}
			}
		
		function isBlank(val){
			if(val==null){return true;}
			for(var i=0;i<val.length;i++) {
				if ((val.charAt(i)!=' ')&&(val.charAt(i)!="\t")&&(val.charAt(i)!="\n")&&(val.charAt(i)!="\r")){return false;}
				}
			return true;
		}
		
		function isDigit(num) {
			if (num.length>1){return false;}
			var string="1234567890.";
			if (string.indexOf(num)!=-1){return true;}
			return false;
		}

		function isSpaceChar(val) {
			if(val.substring(0,1) == ' '){
				return true;
			} else {
				return false;
			}
			
		}
		
		function ctrlChar(x,y){
		error = 0;
		if(x.length != 0){
		for(i=0;i<=x.length;i++){
			priChr = x.substring(i,i+1);
			priChr2 = x.substring(i,i+2);   
			//alert(priChr);
			//if(priChr == "|" || priChr == "&" || priChr == ";" || priChr == "$" || priChr == "%" || priChr == "'" || priChr == "<>" || priChr == "()" || priChr == "+" || priChr == "," || priChr == ")" || priChr == "(" || priChr == "<" || priChr == ">" || priChr == "\\" || priChr == "\"" || priChr2 == "CR" || priChr2 == "LF" || priChr2 == "\\'" || priChr2 == "\\\""){
			if(priChr == "|"  || priChr == ";" || priChr == "$" || priChr == "%" || priChr == "'" || priChr == "<>"  || priChr == "+"  || priChr == "<" || priChr == ">" || priChr == "\\" || priChr == "\"" || priChr2 == "\\'" || priChr2 == "\\\""){
				error = 1;
			}
			if(y==0 && priChr == "@"){ 
				error = 1;
			}
		}
		}
			if(error == 1)return true;
		}
		
		function isInteger(val){
			var havePoint = 0;
			for(var i=0;i<val.length;i++){
				if(val.charAt(i) == '.'){ havePoint++;}
				
				if(!isDigit(val.charAt(i)) || havePoint == 2){return false;}
				}
			return true;
		}

		function isIntegerWithPoint(val){
			//if (isBlank(val)){return false;}
			for(var i=0;i<val.length;i++){
				if(!isDigit(val.charAt(i))){return false;}
				}
			return true;
		}
		
		
		function textCounter(field, countfield, maxlimit) {
			if (field.value.length > maxlimit){ // if too long...trim it!
				field.value = field.value.substring(0, maxlimit);
				// otherwise, update 'characters left' counter
			 } else {
				countfield.value = maxlimit - field.value.length;
			}
		}
		

		function emailCheck (emailStr) {
			var checkTLD=1;
			/* 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 false;
                        }
                        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 false;
                           }
                        }
                        for (i=0; i<domain.length; i++) {
                        if (domain.charCodeAt(i)>127) {
                        //alert("Ths domain name contains invalid characters.");
                        return false;
                           }
                        }
                        
                        // See if "user" is valid 
                        
                        if (user.match(userPat)==null) {
                        
                        // user is not valid
                        
                        //alert("The username doesn't seem to be valid.");
                        return false;
                        }
                        
                        /* 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 false;
                           }
                        }
                        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 false;
                           }
                        }
                        
                        /* domain name seems valid, but now make sure that it ends in a
                        known top-level domain (like com, edu, gov) or a two-letter word,
                        representing country (uk, nl), and that there's a hostname preceding 
                        the domain or country. */
                        
                        if (checkTLD && domArr[domArr.length-1].length!=2 && 
                        domArr[domArr.length-1].search(knownDomsPat)==-1) {
                        //alert("The address must end in a well-known domain or two letter " + "country.");
                        return false;
                        }
                        
                        // Make sure there's a host name preceding the domain.
                        
                        if (len<2) {
                        //alert("This address is missing a hostname!");
                        return false;
                        }
                        
                        // If we've gotten this far, everything's valid!
                        return true;
              }