/***************************************************************************************************
/*   FIELD OPTION VALIDATION
/*   
/*   Umer Farooq
/*   (c) Octadyne Systems
/*   http://www.octadyne.com
/*   support@octadyne.com
/*
/*   Version 2.0
/*   08/14/2006 - Added support for list of values search. - Farooq
***************************************************************************************************/

function octUpdateFormFields(frmObj)
{
		
	for (var i=0; i<frmObj.elements.length; i++) {		
		// check to see if there are matX checks 
		if (frmObj.elements[i].getAttribute('mLen')) {
			var numberOfchecks = frmObj.elements[i].getAttribute('mLen');
			for (var x=0; x<numberOfchecks; x++)
			{
				
				if (!octGetAttributes(frmObj, frmObj.elements[i], x, false)) 
				{
					return false;
				}
			}
		}
	}
	return true;
}
function octShowHideFormFields(frmObj, runShowHide, reRun)
{
	runShowHide = typeof(runShowHide) != 'undefined' ? runShowHide : 1;
	reRun = typeof(reRun) != 'undefined' ? reRun : 0;
	
	for (var i=0; i<frmObj.elements.length; i++) {		
		// check to see if there are matX checks 
		if (frmObj.elements[i].getAttribute('mLen')) {
			var numberOfchecks = frmObj.elements[i].getAttribute('mLen');
			for (var x=0; x<numberOfchecks; x++)
			{
				octGetAttributes(frmObj, frmObj.elements[i], x, runShowHide);
			}
		}
	}
	
	// Hide out all fields that should be hidden and clear them.
	// this is just bit silly to do... but since matrix can be defined free form...
	// we do this check at the end... 
	$$('tr.tssInputField').each(function(elm){
			if (elm.style.display =='none')
			{
				if (elm.down('.tssAttrField'))
				{
					onField = elm.down('.tssAttrField');
					updateOnFieldNotRequired(onField);
					switch (onField.type)
					{
						case 'radio'    : 
							for (i=0; i<onField.length; i++)
							{
								onField[i].checked = false;
							}
							break;
						case 'checkbox' : 
							for (i=0; i<onField.length; i++)
							{
								onField[i].checked = false;
							}
							break;
						case 'select-one'   : 
							onField.form['O_'+onField.getAttribute("tssFieldId")].value = '';
							onField.form['A_'+onField.getAttribute("tssFieldId")].value = '';
							onField.selectedIndex = 0;
							break;
						default         : 
							onField.value = '';
							break;
					}
				}
				
			}
		});
		
	// re run our matrix... as some drop downs that were hidden before may be hidding our other 
	// attributes... again silly but since the chains can get complex... better to just
	// iterate the fields and double up. 
	// Technically... when setting up the attributes... everything should be defined in a chain... 
	// but that can not be done... since some attributes in a template may be used by different products... 
		
	for (var i=0; i<frmObj.elements.length; i++) {		
		// check to see if there are matX checks 
		if (frmObj.elements[i].getAttribute('mLen')) {
			var numberOfchecks = frmObj.elements[i].getAttribute('mLen');
			for (var x=0; x<numberOfchecks; x++)
			{
				octGetAttributes(frmObj, frmObj.elements[i], x, runShowHide);
			}
		}
	}
	return true;
}

// frmElement here is equal to the field that has a value
// and would impact other fields on the form.
function octGetAttributes(frmObj, frmElement, atNumber, runShowHide)
{
	if (frmElement)
	{
		var test = false;
		var etag = frmElement.type;
		
		switch (etag)
		{
			case 'radio'    : if (doMatrixOnRadio(frmObj,frmElement,atNumber,runShowHide)) test = true; break;
			case 'checkbox' : if (doMatrixOnCheckBox(frmObj,frmElement,atNumber,runShowHide)) test = true; break;
			case 'select-one'   : if (doMatrixOnSelect(frmObj,frmElement,atNumber,runShowHide)) test = true; break;
			default         : if (doMatrixOnText(frmObj,frmElement,atNumber,runShowHide)) test = true; break;
		}
	}
	else
	{
		test = true;
	}
	return test;
}

function octCheckRadio(testObject) {   
  if (testObject[0] && testObject[0].type && testObject[0].type == 'radio')
  {
  	return true;
  }
  return false;
}
// does the validation where the field is radio button
function doMatrixOnRadio(frmObj, frmElement, atNumber, runShowHide)
{
			
		    var onField = frmElement.getAttribute('m_'+atNumber+'_ID');
			var checkType = frmElement.getAttribute('m_'+atNumber+'_tID');
			var matchType = frmElement.getAttribute('m_'+atNumber+'_m');
			var matchOnValue = frmElement.getAttribute('m_'+atNumber+'_v');
			var onFieldValue = frmElement.getAttribute('m_'+atNumber+'_onIDV').split("|");
			var onFieldValueId = onFieldValue[1];
			var errMsg = frmElement.getAttribute('m_'+atNumber+'_eMsg');
			var ignoreFirstDropDownOption =  frmElement.getAttribute('m_'+atNumber+'_ignore');
			var hasSelection = false;
			
			if (frmObj.elements[onField] && frmElement.checked)
			{
				if (console)
				{
					console.log('running...' + frmElement.value);
				}
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
	return true;
}
// does the validation where the field is  checkbox
function doMatrixOnCheckBox(frmObj, frmElement, atNumber, runShowHide)
{
		    var onField = frmElement.getAttribute('m_'+atNumber+'_ID');
			var checkType = frmElement.getAttribute('m_'+atNumber+'_tID');
			var matchType = frmElement.getAttribute('m_'+atNumber+'_m');
			var matchOnValue = frmElement.getAttribute('m_'+atNumber+'_v');
			var onFieldValue = frmElement.getAttribute('m_'+atNumber+'_onIDV').split("|");
			var onFieldValueId = onFieldValue[1];
			var errMsg = frmElement.getAttribute('m_'+atNumber+'_eMsg');
			var ignoreFirstDropDownOption =  frmElement.getAttribute('m_'+atNumber+'_ignore');
			var hasSelection = false;
			if (frmElement.checked)
			{
				hasSelection = true;
			}
			
			if (frmObj.elements[onField] && hasSelection)
			{
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
				
			}
	return true;
}

// does the validation where the field is select drop down
function doMatrixOnSelect(frmObj, frmElement, atNumber, runShowHide)
{
    var onField = frmElement.getAttribute('m_'+atNumber+'_ID');
	var checkType = frmElement.getAttribute('m_'+atNumber+'_tID');
	var matchType = frmElement.getAttribute('m_'+atNumber+'_m');
	
	// lets see if we are doing a list compairson... 
	var matchOnValue = frmElement.getAttribute('m_'+atNumber+'_v');
	var matchOnId = "";
	var matchOnText = "";
	if (matchOnValue.indexOf(","))
	{
		var temp = matchOnValue.split(',');
		// note text matching is not done... so this stays blank
		for (var i=0; i<temp.length; i++)
		{
			var mOnValue = temp[i].split("|");
			if (matchOnId.length)
			{
				matchOnId += "," + mOnValue[1];
			}
			else
			{
				matchOnId = mOnValue[1];
			}
		 }
	} 
	else 
	{
		matchOnValue = matchOnValue.split("|");
		matchOnId = matchOnValue[1];
		matchOnText = matchOnValue[2];	
	}
	var onFieldValue = frmElement.getAttribute('m_'+atNumber+'_onIDV');
	var onFieldValueId = "";
	
	// lets see if we are matching on list
	if (onFieldValue.indexOf(","))
	{
		var onFVTemp = onFieldValue.split(',');
		for (var i=0; i<onFVTemp.length; i++)
		{
			var fvOnValue = onFVTemp[i].split("|");
			
			if (onFieldValueId)
			{
				onFieldValueId += "," + fvOnValue[1];
			}
			else
			{
				onFieldValueId = fvOnValue[1];
			}
		 }
	}
	else
	{
		onFieldValue = onFieldValue.split("|");
		onFieldValueId = onFieldValue[1];
	}
	var matchOnCount = findSelectBoxMatchLocation(frmElement, matchOnId);
	var errMsg = frmElement.getAttribute('m_'+atNumber+'_eMsg');
	var ignoreFirstDropDownOption =  frmElement.getAttribute('m_'+atNumber+'_ignore');
	var hasSelection = false;
	var frmElementValue = trim(frmElement.value);
	if (frmElement.selectedIndex > 0)
	{
		hasSelection = true;
	}
	
	if (frmObj.elements[onField] && hasSelection)
	{
	var elementSelection = frmElement.value.split("|");
	var selectedOption = elementSelection[0];
	var selectedText = elementSelection[1];
	switch (matchType) {
	case '1' : 
			if (frmElementValue.length >= 1) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
			break;
	case '2' :
			
			if (matchOnId == selectedOption) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
			break;
	case '3' :
			if (frmElement.selectedIndex > matchOnCount) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
			break;
	 case '4' :
	 		if (frmElement.selectedIndex < matchOnCount) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
			break;
	  case '5' :
	  		
			if (matchOnId != selectedOption) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}	
			break;
	  case '6' :
			if (selectedText.substring(0, matchOnText.length) == matchOnText) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
				
			}	
			break;
	  case '7' :
	  		
	  	    if (findList(matchOnId, selectedOption))
			{
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
			break;
		}
	}
	return true;
}

// text field matx is the most complex as we have diffrent match
// style principles. so first we need to know what are we trying to 
// match on and then do the matrix validation on that match type.
function doMatrixOnText(frmObj, frmElement, atNumber, runShowHide)
{
	var onField = frmElement.getAttribute('m_'+atNumber+'_ID');
	var checkType = frmElement.getAttribute('m_'+atNumber+'_tID');
	var matchType = frmElement.getAttribute('m_'+atNumber+'_m');
	var matchOnValue = frmElement.getAttribute('m_'+atNumber+'_v');
	var onFieldValue = frmElement.getAttribute('m_'+atNumber+'_onIDV').split("|");
	var onFieldValueId = onFieldValue[1];
	var errMsg = frmElement.getAttribute('m_'+atNumber+'_eMsg');
	var ignoreFirstDropDownOption =  frmElement.getAttribute('m_'+atNumber+'_ignore');
	var frmElementValue = trim(frmElement.value);
	if (frmObj.elements[onField])
	{
	switch (matchType) {
	case '1' : 
			if (frmElementValue.length >= 1) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
			break;
	case '2' :
			if (frmElement.value == matchOnValue) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
			break;
	case '3' :
			if (frmElement.value > matchOnValue) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
			break;
	 case '4' :
	 		if (frmElement.value < matchOnValue) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
			break;
	  case '5' :
	  		if (frmElement.value != matchOnValue) 
			{ 
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}	
			break;
	  case '7' :
	  	    if (findList(matchOnValue, frmElement.value))
			{
				return findMethodToRun(checkType, frmObj.elements[onField], errMsg, ignoreFirstDropDownOption, frmElement, onFieldValueId, runShowHide);
			}
			break;		
		}
	}
	return true;
}
// function to find out what methods below to run...
function findMethodToRun(checkType, onField, errMsg, ignoreFirstDropDownOption, whenField, onFieldValueId, runShowHide)
{
	if (runShowHide)
	{
		if (checkType == 7)
		{
			
			updateOnFieldNotRequired(onField, errMsg, ignoreFirstDropDownOption, whenField);
			return showHideAttributeFields(onField, false, runShowHide);
		}
		else if (checkType == 8)
		{
			resetRequired(onField);
			return showHideAttributeFields(onField, true, runShowHide);
		}
	}
	else
	{
	
		if (checkType == 1) 
		{
			showHideAttributeFields(onField, true, runShowHide);
			return updateOnFieldRequired(onField, errMsg, ignoreFirstDropDownOption, whenField);
		}
		else if (checkType == 2)
		{
			showHideAttributeFields(onField, true, runShowHide);
			return updateOnFieldNotRequired(onField, errMsg, ignoreFirstDropDownOption, whenField);
		}
		else if (checkType == 3)
		{
			showHideAttributeFields(onField, true, runShowHide);
			return updateOnFieldMatch(onField, whenField, errMsg, whenField);
		}
		else if (checkType == 4)
		{
			showHideAttributeFields(onField, true, runShowHide);
			return getNotEqual(onField, errMsg, onFieldValueId, whenField);
		}
		else if (checkType == 5)
		{
			showHideAttributeFields(onField, true, runShowHide);
			return getEqual(onField, errMsg, onFieldValueId, whenField);
		}
		else if (checkType == 6)
		{
			showHideAttributeFields(onField, true, runShowHide);
			return getInListSearch(onField, errMsg, onFieldValueId, whenField);
		}
	
		else if (checkType == 7)
		{
			
			updateOnFieldNotRequired(onField, errMsg, ignoreFirstDropDownOption, whenField);
			return showHideAttributeFields(onField, false, runShowHide);
		}
		else if (checkType == 8)
		{
			
			resetRequired(onField);
			return showHideAttributeFields(onField, true, runShowHide);
		}
	}
	
}
function showHideAttributeFields(onField,show, runShowHide)
{
	
	if (octCheckRadio(onField))
	{
		var hideFieldId = onField[0].getAttribute('tssFieldId');
		var fieldType = onField[0].type;
	}
	else
	{
		var hideFieldId = onField.getAttribute('tssFieldId');
		var fieldType = onField.type;
	}

	
	// if run show hide is at the end... then we do our stuff
	//!show && runShowHide == 2
	if (!show && runShowHide != 3)
	{
		/* switch (fieldType)
		{
			case 'radio'    : 
				for (i=0; i<onField.length; i++)
				{
					onField[i].checked = false;
				}
				break;
			case 'checkbox' : 
				for (i=0; i<onField.length; i++)
				{
					onField[i].checked = false;
				}
				break;
			case 'select-one'   : 
				onField.form['O_'+hideFieldId].value = '';
				onField.form['A_'+hideFieldId].value = '';
				onField.selectedIndex = 0;
				break;
			default         : 
				onField.value = '';
				break;
		} */
	}
	if (hideFieldId)
	{	
		var labelField = 'tr_fieldLabel_' + hideFieldId;
		var fieldInputField = 'tr_fieldInputField_' +hideFieldId;
		var fieldSpacerField = 'tr_fieldInputSpacer_' +hideFieldId;
		var browserShow = 'table-row';
		var temp = show ? browserShow : 'none';
		if (document.getElementById(labelField))
		{
			document.getElementById(labelField).style.display = show ? '' : 'none';
		}
		if (document.getElementById(fieldInputField))
		{
			document.getElementById(fieldInputField).style.display = show ? '' : 'none';
		}
		if (document.getElementById(fieldSpacerField))
		{
			document.getElementById(fieldSpacerField).style.display = show ? '' : 'none';
		}
	}
	return true;
}
// Reset fields on change...
function resetRequired(onField)
{
	
	if (onField[0] && onField[0].type)
	{	
		if (console)
		{
			console.log ("onFiled " + onField[0].type);
		}
		
		var fieldType = onField[0].type;
		var onFieldID = onField[0].name.split("_");
	}
	else
	{
		var fieldType = onField.type;
		var onFieldID = onField.name.split("_");
	}
		switch (fieldType)
		{
			case 'radio'    : 
				var curAltValue =  onField[0].getAttribute('orgAlt');
				onField[0].setAttribute('alt', curAltValue)
				if (curAltValue)
				{
					updateRequiredSpanElement('span_req_'+onFieldID[1], 'yes');
				}
				break;
			case 'checkbox' : 
				var curAltValue =  onField.getAttribute('orgAlt');
				onField.setAttribute('alt', curAltValue)
				if (curAltValue)
				{
					updateRequiredSpanElement('span_req_'+onFieldID[1], 'yes');
				}
				break;
			case 'select-one'   : 
				var curAltValue =  onField.getAttribute('orgAlt');
				onField.setAttribute('alt', curAltValue);
				if (curAltValue)
				{
					updateRequiredSpanElement('span_req_'+onFieldID[1], 'yes');
				}
				break;
			default         : 
				var curAltValue =  onField.getAttribute('orgAlt');
				onField.setAttribute('alt', curAltValue);
				if (curAltValue)
				{
					updateRequiredSpanElement('span_req_'+onFieldID[1], 'yes');
				}
				break;
		}
}
// marks the matX on to required.
function updateOnFieldRequired (frmElement, errMsg, ignoreFirstDropDownOption, field)
{
	
	var etag = frmElement.type;
	var setRequired = false;
	var onFieldID = frmElement.name.split("_");
	if (errMsg.length) 
	{ 
		var errorMessage = errMsg;
	}
	 else 
	{
	    var errorMessage  = frmElement.getAttribute('emsg');
	}
	switch (etag)
	{
		case 'radio'    : 
				 updateRequiredSpanElement('span_req_'+onFieldID[1], 'yes');
				 return octValidateRadio(frmElement, errorMessage);
				 break;
		case 'checkbox' : 
				 updateRequiredSpanElement('span_req_'+onFieldID[1], 'yes');
				 return octValidateCheckbox(frmElement, errorMessage);
				 break;
		case 'select-one'   : 
				 updateRequiredSpanElement('span_req_'+onFieldID[1], 'yes');
				 if (ignoreFirstDropDownOption > 0)
				 {
				 	 return octValidateSelectI(frmElement, '0,1', errorMessage); 
				 }
				 else
				 {
				 	 return octValidateSelect(frmElement, errorMessage);
				 }
				 break;
		default         : 
				 updateRequiredSpanElement('span_req_'+onFieldID[1], 'yes');
				 return octValidateBlank(frmElement, errorMessage);
				 break;
	}
	return true;
}

// does on field value not equal
function getNotEqual(frmElement, errMsg, canNotEqual, whenField)
{

	var etag = frmElement.type;
	if (errMsg.length) 
	{ 
		var errorMessage = errMsg;
	}
	 else 
	{
	    var errorMessage  = frmElement.getAttribute('emsg');
	}
	switch (etag)
	{
		
		case 'radio'    : 
				 if (getRadioButtonValue(frmElement) == canNotEqual)
				 {
				 	  alert(errorMessage);
					  frmElement[0].focus();
					  return false;
				 }
				 break;
		case 'checkbox' :
				if (frmElement.checked)
				{
					  alert(errorMessage);
					  frmElement.focus();
					  return false;
				}
				break;
		case 'select-one'   : 
				if (getSelectValue(frmElement) == canNotEqual)
				{
					return octShowErrorMessage(frmElement,errorMessage,0,1);
				}
				 break;
		default         : 
				 if (frmElement.value == canNotEqual)
				 {
				 	return octShowErrorMessage(frmElement, errorMessage,1,1);	
				 }
				 break;
	}
	return true;
}
// does on field value  equal
function getEqual(frmElement, errMsg, canNotEqual, whenField)
{

	var etag = frmElement.type;
	if (errMsg.length) 
	{ 
		var errorMessage = errMsg;
	}
	 else 
	{
	    var errorMessage  = frmElement.getAttribute('emsg');
	}
	switch (etag)
	{
		
		case 'radio'    : 
				 if (getRadioButtonValue(frmElement) != canNotEqual)
				 {
				 	  alert(errorMessage);
					  frmElement[0].focus();
					  return false;
				 }
				 break;
		case 'checkbox' :
				if (frmElement.checked)
				{
					  alert(errorMessage);
					  frmElement.focus();
					  return false;
				}
				break;
		case 'select-one'   : 
				if (getSelectValue(frmElement) != canNotEqual)
				{
					return octShowErrorMessage(frmElement,errorMessage,0,1);
				}
				 break;
		default         : 
				 if (frmElement.value != canNotEqual)
				 {
				 	return octShowErrorMessage(frmElement, errorMessage,1,1);	
				 }
				 break;
	}
	return true;
}

// does the matching
function updateOnFieldMatch(onField, field, errMsg)
{
	if (errMsg.length) 
	{ 
		var errorMessage = errMsg;
	}
	 else 
	{
	    var errorMessage  = frmElement.getAttribute('emsg');
	}
	return octValidateSelectMatch(onField, field, errorMessage);
}

// works with a list
/*
function getNotInListSearch(frmElement, errMsg, listOfValues, whenField)
{

	var etag = frmElement.type;
	if (errMsg.length) 
	{ 
		var errorMessage = errMsg;
	}
	 else 
	{
	    var errorMessage  = frmElement.getAttribute('emsg');
	}
	switch (etag)
	{
		
		case 'radio'    : 
				 var temp = listOfValues.split(',');
				 for (var i=0; i<temp.length; i++)
					{
						 if (getRadioButtonValue(frmElement).toUpperCase() == trim(temp[i].toUpperCase()))
						 {
						 	  alert(errorMessage);
							  frmElement[0].focus();
							  break;
							  return false;
						 }
					}
				 break;
		case 'select-one'   : 
				 var temp = listOfValues.split(',');
				 for (var i=0; i<templ.length(); i++)
				 {
						if (getSelectValue(frmElement).toUpperCase() == trim(temp[i].toUpperCase()))
						{
							return octShowErrorMessage(frmElement,errorMessage,0,1);
							break;
						}
				  }
				 break;
		default         : 
				 alert(listOfValues);
				 var temp = listOfValues.split(',');
				 for (var i=0; i<temp.length; i++)
					{
						 alert(temp[i]);
						 if (frmElement.value.toUpperCase() ==  trim(temp[i].toUpperCase()))
						 {
						 	return octShowErrorMessage(frmElement, errorMessage,1,1);	
							break;
						 }
					}
				 break;
	}
	return true;
}
*/
// works with a list
function getInListSearch(frmElement, errMsg, listOfValues, whenField)
{

	var etag = frmElement.type;
	if (errMsg.length) 
	{ 
		var errorMessage = errMsg;
	}
	 else 
	{
	    var errorMessage  = frmElement.getAttribute('emsg');
	}
	switch (etag)
	{
		
		case 'radio'    : 
				 var matchFound = false;
				 var temp = listOfValues.split(',');
				 for (var i=0; i<temp.length; i++)
				 {
						 if (getRadioButtonValue(frmElement).toUpperCase() == trim(temp[i].toUpperCase()))
						 {
						 	matchFound = true;
							break;
						 }
				 }
				 if (!matchFound)
				 {
				 	 		  alert(errorMessage);
							  frmElement[0].focus();
							  return false;
				 }
				 break;
		case 'select-one'   : 
				 var matchFound = false;
				 var temp = listOfValues.split(',');
				 for (var i=0; i<temp.length; i++)
				 {
						if (getSelectValue(frmElement).toUpperCase() == trim(temp[i].toUpperCase()))
						{
							matchFound = true;
							break;
						}
				  }
				  if (!matchFound)
				  {
				 	 		return octShowErrorMessage(frmElement,errorMessage,0,1);
				  }
				 break;
		default         : 
				 var matchFound = false;
				 var temp = listOfValues.split(',');
				 for (var i=0; i<temp.length; i++)
					{
						 if (frmElement.value.toUpperCase() ==  trim(temp[i].toUpperCase()))
						 {
						 	matchFound = true;
							break;
						 }
					}
					if (!matchFound)
				  	{
				 	 	return octShowErrorMessage(frmElement, errorMessage,1,1);	
				  	}
				 break;
	}
	return true;
}
// updates the required field indicator
function updateRequiredSpanElement(elementId, validationType)
{
	if (validationType.length)
	{
		setText = '*';
	}
	else
	{
		setText = '';
	}
	if (document.getElementById(elementId))
	{
	document.getElementById(elementId).innerHTML = setText;
	}
}

/**********************************************************************
     CODE BELOW IS FROM PETER BAILYS fValidate.js with functions
	 moded to fit our needs.
***********************************************************************/
// validate blanks
/*********************************************************************/
function octValidateBlank(formObj, errorMessage) {
	if (octCheckBlank(formObj)) {
		return octShowErrorMessage(formObj, errorMessage,1,1);			
		}
	return true;
}
// validate Select box
/***************************************************************************/
function octCheckBlank(formObj) {
	if (formObj.value == "")
		return true;
	var regex = new RegExp(/^\s+$/);
	if (regex.test(formObj.value))
		return true;			
	return false;
	}

// validate Select box
/***************************************************************************/
function octValidateSelect(formObj, errorMessage) {
	if (formObj.selectedIndex == 0) {
		
		return octShowErrorMessage(formObj,errorMessage,0,1);
		}
	return true;
}

// validate restricted selects
/***************************************************************************/
function octValidateSelectI(formObj, indexes, errorMessage) {
	var arrIndexes =indexes.split(/[,]/);
	var selectOK = true;
	for (var i=0; i<arrIndexes.length; i++)
		if (formObj.selectedIndex == arrIndexes[i])
			selectOK = false;
	if (!selectOK) {
		 return octShowErrorMessage(formObj, errorMessage,0,1);	
		}
	return true;
	}

// validate matching select
/***************************************************************************/	
function octValidateSelectMatch(formObj, matchToObj, errorMessage) {
    if (formObj.selectedIndex < 1 || matchToObj.selectedIndex < 1) {
	return true;
	}
	var re = new RegExp(/(^\d+)(.*)/);
	// find the values for first option
	var objName = formatName(formObj);
	var objValue = formObj.value.split("|");
	var firstSelection = objValue[1];
	var firstValue = firstSelection.replace(re, "$1");
	// find the values for second option
	var matchObjValue = matchToObj.value.split("|");
	var secondSelection = matchObjValue[1];
	var secondValue = secondSelection.replace(re, "$1");
	// now dow our regex...

	if (firstValue != secondValue) {
		   return octShowErrorMessage(matchToObj, errorMessage,0,1);
		}
	return true;
	}	
	
// validate radio button	
/***************************************************************************/	
function octValidateRadio(formObj, errorMessage) {	
	var formObj = formObj.form.elements[formObj.name];
	var selectTotal = 0;
	
	for (i=0; i<formObj.length; i++)
		if (formObj[i].checked)
			selectTotal++;

	if (selectTotal != 1) {
		  alert(errorMessage);
		  formObj[0].focus();
		  return false;
		}		
	return true;
}	

// validate check box.
/***************************************************************************/	
function octValidateCheckbox(formObj, errorMessage) {	
	var formObj = formObj.form.elements[formObj.name];
	var checkTotal = formObj.length;
	var checkCount = 0;
	for (var i=0; i<checkTotal; i++) {
		if (formObj[i].checked) checkCount++;
	}
	if (!checkCount) {
		 alert(errorMessage);
		  formObj[0].focus();
		  return false;
	}
	return true;
}
/***************************************************************************/	
function octShowErrorMessage(formObj, errorMsg, sel, foc) {
	var ret = false;
	alert(errorMsg);
	if (sel) formObj.select();
	if (formObj.style.display != 'none')
	{
		if (foc) formObj.focus();
	}
	fv['revertClass'] = formObj.className;		
	formObj.className = fv['errorClass'];
	return ret;
}		
/***************************************************************************/	
function updateOnFieldNotRequired(frmElement, errMsg, ignoreFirstDropDownOption, field)
{
	
	if (octCheckRadio(frmElement))
	{
		var onFieldID = frmElement[0].name.split("_");
		frmElement[0].setAttribute('alt','');
	}
	else
	{
		var onFieldID = frmElement.name.split("_");
		frmElement.setAttribute('alt','');
	}

	
	updateRequiredSpanElement('span_req_'+onFieldID[1],'');
	
	return true;
}
/***************************************************************************/	
function findSelectBoxMatchLocation(frmElement, fieldOptionID)
{
	
	var matchOnCount = 1;
	if (frmElement.type == "select-one")
	{
		for (var i=0; i<frmElement.options.length; i++)
		{
			var selectedOption  = frmElement.options[i].value.split("|");
			if (selectedOption[0] == fieldOptionID)
			{
				matchOnCount = i;
				break;
			}
		}
	}
	return matchOnCount;
}
/******************* GET RADIO BUTTON VALUE *****************************/
function getRadioButtonValue(formObj)
{
	for (i=0; i<formObj.length; i++)
	{
		if (formObj[i].checked)
		{
			return formObj[i].value;
		}
	}
}

/******************* GET SELECT BOX VALUE *****************************/
function getSelectValue(formObj)
{
	var selectOptionSelection = formObj.options[formObj.selectedIndex].value.split("|");
	return selectOptionSelection[0];

}

// loop list and return true if we find value
/***************************************************************************/
function findList(list, matchOn)
{
	
	var match = false;
	var temp = new Array();
	temp = list.split(',');
	for (var i=0; i<temp.length; i++)
	{
		if (trim(temp[i].toUpperCase()) == matchOn.toUpperCase())
		{
			match = true;
			break;
		}
	}
	return match;
}