TableSorter.java revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2000 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*
* ident "%Z%%M% %I% %E% SMI"
*/
/*
* @(#)TableSorter.java 1.5 97/12/17
*/
/**
* A sorter for TableModels. The sorter has a model (conforming to TableModel)
* and itself implements TableModel. TableSorter does not store or copy
* the data in the TableModel, instead it maintains an array of
* integers which it keeps the same size as the number of rows in its
* model. When the model changes it notifies the sorter that something
* has changed eg. "rowsAdded" so that its internal array of integers
* can be reallocated. As requests are made of the sorter (like
* getValueAt(row, col) it redirects them to its model via the mapping
* array. That way the TableSorter appears to hold another copy of the table
* with the rows in a different order. The sorting algorthm used is stable
* which means that it does not move around rows when its comparison
* function returns 0 to denote that they are equivalent.
*
* @version 1.5 12/17/97
* @author Philip Milne
*/
// Imports for picking up mouse events from the JTable.
public class TableSorter extends TableMap
{
int indexes[] = new int[0];
boolean ascending = true;
int compares;
public TableSorter() {
}
}
}
// Check for nulls
// If both values are null return 0
return 0;
return -1;
return 1;
}
/*
* We copy all returned values from the getValue call in case
* an optimised model is reusing one object to return many values.
* The Number subclasses in the JDK are immutable and so will not be
* used in this way but other subclasses of Number might want to do
* this to save space and avoid unnecessary heap allocation.
*/
return -1;
return 1;
else
return 0;
// Handle negatives specially
if (n1 < 0) {
return 1;
} else if (n2 < 0) {
return -1;
}
return -1;
return 1;
else
return 0;
if (result < 0)
return -1;
else if (result > 0)
return 1;
else return 0;
return 0;
else if (b1) // Define false < true
return 1;
else
return -1;
/*
* Promote and mask because bytes are signed and 128-255
* will be done wrong
*/
return -1;
return 1;
}
}
return 0;
} else {
if (result < 0)
return -1;
else if (result > 0)
return 1;
else return 0;
}
}
compares++;
if (result != 0)
}
return 0;
}
public void reallocateIndexes() {
// Set up a new array of indexes with the right number of elements
// for the new data model.
// Initialise with the identity mapping.
}
public void tableChanged(TableModelEvent e) {
// System.out.println("Sorter: tableChanged");
sort(this);
super.tableChanged(e);
}
public void checkModel() {
}
}
checkModel();
compares = 0;
// n2sort();
// qsort(0, indexes.length-1);
// System.out.println("Compares: "+compares);
}
public void n2sort() {
for (int i = 0; i < getRowCount(); i++) {
for (int j = i+1; j < getRowCount(); j++) {
swap(i, j);
}
}
}
}
/*
* This is a home-grown implementation which we have not had time
* to research - it may perform poorly in some circumstances. It
* requires twice the space of an in-place algorithm and makes
* NlogN assigments shuttling the values between the two
* arrays. The number of compares appears to vary between N-1 and
* NlogN depending on the initial order but the main reason for
* using it here is that, unlike qsort, it is stable.
*/
return;
}
int p = low;
int q = middle;
/*
* This is an optional short-cut; at each recursive call,
* check to see if the elements in this subset are already
* ordered. If so, no further comparisons are needed; the
* sub-array can just be copied. The array must be copied rather
* than assigned otherwise sister calls in the recursion might
* get out of sinc. When the number of elements is three they
* are partitioned so that the first set, [low, mid), has one
* element and and the second, [mid, high), has two. We skip the
* optimisation when the number of elements is three or less as
* the first compare in the normal merge will produce the same
* sequence of steps. This optimisation seems to be worthwhile
* for partially ordered lists but some analysis is needed to
* find out how the performance drops to Nlog(N) as the initial
* order diminishes - it may drop very quickly.
*/
}
return;
}
// A normal merge.
} else {
}
}
}
public void swap(int i, int j) {
}
/*
* The mapping only affects the contents of the data rows.
* Pass all requests to these rows through the mapping array: "indexes".
*/
{
checkModel();
}
checkModel();
} else {
return -1;
}
}
checkModel();
}
public void sortByColumn(int column) {
// Re-sort on this column, but don't change sort order
}
sort(this);
super.tableChanged(new TableModelEvent(this));
}
/*
* There is no-where else to put this.
* Add a mouse listener to the Table to trigger a table sort
* when a column heading is clicked in the JTable.
*/
final TableSorter sorter = this;
tableView.setColumnSelectionAllowed(false);
public void mouseClicked(MouseEvent e) {
// System.out.println("Sorting ...");
}
}
};
}
// Allow others to be notified when re-sorting is done
public void addActionListener(ActionListener l) {
listeners.addElement(l);
}
// Take me off the notify list
public void removeActionListener(ActionListener l) {
}
/*
* Notify listeners of sort events; we just use ActionEvent as it's a
* good all-purpose event
*/
protected void fireActionPerformed() {
while (en.hasMoreElements()) {
l.actionPerformed(e);
}
}
}