Clicking on radiobutton gives old value?

Question

I am quite new to java, so please don't be too harsh :)

I have a JTable with a column with 3 JRadioButtons in each cell.

The JRadioButtons display correctly, and the correct JRadioButtons are selected.

To put the JRadioButtons in the JTable I use setCellRenderer() and setCellEditor() :

private void addRadio(int intCol)
{
  mgrdData.getColumnModel().getColumn(intCol).setCellRenderer(new RadioButtonRenderer());
  RadioButtonEditor butEdit = new RadioButtonEditor(new JCheckBox());
  butEdit.UseTcp(mtcpGrid);
  mgrdData.getColumnModel().getColumn(intCol).setCellEditor(butEdit);
}

Below is the code of the RadioButtonEditor class :

public class RadioButtonEditor extends DefaultCellEditor implements ItemListener
{
  public JPanel pnl = new JPanel();
  public ButtonGroup group1 = new ButtonGroup();
  public JRadioButton btnVA = new JRadioButton("VA");
  public JRadioButton btnUIT = new JRadioButton("UIT");
  public JRadioButton btnAAN = new JRadioButton("AAN");

  public tcp mtcpCon;

  public RadioButtonEditor(JCheckBox checkBox)
  {
    super(checkBox);
  }

  public void UseTcp(tcp tcpCon)
  {
    mtcpCon = tcpCon;
  }

  public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column)
  {
    if (value==null) return null;
    group1.add(btnVA );
    group1.add(btnUIT );
    group1.add(btnAAN );
    pnl.add(btnVA );
    pnl.add(btnUIT );
    pnl.add(btnAAN );
    btnVA.setSelected(false);
    btnUIT .setSelected(false);
    btnAAN .setSelected(false);
    String strVal1 = (String)value;
    switch(Integer.parseInt(strVal1))
    {
      Case 0:
        btnVA.setSelected(true);
        break;
      Case 1:
        btnUIT.setSelected(true);
        break;
      Case 2:
        btnAAN.setSelected(true);
        break;
    }
    System.out.println("gettablecelleditorcomponent strVal1 : " + strVal1);
    return pnl;
  }

  public Object getCellEditorValue()
  {
    String strVal2="";
    if(btnVA.isSelected()  == true) strVal2="0";
    if(btnUIT.isSelected() == true) strVal2="1";
    if(btnAAN.isSelected() == true) strVal2="2";
    System.out.println("getcelleditorvalue strVal2 : " + strVal2);
    return strVal2;
  }

  public void itemStateChanged(ItemEvent e)
  {
    super.fireEditingStopped();
  }
}

Below is the code of the RadioButtonRenderer class :

public class RadioButtonRenderer implements TableCellRenderer
{
  public JPanel pnl = new JPanel();
  public ButtonGroup group1 = new ButtonGroup();
  public JRadioButton btnVA = new JRadioButton("VA");
  public JRadioButton btnUIT = new JRadioButton("UIT");
  public JRadioButton btnAAN = new JRadioButton("AAN");

  public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column)
  {
    if (value==null) value="0";
    btnVA.putClientProperty("JComponent.sizeVariant","small");
    btnAAN.putClientProperty("JComponent.sizeVariant","small");
    btnUIT.putClientProperty("JComponent.sizeVariant","small");
    group1.add(btnVA );
    group1.add(btnUIT );
    group1.add(btnAAN );
    pnl.add(btnVA );
    pnl.add(btnUIT );
    pnl.add(btnAAN );
    btnVA.setSelected(false);
    btnUIT .setSelected(false);
    btnAAN .setSelected(false);
    switch(Integer.parseInt((String)value))
    {
      Case 0:
        btnVA.setSelected(true);
        break;
      Case 1:
        btnUIT.setSelected(true);
        break;
      Case 2:
        btnAAN.setSelected(true);
        break;
    }
    return pnl;
  }
}

I want to detect which JRadioButton is clicked, and process that new value. I assume the fired event should be in the RadioButtonEditor class, but I don't know event.

I added println() to both the getTableCellEditor() as well as the getCellEditorValue() events, but both print an old value.

For example :

Start with row0=0, row1=1, row2=2

Click on 2 on row1 gives :

gettablecelleditorcomponent : 1

Now row0=0, row1=2, row2=2 Click on 1 on row0 gives :

getcelleditorvalue : 2
gettablecelleditorcomponent : 0

Now row0=1, row1=2, row2=2 Then click on 0 on row1 gives :

getcelleditorvalue : 1
gettablecelleditorcomponent : 2

Now row0=1, row1=0, row2=2 Then click on 1 on row2 gives :

getcelleditorvalue : 0
gettablecelleditorcomponent : 2

Now row0=1, row1=0, row2=1

From this can be seen :

getTableCellEditor() has the previous value of that row
getCellEditorValue() has the global previous value 

Which event can I use to obtain the new value of the JRadioButton, after it has been clicked?

[EDIT]

I added a TableModelListener to the table, but getFirstRow() still show the last selected row, and not the row in which the user clicked on the radiobutton.

So for example, when they last clicked on a radiobutton in row 5, and now click on a radiobuttion on row 7, then getFirstRow() in tabelChanged() still shows 5

Below is the code of my TableModelListener :

mgrdData.getModel().addTableModelListener(new TableModelListener()
{
  public void tableChanged(TableModelEvent e)
  {
    System.out.println("column : " + e.getColumn());
    System.out.println("firstrow : " + e.getFirstRow());
  }
});

Answer 1

Here is how I would do this:

public class RadioButtonsCellEditor
    extends AbstractCellEditor
    implements TableCellEditor
{
    private final JRadioButton vuButton = new JRadioButton ("VA");
    private final JRadioButton uitButton = new JRadioButton ("UIT");
    private final JRadioButton aanButton = new JRadioButton ("AAN");
    private final ButtonGroup group = new ButtonGroup ();
    private final Box box = Box.createHorizontalBox ();

    public RadioButtonsCellEditor ()
    {
        super ();

        group.add (vuButton);
        group.add (uitButton);
        group.add (aanButton);

        box.add (vuButton);
        box.add (uitButton);
        box.add (aanButton);
    }

    @Override
    public Object getCellEditorValue ()
    {
        return
            vuButton.isSelected () ? "VU" :
            uitButton.isSelected () ? "UIT" :
            aanButton.isSelected () ? "AAN" : "";
    }

    @Override
    public Component getTableCellEditorComponent (JTable table, Object value,
            boolean isSelected, int row, int column)
    {
        vuButton.setSelected ("VA".equals (value));
        uitButton.setSelected ("UIT".equals (value));
        aanButton.setSelected ("AAN".equals (value));

        box.setBackground (table.getBackground ());
        box.setForeground (table.getForeground ());

        vuButton.setBackground (table.getBackground ());
        vuButton.setForeground (table.getForeground ());
        uitButton.setBackground (table.getBackground ());
        uitButton.setForeground (table.getForeground ());
        aanButton.setBackground (table.getBackground ());
        aanButton.setForeground (table.getForeground ());

        return box;
    }

    public static void main (String [] args)
    {
        JTable table = new JTable (
            new Object [][] {
                new Object [] {"1", "VU"},
                new Object [] {"2", "UIT"},
                new Object [] {"3", "AAN"}
            }, new Object [] {"#", "Value"});

        table.getColumnModel ().getColumn (1).setCellRenderer (new RadioButtonsCellRenderer ());
        table.getColumnModel ().getColumn (1).setCellEditor (new RadioButtonsCellEditor ());

        JFrame frame = new JFrame ("RadioButtonsCellRenderer");
        frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
        frame.getContentPane ().setLayout (new BorderLayout ());
        frame.getContentPane ().add (
            new JScrollPane (
                table,
                JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));
        frame.pack ();
        frame.setVisible (true);
    }

    private static class RadioButtonsCellRenderer
        extends Box
        implements TableCellRenderer
    {
        private final JRadioButton vuButton = new JRadioButton ("VA");
        private final JRadioButton uitButton = new JRadioButton ("UIT");
        private final JRadioButton aanButton = new JRadioButton ("AAN");
        private final ButtonGroup group = new ButtonGroup ();

        public RadioButtonsCellRenderer ()
        {
            super (BoxLayout.LINE_AXIS);

            group.add (vuButton);
            group.add (uitButton);
            group.add (aanButton);

            add (vuButton);
            add (uitButton);
            add (aanButton);
        }

        @Override
        public Component getTableCellRendererComponent (JTable table,
                Object value, boolean isSelected, boolean hasFocus, int row,
                int column)
        {
            vuButton.setSelected ("VU".equals (value));
            uitButton.setSelected ("UIT".equals (value));
            aanButton.setSelected ("AAN".equals (value));

            setBackground (table.getBackground ());
            setForeground (table.getForeground ());

            vuButton.setBackground (table.getBackground ());
            vuButton.setForeground (table.getForeground ());
            uitButton.setBackground (table.getBackground ());
            uitButton.setForeground (table.getForeground ());
            aanButton.setBackground (table.getBackground ());
            aanButton.setForeground (table.getForeground ());

            return this;
        }
    }
}

Editor will just provider new value which will be set into table model. You need to read it from table model, not from editor.

Answer 2

If I correct understand your problem you simply should add to each radio button the same ActionListener

public void actionPerformed(ActionEvent ae) {
  JRadioButton rb = (JRadioButton) ae.getSource();
  if (rb.isSelected()) {
    // do something depended on the button which was pressed
  }
}

Answer 3

Try adding a TableModelListener to your JTable.

Editing is just a process for updating the model data inside the JTable. The values stored in the Editor are usually temporary and unpredictable.

At the end of editing, the end result is that your table's underlying model is updated. Then all TableModelListeners will be informed.

Updated

Ah ok. The problem now might be that the "editing finished" event isn't getting fired until the radio buttons in the editor lose focus. So, clicking onto row 7 actually fires you the event from row 5 which just lost focus. Clicking on 7 just gives it focus and BEGINS the editing process for 7. But, you can tell the editor when editing is finished. In the editor, try something like this:

public RadioButtonEditor(JCheckBox checkBox)
{
  super(checkBox);
  ActionListener editingListener = new ActionListener()
  {
    public void actionPerformed(ActionEvent e)
    {
      // editing is now complete - don't wait for focus to be lost
      // this will switch back to showing renderer
      //    and fire the event to tablemodellisteners
      stopCellEditing();
    }
  };
  btnVA.addActionListener(editingListener);
  btnUIT.addActionListener(editingListener);
  btnAAN.addActionListener(editingListener);
}

I think you were going down that route with your ItemListener, but you haven't called btnVA.addItemListener(this), etc.. But an ActionListener is normally better for radiobuttons anyway.

Answer 4

• not easy job to override all notifiers and properly for JRadioButtons in ButtonGroup as EditorComponent

  

• use JComboBox for XxxCellEditor instead of JRadioButtons in ButtonGroup

  

un_comment line 343th., see my point of view, JComboBox as XxxCellEditor

import javax.swing.*;
import javax.swing.table.*;
import java.util.Date;
import java.util.Vector;
import java.awt.*;
import java.awt.event.*;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import javax.swing.UIManager.LookAndFeelInfo;

public class TableTestPanel extends JPanel {

    private static final String[] COLUMN_NAMES = {"List ID", "Expiration Date", "Status", "Date Created"};
    private static final DateFormat DATE_FORMAT = new SimpleDateFormat("dd/MM/yyyy");
    private static final long serialVersionUID = 1L;

    private static class StatusPanel extends JPanel {

        private static final long serialVersionUID = 1L;
        private JRadioButton theSingleOption;
        private JRadioButton theMarriedOption;
        private JRadioButton theDivorcedOption;

        StatusPanel() {
            super(new GridLayout(3, 1));
            setOpaque(true);
            ButtonGroup buttonGroup = new ButtonGroup();
            theSingleOption = new JRadioButton("Single");
            theSingleOption.setOpaque(false);
            add(theSingleOption);
            buttonGroup.add(theSingleOption);
            theMarriedOption = new JRadioButton("Married");
            theMarriedOption.setOpaque(false);
            add(theMarriedOption);
            buttonGroup.add(theMarriedOption);
            theDivorcedOption = new JRadioButton("Divorced");
            theDivorcedOption.setOpaque(false);
            add(theDivorcedOption);
            buttonGroup.add(theDivorcedOption);
        }

        public Status getStatus() {
            if (theMarriedOption.isSelected()) {
                return Status.MARRIED;
            } else if (theDivorcedOption.isSelected()) {
                return Status.DIVORCED;
            } else {
                return Status.SINGLE;
            }
        }

        public void setStatus(Status status) {
            if (status == Status.MARRIED) {
                theMarriedOption.setSelected(true);
            } else if (status == Status.DIVORCED) {
                theDivorcedOption.setSelected(true);
            } else {
                theSingleOption.setSelected(true);
            }
        }
    }

    private static class Status {

        static final Status SINGLE = new Status("Single");
        static final Status MARRIED = new Status("Married");
        static final Status DIVORCED = new Status("Divorced");
        private final String myName; // for debug only

        private Status(String name) {
            myName = name;
        }

        @Override
        public String toString() {
            return myName;
        }
    }

    private static class TableEntry {

        private static int instanceNumber;
        private Long theId;
        private Date theExpirationDate;
        private Status theStatus;
        private Date theCreationDate;

        TableEntry() {
            instanceNumber++;
            theId = new Long(instanceNumber);
            theExpirationDate = new Date();
            theStatus = Status.SINGLE;
            theCreationDate = new Date();
        }

        TableEntry(Long anId, Date anExpirationDate, Status aStatus, Date aCreationDate) {
            theId = anId;
            theExpirationDate = anExpirationDate;
            theStatus = aStatus;
            theCreationDate = aCreationDate;
        }

        public Long getId() {
            return theId;
        }

        public Date getExpirationDate() {
            return theExpirationDate;
        }

        public Status getStatus() {
            return theStatus;
        }

        public Date getCreationDate() {
            return theCreationDate;
        }

        public void setId(Long anId) {
            theId = anId;
        }

        public void setExpirationDate(Date anExpirationDate) {
            theExpirationDate = anExpirationDate;
        }

        public void setStatus(Status aStatus) {
            theStatus = aStatus;
        }

        public void setCreationDate(Date aCreationDate) {
            theCreationDate = aCreationDate;
        }
    }

    private static class MyTableModel extends AbstractTableModel {

        private static final long serialVersionUID = 1L;
        private Vector<Object> theEntries;

        MyTableModel() {
            theEntries = new Vector<Object>();
        }

        @SuppressWarnings("unchecked")
        public void add(TableEntry anEntry) {
            int index = theEntries.size();
            theEntries.add(anEntry);
            fireTableRowsInserted(index, index);
        }

        public void remove(int aRowIndex) {
            if (aRowIndex < 0 || aRowIndex >= theEntries.size()) {
                return;
            }
            theEntries.removeElementAt(aRowIndex);
            fireTableRowsDeleted(aRowIndex, aRowIndex);

        }

        public int getRowCount() {
            return theEntries.size();
        }

        @Override
        public String getColumnName(int column) {
            return COLUMN_NAMES[column];
        }

        @Override
        public Class<?> getColumnClass(int columnIndex) {
            switch (columnIndex) {
                case 0:
                    return Long.class;
                case 1:
                    return Date.class;
                case 2:
                    return Status.class;
                case 3:
                    return Date.class;
            }
            return Object.class;
        }

        @Override
        public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
            TableEntry entry = (TableEntry) theEntries.elementAt(rowIndex);
            switch (columnIndex) {
                case 0:
                    try {
                        entry.setId(new Long(Long.parseLong(aValue.toString())));
                    } catch (NumberFormatException nfe) {
                        return;
                    }
                    break;
                case 1:
                    entry.setExpirationDate((Date) aValue);
                    break;
                case 2:
                    entry.setStatus((Status) aValue);
                    break;
                case 3:
                    entry.setCreationDate((Date) aValue);
                    break;
                default:
                    return;
            }
            fireTableCellUpdated(rowIndex, columnIndex);
        }

        @Override
        public boolean isCellEditable(int rowIndex, int columnIndex) {
            return true;
        }

        @Override
        public int getColumnCount() {
            return 4;
        }

        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            TableEntry entry = (TableEntry) theEntries.elementAt(rowIndex);
            switch (columnIndex) {
                case 0:
                    return entry.getId();
                case 1:
                    return entry.getExpirationDate();
                case 2:
                    return entry.getStatus();
                case 3:
                    return entry.getCreationDate();
            }
            return null;
        }
    }

    private static class DateRenderer extends DefaultTableCellRenderer {

        private static final long serialVersionUID = 1L;

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
            if (!(value instanceof Date)) {
                return this;
            }
            setText(DATE_FORMAT.format((Date) value));
            return this;
        }
    }

    private static class DateEditor extends AbstractCellEditor implements TableCellEditor {

        private static final long serialVersionUID = 1L;
        private JSpinner theSpinner;
        private Object value;

        DateEditor() {
            theSpinner = new JSpinner(new SpinnerDateModel());
            theSpinner.setOpaque(true);
            theSpinner.setEditor(new JSpinner.DateEditor(theSpinner, "dd/MM/yyyy"));
        }

        @Override
        public Object getCellEditorValue() {
            return theSpinner.getValue();
        }

        @Override
        public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
            theSpinner.setValue(value);
            if (isSelected) {
                theSpinner.setBackground(table.getSelectionBackground());
            } else {
                theSpinner.setBackground(table.getBackground());
            }
            return theSpinner;
        }
    }

    private static class StatusEditor extends AbstractCellEditor implements TableCellEditor {

        private static final long serialVersionUID = 1L;
        private StatusPanel theStatusPanel;

        StatusEditor() {
            theStatusPanel = new StatusPanel();
        }

        @Override
        public Object getCellEditorValue() {
            return theStatusPanel.getStatus();
        }

        @Override
        public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
            theStatusPanel.setStatus((Status) value);
            if (isSelected) {
                theStatusPanel.setBackground(table.getSelectionBackground());
            } else {
                theStatusPanel.setBackground(table.getBackground());
            }
            return theStatusPanel;
        }
    }

    private static class StatusRenderer extends StatusPanel implements TableCellRenderer {

        private static final long serialVersionUID = 1L;

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            setStatus((Status) value);
            if (isSelected) {
                setBackground(table.getSelectionBackground());
            } else {
                setBackground(table.getBackground());
            }
            return this;
        }
    }
    private MyTableModel theTableModel;
    private JTable theTable;

    public TableTestPanel() {
        super(new BorderLayout(0, 5));
        setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
        theTableModel = new MyTableModel();
        theTable = new JTable(theTableModel);
        theTable.setDefaultEditor(Date.class, new DateEditor());
        theTable.setDefaultRenderer(Date.class, new DateRenderer());
        theTable.setDefaultEditor(Status.class, new StatusEditor());
        theTable.setDefaultRenderer(Status.class, new StatusRenderer());
// comment out the two preceding lines and uncomment the following one if you want a more standard editor
// theTable.setDefaultEditor(Status.class, new DefaultCellEditor(new JComboBox(new Status[]{Status.SINGLE, Status.MARRIED, Status.DIVORCED})));
        add(new JScrollPane(theTable), BorderLayout.CENTER);
        JToolBar toolBar = new JToolBar();
        toolBar.setFloatable(false);
        toolBar.add(new AbstractAction("Add new") {

            private static final long serialVersionUID = 1L;

            @Override
            public void actionPerformed(ActionEvent e) {
                theTableModel.add(new TableEntry());
                packTable();
            }
        });
        toolBar.add(new AbstractAction("Remove") {

            private static final long serialVersionUID = 1L;

            @Override
            public void actionPerformed(ActionEvent e) {
                theTableModel.remove(theTable.getSelectedRow());
            }
        });
        add(toolBar, BorderLayout.NORTH);
    }

    private void packTable() {
        TableColumnModel columnModel = theTable.getColumnModel();
        int columnCount = theTable.getColumnCount();
        int rowCount = theTable.getRowCount();
        int[][] preferredHeights = new int[columnCount][rowCount];
        TableCellRenderer renderer;
        Component comp;
        for (int col = 0; col < columnCount; col++) {
            renderer = columnModel.getColumn(col).getCellRenderer();
            if (renderer == null) {
                renderer = theTable.getDefaultRenderer(theTableModel.getColumnClass(col));
            }
            for (int row = 0; row < rowCount; row++) {
                comp = renderer.getTableCellRendererComponent(theTable, theTableModel.getValueAt(row, col), false, false, row, col);
                preferredHeights[col][row] = (int) comp.getPreferredSize().getHeight();
            }
        }
        for (int row = 0; row < rowCount; row++) {
            int pref = 0;
            for (int col = 0; col < columnCount; col++) {
                pref = Math.max(pref, preferredHeights[col][row]);
            }
            theTable.setRowHeight(row, pref);
        }
    }

    public static void main(String[] args) {
        try {
            // UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
            for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
                if (info.getName().equals("Nimbus")) {
                    UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        final JFrame frame = new JFrame("TestRadioButtonRenderer");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setContentPane(new TableTestPanel());
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                frame.setSize(400, 300);
                frame.setVisible(true);
            }
        });
    }
}