function Validator(frmname)
    {
       this.validate_on_killfocus=false;
        this.formobj=document.forms[frmname];
       if(!this.formobj)
       {
         alert("Error: couldnot get Form object "+frmname);
          return;
       }
       if(this.formobj.onsubmit)
       {
        this.formobj.old_onsubmit = this.formobj.onsubmit;
        this.formobj.onsubmit=null;
       }
       else
       {
        this.formobj.old_onsubmit = null;
       }
       this.formobj._sfm_form_name=frmname;

       this.formobj.onsubmit=form_submit_handler;
       this.addValidation = add_validation;
       this.setAddnlValidationFunction=set_addnl_vfunction;
       this.clearAllValidations = clear_all_validations;
        this.disable_validations = false;
       
        document.error_disp_handler = new sfm_ErrorDisplayHandler();
       
        this.EnableOnPageErrorDisplay=validator_enable_OPED;
        this.show_errors_together=false;
        this.EnableMsgsTogether=sfm_enable_show_msgs_together;
    }

    function set_addnl_vfunction(functionname)
    {
      this.formobj.addnlvalidation = functionname;
    }
    function sfm_enable_show_msgs_together()
    {
        this.show_errors_together=true;
        this.formobj.show_errors_together=true;
    }
    function clear_all_validations()
    {
       for(var itr=0;itr < this.formobj.elements.length;itr++)
       {
          this.formobj.elements[itr].validationset = null;
       }
    }
    function form_submit_handler()
    {
       var bRet = true;
        document.error_disp_handler.clear_msgs();
       for(var itr=0;itr < this.elements.length;itr++)
       {
          if(this.elements[itr].validationset &&
          !this.elements[itr].validationset.validate())
          {
            bRet = false;
          }
            if(!bRet && !this.show_errors_together)
            {
              break;
            }
       }
        if(!bRet)
        {
          document.error_disp_handler.FinalShowMsg();
          return false;
        }

       if(this.addnlvalidation)
       {
         str =" var ret = "+this.addnlvalidation+"()";
         eval(str);
        if(!ret) return ret;
       }
       return true;
    }

    function add_validation(itemname,descriptor,errstr)
    {
       var condition = null;
       if(arguments.length > 3)
       {
        condition = arguments[3];
       }
       if(!this.formobj)
       {
          alert("Error: The form object is not set properly");
          return;
       }//if
       var itemobj = this.formobj[itemname];

        if(itemobj.length && isNaN(itemobj.selectedIndex) )
        //for radio button; don't do for 'select' item
       {
          itemobj = itemobj[0];
       }   
       if(!itemobj)
       {
          alert("Error: Couldnot get the input object named: "+itemname);
          return;
       }
       if(true == this.validate_on_killfocus)
       {
         itemobj.onblur=handle_item_on_killfocus;
       }
       if(!itemobj.validationset)
       {
          itemobj.validationset = new ValidationSet(itemobj,this.show_errors_together);
       }
       itemobj.validationset.add(descriptor,errstr,condition);
        itemobj.validatorobj=this;
    }

    function handle_item_on_killfocus()
    {
        if(this.validatorobj.disable_validations == true)
        {
            /*
                To avoid repeated looping message boxes
            */
            this.validatorobj.disable_validations = false;
            return false;
        }
       
       if(null != this.validationset)
       {
            document.error_disp_handler.clear_msgs();
          if(false == this.validationset.validate())
          {
                document.error_disp_handler.FinalShowMsg();
             return false;
          }
       }
    }

    function validator_enable_OPED()
    {
        document.error_disp_handler.EnableOnPageDisplay();
    }

    function sfm_ErrorDisplayHandler()
    {
      this.msgdisplay = new AlertMsgDisplayer();
      this.EnableOnPageDisplay= edh_EnableOnPageDisplay;
      this.ShowMsg=edh_ShowMsg;
      this.FinalShowMsg=edh_FinalShowMsg;
      this.all_msgs=new Array();
      this.clear_msgs=edh_clear_msgs;
    }

    function edh_clear_msgs()
    {
        this.msgdisplay.clearmsg(this.all_msgs);
        this.all_msgs = new Array();
    }

    function edh_FinalShowMsg()
    {
        this.msgdisplay.showmsg(this.all_msgs);
    }

    function edh_EnableOnPageDisplay()
    {
        this.msgdisplay = new DivMsgDisplayer();
    }

    function edh_ShowMsg(msg,input_element)
    {
       var objmsg = new Array();
       objmsg["input_element"] = input_element;
       objmsg["msg"] =  msg;
       this.all_msgs.push(objmsg);
    }

    function AlertMsgDisplayer()
    {
      this.showmsg = alert_showmsg;
      this.clearmsg=alert_clearmsg;
    }

    function alert_clearmsg(msgs)
    {

    }

    function alert_showmsg(msgs)
    {
        var whole_msg="";
        var first_elmnt=null;
        for(var m in msgs)
        {
            if(null == first_elmnt)
            {
                first_elmnt = msgs[m]["input_element"];
            }
            whole_msg += msgs[m]["msg"] + "\n";
        }
       
        alert(whole_msg);

        if(null != first_elmnt)
        {
            first_elmnt.focus();
        }
    }

    function sfm_show_error_msg(msg,input_elmt)
    {
        document.error_disp_handler.ShowMsg(msg,input_elmt);
    }

    function DivMsgDisplayer()
    {
    this.showmsg=div_showmsg;
    this.clearmsg=div_clearmsg;
    }

    function div_clearmsg(msgs)
    {
        for(var m in msgs)
        {
            var divname = element_div_name(msgs[m]["input_element"]);
            show_div_msg(divname,"");
        }
    }

    function element_div_name(input_element)
    {
      var divname = input_element.form._sfm_form_name + "_" +
                       input_element.name + "_errorloc";

      divname = divname.replace(/[\[\]]/gi,"");

      return divname;
    }

    function div_showmsg(msgs)
    {
        var whole_msg;
        var first_elmnt=null;
        for(var m in msgs)
        {
            if(null == first_elmnt)
            {
                first_elmnt = msgs[m]["input_element"];
            }
            var divname = element_div_name(msgs[m]["input_element"]);
            show_div_msg(divname,msgs[m]["msg"]);
        }
        if(null != first_elmnt)
        {
            first_elmnt.focus();
        }
    }

    function show_div_msg(divname,msgstring)
    {
       if(document.layers)
       {
          divlayer = document.layers[divname];
            if(!divlayer){return;}
          divlayer.document.open();
          divlayer.document.write(msgstring);
          divlayer.document.close();
       }
       else
       if(document.all)
       {
          divlayer = document.all[divname];
            if(!divlayer){return;}
          divlayer.innerHTML=msgstring;
       }
       else
       if(document.getElementById)
       {
          divlayer = document.getElementById(divname);
            if(!divlayer){return;}
          divlayer.innerHTML =msgstring;
       }
       
       return false;
    }

    function ValidationDesc(inputitem,desc,error,condition)
    {
        this.desc=desc;
       this.error=error;
       this.itemobj = inputitem;
       this.condition = condition;
       this.validate=vdesc_validate;
    }
    function vdesc_validate()
    {
       if(this.condition != null )
       {
          if(!eval(this.condition))
          {
             return true;
          }
       }
       if(!validateInput(this.desc,this.itemobj,this.error))
       {
           this.itemobj.validatorobj.disable_validations=true;
          this.itemobj.focus();
          return false;
       }
       
       return true;
    }

    function ValidationSet(inputitem,msgs_together)
    {
        this.vSet=new Array();
       this.add= add_validationdesc;
       this.validate= vset_validate;
       this.itemobj = inputitem;
        this.msgs_together = msgs_together;
    }

    function add_validationdesc(desc,error,condition)
    {
      this.vSet[this.vSet.length]=
      new ValidationDesc(this.itemobj,desc,error,condition);
    }

    function vset_validate()
    {
        var bRet = true;
        for(var itr=0;itr<this.vSet.length;itr++)
        {
            bRet = bRet && this.vSet[itr].validate();
            if(!bRet && !this.msgs_together)
            {
                break;
            }
        }
        return bRet;
    }
    /*  checks the validity of an email address entered
    *   returns true or false
    */
    function validateEmail(email)
    {
        var splitted = email.match("^(.+)@(.+)$");
        if(splitted == null) return false;
        if(splitted[1] != null )
        {
          var regexp_user=/^\"?[\w-_\.]*\"?$/;
          if(splitted[1].match(regexp_user) == null) return false;
        }
        if(splitted[2] != null)
        {
          var regexp_domain=/^[\w-\.]*\.[A-Za-z]{2,4}$/;
          if(splitted[2].match(regexp_domain) == null)
          {
           var regexp_ip =/^\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\]$/;
           if(splitted[2].match(regexp_ip) == null) return false;
          }// if
          return true;
        }
    return false;
    }

    function TestComparison(objValue,strCompareElement,strvalidator,strError)
    {
       var bRet=true;
       var objCompare=null;
       if(!objValue.form)
       {
          sfm_show_error_msg("Error: No Form object!",objValue);
         return false
       }
       objCompare = objValue.form.elements[strCompareElement];
       if(!objCompare)
       {
         sfm_show_error_msg("Error: Element with name"+strCompareElement+" not found !",objValue);
         return false;
       }
       if(strvalidator != "eqelmnt" &&
            strvalidator != "neelmnt")
       {
          if(isNaN(objValue.value))
          {
            sfm_show_error_msg(objValue.name+": Should be a number ",objValue);
            return false;
          }//if
          if(isNaN(objCompare.value))
          {
            sfm_show_error_msg(objCompare.name+": Should be a number ",objCompare);
            return false;
          }//if     
       }//if
       var cmpstr="";
       switch(strvalidator)
       {
           case "eqelmnt":
             {
                if(objValue.value != objCompare.value)
                {
                    cmpstr = " should be equal to ";
                   bRet = false;
                }//if
                break;
             }//case
          case "ltelmnt":
             {
             if(eval(objValue.value) >= eval(objCompare.value))
                {
                    cmpstr =  " should be less than ";
                    bRet = false;               
                }
               break;
             }//case
          case "leelmnt":
             {
                if(eval(objValue.value) >  eval(objCompare.value))
                {
                    cmpstr =  " should be less than or equal to";
                    bRet = false;               
                }
               break;
             }//case      
          case "gtelmnt":
             {
                if(eval(objValue.value) <=  eval(objCompare.value))
                {
                    cmpstr =  " should be greater than";
                    bRet = false;               
                }
               break;
             }//case
          case "geelmnt":
             {
                if(eval(objValue.value) < eval(objCompare.value))
                {
                    cmpstr =  " should be greater than or equal to";
                    bRet = false;               
                }
               break;
             }//case
			 
          case "neelmnt":
             {
                if(objValue.value.length == 0 &&
                  objCompare.value.length == 0)
                {
                    cmpstr = " should be different from ";
                   bRet = false;
                }//if
                break;         
             }         
       }//switch
       if(bRet==false)
       {
          if(!strError || strError.length==0)
         {
           strError = objValue.name + cmpstr + objCompare.value;
         }//if
         sfm_show_error_msg(strError,objValue);
       }//if
       return bRet;
    }
    function TestSelMin(objValue,strMinSel,strError)
    {
        var bret = true;
       var objcheck = objValue.form.elements[objValue.name];
       var chkcount =0;
       if(objcheck.length)
       {
          for(var c=0;c < objcheck.length;c++)
          {
             if(objcheck[c].checked == "1")
             {
               chkcount++;
             }//if
          }//for
       }
       else
       {
         chkcount = (objcheck.checked == "1")?1:0;
       }
       var minsel = eval(strMinSel);
       if(chkcount < minsel)
       {
          if(!strError || strError.length ==0)
          {
             strError = "Please Select atleast"+minsel+" check boxes for"+objValue.name; 
          }//if                                                               
          sfm_show_error_msg(strError,objValue);
          bret = false;
       }
       return bret;
    }

    function TestSelMax(objValue,strMaxSel,strError)
    {
        var bret = true;
       var objcheck = objValue.form.elements[objValue.name];
       var chkcount =0;
       if(objcheck.length)
       {
          for(var c=0;c < objcheck.length;c++)
          {
             if(objcheck[c].checked == "1")
             {
               chkcount++;
             }//if
          }//for
       }
       else
       {
         chkcount = (objcheck.checked == "1")?1:0;
       }
       var maxsel = eval(strMaxSel);
       if(chkcount > maxsel)
       {
          if(!strError || strError.length ==0)
          {
             strError = "Please Select atmost "+maxsel+" check boxes for"+objValue.name; 
          }//if                                                               
          sfm_show_error_msg(strError,objValue);
          bret = false;
       }
       return bret;
    }
    function IsCheckSelected(objValue,chkValue)
    {
        var selected=false;
       var objcheck = objValue.form.elements[objValue.name];
        if(objcheck.length)
       {
          var idxchk=-1;
          for(var c=0;c < objcheck.length;c++)
          {
             if(objcheck[c].value == chkValue)
             {
               idxchk=c;
              break;
             }//if
          }//for
          if(idxchk>= 0)
          {
            if(objcheck[idxchk].checked=="1")
            {
              selected=true;
            }
          }//if
       }
       else
       {
          if(objValue.checked == "1")
          {
             selected=true;
          }//if
       }//else   

       return selected;
    }

    function TestDontSelectChk(objValue,chkValue,strError)
    {
       var pass = true;
       pass = IsCheckSelected(objValue,chkValue)?false:true;

       if(pass==false)
       {
         if(!strError || strError.length ==0)
            {
               strError = "Can't Proceed as you selected "+objValue.name; 
            }//if          
         sfm_show_error_msg(strError,objValue);
        
       }
        return pass;
    }

    function TestShouldSelectChk(objValue,chkValue,strError)
    {
       var pass = true;

       pass = IsCheckSelected(objValue,chkValue)?true:false;

       if(pass==false)
       {
         if(!strError || strError.length ==0)
            {
               strError = "You should select"+objValue.name; 
            }//if          
         sfm_show_error_msg(strError,objValue);
        
       }
        return pass;
    }

    function TestRequiredInput(objValue,strError)
    {
    var ret = true;
        if(eval(objValue.value.length) == 0)
        {
           if(!strError || strError.length ==0)
           {
             strError = objValue.name + " : Required Field";
           }//if
           sfm_show_error_msg(strError,objValue);
           ret=false;
        }//if
    return ret;
    }
    function TestFileExtension(objValue,cmdvalue,strError)
    {
        var ret=false;
        var found=false;

        if(objValue.value.length <= 0)
        {//The 'required' validation is not done here
            return true;
        }

        var extns = cmdvalue.split(";");
        for(var i=0;i < extns.length;i++)
        {
            ext = objValue.value.substr(objValue.value.length - extns[i].length,extns[i].length);
            ext = ext.toLowerCase();
            if(ext == extns[i])
            {
                found=true;break;
            }
        }
        if(!found)
        {
           if(!strError || strError.length ==0)
           {
             strError = objValue.name + " allowed file extensions are: "+cmdvalue;
           }//if
           sfm_show_error_msg(strError,objValue);
           ret=false;       
        }
        else
        {
            ret=true;
        }
        return ret;
    }
    function TestMaxLen(objValue,strMaxLen,strError)
    {
    var ret = true;
        if(eval(objValue.value.length) > eval(strMaxLen))
        {
          if(!strError || strError.length ==0)
          {
            strError = objValue.name + " : "+ strMaxLen +" characters maximum ";
          }//if
          sfm_show_error_msg(strError,objValue);
          ret = false;
        }//if
    return ret;
    }

    function TestMinLen(objValue,strMinLen,strError)
    {
    var ret = true;
        if(eval(objValue.value.length) <  eval(strMinLen))
        {
          if(!strError || strError.length ==0)
          {
            strError = objValue.name + " : " + strMinLen + " characters minimum  ";
          }//if               
          sfm_show_error_msg(strError,objValue);
          ret = false;   
        }//if
    return ret;
    }

    function TestInputType(objValue,strRegExp,strError,strDefaultError)
    {
       var ret = true;

        var charpos = objValue.value.search(strRegExp);
        if(objValue.value.length > 0 &&  charpos >= 0)
        {
         if(!strError || strError.length ==0)
          {
            strError = strDefaultError;
          }//if
          sfm_show_error_msg(strError,objValue);
          ret = false;
        }//if
    return ret;
    }

    function TestEmail(objValue,strError)
    {
    var ret = true;
         if(objValue.value.length > 0 && !validateEmail(objValue.value)    )
         {
           if(!strError || strError.length ==0)
           {
              strError = objValue.name+": Enter a valid Email address ";
           }//if                                               
           sfm_show_error_msg(strError,objValue);
           ret = false;
         }//if
    return ret;
    }

    function TestLessThan(objValue,strLessThan,strError)
    {
    var ret = true;
         if(isNaN(objValue.value))
         {
           sfm_show_error_msg(objValue.name +": Should be a number ",objValue);
           ret = false;
         }//if
         else
         if(eval(objValue.value) >=  eval(strLessThan))
         {
           if(!strError || strError.length ==0)
           {
             strError = objValue.name + " : value should be less than "+ strLessThan;
           }//if               
           sfm_show_error_msg(strError,objValue);
           ret = false;                 
          }//if   
    return ret;         
    }

    function TestGreaterThan(objValue,strGreaterThan,strError)
    {
    var ret = true;
         if(isNaN(objValue.value))
         {
           sfm_show_error_msg(objValue.name+": Should be a number ",objValue);
           ret = false;
         }//if
        else
         if(eval(objValue.value) <=  eval(strGreaterThan))
          {
            if(!strError || strError.length ==0)
            {
              strError = objValue.name + " : value should be greater than "+ strGreaterThan;
            }//if               
            sfm_show_error_msg(strError,objValue); 
            ret = false;
          }//if 
    return ret;           
    }

    function TestRegExp(objValue,strRegExp,strError)
    {
    var ret = true;
        if( objValue.value.length > 0 &&
            !objValue.value.match(strRegExp) )
        {
          if(!strError || strError.length ==0)
          {
            strError = objValue.name+": Invalid characters found ";
          }//if                                                               
          sfm_show_error_msg(strError,objValue);
          ret = false;                   
        }//if
    return ret;
    }
    function TestDontSelect(objValue,dont_sel_value,strError)
    {
    var ret = true;
         if(objValue.value == null)
         {
           sfm_show_error_msg("Error: dontselect command for non-select Item",objValue);
           ret = false;
         }
        else
         if(objValue.value == dont_sel_value)
         {
          if(!strError || strError.length ==0)
           {
            strError = objValue.name+": Please Select one option ";
           }//if                                                               
           sfm_show_error_msg(strError,objValue);
           ret =  false;                                   
          }
    return ret;
    }

    function TestSelectOneRadio(objValue,strError)
    {
       var objradio = objValue.form.elements[objValue.name];
       var one_selected=false;
       for(var r=0;r < objradio.length;r++)
       {
         if(objradio[r].checked == "1")
         {
            one_selected=true;
          break;
         }
       }
       if(false == one_selected)
       {
          if(!strError || strError.length ==0)
           {
           strError = "Please select one option from "+objValue.name;
          }   
         sfm_show_error_msg(strError,objValue);
       }
    return one_selected;
    }

    function TestSelectRadio(objValue,cmdvalue,strError,testselect)
    {
       var objradio = objValue.form.elements[objValue.name];
       var selected=false;
       
       for(var r=0;r < objradio.length;r++)
       {
         if(objradio[r].value == cmdvalue && objradio[r].checked == "1")
         {
            selected=true;
          break;
         }
       }
       if(testselect==true && false == selected ||
           testselect==false && true == selected)
       {
           sfm_show_error_msg(strError,objValue);
            return false;
       }
    return true;
    }

    //*  Checks each field in a form
    function validateInput(strValidateStr,objValue,strError)
    {

        var ret = true;
        var epos = strValidateStr.search("=");
        var  command  = "";
        var  cmdvalue = "";
        if(epos >= 0)
        {
         command  = strValidateStr.substring(0,epos);
         cmdvalue = strValidateStr.substr(epos+1);
        }
        else
        {
         command = strValidateStr;
        }
       
        switch(command)
        {
            case "req":
            case "required":
             {
             ret = TestRequiredInput(objValue,strError)
               break;             
             }
            case "maxlength":
            case "maxlen":
              {
              ret = TestMaxLen(objValue,cmdvalue,strError)
                 break;
              }
            case "minlength":
            case "minlen":
               {
              ret = TestMinLen(objValue,cmdvalue,strError)
                 break;
               }
            case "alnum":
            case "alphanumeric":
               {
                ret = TestInputType(objValue,"[^A-Za-z0-9]",strError,
                      objValue.name+": Only alpha-numeric characters allowed ");
                break;
               }
            case "alnum_s":
            case "alphanumeric_space":
               {
                ret = TestInputType(objValue,"[^A-Za-z0-9\\s]",strError,
                      objValue.name+": Only alpha-numeric characters and space allowed ");
                break;
               }         
            case "num":
            case "numeric":
               {
                    ret = TestInputType(objValue,"[^0-9]",strError,
                      objValue.name+": Only digits allowed ");
                    break;               
               }
            case "alphabetic":
            case "alpha":
               {
                    ret = TestInputType(objValue,"[^A-Za-z]",strError,
                      objValue.name+": Only alphabetic characters allowed ");
                    break;
               }
            case "alphabetic_space":
            case "alpha_s":
               {
                    ret = TestInputType(objValue,"[^A-Za-z\\s]",strError,
                      objValue.name+": Only alphabetic characters and space allowed ");
                    break;
               }
            case "email":
              {
                ret = TestEmail(objValue,strError);
                   break;
              }
            case "lt":
            case "lessthan":
             {
                 ret = TestLessThan(objValue,cmdvalue,strError);
                  break;
             }
            case "gt":
            case "greaterthan":
             {
             ret = TestGreaterThan(objValue,cmdvalue,strError);
                break;
             }
            case "regexp":
             {
             ret = TestRegExp(objValue,cmdvalue,strError);
               break;
             }
            case "dontselect":
             {
              ret = TestDontSelect(objValue,cmdvalue,strError)
                 break;
             }
          case "dontselectchk":
          {
             ret = TestDontSelectChk(objValue,cmdvalue,strError)
             break;
          }
          case "shouldselchk":
          {
             ret = TestShouldSelectChk(objValue,cmdvalue,strError)
             break;
          }
          case "selmin":
          {
             ret = TestSelMin(objValue,cmdvalue,strError);
             break;
          }
          case "selmax":
          {
             ret = TestSelMax(objValue,cmdvalue,strError);
             break;
          }
          case "selone":
          {
             ret = TestSelectOneRadio(objValue,strError);
              break;
          }      
            case "dontselectradio":
            {
                ret = TestSelectRadio(objValue,cmdvalue,strError,false);
                break;
            }
            case "selectradio":
            {
                ret = TestSelectRadio(objValue,cmdvalue,strError,true);
                break;
            }
          //Comparisons
          case "eqelmnt":
          case "ltelmnt":
          case "leelmnt":
          case "gtelmnt":
          case "geelmnt":
          case "neelmnt":
          {
              return TestComparison(objValue,cmdvalue,command,strError);
              break;
          }
            case "req_file":
            {
               ret = TestRequiredInput(objValue,strError);
               break;
            }
            case "file_extn":
            {
                ret = TestFileExtension(objValue,cmdvalue,strError);
                break;
            }

        }//switch
        return ret;
    }
    function VWZ_IsListItemSelected(listname,value)
    {
    for(var i=0;i < listname.options.length;i++)
    {
      if(listname.options[i].selected == true &&
       listname.options[i].value == value)
       {
         return true;
       }
    }
    return false;
    }

    function VWZ_IsChecked(objcheck,value)
    {
    if(objcheck.length)
    {
         for(var c=0;c < objcheck.length;c++)
         {
           if(objcheck[c].checked == "1" &&
            objcheck[c].value == value)
           {
            return true;
           }
         }
    }
    else
    {
      if(objcheck.checked == "1" )
       {
        return true;
       }   
    }
    return false;
    }