home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / controls / List.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  64.0 KB  |  1,850 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Graphics;
  5.    import flash.display.Shape;
  6.    import flash.display.Sprite;
  7.    import flash.events.Event;
  8.    import flash.events.FocusEvent;
  9.    import flash.events.KeyboardEvent;
  10.    import flash.events.MouseEvent;
  11.    import flash.geom.Point;
  12.    import flash.ui.Keyboard;
  13.    import flash.utils.Dictionary;
  14.    import mx.collections.CursorBookmark;
  15.    import mx.collections.IList;
  16.    import mx.collections.ItemResponder;
  17.    import mx.collections.ItemWrapper;
  18.    import mx.collections.ModifiedCollectionView;
  19.    import mx.collections.errors.ItemPendingError;
  20.    import mx.controls.listClasses.BaseListData;
  21.    import mx.controls.listClasses.IDropInListItemRenderer;
  22.    import mx.controls.listClasses.IListItemRenderer;
  23.    import mx.controls.listClasses.ListBase;
  24.    import mx.controls.listClasses.ListBaseSeekPending;
  25.    import mx.controls.listClasses.ListData;
  26.    import mx.controls.listClasses.ListItemRenderer;
  27.    import mx.controls.listClasses.ListRowInfo;
  28.    import mx.controls.scrollClasses.ScrollBar;
  29.    import mx.core.ClassFactory;
  30.    import mx.core.EdgeMetrics;
  31.    import mx.core.EventPriority;
  32.    import mx.core.FlexShape;
  33.    import mx.core.FlexSprite;
  34.    import mx.core.FlexVersion;
  35.    import mx.core.IFactory;
  36.    import mx.core.IIMESupport;
  37.    import mx.core.IInvalidating;
  38.    import mx.core.IPropertyChangeNotifier;
  39.    import mx.core.ScrollPolicy;
  40.    import mx.core.UIComponent;
  41.    import mx.core.UIComponentGlobals;
  42.    import mx.core.mx_internal;
  43.    import mx.events.CollectionEvent;
  44.    import mx.events.CollectionEventKind;
  45.    import mx.events.ListEvent;
  46.    import mx.events.ListEventReason;
  47.    import mx.events.SandboxMouseEvent;
  48.    import mx.events.ScrollEvent;
  49.    import mx.events.ScrollEventDetail;
  50.    import mx.managers.IFocusManager;
  51.    import mx.managers.IFocusManagerComponent;
  52.    import mx.styles.StyleManager;
  53.    
  54.    use namespace mx_internal;
  55.    
  56.    public class List extends ListBase implements IIMESupport
  57.    {
  58.       mx_internal static var createAccessibilityImplementation:Function;
  59.       
  60.       mx_internal static const VERSION:String = "3.5.0.12683";
  61.       
  62.       public var editorXOffset:Number = 0;
  63.       
  64.       public var itemEditorInstance:IListItemRenderer;
  65.       
  66.       public var rendererIsEditor:Boolean = false;
  67.       
  68.       private var dontEdit:Boolean = false;
  69.       
  70.       public var editorYOffset:Number = 0;
  71.       
  72.       public var editorWidthOffset:Number = 0;
  73.       
  74.       private var lastEditedItemPosition:*;
  75.       
  76.       public var itemEditor:IFactory = new ClassFactory(TextInput);
  77.       
  78.       public var editable:Boolean = false;
  79.       
  80.       private var losingFocus:Boolean = false;
  81.       
  82.       public var editorUsesEnterKey:Boolean = false;
  83.       
  84.       public var editorDataField:String = "text";
  85.       
  86.       private var bEditedItemPositionChanged:Boolean = false;
  87.       
  88.       mx_internal var _lockedRowCount:int = 0;
  89.       
  90.       private var inEndEdit:Boolean = false;
  91.       
  92.       public var editorHeightOffset:Number = 0;
  93.       
  94.       private var _editedItemPosition:Object;
  95.       
  96.       private var _imeMode:String;
  97.       
  98.       private var actualRowIndex:int;
  99.       
  100.       private var _proposedEditedItemPosition:*;
  101.       
  102.       private var actualColIndex:int = 0;
  103.       
  104.       protected var measuringObjects:Dictionary;
  105.       
  106.       public function List()
  107.       {
  108.          super();
  109.          mx_internal::listType = "vertical";
  110.          mx_internal::bColumnScrolling = false;
  111.          itemRenderer = new ClassFactory(ListItemRenderer);
  112.          mx_internal::_horizontalScrollPolicy = ScrollPolicy.OFF;
  113.          mx_internal::_verticalScrollPolicy = ScrollPolicy.AUTO;
  114.          defaultColumnCount = 1;
  115.          defaultRowCount = 7;
  116.          addEventListener(ListEvent.ITEM_EDIT_BEGINNING,itemEditorItemEditBeginningHandler,false,EventPriority.DEFAULT_HANDLER);
  117.          addEventListener(ListEvent.ITEM_EDIT_BEGIN,itemEditorItemEditBeginHandler,false,EventPriority.DEFAULT_HANDLER);
  118.          addEventListener(ListEvent.ITEM_EDIT_END,itemEditorItemEditEndHandler,false,EventPriority.DEFAULT_HANDLER);
  119.       }
  120.       
  121.       override public function measureWidthOfItems(param1:int = -1, param2:int = 0) : Number
  122.       {
  123.          var i:int;
  124.          var paddingRight:Number;
  125.          var more:Boolean;
  126.          var bookmark:CursorBookmark;
  127.          var w:Number;
  128.          var paddingLeft:Number;
  129.          var item:IListItemRenderer = null;
  130.          var rw:Number = NaN;
  131.          var data:Object = null;
  132.          var factory:IFactory = null;
  133.          var index:int = param1;
  134.          var count:int = param2;
  135.          if(count == 0)
  136.          {
  137.             count = !!collection ? collection.length : 0;
  138.          }
  139.          if(Boolean(collection) && collection.length == 0)
  140.          {
  141.             count = 0;
  142.          }
  143.          w = 0;
  144.          bookmark = !!iterator ? iterator.bookmark : null;
  145.          if(index != -1 && Boolean(iterator))
  146.          {
  147.             try
  148.             {
  149.                iterator.seek(CursorBookmark.FIRST,index);
  150.             }
  151.             catch(e:ItemPendingError)
  152.             {
  153.                return 0;
  154.             }
  155.          }
  156.          more = iterator != null;
  157.          i = 0;
  158.          while(i < count)
  159.          {
  160.             if(more)
  161.             {
  162.                data = iterator.current;
  163.                factory = getItemRendererFactory(data);
  164.                item = measuringObjects[factory];
  165.                if(!item)
  166.                {
  167.                   item = mx_internal::getMeasuringRenderer(data);
  168.                }
  169.                item.explicitWidth = NaN;
  170.                mx_internal::setupRendererFromData(item,data);
  171.                rw = Number(item.measuredWidth);
  172.                w = Math.max(w,rw);
  173.             }
  174.             if(more)
  175.             {
  176.                try
  177.                {
  178.                   more = iterator.moveNext();
  179.                }
  180.                catch(e:ItemPendingError)
  181.                {
  182.                   more = false;
  183.                }
  184.             }
  185.             i++;
  186.          }
  187.          if(iterator)
  188.          {
  189.             iterator.seek(bookmark,0);
  190.          }
  191.          if(w == 0)
  192.          {
  193.             if(explicitWidth)
  194.             {
  195.                return explicitWidth;
  196.             }
  197.             return DEFAULT_MEASURED_WIDTH;
  198.          }
  199.          paddingLeft = getStyle("paddingLeft");
  200.          paddingRight = getStyle("paddingRight");
  201.          w += paddingLeft + paddingRight;
  202.          return w;
  203.       }
  204.       
  205.       private function findNextEnterItemRenderer(param1:KeyboardEvent) : void
  206.       {
  207.          if(_proposedEditedItemPosition !== undefined)
  208.          {
  209.             return;
  210.          }
  211.          _editedItemPosition = lastEditedItemPosition;
  212.          var _loc2_:int = int(_editedItemPosition.rowIndex);
  213.          var _loc3_:int = int(_editedItemPosition.columnIndex);
  214.          var _loc4_:int = _editedItemPosition.rowIndex + (param1.shiftKey ? -1 : 1);
  215.          if(_loc4_ < collection.length && _loc4_ >= 0)
  216.          {
  217.             _loc2_ = _loc4_;
  218.          }
  219.          var _loc5_:ListEvent = new ListEvent(ListEvent.ITEM_EDIT_BEGINNING,false,true);
  220.          _loc5_.rowIndex = _loc2_;
  221.          _loc5_.columnIndex = 0;
  222.          dispatchEvent(_loc5_);
  223.       }
  224.       
  225.       public function get imeMode() : String
  226.       {
  227.          return _imeMode;
  228.       }
  229.       
  230.       private function mouseFocusChangeHandler(param1:MouseEvent) : void
  231.       {
  232.          if(itemEditorInstance && !param1.isDefaultPrevented() && itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  233.          {
  234.             param1.preventDefault();
  235.          }
  236.       }
  237.       
  238.       public function set imeMode(param1:String) : void
  239.       {
  240.          _imeMode = param1;
  241.       }
  242.       
  243.       override protected function mouseUpHandler(param1:MouseEvent) : void
  244.       {
  245.          var _loc2_:ListEvent = null;
  246.          var _loc3_:IListItemRenderer = null;
  247.          var _loc4_:Sprite = null;
  248.          var _loc5_:int = 0;
  249.          var _loc6_:int = 0;
  250.          var _loc7_:Point = null;
  251.          _loc3_ = mouseEventToItemRenderer(param1);
  252.          super.mouseUpHandler(param1);
  253.          if(_loc3_ && _loc3_.data && _loc3_ != itemEditorInstance)
  254.          {
  255.             _loc7_ = itemRendererToIndices(_loc3_);
  256.             if(editable && !dontEdit)
  257.             {
  258.                _loc2_ = new ListEvent(ListEvent.ITEM_EDIT_BEGINNING,false,true);
  259.                _loc2_.rowIndex = _loc7_.y;
  260.                _loc2_.columnIndex = 0;
  261.                _loc2_.itemRenderer = _loc3_;
  262.                dispatchEvent(_loc2_);
  263.             }
  264.          }
  265.       }
  266.       
  267.       private function itemEditorItemEditEndHandler(param1:ListEvent) : void
  268.       {
  269.          var bChanged:Boolean = false;
  270.          var bFieldChanged:Boolean = false;
  271.          var newData:Object = null;
  272.          var data:Object = null;
  273.          var editCollection:IList = null;
  274.          var listData:BaseListData = null;
  275.          var fm:IFocusManager = null;
  276.          var event:ListEvent = param1;
  277.          if(!event.isDefaultPrevented())
  278.          {
  279.             bChanged = false;
  280.             bFieldChanged = false;
  281.             newData = itemEditorInstance[editorDataField];
  282.             data = event.itemRenderer.data;
  283.             if(data is String)
  284.             {
  285.                if(!(newData is String))
  286.                {
  287.                   newData = newData.toString();
  288.                }
  289.             }
  290.             else if(data is uint)
  291.             {
  292.                if(!(newData is uint))
  293.                {
  294.                   newData = uint(newData);
  295.                }
  296.             }
  297.             else if(data is int)
  298.             {
  299.                if(!(newData is int))
  300.                {
  301.                   newData = int(newData);
  302.                }
  303.             }
  304.             else if(data is Number)
  305.             {
  306.                if(!(newData is int))
  307.                {
  308.                   newData = Number(newData);
  309.                }
  310.             }
  311.             else
  312.             {
  313.                bFieldChanged = true;
  314.                try
  315.                {
  316.                   data[labelField] = newData;
  317.                   if(!(data is IPropertyChangeNotifier))
  318.                   {
  319.                      if(actualCollection)
  320.                      {
  321.                         actualCollection.itemUpdated(data,labelField);
  322.                      }
  323.                      else
  324.                      {
  325.                         collection.itemUpdated(data,labelField);
  326.                      }
  327.                   }
  328.                }
  329.                catch(e:Error)
  330.                {
  331.                   trace("attempt to write to",labelField,"failed.  You may need a custom ITEM_EDIT_END handler");
  332.                }
  333.             }
  334.             if(!bFieldChanged)
  335.             {
  336.                if(data !== newData)
  337.                {
  338.                   bChanged = true;
  339.                   data = newData;
  340.                }
  341.                if(bChanged)
  342.                {
  343.                   editCollection = !!actualCollection ? actualCollection as IList : collection as IList;
  344.                   if(editCollection)
  345.                   {
  346.                      IList(editCollection).setItemAt(data,event.rowIndex);
  347.                   }
  348.                   else
  349.                   {
  350.                      trace("attempt to update collection failed.  You may need a custom ITEM_EDIT_END handler");
  351.                   }
  352.                }
  353.             }
  354.             if(event.itemRenderer is IDropInListItemRenderer)
  355.             {
  356.                listData = BaseListData(IDropInListItemRenderer(event.itemRenderer).listData);
  357.                listData.label = itemToLabel(data);
  358.                IDropInListItemRenderer(event.itemRenderer).listData = listData;
  359.             }
  360.             delete visibleData[itemToUID(event.itemRenderer.data)];
  361.             event.itemRenderer.data = data;
  362.             visibleData[itemToUID(data)] = event.itemRenderer;
  363.          }
  364.          else if(event.reason != ListEventReason.OTHER)
  365.          {
  366.             if(Boolean(itemEditorInstance) && Boolean(_editedItemPosition))
  367.             {
  368.                if(selectedIndex != _editedItemPosition.rowIndex)
  369.                {
  370.                   selectedIndex = _editedItemPosition.rowIndex;
  371.                }
  372.                fm = focusManager;
  373.                if(itemEditorInstance is IFocusManagerComponent)
  374.                {
  375.                   fm.setFocus(IFocusManagerComponent(itemEditorInstance));
  376.                }
  377.             }
  378.          }
  379.          if(event.reason == ListEventReason.OTHER || !event.isDefaultPrevented())
  380.          {
  381.             destroyItemEditor();
  382.          }
  383.       }
  384.       
  385.       private function itemEditorItemEditBeginningHandler(param1:ListEvent) : void
  386.       {
  387.          if(!param1.isDefaultPrevented())
  388.          {
  389.             setEditedItemPosition({
  390.                "columnIndex":param1.columnIndex,
  391.                "rowIndex":param1.rowIndex
  392.             });
  393.          }
  394.          else if(!itemEditorInstance)
  395.          {
  396.             _editedItemPosition = null;
  397.             editable = false;
  398.             setFocus();
  399.             editable = true;
  400.          }
  401.       }
  402.       
  403.       override public function createItemRenderer(param1:Object) : IListItemRenderer
  404.       {
  405.          var _loc2_:IFactory = null;
  406.          var _loc3_:IListItemRenderer = null;
  407.          var _loc4_:Dictionary = null;
  408.          var _loc5_:* = undefined;
  409.          _loc2_ = getItemRendererFactory(param1);
  410.          if(!_loc2_)
  411.          {
  412.             if(param1 == null)
  413.             {
  414.                _loc2_ = nullItemRenderer;
  415.             }
  416.             if(!_loc2_)
  417.             {
  418.                _loc2_ = itemRenderer;
  419.             }
  420.          }
  421.          if(_loc2_ == itemRenderer)
  422.          {
  423.             if(Boolean(freeItemRenderers) && Boolean(freeItemRenderers.length))
  424.             {
  425.                _loc3_ = freeItemRenderers.pop();
  426.                delete freeItemRenderersByFactory[_loc2_][_loc3_];
  427.             }
  428.          }
  429.          else if(freeItemRenderersByFactory)
  430.          {
  431.             _loc4_ = freeItemRenderersByFactory[_loc2_];
  432.             if(_loc4_)
  433.             {
  434.                var _loc6_:int = 0;
  435.                var _loc7_:* = _loc4_;
  436.                for(_loc5_ in _loc7_)
  437.                {
  438.                   _loc3_ = IListItemRenderer(_loc5_);
  439.                   delete _loc4_[_loc5_];
  440.                }
  441.             }
  442.          }
  443.          if(!_loc3_)
  444.          {
  445.             _loc3_ = _loc2_.newInstance();
  446.             _loc3_.styleName = this;
  447.             factoryMap[_loc3_] = _loc2_;
  448.          }
  449.          _loc3_.owner = this;
  450.          return _loc3_;
  451.       }
  452.       
  453.       override protected function focusOutHandler(param1:FocusEvent) : void
  454.       {
  455.          if(param1.target == this)
  456.          {
  457.             super.focusOutHandler(param1);
  458.          }
  459.          if(param1.relatedObject == this && itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  460.          {
  461.             return;
  462.          }
  463.          if(param1.relatedObject == null && itemRendererContains(editedItemRenderer,DisplayObject(param1.target)))
  464.          {
  465.             return;
  466.          }
  467.          if(param1.relatedObject == null && itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  468.          {
  469.             return;
  470.          }
  471.          if(Boolean(itemEditorInstance) && (!param1.relatedObject || !itemRendererContains(itemEditorInstance,param1.relatedObject)))
  472.          {
  473.             endEdit(ListEventReason.OTHER);
  474.             removeEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler);
  475.             removeEventListener(MouseEvent.MOUSE_DOWN,mouseFocusChangeHandler);
  476.          }
  477.       }
  478.       
  479.       override protected function scrollHorizontally(param1:int, param2:int, param3:Boolean) : void
  480.       {
  481.          var _loc4_:int = int(listItems.length);
  482.          var _loc5_:Number = getStyle("paddingLeft");
  483.          var _loc6_:int = 0;
  484.          while(_loc6_ < _loc4_)
  485.          {
  486.             if(listItems[_loc6_].length)
  487.             {
  488.                listItems[_loc6_][0].x = -param1 + _loc5_;
  489.             }
  490.             _loc6_++;
  491.          }
  492.       }
  493.       
  494.       override protected function drawHighlightIndicator(param1:Sprite, param2:Number, param3:Number, param4:Number, param5:Number, param6:uint, param7:IListItemRenderer) : void
  495.       {
  496.          super.drawHighlightIndicator(param1,0,param3,unscaledWidth - viewMetrics.left - viewMetrics.right,param5,param6,param7);
  497.       }
  498.       
  499.       [Bindable("itemFocusIn")]
  500.       public function get editedItemPosition() : Object
  501.       {
  502.          if(_editedItemPosition)
  503.          {
  504.             return {
  505.                "rowIndex":_editedItemPosition.rowIndex,
  506.                "columnIndex":0
  507.             };
  508.          }
  509.          return _editedItemPosition;
  510.       }
  511.       
  512.       private function setEditedItemPosition(param1:Object) : void
  513.       {
  514.          bEditedItemPositionChanged = true;
  515.          _proposedEditedItemPosition = param1;
  516.          invalidateDisplayList();
  517.       }
  518.       
  519.       override protected function drawRowBackgrounds() : void
  520.       {
  521.          var _loc2_:Array = null;
  522.          var _loc6_:int = 0;
  523.          var _loc1_:Sprite = Sprite(listContent.getChildByName("rowBGs"));
  524.          if(!_loc1_)
  525.          {
  526.             _loc1_ = new FlexSprite();
  527.             _loc1_.mouseEnabled = false;
  528.             _loc1_.name = "rowBGs";
  529.             listContent.addChildAt(_loc1_,0);
  530.          }
  531.          _loc2_ = getStyle("alternatingItemColors");
  532.          if(!_loc2_ || _loc2_.length == 0)
  533.          {
  534.             while(_loc1_.numChildren > _loc6_)
  535.             {
  536.                _loc1_.removeChildAt(_loc1_.numChildren - 1);
  537.             }
  538.             return;
  539.          }
  540.          StyleManager.getColorNames(_loc2_);
  541.          var _loc3_:int = 0;
  542.          var _loc4_:int = verticalScrollPosition;
  543.          var _loc5_:int = 0;
  544.          _loc6_ = int(listItems.length);
  545.          while(_loc3_ < _loc6_)
  546.          {
  547.             drawRowBackground(_loc1_,_loc5_++,rowInfo[_loc3_].y,rowInfo[_loc3_].height,_loc2_[_loc4_ % _loc2_.length],_loc4_);
  548.             _loc3_++;
  549.             _loc4_++;
  550.          }
  551.          while(_loc1_.numChildren > _loc6_)
  552.          {
  553.             _loc1_.removeChildAt(_loc1_.numChildren - 1);
  554.          }
  555.       }
  556.       
  557.       override protected function drawCaretIndicator(param1:Sprite, param2:Number, param3:Number, param4:Number, param5:Number, param6:uint, param7:IListItemRenderer) : void
  558.       {
  559.          super.drawCaretIndicator(param1,0,param3,unscaledWidth - viewMetrics.left - viewMetrics.right,param5,param6,param7);
  560.       }
  561.       
  562.       private function deactivateHandler(param1:Event) : void
  563.       {
  564.          if(itemEditorInstance)
  565.          {
  566.             endEdit(ListEventReason.OTHER);
  567.             losingFocus = true;
  568.             setFocus();
  569.          }
  570.       }
  571.       
  572.       protected function layoutEditor(param1:int, param2:int, param3:int, param4:int) : void
  573.       {
  574.          itemEditorInstance.move(param1,param2);
  575.          itemEditorInstance.setActualSize(param3,param4);
  576.       }
  577.       
  578.       private function editorKeyDownHandler(param1:KeyboardEvent) : void
  579.       {
  580.          if(param1.keyCode == Keyboard.ESCAPE)
  581.          {
  582.             endEdit(ListEventReason.CANCELLED);
  583.          }
  584.          else if(param1.ctrlKey && param1.charCode == 46)
  585.          {
  586.             endEdit(ListEventReason.CANCELLED);
  587.          }
  588.          else if(param1.charCode == Keyboard.ENTER && param1.keyCode != 229)
  589.          {
  590.             if(editorUsesEnterKey)
  591.             {
  592.                return;
  593.             }
  594.             if(endEdit(ListEventReason.NEW_ROW))
  595.             {
  596.                if(!dontEdit)
  597.                {
  598.                   findNextEnterItemRenderer(param1);
  599.                }
  600.             }
  601.          }
  602.       }
  603.       
  604.       private function itemEditorItemEditBeginHandler(param1:ListEvent) : void
  605.       {
  606.          var _loc2_:IFocusManager = null;
  607.          if(root)
  608.          {
  609.             systemManager.addEventListener(Event.DEACTIVATE,deactivateHandler,false,0,true);
  610.          }
  611.          if(!param1.isDefaultPrevented() && listItems[actualRowIndex][actualColIndex].data != null)
  612.          {
  613.             createItemEditor(param1.columnIndex,param1.rowIndex);
  614.             if(editedItemRenderer is IDropInListItemRenderer && itemEditorInstance is IDropInListItemRenderer)
  615.             {
  616.                IDropInListItemRenderer(itemEditorInstance).listData = IDropInListItemRenderer(editedItemRenderer).listData;
  617.             }
  618.             if(!rendererIsEditor)
  619.             {
  620.                itemEditorInstance.data = editedItemRenderer.data;
  621.             }
  622.             if(itemEditorInstance is IInvalidating)
  623.             {
  624.                IInvalidating(itemEditorInstance).validateNow();
  625.             }
  626.             if(itemEditorInstance is IIMESupport)
  627.             {
  628.                IIMESupport(itemEditorInstance).imeMode = imeMode;
  629.             }
  630.             _loc2_ = focusManager;
  631.             if(itemEditorInstance is IFocusManagerComponent)
  632.             {
  633.                _loc2_.setFocus(IFocusManagerComponent(itemEditorInstance));
  634.             }
  635.             _loc2_.defaultButtonEnabled = false;
  636.             param1 = new ListEvent(ListEvent.ITEM_FOCUS_IN);
  637.             param1.rowIndex = _editedItemPosition.rowIndex;
  638.             param1.itemRenderer = itemEditorInstance;
  639.             dispatchEvent(param1);
  640.          }
  641.       }
  642.       
  643.       private function editingTemporarilyPrevented(param1:Object) : Boolean
  644.       {
  645.          var _loc2_:int = 0;
  646.          var _loc3_:IListItemRenderer = null;
  647.          if(runningDataEffect && Boolean(param1))
  648.          {
  649.             _loc2_ = param1.rowIndex - verticalScrollPosition + offscreenExtraRowsTop;
  650.             if(_loc2_ < 0 || _loc2_ >= listItems.length)
  651.             {
  652.                return false;
  653.             }
  654.             _loc3_ = listItems[_loc2_][0];
  655.             if(Boolean(_loc3_) && (Boolean(getRendererSemanticValue(_loc3_,"replaced")) || Boolean(getRendererSemanticValue(_loc3_,"removed"))))
  656.             {
  657.                return true;
  658.             }
  659.          }
  660.          return false;
  661.       }
  662.       
  663.       override public function measureHeightOfItems(param1:int = -1, param2:int = 0) : Number
  664.       {
  665.          var ww:Number;
  666.          var paddingTop:Number;
  667.          var rh:Number;
  668.          var i:int;
  669.          var h:Number;
  670.          var more:Boolean;
  671.          var paddingBottom:Number;
  672.          var bookmark:CursorBookmark;
  673.          var data:Object = null;
  674.          var item:IListItemRenderer = null;
  675.          var index:int = param1;
  676.          var count:int = param2;
  677.          if(count == 0)
  678.          {
  679.             count = !!collection ? collection.length : 0;
  680.          }
  681.          paddingTop = getStyle("paddingTop");
  682.          paddingBottom = getStyle("paddingBottom");
  683.          ww = 200;
  684.          if(listContent.width)
  685.          {
  686.             ww = listContent.width;
  687.          }
  688.          h = 0;
  689.          bookmark = !!iterator ? iterator.bookmark : null;
  690.          if(index != -1 && Boolean(iterator))
  691.          {
  692.             iterator.seek(CursorBookmark.FIRST,index);
  693.          }
  694.          rh = rowHeight;
  695.          more = iterator != null;
  696.          i = 0;
  697.          while(i < count)
  698.          {
  699.             if(more)
  700.             {
  701.                rh = rowHeight;
  702.                data = iterator.current;
  703.                item = mx_internal::getMeasuringRenderer(data);
  704.                item.explicitWidth = ww;
  705.                mx_internal::setupRendererFromData(item,data);
  706.                if(variableRowHeight)
  707.                {
  708.                   rh = item.getExplicitOrMeasuredHeight() + paddingTop + paddingBottom;
  709.                }
  710.             }
  711.             h += rh;
  712.             if(more)
  713.             {
  714.                try
  715.                {
  716.                   more = iterator.moveNext();
  717.                }
  718.                catch(e:ItemPendingError)
  719.                {
  720.                   more = false;
  721.                }
  722.             }
  723.             i++;
  724.          }
  725.          if(iterator)
  726.          {
  727.             iterator.seek(bookmark,0);
  728.          }
  729.          return h;
  730.       }
  731.       
  732.       mx_internal function callSetupRendererFromData(param1:IListItemRenderer, param2:Object) : void
  733.       {
  734.          mx_internal::setupRendererFromData(param1,param2);
  735.       }
  736.       
  737.       override protected function drawSelectionIndicator(param1:Sprite, param2:Number, param3:Number, param4:Number, param5:Number, param6:uint, param7:IListItemRenderer) : void
  738.       {
  739.          super.drawSelectionIndicator(param1,0,param3,unscaledWidth - viewMetrics.left - viewMetrics.right,param5,param6,param7);
  740.       }
  741.       
  742.       private function keyFocusChangeHandler(param1:FocusEvent) : void
  743.       {
  744.          if(param1.keyCode == Keyboard.TAB && !param1.isDefaultPrevented() && findNextItemRenderer(param1.shiftKey))
  745.          {
  746.             param1.preventDefault();
  747.          }
  748.       }
  749.       
  750.       public function set editedItemPosition(param1:Object) : void
  751.       {
  752.          var _loc2_:Object = {
  753.             "rowIndex":param1.rowIndex,
  754.             "columnIndex":0
  755.          };
  756.          setEditedItemPosition(_loc2_);
  757.       }
  758.       
  759.       override protected function makeRowsAndColumns(param1:Number, param2:Number, param3:Number, param4:Number, param5:int, param6:int, param7:Boolean = false, param8:uint = 0) : Point
  760.       {
  761.          var paddingRight:Number;
  762.          var xx:Number;
  763.          var rowsMade:int;
  764.          var bSelected:Boolean;
  765.          var paddingLeft:Number;
  766.          var bCaret:Boolean;
  767.          var rowNum:int;
  768.          var colNum:int;
  769.          var ww:Number;
  770.          var more:Boolean;
  771.          var bHighlight:Boolean;
  772.          var valid:Boolean;
  773.          var yy:Number = NaN;
  774.          var hh:Number = NaN;
  775.          var i:int = 0;
  776.          var j:int = 0;
  777.          var item:IListItemRenderer = null;
  778.          var oldItem:IListItemRenderer = null;
  779.          var rowData:BaseListData = null;
  780.          var data:Object = null;
  781.          var wrappedData:Object = null;
  782.          var uid:String = null;
  783.          var rh:Number = NaN;
  784.          var ld:BaseListData = null;
  785.          var rr:Array = null;
  786.          var rowInfo:ListRowInfo = null;
  787.          var dx:Number = NaN;
  788.          var dy:Number = NaN;
  789.          var dw:Number = NaN;
  790.          var dh:Number = NaN;
  791.          var left:Number = param1;
  792.          var top:Number = param2;
  793.          var right:Number = param3;
  794.          var bottom:Number = param4;
  795.          var firstCol:int = param5;
  796.          var firstRow:int = param6;
  797.          var byCount:Boolean = param7;
  798.          var rowsNeeded:uint = param8;
  799.          listContent.mx_internal::allowItemSizeChangeNotification = false;
  800.          paddingLeft = getStyle("paddingLeft");
  801.          paddingRight = getStyle("paddingRight");
  802.          xx = left + paddingLeft - horizontalScrollPosition;
  803.          ww = right - paddingLeft - paddingRight;
  804.          bSelected = false;
  805.          bHighlight = false;
  806.          bCaret = false;
  807.          colNum = 0;
  808.          rowNum = lockedRowCount;
  809.          rowsMade = 0;
  810.          more = true;
  811.          valid = true;
  812.          yy = top;
  813.          rowNum = firstRow;
  814.          more = iterator != null && !iterator.afterLast && iteratorValid;
  815.          while(!byCount && yy < bottom || byCount && rowsNeeded > 0)
  816.          {
  817.             if(byCount)
  818.             {
  819.                rowsNeeded--;
  820.             }
  821.             valid = more;
  822.             wrappedData = more ? iterator.current : null;
  823.             data = wrappedData is ItemWrapper ? wrappedData.data : wrappedData;
  824.             uid = null;
  825.             if(!listItems[rowNum])
  826.             {
  827.                listItems[rowNum] = [];
  828.             }
  829.             if(valid)
  830.             {
  831.                item = listItems[rowNum][colNum];
  832.                uid = itemToUID(wrappedData);
  833.                if(!item || (runningDataEffect && Boolean(dataItemWrappersByRenderer[item]) ? dataItemWrappersByRenderer[item] != wrappedData : item.data != data))
  834.                {
  835.                   if(mx_internal::allowRendererStealingDuringLayout)
  836.                   {
  837.                      item = visibleData[uid];
  838.                      if(!item && wrappedData != data)
  839.                      {
  840.                         item = visibleData[itemToUID(data)];
  841.                      }
  842.                   }
  843.                   if(item)
  844.                   {
  845.                      ld = BaseListData(rowMap[item.name]);
  846.                      if(Boolean(ld) && ld.rowIndex > rowNum)
  847.                      {
  848.                         listItems[ld.rowIndex] = [];
  849.                      }
  850.                      else
  851.                      {
  852.                         item = null;
  853.                      }
  854.                   }
  855.                   if(!item)
  856.                   {
  857.                      item = getReservedOrFreeItemRenderer(wrappedData);
  858.                   }
  859.                   if(!item)
  860.                   {
  861.                      item = createItemRenderer(data);
  862.                      item.owner = this;
  863.                      item.styleName = listContent;
  864.                      listContent.addChild(DisplayObject(item));
  865.                   }
  866.                   oldItem = listItems[rowNum][colNum];
  867.                   if(oldItem)
  868.                   {
  869.                      addToFreeItemRenderers(oldItem);
  870.                   }
  871.                   listItems[rowNum][colNum] = item;
  872.                }
  873.                rowData = makeListData(data,uid,rowNum);
  874.                rowMap[item.name] = rowData;
  875.                if(item is IDropInListItemRenderer)
  876.                {
  877.                   if(data != null)
  878.                   {
  879.                      IDropInListItemRenderer(item).listData = rowData;
  880.                   }
  881.                   else
  882.                   {
  883.                      IDropInListItemRenderer(item).listData = null;
  884.                   }
  885.                }
  886.                item.data = data;
  887.                item.enabled = enabled;
  888.                item.visible = true;
  889.                if(uid != null)
  890.                {
  891.                   visibleData[uid] = item;
  892.                }
  893.                if(wrappedData != data)
  894.                {
  895.                   dataItemWrappersByRenderer[item] = wrappedData;
  896.                }
  897.                item.explicitWidth = ww;
  898.                if(item is IInvalidating && (wordWrapChanged || variableRowHeight))
  899.                {
  900.                   IInvalidating(item).invalidateSize();
  901.                }
  902.                UIComponentGlobals.mx_internal::layoutManager.validateClient(item,true);
  903.                hh = Math.ceil(variableRowHeight ? item.getExplicitOrMeasuredHeight() + mx_internal::cachedPaddingTop + mx_internal::cachedPaddingBottom : rowHeight);
  904.                rh = Number(item.getExplicitOrMeasuredHeight());
  905.                item.setActualSize(ww,variableRowHeight ? rh : rowHeight - mx_internal::cachedPaddingTop - mx_internal::cachedPaddingBottom);
  906.                item.move(xx,yy + mx_internal::cachedPaddingTop);
  907.             }
  908.             else
  909.             {
  910.                hh = rowNum > 0 ? Number(rowInfo[rowNum - 1].height) : rowHeight;
  911.                if(hh == 0)
  912.                {
  913.                   hh = rowHeight;
  914.                }
  915.                oldItem = listItems[rowNum][colNum];
  916.                if(oldItem)
  917.                {
  918.                   addToFreeItemRenderers(oldItem);
  919.                   listItems[rowNum].splice(colNum,1);
  920.                }
  921.             }
  922.             bSelected = selectedData[uid] != null;
  923.             if(wrappedData != data)
  924.             {
  925.                bSelected ||= Boolean(selectedData[itemToUID(data)]);
  926.                bSelected = bSelected && !getRendererSemanticValue(item,ModifiedCollectionView.REPLACEMENT) && !getRendererSemanticValue(item,ModifiedCollectionView.ADDED);
  927.             }
  928.             bHighlight = highlightUID == uid;
  929.             bCaret = caretUID == uid;
  930.             rowInfo[rowNum] = new ListRowInfo(yy,hh,uid,data);
  931.             if(valid)
  932.             {
  933.                drawItem(item,bSelected,bHighlight,bCaret);
  934.             }
  935.             yy += hh;
  936.             rowNum++;
  937.             rowsMade++;
  938.             if(Boolean(iterator) && more)
  939.             {
  940.                try
  941.                {
  942.                   more = iterator.moveNext();
  943.                }
  944.                catch(e:ItemPendingError)
  945.                {
  946.                   lastSeekPending = new ListBaseSeekPending(CursorBookmark.CURRENT,0);
  947.                   e.addResponder(new ItemResponder(seekPendingResultHandler,seekPendingFailureHandler,lastSeekPending));
  948.                   more = false;
  949.                   iteratorValid = false;
  950.                }
  951.             }
  952.          }
  953.          if(!byCount)
  954.          {
  955.             while(rowNum < listItems.length)
  956.             {
  957.                rr = listItems.pop();
  958.                rowInfo.pop();
  959.                while(rr.length)
  960.                {
  961.                   item = rr.pop();
  962.                   addToFreeItemRenderers(item);
  963.                }
  964.             }
  965.          }
  966.          if(itemEditorInstance)
  967.          {
  968.             listContent.setChildIndex(DisplayObject(itemEditorInstance),listContent.numChildren - 1);
  969.             item = listItems[actualRowIndex][actualColIndex];
  970.             rowInfo = rowInfo[actualRowIndex];
  971.             if(Boolean(item) && !rendererIsEditor)
  972.             {
  973.                dx = editorXOffset;
  974.                dy = editorYOffset;
  975.                dw = editorWidthOffset;
  976.                dh = editorHeightOffset;
  977.                layoutEditor(item.x + dx,rowInfo.y + dy,Math.min(item.width + dw,listContent.width - listContent.x - itemEditorInstance.x),Math.min(rowInfo.height + dh,listContent.height - listContent.y - itemEditorInstance.y));
  978.             }
  979.          }
  980.          listContent.mx_internal::allowItemSizeChangeNotification = variableRowHeight;
  981.          return new Point(colNum,rowsMade);
  982.       }
  983.       
  984.       override protected function measure() : void
  985.       {
  986.          super.measure();
  987.          var _loc1_:EdgeMetrics = viewMetrics;
  988.          measuredMinWidth = DEFAULT_MEASURED_MIN_WIDTH;
  989.          if(initialized && variableRowHeight && explicitRowCount < 1 && isNaN(explicitRowHeight))
  990.          {
  991.             measuredHeight = height;
  992.          }
  993.       }
  994.       
  995.       private function findNextItemRenderer(param1:Boolean) : Boolean
  996.       {
  997.          if(!lastEditedItemPosition)
  998.          {
  999.             return false;
  1000.          }
  1001.          if(_proposedEditedItemPosition !== undefined)
  1002.          {
  1003.             return true;
  1004.          }
  1005.          _editedItemPosition = lastEditedItemPosition;
  1006.          var _loc2_:int = int(_editedItemPosition.rowIndex);
  1007.          var _loc3_:int = int(_editedItemPosition.columnIndex);
  1008.          var _loc4_:int = _editedItemPosition.rowIndex + (param1 ? -1 : 1);
  1009.          if(_loc4_ < collection.length && _loc4_ >= 0)
  1010.          {
  1011.             _loc2_ = _loc4_;
  1012.             var _loc5_:ListEvent = new ListEvent(ListEvent.ITEM_EDIT_BEGINNING,false,true);
  1013.             _loc5_.rowIndex = _loc2_;
  1014.             _loc5_.columnIndex = _loc3_;
  1015.             dispatchEvent(_loc5_);
  1016.             return true;
  1017.          }
  1018.          setEditedItemPosition(null);
  1019.          losingFocus = true;
  1020.          setFocus();
  1021.          return false;
  1022.       }
  1023.       
  1024.       override protected function mouseDownHandler(param1:MouseEvent) : void
  1025.       {
  1026.          var _loc2_:IListItemRenderer = null;
  1027.          var _loc3_:Sprite = null;
  1028.          var _loc5_:Point = null;
  1029.          var _loc6_:Boolean = false;
  1030.          _loc2_ = mouseEventToItemRenderer(param1);
  1031.          var _loc4_:Boolean = itemRendererContains(itemEditorInstance,DisplayObject(param1.target));
  1032.          if(!_loc4_)
  1033.          {
  1034.             if(Boolean(_loc2_) && Boolean(_loc2_.data))
  1035.             {
  1036.                _loc5_ = itemRendererToIndices(_loc2_);
  1037.                _loc6_ = true;
  1038.                if(itemEditorInstance)
  1039.                {
  1040.                   _loc6_ = endEdit(ListEventReason.NEW_ROW);
  1041.                }
  1042.                if(!_loc6_)
  1043.                {
  1044.                   return;
  1045.                }
  1046.             }
  1047.             else if(itemEditorInstance)
  1048.             {
  1049.                endEdit(ListEventReason.OTHER);
  1050.             }
  1051.             super.mouseDownHandler(param1);
  1052.          }
  1053.       }
  1054.       
  1055.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  1056.       {
  1057.          if(itemEditorInstance)
  1058.          {
  1059.             return;
  1060.          }
  1061.          super.keyDownHandler(param1);
  1062.       }
  1063.       
  1064.       override protected function focusInHandler(param1:FocusEvent) : void
  1065.       {
  1066.          var _loc2_:* = false;
  1067.          if(param1.target != this)
  1068.          {
  1069.             return;
  1070.          }
  1071.          if(losingFocus)
  1072.          {
  1073.             losingFocus = false;
  1074.             return;
  1075.          }
  1076.          super.focusInHandler(param1);
  1077.          if(editable && !mx_internal::isPressed)
  1078.          {
  1079.             _editedItemPosition = lastEditedItemPosition;
  1080.             _loc2_ = editedItemPosition != null;
  1081.             if(!_editedItemPosition)
  1082.             {
  1083.                _editedItemPosition = {
  1084.                   "rowIndex":0,
  1085.                   "columnIndex":0
  1086.                };
  1087.                _loc2_ = Boolean(listItems.length) && listItems[0].length > 0;
  1088.             }
  1089.             if(_loc2_)
  1090.             {
  1091.                setEditedItemPosition(_editedItemPosition);
  1092.             }
  1093.          }
  1094.          if(editable)
  1095.          {
  1096.             addEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler);
  1097.             addEventListener(MouseEvent.MOUSE_DOWN,mouseFocusChangeHandler);
  1098.          }
  1099.       }
  1100.       
  1101.       override protected function mouseEventToItemRenderer(param1:MouseEvent) : IListItemRenderer
  1102.       {
  1103.          var _loc2_:IListItemRenderer = super.mouseEventToItemRenderer(param1);
  1104.          return _loc2_ == itemEditorInstance ? null : _loc2_;
  1105.       }
  1106.       
  1107.       protected function makeListData(param1:Object, param2:String, param3:int) : BaseListData
  1108.       {
  1109.          return new ListData(itemToLabel(param1),itemToIcon(param1),labelField,param2,this,param3);
  1110.       }
  1111.       
  1112.       public function createItemEditor(param1:int, param2:int) : void
  1113.       {
  1114.          var _loc5_:Number = NaN;
  1115.          var _loc6_:Number = NaN;
  1116.          var _loc7_:Number = NaN;
  1117.          var _loc8_:Number = NaN;
  1118.          param1 = 0;
  1119.          if(param2 > lockedRowCount)
  1120.          {
  1121.             param2 -= verticalScrollPosition;
  1122.          }
  1123.          var _loc3_:IListItemRenderer = listItems[param2][param1];
  1124.          var _loc4_:ListRowInfo = rowInfo[param2];
  1125.          if(!rendererIsEditor)
  1126.          {
  1127.             _loc5_ = 0;
  1128.             _loc6_ = -2;
  1129.             _loc7_ = 0;
  1130.             _loc8_ = 4;
  1131.             if(!itemEditorInstance)
  1132.             {
  1133.                _loc5_ = editorXOffset;
  1134.                _loc6_ = editorYOffset;
  1135.                _loc7_ = editorWidthOffset;
  1136.                _loc8_ = editorHeightOffset;
  1137.                itemEditorInstance = itemEditor.newInstance();
  1138.                itemEditorInstance.owner = this;
  1139.                itemEditorInstance.styleName = this;
  1140.                listContent.addChild(DisplayObject(itemEditorInstance));
  1141.             }
  1142.             listContent.setChildIndex(DisplayObject(itemEditorInstance),listContent.numChildren - 1);
  1143.             itemEditorInstance.visible = true;
  1144.             layoutEditor(_loc3_.x + _loc5_,_loc4_.y + _loc6_,Math.min(_loc3_.width + _loc7_,listContent.width - listContent.x - itemEditorInstance.x),Math.min(_loc4_.height + _loc8_,listContent.height - listContent.y - itemEditorInstance.y));
  1145.             DisplayObject(itemEditorInstance).addEventListener("focusOut",itemEditorFocusOutHandler);
  1146.          }
  1147.          else
  1148.          {
  1149.             itemEditorInstance = _loc3_;
  1150.          }
  1151.          DisplayObject(itemEditorInstance).addEventListener(KeyboardEvent.KEY_DOWN,editorKeyDownHandler);
  1152.          systemManager.getSandboxRoot().addEventListener(MouseEvent.MOUSE_DOWN,editorMouseDownHandler,true,0,true);
  1153.          systemManager.getSandboxRoot().addEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,editorMouseDownHandler,false,0,true);
  1154.       }
  1155.       
  1156.       public function get lockedRowCount() : int
  1157.       {
  1158.          return mx_internal::_lockedRowCount;
  1159.       }
  1160.       
  1161.       override public function set enabled(param1:Boolean) : void
  1162.       {
  1163.          super.enabled = param1;
  1164.          if(itemEditorInstance)
  1165.          {
  1166.             endEdit(ListEventReason.OTHER);
  1167.          }
  1168.          invalidateDisplayList();
  1169.       }
  1170.       
  1171.       protected function endEdit(param1:String) : Boolean
  1172.       {
  1173.          if(!editedItemRenderer)
  1174.          {
  1175.             return true;
  1176.          }
  1177.          inEndEdit = true;
  1178.          var _loc2_:ListEvent = new ListEvent(ListEvent.ITEM_EDIT_END,false,true);
  1179.          _loc2_.rowIndex = editedItemPosition.rowIndex;
  1180.          _loc2_.itemRenderer = editedItemRenderer;
  1181.          _loc2_.reason = param1;
  1182.          dispatchEvent(_loc2_);
  1183.          dontEdit = itemEditorInstance != null;
  1184.          if(!dontEdit && param1 == ListEventReason.CANCELLED)
  1185.          {
  1186.             losingFocus = true;
  1187.             setFocus();
  1188.          }
  1189.          inEndEdit = false;
  1190.          return !_loc2_.isDefaultPrevented();
  1191.       }
  1192.       
  1193.       override protected function collectionChangeHandler(param1:Event) : void
  1194.       {
  1195.          var _loc2_:CollectionEvent = null;
  1196.          if(param1 is CollectionEvent)
  1197.          {
  1198.             _loc2_ = CollectionEvent(param1);
  1199.             if(_loc2_.kind == CollectionEventKind.REMOVE)
  1200.             {
  1201.                if(editedItemPosition)
  1202.                {
  1203.                   if(collection.length == 0)
  1204.                   {
  1205.                      if(itemEditorInstance)
  1206.                      {
  1207.                         endEdit(ListEventReason.CANCELLED);
  1208.                      }
  1209.                      setEditedItemPosition(null);
  1210.                   }
  1211.                   else if(_loc2_.location <= editedItemPosition.rowIndex)
  1212.                   {
  1213.                      if(inEndEdit)
  1214.                      {
  1215.                         _editedItemPosition = {
  1216.                            "columnIndex":editedItemPosition.columnIndex,
  1217.                            "rowIndex":Math.max(0,editedItemPosition.rowIndex - _loc2_.items.length)
  1218.                         };
  1219.                      }
  1220.                      else
  1221.                      {
  1222.                         setEditedItemPosition({
  1223.                            "columnIndex":editedItemPosition.columnIndex,
  1224.                            "rowIndex":Math.max(0,editedItemPosition.rowIndex - _loc2_.items.length)
  1225.                         });
  1226.                      }
  1227.                   }
  1228.                }
  1229.             }
  1230.          }
  1231.          super.collectionChangeHandler(param1);
  1232.       }
  1233.       
  1234.       override public function get baselinePosition() : Number
  1235.       {
  1236.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  1237.          {
  1238.             if(Boolean(listItems.length) && Boolean(listItems[0].length))
  1239.             {
  1240.                return borderMetrics.top + mx_internal::cachedPaddingTop + listItems[0][0].baselinePosition;
  1241.             }
  1242.             return NaN;
  1243.          }
  1244.          return super.baselinePosition;
  1245.       }
  1246.       
  1247.       private function itemEditorFocusOutHandler(param1:FocusEvent) : void
  1248.       {
  1249.          if(Boolean(param1.relatedObject) && contains(param1.relatedObject))
  1250.          {
  1251.             return;
  1252.          }
  1253.          if(!param1.relatedObject)
  1254.          {
  1255.             return;
  1256.          }
  1257.          if(itemEditorInstance)
  1258.          {
  1259.             endEdit(ListEventReason.OTHER);
  1260.          }
  1261.       }
  1262.       
  1263.       override public function set dataProvider(param1:Object) : void
  1264.       {
  1265.          if(itemEditorInstance)
  1266.          {
  1267.             endEdit(ListEventReason.OTHER);
  1268.          }
  1269.          super.dataProvider = param1;
  1270.       }
  1271.       
  1272.       override protected function initializeAccessibility() : void
  1273.       {
  1274.          if(mx_internal::createAccessibilityImplementation != null)
  1275.          {
  1276.             mx_internal::createAccessibilityImplementation(this);
  1277.          }
  1278.       }
  1279.       
  1280.       override protected function configureScrollBars() : void
  1281.       {
  1282.          var _loc2_:Number = NaN;
  1283.          var _loc3_:int = 0;
  1284.          var _loc1_:int = int(listItems.length);
  1285.          if(_loc1_ == 0)
  1286.          {
  1287.             return;
  1288.          }
  1289.          var _loc4_:int = int(listItems.length);
  1290.          while(_loc1_ > 1 && rowInfo[_loc4_ - 1].y + rowInfo[_loc4_ - 1].height > listContent.height - listContent.bottomOffset)
  1291.          {
  1292.             _loc1_--;
  1293.             _loc4_--;
  1294.          }
  1295.          var _loc5_:int = verticalScrollPosition - lockedRowCount - 1;
  1296.          var _loc6_:int = 0;
  1297.          while(Boolean(_loc1_) && listItems[_loc1_ - 1].length == 0)
  1298.          {
  1299.             if(!(Boolean(collection) && _loc1_ + _loc5_ >= collection.length))
  1300.             {
  1301.                break;
  1302.             }
  1303.             _loc1_--;
  1304.             _loc6_++;
  1305.          }
  1306.          if(verticalScrollPosition > 0 && _loc6_ > 0 && !runningDataEffect)
  1307.          {
  1308.             if(adjustVerticalScrollPositionDownward(Math.max(_loc1_,1)))
  1309.             {
  1310.                return;
  1311.             }
  1312.          }
  1313.          if(listContent.topOffset)
  1314.          {
  1315.             _loc2_ = Math.abs(listContent.topOffset);
  1316.             _loc3_ = 0;
  1317.             while(rowInfo[_loc3_].y + rowInfo[_loc3_].height <= _loc2_)
  1318.             {
  1319.                _loc1_--;
  1320.                _loc3_++;
  1321.                if(_loc3_ == _loc1_)
  1322.                {
  1323.                   break;
  1324.                }
  1325.             }
  1326.          }
  1327.          var _loc7_:int = int(listItems[0].length);
  1328.          var _loc8_:Object = horizontalScrollBar;
  1329.          var _loc9_:Object = verticalScrollBar;
  1330.          var _loc10_:int = Math.round(unscaledWidth);
  1331.          var _loc11_:int = !!collection ? collection.length - lockedRowCount : 0;
  1332.          var _loc12_:int = _loc1_ - lockedRowCount;
  1333.          setScrollBarProperties(isNaN(mx_internal::_maxHorizontalScrollPosition) ? int(Math.round(listContent.width)) : int(Math.round(mx_internal::_maxHorizontalScrollPosition + _loc10_)),_loc10_,_loc11_,_loc12_);
  1334.          maxVerticalScrollPosition = Math.max(_loc11_ - _loc12_,0);
  1335.       }
  1336.       
  1337.       override protected function mouseWheelHandler(param1:MouseEvent) : void
  1338.       {
  1339.          if(itemEditorInstance)
  1340.          {
  1341.             endEdit(ListEventReason.OTHER);
  1342.          }
  1343.          super.mouseWheelHandler(param1);
  1344.       }
  1345.       
  1346.       override public function set maxHorizontalScrollPosition(param1:Number) : void
  1347.       {
  1348.          super.maxHorizontalScrollPosition = param1;
  1349.          scrollAreaChanged = true;
  1350.          invalidateDisplayList();
  1351.       }
  1352.       
  1353.       override protected function scrollHandler(param1:Event) : void
  1354.       {
  1355.          var scrollBar:ScrollBar = null;
  1356.          var pos:Number = NaN;
  1357.          var delta:int = 0;
  1358.          var o:EdgeMetrics = null;
  1359.          var bookmark:CursorBookmark = null;
  1360.          var event:Event = param1;
  1361.          if(event is ScrollEvent)
  1362.          {
  1363.             if(itemEditorInstance)
  1364.             {
  1365.                endEdit(ListEventReason.OTHER);
  1366.             }
  1367.             if(!liveScrolling && ScrollEvent(event).detail == ScrollEventDetail.THUMB_TRACK)
  1368.             {
  1369.                return;
  1370.             }
  1371.             scrollBar = ScrollBar(event.target);
  1372.             pos = scrollBar.scrollPosition;
  1373.             mx_internal::removeClipMask();
  1374.             if(scrollBar == verticalScrollBar)
  1375.             {
  1376.                delta = pos - verticalScrollPosition;
  1377.                super.scrollHandler(event);
  1378.                if(Math.abs(delta) >= listItems.length - lockedRowCount || !iteratorValid)
  1379.                {
  1380.                   try
  1381.                   {
  1382.                      if(!iteratorValid)
  1383.                      {
  1384.                         iterator.seek(CursorBookmark.FIRST,pos);
  1385.                      }
  1386.                      else
  1387.                      {
  1388.                         iterator.seek(CursorBookmark.CURRENT,delta);
  1389.                      }
  1390.                      if(!iteratorValid)
  1391.                      {
  1392.                         iteratorValid = true;
  1393.                         lastSeekPending = null;
  1394.                      }
  1395.                   }
  1396.                   catch(e:ItemPendingError)
  1397.                   {
  1398.                      lastSeekPending = new ListBaseSeekPending(CursorBookmark.FIRST,pos);
  1399.                      e.addResponder(new ItemResponder(seekPendingResultHandler,seekPendingFailureHandler,lastSeekPending));
  1400.                      iteratorValid = false;
  1401.                   }
  1402.                   bookmark = iterator.bookmark;
  1403.                   clearIndicators();
  1404.                   clearVisibleData();
  1405.                   makeRowsAndColumns(0,0,listContent.width,listContent.height,0,0);
  1406.                   iterator.seek(bookmark,0);
  1407.                }
  1408.                else if(delta != 0)
  1409.                {
  1410.                   scrollVertically(pos,Math.abs(delta),Boolean(delta > 0));
  1411.                }
  1412.                if(variableRowHeight)
  1413.                {
  1414.                   configureScrollBars();
  1415.                }
  1416.                drawRowBackgrounds();
  1417.             }
  1418.             else
  1419.             {
  1420.                delta = pos - mx_internal::_horizontalScrollPosition;
  1421.                super.scrollHandler(event);
  1422.                scrollHorizontally(pos,Math.abs(delta),Boolean(delta > 0));
  1423.             }
  1424.             mx_internal::addClipMask(false);
  1425.          }
  1426.       }
  1427.       
  1428.       public function get editedItemRenderer() : IListItemRenderer
  1429.       {
  1430.          if(!itemEditorInstance)
  1431.          {
  1432.             return null;
  1433.          }
  1434.          return listItems[actualRowIndex][actualColIndex];
  1435.       }
  1436.       
  1437.       private function commitEditedItemPosition(param1:Object) : void
  1438.       {
  1439.          var _loc10_:String = null;
  1440.          if(!enabled || !editable)
  1441.          {
  1442.             return;
  1443.          }
  1444.          if(itemEditorInstance && param1 && itemEditorInstance is IFocusManagerComponent && _editedItemPosition.rowIndex == param1.rowIndex)
  1445.          {
  1446.             IFocusManagerComponent(itemEditorInstance).setFocus();
  1447.             return;
  1448.          }
  1449.          if(itemEditorInstance)
  1450.          {
  1451.             if(!param1)
  1452.             {
  1453.                _loc10_ = ListEventReason.OTHER;
  1454.             }
  1455.             else
  1456.             {
  1457.                _loc10_ = ListEventReason.NEW_ROW;
  1458.             }
  1459.             if(!endEdit(_loc10_) && _loc10_ != ListEventReason.OTHER)
  1460.             {
  1461.                return;
  1462.             }
  1463.          }
  1464.          _editedItemPosition = param1;
  1465.          if(!param1 || dontEdit)
  1466.          {
  1467.             return;
  1468.          }
  1469.          var _loc2_:int = int(param1.rowIndex);
  1470.          var _loc3_:int = int(param1.columnIndex);
  1471.          if(selectedIndex != param1.rowIndex)
  1472.          {
  1473.             mx_internal::commitSelectedIndex(param1.rowIndex);
  1474.          }
  1475.          var _loc4_:int = lockedRowCount;
  1476.          var _loc5_:int = verticalScrollPosition + listItems.length - offscreenExtraRowsTop - offscreenExtraRowsBottom - 1;
  1477.          var _loc6_:int = rowInfo[listItems.length - offscreenExtraRowsBottom - 1].y + rowInfo[listItems.length - offscreenExtraRowsBottom - 1].height > listContent.height ? 1 : 0;
  1478.          if(_loc2_ > _loc4_)
  1479.          {
  1480.             if(_loc2_ < verticalScrollPosition + _loc4_)
  1481.             {
  1482.                verticalScrollPosition = _loc2_ - _loc4_;
  1483.             }
  1484.             else
  1485.             {
  1486.                while(_loc2_ > _loc5_ || _loc2_ == _loc5_ && _loc2_ > verticalScrollPosition + _loc4_ && _loc6_)
  1487.                {
  1488.                   if(verticalScrollPosition == maxVerticalScrollPosition)
  1489.                   {
  1490.                      break;
  1491.                   }
  1492.                   verticalScrollPosition = Math.min(verticalScrollPosition + (_loc2_ > _loc5_ ? _loc2_ - _loc5_ : _loc6_),maxVerticalScrollPosition);
  1493.                   _loc5_ = verticalScrollPosition + listItems.length - offscreenExtraRowsTop - offscreenExtraRowsBottom - 1;
  1494.                   _loc6_ = rowInfo[listItems.length - offscreenExtraRowsBottom - 1].y + rowInfo[listItems.length - offscreenExtraRowsBottom - 1].height > listContent.height ? 1 : 0;
  1495.                }
  1496.             }
  1497.             actualRowIndex = _loc2_ - verticalScrollPosition;
  1498.          }
  1499.          else
  1500.          {
  1501.             if(_loc2_ == _loc4_)
  1502.             {
  1503.                verticalScrollPosition = 0;
  1504.             }
  1505.             actualRowIndex = _loc2_;
  1506.          }
  1507.          var _loc7_:EdgeMetrics = borderMetrics;
  1508.          actualColIndex = _loc3_;
  1509.          var _loc8_:IListItemRenderer = listItems[actualRowIndex][actualColIndex];
  1510.          if(!_loc8_)
  1511.          {
  1512.             commitEditedItemPosition(null);
  1513.             return;
  1514.          }
  1515.          if(!isItemEditable(_loc8_.data))
  1516.          {
  1517.             commitEditedItemPosition(null);
  1518.             return;
  1519.          }
  1520.          var _loc9_:ListEvent = new ListEvent(ListEvent.ITEM_EDIT_BEGIN,false,true);
  1521.          _loc9_.rowIndex = _editedItemPosition.rowIndex;
  1522.          _loc9_.itemRenderer = _loc8_;
  1523.          dispatchEvent(_loc9_);
  1524.          lastEditedItemPosition = _editedItemPosition;
  1525.          if(bEditedItemPositionChanged)
  1526.          {
  1527.             bEditedItemPositionChanged = false;
  1528.             commitEditedItemPosition(_proposedEditedItemPosition);
  1529.             _proposedEditedItemPosition = undefined;
  1530.          }
  1531.          if(!itemEditorInstance)
  1532.          {
  1533.             commitEditedItemPosition(null);
  1534.          }
  1535.       }
  1536.       
  1537.       protected function drawRowBackground(param1:Sprite, param2:int, param3:Number, param4:Number, param5:uint, param6:int) : void
  1538.       {
  1539.          var _loc7_:Shape = null;
  1540.          if(param2 < param1.numChildren)
  1541.          {
  1542.             _loc7_ = Shape(param1.getChildAt(param2));
  1543.          }
  1544.          else
  1545.          {
  1546.             _loc7_ = new FlexShape();
  1547.             _loc7_.name = "rowBackground";
  1548.             param1.addChild(_loc7_);
  1549.          }
  1550.          param4 = Math.min(rowInfo[param2].height,listContent.height - rowInfo[param2].y);
  1551.          _loc7_.y = rowInfo[param2].y;
  1552.          var _loc8_:Graphics = _loc7_.graphics;
  1553.          _loc8_.clear();
  1554.          _loc8_.beginFill(param5,getStyle("backgroundAlpha"));
  1555.          _loc8_.drawRect(0,0,listContent.width,param4);
  1556.          _loc8_.endFill();
  1557.       }
  1558.       
  1559.       override protected function commitProperties() : void
  1560.       {
  1561.          var _loc1_:Number = NaN;
  1562.          var _loc2_:Number = NaN;
  1563.          var _loc3_:IListItemRenderer = null;
  1564.          var _loc4_:Number = NaN;
  1565.          var _loc5_:int = 0;
  1566.          super.commitProperties();
  1567.          if(itemsNeedMeasurement)
  1568.          {
  1569.             itemsNeedMeasurement = false;
  1570.             if(isNaN(explicitRowHeight))
  1571.             {
  1572.                if(iterator)
  1573.                {
  1574.                   _loc1_ = getStyle("paddingTop");
  1575.                   _loc2_ = getStyle("paddingBottom");
  1576.                   _loc3_ = mx_internal::getMeasuringRenderer(iterator.current);
  1577.                   _loc4_ = 200;
  1578.                   if(listContent.width)
  1579.                   {
  1580.                      _loc4_ = listContent.width;
  1581.                   }
  1582.                   _loc3_.explicitWidth = _loc4_;
  1583.                   mx_internal::setupRendererFromData(_loc3_,iterator.current);
  1584.                   _loc5_ = _loc3_.getExplicitOrMeasuredHeight() + _loc1_ + _loc2_;
  1585.                   setRowHeight(Math.max(_loc5_,20));
  1586.                }
  1587.                else
  1588.                {
  1589.                   setRowHeight(20);
  1590.                }
  1591.             }
  1592.             if(isNaN(explicitColumnWidth))
  1593.             {
  1594.                mx_internal::setColumnWidth(measureWidthOfItems(0,explicitRowCount < 1 ? defaultRowCount : explicitRowCount));
  1595.             }
  1596.          }
  1597.       }
  1598.       
  1599.       mx_internal function getMeasuringRenderer(param1:Object) : IListItemRenderer
  1600.       {
  1601.          var _loc2_:IListItemRenderer = null;
  1602.          if(!measuringObjects)
  1603.          {
  1604.             measuringObjects = new Dictionary(true);
  1605.          }
  1606.          var _loc3_:IFactory = getItemRendererFactory(param1);
  1607.          _loc2_ = measuringObjects[_loc3_];
  1608.          if(!_loc2_)
  1609.          {
  1610.             _loc2_ = createItemRenderer(param1);
  1611.             _loc2_.owner = this;
  1612.             _loc2_.name = "hiddenItem";
  1613.             _loc2_.visible = false;
  1614.             _loc2_.styleName = listContent;
  1615.             listContent.addChild(DisplayObject(_loc2_));
  1616.             measuringObjects[_loc3_] = _loc2_;
  1617.          }
  1618.          return _loc2_;
  1619.       }
  1620.       
  1621.       mx_internal function purgeMeasuringRenderers() : void
  1622.       {
  1623.          var _loc1_:IListItemRenderer = null;
  1624.          for each(_loc1_ in measuringObjects)
  1625.          {
  1626.             if(_loc1_.parent)
  1627.             {
  1628.                _loc1_.parent.removeChild(DisplayObject(_loc1_));
  1629.             }
  1630.          }
  1631.          if(!measuringObjects)
  1632.          {
  1633.             measuringObjects = new Dictionary(true);
  1634.          }
  1635.       }
  1636.       
  1637.       private function adjustVerticalScrollPositionDownward(param1:int) : Boolean
  1638.       {
  1639.          var item:IListItemRenderer;
  1640.          var n:int = 0;
  1641.          var j:int = 0;
  1642.          var more:Boolean = false;
  1643.          var data:Object = null;
  1644.          var rowCount:int = param1;
  1645.          var bookmark:CursorBookmark = iterator.bookmark;
  1646.          var h:Number = 0;
  1647.          var ch:Number = 0;
  1648.          var paddingTop:Number = getStyle("paddingTop");
  1649.          var paddingBottom:Number = getStyle("paddingBottom");
  1650.          var paddingLeft:Number = getStyle("paddingLeft");
  1651.          var paddingRight:Number = getStyle("paddingRight");
  1652.          h = rowInfo[rowCount - 1].y + rowInfo[rowCount - 1].height;
  1653.          h = listContent.heightExcludingOffsets - listContent.topOffset - h;
  1654.          var numRows:int = 0;
  1655.          try
  1656.          {
  1657.             if(iterator.afterLast)
  1658.             {
  1659.                iterator.seek(CursorBookmark.LAST,0);
  1660.             }
  1661.             else
  1662.             {
  1663.                more = iterator.movePrevious();
  1664.             }
  1665.          }
  1666.          catch(e:ItemPendingError)
  1667.          {
  1668.             more = false;
  1669.          }
  1670.          if(!more)
  1671.          {
  1672.             super.verticalScrollPosition = 0;
  1673.             try
  1674.             {
  1675.                iterator.seek(CursorBookmark.FIRST,0);
  1676.                if(!iteratorValid)
  1677.                {
  1678.                   iteratorValid = true;
  1679.                   lastSeekPending = null;
  1680.                }
  1681.             }
  1682.             catch(e:ItemPendingError)
  1683.             {
  1684.                lastSeekPending = new ListBaseSeekPending(CursorBookmark.FIRST,0);
  1685.                e.addResponder(new ItemResponder(seekPendingResultHandler,seekPendingFailureHandler,lastSeekPending));
  1686.                iteratorValid = false;
  1687.                invalidateList();
  1688.                return true;
  1689.             }
  1690.             updateList();
  1691.             return true;
  1692.          }
  1693.          item = mx_internal::getMeasuringRenderer(iterator.current);
  1694.          item.explicitWidth = listContent.width - paddingLeft - paddingRight;
  1695.          while(h > 0 && more)
  1696.          {
  1697.             if(more)
  1698.             {
  1699.                data = iterator.current;
  1700.                mx_internal::setupRendererFromData(item,data);
  1701.                ch = variableRowHeight ? item.getExplicitOrMeasuredHeight() + paddingBottom + paddingTop : rowHeight;
  1702.             }
  1703.             h -= ch;
  1704.             try
  1705.             {
  1706.                more = iterator.movePrevious();
  1707.                numRows++;
  1708.             }
  1709.             catch(e:ItemPendingError)
  1710.             {
  1711.                more = false;
  1712.             }
  1713.          }
  1714.          if(h < 0)
  1715.          {
  1716.             numRows--;
  1717.          }
  1718.          iterator.seek(bookmark,0);
  1719.          verticalScrollPosition = Math.max(0,verticalScrollPosition - numRows);
  1720.          if(numRows > 0 && !variableRowHeight)
  1721.          {
  1722.             configureScrollBars();
  1723.          }
  1724.          return numRows > 0;
  1725.       }
  1726.       
  1727.       public function isItemEditable(param1:Object) : Boolean
  1728.       {
  1729.          if(!editable)
  1730.          {
  1731.             return false;
  1732.          }
  1733.          if(param1 == null)
  1734.          {
  1735.             return false;
  1736.          }
  1737.          return true;
  1738.       }
  1739.       
  1740.       override protected function adjustListContent(param1:Number = -1, param2:Number = -1) : void
  1741.       {
  1742.          var _loc3_:Number = viewMetrics.left + Math.max(listContent.leftOffset,0);
  1743.          var _loc4_:Number = viewMetrics.top + listContent.topOffset;
  1744.          listContent.move(_loc3_,_loc4_);
  1745.          var _loc5_:Number = Math.max(0,listContent.rightOffset) - _loc3_ - viewMetrics.right;
  1746.          var _loc6_:Number = Math.max(0,listContent.bottomOffset) - _loc4_ - viewMetrics.bottom;
  1747.          var _loc7_:Number = param1 + _loc5_;
  1748.          if(horizontalScrollPolicy == ScrollPolicy.ON || horizontalScrollPolicy == ScrollPolicy.AUTO && !isNaN(mx_internal::_maxHorizontalScrollPosition))
  1749.          {
  1750.             if(isNaN(mx_internal::_maxHorizontalScrollPosition))
  1751.             {
  1752.                _loc7_ *= 2;
  1753.             }
  1754.             else
  1755.             {
  1756.                _loc7_ += mx_internal::_maxHorizontalScrollPosition;
  1757.             }
  1758.          }
  1759.          listContent.setActualSize(_loc7_,param2 + _loc6_);
  1760.       }
  1761.       
  1762.       private function editorMouseDownHandler(param1:Event) : void
  1763.       {
  1764.          if(param1 is MouseEvent && itemRendererContains(itemEditorInstance,DisplayObject(param1.target)))
  1765.          {
  1766.             return;
  1767.          }
  1768.          endEdit(ListEventReason.OTHER);
  1769.       }
  1770.       
  1771.       override public function set itemRenderer(param1:IFactory) : void
  1772.       {
  1773.          super.itemRenderer = param1;
  1774.          mx_internal::purgeMeasuringRenderers();
  1775.       }
  1776.       
  1777.       mx_internal function setupRendererFromData(param1:IListItemRenderer, param2:Object) : void
  1778.       {
  1779.          var _loc3_:Object = param2 is ItemWrapper ? param2.data : param2;
  1780.          if(param1 is IDropInListItemRenderer)
  1781.          {
  1782.             if(_loc3_ != null)
  1783.             {
  1784.                IDropInListItemRenderer(param1).listData = makeListData(_loc3_,itemToUID(param2),0);
  1785.             }
  1786.             else
  1787.             {
  1788.                IDropInListItemRenderer(param1).listData = null;
  1789.             }
  1790.          }
  1791.          param1.data = _loc3_;
  1792.          if(param1 is IInvalidating)
  1793.          {
  1794.             IInvalidating(param1).invalidateSize();
  1795.          }
  1796.          UIComponentGlobals.mx_internal::layoutManager.validateClient(param1,true);
  1797.       }
  1798.       
  1799.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  1800.       {
  1801.          super.updateDisplayList(param1,param2);
  1802.          setRowCount(listItems.length);
  1803.          if(bEditedItemPositionChanged && !editingTemporarilyPrevented(_proposedEditedItemPosition))
  1804.          {
  1805.             bEditedItemPositionChanged = false;
  1806.             commitEditedItemPosition(_proposedEditedItemPosition);
  1807.             _proposedEditedItemPosition = undefined;
  1808.          }
  1809.          drawRowBackgrounds();
  1810.       }
  1811.       
  1812.       public function destroyItemEditor() : void
  1813.       {
  1814.          var _loc1_:ListEvent = null;
  1815.          if(itemEditorInstance)
  1816.          {
  1817.             DisplayObject(itemEditorInstance).removeEventListener(KeyboardEvent.KEY_DOWN,editorKeyDownHandler);
  1818.             systemManager.getSandboxRoot().removeEventListener(MouseEvent.MOUSE_DOWN,editorMouseDownHandler,true);
  1819.             systemManager.getSandboxRoot().removeEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,editorMouseDownHandler);
  1820.             _loc1_ = new ListEvent(ListEvent.ITEM_FOCUS_OUT);
  1821.             _loc1_.rowIndex = _editedItemPosition.rowIndex;
  1822.             _loc1_.itemRenderer = editedItemRenderer;
  1823.             dispatchEvent(_loc1_);
  1824.             if(!rendererIsEditor)
  1825.             {
  1826.                if(Boolean(itemEditorInstance) && itemEditorInstance is UIComponent)
  1827.                {
  1828.                   UIComponent(itemEditorInstance).drawFocus(false);
  1829.                }
  1830.                listContent.removeChild(DisplayObject(itemEditorInstance));
  1831.             }
  1832.             itemEditorInstance = null;
  1833.             _editedItemPosition = null;
  1834.          }
  1835.       }
  1836.       
  1837.       mx_internal function callMakeListData(param1:Object, param2:String, param3:int) : BaseListData
  1838.       {
  1839.          return makeListData(param1,param2,param3);
  1840.       }
  1841.       
  1842.       public function set lockedRowCount(param1:int) : void
  1843.       {
  1844.          mx_internal::_lockedRowCount = param1;
  1845.          invalidateDisplayList();
  1846.       }
  1847.    }
  1848. }
  1849.  
  1850.