/* * Copyright (c) 1995 - 2008 Sun Microsystems, Inc.  All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * *   - Redistributions of source code must retain the above copyright *     notice, this list of conditions and the following disclaimer. * *   - Redistributions in binary form must reproduce the above copyright *     notice, this list of conditions and the following disclaimer in the *     documentation and/or other materials provided with the distribution. * *   - Neither the name of Sun Microsystems nor the names of its *     contributors may be used to endorse or promote products derived *     from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package components;import java.awt.*;import java.awt.event.*;import java.util.*;import java.util.List;import javax.swing.*;import javax.swing.event.TableModelEvent;import javax.swing.event.TableModelListener;import javax.swing.table.*;/** * TableSorter is a decorator for TableModels; adding sorting * functionality to a supplied TableModel. TableSorter does * not store or copy the data in its TableModel; instead it maintains * a map from the row indexes of the view to the row indexes of the * model. As requests are made of the sorter (like getValueAt(row, col)) * they are passed to the underlying model after the row numbers * have been translated via the internal mapping array. This way, * the TableSorter appears to hold another copy of the table * with the rows in a different order. * <p/> * TableSorter registers itself as a listener to the underlying model, * just as the JTable itself would. Events recieved from the model * are examined, sometimes manipulated (typically widened), and then * passed on to the TableSorter's listeners (typically the JTable). * If a change to the model has invalidated the order of TableSorter's * rows, a note of this is made and the sorter will resort the * rows the next time a value is requested. * <p/> * When the tableHeader property is set, either by using the * setTableHeader() method or the two argument constructor, the * table header may be used as a complete UI for TableSorter. * The default renderer of the tableHeader is decorated with a renderer * that indicates the sorting status of each column. In addition, * a mouse listener is installed with the following behavior: * <ul> * <li> * Mouse-click: Clears the sorting status of all other columns * and advances the sorting status of that column through three * values: {NOT_SORTED, ASCENDING, DESCENDING} (then back to * NOT_SORTED again). * <li> * SHIFT-mouse-click: Clears the sorting status of all other columns * and cycles the sorting status of the column through the same * three values, in the opposite order: {NOT_SORTED, DESCENDING, ASCENDING}. * <li> * CONTROL-mouse-click and CONTROL-SHIFT-mouse-click: as above except * that the changes to the column do not cancel the statuses of columns * that are already sorting - giving a way to initiate a compound * sort. * </ul> * <p/> * This is a long overdue rewrite of a class of the same name that * first appeared in the swing table demos in 1997. *  * @author Philip Milne * @author Brendon McLean  * @author Dan van Enckevort * @author Parwinder Sekhon * @version 2.0 02/27/04 */public class TableSorter extends AbstractTableModel {    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();    public TableSorter() {        this.mouseListener = new MouseHandler();        this.tableModelListener = new TableModelHandler();    }    public TableSorter(TableModel tableModel) {        this();        setTableModel(tableModel);    }    public TableSorter(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;        }        return new Arrow(directive.direction == DESCENDING, size, sortingColumns.indexOf(directive));    }    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++) {