     public function invalidateCell(rowIndex:int, columnIndex:int):void
     {
         if (!dataProvider)
-            return;
-        
-        const dataProviderLength:int = dataProvider.length;
-        if (rowIndex >= dataProvider.length)
-            return;
-        
-        if (!isCellVisible(rowIndex, columnIndex))
-            return;
-        
-        // TODO (hmuller) this is a provisional implementation: invalidate the entire row
-        
-        const column:GridColumn = getGridColumn(columnIndex);
-        const dataField:String = (column) ? column.dataField : null;
-        
-        if (rowIndex >= 0)
-        {
-            // invalidate the cell or the row by invalidating the visible row
-            dataProvider.itemUpdated(dataProvider.getItemAt(rowIndex), dataField);
-        }
-        else
-        {
-            // invaliate the column by invalidating all visible rows
-            const rowIndices:Vector.<int> = getVisibleRowIndices();
-            for each (rowIndex in rowIndices)
+			return;
+		
+		const dataProviderLength:int = dataProvider.length;
+		if (rowIndex >= dataProvider.length)
+			return;
+		
+		if (!isCellVisible(rowIndex, columnIndex))
+			return;
+
+        if (invalidateDisplayListFlag || invalidateSizeFlag)
+            return;        
+		
+		if ((rowIndex >= 0) && (columnIndex >= 0))
+		{
+            gridLayout.invalidateCell(rowIndex, columnIndex);
+		}
+        else if (rowIndex >= 0)  // invalidate a row
+        {
+            const visibleColumnIndices:Vector.<int> = getVisibleColumnIndices();
+            for each (var visibleColumnIndex:int in visibleColumnIndices)
             {
-                // If there are any padding rows, skip them.
-                if (rowIndex >= dataProviderLength)
+                gridLayout.invalidateCell(rowIndex, visibleColumnIndex);
+                
+                // If invalidating the cell caused the entire grid to be invalid, punt 
+                if (invalidateDisplayListFlag || invalidateSizeFlag)
+                    break;                
+            }
+        }
+		else if (columnIndex >= 0)  // invalidate a column
+		{
+			const visibleRowIndices:Vector.<int> = getVisibleRowIndices();
+			for each (var visibleRowIndex:int in visibleRowIndices)
+			{
+				// If there are any padding rows, skip them.
+				if (visibleRowIndex >= dataProviderLength)
+					break;
+                
+                gridLayout.invalidateCell(visibleRowIndex, columnIndex);
+
+                // If invalidating the cell caused the entire grid to be invalid, punt 
+                if (invalidateDisplayListFlag || invalidateSizeFlag)
                     break;
-                
-                dataProvider.itemUpdated(dataProvider.getItemAt(rowIndex), dataField);          
-            }
-        }
+			}
+		}
     }
     
     /**

    
    /**
     *  Return the data provider indices and padding indices of the 
     *  currently visible rows.  
     *  Indices which are greater than or equal to the 
     *  <code>dataProvider</code> length represent padding rows.
     *  Note that the item renderers for the first and last rows 
     *  may only be partially visible. 
     *  The returned vector's contents are in the order they're displayed.

     * 
     *  @param rowIndex The 0-based row index of the cell that changed, or -1.
     *
     *  @param columnIndex The 0-based column index of the cell that changed or -1.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 10
