//	From http://javascript.internet.com/forms/check-email.html
isEmailAddress = function(emailStr) 
	{
	if (ao__emailRolePat == undefined)
		var ao__emailRolePat =/^(abuse|admin|administrator|billing|customerservice|info|marketing|noreply|returns|sales|support|spam)$/

	//	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.
		return false
		}
	var user=matchArray[1]

	var domain=matchArray[2]

	//	See if "user" is valid 
	if (user.match(userPat)==null) 
		{
	    //	User is not valid
	    return false
		}

	/*
	if (user.match( ao__emailRolePat )!= null)
		{
		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) 
		    	{
				return false
			    }
	 		}
	    return true
		}

	//	Domain is symbolic name
	
	//	Special handling of localhost situation
	if (domain == "localhost")
		return true;
	
	var domainArray=domain.match(domainPat)
	if (domainArray==null) 
		{
	    return false
		}

	//	Domain name seems valid, but now make sure that it ends in a
	//	three-letter word (like com, edu, gov) or a two-letter word,
	//	representing country (uk, nl), and that there's a hostname preceding 
	//	the domain or country.

	//	Now we need to break up the domain to get a count of how many atoms
	//	it consists of.
	var atomPat=new RegExp(atom,"g")
	var domArr=domain.match(atomPat)
	var len=domArr.length
	var sfx = domArr [domArr.length-1].toLowerCase()
	if (sfx != "com" && sfx != "net" && sfx != "org" && sfx != "edu" && sfx != "gov" &&
		sfx != "int" && sfx != "mil" && sfx != "arpa" &&
		sfx != "biz" && sfx != "info" && sfx != "name" && sfx != "pro" &&
		sfx != "aero" && sfx != "coop" && sfx != "museum" &&  
		sfx.length != 2)	//	covers .us, .to, .cc, etc.
	    {
		return false
		}

	//	Make sure there are at least 2 components in the domain specification.
	if (len < 2) 
		{
		return false
		}

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

//	Field Validators

validateNonBlank = function (value)
	{
	return value.length > 0;
	};
	
validateNumber = function (value)
	{
	return ! isNaN (value);
	};

implicitValidateLength = function ()
	{
	var args = Array.prototype.slice.call(arguments); 
	// args[0] should be value - //args[1] should be length
	var value = args[0];
	var len = args[1];

	if (typeof(value) == undefined) return true;
	if (typeof(len) == undefined) return true;

	return value.length < len+1;
	}

implicitValidateNumberRange = function ()
	{
	var args = Array.prototype.slice.call(arguments); 
	var value = args[0];
	var lowrange = args[1];
	var highrange = args[2];

	if (isNaN (value)) return false;

	if ((lowrange < value) && (value < hirange))
		return true;

	return false;
	};
	
validateEmail = function (value)
	{
	value = value.replace(/^\s+/, '').replace(/\s+$/, '');
	// Return true if empty or is valid email
	if( value.length > 0 )
		return isEmailAddress(value);
	return true;
	};

validateNoPublicEmail = function (value)
	{
	value = value.replace(/^\s+/, '').replace(/\s+$/, '');
	// Return true if empty or is valid email
	if (value.length <= 0)
		return true;

	var regTest = /hotmail\./i;
	if (value.match(regTest)) return false;
	regTest = /live\./i;
	if (value.match(regTest)) return false;
	regTest = /msn\./i;
	if (value.match(regTest)) return false;
	regTest = /gmail\./i;
	if (value.match(regTest)) return false;
	regTest = /yahoo\./i;
	if (value.match(regTest)) return false;
	regTest = /aol\./i;
	if (value.match(regTest)) return false;

	return isEmailAddress(value);
	};

validateUSPhone = function (value)
	{
	var regPhone = /^(\+\d)*\s*(\(\d{3}\)\s*)*\d{3}(-{0,1}|\s{0,1})\d{2}(-{0,1}|\s{0,1})\d{2}$/;
	if (value.match(regPhone)) return true;

 	regPhone = /\d{3}\-\d{3}\-\d{4}/;
	if (value.match(regPhone)) return true;

 	regPhone = /\d{3}\.\d{3}\.\d{4}/;
	if (value.match(regPhone)) return true;

	return validateNumber(value);
	};
	
//	Field validator registry
//	these are exposed to the end user in the choice dropdown

var	validators = [ 
	[ "Cannot be blank", 				"NONBLANK",		validateNonBlank ],
	[ "Should be a number",  			"NUMBER",		validateNumber   ],
	[ "Should be an e-mail address",  	        "EMAIL",		validateEmail    ],
	[ "Should be an e-mail address, not Hotmail, Gmail, Aol or Yahoo",  	"NPEMAIL",		validateNoPublicEmail    ],
	[ "Should be a US phone number",  	        "USPHONE",		validateUSPhone  ]
	];

//	these can be used, but are not presented in the dropdown

var implicitValidators = [
	[ "Between range",  				"RANGE",		implicitValidateNumberRange	],
	[ "Don't exceed maximum length",  	"LENGTH",		implicitValidateLength  ]
	];
	
//	Password Field Checker

doubleCheck = function (idPrimaryField, idCheckerField, idLabel)
	{
	var primary = document.getElementById(idPrimaryField);
	var checker = document.getElementById(idCheckerField);
	
	var label   = document.getElementById(idLabel);
	
	if (!primary) return;
	if (!checker) return;
	
	if (primary.value != checker.value)
		label.className = 'formFieldLabelBad';
	else
		label.className = 'formFieldLabelGood';
	};