/*
  -------------------------------------------------------------------------
		      JavaScript Form Validator
              Version 6.0
              Part of Simfatic Forms software
					
	Copyright (C) 2003-2009 Simfatic Solutions. All rights reserved.
    This javascript code is installed as part of Simfatic Forms software.
	You may adapt this script for your own needs, provided these opening credit
    lines (down to the lower dividing line) are kept intact.
    You may not reprint or redistribute this code without permission from 
    Simfatic Solutions.
	http://www.simfatic.com/
    -------------------------------------------------------------------------  
*/

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.formobj.addnlvalidations = new Array();
    this.addAddnlValidationFunction = add_addnl_vfunction;
    this.formobj.runAddnlValidations = run_addnl_validations;
    

	this.clearAllValidations = clear_all_validations;
    this.disable_validations = false;
    
    document.error_disp_handler = new sfm_ErrorDisplayHandler();
    
    this.EnableOnPageErrorDisplay=validator_enable_OPED;
	this.EnableOnPageErrorDisplaySingleBox=validator_enable_OPED_SB;

    this.show_errors_together=false;
    this.EnableMsgsTogether=sfm_enable_show_msgs_together;
    document.set_focus_onerror=true;
    this.EnableFocusOnError=sfm_validator_enable_focus;

    this.formobj.error_display_loc = 'right';
    this.SetMessageDisplayPos = sfm_validator_message_disp_pos;
}


function sfm_validator_enable_focus(enable)
{
    document.set_focus_onerror = enable;
}

function add_addnl_vfunction()
{
     var proc = {};
     proc.func = arguments[0];
     proc.arguments = [];

     for(var i = 1; i < arguments.length; i++ )
     {          
        proc.arguments.push(arguments[i]);       
     }           
     this.formobj.addnlvalidations.push(proc);  
}

function run_addnl_validations()
{
    var ret = true;
    for(var f=0;f<this.addnlvalidations.length;f++)
    {
        var proc = this.addnlvalidations[f];
        var args = proc.arguments || [];
        if(!proc.func.apply(null, args))
        {
            ret = false;
        }
    }
    return ret;
}

function sfm_set_focus(objInput)
{
    if(document.set_focus_onerror)
    {
        if(!objInput.disabled && objInput.type != 'hidden')
        {
            objInput.focus();
        }
    }
}

function sfm_enable_show_msgs_together()
{
    this.show_errors_together=true;
    this.formobj.show_errors_together=true;
}

function sfm_validator_message_disp_pos(pos)
{
    this.formobj.error_display_loc= pos;
}
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(this.show_errors_together ||
      bRet && !this.show_errors_together)
      {
        if(!this.runAddnlValidations())
        {
            bRet = false;
        }
      }
   if(!bRet)
    {
      document.error_disp_handler.FinalShowMsg();
      return false;
    }
	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(false);
}

function validator_enable_OPED_SB()
{
	document.error_disp_handler.EnableOnPageDisplay(true);
}

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()
{
    if(this.all_msgs.length == 0){ return ;}
    this.msgdisplay.showmsg(this.all_msgs);
}

function edh_EnableOnPageDisplay(single_box)
{
	if(true == single_box)
	{
		this.msgdisplay = new SingleBoxErrorDisplay();
	}
	else
	{
		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=0;m < msgs.length;m++)
    {
        if(null == first_elmnt)
        {
            first_elmnt = msgs[m]["input_element"];
        }
        whole_msg += msgs[m]["msg"] + "\n";
    }
	
    alert(whole_msg);

    if(null != first_elmnt)
    {
        sfm_set_focus(first_elmnt);
    }
}

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

function SingleBoxErrorDisplay()
{
 this.showmsg=sb_div_showmsg;
 this.clearmsg=sb_div_clearmsg;
}

function sb_div_clearmsg(msgs)
{
	var divname = form_error_div_name(msgs);
	sfm_show_div_msg(divname,"");
}

function sb_div_showmsg(msgs)
{
	var whole_msg="<ul>\n";
	for(var m=0;m < msgs.length;m++)
    {
        whole_msg += "<li>" + msgs[m]["msg"] + "</li>\n";
    }
	whole_msg += "</ul>";
	var divname = form_error_div_name(msgs);
    var anc_name = divname+"_loc";
    whole_msg = "<a name='"+anc_name+"' >"+whole_msg;

	sfm_show_div_msg(divname,whole_msg);

    window.location.hash = anc_name;
}

function form_error_div_name(msgs)
{
	var input_element= null;

	for(var m in msgs)
	{
	 input_element = msgs[m]["input_element"];
	 if(input_element){break;}
	}

	var divname ="";
	if(input_element)
	{
	 divname = input_element.form._sfm_form_name + "_errorloc";
	}

	return divname;
}

function sfm_show_div_msg(divname,msgstring)
{
	if(divname.length<=0) return false;

	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;
	}
	divlayer.style.visibility="visible";	
	return false;
}

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"]);
        var divxx = document.getElementById(divname);
        if(divxx)
        {
            divxx.parentNode.removeChild(divxx);
        }
    }
}

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 sfm_getAbsX(obj)
{
  var leftOffset = 0;
  if (obj.offsetParent)
  {
        while (obj.offsetParent)
        {
              leftOffset += obj.offsetLeft;
              obj = obj.offsetParent;
        }
  }
  else if (obj.x) //for NN4
  {
        leftOffset = obj.x;
  }
  return leftOffset;
}

function sfm_getAbsY(obj)
{
  var topOffset = 0;
  if (obj.offsetParent)
  {
        while (obj.offsetParent)
        {
              topOffset += obj.offsetTop;
              obj = obj.offsetParent;
        }
  }
  else if (obj.y) // for NN4
  {
        topOffset = obj.y;
  }
  return topOffset;
}

function div_showmsg(msgs)
{
    var whole_msg;
    var first_elmnt=null;

    this.clearmsg(msgs);
    for(var m in msgs)
    {
        if(null == first_elmnt)
        {
            first_elmnt = msgs[m]["input_element"];
        }
        var divname = element_div_name(msgs[m]["input_element"]);
        sfm_show_floating_div_msg(divname,msgs[m]["msg"],msgs[m]["input_element"]);
    }
    if(null != first_elmnt)
    {
        sfm_set_focus(first_elmnt);
    }
}

function sfm_removeNode(nodeid)
{
	var divxx = document.getElementById(nodeid);
	divxx.parentNode.removeChild(divxx);
}
function sfm_show_floating_div_msg(divname,msgstring,inputobj)
{
	if(divname.length<=0) return false;

    var popUpCode = "<div class='sfm_float_error_box' id='"+divname+"' >"+
        "<table border='0' cellspacing='0' ><tr><td class='sfm_float_box_td'>" + msgstring + " &nbsp; </td> "+
        "<td class='sfm_close_box' width='20px' onclick='sfm_removeNode(\""+divname+"\")'>X</td></tr></table></div>"

    var div = document.createElement('div'); 
    div.innerHTML = popUpCode; 
    inputobj.form.appendChild(div);

    var rel_obj = inputobj;

    if(inputobj.parentNode && inputobj.parentNode.className == 'sfm_element_container')
    {
        rel_obj = inputobj.parentNode;
    }
    else
    if(inputobj.type && 
     (inputobj.type =='checkbox'||inputobj.type == 'radio') && 
      inputobj.parentNode)
    {
        rel_obj = inputobj.parentNode;
    }

    var errposx = sfm_getAbsX(rel_obj);
	var errposy = sfm_getAbsY(rel_obj);

    var divxx = document.getElementById(divname);

    if(inputobj.form.error_display_loc == 'top')
    {
        errposy -= divxx.offsetHeight;
        errposy += 2;
        errposx += 10;
    }
    else
    if(inputobj.form.error_display_loc == 'right')
    {
        var offsetWidth  = rel_obj.offsetWidth;
        var offsetHeight = rel_obj.offsetHeight;

        errposx += offsetWidth;
        errposx += 4;
        
        errposy += ( offsetHeight - divxx.offsetHeight)/2;
    }
    divxx.style.top  = errposy + 'px';
    divxx.style.left = errposx + 'px'; 
    divxx.handlerobj = new SFM_MoveablePopup(divxx);

	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;
		sfm_set_focus(this.itemobj);
	   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;
   }

   var objval_value = objValue.value;
   var objcomp_value = objCompare.value;
   
   if(strvalidator != "eqelmnt" &&
   	  strvalidator != "neelmnt")
   {
        objval_value = objval_value.replace(/\,/g,"");
        objcomp_value = objcomp_value.replace(/\,/g,"");

        if(isNaN(objval_value)) 
        { 
            sfm_show_error_msg(objValue.name+": Should be a number ",objValue); 
            return false; 
        }//if 
        if(isNaN(objcomp_value)) 
        { 
            sfm_show_error_msg(objCompare.name+": Should be a number ",objCompare); 
            return false; 
        }//if 	  
   }//if
   var cmpstr="";
   switch(strvalidator)
   {
       case "eqelmnt": 
			{
			   if(objval_value != objcomp_value)
			   {
 	 		      cmpstr = " should be equal to ";
			      bRet = false;
			   }//if
			   break;
			}//case
		case "ltelmnt":
			{
			if(eval(objval_value) >= eval(objcomp_value)) 
				{
			       cmpstr =  " should be less than "; 
			       bRet = false;					
				}
			  break;
			}//case
		case "leelmnt":
			{
				if(eval(objval_value) >  eval(objcomp_value)) 
				{
			       cmpstr =  " should be less than or equal to"; 
			       bRet = false;					
				}
			  break;
			}//case		
		case "gtelmnt":
			{
				if(eval(objval_value) <=  eval(objcomp_value)) 
				{
			       cmpstr =  " should be greater than"; 
			       bRet = false;					
				}
			  break;
			}//case
		case "geelmnt":
			{
				if(eval(objval_value) < eval(objcomp_value)) 
				{
			       cmpstr =  " should be greater than or equal to"; 
			       bRet = false;					
				}
			  break;
			}//case
		case "neelmnt":
			{
			   if(objval_value.length > 0 &&
			     objcomp_value.length > 0 &&
			     objval_value == objcomp_value)
			   {
 	 		      cmpstr = " should be different from ";
			      bRet = false;
			   }//if
			   break;			
			}			
   }//switch
   if(bRet==false)
   {
      if(!strError || strError.length==0)
	  {
	    strError = objValue.name + cmpstr + objcomp_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(VWZ_IsEmpty(objValue.value)) 
    { 
       ret=false;
    }//if 
    else 
    if(objValue.getcal && !objValue.getcal())
    {
        ret=false; 
    }

    if(!ret)
    {
       if(!strError || strError.length ==0) 
       { 
         strError = objValue.name + " : Required Field"; 
       }//if 
       sfm_show_error_msg(strError,objValue);
    }
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;
      var obj_value = objValue.value.replace(/\,/g,"");
      strLessThan = strLessThan.replace(/\,/g,"");

	  if(isNaN(obj_value)) 
	  { 
	    sfm_show_error_msg(objValue.name +": Should be a number ",objValue); 
	    ret = false; 
	  }//if 
	  else
	  if(eval(obj_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;
    var obj_value = objValue.value.replace(/\,/g,"");
    strGreaterThan = strGreaterThan.replace(/\,/g,"");        

    if(isNaN(obj_value)) 
    { 
        sfm_show_error_msg(objValue.name+": Should be a number ",objValue); 
        ret = false; 
    }//if 
    else
    if(eval(obj_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;
}

function TestDateComparison(objValue,cmdvalue,strError,test_after)
{
    ret=false;

    if(objValue.value.length <= 0)
    {//The 'required' validation is not done here
        return true;
    }
    var dateother = sfm_val_getOtherDate(objValue,cmdvalue);
    var valuedateobj =  objValue.getcal();
    if(dateother && valuedateobj)
    {
        var error = false;
        if(test_after)
        {
            error = sfm_compare_dates(dateother,valuedateobj) <= 0?true:false;
        }
        else
        {//test_before
            error = sfm_compare_dates(dateother,valuedateobj) >= 0?true:false;
        }
        if(error)
        {
            sfm_show_error_msg(strError,objValue);
        }
        else
        {
            ret=true;
        }
    }
    else
    {
        sfm_show_error_msg("Invalid date value",objValue); ret=false;
    }
    return ret;
}

function sfm_val_getOtherDate(objValue,cmdvalue)
{
    var date_ret;
    if(cmdvalue == "SameDay")
    {
        date_ret = new Date();
    }
    else
    {
        var ret_arr = cmdvalue.match(/^(\w+)\(([\d\w\-]+)\)$/);
        if('FixedDate' == ret_arr[1])
        {
            var date_str = ret_arr[2];
            var date_arr = date_str.match(/^(\d*)\-(\d*)\-(\d*)$/);
            date_ret = new Date();
            date_ret.setFullYear(parseInt(date_arr[1],10));
            date_ret.setMonth(parseInt(date_arr[2],10)-1);
            date_ret.setDate(parseInt(date_arr[3],10));
        }
        else
        if('Field' == ret_arr[1])
        {
            var field_name = ret_arr[2];
            date_ret = objValue.form.elements[field_name].getcal();
        }
    }
    return date_ret;
}

//*  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": 
           { 
                if( objValue.value.length > 0 && 
                    !objValue.value.match(/^[\-\+]?[\d\,]*\.?[\d]*$/) ) 
                { 
                  sfm_show_error_msg(strError,objValue); 
                  ret = false;                   
                }//if 

                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;
        }
        case "after_date":
        {
            ret = TestDateComparison(objValue,cmdvalue,strError,/*test_after*/true)
            break;
        }
        case "before_date":
        {
            ret = TestDateComparison(objValue,cmdvalue,strError,/*test_after*/false)
            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;
}

function sfm_str_trim(strIn)
{
    return strIn.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
}

function sfm_compare_dates(date1,date2)
{
    var d1 = date1.print('%Y-%m-%d');
    var d2 = date2.print('%Y-%m-%d');
    if(d1 < d2 )
    {
        return 1;
    }
    else
    if(d1 > d2)
    {
        return -1;
    }
    else
    {
        return 0;
    }
}
function VWZ_IsEmpty(value)
{
    value = sfm_str_trim(value);
    return (value.length) == 0?true:false;
}
/*
	Copyright (C) 2003-2009 Simfatic Solutions . All rights reserved.
*/ 