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 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-._";
	var intCounter;

	if ((strUserName != "") && (strUserName != "undefined"))
	{
		for (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 intCounter;
		var strReturn = new String();
		
		for (intCounter = 0; intCounter < strTarget.length; intCounter++)
		{
			if (strAllowed.indexOf(strTarget.charAt(intCounter)) != -1)
			{
				strReturn += strTarget.charAt(intCounter).toString();
			}
		}
		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;
			}
		}
	}
}

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)
{
	document.getElementById(errID).className='errorMessageOff';
	document.getElementById(errID).parentNode.className='';
}

// ****************************
// * 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
		   {
                if (validateCurrencyEx(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 Jim *
// ****************************
function validateCurrencyRange(strResult, strTargetID, dblMinValue, dblMaxValue)
{
	var objTarget = getElementByID(strTargetID);

	var dblValue = parseFloat(stripNonNumeric(objTarget.value));

	/*	If the target object has a value that is greater than the minimum amount and less
		than the maximum amount allowed, then the currency range is valid. */
	if (dblValue >= dblMinValue && dblValue <= dblMaxValue)
	{
		errorDisplayOff(strTargetID, objTarget);
		return result;
	}
	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             *
// * Do not hide error display *
// *****************************
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";
	var intCounter;

	for (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-";
	var intCounter;

	//are there any invalid characters?
	for (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;
}

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

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

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

	if (intTotalDecimals > 1)
		return false;
	else
		return true;
}

/*******************************
* 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'))
				{
					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)
	{
		document.getElementById(errID).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;
	}
}

/*******************************
* 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)
	{
		document.getElementById(errID).className='errorMessage';
		return false;
	}

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

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

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

	if ((strItems[2].length != 2) && (strItems[2].length != 4))
	{
		document.getElementById(errID).className='errorMessage';
		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)
			{
				document.getElementById(errID).className='errorMessage';
				return false;
			}
		}
	}
	catch (e)
	{
	}

	if (isValidDate(year, month, day) == false)
	{
		document.getElementById(errID).className='errorMessage';
		return false;
	}
	else
	{
		if (minvalue == false)
		{
			document.getElementById(errID).className='errorMessageOff';
	
			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)
			{
				document.getElementById(errID).className='errorMessage';
				return false;
			}
			else
			{
				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;
	}
}

/*******************************
* 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
	element.parentNode.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
	element.parentNode.className = "";
}
/*******************************
* Display/Hide Error Messages v2
*******************************/
/* Commented out by Jim T. (consolidated all calls to the above errorDisplay functions)
function errorDisplay(fieldID, element)
{
	document.getElementById('err' + fieldID).className='errorMessage';
	element.parentNode.className='errorMessageOutline';
}

function errorDisplayOff(fieldID, element)
{
	document.getElementById('err' + fieldID).className='errorMessageOff';
	element.parentNode.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;
	}
}

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

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



//Function Created By Kevin Wiegand
//Created on 10/21/2005
//
//Use:  Gets the client id of a .Net
//		control using it's server side
//		name.

/*	Commented out by Jim T. (replaced with the function after it, which is compatible with Firefox and other browsers)

function getElementByPartialId(strPartialID)
{
	var intCounter;
	var objElements = document.all;
	var objReturn = null;

	strPartialID = "_" + strPartialID;

	if (objElements != undefined)
	{
		for (intCounter = 0; intCounter < objElements.length; intCounter++)
		{
			var strFullName = objElements[intCounter].getAttribute("ID");

			if (strFullName != "")
			{
				var intIndex = strFullName.indexOf(strPartialID);

				if (intIndex != -1)
				{
					var strPartialName = strFullName.substring(intIndex);

					if (strPartialName == strPartialID)
					{
						objReturn = objElements[intCounter];
					}
				}
			}
		}
	}

	return objReturn
}*/

/*******************************
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
				objFoundTarget = allElementsNodeList[intCounter];
			}
		}
	}
	
	return objFoundTarget;
}