Merge branch 'releases/Release_2_11_4_Branch'
[jalview.git] / util / TableSorter.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
3  * Copyright (C) 2014 The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.util;
22
23 import java.util.*;
24 import java.util.List;
25
26 import java.awt.*;
27 import java.awt.event.*;
28 import javax.swing.*;
29 import javax.swing.event.*;
30 import javax.swing.table.*;
31
32 /**
33  * TableSorter is a decorator for TableModels; adding sorting functionality to a
34  * supplied TableModel. TableSorter does not store or copy the data in its
35  * TableModel; instead it maintains a map from the row indexes of the view to
36  * the row indexes of the model. As requests are made of the sorter (like
37  * getValueAt(row, col)) they are passed to the underlying model after the row
38  * numbers have been translated via the internal mapping array. This way, the
39  * TableSorter appears to hold another copy of the table with the rows in a
40  * different order.
41  * <p/>
42  * TableSorter registers itself as a listener to the underlying model, just as
43  * the JTable itself would. Events recieved from the model are examined,
44  * sometimes manipulated (typically widened), and then passed on to the
45  * TableSorter's listeners (typically the JTable). If a change to the model has
46  * invalidated the order of TableSorter's rows, a note of this is made and the
47  * sorter will resort the rows the next time a value is requested.
48  * <p/>
49  * When the tableHeader property is set, either by using the setTableHeader()
50  * method or the two argument constructor, the table header may be used as a
51  * complete UI for TableSorter. The default renderer of the tableHeader is
52  * decorated with a renderer that indicates the sorting status of each column.
53  * In addition, a mouse listener is installed with the following behavior:
54  * <ul>
55  * <li>Mouse-click: Clears the sorting status of all other columns and advances
56  * the sorting status of that column through three values: {NOT_SORTED,
57  * ASCENDING, DESCENDING} (then back to NOT_SORTED again).
58  * <li>SHIFT-mouse-click: Clears the sorting status of all other columns and
59  * cycles the sorting status of the column through the same three values, in the
60  * opposite order: {NOT_SORTED, DESCENDING, ASCENDING}.
61  * <li>CONTROL-mouse-click and CONTROL-SHIFT-mouse-click: as above except that
62  * the changes to the column do not cancel the statuses of columns that are
63  * already sorting - giving a way to initiate a compound sort.
64  * </ul>
65  * <p/>
66  * This is a long overdue rewrite of a class of the same name that first
67  * appeared in the swing table demos in 1997.
68  * 
69  * @author Philip Milne
70  * @author Brendon McLean
71  * @author Dan van Enckevort
72  * @author Parwinder Sekhon
73  * @version 2.0 02/27/04
74  */
75
76 public class TableSorter extends AbstractTableModel
77 {
78   protected TableModel tableModel;
79
80   public static final int DESCENDING = -1;
81
82   public static final int NOT_SORTED = 0;
83
84   public static final int ASCENDING = 1;
85
86   private static Directive EMPTY_DIRECTIVE = new Directive(-1, NOT_SORTED);
87
88   public static final Comparator COMPARABLE_COMAPRATOR = new Comparator()
89   {
90     public int compare(Object o1, Object o2)
91     {
92       return ((Comparable) o1).compareTo(o2);
93     }
94   };
95
96   public static final Comparator LEXICAL_COMPARATOR = new Comparator()
97   {
98     public int compare(Object o1, Object o2)
99     {
100       return o1.toString().compareTo(o2.toString());
101     }
102   };
103
104   private Row[] viewToModel;
105
106   private int[] modelToView;
107
108   private JTableHeader tableHeader;
109
110   private MouseListener mouseListener;
111
112   private TableModelListener tableModelListener;
113
114   private Map columnComparators = new HashMap();
115
116   private List sortingColumns = new ArrayList();
117
118   public TableSorter()
119   {
120     this.mouseListener = new MouseHandler();
121     this.tableModelListener = new TableModelHandler();
122   }
123
124   public TableSorter(TableModel tableModel)
125   {
126     this();
127     setTableModel(tableModel);
128   }
129
130   public TableSorter(TableModel tableModel, JTableHeader tableHeader)
131   {
132     this();
133     setTableHeader(tableHeader);
134     setTableModel(tableModel);
135   }
136
137   private void clearSortingState()
138   {
139     viewToModel = null;
140     modelToView = null;
141   }
142
143   public TableModel getTableModel()
144   {
145     return tableModel;
146   }
147
148   public void setTableModel(TableModel tableModel)
149   {
150     if (this.tableModel != null)
151     {
152       this.tableModel.removeTableModelListener(tableModelListener);
153     }
154
155     this.tableModel = tableModel;
156     if (this.tableModel != null)
157     {
158       this.tableModel.addTableModelListener(tableModelListener);
159     }
160
161     clearSortingState();
162     fireTableStructureChanged();
163   }
164
165   public JTableHeader getTableHeader()
166   {
167     return tableHeader;
168   }
169
170   public void setTableHeader(JTableHeader tableHeader)
171   {
172     if (this.tableHeader != null)
173     {
174       this.tableHeader.removeMouseListener(mouseListener);
175       TableCellRenderer defaultRenderer = this.tableHeader
176               .getDefaultRenderer();
177       if (defaultRenderer instanceof SortableHeaderRenderer)
178       {
179         this.tableHeader
180                 .setDefaultRenderer(((SortableHeaderRenderer) defaultRenderer).tableCellRenderer);
181       }
182     }
183     this.tableHeader = tableHeader;
184     if (this.tableHeader != null)
185     {
186       this.tableHeader.addMouseListener(mouseListener);
187       this.tableHeader.setDefaultRenderer(new SortableHeaderRenderer(
188               this.tableHeader.getDefaultRenderer()));
189     }
190   }
191
192   public boolean isSorting()
193   {
194     return sortingColumns.size() != 0;
195   }
196
197   private Directive getDirective(int column)
198   {
199     for (int i = 0; i < sortingColumns.size(); i++)
200     {
201       Directive directive = (Directive) sortingColumns.get(i);
202       if (directive.column == column)
203       {
204         return directive;
205       }
206     }
207     return EMPTY_DIRECTIVE;
208   }
209
210   public int getSortingStatus(int column)
211   {
212     return getDirective(column).direction;
213   }
214
215   private void sortingStatusChanged()
216   {
217     clearSortingState();
218     fireTableDataChanged();
219     if (tableHeader != null)
220     {
221       tableHeader.repaint();
222     }
223   }
224
225   public void setSortingStatus(int column, int status)
226   {
227     Directive directive = getDirective(column);
228     if (directive != EMPTY_DIRECTIVE)
229     {
230       sortingColumns.remove(directive);
231     }
232     if (status != NOT_SORTED)
233     {
234       sortingColumns.add(new Directive(column, status));
235     }
236     sortingStatusChanged();
237   }
238
239   protected Icon getHeaderRendererIcon(int column, int size)
240   {
241     Directive directive = getDirective(column);
242     if (directive == EMPTY_DIRECTIVE)
243     {
244       return null;
245     }
246     return new Arrow(directive.direction == DESCENDING, size,
247             sortingColumns.indexOf(directive));
248   }
249
250   private void cancelSorting()
251   {
252     sortingColumns.clear();
253     sortingStatusChanged();
254   }
255
256   public void setColumnComparator(Class type, Comparator comparator)
257   {
258     if (comparator == null)
259     {
260       columnComparators.remove(type);
261     }
262     else
263     {
264       columnComparators.put(type, comparator);
265     }
266   }
267
268   protected Comparator getComparator(int column)
269   {
270     Class columnType = tableModel.getColumnClass(column);
271     Comparator comparator = (Comparator) columnComparators.get(columnType);
272     if (comparator != null)
273     {
274       return comparator;
275     }
276     if (Comparable.class.isAssignableFrom(columnType))
277     {
278       return COMPARABLE_COMAPRATOR;
279     }
280     return LEXICAL_COMPARATOR;
281   }
282
283   private Row[] getViewToModel()
284   {
285     if (viewToModel == null)
286     {
287       int tableModelRowCount = tableModel.getRowCount();
288       viewToModel = new Row[tableModelRowCount];
289       for (int row = 0; row < tableModelRowCount; row++)
290       {
291         viewToModel[row] = new Row(row);
292       }
293
294       if (isSorting())
295       {
296         Arrays.sort(viewToModel);
297       }
298     }
299     return viewToModel;
300   }
301
302   public int modelIndex(int viewIndex)
303   {
304     return getViewToModel()[viewIndex].modelIndex;
305   }
306
307   private int[] getModelToView()
308   {
309     if (modelToView == null)
310     {
311       int n = getViewToModel().length;
312       modelToView = new int[n];
313       for (int i = 0; i < n; i++)
314       {
315         modelToView[modelIndex(i)] = i;
316       }
317     }
318     return modelToView;
319   }
320
321   // TableModel interface methods
322
323   public int getRowCount()
324   {
325     return (tableModel == null) ? 0 : tableModel.getRowCount();
326   }
327
328   public int getColumnCount()
329   {
330     return (tableModel == null) ? 0 : tableModel.getColumnCount();
331   }
332
333   public String getColumnName(int column)
334   {
335     return tableModel.getColumnName(column);
336   }
337
338   public Class getColumnClass(int column)
339   {
340     return tableModel.getColumnClass(column);
341   }
342
343   public boolean isCellEditable(int row, int column)
344   {
345     return tableModel.isCellEditable(modelIndex(row), column);
346   }
347
348   public Object getValueAt(int row, int column)
349   {
350     return tableModel.getValueAt(modelIndex(row), column);
351   }
352
353   public void setValueAt(Object aValue, int row, int column)
354   {
355     tableModel.setValueAt(aValue, modelIndex(row), column);
356   }
357
358   // Helper classes
359
360   private class Row implements Comparable
361   {
362     private int modelIndex;
363
364     public Row(int index)
365     {
366       this.modelIndex = index;
367     }
368
369     public int compareTo(Object o)
370     {
371       int row1 = modelIndex;
372       int row2 = ((Row) o).modelIndex;
373
374       for (Iterator it = sortingColumns.iterator(); it.hasNext();)
375       {
376         Directive directive = (Directive) it.next();
377         int column = directive.column;
378         Object o1 = tableModel.getValueAt(row1, column);
379         Object o2 = tableModel.getValueAt(row2, column);
380
381         int comparison = 0;
382         // Define null less than everything, except null.
383         if (o1 == null && o2 == null)
384         {
385           comparison = 0;
386         }
387         else if (o1 == null)
388         {
389           comparison = -1;
390         }
391         else if (o2 == null)
392         {
393           comparison = 1;
394         }
395         else
396         {
397           comparison = getComparator(column).compare(o1, o2);
398         }
399         if (comparison != 0)
400         {
401           return directive.direction == DESCENDING ? -comparison
402                   : comparison;
403         }
404       }
405       return 0;
406     }
407   }
408
409   private class TableModelHandler implements TableModelListener
410   {
411     public void tableChanged(TableModelEvent e)
412     {
413       // If we're not sorting by anything, just pass the event along.
414       if (!isSorting())
415       {
416         clearSortingState();
417         fireTableChanged(e);
418         return;
419       }
420
421       // If the table structure has changed, cancel the sorting; the
422       // sorting columns may have been either moved or deleted from
423       // the model.
424       if (e.getFirstRow() == TableModelEvent.HEADER_ROW)
425       {
426         cancelSorting();
427         fireTableChanged(e);
428         return;
429       }
430
431       // We can map a cell event through to the view without widening
432       // when the following conditions apply:
433       //
434       // a) all the changes are on one row (e.getFirstRow() == e.getLastRow())
435       // and,
436       // b) all the changes are in one column (column !=
437       // TableModelEvent.ALL_COLUMNS) and,
438       // c) we are not sorting on that column (getSortingStatus(column) ==
439       // NOT_SORTED) and,
440       // d) a reverse lookup will not trigger a sort (modelToView != null)
441       //
442       // Note: INSERT and DELETE events fail this test as they have column ==
443       // ALL_COLUMNS.
444       //
445       // The last check, for (modelToView != null) is to see if modelToView
446       // is already allocated. If we don't do this check; sorting can become
447       // a performance bottleneck for applications where cells
448       // change rapidly in different parts of the table. If cells
449       // change alternately in the sorting column and then outside of
450       // it this class can end up re-sorting on alternate cell updates -
451       // which can be a performance problem for large tables. The last
452       // clause avoids this problem.
453       int column = e.getColumn();
454       if (e.getFirstRow() == e.getLastRow()
455               && column != TableModelEvent.ALL_COLUMNS
456               && getSortingStatus(column) == NOT_SORTED
457               && modelToView != null)
458       {
459         int viewIndex = getModelToView()[e.getFirstRow()];
460         fireTableChanged(new TableModelEvent(TableSorter.this, viewIndex,
461                 viewIndex, column, e.getType()));
462         return;
463       }
464
465       // Something has happened to the data that may have invalidated the row
466       // order.
467       clearSortingState();
468       fireTableDataChanged();
469       return;
470     }
471   }
472
473   private class MouseHandler extends MouseAdapter
474   {
475     public void mouseClicked(MouseEvent e)
476     {
477       JTableHeader h = (JTableHeader) e.getSource();
478       TableColumnModel columnModel = h.getColumnModel();
479       int viewColumn = columnModel.getColumnIndexAtX(e.getX());
480       int column = columnModel.getColumn(viewColumn).getModelIndex();
481       if (column != -1)
482       {
483         int status = getSortingStatus(column);
484         if (!e.isControlDown())
485         {
486           cancelSorting();
487         }
488         // Cycle the sorting states through {NOT_SORTED, ASCENDING, DESCENDING}
489         // or
490         // {NOT_SORTED, DESCENDING, ASCENDING} depending on whether shift is
491         // pressed.
492         status = status + (e.isShiftDown() ? -1 : 1);
493         status = (status + 4) % 3 - 1; // signed mod, returning {-1, 0, 1}
494         setSortingStatus(column, status);
495       }
496     }
497   }
498
499   private static class Arrow implements Icon
500   {
501     private boolean descending;
502
503     private int size;
504
505     private int priority;
506
507     public Arrow(boolean descending, int size, int priority)
508     {
509       this.descending = descending;
510       this.size = size;
511       this.priority = priority;
512     }
513
514     public void paintIcon(Component c, Graphics g, int x, int y)
515     {
516       Color color = c == null ? Color.GRAY : c.getBackground();
517       // In a compound sort, make each succesive triangle 20%
518       // smaller than the previous one.
519       int dx = (int) (size / 2 * Math.pow(0.8, priority));
520       int dy = descending ? dx : -dx;
521       // Align icon (roughly) with font baseline.
522       y = y + 5 * size / 6 + (descending ? -dy : 0);
523       int shift = descending ? 1 : -1;
524       g.translate(x, y);
525
526       // Right diagonal.
527       g.setColor(color.darker());
528       g.drawLine(dx / 2, dy, 0, 0);
529       g.drawLine(dx / 2, dy + shift, 0, shift);
530
531       // Left diagonal.
532       g.setColor(color.brighter());
533       g.drawLine(dx / 2, dy, dx, 0);
534       g.drawLine(dx / 2, dy + shift, dx, shift);
535
536       // Horizontal line.
537       if (descending)
538       {
539         g.setColor(color.darker().darker());
540       }
541       else
542       {
543         g.setColor(color.brighter().brighter());
544       }
545       g.drawLine(dx, 0, 0, 0);
546
547       g.setColor(color);
548       g.translate(-x, -y);
549     }
550
551     public int getIconWidth()
552     {
553       return size;
554     }
555
556     public int getIconHeight()
557     {
558       return size;
559     }
560   }
561
562   private class SortableHeaderRenderer implements TableCellRenderer
563   {
564     private TableCellRenderer tableCellRenderer;
565
566     public SortableHeaderRenderer(TableCellRenderer tableCellRenderer)
567     {
568       this.tableCellRenderer = tableCellRenderer;
569     }
570
571     public Component getTableCellRendererComponent(JTable table,
572             Object value, boolean isSelected, boolean hasFocus, int row,
573             int column)
574     {
575       Component c = tableCellRenderer.getTableCellRendererComponent(table,
576               value, isSelected, hasFocus, row, column);
577       if (c instanceof JLabel)
578       {
579         JLabel l = (JLabel) c;
580         l.setHorizontalTextPosition(JLabel.LEFT);
581         int modelColumn = table.convertColumnIndexToModel(column);
582         l.setIcon(getHeaderRendererIcon(modelColumn, l.getFont().getSize()));
583       }
584       return c;
585     }
586   }
587
588   private static class Directive
589   {
590     private int column;
591
592     private int direction;
593
594     public Directive(int column, int direction)
595     {
596       this.column = column;
597       this.direction = direction;
598     }
599   }
600 }