// Last Updated: 12/12/2002 by S. Tobias
// Added Signed Currency datatype
//
// Updated: 09/16/2002 by WMP
// Added SSN validation
//
// Updated: 08/19/2002 by WMP
// Added semicolons to those statements that didn't have any 
//
// Updated: 08/15/2002 by WMP
// Updated the validate function to impose character limitations for text fields
//


    
var digits = "0123456789";
var lowercaseletters = "abcdefghijklmnopqrstuvwxyz";
var uppercaseletters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var positivenegative = "+-";
var whitespace = " \t\n\r";
var decimaldelimiter = ".";
var phonedelimiters = "()-. ";
var currencydelimiters = "$, ";
var percentdelimiters = "%, ";
var numberdelimiters = ", ";
var zipcodedelimiters = "-";
var ssndelimiters = "- ";
var statedelimiter = "|";
var phonecharacters = digits + phonedelimiters;
var zipcodecharacters = digits + zipcodedelimiters;
var mindigitsinphonenumber = 10;
var maxdigitsinphonenumber = 15;
var digitsinzipcode1 = 5;
var digitsinzipcode2 = 9;
var digitsinssn = 9;

var ValidationTypes = new Array(12);
ValidationTypes[0] = "Integer";
ValidationTypes[1] = "Alphabetic Value";
ValidationTypes[2] = "Alphanumeric Value";
ValidationTypes[3] = "Float";
ValidationTypes[4] = "Currency";
ValidationTypes[5] = "Date";
ValidationTypes[6] = "Phone or Fax Number";
ValidationTypes[7] = "Zipcode";
ValidationTypes[8] = "Email Address";
ValidationTypes[9] = "Social Security Number";
ValidationTypes[10] = "Signed Currency";
ValidationTypes[11] = "Long Year";
ValidationTypes[12] = "Whole Number Currency";
ValidationTypes[13] = "Percent";

function listtypes() 
{
  var intloop = 0;
  var intloop2 = 0;
  var intspacelength = 0;
  var space = "";
  var newwindow = "";
  newwindow += "JavaScript Validation Data Types\npreceeded by the integer reference.\n\n";

  for(intloop=0; intloop < ValidationTypes.length; intloop++)
  {	
    intspacelength = intloop.toString();
    space = "	";
    if (intspacelength.length < 2) space += "  ";
    newwindow += intloop + space + ValidationTypes[intloop] + "\n";
  }
  
  newwindow += "\n\nfunction validate(inttype, field, strfieldname, blnautocorrect, blnautoformat, strcustomerrormessage, intminvalue, intmaxvalue, intnumberofdecimals )";
  
  alert(newwindow);
}

var daysinmonth = Array(12);
daysinmonth[1] = 31;
daysinmonth[2] = 29;
daysinmonth[3] = 31;
daysinmonth[4] = 30;
daysinmonth[5] = 31;
daysinmonth[6] = 30;
daysinmonth[7] = 31;
daysinmonth[8] = 31;
daysinmonth[9] = 30;
daysinmonth[10] = 31;
daysinmonth[11] = 30;
daysinmonth[12] = 31;


var states = "AL|AK|AS|AZ|AR|CA|CO|CT|DE|DC|FM|FL|GA|GU|HI|ID|IL|IN|IA|KS|KY|LA|ME|MH|MD|MA|MI|MN|MS|MO|MT|NE|NV|NH|NJ|NM|NY|NC|ND|MP|OH|OK|OR|PW|PA|PR|RI|SC|SD|TN|TX|UT|VT|VI|VA|WA|WV|WI|WY|AE|AA|AE|AE|AP";
var defaultEmptyOK = false;

function givefocus()
{
  var blnFound = false;
	  
  if(document.forms.length!=0)
  {
    for(i=0; i<document.forms.length; i++)
    {
      for(j=0; j<document.forms[i].length; j++)
      {
	if((document.forms[i].elements[j].type == "text" && !document.forms[i].elements[j].disabled) || document.forms[i].elements[j].type == "textarea" || document.forms[i].elements[j].type == "password" )
	{
	  blnFound = true;
	  document.forms[i].elements[j].focus();
	  window.scrollTo(0,0);
	  window.scroll(0,0);
	  break;
	}
      }
	      
      if( blnFound ) break;
    }
  }
}




/////////////////////////////////////////////////
// GROUPED IS FUNCTIONS
/////////////////////////////////////////////////

function isEmpty(s)
{
  return ((s == null) || (s.length == 0));
}

function isWhitespace (s)
{   
	var intloop;
  if (isEmpty(s)) 
    return true;
  for (intloop = 0; intloop < s.length; intloop++)
  {   
    var character = s.charAt(intloop);
    if (whitespace.indexOf(character) == -1) 
      return false;
  }
  return true;
}

function isLetter(c)
{   
  return ( ((c >= "a") && (c <= "z")) || ((c >= "A") && (c <= "Z")) );
}

function isDigit(c)
{
  return ((c >= "0") && (c <= "9"));
}

function isLetterOrDigit(c)
{
  return (isLetter(c) || isDigit(c));
}

function isInteger(s)
{   
	var intloop;
   
  for (intloop = 0; intloop < s.length; intloop++)
  {   
    var character = s.charAt(intloop);
    if (!isDigit(character)) 
      return false;
  }
  return true;
}

function isFloat(s)		
{   
  var intloop;
  var seenDecimalPoint = false;
	
  if (s == '.') 
    return false;
		  
  for (intloop = 0; intloop < s.length; intloop++)
  {
    var character = s.charAt(intloop);			
    if ((character == '.') && !seenDecimalPoint) 
      seenDecimalPoint = true;
    else if (!isDigit(character)) 
      return false;
  }		     
  return true;
}

function isAlphabetic(s)
{   
  var intloop;

  for (intloop = 0; intloop < s.length; intloop++)
  {   
    var character = s.charAt(intloop);
    if (!isLetter(character))
      return false;
  }
  return true;
}

function isAlphanumeric(s)
{   
  var i;

    for (i = 0; i < s.length; i++)
    {	
      var c = s.charAt(i);

      if (! (isLetter(c) || isDigit(c) ) )
        return false;
    }

    return true;
}

function isSignedInteger(s)
{   
  var startPos = 0;

  if ( (s.charAt(0) == "-") || (s.charAt(0) == "+") )
     startPos = 1;
    
  return (isInteger(s.substring(startPos, s.length)));
}

function isPositiveInteger(theField)
{
  var normalizedint = RemoveCharacters(theField, numberdelimiters);
   
  return (isSignedInteger(normalizedint) && (parseInt (normalizedint) >= 0));
}

function isPositiveFloat(s)
{	  
	if (isFloat(s) && parseFloat(s) >= 0)
		return true;
	else
    return false;
}

function isSignedCurrency(s)
{     
  var startPos = 0;

  s = convertParenthesis(s);
  if ( (s.charAt(0) == "-") || (s.charAt(0) == "+") )
     startPos = 1;
    
  return (isFloat(unformatCurrency(s.substring(startPos, s.length))));
}

function isPositiveCurrency(s)
{     
	if (!isPositiveFloat(unformatCurrency(s)))
		return false;
	else
    return true;
}

function isNonNegWholeCurrency(s)
{
	if (!isPositiveInteger(unformatCurrency(s)))
		return false;
	else
    return true;
}

function isPositivePercent(s)
{
  var normalizedpercent = unformatPercent(s);
   
  return (isPositiveFloat(normalizedpercent) && (parseFloat(normalizedpercent) >= 0) && (parseFloat(normalizedpercent) <= 1));

}

function isYear(s)
{
  if (!isPositiveInteger(s))
    return false;
  
  return ((s.length == 2) || (s.length == 4));
}

function isLongYear(s)
{
  if (!isPositiveInteger(s)) return false;
  return (s.length == 4);
}

function isIntegerInRange(s, a, b)
{
  if (!isInteger(s)) 
    return false;

  if (!isInteger(a) || !isInteger(b))
  {
    alert("Your upper and lower bounds were not integers./nPlease check your code.");
    return false;
  }
  
  var num = parseInt(s);
  
  if (a == null && b == null)
    return true;
  else if (a == null)
    return (num >= a);
  else if (b == null)
    return (num <= b);
  else
    return ((num >= a) && (num <= b));
}

function isMonth(s)
{
  return isIntegerInRange (s, 1, 12);
}

function isDay(s)
{   
  return isIntegerInRange (s, 1, 31);
}

function isDate(year, month, day)
{
  if (! (isYear(year) && isMonth(month) && isDay(day))) 
    return false;

  var intYear = parseInt(year);
  var intMonth = parseInt(month);
  var intDay = parseInt(day);

  if (intDay > daysinmonth[intMonth]) 
    return false; 

  if ((intMonth == 2) && (intDay > daysInFebruary(intYear))) 
    return false;

  return true;
}

function isZIPCode(s)
{
  return (isInteger(s) && ((s.length == digitsinzipcode1) || (s.length == digitsinzipcode2)));
}

function isSSN(s)
{
  var strNumericalSSN;
  strNumericalSSN = RemoveCharacters(s, ssndelimiters);
  
  return (isInteger(strNumericalSSN) && strNumericalSSN.length == digitsinssn);  
}

function isEmail(s)
{ 
  if (isWhitespace(s)) 
    return false;
    
  var i = 1;
  var sLength = s.length;

  while ((i < sLength) && (s.charAt(i) != "@"))
  { 
    i++;
  }

  if ((i >= sLength) || (s.charAt(i) != "@")) 
    return false;
  else 
    i += 2;

  while ((i < sLength) && (s.charAt(i) != "."))
  { 
    i++;
  }

  if ((i >= sLength - 1) || (s.charAt(i) != ".")) 
    return false;
  else 
    return true;
}

function isCurrency(s)
{
  return (isParenSignedFloat(s));
}

function isPhoneNumber(s)
{
  return (isInteger(s) && s.length >= mindigitsinphonenumber && s.length <= maxdigitsinphonenumber);
}












///////////////////////////////////////////////
// GROUPED FORMAT FUNCTIONS
///////////////////////////////////////////////

function RemoveCharacters (s, characters)
{   
  var intcount;
  var returnString = "";
  for (intcount = 0; intcount < s.length; intcount++)
  {   
    var c = s.charAt(intcount);
    if (characters.indexOf(c) == -1) 
      returnString += c;
  }
  return returnString;
}

function RemoveOtherCharacters (s, characters)
{   
  var intcount;
  var returnString = "";
  for (intcount = 0; intcount < s.length; intcount++)
  {   
    var c = s.charAt(intcount);
    if (characters.indexOf(c) != -1) 
      returnString += c;
  }
  return returnString;
}

function stripWhitespace(s)
{
  return RemoveCharacters (s, whitespace);
}

function trim(s)
{
  if (!isEmpty(s))
  {
    var intcount = 0;
    var intstringstart = 0;
    var intstringend = s.length;
    if (intstringend == null)
      intstringend = 0;
      
    for (intcount = 0; intcount < s.length; intcount++)
    {
      if (s.charAt(intcount) == " " || s.charAt(intcount) == "\t" || s.charAt(intcount) == "\n" || s.charAt(intcount) == "\r")	 
	      intstringstart++;
      else
	      break;
    }	     
    for (intcount = s.length - 1; intcount > 0; intcount--)
    {
      if (s.charAt(intcount) == " " || s.charAt(intcount) == "\t" || s.charAt(intcount) == "\n" || s.charAt(intcount) == "\r")	 
	      intstringend--;
      else
	      break;
    }
    if (s.length != null) 
      s = s.substring(intstringstart, intstringend);	 
    return s;
  }
  else
    return s;  
  
}

function RemoveLeadingZeros(value)
{
  var convertedvalue = '';
  var endremovezeros = false;

  for (i = 0; i < value.length; i++)
  {
    var c = value.charAt(i);
   
    if ((c != 0) && !endremovezeros)
    {
      endremovezeros = true;
      convertedvalue += c;
    }
    else if ((c == 0) && !endremovezeros && value.charAt(i + 1) == '.')
    {
      endremovezeros = true;
      convertedvalue += c;    
    }
    else if ((c == 0) && !endremovezeros && value.length == 1)
    {
      endremovezeros = true;
      convertedvalue += c;    
    }	 
    else if (endremovezeros) 
      convertedvalue += c;	 
  }    
return(convertedvalue);
}

function RemoveTrailingZeros(value)
{
  var convertedvalue = '';
  var endvalue = value.length;
  var endremovezeros = false;
  var decimalexists = false;
  
  if (value.indexOf('.') == -1)
  {
    return(value);
  }
  for (i = (value.length - 1); i > 0; i--)
  {
    //alert("loop = " + i);
    var c = value.charAt(i);
    //alert("char = " + c);
      
    if ((c != 0) && (c != '.') && !endremovezeros)
      endremovezeros = true;
    else if ((c == 0) && !endremovezeros && value.length == 1)
      endremovezeros = true;
    else
      endvalue -= 1;
	    
    if (endremovezeros)
      break;
  }
  
  convertedvalue = value.substring(0, endvalue);    
  return(convertedvalue);
}


function reformat(s)
{
  var arg;
  var sPos = 0;
  var resultString = "";

  for (var i = 1; i < reformat.arguments.length; i++) {
    arg = reformat.arguments[i];
    if (i % 2 == 1) 
      resultString += arg;
    else
    {
      resultString += s.substring(sPos, sPos + arg);
      sPos += arg;
    }
  }
  return resultString;
}

function roundtodecimals(original_number, decimalplaces) 
{
  var value1 = original_number * Math.pow(10, decimalplaces);
  var value2 = Math.round(value1);
  var value3 = value2 / Math.pow(10, decimalplaces);
  return insertzeros(value3, decimalplaces);
}

function roundToPennies(n)
{
 pennies = n * 100;
 pennies = Math.round(pennies);

 strPennies = "" + pennies;
 len = strPennies.length;

 return strPennies.substring(0, len - 2) + "." + strPennies.substring(len - 2, len);
}

function insertzeros(rounded_value, decimal_places)
{
  var value_string = rounded_value.toString();
  var decimal_location = value_string.indexOf(".");
  if (decimal_location == -1)
  {
    decimal_part_length = 0;
    value_string += decimal_places > 0 ? "." : "";
  }
  else
    decimal_part_length = value_string.length - decimal_location - 1;

  var pad_total = decimal_places - decimal_part_length;
  if (pad_total > 0)
  {
    for (var counter = 1; counter <= pad_total; counter++) 
      value_string += "0";
  }
  return value_string;
}

function insertcommas(s)
{
  var sPos;
  var start = s.length - 1;
  var resultString = s.charAt(start);

  for (sPos = start-1; sPos >= 0; sPos--) 
  {
    if ((start - sPos) % 3 == 0) 
      resultString = s.charAt(sPos) + ',' + resultString;
    else 
      resultString = s.charAt(sPos) + resultString;
  }
  return resultString;
}

function reformatPercent(s, intnumberofdecimals)
{

  if (!isEmpty(intnumberofdecimals))
  {
    if (intnumberofdecimals.toString() == "NaN")
      intnumberofdecimals = 2; // default
  }
  else
    intnumberofdecimals = 2; // default 
    
  var percent;

  percent = RemoveOtherCharacters(s, decimaldelimiter + digits);
  if(isFloat(percent)) {
    percent = parseFloat(percent);
    percent = percent * 100;
    percent = percent.toString();
  }
  percent = roundtodecimals(percent, intnumberofdecimals);
  percent = percent + '%';
  return (percent);  
}

function reformatCurrency(s, intnumberofdecimals)
{

  if (!isEmpty(intnumberofdecimals))
  {
    if (intnumberofdecimals.toString() == "NaN")
      intnumberofdecimals = 2; // default
  }
  else
    intnumberofdecimals = 2; // default 
    
  var length; 
	var startPos = 0;
	var endPos;
	var currency;
  var currencyfirstcharacter;
  var decimalpointposition;

  currency = RemoveOtherCharacters(s, decimaldelimiter + digits + positivenegative);
  length = currency.length;
  currencyfirstcharacter = currency.substring(0,1);  
  currency = currency.substring(1,length + 1);
  currency = RemoveCharacters(currency, positivenegative);
  length = currency.length;
  decimalpointposition = currency.indexOf(decimaldelimiter);  
  if (decimalpointposition != -1)
    currency = RemoveCharacters(currency.substring(0,decimalpointposition + 1), decimaldelimiter) + "." + RemoveCharacters(currency.substring(decimalpointposition,length + 1), decimaldelimiter);  

  currency = currencyfirstcharacter + currency;
  currency = roundtodecimals(currency, intnumberofdecimals); 
  length = currency.length;
  
  //if (currency.substring(length - 3, length + 1) == ".00")
  //  currency = currency.substring(0, currency.indexOf("."));
	
	if ( (currency.charAt(0) == "-") || (currency.charAt(0) == "+") ) 
		startPos = 1;	
	
	endPos = currency.indexOf(".");
	
	if (endPos == -1)
		endPos = s.length;
					
	if (currency.charAt(0) == "-") {
		return( '-' + '$' + insertcommas(currency.substring(startPos, endPos)) + currency.substring(endPos, s.length));
		//currency = ( '-' + '$' + insertcommas(currency.substring(startPos, endPos)) + currency.substring(endPos, s.length));
	} else {
		return( '$' + insertcommas(currency.substring(startPos, endPos)) + currency.substring(endPos, currency.length) );
		//currency = ( '$' + insertcommas(currency.substring(startPos, endPos)) + currency.substring(endPos, currency.length) );
  }

  currency = roundtodecimals(currency, 2);
  return( currency );


/*
	if (currency.charAt(0) == "-")
	{   
		return( '-' + '$' + insertCurrencyCommas(currency.substring(startPos, endPos)) + currency.substring(endPos, s.length));
	  //currency = '-' + insertCurrencyCommas(currency.substring(startPos, endPos)) + currency.substring(endPos, s.length);
	}
	else 
	{
		return( '$' + insertCurrencyCommas(currency.substring(startPos, endPos)) + currency.substring(endPos, currency.length) );
    //currency = insertCurrencyCommas(currency.substring(startPos, endPos)) + currency.substring(endPos, currency.length);
  }

    currency = roundtodecimals(currency, 2)
    return( currency );
*/

}	

function reformatPhone(Phone)
{
	var normalizedPhone = RemoveCharacters(Phone.value, phonedelimiters);
  if (normalizedPhone.length == 10) 
    return (reformat (normalizedPhone, "(", 3, ") ", 3, "-", 4));
  else 
    return (reformat (normalizedPhone, "(", 3, ") ", 3, "-", 4, " ", 5));
}

function reformatZipcode(Zipcode)
{   
  if (Zipcode.length == 5) 
    return Zipcode;
  else
    return (reformat (Zipcode, "", 5, "-", 4));
}

function reformatSSN(SSN)
{ 
  var strformattedSSN;
  strformattedSSN = RemoveOtherCharacters(SSN, digits);  
  if (strformattedSSN.length == 9)
  { 
    strformattedSSN = (reformat (strformattedSSN, "", 3, "-", 2, "-", 4));
  }
  return strformattedSSN;
}


function unformatCurrency(s)
{
	return RemoveCharacters(convertParenthesis(s), currencydelimiters);
}

function unformatPercent(s)
{
  var percent;
  percent = RemoveCharacters(s, percentdelimiters);
  if(isFloat(percent)) {
    percent = parseFloat(percent);
    percent = percent / 100;
    percent = percent.toString();
  }
  return percent;
}

function convertParenthesis(s)
{   
	if ( (s.charAt(0) == "(") && (s.charAt( s.length - 1 ) == ")") )
		return ( '-' + s.substring(1, s.length - 1 ) );
  else
		return( s );
}

function selectField(field)
{
  field.focus();
	field.select();
}

function noFocus(field, text)
{
  var Errormessage;
  Errormessage = "You may not change this value.\nThe system automatically calculates this value";
  if (isEmpty(text))
    Errormessage = Errormessage + ".";
  else
    Errormessage = Errormessage + " by " + text;
	field.blur();  
  alert(Errormessage);	
}

function setToZeroIfBlank(field)
{
	if (field.value == "")
		field.value = "0";
}

function removeQuotes(field)
{
  var pattern = /"/g;
  var tempString = new String(field.value);
  field.value = tempString.replace(pattern, "");
}


function checkCurrency(theField)
{
  var normalizedCurrency = RemoveCharacters(theField.value, currencydelimiters);
  normalizedCurrency = convertParenthesis(normalizedCurrency);

  if (!isCurrency(normalizedCurrency)) 
     return false;
  else 
  {
    theField.value = reformatCurrency(normalizedCurrency);
    return true;
  }
}


function checkPhone(theField)
{   
	var normalizedPhone = RemoveCharacters(theField.value, phonedelimiters);
  if (!isPhoneNumber(normalizedPhone, false)) 
     return false;
  else 
  {
     //theField.value = reformatPhone(normalizedPhone);
     return true;
  }

}

function checkZipcode(theField)
{   
  var normalizedZIP = RemoveCharacters(theField.value, zipcodedelimiters);
  if (!isZIPCode(normalizedZIP)) 
     return false;
  else 
  {
     theField.value = reformatZipcode(normalizedZIP);
     return true;
  }
}

function checkSSN(theField)
{
  var normalizedSSN = RemoveCharacters(theField.value, ssndelimiters);
  if (!isSSN(normalizedSSN)) 
     return false;
  else 
  {
     theField.value = reformatSSN(normalizedSSN);
     return true;
  }
}

function checkEmail(theField)
{
  if (!isEmail(theField.value)) 
    return false;
  else 
    return true;
}

function daysInFebruary(year)
{
  return (  ((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0) ) ) ? 29 : 28 );
}

function checkYear(theField)
{
  if (!isYear(theField.value)) 
    return false;
  else 
    return true;
}

function checkMonth(theField)
{
  if (!isMonth(theField.value)) 
     return false;
  else
    return true;
}

function checkDay (theField)
{   
  if (!isDay(theField.value)) 
    return false;
  else 
    return true;
}

function checkDate (yearField, monthField, dayField, labelString, OKtoOmitDay)
{
  if (checkDate.arguments.length == 4) 
    OKtoOmitDay = false;
  if (!isYear(yearField.value)) 
    return false;
  if (!isMonth(monthField.value)) 
    return false;
  if ( (OKtoOmitDay == true) && isEmpty(dayField.value) ) 
    return true;
  else if (!isDay(dayField.value)) 
    return false;
  if (isDate (yearField.value, monthField.value, dayField.value))
    return true;
  
  return false;
}

function getRadioButtonValue (radio)
{   
  for (var i = 0; i < radio.length; i++)
  {
    if (radio[i].checked)
      break;
  }
  return radio[i].value;
}

function checkDate(theField, emptyOK) 
{
	var dateStr = theField.value;
	var datePat = /^(\d{1,2})(\/)(\d{1,2})\2(\d{4})$/;      // requires 4 digit year
	var datePat2 = /^(\d{1,2})(\/)(\d{1,2})\2(\d{2})$/;     // requires 2 digit year

	if (checkDate.arguments.length == 1) 
    defaultEmptyOK = false;
	if ((emptyOK == true) && (isEmpty(theField.value))) 
    return true;

	var matchArray;
	matchArray = (dateStr.match(datePat) || dateStr.match(datePat2)); // is the format ok?
	if (matchArray == null) 
	{
		//alert(dateStr + " Date is not in a valid format.")
		return false;
	}
	
	month = matchArray[1]; // parse date into variables
	day = matchArray[3];
	year = matchArray[4];
	
	if (year.length == 2)
	{
	  year = parseInt("20" + year);
	  alert("The date you have entered is going to be reformatted to have a four digit year.\nIf the resulting date is not what you intended than please change the value.");
	  theField.value = month + "/" + day + "/" + year;
    theField.select();
    theField.focus();		  
	}
	
	if (month < 1 || month > 12) 
		return false;
	if (day < 1 || day > 31) 
		return false;
	if ((month==4 || month==6 || month==9 || month==11) && day==31) 
		return false;
	if (month == 2) 
	{ 
		var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
		if (day>29 || (day==29 && !isleap)) 
			return false;
	}
	return true;
}

function checkTextLength(theField, minSize, maxSize)
{
  if (minSize != null)
  {
    if (theField.value.length < minSize)
      return false;    
  }
  if (maxSize != null)
  {
    if (theField.value.length > maxSize)
      return false;    
  }
	
	return true;
}

function checkNonNegInt(field)
{
	if (!isPositiveInteger(field.value))
		alert(strNonNegIntMsg);
}

function checkNonNegFloat(field)
{
	if (!isPositiveFloat(field.value))
		alert(strNonNegFloatMsg);
}

function checkNonNegCurrency(field)
{	
	field.value = reformatCurrency(unformatCurrency(field.value));
}

function checkNonNegWholeCurrency(field)
{	
	if (!isNonNegWholeCurrency(field.value))
		alert(strMoneyErrorMsg);
	else 
    field.value = reformatCurrency(unformatCurrency(field.value));
}


function allowcharacters(s, inttype)
//, characters)
{
  //s.value = RemoveOtherCharacters (s.value, lowercaseletters + uppercaseletters)
  
  if( inttype == 0 )
    s.value = RemoveOtherCharacters(s.value, digits);  
  else if( inttype == 1 )
    s.value = RemoveOtherCharacters(s.value, lowercaseletters + uppercaseletters + whitespace);  
  else if( inttype == 2 )
    s.value = RemoveOtherCharacters(s.value, lowercaseletters + uppercaseletters + whitespace + digits);  
  else if( inttype == 3 )
    s.value = RemoveOtherCharacters(s.value, digits + positivenegative + decimaldelimiter);
  else if( inttype == 4 )
    s.value = RemoveOtherCharacters(s.value, digits + positivenegative + decimaldelimiter);  
  else if( inttype == 5 )
    s.value = RemoveOtherCharacters(s.value, digits + "/");
  else if( inttype == 6 )
    s.value = RemoveOtherCharacters(s.value, phonecharacters);
  else if( inttype == 7 )
    s.value = RemoveOtherCharacters(s.value, zipcodecharacters);
  else if( inttype == 8 )
    s.value = RemoveOtherCharacters(s.value, digits + positivenegative + decimaldelimiter + lowercaseletters + uppercaseletters + "@");
  else if( inttype == 11 )
    s.value = RemoveOtherCharacters(s.value, digits);
  
}







var strIntegerMsg = 'This field must be a whole number.  Please reenter it now.';
var strPositiveIntegerMsg = 'This field must be a non-negative whole number.  Please reenter it now.';
var strNegativeIntegerMsg = 'This field must be a negative whole number.  Please reenter it now.';
var strCurrencyMsg = 'This field must be a dollar amount.  Please reenter it now.';

var strValidPhoneMsg = "This field must be a valid phone number with area code.  Please reenter it now.";
var strValidFaxMsg = "This field must be a valid fax number with area code.  Please reenter it now.";
var strValidZipMsg = "This field must be a valid zip code.  Please reenter it now.";
var strValidDateMsg = "This field must be a valid date using the format: mm/dd/yyyy.  Please reenter it now.";

function validate(inttype, field, strfieldname, blnautocorrect, blnautoformat, strcustomerrormessage, intminvalue, intmaxvalue, intnumberofdecimals )
{ 
  var blnshowerror = true;
  var blntrim = true;
  var blnforcecorrection = true;
  var blnallowempty = true;
  
  var blnrange = false;
  var strpositivenegative = "";
  var strvaluebetween = "";

  if (isEmpty(strfieldname))
  {
    strfieldname = "This field";
  }
  if (isEmpty(strcustomerrormessage))
  {
    strcustomerrormessage = null;      
  }
  if (!isEmpty(blnautocorrect))
  {
    blnautocorrect = blnautocorrect + "";
    if (blnautocorrect.toUpperCase() == "TRUE" || blnautocorrect.toUpperCase() == "1")
      blnautocorrect = 1;
    else
      blnautocorrect = 0;
  }
  else
      blnautocorrect = 0;

  if (!isEmpty(blnautoformat))
  {
    blnautoformat = blnautoformat + "";
    if (blnautoformat.toUpperCase() == "FALSE" || blnautoformat.toUpperCase() == "0")
      blnautoformat = 0;
    else
      blnautoformat = 1;    
  }
  else
      blnautocorrect = 1;     

  
  if (!isEmpty(intmaxvalue))
  {
    if (intmaxvalue.toString() == "NaN")
      intmaxvalue = null;
  }
  else
    intmaxvalue = null;   
    
  if (!isEmpty(intminvalue) )
  {
    if (intminvalue.toString() == "NaN")
      intminvalue = null;    
  }  
  else
    intminvalue = null;   
  
  if (intmaxvalue != null || intminvalue != null)
    blnrange = true;  
  
  if (intmaxvalue == null && intminvalue == null)
    strpositivenegative = ""  
  else if (!isNaN(parseFloat(intminvalue)) && intminvalue >= 0 && intmaxvalue == null)
    strpositivenegative = " positive";
  else if (!isNaN(parseFloat(intmaxvalue)) && intmaxvalue <= 0 && intminvalue == null)
    strpositivenegative = " negative"; 
  else if (intmaxvalue != null && intminvalue != null) 
    strvaluebetween = " value between " + intminvalue + " and " + intmaxvalue;
  else if (intmaxvalue == null)
    strvaluebetween = " value greater than or equal to " + intminvalue;
  else if (intminvalue == null) 
    strvaluebetween = " value less than or equal to " + intmaxvalue;   
  
  if (strpositivenegative != " positive" && strpositivenegative != " negative" && inttype == 0)
    strpositivenegative = "n"; 
  
  if (blntrim)
    field.value = trim(field.value);

  if (blnallowempty && field.value == "")
    return true; 
    
  if (blnautocorrect)
  {
    if ( inttype == 0 || inttype == 3 || inttype == 3 || inttype == 4 )
      field.value = RemoveLeadingZeros(RemoveTrailingZeros(field.value));  
  }
   
  if (blnrange && intminvalue == null)
    intminvalue = -3362500.08;
  if (blnrange && intmaxvalue == null)
    intmaxvalue = 3362500.08;  
  
  var errormessage = "";

   // Validate an integer   
  if( inttype == 0 )
  {
    if(field.value == "")
      return true;
    
    if( !isPositiveInteger(field.value) )
    {
      errormessage += strfieldname + " must be a" + strpositivenegative + " integer" + strvaluebetween + ".";
      errormessage += "\nPlease re-enter it now.";
      
      if (strfieldname == null)
	      errormessage = strIntegerMsg;
    }  
    else
    {
      if(blnrange)
      {
      	if (!isIntegerInRange(field.value, intminvalue, intmaxvalue))
      	{  
      	  errormessage += strfieldname + " must be ";
      	  
      	  if ( intmaxvalue == 3362500.08 )
      	    errormessage += "greater than or equal to " + intminvalue + ".";
      	  else if ( intminvalue == -3362500.08 )
      	    errormessage += "less than or equal to " + intmaxvalue + ".";
      	  else
      	    errormessage += "between " + intminvalue + " and " + intmaxvalue + ".";	    
      	  
      	  errormessage += "\nPlease re-enter it now."; 
      	}
      }
    }

	if(blnautocorrect)
    {
      field.value = RemoveOtherCharacters(field.value, digits + positivenegative);
    	if (errormessage != "")
    	  errormessage += "\nThe value entered will be changed to a proper data type";
    }

    if(blnautoformat && errormessage == "")
      field.value = insertcommas(RemoveLeadingZeros(RemoveOtherCharacters(field.value, digits + positivenegative)));

      //alert(blnautoformat + "\n" + errormessage);
      //alert(blnautoformat && errormessage == "");
  }
  
   
   // Validate an alphanumeric value
  else if( inttype == 2 )
  {
    var intcharacterdeficiency = 0;
    var strmessage = "";
    var intComparisonType;
  
  if (intminvalue == -3362500.08 )
    intminvalue = null;
  if (intmaxvalue == 3362500.08 )
    intmaxvalue = null;

    if(intminvalue != null || intmaxvalue != null)
    {
      //alert("test");
      if(!checkTextLength(field, intminvalue, intmaxvalue))
      {
        if (intminvalue != null && intmaxvalue == null)
        {
          intComparisonType = 1;
          intcharacterdeficiency = intminvalue - field.value.length;  
        }
        else if (intminvalue == null && intmaxvalue != null)
        {
          intComparisonType = 2;
          intcharacterdeficiency = field.value.length - intmaxvalue;
        }
        else
        {
          intComparisonType = 3;
          intcharacterdeficiency = intminvalue - field.value.length;
          if (intcharacterdeficiency > 0) 
            intComparisonType = 31;
          else
          {
            intcharacterdeficiency = field.value.length - intmaxvalue; 
            intComparisonType = 32;
          }           
        }
      	
      	errormessage += "The field";
        if(strfieldname != "")
          errormessage += " " + strfieldname;        
        errormessage += " must be";

        if (intComparisonType == 1)
        {
          errormessage += " greater than or equal to " + intminvalue + " character";
          if (intminvalue != 1)
            errormessage += "s.\n";
          else
            errormessage += ".\n";    
        }
          
        if (intComparisonType == 2)
        {
          errormessage += " less than or equal to " + intmaxvalue + " character";
          if (intmaxvalue != 1)
            errormessage += "s.\n";
          else
            errormessage += ".\n";
        }

        if (intComparisonType == 31 || intComparisonType == 32)
          errormessage += " between " + intminvalue + " and " + intmaxvalue + " characters.\n";
 
        errormessage += "Please";

        if (intComparisonType == 1 || intComparisonType == 31)
          errormessage += " add";
        else
          errormessage += " remove";     
        
        errormessage += " " + intcharacterdeficiency;

        if (intcharacterdeficiency == 1)
          errormessage += " character";
        else
          errormessage += " characters"; 
        
        errormessage += " now.\n";

        errormessage += "Note: Characters include whitespaces.";
      }
    }
  }
    
   // Validate a float 
  else if( inttype == 3 )
  {
    if( !isPositiveFloat(field.value) )
    {
      errormessage += strfieldname + " must be a" + strpositivenegative + " number" + strvaluebetween + ".";
      errormessage += "\nPlease re-enter it now.";
    }
    else
    {

    }
    if(blnautoformat && errormessage == "")
    {
      field.value = RemoveLeadingZeros(RemoveTrailingZeros(RemoveOtherCharacters(field.value, digits + positivenegative + decimaldelimiter))); 
    }
	
  }  
   // Validate a currency 
  else if( inttype == 4 )
  {    
    if( !isPositiveCurrency(field.value) )
    {
      errormessage += strfieldname + " must be a valid currency amount.";
      errormessage += "\nPlease re-enter it now.";
    }
    else
    {
      field.value = reformatCurrency(unformatCurrency(field.value),intnumberofdecimals);
    }
  }
  // Validate a date field
  else if( inttype == 5 )
  {
    if( !checkDate(field) )
    {
      errormessage += strfieldname+ " must be a valid date.";
      errormessage += "\nValid format:	MM/DD/YYYY";
    }  
  }
  // Validate a phone field  
  else if( inttype == 6 )
  {
    if( !checkPhone(field) )
    {
      errormessage += strfieldname + " must be a valid phone number.";
      errormessage += "\nValid format:	(123) 456-7890";
    }
    else
    {
      if(blnautoformat)
	field.value = reformatPhone(field);    
    }	     
  }
  // Validate a zipcode 
  else if( inttype == 7 )
  {
    if( !checkZipcode(field) )
    {
      errormessage += strfieldname + " must be a valid zipcode.";
      errormessage += "\nValid formats:  12345 or 12345-6789";
    }
  } 
  else if( inttype == 8 )
  {
    if(!isEmail(field.value))
    {
      errormessage += strfieldname + " must be a valid email address.";
      errormessage += "\nPlease re-enter it now.";
    }
  }
  else if( inttype == 9 )
  {
    if(!isSSN(field.value))
    {
      if(blnautocorrect)
        field.value = RemoveOtherCharacters(field.value, digits);       
      errormessage += strfieldname + " must be a valid Social Security Number.";
      errormessage += "\nPlease re-enter it now.";
    }
    if(blnautoformat && errormessage == "")
    {
      field.value = reformatSSN(field.value); 
    }
  }	     
  else if( inttype == 10 )
  {
    if( !isSignedCurrency(field.value) )
    {
      errormessage += strfieldname + " must be a valid currency amount.";
      errormessage += "\nPlease re-enter it now.";
    }
    else
    {
      field.value = reformatCurrency(unformatCurrency(field.value),intnumberofdecimals);
    }
  }
  else if( inttype == 11 )
  {
    if( !isLongYear(field.value) )
    {
      errormessage += strfieldname + " must be a valid 4-digit year.";
      errormessage += "\nPlease re-enter it now.";
    }
  }
  // Validate a currency 
  else if( inttype == 12 )
  {
    if( !isNonNegWholeCurrency(field.value) )
    {
      errormessage += strfieldname + " must be a positive whole number currency amount.";
      errormessage += "\nPlease re-enter it now.";
    }
    else
    {
      field.value = reformatCurrency(unformatCurrency(field.value),0);
    }
  } 
  else if( inttype == 13 )
  {
    if( !isPositivePercent(field.value) )
    {
      errormessage += strfieldname + " must be a valid percent number.";
      errormessage += "\nPlease re-enter it now.";
    }
    else
    {
      field.value = reformatPercent(unformatPercent(field.value));
    }
  }

  if( blnshowerror && errormessage != '' )
  {
    //alert(strcustomerrormessage);
    if (trim(strcustomerrormessage) != null && strcustomerrormessage != "")
      alert(strcustomerrormessage);
    else
      alert(errormessage);
    
    if (blnforcecorrection)
    {
      field.select();
      field.focus();
    }
  }
  
  
	return true;
}




function getMonthDifference(strFieldNameOne, strFieldNameTwo, answerField)     
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function getMonthDifference 
// Description: This function finds the difference, in Months, given 2 dates.
//
// input -  strFieldNameOne:  name of text field with start date
//          strFieldNameTwo:  name of text field with end date
//          answerField:      name of text field answer will be written to.
//            
// output - writes out answer value
//
// March 4, 2002
// Created by:     Heath Cleland
///////////////////////////////////////////////////////////////////////////////////////////////////////////
  if (!isEmpty(strFieldNameOne.value))
  {
    if (!isEmpty(strFieldNameTwo.value))
    {  
// First find out if month is required to be round up.
// This may need to be removed.
        var offset = new Array(0,31,59,90,121,151,181,212,243,273,304,334);   // array of total days in year by month 
        var numDaysInMonth = new Array(31,28,31,30,31,30,31,31,30,31,30,31);  // array of days in each month

        dteStartDate = new Date(strFieldNameOne.value);                       // Get Start Date (example - employee start date) 
        dteEndDate   = new Date(strFieldNameTwo.value);                       // Get End Date (example - an expiration date)

        intTempMS = dteEndDate.getTime() - dteStartDate.getTime();            // convert milliseconds        
        intDays = (intTempMS/(1000*60*60*24*(numDaysInMonth[dteStartDate.getMonth()])));        
        fltMonthsRounded = intDays.toString().substr(0,3);
        
        //alert(dteStartDate.getDate());
        
        
        numMonths = intDays / 30;                                             
        decPos = numMonths.toString().indexOf(".");
        
        if (decPos == -1){
          totalNumMonths    = numMonths;
        } else {
          if (numMonths.toString().substring(decPos+1, decPos + 2) != 0){
                if (numMonths < 1){                                   
                  totalNumMonths  = numMonths.toString().substring(decPos, decPos +2);
                } else {                
                  totalNumMonths  = numMonths.toString().substring(0, decPos +2);
                }
          } else {          
              totalNumMonths  = numMonths.toString().substr(0,decPos);            
          }
        }
 /*
        var Sdays = offset[dteStartDate.getMonth()];                          // number of days in first month  
        var Edays = offset[dteEndDate.getMonth()];                            // number of days in last month
    
        var intTotalDaysInMonths = 0;                                         // counts number of days in each month between Start and End date.
       
          for ( mnthCntr = 0; mnthCntr < 12; mnthCntr++){               
            if (offset[mnthCntr] >= Sdays){
              if (offset[mnthCntr] < Edays){
                intTotalDaysInMonths += numDaysInMonth[mnthCntr];                 // add days in Month (in array) to intTotalDaysInMonths counter.
              }
            }
          }

 
          Sdays += dteStartDate.getDate();                    // adds number of days in current month to days in year.
          Edays += dteEndDate.getDate();            
          totalDays = Edays - Sdays;                         
          
          
          var intAddExtraMonth = 0;                           // Decides whether or not to round month up or not.
            if (totalDays > intTotalDaysInMonths){
              intAddExtraMonth = 1;
            }            
*/
// begin calc on Total number of months
// Finds Full month, does not find down to day.


      var dteEndYear = dteEndDate.getFullYear();         // Find Year for the end date
      var dteStartYear = dteStartDate.getFullYear();     // Find Year for the start date
      
      var dteEndMonth = dteEndDate.getMonth();           // Find Month of the end Date
      var dteStartMonth = dteStartDate.getMonth();       // Find Month of the Start Date

      // Find Total number of months in both years
      intDiffStartYear = dteStartYear * 12 + dteStartMonth;
      intDiffEndYear = dteEndYear * 12 + dteEndMonth;

      intTotalNumMonths = intDiffEndYear - intDiffStartYear;

      //write value to answer Text Field
      //answerField.value = intTotalNumMonths + intAddExtraMonth;
      //answerField.value = fltMonthsRounded;
      //answerField.value = totalNumMonths;
      
      if (dteStartDate.getDate() == dteEndDate.getDate()){      
        answerField.value = intTotalNumMonths;
      } else {      
        answerField.value = fltMonthsRounded;
      }
 
    } else {
    //  alert("A date is required for "+ messageNameTwo);
    }
  } else { 
  //  alert("A date is required for "+ messageName);
  }
}

function getMonthExpDate(strFieldNameOne, strFieldNameTwo, answerField)     
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function getMonthDifference 
// Description: This function finds the difference, in Months, given 2 dates.

// input -  strFieldNameOne:  name of text field with start date
//          strFieldNameTwo:  name of text field with end date
//          answerField:      name of text field answer will be written to.
            
// output - writes out answer value

// March 4, 2002
// Created by:     Heath Cleland
///////////////////////////////////////////////////////////////////////////////////////////////////////////
  if (!isEmpty(strFieldNameOne.value))
  {
    if (!isEmpty(strFieldNameTwo.value))
    {
    
    dteStartDate = new Date(strFieldNameOne.value);                                   // Get Start Date (example - employee start date) 
    
    dteStartDate.setMonth(dteStartDate.getMonth()+ parseInt(strFieldNameTwo.value))   // add months to date   
    
    answerField.value = (dteStartDate.getMonth()+1) + "/" + dteStartDate.getDate() + "/" + dteStartDate.getYear();  // display answer
    
    
    }
    
  }

}