var numbers = "1234567890";
var letters = "abcdefghijklmnopqrstuvwxyz";
var errorBlockStart = "";
var errorBlockEnd = "";
// array of validation types
// the array index is the field name
var fieldValidation = new Array();
var validationParams = new Array();
var minlengthValidation = new Array();
var maxlengthValidation = new Array();
var validationFields = new Array();
var fieldLabels = new Array();
// array of operation expressions
// the array index is the field name
var sumValidation = new Array();
// array of error messages
var validationMessages = new Array();
// the text of the errors
var errors = "";
var focusSet = true;
var sumErrorFlag = false;
//var errorDivStart = '<div class="error"><ic:img src="/common/images/icons/ico_alert.gif" align="absmiddle" height="21" width="21" border="0" vspace="2"/>&nbsp;&nbsp;&nbsp;'
var errorDivStart = '<div class="error"> <img src="' + document.location.pathname.match("/[^/]*") + '/common/images/icons/ico_alert.gif" align="absmiddle" height="21" width="21" border="0" vspace="2"/>&nbsp;&nbsp;&nbsp;'
var errorDivEnd = '</div>';
var CLR_VAL_ERROR = '#FD8E7F';
var CLR_VAL_OK = '#FFFFFF';
var c,s,i;
var found=0;
function getMessages() {
  return errors;
}

function resetMessages() {
  errors = "";
}

function getFormByName(formName) {
  return document.forms[formName];
}
function getFormByNumber(formNumber) {
  return eval('document.forms._form_tag_'+formNumber);
//  return document.forms[formNumber];
}

function getForm(form) {
  if (form==null || form=='') form = document.forms[0];
  return form;
}

function getElem(elemName, formName) {
  var form = (formName!=null && formName!='') ? form = document.forms[formName] : getForm();
  if (form.tagName == "FORM") {
    return form[elemName];
  } else { // it is a HTMLCollection of forms
    for (var i=0; i < form.length; i++) {
      if (form[i] [elemName] != undefined)
      {
        return form[i] [elemName];
      }
    }
  }
  return undefined;
}

function findObj( oName, oFrame, oDoc ) {
  if( !oDoc ) { if( oFrame ) { oDoc = oFrame.document; } else { oDoc = window.document; } }
  if( oDoc[oName] ) { return oDoc[oName]; } if( oDoc.all && oDoc.all[oName] ) { return oDoc.all[oName]; }
  if( oDoc.getElementById && oDoc.getElementById(oName) ) { return oDoc.getElementById(oName); }
  for( var x = 0; x < oDoc.forms.length; x++ ) { if( oDoc.forms[x][oName] ) { return oDoc.forms[x][oName]; } }
  for( var x = 0; x < oDoc.anchors.length; x++ ) { if( oDoc.anchors[x].name == oName ) { return oDoc.anchors[x]; } }
  for( var x = 0; document.layers && x < oDoc.layers.length; x++ ) {
    var theOb = findObj( oName, null, oDoc.layers[x].document ); if( theOb ) { return theOb; } }
  if( !oFrame && window[oName] ) { return window[oName]; } if( oFrame && oFrame[oName] ) { return oFrame[oName]; }
  for( var x = 0; oFrame && oFrame.frames && x < oFrame.frames.length; x++ ) {
    var theOb = findObj( oName, oFrame.frames[x], oFrame.frames[x].document ); if( theOb ) { return theOb; } }
  return null;
}

function noSubmit() {
  return false;
}

function canSubmitForm(form) {

  if(form.name == "actionForm") {
    if(form.isFormSubmitted != null && form.isFormSubmitted == true) {
      return false;
    }
    var elements = document.getElementsByName("btn_cancel");
    if(elements != null && elements.size > 0) {
      var cancelButton = elements[0];
      if(cancelButton != null) {
        var h = cancelButton.outerHTML;
        cancelButton.parentNode.outerHTML = h;
      }
    }
  }
  resetMessages();
  focusSet = false;
  sumErrorFlag = false;
  form = getForm(form);
  if (validateForm(form)) {
    form.isFormSubmitted = true;
    return true;
  }
  return false;
}

function submitForm(form) {
  if(canSubmitForm(form)) {
    form.submit();
    form.isFormSubmitted = true;
    return true;
  }
  return false;
}

function setValidation(fieldName, required, validationType, errorMessage, formName, params, minlength, maxlength, fieldLabel) {
  var elem = getElem(fieldName, formName);
  if (elem!=null) {
    elem.performvalidation = true;
    validationFields[validationFields.length] = elem;
    if (minlength==null || minlength=='') minlength = 0;
    if (minlength==0 && required==true) minlength = 1;
    if (minlength==0) elem.style.backgroundColor = CLR_VAL_OK;
    fieldValidation[getFieldName(elem)] = validationType;
    validationParams[getFieldName(elem)] = params;
    minlengthValidation[getFieldName(elem)] = minlength;
    maxlengthValidation[getFieldName(elem)] = maxlength;
    if (fieldLabel==null||fieldLabel=='') fieldLabel = fieldName.replace("value.", "");
    fieldLabels[getFieldName(elem)] = fieldLabel;
    if(errorMessage=='') errorMessage=null;
    validationMessages[getFieldName(elem)] = errorMessage;
  }
}

function setSumValidation(compareField, fieldOperation, formName) {
  sumValidation[getFieldName(getElem(compareField, formName))] = fieldOperation;
}

function validateForm(form) {
  if(true == form.dontValidate) return true;

  window.status = "Validating Form...";
  var retval = true;
//  for (var eIter=0; eIter<form.elements.length; eIter++) {
//    if(eIter%10==0) window.status = "Validating form element #"+eIter+"...";
//    retval = validate(form.elements[eIter]) && retval;
//  }

  for (var eIter=0; eIter<validationFields.length; eIter++) {
    if(form==validationFields[eIter].form) {
      retval = validate(validationFields[eIter]) && retval;
    }
  }
  var validationErrors = getMessages();
  if (validationErrors!=null && validationErrors!="") {
    window.status = "Form Validation Found Errors";
    document.all.formErrors.innerHTML = errorBlockStart + validationErrors + errorBlockEnd;
    return false;
  } else {
    window.status = "Form Validation Completed Successfully";
    return true;
  }

  return retval;
}

/**
 * Allow multiple validation.
 * Each validation type can be separated with a pipe character to allow muliple validation.
 * For instance "xml | maxlength" would perform validation for both xml and maxlength.
 */
function validateMultiple(field, validations) {
  var params = validationParams[getFieldName(field)];
  var validateArray = validations.toString().split("|");
  var retval = true;
  for (var i=0; i<validateArray.length; i++) {
    validation = "validate_"+validateArray[i]+"('"+field.form.name+"', '"+field.name+"', '"+params+"')";
    // We could get out at the first failure, but we want to the user to get all the
    // error messages, so that they can correct it all at once.
    retval = eval(validation) && retval;
  }
  return retval;
}

/**
 * returns a trimmed string
 */
function trim(value) {
  return value.replace(/^\s+|\s+$/g,'');
}

/**
* validates everything for this field
*/
function validate(field) {
  window.status = "Validating field '"+fieldLabels[getFieldName(field)]+"'...";
  var retval = true;
  if(field.disabled!=true && field.readOnly!=true && field.performvalidation) {
    var validation = fieldValidation[getFieldName(field)];
    if (validation!=null && validation!='') {
      retval = validateMultiple(field, validation);
    }
    //retval = retval && validate_sum(field);
    retval = validate_minlength(field) && retval;
    if (field.name!=null && field.name!='') {
                                                                                             // This shows optional fields in different color
      field.style.backgroundColor= (retval) ? (minlengthValidation[getFieldName(field)]==0 ? /*'#999999'*/CLR_VAL_OK : CLR_VAL_OK) : CLR_VAL_ERROR;
    }
  }
  if (field.disabled!=true && field.readOnly!=true && !field.performvalidation) {
      field.style.backgroundColor= CLR_VAL_OK;
  }

  window.status = "Done";

  return retval;
}

/*function validate_required(field) {
  if (requiredValidation[getFieldName(field)]=='true' && field.value=='') {
    //if (requiredErrorFlag==false) {
      //addError(field, "One or more required fields are empty");
      //requiredErrorFlag = true;
    //}
    addError(field, validationMessages[getFieldName(field)]);
    return false;
  }
  return true;
}*/

function validate_emptyString(formName, fieldName, params){
  field = getElem(fieldName, formName);
  s=field.value;
  for (i = 0; i < s.length; i++) {
    c = s.charAt(i);
    if ((c != ' ') && (c != '\n') && (c != '\t')) {
      found=1;
      break;
    }
  }
  if (found==0 && s.length >0) {
    addError(field, validationMessages[getFieldName(field)] );
    return false;
    }
     return true;
}

function validate_minlength(field) {
  var length = minlengthValidation[getFieldName(field)];
  var val = trim(field.value);
  if (length>0 && val.length<length) {
    if (validationMessages[getFieldName(field)] != null) {
      addError(field, validationMessages[getFieldName(field)]);
    }
    else if(length == 1){
      addError(field, fieldLabels[getFieldName(field)] + " is a required field");
    }
    else{
      addError(field, fieldLabels[getFieldName(field)] + " must have a minimum length of " + length);
    }
    return false;
  }
  return true;
}

function validate_maxlength(formName, fieldName, params) {
  field = getElem(fieldName, formName);
  var length = maxlengthValidation[formName+"."+fieldName];
  if (field.value.length>length) {
    if (validationMessages[getFieldName(field)] != null) {
      addError(field, validationMessages[getFieldName(field)]);
    } else {
      addError(field, fieldLabels[getFieldName(field)] + " can have a maximum length of " + length);
    }
    return false;
  }
  return true;
}

function validate_year(formName, fieldName, params){
  field = getElem(fieldName, formName);
  var retValue = true;
  if(field.value.length > 0){
    if(isNaN(field.value))
      retValue = false;
    else{
      var year = parseInt(field.value);
      retValue = (year >= 1900 && year <= 2100);
    }
    if(!retValue){
      if(validationMessages[getFieldName(field)] != null)
        addError(field, validationMessages[getFieldName(field)]);
      else
        addError(field, fieldLabels[getFieldName(field)] + " must be between 1900 and 2100");
    }
  }
  return retValue;
}
/**
   this method does validate integer. it will remove minus sign, anything right of a period
   and after that if it cant convert to numeric it returns false
   otherwise it returns true
**/
function validate_positiveinteger(formName,fieldName,params){
    field = getElem(fieldName, formName);
    field.value = integerFormatting(field.value,"false");
    var min = getParamValue(params,"min");
    var max = getParamValue(params,"max");
    if(field.value!=null && field.value!='' && (!isInteger(field) || (min!=null && parseInt(field.value)<min) || (max!=null && parseInt(field.value)>max)))
    {
      addError(field, "Please enter a valid number" + ((min!=null)?" with a minimum value of "+min:"") + ((max!=null)?((min!=null)?" and a ":" with a ")+"maximum value of "+max:"")+".");
      return false;
    }

    return true;
}

function getParamValue(params, paramName) {
  paramName = paramName+"=";
  if (params!=null && params!='') {
    var pos = params.indexOf(paramName);
    if (pos!=-1) {
      var pos2 = params.indexOf(",");
      if (pos>pos2) pos2 = params.length;
      var paramValue = params.substring(pos+paramName.length, pos2);
      return paramValue;
    }
  }
  return null;
}

function validate_email(formName, fieldName, params) {
  field = getElem(fieldName, formName);
  if (field.value.length<4 ||
      field.value.indexOf('@')<1 ||
      field.value.indexOf('.')<1 ||
      field.value.indexOf('@')==field.value.length-1 ||
      field.value.indexOf('.')==field.value.length-1) {
    addError(field, "Please enter a valid email address");
    return false;
  }
  return true;
}
function validate_max4000(formName, fieldName, params) {
  field = getElem(fieldName, formName);
  if (field.value.length>4000 )
       {
    addError(field, "The application does not allow more than 4000 characters.");
    return false;
  }else
  if (field.value.length<0)
       {
    addError(field, "Field is required.");
    return false;
  }
  return true;
}
/**
   this method is could be used to validate integer
   however, it returns true regardsless if it the value is an
   integer or not
**/
function validate_integer(formName, fieldName, params) {
  field = getElem(fieldName, formName);
  field.value = integerFormatting(field.value,"true");
  return true;
}
/**
   this method is needed for the bulk of the integer formatting functions
**/
function integerFormatting( integerString, negativeOkay ){
  integerString = getWholeNumber(integerString);
  if( negativeOkay == "false" ) {//not negative okay remove them
    integerString = stringFilter(integerString, numbers);
  } else {
    integerString = stringFilter(integerString, numbers+"-");
  }
  integerString = filterLeadingZeros(integerString);
  if( negativeOkay == "false" ) //not negative okay remove them
  {
    if( integerString.charAt(0) == '-' )
      integerString = integerString.substring(1);
  }
  return integerString;
}

/**
  Search through strings characters one by one. If character is not in bag, append to returnString.
  date format method
**/
function stripCharsInBag(s, bag){
  var i;
    var returnString = "";

    for (i = 0; i < s.length; i++){
        var c = s.charAt(i);
        if (bag.indexOf(c) == -1) returnString += c;
    }
    return returnString;
}
/**
  this checks for leap year
  date format method
**/
function daysInFebruary (year){
  /* February has 29 days in any year evenly divisible by four,
    // EXCEPT for centurial years which are not also divisible by 400. */
    return (((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0))) ? 29 : 28 );
}

/**
  this fills the daysarray
  date format method
**/
function DaysArray(n) {
  for (var i = 1; i <= n; i++) {
    this[i] = 31;
    if (i==4 || i==6 || i==9 || i==11) {this[i] = 30};
    if (i==2) {this[i] = 29};
   }
   return this;
}

/**


**/
function indexOf(dsStr,dtCh,startPos){
 var iPos = -1;
  for( iPos = startPos; iPos < dsStr.length;iPos++)
  {
    if( dsStr.charAt(iPos) == dtCh )
      return iPos;
  }
  return -1;
}





/**
  this is needed to validate any date. it will replace hyphens or spaces if
  the user followed the format
  dd/mm/yy or dd/mm/yyyy else it will show the user an error message box
**/
function validate_date(formName, fieldName, params) {
  field = getElem(fieldName, formName);
  delim = "/";
  var dateStr = stringFilter(field.value, numbers+"/-:");
  dateStr = dateStr.replace("-", delim);
  dateStr = dateStr.replace(":", delim);

  // Separate the date into elements
  var array = getNextDateElem(dateStr, delim, 2);
  var month = array[0];
  dateStr = array[1];

  var array = getNextDateElem(dateStr, delim, 2);
  var day = array[0];
  dateStr = array[1];

  var array = getNextDateElem(dateStr, delim, 4);
  var year = array[0];
  dateStr = array[1];

  if (month.length==1) month = "0" + month;
  if (day.length==1) day = "0" + day;

  var newDate = month+day+year;
  if (newDate.length==0) {
    field.value = "";
    return true;
  }
  field.value = formatDateString(newDate);

  if(!isValidDate(field.value,fieldName,delim) )
  {
    addError(field, "Please enter a valid date");
    return false;
  }
  else
    return true;
}

function getNextDateElem(dateStr, delim, length) {
  var pos = dateStr.indexOf(delim);
  var sub1;
  var sub2;
  if (pos!=-1) {
    sub1 = dateStr.substring(0, pos);
    sub2 = dateStr.substring(pos+1);
  } else {
    sub1 = dateStr.substring(0, length);
    sub2 = dateStr.substring(length);
  }
  var array = new Array;
  array[0] = sub1;
  array[1] = sub2;
  return array;
}
/**
*
* this method is the heart of the date validator
* 040703 which is 4 jul 2003
* or
* 04072003 which is 4 jul 2003
* @return
*/
function isValidDate(dtStr,field,dtCh){
  var minYear=1900;
  var maxYear=2100;
  var daysInMonth = DaysArray(12);
  //pos1 = dtStr.indexOf(dtStr) + 1;
  var iPos1 = 0;
  var iPos2 = 0;
  iPos1 = indexOf(dtStr,dtCh,0);
  if( iPos1 != -1 )
    iPos2 = indexOf(dtStr,dtCh,(iPos1 + 1) );
  else
    return false;

  var strMonth =dtStr.substring(0,iPos1);
  var strDay   =dtStr.substring(iPos1+1,iPos2);
  var strYear  =dtStr.substring(iPos2+1);
  strYr=strYear;
  if (strDay.charAt(0)=="0" && strDay.length>1)
    strDay=strDay.substring(1);
  if (strMonth.charAt(0)=="0" && strMonth.length>1)
    strMonth=strMonth.substring(1);
  for (var i = 1; i <= 3; i++)
  {
    if (strYr.charAt(0)=="0" && strYr.length>1) strYr=strYr.substring(1);
  }
  month=parseInt(strMonth);
  day=parseInt(strDay);
  year=parseInt(strYr);
   if (iPos1==-1 || iPos2==-1){
    return false;
  }
  if (strMonth.length < 1 ||  month < 1 || month > 12 )
  {
    return false;
  }

  if (strDay.length<1 || day<1 || day>31 || (month==2 && day>daysInFebruary(year)) || day > daysInMonth[month]){
    return false;
  }
  if (strYear.length != 4 || year==0 || year<minYear || year>maxYear){
    return false;
  }
  if ( indexOf( dtStr, dtCh,iPos2+1)!=-1 || isInteger(stripCharsInBag(dtStr, dtCh))==false){
    return false;
  }
return true;
}
/**
*
* this method formats the date string if a user enters in either
* 040703 which is 4 jul 2003
* or
* 04072003 which is 4 jul 2003
* @return
*/
function formatDateString(dtStr,number) {
   field1 = dtStr.substring(0,2);
   field2 = dtStr.substring(2,4);
   field3 = dtStr.substring(4,8);
   if(dtStr.length == 6)//only has two characters for date we need to guess what the year value might be
   {
     if( field3 < 50 )//probably add 20
       field3 = "20" + field3;
     else
       field3 = "19" + field3;
   }
   return ( field1 + "/" + field2 + "/" + field3 );
}

/**
   this checks and sees if the value is strictly numeric
   date method

**/
function isInteger(s){
  var i;
    for (i = 0; i < s.length; i++){
        // Check that current character is number.
        var c = s.charAt(i);
        if (((c < "0") || (c > "9"))) return false;
    }
    // All characters are numbers.
    return true;
}
/**
   date format method
**/

function validate_sum(field) {
  if (field.value == '') return true;
  var fieldOperation = sumValidation[getFieldName(field)];
  if (fieldOperation!=null) {
    var tot = 0;
    var elem = '';
    var op = '+';
    for (var sIndex=0; sIndex<fieldOperation.length; sIndex++) {
      var char = fieldOperation.charAt(sIndex);
      if (char == '+' || char == '-') {
        //alert(getElem(elem).value);
        tot = eval (tot + op + parseInt(getElem(elem).value));
        op = char;
        elem = '';
      } else {
        elem += char;
      }
    }
    //alert(tot + op + parseInt(getElem(elem).value));
    tot = eval (tot + op + parseInt(getElem(elem).value));

//    alert(tot);
/*    for (var i=0; i<fieldArray.length; i++) {
      tot += eval(getElem(fieldArray[i]).value);
    }
*/
    if (tot != eval(field.value)) {
      if (sumErrorFlag==false) {
        addError(field, "One or more calculated fields have the incorrect value");
        sumErrorFlag = true;
      }
      return false;
    }
  }

  return true;
}

function addError(field, error) {
  errors += errorDivStart + error;
  if (field!=null && !focusSet) {
    try {
      field.focus();
      if (field.type=="text") field.select();
    } catch(e) {}
    focusSet = true;
  }
  errors += errorDivEnd;
}

/*function formatCurrency(num) {
  num = num.toString().replace(/\$|\,/g,'');
  if(isNaN(num))
    num = "0";
  sign = (num == (num = Math.abs(num)));
  num = Math.floor(num*100+0.50000000001);
  cents = num%100;
  num = Math.floor(num/100).toString();
  if(cents<10)
    cents = "0" + cents;
  for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++)
    num = num.substring(0,num.length-(4*i+3))+','+
  num.substring(num.length-(4*i+3));
  return (((sign)?'':'-') + '$' + num );
}*/

function stringFilter (value, allowed) {
  var i;
  var retString = "";
  for (i = 0; i < value.length; i++) {  // Search through string and append to unfiltered values to returnString.
    var c = value.charAt(i);
    if (allowed.indexOf(c) > -1) retString += c;
  }
  return retString;
}

function filterLeadingZeros (value) {
  var x;
  for (x = 0; x < value.length; x++) {
    var c = value.charAt(x);
    if ( c != "0") {
      value = value.substring(x);
      break;
    }
  }
  return value;
}

function getWholeNumber(value) {
  var c = indexOf(value,".",0);
  if (c > -1)
  {
    return value.substring(0,c);
  }
  return value;
}

function getFieldName(field) {
  return field.form.name + "." + field.name;
}

/*var focusField;
function keyDown(DnEvents) { // handles keypress
  k = (isNetscape()) ? DnEvents.which : window.event.keyCode;
  if (k == 13) { // enter key pressed
    var nextIndex = 0;
    var form = document.forms[0];
    if (focusField != null && focusField != '') {
      nextIndex = getIndex(focusField)+1;
      form = focusField.form;
    }
    if (nextIndex<form.length) {
      form[nextIndex].focus();
      form[nextIndex].select();
      return false;
    } else {
      return submitForm(form);
    }
  }
}

document.onkeydown = keyDown; // work together to analyze keystrokes
if (isNetscape()) document.captureEvents(Event.KEYDOWN|Event.KEYUP);*/

function putFocus(formName, fieldName) {
  if (document.forms.length > 0) {
    document.forms[formName].elements[fieldName].focus();
  }
}

function getIndex(field) {
  var index = -1, i = 0, found = false;
  while (i < field.form.length && index == -1)
    if (field.form[i] == field) index = i;
    else i++;
  return index;
}

function setFocus(field) {
  focusField = field;
}

function validate_codetype(formName, fieldName, params) {
  field = getElem(fieldName, formName);
  var validationParams = "codetype";
  validationParams=validationParams+"|"+params;

  if (!invokeRegularExpressionValidation(field, validationParams)) {

    if(validationMessages[getFieldName(field)] != null) {
      addError(field, validationMessages[getFieldName(field)]);
    }
    else if (params != "" || params != "*") {
      // Dump the code type(s) out.
      var extensions = params.split(",");
      var exs = "";
      for( var i = 0; i < extensions.length; i++ ) {
        exs = exs + "." + extensions[i]
        if (i + 1< extensions.length) {
          exs = exs + ", ";
        }
      }
      addError(field, fieldLabels[getFieldName(field)] + " has to be the valid code type(s): " + exs);
    }
    else {
      addError(field, fieldLabels[getFieldName(field)] + " has to be a valid code type.");
    }
    return false;
  }
}

function validate_phone(formName, fieldName, params) {
  field = getElem(fieldName, formName);
  if(field.value.length>0){
    var validationParams = "phone";
    validationParams=validationParams+"|"+params;
    if (!invokeRegularExpressionValidation(field, validationParams)) {
      if (validationMessages[getFieldName(field)] != null) {
        addError(field, validationMessages[getFieldName(field)]);
      } else {
        addError(field, fieldLabels[getFieldName(field)] + " has to be a valid phone number plus the area code.");
      }
      return false;
    }
  }
  return true;
}

function validate_money(formName, fieldName, params) {
  field = getElem(fieldName, formName);
  var validationParams = "money";
  validationParams=validationParams+"|"+params;
  if (!invokeRegularExpressionValidation(field, validationParams)) {
    if (validationMessages[getFieldName(field)] != null) {
      addError(field, validationMessages[getFieldName(field)]);
    } else {
      addError(field, fieldLabels[getFieldName(field)] + " has to be a valid currency.");
    }
    return false;
  }
  return true;
}

function validate_file(formName, fieldName, params) {
  field = getElem(fieldName, formName);
  if(field.value.length>0){
    var validationParams = "file";
    validationParams=validationParams+"|"+params;
    if (!invokeRegularExpressionValidation(field, validationParams)) {
      if (validationMessages[getFieldName(field)] != null) {
        addError(field, validationMessages[getFieldName(field)]);
      }
      else if (params != "" || params != "*") {
        // Dump the file extensions out.
        var extensions = params.split(",");
        var exs = "";
        for( var i = 0; i < extensions.length; i++ ) {
          exs = exs + "." + extensions[i]
          if (i + 1< extensions.length) {
            exs = exs + ", ";
          }
        }
        addError(field, fieldLabels[getFieldName(field)] + " has to be a valid file with the following extensions: " + exs);
      }
      else {
        addError(field, fieldLabels[getFieldName(field)] + " has to be a valid file.");
      }
      return false;
    }
  }
  return true;
}

function invokeRegularExpressionValidation(validateObj, validateType) {
  testOk = false;
  var params = validateType.split("|");     // Separates validation string into parameters
  if (params[0] == 'money') {        // Sets flags for money syntax
    var dollarsign = (params[1].indexOf('$') != -1);
    var grouping = (params[1].indexOf(',') != -1);
    var decimal  = (params[1].indexOf('.') != -1);
    var num = 2;
    if (params.length > 2)
      num = params[2];
  }
  switch (params[0]) {         // Calls appropriate validation function based on type
    //case 'blank' : if (validateBlank(validateObj)) testOk = true; break;
    //case 'equalto' : if (validateEqualTo(validateObj, params[1], Frm)) testOk = true; break;
    //case 'length' : if (validateLength(validateObj, params[1])) testOk = true; break;
    //case 'number' : if (validateNumber(validateObj, params[1], params[2], params[3])) testOk = true; break;
    //case 'numeric' : if (validateNumeric(validateObj, params[1])) testOk = true; break;
    //case 'alnum' : if (validateAlnum(validateObj, params[1], params[2], params[3], params[4], params[5] )) testOk = true; break;
    //case 'decimal' : if (validateDecimal(validateObj, params[1], params[2] )) testOk = true; break;
    //case 'decimalr' : if (validateDecimalR(validateObj, params[1], params[2], params[3], params[4] )) testOk = true; break;
    //case 'ip'  : if (validateIP(validateObj, params[1], params[2])) testOk = true; break;
    //case 'ssn'  : if (validateSSN(validateObj)) testOk = true; break;
    case 'money' : if (validateMoney(validateObj, dollarsign, grouping, decimal, num)) testOk = true; break;
    //case 'zip'  : if (validateZip(validateObj, params[1])) testOk = true; break;
    //case 'cazip' : if (validateCAzip(validateObj)) testOk = true; break;
    case 'phone' : if (validatePhone(validateObj)) testOk = true; break;
    //case 'email' : if (validateEmail(validateObj)) testOk = true; break;
    //case 'date'  : if (validateDate(validateObj, params[1], params[2], params[3], params[4])) testOk = true; break;
    //case 'cc'  : if (validateCC(validateObj)) testOk = true; break;
    //case 'select' : if (validateSelect(validateObj)) testOk = true; break;
    //case 'selectm' : if (validateSelectM(validateObj, params[1], params[2])) testOk = true; break;
    //case 'selecti' : if (validateSelectI(validateObj, params[1])) testOk = true; break;
    //case 'checkbox' : if (validateCheckbox(validateObj, params[1], params[2])) testOk = true; break;
    //case 'radio' : if (validateRadio(validateObj)) testOk = true; break;
    //case 'eitheror' : if (validateEitherOr(validateObj, params[1], params[2])) testOk = true; break;
    //case 'atleast' : if (validateAtLeast(validateObj, params[1], params[2], params[3])) testOk = true; break;
    case 'file'  : if (validateFile(validateObj, params[1])) testOk = true; break;
    //case 'custom' : if (validateCustom(validateObj)) testOk = true; break;
    // Add additional cases here
    case 'codetype'  : if (validateCodetype(validateObj, params[1])) testOk = true; break;    
    default   : alert('Validation Type Not Found:\n'+params[0]);
  }
  return testOk;
}

/***************************************************************************/
/*
Syntax: validation="money" validationParams="flags|rightdigits"
flags A string of up to three characters. Valid characters are period (.) comma (,) and dollar sign ($).
$ = Dollar sign required beginning of the string
, = Digit grouping must be applied (a comma between every 3rd digit)
. = The decimal plus 2 or 'rightdigits' digits is required at end of string
rightdigits The number of digits after the decimal point
Errors: if Field data does not match money format specified -OR- is left blank*
Notes: The flags can appear in any order. Omission of flags (just using "money") will validate the field, but with all flag parameters as optional.
Examples:
  money|&, ( '$99,999'-OR- '$9' -OR- '$999,999,999' )
  money|,. ( '99,999.99'-OR- $9.99' -OR- '999,999,999.99' )
  money|*|4 ( '99,999.999'-OR- $9.9999' -OR- '999,999,999.9' )
*/
function validateMoney(formObj, ds, grp, dml, num) {
  var moneySyntax;
  if (ds && grp && dml)  // Dollar sign, grouping, and decimal
    { moneyReg = "^\\$(?:(?:[0-9]{1,3},)(?:[0-9]{3},)*[0-9]{3}|[0-9]{1,3})(\\.[0-9]{0,"+num+"})$"; moneySyntax = "$XX,XXX.XX"; }
  if (ds && grp && !dml)  // Dollar sign and grouping
    { moneyReg="^\\$(?:(?:[0-9]{1,3},)(?:[0-9]{3},)*[0-9]{3}|[0-9]{1,3})$"; moneySyntax="$XX,XXX"; }
  if (ds && !grp && dml)  // Dollar sign and decimal
    { moneyReg="^\\$[0-9]*(\\.[0-9]{0,"+num+"})$"; moneySyntax="$XXXXX.XX"; }
  if (!ds && grp && dml)  // Grouping and decimal
    { moneyReg="^(?:(?:[0-9]{1,3},)(?:[0-9]{3},)*[0-9]{3}|[0-9]{1,3})(\\.[0-9]{0,"+num+"})?$"; moneySyntax="XX,XXX.XX"; }
  if (ds && !grp && !dml)  // Dollar sign only
    { moneyReg="^\\$[0-9]*$"; moneySyntax="$XXXXX"; }
  if (!ds && grp && !dml)  // Grouping only
    { moneyReg="^(?:(?:[0-9]{1,3},)(?:[0-9]{3},)*[0-9]{3}|[0-9]{1,3})$"; moneySyntax="XX,XXX"; }
  if (!ds && !grp && dml)  // Decimal only
    { moneyReg="^[0-9]*(\\.[0-9]{0,"+num+"})$"; moneySyntax="XXXXX.XX"; }
  if (!ds && !grp && !dml) // No params set, all special chars become optional
    { moneyReg="^\\$?(?:(?:[0-9]{1,3},?)(?:[0-9]{3},?)*[0-9]{3}|[0-9]{1,3})(\\.[0-9]{0,"+num+"})?$"; moneySyntax="[$]XX[,]XXX[.XX]"; }
  var regex = new RegExp(moneyReg);
  return regex.test(formObj.value);
}

/***************************************************************************
 * Syntax: validation="float"
 * Purpose:  Use this method to validate a float number
 *****************************************************************************/
function validate_float(formName, fieldName, params) {
  var field = getElem(fieldName, formName);
  if(!parseFloat(field.value)) {
    if (validationMessages[getFieldName(field)] != null) {
      addError(field, validationMessages[getFieldName(field)]);
    } else {
      addError(field, fieldLabels[getFieldName(field)] + " has to be a valid decimal number.");
    }
    return false;
  }
  return true;
}

/***************************************************************************
 * Syntax: validation="floatNumber"
 * Purpose:  Use this method to validate a float number, signed or unsigned.
 *****************************************************************************/
function validate_floatNumber(formName, fieldName, params)
{
  var field = getElem(fieldName, formName);
  var numeric = field.value;
  var numOfDecPoint = 0;
  var firstCharFound = false;
  var numOfDecimals = 0;
  for(var j = 0; j < numeric.length; j++)
    {
      var alpha = numeric.charAt(j);
      if(alpha != " ")
      {
        firstCharFound = true;
      }
      if(firstCharFound)
      {
        var hh = alpha.charCodeAt(0);
        if(hh != 43 && hh != 46 && hh != 45 && !(hh > 47 && hh < 58))
        {
          //addError(field, fieldLabels[getFieldName(field)] + " has to be a valid float number.");
          addError(field, " Please provide a valid number.");
          return false;
        }
        if(j > 0 && (hh == 43 || hh == 45))
        {
          //addError(field, fieldLabels[getFieldName(field)] + " has to be a valid float number.");
          addError(field, " Please provide a valid number.");
          return false;
        }
        if(hh == 46)
        {
          ++numOfDecimals;
          if(numOfDecimals > 1)
          {
            //addError(field, fieldLabels[getFieldName(field)] + " has to be a valid float number.");
            addError(field, " Please provide a valid number.");
            return false;
          }
        }
      }
  }
    if(!parseFloat(field.value))
  {
    //addError(field, fieldLabels[getFieldName(field)] + " has to be a valid float number.");
    addError(field, " Please provide a valid number.");
    return false;
  }
  return true;
}

/***************************************************************************/
/*
Syntax: validation="file" validationParams="extensions|cSens"
extensions  Comma separated list of valid file extensions
sCens       Boolean value indicating whether or not the filetype extension should be case sensitive.
Errors:     File entered is not of valid type as specified -OR- is left blank
Examples:
  file|pdf|0 ( PDF files, case insensitive)
*/
function validateFile(formObj, extensions, cSens) {
  cSens = (cSens) ? "" : "i";
  regExten = extensions.replace(/,/g,"|");
  var fileReg = "^.+\\.("+regExten+")$";
  var regex = new RegExp(fileReg,cSens);
  return regex.test(formObj.value);
}

function validateCodetype(formObj, codetype, cSens) {
  cSens = (cSens) ? "" : "i";
  regExp = codetype.replace(/,/g,"|");
  regCpt="^[0-9]{4}([tf]|[0-9]{1})$";
  regHcpcs="^[a-z]{1}[0-9]{4}$";
  regI9="^([0-9]{2}|([0-9]{3}))(.?[0-9]{1}|.?[0-9]{2})$";
  
  if(regExp=="cpt|hcpcs" || regExp=="hcpcs|cpt"){
    var typeExp = new RegExp(regCpt,cSens);
    if(!typeExp.test(formObj.value)){
      var typeExp = new RegExp(regHcpcs,cSens);
     if(!typeExp.test(formObj.value))
       return false;
    }     
  }else if(regExp=="cpt"){
    var typeExp = new RegExp(regCpt,cSens);
    if(!typeExp.test(formObj.value))
      return false;
  }else if(regExp=="hcpcs"){
    var typeExp = new RegExp(regHcpcs,cSens);
    if(!typeExp.test(formObj.value))
      return false;  
  }else if(regExp=="i9v1" || regExp=="i9v3"){
    var typeExp = new RegExp(regI9,cSens);
    if(!typeExp.test(formObj.value))
      return false;    
  }
  return true;
}

/******************************************************/

function validate_fromAndToDate(formName, fieldName, params) {
  field = getElem(fieldName, formName);
  //delim = "/";
 
  //var delimLoc = field.value.indexOf("/");
   //alert("delimLoc:"+ delimLoc);
  //if (delimLoc == -1) {
    //addError(field, "Please enter a valid date(mm/dd/yyyy)");
    //return false;
  //}
  var result = validate_date(formName, fieldName, params);
  
  if(result) {
     if(compareDates(field.value , formatDate(new Date(),'MM/dd/yyyy'))){
    addError(field, "Date cannot be a future date");
    result = false;
     return result;
      }
  }
  
  if(result){
   if(fieldName == "toDate"){
     var fromDate = getElem('fromDate', formName);
     var toDate = getElem('toDate', formName);
      if(compareDates(fromDate.value , toDate.value)){
    addError(fromDate, "FromDate has to be less than ToDate");
     result = false;
     return result;
     }
   }
  }  
  return result;
 
}

/**
 To Compare two Dates.
*/
function compareDates(date1 , date2){
 var date1Arr = date1.split("/");
 var date2Arr = date2.split("/");
 month1 = date1Arr[0];
 date1 = date1Arr[1];
 year1 = date1Arr[2];
 month2 = date2Arr[0];
 date2 = date2Arr[1];
 year2 = date2Arr[2];
 if(year1 > year2){
  return true;
 }else
 if(year1 == year2 && month1 > month2){
  return true;
 }else
 if(year1 == year2 && month1 == month2 && date1 > date2){
   return true;
 }else
 return false;
}

function LZ(x) {return(x<0||x>9?"":"0")+x}

/**
To Convert the date to MM/dd/yyyy Format.
*/
function formatDate(date,format) {
 format=format+"";
 var result="";
 var i_format=0;
 var c="";
 var token="";
 var y=date.getYear()+"";
 var M=date.getMonth()+1;
 var d=date.getDate();
 var E=date.getDay();
 var H=date.getHours();
 var m=date.getMinutes();
 var s=date.getSeconds();
 var yyyy,yy,MMM,MM,dd,hh,h,mm,ss,ampm,HH,H,KK,K,kk,k;
 // Convert real date parts into formatted versions
 var value=new Object();
 if (y.length < 4) {y=""+(y-0+1900);}
 value["y"]=""+y;
 value["yyyy"]=y;
 value["yy"]=y.substring(2,4);
 value["M"]=M;
 value["MM"]=LZ(M);
 //value["MMM"]=MONTH_NAMES[M-1];
 //value["NNN"]=MONTH_NAMES[M+11];
 value["d"]=d;
 value["dd"]=LZ(d);
 //value["E"]=DAY_NAMES[E+7];
 //value["EE"]=DAY_NAMES[E];
 value["H"]=H;
 value["HH"]=LZ(H);
 if (H==0){value["h"]=12;}
 else if (H>12){value["h"]=H-12;}
 else {value["h"]=H;}
 value["hh"]=LZ(value["h"]);
 if (H>11){value["K"]=H-12;} else {value["K"]=H;}
 value["k"]=H+1;
 value["KK"]=LZ(value["K"]);
 value["kk"]=LZ(value["k"]);
 if (H > 11) { value["a"]="PM"; }
 else { value["a"]="AM"; }
 value["m"]=m;
 value["mm"]=LZ(m);
 value["s"]=s;
 value["ss"]=LZ(s);
 while (i_format < format.length) {
  c=format.charAt(i_format);
  token="";
  while ((format.charAt(i_format)==c) && (i_format < format.length)) {
   token += format.charAt(i_format++);
   }
  if (value[token] != null) { result=result + value[token]; }
  else { result=result + token; }
  }
 return result;
 }
 
 
/*********************************************************/

///***************************************************************************/
//function validateBlank(formObj) {
//  var objName = formatName(formObj);
//  if (fv['is'].ie5 || fv['is'].mac) {
//    if (formObj.value == "") {
//      return errorProcess2(formObj,0,1,'Please enter the '+objName);
//      }
//    }
//  else {
//    var regex = new RegExp(/\S/);
//    if (!regex.test(formObj.value)) {
//      return errorProcess2(formObj,1,1,'Please enter the '+objName);
//      }
//    }
//  return true;
//  }
///***************************************************************************/
//// Special function used for bok
//function checkBlank(formObj) {
//  if (formObj.value == "")
//    return true;
//  var regex = new RegExp(/^\s+$/);
//  if (regex.test(formObj.value))
//    return true;
//  return false;
//  }
//
///***************************************************************************/
//function validateEqualTo(formObj, otherObjName, Frm) {
//  var objName = formatName(formObj);
//  var equalToValue = Frm.elements[otherObjName].value;
//
//  if (formObj.value != equalToValue) {
//    return errorProcess2(formObj,1,1,otherObjName+' must be the same as '+objName+'.\nPlease make sure the data you entered matches.');
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateLength(formObj,len) {
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//
//  if (formObj.value.length < parseInt(len)) {
//    return errorProcess2(formObj,1,1,'The '+objName+' must be at least '+len+' characters long');
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateNumber(formObj, type, lb, ub) {
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//
//  var num = formObj.value;
//  if (isNaN(num) || checkBlank(formObj)) {
//    return errorProcess2(formObj,1,1,'Please enter a valid number');
//    }
//  num = (parseInt(type) == 1) ? parseFloat(num) : parseInt(num) ;
//  if (num < lb || num > ub) {
//    return errorProcess2(formObj,1,1,'Please enter a number between ' + lb + ' and ' + ub);
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateNumeric(formObj, len) {
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//  var objName = formatName(formObj);
//
//  if (len == '*') {
//    var regex = /^\d+$/;
//    if (!regex.test(formObj.value)) {
//      return errorProcess2(formObj,1,1,'Only numeric values are valid for the ' + objName);
//      }
//    }
//  else {
//    numReg = "^\\d{"+parseInt(len)+",}$";
//    var regex = new RegExp(numReg);
//    if (!regex.test(formObj.value)) {
//      return errorProcess2(formObj,1,1,'A minimum of '+len+' numeric values are required for the ' + objName);
//      }
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateAlnum(formObj, minLen, tCase, numbers, spaces, puncs) {
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//  var arrE = new Array();
//  arrE[0] = (minLen == "*") ? "None" : minLen;
//  var okChars = "";
//  switch (tCase.toUpperCase()) {
//    case 'U'  : okChars = "A-Z"; arrE[1] = "UPPER"; break;
//    case 'L'  : okChars = "a-z"; arrE[1] = "lower"; break;
//    case 'C'  : okChars = "A-Z][a-z"; if (minLen != "*") minLen--; arrE[1]="Initial capital"; break;
//    default   : okChars = "a-zA-Z"; arrE[1]="Any"; break;
//    }
//  if (parseInt(numbers)) { okChars += "0-9"; arrE[2] = "Yes"; } else arrE[2] = "No";
//  if (parseInt(spaces)) { okChars += " "; arrE[3] = "Yes"; } else arrE[3] = "No";
//  if (puncs == "all") { okChars += "."; arrE[4] = "All"; }
//  if (puncs == "all") { okChars += puncStr("!@#$%^&*()_+-={}|[]:\";'<\\>?,.?~`"); arrE[4] = "All"; }
//  else if (puncs == "none") arrE[4] = "None";
//  else { okChars += puncStr(puncs); arrE[4] =  puncStr(puncs).replace(/\\/g,""); }
//  var length = (minLen == "*") ? "+ ?" : "{"+minLen+",}";
//  var alnumReg = "^["+okChars+"]"+length+"$";
//  var regex = new RegExp(alnumReg);
//  if (!regex.test(formObj.value) ) {
//    return errorProcess2(formObj,1,1,"The data you entered ("+formObj.value+") does not match the requested format for the "+objName+"\nMinimum Length: "+arrE[0]+"\nCase: "+arrE[1]+"\nNumbers allowed: "+arrE[2]+"\nSpaces allowed: "+arrE[3]+"\nPunctuation characters allowed: "+arrE[4]);
//    }
//  return true;
//  }
///***************************************************************************/
//function validateDecimal(formObj, lval, rval) {
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//
//  (lval == '*')? lval = '*': lval = parseInt(lval);
//  (rval == '*')? rval = '*': rval = parseInt(rval);
//  var decReg = "";
//  if (lval == 0)
//    decReg = "^\\.[0-9]{"+rval+"}$";
//  else if (lval == '*')
//    decReg = "^[0-9]"+lval+"\\.[0-9]{"+rval+"}$";
//  else if (rval == '*')
//    decReg = "^[0-9]{"+lval+"}\\.[0-9]"+rval+"$";
//  else
//    decReg = "^[0-9]{"+lval+"}\\.[0-9]{"+rval+"}$";
//  var regex = new RegExp(decReg);
//  if (!regex.test(formObj.value)) {
//    return errorProcess2(formObj,1,1,formObj.value+' is not a valid '+objName+'.  Please re-enter the '+objName);
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateDecimalR(formObj, lmin, lmax, rmin, rmax) {
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//
//  (lmin == '*')? lmin = 0: lmin = parseInt(lmin);
//  (lmax == '*')? lmax = '': lmax = parseInt(lmax);
//  (rmin == '*')? rmin = 0: rmin = parseInt(rmin);
//  (rmax == '*')? rmax = '': rmax = parseInt(rmax);
//  var decReg = "^[0-9]{"+lmin+","+lmax+"}\\.[0-9]{"+rmin+","+rmax+"}$";
//  var regex = new RegExp(decReg);
//  if (!regex.test(formObj.value)) {
//    return errorProcess2(formObj,1,1,formObj.value+' is not a valid '+objName+'.  Please re-enter the '+objName);
//    }
//  return true;
//  }
///***************************************************************************/
//function validateIP(formObj, portMin, portMax) {
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//  if (typeof portMin == 'undefined') portMin = 0;
//  if (typeof portMax == 'undefined') portMax = 99999;
//  var portOk = true;
//  var ipReg = "^((?:([2]{1}[0-5]{2})|([2]{1}[0-4]{1}[0-9]{1})|([1]?[0-9]{2})|([0-9]{1}))[\\.]){3}(?:([2]{1}[0-5]{2})|([2]{1}[0-4]{1}[0-9]{1})|([1]?[0-9]{2})|([0-9]{1}))(\\:[0-9]{1,5})?$";
//  var portLoc = formObj.value.indexOf(":");
//  if (portLoc != -1) {
//     var port = parseInt(formObj.value.substring(portLoc+1));
//     if (port < portMin || port > portMax) portOk = false;
//     }
//  var regex = new RegExp(ipReg);
//  if (!regex.test(formObj.value) || !portOk) {
//    var errorMessage =  (regex.test(formObj.value) && !portOk) ?
//      "The port number you specified, "+port+",  is out of range.\nIt must be between "+portMin+" and "+portMax :
//      formObj.value+' is not a valid IP address.  Please re-enter';
//    return errorProcess2(formObj,1,1,errorMessage);
//    }
//  return true;
//  }
///***************************************************************************/
//function validateSSN(formObj) {
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//
//  var regex = new RegExp(/^\d{3}\-\d{2}\-\d{4}$/);
//  if (!regex.test(formObj.value)) {
//    return errorProcess2(formObj,1,1,formObj.value+' is not a valid Social Security Number.\nYour SSN must be entered in \'XXX-XX-XXXX\' format.');
//    }
//  return true;
//  }
///***************************************************************************/
//function validateSelect(formObj) {
//  var objName = formatName(formObj);
//  if (formObj.selectedIndex == 0) {
//    return errorProcess2(formObj,0,1,"Please select the "+objName);
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateSelectM(formObj, minS, maxS) {
//  var objName = formatName(formObj);
//  var selectCount = 0;
//  if (maxS == 999) maxS = formObj.length;
//  for (var i=0; i<formObj.length; i++)
//    {
//    if (formObj.options[i].selected)
//      selectCount++;
//    }
//  if (selectCount < minS || selectCount > maxS) {
//    return errorProcess2(formObj,0,1,'Please select between '+minS+' and '+maxS+' '+objName+'.\nYou currently have '+selectCount+' selected');
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateSelectI(formObj, indexes) {
//  var objName = formatName(formObj);
//  var arrIndexes =indexes.split(/[,]/);
//  var selectOK = true;
//  for (var i=0; i<arrIndexes.length; i++)
//    if (formObj.selectedIndex == arrIndexes[i])
//      selectOK = false;
//  if (!selectOK) {
//    return errorProcess2(formObj,0,1,"Please select a valid option for "+objName);
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateZip(formObj, sep) {
//  if (typeof sep == 'undefined')
//    sep = "- ";
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//  zipReg = "^[0-9]{5}(|["+puncStr(sep)+"]?[0-9]{4})$";
//  var regex = new RegExp(zipReg);
//  if (!regex.test(formObj.value)) {
//    return errorProcess2(formObj,1,1,"Please enter a valid 5 or 9 digit Zip code.");
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateCAzip(formObj) {
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//
//  zipReg = "^[A-Z][0-9][A-Z] [0-9][A-Z][0-9]$";
//  var regex = new RegExp(zipReg);
//  if (!regex.test(formObj.value)) {
//    return errorProcess2(formObj,1,1,"Please enter a valid postal code.");
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateEmail(formObj) {
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//
//  var emailStr = formObj.value;
//  var emailReg1 = /(@.*@)|(\.\.)|(@\.)|(\.@)|(^\.)/; // not valid
//  var emailReg2 = /^.+\@(\[?)[a-zA-Z0-9\-\.]+\.([a-zA-Z]{2,6}|[0-9]{1,3})(\]?)$/; // valid
//  if (!(!emailReg1.test(emailStr) && emailReg2.test(emailStr))) {// if syntax is valid
//    return errorProcess2(formObj,1,1,"Please enter a valid Email address.");
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateDate(formObj, dateStr, delim, code, specDate) {
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//
//  var months = ['January','February','March','April','May','June','July','August','September','October','November','December'];
//  var vDate = formObj.value;
//  var mPlace = dateStr.indexOf("m");
//  var dPlace = dateStr.indexOf("d");
//  var yPlace = dateStr.indexOf("y");
//  var yLength = dateStr.lastIndexOf("y") - yPlace + 1;
//  var dateReg = dateStr.replace(/\w/g,"\\d");
//  delim = puncStr(delim);
//  dateReg = dateReg.replace(/-/g,"[" + delim + "]");
//  dateReg = "^" + dateReg + "$";
//  var day = vDate.substring(dPlace, dPlace+2);
//  var month = vDate.substring(mPlace, mPlace+2);
//  var year = vDate.substring(yPlace, yPlace + yLength);
//  var regex = new RegExp(dateReg);
//  var d = new Date(months[month-1] + " " + day + ", " + year);
//  var today = (specDate == 'today') ? new Date() : new Date(specDate);
//  today.setHours(0);
//  today.setMinutes(0);
//  today.setSeconds(0);
//  today.setMilliseconds(0);
//  var timeDiff = today.getTime() - d.getTime();
//  var dateOk = false;
//  switch (parseInt(code)) {
//    case 1 : // Before specDate
//      dateOk = (timeDiff > 0);
//      break;
//    case 2 : // Before or on specDate
//      dateOk = ((timeDiff + 86400000) > 0);
//      break;
//    case 3 : // After specDate
//      dateOk = (timeDiff < 0);
//      break;
//    case 4 : // After or on specDate
//      dateOk = ((timeDiff - 86400000) < 0);
//      break;
//    default : dateOk = true;
//    }
//  if (!regex.test(vDate) || d == 'NaN' || !dateOk) {
//    return errorProcess2(formObj,1,1,"Please enter a valid date");
//    }
//  return true;
//  }
//
///***************************************************************************/
function validatePhone(formObj) {

  phoneReg = "^(?:[\(][0-9]{3}[\)]|[0-9]{3})[-. ]?[0-9]{3}[-. ]?[0-9]{4}$";
  var regex = new RegExp(phoneReg); 
  return regex.test(formObj.value);
  }

///***************************************************************************/
//function validateCheckbox(formObj, minC, maxC) {
//  var objName = formatName(formObj);
//  var formObj = formObj.form.elements[formObj.name];
//  var checkTotal = formObj.length;
//  var checkCount = 0;
//
//  if (maxC == 999) maxC = checkTotal;
//  for (var i=0; i<checkTotal; i++) {
//    if (formObj[i].checked) checkCount++;
//    }
//  if (checkCount < minC || checkCount > maxC) {
//    if (fv['groupError']) { addError(formObj); return true; }
//    alert('Please select between '+minC+' and '+maxC+' options for '+objName+'.\nYou currently have '+checkCount+' selected');
//    for (i=formObj.length-1; i>=0; i--)
//      errorProcess(formObj[i],0,1);
//    return false;
//    }
//  return true;
//  }
//
///***************************************************************************/
//function validateRadio(formObj) {
//  var objName = formatName(formObj);
//  var formObj = formObj.form.elements[formObj.name];
//  var selectTotal = 0;
//
//  for (i=0; i<formObj.length; i++)
//    if (formObj[i].checked)
//      selectTotal++;
//
//  if (selectTotal != 1) {
//    if (fv['groupError']) { addError(formObj); return true; }
//    alert((formObj[0].getAttribute(fv['emsg'])) ? formObj[0].getAttribute(fv['emsg']) : 'Please select an option for '+objName);
//    for (i=formObj.length-1; i>=0; i--)
//      errorProcess(formObj[i],0,1);
//    return false;
//    }
//  return true;
//  }
///***************************************************************************/
//function validateEitherOr(formObj, del, fields) {
//  var f = formObj.form;
//  var arrF = fields.split(del);
//  var nbCount = 0;
//  var list = "";
//  for (var i=0; i<arrF.length; i++) {
//    list += " -"+formatName(f.elements[arrF[i]])+"\n";
//    if (!checkBlank(f.elements[arrF[i]]))
//      nbCount++;
//    }
//  if (nbCount != 1) {
//    if (fv['groupError']) { addError(f.elements[arrF[0]]); return true; }
//    alert((formObj.getAttribute(fv['emsg'])) ? formObj.getAttribute(fv['emsg']) : "Only one of the following fields may be filled in:\n"+list);
//    for (var i=0; i<arrF.length; i++)
//      errorProcess(f.elements[arrF[i]],0,0);
//    return false;
//    }
//  return true;
//  }
///***************************************************************************/
//function validateAtLeast(formObj, qty, del, fields) {
//  var f = formObj.form;
//  var arrF = fields.split(del);
//  var nbCount = 0;
//  var list = "";
//  for (var i=0; i<arrF.length; i++) {
//    list += " -"+formatName(f.elements[arrF[i]])+"\n";
//    if (!checkBlank(f.elements[arrF[i]])) {
//      nbCount++;
//      }
//    }
//  if (nbCount < parseInt(qty)) {
//    if (fv['groupError']) { addError(f.elements[arrF[0]]); return true; }
//    alert((formObj.getAttribute(fv['emsg'])) ? formObj.getAttribute(fv['emsg']) : "At least "+qty+" of the following fields must be filled in:\n"+list);
//    for (var i=0; i<arrF.length; i++)
//      errorProcess(f.elements[arrF[i]],0,0);
//    return false;
//    }
//  return true;
//  }
///***************************************************************************/
//function validateCustom(formObj) {
//  var objName = formatName(formObj);
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//
//  var regex = new RegExp(formObj.getAttribute(fv['pattern']));
//  if (!regex.test(formObj.value)) {
//    return errorProcess2(formObj,1,1,"The "+objName+" is invalid.");
//    }
//  return true;
//  }
///****************************************************************************
//* Here are all the ancillary functions
//****************************************************************************/
//function addError(o) {
//  errorData[errorData.length] = o;
//  }
///***************************************************************************/
//function formatName(o) {
//  var wStr = (o.name) ? o.name : o.id;
//  wStr = wStr.replace(/_/g," ");
//  return wStr;
//  }
///***************************************************************************/
//function errorProcess(o, sel, foc) {
//  fv['revertClass'] = o.className;
//  o.className = fv['errorClass'];
//  if (sel) o.select();
//  if (foc) o.focus();
//  }
//
//function errorProcess2(o, sel, foc, error) {
//  var ret = false;
//  if (fv['groupError']) { addError(o); ret = true; }
//  else {
//    alert((o.getAttribute(fv['emsg'])) ? o.getAttribute(fv['emsg']) : error);
//    if (sel) o.select();
//    if (foc) o.focus();
//    }
//  fv['revertClass'] = o.className;
//  o.className = fv['errorClass'];
//  return ret;
//  }
///***************************************************************************/
//function clearStyle(o) {
//  if (o.className == fv['errorClass']) o.className = fv['revertClass'];
//  }
///***************************************************************************/
//function puncStr(str) {
//  str = str.replace("pipe", "|");
//  return str.replace(/([\\\|\(\)\[\{\^\$\*\+\?\.])/g,"\\$1");
////  return str.replace(/([\!\@\#\$\%\^\&\*\(\)\_\+\-\=\{\}\|\[\]\\\:\"\;\'\<\>\?\,\.\/])/g,"\\$1");
//  }
//
///*****************************************************************************************************
//* CREDIT CARD FUNCTIONS
//*
//*********** WARNING: DO NOT EDIT BELOW THIS LINE UNLESS YOU KNOW WHAT YOU ARE DOING! ****************/
//
//function cleanupCCNum(ccNum) {
//  return ccNum.replace(/\D/g,'');
//  }
///***************************************************************************/
//function validateCC(formObj) {
//  if (fv['bok'] && checkBlank(formObj))
//    { fv['bok']=false; return true; }
//  var objName = formatName(formObj);
//
//  switch (formObj.form.elements[fv['ccType']].value.toUpperCase()) {
//    case 'VISA'   : var ccReg = /^4\d{12}(\d{3})?$/; break;
//    case 'MC'   : var ccReg = /^5[1-5]\d{14}$/; break;
//    case 'DISC'   : var ccReg = /^6011\d{12}$/; break;
//    case 'AMEX'   : var ccReg = /^3[4|7]\d{13}$/; break;
//    case 'DINERS' : var ccReg = /^3[0|6|8]\d{12}$/; break;
//    case 'ENROUTE'  : var ccReg = /^2[014|149]\d{11}$/; break;
//    case 'JCB'    : var ccReg = /^3[088|096|112|158|337|528]\d{12}$/; break;
//    case 'SWITCH' : var ccReg = /^(49030[2-9]|49033[5-9]|49110[1-2]|4911(7[4-9]|8[1-2])|4936[0-9]{2}|564182|6333[0-4][0-9]|6759[0-9]{2})\d{10}(\d{2,3})?$/; break;
//    case 'DELTA'  : var ccReg = /^4(1373[3-7]|462[0-9]{2}|5397[8|9]|54313|5443[2-5]|54742|567(2[5-9]|3[0-9]|4[0-5])|658[3-7][0-9]|659(0[1-9]|[1-4][0-9]|50)|844[09|10]|909[6-7][0-9]|9218[1|2]|98824)\d{10}$/; break;
//    case 'SOLO'   : var ccReg = /^(6334[5-9][0-9]|6767[0-9]{2})\d{10}(\d{2,3})?$/; break;
//    // Add additonal card types here
//    default     : if (!fv['groupError']) alert('Error! Card Type not found!'); return false;
//    }
//  var formatOK = ccReg.test(formObj.value);
//  var luhnOK = validateLUHN(formObj.value);
//  if (!formatOK || !luhnOK) {
//    return errorProcess2(formObj,1,1,'The '+objName+' you entered is not valid. Please check again and re-enter');
//    }
//  return true;
//  }
///***************************************************************************/
//function validateLUHN(ccString) {
//  var odds = "";
//  var evens = "";
//  var i=1;
//
//  for (i=ccString.length-2; i>=0; i=i-2) {
//    var digit = parseInt(ccString.charAt(i)) * 2;
//    odds += digit+"";
//    }
//  for (i=ccString.length-1; i>=0; i=i-2)
//    evens += ccString.charAt(i);
//  var luhnStr = odds + evens;
//  var checkSum = 0;
//  for ( i = 0; ( c = luhnStr.charAt( i ) ); i++ )
//    checkSum += parseInt( c );
//  return (checkSum % 10 == 0);
//  }