                 var colWidth:Number = gridDimensions.getColumnWidth(colIndex);
                 layoutGridElement(renderer, cellX, cellY, colWidth, rowHeight);
                 
-                // If there is a column header, it should be the same width
-                // as the column.
-                var headerElement:IVisualElement = getGridColumnHeader(colIndex);
-                if (headerElement)
-                    headerElement.width = colWidth;
-                
                 // TBD(hmuller): need a local preferred bounds method once layoutGridElement supports constraints
                 gridDimensions.setCellHeight(rowIndex, colIndex, renderer.getPreferredBoundsHeight());
                 cellX += colWidth + colGap;
             }
             
-            // ToDo(cframpto): where and how should this be done?
-            const columnHeaderBar:ColumnHeaderBar = getColumnHeaderBar();
-            if (columnHeaderBar)
-            {
-                // Horizontal layout repositions all the elements.  The layout
-                // starts at paddingLeft.  There is "gap" between each element.
-                if (columnHeaderBar.layout is HorizontalLayout)
-                {
-                    var headerBarLayout:HorizontalLayout = 
-                        HorizontalLayout(columnHeaderBar.layout);
-                    headerBarLayout.gap = colGap;
-                    headerBarLayout.paddingLeft = grid.x;
-                }
-            }
-            
             // TBD: if gridDimensions.rowHeight is now larger, we need to make another
             // pass to fix up the item renderer heights.
             

    private function getGridColumnHeader(columnIndex:int):IVisualElement
    {
        const headerBar:ColumnHeaderBar = getColumnHeaderBar();
        if (headerBar == null)
            return null;
        
        return headerBar.getElementAt(columnIndex);
    }
    
    /**

        if (!grid)
            return;
        
        var measuredWidth:Number;
        var measuredHeight:Number;

        if (!isNaN(grid.explicitWidth))
        {
            measuredWidth = grid.explicitWidth;
        }
        else
        {
            const columns:IList = grid.columns;
            const numColumns:int = columns.length;
            var columnCount:int;
            for (var i:int = 0; i < numColumns; i++)
            {
                var c:GridColumn = columns.getItemAt(i) as GridColumn;
                if (c && c.visible)
                    columnCount ++;
            }
            
            const defaultColumnWidth:Number = 
                typicalLayoutElement.getPreferredBoundsWidth();
            const columnGap:Number = gridDimensions.columnGap;
            
            measuredWidth = (columnCount * (defaultColumnWidth + columnGap)) - columnGap;         
        }
        
        if (!isNaN(grid.explicitHeight))
        {
            measuredHeight = grid.explicitWidth;
        }
        else
        {
            const rowCount:int = grid.dataProvider.length;
            const rowGap:Number = gridDimensions.rowGap;
            const defaultRowHeight:Number = 
                typicalLayoutElement.getPreferredBoundsHeight();

            measuredHeight = rowCount * (defaultRowHeight + rowGap);
            
            // One less row gap if there isn't a column header bar.
            const columnHeaderBar:ColumnHeaderBar = getColumnHeaderBar();
            if (!columnHeaderBar || !columnHeaderBar.visible)
                measuredHeight -= rowGap;
        }
                    
        // ToDo:(cframpto)  If there is a scroller without an explicit size, 
        // what should the measured size of the grid?
        
        measuredWidth = Math.min(measuredWidth, 600);
        measuredHeight = Math.min(measuredHeight, 480);
        
        // Use Math.ceil() to make sure that if the content partially occupies
        // the last pixel, we'll count it as if the whole pixel is occupied.
        
        grid.measuredWidth = Math.ceil(measuredWidth);    
        grid.measuredHeight = Math.ceil(measuredHeight);
        
        // Not used if virtual layout so don't bother to calculate.
        grid.measuredMinWidth = grid.measuredWidth;    
        grid.measuredMinHeight = grid.measuredHeight; 
        
       //trace("GridLayout.measure", grid.measuredWidth, grid.measuredHeight);        
    }
    
    /**
