JComboBox cell editor for JTable

[Samba Medavarapu]

Hi,

I am trying to create a JCombobox cell Editor for JTable by following the instructions given in the below url,

How to create JComboBox cell editor for JTable
https://www.codejava.net/java-se/swing/how-to-create-jcombobox-cell-editor-for-jtable

Getting the look & feel as expected. Able to change the menu selection. But the change in menu selection not persisting with different row selection. I mean, when I try to select the different row, unable to persist the menu selection change.

Ex: I've two rows, row1 & row2. Column 5 is named as 'Status' with different status values like 'Review', 'Complete', 'Progress', 'Inactive' ..etc. Initially row-1 is having status as 'Review' and row-2 is having status as 'Complete'. I tried to change the status of row-1 to 'Progress'. Till now, it's ok. Now I am selecting the row-2, the status of row-1 is changed to 'Review' which is it's initial value.

I tried to debug the code. Found that, setValueAT() method of AcmsFilesTableModel extends AbstractTableModel is not getting the changed selected value.
public void setValueAt(Object value, int row, int column) {}

Do we need to do any thing to persist the selected value in combobox? Please correct me if Iam doing something wrong.
Please find the attached table model & cell editor implementation classes.

[Brian Cole]

I don't know where the code on codejava.net comes from, but IMHO their CountryCellEditor is not quality code.

Here's their implementation:

import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
 
import javax.swing.AbstractCellEditor;
import javax.swing.JComboBox;
import javax.swing.JTable;
import javax.swing.table.TableCellEditor;
 
/**
 * A custom editor for cells in the Country column.
 * @author www.codejava.net
 *
 */
public class CountryCellEditor extends AbstractCellEditor
        implements TableCellEditor, ActionListener {
 
    private Country country;
    private List<Country> listCountry;
     
    public CountryCellEditor(List<Country> listCountry) {
        this.listCountry = listCountry;
    }
     
    @Override
    public Object getCellEditorValue() {
        return this.country;
    }
 
    @Override
    public Component getTableCellEditorComponent(JTable table, Object value,
            boolean isSelected, int row, int column) {
        if (value instanceof Country) {
            this.country = (Country) value;
        }
         
        JComboBox<Country> comboCountry = new JComboBox<Country>();
         
        for (Country aCountry : listCountry) {
            comboCountry.addItem(aCountry);
        }
         
        comboCountry.setSelectedItem(country);
        comboCountry.addActionListener(this);
         
        if (isSelected) {
            comboCountry.setBackground(table.getSelectionBackground());
        } else {
            comboCountry.setBackground(table.getSelectionForeground());
        }
         
        return comboCountry;
    }
 
    @Override
    public void actionPerformed(ActionEvent event) {
        JComboBox<Country> comboCountry = (JComboBox<Country>) event.getSource();
        this.country = (Country) comboCountry.getSelectedItem();
    }
 
}

Lines 38-42 create a new instance of JComboBox and populate its entries, which is slow. The idea is that this method should be fast. Speed is crucial in a Cell Renderer, and definitely not as crucial in a Cell Editor, but this method is called when the user clicks a cell for editing. The ComboBox should be already set up (as much as possible) before this method is called, so that the user does not perceive a delay. This code could be changed to instantiate the ComboBox, and populate its entries, in the constructor.

Line 44 is appropriate. If the code were changed to instantiate the ComboBox in the constructor, this line would still appear here in the getTableCellEditorComponent() method.

Line 45 is setting an ActionListener on the ComboBox. This is appropriate, so that when the user hits the enter key the Cell Editor will finish editing, rather than remaining in the cell and requiring the user to hit the escape key or click somewhere to actually complete the edit. But there are problems:

Presuming that we have improved the code by only instantiating the ComboBox only once, then the action listener needs to be added only once, outside of this method.

Having the CountryCellEditor actually implement the ActionListener interface, and adding this as the listener, is an old coding style. Modern code would probably structure this differently. But it could work with this structure, except...

But what it's actually doing in the actionPerformed() method (lines 58-59) isn't quite right. It is taking the selected value and storing it in the country instance variable, so it can later be returned by the getCellEditorValue() method, which I guess is fine. [If the ComboBox were an instance variable, then wouldn't need to keep country as a separate variable but could simply have getCellEditorValue() return cb.getSelectedItem()—no ActionListener needed to get getCellEditorValue() to work correctly.] But the ActionListener is not doing anything else. It's not notifying the table that the edit has completed, and it should.

Lines 47-51 are misguided, I think. This would be appropriate for a Cell Renderer, not so much for a Cell Editor. It's possible that something like this could work in a Cell Editor, but it would take some experimentation. As the very least, I think line 50 is setting the wrong color. It would be more appropriate to setBackground(table.getBackground()). That is, to match the ComboBox's background with the table's (regular non-selected) background, rather than to the table's (selected) foreground. But I think it would probably be best to skip these lines entirely and let the ComboBox have its default background.

They declare the CountryCellEditor class itself (lines 16-17) is like this:

public class CountryCellEditor extends AbstractCellEditor implements TableCellEditor

I can understand why they want to extend AbstractCellEditor because that way they inherit a bunch of event-handling methods and don't have to mess with them. But I think I would prefer to do it like this instead:

public class MyCellEditor extends JComboBox implements TableCellEditor

This way, the Cell Editor is a JComboBox, which I kind of like better, but the trade-off is that we then need to implement those event-handling methods (which isn't too bad). But the other way could work too. This is simply my preference.

Anyway, my code might look something like this:

package com.bitguru.swing.table;

import java.awt.Component;
import java.util.EventObject;

import javax.swing.JComboBox;
import javax.swing.JTable;
import javax.swing.JTree;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.EventListenerList;
import javax.swing.table.TableCellEditor;
import javax.swing.tree.TreeCellEditor;

/**
 * table/tree cell editor that inherits from JComboBox
 * 
 * @author Brian Cole
 *
 */
public class ComboBoxCellEditor extends JComboBox<Object> implements TableCellEditor, TreeCellEditor {
	private static final long serialVersionUID = 1L;

	protected EventListenerList listeners = new EventListenerList();
	protected ChangeEvent event = new ChangeEvent(this);

	/**
	 * constructor - pass in a fixed array of values that should be
	 * presented in the JComboBox when a cell is being edited <p>
	 * 
	 * Make sure that the type(s) of the array elements match the
	 * type(s) that are accepted by your TableModel's setValueAt()
	 * method and returned by your TableModel's getValueAt() method.
	 * 
	 * @param valuesToPresent array of values (see text above) 
	 */
	public ComboBoxCellEditor(Object[] valuesToPresent) {
		super(valuesToPresent);
		addActionListener( e -> stopCellEditing() );
	}

	@Override
	public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected,
			                                     int row, int column) {
		setSelectedItem(value); // null is ok
		return this;
	}

	@Override
	public Component getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected,
			                                    boolean expanded, boolean leaf, int row) {
		setSelectedItem(value); // null is ok
		return this;
	}

	@Override
	public Object getCellEditorValue() {
		return getSelectedItem();
	}

	@Override
	public boolean isCellEditable(EventObject eo) {
		return true;
	}

	@Override
	public boolean shouldSelectCell(EventObject eo) {
		return true; // sometimes false is nicer
	}

	@Override
	public void cancelCellEditing() {
		fireEditingCanceled();
	}

	@Override
	public boolean stopCellEditing() {
		fireEditingStopped();
		return true;
	}

	@Override
	public void addCellEditorListener(CellEditorListener cel) {
		listeners.add(CellEditorListener.class, cel);
	}

	@Override
	public void removeCellEditorListener(CellEditorListener cel) {
		listeners.remove(CellEditorListener.class, cel);
	}

	protected void fireEditingCanceled() {
		CellEditorListener[] aListeners = listeners.getListeners(CellEditorListener.class);
		// can't use for-each loop because we need to traverse in order from last to first
		for (int j = aListeners.length - 1; j >= 0; j -= 1) {
			aListeners[j].editingCanceled(event);
		}
	}

	protected void fireEditingStopped() {
		CellEditorListener[] aListeners = listeners.getListeners(CellEditorListener.class);
		// traverse in order from last to first
		for (int j = aListeners.length - 1; j >= 0; j -= 1) {
			aListeners[j].editingStopped(event);
		}
	}

}

[Brian Cole]

Here's a quick driver for the ComboBoxCellEditor in the posting above, which I used so I could test it (minimally) before posting.

Well, it's not so quick, because my TableModel takes 100 lines of code. But the rest of it is fairly quick. The three rightmost column of the table each have their own custom ComboBoxCellEditor, set in lines 165-167.

package com.bitguru.swing.table;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.util.ArrayList;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.table.AbstractTableModel;

/**
 * GUI with JTable to demonstrate ComboBoxCellEditor. Also a JTree, for kicks.
 * 
 * @author Brian Cole
 */
public class TableDriver {

	public static enum Fader { Front, Center, Rear }
	public static enum Balance { Left, Center, Right }
	public static enum Size { Tiny, Small, Medium, Large }

	public static class TestRow {
		String name;
		Fader f;
		Balance b;
		Size s;
		public TestRow(String name, Fader f, Balance b, Size s) {
			this.name=name; this.f=f; this.b=b; this.s=s;
		}
	}

	public static class TestModel extends AbstractTableModel {
		private static final long serialVersionUID = 1L;

		private ArrayList<TestRow> rows = new ArrayList<>();

		public void addRow(TestRow tr) {
			int indexForNewRow = rows.size();
			rows.add(tr);
			fireTableRowsInserted(indexForNewRow, indexForNewRow);
		}

		public void addRow(String name, Fader f, Balance b, Size s) {
			addRow(new TestRow(name, f, b, s));
		}

		@Override
		public int getRowCount() {
			return rows.size();
		}

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

		@Override
		public String getColumnName(int column) {
			switch (column) {
			case 0:
				return "Record#";
			case 1:
				return "Name";
			case 2:
				return "Fader";
			case 3:
				return "Balance";
			case 4:
				return "Size";
			default:
				return "?";
			}
		}

		@Override
		public Class<?> getColumnClass(int column) {
			switch (column) {
			case 0:
				return Integer.class;
			case 1:
				return String.class;
			case 2:
				return Fader.class;
			case 3:
				return Balance.class;
			case 4:
				return Size.class;
			default:
				return Object.class;
			}
		}

		@Override
		public boolean isCellEditable(int row, int column) {
			return (0 < column);
		}

		@Override
		public Object getValueAt(int row, int column) {
			if (rows.size() <= row) return "?";
			TestRow tr = rows.get(row);
			switch (column) {
			case 0:
				return Integer.valueOf(row);
			case 1:
				return tr.name;
			case 2:
				return tr.f;
			case 3:
				return tr.b;
			case 4:
				return tr.s;
			default:
				return "?";
			}
		}

		@Override
		public void setValueAt(Object val, int row, int column) {
			if (rows.size() <= row) return;
			TestRow tr = rows.get(row);
			switch (column) {
			case 1:
				tr.name = (String)val;
				break;
			case 2:
				tr.f = (Fader)val;
				break;
			case 3:
				tr.b = (Balance)val;
				break;
			case 4:
				tr.s = (Size)val;
				break;
			}
			fireTableCellUpdated(row, column);
		}

	}

	public static void main(String[] args) throws Exception {
		// UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
		SwingUtilities.invokeLater(() -> new TableDriver().startup());
	}

	public void startup() {
		TestModel tm = new TestModel();
		tm.addRow("Fred", Fader.Front, Balance.Center, Size.Large);
		tm.addRow("Wilma", Fader.Center, Balance.Right, Size.Medium);
		
		JButton button = new JButton("Add Row");
		button.addActionListener( e -> tm.addRow("Dino", Fader.Rear, Balance.Left, Size.Tiny) );
		JPanel flowPanel = new JPanel(new FlowLayout(FlowLayout.LEADING));
		flowPanel.add(button);

		JTable tab = new JTable(tm);
		tab.setAutoCreateRowSorter(true);
		tab.setDefaultEditor(Fader.class, new ComboBoxCellEditor(Fader.class.getEnumConstants()));
		tab.setDefaultEditor(Balance.class, new ComboBoxCellEditor(Balance.class.getEnumConstants()));
		tab.setDefaultEditor(Size.class, new ComboBoxCellEditor(Size.class.getEnumConstants()));
		JScrollPane spTable = new JScrollPane(tab);
		
		JTree tree = new JTree(); // creates colors/sports/food nodes by default
		tree.setEditable(true);
		tree.setCellEditor(new ComboBoxCellEditor(new String[] {"foo", "bar", "baz"}));
		JScrollPane spTree = new JScrollPane(tree);
		spTree.setPreferredSize(new Dimension(160, 160));

		JFrame f = new JFrame(getClass().getName());
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.getContentPane().add(flowPanel, BorderLayout.NORTH);
		f.getContentPane().add(spTable, BorderLayout.CENTER);
		f.getContentPane().add(spTree, BorderLayout.EAST);

		f.setSize(600, 240);
		f.setVisible(true);
	}

}

[Rob Camick]

JTable already supports a combo box as an editor.

Read the section from the Swing tutorial on Using a Combo Box as an Editor.

[Kc Atum]

yes rob it does, but if you run the example, TableRender.java that they have, you'll see that when you click on the cell, you see a nice combo box and this works. However if you are not actively editing the cell, it appears as a normal cell.  I believe it is desired that the cell looks like a combo box that is closed when it is not being edited AND appears as a combo while it is being edited.

[Carey Brown]

In the example that Rob linked to...

TableColumn sportColumn = table.getColumnModel().getColumn(2);
...
JComboBox comboBox = new JComboBox();
comboBox.addItem("Snowboarding");
comboBox.addItem("Rowing");
comboBox.addItem("Chasing toddlers");
comboBox.addItem("Speed reading");
comboBox.addItem("Teaching high school");
comboBox.addItem("None");
sportColumn.setCellEditor(new DefaultCellEditor(comboBox));

CellEditor is being overridden. If you want to change the default display that is used once the CellEditor goes away you have to also override setCellRenderer().