/*
* Este archivo contiene las funciones de validacion generadas por struts.
* */
var bCancel = false;
var types = new Array();
var fields = new Array();
var focusField = null;
var i = 0;
var prefix = "";

function inicializeValidationTypes(elementType, frameCode)
{
	types = new Array();
	prefix = elementType + "-" + frameCode + "-";
}

function addValidationElement(type, element)
{
	var typeElements = types[type];
	if (typeElements == undefined) {
		typeElements = new Array();
		types[type] = typeElements;
	}
	typeElements[typeElements.length] = element;
}


function validate()
{
	if (bCancel) {
		return true;
	} else {
		var formValidationResult = 1;
		focusField = null;
		fields = new Array();

		if (types["required"] != undefined) {
			formValidationResult = validateRequired() && formValidationResult;
		}
		if (types["date"] != undefined) {
			formValidationResult = validateDate() && formValidationResult;
		}
		if (types["email"] != undefined) {
			formValidationResult = validateEmail() && formValidationResult;
		}
		if (types["float"] != undefined) {
			formValidationResult = validateFloat() && formValidationResult;
		}
		if (types["integer"] != undefined) {
			formValidationResult = validateInteger() && formValidationResult;
		}
		if (types["minLength"] != undefined) {
			formValidationResult = validateMinLength("minLength") && formValidationResult;
		}
		if (types["maxLength"] != undefined) {
			formValidationResult = validateMaxLength("maxLength") && formValidationResult;
		}
		if (types["intRange"] != undefined) {
			formValidationResult = validateIntRange("intRange") && formValidationResult;
		}
		if (types["minLengthElement"] != undefined) {
			formValidationResult = validateMinLength("minLengthElement") && formValidationResult;
		}
		if (types["maxLengthElement"] != undefined) {
			formValidationResult = validateMaxLength("maxLengthElement") && formValidationResult;
		}
		if (types["intRangeElement"] != undefined) {
			formValidationResult = validateIntRange("intRangeElement") && formValidationResult;
		}
		//TODO: Agregar mas validaciones

		if (fields.length > 0) {
			if (focusField != null) {
				focusField.focus();
			}
			alert(fields.join('\n'));
		}
		return (formValidationResult == 1);
	}
}

/*$RCSfile: validateRequired.js,v $ $Revision: 1.13 $ $Date: 2004/03/28 16:53:21 $ */
/**
*  Check to see if fields must contain a value.
* Fields are not checked if they are disabled.
* <p>
* @param form The form validation is taking place on.
*/
function validateRequired() {
	var isValid = true;
	var oRequired = types["required"];

	if (oRequired != undefined) {
		for (var pos = 0; pos < oRequired.length; pos++) {
			var field = document.getElementById(prefix + oRequired[pos][0]);

			if ((field.type == 'hidden' || field.type == 'text' || field.type == 'textarea' || field.type == 'file' ||
				 field.type == 'checkbox' || field.type == 'select-one' || field.type == 'password') &&	!field.disabled) {

				var value = '';
				// get field's value
				if (field.type == "select-one") {
					var si = field.selectedIndex;
					if (si >= 0) {
						value = field.options[si].value;
					}
				} else if (field.type == 'checkbox') {
					if (field.checked) {
						value = field.value;
					} else { //Agregado para que no de problemas de validación con ajax
						value = "false";
					}
				} else {
					value = field.value;
				}

				if (trim(value).length == 0) {
					if ((focusField == null) && (field.type != 'hidden')) {
						focusField = field;
					}
					fields[fields.length] = oRequired[pos][1];
					isValid = false;
				}
			} else if (field.type == "select-multiple") {
				var numOptions = field.options.length;
				var lastSelected = -1;
				for(var loop = numOptions - 1; loop >= 0; loop--) {
					if (field.options[loop].selected) {
						lastSelected = loop;
						value = field.options[loop].value;
						break;
					}
				}
				if(lastSelected < 0 || trim(value).length == 0) {
					if ((focusField == null) && (field.type != 'hidden')) {
						focusField = field;
					}
					fields[fields.length] = oRequired[pos][1];
					isValid = false;
				}
			} else if ((field.length > 0) && (field[0].type == 'radio' || field[0].type == 'checkbox')) {
				var isChecked = -1;
				for (loop = 0; loop < field.length; loop++) {
					if (field[loop].checked) {
						isChecked = loop;
						break; // only one needs to be checked
					}
				}
				if (isChecked < 0) {
					if ((focusField == null) && (field.type != 'hidden')) {
						focusField = field[0];
					}
					fields[fields.length] = oRequired[pos][1];
					isValid = false;
				}
			}
		}
	}
	return isValid;
}

/*$RCSfile: validateMinLength.js,v $ $Revision: 1.11 $ $Date: 2004/03/28 16:53:21 $ */
/**
* A field is considered valid if greater than the specified minimum.
* Fields are not checked if they are disabled.
* <p>
* <strong>Caution:</strong> Using <code>validateMinLength</code> on a password field in a
*  login page gives unnecessary information away to hackers. While it only slightly
*  weakens security, we suggest using it only when modifying a password.</p>
*/
function validateMinLength(type) {
	var isAllValid = true;
	var oMinLength = types[type];

	if (oMinLength != undefined) {
		for (var pos = 0; pos < oMinLength.length; pos++) {
			var field = document.getElementById(prefix + oMinLength[pos][0]);
			var iMin = parseInt(oMinLength[pos][2]("minlength"));
			var isValid = true;

			if ((field.type == 'hidden' || field.type == 'text' || field.type == 'password' || field.type == 'textarea')
			&& !field.disabled) {
				if ((trim(field.value).length > 0) && (field.value.length < iMin)) {
					if ((focusField == null) && (field.type != 'hidden')) {
						focusField = field;
					}
					isValid = false;
				}
			} else if ((field.type == 'select-one') && !field.disabled) {
				var si = field.selectedIndex;
				var value = '';
				if (si >= 0) {
					value = field.options[si].value;
				}
				isValid = (trim(value).length > 0 && iMin == 1); //Solo sirve para cardinales de 1
			} else if ((field.type == 'select-multiple') && !field.disabled) {
				var numOptions = field.options.length;
				var selected = 0;
				for(var loop = numOptions - 1; loop >= 0; loop--) {
					if (field.options[loop].selected) {
						selected++;
					}
				}
				isValid = selected >= iMin;
			}

			if (!isValid) {
				fields[fields.length] = oMinLength[pos][1];
				isAllValid = false;
			}
		}
	}
	return isAllValid;
}

/*$RCSfile: validateIntRange.js,v $ $Revision: 1.10 $ $Date: 2004/03/28 16:53:21 $ */
/**
* Check to see if fields is in a valid integer range.
* Fields are not checked if they are disabled.
* <p>
*/
function validateIntRange(type) {
	var isValid = true;
	var oRange = types[type];

	if (oRange != undefined) {
		for (var pos = 0; pos < oRange.length; pos++) {
			var field = document.getElementById(prefix + oRange[pos][0]);
			if (!field.disabled)  {
				var value = '';
				if (field.type == 'hidden' || field.type == 'text' || field.type == 'textarea' || field.type == 'radio' ) {
					value = field.value;
				}
				if (field.type == 'select-one') {
					var si = field.selectedIndex;
					if (si >= 0) {
						value = field.options[si].value;
					}
				}
				if (value.length > 0) {
					var iMin = parseInt(oRange[pos][2]("min"));
					var iMax = parseInt(oRange[pos][2]("max"));
					var iValue = parseInt(value);
					if (!(iValue >= iMin && iValue <= iMax)) {
						if ((focusField == null) && (field.type != 'hidden')) {
							focusField = field;
						}
						fields[fields.length] = oRange[pos][1];
						isValid = false;
					}
				}
			}
		}
	}
	return isValid;
}

/*$RCSfile: validateInteger.js,v $ $Revision: 1.9 $ $Date: 2004/03/28 16:53:21 $ */
/**
* Check to see if fields are a valid integer.
* Fields are not checked if they are disabled.
* <p>
* @param form The form validation is taking place on.
*/
function validateInteger() {
	var bValid = true;
	var oInteger = types["integer"];

	if (oInteger != undefined) {
		for (var pos = 0; pos < oInteger.length; pos++) {
			var field = document.getElementById(prefix + oInteger[pos][0]);

			if ((field.type == 'hidden' || field.type == 'text' || field.type == 'textarea' ||
				 field.type == 'select-one' || field.type == 'radio') && !field.disabled) {
				var value = '';
				// get field's value
				if (field.type == "select-one") {
					var si = field.selectedIndex;
					if (si >= 0) {
						value = field.options[si].value;
					}
				} else {
					value = field.value;
				}

				if (value.length > 0) {
					if (!isAllDigits(value)) {
						bValid = false;
						if ((focusField == null) && (field.type != 'hidden')) {
							focusField = field;
						}
						fields[fields.length] = oInteger[pos][1];
					} else {
						var iValue = parseInt(value);
						if (isNaN(iValue) || !(iValue >= -2147483648 && iValue <= 2147483647)) {
							if ((focusField == null) && (field.type != 'hidden')) {
								focusField = field;
							}
							fields[fields.length] = oInteger[pos][1];
							bValid = false;
						}
					}
				}
			}
		}
	}
	return bValid;
}

function isAllDigits(argvalue) {
	argvalue = argvalue.toString();
	var validChars = "0123456789";
	var startFrom = 0;
	if (argvalue.substring(0, 2) == "0x") {
	   validChars = "0123456789abcdefABCDEF";
	   startFrom = 2;
	} else if (argvalue.charAt(0) == "0") {
	   validChars = "01234567";
	   startFrom = 1;
	} else if (argvalue.charAt(0) == "-") {
		startFrom = 1;
	}

	for (var n = startFrom; n < argvalue.length; n++) {
		if (validChars.indexOf(argvalue.substring(n, n+1)) == -1) return false;
	}
	return true;
}

/*$RCSfile: validateDate.js,v $ $Revision: 1.10 $ $Date: 2004/03/28 16:53:21 $ */
/**
* Check to see if fields are a valid date.
* Fields are not checked if they are disabled.
* <p>
* @param form The form validation is taking place on.
*/
function validateDate() {
	var bValid = true;
	var oDate = types["date"];

	if (oDate != undefined) {
		for (var pos = 0; pos < oDate.length; pos++) {
			var field = document.getElementById(prefix + oDate[pos][0]);
			var value = field.value;
			var datePattern = oDate[pos][2]("datePatternStrict");
			// try loose pattern
			if (datePattern == null) {
				datePattern = oDate[pos][2]("datePattern");
			}
			if ((field.type == 'hidden' || field.type == 'text' || field.type == 'textarea') &&
				(value.length > 0) && (datePattern.length > 0) && !field.disabled) {
				var MONTH = "MM";
				var DAY = "dd";
				var YEAR = "yyyy";
				var orderMonth = datePattern.indexOf(MONTH);
				var orderDay = datePattern.indexOf(DAY);
				var orderYear = datePattern.indexOf(YEAR);
				var iDelim1;
				var iDelim2;
				var delim1;
				var delim2;
				var dateRegexp;
				var matched;

				if ((orderDay < orderYear && orderDay > orderMonth)) {
					iDelim1 = orderMonth + MONTH.length;
					iDelim2 = orderDay + DAY.length;
					delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
					delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
					if (iDelim1 == orderDay && iDelim2 == orderYear) {
						dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
					} else if (iDelim1 == orderDay) {
						dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
					} else if (iDelim2 == orderYear) {
						dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
					} else {
						dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
					}
					matched = dateRegexp.exec(value);
					if(matched != null) {
						if (!isValidDate(matched[2], matched[1], matched[3])) {
							if ((focusField == null) && (field.type != 'hidden')) {
								focusField = field;
							}
							fields[fields.length] = oDate[pos][1];
							bValid =  false;
						}
					} else {
						if ((focusField == null) && (field.type != 'hidden')) {
							focusField = field;
						}
						fields[fields.length] = oDate[pos][1];
						bValid =  false;
					}
				} else if ((orderMonth < orderYear && orderMonth > orderDay)) {
					iDelim1 = orderDay + DAY.length;
					iDelim2 = orderMonth + MONTH.length;
					delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
					delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
					if (iDelim1 == orderMonth && iDelim2 == orderYear) {
						dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
					} else if (iDelim1 == orderMonth) {
						dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
					} else if (iDelim2 == orderYear) {
						dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
					} else {
						dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
					}
					matched = dateRegexp.exec(value);
					if(matched != null) {
						if (!isValidDate(matched[1], matched[2], matched[3])) {
							if ((focusField == null) && (field.type != 'hidden')) {
								focusField = field;
							}
							fields[fields.length] = oDate[pos][1];
							bValid =  false;
						}
					} else {
						if ((focusField == null) && (field.type != 'hidden')) {
							focusField = field;
						}
						fields[fields.length] = oDate[pos][1];
						bValid =  false;
					}
				} else if ((orderMonth > orderYear && orderMonth < orderDay)) {
					iDelim1 = orderYear + YEAR.length;
					iDelim2 = orderMonth + MONTH.length;
					delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
					delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
					if (iDelim1 == orderMonth && iDelim2 == orderDay) {
						dateRegexp = new RegExp("^(\\d{4})(\\d{2})(\\d{2})$");
					} else if (iDelim1 == orderMonth) {
						dateRegexp = new RegExp("^(\\d{4})(\\d{2})[" + delim2 + "](\\d{2})$");
					} else if (iDelim2 == orderDay) {
						dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})(\\d{2})$");
					} else {
						dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{2})$");
					}
					matched = dateRegexp.exec(value);
					if(matched != null) {
						if (!isValidDate(matched[3], matched[2], matched[1])) {
							if ((focusField == null) && (field.type != 'hidden')) {
								focusField = field;
							}
							fields[fields.length] = oDate[pos][1];
							bValid =  false;
						}
					} else {
						if ((focusField == null) && (field.type != 'hidden')) {
							focusField = field;
						}
						fields[fields.length] = oDate[pos][1];
						bValid =  false;
					}
				} else {
					if ((focusField == null) && (field.type != 'hidden')) {
						focusField = field;
					}
					fields[fields.length] = oDate[pos][1];
					bValid =  false;
				}
			}
		}
	}
	return bValid;
}

function isValidDate(day, month, year) {
	if (month < 1 || month > 12) {
		return false;
	}
	if (day < 1 || day > 31) {
		return false;
	}
	if ((month == 4 || month == 6 || month == 9 || month == 11) &&
		(day == 31)) {
		return false;
	}
	if (month == 2) {
		var leap = (year % 4 == 0 &&
		   (year % 100 != 0 || year % 400 == 0));
		if (day>29 || (day == 29 && !leap)) {
			return false;
		}
	}
	return true;
}

/*$RCSfile: validateFloat.js,v $ $Revision: 1.11 $ $Date: 2004/03/28 16:53:21 $ */
/**
* Check to see if fields are a valid float.
* Fields are not checked if they are disabled.
* <p>
* @param form The form validation is taking place on.
*/
function validateFloat() {
	var bValid = true;
	var oFloat = types["float"];

	if (oFloat != undefined) {
		for (var pos = 0; pos < oFloat.length; pos++) {
			var field = document.getElementById(prefix + oFloat[pos][0]);

			if ((field.type == 'hidden' || field.type == 'text' || field.type == 'textarea' ||
				 field.type == 'select-one' || field.type == 'radio') && !field.disabled) {

				var value = '';
				// get field's value
				if (field.type == "select-one") {
					var si = field.selectedIndex;
					if (si >= 0) {
						value = field.options[si].value;
					}
				} else {
					value = field.value;
				}

				if (value.length > 0) {
					// remove '.' before checking digits
					var tempArray = value.split('.');
					//Strip off leading '0'
					var zeroIndex = 0;
					var joinedString= tempArray.join('');
					while (joinedString.charAt(zeroIndex) == '0') {
						zeroIndex++;
					}
					var noZeroString = joinedString.substring(zeroIndex,joinedString.length);

					if (!isAllDigits(noZeroString)) {
						bValid = false;
						if ((focusField == null) && (field.type != 'hidden')) {
							focusField = field;
						}
						fields[fields.length] = oFloat[pos][1];

					} else {
					var iValue = parseFloat(value);
					if (isNaN(iValue)) {
						if ((focusField == null) && (field.type != 'hidden')) {
							focusField = field;
						}
						fields[fields.length] = oFloat[pos][1];
						bValid = false;
					}
					}
				}
			}
		}
	}
	return bValid;
}

/*$RCSfile: validateMaxLength.js,v $ $Revision: 1.10 $ $Date: 2004/03/28 16:53:21 $ */
/**
* A field is considered valid if less than the specified maximum.
* Fields are not checked if they are disabled.
* <p>
* <strong>Caution:</strong> Using <code>validateMaxLength</code> on a password field in a
*  login page gives unnecessary information away to hackers. While it only slightly
*  weakens security, we suggest using it only when modifying a password.</p>
*/
function validateMaxLength(type) {
	var isAllValid = true;
	var oMaxLength = types[type];

	if (oMaxLength != undefined) {
		for (var pos = 0; pos < oMaxLength.length; pos++) {
			var field = document.getElementById(prefix + oMaxLength[pos][0]);
			var iMax = parseInt(oMaxLength[pos][2]("maxlength"));
			var isValid = true;

			if ((field.type == 'hidden' || field.type == 'text' || field.type == 'password' || field.type == 'textarea')
			&& !field.disabled) {
				if (field.value.length > iMax) {
					if ((focusField == null) && (field.type != 'hidden')) {
						focusField = field;
					}
					isValid = false;
				}
			} else if ((field.type == 'select-one') && !field.disabled) {
				var si = field.selectedIndex;
				var value = '';
				if (si >= 0) {
					value = field.options[si].value;
				}
				isValid = (trim(value).length <= 0 && iMax == 1); //Solo sirve para cardinales de 1
			} else if ((field.type == 'select-multiple') && !field.disabled) {
				var numOptions = field.options.length;
				var selected = 0;
				for(var loop = numOptions - 1; loop >= 0; loop--) {
					if (field.options[loop].selected) {
						selected++;
					}
				}
				isValid = selected <= iMax;
			}

			if (!isValid) {
				fields[fields.length] = oMaxLength[pos][1];
				isAllValid = false;
			}
		}
	}
	return isAllValid;
}

/*$RCSfile: validateEmail.js,v $ $Revision: 1.9 $ $Date: 2004/03/28 16:53:21 $ */
/**
* Check to see if fields are a valid email address.
* Fields are not checked if they are disabled.
* <p>
* @param form The form validation is taking place on.
*/
function validateEmail() {
	var bValid = true;
	var oEmail = types["email"];

	if (oEmail != undefined) {
		for (var pos = 0; pos < oEmail.length; pos++) {
			var field = document.getElementById(prefix + oEmail[pos][0]);
			if ((field.type == 'hidden' || field.type == 'text' || field.type == 'textarea') && (field.value.length > 0)
			&& !field.disabled) {
				if (!checkEmail(field.value)) {
					if ((focusField == null) && (field.type != 'hidden')) {
						focusField = field;
					}
					fields[fields.length] = oEmail[pos][1];
					bValid = false;
				}
			}
		}
	}
	return bValid;
}

/**
 * Reference: Sandeep V. Tamhankar (stamhankar@hotmail.com),
 * http://javascript.internet.com
 */
function checkEmail(emailStr) {
   if (emailStr.length == 0) {
	   return true;
   }
   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) {
	   return false;
   }
   var user=matchArray[1];
   var domain=matchArray[2];
   if (user.match(userPat) == null) {
	   return false;
   }
   var IPArray = domain.match(ipDomainPat);
   if (IPArray != null) {
	   for (var i = 1; i <= 4; i++) {
		  if (IPArray[i] > 255) {
			 return false;
		  }
	   }
	   return true;
   }
   var domainArray=domain.match(domainPat);
   if (domainArray == null) {
	   return false;
   }
   var atomPat=new RegExp(atom,"g");
   var domArr=domain.match(atomPat);
   var len=domArr.length;
   if ((domArr[domArr.length-1].length < 2) ||
	   (domArr[domArr.length-1].length > 3)) {
	   return false;
   }
   if (len < 2) {
	   return false;
   }
   return true;
}

//--- ACA COMIENZAN LAS FUNCIONES NO UTILIZADAS AUN POR PUZZLE ---

/*$RCSfile: validateCreditCard.js,v $ $Revision: 1.8 $ $Date: 2004/03/28 16:53:21 $ */
/**
* Check to see if fields are a valid creditcard number based on Luhn checksum.
* Fields are not checked if they are disabled.
* <p>
* @param form The form validation is taking place on.
*/
function validateCreditCard(form) {
	var bValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var formName = form.getAttributeNode("name");

	var oCreditCard = eval('new ' + formName.value + '_creditCard()');

	for (var x in oCreditCard) {
		if ((form[oCreditCard[x][0]].type == 'text' ||
			 form[oCreditCard[x][0]].type == 'textarea') &&
			(form[oCreditCard[x][0]].value.length > 0)  &&
			 form[oCreditCard[x][0]].disabled == false) {
			if (!luhnCheck(form[oCreditCard[x][0]].value)) {
				if (i == 0) {
					focusField = form[oCreditCard[x][0]];
				}
				fields[i++] = oCreditCard[x][1];
				bValid = false;
			}
		}
	}
	if (fields.length > 0) {
		focusField.focus();
		alert(fields.join('\n'));
	}
	return bValid;
}

/**
 * Checks whether a given credit card number has a valid Luhn checksum.
 * This allows you to spot most randomly made-up or garbled credit card numbers immediately.
 * Reference: http://www.speech.cs.cmu.edu/~sburke/pub/luhn_lib.html
 */
function luhnCheck(cardNumber) {
	if (isLuhnNum(cardNumber)) {
		var no_digit = cardNumber.length;
		var oddoeven = no_digit & 1;
		var sum = 0;
		for (var count = 0; count < no_digit; count++) {
			var digit = parseInt(cardNumber.charAt(count));
			if (!((count & 1) ^ oddoeven)) {
				digit *= 2;
				if (digit > 9) digit -= 9;
			};
			sum += digit;
		};
		if (sum == 0) return false;
		if (sum % 10 == 0) return true;
	};
	return false;
}

function isLuhnNum(argvalue) {
	argvalue = argvalue.toString();
	if (argvalue.length == 0) {
		return false;
	}
	for (var n = 0; n < argvalue.length; n++) {
		if ((argvalue.substring(n, n+1) < "0") ||
			(argvalue.substring(n,n+1) > "9")) {
			return false;
		}
	}
	return true;
}

/*$RCSfile: validateShort.js,v $ $Revision: 1.9 $ $Date: 2004/03/28 16:53:21 $ */
/**
*  Check to see if fields are a valid short.
* Fields are not checked if they are disabled.
* <p>
* @param form The form validation is taking place on.
*/
function validateShort(form) {
	var bValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var formName = form.getAttributeNode("name");

	var oShort = eval('new ' + formName.value + '_ShortValidations()');

	for (var x in oShort) {
		var field = form[oShort[x][0]];

		if ((field.type == 'hidden' ||
			field.type == 'text' ||
			field.type == 'textarea' ||
			field.type == 'select-one' ||
			field.type == 'radio')  &&
			field.disabled == false) {

			var value = '';
			// get field's value
			if (field.type == "select-one") {
				var si = field.selectedIndex;
				if (si >= 0) {
					value = field.options[si].value;
				}
			} else {
				value = field.value;
			}

			if (value.length > 0) {
				if (!isAllDigits(value)) {
					bValid = false;
					if (i == 0) {
						focusField = field;
					}
					fields[i++] = oShort[x][1];

				} else {

					var iValue = parseInt(value);
					if (isNaN(iValue) || !(iValue >= -32768 && iValue <= 32767)) {
						if (i == 0) {
							focusField = field;
						}
						fields[i++] = oShort[x][1];
						bValid = false;
					}
			   }
		   }
		}
	}
	if (fields.length > 0) {
	   focusField.focus();
	   alert(fields.join('\n'));
	}
	return bValid;
}

/*$RCSfile: validateByte.js,v $ $Revision: 1.9 $ $Date: 2004/03/28 16:53:21 $ */
/**
* Check to see if fields are a valid byte.
* Fields are not checked if they are disabled.
* <p>
* @param form The form validation is taking place on.
*/
function validateByte(form) {
	var bValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var formName = form.getAttributeNode("name");
	var oByte = eval('new ' + formName.value + '_ByteValidations()');

	for (var x in oByte) {
		var field = form[oByte[x][0]];

		if ((field.type == 'hidden' ||
			field.type == 'text' ||
			field.type == 'textarea' ||
			field.type == 'select-one' ||
			field.type == 'radio')  &&
			field.disabled == false) {

			var value = '';
			// get field's value
			if (field.type == "select-one") {
				var si = field.selectedIndex;
				if (si >= 0) {
					value = field.options[si].value;
				}
			} else {
				value = field.value;
			}

			if (value.length > 0) {
				if (!isAllDigits(value)) {
					bValid = false;
					if (i == 0) {
						focusField = field;
					}
					fields[i++] = oByte[x][1];

				} else {

					var iValue = parseInt(value);
					if (isNaN(iValue) || !(iValue >= -128 && iValue <= 127)) {
						if (i == 0) {
							focusField = field;
						}
						fields[i++] = oByte[x][1];
						bValid = false;
					}
				}
			}

		}
	}
	if (fields.length > 0) {
	   focusField.focus();
	   alert(fields.join('\n'));
	}
	return bValid;
}

/*$RCSfile: validateFloatRange.js,v $ $Revision: 1.9 $ $Date: 2004/03/28 16:53:21 $ */
/**
* Check to see if fields are in a valid float range.
* Fields are not checked if they are disabled.
* <p>
* @param form The form validation is taking place on.
*/
function validateFloatRange(form) {
	var isValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var formName = form.getAttributeNode("name");

	var oRange = eval('new ' + formName.value + '_floatRange()');
	for (var x in oRange) {
		var field = form[oRange[x][0]];

		if ((field.type == 'hidden' ||
			field.type == 'text' || field.type == 'textarea') &&
			(field.value.length > 0)  &&
			 field.disabled == false) {

			var fMin = parseFloat(oRange[x][2]("min"));
			var fMax = parseFloat(oRange[x][2]("max"));
			var fValue = parseFloat(field.value);
			if (!(fValue >= fMin && fValue <= fMax)) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oRange[x][1];
				isValid = false;
			}
		}
	}
	if (fields.length > 0) {
		focusField.focus();
		alert(fields.join('\n'));
	}
	return isValid;
}

/*$RCSfile: validateMask.js,v $ $Revision: 1.10 $ $Date: 2004/03/28 16:53:21 $ */
/**
* Check to see if fields are a valid using a regular expression.
* Fields are not checked if they are disabled.
* <p>
* @param form The form validation is taking place on.
*/
function validateMask(form) {
	var isValid = true;
	var focusField = null;
	var i = 0;
	var fields = new Array();
	var formName = form.getAttributeNode("name");

	var oMasked = eval('new ' + formName.value + '_mask()');
	for (var x in oMasked) {
		var field = form[oMasked[x][0]];

		if ((field.type == 'hidden' ||
			field.type == 'text' ||
			 field.type == 'textarea' ||
			 field.type == 'file') &&
			 (field.value.length > 0) &&
			 field.disabled == false) {

			if (!matchPattern(field.value, oMasked[x][2]("mask"))) {
				if (i == 0) {
					focusField = field;
				}
				fields[i++] = oMasked[x][1];
				isValid = false;
			}
		}
	}

	if (fields.length > 0) {
	   focusField.focus();
	   alert(fields.join('\n'));
	}
	return isValid;
}

function matchPattern(value, mask) {
   return mask.exec(value);
}


/*$RCSfile: validateUtilities.js,v $ $Revision: 1.2 $ $Date: 2004/03/28 16:53:21 $ */

/**
* This is a place holder for common utilities used across the javascript validation
*
**/

// Trim whitespace from left and right sides of s.
function trim(s) {
	return s.replace( /^\s*/, "" ).replace( /\s*$/, "" );
}