/***************************************************************************************************
*
*-- Form validation script by Peter Bailey copyright 2001-2002
*	Version 2.85b
*	Updated on September 12, 2002
*	www.peterbailey.net
*	me@peterbailey.net
*
*	IF YOU USE THIS SCRIPT, GIVE ME CREDIT PLEASE =)
*
*	Visit www.peterbailey.net/fValidate for more info
*
*	Please contact me with any questions, comments, problems, or suggestions
*	This script has only been validated on various versions of Windows with IE4+
*
*******************************************************************************************************/

function validateForm(Frm, bConfirm, bDisable, bDisableR, groupError) {
	var testOk = false;
	if (groupError) { 
		window.groupError = 1; 
		errorData = new Array(); 
		} 
	else 
		window.groupError = 0;
		
	for (var i=0; i<Frm.elements.length; i++) {	// Loops through all the form's elements		
		if (Frm.elements[i].alt) {		// Gets the ALT text if it exists, starting the validation			
			replaceChars(Frm.elements[i],'&','and');
			var validateType = Frm.elements[i].alt;
			var validateObj = Frm.elements[i];
			testOk = false;			
			var params = validateType.split(/[|]/);	// Separates validation string into parameters
		
			if (params[0] == 'money') {	// Sets flags for money syntax				
				var dollarsign	= (params[1].indexOf('$') != -1);
				var grouping	= (params[1].indexOf(',') != -1);
				var decimal		= (params[1].indexOf('.') != -1);
				}
			
			if (params[params.length-1] == 'bok')	// Sets flag if field is allowed to be blank
				blankOK = true;
	
			switch (params[0]) {	// Calls appropriate validation function based on type				
				case 'blank'		: if (validateBlank(validateObj)) testOk = true; break;
				case 'equalto'		: if (validateEqualTo(validateObj, params[1], Frm)) testOk = true; break;
				case 'length'		: if (validateLength(validateObj, params[1])) testOk = true; break;
				case 'number'		: if (validateNumber(validateObj)) testOk = true; break;
				case 'numberl'		: if (validateNumberL(validateObj, params[1], params[2])) testOk = true; break;
				case 'numberr'		: if (validateNumberR(validateObj, params[1], params[2] )) testOk = true; break;
				case 'alnum'		: if (validateAlnum(validateObj, params[1], params[2], params[3], params[4], params[5] )) testOk = true; break;				
				case 'decimal'		: if (validateDecimal(validateObj, params[1], params[2] )) testOk = true; break;
				case 'decimalr'		: if (validateDecimalR(validateObj, params[1], params[2], params[3], params[4] )) testOk = true; break;				
				case 'ip'		: if (validateIP(validateObj, params[1], params[2])) testOk = true; break;
				case 'ssn'		: if (validateSSN(validateObj)) testOk = true; break;
				case 'money'		: if (validateMoney(validateObj, dollarsign, grouping, decimal)) testOk = true; break;
				case 'zip'		: if (validateZip(validateObj)) testOk = true; break;
				case 'phone'		: if (validatePhone(validateObj)) testOk = true; break;
				case 'email'		: if (validateEmail(validateObj)) testOk = true; break;
				case 'cc'		: if (validateCC(validateObj)) testOk = true; break;
				case 'select'		: if (validateSelect(validateObj)) testOk = true; break;
				case 'selectm'		: if (validateSelectM(validateObj, params[1], params[2])) testOk = true; break;
				case 'selecti'		: if (validateSelectI(validateObj, params[1])) testOk = true; break;
				case 'checkbox'		: if (validateCheckbox(validateObj, Frm.name, validateObj.name, params[1], params[2])) testOk = true; break;
				case 'radio'		: if (validateRadio(validateObj, Frm.name, validateObj.name)) testOk = true; break;
				// Add additional cases here
				case 'domain'		: if (validateDomain(validateObj, params[1])) testOk = true; break;
				case 'bulkdomains'	: if (validateBulkDomains(validateObj)) testOk = true; break;
				case 'nameserver'	: if (validateNameserver(validateObj)) testOk = true; break;
				default			: alert('Validation Type Not Found');
				}
			if (!testOk && !groupError) return false;
			}
		}
	if (groupError) {
		var alertStr = "The fields listed below have erroneous data or need to be filled in.\n\n";
		for (var i in errorData) {
			revertClass = errorData[i].className;
			if (typeof errorData[i].type != 'undefined'  && typeof errorData[i].name != 'undefined') { 
				errorData[i].className = errorClass;
				alertStr += " -" + formatName(errorData[i]) + "\n";
				}
			else {
				var temp = errorData[i];
				temp[0].className = errorClass;
				alertStr += " -" + formatName(temp[0]) + "\n";
				}
			errorProcess(errorData[0],0,1);
			}
		errorData[0].focus();
		alert(alertStr);
		return false;
		}
/*******************************************************
*	Any special conditions you have can be added here
********************************************************/		
		
	if (typeof bConfirm == 'undefined') bConfirm = 0;				// Checks for submission flags
	if (typeof bDisable == 'undefined') bDisable = 0;	
	if (typeof bDisableR == 'undefined') bDisableR = 0;	
	if (bConfirm)
		{
		if(!confirm(confirmMsg))
			{
			if (confirmAbortMsg != '') alert(confirmAbortMsg);		// Displays confim if requested
			return false;
			}
		}
	if (bDisable) Frm.elements[submitButton].disabled=true;			// Disables submit if requested
	if (bDisableR) Frm.elements[resetButton].disabled=true;			// Disables reset if requested
	return true;								// Form has been validated
	}

/***************************************************************************/
function validateBlank(formObj) {
	var objName = formatName(formObj);
	if (formObj.value == "") {
		if (groupError) { addError(formObj); return true; }
		alert('Please enter the '+objName);		
		errorProcess(formObj,0,1);
		return false;
		}
	var regex = new RegExp(/\S/);
	if (!regex.test(formObj.value)) {
		if (groupError) { addError(formObj); return true; }
		alert('Please enter the '+objName);
		errorProcess(formObj,1,1);
		return false;			
		}
	return true;
	}
/***************************************************************************/
// Special function used for bok
function checkBlank(formObj) {
	if (formObj.value == "")
		return true;
	var regex = new RegExp(/\S/);
	if (!regex.test(formObj.value))
		return true;			
	return false;
	}
		
/***************************************************************************/
function validateEqualTo(formObj, otherObjName, Frm) {
	var objName = formatName(formObj);
	var equalToValue = Frm.elements[otherObjName].value;

	if (formObj.value != equalToValue) {
		if (groupError) { addError(formObj); return true; }
		alert(otherObjName+' must be the same as '+objName+'.\nPlease make sure the data you entered matches.');
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
	
/***************************************************************************/
function validateLength(formObj,len) {
	var objName = formatName(formObj);	
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	if (formObj.value.length < parseInt(len)) {
		if (groupError) { addError(formObj); return true; }
		alert('The '+objName+' must be at least '+len+' characters long');
		errorProcess(formObj,1,1);
		return false;
		}		
	return true;
	}
	
/***************************************************************************/
function validateDomain(formObj,withTld) {
	var objName = formatName(formObj);	
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	tmpStr=formObj.value.toLowerCase(); formObj.value=tmpStr;
	replaceChars(formObj,'www.','');
	
	if (withTld) {
	  numReg = "^[a-z0-9][a-z0-9\-]*[a-z0-9]\\.[a-z0-9\.]{2,}$"
	} else {
	  numReg = "^[a-z0-9][a-z0-9\-]*[a-z0-9]$"
	}
	
	var regex = new RegExp(numReg);
	if (!regex.test(formObj.value)) {
		if (groupError) { addError(formObj); return true; }
		window.alert('Only alphanumeric values and the hyphen (-) are valid for a domain with a\nminimum of two characters.  It also cannot begin or end with a hyphen.');
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
	
/***************************************************************************/
function validateBulkDomains(formObj) {
	var objName = formatName(formObj);	
	if (checkBlank(formObj)) {
		window.alert('Please enter a list of domain names that you would to check\nthe availability of into the box provided.\n\nSeparate each domain with a comma, space or place each on a new line.');
		errorProcess(formObj,1,1);
		return false;
		}

	tmpStr=formObj.value.toLowerCase(); formObj.value=tmpStr;
	tmpStr=formObj.value.replace(/\r\s|\s|,/g, "\n"); formObj.value=tmpStr;
	numReg = "^[a-zA-Z0-9\-]{3,68}\\.[a-zA-Z0-9.]{2,}$"
	var regex = new RegExp(numReg);
	
	var wrongDom='';
	var tmpStri='';
	tmpStri=formObj.value.split(/\r\s/);
	for (var i in tmpStri) {
		if (tmpStri[i] != true && tmpStri[i] != false)
			if (!regex.test(tmpStri[i]))
				wrongDom = (wrongDom=='') ? tmpStri[i] : wrongDom+"\n"+tmpStri[i];
	}

	if (wrongDom!='') {
		if (groupError) { addError(formObj); return true; }
		window.alert('Only alphanumeric values and the hyphen (-) are valid for a domain\nwith a minimum of two characters');
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
	
/***************************************************************************/
function validateNameserver(formObj) {
	var objName = formatName(formObj);	
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	tmpStr=formObj.value.toLowerCase(); formObj.value=tmpStr;
	numReg = "^[a-zA-Z0-9\-\.]{3,}\\.[a-zA-Z0-9.]{2,}$"
	var regex = new RegExp(numReg);
	if (!regex.test(formObj.value)) {
		if (groupError) { addError(formObj); return true; }
		window.alert('1Only alphanumeric values, the hyphen (-) and dot (.) characters are\nvalid for a nameserver.  There is a minimum of two characters');
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
	
/***************************************************************************/
function validateNumber(formObj) {
	var objName = formatName(formObj);
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	numReg = "^[0-9]+$"
	var regex = new RegExp(numReg);
	if (!regex.test(formObj.value)) {
		//if (groupError) { addError(formObj); return true; }
		window.alert('Only numeric values are valid for the '+objName);
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
	
/***************************************************************************/
function validateNumberL(formObj, len, puncs) {
	var objName = formatName(formObj);
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	var okChars="";
	var puncsTxt = "";
	if (puncs == "all") { okChars += puncStr("!@#$%^&*()_+-={}|[]:\";'<\\>?,.?~`"); }
	else if (puncs == "none" || puncs == "") puncsTxt = '\nOnly Numbers are allowed.';
	else { okChars += puncStr(puncs); puncsTxt = '\nOnly Numbers and the following punctuation\ncharacters are allowed: '+puncStr(puncs).replace(/\\/g,""); }
	
	numReg = "^["+okChars+"0-9]{"+parseInt(len)+",}$"
	var regex = new RegExp(numReg);
	if (!regex.test(formObj.value)) {
		//if (groupError) { addError(formObj); return true; }
		window.alert('A minimum of '+len+' characters and no spaces are required for the '+objName+puncsTxt);
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
/***************************************************************************/
function validateNumberR(formObj, lb, ub) {
	var objName = formatName(formObj);
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	var num = parseInt(formObj.value);
	numReg = "^\-?[0-9]+$"
	if (lb == 'none') lb = -999999999999999999;
	if (ub == 'none') ub = 999999999999999999;
	var regex = new RegExp(numReg);
	if (!regex.test(num) || num < lb || num > ub ) {
		if (groupError) { addError(formObj); return true; }
		window.alert(objName+" must be an integer between "+lb+" and "+ub);
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
/***************************************************************************/
function validateAlnum(formObj, minLen, tCase, numbers, spaces, puncs) {
	var objName = formatName(formObj);
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	var arrE = new Array();
	arrE[0] = (minLen != "*") ? "Minimum Length: "+minLen+"\n" : "";
	var okChars = "";
	switch (tCase.toUpperCase()) {
		case 'U'	:	okChars = "a-zA-Z"; tmpStr=formObj.value.toUpperCase(); formObj.value=tmpStr; break;
		case 'L'	:	okChars = "a-zA-Z"; tmpStr=formObj.value.toLowerCase(); formObj.value=tmpStr; break;
		case 'C'	:	okChars = "a-zA-Z"; changeCase(formObj); if (minLen != "*") minLen--; break;
		default		:	okChars = "a-zA-Z"; break;
		}
	if (parseInt(numbers)) { okChars += "0-9"; arrE[2] = "Yes"; } else arrE[2] = "No";
	if (parseInt(spaces)) { okChars += " "; arrE[3] = "Yes"; } else arrE[3] = "No";
	if (puncs == "all") { okChars += puncStr("!@#$%^&*()_+-={}|[]:\";'<\\>?,.?~`"); arrE[4] = ""; }
	else if (puncs == "none") arrE[4] = "\nNumber and letters only";
	else { okChars += puncStr(puncs); arrE[4] =  "\nNumbers and letters, plus the following characters\nare allowed: "+puncStr(puncs).replace(/\\/g,""); }
	var length = (minLen == "*") ? "+" : "{"+minLen+",}";
	var alnumReg = "^["+okChars+"]"+length+"$";
	var regex = new RegExp(alnumReg);
	if (!regex.test(formObj.value) ) {
		if (groupError) { addError(formObj); return true; }
		window.alert("The data you entered ("+formObj.value+") does not match the requested format for the "+objName+"\n"+arrE[0]+"Numbers allowed: "+arrE[2]+"\nSpaces allowed: "+arrE[3]+arrE[4]);		
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}	

/***************************************************************************/
function replaceChars(entry,out,add) {
	temp = "" + entry.value; // temporary holder
	while (temp.indexOf(out)>-1) {
	  pos= temp.indexOf(out);
	  temp = "" + (temp.substring(0, pos) + add + 
	  temp.substring((pos + out.length), temp.length));
	}
	entry.value = temp;
}

/***************************************************************************/
function changeCase(frmObj) {
	var index;
	var tmpStr;
	var tmpChar;
	var preString;
	var postString;
	var strlen;
	tmpStr = frmObj.value.toLowerCase();
	strLen = tmpStr.length;
	if (strLen > 0)  {
	for (index = 0; index < strLen; index++)  {
	if (index == 0)  {
	tmpChar = tmpStr.substring(0,1).toUpperCase();
	postString = tmpStr.substring(1,strLen);
	tmpStr = tmpChar + postString;
	}
	else {
	tmpChar = tmpStr.substring(index, index+1);
	if (tmpChar == " " && index < (strLen-1))  {
	tmpChar = tmpStr.substring(index+1, index+2).toUpperCase();
	preString = tmpStr.substring(0, index+1);
	postString = tmpStr.substring(index+2,strLen);
	tmpStr = preString + tmpChar + postString;
		 }
	      }
	   }
	}
	frmObj.value = tmpStr;
}

/***************************************************************************/
function validateDecimal(formObj, lval, rval) {
	var objName = formatName(formObj);
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	(lval == '*')? lval = '*': lval = parseInt(lval);
	(rval == '*')? rval = '*': rval = parseInt(rval);
	var decReg = "";
	if (lval == 0)
		decReg = "^\\.[0-9]{"+rval+"}$";	
	else if (lval == '*')
		decReg = "^[0-9]"+lval+"\\.[0-9]{"+rval+"}$";
	else if (rval == '*')
		decReg = "^[0-9]{"+lval+"}\\.[0-9]"+rval+"$";
	else
		decReg = "^[0-9]{"+lval+"}\\.[0-9]{"+rval+"}$";
	var regex = new RegExp(decReg);
	if (!regex.test(formObj.value)) {
		if (groupError) { addError(formObj); return true; }
		window.alert(formObj.value+' is not a valid '+objName+'.  Please re-enter the '+objName);
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
	
/***************************************************************************/
function validateDecimalR(formObj, lmin, lmax, rmin, rmax) {
	var objName = formatName(formObj);
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	(lmin == '*')? lmin = 0: lmin = parseInt(lmin);
	(lmax == '*')? lmax = '': lmax = parseInt(lmax);
	(rmin == '*')? rmin = 0: rmin = parseInt(rmin);
	(rmax == '*')? rmax = '': rmax = parseInt(rmax);
	var	decReg = "^[0-9]{"+lmin+","+lmax+"}\\.[0-9]{"+rmin+","+rmax+"}$"
	var regex = new RegExp(decReg);
	if (!regex.test(formObj.value)) {
		if (groupError) { addError(formObj); return true; }
		window.alert(formObj.value+' is not a valid '+objName+'.  Please re-enter the '+objName);
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
/***************************************************************************/
function validateIP(formObj, portMin, portMax) {
	var objName = formatName(formObj);	
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	if (typeof portMin == 'undefined') portMin = 0;
	if (typeof portMax == 'undefined') portMax = 99999;
	var portOk = true;
	var ipReg = "^((?:([2]{1}[0-5]{2})|([2]{1}[0-4]{1}[0-9]{1})|([1]?[0-9]{2})|([0-9]{1}))[\\.]){3}(?:([2]{1}[0-5]{2})|([2]{1}[0-4]{1}[0-9]{1})|([1]?[0-9]{2})|([0-9]{1}))(\\:[0-9]{1,5})?$"
	var portLoc = formObj.value.indexOf(":");
	if (portLoc != -1) {
		 var port = parseInt(formObj.value.substring(portLoc+1));
		 if (port < portMin || port > portMax) portOk = false;		
		 }
	var regex = new RegExp(ipReg);
	if (!regex.test(formObj.value) || !portOk) {
		if (groupError) { addError(formObj); return true; }
		if (regex.test(formObj.value) && !portOk)
			window.alert("The port number you specified, "+port+",  is out of range.\nIt must be between "+portMin+" and "+portMax);
		else			
			window.alert(formObj.value+' is not a valid IP address.  Please re-enter');
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
/***************************************************************************/
function validateSSN(formObj) {
	var objName = formatName(formObj);	
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }

	var regex = new RegExp(/^\d{3}\-\d{2}\-\d{4}$/);
	if (!regex.test(formObj.value)) {
		if (groupError) { addError(formObj); return true; }
		window.alert(formObj.value+' is not a valid Social Security Number.\nYour SSN must be entered in \'XXX-XX-XXXX\' format.');
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
/***************************************************************************/
function validateMoney(formObj, ds, grp, dml) {
	var objName = formatName(formObj);	
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	var moneySyntax;
	if (ds && grp && dml)		// Dollar sign, grouping, and decimal
		{ moneyReg = "^\\$(?:(?:[0-9]{1,3},)(?:[0-9]{3},)*[0-9]{3}|[0-9]{1,3})(\\.[0-9]{2})$";	moneySyntax = "$XX,XXX.XX"; }
	if (ds && grp && !dml)		// Dollar sign and grouping
		{ moneyReg="^\\$(?:(?:[0-9]{1,3},)(?:[0-9]{3},)*[0-9]{3}|[0-9]{1,3})$"; moneySyntax="$XX,XXX"; }
	if (ds && !grp && dml)		// Dollar sign and decimal
		{ moneyReg="^\\$[0-9]*(\\.[0-9]{2})$"; moneySyntax="$XXXXX.XX"; }
	if (!ds && grp && dml)		// Grouping and decimal
		{ moneyReg="^(?:(?:[0-9]{1,3},)(?:[0-9]{3},)*[0-9]{3}|[0-9]{1,3})(\\.[0-9]{2})?$"; moneySyntax="XX,XXX.XX"; }
	if (ds && !grp && !dml)		// Dollar sign only
		{ moneyReg="^\\$[0-9]*$"; moneySyntax="$XXXXX"; }
	if (!ds && grp && !dml)		// Grouping only
		{ moneyReg="^(?:(?:[0-9]{1,3},)(?:[0-9]{3},)*[0-9]{3}|[0-9]{1,3})$"; moneySyntax="XX,XXX"; }
	if (!ds && !grp && dml)		// Decimal only
		{ moneyReg="^[0-9]*(\\.[0-9]{2})$"; moneySyntax="XXXXX.XX"; }
	if (!ds && !grp && !dml)	// No params set, all special chars become optional
		{ moneyReg="^\\$?(?:(?:[0-9]{1,3},?)(?:[0-9]{3},?)*[0-9]{3}|[0-9]{1,3})(\\.[0-9]{2})?$"; moneySyntax="[$]XX[,]XXX[.XX]"; }
	var regex = new RegExp(moneyReg);
	if (!regex.test(formObj.value)) {
		if (groupError) { addError(formObj); return true; }
		window.alert(formObj.value+' does not match the required format of '+moneySyntax+' for '+objName+'.');
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}

/***************************************************************************/
function validateSelect(formObj) {
	var objName = formatName(formObj);
	if (formObj.selectedIndex == 0) {
		//if (groupError) { addError(formObj); return true; }
		alert('Please select the '+objName);
		errorProcess(formObj,0,1);
		return false;
		}
	return true;
	}
	
/***************************************************************************/
function validateSelectM(formObj, minS, maxS) {
	var objName = formatName(formObj);
	var selectCount = 0;
	if (maxS == 999) maxS = formObj.length;
	for (var i=0; i<formObj.length; i++)
		{
		if (formObj.options[i].selected)
			selectCount++; 
		}
	if (selectCount < minS || selectCount > maxS) {
		if (groupError) { addError(formObj); return true; }
		alert('Please select between '+minS+' and '+maxS+' '+objName+'.\nYou currently have '+selectCount+' selected');
		errorProcess(formObj,0,1);
		return false;
		}
	return true;
	}
	
/***************************************************************************/
function validateSelectI(formObj, indexes) {
	var objName = formatName(formObj);
	var arrIndexes =indexes.split(/[,]/);
	var selectOK = true;
	for (var i=0; i<arrIndexes.length; i++)
		{
		if (formObj.selectedIndex == arrIndexes[i])
			selectOK = false;
		}

	if (!selectOK) {
		if (groupError) { addError(formObj); return true; }
		alert('Please select a valid option for '+objName);
		errorProcess(formObj,0,1);
		return false;
		}
	return true;
	}
		
/***************************************************************************/
function validateZip(formObj) {
	var objName = formatName(formObj);	
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	zipReg = "^[0-9]{5}(|[\- ]?[0-9]{4})$"
	var regex = new RegExp(zipReg);
	if (!regex.test(formObj.value)) {
		if (groupError) { addError(formObj); return true; }
		window.alert("Please enter a valid 5 or 9 digit Zip code.    ");
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}

/***************************************************************************/
function validateEmail(formObj)	{	
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }

	var emailStr = formObj.value;

	if (emailCheck(emailStr)) {// if syntax is valid
		return true;
		}
	else {
		if (groupError) { addError(formObj); return true; }
		//window.alert("Please enter a valid Email address.");
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
	
function emailCheck (emailStr) {

var checkTLD=1;
var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;
var emailPat=/^(.+)@(.+)$/;
var specialChars="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";
var validChars="\[^\\s" + specialChars + "\]";
var quotedUser="(\"[^\"]*\")";
var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;
var atom=validChars + '+';
var word="(" + atom + "|" + quotedUser + ")";
var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");
var matchArray=emailStr.match(emailPat);

if (matchArray==null) {
alert("Email address seems incorrect (check @ and .'s)");
return false;
}
var user=matchArray[1];
var domain=matchArray[2];

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;
   }
}

if (user.match(userPat)==null) {
alert("The username doesn't seem to be valid.");
return false;
}

var IPArray=domain.match(ipDomainPat);
if (IPArray!=null) {
for (var i=1;i<=4;i++) {
if (IPArray[i]>255) {
alert("Destination IP address is invalid!");
return false;
   }
}
return true;
}

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;
   }
}

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;
}

if (len<2) {
alert("This address is missing a hostname!");
return false;
}

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


/***************************************************************************/
function validatePhone(formObj)	{
	var objName = formatName(formObj);	
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	phoneReg = "^(?:[\(][0-9]{3}[\)]|[0-9]{3})[-. ]?[0-9]{3}[-. ]?[0-9]{4}$";
	var regex = new RegExp(phoneReg);
	if (regex.test(formObj.value)) {
		return true;
		}
	else {
		if (groupError) { addError(formObj); return true; }
		window.alert("Please enter a valid Phone number plus Area Code.");
		errorProcess(formObj,1,1);
		return false;
		}
	return true;
	}
	
/***************************************************************************/
function validateCheckbox(formObj, FRM, chkbxName, minC, maxC) {
	var formObj = eval(FRM+'.'+chkbxName);
	var objName = chkbxName;
	var checkTotal = eval(FRM+'.'+chkbxName+'.length');
	var checkCount = 0;
	if (maxC == 999) maxC = checkTotal;
	for (var i=0; i<checkTotal; i++) {
		if (formObj[i].checked) checkCount++;
		}
	if (checkCount < minC || checkCount > maxC) {
		if (groupError) { addError(formObj); return true; }
		alert('Please select between '+minC+' and '+maxC+' options for '+objName+'.\nYou currently have '+checkCount+' selected');
		errorProcess(formObj[0],0,1);
		return false;
		}
	return true;
	}

/***************************************************************************/	
function validateRadio(formObj, FRM, radioName) {	
	var radioLength = eval(FRM+'.'+radioName+'.length');
	var objName = formatName(formObj);
	var selectTotal = 0;
	for (i=0; i<radioLength; i++) {
		if (eval(FRM+'.'+radioName+'['+i+'].checked'))
			selectTotal++;	
		}
	if (selectTotal != 1) {
		if (groupError) { addError(formObj); return true; }
		alert('Please select an option for '+objName);
		errorProcess(formObj,0,1);
		return false;
		}		
	return true;
	}
/***************************************************************************/
function addError(obj) {
	errorData[errorData.length] = obj;	
	}
/***************************************************************************/
function formatName(o) {
	var wStr = (o.name) ? o.name : o.id;
	wStr = wStr.replace(/_/g," ");
	return wStr;
	}
/***************************************************************************/	
function errorProcess(tempObj, sel, foc) {
	revertClass = tempObj.className;
	tempObj.className = errorClass;
	if (sel) tempObj.select();
	if (foc) tempObj.focus();
	}
/***************************************************************************/
function clearStyle(tempObj) {
	if (tempObj.className == errorClass) tempObj.className = revertClass;
	}
/***************************************************************************/	
function puncStr(str) {
	str = str.replace("pipe", "|");
	return str.replace(/([\\\|\(\)\[\{\^\$\*\+\?\.])/g,"\\$1");
//	return str.replace(/([\!\@\#\$\%\^\&\*\(\)\_\+\-\=\{\}\|\[\]\\\:\"\;\'\<\>\?\,\.\/])/g,"\\$1");
	}
/*****************************************************************************************************	
*	CREDIT CARD FUNCTIONS
*
*********** WARNING: DO NOT EDIT BELOW THIS LINE UNLESS YOU KNOW WHAT YOU ARE DOING! ****************/	

function cleanupCCNum(ccNum) {
	return ccNum.replace(/\D/g,'');
	}	
/***************************************************************************/	
function validateCC(formObj) {
	var objName = formatName(formObj);	
	if (blankOK && checkBlank(formObj))
		{ blankOK=false; return true; }
	
	switch (eval(ccTypeObj).value) {
		case 'VISA'		: var ccReg = new RegExp(/^4\d{12}(\d{3})?$/); break;
		case 'MC'		: var ccReg = new RegExp(/^5[1-5]\d{14}$/); break;
		case 'DISC'		: var ccReg = new RegExp(/^6011\d{12}$/); break;
		case 'AMEX'		: var ccReg = new RegExp(/^6011\d{12}$/); break;		
		case 'DINERS'	: var ccReg = new RegExp(/^3[0|6|8]\d{12}$/); break;
		case 'ENROUTE'	: var ccReg = new RegExp(/^2[014|149]\d{11}$/); break;
		case 'JCB'		: var ccReg = new RegExp(/^3[088|096|112|158|337|528]\d{12}$/); break;
		// Add additonal card types here
		default			: if (!groupError) alert('Error! Card Type not found!'); return false;
		}
	var formatOK = ccReg.test(formObj.value);
	var luhnOK = validateLUHN(formObj.value);	
	if (!formatOK || !luhnOK) {
		if (groupError) { addError(formObj); return true; }
		alert('The '+objName+' you entered is not valid. Please check again and re-enter');
		errorProcess(formObj,1,1);
		return false;
		}		
	return true;
	}
/***************************************************************************/	
function validateLUHN(ccString) {
	var odds = "";
	var evens = "";
	var i=1;
	for (i=0; i<ccString.length; i=i+2) {
		var digit = parseInt(ccString.charAt(i)) * 2;
		odds += digit+"";
		}
	for (i=1; i<ccString.length; i=i+2)
		evens += ccString.charAt(i);
	var luhnStr = odds + evens;
	var checkSum = 0;
	for (i=0; i<luhnStr.length; i++)
		checkSum += parseInt(luhnStr.charAt(i));
	return (checkSum % 10 == 0);
	}