Já virei e revirei jamanac e a API do JTable.
Vi um tal de GetCellRenderer mas foi o mais próximo a que cheguei.
Não é possível que algo tão simples seja tão complicado de fazer.
O que quero é colorir (ou não) uma célula da minha JTable de acordo com um teste condicional. Mas o setBackground() pinta a tabela inteira.
Alguma luz?
ve se te ajuda
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.AbstractCellEditor;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.border.Border;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
/**
* This is like TableDemo, except that it substitutes a
* Favorite Color column for the Last Name column and specifies
* a custom cell renderer and editor for the color data.
*/
public class TableDialogEditDemo extends JPanel {
private boolean DEBUG = false;
public TableDialogEditDemo() {
super(new GridLayout(1,0));
JTable table = new JTable(new MyTableModel());
table.setPreferredScrollableViewportSize(new Dimension(500, 70));
//Create the scroll pane and add the table to it.
JScrollPane scrollPane = new JScrollPane(table);
//Set up renderer and editor for the Favorite Color column.
table.setDefaultRenderer(Color.class,
new ColorRenderer(true));
table.setDefaultEditor(Color.class,
new ColorEditor());
//Add the scroll pane to this panel.
add(scrollPane);
}
class MyTableModel extends AbstractTableModel {
private String[] columnNames = {"First Name",
"Favorite Color",
"Sport",
"# of Years",
"Vegetarian"};
private Object[][] data = {
{"Mary", new Color(153, 0, 153),
"Snowboarding", new Integer(5), new Boolean(false)},
{"Alison", new Color(51, 51, 153),
"Rowing", new Integer(3), new Boolean(true)},
{"Kathy", new Color(51, 102, 51),
"Knitting", new Integer(2), new Boolean(false)},
{"Sharon", Color.red,
"Speed reading", new Integer(20), new Boolean(true)},
{"Philip", Color.pink,
"Pool", new Integer(10), new Boolean(false)}
};
public int getColumnCount() {
return columnNames.length;
}
public int getRowCount() {
return data.length;
}
public String getColumnName(int col) {
return columnNames[col];
}
public Object getValueAt(int row, int col) {
return data[row][col];
}
/*
* JTable uses this method to determine the default renderer/
* editor for each cell. If we didn't implement this method,
* then the last column would contain text ("true"/"false"),
* rather than a check box.
*/
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
public boolean isCellEditable(int row, int col) {
//Note that the data/cell address is constant,
//no matter where the cell appears onscreen.
if (col < 1) {
return false;
} else {
return true;
}
}
public void setValueAt(Object value, int row, int col) {
if (DEBUG) {
System.out.println("Setting value at " + row + "," + col
+ " to " + value
+ " (an instance of "
+ value.getClass() + ")");
}
data[row][col] = value;
fireTableCellUpdated(row, col);
if (DEBUG) {
System.out.println("New value of data:");
printDebugData();
}
}
private void printDebugData() {
int numRows = getRowCount();
int numCols = getColumnCount();
for (int i=0; i < numRows; i++) {
System.out.print(" row " + i + ":");
for (int j=0; j < numCols; j++) {
System.out.print(" " + data[i][j]);
}
System.out.println();
}
System.out.println("--------------------------");
}
}
/**
* Create the GUI and show it. For thread safety,
* this method should be invoked from the
* event-dispatching thread.
*/
private static void createAndShowGUI() {
//Make sure we have nice window decorations.
JFrame.setDefaultLookAndFeelDecorated(true);
//Create and set up the window.
JFrame frame = new JFrame("TableDialogEditDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Create and set up the content pane.
JComponent newContentPane = new TableDialogEditDemo();
newContentPane.setOpaque(true); //content panes must be opaque
frame.setContentPane(newContentPane);
//Display the window.
frame.pack();
frame.setVisible(true);
}
public static void main(String[] args) {
//Schedule a job for the event-dispatching thread:
//creating and showing this application's GUI.
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
createAndShowGUI();
}
});
}
}
/*
* ColorRenderer.java (compiles with releases 1.2, 1.3, and 1.4) is used by
* TableDialogEditDemo.java.
*/
class ColorRenderer extends JLabel
implements TableCellRenderer {
Border unselectedBorder = null;
Border selectedBorder = null;
boolean isBordered = true;
public ColorRenderer(boolean isBordered) {
this.isBordered = isBordered;
setOpaque(true); //MUST do this for background to show up.
}
public Component getTableCellRendererComponent(
JTable table, Object color,
boolean isSelected, boolean hasFocus,
int row, int column) {
Color newColor = (Color)color;
setBackground(newColor);
if (isBordered) {
if (isSelected) {
if (selectedBorder == null) {
selectedBorder = BorderFactory.createMatteBorder(2,5,2,5,
table.getSelectionBackground());
}
setBorder(selectedBorder);
} else {
if (unselectedBorder == null) {
unselectedBorder = BorderFactory.createMatteBorder(2,5,2,5,
table.getBackground());
}
setBorder(unselectedBorder);
}
}
setToolTipText("RGB value: " + newColor.getRed() + ", "
+ newColor.getGreen() + ", "
+ newColor.getBlue());
return this;
}
}
/*
* ColorEditor.java (compiles with releases 1.3 and 1.4) is used by
* TableDialogEditDemo.java.
*/
class ColorEditor extends AbstractCellEditor
implements TableCellEditor,
ActionListener {
Color currentColor;
JButton button;
JColorChooser colorChooser;
JDialog dialog;
protected static final String EDIT = "edit";
public ColorEditor() {
//Set up the editor (from the table's point of view),
//which is a button.
//This button brings up the color chooser dialog,
//which is the editor from the user's point of view.
button = new JButton();
button.setActionCommand(EDIT);
button.addActionListener(this);
button.setBorderPainted(false);
//Set up the dialog that the button brings up.
colorChooser = new JColorChooser();
dialog = JColorChooser.createDialog(button,
"Pick a Color",
true, //modal
colorChooser, this, //OK button handler
null); //no CANCEL button handler
}
/**
* Handles events from the editor button and from
* the dialog's OK button.
*/
public void actionPerformed(ActionEvent e) {
if (EDIT.equals(e.getActionCommand())) {
//The user has clicked the cell, so
//bring up the dialog.
button.setBackground(currentColor);
colorChooser.setColor(currentColor);
dialog.setVisible(true);
//Make the renderer reappear.
fireEditingStopped();
} else { //User pressed dialog's "OK" button.
currentColor = colorChooser.getColor();
}
}
//Implement the one CellEditor method that AbstractCellEditor doesn't.
public Object getCellEditorValue() {
return currentColor;
}
//Implement the one method defined by TableCellEditor.
public Component getTableCellEditorComponent(JTable table,
Object value,
boolean isSelected,
int row,
int column) {
currentColor = (Color)value;
return button;
}
}ou então esse aqui é melhor
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.EventObject;
import javax.swing.DefaultCellEditor;
import javax.swing.ImageIcon;
import javax.swing.JColorChooser;
import javax.swing.JComboBox;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.EventListenerList;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;
public class TableCellRenderTest {
public static void main(String[] args) {
JFrame frame = new TableCellRenderFrame();
frame.show();
}
}
/*
* the planet table model specifies the values, rendering and editing properties
* for the planet data
*/
class PlanetTableModel extends AbstractTableModel {
public String getColumnName(int c) {
return columnNames[c];
}
public Class getColumnClass(int c) {
return cells[0][c].getClass();
}
public int getColumnCount() {
return cells[0].length;
}
public int getRowCount() {
return cells.length;
}
public Object getValueAt(int r, int c) {
return cells[r][c];
}
public void setValueAt(Object obj, int r, int c) {
cells[r][c] = obj;
}
public boolean isCellEditable(int r, int c) {
return c == NAME_COLUMN || c == MOON_COLUMN || c == GASEOUS_COLUMN
|| c == COLOR_COLUMN;
}
public static final int NAME_COLUMN = 0;
public static final int MOON_COLUMN = 2;
public static final int GASEOUS_COLUMN = 3;
public static final int COLOR_COLUMN = 4;
private Object[][] cells = {
{ "Mercury", new Double(2440), new Integer(0), Boolean.FALSE,
Color.yellow, new ImageIcon("Mercury.gif") },
{ "Venus", new Double(6052), new Integer(0), Boolean.FALSE,
Color.yellow, new ImageIcon("Venus.gif") },
{ "Earth", new Double(6378), new Integer(1), Boolean.FALSE,
Color.blue, new ImageIcon("Earth.gif") },
{ "Mars", new Double(3397), new Integer(2), Boolean.FALSE,
Color.red, new ImageIcon("Mars.gif") },
{ "Jupiter", new Double(71492), new Integer(16), Boolean.TRUE,
Color.orange, new ImageIcon("Jupiter.gif") },
{ "Saturn", new Double(60268), new Integer(18), Boolean.TRUE,
Color.orange, new ImageIcon("Saturn.gif") },
{ "Uranus", new Double(25559), new Integer(17), Boolean.TRUE,
Color.blue, new ImageIcon("Uranus.gif") },
{ "Neptune", new Double(24766), new Integer(8), Boolean.TRUE,
Color.blue, new ImageIcon("Neptune.gif") },
{ "Pluto", new Double(1137), new Integer(1), Boolean.FALSE,
Color.black, new ImageIcon("Pluto.gif") } };
private String[] columnNames = { "Planet", "Radius", "Moons", "Gaseous",
"Color", "Image" };
}
class TableCellRenderFrame extends JFrame {
public TableCellRenderFrame() {
setTitle("TableCellRenderTest");
setSize(300, 200);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
TableModel model = new PlanetTableModel();
JTable table = new JTable(model);
// set up renderers and editors
table.setDefaultRenderer(Color.class, new ColorTableCellRenderer());
table.setDefaultEditor(Color.class, new ColorTableCellEditor());
JComboBox moonCombo = new JComboBox();
for (int i = 0; i <= 20; i++)
moonCombo.addItem(new Integer(i));
TableColumnModel columnModel = table.getColumnModel();
TableColumn moonColumn = columnModel
.getColumn(PlanetTableModel.MOON_COLUMN);
moonColumn.setCellEditor(new DefaultCellEditor(moonCombo));
// show table
table.setRowHeight(100);
Container contentPane = getContentPane();
contentPane.add(new JScrollPane(table), "Center");
}
}
class ColorTableCellRenderer implements TableCellRenderer {
public Component getTableCellRendererComponent(JTable table, Object value,
boolean isSelected, boolean hasFocus, int row, int column) {
panel.setBackground((Color) value);
return panel;
}
/*
* the following panel is returned for all cells, with the background color
* set to the Color value of the cell
*/
private JPanel panel = new JPanel();
}
class ColorTableCellEditor extends ColorTableCellRenderer implements
TableCellEditor {
ColorTableCellEditor() { // prepare color dialog
colorChooser = new JColorChooser();
colorDialog = JColorChooser.createDialog(null, "Planet Color", false,
colorChooser, new ActionListener() // OK button listener
{
public void actionPerformed(ActionEvent event) {
fireEditingStopped();
}
}, new ActionListener() // Cancel button listener
{
public void actionPerformed(ActionEvent event) {
fireEditingCanceled();
}
});
}
public Component getTableCellEditorComponent(JTable table, Object value,
boolean isSelected, int row, int column) { /*
* this is where we get
* the current Color
* value We store it in
* the dialog in case the
* user starts editing
*/
colorChooser.setColor((Color) value);
return getTableCellRendererComponent(table, value, isSelected, true,
row, column);
}
public boolean isCellEditable(EventObject anEvent) {
return true;
}
public boolean shouldSelectCell(EventObject anEvent) { // start editing
colorDialog.setVisible(true);
// tell caller it is ok to select this cell
return true;
}
public void cancelCellEditing() { // editing is canceled--hide dialog
colorDialog.setVisible(false);
}
public boolean stopCellEditing() { // editing is complete--hide dialog
colorDialog.setVisible(false);
// tell caller is is ok to use color value
return true;
}
public Object getCellEditorValue() {
return colorChooser.getColor();
}
public void addCellEditorListener(CellEditorListener l) {
listenerList.add(CellEditorListener.class, l);
}
public void removeCellEditorListener(CellEditorListener l) {
listenerList.remove(CellEditorListener.class, l);
}
protected void fireEditingStopped() {
Object[] listeners = listenerList.getListenerList();
for (int i = listeners.length - 2; i >= 0; i -= 2)
((CellEditorListener) listeners[i + 1]).editingStopped(event);
}
protected void fireEditingCanceled() {
Object[] listeners = listenerList.getListenerList();
for (int i = listeners.length - 2; i >= 0; i -= 2)
((CellEditorListener) listeners[i + 1]).editingCanceled(event);
}
private Color color;
private JColorChooser colorChooser;
private JDialog colorDialog;
private EventListenerList listenerList = new EventListenerList();
private ChangeEvent event = new ChangeEvent(this);
}Então…eu ja tinha visto esse exemplo. Mas ele transforma a célula em um botão como percebi.
Não quero fazer isso. Essa célula não será editável e a cor será alterada apenas uma vez quando a JTable for iniciada.
Mas to tentando abstrair daí de dentro uma forma de fazer isso…sem precisar usar uma célula como botão
Minha ultima resposta foi pro primeiro código…não tinha visto o segundo =)
Ent~so…é o seguinte.
Ao inicializar a tabela eu quero que ele coloque os valores(até aí normal) a fonte em que serão exibidos os valores(normal) e a cor de cada célula baseada num teste if.
Como é um relatório de entrada e saída de funcionários seria por exemplo um verde se ele fez hora extra e um vermelho se ele chegou atrasado. Este teste if tá pronto…o problema é seta a cor da tabela.
E mais…essa tabela NÃO é editavel por isso a celula não poderia ser um botão.
Continuo tentando solucionar este problema 
Alguém pode ao menos me dar uma luz de algo que poderia solucionar este problema?
To tentando usar esses exemplos aí de cima e no lugar de um botão criando um JLabel mas não tá dando mto certo to trabalhando nisso se der certo posto o código aqui.
Mas alguém sabe de outro jeito? Preciso mesmo criar subclasses?
Ninguém?
Help!
Continuo sem conseguir resolver este problema.
Alguém tem alguma dica?
Gerenciando por completo uma JTable:
TableModel:
import java.text.*;
import javax.swing.JOptionPane;
import javax.swing.table.*;
public class PessoasTableModel extends AbstractTableModel{
private List<Pessoa> pessoas;
private DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
/** Creates a new instance of TarefasTableModel */
public PessoasTableModel(List<Pessoa> pessoas) {
this.pessoas = pessoas;
}
public Object getValueAt(int rowIndex, int columnIndex) {
Pessoa umPessoa = pessoas.get(rowIndex);
switch(columnIndex){
case 0: return umPessoa.getCpf();
case 1: return umPessoa.getNome();
}
return null;
}
public void update(ArrayList<Pessoa> newPessoas) {
this.pessoas = newPessoas;
fireTableDataChanged();
}
public int getRowCount() {
return pessoas.size();
}
public int getColumnCount() {
return 4;
}
public Pessoa getValoresPessoa(int rowIndex){
return pessoas.get(rowIndex);
}
}ColumnModel
import java.awt.*;
import javax.swing.table.*;
public class PessoasColumnModel extends DefaultTableColumnModel{
/** Creates a new instance of TarefasColumnModel */
public PessoasColumnModel(FontMetrics fm) {
int digito = fm.stringWidth("0");
int letra = fm.stringWidth("M");
addColumn(criaColuna(0, 15 * digito, fm, false, "CPF"));
addColumn(criaColuna(1, 35 * letra, fm, false, "Nome"));
}
private TableColumn criaColuna(int columnIndex, int largura, FontMetrics fm,
boolean resizeable, String titulo){
int larguraTitulo = fm.stringWidth(titulo + " ");
if(largura < larguraTitulo)
largura = larguraTitulo;
TableColumn col = new TableColumn(columnIndex);
col.setCellRenderer(new PessoasCellRenderer());
col.setHeaderRenderer(new PessoasHeaderRenderer());
col.setHeaderValue(titulo);
col.setPreferredWidth(largura);
if(!resizeable){
col.setMaxWidth(largura);
col.setMinWidth(largura);
}
col.setResizable(resizeable);
return col;
}
}CellRenderer
import java.awt.Color;
import java.awt.Component;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.table.*;
public class PessoasCellRenderer extends DefaultTableCellRenderer{
/** Creates a new instance of TarefasCellRenderer */
public PessoasCellRenderer() {
super();
}
public Component getTableCellRendererComponent(JTable table,
Object value, boolean isSelected, boolean hasFocus, int row, int column){
JLabel label = (JLabel)super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
row, column);
if(isSelected){
label.setForeground(Color.WHITE);
label.setBackground(Color.GRAY);
}else{
label.setForeground(Color.BLACK);
label.setBackground(Color.WHITE);
//aqui vc pode fazer o seu if tipo if(value.toString.equals("seila")) label.setbackgrund...
}
//lembrando que vc pode obter o objeto da linhas correspondente assim
Pessoa pessoa = ((PessoasTableModel)table.getModel()).getValoresPessoa(row);
//e fazer os if's direto nos valores do objeto, nesse caso para colorir a linha inteira!!
return label;
}
}
e HeaderRenderer
import java.awt.*;
import java.text.DateFormat;
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;
public class PessoasHeaderRenderer extends DefaultTableCellRenderer{
/** Creates a new instance of TarefasCellRenderer */
public PessoasHeaderRenderer() {
super();
}
public Component getTableCellRendererComponent(JTable table,
Object value, boolean isSelected, boolean hasFocus, int row, int column){
JLabel label = (JLabel)super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
row, column);
label.setBackground(new Color(183,216,226));
label.setBorder(BorderFactory.createEtchedBorder());
label.setFont(new Font("Arial", Font.BOLD, 12));
return label;
}
}agora faça o que quiser com os Titulos, celulas e etc!!!
PERFEITO!!! um label na célula, daí eu só mudo a cor do label!!!
Mas vem ca isso não fica pesado demais? Tenho tabelas aqui de tipo 2000 linhas…fico imaginando a quantidade de labels que serão gerados…
Muitos componentes num mesmo frame podem deixar o programa pesado?
[quote=Ricardo Siqueira]PERFEITO!!! um label na célula, daí eu só mudo a cor do label!!!
Mas vem ca isso não fica pesado demais? Tenho tabelas aqui de tipo 2000 linhas…fico imaginando a quantidade de labels que serão gerados…
Muitos componentes num mesmo frame podem deixar o programa pesado?[/quote]
Mas vc vai mostrar os 2000 de uma vez?
Limita seu jtable a mostrar apenas o 100 primeiros talvez…
Um abraço !
[quote=Ricardo Siqueira]PERFEITO!!! um label na célula, daí eu só mudo a cor do label!!!
Mas vem ca isso não fica pesado demais? Tenho tabelas aqui de tipo 2000 linhas…fico imaginando a quantidade de labels que serão gerados…
Muitos componentes num mesmo frame podem deixar o programa pesado?[/quote]
Cara achei um código aqui que vai ser bala para o que vc quer,rodei ele aqui e funcionou blz vou colocá-lo para vc testar,os números negativos ficam em vermelho.
São tres classes…
[code]import java.awt.Component;
import java.awt.Color;
import javax.swing.JTable;
import javax.swing.table.DefaultTableCellRenderer;
public class CustomTableCellRenderer extends DefaultTableCellRenderer
{
public Component getTableCellRendererComponent
(JTable table, Object value, boolean isSelected,
boolean hasFocus, int row, int column)
{
Component cell = super.getTableCellRendererComponent
(table, value, isSelected, hasFocus, row, column);
if( value instanceof Integer )
{
Integer amount = (Integer) value;
if( amount.intValue() < 0 )
{
cell.setBackground( Color.red );
// You can also customize the Font and Foreground this way
// cell.setForeground();
// cell.setFont();
}
else
{
cell.setBackground( Color.white );
}
}
return cell;
}
}[/code]
[code]import javax.swing.table.AbstractTableModel;
[code]public class ExampleTableModel extends AbstractTableModel
{
private final String[] columnNames = { “Month”, “Income” };
final Object[][] data = {
{"January", new Integer(150) },
{"February", new Integer(500) },
{"March", new Integer(54) },
{"April", new Integer(-50) },
{"May", new Integer(52) },
{"June", new Integer(74) },
{"July", new Integer(-25) },
{"August", new Integer(62) },
{"September", new Integer(15) },
{"October", new Integer(-5) },
{"November", new Integer(5) },
{"December", new Integer(59) }
};
public Class getColumnClass( int column )
{
return getValueAt(0, column).getClass();
}
public int getColumnCount()
{
return columnNames.length;
}
public String getColumnName( int column )
{
return columnNames[column];
}
public int getRowCount()
{
return data.length;
}
public Object getValueAt( int row, int column )
{
return data[row][column];
}
}[/code]
[code]
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.table.TableCellRenderer;
import javax.swing.JFrame;
import javax.swing.JTable;
public class TableCellExample
{
public static void main( String[] args )
{
JTable table = new JTable( new ExampleTableModel() );
TableCellRenderer renderer = new CustomTableCellRenderer();
try
{
table.setDefaultRenderer( Class.forName
( "java.lang.Integer" ), renderer );
}
catch( ClassNotFoundException ex )
{
System.exit( 0 );
}
JFrame frame = new JFrame();
frame.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
}
);
frame.getContentPane().add( table );
frame.pack();
frame.setVisible( true );
}
}[/code]
Depois vc fala ae se ajudou …Um abraço !
Não, não fica pesado não!!! eu ja testei com até 100.000 registros(mostrando 2 campos) e o que gastou mais tempo foi o select do banco, a table ficou normal!!!
E outra coisa, é exatamente assim, com essas classes que a JTable trabalha, so que escondido!!, nesse exemplo vc apenas escreveu suas proprias renderers e falou pra table usa-las!!!
.
Semelhante ao do dsfextreme…
no método main coloca o codigo abaixo:
[code] JTable tableteste = new JTable(3,3);
JOptionPane.showMessageDialog(null, tableteste); //aqui voce pode preencher os dados da tabela na mao. ou pegar os valores como queira
tableteste.setDefaultRenderer(Object.class, new CustomTableCellRenderer());
JOptionPane.showMessageDialog(null, tableteste); //aqui a tabela é apresentada com as modificações do CustomTableCellRenderer() [/code]
Utilizei a seguinte classe CustomTableCellRenderer:
[code]import java.awt.Component;
import java.awt.Color;
import javax.swing.JTable;
import javax.swing.table.DefaultTableCellRenderer;
public class CustomTableCellRenderer extends DefaultTableCellRenderer{
@Override
public Component getTableCellRendererComponent
(JTable table, Object value, boolean isSelected,
boolean hasFocus, int row, int column)
{
Component cell = super.getTableCellRendererComponent
(table, value, isSelected, hasFocus, row, column);
if( value instanceof Integer ){
Integer amount = (Integer) value;
if( amount.intValue() < 0 ){
cell.setBackground( Color.red );
// You can also customize the Font and Foreground this way
// cell.setForeground();
// cell.setFont();
}
else{
cell.setBackground( Color.white );
}
}else if(value instanceof String){
String valor = (String)value;
if( valor.equalsIgnoreCase("A") ){
cell.setBackground( Color.red );
// You can also customize the Font and Foreground this way
// cell.setForeground();
// cell.setFont();
}
else{
cell.setBackground( Color.white );
}
}
return cell;
}
}[/code]
Desta forma que utilizei, quando executar o main, na tela irá aparecer a tabela 3 por 3 para preenchimento na mão, se preencher com A ou com -1 e der ok, irá pintar a celula de vermelho… todas essas modificações ficam centralizadas na CustomTableCellRenderer.