// JavaScript Document
// VARIABLE DECLARATIONS
var digits = "0123456789";
var lowercaseLetters = "abcdefghijklmnopqrstuvwxyz"
var uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
var whitespace = " \t\n\r";
var sValidAddstr = uppercaseLetters + lowercaseLetters + digits + "#()-,[]: ./&'";
var sNumWithDecimal = digits + "."
var sValidNamestr = uppercaseLetters + lowercaseLetters + ". -&"
var sValidRemarks = uppercaseLetters + lowercaseLetters + digits + whitespace + "!#$%&*()-+=/.,:'[]{}"
var sValidAWBno = lowercaseLetters+uppercaseLetters+digits
var sValidState = sValidNamestr + digits
var sValidIndZip = digits
var sValidIntrZip = lowercaseLetters+uppercaseLetters+digits+"-"
var sValiemail = digits+uppercaseLetters+lowercaseLetters+"._-@"
var sValidPhone = digits+"() -+,"
var sValidPanNo = lowercaseLetters + uppercaseLetters +digits+ " /-"
var sValidUrl = lowercaseLetters + uppercaseLetters +digits+"./"
var sValidMfNo = lowercaseLetters+uppercaseLetters+digits
var sValidVehicle = sValidMfNo+" -/"
var svalidnostr=""
// CONSTANT STRING DECLARATIONS
// m is an abbreviation for "missing"
var mPrefix = "You did not enter a value into the "
var mSuffix = " field. This is a required field. Please enter it now."

// s is an abbreviation for "string"
var sAWBno = "Airway Bill No."
var sDparty = "Direct Party"
var sWaik = "Waik-In Customer"
var sFranchisee = "Franchisee"
var sCr = "Consignor "
var sCe = "Consignee "
var sName = "Name"
var sCity = "City"
var sStateCode = "State Code"
var sWorldState = "State, Province, or Prefecture"
var sCountry = "Country"
var sZIPCode = "ZIP Code"
var sWorldPostalCode = "Postal Code"
var sPhone = "Phone Number"
var sFax = "Fax Number"
var sDbirth = "Date of Birth"
var sExpirationDate = "Expiration Date"
var sEmail = "Email"
var sSSN = "Social Security Number"
var sIntrDate = "Introducing Date"
var sEndDate = "Valid Upto"
var sContName = "Contact Person Name"
var sOtherInfo = "Other Information"

// i is an abbreviation for "invalid"
var iUSStateCode = "This field must be a valid two character U.S. state abbreviation (like CA for California). Please reenter it now."
var iStateName = "Invalid State Name."
var iZIPCode = "Invalid Zip Code ."
var iWorldPhone = "Phone number must be a valid international phone number."
var iEmail = "Enter valid email address (like foo@bar.com)."
var iDay = "Enter a day between 1 and 31."
var iMonth = "Enter month between 1 and 12."
var iYear = "Year must be a 4 digit year number."
var iDatePrefix = "The Day, Month, and Year for "
var iDateSuffix = " do not form a valid date.  Please reenter ..."

// p is an abbreviation for "prompt"
var pEntryPrompt = "Please enter a "
var pZIPCode = "Valid Zip Code(like 94043)."
var pWorldPhone = "international phone number."
var pEmail = "valid email address (like foo@bar.com)."
var pDay = "day number between 1 and 31."
var pMonth = "month number between 1 and 12."
var pYear = "2 or 4 digit year number."

/*The simplest way to check whether the details entered in a text field are numeric is to to loop 
through the string and compare each character to a pre-defined list of acceptable characters.*/
function IsNumeric(sText)
{
   var ValidChars = "0123456789";
   var IsNumber=true;
   var Char;
   for (i = 0; i < sText.length && IsNumber == true; i++) 
      { 
      Char = sText.charAt(i); 
      if (ValidChars.indexOf(Char) == -1) 
         {
         IsNumber = false;
         }
      }
   return IsNumber;
}


/***************************************************
There are many varieties of email validation. This one is simple, but effective. It checks for a 
period (.) character anywhere after the 3rd character in the string (this is very cautious, allowing 
for one letter domain names e.g. a@b.com; and for @ characters anywhere after the first character 
(more possible, as a single letter username is easily possible)*/

function emailCheck (emailStr) {
	var checkTLD=1;
	var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;
	var emailPat=/^(.+)@(.+)$/;
	var specialChars="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";
	var validChars="\[^\\s" + specialChars + "\]";
	var quotedUser="(\"[^\"]*\")";
	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;

	var atom=validChars + '+';
	var word="(" + atom + "|" + quotedUser + ")";
	
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$");

	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");

	var matchArray=emailStr.match(emailPat);

	if (matchArray==null) {
		alert("Email address seems incorrect (check @ and .'s)");
		return false;
	}
	var user=matchArray[1];
	var domain=matchArray[2];
	for (i=0; i<user.length; i++) {
		if (user.charCodeAt(i)>127) {
			alert("Ths username contains invalid characters.");
			return false;
	   }
	}
	for (i=0; i<domain.length; i++) {
		if (domain.charCodeAt(i)>127) {
			alert("Ths domain name contains invalid characters.");
			return false;
	   }
	}
	if (user.match(userPat)==null) {
		// user is not valid
		alert("The username doesn't seem to be valid.");
		return false;
	}
/* if the e-mail address is at an IP address (as opposed to a symbolic
host name) make sure the IP address is valid. */
	var IPArray=domain.match(ipDomainPat);
	if (IPArray!=null) {
		// this is an IP address
		for (var i=1;i<=4;i++) {
			if (IPArray[i]>255) {
				alert("Destination IP address is invalid!");
				return false;
		   }
	}
	return true;
}

// Domain is symbolic name.  Check if it's valid.
 
var atomPat=new RegExp("^" + atom + "$");
var domArr=domain.split(".");
var len=domArr.length;
for (i=0;i<len;i++) {
if (domArr[i].search(atomPat)==-1) {
alert("The domain name does not seem to be valid.");
return false;
   }
}

/* domain name seems valid, but now make sure that it ends in a
known top-level domain (like com, edu, gov) or a two-letter word,
representing country (uk, nl), and that there's a hostname preceding 
the domain or country. */

if (checkTLD && domArr[domArr.length-1].length!=2 && 
domArr[domArr.length-1].search(knownDomsPat)==-1) {
alert("The address must end in a well-known domain or two letter " + "country.");
return false;
}

// Make sure there's a host name preceding the domain.

if (len<2) {
alert("This address is missing a hostname!");
return false;
}

// If we've gotten this far, everything's valid!
return true;
}

/* ***********************************
This function is used to format the number in double data type
*/
function format_number(pnumber,decimals) 
{  
  if (isNaN(pnumber)) { return 0};  
  if (pnumber=='') { return 0};  
   
  var IsNegative=(parseInt(pnumber)<0); 
  if(IsNegative)pnumber=-pnumber; 

  var snum = new String(pnumber);  
  var sec = snum.split('.');  
  var whole = parseInt(sec[0]);  
  var result = '';  
  if(sec.length > 1){  
  var dec = new String(sec[1]);  
  dec = parseInt(dec)/Math.pow(10,parseInt(dec.length-decimals-1)); 
  Math.round(dec); 
  dec = parseInt(dec)/10; 

  if(IsNegative) 
	{ 
	  var x = 0-dec; 
		  x = Math.round(x); 
	  dec = - x; 
	} 
  else 
	{ 
		  dec = Math.round(dec); 
	} 

/* 
 * If the number was rounded up from 9 to 10, and it was for 1 'decimal' 
 * then we need to add 1 to the 'whole' and set the dec to 0. 
 */ 
	if(dec==Math.pow(10, parseInt(decimals)))
	{ 
	  whole+=1; 
	  dec="0"; 
	} 

    dec = String(whole) + "." + String(dec);  
    var dot = dec.indexOf('.');  
    if(dot == -1){  
      dec += '.';  
      dot = dec.indexOf('.');  
    } 
	var l=parseInt(dot)+parseInt(decimals); 
    while(dec.length <= l) { dec += '0'; }  
    result = dec;  
  	} else{  
    var dot;  
    var dec = new String(whole);  
    dec += '.';  
    dot = dec.indexOf('.');  
	var l=parseInt(dot)+parseInt(decimals); 
    while(dec.length <= l) { dec += '0'; }  
    result = dec;  
  }  
  if(IsNegative)result="-"+result; 
  return result;  
} 

function bGetDate(sMonth,sDay,sYear)
{
	var strDate;
	strDate=""+sMonth+"/"+sDay+"/"+sYear;
	return strDate;
}

/***********************************************************
Function to Validate the date in MM/DD/YYYY format
/*************************************************************/
function isValidDate(dateStr) 
{
	// Checks for the following valid date formats:
	// DD/MM/YY   DD/MM/YYYY   DD-MM-YY   DD-MM-YYYY
	var datePat = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{4})$/; // requires 4 digit year
	var matchArray = dateStr.match(datePat); // is the format ok?
	/*if (matchArray == null) 
	{
		alert(dateStr + " Date is not in a valid format.")
		return false;
	}*/
	//alert(matchArray)
	day = matchArray[1];
	month = matchArray[3]; // parse date into variables
	year = matchArray[4];
	/*if (month < 1 || month > 12) 
	{ // check month range
		alert("Month must be between 1 and 12.");
		return false;
	}
	if (day < 1 || day > 31) {
	alert("Day must be between 1 and 31.");
	return false;
	}*/

	if ((month==4 || month==6 || month==9 || month==11) && day==31){
		alert("Month "+month+" doesn't have 31 days!")
		return false;
	}

	if (month == 2){ // check for february 29th
		var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
		if (day>29 || (day==29 && !isleap)){
			alert("February " + year + " doesn't have " + day + " days!");
			return false;
   		}
	}
	return true;
}


function ValidateDomain(str)
{
	checkTLD = 1;
	var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum|ws)$/;
	var specialChars="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";
	var validChars="\[^\\s" + specialChars + "\]";
	var quotedUser="(\"[^\"]*\")";
	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;
	var atom=validChars + '+';
	var word="(" + atom + "|" + quotedUser + ")";
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");
	str = str.toLowerCase();
	var resultStr = str.replace(/ /gi, "");
	//alert(resultStr);
	var wIndex = resultStr.indexOf("www");
	//alert(wIndex);
	var hIndex = resultStr.indexOf("http://");
	//alert(hIndex);
	var hsIndex = resultStr.indexOf("https://");
	//alert(hsIndex);
	var dotIndex = resultStr.lastIndexOf(".");
	var hLIndex = resultStr.lastIndexOf("/");
	var domain=resultStr.substring(hLIndex+1, resultStr.length);
	for (i=0; i<domain.length; i++) {
		if (domain.charCodeAt(i)>127) {
			alert("The Web Site Address contains invalid characters.");
			return false;
		   }
	}
	s_c="`~!#$%^&*'()+|}{[]?><,:;/-";						
	for(k=0;k<domain.length;k++)
	{			
	for(x=0; x<s_c.length; x++)
		{
		if((domain.substring(k,k+1) == s_c.substring(x,x+1)) || (domain.substring(x,x+1)==" ")){
			alert("The Web Site Address contains invalid characters.");
			return false;
			}
		}	
	}
	var IPArray=domain.match(ipDomainPat);
	if (IPArray!=null) {
		for (var i=1;i<=4;i++) {
			if (IPArray[i]>255) {
				alert("Destination IP address is invalid!");
				return false;
				}
			}
		return true;
	}else{
		var atomPat=new RegExp("^" + atom + "$");
		var domArr=domain.split(".");
		var len=domArr.length;
		
		if (checkTLD && domArr[domArr.length-1].length!=2 && domArr[domArr.length-1].search(knownDomsPat)==-1) {
			alert("The Web Site Address must end in a well-known domain or two letter " + "country.");
			return false;
		}
		if (len<2) {
			alert("The Web Site Address is missing a hostname!");
			return false;
		}
		if(hIndex < 0 && hsIndex < 0) {
			alert("Enter Full Web Site address including http:// or https://");
			return false;
		}
		return true
	}
}


/***********************************************************
Function to Validate the time with AM and PM
/*************************************************************/
function isValidTime(timeStr) 
{
	var timePat = /^(\d{1,2}):(\d{2})(:(\d{2}))?(\s?(AM|am|PM|pm))?$/;
	var matchArray = timeStr.match(timePat);
	if (matchArray == null) 
	{
		alert("Time is not in a valid format.");
		return false;
	}
	hour = matchArray[1];
	minute = matchArray[2];
	second = matchArray[4];
	ampm = matchArray[6];

	if (second=="") { second = null; }
	if (ampm=="") { ampm = null }

	if (hour < 0  || hour > 23) {
		alert("Hour must be between 1 and 12. (or 0 and 23 for military time)");
		return false;
	}
	if (hour <= 12 && ampm == null) {
		if (confirm("Please indicate which time format you are using.  OK = Standard Time, CANCEL = Military Time")) {
			alert("You must specify AM or PM.");
			return false;
		}
	}
	if  (hour > 12 && ampm != null) {
		alert("You can't specify AM or PM for military time.");
		return false;
	}
	if (minute < 0 || minute > 59) {
		alert ("Minute must be between 0 and 59.");
		return false;
	}
	if (second != null && (second < 0 || second > 59)) {
		alert ("Second must be between 0 and 59.");
		return false;
	}
	return true;
}

/***********************************************************
Function to caculate the difference between two dates
date should be in "MM/DD/YYYY" format and time should be in "HH:MM:SSam" format
/*************************************************************/
function dateDiff(strdt1,strtm1,strdt2,strtm2) {
	date1 = new Date();
	date2 = new Date();
	diff  = new Date();
	
	if (isValidDate(strdt1) && isValidTime(strtm1)) { // Validates first date 
	date1temp = new Date(strdt1 + " " + strtm1);
	date1.setTime(date1temp.getTime());
	}
	else return false; // otherwise exits
	
	if (isValidDate(strdt2) && isValidTime(strtm2)) { // Validates second date 
	date2temp = new Date(strdt2 + " " + strtm2);
	date2.setTime(date2temp.getTime());
	}
	else return false; // otherwise exits
	
	// sets difference date to difference of first date and second date
	
	diff.setTime(Math.abs(date1.getTime() - date2.getTime()));
	
	timediff = diff.getTime();
	
	/*weeks = Math.floor(timediff / (1000 * 60 * 60 * 24 * 7));
	timediff -= weeks * (1000 * 60 * 60 * 24 * 7);*/
	
	days = Math.floor(timediff / (1000 * 60 * 60 * 24)); 
	timediff -= days * (1000 * 60 * 60 * 24);
	
	/*hours = Math.floor(timediff / (1000 * 60 * 60)); 
	timediff -= hours * (1000 * 60 * 60);
	
	mins = Math.floor(timediff / (1000 * 60)); 
	timediff -= mins * (1000 * 60);
	
	secs = Math.floor(timediff / 1000); 
	timediff -= secs * 1000;*/
	
	//alert( days + " -days");
	
	return days; 
}

//***********************************************************
// GENERAL VALIDATION 
//***********************************************************

function Isvalidate(sText,vFstr)
{
	
	var IsRetValid = true;   
	var Mchar;
	for(i=0;i<sText.length && IsRetValid == true;i++){
		Mchar=sText.charAt(i);
		if (vFstr.indexOf(Mchar) == -1){         	
			IsRetValid = false;
		}
	}
	return IsRetValid; 
}
//--------------------------
//		To restrict some keys
//--------------------------
function fldcheck(e,validStr)
{
//alert(validStr)
var whichCode = (window.Event)? e.which : e.keyCode;
if (whichCode == 13) return true;  // Enter
var key = String.fromCharCode(whichCode);  // Get key value from key code
if (validStr.indexOf(key) == -1) return false;
}

/************************************************************
			CURRENCY FORMAT i.e. 100.00
*************************************************************/
function currencyFormat(fld, decSep, e, aftdec) {
var sep = 0;
var key = '';
var i = j = 0;
var len = len2 = 0;
var strCheck = '0123456789';
var aux = aux2 = '';
var whichCode = (window.Event) ? e.which : e.keyCode;
if (whichCode == 13) return true;  // Enter
key = String.fromCharCode(whichCode);  // Get key value from key code
if (strCheck.indexOf(key) == -1) return false;  // Not a valid key
len = fld.value.length;
for(i = 0; i < len; i++)
if ((fld.value.charAt(i) != '0') && (fld.value.charAt(i) != decSep)) break;
aux = '';
for(; i < len; i++)
if (strCheck.indexOf(fld.value.charAt(i))!=-1) aux += fld.value.charAt(i);
aux += key;
len = aux.length;
if (len == 0) fld.value = '';
if (aftdec == 3)
{
	if (len == 1) fld.value = '0'+ decSep + '0' + '0' +aux;
	if (len == 2) fld.value = '0'+ decSep + '0' + aux;
	if (len == 3) fld.value = '0'+ decSep + aux;
	if (len > 3) 
	{
		aux2 = '';
		for (j = 0, i = len - 4; i >= 0; i--)
		{
			//if (j == 3) {
			//aux2 += milSep;
			j = 0;
			//}
			aux2 += aux.charAt(i);
			j++;
		}
		fld.value = '';
		len2 = aux2.length;
		for (i = len2 - 1; i >= 0; i--)
		fld.value += aux2.charAt(i);
		fld.value += decSep + aux.substr(len - 3, len);
	}
	return false;
}else {
	if (len == 1) fld.value = '0'+ decSep + '0' + aux;
	if (len == 2) fld.value = '0'+ decSep + aux;
	if (len > 2) 
	{
		aux2 = '';
		for (j = 0, i = len - 3; i >= 0; i--)
		{
			//if (j == 3) {
			//aux2 += milSep;
			j = 0;
			//}
			aux2 += aux.charAt(i);
			j++;
		}
		fld.value = '';
		len2 = aux2.length;
		for (i = len2 - 1; i >= 0; i--)
		fld.value += aux2.charAt(i);
		fld.value += decSep + aux.substr(len - 2, len);
	}
	return false;
}

}

//****************************************************************
//
//****************************************************************
var isNav4 = false, isNav5 = false, isIE4 = false
var strSeperator = "/"; 
var vDateType = 3; // Global value for type of date format
//                1 = mm/dd/yyyy
//                2 = yyyy/dd/mm  (Unable to do date check at this time)
//                3 = dd/mm/yyyy
var vYearType = 4; //Set to 2 or 4 for number of digits in the year for Netscape
var vYearLength = 2; // Set to 4 if you want to force the user to enter 4 digits for the year before validating.
var err = 0; // Set the error code to a default of zero
if(navigator.appName == "Netscape") {
if (navigator.appVersion < "5") {
isNav4 = true;
isNav5 = false;
}
else
if (navigator.appVersion > "4") {
isNav4 = false;
isNav5 = true;
   }
}
else {
isIE4 = true;
}


function DateFormat(vDateName, vDateValue, e, dateCheck, dateType) 
{
	vDateType = dateType;
	// vDateName = object name
	// vDateValue = value in the field being checked
	// e = event
	// dateCheck 
	// True  = Verify that the vDateValue is a valid date
	// False = Format values being entered into vDateValue only
	// vDateType
	// 1 = mm/dd/yyyy
	// 2 = yyyy/mm/dd
	// 3 = dd/mm/yyyy
	//Enter a tilde sign for the first number and you can check the variable information.
	if (vDateValue == "~") 
	{
		alert("AppVersion = "+navigator.appVersion+" \nNav. 4 Version = "+isNav4+" \nNav. 5 Version = "+isNav5+" \nIE Version = "+isIE4+" \nYear Type = "+vYearType+" \nDate Type = "+vDateType+" \nSeparator = "+strSeperator);
		vDateName.value = "";
		vDateName.focus();
		return true;
	}
	var whichCode = (window.Event) ? e.which : e.keyCode;
	// Check to see if a seperator is already present.
	// bypass the date if a seperator is present and the length greater than 8
	if (vDateValue.length > 8 && isNav4) 
	{
		if ((vDateValue.indexOf("-") >= 1) || (vDateValue.indexOf("/") >= 1))
			return true;
	}
	//Eliminate all the ASCII codes that are not valid
	var alphaCheck = " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/-";
	if (alphaCheck.indexOf(vDateValue) >= 1) 
	{
		if (isNav4) 
		{
			vDateName.value = "";
			vDateName.focus();
			vDateName.select();
			return false;
		}
		else 
		{
			vDateName.value = vDateName.value.substr(0, (vDateValue.length));
			return false;
		   }
	}
	if (whichCode == 8) //Ignore the Netscape value for backspace. IE has no value
		return false;
	else 
	{
	//Create numeric string values for 0123456789/
	//The codes provided include both keyboard and keypad values
	var strCheck = '47,48,49,50,51,52,53,54,55,56,57,58,59,95,96,97,98,99,100,101,102,103,104,105';
	if (strCheck.indexOf(whichCode) != -1) 
	{
		if (isNav4) 
		{
			if (((vDateValue.length < 6 && dateCheck) || (vDateValue.length == 7 && dateCheck)) && (vDateValue.length >=1)) 
			{
				alert("Invalid Date\nPlease Re-Enter");
				vDateName.value = "";
				vDateName.focus();
				vDateName.select();
				return false;
			}
			if (vDateValue.length == 6 && dateCheck) 
			{
				var mDay = vDateName.value.substr(0,2);
				var mMonth = vDateName.value.substr(2,2);
				var mYear = vDateName.value.substr(4,4)
				//Turn a two digit year into a 4 digit year
				if (mYear.length == 2 && vYearType == 4) 
				{
					var mToday = new Date();
					//If the year is greater than 30 years from now use 19, otherwise use 20
					var checkYear = mToday.getFullYear() + 30; 
					var mCheckYear = '20' + mYear;
					if (mCheckYear >= checkYear)
					mYear = '19' + mYear;
					else
					mYear = '20' + mYear;
				}
				var vDateValueCheck = mMonth+strSeperator+mDay+strSeperator+mYear;
				if (!dateValid(vDateValueCheck)) 
				{
					alert("Invalid Date\nPlease Re-Enter");
					vDateName.value = "";
					vDateName.focus();
					vDateName.select();
					return false;
				}
			vDateName.value=mDay+"/"+mMonth+"/"+mYear;
			return true;
			}
			else 
			{
			// Reformat the date for validation and set date type to a 1
				if (vDateValue.length >= 8  && dateCheck) 
				{
					if (vDateType == 1) // mmddyyyy
					{
						var mDay = vDateName.value.substr(2,2);
						var mMonth = vDateName.value.substr(0,2);
						var mYear = vDateName.value.substr(4,4)
						vDateName.value = mMonth+strSeperator+mDay+strSeperator+mYear;
					}
					if (vDateType == 2) // yyyymmdd
					{
						var mYear = vDateName.value.substr(0,4)
						var mMonth = vDateName.value.substr(4,2);
						var mDay = vDateName.value.substr(6,2);
						vDateName.value = mYear+strSeperator+mMonth+strSeperator+mDay;
					}
					if (vDateType == 3) // ddmmyyyy
					{
						var mMonth = vDateName.value.substr(2,2);
						var mDay = vDateName.value.substr(0,2);
						var mYear = vDateName.value.substr(4,4)
						vDateName.value = mDay+strSeperator+mMonth+strSeperator+mYear;
					}
					//Create a temporary variable for storing the DateType and change
					//the DateType to a 1 for validation.
					var vDateTypeTemp = vDateType;
					vDateType = 1;
					var vDateValueCheck = mMonth+strSeperator+mDay+strSeperator+mYear;
					if (!dateValid(vDateValueCheck)) 
					{
						alert("Invalid Date\nPlease Re-Enter");
						vDateType = vDateTypeTemp;
						vDateName.value = "";
						vDateName.focus();
						vDateName.select();
						return false;
					}
					vDateType = vDateTypeTemp;
					vDateName.value = mDay+strSeperator+mMonth+strSeperator+mYear;
					return true;
				}
				else 
				{
				if (((vDateValue.length < 8 && dateCheck) || (vDateValue.length == 9 && dateCheck)) && (vDateValue.length >=1)) 
				{
					alert("Invalid Date\nPlease Re-Enter");
					vDateName.value = "";
					vDateName.focus();
					vDateName.select();
					return false;
				}
			}
		}
	}
	else 
	{
		// Non isNav Check
		if (((vDateValue.length < 8 && dateCheck) || (vDateValue.length == 9 && dateCheck)) && (vDateValue.length >=1)) 
		{
			alert("Invalid Date\nPlease Re-Enter");
			vDateName.value = "";
			vDateName.focus();
			return true;
		}
	// Reformat date to format that can be validated. mm/dd/yyyy
	if (vDateValue.length >= 8 && dateCheck) 
	{
		// Additional date formats can be entered here and parsed out to
		// a valid date format that the validation routine will recognize.
		if (vDateType == 1) // mm/dd/yyyy
		{
			var mMonth = vDateName.value.substr(0,2);
			var mDay = vDateName.value.substr(3,2);
			var mYear = vDateName.value.substr(6,4)
		}
		if (vDateType == 2) // yyyy/mm/dd
		{
			var mYear = vDateName.value.substr(0,4)
			var mMonth = vDateName.value.substr(5,2);
			var mDay = vDateName.value.substr(8,2);
		}
		if (vDateType == 3) // dd/mm/yyyy
		{
			var mDay = vDateName.value.substr(0,2);
			var mMonth = vDateName.value.substr(3,2);
			var mYear = vDateName.value.substr(6,4)
		}
		if (vYearLength == 4)
		{
			if (mYear.length < 4) 
			{
				alert("Invalid Date\nPlease Re-Enter");
				vDateName.value = "";
				vDateName.focus();
				return true;
			}
		}
		// Create temp. variable for storing the current vDateType
		var vDateTypeTemp = vDateType;
		// Change vDateType to a 1 for standard date format for validation
		// Type will be changed back when validation is completed.
		vDateType = 1;
		// Store reformatted date to new variable for validation.
		var vDateValueCheck = mMonth+strSeperator+mDay+strSeperator+mYear;
		if (mYear.length == 2 && vYearType == 4 && dateCheck) {
		//Turn a two digit year into a 4 digit year
		var mToday = new Date();
		//If the year is greater than 30 years from now use 19, otherwise use 20
		var checkYear = mToday.getFullYear() + 30; 
		var mCheckYear = '20' + mYear;
		if (mCheckYear >= checkYear)
			mYear = '19' + mYear;
		else
			mYear = '20' + mYear;
		vDateValueCheck = mMonth+strSeperator+mDay+strSeperator+mYear;
		// Store the new value back to the field.  This function will
		// not work with date type of 2 since the year is entered first.
		if (vDateTypeTemp == 1) // mm/dd/yyyy
			vDateName.value = mMonth+strSeperator+mDay+strSeperator+mYear;
		if (vDateTypeTemp == 3) // dd/mm/yyyy
			vDateName.value = mDay+strSeperator+mMonth+strSeperator+mYear;
	} 
	if (!dateValid(vDateValueCheck)) 
	{
		alert("Invalid Date\nPlease Re-Enter");
		vDateType = vDateTypeTemp;
		vDateName.value = "";
		vDateName.focus();
		return true;
	}
	vDateType = vDateTypeTemp;
	if((vDateType == 3) && dateCheck)
	{
		vDateName.value = mDay+strSeperator+mMonth+strSeperator+mYear;
	}
	return true;
}
else 
{
	if (vDateType == 1) 
	{
		if (vDateValue.length == 2) 
		{
			vDateName.value = vDateValue+strSeperator;
		}
		if (vDateValue.length == 5) 
		{
			vDateName.value = vDateValue+strSeperator;
		}
	}
	if (vDateType == 2)
	{
		if (vDateValue.length == 4) 
		{
			vDateName.value = vDateValue+strSeperator;
		}
		if (vDateValue.length == 7) 
		{
			vDateName.value = vDateValue+strSeperator;
		}
	} 
	if (vDateType == 3) 
	{
		if (vDateValue.length == 2) 
		{
			vDateName.value = vDateValue+strSeperator;
		}
		if (vDateValue.length == 5) 
		{
			vDateName.value = vDateValue+strSeperator;
	    }
	}
	return true;
   }
}
if (vDateValue.length == 10&& dateCheck) 
{
	if (!dateValid(vDateName)) 
	{
		// Un-comment the next line of code for debugging the dateValid() function error messages
		//alert(err);  
		alert("Invalid Date\nPlease Re-Enter");
		vDateName.focus();
		vDateName.select();
	}
	else
	{
		if((vDateType == 3) && dateCheck)
		{
			vDateName.value = mDay+strSeperator+mMonth+strSeperator+mYear;
		}
	}
	
}

return false;
}
else {
// If the value is not in the string return the string minus the last
// key entered.
if (isNav4) {
vDateName.value = "";
vDateName.focus();
vDateName.select();
return false;
}
else
{
vDateName.value = vDateName.value.substr(0, (vDateValue.length));
return false;
         }
      }
   }
}
function dateValid(objName) {
var strDate;
var strDateArray;
var strDay;
var strMonth;
var strYear;
var intday;
var intMonth;
var intYear;
var booFound = false;
var datefield = objName;
var strSeparatorArray = new Array("-"," ","/",".");
var intElementNr;
// var err = 0;
var strMonthArray = new Array(12);
strMonthArray[0] = "Jan";
strMonthArray[1] = "Feb";
strMonthArray[2] = "Mar";
strMonthArray[3] = "Apr";
strMonthArray[4] = "May";
strMonthArray[5] = "Jun";
strMonthArray[6] = "Jul";
strMonthArray[7] = "Aug";
strMonthArray[8] = "Sep";
strMonthArray[9] = "Oct";
strMonthArray[10] = "Nov";
strMonthArray[11] = "Dec";
//strDate = datefield.value;
strDate = objName;
if (strDate.length < 1) {
return true;
}
for (intElementNr = 0; intElementNr < strSeparatorArray.length; intElementNr++) {
if (strDate.indexOf(strSeparatorArray[intElementNr]) != -1) {
strDateArray = strDate.split(strSeparatorArray[intElementNr]);
if (strDateArray.length != 3) {
err = 1;
return false;
}
else {
strDay = strDateArray[0];
strMonth = strDateArray[1];
strYear = strDateArray[2];
}
booFound = true;
   }
}
if (booFound == false) {
if (strDate.length>5) {
strDay = strDate.substr(0, 2);
strMonth = strDate.substr(2, 2);
strYear = strDate.substr(4);
   }
}
//Adjustment for short years entered
if (strYear.length == 2) {
strYear = '20' + strYear;
}
strTemp = strDay;
strDay = strMonth;
strMonth = strTemp;
intday = parseInt(strDay, 10);
if (isNaN(intday)) {
err = 2;
return false;
}
intMonth = parseInt(strMonth, 10);
if (isNaN(intMonth)) {
for (i = 0;i<12;i++) {
if (strMonth.toUpperCase() == strMonthArray[i].toUpperCase()) {
intMonth = i+1;
strMonth = strMonthArray[i];
i = 12;
   }
}
if (isNaN(intMonth)) {
err = 3;
return false;
   }
}
intYear = parseInt(strYear, 10);
if (isNaN(intYear)) {
err = 4;
return false;
}
if (intMonth>12 || intMonth<1) {
err = 5;
return false;
}
if ((intMonth == 1 || intMonth == 3 || intMonth == 5 || intMonth == 7 || intMonth == 8 || intMonth == 10 || intMonth == 12) && (intday > 31 || intday < 1)) {
err = 6;
return false;
}
if ((intMonth == 4 || intMonth == 6 || intMonth == 9 || intMonth == 11) && (intday > 30 || intday < 1)) {
err = 7;
return false;
}
if (intMonth == 2) {
if (intday < 1) {
err = 8;
return false;
}
if (LeapYear(intYear) == true) {
if (intday > 29) {
err = 9;
return false;
   }
}
else {
if (intday > 28) {
err = 10;
return false;
      }
   }
}
return true;
}
function LeapYear(intYear) {
if (intYear % 100 == 0) {
if (intYear % 400 == 0) { return true; }
}
else {
if ((intYear % 4) == 0) { return true; }
}
return false;
}

//*****************************************************88
//				Valid Date of Birth
//******************************************************

function isValidDateOfBirth(day,month,year)
{
	var isValid= true;
	var nowDate = new Date();
	year = parseInt(year);
	dateofBirth = new Date(year+"/"+month+"/"+day);
	if(!this.isValidDate(""+day+"/"+month+"/"+year+""))
	{
		isValid = false;
	}
	else if (dateofBirth > nowDate || (year + 140) < nowDate.getFullYear())
	{
		isValid = false;
	}
	return isValid;
}

/*
==================================================================
LTrim(string) : Returns a copy of a string without leading spaces.
==================================================================
*/
function LTrim(str)
/*
   PURPOSE: Remove leading blanks from our string.
   IN: str - the string we want to LTrim
*/
{
   var whitespace = new String(" \t\n\r");
   var s = new String(str);
   if (whitespace.indexOf(s.charAt(0)) != -1) 
   {
		var j=0, i = s.length;
		while (j < i && whitespace.indexOf(s.charAt(j)) != -1)
		 j++;
		s = s.substring(j, i);
	}
   return s;
}

/*
==================================================================
RTrim(string) : Returns a copy of a string without trailing spaces.
==================================================================
*/
function RTrim(str)
/*
   PURPOSE: Remove trailing blanks from our string.
   IN: str - the string we want to RTrim
*/
{
   var whitespace = new String(" \t\n\r");
   var s = new String(str);
   if (whitespace.indexOf(s.charAt(s.length-1)) != -1) {
	  var i = s.length - 1;       // Get length of string
	  while (i >= 0 && whitespace.indexOf(s.charAt(i)) != -1)
		 i--;
	  s = s.substring(0, i+1);
	}
   return s;
}
/*
=============================================================
Trim(string) : Returns a copy of a string without leading or trailing spaces
=============================================================
*/
function Trim(str)
/*
   PURPOSE: Remove trailing and leading blanks from our string.
   IN: str - the string we want to Trim
   RETVAL: A Trimmed string!
*/
{
   return RTrim(LTrim(str));
}

function ToDay()
{
	var dt = new Date();
	var iDate=dt.getDate();
	var iMonth =dt.getMonth()+1;
	var sYear = dt.getYear()+"";
	var sDate = String(iDate);
	if(sDate.length ==1)
		sDate="0"+sDate;
	var sMonth = String(iMonth);
	if(sMonth.length == 1)
		sMonth="0"+sMonth;
	var sToday = sDate+"/"+sMonth+"/"+sYear;
	return sToday;
}

function NxtYear()
{
	var dt = new Date();
	var iDate=dt.getDate();
	var iMonth =dt.getMonth()+1;
	var iYear = dt.getYear()+1;
	var sYear = String(iYear);
	var sDate = String(iDate);
	if(sDate.length ==1)
		sDate="0"+sDate;
	var sMonth = String(iMonth);
	if(sMonth.length == 1)
		sMonth="0"+sMonth;
	var sToday = sDate+"/"+sMonth+"/"+sYear;
	return sToday;
}

function sHour()
{
	var dt = new Date();
	var mHour = String(dt.getHours());
	if(mHour.length == 1)
		mHour="0"+mHour;
	return mHour;
}

function sMinute()
{
	var dt = new Date();
	var mMinutes = String(dt.getMinutes());
	if(mMinutes.length == 1)
		mMinutes = "0"+mMinutes;
	return mMinutes;
}

function Toggle(e, cName, frmName)
    {
	if (e.checked) {
	    //Highlight(e);
	    frmName.toggleAll.checked = AllChecked(cName, frmName);
	}
	else {
	   // Unhighlight(e);
	    frmName.toggleAll.checked = false;
	}
    }

    function ToggleAll(e, cName, frmName, toWrite)
    {
	if (e.checked) {
	    CheckAll(cName, frmName, toWrite);
	}
	else {
	    ClearAll(cName, frmName, toWrite);
	}
    }

    function Check(e)
    {
	e.checked = true;
	//Highlight(e);
    }

    function Clear(e)
    {
	e.checked = false;
	//Unhighlight(e);
    }
	//check all selection with the name cName
    function CheckAll(cName, frmName, toWrite)
    {
	//alert(toWrite);
	//var ml1 = frmName.value;
	var ml = frmName;
	//alert(ml);
	var len = ml.elements.length;
	for (var i = 0; i < len; i++) {
	    var e = ml.elements[i];
	    if (e.name == cName) {
		Check(e);
	    }
	}
	//if(toWrite){writeInside("<A href=\"javascript:ClearAll('"+cName+"', "+ml+", true);\">CLEAR ALL</A>", "Layer1")};
	ml.toggleAll.checked = true;
    }
	//clear all selection with the name cName
    function ClearAll(cName, frmName, toWrite)
    {
	//var ml = document.frmListCon;
	//var ml1 = "'"+frmName+"'";
	//alert(ml);
	var ml = frmName;
	var len = ml.elements.length;
	for (var i = 0; i < len; i++) {
	    var e = ml.elements[i];
	    if (e.name == cName) {
		Clear(e);
	    }
	}
	//if(toWrite){writeInside("<A href=\"javascript:CheckAll('"+cName+"', "+ml+", true);\">CHECK ALL</A>", "Layer1")};
	ml.toggleAll.checked = false;
    }

    
    function AllChecked(cName, frmName)
    {
	ml = frmName;
	len = ml.elements.length;
	for(var i = 0 ; i < len ; i++) {
	    if (ml.elements[i].name == cName && !ml.elements[i].checked) {
		return false;
	    }
	}
	return true;
    }
	//writes any text ans inside any layer frmType
    function writeInside(ans, frmType){
	if(ie4){document.all[frmType].innerHTML = ans}
	else
		{
			document.layers[frmType].document.open()
			document.layers[frmType].document.write(ans)
			document.layers[frmType].document.close()
		}
	}
/*==================================
FUNCTION TO FORMAT THE CURRENCY
====================================*/	
	function formatCurrency(num)
	{
		num = num.toString().replace(/\$|\,/g,'');
		if(isNaN(num))
		num = "0";
		sign = (num == (num = Math.abs(num)));
		num = Math.floor(num*100+0.50000000001);
		cents = num%100;
		num = Math.floor(num/100).toString();
		if(cents<10)
		cents = "0" + cents;
		for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++)
		num = num.substring(0,num.length-(4*i+3))+ num.substring(num.length-(4*i+3));
		return (((sign)?'':'-') + num + '.' + cents);
	}
	
	
function MM_reloadPage(init) {  
  if (init==true) with (navigator) {if ((appName=="Netscape")&&(parseInt(appVersion)==4)) {
    document.MM_pgW=innerWidth; document.MM_pgH=innerHeight; onresize=MM_reloadPage; }}
  else if (innerWidth!=document.MM_pgW || innerHeight!=document.MM_pgH) location.reload();
}
MM_reloadPage(true);
// -->

function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

function MM_preloadImages() { //v3.0
  var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
    var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
    if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}
}

function MM_findObj(n, d) { //v4.0
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
  if(!x && document.getElementById) x=document.getElementById(n); return x;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}

function MM_showHideLayers() { //v3.0
  var i,p,v,obj,args=MM_showHideLayers.arguments;
  for (i=0; i<(args.length-2); i+=3) if ((obj=MM_findObj(args[i]))!=null) { v=args[i+2];
    if (obj.style) { obj=obj.style; v=(v=='show')?'visible':(v='hide')?'hidden':v; }
    obj.visibility=v; }
}