home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / collections / ArrayList.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  10.7 KB  |  347 lines
  1. package mx.collections
  2. {
  3.    import flash.events.EventDispatcher;
  4.    import flash.events.IEventDispatcher;
  5.    import flash.utils.IDataInput;
  6.    import flash.utils.IDataOutput;
  7.    import flash.utils.IExternalizable;
  8.    import flash.utils.getQualifiedClassName;
  9.    import mx.core.IPropertyChangeNotifier;
  10.    import mx.core.mx_internal;
  11.    import mx.events.CollectionEvent;
  12.    import mx.events.CollectionEventKind;
  13.    import mx.events.PropertyChangeEvent;
  14.    import mx.events.PropertyChangeEventKind;
  15.    import mx.resources.IResourceManager;
  16.    import mx.resources.ResourceManager;
  17.    import mx.utils.ArrayUtil;
  18.    import mx.utils.UIDUtil;
  19.    
  20.    use namespace mx_internal;
  21.    
  22.    public class ArrayList extends EventDispatcher implements IList, IExternalizable, IPropertyChangeNotifier
  23.    {
  24.       mx_internal static const VERSION:String = "3.5.0.12683";
  25.       
  26.       private var _source:Array;
  27.       
  28.       private var _dispatchEvents:int = 0;
  29.       
  30.       private var _uid:String;
  31.       
  32.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  33.       
  34.       public function ArrayList(param1:Array = null)
  35.       {
  36.          super();
  37.          disableEvents();
  38.          this.source = param1;
  39.          enableEvents();
  40.          _uid = UIDUtil.createUID();
  41.       }
  42.       
  43.       public function addAll(param1:IList) : void
  44.       {
  45.          addAllAt(param1,length);
  46.       }
  47.       
  48.       public function readExternal(param1:IDataInput) : void
  49.       {
  50.          source = param1.readObject();
  51.       }
  52.       
  53.       private function internalDispatchEvent(param1:String, param2:Object = null, param3:int = -1) : void
  54.       {
  55.          var _loc4_:CollectionEvent = null;
  56.          var _loc5_:PropertyChangeEvent = null;
  57.          if(_dispatchEvents == 0)
  58.          {
  59.             if(hasEventListener(CollectionEvent.COLLECTION_CHANGE))
  60.             {
  61.                _loc4_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  62.                _loc4_.kind = param1;
  63.                _loc4_.items.push(param2);
  64.                _loc4_.location = param3;
  65.                dispatchEvent(_loc4_);
  66.             }
  67.             if(hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE) && (param1 == CollectionEventKind.ADD || param1 == CollectionEventKind.REMOVE))
  68.             {
  69.                _loc5_ = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE);
  70.                _loc5_.property = param3;
  71.                if(param1 == CollectionEventKind.ADD)
  72.                {
  73.                   _loc5_.newValue = param2;
  74.                }
  75.                else
  76.                {
  77.                   _loc5_.oldValue = param2;
  78.                }
  79.                dispatchEvent(_loc5_);
  80.             }
  81.          }
  82.       }
  83.       
  84.       public function removeAll() : void
  85.       {
  86.          var _loc1_:int = 0;
  87.          var _loc2_:int = 0;
  88.          if(length > 0)
  89.          {
  90.             _loc1_ = length;
  91.             _loc2_ = 0;
  92.             while(_loc2_ < _loc1_)
  93.             {
  94.                stopTrackUpdates(source[_loc2_]);
  95.                _loc2_++;
  96.             }
  97.             source.splice(0,length);
  98.             internalDispatchEvent(CollectionEventKind.RESET);
  99.          }
  100.       }
  101.       
  102.       public function getItemIndex(param1:Object) : int
  103.       {
  104.          return ArrayUtil.getItemIndex(param1,source);
  105.       }
  106.       
  107.       public function removeItemAt(param1:int) : Object
  108.       {
  109.          var _loc3_:String = null;
  110.          if(param1 < 0 || param1 >= length)
  111.          {
  112.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  113.             throw new RangeError(_loc3_);
  114.          }
  115.          var _loc2_:Object = source.splice(param1,1)[0];
  116.          stopTrackUpdates(_loc2_);
  117.          internalDispatchEvent(CollectionEventKind.REMOVE,_loc2_,param1);
  118.          return _loc2_;
  119.       }
  120.       
  121.       public function addAllAt(param1:IList, param2:int) : void
  122.       {
  123.          var _loc3_:int = param1.length;
  124.          var _loc4_:int = 0;
  125.          while(_loc4_ < _loc3_)
  126.          {
  127.             this.addItemAt(param1.getItemAt(_loc4_),_loc4_ + param2);
  128.             _loc4_++;
  129.          }
  130.       }
  131.       
  132.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  133.       {
  134.          var _loc5_:PropertyChangeEvent = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE);
  135.          _loc5_.kind = PropertyChangeEventKind.UPDATE;
  136.          _loc5_.source = param1;
  137.          _loc5_.property = param2;
  138.          _loc5_.oldValue = param3;
  139.          _loc5_.newValue = param4;
  140.          itemUpdateHandler(_loc5_);
  141.       }
  142.       
  143.       public function get uid() : String
  144.       {
  145.          return _uid;
  146.       }
  147.       
  148.       public function writeExternal(param1:IDataOutput) : void
  149.       {
  150.          param1.writeObject(_source);
  151.       }
  152.       
  153.       public function addItem(param1:Object) : void
  154.       {
  155.          addItemAt(param1,length);
  156.       }
  157.       
  158.       public function toArray() : Array
  159.       {
  160.          return source.concat();
  161.       }
  162.       
  163.       public function get source() : Array
  164.       {
  165.          return _source;
  166.       }
  167.       
  168.       public function getItemAt(param1:int, param2:int = 0) : Object
  169.       {
  170.          var _loc3_:String = null;
  171.          if(param1 < 0 || param1 >= length)
  172.          {
  173.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  174.             throw new RangeError(_loc3_);
  175.          }
  176.          return source[param1];
  177.       }
  178.       
  179.       public function set uid(param1:String) : void
  180.       {
  181.          _uid = param1;
  182.       }
  183.       
  184.       public function setItemAt(param1:Object, param2:int) : Object
  185.       {
  186.          var _loc4_:String = null;
  187.          var _loc5_:Boolean = false;
  188.          var _loc6_:Boolean = false;
  189.          var _loc7_:PropertyChangeEvent = null;
  190.          var _loc8_:CollectionEvent = null;
  191.          if(param2 < 0 || param2 >= length)
  192.          {
  193.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  194.             throw new RangeError(_loc4_);
  195.          }
  196.          var _loc3_:Object = source[param2];
  197.          source[param2] = param1;
  198.          stopTrackUpdates(_loc3_);
  199.          startTrackUpdates(param1);
  200.          if(_dispatchEvents == 0)
  201.          {
  202.             _loc5_ = hasEventListener(CollectionEvent.COLLECTION_CHANGE);
  203.             _loc6_ = hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE);
  204.             if(_loc5_ || _loc6_)
  205.             {
  206.                _loc7_ = new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE);
  207.                _loc7_.kind = PropertyChangeEventKind.UPDATE;
  208.                _loc7_.oldValue = _loc3_;
  209.                _loc7_.newValue = param1;
  210.                _loc7_.property = param2;
  211.             }
  212.             if(_loc5_)
  213.             {
  214.                _loc8_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  215.                _loc8_.kind = CollectionEventKind.REPLACE;
  216.                _loc8_.location = param2;
  217.                _loc8_.items.push(_loc7_);
  218.                dispatchEvent(_loc8_);
  219.             }
  220.             if(_loc6_)
  221.             {
  222.                dispatchEvent(_loc7_);
  223.             }
  224.          }
  225.          return _loc3_;
  226.       }
  227.       
  228.       public function get length() : int
  229.       {
  230.          if(source)
  231.          {
  232.             return source.length;
  233.          }
  234.          return 0;
  235.       }
  236.       
  237.       private function disableEvents() : void
  238.       {
  239.          --_dispatchEvents;
  240.       }
  241.       
  242.       protected function itemUpdateHandler(param1:PropertyChangeEvent) : void
  243.       {
  244.          var _loc2_:PropertyChangeEvent = null;
  245.          var _loc3_:uint = 0;
  246.          internalDispatchEvent(CollectionEventKind.UPDATE,param1);
  247.          if(_dispatchEvents == 0 && hasEventListener(PropertyChangeEvent.PROPERTY_CHANGE))
  248.          {
  249.             _loc2_ = PropertyChangeEvent(param1.clone());
  250.             _loc3_ = uint(getItemIndex(param1.target));
  251.             _loc2_.property = _loc3_.toString() + "." + param1.property;
  252.             dispatchEvent(_loc2_);
  253.          }
  254.       }
  255.       
  256.       public function addItemAt(param1:Object, param2:int) : void
  257.       {
  258.          var _loc3_:String = null;
  259.          if(param2 < 0 || param2 > length)
  260.          {
  261.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param2]);
  262.             throw new RangeError(_loc3_);
  263.          }
  264.          source.splice(param2,0,param1);
  265.          startTrackUpdates(param1);
  266.          internalDispatchEvent(CollectionEventKind.ADD,param1,param2);
  267.       }
  268.       
  269.       public function removeItem(param1:Object) : Boolean
  270.       {
  271.          var _loc2_:int = getItemIndex(param1);
  272.          var _loc3_:* = _loc2_ >= 0;
  273.          if(_loc3_)
  274.          {
  275.             removeItemAt(_loc2_);
  276.          }
  277.          return _loc3_;
  278.       }
  279.       
  280.       protected function stopTrackUpdates(param1:Object) : void
  281.       {
  282.          if(Boolean(param1) && param1 is IEventDispatcher)
  283.          {
  284.             IEventDispatcher(param1).removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE,itemUpdateHandler);
  285.          }
  286.       }
  287.       
  288.       protected function startTrackUpdates(param1:Object) : void
  289.       {
  290.          if(Boolean(param1) && param1 is IEventDispatcher)
  291.          {
  292.             IEventDispatcher(param1).addEventListener(PropertyChangeEvent.PROPERTY_CHANGE,itemUpdateHandler,false,0,true);
  293.          }
  294.       }
  295.       
  296.       override public function toString() : String
  297.       {
  298.          if(source)
  299.          {
  300.             return source.toString();
  301.          }
  302.          return getQualifiedClassName(this);
  303.       }
  304.       
  305.       private function enableEvents() : void
  306.       {
  307.          ++_dispatchEvents;
  308.          if(_dispatchEvents > 0)
  309.          {
  310.             _dispatchEvents = 0;
  311.          }
  312.       }
  313.       
  314.       public function set source(param1:Array) : void
  315.       {
  316.          var _loc2_:int = 0;
  317.          var _loc3_:int = 0;
  318.          var _loc4_:CollectionEvent = null;
  319.          if(Boolean(_source) && Boolean(_source.length))
  320.          {
  321.             _loc3_ = int(_source.length);
  322.             _loc2_ = 0;
  323.             while(_loc2_ < _loc3_)
  324.             {
  325.                stopTrackUpdates(_source[_loc2_]);
  326.                _loc2_++;
  327.             }
  328.          }
  329.          _source = !!param1 ? param1 : [];
  330.          _loc3_ = int(_source.length);
  331.          _loc2_ = 0;
  332.          while(_loc2_ < _loc3_)
  333.          {
  334.             startTrackUpdates(_source[_loc2_]);
  335.             _loc2_++;
  336.          }
  337.          if(_dispatchEvents == 0)
  338.          {
  339.             _loc4_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  340.             _loc4_.kind = CollectionEventKind.RESET;
  341.             dispatchEvent(_loc4_);
  342.          }
  343.       }
  344.    }
  345. }
  346.  
  347.