function AssignAwardAppReviewer(iAwardAppID)
{
	window.open("AwardApplicationReviewer.aspx?id=" + iAwardAppID, "AwardAppRev", "height=400, location=0, menubar=0, resizable=0, scrollbars=1, width=400");
}
function AssignFellowAppReviewer(iFellowAppID)
{
	window.open("FellowshipApplicationReviewers.aspx?id=" + iFellowAppID, "FellowAppRev", "height=400, location=0, menubar=0, resizable=0, scrollbars=1, width=400");
}
function archiveApp(iAwardID, iAppID)
{
	var strPage = window.location.pathname;
	strPage = strPage.substring(strPage.lastIndexOf('/') + 1);
	
	if(confirm('Are you sure you want to archive this?'))
		window.location.href = strPage + "?id=" + iAwardID + "&archive=" + iAppID;
}
function ArchiveFellowApp(iFellowAppID)
{
	if(confirm('Are you sure you want to archive this application?'))
		window.location.href = 'FellowshipApplications.aspx?archive_id=' + iFellowAppID;
}
function deleteApp(iAwardID, iAppID)
{
	var strPage = window.location.pathname;
	strPage = strPage.substring(strPage.lastIndexOf('/') + 1);
	
	if(confirm('Are you sure you want to delete this?'))
		window.location.href = strPage + "?id=" + iAwardID + "&delete=" + iAppID;
}


var imgNew = new Image();
imgNew.src = '/images/icon_check.gif';
function reviewFile(strImgName, strFile)
{
	if(document.images)
		document.getElementById(strImgName).src = imgNew.src;
	window.location.href = strFile;
}
function toggleDisplay(strElement)
{
	var objInfo = document.getElementById(strElement);
	if(objInfo.style.display == 'none')
		objInfo.style.display = 'block';
	else
		objInfo.style.display = 'none';
}

//----------------------------------------------------------------------------------
function validateExpression (val, RE) {
	var re = new RegExp(RE);
	if (val.search(RE) == -1) { return false; }
	else { return true; }
}
//----------------------------------------------------------------------------------

// this was snagged from www.siteExperts.com and modified
/************************************************
DESCRIPTION: Validates that a string contains only 
    valid dates with 2 digit month, 2 digit day, 
    4 digit year. Date separator is /.
    Uses combination of regular expressions and 
    string parsing to validate date.
    Ex. mm/dd/yyyy
    
PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
*************************************************/
function validateUSDate(strValue) {
	var RE = /\b\d{1,2}\/\d{1,2}\/\d{4}\b/;
	
	if (validateExpression(strValue, RE) == false) return false; //doesn't match pattern, bad date
	else{
		var arrayDate = strValue.split('/'); //split date into month, day, year
		var intDay = parseInt(arrayDate[1],10); 
		var intYear = parseInt(arrayDate[2],10);
		var intMonth = parseInt(arrayDate[0],10);
		
		//check for valid month
		if(intMonth > 12 || intMonth < 1) return false;
	
		//create a lookup for months not equal to Feb.
		var arrayLookup = { '01' : 31,'03' : 31, '04' : 30,'05' : 31,'06' : 30,'07' : 31,'08' : 31,'09' : 30,'10' : 31,'11' : 30,'12' : 31}
	
		//check if month value and day value agree
		if(arrayLookup[arrayDate[0]] != null) {
			if(intDay <= arrayLookup[arrayDate[0]] && intDay != 0) return true; //found in lookup table, good date
		}
		//check for February
		var booLeapYear = (intYear % 4 == 0 && (intYear % 100 != 0 || intYear % 400 == 0));
		if( ((booLeapYear && intDay <= 29) || (!booLeapYear && intDay <=28)) && intDay !=0)
			return true; //Feb. had valid number of days
	}
	return false; //any other values, bad date
}
// this was snagged from www.siteExperts.com and modified
/************************************************
DESCRIPTION: Validates that a string contains only 
    valid dates with 2 digit month, 2 digit day, 
    4 digit year. Date separator is /.
    Uses combination of regular expressions and 
    string parsing to validate date.
    Ex. mm-yyyy
    
PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
*************************************************/
function validateUSMMYYYY(strValue) {
	var RE = /\b\d{1,2}-\d{4}\b/;
	
	if (validateExpression(strValue, RE) == false) return false; //doesn't match pattern, bad date
	else{
		var arrayDate = strValue.split('-'); //split date into month, day, year
		var intYear = parseInt(arrayDate[1],10);
		var intMonth = parseInt(arrayDate[0],10);
		
		//check for valid month
		if(intMonth > 12 || intMonth < 1) return false;
		return true;
	}
	return false; //any other values, bad date
}
//----------------------------------------------------------------------------------
/*=======================================================
description:
	this validates a 12-hour time format. hh:mm am|pm
	also, it only validates valid time ranges
	
parameters:
	str - string to be tested
	
returns:
	true if valid, oterwise false
=======================================================*/
function validate12hourTime(str) {
	return validateExpression(str, /\b^(([1-9]|1[0-2]):[0-5]\d{1}\s(am|pm)\b){1}$\b/i);
}

function validateUSDateTime(strValue) {
	var RE = /\b\d{1,2}\/\d{1,2}\/\d{4}\s{1}(([1-9]|1[0-2]):[0-5]\d{1}(:[0-5]\d{1})?\s(am|pm)\b){1}$\b/i;
	
	if (validateExpression(strValue, RE) == false) return false; //doesn't match pattern, bad date
	else{
		var arrayDate = strValue.split('/'); //split date into month, day, year
		var intDay = parseInt(arrayDate[1],10); 
		var intYear = parseInt(arrayDate[2],10);
		var intMonth = parseInt(arrayDate[0],10);
		
		//check for valid month
		if(intMonth > 12 || intMonth < 1) return false;
	
		//create a lookup for months not equal to Feb.
		var arrayLookup = { '01' : 31,'03' : 31, '04' : 30,'05' : 31,'06' : 30,'07' : 31,'08' : 31,'09' : 30,'10' : 31,'11' : 30,'12' : 31}
	
		//check if month value and day value agree
		if(arrayLookup[arrayDate[0]] != null) {
			if(intDay <= arrayLookup[arrayDate[0]] && intDay != 0) return true; //found in lookup table, good date
		}
		//check for February
		var booLeapYear = (intYear % 4 == 0 && (intYear % 100 != 0 || intYear % 400 == 0));
		if( ((booLeapYear && intDay <= 29) || (!booLeapYear && intDay <=28)) && intDay !=0)
			return true; //Feb. had valid number of days
	}
	return false; //any other values, bad date
}

function validateNumeric( strValue ) {
	
	var objRegExp  =  /(^-?\d\d*\.\d*$)|(^-?\d\d*$)|(^-?\.\d\d*$)/; 
	//alert(objRegExp.test(strValue));
	return objRegExp.test(strValue);
}



/*
----------------------------------------------------------------
| General date functions used on the 'onBlur' event in 
| ASP pages for client-side validation
----------------------------------------------------------------
FUNCTIONS:

1	dateValidation
2	isValidDate
3	daysDiff
4	passNumValidation
5	isValidNumField
6	isValidNumFmt
7	isValidNumRange
8   isValidYear
9   passTimeValidation (added 8/18/99 KKB)
10  FutureDateValidation (added 05/26/00  AMN)
11 ExpectedRangeWarn (added 01/10/2001 KMCG)
12  PassNumValidationWithChild   (added 01/24/01  GK)
13  intAgeInMonthsCalc        ( added 02/02 MCTIER )
----------------------------------------------------------------

----------------------------------------------------------------
| General height and weight functions used on the  
| 'onBlur' event in ASP pages for client-side validation
----------------------------------------------------------------
FUNCTIONS:

1	CMToFtIn
2	FtInToCmFT
3	FtInToCmIN
4	KgToLb
5	LbToKg
6	ageCalc
7   ageCalcOther

----------------------------------------------------------------
*/


/*
'****************************************************************************
'                              dateValidation                               
'****************************************************************************
' Purpose:          Perform full date validation and range checks on a date 
'                   field.  If necessary, alert user if invalid date or     
'                   format.                                                 
'                                                                           
' Input Parameters: datefld1  --  reference to date object                  
'                   datefld2  --  low date range     D1 => D2               
'                   datefld3  --  high date range    D1 <= D3               
'                                 Default to "Today" system date; there     
'                                 are no future dates in TIEDI.             
'  																		          
' Returns:          True if the field is a valid date, otherwise False		                                    
'                                                                           
' Called Routines:  isValidDate                                             
'                   daysDiff                                                
' 					errorMessages 	
' HISTORY:
'
' 01/14/2002 (JLL)  Added fldVal3 value optional slash coversion to prevent
'                   alert from poping up if datefld3 did not have slashes.
' 01/04/2000 (KAA)	changed Y2K code to reference getFullYear() 
'											 
'****************************************************************************
*/

function dateValidation(datefld1, datefld2, datefld3, page) 
{
	var NS4 = (document.layers) ? true : false;
	var IE4 = (document.all) ? true : false;

    fldVal1 = datefld1.value;
    

    if ( fldVal1.length == 8 )	// make / optional by converting mmddccyy to mm/dd/ccyy
    {
		fldVal1 = fldVal1.substring( 0 , 2 ) + "/" + fldVal1.substring( 2, 4 ) + "/" + fldVal1.substring( 4, 8 );
		if ( datefld2.value == datefld1.value ) datefld2.value = fldVal1;
		if ( datefld3.value == datefld1.value ) datefld3.value = fldVal1;
		datefld1.value = fldVal1;
    }

	//get date values passed
    fldVal1 = datefld1.value;
    fldVal2 = datefld2.value;
    fldVal3 = datefld3.value;

    	
    //today's date    
   if (page == "ptr")
		var today = new Date(fldVal3);
   else
		var today = new Date();
    var todayYear = today.getFullYear();
        
    var todayMonth = today.getMonth();
    var todayDay = today.getDate();
    todayVal = Date.UTC(todayYear,todayMonth,todayDay);
    
   
    //datefld1 date
	var dateVal = new Date(fldVal1);
    var todayYear = dateVal.getFullYear();
    
    var todayMonth = dateVal.getMonth();
    var todayDay = dateVal.getDate();
    dateVal1 = Date.UTC(todayYear,todayMonth,todayDay);


    //datefld2 date
    var dateVal = new Date(fldVal2);
    var todayYear = dateVal.getFullYear();
    
    var todayMonth = dateVal.getMonth();
    var todayDay = dateVal.getDate();
    dateVal2 = Date.UTC(todayYear,todayMonth,todayDay);

    //datefld3 date
    
    if (datefld3 == "")				//added 09/99
    {
		fldVal3 = todayVal
		
	}
	else
	{
	    fldVal3 = datefld3.value;
		if ( fldVal3.length == 8 )	// make / optional by converting mmddccyy to mm/dd/ccyy
		{
			fldVal3 = fldVal3.substring( 0 , 2 ) + "/" + fldVal3.substring( 2, 4 ) + "/" + fldVal3.substring( 4, 8 );
			datefld3.value = fldVal3;
		}
	}
	
    var dateVal = new Date(fldVal3);
    var todayYear = dateVal.getFullYear();
    
    var todayMonth = dateVal.getMonth();
    var todayDay = dateVal.getDate();
    dateVal3 = Date.UTC(todayYear,todayMonth,todayDay);
    
    
    //check if valid format
    if (!isValidDate(fldVal1)) 
    {
       datefld1.value = "";
       datefld1.focus();
	   return (false);
    }
    else
    {
	       
	  //datefld1 date
	  var dateVal = new Date(fldVal1);
	  var todayYear = dateVal.getFullYear();
		
	  var strYear = fldVal1.substring(6, 10);   // year
		
	  //if (IE4 == true || ((strYear < 2000) &&  NS4 == true))
	  //{
			if (daysDiff(dateVal1, todayVal) < 0)
			{
			  //date must not be greater than today
			  errorMessages("dateToday");
			  datefld1.value = "";
			  datefld1.focus();
			  return (false);
			} 
      //}
      //else
      //{
			//if (daysDiff(dateVal1, todayVal) > 0)
			//{
			  //alert(daysDiff(dateVal1, todayVal))
			  //date must not be greater than today
			  //errorMessages("dateToday");
			  //datefld1.value = "";
			  //datefld1.focus();
			  //return (false);
			//}
	  //}
		
      if ((datefld2 != "") && (datefld3 != ""))    
      {
		if (daysDiff(dateVal2, dateVal3) < 0)
        {
			//date2 must be Prior to date3
			errorMessages("datePrior23", datefld1, datefld2, datefld3);
            datefld1.value = "";
            //datefld1.focus();
            return (false);
        }
        else if ((daysDiff(dateVal2, todayVal)) < 0)
        {
			//date must not be greater than today
			errorMessages("dateToday");
			datefld2.value = "";
			datefld2.focus();
			return (false);
        }
        else if ((daysDiff(dateVal3, todayVal)) < 0)
        {
			//date must not be greater than today
			errorMessages("dateToday");
			datefld3.value = "";
			datefld3.focus();
			return (false);
        }
		else if ((isValidDate(fldVal2)) && (isValidDate(fldVal3)))
        {
          if ((daysDiff(dateVal1, dateVal2) > 0) ||
             (daysDiff (dateVal1, dateVal3) < 0))
          {
                //date must be between datefld2 and datefld3
                errorMessages("dateRange", datefld1, datefld2, datefld3);
                datefld1.focus();
                return (false);
          }
        }
      } 
		
      else if (datefld2 != "") 
      {
		    if (isValidDate(fldVal2))
        { 
          if (daysDiff(dateVal1, dateVal2) > 0)
          {
				      //date must not be prior to datefld2
              errorMessages("datePrior", datefld1, datefld2);
              datefld1.focus();
              return (false);
          }
        }

      }          
      else if (datefld3 != "")
      {
        if (isValidDate(fldVal3))
        {
          if (daysDiff(dateVal1, dateVal3) < 0) 
          { 
		      //date must not be greater than datefld3
              errorMessages("dateGreater", datefld1, datefld3);
              datefld1.focus();
              return (false);
          }
        }
      }
    }
return (true);
}



/*
'****************************************************************************
'                                 isValidDate                               
'****************************************************************************
' Purpose:          Verifies whether or not the value of a specified field  
'					on the form is a valid date, in the format              
'                   of MM/DD/CCYY and in the 20th or 21st century.                                   
'                                                                           
' Input Parameters: field --  String containing field value to check        
'                                                                           
' Returns:          True if the field is a valid date, otherwise False      
'                                                                           
' Called Routines:  errorMessages 										    
'****************************************************************************
*/

function isValidDate(field)
{	
	var nErrorCode=0;
	var strMonth = "";
	var strDelim1 = "";
	var strDay = "";
	var strDelim2 = "";
	var strYear = "";
	var strMessage = "";
	var strExample = "01/01/1998";
		
	// check length of date 
	 
	if (field != "")
	{
		if (field.length !=10)
		{
			nErrorCode=1;
			strMessage += "The date (" + field + ") must be in the following format: mm/dd/ccyy.";
			strMessage += "\nExample: " + strExample;
				
		}
		// parse string
		else 
		{
      
		strMonth = field.substring(0, 2);		// month
		strDelim1 = field.substring(2, 3);		// '/'
		strDay = field.substring(3, 5);			// day
		strDelim2 = field.substring(5, 6);		// '/'
		strYear = field.substring(6, 10);		// year
		
		//error checking
		if (strMonth<1 || strMonth>12) 
		{
			nErrorCode=1;
			strMessage += "\nMonth must be between 1 and 12.";
		}
		
		// check for alphas
		
		// valid numeric digits
		var digits = "0123456789";
		
		for (var i = 0; i < strMonth.length; i++)
		{
			if (digits.indexOf(strMonth.charAt(i)) < 0)
			{
				nErrorCode=1;
				strMessage += "\nMonth must be a number.";
			}
		}
		for (var i = 0; i < strDay.length; i++)
		{
			if (digits.indexOf(strDay.charAt(i)) < 0)
			{
				nErrorCode=1;
				strMessage += "\nDay must be a number.";
			}
		}
		for (var i = 0; i < strYear.length; i++)
		{
			if (digits.indexOf(strYear.charAt(i)) < 0)
			{
				nErrorCode=1;
				strMessage += "\nYear must be a number.";
			}
		}
		
		if ((strDelim1 != '/') || (strDelim2 != '/'))
		{
			nErrorCode = 1;
			strMessage += "\nMonth, day, and year must be separated by /."
		}
		if (strDay<1 || strDay>31) 
		{
			nErrorCode=1;
			strMessage += "\nDay must be between 1 and 31.";
		}
        if (strYear<1900 || strYear>2099) 
        {
			nErrorCode=1;
			strMessage += "\nYear must be in the 20th or 21st Century.";
		}

        // months with 30 days
        if (strMonth==4 || strMonth==6 || strMonth==9 || strMonth==11)
        {
			//alert(strDay);
			if (strDay==31) 
			{
				nErrorCode=1;
				strMessage += "\nThis month only has 30 days.";
			}
		}
	
        // February, leap year
		if (strMonth==2)
        {
			var g=parseInt(strYear/4);
			if (isNaN(g)) 
			{
				nErrorCode=1;
			}
			if (strDay>29) 
			{
				nErrorCode=1;
				strMessage += "\nLeap year Feb. only has 29 days.";
			}
	
			if (strDay==29 && ((strYear/4)!=parseInt(strYear/4))) 
			{
				nErrorCode=1;
				strMessage += "\nNon leap year Feb. only has 28 days.";
			}
		}
		}
	}
	// error handler
	if (nErrorCode==1)
    {
		alert(strMessage);
		return (false);
	}
    else
    {
        return (true);
    } 
}   



/*
'****************************************************************************
'                              daysDiff                       			    
'****************************************************************************
' Purpose:          Computes the number of days between two dates.			 
'                                                                           
' Input Parameters: field	--  date object									
'                   field2  --  date object								    
'        																	
' Returns:          number of days                                          
'                                                                           
' Called Routines:	none												    
'****************************************************************************
*/

function daysDiff(field, field2) 
{
	
	//alert (field.value);
	var DateVal1 = eval(field);
	//alert ("DateVal1 " + DateVal1);

	var DateVal2 = eval(field2);
	//alert ("DateVal2 " + DateVal2);
	
	//Compute day difference
	var TotalDays = ((DateVal2 - DateVal1) / 86400000);
	//document.forms[0].TotalDiffDays.value = TotalDays;
	//alert(TotalDays);

	return TotalDays;
}



/*
'****************************************************************************
'                              passNumValidation                            
'****************************************************************************
' Purpose:          Perform numeric validation checks on specified field.   
'                   If necessary, alert user if invalid.		            
'                                                                           
' Input Parameters: field		--  String containing number to verify                               
'					statusfield --	status field object						
'                   decimal		--  Maximum # of allowed decimal places     
'                   rangechk	--  True/False parameter whether or not to  
'									perform range checking                  
'                   rangelow	--  Low range value                         
'                   rangehigh	--  High range value                        
'                                                                           
' Returns:          True if the number is within the specified range,       
'                   otherwise False.				                        
'                                                                           
' Called Routines:  isValidNumField                                         
'                   isValidNumFmt                                           
'                   isValidNumRange                                         
' 					errorMessages 		
' HISTORY:
'
' 10/19/1999 (KAA)	if field not in range, set to spaces
'								    
'****************************************************************************
*/

function passNumValidation(field, statusField, decimal, rangechk, rangelow, rangehigh)
{	
    var fldVal = field.value;         
    if (field.value == "")
    {
		return (false);
    }
    else
    {
		if (statusField != "")
		{
			var fldType = statusField.type;
			if (fldType.indexOf("select-one") >= 0)
			{
				statusField.selectedIndex = 0; 
			}
		}
    }

    if (!isValidNumField(fldVal))
    {
        field.focus();
        field.select();
        //field.value = "";
        return (false);
    } 
    
    if (!isValidNumFmt(fldVal, decimal))
    { 
		
        if (decimal == 0)
        {
			//must be a whole number
			errorMessages("notwholenum");
			field.focus();
			field.select();
			return (false);
        }
        else
        {
			//required number of decimal
			errorMessages("maxdecimal", decimal);
			field.focus();
			field.select();
			return (false);
        }
    }     
     
    if ((rangechk) && (!isValidNumRange(fldVal, rangelow, rangehigh))) 
    {
		//must fall between rangelow and rangehigh	
		errorMessages("invalidrange", rangelow, rangehigh);
		//field.focus();		//Commented out NS:1/9/03 WO 67888
		//Added NS:1/9/03 WO 67888
		if(fldVal < rangelow) {field.value = rangelow;}
		if(fldVal > rangehigh) {field.value = rangehigh;} 
		field.select();
		//field.value = "";	
		return (false);
    }
    
return (true);
}



/*
'****************************************************************************
'                              isValidNumField                              
'****************************************************************************
' Purpose:          Verify that a specified field on the form contains a    
'                   numeric entry.  Alerts user if the field                
'                   contains non-numeric data.                              
'                                                                           
' Input Parameters: fieldname --  String containing number to verify                                 
'                                                                           
' Returns:          True if the field contains a numeric entry, otherwise   
'                   False                                                   
'                                                                           
' Called Routines:  errorMessages 																				    
'****************************************************************************
*/

function isValidNumField(fieldname)
{
  for (var i=0; i < fieldname.length; i++)
  {
	var digit = fieldname.charAt(i)
	if (digit != ".")
	{
		if (digit < "0" || digit > "9")
		{
			if (digit == ",")
			{
				//leave out commas
				errorMessages("nocommas");
				return (false);
			} 
			else
			{
				//not numeric
				errorMessages("invalidNumeric");
				return (false);
			}
		}
	}
  }
  
return (true);       
}



/*   
'****************************************************************************
'                               isValidNumFmt                               
'****************************************************************************
' Purpose:          Verify that a specified field contains a valid number   
'                   format.                                                 
'                                                                           
' Input Parameters: fieldname --  String containing number to verify                                 
'                   decimal   --  Maximum # of allowed decimal places       
'                                                                           
' Returns:          True if the number is formatted properly, otherwise     
'                   False                                                   
'                                                                           
' Called Routines:  																							    
'****************************************************************************
*/

function isValidNumFmt(fieldname, decimal)
{
    //check if decimal exists in string
    
    
    var x = fieldname.length
    var i = (fieldname.indexOf(".")) + 1 
    var z = x - i
       
    if ((fieldname.indexOf(".")) < 0) 
    { 
        return (true);
    }
    else
    {
        if (decimal == 0) 
        {
            return (false);
        } 
        else
        { 
             if (z <= decimal) 
             {
                return (true);
             } 
             else
             {
                return (false);
             } 
        }    
    }
}



/*
'****************************************************************************
'                              isValidNumRange                              
'****************************************************************************
' Purpose:          Verify that a specified field contains a valid number   
'                   range.                                                  
'                                                                           
' Input Parameters: fieldname --  String containing number to verify                                  
'                   rangelow  --  Low range value                           
'                   rangehigh --  High range value                          
'                                                                           
' Returns:          True if the number is within the specified range,       
'                   otherwise False									        
'                                                                           
' Called Routines:  																							    
'****************************************************************************
*/

function isValidNumRange(fieldname, rangelow, rangehigh)
{
	var fieldvalue;
	fieldvalue = parseFloat(fieldname);

    if ((fieldvalue >= parseFloat(rangelow)) && (fieldvalue <= parseFloat(rangehigh)))
    {
        return (true);
    }
    else
    { 
        return (false);
    } 
}    

/*
'****************************************************************************
'                              isValidYear                             
'****************************************************************************
' Purpose:          Verify that a specified field contains a valid year.   
'                                             
'                                                                           
' Input Parameters: field --  date object                                  
'            
'                                                                           
' Returns:          True if the number is within the specified range,       
'                   otherwise False									        
'                                                                           
' Called Routines:  																							    
'****************************************************************************
*/

function isValidYear(field)
{
	var strYear = field.value;
	
	if (strYear != "")
	{					
		// check for alphas
		// valid numeric digits
		var digits = "0123456789";
									
		for (var i = 0; i < strYear.length; i++)
		{
			if (digits.indexOf(strYear.charAt(i)) < 0)
			{
				alert("Year must be numeric.");
				field.focus();
			}
		}
				
		// check century		
		if (strYear < 1900 || strYear > 2099) 
		{
			alert("Year must be in the 20th or 21st Century.");
			field.focus();
			return (false);
		}
		else
		{
			 return (true);
		}
	}
}


/*
'****************************************************************************
'                              CMToFtIn 	 	                            
'****************************************************************************
' Purpose:      Computes feet and inches when given 	            	    
'				centimeters.  Calculation occurs on 'on load' event.         
'                                                                           
' Input Parameters: fieldcm		--  cm object								
'      				fieldft		--	ft object								
'					fieldin		--	in object							    
'					statusfield --	status field object						
'                   decimal		--  Maximum # of allowed decimal places     
'                   rangechk	--  True/False parameter whether or not to  
'									perform range checking                  
'                   rangelow	--  Low range value                         
'                   rangehigh	--  High range value                        	
'        									       							
' Returns:          set fields                                              
'                                                                           
' Called Routines:  passNumValidation	
'
' HISTORY:
'
' 10/14/1999 (KAA)	set 'fieldft' object to zero when computation results 
'					only inches		
' 10/19/1999 (KAA)	set feet and inches to spaces if cm is spaces; if inches
'					equals 12 than add one to feet and set inches to 0								
'****************************************************************************
*/

function CMToFtIn(fieldcm, fieldft, fieldin, fieldstatus, decimal, rangechk, rangelow, rangehigh) 
{
	if (fieldcm.value == "" && fieldft.value != "" && fieldin.value != "")
	{
		fieldft.value = "";
		fieldin.value = "";
	}
	else
	{
	if (passNumValidation(fieldcm, fieldstatus, decimal, rangechk, rangelow, rangehigh))
	{
		fieldft.value = "";
		fieldin.value = "";
		var allin = (eval(fieldcm.value) / 2.54);
		var FTval = parseInt((allin / 12));
		var INval = Math.round((allin - (FTval * 12)));
				
		if (INval == 12)
		{
			FTval = (FTval + 1);
			fieldin.value = "0";
		}
		else
		{
    		fieldin.value = (INval);
		}
    	
		if (FTval != 0)
		{
			fieldft.value = (FTval);
		}
		else
		{
			fieldft.value = 0;
			if (fieldstatus != "")
			{
				var fldType = fieldstatus.type;
				if (fldType.indexOf("select-one") >= 0)
				{
					fieldstatus.selectedIndex = 0;    
				}
			}
		}
		
	}
	}
}



/*
'****************************************************************************
'                              FtInToCmFT 	 	                            
'****************************************************************************
' Purpose:      Computes centimeters given feet				 				
'				Calculation occurs on 'on load' event. 		                 
'																			
' Input Parameters: fieldcm		--  cm object								
'      				fieldft		--	ft object								
'					fieldin		--	in object							    
'					statusfield --	status field object						
'                   decimal		--  Maximum # of allowed decimal places     
'                   rangechk	--  True/False parameter whether or not to  
'									perform range checking                  
'                   rangelow	--  Low range value                         
'                   rangehigh	--  High range value                        	
'        									       							
' Returns:          set fields                                              
'                                                                           
' Called Routines:  passNumValidation	
' 
' HISTORY:
'
' 10/08/1999 (KAA)	added select() code when value equals spaces	
' 08/05/2002 (NHS)  added max limit code								
'****************************************************************************
*/

function FtInToCmFT(fieldcm, fieldft, fieldin, fieldstatus, decimal, rangechk, rangelow, rangehigh) 
{

	if (passNumValidation(fieldft, fieldstatus, decimal, rangechk, rangelow, rangehigh) || fieldft.value == "")
	{
		//if (passNumValidation(fieldin, fieldstatus, decimal, rangechk, rangelow, rangehigh))
		//{	
		if (fieldft.value == "")
		{
			fieldft.value = 0;
		}
		
		var FTval = eval(fieldft.value);
		//alert ("FTval = "  + FTval);
		
		//set inches value to 0 until entered
		if (fieldin.value == "")
		{
			fieldin.value = 0;
			fieldin.select();
		}
						
		var INval = eval(fieldin.value);
		//alert ("INval = "  + INval);
		var Subval = FTval * 12;
		var CMval = ((Subval + INval) * 2.54);
		//alert ("CMval = "  + CMval);
		//if (CMval > cmrangehigh) { CMval = cmrangehigh; }  //Added to limit NS:8/2/02
		//if (FTval == 7 && INval > 5) { fieldin.value = 5 }  //Added to limit NS:8/5/02
		
		// convert value to string
		var CMstr = CMval.toString();
		//alert ("CMstr = "  + CMstr);

		// add one to get actual decimal placement since start with zero
    	var i = (CMstr.indexOf(".")) + 1;
		//alert ("i = "  + i);
		
     	// carry out to five (5) decimals for rounding
		var z = CMstr.substring(i, i + 5);
		//alert ("Z = "  + z);

		// check if fifth decimal needs rounding
		var start = 4;
		
		if (z.substring(start, start + 1) >= 5)
		{
			// get number before decimal
			var string1 = CMstr.substring(0, i);
			//alert ("string1 = " + string1);			
			
			// get fourth decimal
			var CMrnd = z.substring(0, 4);
			//alert ("CMrnd = " + CMrnd);
			
			// create new number and add .0001
			var CMval = eval(string1 + CMrnd);
			var CMval = CMval + .0001
			//alert ("CMval = " + CMval);
				
		}
		else
		{
			// no rounding needed; carry to four decimals
			var string1 = CMstr.substring(0, i);
			var string2 = z.substring(0, 4);
			var CMval = string1 + string2;
			//alert ("CMval = " + CMval);

		}

		fieldcm.value = CMval;
		if (fieldstatus != "")
		{
			if (fieldstatus.options[fieldstatus.selectedIndex].value.length != 0)
			{
				fieldstatus.selectedIndex = 0;    
			}
		}
	}
}



/*
'****************************************************************************
'                              FtInToCmIN 	 	                            
'****************************************************************************
' Purpose:      Computes centimeters given inches.   		 				
'				Calculation occurs on 'on load' event. 		                 
'																			
' Input Parameters: fieldcm		--  cm object								
'      				fieldft		--	ft object								
'					fieldin		--	in object							    
'					statusfield --	status field object						
'                   decimal		--  Maximum # of allowed decimal places     
'                   rangechk	--  True/False parameter whether or not to  
'									perform range checking                  
'                   rangelow	--  Low range value                         
'                   rangehigh	--  High range value                        	
'        									       							
' Returns:          set fields                                              
'                                                                           
' Called Routines:  passNumValidation	
'
' HISTORY:
'
' 08/05/2002 (NHS)  added max limit code and parameter for cm max										
'****************************************************************************
*/

function FtInToCmIN(fieldcm, fieldft, fieldin, fieldstatus, decimal, rangechk, rangelow, rangehigh, cmrangehigh) 
{
	if (passNumValidation(fieldin, fieldstatus, decimal, rangechk, rangelow, rangehigh) || fieldin.value == "")
	{
		//if (passNumValidation(fieldin, fieldstatus, decimal, rangechk, rangelow, rangehigh))
		//{	
		
		//check if feet value entered
		if (fieldft.value == "")
		{
			fieldft.value = 0;
			var FTval = eval(fieldft.value);
		}
		else
		{
			var FTval = eval(fieldft.value);
		}
		//alert("testing ignore.")
		//check if feet value entered
		if (fieldin.value == "")
		{
			fieldin.value = 0;
		}	
		
		//alert ("FTval = "  + FTval);
		var INval = eval(fieldin.value);
		//alert ("INval = "  + INval);
		var Subval = FTval * 12;
		var CMval = ((Subval + INval) * 2.54);
		//alert ("CMval = "  + CMval);
		if (CMval > cmrangehigh) { 
			CMval = cmrangehigh; 
			fieldin.value = Math.round((CMval / 2.54) - (parseInt((CMval / 2.54) / 12) * 12));
		}  //Added to limit NS:8/2/02
		
		// convert value to string
		var CMstr = CMval.toString();
		//alert ("CMstr = "  + CMstr);

		// add one to get actual decimal placement since start with zero
    	var i = (CMstr.indexOf(".")) + 1;
		//alert ("i = "  + i);
		
     	// carry out to five (5) decimals for rounding
		var z = CMstr.substring(i, i + 5);
		//alert ("Z = "  + z);

		// check if fifth decimal needs rounding
		var start = 4;
		
		if (z.substring(start, start + 1) >= 5)
		{
			// get number before decimal
			var string1 = CMstr.substring(0, i);
			//alert ("string1 = " + string1);			
			
			// get fourth decimal
			var CMrnd = z.substring(0, 4);
			//alert ("CMrnd = " + CMrnd);
			
			// create new number and add .0001
			var CMval = eval(string1 + CMrnd);
			var CMval = CMval + .0001
			//alert ("CMval = " + CMval);
				
		}
		else
		{
			// no rounding needed; carry to four decimals
			var string1 = CMstr.substring(0, i);
			var string2 = z.substring(0, 4);
			var CMval = string1 + string2;
			//alert ("CMval = " + CMval);

		}

		fieldcm.value = CMval;
		if (fieldstatus != "")
		{
			if (fieldstatus.options[fieldstatus.selectedIndex].value.length != 0)
			{
				fieldstatus.selectedIndex = 0;    
			}
		}
	}
}



/*
'****************************************************************************
'                              KgToLb 	 	 								
'****************************************************************************
' Purpose:      Computes pounds when given kilograms.  Calculation          
'				occurs on 'on load' event. 								     
'                                                                           
' Input Parameters: fieldkg		--  kg object								
'					fieldlb		--	lb object							    
'					statusfield --	status field object						
'                   decimal		--  Maximum # of allowed decimal places     
'                   rangechk	--  True/False parameter whether or not to  
'									perform range checking                  
'                   rangelow	--  Low range value                         
'                   rangehigh	--  High range value                        	
'        									       							
' Returns:          set fields                                              
'                                                                           
' Called Routines:  passNumValidation										
'****************************************************************************
*/

function KgToLb(fieldkg, fieldlb, fieldstatus, decimal, rangechk, rangelow, rangehigh, lbrangehigh) 
{	
	if (lbrangehigh == 'undefined'){//mtj added 7/30/03 to limit lb high to 400		
		lbrangehigh = 400;
	}
		
	if (passNumValidation(fieldkg, fieldstatus, decimal, rangechk, rangelow, rangehigh))
	{
		var LBval = Math.round(eval(fieldkg.value) * 2.204622621849);
		if (LBval > lbrangehigh) { 
			LBval = lbrangehigh; 
		}  //Added to limit NS:8/2/02		
		fieldlb.value = (LBval);
		
		if (fieldstatus != "")
		{
			var fldType = fieldstatus.type;
			if (fldType.indexOf("select-one") >= 0)
			{
				fieldstatus.selectedIndex = 0;    
			}
		}
	}

}



/*
'****************************************************************************
'                              LbToKg	 	 								
'****************************************************************************
' Purpose:     Computes kilograms when given pounds. Calculation	        
'			   occurs on 'on load' event. 									 
'                                                                           
' Input Parameters: fieldkg		--  kg object								
'					fieldlb		--	lb object							    
'					statusfield --	status field object						
'                   decimal		--  Maximum # of allowed decimal places     
'                   rangechk	--  True/False parameter whether or not to  
'									perform range checking                  
'                   rangelow	--  Low range value                         
'                   rangehigh	--  High range value                        	
'        									       							
' Returns:          set fields                                              
'                                                                           
' Called Routines:  passNumValidation										
'****************************************************************************
*/
function LbToKg(fieldlb, fieldkg, fieldstatus, decimal, rangechk, rangelow, rangehigh) 
{

	if (passNumValidation(fieldlb, fieldstatus, decimal, rangechk, rangelow, rangehigh))
	{
		var KGval = fieldlb.value / 2.204622621849;

		// convert value to string
		var KGstr = KGval.toString();
		//alert (KGstr);

		// add one to get actual decimal placement since start with zero
    	var i = (KGstr.indexOf(".")) + 1;
		
    	// carry out to four (4) decimals for rounding
		var z = KGstr.substring(i, i + 4);
		//alert ("z  = " + z);		

		// check if fourth decimal needs rounding
		var start =3;
		
		if (z.substring(start, start + 1) >= 4)
		{
			// get number before decimal
			var string1 = KGstr.substring(0, i);
			//alert ("string1 = " + string1);
			
			// get third decimal
			var KGrnd = z.substring(0, 3);
			//alert ("KGrnd = " + KGrnd);
									
			// create new number and add .0001
			var KGval = eval(string1 + KGrnd);
			
			//after addition, truncate to 3 decimals
			var KGval = KGval + .001;
			//alert("KGval after addition = " + KGval);
			// convert value to string
			var KGval = KGval.toString();
			var i = (KGval.indexOf(".")) + 1;
    		KGval = KGval.substring(i, i + 3);
    		KGval = eval(string1 + KGval)
			//alert ("KGval1 = " + KGval);
									
		}
		else
		{

			// no rounding needed; carry to four decimals
			var string1 = KGstr.substring(0, i);
			var string2 = z.substring(0, 4);
			var KGval = string1 + string2;
			//alert ("KGval = " + KGval);
			
		}
    	
		fieldkg.value = (KGval);
		//alert ("KGval2 = " + KGval);
		if (fieldstatus != "")
		{
			if (fieldstatus.options[fieldstatus.selectedIndex].value.length != 0)
			{
				fieldstatus.selectedIndex = 0;   
			} 
		} 
	}
}



/*
'****************************************************************************
'                              ageCalc	 	 	                
'****************************************************************************
' Purpose:				calculate age of person  								           
'                                                                           
' Input Parameters: 	date of birth				 			          
'      		  									    
'	           										    
'        											    
' Returns:				age   									    
'                                                                           
' Called Routines:  		                                       	    
'****************************************************************************
*/

function ageCalc(field)
{
	//Date of Birth
	var dobValue = new Date(field.value);
	var dobYear = dobValue.getFullYear();
	var dobMonth = (dobValue.getMonth() + 1);
	var dobDay = dobValue.getDate();

	//today's date    
	var today = new Date();
	var todayYear = today.getFullYear();
		
	//today - 18 years
	var backDateYear = (todayYear - 18);
	if (backDateYear < 100)
	{
		backDateYear += 1900;
	}
	var backDateMonth = (today.getMonth() + 1);
	var backDateDay = today.getDate();
	
	//DOB year equals year eighteen years ago
	if (eval(dobYear) == eval(backDateYear))
	{
	
			//patient has passed birthday month (>18)
		if (eval(dobMonth) < eval(backDateMonth)){
		
			var years = (todayYear - dobYear);
			return (years);		
		}
			//patient is in birthdate month (may be 18 depending on current day)
		else if (eval(dobMonth) == eval(backDateMonth))
		{	
				//patient has not passed birthday day (<18)
			if (eval(dobDay) > eval(backDateDay))
			{
				var years = ((todayYear - dobYear) - 1);
				return (years);
			}
				//patient has passed birthday (>18)
			else
			{
				var years = (todayYear - dobYear);
				return (years);
			}
		}
			//patient has not reached birthday month (<18)
		else
		{
			var years = ((todayYear - dobYear) - 1);
			return (years);
		}
	}
	else
	{
		if (eval(dobMonth) == eval(backDateMonth))
		{
			if (eval(dobDay) > eval(backDateDay))
			{
				var years = ((todayYear - dobYear) - 1);
				return (years);
			}
			else
			{
				var years = (todayYear - dobYear);
				return (years);
			}
		}
		else
		{		
			if (eval(dobMonth) > eval(backDateMonth))
			{
				var years = ((todayYear - dobYear) - 1);
				return (years);
			}
			else
			{
				var years = (todayYear - dobYear);	
				return (years);
			}
		}
	}
}

/*
'****************************************************************************
'                              ageCalcOther	 	 	                
'****************************************************************************
' Purpose:				calculate age of person  								           
'                                                                           
' Input Parameters: 	field: date of birth 		 			          
'      		  			field2: other date						    
'	           										    
'        											    
' Returns:				age   									    
'                                                                           
' Called Routines:  		                                       	    
'****************************************************************************
*/

function ageCalcOther(field, field2)
{
	//Date of Birth
	var dobValue = new Date(field.value);
	var dobYear = dobValue.getFullYear();
	var dobMonth = (dobValue.getMonth() + 1);
	var dobDay = dobValue.getDate();

	//OTHER date    
	var other = new Date(field2.value);
	var otherYear = other.getFullYear();
		
	//OTHER - 18 years
	var backDateYear = (otherYear - 18);
	if (backDateYear < 100)
	{
		backDateYear += 1900;
	}
	var backDateMonth = (other.getMonth() + 1);
	var backDateDay = other.getDate();
	
	//DOB year equals year eighteen years ago
	if (eval(dobYear) == eval(backDateYear))
	{
	
			//patient has passed birthday month (>18)
		if (eval(dobMonth) < eval(backDateMonth)){
		
			var years = (otherYear - dobYear);
			return (years);		
		}
			//patient is in birthdate month (may be 18 depending on other day)
		else if (eval(dobMonth) == eval(backDateMonth))
		{	
				//patient has not passed birthday day (<18)
			if (eval(dobDay) > eval(backDateDay))
			{
				var years = ((otherYear - dobYear) - 1);
				return (years);
			}
				//patient has passed birthday (>18)
			else
			{
				var years = (otherYear - dobYear);
				return (years);
			}
		}
			//patient has not reached birthday month (<18)
		else
		{
			var years = ((otherYear - dobYear) - 1);
			return (years);
		}
	}
	else
	{
		if (eval(dobMonth) == eval(backDateMonth))
		{
			if (eval(dobDay) > eval(backDateDay))
			{
				var years = ((otherYear - dobYear) - 1);
				return (years);
			}
			else
			{
				var years = (otherYear - dobYear);
				return (years);
			}
		}
		else
		{		
			if (eval(dobMonth) > eval(backDateMonth))
			{
				var years = ((otherYear - dobYear) - 1);
				return (years);
			}
			else
			{
				var years = (otherYear - dobYear);	
				return (years);
			}
		}
	}
}

/*
'****************************************************************************
'                              passTimeValidation                           *
'****************************************************************************
' Purpose:          Perform full Time validation checks and formatting on a *
'                   Time field.  Show error(s) on screen                    *
'                                                                           *
' Input Parameters: field    --  String containing fieldname containing     *
'                                Time to check                              *
'                   fmthr    --  Integer containing True if time is in      *
'                                 24 hr format; False if time is in 12 hr   *
'                                 format.                                   *
'                   									    *
' Returns:          True if the Time passes all validation checks,          *
'                   otherwise False                                         *
'                                                                           *
' Called Routines:                                             		    *
'****************************************************************************
*/

function passTimeValidation(field, hrfmt)
{
    var fldVal = field.value
    var fldLen = fldVal.length
    var hr = 0    
    var min = 0 
    
    if (fldVal != "")
	{

	   if ( fldLen == 4 )	// make : optional by converting hhmm to hh:mm
	   {
		fldVal = fldVal.substring( 0 , 2 ) + ":" + fldVal.substring( 2, 4 );
		field.value = fldVal;
		fldLen = fldVal.length;
	   }
	
	   if ( ((fldLen != 5) || (fldVal.charAt(2)) != ":") ) 
       {
       
		if ( hrfmt )
			errorMessages("invalidTime24");
		else
			errorMessages("invalidTime12");
			
        field.focus();
        return (false);
       }
	

    for (var y = 0; y < fldLen; y++)
    {
     if (y != 2)
     {
       var digit = fldVal.charAt(y)
       if (digit < "0" || digit > "9")
       {
          errorMessages("invalidTimeChar", digit);
          field.focus();
          return (false);
       }
     }
    }
 
    hr = parseInt(fldVal.substring(0,2))
    min = parseInt(fldVal.substring(3,5))
        
    if ((hrfmt == true) && ((min > 59) || (hr > 23))) 
    {
        errorMessages("invalidTime24");
        field.focus();
        return (false);
    }
    else if ((hrfmt == false) && ((min > 59) || (hr > 12)))
    {
        errorMessages("invalidTime12");
        field.focus();
        return (false);
    }
    else
    {
        return (true);
    }
    
    } //ending bracket for first if check
}  

/*
'****************************************************************************
'                              FutureDateValidation                               
'****************************************************************************
' Purpose:          Perform full date validation and range checks on a date 
'                   field.  If necessary, alert user if invalid date or     
'                   format.                                                 
'                                                                           
' Input Parameters: datefld1  --  reference to date object                  
'                   datefld2  --  low date range     D1 => D2               
'                   datefld3  --  high date range    D1 <= D3               
'  																		          
' Returns:          True if the field is a valid date, otherwise False		                                    
'                                                                           
' Called Routines:  isValidDate                                             
'                   daysDiff                                                
' 					errorMessages 	
' HISTORY:
'
' 05/26/2000 (AMN)	Created from DateValidation.  
'											 
'****************************************************************************
*/

function FutureDateValidation(datefld1, datefld2, datefld3) 
{
	var NS4 = (document.layers) ? true : false;
	var IE4 = (document.all) ? true : false;

	//get date values passed
    fldVal1 = datefld1.value;
    fldVal2 = datefld2.value;
    fldVal3 = datefld3.value;
    	
    	
    //today's date    
    var today = new Date();
    var todayYear = today.getFullYear();
        
    var todayMonth = today.getMonth();
    var todayDay = today.getDate();
    todayVal = Date.UTC(todayYear,todayMonth,todayDay);
    
   
    //datefld1 date
	var dateVal = new Date(fldVal1);
    var todayYear = dateVal.getFullYear();
    
    var todayMonth = dateVal.getMonth();
    var todayDay = dateVal.getDate();
    dateVal1 = Date.UTC(todayYear,todayMonth,todayDay);


    //datefld2 date
    var dateVal = new Date(fldVal2);
    var todayYear = dateVal.getFullYear();
    
    var todayMonth = dateVal.getMonth();
    var todayDay = dateVal.getDate();
    dateVal2 = Date.UTC(todayYear,todayMonth,todayDay);

	//05/24/00   AMN   Commented
    //datefld3 date    
    //if (datefld3 == "")				//added 09/99
    //{
	//	fldVal3 = todayVal
	//}
	
    var dateVal = new Date(fldVal3);
    var todayYear = dateVal.getFullYear();
    
    var todayMonth = dateVal.getMonth();
    var todayDay = dateVal.getDate();
    dateVal3 = Date.UTC(todayYear,todayMonth,todayDay);
    
   
    //check if valid format
    if (!isValidDate(fldVal1)) 
    {
       datefld1.value = "";
       datefld1.focus();
	   return (false);
    }
    else
    {
	       
	  //datefld1 date
	  var dateVal = new Date(fldVal1);
	  var todayYear = dateVal.getFullYear();
		
	  var strYear = fldVal1.substring(6, 10);   // year
		
	  //if (IE4 == true || ((strYear < 2000) &&  NS4 == true))
	  //{
	  //		if (daysDiff(dateVal1, todayVal) < 0)
	  //		{
	  //		  //date must not be greater than today
	  //		  errorMessages("dateToday");
	  //		  datefld1.value = "";
	  //		  datefld1.focus();
	  //		  return (false);
	  //		} 
      //}
      //else
      //{
			//if (daysDiff(dateVal1, todayVal) > 0)
			//{
			  //alert(daysDiff(dateVal1, todayVal))
			  //date must not be greater than today
			  //errorMessages("dateToday");
			  //datefld1.value = "";
			  //datefld1.focus();
			  //return (false);
			//}
	  //}
		


      if ((datefld2 != "") && (datefld3 != ""))    
      {
		if (daysDiff(dateVal2, dateVal3) < 0)
        {
			//date2 must be Prior to date3
			errorMessages("datePrior23", datefld1, datefld2, datefld3);
            datefld1.value = "";
            //datefld1.focus();
            return (false);
        }
/*        else if ((daysDiff(dateVal2, todayVal)) < 0)
        {
			//date must not be greater than today
			errorMessages("dateToday");
			datefld2.value = "";
			datefld2.focus();
			return (false);
        }
        else if ((daysDiff(dateVal3, todayVal)) < 0)
        {
			//date must not be greater than today
			errorMessages("dateToday");
			datefld3.value = "";
			datefld3.focus();
			return (false);
        }
*/
		else if ((isValidDate(fldVal2)) && (isValidDate(fldVal3)))
        {
          if ((daysDiff(dateVal1, dateVal2) > 0) ||
             (daysDiff (dateVal1, dateVal3) < 0))
          {
                //date must be between datefld2 and datefld3
                errorMessages("dateRange", datefld1, datefld2, datefld3);
                datefld1.focus();
                return (false);
          }
        }
      } 
		
      else if (datefld2 != "") 
      {
		    if (isValidDate(fldVal2))
        { 
          if (daysDiff(dateVal1, dateVal2) > 0)
          {
				//date must not be prior to datefld2
                errorMessages("datePrior", datefld1, datefld2);
                datefld1.focus();
                return (false);
          }
        }

      }          
      else if (datefld3 != "")
      {
        if (isValidDate(fldVal3))
        {
          if (daysDiff(dateVal1, dateVal3) < 0) 
          { 
				//date must not be greater than datefld3
                errorMessages("dateGreater", datefld1, datefld3);
                datefld1.focus();
                return (false);
          }
        }
      }
      
//---       
    }
return (true);
}	  

/*
'****************************************************************************
'                              ExpectedRangeWarn                               
'****************************************************************************
' Purpose:          Perform numeric validation checks on specified field.   
'                   If necessary, alert user if exceeds normal expected range
'                   or is invalid.		            
'                                                                           
' Input Parameters: field		--  String containing number to verify                               
'					          statusfield --	status field object						
'                   decimal		--  Maximum # of allowed decimal places     
'                   rangelow	--  Low range value                         
'                   rangehigh	--  High range value
'                   warnlow   --  Low range of normal expected range
'                   warnhigh  --  High range of normal expected range
'                   displayName -- Field name to be displayed back to user in message
'                                                                           
' Returns:          True if the number is within the specified range,       
'                   otherwise False.				                        
'                                                                           
' Called Routines:  passNumValidation
'
' HISTORY:
'
' 01/10/2001 (KMCG)	Initial Implementation
'								    
'****************************************************************************
*/

function ExpectedRangeWarn(field,statusField,decimal,rangelow,rangehigh,warnlow,warnhigh,displayName)
{
    var fldVal = field
    var sfldVal = statusField
    var decVal = decimal
    var rlowVal = rangelow
    var rhiVal = rangehigh
    var wlow = warnlow
    var whi = warnhigh
    var wlowVal = eval(wlow)
    var whiVal = eval(whi)
    var dispName = displayName

//if field is empty
   if(fldVal.value=="")
   {
    return (false);
   }
   else
   {
        //It must pass validation
        if (!passNumValidation(fldVal, sfldVal, decVal, true, rlowVal, rhiVal))
        {
            field.focus();
            field.select();
            //field.value = "";
            return (false);
        } 
        else
        {
            //check if value falls within expected range
            if(fldVal.value<wlowVal || fldVal.value >whiVal)
            {
                //if value falls outside range user needs to confirm value is correct
                if(confirm("WARNING: \nThe "+dispName+" value falls outside the expected normal range of "+wlowVal+" - "+whiVal+ "\nPlease verify this "+dispName+" value.\nPress OK if "+fldVal.value+" is correct."))
                {
                 return (true);
                }
                else
                {
                    field.focus();
                    field.select();
                    return (false);
                }
            }
        }
   }

}




/*
'****************************************************************************
'                              passNumValidationWithChild                            
'****************************************************************************
' Purpose:          Perform numeric validation checks on specified field.  
'                    used on thoracic TCR for hemo fields
'                     that have child vasodialator Y/N fields
'                   If necessary, alert user if invalid.		            
'                                                                           
' Input Parameters: field		--  String containing number to verify                               
'					statusfield --	status field object			
'					childfield   -- Y/N radio object, na if status field has value			
'                   decimal		--  Maximum # of allowed decimal places     
'                   rangechk	--  True/False parameter whether or not to  
'									perform range checking                  
'                   rangelow	--  Low range value                         
'                   rangehigh	--  High range value                        
'                                                                           
' Returns:          True if the number is within the specified range,       
'                   otherwise False.				                        
'                                                                           
' Called Routines:  isValidNumField                                         
'                   isValidNumFmt                                           
'                   isValidNumRange                                         
' 					errorMessages 		
' HISTORY:
'
' 01/24/01  GK		initial, modification of PassNumValidation
'								    
'****************************************************************************
*/

function passNumValidationWithChild(field, statusField, childfield, decimal, rangechk, rangelow, rangehigh)
{
	
    var fldVal = field.value;         
    if (field.value == "")
    {
		return (false);
    }
    else
    {
		if (statusField != "")
		{
			var fldType = statusField.type;
			if (fldType.indexOf("select-one") >= 0)
			{
				statusField.selectedIndex = 0; 
			}
		}
		childfield[0].disabled = false;
		childfield[1].disabled = false;
    }

    if (!isValidNumField(fldVal))
    {
        field.focus();
        field.select();
        //field.value = "";
        return (false);
    } 
    
    if (!isValidNumFmt(fldVal, decimal))
    { 
		
        if (decimal == 0)
        {
			//must be a whole number
			errorMessages("notwholenum");
			field.focus();
			field.select();
			return (false);
        }
        else
        {
			//required number of decimal
			errorMessages("maxdecimal", decimal);
			field.focus();
			field.select();
			return (false);
        }
    }     
     
    if ((rangechk) && (!isValidNumRange(fldVal, rangelow, rangehigh))) 
    {
		//must fall between rangelow and rangehigh	
		errorMessages("invalidrange", rangelow, rangehigh);
		field.focus();
		field.select();
		//field.value = "";	
		return (false);
    }
    
return (true);
}


/*
'****************************************************************************
'                              intAgeInMonthsCalc                           
'****************************************************************************
' Purpose:          Calculates the Age in months between two date fields
'                                                                           
' Input Parameters: field   -- The earlier date field
'                   field2	-- The later date field                   
'                                                                           
' Returns:          Age in months as an integer
'                   
'                                                                           
' Called Routines:  
'                   
'                   
' 					
' HISTORY:
'
' 02/2001  MCTIER	Initial Implementation
'								    
'****************************************************************************
*/

	function intAgeInMonthsCalc( field , field2 )
	{
	var dobValue = new Date( field.value )
	var intMonths = parseInt( 0 );
	var dobYear  = dobValue.getFullYear();
	var dobMonth = ( dobValue.getMonth() + 1 );
	var dobDay  = dobValue.getDate();
			
	var todayValue = new Date( field2.value )
	var todayYear  = todayValue.getFullYear();
	var todayMonth = ( todayValue.getMonth() + 1 );
	var todayDay  = todayValue.getDate();
	
	if ( eval( dobYear ) == eval( todayYear ) )
	{
		if ( eval( dobMonth ) == eval( todayMonth ) )
		{
			intMonths = 0;
		}
		else if ( eval( dobMonth ) < eval( todayMonth ) )
		{
			if ( eval( dobDay ) <= eval( todayDay ) )
			{
				intMonths = eval( todayMonth ) - eval( dobMonth );
			}
			else
			{
				intMonths = eval( todayMonth ) - eval( dobMonth ) - 1;
			}
		}
		else
		{
			intMonths = 0;
		}
	}
	else if ( eval( dobYear ) < eval( todayYear ) )
	{
		intMonths = ( eval( todayYear  ) - eval( dobYear ) - 1 )*12;
		if ( eval( dobMonth ) == eval( todayMonth ) )
		{
			if ( eval( dobDay ) <= eval( todayDay ) )
			{
				intMonths = intMonths + 12;
			}
			else
			{
				intMonths = intMonths + 11;
			}
		} 
		else if ( eval( dobMonth ) < eval( todayMonth ) )
		{
			if ( eval( dobDay ) <= eval( todayDay ) )
			{
				intMonths = intMonths + ( 12 - eval( dobMonth ) ) + eval( todayMonth  ) ;
			}
			else
			{
				intMonths = intMonths + ( 12 - eval( dobMonth ) ) + ( eval( todayMonth  ) - 1 );
			}
		} 
		else
		{
			if ( eval( dobDay ) <= eval( todayDay ) )
			{
				intMonths = intMonths + ( 12 - eval( dobMonth ) ) + eval( todayMonth  ) ;
			}
			else
			{
				intMonths = intMonths + ( 12 - eval( dobMonth ) ) + ( eval( todayMonth  ) - 1 );
			}
		}
	}
	else 
	{
		intMonths = 0;
	}
	return intMonths;
	
	}




function validateInteger( strValue ) {
	var objRegExp  = /(^-?\d\d*$)/;
	return objRegExp.test(strValue);
}

function isValidEmail(field)
{
	if (field.value!="") {	
	    if(validateEmail(field.value))
		    return true;
	    alert("Please enter a valid email address");
	    field.focus();
	    return false;
	}
}
//----------------------------------------------------------------------------------
/*
function validateEmail( strValue ) {
	var objRegExp = /[\w]{1,}(@){1}([\w]{1,}(\.){1}){1,}(com|net|edu|org|gov|mil|tv){1}$/gi;
	return objRegExp.test(strValue);
}
*/
//Old validateEmail function was having problems with dashes and/or periods per WO#73249
//The new function sets up two regular expressions.  The first makes sure there is at least
//an @ and a . and that the . is after the @.  The second looks for at least 1 character before
//the @, an optional [ and ] to enclose the domain (IP Addresses), some sequence of letters, numbers,
//dashes and periods, and a 2 or 3 letter extension.  Adapted from http://www.webreference.com/js/column5/form.html
function validateEmail(strValue) {
    var reg1 = /(@.*@)|(\.\.)|(@\.)|(\.@)|(^\.)/; // not valid
    var reg2 = /^.+\@(\[?)[a-zA-Z0-9\-\.]+\.([a-zA-Z]{2,3}|[0-9]{1,3})(\]?)$/; // valid
    if (!reg1.test(strValue) && reg2.test(strValue)) { // if syntax is valid
        return true;
    }
    return false;
}

//----------------------------------------------------------------------------------
// this is another way of checking for a real date
// returns true or false
//function isValidDate(frmValue) {
	// this is based off the fact that an invalid date (like 6/31/2002) will skip over to the next month
	// when a date object is created based on that date. compare the pre-object month with the object month 
	// to know
	// date coming in in mm/dd/yyyy format; grab the month and store away for future matching
	//if (frmValue.indexOf('/') == -1) { return false; }
//	var iMonth = parseInt(frmValue.split('/')[0]);
	// create a new date object based on the date
//	var myDate =  new Date(frmValue);
//	if ((iMonth-1) != myDate.getMonth()) { return false; }
//	else { return true; }
//}

//----------------------------------------------------------------------------------
function rightTrim(str) { //Trims trailing whitespace chars.
	var objRegExp = /^([\w\W]*)(\b\s*)$/;
	
	if(objRegExp.test(str)) {
		//remove trailing a whitespace characters
		str = str.replace(objRegExp, '$1');
	}
	return str;
}
//----------------------------------------------------------------------------------
function leftTrim(str) { //Trims leading whitespace chars.
	var objRegExp = /^(\s*)(\b[\w\W]*)$/;
	
	if(objRegExp.test(str)) {
		//remove leading a whitespace characters
		str = str.replace(objRegExp, '$2');
	}
	return str;
}
//----------------------------------------------------------------------------------
function trimAll(str) { //Removes leading and trailing spaces.
	var objRegExp = /^(\s*)$/;
	
	//check for all spaces
	if(objRegExp.test(str)) {
		str = str.replace(objRegExp, '');
		if( str.length == 0)
			return str;
	}
	//check for leading & trailing spaces
	objRegExp = /^(\s*)([\W\w]*)(\b\s*$)/;
	if(objRegExp.test(str)) {
		//remove leading and trailing whitespace characters
		str = str.replace(objRegExp, '$2');
	}
	return str;
}
//----------------------------------------------------------------------------------
//submitSearch() - used on all search pages to check and submit
function submitSearch() {
	var url;
	if (document.keywordSearch.qu.value == "") {
		alert("Please enter search criteria");
		document.keywordSearch.qu.focus();
		return;
	}
	document.keywordSearch.submit();
}
//----------------------------------------------------------------------------------
// submitVote() - used on all quick vote pages to verify submission
function submitVote(){
		var form = document.forms.frmSubmitVote;
		var val = "";		
		
		for(i=0;i<form.radio1.length;i++)
		{
			if(form.radio1[i].checked==true)
				val = form.radio1[i].value;
		}
		
		if (val == "")
		{
			alert('Please Select A Yes Or No Response.');
		}	
		else
		{
			form.result.value = val;
			form.submit();				
		}		
}	
//----------------------------------------------------------------------------------
//toggleQuickVote() - expand/collapse utility for all quick vote pages.
function toggleQuickVote(id) {
		var obj = document.getElementById(id);
		
		if (obj.style.display == "none")
		{	
			obj.style.display = "block";
		} 
		
		else		
		
		{			
			obj.style.display = "none";
		}
}
//----------------------------------------------------------------------------------
function getNumeric(elmnt)
{
	elm = document.getElementById(elmnt);
	var str = elm.value;
	elm.value = str.replace(/[^\d]*/gi,"");
}
//----------------------------------------------------------------------------------
function getElement(elmnt)
{
	isNS4 = (document.layers) ? true : false;
	isIE4 = (document.all && !document.getElementById) ? true : false;
	isIE5 = (document.all && document.getElementById) ? true : false;
	isNS6 = (!document.all && document.getElementById) ? true : false;
	
	if (isNS4){
	   elm = document.layers[elmnt];
	}
	else if (isIE4) {
	   elm = document.all[elmnt];
	}
	else if (isIE5 || isNS6) {
	   elm = document.getElementById(elmnt);
	}	
	else {
		elm = document.all[elmnt];
	}
	return elm;
}
//----------------------------------------------------------------------------------
function checkEmail(strEmail) {
	var emailArr = strEmail.split(",");
	var i;
	var bln = 0;
	// create email filter regular expression & check email address
	var myRegExp = new RegExp("^[A-Za-z0-9_\.-]+@[A-Za-z0-9_\.-]+[\.][A-Za-z]+$");
		
	// loop through the email array (emailArr)
	for (i=0;i<emailArr.length;i++){
		myRegExp.test(emailArr[i]);		
		if (!myRegExp.test(emailArr[i])){
	// if the array index does not come back true then increment the counter
				bln++;
		} 
	}			
	if (bln > 0){
	// if the counter is greater than 0 return false;
		return false;
	} else {
		return true;
	}
}

function checkWeb(address) {
	var re;
	re = /(http|ftp|https):\/\/[\w]+(.[\w]+)([\w\-\.\,\@\?\^\=\%\&\:\/\~\+\#]*[\w\-\@\?\^\=\%\&\/\~\+\#])?/;
        if (re.test(address) == true)
           return true;
        else       
           return false;          
   }


function getDays(month,year) {		
	
		// create array to hold number of days in each month
		var ar = new Array(13);
		ar[1] = 31; 
		
		ar[2] = (leapYear(year)) ? 29 : 28; 		
		ar[3] = 31; 
		ar[4] = 30; 
		ar[5] = 31; 
		ar[6] = 30; 
		ar[7] = 31; 
		ar[8] = 31; 
		ar[9] = 30; 
		ar[10] = 31; 
		ar[11] = 30; 
		ar[12] = 31; 

		return ar[month];
	}

	function leapYear(intYear) {
		if (intYear % 100 == 0) {
			if (intYear % 400 == 0) { 
				return true;
			 }
		}
		else {
			if ((intYear % 4) == 0) { 
				return true;
			 }
		}
		return false;
	}


function checkDate(strDate){
    if(strDate.length>0){
		var dateregex=/^[ ]*[0]?(\d{1,2})\/(\d{1,2})\/(\d{4,})[ ]*$/;
        var match=strDate.match(dateregex);
        if (match){
			var tmpdate=new Date(match[3],parseInt(match[1],10)-1,match[2]);
			if (tmpdate.getDate()==parseInt(match[2],10) && tmpdate.getFullYear()==parseInt(match[3],10) && (tmpdate.getMonth()+1)==parseInt(match[1],10)){ 
				return true; 
			}
        }        
         return false;
    }
    else{
         return false;
    }
}

function getWordCount(content){
	var i=0;
	var numberofwords=1;
	
	while(i<=content.length) {

		if (content.substring(i,i+1) == " ") {
			numberofwords++;
			i++; 
			// extra i++ makes it skip double spaces, or space/return
		}
		if (content.substring(i,i+1) == "\n") {
			numberofwords++;
			i++;
			// extra i++ makes it skip double spaces, or space/return

		}

		i++;
	}	
	return numberofwords;	
}

// These functions are used for the Administrator approval and denial
	function confirmAdmin(ctlId){

		var section = document.getElementById(ctlId + '_adminSection'); 
		var sectionDisp = section.value;
		document.getElementById('hidCtlId').value = ctlId; 

		if (section.value == 'P')	{
			sectionDisp = 'Preferred Criteria';
			}
			
		if (!validateAdminConfirm(ctlId))	{
			return;
			}
			
		if (confirm('You are about to Confirm Section ' + sectionDisp + '. \n\n By clicking OK, you are indicating that you are completely finished reviewing this section and are ready to Confirm it.  \n\n Once confirmed, data in this review section Cannot Be Edited. \n\n Are you sure you want to confirm this section?'))	{
			document.forms[0].submit();
			}
			
			
		}
	function denyAdmin(ctlId){
	
		var section = document.getElementById(ctlId + '_adminSection'); 
		var sectionDisp = section.value;
		document.getElementById('hidCtlId').value = ctlId; 

		if (section.value == 'P')	{
			sectionDisp = 'Preferred Criteria';
			}

		if (!validateAdminDeny(ctlId))	{
			return;
			}

		if (confirm('You are about to Deny Section ' + sectionDisp + '. \n\n By clicking OK, you are indicating that you are completely finished reviewing this section and are ready to Deny it.  \n\n Once denied, data in this review section Cannot Be Edited. \n\n Are you sure you want to deny this section?'))	{
			document.forms[0].submit();
			}
		}

	function validateAdminConfirm(ctlId){
	
		var ctl = ctlId + '_'; 
		
		if (!document.getElementById(ctl + 'adminSection').value == 'IV')	{
			if (!document.getElementById(ctl + 'radSurgReqYes').checked  && !document.getElementById(ctl + 'radSurgReqNo').checked )	{
				alert('Select Yes or No for Primary and Alternate Primary Surgeon meet requirements');
				return false;
				}
			if (document.getElementById(ctl + 'radSurgReqNo').checked )	{
				if (!document.getElementById(ctl + 'radSurgExcReqYes').checked  && !document.getElementById(ctl + 'radSurgExcReqNo').checked )	{
					alert('Select Yes or No for Primary and Alternate Primary Surgeon meet exception requirements');
					return false;
					}
				}
			}
		
		// Validate the Min Score Yes/No
		if (!document.getElementById(ctl + 'radScoreYes').checked  && !document.getElementById(ctl + 'radScoreNo').checked )	{
			alert('Select Yes or No for meets minimum score');
			return false;
			}

		// Validate the Attachments Yes/No 
		if (!document.getElementById(ctl + 'radAttachYes').checked  && !document.getElementById(ctl + 'radAttachNo').checked )	{
			alert('Select Yes or No for Attachments meet requirements');
			return false;
			}

		if (document.getElementById(ctl + 'radAttachNo').checked == true)	{
			if (document.getElementById(ctl + 'txtDefDescrip').value == '') {
				alert('Enter deficiency summary');
				return false;
				}	
			}

		if (document.getElementById(ctl + 'txtReviewerScore').value != '' )	{
			if (!validateInteger(document.getElementById(ctl + 'txtReviewerScore').value)) {
				alert('Enter a valid number for the Recommended score');
				return false;
				}	
			}

		// Validate checkbox			
		if (!document.getElementById(ctl + 'chkSectionReviewed').checked )	{
			alert('Verify that you have reviewed the material');
			return false;
			}

		// Validate First name
		if (document.getElementById(ctl + 'txtFirstName').value == '' )	{
			alert('Enter your First name');
			return false;
			}

		// Validate Last name
		if (document.getElementById(ctl + 'txtLastName').value == '' )	{
			alert('Enter your Last name');
			return false;
			}

		document.getElementById(ctl + 'adminSubmit').value = 'confirm';
		return true;
		}

	function validateAdminDeny(ctlId){
	
		var ctl = ctlId + '_'; 

		if (document.getElementById(ctl + 'txtReviewerScore').value != '' )	{
			if (!validateInteger(document.getElementById(ctl + 'txtReviewerScore').value)) {
				alert('Enter a valid number for the Recommended score');
				return false;
				}	
			}

		if (document.getElementById(ctl + 'radAttachNo').checked == true)	{
			if (document.getElementById(ctl + 'txtDefDescrip').value == '') {
				alert('Enter deficiency summary');
				return false;
				}	
			}
			
		// Validate checkbox			
		if (!document.getElementById(ctl + 'chkSectionReviewed').checked )	{
			alert('Verify that you have reviewed the material');
			return false;
			}

		// Validate First name
		if (document.getElementById(ctl + 'txtFirstName').value == '' )	{
			alert('Enter your First name');
			return false;
			}

		// Validate Last name
		if (document.getElementById(ctl + 'txtLastName').value == '' )	{
			alert('Enter your Last name');
			return false;
			}

		document.getElementById(ctl + 'adminSubmit').value = 'deny';
		return true;
		}
// These functions are used for the Administrator approval and denial

function CheckZip(control){	
		var intPos;		
		if (control.value.length != 0){
			for (var i = 0; i < control.value.length; i++) {
				var digit = control.value.charAt(i)
				if (digit != "-"){
					if (digit < "0" || digit > "9")
					{
						if (digit == ",")
						{
							//leave out commas
							errorMessages("nocommas");
							control.focus();
							control.select();
							break;
						} 
						else
						{
							//not numeric
							errorMessages("invalidNumeric");
							control.focus();
							control.select();
							break;
						}
		
					}
				}
			
			}
		}
			
	}
//----------------------------------------------------------------------------------
/*=======================================================
description:

	TextCounter
	  set and monitors max lengths for textarea controls.  displays and refreshed character count down 
      object.
	
parameters:
	TextBoxID, CounterID, iMaxLimit
	
returns:
	
=======================================================*/
	function TextCounter(TextBoxID, CounterID, iMaxLimit)
	{
	try
	{
		var oTextBox = document.getElementById(TextBoxID);	// References the TextBox
		var oCounter = document.getElementById(CounterID);	// References the Counter

		var sCurValue  = oTextBox.value;
		var iCurLength = sCurValue.length;

		if (iCurLength > iMaxLimit) // if too long...trim it!
		{
			sCurValue = sCurValue.substring(0, iMaxLimit);
			oTextBox.value = sCurValue;

			alert("The text entered was greater than the maximum " + iMaxLimit + " characters allowed, and the information has been truncated.  \nPlease review and make any necessary modifications." );

			iCurLength = sCurValue.length;

			if (event.ctrlKey)
			{
				event.returnValue = false;
			}
		}

		iCurLength = iMaxLimit - iCurLength;

		while (oCounter.childNodes.length > 0)
		{
			oCounter.removeChild(oCounter.firstChild);	// Removes all child nodes from the Counter element
		}

		oCounter.appendChild(document.createTextNode("Character count: " + iCurLength + " characters remaining (" + iMaxLimit + " limit)"));	// Writes in the character count
	}
	catch(Exc)
	{
		alert("ERROR :: TextCounter ::\nError #" + Exc.number + "\nDescription: " + Exc.description);
	}
}

function deleteFellowTrain(iAwardID)
{
	var strPage = window.location.pathname;
	strPage = strPage.substring(strPage.lastIndexOf('/') + 1);
	
	if(confirm('Are you sure you want to delete this?'))
		window.location.href = strPage + "?id=" + iAwardID + "&delete=true";
}

	function isValidZipCode(obj) {			
			var valid
			if (obj.value!="") {
				var re = /^\d{5}([\-]\d{4})?$/;
				
				
				valid = (re.test(obj.value));
				if (valid==false) {
					alert('Zip code format is invalid.  Please enter a valid format.');
					obj.focus();
				}
			}
			
		}



function checkPhoneNumber(obj) { 
 var valid 
 var re = /^\d{3}-\d{3}-\d{4}$/;
 valid = (re.test(obj.value));
 	
 if (obj.value!="") {
	if (valid==false) { 
	alert('Number format is invalid.  Please enter a valid format (###-###-####).');
	obj.focus();
	} 
 }
}



	function formatDate(el, format) {
			switch (format) {
				case ('mmddyyyy'):
					if (el.value.length == 8) {       
						if (el.value.indexOf('/') < 0) {           
							var newDate;           
							newDate = el.value.substring(0,2)                        
								+ '/' + el.value.substring(2,4)                        
								+ '/' + el.value.substring(4,8);           
							el.value = newDate;       
						}
					}
					break;
				case ('mmyyyy'):
					if (el.value.length == 6) {       
						if (el.value.indexOf('/') < 0) {           
							var newDate;           
							newDate = el.value.substring(0,2)                        
							+ '/' + el.value.substring(2,6)            
							el.value = newDate;       
						}   
					}   
					break;
			}
			return;
		}




function validateDate(el, format)
		{
  			var field = el.value;
			var nErrorCode=0;
			var strMonth = '';
			var strDelim1 = '';
			var strDay = '';
			var strDelim2 = '';
			var strYear = '';
			var strMessage = '';
			var strExample = '01/01/2003';

			if (format == 'mmyyyy') strExample = '01/2003';
				
			// check length of date 
			 
			if (field != '')
			{
				if ((format == 'mmddyyyy' && field.length !=10) || (format == 'mmyyyy' && field.length != 7))
				{
					nErrorCode=1;
					strMessage += 'The date (' + field + ') must be in the following format: ' + format + '';
					strMessage += '\nExample: ' + strExample;	
				}
				// parse string
				else 
				{
		      
				switch (format) {
					case ('mmddyyyy'):
						strMonth = field.substring(0, 2);		// month
						strDelim1 = field.substring(2, 3);		// '/'
						strDay = field.substring(3, 5);			// day
						strDelim2 = field.substring(5, 6);		// '/'
						strYear = field.substring(6, 10);		// year
						break;
					case ('mmyyyy'):
						strMonth = field.substring(0, 2);		// month
						strDelim1 = field.substring(2, 3);		// '/'
						strYear = field.substring(3, 7);		// year
						break;
				}
				
				//error checking
				if (strMonth < 1 || strMonth > 12) 
				{
					nErrorCode=1;
					strMessage += '\nMonth must be between 1 and 12.';
				}
				
				// check for alphas
				
				// valid numeric digits
				var digits = '0123456789';
				
				for (var i = 0; i < strMonth.length; i++)
				{
					if (digits.indexOf(strMonth.charAt(i)) < 0)
					{
						nErrorCode=2;
					}
				}
				if (nErrorCode==2) strMessage += '\nMonth must be a number.';

				if (format != 'mmyyyy') {
					for (var i = 0; i < strDay.length; i++)
					{
						if (digits.indexOf(strDay.charAt(i)) < 0)
						{
							nErrorCode=3;
						}
					}
					if (nErrorCode==3) strMessage += '\nDay must be a number.';
				}
				for (var i = 0; i < strYear.length; i++)
				{
					if (digits.indexOf(strYear.charAt(i)) < 0)
					{
						nErrorCode=4;
					}
				}
				if (nErrorCode==4) {
					if (format == 'yyyy') {
						strMessage += '\nPlease enter only the year.';
					}
					else {
						strMessage += '\nYear must be a number.';
					}
				}

 				if (format != 'mmyyyy') {
					if ((strDelim1 != '/') || (strDelim2 != '/'))
					{
						nErrorCode = 1;
						strMessage += '\nMonth, day, and year must be separated by /.'
					}
					if (strDay < 1 || strDay > 31) 
					{
						nErrorCode=1;
						strMessage += '\nDay must be between 1 and 31.';
					}
				}
        			if (strYear < 1900 || strYear > 2099) 
        			{
					nErrorCode=1;
					strMessage += '\nYear must be in the 20th or 21st Century.';
				}

				if (format != 'mmyyyy') {
        				// months with 30 days
        				if (strMonth==4 || strMonth==6 || strMonth==9 || strMonth==11)
        				{
						//alert(strDay);
						if (strDay==31) 
						{
							nErrorCode=1;
							strMessage += '\nThis month only has 30 days.';
						}
		  			}
				}

        		// February, leap year
				if (strMonth==2)
        			{
					var g=parseInt(strYear/4);
					if (isNaN(g)) 
					{
						nErrorCode=1;
					}
					if (strDay > 29) 
					{
						nErrorCode=1;
						strMessage += '\nLeap year Feb. only has 29 days.';
					}

					if (strDay==29 && ((strYear/4)!=parseInt(strYear/4))) 
					{
						nErrorCode=1;
						strMessage += '\nNon leap year Feb. only has 28 days.';
					}
				}
				}
			}
			// error handler
			if (nErrorCode >=1)
    		{
				alert(strMessage);
				el.value = '';
				el.focus();
				return (false);
			}
    		else
    		{
        		return (true);
    		}
		}
		
			function validateDateRange(el, label, format, lowVal, highVal, lowValDisplay, highValDisplay) {
			if (label == '') label = 'This date';
			switch (format) {
				case ('mmyyyy'):
					var val = new Date(insertDays(el.value));
					var high = new Date(insertDays(highVal));
					var low = new Date(insertDays(lowVal));
					break;
				default:
					var val = new Date(el.value);
					var high = new Date(highVal);
					var low = new Date(lowVal);
					break;
			}
			if (val != '') {
				if (highVal) {
					if (val.valueOf() > high.valueOf()) {
						alert(label + ' must be before ' + highValDisplay + '.');
						el.value = '';
						el.focus();
						return false;
					}
				}
				if (lowVal) {
					if (val.valueOf() < low.valueOf()) {
						alert(label + ' must be after ' + lowValDisplay + '.');
						el.value = '';
						el.focus();
						return false;
					}
				}
			}
			return true;
		}