<!-- check the email address is valid -->

    function emailCheck (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("You seem to have entered an invalid email address. Please check the format (e.g. name@company.com) and try again.")
		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 first half of your email address (before the @) seems to be invalid. You may have used invalid characters such as space or ( ) < > , ; : \ \" [ ]. Please check and try again.")
	    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("You seem to have entered an invalid email address.  Please check and try again.")
			return false
		    }
	    }
	    return true
	}

	// Domain is symbolic name
	var domainArray=domain.match(domainPat)
	if (domainArray==null) {
		alert("The second half of your email address (after the @) seems to be invalid. You may have entered it incorrectly or used invalid characters such as space or ( ) < > , ; : \ \" [ ]. Please check and try again.")
	    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>6) {
	   // the address must end in a two letter or three letter word.
	   alert("The end of your email address (.com, .co.uk, museum, etc) isn't recognized as a valid country code. Please check and try again.")
	   return false
	}

	// Make sure there's a host name preceding the domain.
	if (len<2) {
	   var errStr="You seem to have entered an invalid email address.  Please check and try again."
	   alert(errStr)
	   return false
	}

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

	
    function mailfriend() {
        itm = eval("document.forms['inputform'].email.value");
        doSubmit = 'true';
        if ( itm == "" || itm == null ) { 
			alert("Please enter an email address");
			doSubmit =  'false';
        } 
        userarray = new Array();
        userarray = itm.split(', ');
        usernum = userarray.length;
        if (usernum > 10) {
                alert("You may only send a release to a maximum of 10 addresses.");
                doSubmit =  'false';
        } else {
                for (i=0; i<usernum; i++) {
                        if (!emailCheck (userarray[i])) {
                                j = i+1;
                                if ( j > 1 ) {
                                        alert("The problem is in email address number: " + j);
                                }
                                doSubmit =  'false';
                        }
                }
        }
        if ( doSubmit == 'true' ) {
                mailAfriendRefresh();
                document.forms['inputform'].submit();
        }
    }

    function mailAfriendRefresh() {
    itm = eval("document.forms['inputform'].email.value");
            msg = "Release sent to: ";
            userarray = new Array();
            userarray = itm.split(', ');
            usernum = userarray.length;
            for (i=0; i<usernum; i++) {
                    msg += "\n       "+userarray[i];
            }

            alert(msg);
    }

    function checkEmailScreen(){
        var isFieldOK       = true;
        var isScreenOK      = true;
        var alertStr        = "";
        var toAddrMsg       = "";

        // validate the user name
        isFieldOK = checkNullSpaces("user_name");
        if(!isFieldOK){
            isScreenOK = false;
            alertStr = alertStr + "Please enter your name" + "\n";
        }

        // validate the from address
        isFieldOK = checkNullSpaces("from_address");
        if(!isFieldOK){
            isScreenOK = false;
            alertStr = alertStr + "Please enter your From email address" + "\n";
        }

        // validate the to address
        isFieldOK = checkNullSpaces("to_addresses");
        if(!isFieldOK){
            isScreenOK = false;
            alertStr = alertStr + "Please enter at least one destination email address" + "\n";
        }


        // validate the format of the from address
        isFieldOK = emailCheckNoAlert(trimWhitespace(document.forms.inputform.from_address.value));
        if(!isFieldOK){
            isScreenOK = false;
            alertStr = alertStr + "The format of the From email address is incorrect" + "\n";
        }

        // validate the format of the to_address
        toAddrMsg = validateToAddresses();
        if(toAddrMsg!=""){
            alertStr = alertStr + toAddrMsg;
            isScreenOK = false;
        }

        if(!isScreenOK){
        alert(alertStr);
        }

        return isScreenOK;
    }

    function validateToAddresses(){
      // general vars
      var index          = 0;
      var oneAddress     = "";
      var res            = false;
      var msg            = "";
      var allAddressesWS = document.forms.inputform.to_addresses.value;
      var allAddresses   = "";


      // convert the enter character to ' ', then trim (includes getting rid of consecutive ' ')
      for(index = 0; index<allAddressesWS.length; index++){
        if(   allAddressesWS.charCodeAt(index) == 10
           || allAddressesWS.charCodeAt(index) == 13){
             allAddresses += ' ';
        }else{
             allAddresses += allAddressesWS.charAt(index);
        }
      }

      // trim the to addresses
      allAddresses = trimWhitespace(allAddresses);

      // loop through and validate each email address
      for(index = 0; index < allAddresses.length; index++){
        if(   allAddresses.charCodeAt(index) != 32){
          oneAddress += allAddresses.charAt(index);
        }else{
          if(oneAddress!=""){
            res = emailCheckNoAlert(oneAddress);
            if(!res){
              if(msg == ""){
                msg = "The following email addresses are invalid:" + "\n";
              }
              msg +="   " + oneAddress + "\n";
            }
            oneAddress = "";
          }
        }
      }

      // perform the same check on the last one
      if(oneAddress!=""){
        res = emailCheckNoAlert(oneAddress);
        if(!res){
          if(msg == ""){
            msg += "The following To email addresses are invalid:" + "\n";
          }
          msg += "   " + oneAddress + "\n";
        }
      }

      return msg;
    }

    function emailCheckNoAlert (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. */
                return false
        }
        var user=matchArray[1]
        var domain=matchArray[2]

        // See if "user" is valid
        if (user.match(userPat)==null) {
            // user is not 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) {
                    return false
                }
            }
            return true
        }

        // Domain is symbolic name
        var domainArray=domain.match(domainPat)
        if (domainArray==null) {
            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>6) {
           // the address must end in a two letter or three letter word.
           return false
        }

        // Make sure there's a host name preceding the domain.
        if (len<2) {
           return false
        }

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

    function trimWhitespace(inputString) {
      // Removes leading and trailing spaces from the passed string. Also
      // removes consecutive spaces and replaces it with one space.
      var retValue = inputString;
      var ch = retValue.substring(0, 1);
      while (ch == " ") { // Check for spaces at the beginning of the string
         retValue = retValue.substring(1, retValue.length);
         ch = retValue.substring(0, 1);
      }
      ch = retValue.substring(retValue.length-1, retValue.length);
      while (ch == " ") { // Check for spaces at the end of the string
         retValue = retValue.substring(0, retValue.length-1);
         ch = retValue.substring(retValue.length-1, retValue.length);
      }
      while (retValue.indexOf("  ") != -1) { // Note that there are two spaces in the string - look for multiple spaces within the string
         retValue = retValue.substring(0, retValue.indexOf("  ")) + retValue.substring(retValue.indexOf("  ")+1, retValue.length); // Again, there are two spaces in each of the strings
      }
      return retValue; // Return the trimmed string
   } // Ends the "trim" function
       
   function emailThis(url){       
     window.open(url,'Email','toolbar=yes,menubar=yes,scrollbars=yes,resizable=no,status=yes,location=no,directories=no,width=700,height=600');
   }