 
     //--------------------------------------------------------------------------
     //
-    //  Methods: ILayoutItem
+    //  Methods: ILayoutElement
     //
     //--------------------------------------------------------------------------
 
     /**
+     *  @inheritDoc
+     */
+    public function getMaxWidth(postTransform:Boolean=true):Number
+    {
+        return transformWidthForLayout(maxWidth, maxHeight, postTransform);
+    }
+
+    /**
+     *  @inheritDoc
+     */
+    public function getMaxHeight(postTransform:Boolean=true):Number
+    {
+        return transformHeightForLayout(maxWidth, maxHeight, postTransform);
+    }
+
+    /**
+     *  @inheritDoc
+     */
+    public function getMinWidth(postTransform:Boolean=true):Number
+    {
+        return transformWidthForLayout(minWidth, minHeight, postTransform);
+    }
+
+    /**
+     *  @inheritDoc
+     */
+    public function getMinHeight(postTransform:Boolean=true):Number
+    {
+        return transformHeightForLayout(minWidth, minHeight, postTransform);
+    }
+
+    /**
+     *  @inheritDoc
+     */
+    public function getPreferredWidth(postTransform:Boolean=true):Number
+    {
+        return transformWidthForLayout(preferredWidthPreTransform(),
+                                       preferredHeightPreTransform(),
+                                       postTransform);
+    }
+
+    /**
+     *  @inheritDoc
+     */
+    public function getPreferredHeight(postTransform:Boolean=true):Number
+    {
+        return transformHeightForLayout(preferredWidthPreTransform(),
+                                       preferredHeightPreTransform(),
+                                       postTransform);
+    }
+
+    /**
+     *  @inheritDoc 
+     */
+    public function getLayoutPositionX(postTransform:Boolean=true):Number
+    {
+        var left:Number;
+        // Account for transform
+        var m:Matrix;
+        if (postTransform)
+            m = computeMatrix();
+        if (m)
+        {
+            var topLeft:Point = new Point(measuredX, measuredY);
+
+            // Calculate the vector from pre-transform top-left to
+            // post-transform top-left:
+            computeTopLeft(topLeft, _width, _height, m);
+            left = topLeft.x;
+        }
+        else
+        {
+            left = x + measuredX;
+        }
+
+        // Take stroke into account:
+        // TODO EGeorgie: We assume that the stroke extents are even on both sides.
+        // and that's not necessarily true.
+        var strokeExtents:Point = getStrokeExtents(postTransform);
+        left -= strokeExtents.x * 0.5;
+
+        return left;
+    }
+
+    /**
+     *  @inheritDoc 
+     */
+    public function getLayoutPositionY(postTransform:Boolean=true):Number
+    {
+        var top:Number;
+        // Account for transform
+        var m:Matrix;
+        if (postTransform)
+            m = computeMatrix();
+        if (m)
+        {
+            var topLeft:Point = new Point(measuredX, measuredY);
+
+            // Calculate the vector from pre-transform top-left to
+            // post-transform top-left:
+            computeTopLeft(topLeft, _width, _height, m);
+            top = topLeft.y;
+        }
+        else
+        {
+            top = y + measuredY;
+        }
+
+        // Take stroke into account:
+        // TODO EGeorgie: We assume that the stroke extents are even on both sides.
+        // and that's not necessarily true.
+        var strokeExtents:Point = getStrokeExtents(postTransform);
+        top -= strokeExtents.y * 0.5;
+
+        return top;
+    }
+
+    /**
+     *  @inheirtDoc 
+     */
+    public function getLayoutWidth(postTransform:Boolean=true):Number
+    {
+        return transformWidthForLayout(_width, _height, postTransform);
+    }
+
+    /**
+     *  @inheritDoc 
+     */
+    public function getLayoutHeight(postTransform:Boolean=true):Number
+    {
+        return transformHeightForLayout(_width, _height, postTransform);
+    }
+
+    /**
      *  A reference to the object in the layout tree represented by this interface.
      */
     public function get target():Object

    /**
     *  Transform the element's size.
     *  
     *  @param width The target width.
     *  
     *  @param height The target height.
     *  
     *  @param actualMatrix 
     *  
     *  @return Returns the transformed size. Transformation is this element's
     *  transformation matrix.
     */
    protected function transformSizeForLayout(width:Number, height:Number,
                                              actualMatrix:Boolean):Point
    {
        var size:Point = new Point(width, height);
        var m:Matrix = computeMatrix(actualMatrix);
        if (m)
            size = MatrixUtil.transformSize(size, m);

        // Take stroke into account
        var strokeExtents:Point = getStrokeExtents();
        size.x += strokeExtents.x;
        size.y += strokeExtents.y;
        return size;
    }

    /**

        // Take stroke into account:
        // TODO EGeorgie: We assume that the stroke extents are even on both sides.
        // and that's not necessarily true.
        var strokeExtents:Point = getStrokeExtents(postTransform);
        x += strokeExtents.x * 0.5;
        y += strokeExtents.y * 0.5;

        // Handle arbitrary 2d transform
        var m:Matrix;
        if (postTransform)
            m = computeMatrix();
        if (m)
        {
            // Calculate the origin of the element after transformation before our changes are applied.
