Colorir apenas uma célula do JTable.

JavaGuru Membro desde: 27/03/2006 09:22:41 Mensagens: 200 Offline

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?

HelloWorld Membro desde: 05/07/2005 08:57:11 Mensagens: 13 Offline

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;
    }
}

HelloWorld Membro desde: 05/07/2005 08:57:11 Mensagens: 13 Offline

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);
}

JavaGuru Membro desde: 27/03/2006 09:22:41 Mensagens: 200 Offline

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

JavaGuru Membro desde: 27/03/2006 09:22:41 Mensagens: 200 Offline

Minha ultima resposta foi pro primeiro código...não tinha visto o segundo =)

JavaGuru Membro desde: 27/03/2006 09:22:41 Mensagens: 200 Offline

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.

JavaGuru Membro desde: 27/03/2006 09:22:41 Mensagens: 200 Offline

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?

JavaGuru Membro desde: 27/03/2006 09:22:41 Mensagens: 200 Offline

Ninguém?
Help!

JavaGuru Membro desde: 27/03/2006 09:22:41 Mensagens: 200 Offline

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

agora faça o que quiser com os Titulos, celulas e etc!!!

JavaGuru Membro desde: 27/03/2006 09:22:41 Mensagens: 200 Offline

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?

Ricardo Siqueira wrote: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?

Mas vc vai mostrar os 2000 de uma vez?
Limita seu jtable a mostrar apenas o 100 primeiros talvez....
Um abraço !

Ricardo Siqueira wrote: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?

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....

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];
    }
}

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 );

}
}

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!!!

Smalltalk Membro desde: 11/06/2008 11:14:25 Mensagens: 4 Offline

.

Notícias, artigos e o maior fórum brasileiro sobre Java