         if (_useVirtualLayout == value)
             return;
 
-        dispatchEvent(new Event("useVirtualLayoutChanged"));            
+        dispatchEvent(new Event("useVirtualLayoutChanged"));
+        
+        if (_useVirtualLayout && !value)  // turning virtual layout off
+            clearCachedVirtualLayoutState();
+                     
         _useVirtualLayout = value;
         if (target)
             target.invalidateDisplayList();
     }     
+    
+    /**
+     *  When useVirtualLayout=true, this method can be used by the layout target
+     *  to clear cached layout information when target state that might invalidate
+     *  such information changes.   
+     * 
+     *  For example, when a DataGroup's dataProvider or itemRenderer changes, cached 
+     *  elements sizes will become invalid. 
+     * 
+     *  When useVirtualLayout changes to false, this method is called automatically.
+     * 
+     *  Subclasses that support useVirtualLayout=true must override this method. 
+     */ 
+    public function clearCachedVirtualLayoutState():void
+    {
+    }
     
     //----------------------------------
     //  horizontalScrollPosition

    [Inspectable(defaultValue="false")]

    /**
     *  If true, subclasses will be advised that it's
     *  preferable to lazily create layout elements as they come into view,
     *  and to discard or recycle layout elements that are no longer in view.
     * 
     *  <p>You should implement virtualization support if the layout is going
     *  to be used with data containers and you want to spend resources only
     *  on the data items that are displayed on the screen.
     *  To support virtualization, a layout must be implemented in such a way
     *  that it does not iterate through all of the target's elements as anytime 
     *  you access a data container element, the container allocates an
     *  <code>ItemRenderer</code> for the corresponding data item.
     *  Instead, you should calculate and only access the elements that will be in view.
     *  A typical implementation of a virtual layout will examine the target's
     *  scrollRect and the size of the typicalLayoutElement to determine which
     *  elements will be in view. Additionally some layouts, like the
     *  <code>VerticalLayout</code> and the <code>HorizontalLayout</code>, keep a
     *  cache of the sizes of all elements that have already been accessed
     *  for more precise calculations for casese of bigger variations
     *  in sizes between the typicalLayoutElement and the actual elements.</p>
     * 
     *  @default false
     * 
     *  @see #getScrollRect

        return new Rectangle(hsp, vsp, g.width, g.height);
    }
    
   /**
     *  Returns the specified element's layout bounds as a Rectangle or null
     *  if the index is invalid, the corresponding element is null
     *  or <code>includeInLayout=false</code>, or if this layout's target is null.
