         return " ";
     }
     
+    /**
+     *  Return the indices of the item renderers visible within this DataGroup.
+     * 
+     *  <p>If clipAndEnableScrolling=true, return the indices of the visible=true 
+     *  ItemRenderers that overlap this DataGroup's scrollRect, i.e. the ItemRenders 
+     *  that are at least partially visible relative to this DataGroup.  If 
+     *  clipAndEnableScrolling=false, return a list of integers from 
+     *  0 to dataProvider.length - 1.  Note that if this DataGroup's owner is a 
+     *  Scroller, then clipAndEnableScrolling has been set to true.</p>
+     * 
+     *  <p>The corresponding item renderer for each returned index can be 
+     *  retrieved with getElementAt(), 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
+     *  firstIndexInView and lastIndexInView properties which convey the same information
+     *  as this method.</p>
+     * 
+     *  @return The indices of the visible item renderers.
+     */
+    public function getItemIndicesInView():Vector.<int>
+    {
+        if (layout && layout.useVirtualLayout)
+            return (virtualRendererIndices) ? virtualRendererIndices.concat() : 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

                setUpItemRenderer(elt, index, dataProvider.getItemAt(index));
            else
            {
                var item:Object = dataProvider.getItemAt(index);
                var recyclingOK:Boolean = (itemRendererFunction == null) && (itemRenderer != null);
                
                if (recyclingOK && (freeRenderers.length > 0))
                {
                    elt = freeRenderers.pop();
                    elt.visible = true;

        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.
        
        const recyclingOK:Boolean = isRecyclingOK();       
        
        for each (var vrIndex:int in oldVirtualRendererIndices)
        {
