<!-- hide JavaScript from non-JavaScript browsers

/*
	this file contains validation routines:
		checkrequiredradiogroups
		checkrequired
		emailCheck
		checkage
		checkverifyemail1
*/

function ValidateRequiredRadioGroups(which) {
// alerts the operator to required Radio Groups without a selection
// Paul W. Schluter 24May01
	FoundGroups = new Array(); //keep track of the Radio Groups (name, validated flag)

//find all "required" Radio Elements on form, and set its Radio Group validated if any element is checked
  for (i=0; i<which.length; i++) {
  	var tempobj = which.elements[i];
  	if ( (tempobj.type == "radio") && (tempobj.name.substring(0,8)=="required") ) {
			for (j=0, match=false; j<FoundGroups.length; j++) {
				if (FoundGroups[j][1] == tempobj.name) {
					FoundGroups[j][2] |= tempobj.checked;
					match=true;
					break;
				}
			}
			if (!match) {// did not find, initialize new RadioGroup with this element's state
				FoundGroups[FoundGroups.length] = new Array(tempobj, tempobj.name, tempobj.checked);
			}
  	}
  }
//for all Radio Groups on the form, if validated flag was not set, display alert and exit
	for (j=0; j<FoundGroups.length; j++) {
		if (!FoundGroups[j][2]) {
			alert("Please make sure a choice was made for " + FoundGroups[j][1].substring(8,30).toUpperCase());
			FoundGroups[j][0].focus()
			FoundGroups[j][0].select()
			return false;
		}
	}
	return true;
}

function checkrequired(which) {
	var pass=true;
  ///////////////////if (document.images) {
  	for (i=0; i<which.length; i++) {
  		var tempobj = which.elements[i];
  		if (tempobj.name.substring(0,8)=="required") {
  			if ( ((tempobj.type == "text" || tempobj.type == "textarea") && tempobj.value == "") ||
  				(tempobj.type.toString().charAt(0) == "s" && tempobj.selectedIndex == 0) ) {
  					pass=false;
  					break;
  			}
  		}
  	}
  ////////////////}
  if (!pass) {
  	shortFieldName = tempobj.name.substring(8,30).toUpperCase();
  	alert("Please make sure the " + shortFieldName + " field was properly completed.");
  	tempobj.focus()
  	tempobj.select()
  }
  return pass;
}

//	emailCheck(value)

function emailCheck(value){
//	alert('emailCheck value ' + value)
/* The following variable tells the rest of the function whether or not
to verify that the address ends in a two-letter country or well-known
TLD.  1 means check it, 0 means don't. */

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)$/;
//	alert('emailCheck knownDomsPat ' + knownDomsPat)

/* 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=/^(.+)@(.+)$/;
//	alert('emailCheck emailPat ' + 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="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";
//	alert('emailCheck specialChars ' + 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 + "\]";
//	alert('emailCheck validChars ' + validChars)

/* 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="(\"[^\"]*\")";
//	alert('emailCheck after 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})\]$/;
//	alert('emailCheck ipDomainPat ' + ipDomainPat)

/* The following string represents an atom (basically a series of non-special characters.) */

var atom=validChars + '+';
//	alert('emailCheck atom ' + atom)

/* 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 + ")";
//	alert('emailCheck after word')
//	alert('emailCheck word ' + word)

// The following pattern describes the structure of the user

var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
//	alert('emailCheck userPat ' + userPat)

/* The following pattern describes the structure of a normal symbolic
domain, as opposed to ipDomainPat, shown above. */

var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");
//	alert('emailCheck domainPat ' + domainPat)

/* 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. */

//	alert('emailCheck before setting matchArray by matching emailPat ' + emailPat + ' with value ' + value)
var matchArray=value.match(emailPat);
//	alert('emailCheck checking matchArray')

if (matchArray==null) {
//	alert('emailCheck matchArray is 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 " + value + " seems incorrect (check @ and .'s)");
return false;
}
//	alert('emailCheck matchArray is not null')
var user=matchArray[1];
//	alert('emailCheck user ' + user)
var domain=matchArray[2];
//	alert('emailCheck domain ' + domain)

// Start by checking that only basic ASCII characters are in the strings (0-127).

//	alert('emailCheck user.length ' + user.length)
for (i=0; i<user.length; i++) {
if (user.charCodeAt(i)>127) {
alert("Ths username part of the email address contains invalid characters.");
return false;
   }
}
for (i=0; i<domain.length; i++) {
if (domain.charCodeAt(i)>127) {
alert("Ths domain name part of the email address 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 in the email address 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 in the email address 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("Email address " + value + " 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("Email address " + value + " is missing a hostname!");
return false;
}

// If we've gotten this far, everything's valid!
return true;
}


function checkage(field) {
	var age = parseInt(field.value)
	if (isNaN(age)) {
		alert('please input a number for the age')
		field.focus()
		field.select()
		return false
	}
	if (age < 20) {
		alert('I am sorry, but you must be at least 20 years old!')
		field.focus()
		field.select()
		return false
	}
	if (age > 150) {
		alert('I am sorry, but I doubt that is your age!')
		field.focus()
		field.select()
		return false
	}
	return true
}

function checkverifyemail1(which){
	if (!emailCheck(which.requiredemail.value)) {
		//alert(which.requiredemail.value + ' is not a valid e-mail address.')
		which.requiredemail.focus()
		which.requiredemail.select()
		return false
	}
	if (which.requiredemail.value != which.requiredemailverify.value) {
		alert('please make sure the e-mail addresses match.')
		which.requiredemailverify.focus()
		which.requiredemailverify.select()
		return false
	}
	return true;
}

//--> end hide JavaScript