You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1380 lines
46 KiB
1380 lines
46 KiB
/*
|
|
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
package javax.swing;
|
|
|
|
import java.text.Collator;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.List;
|
|
import javax.swing.SortOrder;
|
|
|
|
/**
|
|
* An implementation of <code>RowSorter</code> that provides sorting and
|
|
* filtering around a grid-based data model.
|
|
* Beyond creating and installing a <code>RowSorter</code>, you very rarely
|
|
* need to interact with one directly. Refer to
|
|
* {@link javax.swing.table.TableRowSorter TableRowSorter} for a concrete
|
|
* implementation of <code>RowSorter</code> for <code>JTable</code>.
|
|
* <p>
|
|
* Sorting is done based on the current <code>SortKey</code>s, in order.
|
|
* If two objects are equal (the <code>Comparator</code> for the
|
|
* column returns 0) the next <code>SortKey</code> is used. If no
|
|
* <code>SortKey</code>s remain or the order is <code>UNSORTED</code>, then
|
|
* the order of the rows in the model is used.
|
|
* <p>
|
|
* Sorting of each column is done by way of a <code>Comparator</code>
|
|
* that you can specify using the <code>setComparator</code> method.
|
|
* If a <code>Comparator</code> has not been specified, the
|
|
* <code>Comparator</code> returned by
|
|
* <code>Collator.getInstance()</code> is used on the results of
|
|
* calling <code>toString</code> on the underlying objects. The
|
|
* <code>Comparator</code> is never passed <code>null</code>. A
|
|
* <code>null</code> value is treated as occurring before a
|
|
* non-<code>null</code> value, and two <code>null</code> values are
|
|
* considered equal.
|
|
* <p>
|
|
* If you specify a <code>Comparator</code> that casts its argument to
|
|
* a type other than that provided by the model, a
|
|
* <code>ClassCastException</code> will be thrown when the data is sorted.
|
|
* <p>
|
|
* In addition to sorting, <code>DefaultRowSorter</code> provides the
|
|
* ability to filter rows. Filtering is done by way of a
|
|
* <code>RowFilter</code> that is specified using the
|
|
* <code>setRowFilter</code> method. If no filter has been specified all
|
|
* rows are included.
|
|
* <p>
|
|
* By default, rows are in unsorted order (the same as the model) and
|
|
* every column is sortable. The default <code>Comparator</code>s are
|
|
* documented in the subclasses (for example, {@link
|
|
* javax.swing.table.TableRowSorter TableRowSorter}).
|
|
* <p>
|
|
* If the underlying model structure changes (the
|
|
* <code>modelStructureChanged</code> method is invoked) the following
|
|
* are reset to their default values: <code>Comparator</code>s by
|
|
* column, current sort order, and whether each column is sortable. To
|
|
* find the default <code>Comparator</code>s, see the concrete
|
|
* implementation (for example, {@link
|
|
* javax.swing.table.TableRowSorter TableRowSorter}). The default
|
|
* sort order is unsorted (the same as the model), and columns are
|
|
* sortable by default.
|
|
* <p>
|
|
* If the underlying model structure changes (the
|
|
* <code>modelStructureChanged</code> method is invoked) the following
|
|
* are reset to their default values: <code>Comparator</code>s by column,
|
|
* current sort order and whether a column is sortable.
|
|
* <p>
|
|
* <code>DefaultRowSorter</code> is an abstract class. Concrete
|
|
* subclasses must provide access to the underlying data by invoking
|
|
* {@code setModelWrapper}. The {@code setModelWrapper} method
|
|
* <b>must</b> be invoked soon after the constructor is
|
|
* called, ideally from within the subclass's constructor.
|
|
* Undefined behavior will result if you use a {@code
|
|
* DefaultRowSorter} without specifying a {@code ModelWrapper}.
|
|
* <p>
|
|
* <code>DefaultRowSorter</code> has two formal type parameters. The
|
|
* first type parameter corresponds to the class of the model, for example
|
|
* <code>DefaultTableModel</code>. The second type parameter
|
|
* corresponds to the class of the identifier passed to the
|
|
* <code>RowFilter</code>. Refer to <code>TableRowSorter</code> and
|
|
* <code>RowFilter</code> for more details on the type parameters.
|
|
*
|
|
* @param <M> the type of the model
|
|
* @param <I> the type of the identifier passed to the <code>RowFilter</code>
|
|
* @see javax.swing.table.TableRowSorter
|
|
* @see javax.swing.table.DefaultTableModel
|
|
* @see java.text.Collator
|
|
* @since 1.6
|
|
*/
|
|
public abstract class DefaultRowSorter<M, I> extends RowSorter<M> {
|
|
/**
|
|
* Whether or not we resort on TableModelEvent.UPDATEs.
|
|
*/
|
|
private boolean sortsOnUpdates;
|
|
|
|
/**
|
|
* View (JTable) -> model.
|
|
*/
|
|
private Row[] viewToModel;
|
|
|
|
/**
|
|
* model -> view (JTable)
|
|
*/
|
|
private int[] modelToView;
|
|
|
|
/**
|
|
* Comparators specified by column.
|
|
*/
|
|
private Comparator[] comparators;
|
|
|
|
/**
|
|
* Whether or not the specified column is sortable, by column.
|
|
*/
|
|
private boolean[] isSortable;
|
|
|
|
/**
|
|
* Cached SortKeys for the current sort.
|
|
*/
|
|
private SortKey[] cachedSortKeys;
|
|
|
|
/**
|
|
* Cached comparators for the current sort
|
|
*/
|
|
private Comparator[] sortComparators;
|
|
|
|
/**
|
|
* Developer supplied Filter.
|
|
*/
|
|
private RowFilter<? super M,? super I> filter;
|
|
|
|
/**
|
|
* Value passed to the filter. The same instance is passed to the
|
|
* filter for different rows.
|
|
*/
|
|
private FilterEntry filterEntry;
|
|
|
|
/**
|
|
* The sort keys.
|
|
*/
|
|
private List<SortKey> sortKeys;
|
|
|
|
/**
|
|
* Whether or not to use getStringValueAt. This is indexed by column.
|
|
*/
|
|
private boolean[] useToString;
|
|
|
|
/**
|
|
* Indicates the contents are sorted. This is used if
|
|
* getSortsOnUpdates is false and an update event is received.
|
|
*/
|
|
private boolean sorted;
|
|
|
|
/**
|
|
* Maximum number of sort keys.
|
|
*/
|
|
private int maxSortKeys;
|
|
|
|
/**
|
|
* Provides access to the data we're sorting/filtering.
|
|
*/
|
|
private ModelWrapper<M,I> modelWrapper;
|
|
|
|
/**
|
|
* Size of the model. This is used to enforce error checking within
|
|
* the table changed notification methods (such as rowsInserted).
|
|
*/
|
|
private int modelRowCount;
|
|
|
|
|
|
/**
|
|
* Creates an empty <code>DefaultRowSorter</code>.
|
|
*/
|
|
public DefaultRowSorter() {
|
|
sortKeys = Collections.emptyList();
|
|
maxSortKeys = 3;
|
|
}
|
|
|
|
/**
|
|
* Sets the model wrapper providing the data that is being sorted and
|
|
* filtered.
|
|
*
|
|
* @param modelWrapper the model wrapper responsible for providing the
|
|
* data that gets sorted and filtered
|
|
* @throws IllegalArgumentException if {@code modelWrapper} is
|
|
* {@code null}
|
|
*/
|
|
protected final void setModelWrapper(ModelWrapper<M,I> modelWrapper) {
|
|
if (modelWrapper == null) {
|
|
throw new IllegalArgumentException(
|
|
"modelWrapper most be non-null");
|
|
}
|
|
ModelWrapper<M,I> last = this.modelWrapper;
|
|
this.modelWrapper = modelWrapper;
|
|
if (last != null) {
|
|
modelStructureChanged();
|
|
} else {
|
|
// If last is null, we're in the constructor. If we're in
|
|
// the constructor we don't want to call to overridable methods.
|
|
modelRowCount = getModelWrapper().getRowCount();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the model wrapper providing the data that is being sorted and
|
|
* filtered.
|
|
*
|
|
* @return the model wrapper responsible for providing the data that
|
|
* gets sorted and filtered
|
|
*/
|
|
protected final ModelWrapper<M,I> getModelWrapper() {
|
|
return modelWrapper;
|
|
}
|
|
|
|
/**
|
|
* Returns the underlying model.
|
|
*
|
|
* @return the underlying model
|
|
*/
|
|
public final M getModel() {
|
|
return getModelWrapper().getModel();
|
|
}
|
|
|
|
/**
|
|
* Sets whether or not the specified column is sortable. The specified
|
|
* value is only checked when <code>toggleSortOrder</code> is invoked.
|
|
* It is still possible to sort on a column that has been marked as
|
|
* unsortable by directly setting the sort keys. The default is
|
|
* true.
|
|
*
|
|
* @param column the column to enable or disable sorting on, in terms
|
|
* of the underlying model
|
|
* @param sortable whether or not the specified column is sortable
|
|
* @throws IndexOutOfBoundsException if <code>column</code> is outside
|
|
* the range of the model
|
|
* @see #toggleSortOrder
|
|
* @see #setSortKeys
|
|
*/
|
|
public void setSortable(int column, boolean sortable) {
|
|
checkColumn(column);
|
|
if (isSortable == null) {
|
|
isSortable = new boolean[getModelWrapper().getColumnCount()];
|
|
for (int i = isSortable.length - 1; i >= 0; i--) {
|
|
isSortable[i] = true;
|
|
}
|
|
}
|
|
isSortable[column] = sortable;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the specified column is sortable; otherwise, false.
|
|
*
|
|
* @param column the column to check sorting for, in terms of the
|
|
* underlying model
|
|
* @return true if the column is sortable
|
|
* @throws IndexOutOfBoundsException if column is outside
|
|
* the range of the underlying model
|
|
*/
|
|
public boolean isSortable(int column) {
|
|
checkColumn(column);
|
|
return (isSortable == null) ? true : isSortable[column];
|
|
}
|
|
|
|
/**
|
|
* Sets the sort keys. This creates a copy of the supplied
|
|
* {@code List}; subsequent changes to the supplied
|
|
* {@code List} do not effect this {@code DefaultRowSorter}.
|
|
* If the sort keys have changed this triggers a sort.
|
|
*
|
|
* @param sortKeys the new <code>SortKeys</code>; <code>null</code>
|
|
* is a shorthand for specifying an empty list,
|
|
* indicating that the view should be unsorted
|
|
* @throws IllegalArgumentException if any of the values in
|
|
* <code>sortKeys</code> are null or have a column index outside
|
|
* the range of the model
|
|
*/
|
|
public void setSortKeys(List<? extends SortKey> sortKeys) {
|
|
List<SortKey> old = this.sortKeys;
|
|
if (sortKeys != null && sortKeys.size() > 0) {
|
|
int max = getModelWrapper().getColumnCount();
|
|
for (SortKey key : sortKeys) {
|
|
if (key == null || key.getColumn() < 0 ||
|
|
key.getColumn() >= max) {
|
|
throw new IllegalArgumentException("Invalid SortKey");
|
|
}
|
|
}
|
|
this.sortKeys = Collections.unmodifiableList(
|
|
new ArrayList<SortKey>(sortKeys));
|
|
}
|
|
else {
|
|
this.sortKeys = Collections.emptyList();
|
|
}
|
|
if (!this.sortKeys.equals(old)) {
|
|
fireSortOrderChanged();
|
|
if (viewToModel == null) {
|
|
// Currently unsorted, use sort so that internal fields
|
|
// are correctly set.
|
|
sort();
|
|
} else {
|
|
sortExistingData();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the current sort keys. This returns an unmodifiable
|
|
* {@code non-null List}. If you need to change the sort keys,
|
|
* make a copy of the returned {@code List}, mutate the copy
|
|
* and invoke {@code setSortKeys} with the new list.
|
|
*
|
|
* @return the current sort order
|
|
*/
|
|
public List<? extends SortKey> getSortKeys() {
|
|
return sortKeys;
|
|
}
|
|
|
|
/**
|
|
* Sets the maximum number of sort keys. The number of sort keys
|
|
* determines how equal values are resolved when sorting. For
|
|
* example, assume a table row sorter is created and
|
|
* <code>setMaxSortKeys(2)</code> is invoked on it. The user
|
|
* clicks the header for column 1, causing the table rows to be
|
|
* sorted based on the items in column 1. Next, the user clicks
|
|
* the header for column 2, causing the table to be sorted based
|
|
* on the items in column 2; if any items in column 2 are equal,
|
|
* then those particular rows are ordered based on the items in
|
|
* column 1. In this case, we say that the rows are primarily
|
|
* sorted on column 2, and secondarily on column 1. If the user
|
|
* then clicks the header for column 3, then the items are
|
|
* primarily sorted on column 3 and secondarily sorted on column
|
|
* 2. Because the maximum number of sort keys has been set to 2
|
|
* with <code>setMaxSortKeys</code>, column 1 no longer has an
|
|
* effect on the order.
|
|
* <p>
|
|
* The maximum number of sort keys is enforced by
|
|
* <code>toggleSortOrder</code>. You can specify more sort
|
|
* keys by invoking <code>setSortKeys</code> directly and they will
|
|
* all be honored. However if <code>toggleSortOrder</code> is subsequently
|
|
* invoked the maximum number of sort keys will be enforced.
|
|
* The default value is 3.
|
|
*
|
|
* @param max the maximum number of sort keys
|
|
* @throws IllegalArgumentException if <code>max</code> < 1
|
|
*/
|
|
public void setMaxSortKeys(int max) {
|
|
if (max < 1) {
|
|
throw new IllegalArgumentException("Invalid max");
|
|
}
|
|
maxSortKeys = max;
|
|
}
|
|
|
|
/**
|
|
* Returns the maximum number of sort keys.
|
|
*
|
|
* @return the maximum number of sort keys
|
|
*/
|
|
public int getMaxSortKeys() {
|
|
return maxSortKeys;
|
|
}
|
|
|
|
/**
|
|
* If true, specifies that a sort should happen when the underlying
|
|
* model is updated (<code>rowsUpdated</code> is invoked). For
|
|
* example, if this is true and the user edits an entry the
|
|
* location of that item in the view may change. The default is
|
|
* false.
|
|
*
|
|
* @param sortsOnUpdates whether or not to sort on update events
|
|
*/
|
|
public void setSortsOnUpdates(boolean sortsOnUpdates) {
|
|
this.sortsOnUpdates = sortsOnUpdates;
|
|
}
|
|
|
|
/**
|
|
* Returns true if a sort should happen when the underlying
|
|
* model is updated; otherwise, returns false.
|
|
*
|
|
* @return whether or not to sort when the model is updated
|
|
*/
|
|
public boolean getSortsOnUpdates() {
|
|
return sortsOnUpdates;
|
|
}
|
|
|
|
/**
|
|
* Sets the filter that determines which rows, if any, should be
|
|
* hidden from the view. The filter is applied before sorting. A value
|
|
* of <code>null</code> indicates all values from the model should be
|
|
* included.
|
|
* <p>
|
|
* <code>RowFilter</code>'s <code>include</code> method is passed an
|
|
* <code>Entry</code> that wraps the underlying model. The number
|
|
* of columns in the <code>Entry</code> corresponds to the
|
|
* number of columns in the <code>ModelWrapper</code>. The identifier
|
|
* comes from the <code>ModelWrapper</code> as well.
|
|
* <p>
|
|
* This method triggers a sort.
|
|
*
|
|
* @param filter the filter used to determine what entries should be
|
|
* included
|
|
*/
|
|
public void setRowFilter(RowFilter<? super M,? super I> filter) {
|
|
this.filter = filter;
|
|
sort();
|
|
}
|
|
|
|
/**
|
|
* Returns the filter that determines which rows, if any, should
|
|
* be hidden from view.
|
|
*
|
|
* @return the filter
|
|
*/
|
|
public RowFilter<? super M,? super I> getRowFilter() {
|
|
return filter;
|
|
}
|
|
|
|
/**
|
|
* Reverses the sort order from ascending to descending (or
|
|
* descending to ascending) if the specified column is already the
|
|
* primary sorted column; otherwise, makes the specified column
|
|
* the primary sorted column, with an ascending sort order. If
|
|
* the specified column is not sortable, this method has no
|
|
* effect.
|
|
*
|
|
* @param column index of the column to make the primary sorted column,
|
|
* in terms of the underlying model
|
|
* @throws IndexOutOfBoundsException {@inheritDoc}
|
|
* @see #setSortable(int,boolean)
|
|
* @see #setMaxSortKeys(int)
|
|
*/
|
|
public void toggleSortOrder(int column) {
|
|
checkColumn(column);
|
|
if (isSortable(column)) {
|
|
List<SortKey> keys = new ArrayList<SortKey>(getSortKeys());
|
|
SortKey sortKey;
|
|
int sortIndex;
|
|
for (sortIndex = keys.size() - 1; sortIndex >= 0; sortIndex--) {
|
|
if (keys.get(sortIndex).getColumn() == column) {
|
|
break;
|
|
}
|
|
}
|
|
if (sortIndex == -1) {
|
|
// Key doesn't exist
|
|
sortKey = new SortKey(column, SortOrder.ASCENDING);
|
|
keys.add(0, sortKey);
|
|
}
|
|
else if (sortIndex == 0) {
|
|
// It's the primary sorting key, toggle it
|
|
keys.set(0, toggle(keys.get(0)));
|
|
}
|
|
else {
|
|
// It's not the first, but was sorted on, remove old
|
|
// entry, insert as first with ascending.
|
|
keys.remove(sortIndex);
|
|
keys.add(0, new SortKey(column, SortOrder.ASCENDING));
|
|
}
|
|
if (keys.size() > getMaxSortKeys()) {
|
|
keys = keys.subList(0, getMaxSortKeys());
|
|
}
|
|
setSortKeys(keys);
|
|
}
|
|
}
|
|
|
|
private SortKey toggle(SortKey key) {
|
|
if (key.getSortOrder() == SortOrder.ASCENDING) {
|
|
return new SortKey(key.getColumn(), SortOrder.DESCENDING);
|
|
}
|
|
return new SortKey(key.getColumn(), SortOrder.ASCENDING);
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*
|
|
* @throws IndexOutOfBoundsException {@inheritDoc}
|
|
*/
|
|
public int convertRowIndexToView(int index) {
|
|
if (modelToView == null) {
|
|
if (index < 0 || index >= getModelWrapper().getRowCount()) {
|
|
throw new IndexOutOfBoundsException("Invalid index");
|
|
}
|
|
return index;
|
|
}
|
|
return modelToView[index];
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*
|
|
* @throws IndexOutOfBoundsException {@inheritDoc}
|
|
*/
|
|
public int convertRowIndexToModel(int index) {
|
|
if (viewToModel == null) {
|
|
if (index < 0 || index >= getModelWrapper().getRowCount()) {
|
|
throw new IndexOutOfBoundsException("Invalid index");
|
|
}
|
|
return index;
|
|
}
|
|
return viewToModel[index].modelIndex;
|
|
}
|
|
|
|
private boolean isUnsorted() {
|
|
List<? extends SortKey> keys = getSortKeys();
|
|
int keySize = keys.size();
|
|
return (keySize == 0 || keys.get(0).getSortOrder() ==
|
|
SortOrder.UNSORTED);
|
|
}
|
|
|
|
/**
|
|
* Sorts the existing filtered data. This should only be used if
|
|
* the filter hasn't changed.
|
|
*/
|
|
private void sortExistingData() {
|
|
int[] lastViewToModel = getViewToModelAsInts(viewToModel);
|
|
|
|
updateUseToString();
|
|
cacheSortKeys(getSortKeys());
|
|
|
|
if (isUnsorted()) {
|
|
if (getRowFilter() == null) {
|
|
viewToModel = null;
|
|
modelToView = null;
|
|
} else {
|
|
int included = 0;
|
|
for (int i = 0; i < modelToView.length; i++) {
|
|
if (modelToView[i] != -1) {
|
|
viewToModel[included].modelIndex = i;
|
|
modelToView[i] = included++;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// sort the data
|
|
Arrays.sort(viewToModel);
|
|
|
|
// Update the modelToView array
|
|
setModelToViewFromViewToModel(false);
|
|
}
|
|
fireRowSorterChanged(lastViewToModel);
|
|
}
|
|
|
|
/**
|
|
* Sorts and filters the rows in the view based on the sort keys
|
|
* of the columns currently being sorted and the filter, if any,
|
|
* associated with this sorter. An empty <code>sortKeys</code> list
|
|
* indicates that the view should unsorted, the same as the model.
|
|
*
|
|
* @see #setRowFilter
|
|
* @see #setSortKeys
|
|
*/
|
|
public void sort() {
|
|
sorted = true;
|
|
int[] lastViewToModel = getViewToModelAsInts(viewToModel);
|
|
updateUseToString();
|
|
if (isUnsorted()) {
|
|
// Unsorted
|
|
cachedSortKeys = new SortKey[0];
|
|
if (getRowFilter() == null) {
|
|
// No filter & unsorted
|
|
if (viewToModel != null) {
|
|
// sorted -> unsorted
|
|
viewToModel = null;
|
|
modelToView = null;
|
|
}
|
|
else {
|
|
// unsorted -> unsorted
|
|
// No need to do anything.
|
|
return;
|
|
}
|
|
}
|
|
else {
|
|
// There is filter, reset mappings
|
|
initializeFilteredMapping();
|
|
}
|
|
}
|
|
else {
|
|
cacheSortKeys(getSortKeys());
|
|
|
|
if (getRowFilter() != null) {
|
|
initializeFilteredMapping();
|
|
}
|
|
else {
|
|
createModelToView(getModelWrapper().getRowCount());
|
|
createViewToModel(getModelWrapper().getRowCount());
|
|
}
|
|
|
|
// sort them
|
|
Arrays.sort(viewToModel);
|
|
|
|
// Update the modelToView array
|
|
setModelToViewFromViewToModel(false);
|
|
}
|
|
fireRowSorterChanged(lastViewToModel);
|
|
}
|
|
|
|
/**
|
|
* Updates the useToString mapping before a sort.
|
|
*/
|
|
private void updateUseToString() {
|
|
int i = getModelWrapper().getColumnCount();
|
|
if (useToString == null || useToString.length != i) {
|
|
useToString = new boolean[i];
|
|
}
|
|
for (--i; i >= 0; i--) {
|
|
useToString[i] = useToString(i);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resets the viewToModel and modelToView mappings based on
|
|
* the current Filter.
|
|
*/
|
|
private void initializeFilteredMapping() {
|
|
int rowCount = getModelWrapper().getRowCount();
|
|
int i, j;
|
|
int excludedCount = 0;
|
|
|
|
// Update model -> view
|
|
createModelToView(rowCount);
|
|
for (i = 0; i < rowCount; i++) {
|
|
if (include(i)) {
|
|
modelToView[i] = i - excludedCount;
|
|
}
|
|
else {
|
|
modelToView[i] = -1;
|
|
excludedCount++;
|
|
}
|
|
}
|
|
|
|
// Update view -> model
|
|
createViewToModel(rowCount - excludedCount);
|
|
for (i = 0, j = 0; i < rowCount; i++) {
|
|
if (modelToView[i] != -1) {
|
|
viewToModel[j++].modelIndex = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Makes sure the modelToView array is of size rowCount.
|
|
*/
|
|
private void createModelToView(int rowCount) {
|
|
if (modelToView == null || modelToView.length != rowCount) {
|
|
modelToView = new int[rowCount];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resets the viewToModel array to be of size rowCount.
|
|
*/
|
|
private void createViewToModel(int rowCount) {
|
|
int recreateFrom = 0;
|
|
if (viewToModel != null) {
|
|
recreateFrom = Math.min(rowCount, viewToModel.length);
|
|
if (viewToModel.length != rowCount) {
|
|
Row[] oldViewToModel = viewToModel;
|
|
viewToModel = new Row[rowCount];
|
|
System.arraycopy(oldViewToModel, 0, viewToModel,
|
|
0, recreateFrom);
|
|
}
|
|
}
|
|
else {
|
|
viewToModel = new Row[rowCount];
|
|
}
|
|
int i;
|
|
for (i = 0; i < recreateFrom; i++) {
|
|
viewToModel[i].modelIndex = i;
|
|
}
|
|
for (i = recreateFrom; i < rowCount; i++) {
|
|
viewToModel[i] = new Row(this, i);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Caches the sort keys before a sort.
|
|
*/
|
|
private void cacheSortKeys(List<? extends SortKey> keys) {
|
|
int keySize = keys.size();
|
|
sortComparators = new Comparator[keySize];
|
|
for (int i = 0; i < keySize; i++) {
|
|
sortComparators[i] = getComparator0(keys.get(i).getColumn());
|
|
}
|
|
cachedSortKeys = keys.toArray(new SortKey[keySize]);
|
|
}
|
|
|
|
/**
|
|
* Returns whether or not to convert the value to a string before
|
|
* doing comparisons when sorting. If true
|
|
* <code>ModelWrapper.getStringValueAt</code> will be used, otherwise
|
|
* <code>ModelWrapper.getValueAt</code> will be used. It is up to
|
|
* subclasses, such as <code>TableRowSorter</code>, to honor this value
|
|
* in their <code>ModelWrapper</code> implementation.
|
|
*
|
|
* @param column the index of the column to test, in terms of the
|
|
* underlying model
|
|
* @throws IndexOutOfBoundsException if <code>column</code> is not valid
|
|
*/
|
|
protected boolean useToString(int column) {
|
|
return (getComparator(column) == null);
|
|
}
|
|
|
|
/**
|
|
* Refreshes the modelToView mapping from that of viewToModel.
|
|
* If <code>unsetFirst</code> is true, all indices in modelToView are
|
|
* first set to -1.
|
|
*/
|
|
private void setModelToViewFromViewToModel(boolean unsetFirst) {
|
|
int i;
|
|
if (unsetFirst) {
|
|
for (i = modelToView.length - 1; i >= 0; i--) {
|
|
modelToView[i] = -1;
|
|
}
|
|
}
|
|
for (i = viewToModel.length - 1; i >= 0; i--) {
|
|
modelToView[viewToModel[i].modelIndex] = i;
|
|
}
|
|
}
|
|
|
|
private int[] getViewToModelAsInts(Row[] viewToModel) {
|
|
if (viewToModel != null) {
|
|
int[] viewToModelI = new int[viewToModel.length];
|
|
for (int i = viewToModel.length - 1; i >= 0; i--) {
|
|
viewToModelI[i] = viewToModel[i].modelIndex;
|
|
}
|
|
return viewToModelI;
|
|
}
|
|
return new int[0];
|
|
}
|
|
|
|
/**
|
|
* Sets the <code>Comparator</code> to use when sorting the specified
|
|
* column. This does not trigger a sort. If you want to sort after
|
|
* setting the comparator you need to explicitly invoke <code>sort</code>.
|
|
*
|
|
* @param column the index of the column the <code>Comparator</code> is
|
|
* to be used for, in terms of the underlying model
|
|
* @param comparator the <code>Comparator</code> to use
|
|
* @throws IndexOutOfBoundsException if <code>column</code> is outside
|
|
* the range of the underlying model
|
|
*/
|
|
public void setComparator(int column, Comparator<?> comparator) {
|
|
checkColumn(column);
|
|
if (comparators == null) {
|
|
comparators = new Comparator[getModelWrapper().getColumnCount()];
|
|
}
|
|
comparators[column] = comparator;
|
|
}
|
|
|
|
/**
|
|
* Returns the <code>Comparator</code> for the specified
|
|
* column. This will return <code>null</code> if a <code>Comparator</code>
|
|
* has not been specified for the column.
|
|
*
|
|
* @param column the column to fetch the <code>Comparator</code> for, in
|
|
* terms of the underlying model
|
|
* @return the <code>Comparator</code> for the specified column
|
|
* @throws IndexOutOfBoundsException if column is outside
|
|
* the range of the underlying model
|
|
*/
|
|
public Comparator<?> getComparator(int column) {
|
|
checkColumn(column);
|
|
if (comparators != null) {
|
|
return comparators[column];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Returns the Comparator to use during sorting. Where as
|
|
// getComparator() may return null, this will never return null.
|
|
private Comparator getComparator0(int column) {
|
|
Comparator comparator = getComparator(column);
|
|
if (comparator != null) {
|
|
return comparator;
|
|
}
|
|
// This should be ok as useToString(column) should have returned
|
|
// true in this case.
|
|
return Collator.getInstance();
|
|
}
|
|
|
|
private RowFilter.Entry<M,I> getFilterEntry(int modelIndex) {
|
|
if (filterEntry == null) {
|
|
filterEntry = new FilterEntry();
|
|
}
|
|
filterEntry.modelIndex = modelIndex;
|
|
return filterEntry;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public int getViewRowCount() {
|
|
if (viewToModel != null) {
|
|
// When filtering this may differ from getModelWrapper().getRowCount()
|
|
return viewToModel.length;
|
|
}
|
|
return getModelWrapper().getRowCount();
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public int getModelRowCount() {
|
|
return getModelWrapper().getRowCount();
|
|
}
|
|
|
|
private void allChanged() {
|
|
modelToView = null;
|
|
viewToModel = null;
|
|
comparators = null;
|
|
isSortable = null;
|
|
if (isUnsorted()) {
|
|
// Keys are already empty, to force a resort we have to
|
|
// call sort
|
|
sort();
|
|
} else {
|
|
setSortKeys(null);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public void modelStructureChanged() {
|
|
allChanged();
|
|
modelRowCount = getModelWrapper().getRowCount();
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public void allRowsChanged() {
|
|
modelRowCount = getModelWrapper().getRowCount();
|
|
sort();
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*
|
|
* @throws IndexOutOfBoundsException {@inheritDoc}
|
|
*/
|
|
public void rowsInserted(int firstRow, int endRow) {
|
|
checkAgainstModel(firstRow, endRow);
|
|
int newModelRowCount = getModelWrapper().getRowCount();
|
|
if (endRow >= newModelRowCount) {
|
|
throw new IndexOutOfBoundsException("Invalid range");
|
|
}
|
|
modelRowCount = newModelRowCount;
|
|
if (shouldOptimizeChange(firstRow, endRow)) {
|
|
rowsInserted0(firstRow, endRow);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*
|
|
* @throws IndexOutOfBoundsException {@inheritDoc}
|
|
*/
|
|
public void rowsDeleted(int firstRow, int endRow) {
|
|
checkAgainstModel(firstRow, endRow);
|
|
if (firstRow >= modelRowCount || endRow >= modelRowCount) {
|
|
throw new IndexOutOfBoundsException("Invalid range");
|
|
}
|
|
modelRowCount = getModelWrapper().getRowCount();
|
|
if (shouldOptimizeChange(firstRow, endRow)) {
|
|
rowsDeleted0(firstRow, endRow);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*
|
|
* @throws IndexOutOfBoundsException {@inheritDoc}
|
|
*/
|
|
public void rowsUpdated(int firstRow, int endRow) {
|
|
checkAgainstModel(firstRow, endRow);
|
|
if (firstRow >= modelRowCount || endRow >= modelRowCount) {
|
|
throw new IndexOutOfBoundsException("Invalid range");
|
|
}
|
|
if (getSortsOnUpdates()) {
|
|
if (shouldOptimizeChange(firstRow, endRow)) {
|
|
rowsUpdated0(firstRow, endRow);
|
|
}
|
|
}
|
|
else {
|
|
sorted = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*
|
|
* @throws IndexOutOfBoundsException {@inheritDoc}
|
|
*/
|
|
public void rowsUpdated(int firstRow, int endRow, int column) {
|
|
checkColumn(column);
|
|
rowsUpdated(firstRow, endRow);
|
|
}
|
|
|
|
private void checkAgainstModel(int firstRow, int endRow) {
|
|
if (firstRow > endRow || firstRow < 0 || endRow < 0 ||
|
|
firstRow > modelRowCount) {
|
|
throw new IndexOutOfBoundsException("Invalid range");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the specified row should be included.
|
|
*/
|
|
private boolean include(int row) {
|
|
RowFilter<? super M, ? super I> filter = getRowFilter();
|
|
if (filter != null) {
|
|
return filter.include(getFilterEntry(row));
|
|
}
|
|
// null filter, always include the row.
|
|
return true;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private int compare(int model1, int model2) {
|
|
int column;
|
|
SortOrder sortOrder;
|
|
Object v1, v2;
|
|
int result;
|
|
|
|
for (int counter = 0; counter < cachedSortKeys.length; counter++) {
|
|
column = cachedSortKeys[counter].getColumn();
|
|
sortOrder = cachedSortKeys[counter].getSortOrder();
|
|
if (sortOrder == SortOrder.UNSORTED) {
|
|
result = model1 - model2;
|
|
} else {
|
|
// v1 != null && v2 != null
|
|
if (useToString[column]) {
|
|
v1 = getModelWrapper().getStringValueAt(model1, column);
|
|
v2 = getModelWrapper().getStringValueAt(model2, column);
|
|
} else {
|
|
v1 = getModelWrapper().getValueAt(model1, column);
|
|
v2 = getModelWrapper().getValueAt(model2, column);
|
|
}
|
|
// Treat nulls as < then non-null
|
|
if (v1 == null) {
|
|
if (v2 == null) {
|
|
result = 0;
|
|
} else {
|
|
result = -1;
|
|
}
|
|
} else if (v2 == null) {
|
|
result = 1;
|
|
} else {
|
|
result = sortComparators[counter].compare(v1, v2);
|
|
}
|
|
if (sortOrder == SortOrder.DESCENDING) {
|
|
result *= -1;
|
|
}
|
|
}
|
|
if (result != 0) {
|
|
return result;
|
|
}
|
|
}
|
|
// If we get here, they're equal. Fallback to model order.
|
|
return model1 - model2;
|
|
}
|
|
|
|
/**
|
|
* Whether not we are filtering/sorting.
|
|
*/
|
|
private boolean isTransformed() {
|
|
return (viewToModel != null);
|
|
}
|
|
|
|
/**
|
|
* Insets new set of entries.
|
|
*
|
|
* @param toAdd the Rows to add, sorted
|
|
* @param current the array to insert the items into
|
|
*/
|
|
private void insertInOrder(List<Row> toAdd, Row[] current) {
|
|
int last = 0;
|
|
int index;
|
|
int max = toAdd.size();
|
|
for (int i = 0; i < max; i++) {
|
|
index = Arrays.binarySearch(current, toAdd.get(i));
|
|
if (index < 0) {
|
|
index = -1 - index;
|
|
}
|
|
System.arraycopy(current, last,
|
|
viewToModel, last + i, index - last);
|
|
viewToModel[index + i] = toAdd.get(i);
|
|
last = index;
|
|
}
|
|
System.arraycopy(current, last, viewToModel, last + max,
|
|
current.length - last);
|
|
}
|
|
|
|
/**
|
|
* Returns true if we should try and optimize the processing of the
|
|
* <code>TableModelEvent</code>. If this returns false, assume the
|
|
* event was dealt with and no further processing needs to happen.
|
|
*/
|
|
private boolean shouldOptimizeChange(int firstRow, int lastRow) {
|
|
if (!isTransformed()) {
|
|
// Not transformed, nothing to do.
|
|
return false;
|
|
}
|
|
if (!sorted || (lastRow - firstRow) > viewToModel.length / 10) {
|
|
// We either weren't sorted, or to much changed, sort it all
|
|
sort();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void rowsInserted0(int firstRow, int lastRow) {
|
|
int[] oldViewToModel = getViewToModelAsInts(viewToModel);
|
|
int i;
|
|
int delta = (lastRow - firstRow) + 1;
|
|
List<Row> added = new ArrayList<Row>(delta);
|
|
|
|
// Build the list of Rows to add into added
|
|
for (i = firstRow; i <= lastRow; i++) {
|
|
if (include(i)) {
|
|
added.add(new Row(this, i));
|
|
}
|
|
}
|
|
|
|
// Adjust the model index of rows after the effected region
|
|
int viewIndex;
|
|
for (i = modelToView.length - 1; i >= firstRow; i--) {
|
|
viewIndex = modelToView[i];
|
|
if (viewIndex != -1) {
|
|
viewToModel[viewIndex].modelIndex += delta;
|
|
}
|
|
}
|
|
|
|
// Insert newly added rows into viewToModel
|
|
if (added.size() > 0) {
|
|
Collections.sort(added);
|
|
Row[] lastViewToModel = viewToModel;
|
|
viewToModel = new Row[viewToModel.length + added.size()];
|
|
insertInOrder(added, lastViewToModel);
|
|
}
|
|
|
|
// Update modelToView
|
|
createModelToView(getModelWrapper().getRowCount());
|
|
setModelToViewFromViewToModel(true);
|
|
|
|
// Notify of change
|
|
fireRowSorterChanged(oldViewToModel);
|
|
}
|
|
|
|
private void rowsDeleted0(int firstRow, int lastRow) {
|
|
int[] oldViewToModel = getViewToModelAsInts(viewToModel);
|
|
int removedFromView = 0;
|
|
int i;
|
|
int viewIndex;
|
|
|
|
// Figure out how many visible rows are going to be effected.
|
|
for (i = firstRow; i <= lastRow; i++) {
|
|
viewIndex = modelToView[i];
|
|
if (viewIndex != -1) {
|
|
removedFromView++;
|
|
viewToModel[viewIndex] = null;
|
|
}
|
|
}
|
|
|
|
// Update the model index of rows after the effected region
|
|
int delta = lastRow - firstRow + 1;
|
|
for (i = modelToView.length - 1; i > lastRow; i--) {
|
|
viewIndex = modelToView[i];
|
|
if (viewIndex != -1) {
|
|
viewToModel[viewIndex].modelIndex -= delta;
|
|
}
|
|
}
|
|
|
|
// Then patch up the viewToModel array
|
|
if (removedFromView > 0) {
|
|
Row[] newViewToModel = new Row[viewToModel.length -
|
|
removedFromView];
|
|
int newIndex = 0;
|
|
int last = 0;
|
|
for (i = 0; i < viewToModel.length; i++) {
|
|
if (viewToModel[i] == null) {
|
|
System.arraycopy(viewToModel, last,
|
|
newViewToModel, newIndex, i - last);
|
|
newIndex += (i - last);
|
|
last = i + 1;
|
|
}
|
|
}
|
|
System.arraycopy(viewToModel, last,
|
|
newViewToModel, newIndex, viewToModel.length - last);
|
|
viewToModel = newViewToModel;
|
|
}
|
|
|
|
// Update the modelToView mapping
|
|
createModelToView(getModelWrapper().getRowCount());
|
|
setModelToViewFromViewToModel(true);
|
|
|
|
// And notify of change
|
|
fireRowSorterChanged(oldViewToModel);
|
|
}
|
|
|
|
private void rowsUpdated0(int firstRow, int lastRow) {
|
|
int[] oldViewToModel = getViewToModelAsInts(viewToModel);
|
|
int i, j;
|
|
int delta = lastRow - firstRow + 1;
|
|
int modelIndex;
|
|
int last;
|
|
int index;
|
|
|
|
if (getRowFilter() == null) {
|
|
// Sorting only:
|
|
|
|
// Remove the effected rows
|
|
Row[] updated = new Row[delta];
|
|
for (j = 0, i = firstRow; i <= lastRow; i++, j++) {
|
|
updated[j] = viewToModel[modelToView[i]];
|
|
}
|
|
|
|
// Sort the update rows
|
|
Arrays.sort(updated);
|
|
|
|
// Build the intermediary array: the array of
|
|
// viewToModel without the effected rows.
|
|
Row[] intermediary = new Row[viewToModel.length - delta];
|
|
for (i = 0, j = 0; i < viewToModel.length; i++) {
|
|
modelIndex = viewToModel[i].modelIndex;
|
|
if (modelIndex < firstRow || modelIndex > lastRow) {
|
|
intermediary[j++] = viewToModel[i];
|
|
}
|
|
}
|
|
|
|
// Build the new viewToModel
|
|
insertInOrder(Arrays.asList(updated), intermediary);
|
|
|
|
// Update modelToView
|
|
setModelToViewFromViewToModel(false);
|
|
}
|
|
else {
|
|
// Sorting & filtering.
|
|
|
|
// Remove the effected rows, adding them to updated and setting
|
|
// modelToView to -2 for any rows that were not filtered out
|
|
List<Row> updated = new ArrayList<Row>(delta);
|
|
int newlyVisible = 0;
|
|
int newlyHidden = 0;
|
|
int effected = 0;
|
|
for (i = firstRow; i <= lastRow; i++) {
|
|
if (modelToView[i] == -1) {
|
|
// This row was filtered out
|
|
if (include(i)) {
|
|
// No longer filtered
|
|
updated.add(new Row(this, i));
|
|
newlyVisible++;
|
|
}
|
|
}
|
|
else {
|
|
// This row was visible, make sure it should still be
|
|
// visible.
|
|
if (!include(i)) {
|
|
newlyHidden++;
|
|
}
|
|
else {
|
|
updated.add(viewToModel[modelToView[i]]);
|
|
}
|
|
modelToView[i] = -2;
|
|
effected++;
|
|
}
|
|
}
|
|
|
|
// Sort the updated rows
|
|
Collections.sort(updated);
|
|
|
|
// Build the intermediary array: the array of
|
|
// viewToModel without the updated rows.
|
|
Row[] intermediary = new Row[viewToModel.length - effected];
|
|
for (i = 0, j = 0; i < viewToModel.length; i++) {
|
|
modelIndex = viewToModel[i].modelIndex;
|
|
if (modelToView[modelIndex] != -2) {
|
|
intermediary[j++] = viewToModel[i];
|
|
}
|
|
}
|
|
|
|
// Recreate viewToModel, if necessary
|
|
if (newlyVisible != newlyHidden) {
|
|
viewToModel = new Row[viewToModel.length + newlyVisible -
|
|
newlyHidden];
|
|
}
|
|
|
|
// Rebuild the new viewToModel array
|
|
insertInOrder(updated, intermediary);
|
|
|
|
// Update modelToView
|
|
setModelToViewFromViewToModel(true);
|
|
}
|
|
// And finally fire a sort event.
|
|
fireRowSorterChanged(oldViewToModel);
|
|
}
|
|
|
|
private void checkColumn(int column) {
|
|
if (column < 0 || column >= getModelWrapper().getColumnCount()) {
|
|
throw new IndexOutOfBoundsException(
|
|
"column beyond range of TableModel");
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* <code>DefaultRowSorter.ModelWrapper</code> is responsible for providing
|
|
* the data that gets sorted by <code>DefaultRowSorter</code>. You
|
|
* normally do not interact directly with <code>ModelWrapper</code>.
|
|
* Subclasses of <code>DefaultRowSorter</code> provide an
|
|
* implementation of <code>ModelWrapper</code> wrapping another model.
|
|
* For example,
|
|
* <code>TableRowSorter</code> provides a <code>ModelWrapper</code> that
|
|
* wraps a <code>TableModel</code>.
|
|
* <p>
|
|
* <code>ModelWrapper</code> makes a distinction between values as
|
|
* <code>Object</code>s and <code>String</code>s. This allows
|
|
* implementations to provide a custom string
|
|
* converter to be used instead of invoking <code>toString</code> on the
|
|
* object.
|
|
*
|
|
* @param <M> the type of the underlying model
|
|
* @param <I> the identifier supplied to the filter
|
|
* @since 1.6
|
|
* @see RowFilter
|
|
* @see RowFilter.Entry
|
|
*/
|
|
protected abstract static class ModelWrapper<M,I> {
|
|
/**
|
|
* Creates a new <code>ModelWrapper</code>.
|
|
*/
|
|
protected ModelWrapper() {
|
|
}
|
|
|
|
/**
|
|
* Returns the underlying model that this <code>Model</code> is
|
|
* wrapping.
|
|
*
|
|
* @return the underlying model
|
|
*/
|
|
public abstract M getModel();
|
|
|
|
/**
|
|
* Returns the number of columns in the model.
|
|
*
|
|
* @return the number of columns in the model
|
|
*/
|
|
public abstract int getColumnCount();
|
|
|
|
/**
|
|
* Returns the number of rows in the model.
|
|
*
|
|
* @return the number of rows in the model
|
|
*/
|
|
public abstract int getRowCount();
|
|
|
|
/**
|
|
* Returns the value at the specified index.
|
|
*
|
|
* @param row the row index
|
|
* @param column the column index
|
|
* @return the value at the specified index
|
|
* @throws IndexOutOfBoundsException if the indices are outside
|
|
* the range of the model
|
|
*/
|
|
public abstract Object getValueAt(int row, int column);
|
|
|
|
/**
|
|
* Returns the value as a <code>String</code> at the specified
|
|
* index. This implementation uses <code>toString</code> on
|
|
* the result from <code>getValueAt</code> (making sure
|
|
* to return an empty string for null values). Subclasses that
|
|
* override this method should never return null.
|
|
*
|
|
* @param row the row index
|
|
* @param column the column index
|
|
* @return the value at the specified index as a <code>String</code>
|
|
* @throws IndexOutOfBoundsException if the indices are outside
|
|
* the range of the model
|
|
*/
|
|
public String getStringValueAt(int row, int column) {
|
|
Object o = getValueAt(row, column);
|
|
if (o == null) {
|
|
return "";
|
|
}
|
|
String string = o.toString();
|
|
if (string == null) {
|
|
return "";
|
|
}
|
|
return string;
|
|
}
|
|
|
|
/**
|
|
* Returns the identifier for the specified row. The return value
|
|
* of this is used as the identifier for the
|
|
* <code>RowFilter.Entry</code> that is passed to the
|
|
* <code>RowFilter</code>.
|
|
*
|
|
* @param row the row to return the identifier for, in terms of
|
|
* the underlying model
|
|
* @return the identifier
|
|
* @see RowFilter.Entry#getIdentifier
|
|
*/
|
|
public abstract I getIdentifier(int row);
|
|
}
|
|
|
|
|
|
/**
|
|
* RowFilter.Entry implementation that delegates to the ModelWrapper.
|
|
* getFilterEntry(int) creates the single instance of this that is
|
|
* passed to the Filter. Only call getFilterEntry(int) to get
|
|
* the instance.
|
|
*/
|
|
private class FilterEntry extends RowFilter.Entry<M,I> {
|
|
/**
|
|
* The index into the model, set in getFilterEntry
|
|
*/
|
|
int modelIndex;
|
|
|
|
public M getModel() {
|
|
return getModelWrapper().getModel();
|
|
}
|
|
|
|
public int getValueCount() {
|
|
return getModelWrapper().getColumnCount();
|
|
}
|
|
|
|
public Object getValue(int index) {
|
|
return getModelWrapper().getValueAt(modelIndex, index);
|
|
}
|
|
|
|
public String getStringValue(int index) {
|
|
return getModelWrapper().getStringValueAt(modelIndex, index);
|
|
}
|
|
|
|
public I getIdentifier() {
|
|
return getModelWrapper().getIdentifier(modelIndex);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Row is used to handle the actual sorting by way of Comparable. It
|
|
* will use the sortKeys to do the actual comparison.
|
|
*/
|
|
// NOTE: this class is static so that it can be placed in an array
|
|
private static class Row implements Comparable<Row> {
|
|
private DefaultRowSorter sorter;
|
|
int modelIndex;
|
|
|
|
public Row(DefaultRowSorter sorter, int index) {
|
|
this.sorter = sorter;
|
|
modelIndex = index;
|
|
}
|
|
|
|
public int compareTo(Row o) {
|
|
return sorter.compare(modelIndex, o.modelIndex);
|
|
}
|
|
}
|
|
}
|