Java JTable change cell color

Question

I would like to make an editable table and then check the data to make sure its valid. Im not sure how to change the color of just one cell. I would like to get a cell, for

Answer 1

Say that the cell you would like to render with a different color represents a status (I'll take Rejected and Approved as examples). I'd then implement a method in my table model called getStatus(int row) which returns the status for any given row.

Then, when that is in place, I'd go about creating a cell renderer responsible for rendering the column which the cell belongs to. The cell renderer would be something in the lines of the below code.

public class StatusColumnCellRenderer extends DefaultTableCellRenderer {
  @Override
  public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int col) {

    //Cells are by default rendered as a JLabel.
    JLabel l = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, col);

    //Get the status for the current row.
    CustomTableModel tableModel = (CustomTableModel) table.getModel();
    if (tableModel.getStatus(row) == CustomTableModel.APPROVED) {
      l.setBackground(Color.GREEN);
    } else {
      l.setBackground(Color.RED);
    }

  //Return the JLabel which renders the cell.
  return l;

}

Then, when the renderer is in place, simply "apply" the renderer to the table with the following piece of code:

Table.getColumnModel().getColumn(columnIndex).setCellRenderer(new StatusColumnCellRenderer());

With regard to making a cell editable, simply implement the isCellEditable(int rowIndex, int columnIndex) method in your table model. You also need to implement the method setValueAt(Object value, int rowIndex, int columnIndex) if you would like to keep the value which the user provides (which i assume you do!).

Answer 2

You can extend DefaultTableCellRenderer, override getTableCellRendererComponent and call something like

if (myConditions) setBackground(myColor);

before returning "this" when conditions apply but it has a very annoying side-effect of changing the default back-color due to the way DefaultTableCellRenderer.setBackGround is coded.

The trick I found was to entirely duplicate the code of DefaultTableCellRenderer in a class named HackedDefaultTableCellRenderer, add a method that calls directly the Component's setBackground implementation:

public void setComponentBackground(Color c) {
    super.setBackground(c);
}

then derive my customized rendered from this hacked class instead of from DefaultTableCellRenderer, and finally call setComponentBackground instead of setBackground in my customized getTableCellRendererComponent.

The drawback is that this HackedDefaultTableCellRenderer relies on a snapshot of DefaultTableCellRenderer.

Answer 3

I believe the correct way to do colouring in a table is via a ColorHighlighter. The table renderers have problems to render different colours in the same column.

Here is an example of how to use highlighters. In this case it is for highlighting a cell that is not editable.

public class IsCellEditablePredicate implements HighlightPredicate {

   private JXTable table;

   public IsCellEditablePredicate (final JXTable table) {
       this.table = table;
   }

   @Override
   public boolean isHighlighted(Component component, ComponentAdapter componentAdapter) {

        return !table.isCellEditable(componentAdapter.row,
          componentAdapter.column);
   }
}

and then in your code for setuping the table you add the highlighter and its colour parameters:

 ColorHighlighter grayHighlighter = new ColorHighlighter(new IsCellEditablePredicate(table));

    grayHighlighter.setBackground(Color.LIGHT_GRAY);
    grayHighlighter.setForeground(table.getForeground());
    grayHighlighter.setSelectedBackground(table.getSelectionBackground().darker());
    grayHighlighter.setSelectedForeground(table.getSelectionForeground().darker());

    table.setHighlighters(grayHighlighter);

Answer 4

I would like to make an editable table and then check the data to make sure its valid.

Another approach would be to edit the data before it is saved to the table model to prevent invalid data from being entered.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.table.*;

public class TableEdit extends JFrame
{
    TableEdit()
    {
        JTable table = new JTable(5,5);
        table.setPreferredScrollableViewportSize(table.getPreferredSize());

        JScrollPane scrollpane = new JScrollPane(table);
        getContentPane().add(scrollpane);

        //  Use a custom editor

        TableCellEditor fce = new FiveCharacterEditor();
        table.setDefaultEditor(Object.class, fce);
    }

    class FiveCharacterEditor extends DefaultCellEditor
    {
        FiveCharacterEditor()
        {
            super( new JTextField() );
        }

        public boolean stopCellEditing()
        {
            try
            {
                String editingValue = (String)getCellEditorValue();

                if(editingValue.length() != 5)
                {
                    JTextField textField = (JTextField)getComponent();
                    textField.setBorder(new LineBorder(Color.red));
                    textField.selectAll();
                    textField.requestFocusInWindow();

                    JOptionPane.showMessageDialog(
                        null,
                        "Please enter string with 5 letters.",
                        "Alert!",JOptionPane.ERROR_MESSAGE);
                    return false;
                }
            }
            catch(ClassCastException exception)
            {
                return false;
            }

            return super.stopCellEditing();
        }

        public Component getTableCellEditorComponent(
            JTable table, Object value, boolean isSelected, int row, int column)
        {
            Component c = super.getTableCellEditorComponent(
                table, value, isSelected, row, column);
            ((JComponent)c).setBorder(new LineBorder(Color.black));

            return c;
        }

    }

    public static void main(String [] args)
    {
        JFrame frame = new TableEdit();
        frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
        frame.pack();
        frame.setLocationRelativeTo( null );
        frame.setVisible(true);
    }
}

Answer 5

This is the simplest way to color a particular Column or cell in a jTable.

First just create a simple class of CustomRenderer

class CustomRenderer extends DefaultTableCellRenderer <br />
{
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column)
    {
        Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
        setForeground(Color.blue); >
        return c;
    }
}

This code gets the column of cell to render

TableColumn col = tblExamHistoryAll.getColumnModel().getColumn(5);
DefaultTableModel model3 = (DefaultTableModel)tblExamHistoryAll.getModel();
col.setCellRenderer(new CustomRenderer());

This is to clear all previous rows from your table. If you do not want them just remove these lines

model3.getDataVector().removeAllElements();
model3.fireTableDataChanged();

Answer 6

The most straightforward way is to write a simple TableCellRenderer by extending the DefaultTableCellRenderer and overwriting the getTableCellRendererComponent method to setBackground( Color.RED ). For example:

final JTable table = new JTable(...);
table.setCellRenderer( new DefaultTableCellRenderer() {
    public Component getTableCellRenderer(JTable table, Object value, ...) {
        super.getTableCellRenderer(...);

        if ( value should be highlighted ) {
            setBackground( Color.RED );
        }
        return this;
    }
});