      */
     override protected function measure():void
     {
-        if (FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
-        {
-            previousMeasure();
-            return;
-        }
-        
         super.measure();
         
         if (direction == FormItemDirection.VERTICAL)

        }
    }
    
    private function previousUpdateDisplayList(unscaledWidth:Number,
                                               unscaledHeight:Number):void
    {
        super.updateDisplayList(unscaledWidth, unscaledHeight);

        var vm:EdgeMetrics = viewMetricsAndPadding;
        var left:Number = vm.left;
        var top:Number = vm.top;
        
        var y:Number = top;
        var labelWidth:Number = calculateLabelWidth();
        var indicatorGap:Number = getStyle("indicatorGap");
        var horizontalAlign:String = getStyle("horizontalAlign");
        var i:int;
        var child:IUIComponent;
        var childBaseline:Number;
        var childWidth:Number;
        var horizontalGap:Number;
        var verticalGap:Number;

        var horizontalAlignValue:Number;
        if (horizontalAlign == "right")
            horizontalAlignValue = 1;
        else if (horizontalAlign == "center")
            horizontalAlignValue = 0.5;
        else
            horizontalAlignValue = 0;

        var n:int = numChildren;

        // Position our label.
        if (n > 0)
        {
            // Center label with first child
            child = getLayoutChildAt(0);
            childBaseline = child.baselinePosition;
            if (!isNaN(childBaseline))
                y += childBaseline - labelObj.baselinePosition;
        }

        // Set label size.
        labelObj.setActualSize(labelWidth, labelObj.getExplicitOrMeasuredHeight());
        labelObj.move(left, y);

        left += labelWidth;

        // Position the "required" indicator.
        displayIndicator(left, y);
        left += indicatorGap;

        var controlWidth:Number = unscaledWidth - vm.right - left;
        if (controlWidth < 0) 
            controlWidth = 0;

        // Position our children.
        if (direction == FormItemDirection.HORIZONTAL)
        {
            var maxWidth:Number = 0;
            var numColumns:int = calcNumColumns(controlWidth);
            var x:Number;
            var col:int = 0;

            horizontalGap = getStyle("horizontalGap");
            verticalGap = getStyle("verticalGap");

            // Earlier, the measure function took a guess at the number
            // of columns, but that function didn't know the width of this
            // FormItem.  Now that we know the width, we may discover that the
            // guess was wrong.  In that case, call invalidateSize(), so that
            // we loop back and repeat the measurement phase again.
            //
            // It's possible that we might introduce an infinite loop - the
            // new guess might change the layout, so that the guess once again
            // is found to be wrong.  If we get back here a second time and
            // discover that the guess is still wrong, we'll just live with it.
            if (numColumns != guessedNumColumns && numberOfGuesses == 0)
            {
                guessedRowWidth = controlWidth;
                numberOfGuesses = 1;
                invalidateSize();
            }
            else
            {
                numberOfGuesses = 0;
            }

            // Special case for single row - use the HBox layout algorithm.
            if (numColumns == n)
            {
                var h:Number = height - (top + vm.bottom);
                var excessSpace:Number = Flex.flexChildWidthsProportionally(
                    this, controlWidth - (n - 1) * horizontalGap, h);

                left += (excessSpace * horizontalAlignValue);

                for (i = 0; i < n; i++)
                {
                    child = getLayoutChildAt(i);
                    child.move(Math.floor(left), top);
                    left += child.width + horizontalGap;
                }
            }
            else
            {
                // Determine the widest child.
                for (i = 0; i < n; i++)
                {
                    child = getLayoutChildAt(i);
                    maxWidth = Math.max(maxWidth,
                                        child.getExplicitOrMeasuredWidth());
                }

                // Determine the left side for the columns.
                var widthSlop:Number = controlWidth -
                    (numColumns * maxWidth + (numColumns - 1) * horizontalGap);
                if (widthSlop < 0)
                    widthSlop = 0;

                left += (widthSlop * horizontalAlignValue);
                x = left;

                // Place the children in columns
                for (i = 0; i < n; i++)
                {
                    child = getLayoutChildAt(i);
                    
                    childWidth = Math.min(maxWidth,
                                          child.getExplicitOrMeasuredWidth());

                    child.setActualSize(childWidth,
                                        child.getExplicitOrMeasuredHeight());
                    child.move(x, top);

                    if (++col >= numColumns)
                    {
                        x = left;
                        col = 0;
                        top += child.height + verticalGap;
                    }
                    else
                    {
                        x += maxWidth + horizontalGap;
                    }
                }
            }
        }
        else
        {
            verticalGap = getStyle("verticalGap");

            for (i = 0; i < n; i++)
            {
                child = getLayoutChildAt(i);

                // Round up to nearest 1/4 of controlWidth
                if (!isNaN(child.percentWidth))
                {
                    childWidth = Math.floor(controlWidth *
                        Math.min(child.percentWidth, 100) / 100);
                }
                else
                {
                    childWidth = child.getExplicitOrMeasuredWidth();

                    // Only do modular sizing if an explicit width isn't set.
                    if (isNaN(child.explicitWidth))
                    {
                        if (childWidth < Math.floor(controlWidth * 0.25)) 
                            childWidth = Math.floor(controlWidth * 0.25);
                        else if (childWidth < Math.floor(controlWidth * 0.5)) 
                            childWidth = Math.floor(controlWidth * 0.5);
                        else if (childWidth < Math.floor(controlWidth * 0.75))
                            childWidth = Math.floor(controlWidth * 0.75);
                        else if (childWidth < Math.floor(controlWidth)) 
                            childWidth = Math.floor(controlWidth);
                    }
                }

                child.setActualSize(childWidth,
                                    child.getExplicitOrMeasuredHeight());

                var xOffset:Number = (controlWidth - childWidth) * horizontalAlignValue;
                child.move(left + xOffset, top);

                top += child.height;
                top += verticalGap;
            }
        }

        // Position our label again, now that our children have been positioned.
        // Moving our children can affect the baselinePosition. (Bug 86725)
        y = vm.top;
        if (n > 0)
        {
            // Center label with first child
            child = getLayoutChildAt(0);
            childBaseline = child.baselinePosition;
            if (!isNaN(childBaseline))
                y += childBaseline - labelObj.baselinePosition;
        }
        labelObj.move(labelObj.x, y);
    }
    
    /**
     *  @private
     */

import mx.controls.Label;
import mx.core.Container;
import mx.core.EdgeMetrics;
import mx.core.IFlexDisplayObject;
import mx.core.IUIComponent;
import mx.core.mx_internal;
