String.prototype.trim = function()
{
	if (this != undefined)
	{
		var strString = new String(this);

		if (strString != undefined)
			return strString.replace(/(^\s*)|(\s*$)/g, "");
		else
			return strString;
	}
	else
		return "";
}

function BrowserIsIE()
{
	var bolIsIE = ((navigator.userAgent.toLowerCase().indexOf("msie") != -1) && (navigator.userAgent.toLowerCase().indexOf("opera") == -1)) ? true : false;
	
	return bolIsIE;
}

function BrowserIsSafari()
{
	var bolIsSafari = ((navigator.userAgent.toLowerCase().indexOf("safari") != -1) && (navigator.userAgent.toLowerCase().indexOf("opera") == -1)) ? true : false;
	
	return bolIsSafari;
}

function ClearHTMLTags(strHTML)
{
	if (strHTML != undefined)
	{
		var strString = new String(strHTML);
		
		strString = strString.replace(/(<([^>]+)>)/gim, " ");
		strString = strString.replace(/[<]/gim, "&lt;");
		strString = strString.replace(/[>]/gim, "&gt;");
		
		return strString;
	}
	else
		return "";
}

function validateRestrictedText(result,fieldID)
{
	var elements = document.getElementsByTagName('input');
	var strEl;
	
	for (var i = 0; i < elements.length; i++)
	{
		strEl = elements[i].getAttribute('name');
		if (endStringCompare(strEl,fieldID))
		{
			// If the required field has no value, show the error hints and return not valid.
			if ((elements[i].value=='') || (checkCharacters(elements[i].value) == false))
			{
				errorDisplay(fieldID, elements[i]);
				return false;
			}
			else
			{
				errorDisplayOff(fieldID, elements[i]);
				if (!result)
					return false;
				else
					return true;
			}
		}
	}
}

function checkCharacters(strUserName)
{
	var strAllowed = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._@";

	if ((strUserName != "") && (strUserName != "undefined"))
	{
		for (var intCounter = 0; intCounter < strUserName.length; intCounter++)
		{
			if (strAllowed.indexOf(strUserName.charAt(intCounter)) == -1)
			{
				return false;
			}
		}
	}

	return true;
}

// Return a string containing only numbers and decimal point(s)
function stripNonNumeric(strTarget)
{
	var strAllowed = "0123456789.";
	var strReturn = new String();
	
	if (strTarget != null)
	{
		for (var intCounter = 0; intCounter < strTarget.length; intCounter++)
		{
			if (strAllowed.indexOf(strTarget.charAt(intCounter)) != -1)
			{
				strReturn += strTarget.charAt(intCounter).toString();
			}
		}
		
		//keep negative numbers if entered in
		if ((strTarget.indexOf("-") == 0) || ((strTarget.indexOf("-") == 1) && (strTarget.indexOf("$") == 0)))
		{
			strReturn = "-" + strReturn;
		}
	}
	
	return strReturn;
}

//Use this as opposed to stripNonNumeric
//when you still need to validate if the value
//entered is a currency value...
function stripCurrencyChars(strTarget)
{
	var strReturn = strTarget;
	
	strReturn = strReturn.replace(/\$/g, "");
	strReturn = strReturn.replace(/,/g, "");
	
	return strReturn;
}
	

/*********************************
* Required Fields                *
*********************************/
function validateRequired(result,fieldID)
{
	var elements = document.getElementsByTagName('input');
	var strEl;
	
	for (var i = 0; i < elements.length; i++)
	{
		strEl = elements[i].getAttribute('name');
		//if (strEl.indexOf(fieldID)!=-1) {  //replaced because fields with simmilar name might be wrongly validated
		if (endStringCompare(strEl,fieldID))
		{
			// If the required field has no value, show the error hints and return not valid.
			if (elements[i].value=='')
			{
				errorDisplay(fieldID, elements[i]);
				return false;
			}
			// Else if the required field does have value, hide the error hints and return valid (unless another field validated before this one returned invalid).
			else
			{
				errorDisplayOff(fieldID, elements[i]);
				if (!result)
					return false;
				else
					return true;
			}
		}
	}
}

/*********************************
* Required Fields - Text Area    *
*********************************/
function validateTextArea(result,fieldID)
{
	var elements = document.getElementsByTagName('textarea');
	var strEl;
	
	for (var i = 0; i < elements.length; i++)
	{
		strEl = elements[i].getAttribute('name');
		//if (strEl.indexOf(fieldID)!=-1) {  //replaced because fields with simmilar name might be wrongly validated
		if (endStringCompare(strEl,fieldID))
		{
			// If the required field has no value, show the error hints and return not valid.
			if (elements[i].value=='')
			{
				errorDisplay(fieldID, elements[i]);
				return false;
			}
			// Else if the required field does have value, hide the error hints and return valid (unless another field validated before this one returned invalid).
			else
			{
				errorDisplayOff(fieldID, elements[i]);
				if (!result)
					return false;
				else
					return true;
			}
		}
	}
}

function validateRequiredNoErrors(result,fieldID)
{
	var elements = document.getElementsByTagName('input');
	var strEl;
	
	for (var i = 0; i < elements.length; i++)
	{
		strEl = elements[i].getAttribute('name');
		
		if (endStringCompare(strEl,fieldID))
		{
			if (elements[i].value == '')
			{
				return false;
			}
			else
			{
				if (!result)
					return false;
				else
					return true;
			}
		}
	}
}


// ****************************
// * Written By Kevin Wiegand *
// * returns true if a        *
// * checkbox is checked      *
// ****************************
function validateCheckbox(result, fieldID)
{
	var elements = document.getElementsByTagName('input');
	var strEl;
	
	for (var i = 0; i < elements.length; i++)
	{
		strEl = elements[i].getAttribute('name');
		
		if (endStringCompare(strEl,fieldID))
		{
			if (result == true)
			{
				return elements[i].checked;
			}
			else
			{
				return false;
			}
		}
	}

	return false;
}

// ****************************
// * Written By Kevin Wiegand *
// * Validates that a field   *
// * is a minimum size        *
// ****************************
function validateMinLength(result, fieldID, minsize)
{
	var elements = document.getElementsByTagName('input');
    var strEl;

    for (var i = 0; i < elements.length; i++)
	{
        strEl = elements[i].getAttribute('name');
        if (endStringCompare(strEl,fieldID))
		{
           if (elements[i].value.length < minsize)
		   {
                errorDisplay(fieldID, elements[i]);
                return false;
           }
		   else
		   {
                errorDisplayOff(fieldID, elements[i]);
                if (!result)
                    return false;
                else
                    return true;
            }
        }
    }
}

// *****************************
// * Written By Kevin Wiegand  *
// * Validates that a field    *
// * is a minimum size         *
// * do not show error display *
// *****************************
function validateMinLengthEx(result, fieldID, minsize)
{
	var elements = document.getElementsByTagName('input');
    var strEl;

    for (var i = 0; i < elements.length; i++)
	{
        strEl = elements[i].getAttribute('name');
        if (endStringCompare(strEl,fieldID))
		{
           if (elements[i].value.length < minsize)
                return false;
		   else
		   {
                if (!result)
                    return false;
                else
                    return true;
            }
        }
    }
}

// ****************************
// * Written By Kevin Wiegand *
// ****************************
function ClearMessage(errID)
{
	var objError = document.getElementById(errID);
		
	if (objError != null)
	{
		objError.className = "errorMessageOff";
			
		if (objError.parentElement != null)
		{
			objError.parentElement.className = "";
		}
	}
}

/*******************************
* Display/Hide Error Messages v1
*******************************/
function ShowMessage(errID)
{
	var objError = document.getElementById(errID);
		
	if (objError != null)
	{
		objError.className = "errorMessage";
			
		if (objError.parentElement != null)
		{
			objError.parentElement.className = "errorMessageOutline";
		}
	}
}

// ****************************
// * Written By Kevin Wiegand *
// * Validates Currency       *
// ****************************
function validateCurrency(result,fieldID)
{
    var elements = document.getElementsByTagName('input');
    var strEl;

    for (var i = 0; i < elements.length; i++)
	{
        strEl = elements[i].getAttribute('name');
        if (endStringCompare(strEl,fieldID))
		{
           if (elements[i].value=='')
		   {
                errorDisplay(fieldID, elements[i]);
                return false;
           }
		   else
		   {
				var bolIsPositive = true;
		   
                if (validateCurrencyEx(elements[i].value) == true)
				{
					var dblValue = parseFloat(stripNonNumeric(elements[i].value));
					
					if (isNaN(dblValue) == false)
					{
						if (dblValue < 0)
						{
							bolIsPositive = false;
						}
					}
					
					if (bolIsPositive == true)
					{
						errorDisplayOff(fieldID, elements[i]);
						
						if (result == true)
							return true;
						else
							return false;
					}
					else
					{
						errorDisplay(fieldID, elements[i]);
						return false;
					}
				}
				else
				{
					errorDisplay(fieldID, elements[i]);
					return false;
				}
           }
        }
    }
}

// ****************************
// * Written By Jim *
// ****************************
//Modified by Kevin...changed the stripNonNumeric to a currency-aware better one
//so that it only strips out currency-allowed characters - this is so a value
//of something like $4,50 0.00 will not validate, but $4,500.00 will.
function validateCurrencyRange(result, strTargetID, dblMinValue, dblMaxValue)
{
	var objTarget = getElementByID(strTargetID);

	if (validateCurrencyEx(objTarget.value) == true)
	{
		var dblValue = parseFloat(stripCurrencyChars(objTarget.value));

		if (isNaN(dblValue) == false)
		{
			if ((dblValue >= dblMinValue) && (dblValue <= dblMaxValue))
			{
				errorDisplayOff(strTargetID, objTarget);
				return result;
			}
			else
			{
				errorDisplay(strTargetID, objTarget);
				return false;
			}
		}
		else
		{
			errorDisplay(strTargetID, objTarget);
			return false;
		}
	}
}

// ****************************
// * Written By Kevin Wiegand *
// * Validates Integers       *
// ****************************
function validateInteger(result,fieldID)
{
    var elements = document.getElementsByTagName('input');
    var strEl;

    for (var i = 0; i < elements.length; i++)
	{
        strEl = elements[i].getAttribute('name');
        if (endStringCompare(strEl,fieldID))
		{
           if (elements[i].value=='')
		   {
                errorDisplay(fieldID, elements[i]);
                return false;
           }
		   else
		   {
                if (validateIntegerEx(elements[i].value) == true)
				{
					errorDisplayOff(fieldID, elements[i]);
					if (result == true)
						return true;
					else
						return false;
				}
				else
				{
					errorDisplay(fieldID, elements[i]);
					return false;
				}
           }
        }
    }
}

// *****************************
// * Written By Kevin Wiegand  *
// * Validates SSN             *
// *****************************
function validateSSN(result, fieldID, showError)
{
	var elements = document.getElementsByTagName('input');
	var strEl;
	
	for (var i = 0; i < elements.length; i++)
	{
		strEl = elements[i].getAttribute('name');
		if (endStringCompare(strEl,fieldID))
		{
			if (elements[i].value=='')
			{
				if (showError == true)
				{
					errorDisplay(fieldID, elements[i]);
				}
				
				return false;
			}
			else
			{
				if (validateSSNEx(elements[i].value) == true)
				{
					if (result == true)
					{
						errorDisplayOff(fieldID, elements[i]);
						return true;
					}
					else
					{
						return false;
					}
				}
				else
				{
					if (showError == true)
					{
						errorDisplay(fieldID, elements[i]);
					}
			
					return false;
				}
			}
		}
	}
}

// ****************************
// * Written By Kevin Wiegand *
// * Actual Integer Validator *
// ****************************
function validateIntegerEx(number)
{
	var strAllowed = "0123456789";

	for (var intCounter = 0; intCounter < number.length; intCounter++)
	{
		if (strAllowed.indexOf(number.charAt(intCounter)) == -1)
		{
			return false;
		}
	}

	return true;
}

// *****************************
// * Written By Kevin Wiegand  *
// * Actual SSN Validator      *
// *****************************
function validateSSNEx(number)
{
	var strAllowed = "0123456789-";

	//are there any invalid characters?
	for (var intCounter = 0; intCounter < number.length; intCounter++)
	{
		if (strAllowed.indexOf(number.charAt(intCounter)) == -1)
		{
			return false;
		}
	}

	//How many "-" characters are there?
	var items = number.split('-');
	var intCount = items.length - 1;

	if ((intCount != 2) && (intCount != 0))
		return false;

	number = number.replace(/-/g,"");
	if (number.length != 9)
		return false;

	return true;
}

function validatePhoneEx(strPhoneNumber)
{
	var strAllowed = '0123456789';
	var strPhone = "";
	
	for (var intCounter=0; intCounter<strPhoneNumber.length; intCounter++)
	{
		if (strAllowed.indexOf(strPhoneNumber.charAt(intCounter)) != -1)
		{
			strPhone += strPhoneNumber.charAt(intCounter);
		}
	}
				
	return (strPhone.length >= 10)
}

/****************************
* Phone Validation
****************************/
function validatePhone(result,fieldID)
{
	var elements = document.getElementsByTagName('input');
	var strEl;
	var strAllowed = '0123456789';
	var phonenum = '';
	
	for (var i = 0; i < elements.length; i++)
	{
		strEl = elements[i].getAttribute('name');
		if (endStringCompare(strEl,fieldID))
		{
			//doesn't check empty values -- use required field validation first (if required)
			if (elements[i].value=='')
			{
				errorDisplayOff(fieldID, elements[i]);
				if (result == true)
					return true;
				else
					return false;
			}
			else
			{
				for (var n=0; n<elements[i].value.length; n++)
				{
					if (strAllowed.indexOf(elements[i].value.charAt(n)) != -1)
						phonenum += elements[i].value.charAt(n);
				}
				
				if (phonenum.length>=10) 
				{
					if (phonenum.length>10) //remove digits preceding the first 10 numbers
						phonenum = phonenum.substring(phonenum.length-10, phonenum.length)
					
					if (result == true) 
					{
						errorDisplayOff(fieldID, elements[i]);
						return true;
					}
					else
					{
						errorDisplayOff(fieldID, elements[i]);
						return false;
					}
				}
				else
				{
					errorDisplay(fieldID, elements[i]);
					return false;
				}
			}
		}
	}
}

/****************************
* Phone Validation (Required)
****************************/
function validateRequiredPhone(result,fieldID)
{
	var elements = document.getElementsByTagName('input');
	var strEl;
	var strAllowed = '0123456789';
	var phonenum = '';
	
	for (var i = 0; i < elements.length; i++)
	{
		strEl = elements[i].getAttribute('name');
		if (endStringCompare(strEl,fieldID))
		{
			if (elements[i].value=='')
			{
				errorDisplay(fieldID, elements[i]);
				return false;
			}
			else
			{
				for (var n=0; n<elements[i].value.length; n++)
				{
					if (strAllowed.indexOf(elements[i].value.charAt(n)) != -1)
						phonenum += elements[i].value.charAt(n);
				}
				
				if (phonenum.length>=10) 
				{
					if (phonenum.length>10) //remove digits preceding the first 10 numbers
						phonenum = phonenum.substring(phonenum.length-10, phonenum.length)
					
					if (result == true) 
					{
						errorDisplayOff(fieldID, elements[i]);
						return true;
					}
					else
					{
						errorDisplayOff(fieldID, elements[i]);
						return false;
					}
				}
				else
				{
					errorDisplay(fieldID, elements[i]);
					return false;
				}
			}
		}
	}
}

// ****************************
// * Written By Kevin Wiegand *
// * Actual Currency          *
// * Validator                *
// ****************************
function validateCurrencyEx(number)
{
	var strAllowed = "0123456789.,$";
	var intTotalDecimals = 0;
	var intTotalDollar = 0;
	var bolResult = true;

	for (var intCounter = 0; intCounter < number.length; intCounter++)
	{
		//Is the character is not is the list of valid characters?
		if ((strAllowed.indexOf(number.charAt(intCounter)) == -1) && (number.charAt(intCounter) != "-"))
		{
			bolResult = false;
			break;
		}
		
		//Do we have more than one decimal point?
		if (number.charAt(intCounter) == '.')
		{
			intTotalDecimals++;
			
			if (intTotalDecimals > 1)
			{
				bolResult = false;
				break;
			}
		}
		
		//Do we have more than one dollar sign?
		if (number.charAt(intCounter) == '$')
		{
			intTotalDollar++;
			
			if (intTotalDollar > 1)
			{
				bolResult = false;
				break;
			}
		}
		
		//Have we matched a minus sign...and is it not the first character?
		if (number.charAt(intCounter) == "-")
		{
			if (intCounter > 0)
			{
				bolResult = false;
				break;
			}
		}
	}

	return bolResult;
}

//Found on the internet (return has a $)
function formatCurrency(num)
{
	num = num.toString().replace(/\$|\,/g,'');
	
	if(isNaN(num))
	{
		num = "0";
	}
	
	sign = (num == (num = Math.abs(num)));
	num = Math.floor(num * 100 + 0.50000000001);
	cents = num % 100;
	num = Math.floor(num / 100).toString();
	
	if(cents < 10)
	{
		cents = "0" + cents;
	}
	
	for (var i = 0; i < Math.floor((num.length - (1 + i)) / 3); i++)
	{
		num = num.substring(0, num.length - (4 * i + 3))+ ',' + num.substring(num.length - (4 * i + 3));
	}
	
	return (((sign) ? '' : '-') + '$' + num + '.' + cents);
}

//Found on the internet (no $ on this one)
function formatCurrencyEx(num)
{
	num = num.toString().replace(/\$|\,/g,'');
	
	if(isNaN(num))
	{
		num = "0";
	}
	
	sign = (num == (num = Math.abs(num)));
	num = Math.floor(num * 100 + 0.50000000001);
	cents = num % 100;
	num = Math.floor(num / 100).toString();
	
	if(cents < 10)
	{
		cents = "0" + cents;
	}
	
	for (var i = 0; i < Math.floor((num.length - (1 + i)) / 3); i++)
	{
		num = num.substring(0, num.length - (4 * i + 3))+ ',' + num.substring(num.length - (4 * i + 3));
	}
	
	return (((sign) ? '' : '-') + num + '.' + cents);
}

/*******************************
* Required Fields
* Do not show error display
* ...used for CoBorrowers...
*******************************/
function validateRequiredEx(result,fieldID)
{
    var elements = document.getElementsByTagName('input');
    var strEl;

    for (var i = 0; i < elements.length; i++)
	{
        strEl = elements[i].getAttribute('name');
        if (endStringCompare(strEl,fieldID))
		{
           if (elements[i].value=='')
		   {
                return false;
           }
		   else
		   {
                if (!result)
                    return false;
                else
                    return true;
            }
        }
    }
}

/*******************************
* Written By Kevin Wiegand
* Required Fields (select boxes)
*******************************/
function validateSelect(result,fieldID)
{
    var elements = document.getElementsByTagName('select');
    var strEl;

    for (var i = 0; i < elements.length; i++)
	{
		if (elements[i] != undefined)
		{
			strEl = elements[i].getAttribute('name');
			if (endStringCompare(strEl,fieldID))
			{
				if ((elements[i].value == '') || (elements[i].value == '-1') || (elements[i].value == 'Select One') || (elements[i].value == '(Select One)') || (elements[i].value == null))
				{
					errorDisplay(fieldID, elements[i]);
					return false;
				}
				else
				{
					errorDisplayOff(fieldID, elements[i]);
					if (!result)
	                    return false;
					else
						return true;
				}
			}
		}
    }
}

/*******************************
* Written By Kevin Wiegand
* Required Fields (radio lists)
*******************************/
function validateRadioList(result,fieldID,errID)
{
    var elements = document.getElementsByTagName('input');
    var strEl;
	var bolReturn = false;

    for (var i = 0; i < elements.length; i++)
	{
		if (elements[i] != undefined)
		{
			strEl = elements[i].getAttribute('name');
			if (endStringCompare(strEl,fieldID))
			{
				if ((elements[i].checked == false))
					bolReturn = false;
				else
				{
					document.getElementById(errID).className='errorMessageOff';
					if (!result)
	                    return false;
					else
						return true;
				}
			}
		}
    }

	if (bolReturn == false)
	{
		var objError = document.getElementById(errID);
		
		if (objError != null)
		{
			objError.className='errorMessage';
			
			if (objError.parentElement != null)
			{
				objError.parentElement.className='errorMessage';
			}
		}
		
		return false;
	}
}

/*******************************
* Required Fields (check box list)
*******************************/
function validateCheckboxList(result,fieldID,errID)
{
    var elements = document.getElementsByTagName('input');
    var strEl;
	var bolReturn = false;

    for (var i = 0; i < elements.length; i++)
	{
		if (elements[i] != undefined && elements[i].getAttribute('type')=='checkbox')
		{
			strEl = elements[i].getAttribute('name');
			//if (endStringCompare(strEl,fieldID))  //replaced because checkboxes have number suffixes
			if (strEl.indexOf(fieldID)!=-1)
			{
				if ((elements[i].checked == false))
					bolReturn = false;
				else
				{
					document.getElementById(errID).className='errorMessageOff';
					if (!result)
	                    return false;
					else
						return true;
				}
			}
		}
    }

	if (bolReturn == false)
	{
		document.getElementById(errID).className='errorMessage';
		return false;
	}
}

function ValidateTime(result, fieldID)
{
	var elements = document.getElementsByTagName('input');
	var objElement = null;
    var strEl;
	var strTime = new String();
	var bolResult = true;

    for (var i = 0; i < elements.length; i++)
	{
		if (elements[i] != undefined)
		{
			strEl = elements[i].getAttribute('name');
			if (endStringCompare(strEl,fieldID))
			{
				try
				{
					strTime = elements[i].value;
					objElement = elements[i];
				}
				catch (e)
				{
				}

				break;
			}
		}
    }
    
    if ((strTime != "") && (strTime != null))
    {
		var bolValidTime = ValidateTimeEx(strTime);
		
		if (bolValidTime == false)
		{
			errorDisplay(fieldID, objElement);
			bolResult = false;
		}
		else
		{
			errorDisplayOff(fieldID, objElement);
			
			if (result == false)
			{
				bolResult = false;
			}
			else
			{
				bolResult = true;
			}
		}
	}
    
	return bolResult;
}

function ValidateTimeEx(strTime)
{
	var bolValidTime = false;
	var strPieces = strTime.split(" ");

	if (strPieces.length == 2)
	{
		if ((strPieces[1].toUpperCase() == "AM") || (strPieces[1].toUpperCase() == "PM"))
		{
			strPieces = strPieces[0].split(":");
			
			//Make sure there is exactly 2 pieces, and that the first item is either a single or double digit, 
			//	and that the second item is a double digit
			if ((strPieces.length == 2) && ((strPieces[0].length == 1) || (strPieces[0].length == 2)) && (strPieces[1].length == 2))
			{
				var intHour = parseInt(strPieces[0], 10);
				var intMinute = parseInt(strPieces[1], 10);
				
				if ((validateIntegerEx(strPieces[0]) == true) && (validateIntegerEx(strPieces[1]) == true) && (isNaN(intHour) == false) && (isNaN(intMinute) == false) && (intHour > 0) && (intMinute >= 0) && (intHour < 13) && (intMinute < 60))
				{
					bolValidTime = true;
				}
			}
		}
	}
	
	return bolValidTime;
}

/*******************************
* Written By Kevin Wiegand
* Custom Date Validators
* DO NOT MODIFY
*******************************/
function validateDate(result, fieldID, errID)
{
	return validateMinimumDate(result, fieldID, errID, false);
}

function validateMinimumDate(result, fieldID, errID, minvalue)
{
	var elements = document.getElementsByTagName('input');
    var strEl;
	var strDate = new String();

    for (var i = 0; i < elements.length; i++)
	{
		if (elements[i] != undefined)
		{
			strEl = elements[i].getAttribute('name');
			if (endStringCompare(strEl,fieldID))
			{
				try
				{
					strDate = elements[i].value;
				}
				catch (e)
				{
				}

				break;
			}
		}
    }

	//Make sure that the split item is the "/" character
	strDate = strDate.replace(/-/g, "/");

	var strItems = strDate.split("/");

	//Are there 3 parts to the array?
	if (strItems.length != 3)
	{
		ShowMessage(errID);
		return false;
	}

	var month = 0;
	var day = 0;
	var year = 0;

	if ((strItems[0].length > 2) || (strItems[0].length = 0))
	{
		ShowMessage(errID);
		return false;
	}

	try
	{
		month = Number(strItems[0]);
	}
	catch (e)
	{
		ShowMessage(errID);
		return false;
	}

	if ((strItems[1].length > 2) || (strItems[1].length = 0))
	{
		ShowMessage(errID);
		return false;
	}

	try
	{
		day = Number(strItems[1]);
	}
	catch (e)
	{
		ShowMessage(errID);
		return false;
	}

	if ((strItems[2].length != 2) && (strItems[2].length != 4))
	{
		ShowMessage(errID);
		return false;
	}

	try
	{
		year = Number(strItems[2]);

		if (Number(year) < 100)
		{
			var strYear = new String();
			var dteNow = new Date();

			strYear = dteNow.getFullYear().toString();
			strYear = strYear.substring(0, 2);

			//Make sure year is 2 digits
			if (Number(year) < 10)
				year = "0" + Number(year);

			year = strYear + year.toString();
		}
		else
		{
			if (Number(year) < 1970)
			{
				ShowMessage(errID);
				return false;
			}
		}
	}
	catch (e)
	{
	}

	if (isValidDate(year, month, day) == false)
	{
		ShowMessage(errID);
		return false;
	}
	else
	{
		if (minvalue == false)
		{
			ClearMessage(errID);
	
			if (result == true)
				return true;
			else
				return false;
		}
		else
		{
			//Check to see if the date is at least equal to the minimum
			var dteCheck = new Date(Number(year), Number(month - 1), Number(day), 23, 59, 59);
			var dteToday = new Date();

			if (checkMinimumDate(dteCheck, dteToday) == false)
			{
				ShowMessage(errID);
				return false;
			}
			else
			{
				ClearMessage(errID);
			
				if (result == false)
					return false;
				else
					return true;
			}
		}
	}
}

function checkMinimumDate(dteDateToCheck, dteMinimumDate)
{
	var intDateDiff = dateDiff(dteDateToCheck, dteMinimumDate)

	if (intDateDiff < 0)
		return false;
	else
		return true;
}

function dateDiff(dteFirstDate, dteSecondDate)
{
	var intSeconds1 = 0;
	var intSeconds2 = 0;

	intSeconds1 = dateToSeconds(dteFirstDate);
	intSeconds2 = dateToSeconds(dteSecondDate);

	try
	{
		return intSeconds1 - intSeconds2;
	}
	catch (e)
	{
		return 0;
	}
}

function dateToSeconds(dteDate)
{
	var dte = new Date(dteDate);

	try
	{
		return dte.getTime();
	}
	catch (e)
	{
		return 0;
	}
}

function GetDayOfWeek(fieldID)
{
	var elements = document.getElementsByTagName('input');
    var strEl;
	var strDate = new String();

    for (var i = 0; i < elements.length; i++)
	{
		if (elements[i] != undefined)
		{
			strEl = elements[i].getAttribute('name');
			if (endStringCompare(strEl,fieldID))
			{
				try
				{
					strDate = elements[i].value;
				}
				catch (e)
				{
				}

				break;
			}
		}
    }

	//Make sure that the split item is the "/" character
	strDate = strDate.replace(/-/g, "/");

	var strItems = strDate.split("/");

	//Are there 3 parts to the array?
	if (strItems.length != 3)
	{
		return -1;
	}

	var month = 0;
	var day = 0;
	var year = 0;

	if ((strItems[0].length > 2) || (strItems[0].length = 0))
	{
		return -1;
	}

	try
	{
		month = Number(strItems[0]);
	}
	catch (e)
	{
		return -1;
	}

	if ((strItems[1].length > 2) || (strItems[1].length = 0))
	{
		return -1;
	}

	try
	{
		day = Number(strItems[1]);
	}
	catch (e)
	{
		return -1;
	}

	if ((strItems[2].length != 2) && (strItems[2].length != 4))
	{
		return -1;
	}

	try
	{
		year = Number(strItems[2]);

		if (Number(year) < 100)
		{
			var strYear = new String();
			var dteNow = new Date();

			strYear = dteNow.getFullYear().toString();
			strYear = strYear.substring(0, 2);

			//Make sure year is 2 digits
			if (Number(year) < 10)
				year = "0" + Number(year);

			year = strYear + year.toString();
		}
		else
		{
			if (Number(year) < 1970)
			{
				return -1;
			}
		}
	}
	catch (e)
	{
	}

	if (isValidDate(year, month, day) == false)
	{
		return -1;
	}
	else
	{
		var dteCheck = new Date(Number(year), Number(month - 1), Number(day));

		return dteCheck.getDay();
	}
	
	return -1;
}

/*******************************
* Display/Hide Error Messages v1
*******************************/
function errorDisplay(fieldID, element)
{
	// Show the error message element
	var errorMessageElement = document.getElementById("err" + fieldID);
	
	if (errorMessageElement)
	{
		errorMessageElement.className = "errorMessage";
	}
	
	// Show the background error effect
	if ((element) && (element.parentElement))
	{
		element.parentElement.className = "errorMessageOutline";
	}
}

function errorDisplayOff(fieldID, element)
{
	// Hide the error message element
	var errorMessageElement = document.getElementById("err" + fieldID);
	
	if (errorMessageElement)
	{
		errorMessageElement.className ="errorMessageOff";
	}
	
	// Hide the background error effect
	if (element.parentElement)
	{
		element.parentElement.className = "";
	}
}

/*******************************
* match validation
*******************************/
function validateMatch(result,fieldID,fieldID2)
{
	obj1 = getElementByID(fieldID);
	obj2 = getElementByID(fieldID2);
	
	// If the fields do not match, show the error on the first field
	if (obj1.value != obj2.value)
	{
		errorDisplay(fieldID,obj1);
		return false;
	}
	// Else if the fields do match
	else
	{
		errorDisplayOff(fieldID,obj1);
		return result;
	}
}

/*******************************
* match validation
*******************************/
function validateMatchEx(result,fieldID,fieldID2,errID)
{
	obj1 = getElementByID(fieldID);
	obj2 = getElementByID(fieldID2);
	
	// If the fields do not match, show the error on the first field
	if (obj1.value != obj2.value)
	{
		ShowMessage(errID);
		return false;
	}
	// Else if the fields do match
	else
	{
		ClearMessage(errID);
		return result;
	}
}

/*******************************
* return the name from a partial field ID
* NO LONGER USED - may be needed later
*******************************/
function getNameByID(fieldID)
{
    var elements = document.getElementsByTagName('input');
    var strEl;
    for (var i = 0; i < elements.length; i++)
	{
        strEl = elements[i].getAttribute('name');
        if (endStringCompare(strEl,fieldID))
		{
            return strEl;
        }
    }
    return false;
}

/*******************************
* return the element from a partial field ID
*******************************/
function getElementByID(fieldID)
{
	var elements;
	var strEl;
	
	// Try to find an input tag that matches the fieldID
	elements = document.getElementsByTagName('input');
	for (var i = 0; i < elements.length; i++)
	{
		strEl = elements[i].getAttribute('name');
	
		if (endStringCompare(strEl,fieldID))
		{
			return elements[i];
		}
	}

	// Try to find a textarea tag  that matches the fieldID
	elements = document.getElementsByTagName('textarea');
	for (var i = 0; i < elements.length; i++)
	{
		strEl = elements[i].getAttribute('name');
	
		if (endStringCompare(strEl,fieldID))
		{
			return elements[i];
		}
	}
	
	// If we didn't find anything...
	return false;
}

/*******************************
* Required Email
*******************************/
function validateRequiredEmail(result, fieldID)
{
    var elements = document.getElementsByTagName('input');
    var strEl;
    for (var i = 0; i < elements.length; i++)
	{
        strEl = elements[i].getAttribute('name');
        //if (strEl.indexOf(fieldID)!=-1) {  //replaced because fields with simmilar name might be wrongly validated
        if (endStringCompare(strEl,fieldID))
		{
            if (!validateEmailEx(elements[i].value))
			{
                errorDisplay(fieldID, elements[i]);
                return false;
            }

            if (validateEmailEx(elements[i].value))
			{
                errorDisplayOff(fieldID, elements[i]);
            }

            if (!result)
                return false;
            else
                return true;   
        }
    }
}

function ValidateZipCode(result, fieldID)
{
    var elements = document.getElementsByTagName('input');
    var strEl;
    
    for (var i = 0; i < elements.length; i++)
	{
        strEl = elements[i].getAttribute('name');

        if (endStringCompare(strEl,fieldID))
		{
			errorDisplayOff(fieldID, elements[i]);
		
			if ((elements[i].value.trim() == "") || (validateIntegerEx(elements[i].value) == false) || (elements[i].value.length != 5))
			{
                errorDisplay(fieldID, elements[i]);
                return false;
            }

            if (!result)
                return false;
            else
                return true;   
        }
    }
}

/*******************************
* Optional Email
*******************************/
function validateEmail(result, fieldID)
{
    var elements = document.getElementsByTagName('input');
    var strEl;

    for (var i = 0; i < elements.length; i++)
	{
        strEl = elements[i].getAttribute('name');
        //if (strEl.indexOf(fieldID)!=-1) {  //replaced because fields with simmilar name might be wrongly validated
        if (endStringCompare(strEl,fieldID))
		{
            if (elements[i].value=='' && !result)
                return false;

            if (elements[i].value=='' && result)
                return true;

            if (!validateEmailEx(elements[i].value))
			{
                errorDisplay(fieldID, elements[i]);
                return false;
            }

            if (validateEmailEx(elements[i].value))
			{
                errorDisplayOff(fieldID, elements[i]);
            }

            if (!result)
                return false;
            else
                return true; 
        }
    }
}

/*******************************
* End of String Compare
*
* since aspx adds characters to
* the name field for aspx controls
* use this to check if the name
* is at the end of the contrl name
*******************************/
function endStringCompare(str1, strFind)
{
	// If both of the strings are not null
	if ((str1 != null) && (strFind != null)) {
	
		var strFindLen = strFind.length;
		var str1Len = str1.length;
		var index = str1.indexOf(strFind);
		
		if (index!=-1)
		{
			//check different length strings
			if (index==str1Len-strFindLen)
			    return true;
			else
			    return false;        
		}
	}
	
	return false;
}

/*******************************
* ValidateEmailEx
*******************************/
function validateEmailEx(incoming)
{
	var emailstring = incoming;
	var ampIndex = emailstring.indexOf("@");
	var afterAmp = emailstring.substring((ampIndex + 1), emailstring.length);
		// find a dot in the portion of the string after the ampersand only
	var dotIndex = afterAmp.indexOf(".");
		// determine dot position in entire string (not just after amp portion)
	dotIndex = dotIndex + ampIndex + 1;
		// afterAmp will be portion of string from ampersand to dot
	afterAmp = emailstring.substring((ampIndex + 1), dotIndex);
		// afterDot will be portion of string from dot to end of string
	var afterDot = emailstring.substring((dotIndex + 1), emailstring.length);
	var beforeAmp = emailstring.substring(0,(ampIndex));
		//old regex did not allow subdomains and dots in names
		//var email_regex = /^[\w\d\!\#\$\%\&\'\*\+\-\/\=\?\^\_\`\{\|\}\~]+(\.[\w\d\!\#\$\%\&\'\*\+\-\/\=\?\^\_\`\{\|\}\~])*\@(((\w+[\w\d\-]*[\w\d]\.)+(\w+[\w\d\-]*[\w\d]))|((\d{1,3}\.){3}\d{1,3}))$/;
	var email_regex = /^\w(?:\w|-|\.(?!\.|@))*@\w(?:\w|-|\.(?!\.))*\.\w{2,3}/ 
		// index of -1 means "not found"
	if ((emailstring.indexOf("@") != "-1") &&
		(emailstring.length > 5) &&
		(afterAmp.length > 0) &&
		(beforeAmp.length > 1) &&
		(afterDot.length > 1) &&
		(email_regex.test(emailstring)))
	{
		  return true;
	}
	else
	{
			return false;
	}
}

// Is is a valid date?
// Written By Kevin Wiegand
function isValidDate(year, month, day)
{
	month--;

	//ensure that the year is 4 digits
	if (Number(year) < 100)
	{
		var strYear = new String();
		var dteNow = new Date();

		strYear = dteNow.getFullYear().toString();
		strYear = strYear.substring(0, 2);

		//Make sure year is 2 digits
		if (Number(year) < 10)
			year = "0" + Number(year);

		year = strYear + year.toString();
	}

	var dte = new Date(Number(year), Number(month), Number(day));

	if ((Number(month) == dte.getMonth()) && (Number(day) == dte.getDate()) && (Number(year) == dte.getFullYear()))
	{
		//Valid Date, make a year check real quick
		if (dte.getFullYear() > 1969)
			return true;
		else
			return false;
	}
	else
		return false;
}

/********************************
If the user presses the enter key, cause the target button to be clicked.
Author: Jim T.
*******************************/
function handleKeyPress(event, targetButtonId)
{
	// If the enter key was pressed
	if (event.keyCode == 13)
	{
		var targetButton;

		// Find the button we want to click
		targetButton = getElementByPartialId(targetButtonId);
		
		// If we have found something, then click it.
		if (targetButton)
		{
			if (targetButton.click != "undefined")
			{
				targetButton.click();
				event.cancelBubble = true;
				return false;
			}
		}
	}
	return true;
}

/*******************************
Get an element based on part of the ID, to support selecting elements that were
created by the .NET framework.
Returns: The element, if it was found. Otherwise returns null.
Author: Jim T.
Version: 1.1 (10/24/2005)	
*******************************/
function getElementByPartialId(strTargetPartialId)
{
	// Get a list of all the elements in the document
	var allElementsNodeList = document.getElementsByTagName("*");
	var objFoundTarget = null;

	/*	KLUDGE:
		To ensure that we get the element we're looking for, rather than a similarly named
		element, we're adding an underscore to the beginning of the partial ID. This is a
		.NET 2.0 specific solution to this problem (so it may need to be updated someday).	*/
	strTargetPartialId = "_" + strTargetPartialId;
	
	// If the list of elements was successfully created
	if (allElementsNodeList != null)
	{
		// Iterate through the list of elements
		for (var intCounter = 0; intCounter < allElementsNodeList.length; intCounter++)
		{
			// Get the ID of the next element
			var strNextFullId = String(allElementsNodeList[intCounter].getAttribute("id"));
			
			// If the next ID contains the target ID inside of it
			if (strNextFullId.indexOf(strTargetPartialId) != -1)
			{
				// Save the next element so it can be returned
				return allElementsNodeList[intCounter];
			}
		}
	}
	
	return null;
}

function FormatCurrencyEx(objControl)
{
	if (validateCurrencyEx(objControl.value) == true)
	{
		var strReturn = formatCurrency(stripCurrencyChars(objControl.value));
		
		objControl.value = strReturn;
	}
}

function FormatSSN(objControl)
{
	if (validateSSNEx(objControl.value) == true)
	{
		var strValue = stripNonNumeric(objControl.value);
		
		var strFirst = strValue.substring(0, 3);
		var strSecond = strValue.substring(3, 5);
		var strLast = strValue.substring(5, 9);
		
		var strReturn = strFirst + "-" + strSecond + "-" + strLast;
		
		objControl.value = strReturn;
	}
}

function FormatDateEx(objControl)
{
	var strDate = document.getElementById(objControl).value;
	
	strDate = strDate.replace(/-/g, "/");

	var strItems = strDate.split("/");

	//Are there 3 parts to the array?
	if (strItems.length == 3)
	{
		var month = 0;
		var day = 0;
		var year = 0;

		try
		{
			month = Number(strItems[0]);
		}
		catch (e)
		{
		}

		try
		{
			day = Number(strItems[1]);
		}
		catch (e)
		{
		}

		try
		{
			year = Number(strItems[2]);

			if (Number(year) < 100)
			{
				var strYear = new String();
				var dteNow = new Date();

				strYear = dteNow.getFullYear().toString();
				strYear = strYear.substring(0, 2);

				//Make sure year is 2 digits
				if (Number(year) < 10)
					year = "0" + Number(year);

				year = strYear + year.toString();
			}
		}
		catch (e)
		{
		}
	}
	
	if (isValidDate(year, month, day) == true)
	{
		var strReturn = month + "/" + day + "/" + year;
		
		document.getElementById(objControl).value = strReturn;
	}
}

/* Validates ABA Number as a Required Field */
function ValidateABANumber(bolResult, strFieldID)
{
	var elements = document.getElementsByTagName('input');
    var strEl;   
    
    for (var i = 0; i < elements.length; i++)
	{
        strEl = elements[i].getAttribute('name');
        
        if (endStringCompare(strEl, strFieldID))
		{
            if (ValidateABANumberEx(elements[i].value) == false)
			{
                errorDisplay(strFieldID, elements[i]);
                return false;
            }
            else
			{
                errorDisplayOff(strFieldID, elements[i]);
            }

            if (bolResult == false)
            {
				return false;
			}
            else
			{
				return true;   
			}
        }
    }
}

/* Helper validator for ValidateABANumber */
function ValidateABANumberEx(strABANumber)
{
	var bolReturn = false;
	
	//Is the string exactly 9 DIGITS in length?
	if ((strABANumber != null) && (strABANumber.length == 9) && (validateIntegerEx(strABANumber) == true))
	{
		var intMultipliers = new Array();
		var intTotal = 0;
		
		intMultipliers[0] = 3;
		intMultipliers[1] = 7;
		intMultipliers[2] = 1;
		intMultipliers[3] = 3;
		intMultipliers[4] = 7;
		intMultipliers[5] = 1;
		intMultipliers[6] = 3;
		intMultipliers[7] = 7;
		intMultipliers[8] = 1;
		
		for (var intCounter = 0; intCounter < 9; intCounter++)
		{
			intTotal += parseInt(strABANumber.substr(intCounter, 1), 10) * intMultipliers[intCounter];
		}
		
		if (isNaN(intTotal) == false)
		{
			bolReturn = ((intTotal > 0) && ((intTotal % 10) == 0));
		}
	}
	
	return bolReturn;
}