diff -r 000000000000 -r 0359f2c3b3ba java/JFTable/src/cz/frantovo/gui/tabulky/TableSorterModel.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/java/JFTable/src/cz/frantovo/gui/tabulky/TableSorterModel.java Sat Feb 28 16:51:54 2009 +0100
@@ -0,0 +1,533 @@
+package cz.frantovo.gui.tabulky;
+
+
+import java.awt.Component;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import javax.swing.Icon;
+import javax.swing.ImageIcon;
+import javax.swing.JLabel;
+import javax.swing.JTable;
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.JTableHeader;
+import javax.swing.table.TableCellRenderer;
+import javax.swing.table.TableColumnModel;
+import javax.swing.table.TableModel;
+
+/**
+ * Tato t��da p�id�v� tabulce funk�nost �azen� podle v�ce sloupc�. Skute�n�
+ * model obsahuj�c� data sta�� obalit touto t��dou + je pot�eba nastavit:
+ * tableSorterModel.setTableHeader(table.getTableHeader());
+ *
+ * Jednodu��� ale je pou��vat t��du cz.ebanka.util.table.JTable, kter� v�echno
+ * �e�� za v�s.
+ *
+ * Tento TableSorterModel je zalo�en na p�vodn�m TableSorter od autor�: Philip
+ * Milne, Brendon McLean, Dan van Enckevort a Parwinder Sekhon.
+ *
+ * J� jsem p�idal hez�� grafick� �ipky v z�hlav� tabulky
+ *
+ *
+ * @author František Kučera
+ */
+
+public class TableSorterModel extends AbstractTableModel {
+
+ private static final long serialVersionUID = 7902301859145867387L;
+
+ protected TableModel tableModel;
+
+ public static final int DESCENDING = -1;
+
+ public static final int NOT_SORTED = 0;
+
+ public static final int ASCENDING = 1;
+
+ private static Directive EMPTY_DIRECTIVE = new Directive( -1,
+ NOT_SORTED);
+
+ public static final Comparator COMPARABLE_COMAPRATOR = new Comparator() {
+
+ public int compare (Object o1,
+ Object o2)
+ {
+ return ((Comparable) o1).compareTo(o2);
+ }
+ };
+
+ public static final Comparator LEXICAL_COMPARATOR = new Comparator() {
+
+ public int compare (Object o1,
+ Object o2)
+ {
+ return o1.toString().compareTo(o2.toString());
+ }
+ };
+
+ private Row[] viewToModel;
+
+ private int[] modelToView;
+
+ private JTableHeader tableHeader;
+
+ private MouseListener mouseListener;
+
+ private TableModelListener tableModelListener;
+
+ private Map columnComparators = new HashMap();
+
+ private List sortingColumns = new ArrayList();
+
+ private ImageIcon headerIconDown = new ImageIcon(getClass().getResource("/cz/frantovo/gui/tabulky/dolu.png"));
+
+ private ImageIcon headerIconUp = new ImageIcon(getClass().getResource("/cz/frantovo/gui/tabulky/nahoru.png"));
+
+ public TableSorterModel ()
+ {
+ this.mouseListener = new MouseHandler();
+ this.tableModelListener = new TableModelHandler();
+ }
+
+ public TableSorterModel (TableModel tableModel)
+ {
+ this();
+ setTableModel(tableModel);
+ }
+
+ public TableSorterModel (TableModel tableModel,
+ JTableHeader tableHeader)
+ {
+ this();
+ setTableHeader(tableHeader);
+ setTableModel(tableModel);
+ }
+
+ private void clearSortingState ()
+ {
+ viewToModel = null;
+ modelToView = null;
+ }
+
+ public TableModel getTableModel ()
+ {
+ return tableModel;
+ }
+
+ public void setTableModel (TableModel tableModel)
+ {
+ if (this.tableModel != null) {
+ this.tableModel.removeTableModelListener(tableModelListener);
+ }
+
+ this.tableModel = tableModel;
+ if (this.tableModel != null) {
+ this.tableModel.addTableModelListener(tableModelListener);
+ }
+
+ clearSortingState();
+ fireTableStructureChanged();
+ }
+
+ public JTableHeader getTableHeader ()
+ {
+ return tableHeader;
+ }
+
+ public void setTableHeader (JTableHeader tableHeader)
+ {
+ if (this.tableHeader != null) {
+ this.tableHeader.removeMouseListener(mouseListener);
+ TableCellRenderer defaultRenderer = this.tableHeader.getDefaultRenderer();
+ if (defaultRenderer instanceof SortableHeaderRenderer) {
+ this.tableHeader.setDefaultRenderer(((SortableHeaderRenderer) defaultRenderer).tableCellRenderer);
+ }
+ }
+ this.tableHeader = tableHeader;
+ if (this.tableHeader != null) {
+ this.tableHeader.addMouseListener(mouseListener);
+ this.tableHeader.setDefaultRenderer(new SortableHeaderRenderer(this.tableHeader.getDefaultRenderer()));
+ }
+ }
+
+ public boolean isSorting ()
+ {
+ return sortingColumns.size() != 0;
+ }
+
+ private Directive getDirective (int column)
+ {
+ for (int i = 0; i < sortingColumns.size(); i++) {
+ Directive directive = (Directive) sortingColumns.get(i);
+ if (directive.column == column) {
+ return directive;
+ }
+ }
+ return EMPTY_DIRECTIVE;
+ }
+
+ public int getSortingStatus (int column)
+ {
+ return getDirective(column).direction;
+ }
+
+ private void sortingStatusChanged ()
+ {
+ clearSortingState();
+ fireTableDataChanged();
+ if (tableHeader != null) {
+ tableHeader.repaint();
+ }
+ }
+
+ public void setSortingStatus (int column,
+ int status)
+ {
+ Directive directive = getDirective(column);
+ if (directive != EMPTY_DIRECTIVE) {
+ sortingColumns.remove(directive);
+ }
+ if (status != NOT_SORTED) {
+ sortingColumns.add(new Directive(column,
+ status));
+ }
+ sortingStatusChanged();
+ }
+
+ protected Icon getHeaderRendererIcon (int column,
+ int size)
+ {
+ Directive directive = getDirective(column);
+ if (directive == EMPTY_DIRECTIVE) {
+ return null;
+ }
+
+ if (directive.direction == DESCENDING) {
+ return headerIconDown;
+ } else {
+ return headerIconUp;
+ }
+ }
+
+ private void cancelSorting ()
+ {
+ sortingColumns.clear();
+ sortingStatusChanged();
+ }
+
+ public void setColumnComparator (Class type,
+ Comparator comparator)
+ {
+ if (comparator == null) {
+ columnComparators.remove(type);
+ } else {
+ columnComparators.put(type,
+ comparator);
+ }
+ }
+
+ protected Comparator getComparator (int column)
+ {
+ Class columnType = tableModel.getColumnClass(column);
+ Comparator comparator = (Comparator) columnComparators.get(columnType);
+ if (comparator != null) {
+ return comparator;
+ }
+ if (Comparable.class.isAssignableFrom(columnType)) {
+ return COMPARABLE_COMAPRATOR;
+ }
+ return LEXICAL_COMPARATOR;
+ }
+
+ private Row[] getViewToModel ()
+ {
+ if (viewToModel == null) {
+ int tableModelRowCount = tableModel.getRowCount();
+ viewToModel = new Row[tableModelRowCount];
+ for (int row = 0; row < tableModelRowCount; row++) {
+ viewToModel[row] = new Row(row);
+ }
+
+ if (isSorting()) {
+ Arrays.sort(viewToModel);
+ }
+ }
+ return viewToModel;
+ }
+
+ public int modelIndex (int viewIndex)
+ {
+ if (viewIndex > -1 && viewIndex < getViewToModel().length) {
+ return getViewToModel()[viewIndex].modelIndex;
+ } else {
+ return -1;
+ }
+ }
+
+ private int[] getModelToView ()
+ {
+ if (modelToView == null) {
+ int n = getViewToModel().length;
+ modelToView = new int[n];
+ for (int i = 0; i < n; i++) {
+ modelToView[modelIndex(i)] = i;
+ }
+ }
+ return modelToView;
+ }
+
+ // Metody rozhran� TableModel
+
+ public int getRowCount ()
+ {
+ return (tableModel == null) ? 0 : tableModel.getRowCount();
+ }
+
+ public int getColumnCount ()
+ {
+ return (tableModel == null) ? 0 : tableModel.getColumnCount();
+ }
+
+ public String getColumnName (int column)
+ {
+ return tableModel.getColumnName(column);
+ }
+
+ public Class getColumnClass (int column)
+ {
+ return tableModel.getColumnClass(column);
+ }
+
+ public boolean isCellEditable (int row,
+ int column)
+ {
+ return tableModel.isCellEditable(modelIndex(row),
+ column);
+ }
+
+ public Object getValueAt (int row,
+ int column)
+ {
+ return tableModel.getValueAt(modelIndex(row),
+ column);
+ }
+
+ public void setValueAt (Object aValue,
+ int row,
+ int column)
+ {
+ tableModel.setValueAt(aValue,
+ modelIndex(row),
+ column);
+ }
+
+ // Pomocn� t��dy
+
+ private class Row implements Comparable {
+
+ private int modelIndex;
+
+ public Row (int index)
+ {
+ this.modelIndex = index;
+ }
+
+ public int compareTo (Object o)
+ {
+ int row1 = modelIndex;
+ int row2 = ((Row) o).modelIndex;
+
+ for (Iterator it = sortingColumns.iterator(); it.hasNext();) {
+ Directive directive = (Directive) it.next();
+ int column = directive.column;
+ Object o1 = tableModel.getValueAt(row1,
+ column);
+ Object o2 = tableModel.getValueAt(row2,
+ column);
+
+ int comparison = 0;
+ // Define null less than everything, except
+ // null.
+ if (o1 == null && o2 == null) {
+ comparison = 0;
+ } else if (o1 == null) {
+ comparison = -1;
+ } else if (o2 == null) {
+ comparison = 1;
+ } else {
+ comparison = getComparator(column).compare(o1,
+ o2);
+ }
+ if (comparison != 0) {
+ return directive.direction == DESCENDING ? -comparison : comparison;
+ }
+ }
+ return 0;
+ }
+ }
+
+ private class TableModelHandler implements TableModelListener {
+
+ public void tableChanged (TableModelEvent e)
+ {
+ // If we're not sorting by anything, just pass the event
+ // along.
+ if ( !isSorting()) {
+ clearSortingState();
+ fireTableChanged(e);
+ return;
+ }
+
+ // If the table structure has changed, cancel the
+ // sorting; the
+ // sorting columns may have been either moved or deleted
+ // from
+ // the model.
+ if (e.getFirstRow() == TableModelEvent.HEADER_ROW) {
+ cancelSorting();
+ fireTableChanged(e);
+ return;
+ }
+
+ // We can map a cell event through to the view without
+ // widening
+ // when the following conditions apply:
+ //
+ // a) all the changes are on one row (e.getFirstRow() ==
+ // e.getLastRow()) and,
+ // b) all the changes are in one column (column !=
+ // TableModelEvent.ALL_COLUMNS) and,
+ // c) we are not sorting on that column
+ // (getSortingStatus(column) == NOT_SORTED) and,
+ // d) a reverse lookup will not trigger a sort
+ // (modelToView != null)
+ //
+ // Note: INSERT and DELETE events fail this test as they
+ // have column == ALL_COLUMNS.
+ //
+ // The last check, for (modelToView != null) is to see
+ // if modelToView
+ // is already allocated. If we don't do this check;
+ // sorting can become
+ // a performance bottleneck for applications where cells
+ // change rapidly in different parts of the table. If
+ // cells
+ // change alternately in the sorting column and then
+ // outside of
+ // it this class can end up re-sorting on alternate cell
+ // updates -
+ // which can be a performance problem for large tables.
+ // The last
+ // clause avoids this problem.
+ int column = e.getColumn();
+ if (e.getFirstRow() == e.getLastRow() && column != TableModelEvent.ALL_COLUMNS && getSortingStatus(column) == NOT_SORTED
+ && modelToView != null) {
+ int viewIndex = getModelToView()[e.getFirstRow()];
+ fireTableChanged(new TableModelEvent(TableSorterModel.this,
+ viewIndex,
+ viewIndex,
+ column,
+ e.getType()));
+ return;
+ }
+
+ // Something has happened to the data that may have
+ // invalidated the row order.
+ clearSortingState();
+ fireTableDataChanged();
+ return;
+ }
+ }
+
+ private class MouseHandler extends MouseAdapter {
+
+ public void mouseClicked (MouseEvent e)
+ {
+ JTableHeader h = (JTableHeader) e.getSource();
+ TableColumnModel columnModel = h.getColumnModel();
+ int viewColumn = columnModel.getColumnIndexAtX(e.getX());
+ int column = columnModel.getColumn(viewColumn).getModelIndex();
+ if (column != -1) {
+ int status = getSortingStatus(column);
+ if ( !e.isControlDown()) {
+ cancelSorting();
+ }
+ // Cycle the sorting states through {NOT_SORTED,
+ // ASCENDING, DESCENDING} or
+ // {NOT_SORTED, DESCENDING, ASCENDING} depending
+ // on whether shift is pressed.
+ status = status + (e.isShiftDown() ? -1 : 1);
+ status = (status + 4) % 3 - 1; // signed mod,
+ // returning
+ // {-1, 0, 1}
+ setSortingStatus(column,
+ status);
+ }
+ }
+ }
+
+ private class SortableHeaderRenderer implements TableCellRenderer {
+
+ private TableCellRenderer tableCellRenderer;
+
+ public SortableHeaderRenderer (TableCellRenderer tableCellRenderer)
+ {
+ this.tableCellRenderer = tableCellRenderer;
+ }
+
+ public Component getTableCellRendererComponent (JTable table,
+ Object value,
+ boolean isSelected,
+ boolean hasFocus,
+ int row,
+ int column)
+ {
+ Component c = tableCellRenderer.getTableCellRendererComponent(table,
+ value,
+ isSelected,
+ hasFocus,
+ row,
+ column);
+ if (c instanceof JLabel) {
+ JLabel l = (JLabel) c;
+ l.setHorizontalTextPosition(JLabel.LEFT);
+ int modelColumn = table.convertColumnIndexToModel(column);
+ l.setIcon(getHeaderRendererIcon(modelColumn,
+ l.getFont().getSize()));
+ }
+ return c;
+ }
+ }
+
+ private static class Directive {
+
+ private int column;
+
+ private int direction;
+
+ public Directive (int column,
+ int direction)
+ {
+ this.column = column;
+ this.direction = direction;
+ }
+ }
+
+ public void fireTableColumnUpdated (int index)
+ {
+ for (int i = 0; i < getRowCount(); i++) {
+ fireTableCellUpdated(i,
+ index);
+ }
+ }
+}