function submitForm(mode, form) {
    	document.forms[form].action.value=mode;
    	return true;
    }

    function submitFormFromLink(mode, form) {
    	document.forms[form].action.value=mode;
    	if (document.forms[form].onsubmit()) {
	    	document.forms[form].submit();
    	}
    	return false;

    }

    function submitFormPopup(url) {
		newwindow=window.open(url,'name','scrollbars=yes, resizable=yes, menubar=yes, status=yes');
		if (window.focus) {newwindow.focus()}
		//return false;
	}

    function onLoadEntry(formName, focusField) {
    	//the focusField is focused, once the search operation for that field has been finished
    	var fieldNames = new String(focusField).split('|');
    	if (fieldNames[0] != "" ) {
	    	var field = document.forms[formName].elements[fieldNames[0]];
	    	if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'file' ||
                        field.type == 'select-one' ||
                        field.type == 'radio' ||
                        field.type == 'password') {
                var cancelBtn = document.forms[formName].elements["cancelBtn"];
                //locate to the bottom of the form, where is the sumit button
                cancelBtn.focus(); 
                //locate to the field on the top area of the browser
            	field.focus();
            }
    	}
    }

	function handleEnter (field, event) {
		var keyCode = event.keyCode ? event.keyCode : event.which ? event.which : event.charCode;
		if (keyCode == 13) {
			var i;
			for (i = 0; i < field.form.elements.length; i++)
				if (field == field.form.elements[i])
					break;
			i = (i + 1) % field.form.elements.length;
			field.form.elements[i].focus();
			return false;
		}
		else
		return true;
	}

	function changeCheckboxValueByState(fieldName) {
		fieldName.value=fieldName.checked;
	}

	function checkMaxLength(obj, max, message) {
		if (obj.value == null) return true;
		if (obj.value.length > max) {
			if (message != null && message != '') alert(message);
			obj.value = obj.value.substring(0, max);
			return false;
		}
		return true;
	}

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

            function validateRequiredExecute(form) {
                oRequired = new required();
                for (x in oRequired) {
                	var field = form[oRequired[x][0]];
                	if (field == undefined) continue;
                    if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'file' ||
                        field.type == 'select-one' ||
                        field.type == 'radio' ||
                        field.type == 'password' ||
                        field.type == 'hidden') {

                        var value = '';
                        //trim the spaces
						if (field.type == 'text' ||
	                        field.type == 'textarea' ||
    	                    field.type == 'file' ||
        	                field.type == 'password' ||
                        	field.type == 'hidden') {
            				field.value = form[oRequired[x][0]].value = trim(field.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 (trim(value).length == 0) {
                        	field.focus();
                        	if (field.type != 'select-one' && field.type != 'hidden') field.select();
	                        alert(oRequired[x][1]);
	                        return false;
                        }
                    }
                }
                return true;
            }
            function validateRequiredObjExecute(form) {
                oRequired = new requiredObj();
                for (x in oRequired) {
                	if (getObjById("contentSubview:registrationForm").membershipType[1].checked) continue;
                	var field = form[oRequired[x][0]];
                	var fieldCompareInput = oRequired[x][2]("datePatternStrict");
                	if (getObjById(fieldCompareInput) == undefined) {
                        return validateSiteUsed(form);
                	} else {
						if (isSiteUsedHasSome(form)) return validateSiteUsed(form);
					}
                }
                return true;
            }
                        
            function validateRatingExecute(form) {
                oRequired = new rating();
                for (x in oRequired) {
                	var field = form[oRequired[x][0]];

                    if (field.type == 'hidden') {

                        var value = '';
                        //trim the spaces
						if (field.type == 'hidden') {
            				field.value = form[oRequired[x][0]].value = trim(field.value);
						}
						value = trim(field.value);
                        if (value == '' || value == 0) {
                        	//field.focus();
                        	//if (field.type != 'select-one' && field.type != 'hidden') field.select();
	                        alert(oRequired[x][1]);
	                        return false;
                        }
                    }
                }
                return true;
            }
            function validateMaxLengthExecute(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oMaxLength = new maxlength();
                for (x in oMaxLength) {
                    var field = form[oMaxLength[x][0]];
                    
                    if (field.type == 'text' ||
                        field.type == 'textarea') {
                        
                        var iMax = parseInt(oMaxLength[x][2]("maxlength"));
                        if (field.value.length > iMax) {
                            if (i == 0) {
                                focusField = field;
                            }
                            fields[i++] = oMaxLength[x][1];
                            isValid = false;
                            break;
                        }
                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return isValid;
            }
            
            function validateIdenticalExecute(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oMasked = new identical();
                for (x in oMasked) {
                    var field = form[oMasked[x][0]];
					var fieldCompareInput = oMasked[x][2]("datePatternStrict");
					var fieldCompare = form[fieldCompareInput];
                        //trim the spaces
						if (field.type == 'text' ||
	                        field.type == 'textarea' ||
    	                    field.type == 'file' ||
        	                field.type == 'password') {
            				field.value = form[oMasked[x][0]].value = trim(field.value);
						}

                    if ((field.type == 'text' ||
                         field.type == 'textarea' ||
    	                    field.type == 'file' ||
        	                field.type == 'password') &&
                         (field.value.length > 0)) {
                        if (field.value != fieldCompare.value) {
                                focusField = fieldCompare;
                            fields[i++] = oMasked[x][1];
                            isValid = false;
                                break;
                        }
                    }
                }

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

            function validateSiteOtherExecute(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oMasked = new siteOther();
                for (x in oMasked) {
                    var field = form[oMasked[x][0]];
					var fieldCompareInput = oMasked[x][2]("datePatternStrict");
					var fieldCompare = form[fieldCompareInput];

					// get field's value
					if (fieldCompare.type == "select-one") {
						var si = fieldCompare.selectedIndex;
						if (si >= 0) {
							value = fieldCompare.options[si].value;
							if (value != 99) {
								return true;
							} else {
								if (trim(field.value).length == 0) {
									focusField = field;
		                            fields[i++] = oMasked[x][1];
		                            isValid = false;
	                                break;								
								}
							}
						}
					}
				}
                if (fields.length > 0) {
                   focusField.focus();
                   focusField.select();
                   alert(fields.join('\n'));
                }
                return isValid;
            }

            function validateCheckboxOtherExecute(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oMasked = new checkboxOther();
                for (x in oMasked) {
                    var field = form[oMasked[x][0]];
					var fieldCompareInput = oMasked[x][2]("datePatternStrict");
					var fieldCompare = form[fieldCompareInput];

					// get field's value
					if (fieldCompare.checked == true && trim(field.value).length == 0) {
						focusField = field;
                           fields[i++] = oMasked[x][1];
                           isValid = false;
                              break;								
					}
				}
                if (fields.length > 0) {
                   focusField.focus();
                   focusField.select();
                   alert(fields.join('\n'));
                }
                return isValid;
            }

            function validateMaskExecute(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oMasked = new mask();
                for (x in oMasked) {
                    var field = form[oMasked[x][0]];

                        //trim the spaces
						if (field.type == 'text' ||
	                        field.type == 'textarea' ||
    	                    field.type == 'file' ||
        	                field.type == 'password') {
            				field.value = form[oMasked[x][0]].value = trim(field.value);
						}

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

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

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

            function matchPattern(value, mask) {
               return mask.exec(value);
            }
            function validateMaskExtExecute(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oMaskedExt = new maskExt();
                for (x in oMaskedExt) {
                    var field = form[oMaskedExt[x][0]];

                        //trim the spaces
						if (field.type == 'text' ||
	                        field.type == 'textarea' ||
    	                    field.type == 'file' ||
        	                field.type == 'password') {
            				field.value = form[oMaskedExt[x][0]].value = trim(field.value);
						}

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

                        if (!matchPattern(field.value, eval('/' + oMaskedExt[x][2]("maskExt") + '/'))) {
                            focusField = field;
                            fields[i++] = oMaskedExt[x][1];
                            isValid = false;
                            break;
                        }
                    }
                }

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

function validateValidBirthExecute(form) {
	oDateValidBirth = new dateValidBirth();
	for (indx in oDateValidBirth) {
		var fMonth = form [oDateValidBirth [indx][0]];
		fMonth.value = form [oDateValidBirth [indx][0]].value = trim(form [oDateValidBirth [indx][0]].value);
		if (fMonth.type == 'text') {
			// get rest of date fields (as variable-arguments)
			var fDay = form [oDateValidBirth [indx][2]("day")];
			var fYear = form [oDateValidBirth [indx][2]("year")];
			fDay.value = form [oDateValidBirth [indx][2]("day")].value = trim(form [oDateValidBirth [indx][2]("day")].value);
			fYear.value = form [oDateValidBirth [indx][2]("year")].value = trim(form [oDateValidBirth [indx][2]("year")].value);

			if (isBlank(fMonth.value) && isBlank(fDay.value) && isBlank(fYear.value)) {
				// not date
				continue;
			}
			if (isInvalidBirthDate(fDay.value, fMonth.value, fYear.value)) {
				fMonth.focus();
				var msg;
				var msgParameters = oDateValidBirth [indx][2]("msg_parameters");
				if (msgParameters != null) {
					msg = setMessageParameters(oDateValidBirth [indx][1], msgParameters, form);
				} else {
					msg = fields [fields.length] = oDateValidBirth [indx][1];
				}
				alert(msg);
				return false;
			}
		}
	}
	return true;
}

function validateCustomDateRangeExecute(form) {
	oDateRange = new customDateRange();
	for (indx in oDateRange) {
		var fMonth = form [oDateRange [indx][0]];
		fMonth.value = form [oDateRange [indx][0]].value = trim(form [oDateRange [indx][0]].value);

		if (fMonth.type == 'text') {

			// get rest of date fields (as variable-arguments)
			var fDay = form [oDateRange [indx][2]("day")];
			var fYear = form [oDateRange [indx][2]("year")];
			var fStartRange = oDateRange [indx][2]("startRange");
			var fEndRange = oDateRange [indx][2]("endRange");

			fDay.value = form [oDateRange [indx][2]("day")].value = trim(form [oDateRange [indx][2]("day")].value);
			fYear.value = form [oDateRange [indx][2]("year")].value = trim(form [oDateRange [indx][2]("year")].value);

			if (isBlank(fMonth.value) && isBlank(fDay.value) && isBlank(fYear.value)) {
				// not date
				continue;
			}
			if (isInvalidRangeDate(fDay.value, fMonth.value, fYear.value, fStartRange, fEndRange)) {
				fMonth.focus();
				var msg;
				var msgParameters = oDateRange [indx][2]("msg_parameters");
				if (msgParameters != null) {
					msg = setMessageParameters(oDateRange [indx][1], msgParameters, form);
				} else {
					msg = fields [fields.length] = oDateRange [indx][1];
				}
				alert(msg);
				return false;
			}
		}
	}
	return true;
}

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

function isInvalidBirthDate(day, month, year) {
	var yr = parseInt(year);
	if (yr < 50) yr = 2000 + yr;
	else if (yr < 100) yr = 1900 + yr;
	else if (yr < 1000) yr = 1000 + yr;
	var date = new Date(yr, parseInt(month) - 1, day)
	var sDate = normalizeDate(date);
	return  sDate < "18401231" || "20840101" < sDate;
}

function isInvalidRangeDate(day, month, year, start, end) {
	var yr = parseInt(year);
	if (yr < 50) yr = 2000 + yr;
	else if (yr < 100) yr = 1900 + yr;
	else if (yr < 1000) yr = 1000 + yr;
	var date = new Date(yr, parseInt(month) - 1, day)
	var sDate = normalizeDate(date);
	return  sDate < start || end < sDate;
}

function setMessageParameters(message, parameters, form) {
	var fieldNames = new String(parameters).split(',');
	for (var i = 0; i < fieldNames.length; ++ i) {
		var obj = form [fieldNames[i]];
		if (obj != null) {
			var reg = "{"+i+"}";
			message = message.replace(reg, obj.value);
		}
	}
	return message;
}

function isFutureDate(day, month, year) {
	var now = new Date();
	var today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
	var yr = parseInt(year);
	if (yr < 50) yr = 2000 + yr;
	else if (yr < 100) yr = 1900 + yr;
	else if (yr < 1000) yr = 1000 + yr;
	var date = new Date(yr, parseInt(month) - 1, day)
	return normalizeDate(date) > normalizeDate(today);
}

/***************************************
* Argument is javascript Date-object.  *
* Return date in format of 'yyyyMMdd'. *
****************************************/
function normalizeDate(date) {
	// to format of Day
	var day = date.getDate();
	var d = day < 10? "0" + day: new String(day);

	// to format of Month
	var month = date.getMonth() + 1;
	var m = month < 10? "0" + month: new String(month);

	return new String(date.getFullYear()) + m + d;
}

function validateDateFutureExecute(form) {
	oDateFuture = new dateFuture();
	var fields = new Array();
	var focusField = null;
	for (indx in oDateFuture) {
		var fMonth = form [oDateFuture [indx][0]];
		fMonth.value = form [oDateFuture [indx][0]].value = trim(form [oDateFuture [indx][0]].value);
		if (fMonth.type == 'text') {
			// get rest of date fields (as variable-arguments)
			var fDay = form [oDateFuture [indx][2]("day")];
			var fYear = form [oDateFuture [indx][2]("year")];
			fDay.value = form [oDateFuture [indx][2]("day")].value = trim(form [oDateFuture [indx][2]("day")].value);
			fYear.value = form [oDateFuture [indx][2]("year")].value = trim(form [oDateFuture [indx][2]("year")].value);

			if (isBlank(fMonth.value) && isBlank(fDay.value) && isBlank(fYear.value)) {
				// not date
				continue;
			}
			if (isFutureDate(fDay.value, fMonth.value, fYear.value)) {
				fMonth.focus();
				alert(oDateFuture [indx][1]);
				return false;
			}
		}
	}
	return true;
}

// if fields of date are entered, then it checks them values on correct date format
function validateDateValidExecute(form) {
	oDateValid = new dateValid();
	for (indx in oDateValid) {
		var fMonth = form [oDateValid [indx][0]];
		fMonth.value = form [oDateValid [indx][0]].value = trim(form [oDateValid [indx][0]].value);
		if (fMonth.type == 'text') {
			// get the rest of fields for completing date
			var fDay = form [oDateValid [indx][2]("day")];
			var fYear = form [oDateValid [indx][2]("year")];
			fDay.value = form [oDateValid [indx][2]("day")].value = trim(form [oDateValid [indx][2]("day")].value);
			fYear.value = form [oDateValid [indx][2]("year")].value = trim(form [oDateValid [indx][2]("year")].value);

			// get their values
			var vM = fMonth.value;
			var vD = fDay.value;
			var vY = fYear.value;

			// check it is empty or not
			var bM = isBlank(vM);
			var bD = isBlank(vD);
			var bY = isBlank(vY);
			if (bM && bD && bY) {
				continue;
			}
			var reg = new RegExp("/[^0-9]+/");
			if ((reg.test(vM) || reg.test(vD) || reg.test(vY)) || (bM || bD || bY) || !isValidDate(vD, vM, vY) || (vY.length != 2 && vY.length != 4)) {
				// Neither full entered fields of date, nor values is number,
				// nor completed date by the field values is not valid date
				fMonth.focus();
				alert(oDateValid [indx][1]);
				return false;
			}
		}
	}
	return true;
}

// check only fields of date are entered
function validateDateRequiredExecute(form) {
	oDateRequired = new dateRequired();
	for (indx in oDateRequired) {
		var fMonth = form [oDateRequired [indx][0]];
		fMonth.value = form [oDateRequired [indx][0]].value = trim(form [oDateRequired [indx][0]].value);
		if (fMonth.type == 'text') {
			var fDay = form [oDateRequired [indx][2]("day")];
			var fYear = form [oDateRequired [indx][2]("year")];
			fDay.value = form [oDateRequired [indx][2]("day")].value = trim(form [oDateRequired [indx][2]("day")].value);
			fYear.value = form [oDateRequired [indx][2]("year")].value = trim(form [oDateRequired [indx][2]("year")].value);

			if (isBlank(fMonth.value) || isBlank(fDay.value)
				|| isBlank(fYear.value)) {

				fMonth.focus();
				alert(oDateRequired [indx][1]);
				return false;
			}
		}
	}
	return true;
}

/*
function validateValidRangeExecute(form) {
	oDateValidRange = new dateValidRange();
	for (indx in oDateValidRange) {
		var fSMonth = form [oDateValidRange [indx][0]];
		if (fSMonth.type == 'text') {
			// get rest of date fields (as variable-arguments)
			var fSDay = form [oDateValidRange [indx][2]("day-start")];
			var fSYear = form [oDateValidRange [indx][2]("year-start")];
			var fEMonth = form [oDateValidRange [indx][2]("month-end")];
			var fEDay = form [oDateValidRange [indx][2]("day-end")];
			var fEYear = form [oDateValidRange [indx][2]("year-end")];

			// complete start and end dates

			if (isBlank(fSMonth.value) && isSBlank(fSDay.value) && isBlank(fSYear.value)
				&& isBlank(fEMonth.value) && isEBlank(fEDay.value) && isBlank(fEYear.value)) {
				// not date
				continue;
			}

			if (isInvalidBirthDate(fDay.value, fMonth.value, fYear.value)) {
				fMonth.focus();
				alert(oDateValidBirth [indx][1]);
				return false;
			}
		}
	}
	return true;
}
*/
function validateConditionRequiredExecute(form) {
	oConditionRequired = new conditionRequired();
	for (x in oConditionRequired) {
		var field = form [oConditionRequired [x][0]];
		if (field.type == 'text') {
                        //trim the spaces
						if (field.type == 'text' ) {
            				field.value = form[oConditionRequired[x][0]].value = trim(field.value);
						}

			if (field.value == null || field.value == '') continue;
			var  fDepends = listDependedFields(form, oConditionRequired [x][2]("dependedField"));
			for (var i = 0; i < fDepends.length; ++ i) {
				var fD = fDepends [i];
				if (fD != null && fD.value != null && trim(fD.value) != '') {
					continue;
				}
				fD.focus();
				alert(oConditionRequired [x][1]);
				return false;
			}
		}
	}
	return true;
}

function listDependedFields(form, fields) {
	if (fields == null || fields == '') return new Array();
	var fieldNames = new String(fields).split(',');
	var res = new Array();
	for (var i = 0; i < fieldNames.length; ++ i) {
		if (form[fieldNames [i]].type == 'text' ||
	        form[fieldNames [i]].type == 'textarea' ||
    	    form[fieldNames [i]].type == 'file' ||
        	form[fieldNames [i]].type == 'password') {
            form[fieldNames [i]].value = trim(form[fieldNames [i]].value);
		}
		form[fieldNames [i]].value = trim(form[fieldNames [i]].value);
		res [i] = form[fieldNames [i]];
	}
	return res;
}

function validateCheckBoxStateExecute(form) {
	var isValid = true;
    var focusField = null;
    var i = 0;
    var fields = new Array();
    oCheckBoxState = new checkBoxState();
    for (x in oCheckBoxState) {
    	var field = form[oCheckBoxState[x][0]];

        if (field.type == 'checkbox') {

        	var value = field.checked;
            if (value != true) {
	        	focusField = field;
	            fields[i++] = oCheckBoxState[x][1];
	            isValid = false;
	            break;
	        }
    	}
	}
	if (fields.length > 0) {
    	focusField.focus();
        alert(fields.join('\n'));
	}
    return isValid;
}
function validateByteExecute(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oByte = new ByteValidations();
                for (x in oByte) {
                    var field = form[oByte[x][0]];
                    
                    if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'select-one' ||
                        field.type == 'radio') {

                        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;
            }
function validateShortExecute(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oShort = new ShortValidations();
                for (x in oShort) {
                    var field = form[oShort[x][0]];
                    
                    if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'select-one' ||
                        field.type == 'radio') {
                        
                        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;
            }            
function validateIntegerExecute(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oInteger = new IntegerValidations();
                for (x in oInteger) {
                    var field = form[oInteger[x][0]];
					if (field == undefined) continue;
                    if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'select-one' ||
                        field.type == 'radio') {
                        
                        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++] = oInteger[x][1];
                                
                            } else {
                                var iValue = parseInt(value);
                                if (isNaN(iValue) || !(iValue >= -2147483648 && iValue <= 2147483647)) {
                                    if (i == 0) {
                                        focusField = field;
                                    }
                                    fields[i++] = oInteger[x][1];
                                    bValid = false;
                               }
                           }
                       }
                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                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;
            }            
function validateFloatExecute(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oFloat = new FloatValidations();
                for (x in oFloat) {
                    var field = form[oFloat[x][0]];
                    
                    if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'select-one' ||
                        field.type == 'radio') {
                        
                        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('.');
                            var joinedString= tempArray.join('');

                            if (!isAllDigits(joinedString)) {
                                bValid = false;
                                if (i == 0) {
                                    focusField = field;
                                }
                                fields[i++] = oFloat[x][1];

                            } else {
                                var iValue = parseFloat(value);
                                if (isNaN(iValue)) {
                                    if (i == 0) {
                                        focusField = field;
                                    }
                                    fields[i++] = oFloat[x][1];
                                    bValid = false;
                                }
                            }
                        }
                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return bValid;
            }            
function validateDateExecute(form) {
               var bValid = true;
               var focusField = null;
               var i = 0;
               var fields = new Array();
               oDate = new DateValidations();
               for (x in oDate) {
                   var value = form[oDate[x][0]].value;
                   var datePattern = oDate[x][2]("datePatternStrict");
                   if ((form[oDate[x][0]].type == 'text' ||
                        form[oDate[x][0]].type == 'textarea') &&
                       (value.length > 0) &&
                       (datePattern.length > 0)) {
                     var MONTH = "MM";
                     var DAY = "dd";
                     var YEAR = "yyyy";
                     var orderMonth = datePattern.indexOf(MONTH);
                     var orderDay = datePattern.indexOf(DAY);
                     var orderYear = datePattern.indexOf(YEAR);
                     if ((orderDay < orderYear && orderDay > orderMonth)) {
                         var iDelim1 = orderMonth + MONTH.length;
                         var iDelim2 = orderDay + DAY.length;
                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
                         var 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})$");
                         }
                         var matched = dateRegexp.exec(value);
                         if(matched != null) {
                            if (!isValidDate(matched[2], matched[1], matched[3])) {
                               if (i == 0) {
                                   focusField = form[oDate[x][0]];
                               }
                               fields[i++] = oDate[x][1];
                               bValid =  false;
                            }
                         } else {
                            if (i == 0) {
                                focusField = form[oDate[x][0]];
                            }
                            fields[i++] = oDate[x][1];
                            bValid =  false;
                         }
                     } else if ((orderMonth < orderYear && orderMonth > orderDay)) {
                         var iDelim1 = orderDay + DAY.length;
                         var iDelim2 = orderMonth + MONTH.length;
                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
                         var 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})$");
                         }
                         var matched = dateRegexp.exec(value);
                         if(matched != null) {
                             if (!isValidDate(matched[1], matched[2], matched[3])) {
                                 if (i == 0) {
                                     focusField = form[oDate[x][0]];
                                 }
                                 fields[i++] = oDate[x][1];
                                 bValid =  false;
                              }
                         } else {
                             if (i == 0) {
                                 focusField = form[oDate[x][0]];
                             }
                             fields[i++] = oDate[x][1];
                             bValid =  false;
                         }
                     } else if ((orderMonth > orderYear && orderMonth < orderDay)) {
                         var iDelim1 = orderYear + YEAR.length;
                         var iDelim2 = orderMonth + MONTH.length;
                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
                         var 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})$");
                         }
                         var matched = dateRegexp.exec(value);
                         if(matched != null) {
                             if (!isValidDate(matched[3], matched[2], matched[1])) {
                                 if (i == 0) {
                                     focusField = form[oDate[x][0]];
                                  }
                                  fields[i++] = oDate[x][1];
                                  bValid =  false;
                              }
                          } else {
                              if (i == 0) {
                                  focusField = form[oDate[x][0]];
                              }
                              fields[i++] = oDate[x][1];
                              bValid =  false;
                          }
                     } else {
                         if (i == 0) {
                             focusField = form[oDate[x][0]];
                         }
                         fields[i++] = oDate[x][1];
                         bValid =  false;
                     }
                  }
               }
               if (fields.length > 0) {
                  focusField.focus();
                  alert(fields.join('\n'));
               }
               return bValid;
            }
            
			function validateIntRangeExecute(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oRange = new intRange();
                for (x in oRange) {
                    var field = form[oRange[x][0]];
                    
                    if ((field.type == 'text' ||
                         field.type == 'textarea' ||
                         field.type == 'hidden') &&
                        (field.value.length > 0)) {
                        
                        var iMin = parseInt(oRange[x][2]("min"));
                        var iMax = parseInt(oRange[x][2]("max"));
                        var iValue = parseInt(field.value);
                        if (!(iValue >= iMin && iValue <= iMax)) {
                            if (i == 0) {
                                focusField = field;
                            }
                            fields[i++] = oRange[x][1];
                            isValid = false;
                        }
                    }
                }
                if (fields.length > 0) {
                	if (field.type != 'hidden') focusField.focus();
                    alert(fields.join('\n'));
                }
                return isValid;
            }
			function validateLengthRangeExecute(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oRange = new lengthRange();
                for (x in oRange) {
                    var field = form[oRange[x][0]];
                    if (field == undefined) continue;
                    if ((field.type == 'text' ||
                         field.type == 'password' ||
                         field.type == 'textarea' ||
                         field.type == 'hidden') &&
                        (field.value.length > 0)) {
                        
                        var iMin = parseInt(oRange[x][2]("min"));
                        var iMax = parseInt(oRange[x][2]("max"));
                        var iValue = field.value.length;
                        if (!(iValue >= iMin && iValue <= iMax)) {
                            if (i == 0) {
                                focusField = field;
                            }
                            fields[i++] = oRange[x][1];
                            isValid = false;
                            break;
                        }
                    }
                }
                if (fields.length > 0) {
                	if (field.type != 'hidden') focusField.focus();
                    alert(fields.join('\n'));
                }
                return isValid;
            }
function validateFloatRangeExecute(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oRange = new floatRange();
                for (x in oRange) {
                    var field = form[oRange[x][0]];
                    
                    if ((field.type == 'text' ||
                         field.type == 'textarea') &&
                        (field.value.length > 0)) {
                        
                        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;
            }            
function validateCreditCardExecute(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oCreditCard = new creditCard();
                for (x in oCreditCard) {
                    if ((form[oCreditCard[x][0]].type == 'text' ||
                         form[oCreditCard[x][0]].type == 'textarea') &&
                        (form[oCreditCard[x][0]].value.length > 0)) {
                        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;
            }

            /**
             * Reference: http://www.ling.nwu.edu/~sburke/pub/luhn_lib.pl
             */
            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;
            }            
function validateEmailExecute(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oEmail = new email();
                for (x in oEmail) {
                	if ((form[oEmail[x][0]]) == undefined) continue;
                    if ((form[oEmail[x][0]].type == 'text' ||
                         form[oEmail[x][0]].type == 'textarea') &&
                        (form[oEmail[x][0]].value.length > 0)) {
                        if (!checkEmail(form[oEmail[x][0]].value)) {
                            if (i == 0) {
                                focusField = form[oEmail[x][0]];
                            }
                            fields[i++] = oEmail[x][1];
                            bValid = false;
                        }
                    }
                }
                if (fields.length > 0) {
                    focusField.focus();
                    alert(fields.join('\n'));
                }
                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;
            }            
function validateMinLengthExecute(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oMinLength = new minlength();
                for (x in oMinLength) {
                    var field = form[oMinLength[x][0]];
                    
                    if (field.type == 'text' ||
                        field.type == 'textarea') {
                        
                        var iMin = parseInt(oMinLength[x][2]("minlength"));
                        if ((trim(field.value).length > 0) && (field.value.length < iMin)) {
                            if (i == 0) {
                                focusField = field;
                            }
                            fields[i++] = oMinLength[x][1];
                            isValid = false;
                        }
                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return isValid;
            }   

function validateNewFriendsExecute(form) {
	for (var i = 0; form['firstName['+i+']'] != null; i++) {
		if (! checkNewFriend(form, i)) return false;
	}
	return true;
}    
            
function isEmpty(obj) {
	return obj.value == null || obj.value == '';
}
            	
function checkNewFriend(form, index) {
	var fn = form['firstName[' + index + ']'];
	var ln = form['lastName[' + index + ']'];
	var em1 = form['email[' + index + ']'];
	var em2 = form['confirmEmail[' + index + ']'];
	if (! isEmpty(fn) && ! isEmpty(ln) && ! isEmpty(em1) && ! isEmpty(em2)) {
		if (em1.value != em2.value) {
			alert('Confirmation email does not match.');
			em1.focus();
			return false;
		}
		if (! checkEmail(em1.value)) {
			alert('Email format is not valid.');
			em1.focus();
			return false;
		}
		return true;
	} else if (isEmpty(fn) && isEmpty(ln) && isEmpty(em1) && isEmpty(em2)) return true;
	alert('Please fill out all fields.');
	fn.focus();
	return false;
}