//------------+
//  Overview  |
//------------+

// <<< General >>>
//
//	Author: Sean Mlinscek <sean.mlinscek@stryker.com>
//	Date:   2004.05.04


// <<< Changelog >>>
//      2004.09.28 - Added emailCheck function. 


//----------------------------------------
// <void> emailCheck()
//----------------------------------------
// - Description:
//	Checks to see if an email address is filled
//      in correctly within a form. 
//
// - Returns: None
//
// - Parameters: 
//      1. formField - The form field the function is checking
//      2. formName - The name of the form the field above is 
//      associated with.
//
// - Details:
//     This script and many more are available free online at
//     The JavaScript Source!! http://javascript.internet.com
//     
//     V1.1.3: Sandeep V. Tamhankar (stamhankar@hotmail.com)
//     Original:  Sandeep V. Tamhankar (stamhankar@hotmail.com)
//
// - Changelog:
//     1.1.5 - (2004.09.28): Added formField and formName parameters so when
//     a user incorrectly enters an email address they will be 
//     redirected back to the Email Address form field.
//
//     1.1.4: Fixed a bug where upper ASCII characters (i.e. accented letters
//     international characters) were allowed.
//
//     1.1.3: Added the restriction to only accept addresses ending in two
//     letters (interpreted to be a country code) or one of the known
//     TLDs (com, net, org, edu, int, mil, gov, arpa), including the
//     new ones (biz, aero, name, coop, info, pro, museum).  One can
//     easily update the list (if ICANN adds even more TLDs in the
//     future) by updating the knownDomsPat variable near the
//     top of the function.  Also, I added a variable at the top
//     of the function that determines whether or not TLDs should be
//     checked at all.  This is good if you are using this function
//     internally (i.e. intranet site) where hostnames don't have to 
//     conform to W3C standards and thus internal organization e-mail
//     addresses don't have to either.
//     Changed some of the logic so that the function will work properly
//     with Netscape 6.
//        
//     1.1.2: Fixed a bug where trailing . in e-mail address was passing
//     (the bug is actually in the weak regexp engine of the browser; I
//     simplified the regexps to make it work).
//     
//     1.1.1: Removed restriction that countries must be preceded by a domain,
//     so abc@host.uk is now legal.  However, there's still the 
//     restriction that an address must end in a two or three letter
//     word.
//       
//     1.1: Rewrote most of the function to conform more closely to RFC 822.
//     
//     1.0: Original  

function emailCheck (formField,formName) {
   var emailStr = eval("window.document."+formName+"."+formField+".value");
   var showFocus = "window.document."+formName+"."+formField+".focus();";

   /* 
      The following variable tells the rest of the function whether or not
      to verify that the address ends in a two-letter country or well-known
      TLD.  1 means check it, 0 means don't. 
   */
   var checkTLD=1;

   // The following is the list of known TLDs that an e-mail address must end with.
   var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;

   /* 
      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 a valid Email Address. (check @ and .)");
      eval(showFocus);
      return false;
   }
         
   var user=matchArray[1];
   var domain=matchArray[2];

   // Start by checking that only basic ASCII characters are in the strings (0-127).
   for (i=0; i<user.length; i++) {
      if (user.charCodeAt(i)>127) {
         alert("The Email Address\' username contains invalid characters.");
         eval(showFocus);
         return false;
      }
   }
   for (i=0; i<domain.length; i++) {
      if (domain.charCodeAt(i)>127) {
         alert("The Email Address\' domain name contains invalid characters.");
         eval(showFocus);
         return false;
      }
   }

   // See if "user" is valid 
   if (user.match(userPat)==null) {
      // user is not valid
      alert("The Email Address\' username is not valid.");
      eval(showFocus);
      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("The Email Address\' Destination IP address is invalid!");
            eval(showFocus);
            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 Email Address\' domain name is not valid.");
         eval(showFocus);
         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 Email Address must end in a well-known domain or two letter " + "country.");
      eval(showFocus);
      return false;
   }
 
   // Make sure there's a host name preceding the domain.
   if (len<2) {
      alert("The Email Address is missing a hostname.");
      eval(showFocus);
      return false;
   }

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


//----------------------------------------
// <void> formValidation()
//----------------------------------------
// - Description:
//	Checks to see if a required form field is filled. 
//
// - Returns: None
//
// - Parameters:
//
// - Details:
//
// - Changelog:
//	Version 1.0 (2004.05.04)
//	 - Initial function documentation (Sean Mlinscek - sean.mlinscek@stryker.com)

function formValidation(formType,formField,formAlert,formName,formCount){
   if(formType == "text"){
      ifStatement = "window.document."+formName+"."+formField+".value == ''";
      showFocus = "window.document."+formName+"."+formField+".focus();";
   }else if(formType == "select"){
      ifStatement = "document.forms['"+formName+"']."+formField+".options[document.forms['"+formName+"']."+formField+".selectedIndex].value == ''"; 
      showFocus = "document.forms['"+formName+"']."+formField+".focus();";      
   }else if(formType == "radio"){
      ifStatement = "";
      for(var i = 0; i <= formCount; i++){
         if(i == formCount){
            ifStatement += "(window.document."+formName+"."+formField+"["+i+"].checked == false)"; 
         }else{
            ifStatement += "(window.document."+formName+"."+formField+"["+i+"].checked == false) &&"; 
         }
      }
      showFocus = "window.document."+formName+"."+formField+"[0].focus();";
   }
	
   if (eval(ifStatement)){
      alert(formAlert);
      eval(showFocus);
      return false;
   }else{
      return true;
   }
}

//----------------------------------------
// <void> showHiddenFields()
//----------------------------------------
// - Description:
//	Hides or Unhides form fields based on event 
//
// - Returns: None
//
// - Parameters:
//
// - Details:
//
// - Changelog:
//     1.1.5 - (2004.10.06): Fixed the if statement which handles the hiding/unhiding
//     of the content.
//
//	Version 1.0 (2004.05.04)
//	 - Initial function documentation (Sean Mlinscek - sean.mlinscek@stryker.com)

function showHiddenFields(formName,formType,formField,divID,divIDAlt,formValue){
   var ifStatement;      

   if(formType == "radio"){
      ifStatement = "document."+formName+"."+formField+".checked == true";
   }else if(formType == "checkbox"){
      ifStatement = "document."+formName+"."+formField+".selected == true";
   }else{
      ifStatement = "document.forms['"+formName+"']."+formField+".options[document.forms['"+formName+"']."+formField+".selectedIndex].value == '"+formValue+"'"; 
   }

   browser = navigator.appName;
   browserNum = parseInt(navigator.appVersion);
   if ((browser == "Netscape") && (browserNum < 5)){
      layerRef = "document.layers['";
      endLayerRef = "']";
      styleRef = "";
	  attribute = ".visibility";
      notVisible = "hide";
      visible = "show";
   }else if ((browser == "Netscape") && (browserNum >= 5)){
      layerRef = "document.getElementById('";
      styleRef = ".style";
	  attribute = ".visibility";
      endLayerRef = "')";
      notVisible = "hidden";
      visible = "visible";
   }else{
      layerRef = "document.all['";
      endLayerRef = "']";
      styleRef = ".style";
	  attribute = ".display";
      notVisible = "none";
      visible = "inline";   
   }

   if (eval(ifStatement)){
      eval(layerRef + divID + endLayerRef + styleRef + attribute + " = '" + visible + "'");
      if(divIDAlt){
         eval(layerRef + divIDAlt + endLayerRef + styleRef + attribute + " = '" + notVisible + "'"); 
	  }       
   }else{
      eval(layerRef + divID + endLayerRef + styleRef + attribute + " = '" + notVisible + "'");
      if(divIDAlt){
         eval(layerRef + divIDAlt + endLayerRef + styleRef + attribute + " = '" + visible + "'"); 
      }
   }
}