home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / validators / Validator.as < prev   
Encoding:
Text File  |  2010-06-23  |  12.8 KB  |  455 lines
  1. package mx.validators
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.events.IEventDispatcher;
  6.    import mx.core.IMXMLObject;
  7.    import mx.core.mx_internal;
  8.    import mx.events.ValidationResultEvent;
  9.    import mx.resources.IResourceManager;
  10.    import mx.resources.ResourceManager;
  11.    
  12.    use namespace mx_internal;
  13.    
  14.    public class Validator extends EventDispatcher implements IMXMLObject
  15.    {
  16.       mx_internal static const VERSION:String = "3.5.0.12683";
  17.       
  18.       protected static const ROMAN_LETTERS:String = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  19.       
  20.       protected static const DECIMAL_DIGITS:String = "0123456789";
  21.       
  22.       private var _resourceManager:IResourceManager = ResourceManager.getInstance();
  23.       
  24.       private var _enabled:Boolean = true;
  25.       
  26.       private var _listener:Object;
  27.       
  28.       protected var subFields:Array = [];
  29.       
  30.       private var document:Object;
  31.       
  32.       public var required:Boolean = true;
  33.       
  34.       private var requiredFieldErrorOverride:String;
  35.       
  36.       private var _triggerEvent:String = "valueCommit";
  37.       
  38.       private var _source:Object;
  39.       
  40.       private var _property:String;
  41.       
  42.       private var _requiredFieldError:String;
  43.       
  44.       private var _trigger:IEventDispatcher;
  45.       
  46.       public function Validator()
  47.       {
  48.          super();
  49.          resourceManager.addEventListener(Event.CHANGE,resourceManager_changeHandler,false,0,true);
  50.          resourcesChanged();
  51.       }
  52.       
  53.       private static function findObjectFromString(param1:Object, param2:String) : Object
  54.       {
  55.          var resourceManager:IResourceManager = null;
  56.          var message:String = null;
  57.          var doc:Object = param1;
  58.          var value:String = param2;
  59.          var obj:Object = doc;
  60.          var parts:Array = value.split(".");
  61.          var n:int = int(parts.length);
  62.          var i:int = 0;
  63.          while(i < n)
  64.          {
  65.             try
  66.             {
  67.                obj = obj[parts[i]];
  68.                if(obj == null)
  69.                {
  70.                }
  71.             }
  72.             catch(error:Error)
  73.             {
  74.                if(error is TypeError && error.message.indexOf("null has no properties") != -1)
  75.                {
  76.                   resourceManager = ResourceManager.getInstance();
  77.                   message = resourceManager.getString("validators","fieldNotFound",[value]);
  78.                   throw new Error(message);
  79.                }
  80.                throw error;
  81.             }
  82.             i++;
  83.          }
  84.          return obj;
  85.       }
  86.       
  87.       private static function trimString(param1:String) : String
  88.       {
  89.          var _loc2_:int = 0;
  90.          while(param1.indexOf(" ",_loc2_) == _loc2_)
  91.          {
  92.             _loc2_++;
  93.          }
  94.          var _loc3_:int = param1.length - 1;
  95.          while(param1.lastIndexOf(" ",_loc3_) == _loc3_)
  96.          {
  97.             _loc3_--;
  98.          }
  99.          return _loc3_ >= _loc2_ ? param1.slice(_loc2_,_loc3_ + 1) : "";
  100.       }
  101.       
  102.       public static function validateAll(param1:Array) : Array
  103.       {
  104.          var _loc5_:Validator = null;
  105.          var _loc6_:ValidationResultEvent = null;
  106.          var _loc2_:Array = [];
  107.          var _loc3_:int = int(param1.length);
  108.          var _loc4_:int = 0;
  109.          while(_loc4_ < _loc3_)
  110.          {
  111.             _loc5_ = Validator(param1[_loc4_]);
  112.             if(_loc5_.enabled)
  113.             {
  114.                _loc6_ = _loc5_.validate();
  115.                if(_loc6_.type != ValidationResultEvent.VALID)
  116.                {
  117.                   _loc2_.push(_loc6_);
  118.                }
  119.             }
  120.             _loc4_++;
  121.          }
  122.          return _loc2_;
  123.       }
  124.       
  125.       private function triggerHandler(param1:Event) : void
  126.       {
  127.          validate();
  128.       }
  129.       
  130.       public function set enabled(param1:Boolean) : void
  131.       {
  132.          _enabled = param1;
  133.       }
  134.       
  135.       public function set triggerEvent(param1:String) : void
  136.       {
  137.          if(_triggerEvent == param1)
  138.          {
  139.             return;
  140.          }
  141.          removeTriggerHandler();
  142.          _triggerEvent = param1;
  143.          addTriggerHandler();
  144.       }
  145.       
  146.       protected function getValueFromSource() : Object
  147.       {
  148.          var _loc1_:String = null;
  149.          if(Boolean(_source) && Boolean(_property))
  150.          {
  151.             return _source[_property];
  152.          }
  153.          if(!_source && Boolean(_property))
  154.          {
  155.             _loc1_ = resourceManager.getString("validators","SAttributeMissing");
  156.             throw new Error(_loc1_);
  157.          }
  158.          if(Boolean(_source) && !_property)
  159.          {
  160.             _loc1_ = resourceManager.getString("validators","PAttributeMissing");
  161.             throw new Error(_loc1_);
  162.          }
  163.          return null;
  164.       }
  165.       
  166.       protected function addListenerHandler() : void
  167.       {
  168.          var _loc1_:Object = null;
  169.          var _loc2_:Array = actualListeners;
  170.          var _loc3_:int = int(_loc2_.length);
  171.          var _loc4_:int = 0;
  172.          while(_loc4_ < _loc3_)
  173.          {
  174.             _loc1_ = _loc2_[_loc4_];
  175.             if(_loc1_ is IValidatorListener)
  176.             {
  177.                addEventListener(ValidationResultEvent.VALID,IValidatorListener(_loc1_).validationResultHandler);
  178.                addEventListener(ValidationResultEvent.INVALID,IValidatorListener(_loc1_).validationResultHandler);
  179.             }
  180.             _loc4_++;
  181.          }
  182.       }
  183.       
  184.       private function removeTriggerHandler() : void
  185.       {
  186.          if(actualTrigger)
  187.          {
  188.             actualTrigger.removeEventListener(_triggerEvent,triggerHandler);
  189.          }
  190.       }
  191.       
  192.       public function validate(param1:Object = null, param2:Boolean = false) : ValidationResultEvent
  193.       {
  194.          if(param1 == null)
  195.          {
  196.             param1 = getValueFromSource();
  197.          }
  198.          if(isRealValue(param1) || required)
  199.          {
  200.             return processValidation(param1,param2);
  201.          }
  202.          return new ValidationResultEvent(ValidationResultEvent.VALID);
  203.       }
  204.       
  205.       public function get source() : Object
  206.       {
  207.          return _source;
  208.       }
  209.       
  210.       public function set property(param1:String) : void
  211.       {
  212.          _property = param1;
  213.       }
  214.       
  215.       public function get requiredFieldError() : String
  216.       {
  217.          return _requiredFieldError;
  218.       }
  219.       
  220.       protected function handleResults(param1:Array) : ValidationResultEvent
  221.       {
  222.          var _loc2_:ValidationResultEvent = null;
  223.          var _loc3_:Object = null;
  224.          var _loc4_:String = null;
  225.          var _loc5_:int = 0;
  226.          var _loc6_:int = 0;
  227.          if(param1.length > 0)
  228.          {
  229.             _loc2_ = new ValidationResultEvent(ValidationResultEvent.INVALID);
  230.             _loc2_.results = param1;
  231.             if(subFields.length > 0)
  232.             {
  233.                _loc3_ = {};
  234.                _loc5_ = int(param1.length);
  235.                _loc6_ = 0;
  236.                while(_loc6_ < _loc5_)
  237.                {
  238.                   _loc4_ = param1[_loc6_].subField;
  239.                   if(_loc4_)
  240.                   {
  241.                      _loc3_[_loc4_] = true;
  242.                   }
  243.                   _loc6_++;
  244.                }
  245.                _loc5_ = int(subFields.length);
  246.                _loc6_ = 0;
  247.                while(_loc6_ < _loc5_)
  248.                {
  249.                   if(!_loc3_[subFields[_loc6_]])
  250.                   {
  251.                      param1.push(new ValidationResult(false,subFields[_loc6_]));
  252.                   }
  253.                   _loc6_++;
  254.                }
  255.             }
  256.          }
  257.          else
  258.          {
  259.             _loc2_ = new ValidationResultEvent(ValidationResultEvent.VALID);
  260.          }
  261.          return _loc2_;
  262.       }
  263.       
  264.       public function get listener() : Object
  265.       {
  266.          return _listener;
  267.       }
  268.       
  269.       public function get trigger() : IEventDispatcher
  270.       {
  271.          return _trigger;
  272.       }
  273.       
  274.       public function set source(param1:Object) : void
  275.       {
  276.          var _loc2_:String = null;
  277.          if(_source == param1)
  278.          {
  279.             return;
  280.          }
  281.          if(param1 is String)
  282.          {
  283.             _loc2_ = resourceManager.getString("validators","SAttribute",[param1]);
  284.             throw new Error(_loc2_);
  285.          }
  286.          removeTriggerHandler();
  287.          removeListenerHandler();
  288.          _source = param1;
  289.          addTriggerHandler();
  290.          addListenerHandler();
  291.       }
  292.       
  293.       [Bindable("unused")]
  294.       protected function get resourceManager() : IResourceManager
  295.       {
  296.          return _resourceManager;
  297.       }
  298.       
  299.       public function get enabled() : Boolean
  300.       {
  301.          return _enabled;
  302.       }
  303.       
  304.       private function processValidation(param1:Object, param2:Boolean) : ValidationResultEvent
  305.       {
  306.          var _loc3_:ValidationResultEvent = null;
  307.          var _loc4_:Array = null;
  308.          if(_enabled)
  309.          {
  310.             _loc4_ = doValidation(param1);
  311.             _loc3_ = handleResults(_loc4_);
  312.          }
  313.          else
  314.          {
  315.             param2 = true;
  316.          }
  317.          if(!param2)
  318.          {
  319.             dispatchEvent(_loc3_);
  320.          }
  321.          return _loc3_;
  322.       }
  323.       
  324.       public function get triggerEvent() : String
  325.       {
  326.          return _triggerEvent;
  327.       }
  328.       
  329.       protected function get actualTrigger() : IEventDispatcher
  330.       {
  331.          if(_trigger)
  332.          {
  333.             return _trigger;
  334.          }
  335.          if(_source)
  336.          {
  337.             return _source as IEventDispatcher;
  338.          }
  339.          return null;
  340.       }
  341.       
  342.       protected function resourcesChanged() : void
  343.       {
  344.          requiredFieldError = requiredFieldErrorOverride;
  345.       }
  346.       
  347.       protected function get actualListeners() : Array
  348.       {
  349.          var _loc1_:Array = [];
  350.          if(_listener)
  351.          {
  352.             _loc1_.push(_listener);
  353.          }
  354.          else if(_source)
  355.          {
  356.             _loc1_.push(_source);
  357.          }
  358.          return _loc1_;
  359.       }
  360.       
  361.       protected function removeListenerHandler() : void
  362.       {
  363.          var _loc1_:Object = null;
  364.          var _loc2_:Array = actualListeners;
  365.          var _loc3_:int = int(_loc2_.length);
  366.          var _loc4_:int = 0;
  367.          while(_loc4_ < _loc3_)
  368.          {
  369.             _loc1_ = _loc2_[_loc4_];
  370.             if(_loc1_ is IValidatorListener)
  371.             {
  372.                removeEventListener(ValidationResultEvent.VALID,IValidatorListener(_loc1_).validationResultHandler);
  373.                removeEventListener(ValidationResultEvent.INVALID,IValidatorListener(_loc1_).validationResultHandler);
  374.             }
  375.             _loc4_++;
  376.          }
  377.       }
  378.       
  379.       public function initialized(param1:Object, param2:String) : void
  380.       {
  381.          this.document = param1;
  382.       }
  383.       
  384.       public function get property() : String
  385.       {
  386.          return _property;
  387.       }
  388.       
  389.       public function set requiredFieldError(param1:String) : void
  390.       {
  391.          requiredFieldErrorOverride = param1;
  392.          _requiredFieldError = param1 != null ? param1 : resourceManager.getString("validators","requiredFieldError");
  393.       }
  394.       
  395.       private function validateRequired(param1:Object) : ValidationResult
  396.       {
  397.          var _loc2_:String = null;
  398.          if(required)
  399.          {
  400.             _loc2_ = param1 != null ? String(param1) : "";
  401.             _loc2_ = trimString(_loc2_);
  402.             if(_loc2_.length == 0)
  403.             {
  404.                return new ValidationResult(true,"","requiredField",requiredFieldError);
  405.             }
  406.          }
  407.          return null;
  408.       }
  409.       
  410.       protected function doValidation(param1:Object) : Array
  411.       {
  412.          var _loc2_:Array = [];
  413.          var _loc3_:ValidationResult = validateRequired(param1);
  414.          if(_loc3_)
  415.          {
  416.             _loc2_.push(_loc3_);
  417.          }
  418.          return _loc2_;
  419.       }
  420.       
  421.       public function set listener(param1:Object) : void
  422.       {
  423.          removeListenerHandler();
  424.          _listener = param1;
  425.          addListenerHandler();
  426.       }
  427.       
  428.       protected function isRealValue(param1:Object) : Boolean
  429.       {
  430.          return param1 != null;
  431.       }
  432.       
  433.       public function set trigger(param1:IEventDispatcher) : void
  434.       {
  435.          removeTriggerHandler();
  436.          _trigger = param1;
  437.          addTriggerHandler();
  438.       }
  439.       
  440.       private function addTriggerHandler() : void
  441.       {
  442.          if(actualTrigger)
  443.          {
  444.             actualTrigger.addEventListener(_triggerEvent,triggerHandler);
  445.          }
  446.       }
  447.       
  448.       private function resourceManager_changeHandler(param1:Event) : void
  449.       {
  450.          resourcesChanged();
  451.       }
  452.    }
  453. }
  454.  
  455.