function validateABI ()
{
   var filter  = /^([0-9])+$/;

//alert(document.forms[0]);
//   var formForValidation = document.forms[0];
//   for(var i=0; i < formForValidation.length; i++) 
//   {
//        var elementID = formForValidation.elements[i].id;
//        var elementVALUE = formForValidation.elements[i].value;
//        var suffix = elementID.substr(elementID.lastIndexOf("_"));
//        var result = ABI(suffix, elementVALUE);
//        if (result == false)
//            return false;                                                      
//   }


   rtArm = document.forms[0].ctl00_ContentPlaceHolderMaster_rtarm.value;
   ltArm = document.forms[0].ctl00_ContentPlaceHolderMaster_ltarm.value;
   rtpt = document.forms[0].ctl00_ContentPlaceHolderMaster_rtpt.value;
   ltpt = document.forms[0].ctl00_ContentPlaceHolderMaster_ltpt.value;
   rtdp = document.forms[0].ctl00_ContentPlaceHolderMaster_rtdp.value;
   ltdp = document.forms[0].ctl00_ContentPlaceHolderMaster_ltdp.value;

   if (!filter.test(rtArm))
   {
//   alert(rtArm);
       alert('Please enter digits for Right Arm');
       //document.CalculatorForm.rt_arm.focus();
       return false;
   }

   if (!filter.test(ltArm))
   {
       alert('Please enter digits for Left Arm');
       //document.CalculatorForm.lt_arm.focus();
       return false;
   }
       if (!filter.test(rtpt))
   {
       alert('Please enter digits for Right PT');
       //document.CalculatorForm.rt_pt.focus();
       return false;
   }
       if (!filter.test(ltpt))
   {
       alert('Please enter digits for Left PT');
       //document.CalculatorForm.lt_pt.focus();
       return false;
   }
      if (!filter.test(rtdp))
   {
       alert('Please enter digits for Right DP');
       //document.CalculatorForm.rt_dp.focus();
       return false;
   }
       if (!filter.test(ltdp))
   {
       alert('Please enter digits for Left DP');
       //document.CalculatorForm.lt_dp.focus();
       return false;
   }
} 


function FormValidation2()
{
    this.getFormElements = getFormElements;
    function getFormElements() 
    {
        var formForValidation = document.forms[0];
        var retVal = true;
        var FunctArray = new Array;
        var int = 0;
        var idx = 0;    
        
        for (var member in myValidator) 
           {
                  
               FunctArray[int] = member;
               int++; 
                
           }    
        
        for(var i=0; i < formForValidation.length; i++) 
        {
            var elementID = formForValidation.elements[i].id;
//            if(elementID == "ctl00_ContentPlaceHolderMaster_yourName_Name")
//            {            
//                elementID = "yourName_Name";
//                alert("element id changed = " + elementID);
//            }
//            if(elementID == "ctl00_ContentPlaceHolderMaster_yourEmail_EmailAddress")
//            {        
//                elementID = "yourEmail_EmailAddress";
//                alert("element id changed = " + elementID);
//            }

            var suffix = elementID.substr(elementID.lastIndexOf("_"));
            
//            alert("elementID = " + elementID);
//            alert("suffix = " + suffix);
            
            if(suffix.indexOf("_") != -1)
            {                                   
//               alert("if loop 3");
                idx = FunctArray.indexOfString("validate" + suffix.substr(suffix.indexOf("_") + 1));    
                    
                if(idx > -1)
                  {
                        if (typeof formForValidation.elements[i] != "undefined")
                        {
                            if(!(eval("myValidator." + FunctArray[idx] + "(formForValidation.elements[i])")))
                            {
                                myErrorObject.CreateErrorContainer(formForValidation.elements[i], myErrorObject.GetErrorMessage());
                                if(retVal) {retVal=false;}
                            }
                        }
                   }     
            }
        }
        return retVal;
    }
    /***** End getFormElements *****/
}


function FormValidation()
{
    this.getFormElements = getFormElements;
    function getFormElements() 
    {
        var formForValidation = document.forms[0];
        var retVal = true;
        var FunctArray = new Array;
        var int = 0;
        var idx = 0;    
        
        for (var member in myValidator) 
           {
                  
               FunctArray[int] = member;
               int++; 
                
           }    
        
        for(var i=0; i < formForValidation.length; i++) 
        {
            var elementID = formForValidation.elements[i].id;
//            if(elementID == "ctl00_ContentPlaceHolderMaster_yourName_Name")
//            {            
//                elementID = "yourName_Name";
//                alert("element id changed = " + elementID);
//            }
//            if(elementID == "ctl00_ContentPlaceHolderMaster_yourEmail_EmailAddress")
//            {        
//                elementID = "yourEmail_EmailAddress";
//                alert("element id changed = " + elementID);
//            }

            var suffix = elementID.substr(elementID.lastIndexOf("_"));
            
//            alert("elementID = " + elementID);
//            alert("suffix = " + suffix);
            
            if(suffix.indexOf("_") != -1)
            {                                   
//               alert("if loop 3");
                idx = FunctArray.indexOfString("validate" + suffix.substr(suffix.indexOf("_") + 1));    
                    
                if(idx > -1)
                  {
                        if (typeof formForValidation.elements[i] != "undefined")
                        {
                            if(!(eval("myValidator." + FunctArray[idx] + "(formForValidation.elements[i])")))
                            {
                                myErrorObject.CreateErrorContainer(formForValidation.elements[i], myErrorObject.GetErrorMessage());
                                if(retVal) {retVal=false;}
                            }
                        }
                   }     
            }
        }
        return retVal;
    }
    /***** End getFormElements *****/
}


/***** Begin Error Object Class *****/

var myErrorObject = new ValidationErrorObject();

function ValidationErrorObject()
{
    /***** CONSTRUCTORS *****/
    this.CreateErrorContainer = CreateErrorContainer;
    this.RemoveErrorContainer = RemoveErrorContainer;
    /***** END CONSTRUCTORS *****/
       
    /***** PUBLIC PROPERTIES *****/   
    this.GetErrorMessage = GetErrorMessage;
    function GetErrorMessage()
    {
        return _errorMessage;
    }
    this.SetErrorMessage = SetErrorMessage;
    function SetErrorMessage(value)
    {
        _errorMessage = value;
    }
    this.GetFieldErrorMessage = GetFieldErrorMessage;
    function GetFieldErrorMessage(code)
    {
        switch(code)
        {
            case "ADDRESSMAXLENGTH":
                return ADDRESSMAXLENGTH;
                break;
            case "HASCRLF":
                return HASCRLF;
                break;
            case "HASDIGITS":
                return HASDIGITS;
                break;
            case "HASSPACES":
                return HASSPACES;
                break;
            case "HASFICOCHARACTERS":
                return HASFICOCHARACTERS;
                break;
            case "HASFICODELIMETER":
                return HASFICODELIMETER;
                break;
            case "INVALIDDATE":
                return INVALIDDATE;
                break;
            case "INVALIDEMAIL":
                return INVALIDEMAIL;
                break;
            case "INVALIDPHONENUMBER":
                return INVALIDPHONENUMBER;
                break;
            case "INVALIDSSN":
                return INVALIDSSN;
                break;
            case "INVALIDSTATE":
                return INVALIDSTATE;
                break;
            case "INVALIDZIPCODE":
                return INVALIDZIPCODE;
                break;
            case "ISATITLE":
                return ISATITLE;
                break;
            case "ISREQUIRED":
                return ISREQUIRED;
                break;
            case "ISREQUIREDLIST":
                return ISREQUIREDLIST;
                break;
            case "MAXLENGTH1":
                return MAXLENGTH1;
                break;
            case "MAXLENGTH2":
                return MAXLENGTH2;
                break;
            case "MAXLENGTH4":
                return MAXLENGTH4;
                break;
            case "MAXLENGTH15":
                return MAXLENGTH15;
                break;
            case "MAXLENGTH20":
                return MAXLENGTH20;
                break;
            case "MINLENGTH1":
                return MINLENGTH1;
                break;
            case "MINLENGTH2":
                return MINLENGTH2;
                break;
            case "NOTALPHA":
                return NOTALPHA;
                break;
            case "TRIPLEREPEAT":
                return TRIPLEREPEAT;
                break;
            case "ZIPCODEMAXLENGTH":
                return ZIPCODEMAXLENGTH;
                break;
            case "ZIPCODEMINLENGTH":
                return ZIPCODEMINLENGTH;
                break;
            case "HASTESTCHARACTERS":
                return HASTESTCHARACTERS;
                break;                
            default:
                return "Unknown error.";
                break;
        }
    }
    /***** END PUBLIC PROPERTIES *****/
    
    /***** PRIVATE VARIABLES *****/
    var _errorMessage = null;
    /***** END PRIVATE VARIABLES *****/
    
    /***** ERROR MESSAGE CONSTANTS *****/
    var HASTESTCHARACTERS = "cannot contain the words TEST, TESTING, FIRST.";
    var ADDRESSMAXLENGTH = "cannot exceed 50 characters.";
    var HASCRLF = "cannot contain carriage returns.";
    var HASDIGITS = "cannot contain digits.";
    var HASSPACES = "cannot contain spaces.";
    //HASFICOCHARACTERS = "cannot contain the characters: '@', '#', '$', '%', '*', '^', '!', '{', '}', '[', ']', '?', '+', '-', '=', '\', '/', ',', '.', '\"'";
    var HASFICOCHARACTERS = "* Value cannot contain invalid characters.";
    var HASFICODELIMETER = "cannot contain the character { .";
    var INVALIDDATE = "* Value for date is invalid.";
    var INVALIDEMAIL = "* Value for email is invalid.";
    var INVALIDPHONENUMBER = "* Value for phone number is invalid.";
    var INVALIDSSN = "* Value for social security number is invalid.";
    var INVALIDSTATE = "* Value for state abbrevation is invalid.";
    var INVALIDZIPCODE = "* Value for zip code is invalid.";
    var ISATITLE = "* Value for first name cannot be a title.";
    var ISREQUIRED = "is required.";
    var ISREQUIREDLIST = "* Please select an option";
    var MAXLENGTH1 = "cannot exceed one (1) characters in length.";
    var MAXLENGTH2 = "cannot exceed two (2) characters in length.";
    var MAXLENGTH4 = "cannot exceed four (4) characters in length.";
    var MAXLENGTH15 = "cannot exceed 15 characters in length.";
    var MAXLENGTH20 = "cannot exceed 20 characters in length.";
    var MINLENGTH1 = "must be at least one (1) character in length.";
    var MINLENGTH2  = "must be at least two (2) characters in length.";
    var NOTALPHA = "cannot contain non-alpha characters.";
    var TRIPLEREPEAT = "cannot triple repeat characters.";
    var ZIPCODEMAXLENGTH = "* Value for zip code cannot exceed ten (10) digits.";
    var ZIPCODEMINLENGTH = "* Value for zip code must be at least five (5) digits.";
    /***** END ERROR MESSAGE CONSTANTS *****/
        
    function CreateErrorContainer(myField, errMsg)
    {
        var errorContainer = null ;
        
        this.RemoveErrorContainer(myField);
        
	    if ((errMsg) && (errMsg.length > 0))
	    {
            errorContainer = document.createElement("div");
            errorContainer.setAttribute("id","error_" + myField.name);
	        errorContainer.className = "errorContainer";
            errorContainer.appendChild(document.createTextNode(errMsg));
            myField.parentNode.insertBefore(errorContainer,myField.nextSibling);
        }
        
        this.SetErrorMessage(null);
    }
    
    function RemoveErrorContainer(myField)
    {
        if (document.getElementById("error_" + myField.name))
	    {
            var rmElem = document.getElementById("error_" + myField.name);
	        rmElem.parentNode.removeChild(rmElem);
	    }
    }
}
/***** End Error Object Class *****/

// ========================================
//        STRING FUNCTION EXTENTIONS
// ========================================
// ========================================
//            TRIM FUNCTIONS
// ========================================
String.prototype.trim = function() {
	return this.replace(/^\s+|\s+$/g,"");
}
String.prototype.ltrim = function() {
	return this.replace(/^\s+/,"");
}
String.prototype.rtrim = function() {
	return this.replace(/\s+$/,"");
}



// ========================================
//        ARRAY FUNCTION EXTENTIONS
// ========================================
// ========================================
//          INDEXOF FUNCTIONS
// ========================================
// ===========================================================================
// Function indexOfString - Find the position of the given string in an array. 
// Parameters: inval - String to loacte in the array.    
//             begin - Begin position in the array zero based.
// ===========================================================================
Array.prototype.indexOfString = function( inval, begin ) 
{
 for( var i = + begin || 0, l = this.length; i < l; i++ ) 
   {
      if(this[i].toLowerCase() == inval.toLowerCase())
        {
            return i; 
        }
      
   }
 return -1;
};


var myValidator = new Validator(); //TODO: To be removed.


// ========================================
//         VALIDATOR CONSTRUCTOR
// ========================================
function Validator()
{
	this.validateRegistration = validateRegistration ;
	this.validatePrefix = validatePrefix ;
	this.validateName = validateName ;
	this.validateFirstName = validateFirstName ;
	this.validateMiddleInitial = validateMiddleInitial ;
	this.validateLastName = validateLastName ;
	this.validateSuffix = validateSuffix ;
	this.validateAddress1 = validateAddress1 ;
	this.validateAddress2 = validateAddress2 ;
	this.validateCity = validateCity ;
	this.validateState = validateState ;
	this.validateZipCode = validateZipCode ;
	this.validateEmailAddress = validateEmailAddress ;
	this.validateRequiredList = validateRequiredList;
	this.doNothing = doNothing;



// ========================================
//        FIELD VALIDATION FUNCTIONS
// ========================================

    function validateRegistration()
    {
        myValidator.validatePrefix(document.forms[0].prefix);
        myValidator.validateName(document.forms[0].name);
        myValidator.validateFirstName(document.forms[0].firstname);
        myValidator.validateMiddleInitial(document.forms[0].middleinitial);
        myValidator.validateLastName(document.forms[0].lastname);
        myValidator.validateSuffix(document.forms[0].suffix);
        myValidator.validateAddress1(document.forms[0].address1);
        myValidator.validateAddress2(document.forms[0].address2);
        myValidator.validateCity(document.forms[0].city);
        myValidator.validateState(document.forms[0].state);
        myValidator.validateZipCode(document.forms[0].zipcode);
        myValidator.validateEmailAddress(document.forms[0].emailaddress);
    }
    
    function doNothing()
	{
	    return true;
	}
    
	function validatePrefix(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);

		if (!(hasNoDigits(myValue)))
		{
			myErrorObject.SetErrorMessage("* Value for prefix " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if (!(hasNoSpaces(myValue)))
		{
			myErrorObject.SetErrorMessage("* Value for prefix " + myErrorObject.GetFieldErrorMessage("HASSPACES"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if (!(hasNoFicoDelimeter(myValue)))
		{
			myErrorObject.SetErrorMessage("* Value for prefix " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if (!(hasNoCrLf(myValue)))
		{
			myErrorObject.SetErrorMessage("* Value for prefix " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if (!(maxLength(myValue,4)))
		{
			myErrorObject.SetErrorMessage("* Value for prefix " + myErrorObject.GetFieldErrorMessage("MAXLENGTH4"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }

		return retVal
	}
    
    
    function validateName(myField)
	{
	    var retVal = true;	    
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for name " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoDigits(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for name " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for name " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoChars(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for name " + myErrorObject.GetFieldErrorMessage("HASFICOCHARACTERS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for name " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(notATitle(myValue)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("ISATITLE"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(notTripleRepeat(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for name " + myErrorObject.GetFieldErrorMessage("TRIPLEREPEAT"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(minLength(myValue, 2)))
		{
		    myErrorObject.SetErrorMessage("* Value for name " + myErrorObject.GetFieldErrorMessage("MINLENGTH2"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 15)))
		{
		    myErrorObject.SetErrorMessage("* Value for name " + myErrorObject.GetFieldErrorMessage("MAXLENGTH15"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}
    
	function validateFirstName(myField)
	{
	    var retVal = true;	    
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoDigits(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoChars(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("HASFICOCHARACTERS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(notATestWord(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("HASTESTCHARACTERS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }		
		if(!(notATitle(myValue)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("ISATITLE"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(notTripleRepeat(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("TRIPLEREPEAT"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(minLength(myValue, 2)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("MINLENGTH2"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 15)))
		{
		    myErrorObject.SetErrorMessage("* Value for first name " + myErrorObject.GetFieldErrorMessage("MAXLENGTH15"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateMiddleInitial(myField)
	{
	    var retVal = true;
	    var myValue = getValue(myField);
	    
	    if(!(hasNoDigits(myValue)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    if(!(isAlpha(myValue)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("NOTALPHA"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    if(!(hasNoSpaces(myValue)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("HASSPACES"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    if(!(hasNoFicoDelimeter(myValue)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    if(!(hasNoCrLf(myValue)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    if(!(maxLength(myValue, 1)))
	    {
	        myErrorObject.SetErrorMessage("* Value for middle initial " + myErrorObject.GetFieldErrorMessage("MAXLENGTH1"));
		    retVal = false;
		    return;
	    }
	    else { myErrorObject.RemoveErrorContainer(myField); }		
		
		return retVal;
	}

	function validateLastName(myField)
	{
		var retVal = true;
		var myValue = getValue(myField);
				
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoDigits(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoChars(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("HASFICOCHARACTERS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(notTripleRepeat(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("TRIPLEREPEAT"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 20)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("MAXLENGTH20"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(minLength(myValue, 2)))
		{
		    myErrorObject.SetErrorMessage("* Value for last name " + myErrorObject.GetFieldErrorMessage("MINLENGTH2"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateSuffix(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);
		
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for suffix " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for suffix " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 4)))
		{
		    myErrorObject.SetErrorMessage("* Value for suffix " + myErrorObject.GetFieldErrorMessage("MAXLENGTH4"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateAddress1(myField)
	{
		var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 50)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("ADDRESSMAXLENGTH"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateAddress2(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);
		
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 50)))
		{
		    myErrorObject.SetErrorMessage("* Value for address " + myErrorObject.GetFieldErrorMessage("ADDRESSMAXLENGTH"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}
	
	function validateCity(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoDigits(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(minLength(myValue, 1)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("MINLENGTH1"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 20)))
		{
		    myErrorObject.SetErrorMessage("* Value for city " + myErrorObject.GetFieldErrorMessage("MAXLENGTH20"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateState(myField)
	{
		var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
//		if(!(hasNoCrLf(myValue)))
//		{
//		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
//		    retVal = false;
//		    return;
//		}
//		else { myErrorObject.RemoveErrorContainer(myField); }
//		if(!(hasNoDigits(myValue)))
//		{
//		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("HASDIGITS"));
//		    retVal = false;
//		    return;
//		}
//		else { myErrorObject.RemoveErrorContainer(myField); }
//		if(!(hasNoFicoDelimeter(myValue)))
//		{
//		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
//		    retVal = false;
//		    return;
//		}
//		else { myErrorObject.RemoveErrorContainer(myField); }
//		if(!(isValidState(myValue)))
//		{
//		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("INVALIDSTATE"));
//		    retVal = false;
//		    return;
//		}
//		else { myErrorObject.RemoveErrorContainer(myField); }
//		if(!(minLength(myValue, 2)))
//		{
//		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("MINLENGTH2"));
//		    retVal = false;
//		    return;
//		}
//		else { myErrorObject.RemoveErrorContainer(myField); }
//		if(!(maxLength(myValue, 2)))
//		{
//		    myErrorObject.SetErrorMessage("* Value for state " + myErrorObject.GetFieldErrorMessage("MAXLENGTH2"));
//		    retVal = false;
//		    return;
//		}
//		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}
	
	function validateZipCode(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for zip code " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoSpaces(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for zip code " + myErrorObject.GetFieldErrorMessage("HASSPACES"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for zip code " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoFicoDelimeter(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for zip code " + myErrorObject.GetFieldErrorMessage("HASFICODELIMETER"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(minLength(myValue, 5)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("ZIPCODEMINLENGTH"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(maxLength(myValue, 10)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("ZIPCODEMAXLENGTH"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(isValidZipCode(myValue)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("INVALIDZIPCODE"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}

	function validateEmailAddress(myField)
	{
	    var retVal = true;
		var myValue = getValue(myField);
		
		if(!(isNotNull(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for email " + myErrorObject.GetFieldErrorMessage("ISREQUIRED"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(isValidEmailAddress(myValue)))
		{
		    myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("INVALIDEMAIL"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoSpaces(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for email " + myErrorObject.GetFieldErrorMessage("HASSPACES"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		if(!(hasNoCrLf(myValue)))
		{
		    myErrorObject.SetErrorMessage("* Value for email " + myErrorObject.GetFieldErrorMessage("HASCRLF"));
		    retVal = false;
		    return;
		}
		else { myErrorObject.RemoveErrorContainer(myField); }
		
		return retVal;
	}
	
	function validateRequiredList(myField)
	{
	    var retVal = true;    	    
	    var selectCount = 0;
	    var fieldName = myField.name;
	    
	    for(var i=0; i<eval("document.forms[0]." + fieldName + ".length"); i++)
	    {
	        if(eval("document.forms[0]." + fieldName + "[i].checked"))
	        {
	            selectCount++;
	        }
	        
	    }	    
        if(selectCount == 0)
        {
            myErrorObject.SetErrorMessage(myErrorObject.GetFieldErrorMessage("ISREQUIREDLIST"));
	        retVal = false;
	        return;
        }
	    else { myErrorObject.RemoveErrorContainer(myField); }
	    
	    return retVal;
	}

// ========================================
//        BASE  VALIDATOR FUNCTIONS
// ========================================

	function getValue(myField)
	{
		var myValue = '';
		switch(myField.type)
		{
			case "button" :
				myValue = myField.value;
			case "checkbox" :
				if (myField.checked) {
					myValue = myField.value;
				}
			case "file" :
				myValue = myField.value;
			case "hidden" :
				myValue = myField.value;
			case "password" :
				myValue = myField.value;
			case "radio" :
				if (myField.checked) {
					myValue = myField.value;
				}
			case "reset" :
				myValue = myField.value;
			case "select-one" :
				var si = myField.selectedIndex;
				if (si >= 0) {
					myValue = myField.options[si].value;
				}
			case "select-multiple" :
				myValue = myField.value;
			case "text" :
				myValue = myField.value;
			case "textarea" :
				myValue = myField.value;
			default : 
				myValue = myField.value;
		}
		return myValue;
	}

	function isNotNull(myText)
	{	   
		if ( (myText.length > 0) && (myText.trim().length > 0) ) {
			return true;
		} else {
			// alert("Not Null!");
			return false;
		}
	}

	function isNumeric(myText)
	{
		var charpos = myText.search("[^0-9]"); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Non-Numeric character at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	function isAlpha(myText)
	{
		var charpos = myText.search("[^A-Za-z]"); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Non-Alpha character at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	function isAlphaNumeric(myText)
	{
		var charpos = myText.search("[^A-Za-z0-9]"); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Non-AlphaNumeric character at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	function hasNoDigits(myText)
	{
		var charpos = myText.search("[0-9]"); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Numeric character at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	function hasNoSpaces(myText)
	{
		var charpos = myText.search(/\s/); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Space at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	// HAS NO SPACES - OLD
	function hasNoSpaces_v1(myText)
	{
		var InvalidChars = " ";
		var Char;
		for (i = 0; i < myText.length; i++) 
		{ 
			Char = myText.charAt(i); 
			if (InvalidChars.indexOf(Char) != -1) 
			{
				// alert("Space!");
				return false;
			}
		}
		return true;
	}
	
	function hasNoCrLf(myText)
	{
		var charpos = myText.search(/\r\n/); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Carriage Return or Line Feed at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}

	function notATitle(myText)
	{
		var regTitle = /^(CAPT|COL|DR|FR|LT|MISS|MS|MRS|MR|MJR|REV|SIST|AGENCY)$/i ;
		if (regTitle.test(myText))
		{
			// alert("Name is a Title. Please correct and submit again.");
			return false;
		}
		return true;
	}
	
	function notATestWord(myText)
	{
		var regTest = /^(TEST|TESTING|FIRST)$/i ;
		if (regTest.test(myText))
		{
			// alert("Name is a Test Word. Please correct and submit again.");
			return false;
		}
		return true;
	}
	
	function notTripleRepeat(myText)
	{
		var charpos = myText.search(/^([0-9a-zA-Z])\1\1/i); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Triple Alpha Character " + myText.charAt(charpos) + " at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}
	
	function hasNoFicoDelimeter(myText)
	{
		var charpos = myText.search(/{/); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("FICO Delimeter Character " + myText.charAt(charpos) + " at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}
	
	function hasNoFicoChars(myText)
	{
		var charpos = myText.search(/@|#|\$|%|\*|\^|!|{|}|\[|\]|\?|\+|-|=|\\|\/|,|\.|\"/); 
		if(myText.length > 0 && charpos >= 0) 
		{		  
			// alert("Invalid Character " + myText.charAt(charpos) + " at position " + eval(charpos + 1)); 
			return false; 
		}
		return true;
	}
	
	function hasNoFicoChars_old(myText)
	{
		var InvalidChars = "@#$%*^!{}[]?+-=/,.\"";
		var Char;
		for (i = 0; i < myText.length; i++) 
		{ 
			Char = myText.charAt(i); 
			if (InvalidChars.indexOf(Char) != -1) 
			{
				// alert("Invalid Character " + Char + " at " + eval(myText.indexOf(Char) + 1) );
				return false;
			}
		}
		return true;
	}

	function maxLength(myText,myMaxLength)
	{
		if (myText.length > myMaxLength)
		{
			// alert("More than " + myMaxLength + "!");
			return false;
		} else {
			return true;
		}
	}

	function minLength(myText,myMinLength)
	{
		if (myText.length < myMinLength)
		{
			// alert("Less than " + myMinLength + "!");
			return false;
		} else {
			return true;
		}
	}

	function isValidZipCode(myText)
	{
		var regZip = new RegExp(/(^\d{5}$)|(^\d{5}-\d{4}$)/);
		if (!regZip.test(myText))
		{
			// alert("Zip Code Is Not Valid");
			return false;
		}
		return true;
	}

	function isValidEmailAddress(myText)
	{
		var regEmail = "^[\\w-_\.]*[\\w-_\.]\@[\\w]\.+[\\w]+[\\w]$";
		var regex = new RegExp(regEmail);
		if (!regex.test(myText))
		{
			// alert("Email Address Is Not Valid");
			return false;
		}
		return true;
	}

	function isValidDate(myText)
	{
		var regDate=/^\d{2}\/\d{2}\/\d{4}$/ ;
		if (!regDate.test(myText))
		{
			// alert("Invalid Date Format (MM/DD/YYYY). Please correct and submit again.");
			return false;
		}
		return true ;
	}

	function isValidPhoneNumber(myText)
	{
		var regPhone = /^\(?\d{3}\)?\s|-\d{3}-\d{4}$/ ;
		if (!regPhone.test(myText))
		{
			// alert("Invalid Phone Format (###-###-####). Please correct and submit again.");
			return false;
		}
		return true;
	}
	
	function isValidState(myText)
	{
		var regState = /^(AK|AL|AR|AZ|CA|CO|CT|DC|DE|FL|GA|HI|IA|ID|IL|IN|KS|KY|LA|MA|MD|ME|MI|MN|MO|MS|MT|NB|NC|ND|NH|NJ|NM|NV|NY|OH|OK|OR|PA|RI|SC|SD|TN|TX|UT|VA|VT|WA|WI|WV|WY|AA|AE|AP|AS|FM|GU|MH|MP|PR|PW|VI)$/i ;
		if (!regState.test(myText))
		{
			// alert("Invalid State Abbreviation. Please correct and submit again.");
			return false;
		}
		return true;
	}	
	
	function isValidSSN(myText)
	{
		var regSSN = /^\d{3}\-?\d{2}\-?\d{4}$/ ;
		if (!regSSN.test(myText))
		{
			// alert("Invalid SSN (###-##-####). Please correct and submit again.");
			return false;
		}
		return true;
	}
	
	
}