     protected function measureAndPositionColumnsAndRows():void
     {
         parseConstraints();
-        measureAndPositionColumns();
-        measureAndPositionRows();
+        setColumnWidths(measureColumns());
+        setRowHeights(measureRows());
+    }
+    
+    /**
+     *  Used to set new column widths before laying out the elements.
+     *  Used by FormItemLayout to set column widths provided by the
+     *  Form.
+     */ 
+    protected function setColumnWidths(value:Vector.<Number>):void
+    {
+        if (value == null)
+            return;
+        
+        var constraintColumns:Vector.<ConstraintColumn> = this.constraintColumns;
+        var numCols:int = constraintColumns.length;
+        var totalWidth:Number = 0;
+        
+        for (var i:int = 0; i < numCols; i++)
+        {
+            constraintColumns[i].setActualWidth(value[i]);
+            constraintColumns[i].x = totalWidth;
+            totalWidth += value[i];
+        }
+    }
+    
+    /**
+     *  Used to set new row heights before laying out the elements.
+     */ 
+    protected function setRowHeights(value:Vector.<Number>):void
+    {
+        if (value == null)
+            return;
+        
+        var constraintRows:Vector.<ConstraintRow> = this.constraintRows;
+        var numRows:int = constraintRows.length;
+        var totalHeight:Number = 0;
+        
+        for (var i:int = 0; i < numRows; i++)
+        {
+            constraintRows[i].setActualHeight(value[i]);
+            constraintRows[i].y = totalHeight;
+            totalHeight += value[i];
+        }
     }
 
     /**

                        {
                            col = contentCols[j];
                            
                            colWidth = Math.max(col.width, splitWidth);
                            if (!isNaN(col.maxWidth))
                                colWidth = Math.min(colWidth, col.maxWidth);
                            
                            col.setActualWidth(Math.ceil(colWidth));
                        }
                    }
                }
            }
        }
        
        // Position columns and add up widths.
        for (i = 0; i < numCols; i++)
        {
            col = _constraintColumns[i];
            col.x = measuredWidth;
            measuredWidth += col.width;
        }
        
        return measuredWidth;
    }
    
    /**
     *  @private
     *  Synonymous to measureAndPositionColumns(), but with added baseline constraint.
     *  Baseline is only included in the measurement if at least one of the element's
     *  top or bottom constraint doesn't exist. The calculations are based on the
     *  current constraintCache. To update the constraintCache, one needs to call
     *  the parseConstraints() method.
     */
    private function measureAndPositionRows():Number
    {
        if (_constraintRows.length <= 0)
            return 0;
        
        var measuredHeight:Number = 0;
        var i:Number;
        var numRows:Number = _constraintRows.length;
        var row:ConstraintRow;
        var hasContentSize:Boolean = false;
        
        // Reset content size rows to 0.
        for (i = 0; i < numRows; i++)

        // what parts aren't possible.
        
        if (_constraintColumns.length <= 0)
            return new Vector.<Number>();
        
        var measuredWidth:Number = 0;
        var i:Number;
        var numCols:Number = _constraintColumns.length;
        var col:ConstraintColumn;
        var hasContentSize:Boolean = false;
        var colWidths:Vector.<Number> = new Vector.<Number>();
        
        // Start column widths at the minWidth of each column or
        // its explicit width.
        for (i = 0; i < numCols; i++)
        {
            col = _constraintColumns[i];
