<!--
//##aMandatory## 

/******************
 string.js library 
******************/
// whitespace characters: ' ', '\t', '\r', '\n'
var whitespace = " \t\n\r";

// isEmpty: Check whether string strVal is empty
function isEmpty(strVal) {
	return ((strVal == null) || (strVal.length == 0));
}

// isWhitespace: Check if string strVal has only the whitespace characters
function isWhitespace(strVal) {
	var nPos = 0;

	if (isEmpty(strVal))
		return false;
	for (nPos = 0; nPos < strVal.length; nPos++)
		if (whitespace.indexOf(strVal.charAt(nPos)) == -1){
			return false;
		}
	return true;
}

// rtrim: Right trim the string and return the trimmed value
function rtrim(strVal) {
	var nPos = 0;
    var endPos
	if (isEmpty(strVal))
		return strVal;

	for (nPos = strVal.length-1; nPos >= 0; nPos--) {
		if (whitespace.indexOf(strVal.charAt(nPos)) == -1){
		 endPos = (nPos);
		 nPos = 0;  
		}  	     
	}
  
	return (endPos == strVal.length-1 ? strVal.substring(0) : strVal.substring(0, endPos+1));
}

// ltrim: Left trim the string and return the trimmed value
function ltrim(strVal) {
	var nPos = 0;
	var endPos = 0;
	if (isEmpty(strVal))
		return strVal;

	for (nPos = 0; nPos < strVal.length; nPos++) {
		if (whitespace.indexOf(strVal.charAt(nPos)) == -1){
			endPos = (nPos);
			nPos = strVal.length;  
		}
	}
	return strVal.substring(endPos);
}

// alltrim: Trim the string on left and right, and return the trimmed value
function alltrim(strVal) {
	return (isEmpty(strVal) ? strVal:ltrim(rtrim(strVal)));
}

/********************************************************
 replace: useful for JavaScript 1.0 and 1.1 where replace 
	  is not available. With JavaScript 1.2 (and above)
	  replace function is available.
	: replaces one occurrence of strVal with strWith in strSrc
********************************************************/
function replace(strSrc, strVal, strWith) {
	var nPos = 0, strLeft="", strRight="";

	// check if empty (or) no string is found to replace
	if (isEmpty(strSrc) || (strSrc.indexOf(strVal) < 0))
		return strSrc;

	nPos = strSrc.indexOf(strVal);
	strLeft = strSrc.substring(0, nPos);
	nPos += strVal.length;
	strRight = strSrc.substring(nPos);
	return (strLeft + strWith + strRight);
}

// replaceall : replace all occurrences of strVal with strWith in strSrc
function replaceall(strSrc, strVal, strWith) {
	var strBuffer=strSrc;

	while (strBuffer.indexOf(strVal) >= 0)
		strBuffer = replace(strBuffer, strVal, strWith);
	return (strBuffer);
}

// occurs: return no of occurrences of strVal within strSrc
function occurs(strVal, strSrc) {
	var nCnt = 0, strBuffer=strSrc;

	while (strBuffer.indexOf(strVal) >= 0) {
		strBuffer = replace(strBuffer, strVal, "");
		nCnt++;
	}
	return (nCnt);
}

// replicate: returns string that contains strVal repeated nCnt times
function replicate(strVal, nCnt) {
	var i = 0, strBuffer = "";

	for (i = 0; i < nCnt; i++)
		strBuffer += strVal;
	return (strBuffer);
}

/**************************************************************
 stuff: returns string after replacing nCnt characters (starting
	from nStartPos) with strReplacement in strSrc. 

 NOTE: starting position is 0
**************************************************************/
function stuff(strSrc, nStartPos, nCnt, strReplacement) {
	var strLeft= "", strRight="";

	// check boundary values
	if (nCnt < 0 || nStartPos < 0 || (nStartPos > strSrc.length-1))
		return strSrc;

	strLeft = strSrc.substring(0, nStartPos);
	strRight = strSrc.substring(nStartPos+nCnt);

	return (strLeft + strReplacement + strRight);
}


/**********************************************************************
Depends on: isEmpty(), isWhitespace() functions string.js library 

NOTE: 
  -- always alltrim field value before calling any of these functions
  -- if field is empty, the function call will return true
**********************************************************************/

// isDigit: check if val has digits (0-9)
function isDigit(val)
{
	var strBuffer = new String(val);
	var nPos = 0;

	if (isEmpty(strBuffer))
		return false;

	for (nPos = 0; nPos < strBuffer.length; nPos++)
		if (strBuffer.charAt(nPos) < '0' || strBuffer.charAt(nPos) > '9')
			return false;

	return true;
}

// isAlpha: check if val has alphabets only (a-z, A-Z)
function isAlpha(val) {
	var strBuffer = new String(val);
	var nPos = 0;

	if (isEmpty(strBuffer))
		return false;
	for (nPos = 0; nPos < strBuffer.length; nPos++)
		if (!((strBuffer.charAt(nPos) >= 'a' && strBuffer.charAt(nPos) <= 'z') ||
			(strBuffer.charAt(nPos) >= 'A' && strBuffer.charAt(nPos) <= 'Z')))
			return false;
	return true;
}

// isInteger: check if nVal is integer type
function isInteger(nVal) {
	var strBuffer = new String(nVal);
	var nPos = 0, nStart = 0;

	if (isEmpty(strBuffer))
		return true;
	if (isWhitespace(strBuffer))
		return false;

	// check if -ve or +ve sign occurs in the beginning
	if ((strBuffer.charAt(0) == '-') || (strBuffer.charAt(0) == '+'))
		nStart = 1;
	else
		nStart = 0;

	for (nPos = nStart; nPos < strBuffer.length; nPos++)
		if (strBuffer.charAt(nPos) < '0' || strBuffer.charAt(nPos) > '9')
			return false;
	return true;	
}

// isFloat: check if fVal is floating-point type
//	LIMITATION: no scientific notation (for eg: xxxx.xxE+xx)
function isFloat(fVal) {
	var strBuffer = new String(fVal);
	var nPos = 0, nStart = 0;

	if (isEmpty(strBuffer))
		return true;
	if (isWhitespace(strBuffer))
		return false;

	// check if -ve or +ve sign occurs in the beginning
	if ((strBuffer.charAt(0) == '-') || (strBuffer.charAt(0) == '+'))
		nStart = 1;
	else
		nStart = 0;

	for (nPos = nStart; nPos < strBuffer.length; nPos++)
		if ((strBuffer.charAt(nPos) < '0' || strBuffer.charAt(nPos) > '9') && 
				(strBuffer.charAt(nPos) != '.'))
			return false;
	return true;
}

/************************************************************
isDate	: Check if dVal is valid date
	: valid date format - 
		MM (or) M / DD (or) D / Y (or) YY (or) YYYY
	: YY > 50 should be 19YY
	: YY <= 50 should be 20YY
*************************************************************/
function isDate(dVal) {
	var strBuffer= new String(dVal);
	var cDelimiter='';
	var strMonth=0, strDay=0, strYear=0;
	var nPos=-1;

	if (isEmpty(strBuffer))
		return true;
	if (isWhitespace(strBuffer))
		return false;

	// Get the delimiter used
	if (occurs('/', strBuffer) == 2)
		cDelimiter = '/';
	else if (occurs('-', strBuffer) == 2)
		cDelimiter = '-';

	// If no '/' or '-' found return false
	if (cDelimiter == '')
		return false;

	// validate month, date, and year (Y, YY, YYYY are valid year formats)
	nPos = strBuffer.indexOf(cDelimiter);
	strMonth = strBuffer.substring(0, nPos);
	if (strMonth.length > 2 || !isDigit(strMonth))
		return false;
	strBuffer = strBuffer.substring(nPos+1);
	nPos = strBuffer.indexOf(cDelimiter);
	strDay = strBuffer.substring(0, nPos);
	if (strDay.length > 2 || !isDigit(strDay))
		return false;
	strBuffer = strBuffer.substring(nPos+1);
	strYear = strBuffer;
	if ((strYear.length > 4) || (strYear.length == 3) || !isDigit(strYear))
		return false;

	// if YY < 50 then YYYY=20YY, else if YY >= 50 then YYYY=19YY
	var iYear = parseInt(strYear);
	if (iYear < 50)
		strYear = "20" + (strYear < 10 ? '0' + strYear:strYear);
	else if (iYear >= 50 && iYear < 100)
		strYear = "19" + strYear;

	strBuffer = strMonth + cDelimiter + strDay + cDelimiter + strYear;
	
	

	// validate date
	var dBuffer = new Date(strBuffer);
	if (dBuffer.getDate() != eval(strDay) || 
				dBuffer.getMonth()+1 != eval(strMonth) || 
				dBuffer.getFullYear() != eval(strYear))
	
		return false;

	return true;
}

// isZipcode: check if valid US zip code (##### or #####-####)
function isZipcode(strZip) {
	var strLeft="", strRight="", strVal = new String(strZip);

	if (isEmpty(strVal))
		return true;
	if (isWhitespace(strVal))
		return false;

	if (strVal.length != 5 && strVal.length != 10)
		return false;

	if ((strVal.length == 5) && isDigit(strVal))
		return true;

	if ((strVal.length == 10) && isDigit(strVal.substring(0, 5)) && 
						isDigit(strVal.substring(6)))
		return true;

	return false;
}

// isDatePart: check if nVal is valid day: 1-31, month:1-12, year:YYYY
function isDatePart(nVal, strType)
{
	var strBuffer = new String(nVal);

	if (isEmpty(strBuffer) || isWhitespace(strBuffer))
		return false;
	
	nVal = parseInt(strBuffer);
	if (!isDigit(nVal))
		return false;

	if ((strType == "Year") && (nVal < 0 || (nVal > 99 && nVal < 1000) || nVal > 9999))
		return false;
	else if ((strType == "Month") && (nVal < 1 || nVal > 12))
		return false;
	else if ((strType == "Day") && (nVal < 1 || nVal > 31))
		return false;

	return true;
}

/**************************************************************
 Description: Check according to strType:
   Integer, Float, Digit, ZIP, Date or DatePartYear. 
**************************************************************/
function checkField(objFld, strType)
{
	objFld.value = alltrim(objFld.value);
	if (isEmpty(objFld.value))
		return true;

	// Remove commas from Integer and Float fields
	if ((strType == "Integer") || (strType == "Float"))
		objFld.value = replaceall(objFld.value, ",", "");

	if ((strType == "Digit") && !isDigit(objFld.value)) {
		alert("Please enter a response in numerical format (please " + 
			"exclude dollar signs, commas, parenthesis or any other " + 
			"non-numeric symbols).");
		// objFld.value = "";
		objFld.focus();
		return false;
	}

	if (strType == "Integer") 
		if (!isInteger(parseInt(objFld.value))) {
			alert("Please enter a response in numerical format (please " + 
				"exclude dollar signs, commas, parenthesis or any other " + 
				"non-numeric symbols).");
			//objFld.value = "";
			objFld.focus();
			return false;
		}
		else
			objFld.value = parseInt(objFld.value);

	if (strType == "Float") 
		if (!isFloat(parseFloat(objFld.value))) {
			alert("Please enter a response in numerical format (please " + 
				"exclude dollar signs, commas, parenthesis or any other " + 
				"non-numeric symbols).");
			//objFld.value = "";
			objFld.focus();
			return false;
		}
		else
			objFld.value = parseFloat(objFld.value);

	if (strType == "ZIP") 
		if (!isZipcode(objFld.value)) {
			alert("Please enter valid zip code value");
			//objFld.value = "";
			objFld.focus();
			return false;
		}

	if (strType == "Date") 
		if (!isDate(objFld.value)) {
			alert("Please enter valid date value (MM/DD/YYYY)");
			//objFld.value = "";
			objFld.focus();
			return false;
		}

	if (strType == "DatePartYear" && checkField(objFld, "Digit")) {
		if (!isDatePart(objFld.value, "Year")) {
			alert("Please enter valid year value");
			//objFld.value = "";
			objFld.focus();
			return false;
		}
		else if (objFld.value < 100)
			objFld.value = (objFld.value < 50 ? 2000:1900) + parseInt(objFld.value);
	}
	return true;
}

function checkFloatRange(objFld, min, max) {
	if (checkField(objFld, 'Float')) {
		if (objFld.value < min) {
			alert("This field cannot be less than " + min);
			objFld.value = min;
			return false;
		}
		else if (objFld.value > max) {
			alert("This field cannot be greater than " + max);
			objFld.value = max;
			return false;
		}
		return true;
	}
	else
		return true;
}


// Validate E-mail Address (JavaScript 1.0 version)
// by Kevin Lynn Brown 
// kbrown@myersinternet.com
// Š1999 All rights reserved

/**************************************************************
 Description: Email address must be of form a@b.c i.e., 
	there must be at least one character before the @
	there must be at least one character before and after the .
	the characters @ and . are both required
 Dependencies: alltrim, isEmpty, occurs of string.js
**************************************************************/

function validEmail(objFld) {
	var strInvalid = "*?#&^~`'\\[]<>;/:\" ";
	var bAliasedEmail = false, strAliasedEmail="";
	var i = 0, bValid = true;

	objFld.value = alltrim(objFld.value);
	if (isEmpty(objFld.value))
		return true;

	var strEmail = new String(objFld.value);

	// Assumption: if strEmail contains < and >, Email is between < and >
	if (strEmail.indexOf('<') < strEmail.indexOf('>')
	   && strEmail.indexOf('<') >= 0) {
		bAliasedEmail = true;
		strAliasedEmail = strEmail;
		strEmail = strEmail.substring(strEmail.indexOf('<')+1, 
				strEmail.indexOf('>'));
	}

	if (strEmail.length < 5)	// check the length
		bValid = false;
	else if (strEmail.lastIndexOf("@") <= 0 || (strEmail.lastIndexOf(".") - 
		strEmail.lastIndexOf("@") <= 1)) // check positions of @ and .
		bValid = false;
	else if (occurs('@', strEmail) > 1)
		// check if @ occurs more than once
		bValid = false
	else {	// check if any invalid characters present
		for (i = 0; i < strEmail.length; i++)
			if (strInvalid.indexOf(strEmail.charAt(i)) >= 0) {
				bValid = false;
				break;
			}
	}
	
	if (!bValid) {
		alert("Please enter a valid email address");
		//objFld.value = "";
		objFld.focus();
		return bValid;
	}	
	
	if (bAliasedEmail)
	 this.value = strAliasedEmail;
	else
	 this.value = strEmail;
	
	return bValid;
}

// Phone number validation and formatting (JavaScript 1.0 version)
// by Kevin Lynn Brown
// Š1999 All rights reserved
// for Myers Internet Services

function formatPhone(number,format) {
	// format = "0" | "none" | "";
	//          "1" | "()";
	//          "-" | (user selected separator);
	// Note: all above must be passed as strings
	// Otherwise generates an error in comparison
	var formattedNumber = number + "";
	var pre = "";
	var area = "";
	var trunk = "";
	var post = "";
	if (number.length == 11) {
		pre = number.substring(0,1);
		area = number.substring(1,4);
		trunk = number.substring(4,7);
		post = number.substring(7);
	}
	else if (number.length == 10) {
		area = number.substring(0,3);
		trunk = number.substring(3,6);
		post = number.substring(6);
	}
	else if (number.length == 7) {
		trunk = number.substring(0,3);
		post = number.substring(3);
	}
	if (format != "" || format != null) {
		// Use the default U.S. format: 1 (800) 123-4567
		if (format == "()" || format == "1") {
			if (number.length == 11) {
				formattedNumber = pre + " (" +  area + ") " + trunk + "-" + post;
			}
			else if (number.length == 10) {
				formattedNumber = "(" +  area + ") " + trunk + "-" + post;
			}
			else if (number.length == 7) {
				formattedNumber = trunk + "-" + post;
			}
		}
		// Use a passed separator to hyphenate the output
		else if (format != "()" || format != "1") {
			if (number.length == 11) {
				formattedNumber = pre + format +  area + format + trunk + format + post;
			}
			else if (number.length == 10) {
				formattedNumber = area + format + trunk + format + post;
			}
			else if (number.length == 7) {
				formattedNumber = trunk + format + post;
			}
		}
	}
	return formattedNumber;
}

function validPhone(phNumber,format,form,field,required) {
	// Pass in form and field name
	// Makes the function reusable
	// format = "0" | "none" | "";
	//          "1" | "()";
	//          "-" | (user selected separator);
	// Note: all above must be passed as quoted strings
	// Otherwise generates an error in comparison
	
	// required = 0 | false | null for optional;
	//            1 | true for required;
	// Note: the above are boolean|numeric, no quotes
	
	// VARIABLES USED:
	//   killForm = a numeric flag used to stop or post the form
	//    special = a string of special characters to strip out for validation
	//     phOrig = the stored original user input
	//      phNum = the same, but will be manipulated/changed by the script
	//    phTrunc = the phone number truncated, minus any Ext.; will be changed by the script
	//  phLowCase = the phone number in lowercase; to find "Ext.", "ext", etc.
	// phLowCaseX = phTrunc in lowercase; to find "x000", "X 000", etc.
	//    phNoExt = the changed number without any extension; sent to the format function
	//        ext = holds the value "Ext" || "ext" || "ex." etc. (if found in the phone number)
	//          x = holds the value "x" || "X" (if found in the phone number)
	//     before = a section of the phone number before an illegal character
	//      after = a section of the phone number after an illegal character
	// formattedPhone = the final output of both functions

	var i = 0;
	var j = 0;
	var killForm = 0;
	if (form != null && field != null && form != "" && field != "") {
		var useForm = true;
		var phOrig = document[form][field].value;
		var phNum = document[form][field].value;
		var phTrunc = document[form][field].value;
		var phNoExt = document[form][field].value;
	}
	else {
		var useForm = false;
		var phOrig = validPhone.arguments[0];
		var phNum = validPhone.arguments[0];
		var phTrunc = validPhone.arguments[0];
		var phNoExt = validPhone.arguments[0];
	}
	var formattedPhone = "";
	var phLowCase = "";
	var phLowCaseX = "";
	var before = "";
	var after = "";
	var x = "";
	var ext = "";
	var extension = "";
	// Add any special characters to strip out here:
	var special = "()-. ,:;/\|*+#@&=";
	// If blank and required, kill the form
	if (phNum == "" && (required == 1 || required == true)) {
		alert('Sorry!  A phone number is required.')
		// Put the offending field in focus
		if (useForm)
		document[form][field].focus();
		// Stop the form post
		return false;
	}
	// If it's blank but not required, let it through
	else if (phNum == "") {
		return true;
	}
	else {
		// Find "Ext. 000" extensions and separate them out
		phLowCase = phNum.toLowerCase();
		ext = phLowCase.lastIndexOf("ext");
		if (ext != -1) {
			extension = phOrig.substring(ext,phOrig.length);
			phTrunc = phNum.substring(0,ext);
			phNoExt = phNum.substring(0,ext);
		}
		else {
			extension = "";
		}
		// This strips out formatting characters for length comparison
		for (i=0;i<phTrunc.length;i++) {
			var phChar = phTrunc.charAt(i);
			for (j=0;j<special.length;j++) {
				if (phChar == special.charAt(j)) {
					before = phTrunc.substring(0,i);
					after = phTrunc.substring(i+1);
					phTrunc = before + after;
					// If 2 illegal characters are consecutive, we have to test again using
					// the current value of phNum.charAt(i) before incrementing i, otherwise we will miss it.
					i--;
				}
			}
		}
// Obsoleted.  Could not filter out X contained in the number if no extension present
//		// Find x000 extensions.  Must be done after stripping extra characters
//		// because then x denoting an extension would only appear at character 7, 10 or 11
//		if (extension == "") {
//			phLowCaseX = phTrunc.toLowerCase();
//			// Don't want to mistakenly match an X that is part of the phone number itself
//			x = phLowCaseX.lastIndexOf("x");
//			if (phTrunc.length > 7 && x != -1 && (x == 7 || x == 10 || x == 11)) {
//				extension = phTrunc.substring(x,phTrunc.length);
//				phTrunc = phTrunc.substring(0,x);
//				phNoExt = phNum.substring(0,phNum.indexOf(extension));
//			}
//		}
		if (phTrunc.length == 11) {
			// Make sure the first 4 characters (1-800) are numeric
			for (i=0;i<4;i++) {
				if (parseInt(phTrunc.charAt(i)) + "" == Number.NaN + "") {
					killForm = 1;
				}
			}
			// There is no such thing as 2-800 or 1-000
			if (phTrunc.charAt(0) != "1" && phTrunc.charAt(0) != "0" || phTrunc.charAt(1) == "0") {
				killForm = 1;
			}
		}
		else if (phTrunc.length == 10) {
			// Make sure the area code is numeric
			for (i=0;i<3;i++) {
				if (parseInt(phTrunc.charAt(i)) + "" == Number.NaN + "") {
					killForm = 1;
				}
			}
			// No area codes begin with 0 or 1
			if (phTrunc.charAt(0) == "0" || phTrunc.charAt(0) == "1") {
				killForm = 1;		
			}
		}
		else if (phTrunc.length == 7) {
			// No phone numbers begin with 0 or 1
			if (phTrunc.charAt(0) == "0" || phTrunc.charAt(0) == "1") {
				killForm = 1;		
			}
        }
		// A proper US ph# should be 7, 10 or 11 characters now
		else if (phTrunc.length != 7 && phTrunc.length != 10 && phTrunc.length != 11) {
			killForm = 1;
		}
	}
	if (killForm == 1) {
		// Prompt for proper phone number...
		var msg = "Sorry!\nYou have entered an\ninvalid phone number.\n\n"
			+"Please check the number\nand try again.";
		alert(msg);
		// Automatically select and focus the phone number form field for easy user correction
		if (useForm) {
			document[form][field].select();
			document[form][field].focus();
		}
		// Stop the form post
		return false;
	}
	else {
		if (format && format != null && format != "" && format != "none" && format != "0") {
			// If calling field requires phone number formatting
			phNum = formatPhone(phTrunc,format) + " " + extension;
		}
		formattedPhone = phNum;
		if (useForm)
		document[form][field].value = formattedPhone;
		// Garbage collection.  Some variables seemed to retain their modified values after exiting?
		phOrig = phNum = phTrunc = i = j = killForm = formattedPhone = phLowCase = phLowCaseX = phNoExt = before = after = x = ext = extension = null;
		if (useForm) {
			return true;
		}
		else {
			return formattedPhone;
		}
	}
}


/**********************************************************************
 chkMandatory: check mandatory fields on the form objForm
 parameters: objForm - form reference

 pre-requisites: aMandatory - array of fields for which mandatory evaluation 
				should be done
		aMandatory should be defined on each HTML page 
 format of aMandatory:
    aMandatory[<field-name-string>] = new Array(<message-string>, <input-type-string>, <focus-on-string>);

 <message-string>: message to be displayed on mandatory check failure 
		(NOTE: system dispalyes "<message-string> is mandatory")
 <input-type-string>: "TEXT", "RADIO"
 <focus-on-string>: name of the field where focus should be placed on mandatory check failure.
		    if this is "" then focus is place on <field-name-string>
**********************************************************************/
//var aMandatory = new Array();
function chkMandatory(objForm) {
	for (var iLoop in aMandatory) {
		var strVal;
		strVal = "";
		if (aMandatory[iLoop][1] == "Text")
			strVal = eval("objForm." + iLoop + ".value");
		else if (aMandatory[iLoop][1] == "Radio") {
			var oEle = eval("objForm." + iLoop);
			var iLen = oEle.length;
			for (var iEle = 0; iEle < iLen; iEle++)
				if (oEle[iEle].checked) {
					strVal = oEle[iEle].value;
					break;					
				}
		}
		else if (aMandatory[iLoop][1] == "Select") {
			var iIdx = eval("objForm." + iLoop + ".selectedIndex");
			if (iIdx > -1)
				strVal = eval("objForm." + iLoop + "[" + iIdx + "].value");
			else
				strVal = "";
		}
		if (strVal == "") {
			if (aMandatory[iLoop][1] == "Text")
				alert("Please enter value for " + aMandatory[iLoop][0] + ".");
			if (aMandatory[iLoop][1] == "Radio" || aMandatory[iLoop][1] == "Select")
				alert("Please select  " + aMandatory[iLoop][0] + ".");
			if (aMandatory[iLoop][2] != "")
				eval("objForm." + aMandatory[iLoop][2] + ".focus()");
			else {
				if (aMandatory[iLoop][1] == "Radio")
					eval("objForm." + iLoop + "[0].focus()");
				else
					eval("objForm." + iLoop + ".focus()");
			}
			return false;
		}
	}
	return true;
}

// -->