package org.openslx.dozmod.gui.control.table;
import java.awt.Component;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.swing.Icon;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.RowSorter;
import javax.swing.SortOrder;
import javax.swing.event.RowSorterEvent;
import javax.swing.event.RowSorterListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableRowSorter;
import org.openslx.dozmod.gui.helper.TableColumnAdjuster;
@SuppressWarnings("serial")
public abstract class ListTable<T> extends JTable {
private final ListModel<T> model;
private final TableRowSorter<ListModel<T>> sorter;
private List<RowSorter.SortKey> sortKeys = new ArrayList<>();
private final TableColumnAdjuster adjuster;
private final Comparator<T> itemComparator;
public ListTable(ListTableColumn... columns) {
this(null, columns);
}
public ListTable(Comparator<T> itemComparator, ListTableColumn... columns) {
super();
for (int i = 0; i < columns.length; i++) {
TableColumn tc = new TableColumn(i);
tc.setHeaderValue(columns[i].colName);
addColumn(tc);
}
this.model = new ListModel<T>(this, columns);
this.sorter = new TableRowSorter<ListModel<T>>(model);
for (int i = 0; i < columns.length; ++i) {
if (columns[i].sortComparator != null) {
sorter.setComparator(i, columns[i].sortComparator);
}
}
this.adjuster = new TableColumnAdjuster(this, 5);
this.adjuster.setOnlyAdjustLarger(true);
this.itemComparator = itemComparator;
this.setModel(model);
this.setRowSorter(sorter);
this.setShowGrid(false);
this.setCellSelectionEnabled(false);
this.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
this.getTableHeader().setReorderingAllowed(false);
ListTableRenderer listTableRenderer = new ListTableRenderer();
this.setDefaultRenderer(Object.class, listTableRenderer);
this.setDefaultRenderer(Integer.class, listTableRenderer);
this.setDefaultRenderer(Long.class, listTableRenderer);
this.setDefaultRenderer(Boolean.class, getDefaultRenderer(Boolean.class));
this.setDefaultRenderer(Icon.class, new IconRenderer());
this.setDefaultEditor(Boolean.class, getDefaultEditor(Boolean.class));
this.setRowSelectionAllowed(true);
this.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
sorter.addRowSorterListener(new RowSorterListener() {
@Override
public void sorterChanged(RowSorterEvent e) {
adjuster.adjustColumns();
}
});
}
protected abstract Object getValueAtInternal(T item, ListTableColumn column);
public T getModelRow(int rowIndex) {
if (rowIndex < 0 || rowIndex >= model.getRowCount())
throw new IndexOutOfBoundsException();
return model.data.get(rowIndex);
}
public T getViewRow(int rowIndex) {
return getModelRow(convertRowIndexToModel(rowIndex));
}
public List<T> getSelectedItems() {
int[] rows = getSelectedRows();
if (rows.length == 0)
return null;
List<T> itemList = new ArrayList<T>();
for (int i : rows) {
itemList.add(getViewRow(i));
}
return itemList;
}
public T getSelectedItem() {
int rowIndex = getSelectedRow();
if (rowIndex == -1)
return null;
return getViewRow(rowIndex);
}
public List<T> getData() {
if (model.data == null)
return null;
return Collections.unmodifiableList(model.data);
}
public boolean setSelectedItem(T item) {
int selectionIndex = -1;
for (int i = 0; i < model.data.size(); ++i) {
T rowItem = model.data.get(i);
if (itemComparator == null) {
if (rowItem.equals(item)) {
selectionIndex = i;
break;
}
} else {
if (itemComparator.compare(item, rowItem) == 0) {
selectionIndex = i;
break;
}
}
}
if (selectionIndex != -1) {
selectionIndex = convertRowIndexToView(selectionIndex);
}
if (selectionIndex == -1) {
getSelectionModel().clearSelection();
return false;
}
setRowSelectionInterval(selectionIndex, selectionIndex);
return true;
}
public void setData(List<T> data, boolean sort) {
T oldSelection = getSelectedItem();
model.setData(data);
adjuster.adjustColumns();
// handle sorting
if (!sort)
return;
if (sortKeys.isEmpty()) {
// sort by the first column by default
sortKeys.add(new RowSorter.SortKey(0, SortOrder.ASCENDING));
sorter.setSortKeys(sortKeys);
}
// always sort
sorter.sort();
if (oldSelection != null) {
setSelectedItem(oldSelection);
}
}
/**
* Show or hide the given column of the table
*
* @param column
* @param visible
*/
public void setColumnVisible(ListTableColumn column, boolean visible) {
model.setVisible(column, visible);
}
@Override
public TableRowSorter<ListModel<T>> getRowSorter() {
return sorter;
}
@Override
public ListModel<T> getModel() {
return model;
}
/**
* Callback when a cell is edited.
*/
public void setValueAt(Object newValue, T row, ListTableColumn column) {
// Nothing by default
}
/**
* Called when rendering a column is being prepared. This is a good time to
* change the color or font for the given cell.
*
* @param component The component representing the cell being rendered
* @param row item of the row being rendered
* @param listTableColumn column (model-based) of the cell being rendered
* @param isSelected whether the row is currently selected
* @return
*/
public Component prepareRenderHook(Component component, T row, ListTableColumn listTableColumn,
boolean isSelected) {
// Nothing by default
return component;
}
/**
* Called when the value of the given column needs to be transformed into a
* displayable item. By default this is the identity function, returning the
* value as-is.
*
* @param value Value to render
* @param column Column index (model-based) being rendered
* @return Rendered version of value. This should match the column class
*/
public Object modelValueToDisplayFormat(Object value, ListTableColumn column) {
return value;
}
@Override
public final Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
Component c = super.prepareRenderer(renderer, row, column);
T item = getViewRow(row);
if (c != null && item != null) {
c = prepareRenderHook(c, item, model.getColumn(convertColumnIndexToModel(column)), isRowSelected(row));
}
return c;
}
/**
* Model for our table
*/
public static class ListModel<T> extends AbstractTableModel {
private final ColumnState[] columns;
private ArrayList<T> data = null;
private final ListTable<T> table;
public ListModel(ListTable<T> table, ListTableColumn... columns) {
this.table = table;
this.columns = new ColumnState[columns.length];
for (int i = 0; i < columns.length; ++i) {
this.columns[i] = new ColumnState(columns[i]);
}
}
public void setData(List<T> list) {
this.data = new ArrayList<>(list);
fireTableDataChanged();
}
public ListTableColumn getColumn(int modelColumnIndex) {
return columns[modelColumnIndex].column;
}
public void setVisible(ListTableColumn column, boolean visible) {
TableColumnModel cm = table.getColumnModel();
for (int i = 0; i < columns.length; ++i) {
ColumnState c = columns[i];
if (c.column != column)
continue;
if ((c.hiddenColumn == null && visible) || (c.hiddenColumn != null && !visible))
return;
if (visible) {
cm.addColumn(c.hiddenColumn);
cm.moveColumn(cm.getColumnCount() - 1, c.oldIndex);
c.hiddenColumn = null;
} else {
c.oldIndex = table.convertColumnIndexToView(i);
c.hiddenColumn = cm.getColumn(c.oldIndex);
cm.removeColumn(c.hiddenColumn);
}
break;
}
}
@Override
public boolean isCellEditable(int row, int col) {
return columns[col].column.isEditable;
}
@Override
public void setValueAt(Object aValue, int row, int col) {
if (isCellEditable(row, col)) {
T item = table.getModelRow(row);
if (item == null)
return;
table.setValueAt(aValue, item, columns[col].column);
fireTableCellUpdated(row, col);
}
}
@Override
public int getRowCount() {
return data == null ? 0 : data.size();
}
@Override
public int getColumnCount() {
return columns.length;
}
@Override
public String getColumnName(int col) {
return columns[col].column.colName;
}
@Override
public Class<?> getColumnClass(int col) {
return columns[col].column.colClass;
}
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
T item = table.getModelRow(rowIndex);
if (item == null)
return null;
return table.getValueAtInternal(item, columns[columnIndex].column);
}
public T getModelRow(int rowIndex) {
return table.getModelRow(rowIndex);
}
private static class ColumnState {
int oldIndex;
final ListTableColumn column;
TableColumn hiddenColumn = null;
ColumnState(ListTableColumn column) {
this.column = column;
}
}
}
/**
* This renderer simply removes the default dotted border when
* a cell is selected
*/
private class ListTableRenderer extends DefaultTableCellRenderer {
public ListTableRenderer() {
putClientProperty("html.disable", Boolean.TRUE);
putClientProperty("html", null);
}
@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
boolean hasFocus, int row, int column) {
if (value != null) {
value = modelValueToDisplayFormat(value, model.getColumn(convertColumnIndexToModel(column)));
}
super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
setBorder(null);
return this;
}
}
private class IconRenderer extends DefaultTableCellRenderer {
@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
boolean hasFocus, int row, int column) {
if (value != null) {
value = modelValueToDisplayFormat(value, model.getColumn(convertColumnIndexToModel(column)));
}
setIcon((Icon)value);
return this;
}
}
public static class ListTableColumn {
public final boolean isEditable;
public final Class<?> colClass;
public final String colName;
public final Comparator<?> sortComparator;
public ListTableColumn(String colName) {
this(colName, String.class, null);
}
public ListTableColumn(String colName, Class<?> colClass) {
this(colName, colClass, null);
}
public ListTableColumn(String colName, Class<?> colClass, Comparator<?> sortComparator) {
this(colName, colClass, sortComparator, false);
}
public ListTableColumn(String colName, Class<?> colClass, Comparator<?> sortComparator, boolean isEditable) {
this.isEditable = isEditable;
this.colName = colName;
this.colClass = colClass;
this.sortComparator = sortComparator;
}
public ListTableColumn(String colName, Comparator<?> sortComparator) {
this(colName, String.class, sortComparator);
}
}
}
