//	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 ()
	{
	// args: value len arg2 id
	var args = Array.prototype.slice.call(arguments); 
	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 ()
	{
	// args: value lowrange highrange id
	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;
	};
	
implicitValidateConfirm = function ()
	{
	// args: value arg1 arg2 id
	var args = Array.prototype.slice.call(arguments); 

	var primaryInput = args[3];
	var secondaryInput = args[3]+'-confirm';

	return document.getElementById(primaryInput).value == document.getElementById(secondaryInput).value;
	};
	
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;

	if (value.match(/@(aol\.com|bellsouth\.net|btconnect\.com|comcast\.net|cox\.net|earthlink\.net|gmail\.com|hotmail\.com|juno\.com|mindspring\.com|msn\.com|sbcglobal\.net|verizon\.net|yahoo\.co\.uk|yahoo\.com)/i))
		return false;

	return isEmailAddress(value);
	};

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

	if (value.match(/(abuse|admin|administrator|anti-spam|antispam|billing|customerservice|designer|info|mail-daemon|mail-deamon|marketing|no-reply|noreplies|noreply|nospam|postmaster|returns|root|sales|support|spam)@/i))
		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 an e-mail address, not role-based",					"NREMAIL",		validateNoRoleEmail		],
	[ "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  ],
	[ "Please verify that the highlighted field matches the field below it",  	        "CONFIRM",		implicitValidateConfirm  ]
	];
	
//	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';
	};
	
	
//	Text Field Checker

singleCheck = function (idField, validationType, idLabel)
	{
	var value = document.getElementById(idField).value;
	var label = document.getElementById(idLabel);

	if (!value) return;

	for (var i = 0; i < validators.length; i++)
		{
		var validationValue 	= validators[i][1];
		var validationFunction	= validators[i][2];

		if (validationValue == validationType)
			{
			if (validationFunction (value))
				label.className = 'formFieldLabelGood';
			else
				label.className = 'formFieldLabelBad';
			break;
			}
		}
	};