/*****************************************************************
4 May 1999 revised 19 Jan 2009
Functions for frame call and form validation JavaScript 1.2
Copyright 2000-2009 Computer Science Software (Pty) Ltd.
*****************************************************************/
var reEmail = /^.+\@.+\..+$/;
var reWhitespace = /^\s+$/;
//var reSignedInteger = /^(+|-)?\d+$/;     //Wo liegt hier der Fehler??
var reAlphabetic = /^[a-z A-Z -]+$/;


/*****************************************************************
Version Information of PROFIDA and Options
                                                        29.10.2001
*****************************************************************/
function insertVersion(selector){
   switch (selector){
      case 'PFE':
         version = '4.01';
         break;
      case 'DE': //Data Exchange
         version = ' ';
         break;
      case 'LT':
         version = ' ';
         break;
      case 'ST':
         version = ' ';
         break;
      case 'CWM':
         version = ' ';
         break;
      case 'PC': //Premium Collection
         version = ' ';
         break;
      case 'CT': //Commission Administration
         version = ' ';
         break;
      case 'FNA':
         version = ' ';
         break;
      case 'FP': //Financial & Estate Planning
         version = ' ';
         break;
      case 'EBM': //Group Schemes
         version = ' ';
         break;
      case 'PRC': //Product Comparison
         version = ' ';
         break;
      case 'MS': //Mini-Server
         version = ' ';
         break;
      default :
         version = ' ';
   }
   
   document.write(version);
}


/*****************************************************************
Form check email
                                                 14.05.1999 14:27
*****************************************************************/
function isEmailValid(varFormName,varElemName,winName){
   var EmailOk = true;
   var Temp = document.forms[varFormName].elements[varElemName];

   var AtSym        = Temp.value.indexOf('@');
   var Period       = Temp.value.lastIndexOf('.');
   var Space        = Temp.value.indexOf(' ');
   var Length       = Temp.value.length - 1;   // Array is from 0 to length-1
   var reEmailDescr = /\@email.here/;

   if (isEmpty(Temp.value) || reEmailDescr.test(Temp.value)){
      EmailOk = false;
      alert('Please enter a valid e-mail address!');
      Temp.focus();
   }else{
      if ((AtSym < 1) ||             // '@' cannot be in first position
         (Period <= AtSym+1) ||      // Must be atleast one valid char btwn '@' and '.'
         (Period == Length ) ||      // Must be atleast one valid char after '.'
         (Space  != -1))             // No empty spaces permitted
      {
            EmailOk = false;
            alert('Please enter a valid e-mail address!');
            Temp.focus();
      }
   }

   return EmailOk;
}


/*****************************************************************
Checks whether the name is complete and ok
                                                 14.05.1999 14:46
*****************************************************************/
function isNameComplete(varFormName, varElemName, winName){
   var NameOk = true;
   var strObject = document.forms[varFormName].elements[varElemName];
   var strValue = strObject.value;
   var reNameDescr = /Name\b/i;
   
   if(isEmpty(strValue) || reNameDescr.test(strValue)){
      NameOk = false;
      alert('Please type in your name.');
      strObject.focus();
   }else{
      if(strValue.length > 2 && isAlphabetic(strValue)){
         NameOk = true;
      }else{
         NameOk = false;
         alert('Something is wrong with your name. Only alphabetic characters are allowed. Please correct it!');
         strObject.focus();
      }
   }
   
   return NameOk;
}


/*****************************************************************
Check whether string s is empty.
                                                 14.05.1999 14:46
*****************************************************************/
function isEmpty(s)
{
   return ((s == null) || (s.length == 0))
}


/*****************************************************************
Returns true if string s is empty or whitespace characters only.
                                                 14.05.1999 14:46
*****************************************************************/
function isWhitespace (s)
{
   return (isEmpty(s) || reWhitespace.test(s));
}


/*****************************************************************
isSignedInteger (STRING s [, BOOLEAN emptyOK])
Returns true if all characters are numbers;
first character is allowed to be + or - as well.
Does not accept floating point, exponential notation, etc.
We don't use parseInt because that would accept a string
with trailing non-numeric characters.

For explanation of optional argument emptyOK, see comments of function isInteger.

EXAMPLE FUNCTION CALL:          RESULT:
isSignedInteger ("5")           true
isSignedInteger ("")            defaultEmptyOK
isSignedInteger ("-5")          true
isSignedInteger ("+5")          true
isSignedInteger ("", false)     false
isSignedInteger ("", true)      true
                                                 14.05.1999 14:46
*****************************************************************/
function isSignedInteger (s)
{
   if (isEmpty(s))
      if (isSignedInteger.arguments.length == 1) return defaultEmptyOK;
      else return (isSignedInteger.arguments[1] == true);
   else
   {
      return reSignedInteger.test(s)
   }
}


/*****************************************************************
isAlphabetic (STRING s [, BOOLEAN emptyOK])
Returns true if string s is English letters (A .. Z, a..z) only.

NOTE: Need i18n version to support European characters.
This could be tricky due to different character sets and orderings for various languages and platforms.
                                                 14.05.1999 14:46
*****************************************************************/
function isAlphabetic (s)
{
   var i;

   if (isEmpty(s))
      if (isAlphabetic.arguments.length == 1) return defaultEmptyOK;
      else return (isAlphabetic.arguments[1] == true);

   else
   {
      return reAlphabetic.test(s)
   }
}


/*****************************************************************
isNonnegativeInteger (STRING s [, BOOLEAN emptyOK])
Returns true if string s is an integer >= 0.
                                                 14.05.1999 14:46
*****************************************************************/
function isNonnegativeInteger (s)
{
   var secondArg = defaultEmptyOK;

   if (isNonnegativeInteger.arguments.length > 1)
      secondArg = isNonnegativeInteger.arguments[1];

   // The next line is a bit byzantine.  What it means is:
   // a) s must be a signed integer, AND
   // b) one of the following must be true:
   //    i)  s is empty and we are supposed to return true for
   //        empty strings
   //    ii) this is a number >= 0

   return (isSignedInteger(s, secondArg)
         && ( (isEmpty(s) && secondArg)  || (parseInt (s) >= 0) ) );
}


/*****************************************************************
isYear (STRING s [, BOOLEAN emptyOK])
isYear returns true if string s is a valid Year number.  Must be 2 or 4 digits only.
For Year 2000 compliance, you are advised to use 4-digit year numbers everywhere.
                                                 14.05.1999 14:49
*****************************************************************/
function isYear (s)
{
   if (isEmpty(s))
      if (isYear.arguments.length == 1) return defaultEmptyOK;
      else return (isYear.arguments[1] == true);
   if (!isNonnegativeInteger(s)) return false;
   return ((s.length == 2) || (s.length == 4));
}