TableUI implementation to distinguish editable/noneditable cells

Question

I have implemented a Look and Feel for a swing application that changes the background of text fields, combo boxes, check boxes, etc to the standard editable color (typically a white color) when they are enabled. When the field is diabled, the color is made to be that of the button background color (typically a lightgray color). In the tables, the default color for a cell is white (editable or not). I have found a solution for updating the cell renderers that makes the color scheme standard across the application, but I would like to continue with the look&feel approach using a tableUI. I have created a tableUI class that implements the paint method. This method is a variation of the method decompiled from the BasicTableUI implementation (my source code will follow). I am still having a few problems with painting. The first row in the table, the first time the table is painted, still shows up with the standard colors until clicked on, sorted, column dragged, focus lost and gained, etc. - basically anything that forces the table to paint again. I fixed this by calling the paintCells method twice, but I do not like this(for obvious reasones) and do not fully understand the problem. Furthermore, I have noticed that in some tables that have rows with different columns disabled than others, clicking from row to row can cause paint flickering, where the control starts out white and then goes gray. I have yet to see any examples of anyone trying to solve swing's inconsistency with the check boxes, textfields, textarea, dropdowns, and tables. Any help would be appreciated.
     public void paint(Graphics graphics, JComponent jcomponent) {
          if (table.getRowCount() > 0 && table.getColumnCount() > 0) {
               Rectangle rectangle = graphics.getClipBounds();
               Point point = rectangle.getLocation();
               Point diagPoint = new Point(rectangle.x + rectangle.width - 1,
                            rectangle.y + rectangle.height - 1);
               int topRow = table.rowAtPoint(point);
               int bottomRow = table.rowAtPoint(diagPoint);
               if (topRow == -1) topRow = 0;
               if (bottomRow == -1) bottomRow = table.getRowCount() - 1;
               int leftCol = table.columnAtPoint(point);
               int rightCol = table.columnAtPoint(diagPoint);
               if (leftCol == -1) leftCol = 0;
               if (rightCol == -1) rightCol = table.getColumnCount() - 1;
               paintGrid(graphics, topRow, bottomRow, leftCol, rightCol);
               paintCells(graphics, topRow, bottomRow, leftCol, rightCol);
               //added re-call because first line of table was not painting
                        //correct table on first render of the table
               paintCells(graphics, topRow, bottomRow, leftCol, rightCol);
     private void paintCells(Graphics graphics, int topRow, int bottomRow,
                int leftCol, int rightCol) {
          JTableHeader jtableheader = table.getTableHeader();
          TableColumn tablecolumn = jtableheader == null ? null : jtableheader.getDraggedColumn();
          TableColumnModel tablecolumnmodel = table.getColumnModel();
          int colMargin = tablecolumnmodel.getColumnMargin();
          for (int i = topRow; i <= bottomRow; i++) {
               Rectangle rectangle = table.getCellRect(i, leftCol, false);
               for (int j = leftCol; j <= rightCol; j++) {
                    TableColumn column = tablecolumnmodel.getColumn(j);
                    int colWidth = column.getWidth();
                    rectangle.width = colWidth - colMargin;
                    if (column != tablecolumn) paintCell(graphics, rectangle, i, j);
                    rectangle.x += colWidth;
          if (tablecolumn != null)
               paintDraggedArea(graphics, topRow, bottomRow,
                           tablecolumn, jtableheader.getDraggedDistance());
          rendererPane.removeAll();
     private void paintCell(Graphics graphics, Rectangle rectangle, int row, int col) {
          boolean enabled = table.isCellEditable(row, col) && table.isEnabled();
          if (table.isEditing() && table.getEditingRow() == row && table.getEditingColumn() == col) {
               Component component = table.getEditorComponent();
               component.setBounds(rectangle);
               component.validate();
          } else {
               TableCellRenderer tablecellrenderer = table.getCellRenderer(row, col);
               Component component = table.prepareRenderer(tablecellrenderer, row, col);
               boolean selected = table.getSelectedRow() == row;
               if (enabled) {
                    if (selected) {
                         Color bckgrnd = (Color)UIManager.get("Table.selectionBackground");
                         int red = ((bckgrnd.getRed() + 36) >= 255
                                            ? 255 : bckgrnd.getRed() + 36);
                         int green = ((bckgrnd.getGreen() + 36) >= 255
                                            ? 255 : bckgrnd.getGreen() + 36);
                         int blue = ((bckgrnd.getBlue() + 36) >= 255
                                            ? 255 : bckgrnd.getBlue() + 36);
                         bckgrnd = new Color(red, green , blue);
                         component.setBackground(bckgrnd);
                    } else {
                         component.setBackground((Color)UIManager.get("Table.background"));
               } else {
                    if (selected)
                         component.setBackground((Color)UIManager.get(
                                            "Table.selectionBackground"));
                    else
                         component.setBackground((Color)UIManager.get("Label.background"));
               rendererPane.paintComponent(graphics, component, table, rectangle.x,
                            rectangle.y, rectangle.width, rectangle.height, true);
     }

Answer 1

The best way to do this is with a custom table cell renderer. Renderer's are passed all the params about the cell (including if it's editable). You just set the background (or whatever) of your rendering component based on that flag and return it. It is very easy to extend the existing default renderers for this, as well as to create your own custom ones.
Doing this via a custom UI really isn't practical because everyone that creates a custom renderer has the ability to draw the cell themselves ignoring whatever nifty 'work' your UI may be doing.