         var spaceToDistribute:Number = height;
         var totalPercentHeight:Number = 0;
         var childInfoArray:Array = [];
-        var childInfo:LayoutItemFlexChildInfo;
+        var childInfo:LayoutElementFlexChildInfo;
         var newWidth:Number;
-        var layoutItem:ILayoutItem;
+        var layoutElement:ILayoutElement;
         
         // rowHeight can be expensive to compute
         var rh:Number = (variableRowHeight) ? 0 : rowHeight;
-        var count:uint = target.numLayoutItems;
-        var totalCount:uint = count; // number of items to use in gap calculation
+        var count:uint = target.numLayoutElements;
+        var totalCount:uint = count; // number of elements to use in gap calculation
         
         // If the child is flexible, store information about it in the
         // childInfoArray. For non-flexible children, just set the child's
         // width and height immediately.
         for (var index:int = 0; index < count; index++)
         {
-            layoutItem = target.getLayoutItemAt(index);
-            if (!layoutItem || !layoutItem.includeInLayout)
+            layoutElement = target.getLayoutElementAt(index);
+            if (!layoutElement || !layoutElement.includeInLayout)
             {
                 totalCount--;
                 continue;
             }
             
-            if (hasPercentHeight(layoutItem) && variableRowHeight)
+            if (hasPercentHeight(layoutElement) && variableRowHeight)
             {
-                totalPercentHeight += layoutItem.percentHeight;
-
-                childInfo = new LayoutItemFlexChildInfo();
-                childInfo.layoutItem = layoutItem;
-                childInfo.percent    = layoutItem.percentHeight;
-                childInfo.min        = layoutItem.minSize.y;
-                childInfo.max        = layoutItem.maxSize.y;
+                totalPercentHeight += layoutElement.percentHeight;
+
+                childInfo = new LayoutElementFlexChildInfo();
+                childInfo.layoutElement = layoutElement;
+                childInfo.percent    = layoutElement.percentHeight;
+                childInfo.min        = layoutElement.getMinHeight();
+                childInfo.max        = layoutElement.getMaxHeight();
                 
                 childInfoArray.push(childInfo);                
             }
             else
             {
-                sizeLayoutItem(layoutItem, width, horizontalAlign, 
+                sizeLayoutElement(layoutElement, width, horizontalAlign, 
                                restrictedWidth, NaN, variableRowHeight, rh);
                 
-                spaceToDistribute -= layoutItem.actualSize.y;
+                spaceToDistribute -= layoutElement.getLayoutHeight();
             } 
         }
         

        if (!scrollR)
            return 0;
            
        var itemR:Rectangle = null;
        switch(unit)
        {
            case ScrollUnit.UP:
            case ScrollUnit.PAGE_UP:
                itemR = findLayoutItemBounds(g, firstIndexInView, -1, scrollR);
                break;

            case ScrollUnit.DOWN:
            case ScrollUnit.PAGE_DOWN:
                itemR = findLayoutItemBounds(g, lastIndexInView, +1, scrollR);
                break;

            default:
                return super.getVerticalScrollPositionDelta(unit);
        }
        
        if (!itemR)
            return 0;
            
        var delta:Number = 0;            
        switch (unit)
        {
            case ScrollUnit.UP:
                delta = Math.max(-scrollR.height, itemR.top - scrollR.top);
                break;
                
            case ScrollUnit.DOWN:
                delta = Math.min(scrollR.height, itemR.bottom - scrollR.bottom);
                break;
                
            case ScrollUnit.PAGE_UP:
                if ((itemR.top < scrollR.top) && (itemR.bottom >= scrollR.bottom))
                    delta = Math.max(-scrollR.height, itemR.top - scrollR.top);
                else
                    delta = itemR.bottom - scrollR.bottom;
                break;

            case ScrollUnit.PAGE_DOWN:
                if ((itemR.top <= scrollR.top) && (itemR.bottom > scrollR.bottom))
                    delta = Math.min(scrollR.height, itemR.bottom - scrollR.bottom);
                else
                    delta = itemR.top - scrollR.top;
                break;
        }


     * 
     *  <li> 
     *  <code>UP</code>
     *  If the firstIndexInView element is partially visible then top justify
     *  it, otherwise top justify the element at the previous index.
     *  </li>
     * 
     *  <li> 
     *  <code>DOWN</code>
     *  If the lastIndexInView element is partially visible, then bottom justify
     *  it, otherwise bottom justify the element at the following index.
     *  </li>
     * 
     *  <code>PAGE_UP</code>
     *  <li>
     *  If the firstIndexInView element is partially visible, then bottom
     *  justify it, otherwise bottom justify element at the previous index.  
     *  </li>
     * 
     *  <li> 
     *  <code>PAGE_DOWN</code>
     *  If the lastIndexInView element is partially visible, then top
     *  justify it, otherwise top justify element at the following index.  
     *  </li>
     *  
     *  </ul>
