if(!Object.AddEvent)
{
   Object.AddEvent = function(obj, evType, fn)
   {
      if(obj.addEventListener){obj.addEventListener(evType, fn, false);return true;} 
      else if (obj.attachEvent){var r = obj.attachEvent("on"+evType, fn); return r;} 
      else {return false;} 
   } 
}

function ValidateSubject(obj, name)
{
   var subject = obj;
   subject[name] = this;
   var Validators = new Array();
      
   this.Attach = function(validator)
   {
      validator.SubjectToValidate = subject;
      Validators.push(validator);         
   }
      
   this.Detach = function(validator)
   {
      for(var i=0; i<Validators.length; i++)
      {
         if(validator==Validators[i])Validators.slice(i);
      }
   }
      
   this.CallValidators = function()
   {
      for(var i=0; i<Validators.length; i++)
      {
         if(Validators[i].Validate)Validators[i].Validate();
      }
   }
   return subject;
}
  
Validator.All = new Array();
Validator.ErrorMessages = new Array();
Validator.Summary = null;
Validator.ValidateAll = function()
{
   Validator.ErrorMessages = new Array();
   for(var i=0; i<Validator.All.length; i++)
   {   
        if (arguments[0])
        {                    
            if((Validator.All[i].ValidationGroup == arguments[0]) && !Validator.All[i].Validate())
                Validator.ErrorMessages.push({Anchor: Validator.All[i].ControlToValidate.id , Message:Validator.All[i].ErrorMessage});
        }
        else
        {
            if(!Validator.All[i].Validate())
                Validator.ErrorMessages.push({Anchor: Validator.All[i].ControlToValidate.id , Message:Validator.All[i].ErrorMessage});
        }
   }
   
   
   if(Validator.ErrorMessages.length>0)
   {
      if(Validator.Summary)
         Validator.Summary.DisplaySummary(Validator.ErrorMessages);
   }
   else
   {
      if(Validator.Summary)
         Validator.Summary.HideSummary();      
      return true;
   }
   return false;
   
}
Validator.ClearError = function()
{
    for(var i=0; i<Validator.All.length; i++)
    {   
        if (arguments[0])
        {
            if (Validator.All[i].ValidationGroup == arguments[0])
                Validator.All[i].style.display = 'none';
        }
        else        
            Validator.All[i].style.display = 'none';
    }
    if (Validator.Summary)
        Validator.Summary.HideSummary();
}

Validator.Validating = function(evt)
{  
   var ret = Validator.ValidateAll();
   if(ret)return ret;
   
   if (evt && evt.preventDefault)
     evt.preventDefault(); 
   return false;
}
   
   
Validator.ReadyStateChange = function()
{
   if(document.readyState && document.readyState!="complete")return;

   if (document.all)
   {
       for(var i=0; i<document.all.length; i++)
       {   
          var att = document.all[i].getAttributeNode("Validator");
          if(att)
          {
             switch(att.value)
             {
                case "RequiredValidator" : 
                   new RequiredValidator(document.all[i]);
                   break;
                case "RegularExpressionValidator" : 
                   new RegularExpressionValidator(document.all[i]);
                   break;
                case "RangeValidator" : 
                   new RangeValidator(document.all[i]);
                   break;
                case "CustomValidator" : 
                   new CustomValidator(document.all[i]); 
                   break;
                case "ValidationSummary" : 
                   new ValidationSummary(document.all[i]);
                   break;            
                default :
                   break;
             }
          }
             
          if (Validator.ValidateOnSubmit)
          {
            if(document.all[i].tagName.toUpperCase() == "INPUT" && document.all[i].type.toUpperCase() == "SUBMIT")
                Object.AddEvent(document.all[i], 'click', Validator.Validating);
          }
      }
   }      
   else
   {
       var elements = document.getElementsByTagName('*');
       for(var i=0; i<elements.length; i++)
       {   
          var att = elements[i].getAttributeNode("Validator");
          if(att)
          {
             switch(att.value)
             {
                case "RequiredValidator" : 
                   new RequiredValidator(elements[i]);
                   break;
                case "RegularExpressionValidator" : 
                   new RegularExpressionValidator(elements[i]);
                   break;
                case "RangeValidator" : 
                   new RangeValidator(elements[i]);
                   break;
                case "CustomValidator" : 
                   new CustomValidator(elements[i]); 
                   break;
                case "ValidationSummary" : 
                   new ValidationSummary(elements[i]);
                   break;            
                default :
                   break;
             }
          }
             
          if (Validator.ValidateOnSubmit)
          {
            if(elements[i].tagName.toUpperCase() == "INPUT" && elements[i].type.toUpperCase() == "SUBMIT")
                Object.AddEvent(elements[i], 'click', Validator.Validating);
          }
      }
   }
}
   
Object.AddEvent((document.readyState)?document:window, (document.readyState)?"readystatechange":"load", Validator.ReadyStateChange );
   
function Validator(obj)
{
    var implementor = obj;

    var tmpControl = document.getElementById(implementor.attributes["ControlToValidate"]?implementor.attributes["ControlToValidate"].value:'');
    if(tmpControl==null)throw "Invalid controlToValidate";

    Validator.All.push(implementor);
    implementor.ControlToValidate = tmpControl;
    implementor.ErrorMessage = (implementor.attributes["ErrorMessage"])?implementor.attributes["ErrorMessage"].value:"invalid input.";
    implementor.Enabled = (implementor.attributes["Enabled"])?implementor.attributes["Enabled"].value:'true';
    implementor.ValidateOnBlur = (implementor.attributes["ValidateOnBlur"])?implementor.attributes["ValidateOnBlur"].value:'true';
    implementor.Display = (implementor.attributes["Display"])?implementor.attributes["Display"].value:'static';
    implementor.ValidateEmptyText = (implementor.attributes["ValidateEmptyText"])?implementor.attributes["ValidateEmptyText"].value:'false';
    implementor.ValidationGroup = (implementor.attributes["ValidationGroup"])?implementor.attributes["ValidationGroup"].value:"";
    implementor.ValidateOnSubmit = (implementor.attributes["ValidateOnSubmit"])?implementor.attributes["ValidateOnSubmit"].value:'true';

    if(!implementor.ControlToValidate.ValidatorList){
       new ValidateSubject(implementor.ControlToValidate, 'ValidatorList');
       if (implementor.ValidateOnBlur=='true')
            Object.AddEvent(implementor.ControlToValidate, "blur", function(evt){var target=(!evt.srcElement)?evt.target:evt.srcElement;target.ValidatorList.CallValidators();});
    }
    implementor.ControlToValidate.ValidatorList.Attach(implementor);
       
    implementor.Validate = function()
    {
       if(implementor.Enabled=='false')return true;
       if(implementor.ControlToValidate!=null && implementor.IsSatisfy)
       {
          if(implementor.IsSatisfy())
          {
            if(implementor.ValidAction!=null)
               implementor.ValidAction();
            return true;
          }
          else
          {
            if(implementor.InvalidAction!=null)
               implementor.InvalidAction();
          }
       }
       return false;
    };
       
    implementor.InvalidAction = function()
    {
       switch(this.Display.toLowerCase())
       {
          case 'static' :
            this.style.display = ""; 
            break;
          default :
            this.style.position = "static";
            this.style.visibility = "visible";
            break;
       }
    };

    implementor.ValidAction = function()
    {
       switch(this.Display.toLowerCase())
       {
          case 'static' :
            this.style.display = "none"; 
            break;
          default :
            this.style.position = "absolute";
            this.style.visibility = "hidden";
            break;
       }
    };
    implementor.ValidAction()
    implementor.IsSatisfy = function(){return true;}
    return implementor;
}
   
function RequiredValidator(obj)
{
   var implementor = new Validator(obj);
      
   implementor.IsSatisfy = function()
   {
      if(implementor.ControlToValidate!=null)
      {
        if(implementor.ControlToValidate.type == "radio" || implementor.ControlToValidate.type == "checkbox")
          return implementor.ControlToValidate.checked;
        else
          return implementor.ControlToValidate.value!="";
      }
      return false;
   }         
   return implementor;
}
     
function RegularExpressionValidator(obj)
{
    var implementor = new Validator(obj);
    implementor.RegularExpression = (implementor.attributes["RegularExpression"])?implementor.attributes["RegularExpression"].value:null;
    implementor.IsSatisfy = function()
    {
      if (!implementor.ValidateEmptyText && IsEmptyText(obj))
        return true;

      var re = new RegExp(this.RegularExpression);
      return re.test(implementor.ControlToValidate.value);
      return true;
    }
    return implementor;
}
   
function RangeValidator(obj)
{
    var implementor = new Validator(obj);
    implementor.Min = (implementor.attributes["Min"])?implementor.attributes["Min"].value:0;
    implementor.Max = (implementor.attributes["Max"])?implementor.attributes["Max"].value:1000;
    implementor.IsSatisfy = function()
    {
        if (!implementor.ValidateEmptyText && IsEmptyText(obj))
            return true;

       if(this.ControlToValidate.value=='')return true;
       var min = parseFloat(this.Min);
       var max = parseFloat(this.Max);
       var val = parseFloat(this.ControlToValidate.value);
       if(!isNaN(min) && !isNaN(max) && !isNaN(val))
       {
          return (min<=val && val<=max);
       }
       return false;
    }
    return implementor;
}
   
function CustomValidator(obj)
{
   var implementor = new Validator(obj);
   implementor.CustomFunction = (implementor.attributes["CustomFunction"])?implementor.attributes["CustomFunction"].value:"return true;";
   implementor.IsSatisfy = function()
   {
      if (!implementor.ValidateEmptyText && IsEmptyText(obj))
         return true;

      var aaa = new Function(this.CustomFunction);
      var ret = aaa.apply(this);
      return (ret)?ret:false;
   }
   return implementor;
}

function ValidationSummary(obj)
{
   var implementor = obj;
   implementor.ErrorTitle = (implementor.attributes["ErrorTitle"])?implementor.attributes["ErrorTitle"].value:"Invalidate Occured";
   Validator.Summary = implementor;
   implementor.DisplaySummary = function(ErrorMessages)
   {
      this.innerHTML = "";
      this.innerHTML = this.ErrorTitle + "<br/>"
      for(var i=0; i<ErrorMessages.length; i++)
      {
         var controlType = document.getElementById(ErrorMessages[i].Anchor).type;
         this.innerHTML += " - <a href='javascript:document.getElementById(\"" + ErrorMessages[i].Anchor + "\")." + ((controlType!='radio' && controlType!='checkbox')?'select':'focus') + "()' onmouseout=\"window.status=''\" onmousemove='window.status=\"" + ErrorMessages[i].Message + "\"'>" + ErrorMessages[i].Message + " </a><br/>";
      } 
      this.style.position = "static";
      this.style.visibility = "visible";
   }
   implementor.HideSummary = function()
   {
      this.style.position = "absolute";
      this.style.visibility = "hidden";
   }
   implementor.HideSummary();
   return implementor;
}

function IsEmptyText(obj)
{
    var myobj = obj;
    if(myobj.ControlToValidate.type == "radio" || myobj.ControlToValidate.type == "checkbox")
        return !myobj.ControlToValidate.checked;
    else
        return myobj.ControlToValidate.value=="";    
}