You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@royale.apache.org by al...@apache.org on 2018/05/23 07:19:30 UTC
[royale-asjs] branch feature/MXRoyale updated: DataGroup.as Added
This is an automated email from the ASF dual-hosted git repository.
alinakazi pushed a commit to branch feature/MXRoyale
in repository https://gitbox.apache.org/repos/asf/royale-asjs.git
The following commit(s) were added to refs/heads/feature/MXRoyale by this push:
new 1ab9fff DataGroup.as Added
1ab9fff is described below
commit 1ab9fff8a18af017992a5e39e03578e2a558db85
Author: alinakazi <AL...@GMAIL.COM>
AuthorDate: Wed May 23 00:19:27 2018 -0700
DataGroup.as Added
---
.../src/main/royale/spark/components/DataGroup.as | 2056 ++++++++++++++++++++
1 file changed, 2056 insertions(+)
diff --git a/frameworks/projects/SparkRoyale/src/main/royale/spark/components/DataGroup.as b/frameworks/projects/SparkRoyale/src/main/royale/spark/components/DataGroup.as
new file mode 100644
index 0000000..7952a22
--- /dev/null
+++ b/frameworks/projects/SparkRoyale/src/main/royale/spark/components/DataGroup.as
@@ -0,0 +1,2056 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package spark.components
+{
+/* import flash.display.DisplayObject;
+import flash.events.Event;
+import flash.geom.PerspectiveProjection;
+import flash.geom.Rectangle;
+import flash.utils.Dictionary;
+import flash.utils.getQualifiedClassName;
+ */
+/* import mx.collections.IList;
+import mx.core.IDataRenderer;
+import mx.core.IInvalidating;
+import mx.core.ILayoutElement;
+import mx.events.CollectionEvent;
+import mx.events.CollectionEventKind;
+import mx.events.PropertyChangeEvent;
+import mx.managers.ILayoutManagerClient;
+import mx.managers.LayoutManager;
+import mx.utils.MatrixUtil;
+import spark.layouts.supportClasses.LayoutBase;
+
+import spark.events.RendererExistenceEvent;
+ */
+ import mx.core.IFactory;
+import mx.core.IVisualElement;
+
+ import spark.components.supportClasses.GroupBase;
+ import mx.core.IUIComponent;
+
+ import mx.core.mx_internal;
+use namespace mx_internal; // for mx_internal property contentChangeDelta
+
+
+/**
+ * Dispatched when a renderer is added to this dataGroup.
+ * <code>event.renderer</code> is the renderer that was added.
+ *
+ * @eventType spark.events.RendererExistenceEvent.RENDERER_ADD
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+//[Event(name="rendererAdd", type="spark.events.RendererExistenceEvent")]
+
+/**
+ * Dispatched when a renderer is removed from this dataGroup.
+ * <code>event.renderer</code> is the renderer that was removed.
+ *
+ * @eventType spark.events.RendererExistenceEvent.RENDERER_REMOVE
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+//[Event(name="rendererRemove", type="spark.events.RendererExistenceEvent")]
+
+//--------------------------------------
+// Excluded APIs
+//--------------------------------------
+
+[Exclude(name="addChild", kind="method")]
+[Exclude(name="addChildAt", kind="method")]
+[Exclude(name="removeChild", kind="method")]
+[Exclude(name="removeChildAt", kind="method")]
+[Exclude(name="setChildIndex", kind="method")]
+[Exclude(name="swapChildren", kind="method")]
+[Exclude(name="swapChildrenAt", kind="method")]
+[Exclude(name="numChildren", kind="property")]
+[Exclude(name="getChildAt", kind="method")]
+[Exclude(name="getChildIndex", kind="method")]
+
+//--------------------------------------
+// Other metadata
+//--------------------------------------
+
+/* [ResourceBundle("components")]
+
+[DefaultProperty("dataProvider")]
+
+[IconFile("DataGroup.png")]
+ */
+/**
+ * The DataGroup class is the base container class for data items.
+ * The DataGroup class converts data items to visual elements for display.
+ * While this container can hold visual elements, it is often used only
+ * to hold data items as children.
+ *
+ * <p>The DataGroup class takes as children data items or visual elements
+ * that implement the IVisualElement interface and are DisplayObjects.
+ * Data items can be simple data items such String and Number objects,
+ * and more complicated data items such as Object and XMLNode objects.
+ * While these containers can hold visual elements,
+ * they are often used only to hold data items as children.</p>
+ *
+ * <p>An item renderer defines the visual representation of the
+ * data item in the container.
+ * The item renderer converts the data item into a format that can
+ * be displayed by the container.
+ * You must pass an item renderer to a DataGroup container to render
+ * data items appropriately.</p>
+ *
+ * <p>To improve performance and minimize application size,
+ * the DataGroup container cannot be skinned.
+ * If you want to apply a skin, use the SkinnableDataContainer instead. </p>
+ *
+ * <p>The DataGroup container has the following default characteristics:</p>
+ * <table class="innertable">
+ * <tr><th>Characteristic</th><th>Description</th></tr>
+ * <tr><td>Default size</td><td>Large enough to display its children</td></tr>
+ * <tr><td>Minimum size</td><td>0 pixels</td></tr>
+ * <tr><td>Maximum size</td><td>10000 pixels wide and 10000 pixels high</td></tr>
+ * </table>
+ *
+ * @mxml
+ *
+ * <p>The <code><s:DataGroup></code> tag inherits all of the tag
+ * attributes of its superclass and adds the following tag attributes:</p>
+ *
+ * <pre>
+ * <s:DataGroup
+ * <strong>Properties</strong>
+ * dataProvider="null"
+ * itemRenderer="null"
+ * itemRendererFunction="null"
+ * typicalItem="null"
+ *
+ * <strong>Events</strong>
+ * rendererAdd="<i>No default</i>"
+ * rendererRemove="<i>No default</i>"
+ * />
+ * </pre>
+ *
+ * @see spark.components.SkinnableDataContainer
+ * @see spark.components.Group
+ * @see spark.skins.spark.DefaultItemRenderer
+ * @see spark.skins.spark.DefaultComplexItemRenderer
+ * @includeExample examples/DataGroupExample.mxml
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+public class DataGroup extends GroupBase
+{ //implements IItemRendererOwner
+ /**
+ * Constructor.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ public function DataGroup()
+ {
+ super();
+
+ // _rendererUpdateDelegate = this;
+ }
+
+ /**
+ * @private
+ * flag to indicate whether a child in the item renderer has a non-zero layer, requiring child re-ordering.
+ */
+ /* private var _layeringFlags:uint = 0;
+
+ private static const LAYERING_ENABLED:uint = 0x1;
+ private static const LAYERING_DIRTY:uint = 0x2;
+ */
+ /**
+ * @private
+ * The following variables are used to track free virtual item renderers.
+ * When an item renderer is created an entry is added to rendererToFactoryMap
+ * so when it's time to move the renderer to the freeRendererMap "free list",
+ * we can store it with the other renderers produced by the same factory (IFactory).
+ * The value of rendererToFactoryMap[renderer] is a factory, the value of
+ * freeRendererMap[factory] is the vector of free renderers produced by factory.
+ */
+ /* private var rendererToFactoryMap:Dictionary = new Dictionary(true);
+ private var freeRendererMap:Dictionary = new Dictionary();
+ private var addedVirtualRenderer:Boolean = false; // see createVirtualRendererForItem()
+ */
+ //--------------------------------------------------------------------------
+ //
+ // Overridden properties
+ //
+ //--------------------------------------------------------------------------
+
+ //----------------------------------
+ // baselinePosition
+ //----------------------------------
+
+ /**
+ * @inheritDoc
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ /* override public function get baselinePosition():Number
+ {
+ if (!validateBaselinePosition())
+ return NaN;
+
+ if (numElements == 0)
+ return super.baselinePosition;
+
+ return getElementAt(0).baselinePosition + getElementAt(0).y;
+ }
+ */
+ //--------------------------------------------------------------------------
+ //
+ // Properties
+ //
+ //--------------------------------------------------------------------------
+
+ //----------------------------------
+ // typicalItem
+ //----------------------------------
+
+ /* private var _typicalItem:Object = null;
+ private var explicitTypicalItem:Object = null;
+ private var typicalItemChanged:Boolean = false;
+ private var typicalLayoutElement:ILayoutElement = null;
+
+ [Inspectable(category="Data")]
+ */
+ /**
+ * Layouts use the preferred size of the <code>typicalItem</code>
+ * when fixed row or column sizes are required, but a specific
+ * <code>rowHeight</code> or <code>columnWidth</code> value is not set.
+ * Similarly virtual layouts use this item to define the size
+ * of layout elements that have not been scrolled into view.
+ *
+ * <p>The container uses the typical data item, and the associated item renderer,
+ * to determine the default size of the container children.
+ * By defining the typical item, the container does not have to size each child
+ * as it is drawn on the screen.</p>
+ *
+ * <p>Setting this property sets the <code>typicalLayoutElement</code> property
+ * of the layout.</p>
+ *
+ * <p>Restriction: if the <code>typicalItem</code> is an IVisualItem, it must not
+ * also be a member of the data Provider.</p>
+ *
+ * @default null
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ /* public function get typicalItem():Object
+ {
+ return _typicalItem;
+ } */
+
+ /**
+ * @private
+ */
+ /* public function set typicalItem(value:Object):void
+ {
+ if (_typicalItem === value)
+ return;
+ _typicalItem = explicitTypicalItem = value;
+ invalidateTypicalItemRenderer();
+ }
+
+ private function setTypicalLayoutElement(element:ILayoutElement):void
+ {
+ typicalLayoutElement = element;
+ if (layout)
+ layout.typicalLayoutElement = element;
+ }
+ */
+ /**
+ * Call this method if some aspect of the <code>typicalItem</code>
+ * has changed that should be reflected by the layout.
+ *
+ * <p>This method is called automatically if the <code>typicalItem</code>
+ * is changed directly. That means if the property is set to a new value
+ * that is not "==" to current value.</p>
+ *
+ * @langversion 3.0
+ * @playerversion Flash 11
+ * @playerversion AIR 3
+ * @productversion Flex 4.6
+ */
+ /* public function invalidateTypicalItemRenderer():void
+ {
+ typicalItemChanged = true;
+ invalidateProperties();
+ }
+
+ private function initializeTypicalItem():void
+ {
+ if (_typicalItem === null)
+ {
+ setTypicalLayoutElement(null);
+ return;
+ }
+
+ var renderer:IVisualElement = createRendererForItem(_typicalItem, false);
+ var obj:DisplayObject = DisplayObject(renderer);
+ if (!obj)
+ {
+ setTypicalLayoutElement(null);
+ return;
+ }
+
+ super.addChild(obj);
+ setUpItemRenderer(renderer, 0, _typicalItem);
+ if (obj is IInvalidating)
+ IInvalidating(obj).validateNow();
+ setTypicalLayoutElement(renderer);
+ super.removeChild(obj);
+ }
+ */
+ /**
+ * @private
+ * Create and validate a new item renderer (IR) for dataProvider[index].
+ *
+ * This method creates a new IR which is not a child of this DataGroup. It does not
+ * return the existing IR at the specified index and it does not cache the IRs it
+ * creates. This method is intended to be used by clients which need to measure
+ * virtual IRs that may not be visible/allocated.
+ */
+ /* mx_internal function createItemRendererFor(index:int):IVisualElement
+ {
+ if ((index < 0) || (dataProvider == null) || (index >= dataProvider.length))
+ return null;
+
+ const item:Object = dataProvider.getItemAt(index);
+ const renderer:IVisualElement = createRendererForItem(item);
+
+ super.addChild(DisplayObject(renderer));
+ setUpItemRenderer(renderer, index, item);
+ if (renderer is IInvalidating)
+ IInvalidating(renderer).validateNow();
+ super.removeChild(DisplayObject(renderer));
+
+ return renderer;
+ }
+ */
+ /**
+ * @private
+ * Called before measure/updateDisplayList(), if useVirtualLayout=true, to guarantee
+ * that the typicalLayoutElement has been defined. If it hasn't, typicalItem is
+ * initialized to dataProvider[0] and layout.typicalLayoutElement is set.
+ */
+ /* private function ensureTypicalLayoutElement():void
+ {
+ if (layout.typicalLayoutElement)
+ return;
+
+ const list:IList = dataProvider;
+ if (list && (list.length > 0))
+ {
+ _typicalItem = list.getItemAt(0);
+
+ // TextFlows are not shareable. Soft-link TextFlow class.
+ var isTextFlowClass:Boolean =
+ getQualifiedClassName(_typicalItem) ==
+ "flashx.textLayout.elements::TextFlow";
+
+ if (isTextFlowClass)
+ _typicalItem = _typicalItem["deepCopy"]();
+
+ initializeTypicalItem();
+ }
+ }
+ */
+ //----------------------------------
+ // layout
+ //----------------------------------
+
+ //private var useVirtualLayoutChanged:Boolean = false;
+
+ /**
+ * @private
+ * Sync the typicalLayoutElement var with this group's layout.
+ */
+ /*override public function set layout(value:LayoutBase):void
+ */
+ public function set layout(value:Object):void
+ {
+ /* var oldLayout:LayoutBase = layout;
+ if (value == oldLayout)
+ return;
+
+ if (oldLayout)
+ {
+ oldLayout.typicalLayoutElement = null;
+ oldLayout.removeEventListener("useVirtualLayoutChanged", layout_useVirtualLayoutChangedHandler);
+ }
+ // Changing the layout may implicitly change layout.useVirtualLayout
+ if (oldLayout && value && (oldLayout.useVirtualLayout != value.useVirtualLayout))
+ changeUseVirtualLayout();
+ super.layout = value;
+ if (value)
+ {
+ // If typicalLayoutElement was specified for this DataGroup, then use
+ // it, otherwise use the layout's typicalLayoutElement, if any.
+ if (typicalLayoutElement)
+ value.typicalLayoutElement = typicalLayoutElement;
+ else
+ typicalLayoutElement = value.typicalLayoutElement;
+ value.addEventListener("useVirtualLayoutChanged", layout_useVirtualLayoutChangedHandler);
+ } */
+ }
+
+ /**
+ * @private
+ * If layout.useVirtualLayout changes, recreate the ItemRenderers. This can happen
+ * if the layout's useVirtualLayout property is changed directly, or if the DataGroup's
+ * layout is changed.
+ */
+ /* private function changeUseVirtualLayout():void
+ {
+ removeDataProviderListener();
+ removeAllItemRenderers();
+ useVirtualLayoutChanged = true;
+ invalidateProperties();
+ }
+
+ private function layout_useVirtualLayoutChangedHandler(event:Event):void
+ {
+ changeUseVirtualLayout();
+ }*/
+
+ //----------------------------------
+ // itemRenderer
+ //----------------------------------
+
+ /**
+ * @private
+ * Storage for the itemRenderer property.
+ */
+ private var _itemRenderer:IFactory;
+
+ //private var itemRendererChanged:Boolean;
+
+ [Inspectable(category="Data")]
+
+ /**
+ * The item renderer to use for data items.
+ * The class must implement the IDataRenderer interface.
+ * If defined, the <code>itemRendererFunction</code> property
+ * takes precedence over this property.
+ *
+ * @default null
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ public function get itemRenderer():IFactory
+ {
+ return _itemRenderer;
+ }
+
+ /**
+ * @private
+ */
+ public function set itemRenderer(value:IFactory):void
+ {
+ _itemRenderer = value;
+
+ /* removeDataProviderListener();
+ removeAllItemRenderers();
+ invalidateProperties();
+
+ itemRendererChanged = true;
+ typicalItemChanged = true; */
+ }
+
+ //----------------------------------
+ // itemRendererFunction
+ //----------------------------------
+
+ /**
+ * @private
+ * Storage for the itemRendererFunction property.
+ */
+ /* private var _itemRendererFunction:Function;
+
+ [Inspectable(category="Data")]
+ */
+ /**
+ * Function that returns an item renderer IFactory for a
+ * specific item. You should define an item renderer function
+ * similar to this sample function:
+ *
+ * <pre>
+ * function myItemRendererFunction(item:Object):IFactory</pre>
+ *
+ * @default null
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ /* public function get itemRendererFunction():Function
+ {
+ return _itemRendererFunction;
+ } */
+
+ /**
+ * @private
+ */
+ /* public function set itemRendererFunction(value:Function):void
+ {
+ _itemRendererFunction = value;
+
+ removeDataProviderListener();
+ removeAllItemRenderers();
+ invalidateProperties();
+
+ itemRendererChanged = true;
+ typicalItemChanged = true;
+ }
+ */
+ //----------------------------------
+ // rendererUpdateDelegate
+ //----------------------------------
+
+ /**
+ * @private
+ * Storage for the rendererUpdateDelegate property.
+ */
+ //private var _rendererUpdateDelegate:IItemRendererOwner;
+
+ /**
+ * @private
+ * The rendererUpdateDelgate is used to delegate item renderer
+ * updates to another component, usually the owner of the
+ * DataGroup within the context of data centric component such
+ * as List.
+ *
+ * The registered delegate must implement the IItemRendererOwner interface.
+ *
+ * @default null
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ /* mx_internal function get rendererUpdateDelegate():IItemRendererOwner
+ {
+ return _rendererUpdateDelegate;
+ }
+ */
+ /**
+ * @private
+ */
+ /* mx_internal function set rendererUpdateDelegate(value:IItemRendererOwner):void
+ {
+ _rendererUpdateDelegate = value;
+ }
+ */
+ //----------------------------------
+ // dataProvider
+ //----------------------------------
+
+ /* private var _dataProvider:IList;
+ private var dataProviderChanged:Boolean;
+
+ [Bindable("dataProviderChanged")]
+ [Inspectable(category="Data")]
+ */
+ /**
+ * The data provider for this DataGroup.
+ * It must be an IList.
+ *
+ * <p>There are several IList implementations included in the
+ * Flex framework, including ArrayCollection, ArrayList, and
+ * XMLListCollection.</p>
+ *
+ * @default null
+ *
+ * @see #itemRenderer
+ * @see #itemRendererFunction
+ * @see mx.collections.IList
+ * @see mx.collections.ArrayCollection
+ * @see mx.collections.ArrayList
+ * @see mx.collections.XMLListCollection
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ /* public function get dataProvider():IList
+ {
+ return _dataProvider;
+ }
+ */
+ /**
+ * @private
+ */
+ /* public function set dataProvider(value:IList):void
+ {
+ if (_dataProvider == value)
+ return;
+
+ removeDataProviderListener();
+ _dataProvider = value; // listener will be added by commitProperties()
+ dataProviderChanged = true;
+ invalidateProperties();
+ dispatchEvent(new Event("dataProviderChanged"));
+ }
+ */
+ /**
+ * @private
+ * Used below for sorting the virtualRendererIndices Vector.
+ */
+ /* private static function sortDecreasing(x:int, y:int):Number
+ {
+ return y - x;
+ } */
+
+ /**
+ * @private
+ * Apply itemRemoved() to the renderer and dataProvider item at index.
+ */
+ /* private function removeRendererAt(index:int):void
+ {
+ // TODO (rfrishbe): we can't key off of the oldDataProvider for
+ // the item because it might not be there anymore (for instance,
+ // in a dataProvider reset where the new data is loaded into
+ // the dataProvider--the dataProvider doesn't actually change,
+ // but we still need to clean up).
+ // Because of this, we are assuming the item is either:
+ // 1. The data property if the item implements IDataRenderer
+ // and there is an itemRenderer or itemRendererFunction
+ // 2. The item itself
+
+ // Probably could fix above by also storing indexToData[], but that doesn't
+ // seem worth it. Sending in the wrong item here doesn't result in a big error...
+ // just the event with have the wrong item associated with it
+
+ const renderer:IVisualElement = indexToRenderer[index] as IVisualElement;
+ if (renderer)
+ {
+ var item:Object;
+
+ if (renderer is IDataRenderer && (itemRenderer != null || itemRendererFunction != null))
+ item = IDataRenderer(renderer).data;
+ else
+ item = renderer;
+ itemRemoved(item, index);
+ }
+ }
+ */
+ /**
+ * @private
+ * Remove all of the item renderers, clear the indexToRenderer table, clear
+ * any cached virtual layout data, and clear the typical layout element. Note that
+ * this method does not depend on the dataProvider itself, see removeRendererAt().
+ */
+ /* private function removeAllItemRenderers():void
+ {
+ if (indexToRenderer.length == 0)
+ return;
+
+ if (virtualRendererIndices && (virtualRendererIndices.length > 0))
+ {
+ for each (var index:int in virtualRendererIndices.concat().sort(sortDecreasing))
+ removeRendererAt(index);
+
+ virtualRendererIndices.length = 0;
+ oldVirtualRendererIndices.length = 0;
+
+ const freeRenderers:Vector.<IVisualElement> = allFreeRenderers();
+ for each (var renderer:IVisualElement in freeRenderers)
+ super.removeChild(renderer as DisplayObject);
+
+ resetFreeRenderers();
+ }
+ else
+ {
+ for (index = indexToRenderer.length - 1; index >= 0; index--)
+ removeRendererAt(index);
+ }
+
+ indexToRenderer = []; // should be redundant
+
+ if (layout)
+ {
+ layout.clearVirtualLayoutCache();
+ layout.typicalLayoutElement = null;
+ }
+ }
+ */
+ /**
+ * <p>Given a data item, return the <code>toString()</code> representation
+ * of the data item for an item renderer to display.
+ * Null data items return the empty string. </p>
+ *
+ * @copy spark.components.IItemRendererOwner#itemToLabel()
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 2.5
+ * @productversion Flex 4.5
+ */
+ /* public function itemToLabel(item:Object):String
+ {
+ if (item !== null)
+ return item.toString();
+ return " ";
+ }
+ */
+ /**
+ * Return the indices of the item renderers visible within this DataGroup.
+ *
+ * <p>If <code>clipAndEnableScrolling</code> is <code>true</code>,
+ * return the indices of the <code>visible</code> = <code>true</code>
+ * ItemRenderers that overlap this DataGroup's <code>scrollRect</code>.
+ * That is, the ItemRenders
+ * that are at least partially visible relative to this DataGroup.
+ * If <code>clipAndEnableScrolling</code> is <code>false</code>,
+ * return a list of integers from
+ * 0 to <code>dataProvider.length</code> - 1.
+ * Note that if this DataGroup's owner is a
+ * Scroller, then <code>clipAndEnableScrolling</code> has been
+ * set to <code>true</code>.</p>
+ *
+ * <p>The corresponding item renderer for each returned index can be
+ * retrieved with the <code>getElementAt()</code> method,
+ * even if the layout is virtual</p>
+ *
+ * <p>The order of the items in the returned Vector is not guaranteed.</p>
+ *
+ * <p>Note that the VerticalLayout and HorizontalLayout classes provide bindable
+ * <code>firstIndexInView</code> and <code>lastIndexInView</code> properties
+ * which contain the same information as this method.</p>
+ *
+ * @return The indices of the visible item renderers.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 2.5
+ * @productversion Flex 4.5
+ */
+ /* public function getItemIndicesInView():Vector.<int>
+ {
+ if (layout && layout.useVirtualLayout)
+ return (virtualRendererIndices) ? virtualRendererIndices.concat() : new Vector.<int>(0);
+
+ if (!dataProvider)
+ return new Vector.<int>(0);
+
+ const scrollR:Rectangle = scrollRect;
+ const dataProviderLength:int = dataProvider.length;
+
+ if (scrollR)
+ {
+ const visibleIndices:Vector.<int> = new Vector.<int>();
+ const eltR:Rectangle = new Rectangle();
+ const perspectiveProjection:PerspectiveProjection = transform.perspectiveProjection;
+
+ for (var index:int = 0; index < dataProviderLength; index++)
+ {
+ var elt:IVisualElement = getElementAt(index);
+ if (!elt || !elt.visible)
+ continue;
+
+ // TODO (egeorgie): provide a generic getElementBounds() utility function
+ if (elt.hasLayoutMatrix3D && perspectiveProjection)
+ {
+ eltR.x = 0;
+ eltR.y = 0;
+ eltR.width = elt.getLayoutBoundsWidth(false);
+ eltR.height = elt.getLayoutBoundsHeight(false);
+ MatrixUtil.projectBounds(eltR, elt.getLayoutMatrix3D(), perspectiveProjection);
+ }
+ else
+ {
+ eltR.x = elt.getLayoutBoundsX();
+ eltR.y = elt.getLayoutBoundsY();
+ eltR.width = elt.getLayoutBoundsWidth();
+ eltR.height = elt.getLayoutBoundsHeight();
+ }
+
+ if (scrollR.intersects(eltR))
+ visibleIndices.push(index);
+ }
+
+ return visibleIndices;
+ }
+ else
+ {
+ const allIndices:Vector.<int> = new Vector.<int>(dataProviderLength);
+ for (index = 0; index < dataProviderLength; index++)
+ allIndices[index] = index;
+ return allIndices;
+ }
+ }
+ */
+ //--------------------------------------------------------------------------
+ //
+ // Item -> Renderer mapping
+ //
+ //--------------------------------------------------------------------------
+
+ /**
+ * Return the item renderer factory for the specified item, if any. Prefer
+ * itemRendererFunction over itemRenderer.
+ */
+ /* private function itemToRendererFactory(item:Object):IFactory
+ {
+ if (itemRendererFunction != null)
+ return itemRendererFunction(item);
+
+ return itemRenderer;
+ }
+ */
+ /**
+ * Return a new renderer created with the specified factory and add an entry for it
+ * to rendererToFactoryMap so that we can free and allocate it later.
+ */
+ /* private function createRenderer(factory:IFactory):IVisualElement
+ {
+ const element:IVisualElement = factory.newInstance() as IVisualElement;
+ rendererToFactoryMap[element] = factory;
+ return element;
+ } */
+
+ /**
+ * If a vector of free renderers exists for the specified factory, remove
+ * one and return it.
+ */
+ /* private function allocateRenderer(factory:IFactory):IVisualElement
+ {
+ const renderers:Vector.<IVisualElement> = freeRendererMap[factory] as Vector.<IVisualElement>;
+ if (renderers)
+ {
+ const element:IVisualElement = renderers.pop();
+ if (renderers.length == 0)
+ delete freeRendererMap[factory];
+ if (element)
+ return element;
+ }
+
+ return null;
+ }
+ */
+ /**
+ * Add the specified renderer to the rendererToFactoryMap.
+ */
+ /* private function freeRenderer(renderer:IVisualElement):void
+ {
+ if (!renderer)
+ return;
+
+ const factory:IFactory = rendererToFactoryMap[renderer];
+ if (!factory)
+ return;
+
+ var freeRenderers:Vector.<IVisualElement> = freeRendererMap[factory];
+ if (!freeRenderers)
+ {
+ freeRenderers = new Vector.<IVisualElement>();
+ freeRendererMap[factory] = freeRenderers;
+ }
+ freeRenderers.push(renderer);
+ }
+ */
+ /**
+ * @private
+ * Return a vector of all of the renderers in freeRendererMap.
+ */
+ /* private function allFreeRenderers():Vector.<IVisualElement>
+ {
+ const rv:Vector.<IVisualElement> = new Vector.<IVisualElement>();
+
+ for each (var v:Vector.<IVisualElement> in freeRendererMap)
+ {
+ for each (var e:IVisualElement in v)
+ rv.push(e);
+ }
+
+ return rv;
+ } */
+
+ /**
+ * @private
+ * Reset the private free renderers data.
+ */
+ /* private function resetFreeRenderers():void
+ {
+ rendererToFactoryMap = new Dictionary(true);
+ freeRendererMap = new Dictionary();
+ }
+ */
+ /**
+ * @private
+ * Throw an error which indicates that we were unable to create an item renderer
+ * for the specified dataProvide and we weren't able to use the item as an
+ * item renderer.
+ */
+ /* private function throwCreateRendererFailedError(item:Object):void
+ {
+ var err:String;
+ if (itemIsRenderer(item))
+ err = resourceManager.getString("components", "cannotDisplayVisualElement");
+ else
+ err = resourceManager.getString("components", "unableToCreateRenderer", [item]);
+
+ throw new Error(err);
+ }
+ */
+ /**
+ * @private
+ * True if the specified dataProvider item would serve as a renderer.
+ */
+ /* private function itemIsRenderer(item:Object):Boolean
+ {
+ return (item is IVisualElement) && (item is DisplayObject);
+ }
+ */
+ /**
+ * @private
+ * Create or reuse an item renderer for the specified dataProvider item. This method is
+ * used by getVirtualLayoutElementAt(), i.e. when useVirtualLayout=true.
+ *
+ * This method actually "returns" two values: the renderer itself and a flag that indicates
+ * if the renderer was newly added. The second value is actually just a variable. Each
+ * time this method is called it sets addedVirtualRenderer.
+ */
+ /* private function createVirtualRendererForItem(item:Object, failRTE:Boolean=true):IVisualElement
+ {
+ var renderer:IVisualElement = null;
+
+ const rendererFactory:IFactory = itemToRendererFactory(item);
+ if (rendererFactory)
+ renderer = allocateRenderer(rendererFactory); // use a free renderer
+
+ if (!renderer && rendererFactory)
+ {
+ renderer = createRenderer(rendererFactory);
+ addedVirtualRenderer = true;
+ }
+
+ if (!renderer && itemIsRenderer(item))
+ {
+ renderer = IVisualElement(item);
+ addedVirtualRenderer = true;
+ }
+
+ if (!renderer && failRTE)
+ throwCreateRendererFailedError(item);
+
+ return renderer;
+ }
+ */
+ /**
+ * @private
+ * Create an item renderer for the specified dataProvider item. This method is used
+ * when useVirtualLayout=false.
+ */
+ /* private function createRendererForItem(item:Object, failRTE:Boolean=true):IVisualElement
+ {
+ var renderer:IVisualElement = null;
+
+ const rendererFactory:IFactory = itemToRendererFactory(item);
+ if (rendererFactory)
+ renderer = createRenderer(rendererFactory);
+
+ if (!renderer && itemIsRenderer(item))
+ renderer = IVisualElement(item);
+
+ if (!renderer && failRTE)
+ throwCreateRendererFailedError(item);
+
+ return renderer;
+ }
+ */
+ /**
+ * @private
+ * If layout.useVirtualLayout=false, then ensure that there's one item
+ * renderer for every dataProvider item. This method is only intended to be
+ * called by commitProperties().
+ *
+ * Reuse as many of the IItemRenderer renderers in indexToRenders as possible.
+ */
+ /* private function createItemRenderers():void
+ {
+ if (!dataProvider)
+ {
+ removeAllItemRenderers();
+ return;
+ }
+
+ if (layout && layout.useVirtualLayout)
+ {
+ // Add any existing renderers to the free list.
+ if (virtualRendererIndices != null &&
+ virtualRendererIndices.length > 0)
+ {
+ startVirtualLayout();
+ finishVirtualLayout();
+ }
+
+ // The item renderers will be created lazily, at updateDisplayList() time
+ invalidateSize();
+ invalidateDisplayList();
+
+ return;
+ }
+
+ const dataProviderLength:int = dataProvider.length;
+
+ // Remove the renderers we're not going to need
+ for(var index:int = indexToRenderer.length - 1; index >= dataProviderLength; index--)
+ removeRendererAt(index);
+
+ // Reset the existing renderers
+ for(index = 0; index < indexToRenderer.length; index++)
+ {
+ var item:Object = dataProvider.getItemAt(index);
+ var renderer:IVisualElement = indexToRenderer[index] as IVisualElement;
+
+ // If the (new) item is-a renderer and the old renderer is a different
+ // DisplayObject, then we can't reuse the old renderer.
+
+ if (renderer && (!itemIsRenderer(item) || (item == renderer)))
+ {
+ setUpItemRenderer(renderer, index, item);
+ }
+ else
+ {
+ removeRendererAt(index);
+ itemAdded(item, index);
+ }
+ }
+
+ // Create new renderers
+ for (index = indexToRenderer.length; index < dataProviderLength; index++)
+ itemAdded(dataProvider.getItemAt(index), index);
+ }
+ */
+ /**
+ * @private
+ */
+ /* override protected function commitProperties():void
+ {
+ // If the itemRenderer, itemRendererFunction, or useVirtualLayout properties changed,
+ // then recreate the item renderers from scratch. If just the dataProvider changed,
+ // and layout.useVirtualLayout=false, then reuse as many item renderers as possible,
+ // remove the extra ones, or create more as needed.
+
+ if (itemRendererChanged || useVirtualLayoutChanged || dataProviderChanged)
+ {
+ itemRendererChanged = false;
+ useVirtualLayoutChanged = false;
+
+ // SDK-29916: The layout's cache may be in sync with the old data provider.
+ // The layout will sync up its cache with the new data provider
+ // when the DataGroup validateSize() / validateDisplayList().
+ // By clearing the cache here, we make sure that any insert/remove
+ // events for the new dataProvider, that occur from this point on till
+ // validteSize() / validateDisplayList(), won't be mixed up with the
+ // stale layout cache state that reflects the old data provider.
+ if (layout)
+ layout.clearVirtualLayoutCache();
+
+ // item renderers and the dataProvider listener have already been removed
+ createItemRenderers();
+ addDataProviderListener();
+
+ // Don't reset the scroll positions until the new ItemRenderers have been
+ // created, see bug https://bugs.adobe.com/jira/browse/SDK-23175
+ if (dataProviderChanged)
+ {
+ dataProviderChanged = false;
+ verticalScrollPosition = horizontalScrollPosition = 0;
+ }
+
+ maskChanged = true;
+ }
+
+ // Need to create item renderers before calling super.commitProperties()
+ // GroupBase's commitProperties reattaches the mask
+ super.commitProperties();
+
+ if (_layeringFlags & LAYERING_DIRTY)
+ {
+ if (layout && layout.useVirtualLayout)
+ invalidateDisplayList();
+ else
+ manageDisplayObjectLayers();
+ }
+
+ if (typicalItemChanged)
+ {
+ typicalItemChanged = false;
+ initializeTypicalItem();
+ }
+ }
+ */
+ /**
+ * @private
+ * True if we are updating a renderer currently.
+ * We keep track of this so we can ignore any dataProvider collectionChange
+ * UPDATE events while we are updating a renderer just in case we try to update
+ * the rendererInfo of the same renderer twice. This can happen if setting the
+ * data in an item renderer causes the data to mutate and issue a propertyChange
+ * event, which causes an collectionChange.UPDATE event in the dataProvider. This
+ * can happen for components which are being treated as data because the first time
+ * they get set on the renderer, they get added to the display list, which may
+ * cause a propertyChange event (if there's a child with an ID in it, that causes
+ * a propertyChange event) or the data to morph in some way.
+ */
+ //private var renderersBeingUpdated:Boolean = false;
+
+ /**
+ * @private
+ * Sets the renderer's data, owner and label properties.
+ * It does this by calling rendererUpdateDelegate.updateRenderer().
+ * By default, rendererUpdateDelegate points to ourselves, but if
+ * the "true owner" of the item renderer is a List, then the
+ * rendererUpdateDelegate points to that object. The
+ * rendererUpdateDelegate.updateRenderer() call is in charge of
+ * setting all the properties on the renderer, like owner, itemIndex,
+ * data, selected, etc... Note that data should be the last property
+ * set in this lifecycle.
+ */
+ /* private function setUpItemRenderer(renderer:IVisualElement, itemIndex:int, data:Object):void
+ {
+ if (!renderer)
+ return;
+
+ // keep track of whether we are actively updating an renderers
+ // so we can ignore any collectionChange.UPDATE events
+ renderersBeingUpdated = true;
+
+ // Defer to the rendererUpdateDelegate
+ // to update the renderer. By default, the delegate is DataGroup
+ _rendererUpdateDelegate.updateRenderer(renderer, itemIndex, data);
+
+ // technically if this got called "recursively", this renderersBeingUpdated flag
+ // would be prematurely set to false, but in most cases, this check should be
+ // good enough.
+ renderersBeingUpdated = false;
+ } */
+
+ /**
+ * @inheritDoc
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 2.5
+ * @productversion Flex 4.5
+ */
+ /* public function updateRenderer(renderer:IVisualElement, itemIndex:int, data:Object):void
+ {
+ // set the owner
+ renderer.owner = this;
+
+ // Set the index
+ if (renderer is IItemRenderer)
+ IItemRenderer(renderer).itemIndex = itemIndex;
+
+ // set the label to the toString() of the data
+ if (renderer is IItemRenderer)
+ IItemRenderer(renderer).label = itemToLabel(data);
+
+ // always set the data last
+ if ((renderer is IDataRenderer) && (renderer !== data))
+ IDataRenderer(renderer).data = data;
+ }
+ */
+ /**
+ * @private
+ * If the renderer at the specified index has a non-zero depth then: append it to
+ * layers.topLayerItems if depth > 0, or to layers.bottomLayerItems if depth < 0.
+ * Otherwise, if depth is zero (the default) then change the renderer's childIndex
+ * to insertIndex and increment insertIndex. The possibly incremented insertIndex is returned.
+ *
+ * See manageDisplayObjectLayers().
+ */
+ /* private function sortItemAt(index:int, layers:Object, insertIndex:int):int
+ {
+ const renderer:IVisualElement = getElementAt(index);
+ const layer:Number = renderer.depth;
+
+ if (layer != 0)
+ {
+ if (layer > 0)
+ {
+ if (layers.topLayerItems == null)
+ layers.topLayerItems = new Vector.<IVisualElement>();
+ layers.topLayerItems.push(renderer);
+ }
+ else
+ {
+ if (layers.bottomLayerItems == null)
+ layers.bottomLayerItems = new Vector.<IVisualElement>();
+ layers.bottomLayerItems.push(renderer);
+ }
+
+ return insertIndex;
+ }
+
+ super.setChildIndex(renderer as DisplayObject, insertIndex);
+ return insertIndex + 1;
+ } */
+
+ /**
+ * @private
+ */
+ /* private function manageDisplayObjectLayers():void
+ {
+ _layeringFlags &= ~LAYERING_DIRTY;
+
+ var insertIndex:uint = 0;
+ const layers:Object = {topLayerItems:null, bottomLayerItems:null};
+
+ if (layout && layout.useVirtualLayout)
+ {
+ for each (var index:int in virtualRendererIndices)
+ insertIndex = sortItemAt(index, layers, insertIndex);
+ }
+ else
+ {
+ for (index = 0; index < numElements; index++)
+ insertIndex = sortItemAt(index, layers, insertIndex);
+ }
+
+ // itemRenderers should be both DisplayObjects and IVisualElements
+ const topLayerItems:Vector.<IVisualElement> = layers.topLayerItems;
+ const bottomLayerItems:Vector.<IVisualElement> = layers.bottomLayerItems;
+
+ var myItemRenderer:IVisualElement;
+ var keepLayeringEnabled:Boolean = false;
+ var len:int = numElements;
+ var i:int;
+
+ if (topLayerItems != null)
+ {
+ keepLayeringEnabled = true;
+ GroupBase.sortOnLayer(topLayerItems);
+ len = topLayerItems.length;
+ for (i=0;i<len;i++)
+ {
+ myItemRenderer = topLayerItems[i];
+ super.setChildIndex(myItemRenderer as DisplayObject, insertIndex++);
+ }
+ }
+
+ if (bottomLayerItems != null)
+ {
+ keepLayeringEnabled = true;
+ insertIndex=0;
+
+ GroupBase.sortOnLayer(bottomLayerItems);
+ len = bottomLayerItems.length;
+
+ for (i=0;i<len;i++)
+ {
+ myItemRenderer = bottomLayerItems[i];
+ super.setChildIndex(myItemRenderer as DisplayObject, insertIndex++);
+ }
+ }
+
+ if (keepLayeringEnabled == false)
+ {
+ _layeringFlags &= ~LAYERING_ENABLED;
+ }
+ } */
+
+ //--------------------------------------------------------------------------
+ //
+ // Layout item iteration
+ //
+ // Iterators used by Layout objects. For visual items, the layout item
+ // is the item itself. For data items, the layout item is the item renderer
+ // instance that is associated with the item.
+ //--------------------------------------------------------------------------
+
+ /**
+ * @private
+ */
+ /* override public function get numElements():int
+ {
+ return dataProvider ? dataProvider.length : 0;
+ }
+ */
+ /**
+ * @private
+ * Maps from renderer index (same as dataProvider index) to the item renderer itself.
+ */
+ private var indexToRenderer:Array = [];
+
+ /**
+ * @private
+ * The set of layout element indices requested with getVirtualElementAt()
+ * during updateDisplayList(), and the set of "old" indices that were requested
+ * in the previous pass. These vectors are used by finishVirtualLayout()
+ * to distinguish IRs that can be recycled or discarded. The virtualRendererIndices
+ * vector is used in various places to iterate over all of the virtual renderers.
+ */
+ /* private var virtualRendererIndices:Vector.<int> = null;
+ private var oldVirtualRendererIndices:Vector.<int> = null;
+ */
+ /**
+ * @private
+ * During a virtual layout, virtualLayoutUnderway is true. This flag is used
+ * to defeat calls to invalidateSize(), which occur when IRs are lazily validated.
+ * See invalidateSize() and updateDisplayList().
+ */
+ //private var virtualLayoutUnderway:Boolean = false;
+
+ /**
+ * @private
+ * Called before super.updateDisplayList() if layout.useVirtualLayout=true.
+ * Also called by createItemRenderers to ready existing renderers
+ * to be recycled by the following call to finishVirtualLayout.
+ *
+ * Copies virtualRendererIndices to oldRendererIndices, clears virtualRendererIndices
+ * (which will be repopulated by subsequence getVirtualElementAt() calls), and
+ * calls ensureTypicalElement().
+ */
+ /* private function startVirtualLayout():void
+ {
+ // lazily create the virtualRendererIndices vectors
+
+ if (!virtualRendererIndices)
+ virtualRendererIndices = new Vector.<int>();
+ if (!oldVirtualRendererIndices)
+ oldVirtualRendererIndices = new Vector.<int>();
+
+ // Copy the contents virtualRendererIndices to oldVirtualRendererIndices
+ // and then clear virtualRendererIndices
+
+ oldVirtualRendererIndices.length = 0;
+ for each (var index:int in virtualRendererIndices)
+ oldVirtualRendererIndices.push(index);
+ virtualRendererIndices.length = 0;
+
+ // Ensure that layout.typicalLayoutElement is set
+ ensureTypicalLayoutElement();
+ }
+ */
+ /**
+ * @private
+ * Called after super.updateDisplayList() finishes. Also called by
+ * createItemRenderers to recycle existing renderers that were added
+ * to oldVirtualRendererIndices by the preceeding call to
+ * startVirtualLayout.
+ *
+ * Discard the ItemRenderers that aren't needed anymore, i.e. the ones
+ * not explicitly requested with getVirtualElementAt() during the most
+ * recent super.updateDisplayList().
+ *
+ * Discarded IRs may be added to the freeRenderers list per the rules
+ * defined in getVirtualElementAt(). If any visible renderer has a non-zero
+ * depth we resort all of them with manageDisplayObjectLayers().
+ */
+ /* private function finishVirtualLayout():void
+ {
+
+ if (oldVirtualRendererIndices.length == 0)
+ return;
+
+ // Remove the old ItemRenderers that aren't new ItemRenderers and if
+ // recycling is possible, add them to the freeRenderers list.
+
+ for each (var vrIndex:int in oldVirtualRendererIndices)
+ {
+ // Skip renderers that are still in view.
+ if (virtualRendererIndices.indexOf(vrIndex) != -1)
+ continue;
+
+ // Remove previously "in view" IR from the item=>IR table
+ var elt:IVisualElement = indexToRenderer[vrIndex] as IVisualElement;
+ delete indexToRenderer[vrIndex];
+
+ // Free or remove the IR.
+ var item:Object = (dataProvider.length > vrIndex) ? dataProvider.getItemAt(vrIndex) : null;
+ if ((item != elt) && (elt is IDataRenderer))
+ {
+ // IDataRenderer(elt).data = null; see https://bugs.adobe.com/jira/browse/SDK-20962
+ elt.includeInLayout = false;
+ elt.visible = false;
+
+ freeRenderer(elt);
+ }
+ else if (elt)
+ {
+ dispatchEvent(new RendererExistenceEvent(RendererExistenceEvent.RENDERER_REMOVE, false, false, elt, vrIndex, item));
+ super.removeChild(DisplayObject(elt));
+ }
+ }
+
+ // If there are any visible renderers whose depth property is non-zero
+ // then use manageDisplayObjectLayers to resort the children list. Note:
+ // we're assuming that the layout has set the bounds of any elements that
+ // were allocated but aren't actually visible to 0x0.
+
+ var depthSortRequired:Boolean = false;
+ for each (vrIndex in virtualRendererIndices)
+ {
+ elt = indexToRenderer[vrIndex] as IVisualElement;
+ if (!elt || !elt.visible || !elt.includeInLayout)
+ continue;
+ if ((elt.width == 0) || (elt.height == 0))
+ continue;
+ if (elt.depth != 0)
+ {
+ depthSortRequired = true;
+ break;
+ }
+ }
+
+ if (depthSortRequired)
+ manageDisplayObjectLayers();
+ }
+ */
+ /**
+ * @private
+ * This function exists for applications that need to control their footprint by
+ * allowing currently unused IRs to be garbage collected. It is not used by the SDK.
+ */
+ /* mx_internal function clearFreeRenderers():void
+ {
+ resetFreeRenderers();
+ } */
+
+ /**
+ * @private
+ * During virtual layout getLayoutElementAt() eagerly validates lazily
+ * created (or recycled) IRs. We don't want changes to those IRs to
+ * invalidate the size of this UIComponent.
+ */
+ /* override public function invalidateSize():void
+ {
+ if (!virtualLayoutUnderway)
+ super.invalidateSize();
+ }
+ */
+ /**
+ * @private
+ * Make sure there's a valid typicalLayoutElement for virtual layout.
+ */
+ /* override protected function measure():void
+ {
+ if (layout && layout.useVirtualLayout)
+ ensureTypicalLayoutElement();
+
+ super.measure();
+ } */
+
+ /**
+ * @private
+ * Manages the state required by virtual layout.
+ */
+ /* override protected function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void
+ {
+ drawBackground();
+
+ if (layout && layout.useVirtualLayout)
+ {
+ virtualLayoutUnderway = true;
+ startVirtualLayout();
+ }
+
+ super.updateDisplayList(unscaledWidth, unscaledHeight);
+
+ if (virtualLayoutUnderway)
+ {
+ finishVirtualLayout();
+ virtualLayoutUnderway = false;
+ }
+ }
+ */
+ /**
+ * @private
+ *
+ * Returns the ItemRenderer being used for the data provider item at the specified index.
+ * Note that if the layout is virtual, ItemRenderers that are scrolled
+ * out of view may be reused.
+ *
+ * @param index The index of the data provider item.
+ *
+ * @return The ItemRenderer being used for the data provider item
+ * If the index is invalid, or if a data provider was not specified, then
+ * return <code>null</code>.
+ * If the layout is virtual and the specified item is not in view, then
+ * return <code>null</code>.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ //override public function getElementAt(index:int):IVisualElement
+ //is replaced with
+ override public function getElementAt(index:int):IUIComponent
+ {
+ if ((index < 0) || (index >= indexToRenderer.length))
+ return null;
+
+ return indexToRenderer[index];
+
+ }
+
+ /**
+ * @private
+ */
+ /* override public function getVirtualElementAt(index:int, eltWidth:Number=NaN, eltHeight:Number=NaN):IVisualElement
+ {
+ if ((index < 0) || (dataProvider == null) || (index >= dataProvider.length))
+ return null;
+
+ var elt:IVisualElement = indexToRenderer[index];
+
+ if (virtualLayoutUnderway)
+ {
+ if (virtualRendererIndices.indexOf(index) == -1)
+ virtualRendererIndices.push(index);
+
+ var item:Object;
+
+ addedVirtualRenderer = false; // set by createVirtualRendererForItem()
+ if (!elt)
+ {
+ item = dataProvider.getItemAt(index);
+ elt = createVirtualRendererForItem(item);
+ elt.visible = true;
+ elt.includeInLayout = true;
+ indexToRenderer[index] = elt;
+ addItemRendererToDisplayList(DisplayObject(elt));
+ setUpItemRenderer(elt, index, item);
+ }
+ else
+ {
+ // No need to set the data and label in the IR again.
+ // The collectionChangeHandler will handle updates to data.
+ addItemRendererToDisplayList(DisplayObject(elt));
+ }
+
+ // We have the renderer now. getVirtualElement() is called from within layout's
+ // updateDisplayList(). This means it hasn't gone through a fully baked validation
+ // pass yet. To get it in to a valid state, we want to first force a
+ // commitProperties() and measure() to run on our item renderer.
+ if (elt is ILayoutManagerClient)
+ LayoutManager.getInstance().validateClient(elt as ILayoutManagerClient, true);
+
+ // Now, we can resume normal layout updateDisplayList() code. The layout
+ // could directly run this setLayoutBoundsSize() for us, but as legacy,
+ // getVirtualElementAt() calls this on behalf of the layout system
+ // if eltWidth and eltHeight are both NaN
+ if (!isNaN(eltWidth) || !isNaN(eltHeight))
+ elt.setLayoutBoundsSize(eltWidth, eltHeight);
+
+ if (addedVirtualRenderer)
+ dispatchEvent(new RendererExistenceEvent(RendererExistenceEvent.RENDERER_ADD, false, false, elt, index, item));
+ }
+
+ return elt;
+ }
+ */
+ /**
+ * @private
+ *
+ * Returns the index of the data provider item
+ * that the specified item renderer
+ * is being used for, or -1 if there is no such item.
+ * Note that if the layout is virtual, ItemRenderers that are scrolled
+ * out of view may be reused.
+ *
+ * @param element The item renderer.
+ *
+ * @return The index of the data provider item.
+ * If <code>renderer</code> is <code>null</code>, or if the <code>dataProvider</code>
+ * property was not specified, then return -1.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ /* override public function getElementIndex(element:IVisualElement):int
+ {
+ if ((dataProvider == null) || (element == null))
+ return -1;
+
+ return indexToRenderer.indexOf(element);
+ }
+ */
+
+ /**
+ * @private
+ */
+ /* override public function invalidateLayering():void
+ {
+ _layeringFlags |= (LAYERING_ENABLED | LAYERING_DIRTY);
+ invalidateProperties();
+ }
+ */
+ /**
+ * @private
+ * Set the itemIndex of the IItemRenderer at index to index. See resetRenderersIndices.
+ */
+ /* private function resetRendererItemIndex(index:int):void
+ {
+ var renderer:IItemRenderer = indexToRenderer[index] as IItemRenderer;
+ if (renderer)
+ renderer.itemIndex = index;
+ }
+ */
+
+ /**
+ * @private
+ * Recomputes every renderer's index.
+ * This is useful when an item gets added that may change the renderer's
+ * index. In turn, this index may cuase the renderer to change appearance,
+ * like when alternatingItemColors is used.
+ */
+ /* private function resetRenderersIndices():void
+ {
+ if (indexToRenderer.length == 0)
+ return;
+
+ if (layout && layout.useVirtualLayout)
+ {
+ for each (var index:int in virtualRendererIndices)
+ resetRendererItemIndex(index);
+ }
+ else
+ {
+ const indexToRendererLength:int = indexToRenderer.length;
+ for (index = 0; index < indexToRendererLength; index++)
+ resetRendererItemIndex(index);
+ // TODO (rfrishbe): could make this more optimal by only re-computing a subset of the visible
+ // item renderers, but it's probably not worth it
+ }
+ }
+ */
+ /**
+ * Adds the itemRenderer for the specified dataProvider item to this DataGroup.
+ *
+ * This method is called as needed by the DataGroup implementation,
+ * it should not be called directly.
+ *
+ * @param item The item that was added, the value of dataProvider[index].
+ * @param index The index where the dataProvider item was added.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ /* mx_internal function itemAdded(item:Object, index:int):void
+ {
+ if (layout)
+ layout.elementAdded(index);
+
+ if (layout && layout.useVirtualLayout)
+ {
+ // Increment all of the indices in virtualRendererIndices that are >= index.
+
+ if (virtualRendererIndices)
+ {
+ const virtualRendererIndicesLength:int = virtualRendererIndices.length;
+ for (var i:int = 0; i < virtualRendererIndicesLength; i++)
+ {
+ const vrIndex:int = virtualRendererIndices[i];
+ if (vrIndex >= index)
+ virtualRendererIndices[i] = vrIndex + 1;
+ }
+
+ indexToRenderer.splice(index, 0, null); // shift items >= index to the right
+ // virtual ItemRenderer itself will be added lazily, by updateDisplayList()
+ }
+
+ invalidateSize();
+ invalidateDisplayList();
+ return;
+ }
+
+ var myItemRenderer:IVisualElement = createRendererForItem(item);
+ indexToRenderer.splice(index, 0, myItemRenderer);
+ addItemRendererToDisplayList(myItemRenderer as DisplayObject, index);
+ setUpItemRenderer(myItemRenderer, index, item);
+ dispatchEvent(new RendererExistenceEvent(
+ RendererExistenceEvent.RENDERER_ADD, false, false,
+ myItemRenderer, index, item));
+
+ invalidateSize();
+ invalidateDisplayList();
+ }
+ */
+ /**
+ * Removes the itemRenderer for the specified dataProvider item from this DataGroup.
+ *
+ * This method is called as needed by the DataGroup implementation,
+ * it should not be called directly.
+ *
+ * @param item The item that is being removed.
+ *
+ * @param index The index of the item that is being removed.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ /* mx_internal function itemRemoved(item:Object, index:int):void
+ {
+ if (layout)
+ layout.elementRemoved(index);
+
+ // Decrement all of the indices in virtualRendererIndices that are > index
+ // Remove the one (at vrItemIndex) that equals index.
+
+ if (virtualRendererIndices && (virtualRendererIndices.length > 0))
+ {
+ var vrItemIndex:int = -1; // location of index in virtualRendererIndices
+ const virtualRendererIndicesLength:int = virtualRendererIndices.length;
+ for (var i:int = 0; i < virtualRendererIndicesLength; i++)
+ {
+ const vrIndex:int = virtualRendererIndices[i];
+ if (vrIndex == index)
+ vrItemIndex = i;
+ else if (vrIndex > index)
+ virtualRendererIndices[i] = vrIndex - 1;
+ }
+ if (vrItemIndex != -1)
+ virtualRendererIndices.splice(vrItemIndex, 1);
+ }
+
+ // Remove the old renderer at index (if any) from indexToRenderer[], from the
+ // DataGroup, and clear its data property (if any).
+
+ const oldRenderer:IVisualElement = indexToRenderer[index];
+
+ if (indexToRenderer.length > index)
+ indexToRenderer.splice(index, 1);
+
+ if (oldRenderer)
+ {
+ dispatchEvent(new RendererExistenceEvent(
+ RendererExistenceEvent.RENDERER_REMOVE, false, false, oldRenderer, index, item));
+
+ if (oldRenderer is IDataRenderer && oldRenderer !== item)
+ IDataRenderer(oldRenderer).data = null;
+
+ var child:DisplayObject = oldRenderer as DisplayObject;
+ if (child)
+ super.removeChild(child);
+ }
+
+ invalidateSize();
+ invalidateDisplayList();
+ } */
+
+ /**
+ * @private
+ */
+ /* private function addItemRendererToDisplayList(child:DisplayObject, index:int = -1):void
+ {
+ const childParent:Object = child.parent;
+ const overlayCount:int = _overlay ? _overlay.numDisplayObjects : 0;
+ const childIndex:int = (index != -1) ? index : super.numChildren - overlayCount;
+
+ if (childParent == this)
+ {
+ super.setChildIndex(child, childIndex - 1);
+ return;
+ }
+
+ if (childParent is DataGroup)
+ DataGroup(childParent)._removeChild(child);
+
+ if ((_layeringFlags & LAYERING_ENABLED) ||
+ (child is IVisualElement && (child as IVisualElement).depth != 0))
+ invalidateLayering();
+
+ super.addChildAt(child, childIndex);
+ }
+ */
+ /**
+ * @private
+ */
+ /* private function addDataProviderListener():void
+ {
+ if (_dataProvider)
+ _dataProvider.addEventListener(CollectionEvent.COLLECTION_CHANGE, dataProvider_collectionChangeHandler, false, 0, true);
+ } */
+
+ /**
+ * @private
+ */
+ /* private function removeDataProviderListener():void
+ {
+ if (_dataProvider)
+ _dataProvider.removeEventListener(CollectionEvent.COLLECTION_CHANGE, dataProvider_collectionChangeHandler);
+ } */
+
+ /**
+ * @private
+ * Called when contents within the dataProvider changes. We will catch certain
+ * events and update our children based on that.
+ *
+ * @param event The collection change event
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+ /* mx_internal function dataProvider_collectionChangeHandler(event:CollectionEvent):void
+ {
+ switch (event.kind)
+ {
+ case CollectionEventKind.ADD:
+ {
+ // items are added
+ // figure out what items were added and where
+ // for virtualization also figure out if items are now in view
+ adjustAfterAdd(event.items, event.location);
+ break;
+ }
+
+ case CollectionEventKind.REPLACE:
+ {
+ // items are replaced
+ adjustAfterReplace(event.items, event.location);
+ break;
+ }
+
+ case CollectionEventKind.REMOVE:
+ {
+ // items are added
+ // figure out what items were removed
+ // for virtualization also figure out what items are now in view
+ adjustAfterRemove(event.items, event.location);
+ break;
+ }
+
+ case CollectionEventKind.MOVE:
+ {
+ // one item is moved
+ adjustAfterMove(event.items[0], event.location, event.oldLocation);
+ break;
+ }
+
+ case CollectionEventKind.REFRESH:
+ {
+ // from a filter or sort...let's just reset everything
+ removeDataProviderListener();
+ dataProviderChanged = true;
+ invalidateProperties();
+ break;
+ }
+
+ case CollectionEventKind.RESET:
+ {
+ // reset everything
+ removeDataProviderListener();
+ dataProviderChanged = true;
+ invalidateProperties();
+ break;
+ }
+
+ case CollectionEventKind.UPDATE:
+ {
+ // if a renderer is currently being updated, let's
+ // just ignore any UPDATE events.
+ if (renderersBeingUpdated)
+ break;
+
+ //update the renderer's data and data-dependant
+ //properties.
+ for (var i:int = 0; i < event.items.length; i++)
+ {
+ var pe:PropertyChangeEvent = event.items[i];
+ if (pe)
+ {
+ var index:int = dataProvider.getItemIndex(pe.source);
+ var renderer:IVisualElement = indexToRenderer[index];
+ setUpItemRenderer(renderer, index, pe.source);
+ }
+ }
+ break;
+ }
+ }
+ }
+ */
+ /**
+ * @private
+ */
+ /* private function adjustAfterAdd(items:Array, location:int):void
+ {
+ var length:int = items.length;
+ for (var i:int = 0; i < length; i++)
+ {
+ itemAdded(items[i], location + i);
+ }
+
+ // the order might have changed, so we might need to redraw the other
+ // renderers that are order-dependent (for instance alternatingItemColor)
+ resetRenderersIndices();
+ }
+ */
+ /**
+ * @private
+ */
+ /* private function adjustAfterRemove(items:Array, location:int):void
+ {
+ var length:int = items.length;
+ for (var i:int = length-1; i >= 0; i--)
+ {
+ itemRemoved(items[i], location + i);
+ }
+
+ // the order might have changed, so we might need to redraw the other
+ // renderers that are order-dependent (for instance alternatingItemColor)
+ resetRenderersIndices();
+ }
+ */
+ /**
+ * @private
+ */
+ /* private function adjustAfterMove(item:Object, location:int, oldLocation:int):void
+ {
+ itemRemoved(item, oldLocation);
+ itemAdded(item, location);
+ resetRenderersIndices();
+ }
+ */
+ /**
+ * @private
+ */
+ /* private function adjustAfterReplace(items:Array, location:int):void
+ {
+ var length:int = items.length;
+ for (var i:int = length-1; i >= 0; i--)
+ {
+ itemRemoved(items[i].oldValue, location + i);
+ }
+
+ for (i = length-1; i >= 0; i--)
+ {
+ itemAdded(items[i].newValue, location);
+ }
+ }
+ */
+ //--------------------------------------------------------------------------
+ //
+ // Methods: Access to overridden methods of base classes
+ //
+ //--------------------------------------------------------------------------
+
+ /**
+ * @private
+ *
+ * This method allows access to the base class's implementation
+ * of removeChild() (UIComponent's version), which can be useful since components
+ * can override removeChild() and thereby hide the native implementation. For
+ * instance, we override removeChild() here to throw an RTE to discourage people
+ * from using this method. We need this method so we can remove children
+ * that were previously attached to another DataGroup (see addItemToDisplayList).
+ */
+ /* private function _removeChild(child:DisplayObject):DisplayObject
+ {
+ return super.removeChild(child);
+ }
+ */
+ /**
+ * @private
+ */
+ /* override public function addChild(child:DisplayObject):DisplayObject
+ {
+ throw(new Error(resourceManager.getString("components", "addChildDataGroupError")));
+ }
+ */
+ /**
+ * @private
+ */
+ /* override public function addChildAt(child:DisplayObject, index:int):DisplayObject
+ {
+ throw(new Error(resourceManager.getString("components", "addChildAtDataGroupError")));
+ }
+ */
+ /**
+ * @private
+ */
+ /* override public function removeChild(child:DisplayObject):DisplayObject
+ {
+ throw(new Error(resourceManager.getString("components", "removeChildDataGroupError")));
+ }
+ */
+ /**
+ * @private
+ */
+ /* override public function removeChildAt(index:int):DisplayObject
+ {
+ throw(new Error(resourceManager.getString("components", "removeChildAtDataGroupError")));
+ }
+ */
+ /**
+ * @private
+ */
+ /* override public function setChildIndex(child:DisplayObject, index:int):void
+ {
+ throw(new Error(resourceManager.getString("components", "setChildIndexDataGroupError")));
+ } */
+
+ /**
+ * @private
+ */
+ /* override public function swapChildren(child1:DisplayObject, child2:DisplayObject):void
+ {
+ throw(new Error(resourceManager.getString("components", "swapChildrenDataGroupError")));
+ } */
+
+ /**
+ * @private
+ */
+ /* override public function swapChildrenAt(index1:int, index2:int):void
+ {
+ throw(new Error(resourceManager.getString("components", "swapChildrenAtDataGroupError")));
+ } */
+}
+}
--
To stop receiving notification emails like this one, please contact
alinakazi@apache.org.