//set focus
function setFocus() {
  if(document.forms[0] != null) {
    exit = false;
    i=0;
    while(i < document.forms[0].length && !exit) {
      if(document.forms[0].elements[i].type != "hidden") {
        document.forms[0].elements[i].focus();
        exit = true;
      }
      i++;
    }
  }
}

//image swap
//param: img - the image name being swapped
//param: imgSrc - the source of the new image
function imgSwap(img, imgSrc) {
  document.images[img].src = imgSrc;
}

//generic form reset
//param: frm - NAME of form being reseted
function formReset(frm) {
  document.forms[frm].reset();
}

//generic form reset
//param: frm - NAME of form being reseted
//param: btn - NAME of button to swap
function formReset(frm, btn) {
  imgSwap(btn, '../images/button/btn_reset.gif');
  document.forms[frm].reset();
}

//generic form submit 
//param: frm - NAME of form being submitted
function formSubmit(frm) {
  document.forms[frm].submit();
}

//form user input validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
function validateEmpty(element, message) {
   
   if(element.value == "") {
      alert(message);
      element.focus();
      return false;
   }
   return true;
}


//form user input validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
//Author: Imtiaz Sattar

function validateEmptyWithSpace(element, message) {
   
   while(''+element.value.charAt(0)==' ') {
      element.value=element.value.substring(1,element.value.length);
   }   
   if(element.value == "") {
      alert(message);
      element.focus();
      return false;
   }
   return true;
}


//form numeric validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
function validateNumeric(element, message) {

   re = /[^0-9.-]/;
   if(isNaN(element.value) || re.exec(element.value)) {
      alert(message);
      element.focus();
      return false;
   }
   return true;
}


//form numeric integer validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
function validateInteger(element, message) {
   bValid = false;
   bValid = validateNumeric(element, message);
   if (bValid) {
    if (Math.floor(element.value) == element.value) {
      bValid = true;

      if(element.value.indexOf('.') != -1){
        //element.value = element.value.replace('.', '');
        element.value = element.value.substring(0, element.value.indexOf('.'));
      }
    }
    else {
      bValid = false;
      alert(message);
      element.focus();
      element.select();
    }
  }
   return bValid;
}

//form positive number validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
function validatePositive(element, message) {
   bValid = false;
   if (element.value >= 0) {
      bValid = true;
   }
   else {
      alert(message);
      element.focus();
   }
   return bValid;
}

//form positive number greater than 0 validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
function greaterThanZero(element, message) {
   bValid = true;
   if(element.value <= 0) {
      bValid = false;
      alert(message);
      element.focus();
   }
   return bValid;
}


 
//form price validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
function validatePrice(element, message) {
   bValid = true;
   if(element.value != "") {
      var dotIndex = element.value.indexOf('.');

      if(dotIndex == -1) {
         element.value = element.value + ".00";       
         dotIndex = element.value.indexOf('.');
      }
      if(element.value.indexOf('$') != -1){
         element.value = element.value.replace('$', '');
      }
      if(isNaN(element.value.substring(0, dotIndex))) {
         alert(message);
         element.focus();
         bValid = false;
      }
      if(isNaN(element.value.substring(dotIndex+1, element.value.length))) {
         alert(message);
         element.focus();
         bValid = false;
      }
      
   }
   return bValid;
}

//form decimal value validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
//param: precision - the total number of significant digits
//param: scale - the number of significant digits after the decimal point
function validateDecimal(element, message, precision, scale) {
   var dotIndex = element.value.indexOf('.');

   if(dotIndex == -1) {
      element.value = element.value + ".";
      dotIndex = element.value.indexOf('.');

      for(i=0; i<scale; i++) {
         element.value = element.value + "0";         
      }
   }
   if(element.value.length > precision+1) {
      alert(message);
      element.focus();
      return false;
   }
   if(isNaN(element.value.substring(0, dotIndex))) {
      alert(message);
      element.focus();
      return false;
   }
   if(isNaN(element.value.substring(dotIndex+1, element.value.length))) {
      alert(message);
      element.focus();
      return false;
   }
   if(element.value.substring(dotIndex+1, element.value.length) > scale) {
      element.value = element.value.substring(0 , dotIndex+scale+1);
   }
   sigDigits = element.value.substring(dotIndex+1, element.value.length).length;
   if(sigDigits < scale) {
      for(; sigDigits<scale; sigDigits++) {
         element.value = element.value + "0";         
      }
   }
   return true;
}

//form date validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
function validateDate(element, message) {
   if(element.value != "") {
      var firstIndex = element.value.indexOf('-');
      var secondIndex = element.value.lastIndexOf('-');

      if(firstIndex == secondIndex || firstIndex == -1) {
         alert(message);
         element.focus();
         return false;
      }
      if(isNaN(element.value.substring(0, firstIndex))) {
         alert(message);
         element.focus();
         return false;
      }
      if(isNaN(element.value.substring(firstIndex+1, secondIndex))) {
         alert(message);
         element.focus();
         return false;
      }
      if(isNaN(element.value.substring(secondIndex+1, element.value.length))) {
         alert(message);
         element.focus();
         return false;
      }
      if(element.value.substring(0, firstIndex).length != 2){
         alert(message);
         element.focus();
         return false;
      }
      if(element.value.substring(firstIndex+1, secondIndex).length != 2) {
         alert(message);
         element.focus();
         return false;
      }
      if(element.value.substring(secondIndex+1, element.value.length).length != 4) {
         alert(message);
         element.focus();
         return false;
      }
      return true;
   }
   return true;
}

//form field size validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
//param: size - the exact size of the element
function validateSize(element, message, size) {
   if(element.value.length != size) {
      alert(message);
      element.focus();
      return false;
   }
   return true;
}

//form field max size validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
//param: size - the maximum size of the element
function validateMaxSize(element, message, size) {
   if(element.value.length > size) {
      alert(message);
      element.focus();
      return false;
   }
   return true;
}

 //form field value validation - set the first letter of the field's value to upper case
 //param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
 //param: method - what is to be in upper case
 //          1: convert all letters to upper case
 //          2: covert first letter only to upper case
 //          3: convert first letters of each word to upper case
 
 function setToUpperCase(element, method) {
   if(method == 1) {
      element.value = element.value.toUpperCase();
   }
   if(method == 2) {
      first = element.value.substring(0,1).toUpperCase();
      rest = element.value.substring(1, element.value.length);
      element.value = first + rest;
   }
   if(method == 3) {
      var text = new Array();
      temp = element.value + " ";
      
      i = 0;
      j = 0;
      while(i < temp.length) {
         text[j] = temp.substring(i, temp.indexOf(' '));
         i = temp.indexOf(' ') + 1;
         j++;
         temp = temp.replace(" ", "_");
      }
      
      element.value = "";
      for(i=0; i<text.length; i++) {
         text[i] = text[i].substring(0,1).toUpperCase() + text[i].substring(1, text[i].length);
         if (i == 0) {
            element.value = element.value + text[i];
         } else { 
            element.value = element.value + " " + text[i];
         }
      }
   }
 }
 
 function isEmpty(element) {
      if (element.value.length == 0) {
         return true;
      } else {
         for (i = 0; i < element.value.length; i++) {
            if ((i == element.value.length - 1) && (element.value.charAt(i) == ' ')) {
               element.value = "";
               return true;
            } else if (element.value.charAt(i) != ' ') {
               return false;
            }
         }
      }
 }

 function containsAllSpaces(element) {
      
      for (i = 0; i < element.value.length; i++) {
         if ((i == element.value.length - 1) && (element.value.charAt(i) == ' ')) {
            return true;
         } else if (element.value.charAt(i) != ' ') {
            return false;
         }
      }
 }

//form email field validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
function validateEmail(element, message) {
   at = element.value.lastIndexOf('@');
   dot = element.value.lastIndexOf('.');
   temp = element.value;
   
   if(at == -1) {
      alert(message);
      element.focus();
      return false;
   }
   if(at == 0) {
      alert(message);
      element.focus();     
      return false;
   }
   if(dot == -1) {
      alert(message);
      element.focus();     
      return false;
   }
   if(dot < at) {
      alert(message);
      element.focus();     
      return false;
   }
   if(dot - 1 == at) {
      alert(message);
      element.focus();     
      return false;
   }
   if(dot == temp.length-1) {
      alert(message);
      element.focus();     
      return false;
   }
   if(dot+3 != temp.length-1) {
      alert(message);
      element.focus();     
      return false;
   }
   return true;
}



//form time validation
//param: element - THE FORM ELEMENT being validated (e.g. document.myForm.formElem)
//param: message - the message to print to the user
function validateTime(element, message) {
    // HH:MMam/pm
    bOk = true;

    // Check the length.
    if (element.value.length < 6) {
        bOk = false;
    }

    // Search for ":"
    if (bOk) {
        colon = (element.value).indexOf(":");
        if (colon < 0 || colon > 2) {
            bOk = false;
        }
    }

    // Check the hour.
    if (bOk) {
        // Get the characters before : - hour.
        hour = (element.value).substring(0, colon);
        
        // If hour > 12 then hour = hour - 12.  ampm = PM.
        // If hour < 1 then hour = 12.  ampm = AM.
        // Hour should be 1 - 12.
        if (isNaN(hour) || hour < 1 || hour > 12) {
            bOk = false;
        }
        hour = Math.floor(hour);
    }

    // Check the minutes.
    if (bOk) {
        // Make sure there are at least 2 characters after ":".
        if (colon+3 > element.value.length) {
            bOk = false;
        }
    
        if (bOk) {
            // Get the 2 characters after : - minutes.
            minutes = (element.value).substr(colon+1, 2);

            // Minutes should be 0 - 59.
            if (isNaN(minutes) || minutes < 0 || minutes > 59) {
                bOk = false;
            }
            minutes = Math.floor(minutes);
            if (minutes < 10) {
                minutes = "0" + minutes;
            }
        }
    }
    
    // Check the am/pm indicator.
    if (bOk) {
        if (colon+4 > element.value.length) {
            bOk = false;
        }
        
        if (bOk) {
            ampm = ((element.value).substr(colon+3, 2)).toUpperCase();
        
            if (ampm != "AM" && ampm != "PM") {
                bOk = false;
            }
        }
    }
    
    if (! bOk) {
        alert(message);
        element.focus();
    }
    else {
        element.value = hour + ":" + minutes + ampm;
    }

    return bOk;
}



// This function assumes the time is formatted correctly as found in validateTime().
function getHour(sTime) {
    colon = sTime.indexOf(":");
    hour = sTime.substring(0, colon);

    return hour;
}

// This function assumes the time is formatted correctly as found in validateTime().
function getMinutes(sTime) {
    colon = sTime.indexOf(":");
    minutes = sTime.substr(colon+1, 2);

    return minutes;
}

// This function assumes the time is formatted correctly as found in validateTime().
function getAmOrPm(sTime) {
    colon = sTime.indexOf(":");
    ampm = (sTime.substr(colon+3, 2)).toUpperCase();

    return ampm;
}

// This function assumes the time is formatted correctly as found in validateTime().
function get24HourDecimalTime(sTime) {
    hour = getHour(sTime);
    minutes = getMinutes(sTime);
    ampm = getAmOrPm(sTime);
    if (ampm == "PM" && hour != 12) {
        hour = Math.abs(hour) + 12;
    }
    decimaltime = hour + "." + minutes;
    return decimaltime;
}


function checkIfAlpha(event) {
    //alert("Hi");
    var keyStroke = (navigator.appName == "Netscape")?event.which : event.keyCode
    status = keyStroke;
    if (keyStroke > 31 &&(keyStroke < 48 || keyStroke >57)){
      // alert("Junker Error in Input");
       return false;
    }
    return true;
}


//This function validates that the date entered is after todays date
function afterToday(element,message)
{
  var currentDate = new Date();
  var dateTokens = element.value.split("-");
  var enteredDate = new Date(dateTokens[2],dateTokens[0]-1,dateTokens[1]);
  var isAfter = false;
  if(enteredDate>currentDate)
  {
    isAfter=true;
  }
  else 
  {
    alert(message);
    element.focus();
  }
  return isAfter;
}

function isAlphanumeric(event) {
   var key = (navigator.appName == "Netscape")?event.which:event.keyCode;

   if ((key >= 48 && key <= 57) || (key >= 65 && key <= 90)
      || (key >= 97 && key <= 122) || (key == 8) || (key == 0) || (key == 32)) {
      return true
    }
    return false;
}

function isNumeric(event) {
   var key = (navigator.appName == "Netscape")?event.which:event.keyCode;

   if ((key >= 48 && key <= 57) || (key == 8) || (key == 0)) {
      return true
    }
    return false;
}

function checkBrowser() {
   app = navigator.appName;
   ver = navigator.appVersion;
   if (app.indexOf("Microsoft") > -1) {
      idx = ver.indexOf("MSIE");
      if (idx > -1) {
         return "Microsoft " + ver.substring(idx + 4, idx + 8);
      } else {
         return "Microsoft " + ver;
      }
   } else if (app.indexOf("Netscape") > -1) {
      return "Netscape " + ver.substring(0,ver.indexOf(" "));
   } else if (app.indexOf("Opera") > -1) {
      return "Opera " + ver.substring(0,ver.indexOf(" "));
   }
   return "Unidentified";
}

// onKeyPress="return supressNonDigit(event)".
// method can cancel the KeyPress
// if it returns false.
// To allow the KeyPress, it returns true.
// does not work for Netscape 4.7

function supressNonDigit(event) {
   var keyChar;
   keyChar = (navigator.appName == "Netscape")?event.which : event.keyCode;
   if (keyChar < 32) {
      return true;
   }
   if ((keyChar >= 48) && (keyChar <= 57)) {
      return true;
   }
   else {
      return false;
   }
}

// used with ZipCode tag
function validateZip(element, size, displayName, originalValue) {
   if (!isEmpty(element)) {
      if (validateZipNumeric(element, displayName, originalValue)) {
         return validateZipSize(element, size, displayName, originalValue);
      }
   }
   else {
      return true;
   }
}

// used with ZipCode tag
function validateZipNumeric(element, displayName, originalValue) {
   currentValue = element.value;
   if(isNaN(currentValue)) {
      message = "The value entered for " + displayName + ", \"" + currentValue + 
                "\", must contain all digits.  Press OK to correct the value or " +
                "Cancel to revert the field back to its original value, \"" + 
                originalValue + "\".";
    
      if (confirm(message)) {
         element.focus();
         element.select();
      }
      else {
        element.value = originalValue;
      }
      return false;
   }
   return true;
}

// used with ZipCode tag
function validateZipSize(element, size, displayName, originalValue) {
   if(element.value.length != size) {
      currentValue = element.value;
      message = "The value entered for " + displayName + ", \"" + currentValue + 
                "\", must contain " + size + " digits.  Press OK to correct the value or " + 
                "Cancel to revert the field back to its original value, \"" + 
                originalValue + "\".";
      
      if (confirm(message)) {
         element.focus();
         element.select();
      }
      else {
         element.value = originalValue;
      }
      return false;
   }
   return true;
}

// This function is used to put focus on a field and then select its contents, used in case of errors
// 020102 - Omer Qureshi
function selectField(element)
{
   element.focus();
   element.select();
}

// This function is used to validate a numeric field
// 020102 - Omer Qureshi
function validateNumber(element, displayName, originalValue)
{
   currentValue = element.value;
   objRegExp  =  /(^-?\d\d*$)/;

   if(!objRegExp.test(element.value))
   {
      if(currentValue != "") {
        message = "The value entered for " + displayName + ", \"" + element.value + "\", " +
        "must contain all digits.  Press OK to correct the value or Cancel to " +
        "revert the field back to its orignial value, \"" + originalValue + "\".";

        if(confirm(message)) {
          selectField(element);
        }
        else {
          element.value = originalValue;
        }
        return false;
      }
   }

   return true;
}

// This function is used to validate a numeric value with a minimum value
// 020102 - Omer Qureshi
function validateMinNumber(element, min, displayName, originalValue)
{
   if(validateNumber(element))
   {
      if(element.value <= min)
      {
         message = "The value entered for " + displayName +  
                   " must be greater than " + min + ".  Press OK to correct the value or " + 
                   "Cancel to revert the field back to its original value, \"" + 
                   originalValue + "\".";

         if(confirm(message)){
          selectField(element);
         }
         else {
           element.value = originalValue;
         }
         return false;
      }

      return true
   }

   return false;
}

// This function is used to validate a numeric value with a maximum value
// 020102 - Omer Qureshi
function validateMaxNumber(element, max, displayName, originalValue)
{
   if(validateNumber(element))
   {
      if(element.value >= max)
      {
         message = "The value entered for " + displayName + 
                   " must be less than " + max + ".  Press OK to correct the value or " + 
                   "Cancel to revert the field back to its original value, \"" + 
                   originalValue + "\".";

         if(confirm(message)) {
           selectField(element);
         }
         else {
           element.value = originalValue;
         }
         return false;
      }

      return true;
   }

   return false;
}

// This function is used to validate a numeric value with a minimum and maximum value
// 020102 - Omer Qureshi
function validateMinMaxNumber(element, min, max, displayName, originalValue)
{
   if(validateNumber(element))
   {
      if(validateMinNumber(element, min, displayName, originalValue) && validateMaxNumber(element, max, displayName, originalValue))
      {
         return true;
      }
   }

   return false;
}

// This function is used to filter out numeric keystrokes
// 020102 - Omer Qureshi
function checkNumericKeyStroke(event, element)
{
   keyStroke = (navigator.appName == "Netscape")?event.which:event.keyCode;

   if(keyStroke == 45 || (keyStroke >= 48 && keyStroke <= 57))
   {
      return true;
   }

   return false;
}

//This function is used to validate dates
function validateDateValue(event, element) {
  var keyStroke = (navigator.appName == "Netscape")?event.which:event.keyCode;

  if ((keyStroke == 0) || (keyStroke == 8)) { return true; }
  if ((keyStroke < 48) || (keyStroke > 57)) { return false;}
  return forceDateMask(element);
}

function forceDateMask(element) {
  aname = navigator.appName;
  avers = navigator.appVersion.substring(0,4);
  dt = new Date();

  if ((aname == "Netscape") && (avers <= "4.78")) {
    re = /^(\d{2})(\d{2})(\d{4})$/;
    validDate = re.exec(element.value);
    if (validDate) {
      element.value = validDate[1] + "-" + validDate[2] + "-" + validDate[3];
    }
  } else {
    re = /^(\d{2})[\-]?$/;
    validDate = re.exec(element.value);
    if (validDate) {
        element.value = validDate[1] + "-";
    }
    re = /^(\d{2})[\-]?(\d{2})[\-]?$/;
    validDate = re.exec(element.value);
    if (validDate) {
        element.value = validDate[1] + "-" + validDate[2] + "-";
        return true;
        element.value = validDate[1] + "-" + validDate[2] + "-";
        return true;
        element.value = validDate[1] + "-" + validDate[2] + "-";
        return true;
    }
    re = /^(\d{2})[\-]?(\d{2})[\-]?(\d{4})$/;
    validDate = re.exec(element.value);
    if (validDate) {
      element.value = validDate[1] + "-" + validDate[2] + "-" + validDate[3];
      return true;
    }
  }
}

function checkDate(element, displayName, originalValue, minDate, maxDate) {
  dt = new Date();
  aname = navigator.appName;

  re = /^(\d{2})[\-]?(\d{2})[\-]?(\d{4})$/;
  validDate = re.exec(element.value);

  if ((element.value.length) > 0) {
    if (validDate && (element.value.length == 10)) {
      if ((validDate[1] > 12) || (validDate[1] < 1) || (validDate[2] < 1) || (validDate[3] < 1)) {
        dateError(element, displayName, originalValue);
        return false;
      } else if ((validDate[1] < 0) || (validDate[1] > 12)) {
        dateError(element, displayName, originalValue);
        return false;
      } else if (((validDate[1] == "01") || (validDate[1] == "03") || (validDate[1] == "05") ||
        (validDate[1] == "07") || (validDate[1] == "08") || (validDate[1] == "10") ||
        (validDate[1] == "12")) && ((validDate[2] < 1) || (validDate[2] > 31))) {
        dateError(element, displayName, originalValue);
        return false;
      } else if (((validDate[1] == "04") || (validDate[1] == "06") ||
        (validDate[1] == "09") || (validDate[1] == "11")) &&
        ((validDate[2] < 1) || (validDate[2] > 30))) {
        dateError(element, displayName, originalValue);
        return false;
      } else if (validDate[1] == "02") {
        if ((leapYear(validDate[3])) && ((validDate[2] < 1) || (validDate[2] > 29))) {
          dateError(element, displayName, originalValue);
          return false;
        } else if ((leapYear(validDate[3]) == false) && ((validDate[2] < 1) || (validDate[2] > 28))) {
          dateError(element, displayName, originalValue);
          return false;
        }
      }

      
      if(maxDate != '') {
        validMaxDate = re.exec(maxDate);
      
        if (validDate[3] > validMaxDate[3]) {
          maxDateError(element, displayName, maxDate, originalValue);
          return false;
        } else if ((validDate[3] == validMaxDate[3]) && (validDate[1] > validMaxDate[1])) {
          maxDateError(element, displayName, maxDate, originalValue);
          return false;
        } else if ((validDate[3] == validMaxDate[3]) && (validDate[1] == validMaxDate[1]) && (validDate[2] > validMaxDate[2])) {
          maxDateError(element, displayName, maxDate, originalValue);
          return false;
        }
      }
      
      if (minDate != '') {
              validMinDate = re.exec(minDate);

        if (validDate[3] < validMinDate[3]) {
          minDateError(element, displayName, minDate, originalValue);
          return false;
        } else if ((validDate[3] == validMinDate[3]) && (validDate[1] < validMinDate[1])) {
          minDateError(element, displayName, minDate, originalValue);
          return false;
        } else if ((validDate[3] == validMinDate[3]) && (validDate[1] == validMinDate[1]) && (validDate[2] < validMinDate[2])) {
          minDateError(element, displayName, minDate, originalValue);
          return false;
        }
      }

      element.value = validDate[1] + "-" + validDate[2] + "-" + validDate[3];
      return true;
    } else {
      dateError(element, displayName, originalValue);
      //element.focus();
      return false;
    }
  }
}

function verifyDate(element, message) {
  blnSubmit = false;
  dt = new Date();
  aname = navigator.appName;

  re = /^(\d{2})[\-]?(\d{2})[\-]?(\d{4})$/;
  validDate = re.exec(element.value);

  if ((element.value.length) > 0) {
    if (validDate && (element.value.length == 10)) {
      if ((validDate[1] > 12) || (validDate[1] < 1) || (validDate[2] < 1) || (validDate[3] < 1)) {
        alert(message);
        return blnSubmit;
      } else if ((validDate[1] < 0) || (validDate[1] > 12)) {
        alert(message);
        return blnSubmit;
      } else if (((validDate[1] == "01") || (validDate[1] == "03") || (validDate[1] == "05") ||
        (validDate[1] == "07") || (validDate[1] == "08") || (validDate[1] == "10") ||
        (validDate[1] == "12")) && ((validDate[2] < 1) || (validDate[2] > 31))) {
        alert(message);
        return blnSubmit;
      } else if (((validDate[1] == "04") || (validDate[1] == "06") ||
        (validDate[1] == "09") || (validDate[1] == "11")) &&
        ((validDate[2] < 1) || (validDate[2] > 30))) {
        alert(message);
        return blnSubmit;
      } else if (validDate[1] == "02") {
        if ((leapYear(validDate[3])) && ((validDate[2] < 1) || (validDate[2] > 29))) {
          alert(message);
          return blnSubmit;
        } else if ((leapYear(validDate[3]) == false) && ((validDate[2] < 1) || (validDate[2] > 28))) {
          alert(message);
          return blnSubmit;
        }
      }

      element.value = validDate[1] + "-" + validDate[2] + "-" + validDate[3];
    } else {
      alert(message);
      return blnSubmit;
      //element.focus();
    }
  }
  blnSubmit = true;
  return blnSubmit;
}

function dateError(element, displayName, originalValue) {
        message = "The value entered for " + displayName + ", \"" + element.value + "\", " +
        "is not in the desired format MM-DD-YYYY.  Press OK to correct the value or Cancel to " +
        "revert the field back to its original value";
  if(originalValue == ""){
    message += ".";
  }
  else
  {
    message += ", \""+ originalValue + "\".";
  }

  if(confirm(message)) {
    element.focus();
    element.select();
  }
  else {
    element.value = originalValue;
  }
}

function minDateError(element, displayName, minDate, originalValue) {
        message = "The date entered for " + displayName + 
                  " must be greater than " + minDate + ".  Press OK to correct the value or " + 
                  "Cancel to revert the field back to its original value, \"" + 
                  originalValue + "\".";

  if(confirm(message)) {
    element.focus();
    element.select();
  }
  else {
    element.value = originalValue;
  }
}

function maxDateError(element, displayName, maxDate, originalValue) {
        message = "The date entered for " + displayName + 
                  " must be less than " + maxDate + ".  Press OK to correct the value or " + 
                  "Cancel to revert the field back to its original value, \"" + 
                  originalValue + "\".";

  if(confirm(message)) {
    element.focus();
    element.select();
  }
  else {
    element.value = originalValue;
  }
}



function leapYear(intYear) {
  if (intYear % 100 == 0) {
    if (intYear % 400 == 0) {
      return true;
    }
  } else {
    if ((intYear % 4) == 0) {
      return true;
    }
  }
  return false;
}


//This function validates email address
function checkEmail(event, element) {
    var keyStroke = (navigator.appName == "Netscape")?event.which:event.keyCode;

    if ((keyStroke == 0) || (keyStroke == 8) || (keyStroke == 45)
  || (keyStroke == 46) || (keyStroke == 64) || (keyStroke == 95)) {
  return true;
    }
    if ((keyStroke < 48) || ((keyStroke > 57) && (keyStroke < 97 )) || (keyStroke > 122)) {
  return false;
    }
    return true;
}

function forceEmailMask(element, displayName, originalValue) {
  if (element.value.length > 0) {
    re = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,4})+$/
    if (re.test(element.value)) {
      return true
    }

                message = "The value entered for " + displayName + ", \"" + element.value + "\", " +
                "is not in the correct format.  Press OK to correct the value or Cancel to " +
                "revert the field back to its orignial value, \"" + originalValue + "\".";
        
    if (confirm(message)) {
      element.focus();
      element.select();
      return false;
    }
    else {
      element.value = originalValue;
    }
  }
}

//This function validates Phone and Fax numbers
function validatePhoneFaxValue(event, element) {
    var keyStroke = (navigator.appName == "Netscape")?event.which:event.keyCode;

    if ((keyStroke == 0) || (keyStroke == 8)) { return true; }
    if ((keyStroke < 48) || (keyStroke > 57)) { return false;}
    forcePhoneFaxMask(element);
    return true;
}

function forcePhoneFaxMask(element) {
  aname = navigator.appName;
  avers = navigator.appVersion.substring(0,4);

  if ((aname == "Netscape") && (avers <= "4.78")) {
    checkPhoneFax(element);
  } else {
    re = /^(\d{3})$/;
    validPhone = re.exec(element.value);
    if (validPhone) {
      element.value = validPhone[1] + "-";
    }
    re = /^(\d{3})[\-]?(\d{3})$/;
    validPhone = re.exec(element.value);
    if (validPhone) {
      element.value = validPhone[1] + "-" + validPhone[2] + "-";
    }
    re = /^(\d{3})[\-]?(\d{3})[\-]?(\d{4})$/;
    validPhone = re.exec(element.value);
    if ((validPhone) && (isNum(validPhone[1])) && (isNum(validPhone[2])) && (isNum(validPhone[3]))) {
      element.value = validPhone[1] + "-" + validPhone[2] + "-" + validPhone[3];
    }
  }
}

function checkPhoneFax(element, displayName, originalValue) {
  if (element.value != "") {
    re = /^(\d{3})[\-]?(\d{3})[\-]?(\d{4})$/;
    validPhone = re.exec(element.value);
    if ((validPhone) && (isNum(validPhone[1])) && (isNum(validPhone[2])) && (isNum(validPhone[3]))) {
      element.value = validPhone[1] + "-" + validPhone[2] + "-" + validPhone[3];
    } else {
        message = "The value entered for " + displayName + ", \"" + element.value + "\", " +
          "is not in the desired format.  Press OK to correct the value or Cancel to " +
          "revert the field back to its orignial value, \"" + originalValue + "\".";
        question = confirm(message);
        if (question) {
      element.focus();
      element.select();
        }
        else {
      element.value = originalValue;
        }
    }
  }
}

function isNum(passedVal) {
  if (passedVal == "") { return false; }
  for (i = 0; i < passedVal.length; i++) {
    if (passedVal.charAt(i) < "0") { return false; }
    if (passedVal.charAt(i) > "9") { return false; }
  }
  return true;
}

//This functions are for Time Validation
function timeCheck(event, element) {
    var keyStroke = (navigator.appName == "Netscape")?event.which:event.keyCode;

    if ((keyStroke == 0) || (keyStroke == 8)) { return true; }
    if ((keyStroke < 48) || (keyStroke > 57)) { return false;}
    return timeForceMask(element);
 }

 function timeForceMask(element) {
    aname = navigator.appName;
    avers = navigator.appVersion.substring(0,4);

    if ((aname == "Netscape") && (avers.indexOf("4.7") > -1 )) {
      re = /^(\d{2})(\d{2})(\d{2})$/;
      validTime = re.exec(element.value);
      if (validTime) {
        element.value = validTime[1] + ":" + validTime[2] + ":" + validTime[3];
        return true;
      }
    } else {
      re = /^(\d{2})[\:]?$/;
      validTime = re.exec(element.value);
      if (validTime) {
        element.value = validTime[1] + ":";
        return true;
      }
      re = /^(\d{2})[\:]?(\d{2})[\:]?$/;
      validTime = re.exec(element.value);
      if (validTime) {
        element.value = validTime[1] + ":" + validTime[2] + ":";
        return true;
      }
      re = /^(\d{2})[\:]?(\d{2})[\:]?(\d{2})$/;
      validTime = re.exec(element.value);
      if (validTime) {
        element.value = validTime[1] + ":" + validTime[2] + ":" + validTime[3];
        return true;

      }
    }
 }



 function IsValidTime(element,ampm,hiddenElement,givenValue, displayName) { 
 // Checks if time is in HH:MM:SS AM/PM format.
 // The seconds and AM/PM are optional.
        aname = navigator.appName;
  avers = navigator.appVersion.substring(0,4);
 
        if ((aname == "Netscape") && (avers.indexOf("4.7") > -1 )) {
      timeForceMask(element);
        }

  var timeStr = element.value;
  if (timeStr == ""){
    return true;
  }
  var timePat = /^(\d{1,2}):(\d{2})(:(\d{2}))?$/;

  var matchArray = timeStr.match(timePat);

  if (matchArray) {
  hour = matchArray[1];
  minute = matchArray[2];
  second = matchArray[4];

  if (second=="") { second = null; }

  if (hour < 0  || hour > 12) {
        if (confirm("The hour value entered for " + displayName + " must be between 1 and 12. Press OK to correct the value or Cancel to revert the field back to its original value, \"" + givenValue + "\".")) {
      element.focus();
      element.select();
      return false;
        }
        else {
            element.value = givenValue;
        }
  }
  if (minute<0 || minute > 59) {
        if (confirm("The minute value entered for " + displayName + " must be between 0 and 59. Press OK to correct the value or Cancel to revert the field back to its original value, \"" + givenValue + "\"?")) {
      element.focus();
      element.select();
      return false;
      }
              else {
                element.value = givenValue;
              }
  }
  if (second != null && (second < 0 || second > 59)) {
        if (confirm("The seconds value entered for " + displayName + " must be between 0 and 59. Press OK to correct the value or Cancel to revert the field back to its original value, \"" + givenValue + "\"?")) {
      element.focus();
      element.select();
      return false;
      }
        else {
      element.value = givenValue;
        }
  }
  hiddenElement.value = element.value + " " + ampm.options[ampm.selectedIndex].text;
  return true;
   }
   message = "The value entered for " + displayName + ", \"" + element.value + "\", is not in the desired format. Press OK to correct the value or Cancel to revert the field back to its original value, \"" + givenValue + "\".";
   if (confirm(message)) {
      element.focus();
      element.select();
      return false;
   }
   else {
     element.value = givenValue;
   }
   return true;
 }

 function ampmChange(element,time,hiddenElement){
  hiddenElement.value = time.value + " " + element.options[element.selectedIndex].text;
 }



// Validates a field against a regular expression.
function validateRegExp(element, regexp, fieldname, originalValue) {

  bOk = true;
  result = element.value.search(regexp);

  if (result == -1) {
    bOk = false;
    message = "The value entered for " + fieldname + ", \"" + element.value + "\", " +
      "is not in the desired format.  Press OK to correct the value or Cancel to " +
      "revert the field back to its orignial value, \"" + originalValue + "\".";
    var question = confirm(message);
    if (question) {
        element.focus();
        element.select();
    }
    else {
        element.value = originalValue;
    }
  }
  return bOk;
}

function checkTextAreaLength(element, maxLength, displayName) {
  if ((element.value.length) > maxLength) {
    message = "The value entered for " + displayName + " cannot exceed " + maxLength + " characters.  " +
              "Press OK to truncate the current value to its maximum characters or " +
              "Cancel to ignore. This field must be corrected before this form is submitted.";

    if (confirm(message)) {
      element.focus();
      element.value = element.value.substring(0,maxLength);
    }
    return false;
  }
  return true;
}

// This function validates a decimal value against the parameters
function validateDecimalValue(element, displayName, originalValue, prec_back, minValue, maxValue) {
  bValid = true;
  currentValue = element.value;
  if(currentValue != '') {
    if(isNaN(currentValue)) {
          message = "The value entered for " + displayName + 
                    " is not a valid numeric value.  Press OK to correct the value or " + 
                    "Cancel to revert the field back to its original value, \"" + 
                    originalValue + "\".";
          if(confirm(message)) {
            element.focus();
            element.select();
          }
          else {
            element.value = originalValue;
          }
          bValid = false;
    } // end if
    else {
      if(currentValue.indexOf('.') == - 1) {
        currentValue = currentValue + ".";
        for(i=0; i<prec_back; i++) {
          currentValue = currentValue + "0";
        } //end for
        element.value = currentValue;
        currentValue = element.value;
      } //end if
      if(currentValue.indexOf('.') == (currentValue.length - 1)) {
        for(i=0; i<prec_back; i++) {
          currentValue = currentValue + "0";
        } //end for
        element.value = currentValue;
        currentValue = element.value;        
      } //end if
      if(currentValue.length - (currentValue.indexOf('.') + 1) > prec_back) {
        x = new Number(prec_back);
        element.value = currentValue.substring(0, (currentValue.indexOf('.') + x + 1));
        currentValue = element.value;
      } //end if
      if(maxValue != '') {
        max = new Number(maxValue);
        if(currentValue > max) {
          message = "The value entered for " + displayName + 
                    " must be less than or equal to " + maxValue + ".  Press OK to correct the value or " + 
                    "Cancel to revert the field back to its original value, \"" + 
                    originalValue + "\".";
          if(confirm(message)) {
            element.focus();
            element.select();
          }
          else {
            element.value = originalValue;
          }
          bValid = false;
        } // end if
      } //end if
      if(minValue != '') {
        min = new Number(minValue);
        if(currentValue < min) {
          message = "The value entered for " + displayName + 
                    " must be greater than " + minValue + ".  Press OK to correct the value or " + 
                    "Cancel to revert the field back to its original value, \"" + 
                    originalValue + "\".";
          if(confirm(message)) {
            element.focus();
            element.select();
          }
          else {
            element.value = originalValue;
          }
          bValid = false;
        } //end if
      } //end if
    } //end else
  } //end if
  
  return bValid;
} //end validateDecimalValue

function checkDateRange(fromElement, toElement, fromDisplayName, toDisplayName, fromOriginalValue, toOriginalValue, fromMinDate, toMinDate, fromMaxDate, toMaxDate) {
	fromValid = false;
	toValid = false;
	rangeValid = false;
	
	if (fromElement.value != null && fromElement.value != "") {
		fromValid = checkDate(fromElement, fromDisplayName, fromOriginalValue, fromMinDate, fromMaxDate);
		if (!fromValid) {
			return false;
		}
	}
	
	if (toElement.value != null && fromElement.value != "") {
		toValid = checkDate(toElement, toDisplayName, toOriginalValue, toMinDate, toMaxDate);
		if (!toValid) {
			return false;
		}
	}
	
	if (fromValid && toValid) {
		fromDateString = new String(fromElement.value);
		fromMonth = fromDateString.substring(0,2);
		fromDay = fromDateString.substring(3,5);
		fromYear = fromDateString.substring(6,10);
		theFromDate = new Date (fromYear, fromMonth, fromDay);

		toDateString = new String(toElement.value);
		toMonth = toDateString.substring(0,2);
		toDay = toDateString.substring(3,5);
		toYear = toDateString.substring(6,10);
		theToDate = new Date (toYear, toMonth, toDay);
		
		dateDiff = theToDate - theFromDate;
		intDateDiff = parseInt(dateDiff);

		if(intDateDiff < 0) {
			rangeValid = false;
			alert("The " + fromDisplayName + " must be prior or equivalent to the " + toDisplayName + ".");
		} else{
			rangeValid = true;
		}
	}
	
	return rangeValid;
}

function validateSccCode(code, message) {
   result = true;

   if (code.value.length != 14) {
      result = false;
      alert(message);
   }

   return result;
}

function validateUpcCode(code, message) {
   result = true;

   if (code.value.length != 6 && code.value.length != 10) {
      result = false;
      alert(message);
   }

   return result;
}