function checkInt(a)
	{
		if (a.split(" ").join("").length ==0)
		{
			return false;
		}
		var Anum = "0123456789.";
		for (i=0;i<a.length;i++)
		{
			if (Anum.indexOf(a.substr(i,1)) == -1)
			{
				//alert(Anum.indexOf(a.substr(i,1)) + "," + a.substr(i,1));
				return false;
			}
			
		}
		return true;
}
function emailCheck(objEmail)
{
	if(objEmail.value=="")
	{
		//alert("Enter your email pls....");
		//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("Please enter Correct Email address")
	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("Please enter Correct Email address")
    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 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;		
			}
		}
	}
}