function isDate(dateStr)
{
	// Checks for the following valid date formats:
	// old (MM/DD/YYYY   MM-DD-YYYY)
	//alert ("st :"+dateStr+": end");

	//var datePat = /^(\d{1,2})(\/|-|.)(\d{1,2})\2(\d{4})$/;
	//var datePat = /^(\d{1,2})(\/|-|.)(\d{1,2})\2(\d{4})$/;
	var matchArray =dateStr.split("/");
	var len = matchArray.length;
	if(len!=3)
		return false;
	//var matchArray = dateStr.match(datePat)
	//if (matchArray == null)
		//return false
	month = matchArray[1]
	day = matchArray[0]
	year = matchArray[2]
	
	if(isNaN(month) || isNaN(day) || isNaN(year))
		return false;
	if (month < 1 || month > 12)
		return false

	if (day < 1 || day > 31)
		return false

	if(year.length!=4)
		return false;
	
	//if(year <1940 || year>2025)
		//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 emailCheck(objEmail)
{
	if(objEmail.value=="")
	{
		alert("Pleae enter your email address");
		//form1.email.select();
		return false;
	}
	
	else
	{
		var mail=objEmail.value;
		aindex=mail.indexOf("@");
		nexta=mail.lastIndexOf("@");
		dotindex=mail.lastIndexOf(".");
		if((aindex > 0)&&(aindex==nexta)&&(dotindex>aindex)&&((dotindex-aindex)>1))
		{
			return true;
		}
		else
		{	
			alert("Enter your email in proper format.");
			//form1.email.select();
			return false;
		}	
		
	}
}
function emailCheck1 (emailStr) {
/* The following pattern is used to check if the entered e-mail address
   fits the user@domain format.  It also is used to separate the username
   from the domain. */
var emailPat=/^(.+)@(.+)$/
/* The following string represents the pattern for matching all special
   characters.  We don't want to allow special characters in the address. 
   These characters include ( ) < > @ , ; : \ " . [ ]    */
var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]"
/* The following string represents the range of characters allowed in a 
   username or domainname.  It really states which chars aren't allowed. */
var validChars="\[^\\s" + specialChars + "\]"
/* The following pattern applies if the "user" is a quoted string (in
   which case, there are no rules about which characters are allowed
   and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com
   is a legal e-mail address. */
var quotedUser="(\"[^\"]*\")"
/* The following pattern applies for domains that are IP addresses,
   rather than symbolic names.  E.g. joe@[123.124.233.4] is a legal
   e-mail address. NOTE: The square brackets are required. */
var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
/* The following string represents an atom (basically a series of
   non-special characters.) */
var atom=validChars + '+'
/* The following string represents one word in the typical username.
   For example, in john.doe@somewhere.com, john and doe are words.
   Basically, a word is either an atom or quoted string. */
var word="(" + atom + "|" + quotedUser + ")"
// The following pattern describes the structure of the user
var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
/* The following pattern describes the structure of a normal symbolic
   domain, as opposed to ipDomainPat, shown above. */
var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")


/* Finally, let's start trying to figure out if the supplied address is
   valid. */

/* Begin with the coarse pattern to simply break up user@domain into
   different pieces that are easy to analyze. */
var matchArray=emailStr.match(emailPat)
if (matchArray==null) {
  /* Too many/few @'s or something; basically, this address doesn't
     even fit the general mould of a valid e-mail address. */
	alert("Email address seems incorrect (check @ and .'s)")
	return false
}
var user=matchArray[1]
var domain=matchArray[2]

// See if "user" is valid 
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
var domainArray=domain.match(domainPat)
if (domainArray==null) {
	alert("The domain name doesn't seem to be valid.")
    return false
}

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

/* Now we need to break up the domain to get a count of how many atoms
   it consists of. */
var atomPat=new RegExp(atom,"g")
var domArr=domain.match(atomPat)
var len=domArr.length
if (domArr[domArr.length-1].length<2 || 
    domArr[domArr.length-1].length>3) {
   // the address must end in a two letter or three letter word.
   alert("The address must end in a three-letter domain, or two letter country.")
   return false
}

// Make sure there's a host name preceding the domain.
if (len<2) {
   var errStr="This address is missing a hostname!"
   alert(errStr)
   return false
}

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

function IsNumber(Expression)
{
	Expression = Expression.toLowerCase();
	RefString = ".0123456789";

	if (Expression.length < 1) 
		return (false);
	var count =0;
	for (var i = 0; i < Expression.length; i++) 
	{
		var ch = Expression.substr(i, 1)
		var a = RefString.indexOf(ch, 0)
		if (a == -1)
			return (false);
		if(ch=='.')	
			count++;
		if(count>1)	
			return false;
	}
	return(true);
}
function Trim(myval)
{
	var chklen=myval.length; 
	var pos=0;
	mychar = myval.charAt(0);

	while(pos>=0 || lstpos >=0)
	{
		pos=myval.indexOf(" ");
		if (pos==0)
		{
			myval=myval.substring(1,chklen);
			chklen = myval.length;
			mychar = myval.charAt(0);
		}
		lstpos=myval.lastIndexOf(" ");

		if (lstpos==chklen-1)
		{	
			myval=myval.substring(0,chklen-1);
			chklen=myval.length;
			mychar = myval.charAt(chklen-1);
		}
		
		if(mychar!=" ")
			break;

	}
	return myval;			
}

function CheckUncheckAll(frm,chk)
{
	
	if(chk.name.substr(0,8)!="CheckAll")
	{
			
		CheckName = chk.name;
		MyChecked	= true;

		for(i=0;i<frm.elements.length;i++)
		{
			if(frm.elements[i].name==CheckName && frm.elements[i].checked==false)
				MyChecked=false;
		}

		CheckAll = eval("frm.CheckAll_"+CheckName);
		CheckAll.checked=MyChecked;
	}		
	else
	{
		CheckName = chk.name.substr(9,chk.name.length);

		if(chk.checked==true)
			AllChecked = true;
		else
			AllChecked = false;
		for(i=0;i<frm.elements.length;i++)
		{
			if(frm.elements[i].name==CheckName)
			{
				
				frm.elements[i].checked=AllChecked;		
			}
		}
	}
}