function validateData(validateFormElement,validateCommand,commandVar1) 
{ 
   //returns true if found a problem, false if didn't find problem
    switch(validateCommand) 
    { 
	case "emptyString":
	{
		var validateString = validateFormElement.value;
		if((validateString==null)||(validateString.length==0))
			return true;
		else
			return false;
		break;
	}
        
	case "whiteSpace": 
         { 
 	   var validateString = validateFormElement.value;
           var reWhiteSpace = new RegExp(/\s/);
	   if (reWhiteSpace.test(validateString)) 
		return true;
	   else
		return false;
           break;             
         }

        case "maxLength": 
          { 
   	var validateString = validateFormElement.value;
             if(eval(validateString.length) >  commandVar1) 
             	return true;
	     else
		return false;
             break; 
          }
     
        case "minLength": 
           { 
             var validateString = validateFormElement.value;
		if(eval(validateString.length) <  commandVar1) 
             	return true;
	     else
		return false;
             break; 
            }

        case "alphanumeric": 
           { 
              var validateString = validateFormElement.value;

	     var alphaExp = /^[0-9a-zA-Z]+$/;
	     if(!(validateString.match(alphaExp)))
		return true;
	     else
		return false;
              break; 
           }
   case "includesalphanumeric": 
           { 
              var validateString = validateFormElement.value;

	      var alphaExp =new RegExp( /^[0-9a-zA-Z]/);

	   if (alphaExp.test(validateString)) 
		return true;
	     else
		return false;
              break; 
           }      
        case "numeric": 
           { 
              var validateString = validateFormElement.value;
		var charpos = validateString.search("[^0-9]"); 
              if(charpos >= 0) 
		return true;
	     else
		return false;
              break;               
           }

        case "alphabetic": 
           { 
              var validateString = validateFormElement.value;
		var charpos = validateString.search("[^A-Za-z]"); 
              if(charpos >= 0) 
                  return true;
	      else
		return false;    
              break; 
           }

  case "alphaNumHyphenSpace":
 {
              var validateString = validateFormElement.value;
		var charpos = validateString.search("[^A-Za-z0-9\-_]"); 
              if(charpos >= 0) 
                return true;
	      else
		return false;    
              break; 
	   }


	  case "alphaNumHyphen":
	 {
              var validateString = validateFormElement.value;
		var charpos = validateString.search("[^A-Za-z0-9\-_]"); 
              if(charpos >= 0) 
                return true;
	      else
		return false;    
              break; 
	   }

        case "email": 
          { 
/*
    		var validateString = validateFormElement.value;

		 
			var splitted = validateString.match("^(.+)@(.+)$");
    		if(splitted == null) 
			return true;
		

    		if(splitted[1] != null )
    		{
     			 var regexp_user=/^\"?[\w-_\.]*\"?$/;
     			 if(splitted[1].match(regexp_user) == null) 
        		 return true;
    		}
    		if(splitted[2] != null)
    		{
     			 var regexp_domain=/^[\w-\.]*\.[A-Za-z]{2,4}$/;
      			if(splitted[2].match(regexp_domain) == null) 
      			{
	    			var regexp_ip =/^\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\]$/;
	    			if(splitted[2].match(regexp_ip) == null) 
					return true;
      			}
			var second_splitted = splitted[2].split(".");
			//alert ("first part second split"+second_splitted[1]); 
			if(second_splitted[1]!=null)
			{
				var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;
			 	if((second_splitted[1].length!=2) && (second_splitted[1].match(knownDomsPat)==null)){
					return true;
				}
			}

			
    		}
		
//mtschofe@arts.ryerson.ca
		
		return false;    
		*/
var emailStr =validateFormElement.value;
/* 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 true;
}
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 true;
}

/* 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 true;
	    }
    }
    return false;
}

// Domain is symbolic name
var domainArray=domain.match(domainPat);
if (domainArray==null) {
	//alert("The domain name doesn't seem to be valid.")
    return true;
}

/* 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 true;
}

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

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


           	break; 
          }
          
          
          
          
          
          
 
        case "noDropDownSelected": 
         { 
            if((validateFormElement.selectedIndex == null)||(validateFormElement.selectedIndex == 0)) 
              return true;
            else
	      return false; 
             break; 
         }
    }//switch 

    return false; 
}