The class is organized abstractly as a set of intervals of * integers. Each interval indicates an inclusive range of indices in a * list -- held by some other object and unknown to this class -- which is * considered "selected". There are various accessors for querying and * modifying the set of intervals, with simplified forms accepting a single * index, representing an interval with only one element.
*/ public class DefaultListSelectionModel implements Cloneable, ListSelectionModel, Serializable { private static final long serialVersionUID = -5718799865110415860L; /** The list of ListSelectionListeners subscribed to this selection model. */ protected EventListenerList listenerList = new EventListenerList(); /** * The current list selection mode. Must be one of the numeric constants *SINGLE_SELECTION, SINGLE_INTERVAL_SELECTION
* or MULTIPLE_INTERVAL_SELECTION from {@link
* ListSelectionModel}. The default value is
* MULTIPLE_INTERVAL_SELECTION.
*/
int selectionMode = MULTIPLE_INTERVAL_SELECTION;
/**
* The index of the "lead" of the most recent selection. The lead is the
* second argument in any call to {@link #setSelectionInterval}, {@link
* #addSelectionInterval} or {@link #removeSelectionInterval}. Generally
* the lead refers to the most recent position a user dragged their mouse
* over.
*/
int leadSelectionIndex = -1;
/**
* The index of the "anchor" of the most recent selection. The anchor is
* the first argument in any call to {@link #setSelectionInterval},
* {@link #addSelectionInterval} or {@link
* #removeSelectionInterval}. Generally the anchor refers to the first
* recent position a user clicks when they begin to drag their mouse over
* a list.
*
* @see #getAnchorSelectionIndex
* @see #setAnchorSelectionIndex
*/
int anchorSelectionIndex = -1;
/**
* controls the range of indices provided in any {@link
* ListSelectionEvent} fired by the selectionModel. Let
* [A,L] be the range of indices between {@link
* #anchorSelectionIndex} and {@link #leadSelectionIndex} inclusive, and
* let [i0,i1] be the range of indices changed in a given
* call which generates a {@link ListSelectionEvent}. Then when this
* property is true, the {@link ListSelectionEvent} contains
* the range [A,L] union [i0,i1]; when false it
* will contain only [i0,i1]. The default is
* true.
*
* @see #isLeadAnchorNotificationEnabled
* @see #setLeadAnchorNotificationEnabled
*/
protected boolean leadAnchorNotificationEnabled = true;
/**
* Whether the selection is currently "adjusting". Any {@link
* ListSelectionEvent} events constructed in response to changes in this
* list selection model will have their {@link
* ListSelectionEvent#isAdjusting} field set to this value.
*
* @see #getValueIsAdjusting
* @see #setValueIsAdjusting
*/
boolean valueIsAdjusting = false;
/**
* The current set of "intervals", represented simply by a {@link
* java.util.BitSet}. A set bit indicates a selected index, whereas a
* cleared bit indicates a non-selected index.
*/
BitSet sel = new BitSet();
/**
* A variable to store the previous value of sel.
* Used to make sure we only fireValueChanged when the BitSet
* actually does change.
*/
Object oldSel;
/**
* Whether this call of setLeadSelectionInterval was called locally
* from addSelectionInterval
*/
boolean setLeadCalledFromAdd = false;
/**
* Returns the selection mode, which is one of {@link #SINGLE_SELECTION},
* {@link #SINGLE_INTERVAL_SELECTION} and
* {@link #MULTIPLE_INTERVAL_SELECTION}. The default value is
* {@link #MULTIPLE_INTERVAL_SELECTION}.
*
* @return The selection mode.
*
* @see #setSelectionMode(int)
*/
public int getSelectionMode()
{
return selectionMode;
}
/**
* Sets the value of the {@link #selectionMode} property.
*
* @param mode The new value of the property
*/
public void setSelectionMode(int mode)
{
if (mode < ListSelectionModel.SINGLE_SELECTION
|| mode > ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
throw new IllegalArgumentException("Unrecognised mode: " + mode);
selectionMode = mode;
}
/**
* Gets the value of the {@link #anchorSelectionIndex} property.
*
* @return The current property value
*
* @see #setAnchorSelectionIndex
*/
public int getAnchorSelectionIndex()
{
return anchorSelectionIndex;
}
/**
* Sets the value of the {@link #anchorSelectionIndex} property.
*
* @param index The new property value
*
* @see #getAnchorSelectionIndex
*/
public void setAnchorSelectionIndex(int index)
{
if (anchorSelectionIndex != index)
{
int old = anchorSelectionIndex;
anchorSelectionIndex = index;
if (leadAnchorNotificationEnabled)
fireValueChanged(index, old);
}
}
/**
* Gets the value of the {@link #leadSelectionIndex} property.
*
* @return The current property value
*
* @see #setLeadSelectionIndex
*/
public int getLeadSelectionIndex()
{
return leadSelectionIndex;
}
/**
* Sets the value of the {@link #anchorSelectionIndex} property. As a
* side effect, alters the selection status of two ranges of indices. Let
* OL be the old lead selection index, NL be
* the new lead selection index, and A be the anchor
* selection index. Then if A is a valid selection index,
* one of two things happens depending on the seleciton status of
* A:
isSelectedIndex(A) == true: set [A,OL]
* to deselected, then set [A,NL] to
* selected.isSelectedIndex(A) == false: set [A,OL]
* to selected, then set [A,NL] to
* deselected.This method generates at most a single {@link ListSelectionEvent} * despite changing multiple ranges. The range of values provided to the * {@link ListSelectionEvent} includes only the minimum range of values * which changed selection status between the beginning and end of the * method.
* * @param leadIndex The new property value * * @see #getAnchorSelectionIndex */ public void setLeadSelectionIndex(int leadIndex) { // Only set the lead selection index to < 0 if anchorSelectionIndex < 0. if (leadIndex < 0) { if (anchorSelectionIndex < 0) leadSelectionIndex = -1; else return; } // Only touch the lead selection index if the anchor is >= 0. if (anchorSelectionIndex < 0) return; if (selectionMode == SINGLE_SELECTION) setSelectionInterval (leadIndex, leadIndex); int oldLeadIndex = leadSelectionIndex; if (oldLeadIndex == -1) oldLeadIndex = leadIndex; if (setLeadCalledFromAdd == false) oldSel = sel.clone(); leadSelectionIndex = leadIndex; if (anchorSelectionIndex == -1) return; int R1 = Math.min(anchorSelectionIndex, oldLeadIndex); int R2 = Math.max(anchorSelectionIndex, oldLeadIndex); int S1 = Math.min(anchorSelectionIndex, leadIndex); int S2 = Math.max(anchorSelectionIndex, leadIndex); int lo = Math.min(R1, S1); int hi = Math.max(R2, S2); if (isSelectedIndex(anchorSelectionIndex)) { sel.clear(R1, R2+1); sel.set(S1, S2+1); } else { sel.set(R1, R2+1); sel.clear(S1, S2+1); } int beg = sel.nextSetBit(0), end = -1; for(int i=beg; i >= 0; i=sel.nextSetBit(i+1)) end = i; BitSet old = (BitSet) oldSel; // The new and previous lead location requires repainting. old.set(oldLeadIndex, !sel.get(oldLeadIndex)); old.set(leadSelectionIndex, !sel.get(leadSelectionIndex)); fireDifference(sel, old); } /** * Moves the lead selection index toleadIndex without
* changing the selection values.
*
* If leadAnchorNotificationEnabled is true, send a notification covering the
* old and new lead cells.
*
* @param leadIndex the new lead selection index
* @since 1.5
*/
public void moveLeadSelectionIndex (int leadIndex)
{
if (leadSelectionIndex == leadIndex)
return;
leadSelectionIndex = leadIndex;
if (isLeadAnchorNotificationEnabled())
fireValueChanged(Math.min(leadSelectionIndex, leadIndex),
Math.max(leadSelectionIndex, leadIndex));
}
/**
* Gets the value of the {@link #leadAnchorNotificationEnabled} property.
*
* @return The current property value
*
* @see #setLeadAnchorNotificationEnabled
*/
public boolean isLeadAnchorNotificationEnabled()
{
return leadAnchorNotificationEnabled;
}
/**
* Sets the value of the {@link #leadAnchorNotificationEnabled} property.
*
* @param l The new property value
*
* @see #isLeadAnchorNotificationEnabled
*/
public void setLeadAnchorNotificationEnabled(boolean l)
{
leadAnchorNotificationEnabled = l;
}
/**
* Gets the value of the {@link #valueIsAdjusting} property.
*
* @return The current property value
*
* @see #setValueIsAdjusting
*/
public boolean getValueIsAdjusting()
{
return valueIsAdjusting;
}
/**
* Sets the value of the {@link #valueIsAdjusting} property.
*
* @param v The new property value
*
* @see #getValueIsAdjusting
*/
public void setValueIsAdjusting(boolean v)
{
valueIsAdjusting = v;
}
/**
* Determines whether the selection is empty.
*
* @return true if the selection is empty, otherwise
* false
*/
public boolean isSelectionEmpty()
{
return sel.isEmpty();
}
/**
* Gets the smallest index which is currently a member of a selection
* interval.
*
* @return The least integer i such that i >=
* 0 and i is a member of a selected interval, or
* -1 if there are no selected intervals
*
* @see #getMaxSelectionIndex
*/
public int getMinSelectionIndex()
{
if (isSelectionEmpty())
return -1;
return sel.nextSetBit(0);
}
/**
* Gets the largest index which is currently a member of a selection
* interval.
*
* @return The greatest integer i such that i >=
* 0 and i is a member of a selected interval, or
* -1 if there are no selected intervals
*
* @see #getMinSelectionIndex
*/
public int getMaxSelectionIndex()
{
if (isSelectionEmpty())
return -1;
int mx = -1;
for(int i=sel.nextSetBit(0); i >= 0; i=sel.nextSetBit(i+1))
{
mx = i;
}
return mx;
}
/**
* Determines whether a particular index is a member of a selection
* interval.
*
* @param a The index to search for
*
* @return true if the index is a member of a selection interval,
* otherwise false
*/
public boolean isSelectedIndex(int a)
{
// TODO: Probably throw an exception here?
if (a >= sel.length() || a < 0)
return false;
return sel.get(a);
}
/**
* If the {@link #selectionMode} property is equal to
* SINGLE_SELECTION equivalent to calling
* setSelectionInterval(index1, index2);
* If the {@link #selectionMode} property is equal to
* SINGLE_INTERVAL_SELECTION and the interval being
* added is not adjacent to an already selected interval,
* equivalent to setSelectionInterval(index1, index2).
* Otherwise adds the range [index0, index1]
* to the selection interval set.
*
* @param index0 The beginning of the range of indices to select
* @param index1 The end of the range of indices to select
*
* @see #setSelectionInterval
* @see #removeSelectionInterval
*/
public void addSelectionInterval(int index0, int index1)
{
if (index0 == -1 || index1 == -1)
return;
if (selectionMode == SINGLE_SELECTION)
setSelectionInterval(index0, index1);
else
{
int lo = Math.min(index0, index1);
int hi = Math.max(index0, index1);
oldSel = sel.clone();
// COMPAT: Like Sun (but not like IBM), we allow calls to
// addSelectionInterval when selectionMode is
// SINGLE_SELECTION_INTERVAL iff the interval being added
// is adjacent to an already selected interval
if (selectionMode == SINGLE_INTERVAL_SELECTION)
if (!(isSelectedIndex(index0) ||
isSelectedIndex(index1) ||
isSelectedIndex(Math.max(lo-1,0)) ||
isSelectedIndex(Math.min(hi+1,sel.size()))))
sel.clear();
// We have to update the anchorSelectionIndex and leadSelectionIndex
// variables
// The next if statements breaks down to "if this selection is adjacent
// to the previous selection and going in the same direction"
if ((isSelectedIndex(leadSelectionIndex))
&& ((index0 - 1 == leadSelectionIndex
&& (index1 >= index0)
&& (leadSelectionIndex >= anchorSelectionIndex))
|| (index0 + 1 == leadSelectionIndex && (index1 <= index0)
&& (leadSelectionIndex <= anchorSelectionIndex)))
&& (anchorSelectionIndex != -1 || leadSelectionIndex != -1))
{
// setting setLeadCalledFromAdd to true tells setLeadSelectionIndex
// not to update oldSel
setLeadCalledFromAdd = true;
setLeadSelectionIndex(index1);
setLeadCalledFromAdd = false;
}
else
{
leadSelectionIndex = index1;
anchorSelectionIndex = index0;
sel.set(lo, hi+1);
fireDifference(sel, (BitSet) oldSel);
}
}
}
/**
* Deselects all indices in the inclusive range
* [index0,index1].
*
* @param index0 The beginning of the range of indices to deselect
* @param index1 The end of the range of indices to deselect
*
* @see #addSelectionInterval
* @see #setSelectionInterval
*/
public void removeSelectionInterval(int index0,
int index1)
{
if (index0 == -1 || index1 == -1)
return;
oldSel = sel.clone();
int lo = Math.min(index0, index1);
int hi = Math.max(index0, index1);
// if selectionMode is SINGLE_INTERVAL_SELECTION and removing the interval
// (index0,index1) would leave two disjoint selection intervals, remove all
// selected indices from lo to the last selected index
if (getMinSelectionIndex() > 0 && getMinSelectionIndex() < lo &&
selectionMode == SINGLE_INTERVAL_SELECTION)
hi = sel.size() - 1;
sel.clear(lo, hi+1);
//update anchorSelectionIndex and leadSelectionIndex variables
//TODO: will probably need MouseDragged to test properly and know if this works
setAnchorSelectionIndex(index0);
leadSelectionIndex = index1;
fireDifference(sel, (BitSet) oldSel);
}
/**
* Removes all intervals in the selection set.
*/
public void clearSelection()
{
// Find the selected interval.
int from = sel.nextSetBit(0);
if (from < 0)
return; // Empty selection - nothing to do.
int to = from;
int i;
for (i = from; i>=0; i=sel.nextSetBit(i+1))
to = i;
sel.clear();
fireValueChanged(from, to, valueIsAdjusting);
}
/**
* Fire the change event, covering the difference between the two sets.
*
* @param current the current set
* @param x the previous set, the object will be reused.
*/
private void fireDifference(BitSet current, BitSet x)
{
x.xor(current);
int from = x.nextSetBit(0);
if (from < 0)
return; // No difference.
int to = from;
int i;
for (i = from; i >= 0; i = x.nextSetBit(i+1))
to = i;
fireValueChanged(from, to, valueIsAdjusting);
}
/**
* Clears the current selection and marks a given interval as "selected". If
* the current selection mode is SINGLE_SELECTION only the
* index index2 is selected.
*
* @param anchor the anchor selection index.
* @param lead the lead selection index.
*/
public void setSelectionInterval(int anchor, int lead)
{
if (anchor == -1 || lead == -1)
return;
if (selectionMode == SINGLE_SELECTION)
{
int lo = lead;
int hi = lead;
int selected = sel.nextSetBit(0);
if (selected == lead)
return; // the selection is not changing
if (selected >= 0)
{
lo = Math.min(lo, selected);
hi = Math.max(hi, selected);
}
if (anchorSelectionIndex >= 0)
{
lo = Math.min(lo, anchorSelectionIndex);
hi = Math.max(hi, anchorSelectionIndex);
}
sel.clear();
sel.set(lead);
leadSelectionIndex = lead;
anchorSelectionIndex = lead;
fireValueChanged(lo, hi);
}
else if (selectionMode == SINGLE_INTERVAL_SELECTION)
{
// determine the current interval
int first = sel.nextSetBit(0);
int last = first;
if (first >= 0)
last += (sel.cardinality() - 1);
// update the selection
int lo = Math.min(anchor, lead);
int hi = Math.max(anchor, lead);
if (lo == first && hi == last)
return; // selected interval is not being changed
sel.clear();
sel.set(lo, hi + 1);
// include the old selection in the event range
if (first >= 0)
lo = Math.min(lo, first);
if (last >= 0)
hi = Math.max(hi, last);
if (anchorSelectionIndex >= 0)
{
lo = Math.min(lo, anchorSelectionIndex);
hi = Math.max(hi, anchorSelectionIndex);
}
anchorSelectionIndex = anchor;
leadSelectionIndex = lead;
fireValueChanged(lo, hi);
}
else
{
BitSet oldSel = (BitSet) sel.clone();
sel.clear();
if (selectionMode == SINGLE_SELECTION)
anchor = lead;
int lo = Math.min(anchor, lead);
int hi = Math.max(anchor, lead);
sel.set(lo, hi+1);
// update the anchorSelectionIndex and leadSelectionIndex variables
setAnchorSelectionIndex(anchor);
leadSelectionIndex = lead;
fireDifference(sel, oldSel);
}
}
/**
* Inserts a number of indices either before or after a particular
* position in the set of indices. Renumbers all indices after the
* inserted range. The new indices in the inserted range are not
* selected. This method is typically called to synchronize the selection
* model with an inserted range of elements in a {@link ListModel}.
*
* @param index The position to insert indices at
* @param length The number of indices to insert
* @param before Indicates whether to insert the indices before the index
* or after it
*/
public void insertIndexInterval(int index,
int length,
boolean before)
{
if (!before)
{
index++;
length--;
}
BitSet tmp = sel.get(index, sel.size());
sel.clear(index, sel.size());
int n = tmp.size();
for (int i = 0; i < n; ++i)
sel.set(index + length + i, tmp.get(i));
}
/**
* Removes a range from the set of indices. Renumbers all indices after
* the removed range. This method is typically called to synchronize the
* selection model with a deleted range of elements in a {@link
* ListModel}.
*
* @param index0 The first index to remove (inclusive)
* @param index1 The last index to remove (inclusive)
*/
public void removeIndexInterval(int index0,
int index1)
{
int lo = Math.min(index0, index1);
int hi = Math.max(index0, index1);
BitSet tmp = sel.get(hi, sel.size());
sel.clear(lo, sel.size());
int n = tmp.size();
for (int i = 0; i < n; ++i)
sel.set(lo + i, tmp.get(i));
}
/**
* Fires a {@link ListSelectionEvent} to all the listeners of type {@link
* ListSelectionListener} registered with this selection model to
* indicate that a series of adjustment has just ended.
*
* The values of {@link #getMinSelectionIndex} and
* {@link #getMaxSelectionIndex} are used in the {@link ListSelectionEvent}
* that gets fired.
*
* @param isAdjusting true if this is the final change
* in a series of adjustments, false/code> otherwise
*/
protected void fireValueChanged(boolean isAdjusting)
{
fireValueChanged(getMinSelectionIndex(), getMaxSelectionIndex(),
isAdjusting);
}
/**
* Fires a {@link ListSelectionEvent} to all the listeners of type {@link
* ListSelectionListener} registered with this selection model.
*
* @param firstIndex The low index of the changed range
* @param lastIndex The high index of the changed range
*/
protected void fireValueChanged(int firstIndex, int lastIndex)
{
fireValueChanged(firstIndex, lastIndex, getValueIsAdjusting());
}
/**
* Fires a {@link ListSelectionEvent} to all the listeners of type {@link
* ListSelectionListener} registered with this selection model.
*
* @param firstIndex The low index of the changed range
* @param lastIndex The high index of the changed range
* @param isAdjusting Whether this change is part of a seqence of adjustments
* made to the selection, such as during interactive scrolling
*/
protected void fireValueChanged(int firstIndex, int lastIndex,
boolean isAdjusting)
{
ListSelectionEvent evt = new ListSelectionEvent(this, firstIndex,
lastIndex, isAdjusting);
ListSelectionListener[] listeners = getListSelectionListeners();
for (int i = 0; i < listeners.length; ++i)
listeners[i].valueChanged(evt);
}
/**
* Adds a listener.
*
* @param listener The listener to add
*
* @see #removeListSelectionListener
* @see #getListSelectionListeners
*/
public void addListSelectionListener(ListSelectionListener listener)
{
listenerList.add(ListSelectionListener.class, listener);
}
/**
* Removes a registered listener.
*
* @param listener The listener to remove
*
* @see #addListSelectionListener
* @see #getListSelectionListeners
*/
public void removeListSelectionListener(ListSelectionListener listener)
{
listenerList.remove(ListSelectionListener.class, listener);
}
/**
* Returns an array of all registerers listeners.
*
* @param listenerType The type of listener to retrieve
*
* @return The array
*
* @see #getListSelectionListeners
* @since 1.3
*/
public T[] getListeners(Class listenerType)
{
return listenerList.getListeners(listenerType);
}
/**
* Returns an array of all registerd list selection listeners.
*
* @return the array
*
* @see #addListSelectionListener
* @see #removeListSelectionListener
* @see #getListeners
* @since 1.4
*/
public ListSelectionListener[] getListSelectionListeners()
{
return (ListSelectionListener[]) getListeners(ListSelectionListener.class);
}
/**
* Returns a clone of this object.
* listenerList don't gets duplicated.
*
* @return the cloned object
*
* @throws CloneNotSupportedException if an error occurs
*/
public Object clone()
throws CloneNotSupportedException
{
DefaultListSelectionModel model =
(DefaultListSelectionModel) super.clone();
model.sel = (BitSet) sel.clone();
model.listenerList = new EventListenerList();
return model;
}
}