         var numRows:Number = _constraintRows.length;
         var row:ConstraintRow;
         var hasContentSize:Boolean = false;
+        var hasPercentSize:Boolean = false;
         var rowHeights:Vector.<Number> = new Vector.<Number>();
         
         // Reset content size rows to 0.
         for (i = 0; i < numRows; i++)
         {
             row = _constraintRows[i];
-            if (row.contentSize)
-            {
-                hasContentSize = true;
+            
+            if (row.contentSize || !isNaN(row.percentHeight))
+            {
+                hasContentSize ||= row.contentSize;
+                hasPercentSize ||= !isNaN(row.percentHeight);
                 
                 if (!isNaN(row.minHeight))
                     rowHeights[i] = Math.ceil(Math.max(row.minHeight, 0));

     *  current constraintCache. To update the constraintCache, one needs to call
     *  the parseConstraints() method.
     */
    private function measureRows():Vector.<Number>
    {
        if (_constraintRows.length <= 0)
            return new Vector.<Number>();

    }
    
    /**
     *  Adjusts the sizes of percent size columns or rows to fill the constrainedSize.
     *  This method updates the provided column widths or row heights vector in place.
     *  
     *  The term, "region", refers to a column or row.
     *  The percent size region sizes are first reset to their minimum size. 
     *  If the given region sizes from the content and fixed size regions already
     *  fill the available space, then the percent size region sizes stay at their
     *  minimum size. Otherwise, the remaining space is distributed to the percent 
     *  size regions based on the ratio of its percent size to the sum of all the 
     *  percent sizes.
     */
    private function constrainPercentRegionSizes(sizes:Vector.<Number>, constrainedSize:Number, isColumns:Boolean):void
    {
        var col:ConstraintColumn;
        var row:ConstraintRow;
        var numSizes:int = isColumns ? _constraintColumns.length : _constraintRows.length;
        
        var childInfoArray:Array /* of ConstraintRegionFlexChildInfo */ = [];
        var childInfo:ConstraintRegionFlexChildInfo;
        var remainingSpace:Number = constrainedSize;
        var percentMinSizes:Number = 0;
        var totalPercent:Number = 0;
        
        // Set percent size regions back to minSize and
        // find the remaining space.
        for (var i:int = 0; i < numSizes; i++)
        {
            var percentSize:Number;
            var minSize:Number;
            var maxSize:Number;
            
            if (isColumns)
            {
                col = _constraintColumns[i];
                percentSize = col.percentWidth;
                minSize = col.minWidth;
                maxSize = col.maxWidth;
            }
            else
            {
                row = _constraintRows[i];
                percentSize = row.percentHeight;
                minSize = row.minHeight;
                maxSize = row.maxHeight;
            }

            if (!isNaN(percentSize))
            {
                sizes[i] = (!isNaN(minSize)) ? Math.ceil(Math.max(minSize, 0)) : 0;
                percentMinSizes += sizes[i];
                totalPercent += percentSize;
                
                // Fill childInfoArray for distributing the width.
                childInfo = new ConstraintRegionFlexChildInfo();
                childInfo.index = i;
                childInfo.percent = percentSize;
                childInfo.min = minSize;
                childInfo.max = maxSize;
                childInfoArray.push(childInfo);
            }
            else
            {
                remainingSpace -= sizes[i];
            }
        }
        
        // If there's space remaining, distribute the width to the percent size
        // columns based on their ratio of percentWidth to sum of all the percentWidths.
        if (remainingSpace > percentMinSizes)
        {            
            Flex.flexChildrenProportionally(constrainedSize, 
                                            remainingSpace,
                                            totalPercent,
                                            childInfoArray);
            
