source: domaineditor/src/main/java/geniusweb/domaineditor/panels/BidEditorPanel.java@ 49

package geniusweb.domaineditor.panels;

import java.awt.BorderLayout;
import java.awt.Component;
import java.util.EventObject;
import java.util.LinkedList;
import java.util.List;

import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.event.CellEditorListener;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableModel;

import geniusweb.domaineditor.model.BidModel;
import tudelft.utilities.mvc.model.MapModel;
import tudelft.utilities.mvc.model.Model;
import tudelft.utilities.mvc.model.SelectionModel;
import tudelft.utilities.mvc.model.StringModel;
import tudelft.utilities.mvc.panels.PanelFactory;

/**
 * Panel ot edit Bids. This is not a standard MapModelPanel because the issues
 * and values are not directly editable; rather the user can only pick existing
 * values.
 *
 */
public class BidEditorPanel extends JPanel {

        public BidEditorPanel(BidModel model) {
                setLayout(new BorderLayout());
                MyTableModel jtablemodel = new MyTableModel(model);
                JTable table = new JTable(jtablemodel);
                table.setDefaultRenderer(Object.class, new TableCellRenderer() {

                        @Override
                        public Component getTableCellRendererComponent(JTable table,
                                        Object value, boolean isSelected, boolean hasFocus, int row,
                                        int column) {
                                return (Component) value;
                        }
                });
                table.setDefaultEditor(Object.class, new TableCellEditor() {
                        private List<CellEditorListener> listeners = new LinkedList<>();

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

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

                        @Override
                        public boolean shouldSelectCell(EventObject anEvent) {
                                return true;
                        }

                        @Override
                        public boolean stopCellEditing() {
                                for (CellEditorListener l : listeners)
                                        l.editingStopped(null);
                                return true;
                        }

                        @Override
                        public void cancelCellEditing() {
                                for (CellEditorListener l : listeners)
                                        l.editingStopped(null);
                        }

                        @Override
                        public void addCellEditorListener(CellEditorListener l) {
                                listeners.add(l);
                        }

                        @Override
                        public void removeCellEditorListener(CellEditorListener l) {
                                listeners.remove(l);
                        }

                        @Override
                        public Component getTableCellEditorComponent(JTable table,
                                        Object value, boolean isSelected, int row, int column) {
                                // only column 2 is editable so this must be a combo selector
                                return (Component) value;
                        }

                });
                table.setRowSelectionAllowed(true);
                table.setCellSelectionEnabled(false);
                table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
                table.putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);
                add(new JScrollPane(table), BorderLayout.CENTER);
        }
}

/**
 * The list is actually shown in a {@link JTable}. This maps our TableModel into
 * something JTable can digest.
 *
 * @param <K> the key type
 * @param <V> the value type
 */
class MyTableModel<K extends Model, V extends Model> implements TableModel {
        private final PanelFactory panelfactory;

        private final MapModel<StringModel, SelectionModel> issuevalues;
        private List<TableModelListener> listeners = new LinkedList<>();

        public MyTableModel(MapModel<StringModel, SelectionModel> issuevalues,
                        PanelFactory panelfactory) {
                this.panelfactory = panelfactory;
                this.issuevalues = issuevalues;
                issuevalues.addListener((data) -> notifyListeners());
        }

        public MyTableModel(MapModel<StringModel, SelectionModel> issuevalues) {
                this(issuevalues, new PanelFactory());
        }

        @Override
        public int getRowCount() {
                return issuevalues.getKeys().getSize();
        }

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

        @Override
        public String getColumnName(int columnIndex) {
                return columnIndex == 0 ? "issue" : "value";
        }

        @Override
        public Class<?> getColumnClass(int columnIndex) {
                return Component.class;
        }

        @Override
        public boolean isCellEditable(int rowIndex, int columnIndex) {
                return columnIndex == 1; // only values can be edited
        }

        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
                StringModel key = issuevalues.getKeys().get(rowIndex);
                return panelfactory
                                .create(columnIndex == 0 ? key : issuevalues.getValue(key));
        }

        @Override
        public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        }

        @Override
        public void addTableModelListener(TableModelListener l) {
                listeners.add(l);
        }

        @Override
        public void removeTableModelListener(TableModelListener l) {
                listeners.remove(l);

        }

        private void notifyListeners() {
                for (TableModelListener l : listeners) {
                        l.tableChanged(new TableModelEvent(this));
                }
        }

}