function validateRequiredFields(fieldname, fielddesc, form, fieldtype) {
	var msg = new Array('');
	var currentField;
	var currentType;
	var focusObj;
	var focusIdx;
	
	if (fieldname) {
		for (var i=0; i<fieldname.length; i++) {
			eval('currentField = form.' + fieldname[i]);
			if (currentField) {
				switch (currentField.type) {
				case 'hidden':
				case 'text':
				case 'textarea':
					// treat hidden and text items as the same type as both will only contain text
					if (currentField.value == '') {
						msg[0] += '*' + fielddesc[i] + ' cannot be empty.\n'
						if (!focusObj)
							focusObj=currentField;
					} else if (fieldtype && fieldtype[i]) {
						if (!validateFieldType(currentField.value, fieldtype[i])) {
							if (fieldtype[i]=="integer"){
								msg[0] += '*' + fielddesc[i] + ' must be a valid number'  + '\n';
								if (!focusObj)
									focusObj=currentField;
							}
							else{
								msg[0] += '*' + fielddesc[i] + ' must be a valid ' + fieldtype[i] + '\n';
								if (!focusObj)
									focusObj=currentField;
							}
						}
					}
					break;
				case 'select-one':
						// treat a single select as a special case.  The first value is always assumed to be an empty select.
					if (currentField.options[0].selected) {
						msg[0] += '*' + fielddesc[i] + ' must be selected.\n'
						if (!focusObj)
							focusObj=currentField;
						}
					break;
				case 'select-multiple':
					// check that at least one value is selected using helper function
					if (!isValueSelected(currentField)) {
						msg[0] += '*' + 'At least one ' + fielddesc[i] + ' must be selected.\n'
						if (!focusObj)
							focusObj=currentField;
					}
					break;
				default:
					// if at this point the currentField is probably an array of checkbox or radio objects
					// validate these if possible, or show an alert to indicate that the field type could not
					// be validated by this function
					if (currentField.length && (currentField[0].type== 'radio' || currentField[0].type=='checkbox')) {
						if (!isValueChecked(currentField)) {
							msg[0] += '*' + fielddesc[i] + ' must be selected.\n'
							if (!focusObj) {
								focusObj=currentField;
								focusIdx = true;
							}
						}
					} else {
						alert('Unknown type: ' + currentField.type)
					}
					break;
				}
			}
		}
	}
	validateFieldsByForm(form, msg);
	if (msg[0] != '') {
		// if the message is not empty then there has been at least one validation error
		// display the message(s) to the user and return false.
		alert('The following are required fields:\n--------------------\n' + msg[0]);
		if (focusObj) {
			if (focusIdx)
				focusObj[0].focus();
			else
				focusObj.focus();
		}
		return false
	} else {
		// otherwise return true
		return true
	}
}

/**
 * Check that the field types match those that have been specified in the array of appropriate types
 * @param fieldValue The value to be checked
 * @param fieldType The type of field to test against
 */
function validateFieldType(fieldValue, fieldType) {
	switch (fieldType) {
	case 'email':
		return validateEmail(fieldValue);
		break;
	case 'string':
		return validateString(fieldValue);
		break;
	case 'number':
		return validateNumber(fieldValue);
		break;
	case 'integer':
		return validateInteger(fieldValue);
		break;
	case 'phone number':
		return validatePhone(fieldValue);
		break;
	case 'UK phone number':
		return validateUKPhone(fieldValue);
		break;
	default:
		return true;
	}
}

/**
 * function isValueSelected
 * Function returns true if any of the options in the current select object is selected, otherwise it returns false
 */
function isValueSelected (fieldObj) {
	for (i=0; i<fieldObj.length; i++) {
		if (fieldObj.options[i].selected) {
			return true;
		}
	}
	return false;
}

/**
 * function isValueChecked
 * Function returns true is any of the objects in the set of checkboxes/radio buttons is currently checked, otherwise returns
 * false
 */
function isValueChecked (fieldObj) {
	for (i=0; i<fieldObj.length; i++) {
		if (fieldObj[i].checked) {
			return true;
		}
	}
	return false;
}

/**
 * function getSelectedValue
 * Function returns the current value (if present) or text (if no value) of the current selected item of the select object passed
 */
function getSelectedValue(fieldObj) {
	idx = fieldObj.selectedIndex;
	if (fieldObj.options[idx].value == '')
		return fieldObj.options[idx].text
	else
		return fieldObj.options[idx].value
}

/**
 * function getRadioSelectedValue
 * Function returns the value of the first checked item in the radio button/checkbox group.
 */
function getRadioSelectedValue(fieldObj) {
	for (var i=0; i<fieldObj.length; i++) {
		if (fieldObj[i].checked) {
			return fieldObj[i].value
		}
	}
	return null;
}

/**
 * function validateFieldsByForm
 * This function performs the form specific validations on the passed form.  The domino form name is used to identify
 * the form type.  NOTE: This assumes the formname contains no special characters eg. (,<space> etc.  Forms with special
 * characters all have the same name, _DominoForm - so this method would not work.
 * This function is called from validateRequiredFields before displaying the message to the user.  The message is passed
 * as a 0 length array so that it is passed by reference by default.
 */
function validateFieldsByForm(form, msg) {
	switch (Number(getCurrentValue(form.$CreateRing))) {
	case 0:
		if (!form.TermsAndConditions.checked){
				msg[0] += "*You must check the box to confirm that you have read and understood the terms and conditions as layed out.";
		}
		break;
	case 1:
		break;
	case 2:
		if (!form.ConfirmStone.checked){
				msg[0] += "*You must check the box to confirm that you are choosing this stone.";
		}
		break;
	case 3:
		break;
	case 4:
		var Type = getCurrentValue(form.Select_TypeConfirm);
		var RingSize = getCurrentValue(form.Select_SizeRing);
		if ((Type=="Ring") &&(RingSize=="--")){
					msg[0] += "*You must select your ring size.";
		}else if (!form.ConfirmSetting.checked){
				msg[0] += "*You must check the box to confirm that you are choosing this setting.";
		}
		break;
	case 5:
		break;
	}
}

var documentModified = false;
var curFieldValue = '';
/**
 * function onFocusField(obj)
 * This function is attached to all TEXT, TEXTAREA, and SELECT objects dynamically
 * at runtime.  It stores the fields current value when it is selected so that changes
 * can be tracked
 */
function onFocusField(obj) {
	curFieldValue = getCurrentValue(this);
	return curFieldValue;
}

/**
 * function onBlurField(obj)
 * This fucnction is the twin of the onFocusField function above.  When the user leaves
 * a field, it checks to see if the value has changed.
 */
function onBlurField(obj) {
	tmpValue = getCurrentValue(this);
	if (tmpValue && tmpValue[0]) {
		if (tmpValue.length != curFieldValue.length) {
			documentModified = true;
		}
		for (var i=0;i<tmpValue.length;i++) {
			if (!(tmpValue[i] && curFieldValue[i] && tmpValue[i] == curFieldValue[i])) {
				documentModified = true;
			}
		}
	} else {
		documentModified = (documentModified || (curFieldValue != tmpValue))
	}
	return documentModified;
}

/**
 * function getCurrentValue(obj)
 * This function returns the current value of an object.
 * Text, TextArea, Hidden: <property>value</property>
 * select-one: <property>value</property> or <property>text</property> of the selected index
 * select-multiple: Array of <property>value</property> or <property>text</property> of all selected options
 */
function getCurrentValue(obj) {
	switch (obj.type) {
	case 'hidden':
	case 'text':
	case 'textarea':
		// treat hidden and text items as the same type as both will only contain text
		tmpFieldValue = obj.value;
		break;
	case 'select-one':
		// treat a single select as a special case.  The first value is always assumed to be an empty select.
		tmpFieldValue = (obj.options[obj.selectedIndex].value?obj.options[obj.selectedIndex].value:obj.options[obj.selectedIndex].text)
		break;
	case 'select-multiple':
		// check that at least one value is selected using helper function
		tmpFieldValue = new Array();
		for (i=0; i<obj.options.length; i++) {
			if (obj.options[i].selected) {
				tmpFieldValue[tmpFieldValue.length]=(obj[i].value?obj[i].value:obj[i].text);
			}
		}
		break;
	default:
		tmpFieldValue = new Array();
		for (var i=0; i<obj.length; i++) {
			if (obj[i].checked) {
				tmpFieldValue[tmpFieldValue.length]=(obj[i].value?obj[i].value:obj[i].text);
			}
		}
		break;
	}
	return tmpFieldValue;
}

/**
 * Now attach the changehandlers to each of the elements on the form.
 * We also check to see if the current URL has SEQ as part of it.  This is used by domino to
 * indicate a form that has been refreshed.
 */
function setChangeHandlers() {
	vUrl = window.location.href.toUpperCase();
	vSeqIdx = vUrl.indexOf('SEQ');
	if (vSeqIdx!=-1)
		documentModified=true;

	var objType = new Array('INPUT', 'TEXTAREA', 'SELECT');
	for (var idx=0;idx<objType.length;idx++) {
		if (document.getElementsByTagName)
			var tmpObj = document.getElementsByTagName(objType[idx]);
		else if (document.all)
			var tmpObj = document.all.tags(objType[idx]);
		if (tmpObj) {
			for (var i=0;i<tmpObj.length;i++) {
				tmpObj[i].onfocus = onFocusField;
				tmpObj[i].onblur = onBlurField;
			}
		}
	}
	window.status="Monitoring changes...";
}


function validateEmail(emailStr) {

	var emailPat=/^(.+)@(.+)$/;
	var specialChars="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";
	var validChars="\[^\\s" + specialChars + "\]";
	var quotedUser="(\"[^\"]*\")";
	var atom=validChars + '+';
	var word="(" + atom + "|" + quotedUser + ")";
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
	
	var matchArray=emailStr.match(emailPat);
	if (matchArray==null) {
		return false;
	}
	var user=matchArray[1];
	var domain=matchArray[2];
	for (i=0; i<user.length; i++) {
		if (user.charCodeAt(i)>127) {
			return false;
   		}
	}
	for (i=0; i<domain.length; i++) {
		if (domain.charCodeAt(i)>127) {
			return false;
   		}
	}
	if (user.match(userPat)==null) {
		return false;
	}
	var domArr=domain.split(".");
	var len=domArr.length;
	if (len<2)
		return false;
		
	return true;
}

function validateString(str) {
	var regExp = /^[A-Za-z\s]+$/;
	return regExp.test(str);
}

function validateNumber(str) {
	var regExp =/(^\d\d*\.\d*$)|(^\d\d*$)|(^\.\d\d*$)/;
	return regExp.test(str);
}

function validateInteger(str) {
	var regExp =/(^\d\d*$)/;
	return regExp.test(str);
}

function validateUKPhone(str) {
	var regExp = /(^01[0-9\s]+$)|(^02[0-9\s]+$)/;
	return regExp.test(str);
}
function validatePhone(str) {
	var regExp = /(^[0-9\s]+$)|(^[0-9\s]+$)/;
	return regExp.test(str);
}

function validateDate(yyyy, mmm, dd) {
	var dt = new Date();
	dt.setYear(yyyy);
	dt.setMonth(mmm-1);
	dt.setDate(dd);
	if (isNaN(dt)) {
		return false;
	} else {
		return dt.getMonth()==(mmm-1);
	}
}

function validateAge(yyyy, mmm, dd) {
	// Calculate an age from a given date of birth. Must be over 18.
	var age=0;
	var iLimitYear=0;
	today = new Date();
	limitDate=new Date();
	iLimitYear=today.getFullYear() - 18;
	limitDate.setFullYear(iLimitYear);
	DoB = new Date();
	DoB.setDate(dd);
	DoB.setMonth(mmm-1);
	DoB.setYear(yyyy);
	if (DoB.getTime() <= limitDate.getTime()) {
		return true;
	} else {
		return false;
	}
}