/*
* $Id$
*
* Copyright 2009 Sun Microsystems, Inc., 4150 Network Circle,
* Santa Clara, California 95054, U.S.A. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
package org.jdesktop.swingx.plaf.basic.core;
import javax.swing.DefaultListSelectionModel;
import javax.swing.ListModel;
import javax.swing.ListSelectionModel;
import javax.swing.RowSorter;
import javax.swing.event.ListDataEvent;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.RowSorterEvent;
import javax.swing.event.RowSorterListener;
import org.jdesktop.swingx.JXList;
import org.jdesktop.swingx.SwingXUtilities;
import org.jdesktop.swingx.util.Contract;
//import sun.swing.SwingUtilities2;
/**
* ListSortUI provides support for managing the synchronization between
* RowSorter, SelectionModel and ListModel if a JXList is sortable.<p>
*
* This implementation is an adaption of JTable.SortManager fit to the
* needs of a ListUI. In contrast to JTable tradition, the ui delegate has
* full control about listening to model/selection changes and updating
* the list accordingly. So it's role is that of a helper to the ui-delgate
* (vs. as a helper of the JTable). It's still up to the ListUI itself to
* listen to model/selection and propagate the notification to this class, if
* a sorter is installed, but still do the usual updates (layout, repaint) itself.
* On the other hand, listening to the sorter and updating list state accordingly
* is completely done by this.
*
*/
public final class ListSortUI {
private RowSorter<? extends ListModel> sorter;
private JXList list;
// Selection, in terms of the model. This is lazily created
// as needed.
private ListSelectionModel modelSelection;
private int modelLeadIndex;
// Set to true while in the process of changing the selection.
// If this is true the selection change is ignored.
private boolean syncingSelection;
// Temporary cache of selection, in terms of model. This is only used
// if we don't need the full weight of modelSelection.
private int[] lastModelSelection;
private boolean sorterChanged;
private boolean ignoreSortChange;
private RowSorterListener sorterListener;
/**
* Intanstiates a SortUI on the list which has the given RowSorter.
*
* @param list the list to control, must not be null
* @param sorter the rowSorter of the list, must not be null
* @throws NullPointerException if either the list or the sorter is null
* @throws IllegalStateException if the sorter is not the sorter installed
* on the list
*/
public ListSortUI(JXList list, RowSorter<? extends ListModel> sorter) {
this.sorter = Contract.asNotNull(sorter, "RowSorter must not be null");
this.list = Contract.asNotNull(list, "list must not be null");
if (sorter != list.getRowSorter()) throw
new IllegalStateException("sorter must be same as the one on list");
sorterListener = createRowSorterListener();
sorter.addRowSorterListener(sorterListener);
}
/**
* Disposes any resources used by this SortManager.
* Note: this instance must not be used after dispose!
*/
public void dispose() {
if (sorter != null) {
sorter.removeRowSorterListener(sorterListener);
}
sorter = null;
list = null;
}
//----------------------methods called by listeners
/**
* Called after notification from ListModel.
* @param e the change event from the listModel.
*/
public void modelChanged(ListDataEvent e) {
ModelChange change = new ModelChange(e);
prepareForChange(change);
notifySorter(change);
if (change.type != ListDataEvent.CONTENTS_CHANGED) {
// If the Sorter is unsorted we will not have received
// notification, force treating insert/delete as a change.
sorterChanged = true;
}
processChange(change);
}
/**
* Called after notification from selectionModel.
*
* Invoked when the selection, on the view, has changed.
*/
public void viewSelectionChanged(ListSelectionEvent e) {
if (!syncingSelection && modelSelection != null) {
modelSelection = null;
}
}
/**
* Called after notification from RowSorter.
*
* @param e RowSorter event of type SORTED.
*/
protected void sortedChanged(RowSorterEvent e) {
sorterChanged = true;
if (!ignoreSortChange) {
prepareForChange(e);
processChange(null);
// PENDING Jw: this is fix of 1161-swingx - not updated after setting
// rowFilter
// potentially costly? but how to distinguish a mere sort from a
// filterchanged? (only the latter requires a revalidate)
// first fix had only revalidate/repaint but was not
// good enough, see #1261-swingx - no items visible
// after setting rowFilter
// need to invalidate the cell size cache which might be needed
// even after plain sorting as the indi-sizes are now at different
// positions
list.invalidateCellSizeCache();
}
}
//--------------------- prepare change, that is cache selection if needed
/**
* Invoked when the RowSorter has changed.
* Updates the internal cache of the selection based on the change.
*
* @param sortEvent the notification
* @throws NullPointerException if the given event is null.
*/
private void prepareForChange(RowSorterEvent sortEvent) {
Contract.asNotNull(sortEvent, "sorter event not null");
// sort order changed. If modelSelection is null and filtering
// is enabled we need to cache the selection in terms of the
// underlying model, this will allow us to correctly restore
// the selection even if rows are filtered out.
if (modelSelection == null &&
sorter.getViewRowCount() != sorter.getModelRowCount()) {
modelSelection = new DefaultListSelectionModel();
ListSelectionModel viewSelection = getViewSelectionModel();
int min = viewSelection.getMinSelectionIndex();
int max = viewSelection.getMaxSelectionIndex();
int modelIndex;
for (int viewIndex = min; viewIndex <= max; viewIndex++) {
if (viewSelection.isSelectedIndex(viewIndex)) {
modelIndex = convertRowIndexToModel(
sortEvent, viewIndex);
if (modelIndex != -1) {
modelSelection.addSelectionInterval(
modelIndex, modelIndex);
}
}
}
modelIndex = convertRowIndexToModel(sortEvent,
viewSelection.getLeadSelectionIndex());
SwingXUtilities.setLeadAnchorWithoutSelection(
modelSelection, modelIndex, modelIndex);
} else if (modelSelection == null) {
// Sorting changed, haven't cached selection in terms
// of model and no filtering. Temporarily cache selection.
cacheModelSelection(sortEvent);
}
}
/**
* Invoked when the list model has changed. This is invoked prior to
* notifying the sorter of the change.
* Updates the internal cache of the selection based on the change.
*
* @param change the notification
* @throws NullPointerException if the given event is null.
*/
private void prepareForChange(ModelChange change) {
Contract.asNotNull(change, "table event not null");
if (change.allRowsChanged) {
// All the rows have changed, chuck any cached selection.
modelSelection = null;
} else if (modelSelection != null) {
// Table changed, reflect changes in cached selection model.
switch (change.type) {
case ListDataEvent.INTERVAL_REMOVED:
modelSelection.removeIndexInterval(change.startModelIndex,
change.endModelIndex);
break;
case ListDataEvent.INTERVAL_ADDED:
modelSelection.insertIndexInterval(change.startModelIndex,
change.endModelIndex, true);
break;
default:
break;
}
} else {
// table changed, but haven't cached rows, temporarily
// cache them.
cacheModelSelection(null);
}
}
private void cacheModelSelection(RowSorterEvent sortEvent) {
lastModelSelection = convertSelectionToModel(sortEvent);
modelLeadIndex = convertRowIndexToModel(sortEvent,
getViewSelectionModel().getLeadSelectionIndex());
}
//----------------------- process change, that is restore selection if needed
/**
* Inovked when either the table has changed or the sorter has changed
* and after the sorter has been notified. If necessary this will
* reapply the selection and variable row heights.
*/
private void processChange(ModelChange change) {
if (change != null && change.allRowsChanged) {
allChanged();
getViewSelectionModel().clearSelection();
} else if (sorterChanged) {
restoreSelection(change);
}
}
/**
* Restores the selection from that in terms of the model.
*/
private void restoreSelection(ModelChange change) {
syncingSelection = true;
if (lastModelSelection != null) {
restoreSortingSelection(lastModelSelection,
modelLeadIndex, change);
lastModelSelection = null;
} else if (modelSelection != null) {
ListSelectionModel viewSelection = getViewSelectionModel();
viewSelection.setValueIsAdjusting(true);
viewSelection.clearSelection();
int min = modelSelection.getMinSelectionIndex();
int max = modelSelection.getMaxSelectionIndex();
int viewIndex;
for (int modelIndex = min; modelIndex <= max; modelIndex++) {
if (modelSelection.isSelectedIndex(modelIndex)) {
viewIndex = sorter.convertRowIndexToView(modelIndex);
if (viewIndex != -1) {
viewSelection.addSelectionInterval(viewIndex,
viewIndex);
}
}
}
// Restore the lead
int viewLeadIndex = modelSelection.getLeadSelectionIndex();
if (viewLeadIndex != -1) {
viewLeadIndex = sorter.convertRowIndexToView(viewLeadIndex);
}
SwingXUtilities.setLeadAnchorWithoutSelection(
viewSelection, viewLeadIndex, viewLeadIndex);
viewSelection.setValueIsAdjusting(false);
}
syncingSelection = false;
}
/**
* Restores the selection after a model event/sort order changes.
* All coordinates are in terms of the model.
*/
private void restoreSortingSelection(int[] selection, int lead,
ModelChange change) {
// Convert the selection from model to view
for (int i = selection.length - 1; i >= 0; i--) {
selection[i] = convertRowIndexToView(change, selection[i]);
}
lead = convertRowIndexToView(change, lead);
// Check for the common case of no change in selection for 1 row
if (selection.length == 0 ||
(selection.length == 1 && selection[0] == list.getSelectedIndex())) {
return;
}
ListSelectionModel selectionModel = getViewSelectionModel();
// And apply the new selection
selectionModel.setValueIsAdjusting(true);
selectionModel.clearSelection();
for (int i = selection.length - 1; i >= 0; i--) {
if (selection[i] != -1) {
selectionModel.addSelectionInterval(selection[i],
selection[i]);
}
}
SwingXUtilities.setLeadAnchorWithoutSelection(
selectionModel, lead, lead);
selectionModel.setValueIsAdjusting(false);
}
//------------------- row index conversion methods
/**
* Converts a model index to view index. This is called when the
* sorter or model changes and sorting is enabled.
*
* @param change describes the TableModelEvent that initiated the change;
* will be null if called as the result of a sort
*/
private int convertRowIndexToView(ModelChange change, int modelIndex) {
if (modelIndex < 0) {
return -1;
}
// Contract.asNotNull(change, "change must not be null?");
if (change != null && modelIndex >= change.startModelIndex) {
if (change.type == ListDataEvent.INTERVAL_ADDED) {
if (modelIndex + change.length >= change.modelRowCount) {
return -1;
}
return sorter.convertRowIndexToView(
modelIndex + change.length);
}
else if (change.type == ListDataEvent.INTERVAL_REMOVED) {
if (modelIndex <= change.endModelIndex) {
// deleted
return -1;
}
else {
if (modelIndex - change.length >= change.modelRowCount) {
return -1;
}
return sorter.convertRowIndexToView(
modelIndex - change.length);
}
}
// else, updated
}
if (modelIndex >= sorter.getModelRowCount()) {
return -1;
}
return sorter.convertRowIndexToView(modelIndex);
}
private int convertRowIndexToModel(RowSorterEvent e, int viewIndex) {
// JW: the event is null if the selection is cached in prepareChange
// after model notification. Then the conversion from the
// sorter is still valid as the prepare is called before
// notifying the sorter.
if (e != null) {
if (e.getPreviousRowCount() == 0) {
return viewIndex;
}
// range checking handled by RowSorterEvent
return e.convertPreviousRowIndexToModel(viewIndex);
}
// Make sure the viewIndex is valid
if (viewIndex < 0 || viewIndex >= sorter.getViewRowCount()) {
return -1;
}
return sorter.convertRowIndexToModel(viewIndex);
}
/**
* Converts the selection to model coordinates. This is used when
* the model changes or the sorter changes.
*/
private int[] convertSelectionToModel(RowSorterEvent e) {
int[] selection = list.getSelectedIndices();
for (int i = selection.length - 1; i >= 0; i--) {
selection[i] = convertRowIndexToModel(e, selection[i]);
}
return selection;
}
//------------------
/**
* Notifies the sorter of a change in the underlying model.
*/
private void notifySorter(ModelChange change) {
try {
ignoreSortChange = true;
sorterChanged = false;
if (change.allRowsChanged) {
sorter.allRowsChanged();
} else {
switch (change.type) {
case ListDataEvent.CONTENTS_CHANGED:
sorter.rowsUpdated(change.startModelIndex,
change.endModelIndex);
break;
case ListDataEvent.INTERVAL_ADDED:
sorter.rowsInserted(change.startModelIndex,
change.endModelIndex);
break;
case ListDataEvent.INTERVAL_REMOVED:
sorter.rowsDeleted(change.startModelIndex,
change.endModelIndex);
break;
}
}
} finally {
ignoreSortChange = false;
}
}
private ListSelectionModel getViewSelectionModel() {
return list.getSelectionModel();
}
/**
* Invoked when the underlying model has completely changed.
*/
private void allChanged() {
modelLeadIndex = -1;
modelSelection = null;
}
//------------------- implementing listeners
/**
* Creates and returns a RowSorterListener. This implementation
* calls sortedChanged if the event is of type SORTED.
*
* @return rowSorterListener to install on sorter.
*/
protected RowSorterListener createRowSorterListener() {
RowSorterListener l = new RowSorterListener() {
@Override
public void sorterChanged(RowSorterEvent e) {
if (e.getType() == RowSorterEvent.Type.SORTED) {
sortedChanged(e);
}
}
};
return l;
}
/**
* ModelChange is used when sorting to restore state, it corresponds
* to data from a TableModelEvent. The values are precalculated as
* they are used extensively.<p>
*
* PENDING JW: this is not yet fully adapted to ListDataEvent.
*/
final static class ModelChange {
// JW: if we received a dataChanged, there _is no_ notion
// of end/start/length of change
// Starting index of the change, in terms of the model, -1 if dataChanged
int startModelIndex;
// Ending index of the change, in terms of the model, -1 if dataChanged
int endModelIndex;
// Length of the change (end - start + 1), - 1 if dataChanged
int length;
// Type of change
int type;
// Number of rows in the model
int modelRowCount;
// True if the event indicates all the contents have changed
boolean allRowsChanged;
public ModelChange(ListDataEvent e) {
type = e.getType();
modelRowCount = ((ListModel) e.getSource()).getSize();
startModelIndex = e.getIndex0();
endModelIndex = e.getIndex1();
allRowsChanged = startModelIndex < 0;
length = allRowsChanged ? -1 : endModelIndex - startModelIndex + 1;
}
}
}