home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / collections / ListCollectionView.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  43.8 KB  |  1,541 lines
  1. package mx.collections
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.Proxy;
  6.    import flash.utils.flash_proxy;
  7.    import flash.utils.getQualifiedClassName;
  8.    import mx.collections.errors.CollectionViewError;
  9.    import mx.collections.errors.ItemPendingError;
  10.    import mx.collections.errors.SortError;
  11.    import mx.core.IMXMLObject;
  12.    import mx.core.mx_internal;
  13.    import mx.events.CollectionEvent;
  14.    import mx.events.CollectionEventKind;
  15.    import mx.events.PropertyChangeEvent;
  16.    import mx.resources.IResourceManager;
  17.    import mx.resources.ResourceManager;
  18.    import mx.utils.ObjectUtil;
  19.    
  20.    use namespace mx_internal;
  21.    use namespace flash_proxy;
  22.    
  23.    public class ListCollectionView extends Proxy implements ICollectionView, IList, IMXMLObject
  24.    {
  25.       mx_internal static const VERSION:String = "3.5.0.12683";
  26.       
  27.       private var autoUpdateCounter:int;
  28.       
  29.       private var _list:IList;
  30.       
  31.       private var _filterFunction:Function;
  32.       
  33.       protected var localIndex:Array;
  34.       
  35.       mx_internal var dispatchResetEvent:Boolean = true;
  36.       
  37.       private var pendingUpdates:Array;
  38.       
  39.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  40.       
  41.       private var eventDispatcher:EventDispatcher;
  42.       
  43.       private var revision:int;
  44.       
  45.       private var _sort:Sort;
  46.       
  47.       public function ListCollectionView(param1:IList = null)
  48.       {
  49.          super();
  50.          eventDispatcher = new EventDispatcher(this);
  51.          this.list = param1;
  52.       }
  53.       
  54.       private function handlePendingUpdates() : void
  55.       {
  56.          var _loc1_:Array = null;
  57.          var _loc2_:CollectionEvent = null;
  58.          var _loc3_:int = 0;
  59.          var _loc4_:CollectionEvent = null;
  60.          var _loc5_:int = 0;
  61.          if(pendingUpdates)
  62.          {
  63.             _loc1_ = pendingUpdates;
  64.             pendingUpdates = null;
  65.             _loc3_ = 0;
  66.             while(_loc3_ < _loc1_.length)
  67.             {
  68.                _loc4_ = _loc1_[_loc3_];
  69.                if(_loc4_.kind == CollectionEventKind.UPDATE)
  70.                {
  71.                   if(!_loc2_)
  72.                   {
  73.                      _loc2_ = _loc4_;
  74.                   }
  75.                   else
  76.                   {
  77.                      _loc5_ = 0;
  78.                      while(_loc5_ < _loc4_.items.length)
  79.                      {
  80.                         _loc2_.items.push(_loc4_.items[_loc5_]);
  81.                         _loc5_++;
  82.                      }
  83.                   }
  84.                }
  85.                else
  86.                {
  87.                   listChangeHandler(_loc4_);
  88.                }
  89.                _loc3_++;
  90.             }
  91.             if(_loc2_)
  92.             {
  93.                listChangeHandler(_loc2_);
  94.             }
  95.          }
  96.       }
  97.       
  98.       private function replaceItemsInView(param1:Array, param2:int, param3:Boolean = true) : void
  99.       {
  100.          var _loc4_:int = 0;
  101.          var _loc5_:Array = null;
  102.          var _loc6_:Array = null;
  103.          var _loc7_:int = 0;
  104.          var _loc8_:PropertyChangeEvent = null;
  105.          var _loc9_:CollectionEvent = null;
  106.          if(localIndex)
  107.          {
  108.             _loc4_ = int(param1.length);
  109.             _loc5_ = [];
  110.             _loc6_ = [];
  111.             _loc7_ = 0;
  112.             while(_loc7_ < _loc4_)
  113.             {
  114.                _loc8_ = param1[_loc7_];
  115.                _loc5_.push(_loc8_.oldValue);
  116.                _loc6_.push(_loc8_.newValue);
  117.                _loc7_++;
  118.             }
  119.             removeItemsFromView(_loc5_,param2,param3);
  120.             addItemsToView(_loc6_,param2,param3);
  121.          }
  122.          else
  123.          {
  124.             _loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  125.             _loc9_.kind = CollectionEventKind.REPLACE;
  126.             _loc9_.location = param2;
  127.             _loc9_.items = param1;
  128.             dispatchEvent(_loc9_);
  129.          }
  130.       }
  131.       
  132.       private function getFilteredItemIndex(param1:Object) : int
  133.       {
  134.          var _loc4_:Object = null;
  135.          var _loc5_:int = 0;
  136.          var _loc6_:int = 0;
  137.          var _loc2_:int = list.getItemIndex(param1);
  138.          if(_loc2_ == 0)
  139.          {
  140.             return 0;
  141.          }
  142.          var _loc3_:int = _loc2_ - 1;
  143.          while(_loc3_ >= 0)
  144.          {
  145.             _loc4_ = list.getItemAt(_loc3_);
  146.             if(filterFunction(_loc4_))
  147.             {
  148.                _loc5_ = int(localIndex.length);
  149.                _loc6_ = 0;
  150.                while(_loc6_ < _loc5_)
  151.                {
  152.                   if(localIndex[_loc6_] == _loc4_)
  153.                   {
  154.                      return _loc6_ + 1;
  155.                   }
  156.                   _loc6_++;
  157.                }
  158.             }
  159.             _loc3_--;
  160.          }
  161.          return 0;
  162.       }
  163.       
  164.       public function willTrigger(param1:String) : Boolean
  165.       {
  166.          return eventDispatcher.willTrigger(param1);
  167.       }
  168.       
  169.       mx_internal function findItem(param1:Object, param2:String, param3:Boolean = false) : int
  170.       {
  171.          var _loc4_:String = null;
  172.          if(!sort)
  173.          {
  174.             _loc4_ = resourceManager.getString("collections","itemNotFound");
  175.             throw new CollectionViewError(_loc4_);
  176.          }
  177.          if(localIndex.length == 0)
  178.          {
  179.             return param3 ? 0 : -1;
  180.          }
  181.          return sort.findItem(localIndex,param1,param2,param3);
  182.       }
  183.       
  184.       public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  185.       {
  186.          eventDispatcher.removeEventListener(param1,param2,param3);
  187.       }
  188.       
  189.       override flash_proxy function nextName(param1:int) : String
  190.       {
  191.          return (param1 - 1).toString();
  192.       }
  193.       
  194.       public function removeAll() : void
  195.       {
  196.          var _loc2_:int = 0;
  197.          var _loc1_:int = length;
  198.          if(_loc1_ > 0)
  199.          {
  200.             if(localIndex)
  201.             {
  202.                _loc2_ = _loc1_ - 1;
  203.                while(_loc2_ >= 0)
  204.                {
  205.                   removeItemAt(_loc2_);
  206.                   _loc2_--;
  207.                }
  208.             }
  209.             else
  210.             {
  211.                list.removeAll();
  212.             }
  213.          }
  214.       }
  215.       
  216.       override flash_proxy function hasProperty(param1:*) : Boolean
  217.       {
  218.          var index:int;
  219.          var n:Number = NaN;
  220.          var name:* = param1;
  221.          if(name is QName)
  222.          {
  223.             name = name.localName;
  224.          }
  225.          index = -1;
  226.          try
  227.          {
  228.             n = parseInt(String(name));
  229.             if(!isNaN(n))
  230.             {
  231.                index = int(n);
  232.             }
  233.          }
  234.          catch(e:Error)
  235.          {
  236.          }
  237.          if(index == -1)
  238.          {
  239.             return false;
  240.          }
  241.          return index >= 0 && index < length;
  242.       }
  243.       
  244.       public function addAllAt(param1:IList, param2:int) : void
  245.       {
  246.          var _loc3_:int = param1.length;
  247.          var _loc4_:int = 0;
  248.          while(_loc4_ < _loc3_)
  249.          {
  250.             this.addItemAt(param1.getItemAt(_loc4_),_loc4_ + param2);
  251.             _loc4_++;
  252.          }
  253.       }
  254.       
  255.       [Bindable("collectionChange")]
  256.       public function getItemAt(param1:int, param2:int = 0) : Object
  257.       {
  258.          var _loc3_:String = null;
  259.          if(param1 < 0 || param1 >= length)
  260.          {
  261.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  262.             throw new RangeError(_loc3_);
  263.          }
  264.          if(localIndex)
  265.          {
  266.             return localIndex[param1];
  267.          }
  268.          if(list)
  269.          {
  270.             return list.getItemAt(param1,param2);
  271.          }
  272.          return null;
  273.       }
  274.       
  275.       private function moveItemInView(param1:Object, param2:Boolean = true, param3:Array = null) : void
  276.       {
  277.          var _loc4_:int = 0;
  278.          var _loc5_:int = 0;
  279.          var _loc6_:int = 0;
  280.          var _loc7_:CollectionEvent = null;
  281.          if(localIndex)
  282.          {
  283.             _loc4_ = -1;
  284.             _loc5_ = 0;
  285.             while(_loc5_ < localIndex.length)
  286.             {
  287.                if(localIndex[_loc5_] == param1)
  288.                {
  289.                   _loc4_ = _loc5_;
  290.                   break;
  291.                }
  292.                _loc5_++;
  293.             }
  294.             if(_loc4_ > -1)
  295.             {
  296.                localIndex.splice(_loc4_,1);
  297.             }
  298.             _loc6_ = addItemsToView([param1],_loc4_,false);
  299.             if(param2)
  300.             {
  301.                _loc7_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  302.                _loc7_.items.push(param1);
  303.                if(param3 && _loc6_ == _loc4_ && _loc6_ > -1)
  304.                {
  305.                   param3.push(param1);
  306.                   return;
  307.                }
  308.                if(_loc6_ > -1 && _loc4_ > -1)
  309.                {
  310.                   _loc7_.kind = CollectionEventKind.MOVE;
  311.                   _loc7_.location = _loc6_;
  312.                   _loc7_.oldLocation = _loc4_;
  313.                }
  314.                else if(_loc6_ > -1)
  315.                {
  316.                   _loc7_.kind = CollectionEventKind.ADD;
  317.                   _loc7_.location = _loc6_;
  318.                }
  319.                else if(_loc4_ > -1)
  320.                {
  321.                   _loc7_.kind = CollectionEventKind.REMOVE;
  322.                   _loc7_.location = _loc4_;
  323.                }
  324.                else
  325.                {
  326.                   param2 = false;
  327.                }
  328.                if(param2)
  329.                {
  330.                   dispatchEvent(_loc7_);
  331.                }
  332.             }
  333.          }
  334.       }
  335.       
  336.       public function contains(param1:Object) : Boolean
  337.       {
  338.          return getItemIndex(param1) != -1;
  339.       }
  340.       
  341.       [Bindable("sortChanged")]
  342.       public function get sort() : Sort
  343.       {
  344.          return _sort;
  345.       }
  346.       
  347.       private function removeItemsFromView(param1:Array, param2:int, param3:Boolean = true) : void
  348.       {
  349.          var _loc6_:int = 0;
  350.          var _loc7_:Object = null;
  351.          var _loc8_:int = 0;
  352.          var _loc9_:CollectionEvent = null;
  353.          var _loc4_:Array = !!localIndex ? [] : param1;
  354.          var _loc5_:int = param2;
  355.          if(localIndex)
  356.          {
  357.             _loc6_ = 0;
  358.             while(_loc6_ < param1.length)
  359.             {
  360.                _loc7_ = param1[_loc6_];
  361.                _loc8_ = getItemIndex(_loc7_);
  362.                if(_loc8_ > -1)
  363.                {
  364.                   localIndex.splice(_loc8_,1);
  365.                   _loc4_.push(_loc7_);
  366.                   _loc5_ = _loc8_;
  367.                }
  368.                _loc6_++;
  369.             }
  370.          }
  371.          if(param3 && _loc4_.length > 0)
  372.          {
  373.             _loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  374.             _loc9_.kind = CollectionEventKind.REMOVE;
  375.             _loc9_.location = !localIndex || _loc4_.length == 1 ? _loc5_ : -1;
  376.             _loc9_.items = _loc4_;
  377.             dispatchEvent(_loc9_);
  378.          }
  379.       }
  380.       
  381.       [Bindable("listChanged")]
  382.       public function get list() : IList
  383.       {
  384.          return _list;
  385.       }
  386.       
  387.       public function addItemAt(param1:Object, param2:int) : void
  388.       {
  389.          var _loc4_:String = null;
  390.          if(param2 < 0 || !list || param2 > length)
  391.          {
  392.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  393.             throw new RangeError(_loc4_);
  394.          }
  395.          var _loc3_:int = param2;
  396.          if(Boolean(localIndex) && Boolean(sort))
  397.          {
  398.             _loc3_ = list.length;
  399.          }
  400.          else if(Boolean(localIndex) && filterFunction != null)
  401.          {
  402.             if(_loc3_ == localIndex.length)
  403.             {
  404.                _loc3_ = list.length;
  405.             }
  406.             else
  407.             {
  408.                _loc3_ = list.getItemIndex(localIndex[param2]);
  409.             }
  410.          }
  411.          list.addItemAt(param1,_loc3_);
  412.       }
  413.       
  414.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  415.       {
  416.          list.itemUpdated(param1,param2,param3,param4);
  417.       }
  418.       
  419.       private function populateLocalIndex() : void
  420.       {
  421.          if(list)
  422.          {
  423.             localIndex = list.toArray();
  424.          }
  425.          else
  426.          {
  427.             localIndex = [];
  428.          }
  429.       }
  430.       
  431.       private function handlePropertyChangeEvents(param1:Array) : void
  432.       {
  433.          var _loc3_:Array = null;
  434.          var _loc4_:Object = null;
  435.          var _loc5_:int = 0;
  436.          var _loc6_:Array = null;
  437.          var _loc7_:int = 0;
  438.          var _loc8_:PropertyChangeEvent = null;
  439.          var _loc9_:Object = null;
  440.          var _loc10_:* = false;
  441.          var _loc11_:int = 0;
  442.          var _loc12_:int = 0;
  443.          var _loc13_:int = 0;
  444.          var _loc14_:int = 0;
  445.          var _loc15_:CollectionEvent = null;
  446.          var _loc2_:Array = param1;
  447.          if(Boolean(sort) || filterFunction != null)
  448.          {
  449.             _loc3_ = [];
  450.             _loc5_ = 0;
  451.             while(_loc5_ < param1.length)
  452.             {
  453.                _loc8_ = param1[_loc5_];
  454.                if(_loc8_.target)
  455.                {
  456.                   _loc9_ = _loc8_.target;
  457.                   _loc10_ = _loc8_.target != _loc8_.source;
  458.                }
  459.                else
  460.                {
  461.                   _loc9_ = _loc8_.source;
  462.                   _loc10_ = false;
  463.                }
  464.                _loc11_ = 0;
  465.                while(_loc11_ < _loc3_.length)
  466.                {
  467.                   if(_loc3_[_loc11_].item == _loc9_)
  468.                   {
  469.                      param1 = _loc3_[_loc11_].events;
  470.                      _loc12_ = int(param1.length);
  471.                      _loc13_ = 0;
  472.                      while(_loc13_ < _loc12_)
  473.                      {
  474.                         if(param1[_loc13_].property != _loc8_.property)
  475.                         {
  476.                            param1.push(_loc8_);
  477.                            break;
  478.                         }
  479.                         _loc13_++;
  480.                      }
  481.                      break;
  482.                   }
  483.                   _loc11_++;
  484.                }
  485.                if(_loc11_ < _loc3_.length)
  486.                {
  487.                   _loc4_ = _loc3_[_loc11_];
  488.                }
  489.                else
  490.                {
  491.                   _loc4_ = {
  492.                      "item":_loc9_,
  493.                      "move":_loc10_,
  494.                      "events":[_loc8_]
  495.                   };
  496.                   _loc3_.push(_loc4_);
  497.                }
  498.                _loc4_.move = _loc4_.move || filterFunction || !_loc8_.property || sort && sort.propertyAffectsSort(String(_loc8_.property));
  499.                _loc5_++;
  500.             }
  501.             _loc2_ = [];
  502.             _loc5_ = 0;
  503.             while(_loc5_ < _loc3_.length)
  504.             {
  505.                _loc4_ = _loc3_[_loc5_];
  506.                if(_loc4_.move)
  507.                {
  508.                   moveItemInView(_loc4_.item,_loc4_.item,_loc2_);
  509.                }
  510.                else
  511.                {
  512.                   _loc2_.push(_loc4_.item);
  513.                }
  514.                _loc5_++;
  515.             }
  516.             _loc6_ = [];
  517.             _loc7_ = 0;
  518.             while(_loc7_ < _loc2_.length)
  519.             {
  520.                _loc14_ = 0;
  521.                while(_loc14_ < _loc3_.length)
  522.                {
  523.                   if(_loc2_[_loc7_] == _loc3_[_loc14_].item)
  524.                   {
  525.                      _loc6_ = _loc6_.concat(_loc3_[_loc14_].events);
  526.                   }
  527.                   _loc14_++;
  528.                }
  529.                _loc7_++;
  530.             }
  531.             _loc2_ = _loc6_;
  532.          }
  533.          if(_loc2_.length > 0)
  534.          {
  535.             _loc15_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  536.             _loc15_.kind = CollectionEventKind.UPDATE;
  537.             _loc15_.items = _loc2_;
  538.             dispatchEvent(_loc15_);
  539.          }
  540.       }
  541.       
  542.       public function set sort(param1:Sort) : void
  543.       {
  544.          _sort = param1;
  545.          dispatchEvent(new Event("sortChanged"));
  546.       }
  547.       
  548.       override flash_proxy function nextValue(param1:int) : *
  549.       {
  550.          return getItemAt(param1 - 1);
  551.       }
  552.       
  553.       public function setItemAt(param1:Object, param2:int) : Object
  554.       {
  555.          var _loc4_:String = null;
  556.          var _loc5_:Object = null;
  557.          if(param2 < 0 || !list || param2 >= length)
  558.          {
  559.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  560.             throw new RangeError(_loc4_);
  561.          }
  562.          var _loc3_:int = param2;
  563.          if(localIndex)
  564.          {
  565.             if(param2 > localIndex.length)
  566.             {
  567.                _loc3_ = list.length;
  568.             }
  569.             else
  570.             {
  571.                _loc5_ = localIndex[param2];
  572.                _loc3_ = list.getItemIndex(_loc5_);
  573.             }
  574.          }
  575.          return list.setItemAt(param1,_loc3_);
  576.       }
  577.       
  578.       mx_internal function getBookmark(param1:int) : ListCollectionViewBookmark
  579.       {
  580.          var value:Object = null;
  581.          var message:String = null;
  582.          var index:int = param1;
  583.          if(index < 0 || index > length)
  584.          {
  585.             message = resourceManager.getString("collections","invalidIndex",[index]);
  586.             throw new CollectionViewError(message);
  587.          }
  588.          try
  589.          {
  590.             value = getItemAt(index);
  591.          }
  592.          catch(e:Error)
  593.          {
  594.             value = null;
  595.          }
  596.          return new ListCollectionViewBookmark(value,this,revision,index);
  597.       }
  598.       
  599.       private function addItemsToView(param1:Array, param2:int, param3:Boolean = true) : int
  600.       {
  601.          var _loc7_:int = 0;
  602.          var _loc8_:int = 0;
  603.          var _loc9_:Object = null;
  604.          var _loc10_:String = null;
  605.          var _loc11_:CollectionEvent = null;
  606.          var _loc4_:Array = !!localIndex ? [] : param1;
  607.          var _loc5_:int = param2;
  608.          var _loc6_:Boolean = true;
  609.          if(localIndex)
  610.          {
  611.             _loc7_ = param2;
  612.             _loc8_ = 0;
  613.             while(_loc8_ < param1.length)
  614.             {
  615.                _loc9_ = param1[_loc8_];
  616.                if(filterFunction == null || filterFunction(_loc9_))
  617.                {
  618.                   if(sort)
  619.                   {
  620.                      _loc7_ = mx_internal::findItem(_loc9_,Sort.ANY_INDEX_MODE,true);
  621.                      if(_loc6_)
  622.                      {
  623.                         _loc5_ = _loc7_;
  624.                         _loc6_ = false;
  625.                      }
  626.                   }
  627.                   else
  628.                   {
  629.                      _loc7_ = getFilteredItemIndex(_loc9_);
  630.                      if(_loc6_)
  631.                      {
  632.                         _loc5_ = _loc7_;
  633.                         _loc6_ = false;
  634.                      }
  635.                   }
  636.                   if(sort && sort.unique && sort.compareFunction(_loc9_,localIndex[_loc7_]) == 0)
  637.                   {
  638.                      _loc10_ = resourceManager.getString("collections","incorrectAddition");
  639.                      throw new CollectionViewError(_loc10_);
  640.                   }
  641.                   localIndex.splice(_loc7_++,0,_loc9_);
  642.                   _loc4_.push(_loc9_);
  643.                }
  644.                else
  645.                {
  646.                   _loc5_ = -1;
  647.                }
  648.                _loc8_++;
  649.             }
  650.          }
  651.          if(Boolean(localIndex) && _loc4_.length > 1)
  652.          {
  653.             _loc5_ = -1;
  654.          }
  655.          if(param3 && _loc4_.length > 0)
  656.          {
  657.             _loc11_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  658.             _loc11_.kind = CollectionEventKind.ADD;
  659.             _loc11_.location = _loc5_;
  660.             _loc11_.items = _loc4_;
  661.             dispatchEvent(_loc11_);
  662.          }
  663.          return _loc5_;
  664.       }
  665.       
  666.       public function addAll(param1:IList) : void
  667.       {
  668.          addAllAt(param1,length);
  669.       }
  670.       
  671.       public function set list(param1:IList) : void
  672.       {
  673.          var _loc2_:* = false;
  674.          var _loc3_:* = false;
  675.          if(_list != param1)
  676.          {
  677.             if(_list)
  678.             {
  679.                _list.removeEventListener(CollectionEvent.COLLECTION_CHANGE,listChangeHandler);
  680.                _loc2_ = _list.length > 0;
  681.             }
  682.             _list = param1;
  683.             if(_list)
  684.             {
  685.                _list.addEventListener(CollectionEvent.COLLECTION_CHANGE,listChangeHandler,false,0,true);
  686.                _loc3_ = _list.length > 0;
  687.             }
  688.             if(_loc2_ || _loc3_)
  689.             {
  690.                mx_internal::reset();
  691.             }
  692.             dispatchEvent(new Event("listChanged"));
  693.          }
  694.       }
  695.       
  696.       public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  697.       {
  698.          eventDispatcher.addEventListener(param1,param2,param3,param4,param5);
  699.       }
  700.       
  701.       public function dispatchEvent(param1:Event) : Boolean
  702.       {
  703.          return eventDispatcher.dispatchEvent(param1);
  704.       }
  705.       
  706.       public function getItemIndex(param1:Object) : int
  707.       {
  708.          var _loc2_:int = 0;
  709.          var _loc3_:int = 0;
  710.          var _loc4_:int = 0;
  711.          var _loc5_:int = 0;
  712.          if(sort)
  713.          {
  714.             _loc3_ = sort.findItem(localIndex,param1,Sort.FIRST_INDEX_MODE);
  715.             if(_loc3_ == -1)
  716.             {
  717.                return -1;
  718.             }
  719.             _loc4_ = sort.findItem(localIndex,param1,Sort.LAST_INDEX_MODE);
  720.             _loc2_ = _loc3_;
  721.             while(_loc2_ <= _loc4_)
  722.             {
  723.                if(localIndex[_loc2_] == param1)
  724.                {
  725.                   return _loc2_;
  726.                }
  727.                _loc2_++;
  728.             }
  729.             return -1;
  730.          }
  731.          if(filterFunction != null)
  732.          {
  733.             _loc5_ = int(localIndex.length);
  734.             _loc2_ = 0;
  735.             while(_loc2_ < _loc5_)
  736.             {
  737.                if(localIndex[_loc2_] == param1)
  738.                {
  739.                   return _loc2_;
  740.                }
  741.                _loc2_++;
  742.             }
  743.             return -1;
  744.          }
  745.          return list.getItemIndex(param1);
  746.       }
  747.       
  748.       mx_internal function getLocalItemIndex(param1:Object) : int
  749.       {
  750.          var _loc2_:int = 0;
  751.          var _loc3_:int = int(localIndex.length);
  752.          _loc2_ = 0;
  753.          while(_loc2_ < _loc3_)
  754.          {
  755.             if(localIndex[_loc2_] == param1)
  756.             {
  757.                return _loc2_;
  758.             }
  759.             _loc2_++;
  760.          }
  761.          return -1;
  762.       }
  763.       
  764.       override flash_proxy function getProperty(param1:*) : *
  765.       {
  766.          var index:int;
  767.          var n:Number = NaN;
  768.          var message:String = null;
  769.          var name:* = param1;
  770.          if(name is QName)
  771.          {
  772.             name = name.localName;
  773.          }
  774.          index = -1;
  775.          try
  776.          {
  777.             n = parseInt(String(name));
  778.             if(!isNaN(n))
  779.             {
  780.                index = int(n);
  781.             }
  782.          }
  783.          catch(e:Error)
  784.          {
  785.          }
  786.          if(index == -1)
  787.          {
  788.             message = resourceManager.getString("collections","unknownProperty",[name]);
  789.             throw new Error(message);
  790.          }
  791.          return getItemAt(index);
  792.       }
  793.       
  794.       public function enableAutoUpdate() : void
  795.       {
  796.          if(autoUpdateCounter > 0)
  797.          {
  798.             --autoUpdateCounter;
  799.             if(autoUpdateCounter == 0)
  800.             {
  801.                handlePendingUpdates();
  802.             }
  803.          }
  804.       }
  805.       
  806.       mx_internal function reset() : void
  807.       {
  808.          var _loc1_:CollectionEvent = null;
  809.          internalRefresh(false);
  810.          if(mx_internal::dispatchResetEvent)
  811.          {
  812.             _loc1_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  813.             _loc1_.kind = CollectionEventKind.RESET;
  814.             dispatchEvent(_loc1_);
  815.          }
  816.       }
  817.       
  818.       public function toArray() : Array
  819.       {
  820.          var _loc1_:Array = null;
  821.          if(localIndex)
  822.          {
  823.             _loc1_ = localIndex.concat();
  824.          }
  825.          else
  826.          {
  827.             _loc1_ = list.toArray();
  828.          }
  829.          return _loc1_;
  830.       }
  831.       
  832.       public function removeItemAt(param1:int) : Object
  833.       {
  834.          var _loc3_:String = null;
  835.          var _loc4_:Object = null;
  836.          if(param1 < 0 || param1 >= length)
  837.          {
  838.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  839.             throw new RangeError(_loc3_);
  840.          }
  841.          var _loc2_:int = param1;
  842.          if(localIndex)
  843.          {
  844.             _loc4_ = localIndex[param1];
  845.             _loc2_ = list.getItemIndex(_loc4_);
  846.          }
  847.          return list.removeItemAt(_loc2_);
  848.       }
  849.       
  850.       override flash_proxy function callProperty(param1:*, ... rest) : *
  851.       {
  852.          return null;
  853.       }
  854.       
  855.       public function initialized(param1:Object, param2:String) : void
  856.       {
  857.          refresh();
  858.       }
  859.       
  860.       override flash_proxy function setProperty(param1:*, param2:*) : void
  861.       {
  862.          var index:int;
  863.          var n:Number = NaN;
  864.          var message:String = null;
  865.          var name:* = param1;
  866.          var value:* = param2;
  867.          if(name is QName)
  868.          {
  869.             name = name.localName;
  870.          }
  871.          index = -1;
  872.          try
  873.          {
  874.             n = parseInt(String(name));
  875.             if(!isNaN(n))
  876.             {
  877.                index = int(n);
  878.             }
  879.          }
  880.          catch(e:Error)
  881.          {
  882.          }
  883.          if(index == -1)
  884.          {
  885.             message = resourceManager.getString("collections","unknownProperty",[name]);
  886.             throw new Error(message);
  887.          }
  888.          setItemAt(value,index);
  889.       }
  890.       
  891.       public function addItem(param1:Object) : void
  892.       {
  893.          addItemAt(param1,length);
  894.       }
  895.       
  896.       private function internalRefresh(param1:Boolean) : Boolean
  897.       {
  898.          var tmp:Array = null;
  899.          var len:int = 0;
  900.          var i:int = 0;
  901.          var item:Object = null;
  902.          var refreshEvent:CollectionEvent = null;
  903.          var dispatch:Boolean = param1;
  904.          if(Boolean(sort) || filterFunction != null)
  905.          {
  906.             try
  907.             {
  908.                populateLocalIndex();
  909.             }
  910.             catch(pending:ItemPendingError)
  911.             {
  912.                pending.addResponder(new ItemResponder(function(param1:Object, param2:Object = null):void
  913.                {
  914.                   internalRefresh(dispatch);
  915.                },function(param1:Object, param2:Object = null):void
  916.                {
  917.                }));
  918.                return false;
  919.             }
  920.             if(filterFunction != null)
  921.             {
  922.                tmp = [];
  923.                len = int(localIndex.length);
  924.                i = 0;
  925.                while(i < len)
  926.                {
  927.                   item = localIndex[i];
  928.                   if(filterFunction(item))
  929.                   {
  930.                      tmp.push(item);
  931.                   }
  932.                   i++;
  933.                }
  934.                localIndex = tmp;
  935.             }
  936.             if(sort)
  937.             {
  938.                sort.sort(localIndex);
  939.                dispatch = true;
  940.             }
  941.          }
  942.          else if(localIndex)
  943.          {
  944.             localIndex = null;
  945.          }
  946.          ++revision;
  947.          pendingUpdates = null;
  948.          if(dispatch)
  949.          {
  950.             refreshEvent = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  951.             refreshEvent.kind = CollectionEventKind.REFRESH;
  952.             dispatchEvent(refreshEvent);
  953.          }
  954.          return true;
  955.       }
  956.       
  957.       public function set filterFunction(param1:Function) : void
  958.       {
  959.          _filterFunction = param1;
  960.          dispatchEvent(new Event("filterFunctionChanged"));
  961.       }
  962.       
  963.       mx_internal function getBookmarkIndex(param1:CursorBookmark) : int
  964.       {
  965.          var bm:ListCollectionViewBookmark = null;
  966.          var message:String = null;
  967.          var bookmark:CursorBookmark = param1;
  968.          if(!(bookmark is ListCollectionViewBookmark) || ListCollectionViewBookmark(bookmark).mx_internal::view != this)
  969.          {
  970.             message = resourceManager.getString("collections","bookmarkNotFound");
  971.             throw new CollectionViewError(message);
  972.          }
  973.          bm = ListCollectionViewBookmark(bookmark);
  974.          if(bm.mx_internal::viewRevision != revision)
  975.          {
  976.             if(bm.mx_internal::index < 0 || bm.mx_internal::index >= length || getItemAt(bm.mx_internal::index) != bm.value)
  977.             {
  978.                try
  979.                {
  980.                   bm.mx_internal::index = getItemIndex(bm.value);
  981.                }
  982.                catch(e:SortError)
  983.                {
  984.                   bm.mx_internal::index = mx_internal::getLocalItemIndex(bm.value);
  985.                }
  986.             }
  987.             bm.mx_internal::viewRevision = revision;
  988.          }
  989.          return bm.mx_internal::index;
  990.       }
  991.       
  992.       public function refresh() : Boolean
  993.       {
  994.          return internalRefresh(true);
  995.       }
  996.       
  997.       [Bindable("filterFunctionChanged")]
  998.       public function get filterFunction() : Function
  999.       {
  1000.          return _filterFunction;
  1001.       }
  1002.       
  1003.       public function createCursor() : IViewCursor
  1004.       {
  1005.          return new ListCollectionViewCursor(this);
  1006.       }
  1007.       
  1008.       public function hasEventListener(param1:String) : Boolean
  1009.       {
  1010.          return eventDispatcher.hasEventListener(param1);
  1011.       }
  1012.       
  1013.       [Bindable("collectionChange")]
  1014.       public function get length() : int
  1015.       {
  1016.          if(localIndex)
  1017.          {
  1018.             return localIndex.length;
  1019.          }
  1020.          if(list)
  1021.          {
  1022.             return list.length;
  1023.          }
  1024.          return 0;
  1025.       }
  1026.       
  1027.       override flash_proxy function nextNameIndex(param1:int) : int
  1028.       {
  1029.          return param1 < length ? param1 + 1 : 0;
  1030.       }
  1031.       
  1032.       public function disableAutoUpdate() : void
  1033.       {
  1034.          ++autoUpdateCounter;
  1035.       }
  1036.       
  1037.       public function toString() : String
  1038.       {
  1039.          if(localIndex)
  1040.          {
  1041.             return ObjectUtil.toString(localIndex);
  1042.          }
  1043.          if(Boolean(list) && Boolean(Object(list).toString))
  1044.          {
  1045.             return Object(list).toString();
  1046.          }
  1047.          return getQualifiedClassName(this);
  1048.       }
  1049.       
  1050.       private function listChangeHandler(param1:CollectionEvent) : void
  1051.       {
  1052.          if(autoUpdateCounter > 0)
  1053.          {
  1054.             if(!pendingUpdates)
  1055.             {
  1056.                pendingUpdates = [];
  1057.             }
  1058.             pendingUpdates.push(param1);
  1059.          }
  1060.          else
  1061.          {
  1062.             switch(param1.kind)
  1063.             {
  1064.                case CollectionEventKind.ADD:
  1065.                   addItemsToView(param1.items,param1.location);
  1066.                   break;
  1067.                case CollectionEventKind.RESET:
  1068.                   mx_internal::reset();
  1069.                   break;
  1070.                case CollectionEventKind.REMOVE:
  1071.                   removeItemsFromView(param1.items,param1.location);
  1072.                   break;
  1073.                case CollectionEventKind.REPLACE:
  1074.                   replaceItemsInView(param1.items,param1.location);
  1075.                   break;
  1076.                case CollectionEventKind.UPDATE:
  1077.                   handlePropertyChangeEvents(param1.items);
  1078.                   break;
  1079.                default:
  1080.                   dispatchEvent(param1);
  1081.             }
  1082.          }
  1083.       }
  1084.    }
  1085. }
  1086.  
  1087. import flash.events.EventDispatcher;
  1088. import mx.collections.errors.CollectionViewError;
  1089. import mx.collections.errors.CursorError;
  1090. import mx.collections.errors.ItemPendingError;
  1091. import mx.collections.errors.SortError;
  1092. import mx.core.mx_internal;
  1093. import mx.events.CollectionEvent;
  1094. import mx.events.CollectionEventKind;
  1095. import mx.events.FlexEvent;
  1096. import mx.resources.IResourceManager;
  1097. import mx.resources.ResourceManager;
  1098.  
  1099. use namespace mx_internal;
  1100.  
  1101. class ListCollectionViewBookmark extends CursorBookmark
  1102. {
  1103.    mx_internal var viewRevision:int;
  1104.    
  1105.    mx_internal var index:int;
  1106.    
  1107.    mx_internal var view:ListCollectionView;
  1108.    
  1109.    public function ListCollectionViewBookmark(param1:Object, param2:ListCollectionView, param3:int, param4:int)
  1110.    {
  1111.       super(param1);
  1112.       this.mx_internal::view = param2;
  1113.       this.mx_internal::viewRevision = param3;
  1114.       this.mx_internal::index = param4;
  1115.    }
  1116.    
  1117.    override public function getViewIndex() : int
  1118.    {
  1119.       return mx_internal::view.mx_internal::getBookmarkIndex(this);
  1120.    }
  1121. }
  1122.  
  1123. class ListCollectionViewCursor extends EventDispatcher implements IViewCursor
  1124. {
  1125.    private static const BEFORE_FIRST_INDEX:int = -1;
  1126.    
  1127.    private static const AFTER_LAST_INDEX:int = -2;
  1128.    
  1129.    private var _view:ListCollectionView;
  1130.    
  1131.    private var invalid:Boolean;
  1132.    
  1133.    private var resourceManager:IResourceManager;
  1134.    
  1135.    private var currentIndex:int;
  1136.    
  1137.    private var currentValue:Object;
  1138.    
  1139.    public function ListCollectionViewCursor(param1:ListCollectionView)
  1140.    {
  1141.       var view:ListCollectionView = param1;
  1142.       resourceManager = ResourceManager.getInstance();
  1143.       super();
  1144.       _view = view;
  1145.       _view.addEventListener(CollectionEvent.COLLECTION_CHANGE,collectionEventHandler,false,0,true);
  1146.       currentIndex = view.length > 0 ? 0 : int(AFTER_LAST_INDEX);
  1147.       if(currentIndex == 0)
  1148.       {
  1149.          try
  1150.          {
  1151.             setCurrent(view.getItemAt(0),false);
  1152.          }
  1153.          catch(e:ItemPendingError)
  1154.          {
  1155.             currentIndex = BEFORE_FIRST_INDEX;
  1156.             setCurrent(null,false);
  1157.          }
  1158.       }
  1159.    }
  1160.    
  1161.    public function findAny(param1:Object) : Boolean
  1162.    {
  1163.       var lcView:ListCollectionView;
  1164.       var index:int = 0;
  1165.       var values:Object = param1;
  1166.       checkValid();
  1167.       lcView = ListCollectionView(view);
  1168.       try
  1169.       {
  1170.          index = lcView.mx_internal::findItem(values,Sort.ANY_INDEX_MODE);
  1171.       }
  1172.       catch(e:SortError)
  1173.       {
  1174.          throw new CursorError(e.message);
  1175.       }
  1176.       if(index > -1)
  1177.       {
  1178.          currentIndex = index;
  1179.          setCurrent(lcView.getItemAt(currentIndex));
  1180.       }
  1181.       return index > -1;
  1182.    }
  1183.    
  1184.    public function remove() : Object
  1185.    {
  1186.       var removed:Object;
  1187.       var oldIndex:int = 0;
  1188.       var message:String = null;
  1189.       if(Boolean(beforeFirst) || Boolean(afterLast))
  1190.       {
  1191.          message = resourceManager.getString("collections","invalidRemove");
  1192.          throw new CursorError(message);
  1193.       }
  1194.       oldIndex = int(currentIndex);
  1195.       ++currentIndex;
  1196.       if(currentIndex >= view.length)
  1197.       {
  1198.          currentIndex = AFTER_LAST_INDEX;
  1199.          setCurrent(null);
  1200.       }
  1201.       else
  1202.       {
  1203.          try
  1204.          {
  1205.             setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1206.          }
  1207.          catch(e:ItemPendingError)
  1208.          {
  1209.             setCurrent(null,false);
  1210.             ListCollectionView(view).removeItemAt(oldIndex);
  1211.             throw e;
  1212.          }
  1213.       }
  1214.       removed = ListCollectionView(view).removeItemAt(oldIndex);
  1215.       return removed;
  1216.    }
  1217.    
  1218.    private function setCurrent(param1:Object, param2:Boolean = true) : void
  1219.    {
  1220.       currentValue = param1;
  1221.       if(param2)
  1222.       {
  1223.          dispatchEvent(new FlexEvent(FlexEvent.CURSOR_UPDATE));
  1224.       }
  1225.    }
  1226.    
  1227.    public function seek(param1:CursorBookmark, param2:int = 0, param3:int = 0) : void
  1228.    {
  1229.       var newIndex:int;
  1230.       var newCurrent:Object;
  1231.       var message:String = null;
  1232.       var bookmark:CursorBookmark = param1;
  1233.       var offset:int = param2;
  1234.       var prefetch:int = param3;
  1235.       checkValid();
  1236.       if(view.length == 0)
  1237.       {
  1238.          currentIndex = AFTER_LAST_INDEX;
  1239.          setCurrent(null,false);
  1240.          return;
  1241.       }
  1242.       newIndex = int(currentIndex);
  1243.       if(bookmark == CursorBookmark.FIRST)
  1244.       {
  1245.          newIndex = 0;
  1246.       }
  1247.       else if(bookmark == CursorBookmark.LAST)
  1248.       {
  1249.          newIndex = view.length - 1;
  1250.       }
  1251.       else if(bookmark != CursorBookmark.CURRENT)
  1252.       {
  1253.          try
  1254.          {
  1255.             newIndex = ListCollectionView(view).mx_internal::getBookmarkIndex(bookmark);
  1256.             if(newIndex < 0)
  1257.             {
  1258.                setCurrent(null);
  1259.                message = resourceManager.getString("collections","bookmarkInvalid");
  1260.                throw new CursorError(message);
  1261.             }
  1262.          }
  1263.          catch(bmError:CollectionViewError)
  1264.          {
  1265.             message = resourceManager.getString("collections","bookmarkInvalid");
  1266.             throw new CursorError(message);
  1267.          }
  1268.       }
  1269.       newIndex += offset;
  1270.       newCurrent = null;
  1271.       if(newIndex >= view.length)
  1272.       {
  1273.          currentIndex = AFTER_LAST_INDEX;
  1274.       }
  1275.       else if(newIndex < 0)
  1276.       {
  1277.          currentIndex = BEFORE_FIRST_INDEX;
  1278.       }
  1279.       else
  1280.       {
  1281.          newCurrent = ListCollectionView(view).getItemAt(newIndex,prefetch);
  1282.          currentIndex = newIndex;
  1283.       }
  1284.       setCurrent(newCurrent);
  1285.    }
  1286.    
  1287.    public function insert(param1:Object) : void
  1288.    {
  1289.       var _loc2_:int = 0;
  1290.       var _loc3_:String = null;
  1291.       if(afterLast)
  1292.       {
  1293.          _loc2_ = int(view.length);
  1294.       }
  1295.       else if(beforeFirst)
  1296.       {
  1297.          if(view.length > 0)
  1298.          {
  1299.             _loc3_ = resourceManager.getString("collections","invalidInsert");
  1300.             throw new CursorError(_loc3_);
  1301.          }
  1302.          _loc2_ = 0;
  1303.       }
  1304.       else
  1305.       {
  1306.          _loc2_ = int(currentIndex);
  1307.       }
  1308.       ListCollectionView(view).addItemAt(param1,_loc2_);
  1309.    }
  1310.    
  1311.    [Bindable("cursorUpdate")]
  1312.    public function get afterLast() : Boolean
  1313.    {
  1314.       checkValid();
  1315.       return currentIndex == AFTER_LAST_INDEX || view.length == 0;
  1316.    }
  1317.    
  1318.    private function checkValid() : void
  1319.    {
  1320.       var _loc1_:String = null;
  1321.       if(invalid)
  1322.       {
  1323.          _loc1_ = resourceManager.getString("collections","invalidCursor");
  1324.          throw new CursorError(_loc1_);
  1325.       }
  1326.    }
  1327.    
  1328.    private function collectionEventHandler(param1:CollectionEvent) : void
  1329.    {
  1330.       var event:CollectionEvent = param1;
  1331.       switch(event.kind)
  1332.       {
  1333.          case CollectionEventKind.ADD:
  1334.             if(event.location <= currentIndex)
  1335.             {
  1336.                currentIndex += event.items.length;
  1337.             }
  1338.             break;
  1339.          case CollectionEventKind.REMOVE:
  1340.             if(event.location < currentIndex)
  1341.             {
  1342.                currentIndex -= event.items.length;
  1343.             }
  1344.             else if(event.location == currentIndex)
  1345.             {
  1346.                if(currentIndex < view.length)
  1347.                {
  1348.                   try
  1349.                   {
  1350.                      setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1351.                   }
  1352.                   catch(error:ItemPendingError)
  1353.                   {
  1354.                      setCurrent(null,false);
  1355.                   }
  1356.                }
  1357.                else
  1358.                {
  1359.                   currentIndex = AFTER_LAST_INDEX;
  1360.                   setCurrent(null);
  1361.                }
  1362.             }
  1363.             break;
  1364.          case CollectionEventKind.MOVE:
  1365.             if(event.oldLocation == currentIndex)
  1366.             {
  1367.                currentIndex = event.location;
  1368.             }
  1369.             else
  1370.             {
  1371.                if(event.oldLocation < currentIndex)
  1372.                {
  1373.                   currentIndex -= event.items.length;
  1374.                }
  1375.                if(event.location <= currentIndex)
  1376.                {
  1377.                   currentIndex += event.items.length;
  1378.                }
  1379.             }
  1380.             break;
  1381.          case CollectionEventKind.REFRESH:
  1382.             if(!(Boolean(beforeFirst) || Boolean(afterLast)))
  1383.             {
  1384.                try
  1385.                {
  1386.                   currentIndex = ListCollectionView(view).getItemIndex(currentValue);
  1387.                }
  1388.                catch(e:SortError)
  1389.                {
  1390.                   if(ListCollectionView(view).sort)
  1391.                   {
  1392.                      currentIndex = ListCollectionView(view).mx_internal::getLocalItemIndex(currentValue);
  1393.                   }
  1394.                }
  1395.                if(currentIndex == -1)
  1396.                {
  1397.                   setCurrent(null);
  1398.                }
  1399.             }
  1400.             break;
  1401.          case CollectionEventKind.REPLACE:
  1402.             if(event.location == currentIndex)
  1403.             {
  1404.                try
  1405.                {
  1406.                   setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1407.                }
  1408.                catch(error:ItemPendingError)
  1409.                {
  1410.                   setCurrent(null,false);
  1411.                }
  1412.             }
  1413.             break;
  1414.          case CollectionEventKind.RESET:
  1415.             currentIndex = BEFORE_FIRST_INDEX;
  1416.             setCurrent(null);
  1417.       }
  1418.    }
  1419.    
  1420.    public function moveNext() : Boolean
  1421.    {
  1422.       if(afterLast)
  1423.       {
  1424.          return false;
  1425.       }
  1426.       var _loc1_:int = !!beforeFirst ? 0 : int(currentIndex + 1);
  1427.       if(_loc1_ >= view.length)
  1428.       {
  1429.          _loc1_ = int(AFTER_LAST_INDEX);
  1430.          setCurrent(null);
  1431.       }
  1432.       else
  1433.       {
  1434.          setCurrent(ListCollectionView(view).getItemAt(_loc1_));
  1435.       }
  1436.       currentIndex = _loc1_;
  1437.       return !afterLast;
  1438.    }
  1439.    
  1440.    public function get view() : ICollectionView
  1441.    {
  1442.       checkValid();
  1443.       return _view;
  1444.    }
  1445.    
  1446.    public function movePrevious() : Boolean
  1447.    {
  1448.       if(beforeFirst)
  1449.       {
  1450.          return false;
  1451.       }
  1452.       var _loc1_:int = !!afterLast ? int(view.length - 1) : int(currentIndex - 1);
  1453.       if(_loc1_ == -1)
  1454.       {
  1455.          _loc1_ = int(BEFORE_FIRST_INDEX);
  1456.          setCurrent(null);
  1457.       }
  1458.       else
  1459.       {
  1460.          setCurrent(ListCollectionView(view).getItemAt(_loc1_));
  1461.       }
  1462.       currentIndex = _loc1_;
  1463.       return !beforeFirst;
  1464.    }
  1465.    
  1466.    public function findLast(param1:Object) : Boolean
  1467.    {
  1468.       var lcView:ListCollectionView;
  1469.       var index:int = 0;
  1470.       var values:Object = param1;
  1471.       checkValid();
  1472.       lcView = ListCollectionView(view);
  1473.       try
  1474.       {
  1475.          index = lcView.mx_internal::findItem(values,Sort.LAST_INDEX_MODE);
  1476.       }
  1477.       catch(sortError:SortError)
  1478.       {
  1479.          throw new CursorError(sortError.message);
  1480.       }
  1481.       if(index > -1)
  1482.       {
  1483.          currentIndex = index;
  1484.          setCurrent(lcView.getItemAt(currentIndex));
  1485.       }
  1486.       return index > -1;
  1487.    }
  1488.    
  1489.    [Bindable("cursorUpdate")]
  1490.    public function get beforeFirst() : Boolean
  1491.    {
  1492.       checkValid();
  1493.       return currentIndex == BEFORE_FIRST_INDEX || view.length == 0;
  1494.    }
  1495.    
  1496.    [Bindable("cursorUpdate")]
  1497.    public function get bookmark() : CursorBookmark
  1498.    {
  1499.       checkValid();
  1500.       if(view.length == 0 || Boolean(beforeFirst))
  1501.       {
  1502.          return CursorBookmark.FIRST;
  1503.       }
  1504.       if(afterLast)
  1505.       {
  1506.          return CursorBookmark.LAST;
  1507.       }
  1508.       return ListCollectionView(view).mx_internal::getBookmark(currentIndex);
  1509.    }
  1510.    
  1511.    public function findFirst(param1:Object) : Boolean
  1512.    {
  1513.       var lcView:ListCollectionView;
  1514.       var index:int = 0;
  1515.       var values:Object = param1;
  1516.       checkValid();
  1517.       lcView = ListCollectionView(view);
  1518.       try
  1519.       {
  1520.          index = lcView.mx_internal::findItem(values,Sort.FIRST_INDEX_MODE);
  1521.       }
  1522.       catch(sortError:SortError)
  1523.       {
  1524.          throw new CursorError(sortError.message);
  1525.       }
  1526.       if(index > -1)
  1527.       {
  1528.          currentIndex = index;
  1529.          setCurrent(lcView.getItemAt(currentIndex));
  1530.       }
  1531.       return index > -1;
  1532.    }
  1533.    
  1534.    [Bindable("cursorUpdate")]
  1535.    public function get current() : Object
  1536.    {
  1537.       checkValid();
  1538.       return currentValue;
  1539.    }
  1540. }
  1541.