function FormValidator() {

  this.errorMsg = '';
  this.goodEmailAddresses = '';

  this.validateForm = function (theForm) {
    // Customize these calls for your form

    var result = true;
    var isFocused = false;
    var elementToFocus = null;
    var elements = theForm.elements;

    if (elements != null) {

			if (this.areRequiredFields(elements)) {

				for (var i = 0; i < elements.length; i++) {
					var element = elements[i];
					var reqd = element.getAttribute('reqd');
					var name = element.name;
					var disabledFld = element.getAttribute('disabledFld');
					if( disabledFld ) {
						element.disabled = false;
					}

					// reqd value of '2' indicates an optional field (ie. valid if left blank, but needs
					// validation if the value is non-null)
					if ((reqd != null) && (reqd == '2') && (element.value) && (element.value.length > 0))
						reqd = '1';

					if (reqd != null && reqd == '1' && name != null) {
						var field = element.getAttribute('title');
						var fieldType = element.getAttribute('fieldType');
						
						if (field == null) field = 'Form element';

						switch (fieldType) {
							case 'string':
								if (!this.validRequired(element, field)) {
									result = false;
								}
								break;
							case 'securityAnswer':
								if (!this.validRequired(element, field, null, null, true)) {
									result = false;
								}
								break;
							case 'email':
								if (!this.validEmail(element, field)) {
									result = false;
								}								
								break;
							case 'emailMult':
								if(! this.validateEmailAddresses(element)) {
									result = false;
								}
								break;
							case 'numb':
								if(!this.validNum(element, field)) {
									result = false;
								}
								break;
							case 'dropDown':
								if(!this.validDropDown(element, field)) {
									result = false;
								}
								
								//if( disabledFld ) {alert("country"); element.disabled = "true"; }
								break;
							case 'phone':
								if (!this.validPhone(element, field)) {
									result = false;
								}
								break;
							case 'phoneExt':
								if (!this.validPhoneExtension(element, field)) {
									result = false;
								}
								break;
							case 'emailMsg':
								if (!this.validMsgLength(element, field)) {
									result = false;
								}
								break;
							case 'userId':
								if (!this.validUserId(element, field)) {
									result = false;
								}
								break;
							default:
								//alert('nothing');
								break;
						} //end switch
						
						if((result == false) && (isFocused == false)){
							isFocused = true;
							// this is put in here to focus on the first element with an error not the last.
							elementToFocus = element;
						}
						//if (result == false) break;

					}//end if reqd
					//alert(name);
					if( disabledFld ) {element.disabled = "true"; }
				} //end for
			} else
				result = true;
    }
	if(elementToFocus != null){
		elementToFocus.focus();	
	}
    return result;

  }

/**
 * name:  trim
 * args:  - str (String), the string to be trimmed
 * notes:	- equivalent to the 'trim' method in Java
 */
    this.trim = function (str) {
      if (str == null) return str;

      return str.replace(/^\s*/, '').replace(/\s*$/, '');
    }


/**
 * areRequiredFields()
 */
 	this.areRequiredFields = function (elements) {
		var areRequiredFields = false;
		if (elements != null) {

			for (var i = 0; i < elements.length; i++) {
				var element = elements[i];
				var reqd = element.getAttribute('reqd');
				if (reqd != null && reqd == '1') {
					areRequiredFields = true;
					break;
				}
			}

		}
		return areRequiredFields;
	}

/**
 * validUserId()
 */
  
  this.validUserId = function (formField, fieldLabel, outputErrorMsg) {
  		
    var result = true;

    if (!this.validRequired(formField, fieldLabel)) {	
      result = false;
	}

			
    if (result && ((formField.value == undefined) || (formField.value.length < 1) || (formField.value.length > 256) || !(this.isUserId(formField.value))) ) {
		

      // use provided error message if available, otherwise default error message
      this.errorMsg += (outputErrorMsg)
                    ? '\n' + outputErrorMsg
                    : '\n' + 'Please enter a valid user id: ' + formField.value + '\n' ;

      formField.focus();
      result = false;
    }
    return result;
  }

  
 /**
 * isUserId()
 * Note:  Keep this in sync with Validator.validateEmail method's pattern
 */
  this.isUserId = function (userId) {
  //alert(userId);
  //var userIdFilter = /^[a-zA-Z0-9_\-@.]{1,256}$/;
    var illegalChars = /[\>\<\=\*\+\,\;\\\s]/;
    return !(illegalChars.test(userId));
  }

/**
 * validRequired()
 */
  this.validRequired = function (formField, fieldLabel, outputErrorMsg, charset, requireNonWS) {
	//alert(fieldLabel);
	//alert(formField.value);
	
    var result = true;
    var defaultErrorMsg = '';

    // non-whitespace char is required, but not present
    if ((requireNonWS) && (formField.value.search(/\S/) == -1))
    {
      formField.value = '';
      result = false;
    }
    if (this.trim(formField.value) ==  '' || formField.value == undefined) {
      defaultErrorMsg = 'Please enter a value for this field:' + ' ' + this.trim(fieldLabel) + '\n';
      result = false;
    }
	
	//Commented by SK
    //else if (this.hasBadChar(this.trim(formField.value), charset)) {
    // defaultErrorMsg = 'This field does not accept the values that you entered' + '\n\"' + this.trim(formField.value) + '\"\n' + 'because those values are part of a character set that is not allowed for this field. Please re-enter the values in supported character set.';
    // result = false;
    // }

    if (!result) {
      // use provided error message if available, otherwise default error message
      this.errorMsg += (outputErrorMsg) ? outputErrorMsg : defaultErrorMsg;

      formField.focus();
    }

    return result;
  }


/**
 * validRequiredEmail()
 */
  this.validRequiredEmail = function (formField, fieldLabel, outputErrorMsg, charset, requireNonWS) {
	//alert(fieldLabel);
	//alert(formField.value);
	
    var result = true;
    var defaultErrorMsg = '';

    // non-whitespace char is required, but not present
    if ((requireNonWS) && (formField.value.search(/\S/) == -1))
    {
      formField.value = '';
      result = false;
    }
    if (this.trim(formField.value) ==  '' || formField.value == undefined) {
      defaultErrorMsg = 'Please enter a value for this field:' + ' ' + this.trim(fieldLabel) + '\n';
      result = false;
    }
    else if (this.hasBadChar(this.trim(formField.value), charset)) {
      defaultErrorMsg = 'This field does not accept the values that you entered' + '\n\"' + this.trim(formField.value) + '\"\n' + 'because those values are part of a character set that is not allowed for this field. Please re-enter the values in supported character set.';
      result = false;
    }

    if (!result) {
      // use provided error message if available, otherwise default error message
      this.errorMsg += (outputErrorMsg) ? outputErrorMsg : defaultErrorMsg;

      formField.focus();
    }

    return result;
  }

/**
 * allDigits()
 */
  this.allDigits = function (str) {
    return this.inValidCharSet(str,'0123456789');
  }


/**
 * inValidCharSet()
 */
  this.inValidCharSet = function (str, charset) {
    var result = true;

    // Note: doesn't use regular expressions to avoid early Mac browser bugs
    for (var i=0;i<str.length;i++)
      if (charset.indexOf(str.substr(i,1))<0) {
        result = false;
        break;
      }

    return result;
  }



/**
 * validEmail()
 */
  this.validEmail = function (formField, fieldLabel, outputErrorMsg) {
    var result = true;

    if (!this.validRequiredEmail(formField, fieldLabel))
      result = false;


    if (result && ((formField.value == undefined) || (formField.value.length < 3) ||(formField.value.length > 125)|| !this.isEmailAddr(formField.value)) ) {

      // use provided error message if available, otherwise default error message
      this.errorMsg += (outputErrorMsg)
                    ? '\n' + outputErrorMsg
                    : '\n' + 'The following email address contains errors:' + '\n\n' + formField.value + '\n' ;

      formField.focus();
      result = false;
    }

    return result;

  }


/**
 * isEmailAddr()
 * Note:  Keep this in sync with Validator.validateEmail method's pattern
 */
  this.isEmailAddr = function (email) {
    var emailFilter = /^[^@]+@[^@]+\.[^@]{2,4}$/;
    var illegalChars = /[\s\(\)\<\>\,\;\:\\\/\"\[\]]/;
    return (emailFilter.test(email) && !(illegalChars.test(email)));
  }


/**
 * validateEmailAddresses()
 */
  this.validateEmailAddresses = function (formField, outputErrorMsg) {

    var result = false;

    if (formField != null) {

      var fieldLabel = formField.getAttribute("TITLE");
      if (fieldLabel == null) fieldLabel = '';

      if (this.validRequiredEmail(formField, fieldLabel, 'You must provide at least one e-mail address in order to invite new users.', null, true)) {

        var addresses = null;
        var addressArray = new Array();
        var badEmailAddresses = '';

        addresses = formField.value;
        addressArray = addresses.split(/[,;\s]/);

        for (var i = 0; i < addressArray.length; i++) {
          var item = this.trim(addressArray[i]);
          if ( item && (item.length > 0) ) {
            var isEmailGood = this.isEmailAddr(item);

            if (!isEmailGood)
              if (badEmailAddresses.length == 0)
                badEmailAddresses += item;
              else
                badEmailAddresses += '\n' + item;
            else
              if (this.goodEmailAddresses.length == 0)
                this.goodEmailAddresses += item;
              else
                this.goodEmailAddresses += '|' + item;
          }
        }

        if (badEmailAddresses.length > 0) {

          // use provided error message if available, otherwise default error message
          this.errorMsg += (outputErrorMsg)
                        ? '\n' + outputErrorMsg
                        : '\n' + 'Invitations Cannot Be Sent\n\nThere is a formatting error in the following e-mail addresses. Please click \'OK\', correct the formatting, and send again.' + '\n\n' + badEmailAddresses + '\n' ;

          formField.focus();
        } else
          result = true;

      }
    }

    return result;
  }

/**
 * validMsgLength()
 */
  this.validMsgLength = function (formField, fieldLabel, outputErrorMsg) {
    var result = true;

	var length = formField.getAttribute('maxMsgLength');
	if (length == null)	// didn't specify a maxMsgLength attribute
		return true;	// just let it pass

	var theMsg = formField.value;
	if (theMsg.length == 0)	// it's ok if it has nothing in it, but not ok to exceed the max length
		return true;

	if (!this.isOkLength(theMsg, 0, length)){
        // use provided error message if available, otherwise default error message
        this.errorMsg += (outputErrorMsg)
                      ? '\n' + outputErrorMsg
                      : '\n' + 'Please shorten your message. The character limit is {0} characters. \nThank you. ' + '\n' ;
		this.errorMsg = this.errorMsg.replace(/\{0}/, length);
        formField.focus();
        
        result = false;
	}

    return result;
  }


/**
 * validNum()
 */
  this.validNum = function (formField, fieldLabel, outputErrorMsg) {
    var result = true;

    if (!this.validRequired(formField,fieldLabel))
      result = false;

    if (result) {
      if (!this.allDigits(formField.value)) {

        // use provided error message if available, otherwise default error message
        this.errorMsg += (outputErrorMsg)
                      ? '\n' + outputErrorMsg
                      : '\n' + 'Please enter a valid number for this field:' + ' ' + fieldLabel + '\n' ;

        formField.focus();
        result = false;
      }
    }

    return result;
  }

/**
 * validInt()
 */
  this.validInt = function (formField, fieldLabel, outputErrorMsg) {
    var result = true;

    if (!this.validRequired(formField,fieldLabel))
      result = false;

    if (result) {
      var num = parseInt(formField.value,10);
      if (isNaN(num))
      {
        // use provided error message if available, otherwise default error message
        this.errorMsg += (outputErrorMsg)
                      ? '\n' + outputErrorMsg
                      : '\n' + 'Please enter a valid number for this field:' + ' ' + fieldLabel +  '\n' ;

        formField.focus();
        result = false;
      }
    }

    return result;
  }

/**
 * validDate()
 */
  this.validDate = function (formField, fieldLabel, outputErrorMsg) {
    var result = true;

    if (!this.validRequired(formField,fieldLabel))
      result = false;

    if (result) {
      var elems = formField.value.split('/');

      result = (elems.length == 3); // should be three components

      if (result) {
        var month = parseInt(elems[0],10);
          var day = parseInt(elems[1],10);
        var year = parseInt(elems[2],10);
        result = this.allDigits(elems[0]) && (month > 0) && (month < 13) &&
             this.allDigits(elems[1]) && (day > 0) && (day < 32) &&
             this.allDigits(elems[2]) && ((elems[2].length == 2) || (elems[2].length == 4));
      }

        if (!result) {

        // use provided error message if available, otherwise default error message
        this.errorMsg += (outputErrorMsg)
                      ? '\n' + outputErrorMsg
                      : '\n' + 'Please enter a date in the format MM/DD/YYYY for this field:' + ' ' + fieldLabel + '\n' ;

        formField.focus();
      }
    }

    return result;
  }



/**
 * hasBadChar()
 */
  this.hasBadChar = function (fieldValue, charset) {

    var basic = '\\u0000-\\u00FF\\u3040-\\u30FF\\u4E00-\\u9FAF\\uAC00-\\uD7AF\\u3200-\\u32FF';
    var ext1 = '\\u3000-\\u303F';
    var charstr = basic;

    // find the final charset
    if(charset == 1) {
	charstr = charstr+ext1;
    }
    var hasBadChar = false;
    //re1 = new RegExp('^[\u0000-\u00FF\u3040-\u30FF\u4E00-\u9FAF\uAC00-\uD7AF\u3200-\u32FF]', 'gim');
    re1 = new RegExp('^['+charstr+']', 'gim');

    for (charIndex=0; charIndex < fieldValue.length; charIndex++) {
      if (fieldValue.charAt(charIndex).search(re1) == -1) {

        hasBadChar = true;
        break;
      }
    }
    return hasBadChar;
  }

 /**
  * isOkLength()
  * Helper method, called by 'isOkPassword' method
  * - checks that a strings length is acceptable for submission
  */
  this.isOkLength = function (testString, min, max) {
//alert("length");
    if (testString)
      return ((testString.length >= min) && (testString.length <= max));
    else
      return false;
  }

/**
 * isOkPassword()
 * Helper method, called by 'validateSinglePassword' method
 * - does the real checking logic for a given password value
 */
  this.isOkPassword = function (pwd) {

	if(pwd == '#THIS&IS%FAKE!!*')
		return true;

    // needs to be between 6-20 chars and no leading and trailing spaces
    if (this.isOkLength(pwd, 6, 35) && this.trim(pwd).length==pwd.length) {
    // must contain a letter
    regex = /[a-zA-Z]+/;
	result = regex.test(pwd);
	
	 if( result ) {
      // must contain at least 1 digit
      regex = /\d+/;
	   result = regex.test(pwd);
      //return regex.test(pwd)
      
      //the password must contain atleast 3 unique characters
	  if(result) {     
		      var pswdArr = pwd.split(''); 
		      var resultArr = new Array();
		      outer: for(var i=0,j=-1;i<pswdArr.length;i++) {
		      	inner: for(;;) {
		        	if(pswdArr[i]== resultArr[j]) { 
		     	 		break; 
		    		} else {
		      			if(resultArr.length >= 3) {
		      				break outer;
		      			}
		      			resultArr[++j] = pswdArr[i];
		     		}
		  		}
			 }
			 if(resultArr.length < 3) {
				result = false;
		 	 } else {
				result = true;
			 }
		 }
	}
    
    return result;      
    }
    else
      return false;
  }


/**
 * validateSinglePassword()
 * This is not automatically called in the loop, user must make specific call when necessary
 * - leaves checking logic up to 'isOkPassword' method, only handles setting the error message
 * - this is also a helper method, called by 'validateBothPasswords'
 */
  this.validateSinglePassword = function (pwd, outputErrorMsg){

		if (!this.isOkPassword(pwd)) {
      		// use provided error message if available, otherwise default error message
      		this.errorMsg += (outputErrorMsg)
                    ? '\n' + outputErrorMsg
                    : '\n' + 'Password must contain:\n- Between 6 and 35 characters\n- At least three unique characters\n- At least one alphabetic character\n- At least one number'+ '\n' ;

      		return false;
		} else {
		    return true;
		}
	}

/**
 * validateBothPasswords()
 * This is not automatically called in the loop, user must make specific call when necessary
 */
 	this.validateBothPasswords = function (pwd1, pwd2, outputErrorMsg){

		if ( !this.validateSinglePassword(pwd1, outputErrorMsg)
			|| !this.validateSinglePassword(pwd2, outputErrorMsg))
			return false;

		if (pwd1 != pwd2){	// both fields should be the same

      // use provided error message if available, otherwise default error message
      this.errorMsg += (outputErrorMsg)
                    ? '\n' + outputErrorMsg
                    : '\n' + 'The "Verify Password" field is empty or does not match the "Password" field.' + '\n';

			return false;
		}

		return true;
	}

/**
 * validateEmailsMatch()
 * For validating that the 2 fields are the same, by the time this is called
 * there should have been a check that the email field value is valid and correct
 * This is not automatically called in the loop, user must make specific call when necessary
 */
 	this.validateEmailsMatch = function (email1, email2, outputErrorMsg){
		if (email1 != email2){	// both fields should be the same

      // use provided error message if available, otherwise default error message
      this.errorMsg += (outputErrorMsg)
                    ? '\n' + outputErrorMsg
                    : '\n' + 'The "Verify Email Address" field is empty or does not match the "Email Address" field.' + '\n' ;

			return false;
		}
	}

/**
 * validDropDown()
 */
 	this.validDropDown = function (formField, fieldLabel, outputErrorMsg) {
		 
        var result = true;
		if ((formField.type	== 'select-one') &&	(formField.selectedIndex ==	0)) {
			//if (this.errorMsg.length>0) {
				//this.errorMsg += '\n';
			//}
        	// use provided error message if available, otherwise default error message
      		this.errorMsg += (outputErrorMsg)
                    ? outputErrorMsg + '\n'
                    : 'Please select an item for this field:' + ' ' + this.trim(fieldLabel) + '\n' ;
			formField.focus();
			result = false;
		}

        return result;
        
 	}

/**
 * validPhone()
 */
 	this.validPhone = function (formField, fieldLabel, outputErrorMsg) {
    var phoneParam = formField.value;

    if (this.validRequired(formField, fieldLabel))
    {
      var minChars = 10;
      var maxChars = 40;

      // international numbers allow up to 40 digits, domestic 10
      var minDigits = 10;
      var maxDigits = (phoneParam.indexOf('+') == 0) ? 40 : 10;

      var regex = /\D+/g;
      var phoneParamDigitsOnly = phoneParam.replace(regex, '');

      // test that enough digits are present, and that the length of the string is correct
      if ( this.isOkLength(phoneParam, minChars, maxChars)
        && this.isOkLength(phoneParamDigitsOnly, minChars, maxChars) )
        return true;
      else
      {
        // use provided error message if available, otherwise default error message
        this.errorMsg += (outputErrorMsg)
                      ? '\n' + outputErrorMsg
                      : '\n' + 'Please enter a valid phone number for this field:' + ' ' + this.trim(fieldLabel)+ '\n' ;
  			formField.focus();
  			return false;
      }
    }
    else
      return false;
 	}

/**
 * validPhoneExtension()
 */
  this.validPhoneExtension = function (formField, fieldLabel, outputErrorMsg) {
    var phoneParam = formField.value;

    var minChars = 1
    var maxChars = 10;
    var regex = /\D+/g;
    var phoneParamDigitsOnly = phoneParam.replace(regex, '');

    // test that enough digits are present, and that the length of the string is correct
    if ( this.isOkLength(phoneParam, minChars, maxChars)
      && this.isOkLength(phoneParamDigitsOnly, minChars, maxChars) )
      return true;
    else
    {
      // use provided error message if available, otherwise default error message
      this.errorMsg += (outputErrorMsg)
                    ? '\n' + outputErrorMsg
                    : '\n' + 'Please enter a valid phone number for this field:' + ' ' + this.trim(fieldLabel)+ '\n' ;
      formField.focus();
      return false;
    }
  }
}