src/jalview/util/TableSorter.java

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