// ________________________________________________________________________________

	var arrValidations = new Array();
	var mungeDelimiter = 'Œ'

	// ________________________________________________________________________________

	function validateForm(frm){

		if(window.buildGoldURL) buildGoldURL();

		// if(flag32 == 32) return true;
	
		var errMsg = '';
		var varQString = '';
		var cleanName = '';
		var errMsgElement = $("tdErrMsg");
		var vFieldLabels = $('fieldLabels');

		if(errMsgElement) errMsgElement.innerHTML = '';
		// clear those fields that need clearing
		// the purpose of the loop is to get around a javascript issue in Mozilla
		// that doesn't allow element validation like 'if(form.element)...'
		var validations = ',';
		var validationsDone = false;
		var j = 0;
		var tmpErr = '';
		var iDebug = 0;
		
		vFieldLabels.value = '';
		document.getElementById('elementGroups').value = '';
		
		// ---------- ---------- ---------- ---------- ----------
		// check for new validation method
		// ---------- ---------- ---------- ---------- ----------
		for(i = 0; i < frm.elements.length; i++){
			var ctl = frm.elements[i];
			if(ctl.name == 'useNewValidation'){
				// we've found the trigger, validate with new
				// method and exit
				return false;
				return formValidationEx(frm);
				break;
			}
		}
		// ---------- ---------- ---------- ---------- ----------
		// old method from here down
		// ---------- ---------- ---------- ---------- ----------
		
		/*
		arrValidations is used by all subsequent functions to determine how
		a given field should be validated.
		*/
		var C = frm.elements['confidentialFields'];
		
		for(i = 0; i < frm.elements.length; i++){

			var ctl = frm.elements[i]
			
			// assemble a string of the form controls and values
			// for later checking			
			varQString += ctl.name + '=' + ctl.value + '&';
			
			switch(ctl.name){
			
				case 'fieldValidations':
				
					arrValidations[j] = new Array()
					arrValidations[j][0] = ctl.value
					arrValidations[j][1] = ctl.getAttribute('required')
					if(ctl.getAttribute('validateas') != null){
						arrValidations[j][2] = ctl.getAttribute('validateas')
					} else {
						arrValidations[j][2] = 'text'
					}
					arrValidations[j][3] = ctl.getAttribute('min')
					arrValidations[j][4] = ctl.getAttribute('max')
					arrValidations[j][5] = ctl.getAttribute('caption')
					arrValidations[j][6] = ctl.getAttribute('expectedvalue')
					arrValidations[j][7] = ctl.getAttribute('confidential')
					if(arrValidations[j][2] == '') arrValidations[j][2] = 'text'
					j++
					break;
					
				default:
				
					if(ctl.getAttribute('required') || ctl.getAttribute('caption')){
						arrValidations[j] = new Array()
						arrValidations[j][0] = ctl.name
						arrValidations[j][1] = ctl.getAttribute('required') ? ctl.getAttribute('required') : 0;
						if(ctl.getAttribute('caption')){
							arrValidations[j][5] = ctl.getAttribute('caption')
							vFieldLabels.value += ';;' + ctl.name + '||' + ctl.getAttribute('caption');
						}
						if(ctl.getAttribute('groupOn')) {
							cleanName = (ctl.name.indexOf('out.') == 0)?ctl.name.substring(4,100):ctl.name;
							if(document.getElementById('elementGroups')){
								document.getElementById('elementGroups').value += ', ' + cleanName + '|' + ctl.getAttribute('groupOn')
							}
						}
						if(ctl.getAttribute('validateas') != null){
							arrValidations[j][2] = ctl.getAttribute('validateas')
						} else {
							arrValidations[j][2] = 'text'
						}
						arrValidations[j][3] = ctl.getAttribute('min')
						arrValidations[j][4] = ctl.getAttribute('max')
						arrValidations[j][5] = ctl.getAttribute('caption')
						arrValidations[j][6] = ctl.getAttribute('expectedvalue')
						arrValidations[j][7] = (ctl.getAttribute('confidential')) ? ctl.getAttribute('confidential') : '0';
						if(arrValidations[j][2] == '') arrValidations[j][2] = 'text'
						// alert(arrValidations[j]);
						j++
						break;
					}
			}
		}
		haveValue = 0;

//		return false
		var emptyFields = '';
		var ctl;
		var ctlName = ''
		// TODO: this is where we left off.  We've written the required attribute to the array
		// NOW we have to read it out.
		for(var i = 0; i < frm.elements.length; i++){
			
			ctl = frm.elements[i]

			// skip the fieldValidation values
			while(ctl.name == 'fieldValidations'){
				i++
				ctl = frm.elements[i]
			}
			

			try {			
			ctlName = ctl.name.toLowerCase()
			}
			catch(err){
				ctlName = 'DO NOT USE';
			}
			
			if(ctlName.substring(0,3) == 'out'){
				switch(ctlName){
				
					case 'out.contactperson':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					case 'out.decisionmaker':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					case 'out.referralinfo':
						break;
					case 'out.website':
						break;
					case 'out.manufacturer':
						break;
					case 'out.mainaddress':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					case 'out.dealershipphone':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.message':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please enter a message<br>';
						break;
			
					case 'out.joint fullname':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint address':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint city':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint state':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint zipcode':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint daytimephone':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint eveningphone':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint mobilephone':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint emailaddress':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint applicant dob':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint ssn':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint time at residence':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint own_rent_other':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint own_rent_other':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint own_rent_other':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint rent or mortgage':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint previous address':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint time at previous residence':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint employer':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint employer address':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint employer phone':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint occupation':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint time on job':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint monthly income':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.joint other income':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.joint other income source':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.joint previous employer name':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.joint previous employer address':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.joint previous employer phone':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.joint previous occupation':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.joint previous time on job':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.fullname':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please tell us your name<br>'
						break;
					
					case 'out.address':
						tmpErr = '';
						tmpErr += ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.daytimephone':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.eveningphone':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.mobilephone':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.emailaddress':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.applicant dob':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.ssn':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.time at residence':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.own_rent_other':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.own_rent_other':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.own_rent_other':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.rent or mortgage':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.previous address':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.time at previous residence':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.employer':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.employer address':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.employer phone':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.occupation':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.time on job':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.monthly income':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.other income':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.other income source':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.previous employer name':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.previous employer address':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.previous employer phone':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.previous occupation':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.previous time on job':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.city':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
					
					case 'out.state':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please select a state<br>'
						break;
					
					case 'out.zipcode':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>'
						break;
	
					case 'out.e-signature':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please check the box indicating your^Macceptance of the application terms<br>'
						break;
					
					case 'out.location':
						tmpErr = '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please select a recipient for this form<br>';
						break;
					
					case 'out.browser info':
						break;
					
					case 'out.form date':
						break;
					
					case 'out.vehicle year, make, model':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please enter your vehicle\'s year, make, and model<br>';
						break;
					
					case 'out.vin':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						break;
						
					case 'out.vehicle mileage':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						errMsg += tmpErr;
						break;
					
					case 'out.desired service date':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please tell us what day you would like to bring your vehicle in<br>';
						break;
					
					case 'out.desired time of day':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please tell us what time of day would be best for your appointment<br>';
						break;
					
					case 'out.service needed':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please tell us what service your vehicle needs<br>';
						break;

					case 'out.parts needed':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please tell us what parts or accessories your vehicle needs<br>';
						break;

					case 'out.application date':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.fullparttime':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.desiredposition':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.referredby':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr.replace(/\n/gi,'<br>');
						break;
					
					case 'out.workpermit':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please tell us if you require a work permit<br>';
						break;
					
					case 'out.work permit no':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.previouslyemployed':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousemploymentdetails':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.legallyeligible':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.driverslicense':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.criminalrecord':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.criminal record':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.crimedetails':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousemploymentdates1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousemployer1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousemployeraddress1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoustitle1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousphonenumber1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoustitle1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoussalary1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.oktocontact1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.reasonforleaving1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.jobduties1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousemploymentdates2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousemployer2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousemployeraddress2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoustitle2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousphonenumber2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoustitle2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoussalary2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.oktocontact2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.reasonforleaving2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.jobduties2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousemploymentdates3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousemployer3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousemployeraddress3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoustitle3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previousphonenumber3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoustitle3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoussalary3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.oktocontact3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.reasonforleaving3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.jobduties3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.purchased vehicle':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
			
					case 'out.previoussuper1':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoussuper2':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.previoussuper3':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.highschool':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.highschoolyears':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;

					case 'out.highschoolgraduate':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.highschoolgraduate':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.highschoolcourses':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.collegename':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.collegeyears':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.graduatecollege':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.collegecourses':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.othername':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.other years completed':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.graduate other':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.graduate other':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.other courses':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += tmpErr + '<br>';
						break;
					
					case 'out.preferred contact method':
						tmpErr += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') errMsg += 'Please tell us your preferred contact method<br>';
						break;
				
					case 'out.form date and time':
						break;
					case 'out.web browser':
						break;
					case 'out.page':
						break;
					case 'out.news':
						break;
					case 'out.estimate time':
						errMsg += '';
						tmpErr = ftValidateField(ctl);
						if(tmpErr != '') {
							errMsg = errMsg + 'Please tell us the time you '
							errMsg = errMsg + 'would like for your estimate.\n';
						} 
						break;
					case 'out.bdc':
					case 'out.internetsales':
					case 'out.internetsalescount':
					case 'out.websitehost':
					case 'out.contractstatus':
					case 'out.contractexpires':
					case 'out.websitechange':
					case 'out.parts':
					case 'out.rooftopsnew':
					case 'out.rooftopsused':
					case 'out.payingm':
					case 'out.payings':
					case 'out.cost':
					case 'out.appearance':
					case 'out.easeofchange':
					case 'out.customerservice':
					case 'out.lengthofcontract':
					case 'out.dms':
					case 'out.dmsother':
					case 'out.dmsserverlocation':
					case 'out.crm':
					case 'out.buyleads':
					case 'out.eleadmanager':
					case 'out.whopics':
					case 'out.sendpics':
					case 'out.sendpicsother':
					case 'out.newcars':
					case 'out.usedcars':
					case 'out.monthlypmt':
					case 'out.nsellcount':
					case 'out.usellcount':
					case 'out.othervendors':
					case 'out.setup':
					case 'out.monthly':
					case 'out.contractlength':
					case 'out.closingother':
					case 'out.qnotes':
					case 'out.may we contact':
					case 'out.voi type':
					case 'out.model':
					case 'out.make':
					case 'out.model year':
						break;
						
					default:
						emptyFields += ctl.name + '\n'
						document.getElementById('codeSpot').innerHTML += 'case \'' + ctl.name.toLowerCase() + '\':<br>tmpErr += \'\';<br>tmpErr = ftValidateField(ctl);<br>break;<br><br>'
						document.getElementById('codeSpot').contentEditable = true;
						document.getElementById('codeSpot').style.display = 'none';
						break;
		
				}
			}
		}		

		// if the querystring is too long, the form won't submit as a GET
		if(varQString.length > 1000) frm.method = 'POST';
		
		if(vWriteOut){
			if(emptyFields != '') {				
				if(errMsgElement){
					errMsgElement.innerHTML = '<pre>' + emptyFields + '</pre>';
				} else {
					alert(emptyFields);
				}
				return false;
			}
		}

		if(errMsg != ''){
			if(errMsgElement){
				errMsg = errMsg.replace(/<br>/g, '<br><li>')
				errMsg = errMsg.replace(/\^M/g, '<br>')
				errMsgElement.innerHTML = '<ul style="margin-left: 14px;"><li>' + errMsg + 'Please check your values, and re-key.</ul>';
			} else {
				alert(errMsg);
			}
			return false;
		} else {
			// compile the confidential fields
			//$$('[confidential=1]').each(function(D){C.value += D.name + ', '});
		}

	}				

// --------------------------------------------------------------------------------
// Bill Morris
// 28 October, 2000

function validateDate (fieldname, mm, dd, yy, isRequired, dateType){

	var errMsg = ""

	if(!dateType) dateType = '';
	
	if(yy < 100 && yy > 30){
		yy = 1900 + yy
	}
	
	if (dateType != "small"){
		if (yy < "1754" || yy > "3000"){
			return fieldname + ' is not valid: check that the year is four digits\n'
		}
	}
	else {
		if (yy < "1900" || yy > "2079"){
			return fieldname + ' is not valid: check that the year is four digits\n'
		}
	}
	
	// if date is required then there must be a value in every field
	if (isRequired && (mm.length == 0 || dd.length == 0 || yy == 0)){
		errMsg = errMsg + fieldname + ": A date is required and must take the form of mm/dd/yyyy\n"
		return errMsg;
	}
	else {
		// if the date is not required and all the fields are blank, return nothing
		if (mm.length == 0 && dd.length == 0 && yy == 0) {
			return "";
		}
	}
	// now that we're past all that, start validating field values
	if (mm < 1 || mm > 12){
		errMsg = errMsg + fieldname + ": The month value is invalid\n"
	}
	
	// alert (fieldname + '\n' + dd + '\n' + mmInfo[mm]  + '\nLess than 1 = ' + (dd < 1) + '\nGreater than limit = ' + (dd > mmInfo[mm].value))
	// if (dd < 1 || dd > mmInfo[mm].value){
	if (dd < 1 || dd > 31){
		errMsg = errMsg + fieldname + ": The day value is invalid\n"
	}	
	if (yy.length < 4){
		errMsg = errMsg + fieldname + ": The year must be four digits long\n"
	}
	return errMsg
}


// --------------------------------------------------------------------------------
// Bill Morris
// 28 October, 2000
function displayError (errMsg){
	var tmp = "";
	tmp = "The following errors were encountered while processing the form.\n\n" + errMsg;
	tmp = tmp + "\nPlease check your values and re-key.";
	alert (tmp);
}

// --------------------------------------------------------------------------------
// Bill Morris
// 28 October, 2000
function validateDate1 (fieldname, mm, dd, yy, isRequired, fieldObject, dateType){
	var errMsg = ""
	
	// if the date is not required and all the fields are blank, return nothing
	if (!(isRequired) && mm == "" && dd == "" && yy == "") {
		//alert ("hi")
		fieldObject.value = ""
		return "";
	}
	if (dateType != "small"){
		if (yy < "1754" || yy > "3000"){
			return 'The year for ' + fieldname + ' must fall between 1754 and 3000\n'
		}
	}
	else{
		if (yy < "1900" || yy > "2079"){
			return 'The year for ' + fieldname + ' must fall between 1900 and 2079\n'
		}
	}
	
	// if date is required then there must be a value in every field
	if (isRequired && (mm.length == 0 || dd.length == 0 || yy == 0)){
		return  fieldname + ": A date is required and must take the form of mm/dd/yyyy\n"
	}
	
	// now that we're past all that, start validating field values
	if ((mm < 1 || mm > 12) || mm == ""){
		errMsg = errMsg + fieldname + ": The month value is invalid\n"
	}
	if (parseInt(mm)!=mm){
		errMsg = errMsg + fieldname + ": The month value contains invalid characters\n"
	}
	
	if (dd < 1 || dd > 31 || dd ==""){
		errMsg = errMsg + fieldname + ": The day value is invalid\n"
	}	
	
	if (parseInt(dd)!=dd){
		errMsg = errMsg + fieldname + ": The day value contains invalid characters\n"
	}
	if (yy.length < 4){
		errMsg = errMsg + fieldname + ": The year must be four digits long\n"
	}
	if (parseInt(yy)!=yy){
		errMsg = errMsg + fieldname + ": The year value contains invalid characters\n"
	}
	if (errMsg==""){
		fieldObject.value=mm + '/' + dd +  '/' + yy
	}
	else{
		fieldObject.value=""
	}
	return errMsg
}


// --------------------------------------------------------------------------------
function validateField(fieldname, fieldObject, required, mode) {
	/* mode specifies what sort of data, numeric; decimal; email, etc
	if field is required, we test for to see if there is a value.  If field is not required, then
	the only thing that invalidates the field is incorrect characters */
	// alert (mode)
	// note: there is no test for "text" mode.  If text, the only thing we need to check is if it's required.
	var invalidChars = " /:,;"	
	var errMsg=""
	var invalidValue=false;
	var isDroplist
	
	isDroplist = false
	if(mode == 'droplist' || mode == 'dropdown' || mode == 'select') isDroplist = true
    
	if (required){
		// if the value is required and blank, no further tests are required
		if (fieldObject.value == ""){
			return fieldname + ' must have a value.\n'
		}
	} else {
		if(!isDroplist){
			if (fieldObject.value == ""){
				return '';
			}
		}
	}
	
	if(!isDroplist){
	
		switch(mode) {
			case 'numeric':
				errMsg += validateNumeric(fieldname, fieldObject);
				break;
				
			case 'date1':
				var tmpDate = fieldObject.value;
				tmpDate.replace(/\./g, '/');
				tmpDate.replace(/-/g, '/');
				tmpDate.replace(/\\/g, '/');
				var newDate = tmpDate.split('/')
				errMsg += validateDate1 (fieldname, newDate[0], newDate[1], newDate[2], required, fieldObject, 'notSmall');
				break;
			
			case 'date':
				var tmpDate = fieldObject.value;
				tmpDate.replace(/\./g, '/');
				tmpDate.replace(/-/g, '/');
				tmpDate.replace(/\\/g, '/');
				tmpDate += '//'
				var newDate = tmpDate.split('/')
				errMsg += validateDate(fieldname, newDate[0], newDate[1], newDate[2], required, fieldObject, 'notSmall');
				break;
			
			case 'decimal':
				errMsg += validateDecimal(fieldname, fieldObject);
				break;
				
			case 'email':
				errMsg += validateEmail(fieldname, fieldObject);
				break;
				
			case 'phone':
				errMsg += validatePhone(fieldname, fieldObject, required, mode);
				break;
				
			case 'areaphone':
				errMsg += validatePhone(fieldname, fieldObject, required, mode);
				break;
				
			case 'zip','zipcode':
				errMsg += validateZip(fieldname, fieldObject, required);
				break;
				
			case 'ssn':
				errMsg += js_validateSSN(fieldname, fieldObject, required);
				break;
				
			default:
				// nothing to do
				break;
				
		}
	
	} else {
		errMsg += validateDroplist(fieldname, fieldObject)
	}

	return errMsg;		
}

// --------------------------------------------------------------------------------

function validateFieldEx(fieldname, required, mode, doColor, returnMsg){
	var errMsg = validateField(fieldname, document.getElementById(fieldname), required, mode)
	// if(mode=='date')alert(errMsg)
	
    if(errMsg != '') {
    	document.getElementById(fieldname).style.background = '#FF8080';
		if(returnMsg) {
	        return returnMsg;
		} else {
	        return errMsg;
		}
    } else {
    	document.getElementById(fieldname).style.background = '';
    	return '';
    }
}

// --------------------------------------------------------------------------------

function js_validateSSN(fieldname, fieldObject, required) {
	var toTest = fieldObject.value
	toTest = toTest.replace(/-/g, '');
	if(isNaN(toTest)){
		return('' + fieldname + ' does not appear to be valid\n')
	}
	if(toTest.length != 9){
		return('' + fieldname + ' is not a valid length\n')
	}
	
	return '';
}



// --------------------------------------------------------------------------------
function validateZip(fieldname, fieldObject, required){
	var invalidValue=false;  
	// first, we'll check to see if there's a value that just doesn't work...
	for (i = 0; i < fieldObject.value.length; i++){
		if ((fieldObject.value.charAt(i) < "0" || fieldObject.value.charAt(i) > "9") && fieldObject.value.charAt(i) != "-"){
			return fieldname + " contains invalid characters\n"
		} 
	}
	if (invalidValue == false){
		//we're okay so far, so continue checking
		if (required){
			if (fieldObject.value == "-"){
				return fieldname + ' can\'t just be a dash.\n'
			}
			if (fieldObject.value.length != 10 && fieldObject.value.length != 6){
				return fieldname + ' is invalid.\n'
			}
		}
		else {
			// not required.  Let's see if there's anything in the fieldobject
			if (fieldObject.value.length > 0 && fieldObject.value != "-"){
				if (fieldObject.value.length != 10 && fieldObject.value.length != 6){
					return fieldname + ' is invalid.\n'
				}
			}
			else{
				fieldObject.value=""
			}
		}
	}
	return ''
}


// --------------------------------------------------------------------------------
function validatePhone(fieldname, fieldObject, required, mode){
	var invalidValue=false;  // assume that the value is good.
	
	if(fieldObject.value.length == 0){
		if(required){
			return fieldname + ' is missing'
		} else {
			return fieldname + ''
		}
	}
	
	// first, check for invalid characters, which will break the function whether the item is required or not
	for (i = 0; i < fieldObject.value.length; i++){
		if ((fieldObject.value.charAt(i) < "0" || fieldObject.value.charAt(i) > "9") && fieldObject.value.charAt(i) != "-"){
			return fieldname + ' contains invalid characters\n'
		} 
	} // for
	
    var phoneValue = fieldObject.value
    var newPhoneValue = '';
    if(phoneValue.indexOf('-') == -1){
		newPhoneValue = phoneValue.substring(0,3)
        newPhoneValue += '-' + phoneValue.substring(3,6)
        newPhoneValue += '-' + phoneValue.substring(6,50)
    } else {
    	newPhoneValue = phoneValue;
    }
	var aPhone = newPhoneValue.split('-')
	
	if (required){
		// make sure we have an area code
		if (aPhone[0].length != 3){
			return fieldname + ' must include an area code\n'
		} 

		if (aPhone.length == 4){
			// number w/ extension
			if (aPhone[1].length != 3 || aPhone[2].length != 4){
				return fieldname + ' is not a valid number\n';
			}
		} 
		else {
			if (aPhone.length == 3){
				// number without extension
				if (aPhone[1].length != 3 || aPhone[2].length != 4){
					return fieldname + ' is not a valid number\n';
				}
			}
		}

	} //required
	// if the field isn't required, but there's a value in each, hit the function again as if the field is required
	else {
		if (aPhone[0].length != 0 || aPhone[1].length != 0 || aPhone[2].length != 0){
			return validateField(fieldname, fieldObject,true, mode)
		}
		else{
			fieldObject.value = ""
		}
	} //else required							
	return ''
} 

// --------------------------------------------------------------------------------
function validateEmail (fieldname, fieldObject){
	var invalidChars = " /:,;"	
	var invalidValue=true;
	// check for the @ symbol
	for (i = 0; i < fieldObject.value.length; i++){
		if (fieldObject.value.charAt(i) == "@"){
			invalidValue=false;
		} 
	}
	invalidValue=true;
	// check for a dot
	for (i = 0; i < fieldObject.value.length; i++){
		if (fieldObject.value.charAt(i) == "."){
			invalidValue=false;
		} 
	}
	// check for invalid characters	
	for (i = 0; i < invalidChars.length; i++){
		badChar=invalidChars.charAt(i);
		if (fieldObject.value.indexOf(badChar,0) > -1) {
			invalidValue=true;
		} 
	}
	if (invalidValue){
		return fieldname + ' is not a valid email address or contains invalid characters.\n'
	}
	return ''
}


// --------------------------------------------------------------------------------
function validateDecimal (fieldname, fieldObject){
	var invalidValue=false; 	// initialize the value
	for (i = 0; i < fieldObject.value.length; i++){
		if (fieldObject.value.charAt(i) < "0" || fieldObject.value.charAt(i) > "9"){
			if (fieldObject.value.charAt(i) != "."){
				return fieldname + ' must be numeric or decimal.\n'
			}
		} 
	}
	return ''
}

// --------------------------------------------------------------------------------
function validateNumeric (fieldname, fieldObject) {
	var invalidValue = false;
	for (i = 0; i < fieldObject.value.length; i++){
		if (fieldObject.value.charAt(i) < "0" || fieldObject.value.charAt(i) > "9"){
			return fieldname + ' must be numeric.\n'
		} 
	}
	return ''
}


// --------------------------------------------------------------------------------
// Bill Morris
// December 28, 2000
function Date1GTDate2(y1, m1, d1, y2, m2, d2){

	// compares two dates
	// returns true if second date is <= first date

	var SECOND = 1000
	var MINUTE = SECOND * 60; // the number of milliseconds in a minute
	var HOUR = MINUTE * 60; // the number of milliseconds in an hour
	var DAY = HOUR * 24; // the number of milliseconds in a day
	var WEEK = DAY * 7; // the number of milliseconds in a week
	
	var Time1 = Date.UTC(y1, m1 -1, d1)
	var Time2 = Date.UTC(y2, m2 -1, d2); // specified time (UTC)
	var bTime = (Time1 - Time2)  // time difference
	return (( bTime / DAY ) < 0);
 
}

// --------------------------------------------------------------------------------
function validateDroplist(fieldname, fieldObject) {
	for(i = 0; i < fieldObject.options.length; i++){
		if(fieldObject.options[i].selected){
			return '';
		}
	}
	return 'Please make a selection for ' + fieldname;
}

// --------------------------------------------------------------------------------
function getMultipleChoiceValue(fieldObject){
	var ctl
	if(fieldObject.options) {
		ctl = fieldObject.options
		for(i = 0; i < ctl.length; i++){
			if(ctl[i].selected){
				return ctl[i].value;
			}
		}
	} else {
		if (fieldObject.length) {
			ctl = fieldObject
		for(i = 0; i < ctl.length; i++){
			if(ctl[i].checked){
				return ctl[i].value;
			}
		}
		}
	}
	return ''
}


// --------------------------------------------------------------------------------

function makeReplace(haystack, needle, straw){
	haystack.replace(eval('/' + needle + '/gi'), straw);
	return haystack;

}

	//______________________________________________________________________________

	function fnLTrim(str) { 
	 for (var k=0; k<str.length && str.charAt(k)<=" " ; k++) ;
	 return str.substring(k,str.length);
		}				

	//______________________________________________________________________________

	function fnRTrim(str) {
	 for (var j=str.length-1; j>=0 && str.charAt(j)<=" " ; j--) ;
	 return str.substring(0,j+1);
		}				

	//______________________________________________________________________________

	function fnTrim(str) {
	 return fnLTrim(fnRTrim(str));
		}

	//______________________________________________________________________________

	function hasValue(s){
		if(s.value == ''){
			return false;
		} else {
			return true;
			}
		}


	//'______________________________________________________________________________

	function ftValidateField(inCtl, placeholder){
		// this function serves as the switching station 
		// for all incoming validations
		// it uses [arrValidations] for routing

		var validationType = '';
		var vExpectedValue = '';
		var iMin = 0;
		var iMax = 8000;
		var required = 0;
		var sCaption = '';
		var bTemp;
		var arrMonths = new Array(0,31,29,31,30,31,30,31,31,30,31,30,31);
		var validateAs = '';
		var isConfidential = false;
		// get the validation type
		for(var i = 0; i < arrValidations.length; i++){
			// if the fieldname is in the list of fields to be validated
//			alert(arrValidations[i][0].toLowerCase());
			if(inCtl.name.toLowerCase() == arrValidations[i][0].toLowerCase() && inCtl.name != 'fieldValidations'){
				required = (arrValidations[i][1] == '1' || arrValidations[i][1] == 'yes' || arrValidations[i][1] == 'true')
				//  as of 8/23/2006, not used
				isConfidential = (arrValidations[i][7] == '1')
				validateAs = arrValidations[i][2];
				if(validateAs == '') validateAs = 'text';
				iMin = arrValidations[i][3];
				iMax = arrValidations[i][4];
				vExpectedValue = arrValidations[i][6];
				sCaption = inCtl.getAttribute('caption');
				if(sCaption == '' || sCaption == null) sCaption = arrValidations[i][5]
				if(sCaption == '' || sCaption == null) sCaption = arrValidations[i][0]
				break;
//				alert(inCtl.name + ': ' + isConfidential);
			}
		}

		if(iMax == '' || iMax == null) iMax = 8000
		if(iMin == '' || iMin == null) iMin = 1

		// set the default return
		bTemp = true;

		// if the value is not required and it's blank, we're done.
		if (!required && inCtl.value == '') return '';
		
		var delim = '';
		
		// continue with the validation
		// alert(inCtl.name + '\n' + validateAs)
		switch(validateAs){
		
			case 'text':
			
				if(vExpectedValue != null && vExpectedValue != ''){
					if(inCtl.value != vExpectedValue){
						return sCaption + ' does not match the expected value\n'
					}
				}
				// with text the only thing you validate for is that there is a value
				if(inCtl.value == '') 
					return sCaption + ' cannot be blank\n';
					// alert(2)
					
				if(inCtl.value.length < iMin)
					return sCaption + ' is too short\n';
					// alert(3)
					
				if(inCtl.value.length > iMax) 
					return sCaption + ' is too long\n';
					// alert(4)
					
				// return '';
				// alert('after')
				break;
				
			case 'date':
		
				if(inCtl.value.indexOf('.') > 0) delim = '.';
				if(inCtl.value.indexOf('/') > 0) delim = '/';
				if(inCtl.value.indexOf('-') > 0) delim = '-';
				
				if(inCtl.value == '') return 'Please tell us your ' + sCaption + '\n'
				
				var arrDate = inCtl.value.split(delim);
				// validate the month
				
				arrDate[0] = parseInt(arrDate[0], 10)
				arrDate[1] = parseInt(arrDate[1], 10)
				arrDate[2] = parseInt(arrDate[2], 10)
				
				if(arrDate[2] != '') {
					if(parseInt(arrDate[2]) < 40){
						arrDate[2] = 2000 + arrDate[2]
					}
					if(parseInt(arrDate[2]) >=40 && parseInt(arrDate[2]) <= 99){
						arrDate[2] = 1900 + arrDate[2]
					}
//					alert(arrDate[2])
				}
				
				if(parseInt(arrDate[0]) >=1 && parseInt(arrDate[0]) <= 12){
					// validate the day
					if(parseInt(arrDate[1]) >= 1 && parseInt(arrDate[1]) <= arrMonths[arrDate[0]]){
						// validate the year
						if(parseInt(arrDate[2]) >= 1900 && parseInt(arrDate[2]) <= 2050){
							// we're good.
							return '';
						} else {
							return 'The year value for ' + sCaption + ' is not valid\n';
			}
					} else {
					return 'The day value for ' + sCaption + ' is not valid\n';
		}
				} else {
					return 'The month value for ' + sCaption + ' is not valid\n';
		}
				break;
		
			case 'email':
				if(inCtl.value == '') return sCaption + ' cannot be blank'
				if(inCtl.value.indexOf('@') == -1 || inCtl.value.indexOf('.') == -1 || inCtl.value.indexOf(' ') != -1){
					return sCaption + ' is not valid\n';
		}
				break;
		
			case 'phone':
				// strip out non-numbers
				if(inCtl.value == '') return sCaption + ' cannot be blank'
				var temp = stripNonnumeric(inCtl)
				if(temp.length < 7){
					return sCaption + ' is invalid\n';
				}
				break;
		
			case 'zipcode':
				// strip out non-numbers
				if(inCtl.value == '') return sCaption + ' cannot be blank'
				var temp = stripNonnumeric(inCtl)
				if(!(temp.length == 5 || temp.length == 9)){
					return sCaption + ' is invalid\n';
				}
				break;
		
			case 'areaphone':
				// strip out non-numbers
				if(inCtl.value == '') return sCaption + ' cannot be blank'
				var temp = stripNonnumeric(inCtl)
				if(temp.length != 10){
					return sCaption + ' is invalid, or lacks the area code\n';
				}
				break;
		
			case 'numeric':
				// strip out non-numbers
				if(inCtl.value == '') return sCaption + ' cannot be blank'
				var temp = stripNonnumeric(inCtl)
				if(isNaN(temp)){
					return sCaption + ' is not a number\n';
				}
				break;
		
			case 'ssn':
				var tmpSSN = inCtl.value; //.split('-')
				var tmpSSN2 = '';
				// insert dashes if indicated
				if(tmpSSN.indexOf('-') == -1){
					tmpSSN = tmpSSN.substring(0,3) + '-' + tmpSSN.substring(3,5) + '-' + tmpSSN.substring(5,11)
				}
				tmpSSN2 = tmpSSN
				tmpSSN = tmpSSN.split('-');
				if(tmpSSN[0].length != 3 || tmpSSN[1].length != 2 || tmpSSN[2].length != 4){
					return sCaption + ' is not a valid social security number\n';
				} else {
					inCtl.value = tmpSSN2;
				}
				break;
		
		}
		
		if(isConfidential) {
//			inCtl.value = mungeDelimiter + inCtl.value + mungeDelimiter;
		}
		
		return '';
		
	}

	
	// ________________________________________________________________________________

	function stripNonnumeric(ctl){
		var s = ctl.value;
		var Temp = ''
		for(i = 0; i < s.length; i++){
			if(!isNaN(s.substr(i, 1))){
				Temp += s.substr(i, 1)
			}
		}
		return Temp;
	}     

	
	
	// ________________________________________________________________________________
	
	function formValidationEx(frm, errMsgElementId){
		// this validation method uses attributes on each form control
		// to determine how the control is to be validated, grouped, and sorted
		// sortController: determines how fields are to be sorted
		// 		there might be more than one, so loop them and blank them, then set 
		// 		the first one.  For each out.fieldname, set += "fieldname,"
		// elementGroups: A distinct list of groups named in the form
		// groupOn: ? In the current algorithm, the GroupOn attribute signals the processor
		//		to start a new group of "GroupOn" name at the current field.
		// For today, ungrouped fields are to be grouped in "Audit"

		// for this method to work effectively, each control must have the following attributes (CASE SENSITIVE):
		// 	name
		// 	id
		// 	sortOrder		numeric
		// 	caption		some friendly value.  If blank, Name is used.
		// 	group			how the field will be grouped with other fields in the email
		// 	validateAs		how the field should be validated.
		//				current values: text, areaphone, ssn, date, numeric
		//	validated		init to zero "0".  Used for Ajax form processing.
		// each element you wish to output should have the name and id "out.{fieldname}". 
		// The prefix "out." (note the dot...  "out -dot") signals the routine to process that field
		
		var validateAs 		= '';
		var caption 		= '';
		var minValue 		= '';
		var maxValue 		= '';
		var expectedValue 	= '';
		var required		= '';
		var group			= '';
		var sortOrder		= '';
		var cleanName		= '';
		var ctlValue		= '';
		var errorText		= '';
		var safetyCounter	= 0;
		var jCounter		= 0;
		var validated		= 0;
		
		var errMsgElement	= document.getElementById('tdErrMsg');
		if(errMsgElementId) { if(document.getElementById(errMsgElementId)) errMsgElement = document.getElementById(errMsgElementId); }
		
		var arrSorting		= [];
		var arrGrouping		= [];
		var errMsg			= '';
		
		var varQString = '';

		var ctl;
		
		for(var i = 0; i < frm.elements.length; i++){
		
			
		
			ctl = frm.elements[i]
	    	ctl.style.background = '';
			
				// assemble a string of the form controls and values
				// for later checking			
				varQString += ctl.name + '=' + ctl.value + '&';
				
			
			if(ctl.name) {
			
				if(ctl.name.indexOf('out.') == 0) {
					
					// this is a field that will be output, so validate it 
					required	= (ctl.getAttribute('required')) ? ctl.getAttribute('required') : 0;
					ctlValue	= ctl.value;
					caption 	= (ctl.getAttribute('caption')) ? ctl.getAttribute('caption') : ctl.name;
					errorText	= (ctl.getAttribute('errorText')) ? ctl.getAttribute('errorText') : '';
					cleanName 	= ctl.name.substring(4,100)
					sortOrder	= (ctl.getAttribute('sortOrder')) ? ctl.getAttribute('sortOrder') : 9999;
					group		= (ctl.getAttribute('group')) ? ctl.getAttribute('group') : 'Audit';
					validated	= (ctl.getAttribute('validated')) ? ctl.getAttribute('validated') : '0';
	
					arrSorting[jCounter] = [];
					arrSorting[jCounter][0] = cleanName;
					arrSorting[jCounter][1] = sortOrder;
					arrSorting[jCounter][2] = group;
					arrSorting[jCounter][3] = caption;
					arrSorting[jCounter][4] = ctl.name;
					
					jCounter ++
					
					/* get the rest of the validation code */
					validateAs 	= (ctl.getAttribute('validateAs')) ? ctl.getAttribute('validateAs') : 'text';
					sortOrder 	= (ctl.getAttribute('sortOrder')) ? ctl.getAttribute('sortOrder') : 999;
					group		= (ctl.getAttribute('group')) ? ctl.getAttribute('group') : 'Audit';
					
					// alert(ctl.name + ' - ' + validateAs);
					
					if(validated == '0') {
					if(required == '1' && ctlValue == ''){
						// no need to go on, required and blank is all we need to know
						if(errorText != '') {
							// error text is provided, so use it
							errMsg += errorText + '<br>'
						} else {
							// build the error msg using the caption (if available) 
							// or "clean" name (if not)
							errMsg += ((caption != '') ? caption : cleanName) + ' is required<br>'
						}
				    	ctl.style.background = '#FF8080';
	
						} else {
						
							if(ctlValue == ''){
								// if not required and blank, there's no need to do anything	
					} else {
								// we have a value, so we'll work with it.
						// next three aren't used right now
						minValue	= ctl.getAttribute('min');
						maxValue	= ctl.getAttribute('max');
						expectedValue = ctl.getAttribute('expectedValue');
						
						switch(validateAs){
							
							case 'text':
								// Nothing to do here, really.
								// It's text.  It has a value.  Yee haw.
								break;
								
							default:
								errMsg += validateFieldEx(ctl.id, required, validateAs, true, caption + ' is required<br>')
								break;
								
						}
	
					}
						}
					}
				}
			}
			
			safetyCounter++
			
			if(safetyCounter > 200){
				break;
			}
			
		}
		
		arrSorting.sort(compareAscending) 

		setSortOrder(arrSorting)
		setGrouping(arrSorting)
		setFieldLabels(arrSorting)
		//return false;
		
		// if the querystring is too long, the form won't submit as a GET
		// alert('length: ' + varQString.length)
		if(varQString.length > 1000) frm.method = 'POST';
		
		if(errMsg != ''){
			if(errMsgElement){
				errMsg = errMsg.replace(/<br>/g, '<br><li>')
				errMsg = errMsg.replace(/\^M/g, '<br>')
				errMsgElement.innerHTML = '<ul style="margin-left: 14px;"><li>' + errMsg + 'Please check your values, and re-key.</ul>';
			} else {
				errMsg = errMsg.replace(/<br>/g, '\n')
				alert(errMsg);
			}
			return false;
		} else {
			return true;
		}
	}
	
	
//------------------------------------------------------------

function setFieldLabels(inArray){
	var ctl;
	// caption = 3
	// name = 4
	// ;; name || caption ;;
	if($('fieldLabels')){
		ctl = document.getElementById('fieldLabels')
		ctl.value = '';
		for(var i = 0; i < inArray.length; i++){
			ctl.value += ';;' + inArray[i][4] + '||' + inArray[i][3];
		}
	} else {
		if(document.all('fieldLabels')){
			ctl = document.all('fieldLabels');
		for(var i = 0; i < ctl.length; i++){
			ctl[i].value = '';
		}
		for(var i = 0; i < inArray.length; i++){
			ctl[0].value += ';;' + inArray[i][4] + '||' + inArray[i][3];
		}
		} else {
			var frm = document.forms[0];
			var e = document.createElement('input');
			var sTemp = '';
			e.setAttribute('type', 'hidden');
			e.setAttribute('name', 'fieldLabels');
			e.setAttribute('size', '150');
			e.setAttribute('id', 'fieldLabels');
			e.setAttribute('style', 'visibility: visible; display: inline;');
			for(var i = 0; i < inArray.length; i++){
				sTemp += ';;' + inArray[i][4] + '||' + inArray[i][3];
			}
			e.setAttribute('value', sTemp);
			frm.appendChild(e);		
		}
	}
}

// --------------------------------------------------------------------------------

function setGrouping(inArray){
	var ctl;
	if(!$('elementGroups')){
			var frm = document.forms[0];
			var e = document.createElement('input');
			var sTemp = '';
			e.setAttribute('type', 'hidden');
			e.setAttribute('name', 'elementGroups');
			e.setAttribute('size', '150');
			e.setAttribute('id', 'elementGroups');
			for(var i = 0; i < inArray.length; i++){
				sTemp += inArray[i][0] + '|' + inArray[i][2];
				sTemp += (i < inArray.length) ? ', ': '';
			}
			e.setAttribute('value', sTemp);
			frm.appendChild(e);		
		}
	ctl = $('elementGroups');
	$$('[groupOn]').each(function(C){
		var N = C.name;
		if(N.indexOf('out.') > -1) N = C.name.split('.')[1];
		ctl.value += ', ' + N + '|' + C.getAttribute('groupOn') // + ', ';
	});
}

//------------------------------------------------------------

function setSortOrder(inArray)	{
	var ctl;
	var sTemp = '';
	if(document.getElementById('sortController')){
		ctl = document.getElementById('sortController')
		ctl.value = '';
		for(var i = 0; i < inArray.length; i++){
			ctl.value += inArray[i][0];
			ctl.value += (i < inArray.length) ? ', ': '';
		}
		// a/lert(ctl.value)
	} else {
		if(document.all('sortController')){
			ctl = document.all('sortController');
		for(var i = 0; i < ctl.length; i++){
			ctl[i].value = '';
		}
		for(var i = 0; i < inArray.length; i++){
			ctl[0].value += inArray[i][0];
			ctl[0].value += (i < inArray.length) ? ', ': '';
		}
		} else {
			var frm = document.forms[0];
			var e = document.createElement('input');
			e.setAttribute('type', 'hidden');
			e.setAttribute('name', 'sortController');
			e.setAttribute('size', '150');
			e.setAttribute('id', 'sortController');
			for(var i = 0; i < inArray.length; i++){
				sTemp += inArray[i][0];
				sTemp += (i < inArray.length) ? ', ': '';
			}
			e.setAttribute('value', sTemp);
			frm.appendChild(e);
		}
	}
}
	
// --------------------------------------------------------------------------------


function compareAscending(a, b) { return a[1] - b[1] } 
function compareDescending(a, b) { return b[1] - a[1] } 

	
// --------------------------------------------------------------------------------

function writeoutArray(arr, target){

	var sTemp = '<table border="1" cellspacing="0" cellpadding="5">';
	
	for(var jCounter = 0; jCounter < arr.length; jCounter++){
		sTemp += '<tr>';
		sTemp += '<td>' 
		sTemp += arr[jCounter][0] 
		sTemp += '</td>';
		sTemp += '<td>' 
		sTemp += arr[jCounter][1] 
		sTemp += '</td>';
		sTemp += '</tr>';
	}
	sTemp += '</table>';
	
	document.getElementById(target).innerHTML = sTemp;
}
	
// --------------------------------------------------------------------------------						
	
function fillInTestValues(frm){var el; for(var i = 0; i < frm.elements.length; i++){ el = frm.elements[i];if(el.getAttribute('test')){el.value = el.getAttribute('test');if(el.onBlur)el.onBlur();}}}
	
// --------------------------------------------------------------------------------
	
	function ajaxUpdateValidationIcon(forWhat, mode, required, inMin, inMax){
		if(forWhat.value == "test"){fillInTestValues(document.forms[0]);return;}
		vIcon = document.getElementById('span.' + forWhat.id);
		ctlObj = forWhat;
		vMode = mode;
		vRequired = required;
		if(!inMin)inMin = '';
		if(!inMax)inMax = '';
		vMin = inMin;
		vMax = inMax;
		if(valObj)clearTimeout(valObj)
		valObj = setTimeout('doAjaxFieldValidation(ctlObj, vMode, vRequired, vMin, vMax)',750)
	}
	
//------------------------------------------------------------

	function doAjaxFieldValidation(forWhat, sMode, sRequired, sMin, sMax){
		var ctl = forWhat
		var url = '/ajaxFormValidation.asp?s=' + escape(forWhat.value)
		url += '&mode=' + sMode;
		url += '&r=' + sRequired;
		url += '&min=' + sMin;
		url += '&max=' + sMax;
		frmXML = GetXmlHttpObject();
		frmXML.onreadystatechange = function(){
			if(frmXML.readyState == 4){
				var sTemp = frmXML.responseText
				switch(sTemp){
					case '1':
						forWhat.style.background = "transparent";
						if(vIcon) vIcon.style.background = 'transparent url(/library/icons/validationIcon.jpg) 0 0 no-repeat';
						if(forWhat.getAttribute('validated'))forWhat.setAttribute('validated', '1')
						break;
					case '0':
						vIcon.style.background = 'transparent url(/library/icons/validationIcon.jpg) 0 -22 no-repeat';
						break;
					default:
						alert(sTemp);
						break;
				}
			} 
		}
		frmXML.open("GET",url,true);
		frmXML.send(null);
						
	}
						
// ----------------------------------------------------------------------

var formValidation = function(){

	return {
		
		assembleCaptionsAndLabels: function(){
			// insert the needed fields
			formValidation.createFieldLabels();
			formValidation.createElementGroups();
			formValidation.assembleFieldLabels();
			formValidation.assembleGroups();
			return true;
		},
		
		assembleGroups: function(){
			// name|group, name|group, n|g, ...
			// alert('assembleGroups')
			var sTemp
			$$('[groupOn]').each(function(C){
				sTemp += ', ' + C.getAttribute('name') + '|' + C.getAttribute('groupOn');
			});
			$('elementGroups').value = sTemp;
		},
		
		assembleFieldLabels: function(){
			// ;; name || caption ;;
			// alert('assembleFieldLabels');
			var sTemp
			$$('[caption]').each(function(C){
				sTemp += ';;' + C.getAttribute('name') + '||' + C.getAttribute('caption');
			});
			$('fieldLabels').value = sTemp
		},
		
		createFieldLabels: function(){
			//alert('createFieldLabels()');
			if(!$('fieldLabels')) {
				var frm = $('frm1031');
				var e = document.createElement('input');
				var sTemp = '';
				e.setAttribute('type', 'hidden');
				e.setAttribute('name', 'fieldLabels');
				e.setAttribute('size', '150');
				e.setAttribute('id', 'fieldLabels');
				e.setAttribute('style', 'visibility: visible; display: inline;');
				/*
				for(var i = 0; i < inArray.length; i++){
					sTemp += ';;' + inArray[i][4] + '||' + inArray[i][3];
				}
				e.setAttribute('value', sTemp);
				*/
				frm.appendChild(e);		
			}
		},
		
		createElementGroups: function(){
			//alert('createElementGroups()');
			if(!$('elementGroups')){
				var frm = $('frm1031');
				var e = document.createElement('input');
				var sTemp = '';
				e.setAttribute('type', 'hidden');
				e.setAttribute('name', 'elementGroups');
				e.setAttribute('size', '150');
				e.setAttribute('id', 'elementGroups');
				e.setAttribute('style', 'visibility: visible; display: inline;');
				/*
				for(var i = 0; i < inArray.length; i++){
					sTemp += ';;' + inArray[i][4] + '||' + inArray[i][3];
				}
				e.setAttribute('value', sTemp);
				*/
				frm.appendChild(e);		
			}
			$('elementGroups').value = '';
		}
		
	}
}();