//==============================================================================================
// Copyright Surfocracy Ltd, 2004
// Contact: info@surfocracy.com
// No part of this file may be re-used, republished or distributed under any circumstances
// without the permission of Surfocracy Ltd. Any web site found to be containing any content
// copyrighted to Surfocracy Ltd shall be reported for copyright infringement, followed by
// legal action if necessary.
//----------------------------------------------------------------------------------------------
// File   : javascript-common.js
// Scope  : COMMMON  (refer to /includes/readme.txt for explanation)
// Version: 1.1
// Description: Common JavaScript routines which can be used for all dynamic sites.
//              These routines are called from the main site and admin.
//
// Version control
//===========================================================================================================
//   Date        | Changed by |     Description
//===========================================================================================================
//  13-Sept-2004     VLD        First issue 1.0
//  27-Mar-2005      VLD        Added universal Pop up function PopUpWindow.
//                              Removed functions popmapwindow and PopMenuItem as they are sperceded. v 1.1.
//===========================================================================================================
//   
//--------------------------------------------------------------------------------------
// This function Pops up a window with the given parameters.
// Example call to this function would look like:
// onClick="PopUpWindow('POPUP-file.htm','name',WinHeight=400,WinWidth=600,WinLeft=100,WinTop=100,
//                       WinResizable='yes',WinScrollbars='yes',WinToolbar='no',WinMenubar='no',WinStatus='no'); return false;"
//--------------------------------------------------------------------------------------
function PopUpWindow(url,name,WinHeight,WinWidth,WinLeft,WinTop,WinResizable,WinScrollbars,WinToolbar,WinMenubar,WinStatus) {
  var newwindow;

  var settings= "height="+WinHeight+
                 ",width="+WinWidth+
  				 ",left="+WinLeft+
				 ",top="+WinTop+
		         ",resizable="+WinResizable+
				 ",scrollbars="+WinScrollbars+			  
                 ",toolbar="+WinToolbar+
				 ",menubar="+WinMenubar+
                 ",status="+WinStatus;
               //  ",location=yes,directories=yes";

  newwindow=window.open(url,'name',settings);
  if (window.focus) {newwindow.focus()}
}
   
//--------------------------------------------------------------------------------------
// This function checks to see that a something is added in the search box.
//--------------------------------------------------------------------------------------
function CheckSearchBox (MyForm) {
  if (MyForm.SearchFor.value=="") {
	  alert(ErrEnterSearchItem);
      MyForm.SearchFor.focus();
      return (false);
  }
  return (true);
}	
      
//--------------------------------------------------------------------------------------
// This function checks to see that a quantity value is entered in the quantity field.
//--------------------------------------------------------------------------------------
function CheckQty (MyField, val, FormName) {
  var RefString=" 1234567890";
  for (Count=0; Count < val.length; Count++) {
     TempChar= val.substring (Count, Count+1);
     if (RefString.indexOf (TempChar, 0)==-1) {
	     alert(ErrEnterValidNumber);
         eval(FormName + "." + MyField + ".focus();");
         return (false);
	 }
  }  
  return (true);
}

//--------------------------------------------------------------------------------------
// This function checks to see that only visible characters are entered in a form field.
//--------------------------------------------------------------------------------------
function CheckSpace (MyField, val, FormName) {
  if (val.substring(0,1)==" ") {
	  alert(ErrEnterVisibleCharacters);
      eval(FormName + "." + MyField + ".focus();");
      return (false);
  }
  return (true);
}

//--------------------------------------------------------------------------------------
// This function checks if a string is a number. No form parameter exists.
//--------------------------------------------------------------------------------------
function IsNumberString (MyField, val, DisplayErrorText) {
   //No Form parameter
   var RefString="1234567890.()-+ ";	
   for (Count=0; Count < val.length; Count++) {
       TempChar= val.substring (Count, Count+1);
       if (RefString.indexOf (TempChar, 0)==-1) {
	      if (DisplayErrorText) alert(ErrEnterValidNumber);
          return (false);
	   }
   }
   return (true);
}  

//--------------------------------------------------------------------------------------
// This function checks if a string is a number but also rejects spaces or empty fields.
//--------------------------------------------------------------------------------------
function IsNumberString2 (MyField, val, DisplayErrorText, FormName) {
   //space and empty field is rejected
   var RefString="1234567890.()-+";	
   for (Count=0; Count < val.length; Count++) {
       TempChar= val.substring (Count, Count+1);
       if (RefString.indexOf (TempChar, 0)==-1) {
	       if (DisplayErrorText) alert(ErrEnterValidNumber);
           eval(FormName + "." + MyField + ".focus();");
           return (false);
	   }
   }
   if (val=="") {
	  if (DisplayErrorText) alert(ErrEnterValidNumber);
	  eval(FormName + "." + MyField + ".focus();");
	  return (false);
   }		
   return (true);
}    
   
//--------------------------------------------------------------------------------------
// This function checks if a form field contains letters only.
//--------------------------------------------------------------------------------------
function isLetterString (MyField, val, DisplayErrorText, FormName) {

  var RefString="'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ- ";
  if (val.substring(0,1)==" ") {
	 if (DisplayErrorText) alert(ErrEnterVisibleCharacters);
     eval(FormName + "." + MyField + ".focus();");
     return (false);
  }
  for (Count=0; Count < val.length; Count++) {
     TempChar= val.substring (Count, Count+1);
     if (RefString.indexOf (TempChar, 0)==-1) {
	    if (DisplayErrorText) alert(ErrEnterValidAlphaName);
        eval(FormName + "." + MyField + ".focus();");
        return (false);
	 }
   }
   return (true);
}

//--------------------------------------------------------------------------------------
// This function validates a string to check if it is in an email format.
//--------------------------------------------------------------------------------------
function emailCheck (myForm, val, DisplayErrorText) {
var emailStr=val;
/* 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 (emailStr!="") {
      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. */
	        if (DisplayErrorText) alert(ErrIncorrectEmailAddress)
	        //myForm.email.focus()
	        return false
      }
      var user=matchArray[1]
      var domain=matchArray[2]
      // See if "user" is valid 
      if (user.match(userPat)==null) {
         // user is not valid
         if (DisplayErrorText) alert(ErrIncorrectEmailUsername)
	     //myForm.email.focus();
         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) {
	           if (DisplayErrorText) alert(ErrIncorrectEmailIP)
		       //myForm.email.focus();
		       return false
            }
         }
         return true
      }
      // Domain is symbolic name
      var domainArray=domain.match(domainPat)
      if (domainArray==null) {
         if (DisplayErrorText) alert(ErrIncorrectEmailDomain)
         //myForm.email.focus();
         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.
          if (DisplayErrorText) alert(ErrIncorrectEmailExt)
          //myForm.email.focus();
          return false
      }
      // Make sure there's a host name preceding the domain.
      if (len<2) {
         if (DisplayErrorText) alert(ErrMissingEmailHost)
         //myForm.email.focus();
         return false
      }
   }
   // If we've gotten this far, everything's valid!
   return true;
}
      
//--------------------------------------------------------------------------------------
// This function validates a string to check if it is a correct UK postcode format.
//--------------------------------------------------------------------------------------
function postit(MyField, test, Country, FormName){ //check postcode format is valid
  size = test.length;
  var errorString="";
  if (test!="") {
      if ((Country == "Great Britain") || (Country == "United Kingdom")) {
            while (test.slice(0,1) == " ") //Strip leading spaces
               {test = test.substr(1,size-1);size = test.length
               }
            while(test.slice(size-1,size)== " ") //Strip trailing spaces
               {test = test.substr(0,size-1);size = test.length
               }
            eval("document.form1." + MyField + ".value = test;"); //write back to form field
            if (size < 6 || size > 8){ //Code length rule
               errorString = (test + ErrInvalidPostcodeLength);
            }
            if (!(isNaN(test.charAt(0)))){ //leftmost character must be alpha character rule
               errorString = (test + ErrInvalidPostcodeStart);
            }
            if (isNaN(test.charAt(size-3))){ //first character of inward code must be numeric rule
               errorString = (test + ErrInvalidPostcodeAlphaPos);
            }
            if (!(isNaN(test.charAt(size-2)))){ //second character of inward code must be alpha rule
               errorString = (test + ErrInvalidPostcodeNumberPos);
            }
            if (!(isNaN(test.charAt(size-1)))){ //third character of inward code must be alpha rule
               errorString = (test + ErrInvalidPostcodeNumberPos);
            }
            if (!(test.charAt(size-4) == " ")){//space in position length-3 rule
               errorString = (test + ErrInvalidPostcodeSpace);
            }
            count1 = test.indexOf(" ");count2 = test.lastIndexOf(" ");
            if (count1 != count2){//only one space rule
               errorString = (test + ErrInvalidPostcodeOneSpaceOnly);
            }
         }
      }
      if (errorString!=""){
         if (!confirm(ErrProblemWithPostcode + "   " + errorString + AlertProceedOrCancel)) {
            eval(FormName + "." + MyField + ".focus();");
	        return false;
	  }
		 else
		    return true
  }
   else
      return true;
}