tablesorter.java

eq跨平台查询工具源码 eq跨平台查询工具源码

package org.underworldlabs.swing.table;

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.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.swing.Icon;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;
import org.underworldlabs.swing.util.SwingWorker;

/*
 * TableSorter.java
 *
 * Copyright (C) 2002, 2003, 2004, 2005, 2006 Takis Diakoumis
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */



/* ----------------------------------------------------------
 * CVS NOTE: Changes to the CVS repository prior to the 
 *           release of version 3.0.0beta1 has meant a 
 *           resetting of CVS revision numbers.
 * ----------------------------------------------------------
 */

/**
 * 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
 *
 * @author   Takis Diakoumis
 * @version  $Revision: 1.5 $
 * @date     $Date: 2006/05/14 06:56:07 $
 */
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);
    
    private SortableHeaderRenderer headerRenderer;
    
    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();
        this.headerRenderer = new SortableHeaderRenderer(this);
    }
    
    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 (tableModel != null) {
            tableModel.removeTableModelListener(tableModelListener);
        }
        tableModel = _tableModel;
        
        if (tableModel != null) {
            tableModel.addTableModelListener(tableModelListener);
        }
/*
        if (tableHeader != null) {
          tableHeader.removeMouseListener(mouseListener);
          tableHeader = null;
        }
 */
        sortingColumns.clear();
        clearSortingState();
        fireTableStructureChanged();
        
    }
    
    public JTableHeader getTableHeader() {
        return tableHeader;
    }
    
    public void setTableHeader(JTableHeader _tableHeader) {
        
        tableHeader = _tableHeader;
        
        if (tableHeader != null) {
            tableHeader.addMouseListener(mouseListener);
            tableHeader.setDefaultRenderer(headerRenderer);//new SortableHeaderRenderer(this));
        }
        
    }
    
    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();
    }
    
    public Icon getHeaderRendererIcon(int column, int size) {
        Directive directive = getDirective(column);
        
        if (directive == EMPTY_DIRECTIVE) {
            return null;
        }
        
        boolean isAscend = directive.direction == ASCENDING;
        return new ArrowIcon(isAscend ? ArrowIcon.DOWN : ArrowIcon.UP);
    }
    
    public int getHeaderRendererIcon(int column) {
        Directive directive = getDirective(column);        
        if (directive == EMPTY_DIRECTIVE) {
            return -1;
        }
        
        boolean isAscend = (directive.direction == ASCENDING);
        return isAscend ? ArrowIcon.DOWN : ArrowIcon.UP;
    }
    
    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];
            
            if (viewToModel == null)
                return null;
            
            for (int row = 0; row < tableModelRowCount; row++) {
                viewToModel[row] = new Row(row);
            }
            
            if (isSorting())
                Arrays.sort(viewToModel);
            
        }
        
        return viewToModel;
        
    }
    
    public int modelIndex(int viewIndex) {
        return getViewToModel()[viewIndex].modelIndex;
    }
    
    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;