home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / collections / ModifiedCollectionView.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  26.0 KB  |  847 lines
  1. package mx.collections
  2. {
  3.    import flash.events.Event;
  4.    import flash.utils.Dictionary;
  5.    import mx.collections.errors.CollectionViewError;
  6.    import mx.core.mx_internal;
  7.    import mx.events.CollectionEvent;
  8.    import mx.events.CollectionEventKind;
  9.    import mx.events.PropertyChangeEvent;
  10.    import mx.resources.IResourceManager;
  11.    import mx.resources.ResourceManager;
  12.    
  13.    use namespace mx_internal;
  14.    
  15.    public class ModifiedCollectionView implements ICollectionView
  16.    {
  17.       mx_internal static const VERSION:String = "3.5.0.12683";
  18.       
  19.       public static const REMOVED:String = "removed";
  20.       
  21.       public static const ADDED:String = "added";
  22.       
  23.       public static const REPLACED:String = "replaced";
  24.       
  25.       public static const REPLACEMENT:String = "replacement";
  26.       
  27.       private var addedItems:Dictionary = new Dictionary(true);
  28.       
  29.       private var _showPreserved:Boolean = false;
  30.       
  31.       private var list:ICollectionView;
  32.       
  33.       private var deltaLength:int = 0;
  34.       
  35.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  36.       
  37.       private var removedItems:Dictionary = new Dictionary(true);
  38.       
  39.       private var itemWrappersByIndex:Array = [];
  40.       
  41.       private var replacementItems:Dictionary = new Dictionary(true);
  42.       
  43.       private var deltas:Array = [];
  44.       
  45.       private var replacedItems:Dictionary = new Dictionary(true);
  46.       
  47.       private var itemWrappersByCollectionMod:Dictionary = new Dictionary(true);
  48.       
  49.       public function ModifiedCollectionView(param1:ICollectionView)
  50.       {
  51.          super();
  52.          this.list = param1;
  53.       }
  54.       
  55.       mx_internal function getBookmarkIndex(param1:CursorBookmark) : int
  56.       {
  57.          var _loc3_:String = null;
  58.          if(!(param1 is ModifiedCollectionViewBookmark) || ModifiedCollectionViewBookmark(param1).mx_internal::view != this)
  59.          {
  60.             _loc3_ = resourceManager.getString("collections","bookmarkNotFound");
  61.             throw new CollectionViewError(_loc3_);
  62.          }
  63.          var _loc2_:ModifiedCollectionViewBookmark = ModifiedCollectionViewBookmark(param1);
  64.          return _loc2_.mx_internal::index;
  65.       }
  66.       
  67.       public function willTrigger(param1:String) : Boolean
  68.       {
  69.          return false;
  70.       }
  71.       
  72.       private function removeModification(param1:CollectionModification) : Boolean
  73.       {
  74.          var _loc2_:int = 0;
  75.          while(_loc2_ < deltas.length)
  76.          {
  77.             if(deltas[_loc2_] == param1)
  78.             {
  79.                deltas.splice(_loc2_,1);
  80.                return true;
  81.             }
  82.             _loc2_++;
  83.          }
  84.          return false;
  85.       }
  86.       
  87.       mx_internal function getWrappedItemUsingCursor(param1:ModifiedCollectionViewCursor, param2:int) : Object
  88.       {
  89.          var _loc6_:CollectionModification = null;
  90.          var _loc9_:Object = null;
  91.          var _loc3_:int = param2;
  92.          var _loc4_:Object = null;
  93.          var _loc5_:CollectionModification = null;
  94.          var _loc7_:Boolean = false;
  95.          var _loc8_:int = 0;
  96.          while(_loc8_ < deltas.length)
  97.          {
  98.             _loc6_ = deltas[_loc8_];
  99.             if(_loc3_ < _loc6_.index)
  100.             {
  101.                break;
  102.             }
  103.             if(_loc6_.modificationType == CollectionModification.REPLACE)
  104.             {
  105.                if(_loc3_ == _loc6_.index && _loc6_.showOldReplace && _showPreserved)
  106.                {
  107.                   _loc5_ = _loc6_;
  108.                   break;
  109.                }
  110.                if(_loc3_ == _loc6_.index + 1 && _loc6_.showOldReplace && _loc6_.showNewReplace && _showPreserved)
  111.                {
  112.                   _loc3_--;
  113.                   _loc7_ = true;
  114.                   break;
  115.                }
  116.                if(_loc3_ == _loc6_.index && (!_loc6_.showOldReplace && _loc6_.showNewReplace || !_showPreserved))
  117.                {
  118.                   _loc7_ = true;
  119.                   break;
  120.                }
  121.                _loc3_ -= _loc6_.modCount;
  122.             }
  123.             else if(isActive(_loc6_))
  124.             {
  125.                if(_loc3_ == _loc6_.index && _loc6_.isRemove)
  126.                {
  127.                   _loc5_ = _loc6_;
  128.                   break;
  129.                }
  130.                if(_loc3_ >= _loc6_.index)
  131.                {
  132.                   _loc3_ -= _loc6_.modCount;
  133.                }
  134.             }
  135.             _loc8_++;
  136.          }
  137.          if(_loc5_)
  138.          {
  139.             _loc4_ = _loc5_.item;
  140.          }
  141.          else
  142.          {
  143.             param1.internalCursor.seek(CursorBookmark.CURRENT,_loc3_ - param1.internalIndex);
  144.             _loc4_ = param1.internalCursor.current;
  145.             param1.internalIndex = _loc3_;
  146.          }
  147.          if(_loc6_ && _loc3_ == _loc6_.index && _loc6_.modificationType == CollectionModification.ADD)
  148.          {
  149.             _loc9_ = getUniqueItemWrapper(_loc4_,_loc6_,_loc3_);
  150.          }
  151.          else
  152.          {
  153.             _loc9_ = getUniqueItemWrapper(_loc4_,_loc5_,_loc3_);
  154.          }
  155.          return _loc9_;
  156.       }
  157.       
  158.       public function contains(param1:Object) : Boolean
  159.       {
  160.          return false;
  161.       }
  162.       
  163.       private function integrateReplacedElements(param1:CollectionEvent, param2:int, param3:int) : void
  164.       {
  165.          var _loc9_:Object = null;
  166.          var _loc10_:Object = null;
  167.          var _loc11_:CollectionModification = null;
  168.          var _loc12_:CollectionModification = null;
  169.          var _loc4_:int = 0;
  170.          var _loc5_:int = 0;
  171.          var _loc6_:Boolean = false;
  172.          var _loc7_:int = int(param1.items.length);
  173.          var _loc8_:int = 0;
  174.          while(_loc4_ < deltas.length && _loc5_ < _loc7_)
  175.          {
  176.             _loc9_ = PropertyChangeEvent(param1.items[_loc5_]).oldValue;
  177.             _loc10_ = PropertyChangeEvent(param1.items[_loc5_]).newValue;
  178.             _loc11_ = CollectionModification(deltas[_loc4_]);
  179.             _loc12_ = new CollectionModification(param1.location + _loc5_,_loc9_,CollectionModification.REPLACE);
  180.             if(_loc11_.isRemove && _loc11_.index <= _loc12_.index || !_loc11_.isRemove && _loc11_.index < _loc12_.index)
  181.             {
  182.                _loc4_++;
  183.             }
  184.             else if((_loc11_.modificationType == CollectionModification.ADD || _loc11_.modificationType == CollectionModification.REPLACE) && _loc11_.index == _loc12_.index)
  185.             {
  186.                _loc4_++;
  187.                _loc5_++;
  188.             }
  189.             else
  190.             {
  191.                deltas.splice(_loc4_ + _loc5_,0,_loc12_);
  192.                replacedItems[getUniqueItemWrapper(_loc9_,_loc12_,param1.location + _loc5_)] = _loc12_;
  193.                replacementItems[getUniqueItemWrapper(_loc10_,_loc12_,param1.location + _loc5_,true)] = _loc12_;
  194.                _loc5_++;
  195.                _loc4_++;
  196.             }
  197.          }
  198.          while(_loc5_ < _loc7_)
  199.          {
  200.             _loc9_ = PropertyChangeEvent(param1.items[_loc5_]).oldValue;
  201.             _loc10_ = PropertyChangeEvent(param1.items[_loc5_]).newValue;
  202.             deltas.push(_loc12_ = new CollectionModification(param1.location + _loc5_,_loc9_,CollectionModification.REPLACE));
  203.             replacedItems[getUniqueItemWrapper(_loc9_,_loc12_,param1.location + _loc5_)] = _loc12_;
  204.             replacementItems[getUniqueItemWrapper(_loc10_,_loc12_,param1.location + _loc5_,true)] = _loc12_;
  205.             _loc5_++;
  206.          }
  207.       }
  208.       
  209.       mx_internal function getBookmark(param1:ModifiedCollectionViewCursor) : ModifiedCollectionViewBookmark
  210.       {
  211.          var _loc4_:String = null;
  212.          var _loc2_:int = param1.mx_internal::currentIndex;
  213.          if(_loc2_ < 0 || _loc2_ > length)
  214.          {
  215.             _loc4_ = resourceManager.getString("collections","invalidIndex",[_loc2_]);
  216.             throw new CollectionViewError(_loc4_);
  217.          }
  218.          var _loc3_:Object = param1.current;
  219.          return new ModifiedCollectionViewBookmark(_loc3_,this,0,_loc2_,param1.internalCursor.bookmark,param1.internalIndex);
  220.       }
  221.       
  222.       public function get sort() : Sort
  223.       {
  224.          return null;
  225.       }
  226.       
  227.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  228.       {
  229.       }
  230.       
  231.       public function processCollectionEvent(param1:CollectionEvent, param2:int, param3:int) : void
  232.       {
  233.          switch(param1.kind)
  234.          {
  235.             case CollectionEventKind.ADD:
  236.                integrateAddedElements(param1,param2,param3);
  237.                break;
  238.             case CollectionEventKind.REMOVE:
  239.                integrateRemovedElements(param1,param2,param3);
  240.                break;
  241.             case CollectionEventKind.REPLACE:
  242.                integrateReplacedElements(param1,param2,param3);
  243.          }
  244.       }
  245.       
  246.       public function get showPreservedState() : Boolean
  247.       {
  248.          return _showPreserved;
  249.       }
  250.       
  251.       public function getSemantics(param1:ItemWrapper) : String
  252.       {
  253.          if(removedItems[param1])
  254.          {
  255.             return ModifiedCollectionView.REMOVED;
  256.          }
  257.          if(addedItems[param1])
  258.          {
  259.             return ModifiedCollectionView.ADDED;
  260.          }
  261.          if(replacedItems[param1])
  262.          {
  263.             return ModifiedCollectionView.REPLACED;
  264.          }
  265.          if(replacementItems[param1])
  266.          {
  267.             return ModifiedCollectionView.REPLACEMENT;
  268.          }
  269.          return null;
  270.       }
  271.       
  272.       private function getUniqueItemWrapper(param1:Object, param2:CollectionModification, param3:int, param4:Boolean = false) : Object
  273.       {
  274.          if(Boolean(param2) && (param2.isRemove || param2.modificationType == CollectionModification.REPLACE && !param4))
  275.          {
  276.             if(!itemWrappersByCollectionMod[param2])
  277.             {
  278.                itemWrappersByCollectionMod[param2] = new ItemWrapper(param1);
  279.             }
  280.             return itemWrappersByCollectionMod[param2];
  281.          }
  282.          if(Boolean(param2) && param2.modificationType == CollectionModification.ADD)
  283.          {
  284.             param3 = param2.index;
  285.          }
  286.          if(!itemWrappersByIndex[param3])
  287.          {
  288.             itemWrappersByIndex[param3] = new ItemWrapper(param1);
  289.          }
  290.          return itemWrappersByIndex[param3];
  291.       }
  292.       
  293.       public function enableAutoUpdate() : void
  294.       {
  295.       }
  296.       
  297.       public function set sort(param1:Sort) : void
  298.       {
  299.       }
  300.       
  301.       public function removeItem(param1:ItemWrapper) : void
  302.       {
  303.          var _loc2_:CollectionModification = removedItems[param1] as CollectionModification;
  304.          if(!_loc2_)
  305.          {
  306.             _loc2_ = replacedItems[param1] as CollectionModification;
  307.             if(_loc2_)
  308.             {
  309.                delete replacedItems[param1];
  310.                _loc2_.stopShowingReplacedValue();
  311.                --deltaLength;
  312.                if(_loc2_.modCount == 0)
  313.                {
  314.                   removeModification(_loc2_);
  315.                }
  316.             }
  317.          }
  318.          else if(removeModification(_loc2_))
  319.          {
  320.             delete removedItems[param1];
  321.             --deltaLength;
  322.          }
  323.       }
  324.       
  325.       public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  326.       {
  327.       }
  328.       
  329.       private function integrateRemovedElements(param1:CollectionEvent, param2:int, param3:int) : void
  330.       {
  331.          var _loc9_:CollectionModification = null;
  332.          var _loc10_:CollectionModification = null;
  333.          var _loc4_:int = 0;
  334.          var _loc5_:int = 0;
  335.          var _loc6_:int = 0;
  336.          var _loc7_:int = int(param1.items.length);
  337.          var _loc8_:int = 0;
  338.          while(_loc4_ < deltas.length && _loc5_ < _loc7_)
  339.          {
  340.             _loc9_ = CollectionModification(deltas[_loc4_]);
  341.             _loc10_ = new CollectionModification(param1.location,param1.items[_loc5_],CollectionModification.REMOVE);
  342.             removedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  343.             if(_loc8_ != 0)
  344.             {
  345.                _loc9_.index += _loc8_;
  346.             }
  347.             if(_loc9_.isRemove && _loc9_.index <= _loc10_.index || !_loc9_.isRemove && _loc9_.index < _loc10_.index)
  348.             {
  349.                _loc4_++;
  350.             }
  351.             else
  352.             {
  353.                if(!_loc9_.isRemove && _loc9_.index == _loc10_.index)
  354.                {
  355.                   deltas.splice(_loc4_ + _loc5_,1);
  356.                }
  357.                else
  358.                {
  359.                   deltas.splice(_loc4_ + _loc5_,0,_loc10_);
  360.                   _loc4_++;
  361.                }
  362.                _loc8_--;
  363.                _loc5_++;
  364.             }
  365.          }
  366.          while(_loc4_ < deltas.length)
  367.          {
  368.             _loc9_ = CollectionModification(deltas[_loc4_++]);
  369.             _loc9_.index += _loc8_;
  370.          }
  371.          while(_loc5_ < _loc7_)
  372.          {
  373.             deltas.push(_loc10_ = new CollectionModification(param1.location,param1.items[_loc5_],CollectionModification.REMOVE));
  374.             removedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  375.             _loc5_++;
  376.          }
  377.          deltaLength += param1.items.length - _loc6_;
  378.       }
  379.       
  380.       public function dispatchEvent(param1:Event) : Boolean
  381.       {
  382.          return false;
  383.       }
  384.       
  385.       private function isActive(param1:CollectionModification) : Boolean
  386.       {
  387.          return _showPreserved;
  388.       }
  389.       
  390.       public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  391.       {
  392.       }
  393.       
  394.       public function refresh() : Boolean
  395.       {
  396.          return false;
  397.       }
  398.       
  399.       public function addItem(param1:ItemWrapper) : void
  400.       {
  401.          var _loc2_:CollectionModification = addedItems[param1] as CollectionModification;
  402.          if(!_loc2_)
  403.          {
  404.             _loc2_ = replacementItems[param1] as CollectionModification;
  405.             if(_loc2_)
  406.             {
  407.                _loc2_.startShowingReplacementValue();
  408.                ++deltaLength;
  409.                if(_loc2_.modCount == 0)
  410.                {
  411.                   removeModification(_loc2_);
  412.                }
  413.             }
  414.          }
  415.          else if(removeModification(_loc2_))
  416.          {
  417.             ++deltaLength;
  418.          }
  419.       }
  420.       
  421.       public function get length() : int
  422.       {
  423.          return list.length + (_showPreserved ? deltaLength : 0);
  424.       }
  425.       
  426.       public function set filterFunction(param1:Function) : void
  427.       {
  428.       }
  429.       
  430.       public function set showPreservedState(param1:Boolean) : void
  431.       {
  432.          _showPreserved = param1;
  433.       }
  434.       
  435.       public function createCursor() : IViewCursor
  436.       {
  437.          var _loc1_:IViewCursor = list.createCursor();
  438.          var _loc2_:Object = _loc1_.current;
  439.          return new ModifiedCollectionViewCursor(this,_loc1_,_loc2_);
  440.       }
  441.       
  442.       private function integrateAddedElements(param1:CollectionEvent, param2:int, param3:int) : void
  443.       {
  444.          var _loc9_:CollectionModification = null;
  445.          var _loc10_:CollectionModification = null;
  446.          var _loc4_:int = 0;
  447.          var _loc5_:int = 0;
  448.          var _loc6_:Boolean = false;
  449.          var _loc7_:int = int(param1.items.length);
  450.          var _loc8_:int = 0;
  451.          while(_loc4_ < deltas.length && _loc5_ < _loc7_)
  452.          {
  453.             _loc9_ = CollectionModification(deltas[_loc4_]);
  454.             _loc10_ = new CollectionModification(param1.location + _loc5_,null,CollectionModification.ADD);
  455.             addedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  456.             if(_loc9_.isRemove && _loc9_.index <= _loc10_.index || !_loc9_.isRemove && _loc9_.index < _loc10_.index)
  457.             {
  458.                _loc4_++;
  459.             }
  460.             else
  461.             {
  462.                deltas.splice(_loc4_ + _loc5_,0,_loc10_);
  463.                _loc8_++;
  464.                _loc5_++;
  465.                _loc4_++;
  466.             }
  467.          }
  468.          while(_loc4_ < deltas.length)
  469.          {
  470.             _loc9_ = CollectionModification(deltas[_loc4_++]);
  471.             _loc9_.index += _loc8_;
  472.          }
  473.          while(_loc5_ < _loc7_)
  474.          {
  475.             deltas.push(_loc10_ = new CollectionModification(param1.location + _loc5_,null,CollectionModification.ADD));
  476.             addedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  477.             _loc5_++;
  478.          }
  479.          deltaLength -= param1.items.length;
  480.       }
  481.       
  482.       public function disableAutoUpdate() : void
  483.       {
  484.       }
  485.       
  486.       public function hasEventListener(param1:String) : Boolean
  487.       {
  488.          return false;
  489.       }
  490.       
  491.       public function get filterFunction() : Function
  492.       {
  493.          return null;
  494.       }
  495.    }
  496. }
  497.  
  498. import flash.events.EventDispatcher;
  499. import mx.collections.errors.CollectionViewError;
  500. import mx.collections.errors.CursorError;
  501. import mx.collections.errors.ItemPendingError;
  502. import mx.core.mx_internal;
  503. import mx.events.FlexEvent;
  504. import mx.resources.IResourceManager;
  505. import mx.resources.ResourceManager;
  506.  
  507. use namespace mx_internal;
  508.  
  509. class ModifiedCollectionViewBookmark extends CursorBookmark
  510. {
  511.    mx_internal var viewRevision:int;
  512.    
  513.    mx_internal var index:int;
  514.    
  515.    mx_internal var internalBookmark:CursorBookmark;
  516.    
  517.    mx_internal var view:ModifiedCollectionView;
  518.    
  519.    mx_internal var internalIndex:int;
  520.    
  521.    public function ModifiedCollectionViewBookmark(param1:Object, param2:ModifiedCollectionView, param3:int, param4:int, param5:CursorBookmark, param6:int)
  522.    {
  523.       super(param1);
  524.       this.mx_internal::view = param2;
  525.       this.mx_internal::viewRevision = param3;
  526.       this.mx_internal::index = param4;
  527.       this.mx_internal::internalBookmark = param5;
  528.       this.mx_internal::internalIndex = param6;
  529.    }
  530.    
  531.    override public function getViewIndex() : int
  532.    {
  533.       return mx_internal::view.mx_internal::getBookmarkIndex(this);
  534.    }
  535. }
  536.  
  537. class ModifiedCollectionViewCursor extends EventDispatcher implements IViewCursor
  538. {
  539.    private static const BEFORE_FIRST_INDEX:int = -1;
  540.    
  541.    private static const AFTER_LAST_INDEX:int = -2;
  542.    
  543.    private var _view:ModifiedCollectionView;
  544.    
  545.    private var resourceManager:IResourceManager;
  546.    
  547.    public var internalIndex:int;
  548.    
  549.    mx_internal var currentIndex:int;
  550.    
  551.    public var internalCursor:IViewCursor;
  552.    
  553.    private var invalid:Boolean;
  554.    
  555.    private var currentValue:Object;
  556.    
  557.    public function ModifiedCollectionViewCursor(param1:ModifiedCollectionView, param2:IViewCursor, param3:Object)
  558.    {
  559.       var view:ModifiedCollectionView = param1;
  560.       var cursor:IViewCursor = param2;
  561.       var current:Object = param3;
  562.       resourceManager = ResourceManager.getInstance();
  563.       super();
  564.       _view = view;
  565.       internalCursor = cursor;
  566.       if(cursor.beforeFirst && !current)
  567.       {
  568.          internalIndex = BEFORE_FIRST_INDEX;
  569.       }
  570.       else if(cursor.afterLast && !current)
  571.       {
  572.          internalIndex = AFTER_LAST_INDEX;
  573.       }
  574.       else
  575.       {
  576.          internalIndex = 0;
  577.       }
  578.       mx_internal::currentIndex = view.length > 0 ? 0 : int(AFTER_LAST_INDEX);
  579.       if(mx_internal::currentIndex == 0)
  580.       {
  581.          try
  582.          {
  583.             setCurrent(current,false);
  584.          }
  585.          catch(e:ItemPendingError)
  586.          {
  587.             mx_internal::currentIndex = BEFORE_FIRST_INDEX;
  588.             setCurrent(null,false);
  589.          }
  590.       }
  591.    }
  592.    
  593.    public function findAny(param1:Object) : Boolean
  594.    {
  595.       return false;
  596.    }
  597.    
  598.    public function findFirst(param1:Object) : Boolean
  599.    {
  600.       return false;
  601.    }
  602.    
  603.    public function seek(param1:CursorBookmark, param2:int = 0, param3:int = 0) : void
  604.    {
  605.       var newCurrent:Object;
  606.       var newIndex:int;
  607.       var message:String = null;
  608.       var mcvBookmark:ModifiedCollectionViewBookmark = null;
  609.       var bookmark:CursorBookmark = param1;
  610.       var offset:int = param2;
  611.       var prefetch:int = param3;
  612.       checkValid();
  613.       if(view.length == 0)
  614.       {
  615.          mx_internal::currentIndex = AFTER_LAST_INDEX;
  616.          setCurrent(null,false);
  617.          return;
  618.       }
  619.       newIndex = int(mx_internal::currentIndex);
  620.       if(bookmark == CursorBookmark.FIRST)
  621.       {
  622.          newIndex = 0;
  623.          internalIndex = 0;
  624.          internalCursor.seek(CursorBookmark.FIRST);
  625.       }
  626.       else if(bookmark == CursorBookmark.LAST)
  627.       {
  628.          newIndex = view.length - 1;
  629.          internalCursor.seek(CursorBookmark.LAST);
  630.       }
  631.       else if(bookmark != CursorBookmark.CURRENT)
  632.       {
  633.          try
  634.          {
  635.             mcvBookmark = bookmark as ModifiedCollectionViewBookmark;
  636.             newIndex = ModifiedCollectionView(view).mx_internal::getBookmarkIndex(bookmark);
  637.             if(!mcvBookmark || newIndex < 0)
  638.             {
  639.                setCurrent(null);
  640.                message = resourceManager.getString("collections","bookmarkInvalid");
  641.                throw new CursorError(message);
  642.             }
  643.             internalIndex = mcvBookmark.mx_internal::internalIndex;
  644.             internalCursor.seek(mcvBookmark.mx_internal::internalBookmark);
  645.          }
  646.          catch(bmError:CollectionViewError)
  647.          {
  648.             message = resourceManager.getString("collections","bookmarkInvalid");
  649.             throw new CursorError(message);
  650.          }
  651.       }
  652.       newIndex += offset;
  653.       newCurrent = null;
  654.       if(newIndex >= view.length)
  655.       {
  656.          mx_internal::currentIndex = AFTER_LAST_INDEX;
  657.       }
  658.       else if(newIndex < 0)
  659.       {
  660.          mx_internal::currentIndex = BEFORE_FIRST_INDEX;
  661.       }
  662.       else
  663.       {
  664.          newCurrent = ModifiedCollectionView(view).mx_internal::getWrappedItemUsingCursor(this,newIndex);
  665.          mx_internal::currentIndex = newIndex;
  666.       }
  667.       setCurrent(newCurrent);
  668.    }
  669.    
  670.    public function insert(param1:Object) : void
  671.    {
  672.    }
  673.    
  674.    [Bindable("cursorUpdate")]
  675.    public function get afterLast() : Boolean
  676.    {
  677.       checkValid();
  678.       return mx_internal::currentIndex == AFTER_LAST_INDEX || view.length == 0;
  679.    }
  680.    
  681.    public function remove() : Object
  682.    {
  683.       return null;
  684.    }
  685.    
  686.    private function checkValid() : void
  687.    {
  688.       var _loc1_:String = null;
  689.       if(invalid)
  690.       {
  691.          _loc1_ = resourceManager.getString("collections","invalidCursor");
  692.          throw new CursorError(_loc1_);
  693.       }
  694.    }
  695.    
  696.    public function get view() : ICollectionView
  697.    {
  698.       checkValid();
  699.       return _view;
  700.    }
  701.    
  702.    public function movePrevious() : Boolean
  703.    {
  704.       if(beforeFirst)
  705.       {
  706.          return false;
  707.       }
  708.       var _loc1_:int = !!afterLast ? int(view.length - 1) : int(mx_internal::currentIndex - 1);
  709.       if(_loc1_ == -1)
  710.       {
  711.          _loc1_ = int(BEFORE_FIRST_INDEX);
  712.          setCurrent(null);
  713.       }
  714.       else
  715.       {
  716.          setCurrent(ModifiedCollectionView(view).mx_internal::getWrappedItemUsingCursor(this,_loc1_));
  717.       }
  718.       mx_internal::currentIndex = _loc1_;
  719.       return !beforeFirst;
  720.    }
  721.    
  722.    public function moveNext() : Boolean
  723.    {
  724.       if(afterLast)
  725.       {
  726.          return false;
  727.       }
  728.       var _loc1_:int = !!beforeFirst ? 0 : int(mx_internal::currentIndex + 1);
  729.       if(_loc1_ >= view.length)
  730.       {
  731.          _loc1_ = int(AFTER_LAST_INDEX);
  732.          setCurrent(null);
  733.       }
  734.       else
  735.       {
  736.          setCurrent(ModifiedCollectionView(view).mx_internal::getWrappedItemUsingCursor(this,_loc1_));
  737.       }
  738.       mx_internal::currentIndex = _loc1_;
  739.       return !afterLast;
  740.    }
  741.    
  742.    public function findLast(param1:Object) : Boolean
  743.    {
  744.       return false;
  745.    }
  746.    
  747.    [Bindable("cursorUpdate")]
  748.    public function get beforeFirst() : Boolean
  749.    {
  750.       checkValid();
  751.       return mx_internal::currentIndex == BEFORE_FIRST_INDEX || view.length == 0;
  752.    }
  753.    
  754.    [Bindable("cursorUpdate")]
  755.    public function get bookmark() : CursorBookmark
  756.    {
  757.       checkValid();
  758.       if(view.length == 0 || Boolean(beforeFirst))
  759.       {
  760.          return CursorBookmark.FIRST;
  761.       }
  762.       if(afterLast)
  763.       {
  764.          return CursorBookmark.LAST;
  765.       }
  766.       return ModifiedCollectionView(view).mx_internal::getBookmark(this);
  767.    }
  768.    
  769.    [Bindable("cursorUpdate")]
  770.    public function get current() : Object
  771.    {
  772.       checkValid();
  773.       return currentValue;
  774.    }
  775.    
  776.    private function setCurrent(param1:Object, param2:Boolean = true) : void
  777.    {
  778.       currentValue = param1;
  779.       if(param2)
  780.       {
  781.          dispatchEvent(new FlexEvent(FlexEvent.CURSOR_UPDATE));
  782.       }
  783.    }
  784. }
  785.  
  786. class CollectionModification
  787. {
  788.    public static const REMOVE:String = "remove";
  789.    
  790.    public static const ADD:String = "add";
  791.    
  792.    public static const REPLACE:String = "replace";
  793.    
  794.    public var showOldReplace:Boolean = true;
  795.    
  796.    private var _modCount:int = 0;
  797.    
  798.    public var showNewReplace:Boolean = false;
  799.    
  800.    public var index:int;
  801.    
  802.    public var modificationType:String = null;
  803.    
  804.    public var item:Object = null;
  805.    
  806.    public function CollectionModification(param1:int, param2:Object, param3:String)
  807.    {
  808.       super();
  809.       this.index = param1;
  810.       this.modificationType = param3;
  811.       if(param3 != CollectionModification.ADD)
  812.       {
  813.          this.item = param2;
  814.       }
  815.       if(param3 == CollectionModification.REMOVE)
  816.       {
  817.          _modCount = 1;
  818.       }
  819.       else if(param3 == CollectionModification.ADD)
  820.       {
  821.          _modCount = -1;
  822.       }
  823.    }
  824.    
  825.    public function startShowingReplacementValue() : void
  826.    {
  827.       showNewReplace = true;
  828.       ++_modCount;
  829.    }
  830.    
  831.    public function get modCount() : int
  832.    {
  833.       return _modCount;
  834.    }
  835.    
  836.    public function get isRemove() : Boolean
  837.    {
  838.       return modificationType == CollectionModification.REMOVE;
  839.    }
  840.    
  841.    public function stopShowingReplacedValue() : void
  842.    {
  843.       showOldReplace = false;
  844.       --_modCount;
  845.    }
  846. }
  847.