Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.swing.tree;

	import java.beans.PropertyChangeListener;
	import java.io.*;
	import java.util.ArrayList;
	import java.util.BitSet;
	import java.util.Enumeration;
	import java.util.EventListener;
	import java.util.Hashtable;
	import java.util.List;
	import java.util.Vector;
	import javax.swing.event.*;
	import javax.swing.DefaultListSelectionModel;

	/**
	* Default implementation of TreeSelectionModel. Listeners are notified
	* whenever
	* the paths in the selection change, not the rows. In order
	* to be able to track row changes you may wish to become a listener
	* for expansion events on the tree and test for changes from there.
	* <p>resetRowSelection is called from any of the methods that update
	* the selected paths. If you subclass any of these methods to
	* filter what is allowed to be selected, be sure and message
	* <code>resetRowSelection</code> if you do not message super.
	*
	* <strong>Warning:</strong>
	* Serialized objects of this class will not be compatible with
	* future Swing releases. The current serialization support is
	* appropriate for short term storage or RMI between applications running
	* the same version of Swing. As of 1.4, support for long term storage
	* of all JavaBeans™
	* has been added to the <code>java.beans</code> package.
	* Please see {@link java.beans.XMLEncoder}.
	*
	* @see javax.swing.JTree
	*
	* @author Scott Violet
	*/
	@SuppressWarnings("serial")
	public class DefaultTreeSelectionModel implements Cloneable, Serializable, TreeSelectionModel
	{
	/** Property name for selectionMode. */
	public static final String SELECTION_MODE_PROPERTY = "selectionMode";

	/** Used to messaged registered listeners. */
	protected SwingPropertyChangeSupport changeSupport;

	/** Paths that are currently selected. Will be null if nothing is
	* currently selected. */
	protected TreePath[] selection;

	/** Event listener list. */
	protected EventListenerList listenerList = new EventListenerList();

	/** Provides a row for a given path. */
	transient protected RowMapper rowMapper;

	/** Handles maintaining the list selection model. The RowMapper is used
	* to map from a TreePath to a row, and the value is then placed here. */
	protected DefaultListSelectionModel listSelectionModel;

	/** Mode for the selection, will be either SINGLE_TREE_SELECTION,
	* CONTIGUOUS_TREE_SELECTION or DISCONTIGUOUS_TREE_SELECTION.
	*/
	protected int selectionMode;

	/** Last path that was added. */
	protected TreePath leadPath;
	/** Index of the lead path in selection. */
	protected int leadIndex;
	/** Lead row. */
	protected int leadRow;

	/** Used to make sure the paths are unique, will contain all the paths
	* in <code>selection</code>.
	*/
	private Hashtable<TreePath, Boolean> uniquePaths;
	private Hashtable<TreePath, Boolean> lastPaths;
	private TreePath[] tempPaths;


	/**
	* Creates a new instance of DefaultTreeSelectionModel that is
	* empty, with a selection mode of DISCONTIGUOUS_TREE_SELECTION.
	*/
	public DefaultTreeSelectionModel() {
	listSelectionModel = new DefaultListSelectionModel();
	selectionMode = DISCONTIGUOUS_TREE_SELECTION;
	leadIndex = leadRow = -1;
	uniquePaths = new Hashtable<TreePath, Boolean>();
	lastPaths = new Hashtable<TreePath, Boolean>();
	tempPaths = new TreePath[1];
	}

	/**
	* Sets the RowMapper instance. This instance is used to determine
	* the row for a particular TreePath.
	*/
	public void setRowMapper(RowMapper newMapper) {
	rowMapper = newMapper;
	resetRowSelection();
	}

	/**
	* Returns the RowMapper instance that is able to map a TreePath to a
	* row.
	*/
	public RowMapper getRowMapper() {
	return rowMapper;
	}

	/**
	* Sets the selection model, which must be one of SINGLE_TREE_SELECTION,
	* CONTIGUOUS_TREE_SELECTION or DISCONTIGUOUS_TREE_SELECTION. If mode
	* is not one of the defined value,
	* <code>DISCONTIGUOUS_TREE_SELECTION</code> is assumed.
	* <p>This may change the selection if the current selection is not valid
	* for the new mode. For example, if three TreePaths are
	* selected when the mode is changed to <code>SINGLE_TREE_SELECTION</code>,
	* only one TreePath will remain selected. It is up to the particular
	* implementation to decide what TreePath remains selected.
	* <p>
	* Setting the mode to something other than the defined types will
	* result in the mode becoming <code>DISCONTIGUOUS_TREE_SELECTION</code>.
	*/
	public void setSelectionMode(int mode) {
	int oldMode = selectionMode;

	selectionMode = mode;
	if(selectionMode != TreeSelectionModel.SINGLE_TREE_SELECTION &&
	selectionMode != TreeSelectionModel.CONTIGUOUS_TREE_SELECTION &&
	selectionMode != TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION)
	selectionMode = TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION;
	if(oldMode != selectionMode && changeSupport != null)
	changeSupport.firePropertyChange(SELECTION_MODE_PROPERTY,
	Integer.valueOf(oldMode),
	Integer.valueOf(selectionMode));
	}

	/**
	* Returns the selection mode, one of <code>SINGLE_TREE_SELECTION</code>,
	* <code>DISCONTIGUOUS_TREE_SELECTION</code> or
	* <code>CONTIGUOUS_TREE_SELECTION</code>.
	*/
	public int getSelectionMode() {
	return selectionMode;
	}

	/**
	* Sets the selection to path. If this represents a change, then
	* the TreeSelectionListeners are notified. If <code>path</code> is
	* null, this has the same effect as invoking <code>clearSelection</code>.
	*
	* @param path new path to select
	*/
	public void setSelectionPath(TreePath path) {
	if(path == null)
	setSelectionPaths(null);
	else {
	TreePath[] newPaths = new TreePath[1];

	newPaths[0] = path;
	setSelectionPaths(newPaths);
	}
	}

	/**
	* Sets the selection. Whether the supplied paths are taken as the
	* new selection depends upon the selection mode. If the supplied
	* array is {@code null}, or empty, the selection is cleared. If
	* the selection mode is {@code SINGLE_TREE_SELECTION}, only the
	* first path in {@code pPaths} is used. If the selection
	* mode is {@code CONTIGUOUS_TREE_SELECTION} and the supplied paths
	* are not contiguous, then only the first path in {@code pPaths} is
	* used. If the selection mode is
	* {@code DISCONTIGUOUS_TREE_SELECTION}, then all paths are used.
	* <p>
	* All {@code null} paths in {@code pPaths} are ignored.
	* <p>
	* If this represents a change, all registered {@code
	* TreeSelectionListener}s are notified.
	* <p>
	* The lead path is set to the last unique path.
	* <p>
	* The paths returned from {@code getSelectionPaths} are in the same
	* order as those supplied to this method.
	*
	* @param pPaths the new selection
	*/
	public void setSelectionPaths(TreePath[] pPaths) {
	int newCount, newCounter, oldCount, oldCounter;
	TreePath[] paths = pPaths;

	if(paths == null)
	newCount = 0;
	else
	newCount = paths.length;
	if(selection == null)
	oldCount = 0;
	else
	oldCount = selection.length;
	if((newCount + oldCount) != 0) {
	if(selectionMode == TreeSelectionModel.SINGLE_TREE_SELECTION) {
	/* If single selection and more than one path, only allow
	first. */
	if(newCount > 1) {
	paths = new TreePath[1];
	paths[0] = pPaths[0];
	newCount = 1;
	}
	}
	else if(selectionMode ==
	TreeSelectionModel.CONTIGUOUS_TREE_SELECTION) {
	/* If contiguous selection and paths aren't contiguous,
	only select the first path item. */
	if(newCount > 0 && !arePathsContiguous(paths)) {
	paths = new TreePath[1];
	paths[0] = pPaths[0];
	newCount = 1;
	}
	}

	TreePath beginLeadPath = leadPath;
	Vector<PathPlaceHolder> cPaths = new Vector<PathPlaceHolder>(newCount + oldCount);
	List<TreePath> newSelectionAsList =
	new ArrayList<TreePath>(newCount);

	lastPaths.clear();
	leadPath = null;
	/* Find the paths that are new. */
	for(newCounter = 0; newCounter < newCount; newCounter++) {
	TreePath path = paths[newCounter];
	if (path != null && lastPaths.get(path) == null) {
	lastPaths.put(path, Boolean.TRUE);
	if (uniquePaths.get(path) == null) {
	cPaths.addElement(new PathPlaceHolder(path, true));
	}
	leadPath = path;
	newSelectionAsList.add(path);
	}
	}

	TreePath[] newSelection = newSelectionAsList.toArray(
	new TreePath[newSelectionAsList.size()]);

	/* Get the paths that were selected but no longer selected. */
	for(oldCounter = 0; oldCounter < oldCount; oldCounter++)
	if(selection[oldCounter] != null &&
	lastPaths.get(selection[oldCounter]) == null)
	cPaths.addElement(new PathPlaceHolder
	(selection[oldCounter], false));

	selection = newSelection;

	Hashtable<TreePath, Boolean> tempHT = uniquePaths;

	uniquePaths = lastPaths;
	lastPaths = tempHT;
	lastPaths.clear();

	// No reason to do this now, but will still call it.
	insureUniqueness();

	updateLeadIndex();

	resetRowSelection();
	/* Notify of the change. */
	if(cPaths.size() > 0)
	notifyPathChange(cPaths, beginLeadPath);
	}
	}

	/**
	* Adds path to the current selection. If path is not currently
	* in the selection the TreeSelectionListeners are notified. This has
	* no effect if <code>path</code> is null.
	*
	* @param path the new path to add to the current selection
	*/
	public void addSelectionPath(TreePath path) {
	if(path != null) {
	TreePath[] toAdd = new TreePath[1];

	toAdd[0] = path;
	addSelectionPaths(toAdd);
	}
	}

	/**
	* Adds paths to the current selection. If any of the paths in
	* paths are not currently in the selection the TreeSelectionListeners
	* are notified. This has
	* no effect if <code>paths</code> is null.
	* <p>The lead path is set to the last element in <code>paths</code>.
	* <p>If the selection mode is <code>CONTIGUOUS_TREE_SELECTION</code>,
	* and adding the new paths would make the selection discontiguous.
	* Then two things can result: if the TreePaths in <code>paths</code>
	* are contiguous, then the selection becomes these TreePaths,
	* otherwise the TreePaths aren't contiguous and the selection becomes
	* the first TreePath in <code>paths</code>.
	*
	* @param paths the new path to add to the current selection
	*/
	public void addSelectionPaths(TreePath[] paths) {
	int newPathLength = ((paths == null) ? 0 : paths.length);

	if(newPathLength > 0) {
	if(selectionMode == TreeSelectionModel.SINGLE_TREE_SELECTION) {
	setSelectionPaths(paths);
	}
	else if(selectionMode == TreeSelectionModel.
	CONTIGUOUS_TREE_SELECTION && !canPathsBeAdded(paths)) {
	if(arePathsContiguous(paths)) {
	setSelectionPaths(paths);
	}
	else {
	TreePath[] newPaths = new TreePath[1];

	newPaths[0] = paths[0];
	setSelectionPaths(newPaths);
	}
	}
	else {
	int counter, validCount;
	int oldCount;
	TreePath beginLeadPath = leadPath;
	Vector<PathPlaceHolder> cPaths = null;

	if(selection == null)
	oldCount = 0;
	else
	oldCount = selection.length;
	/* Determine the paths that aren't currently in the
	selection. */
	lastPaths.clear();
	for(counter = 0, validCount = 0; counter < newPathLength;
	counter++) {
	if(paths[counter] != null) {
	if (uniquePaths.get(paths[counter]) == null) {
	validCount++;
	if(cPaths == null)
	cPaths = new Vector<PathPlaceHolder>();
	cPaths.addElement(new PathPlaceHolder
	(paths[counter], true));
	uniquePaths.put(paths[counter], Boolean.TRUE);
	lastPaths.put(paths[counter], Boolean.TRUE);
	}
	leadPath = paths[counter];
	}
	}

	if(leadPath == null) {
	leadPath = beginLeadPath;
	}

	if(validCount > 0) {
	TreePath newSelection[] = new TreePath[oldCount +
	validCount];

	/* And build the new selection. */
	if(oldCount > 0)
	System.arraycopy(selection, 0, newSelection, 0,
	oldCount);
	if(validCount != paths.length) {
	/* Some of the paths in paths are already in
	the selection. */
	Enumeration<TreePath> newPaths = lastPaths.keys();

	counter = oldCount;
	while (newPaths.hasMoreElements()) {
	newSelection[counter++] = newPaths.nextElement();
	}
	}
	else {
	System.arraycopy(paths, 0, newSelection, oldCount,
	validCount);
	}

	selection = newSelection;

	insureUniqueness();

	updateLeadIndex();

	resetRowSelection();

	notifyPathChange(cPaths, beginLeadPath);
	}
	else
	leadPath = beginLeadPath;
	lastPaths.clear();
	}
	}
	}

	/**
	* Removes path from the selection. If path is in the selection
	* The TreeSelectionListeners are notified. This has no effect if
	* <code>path</code> is null.
	*
	* @param path the path to remove from the selection
	*/
	public void removeSelectionPath(TreePath path) {
	if(path != null) {
	TreePath[] rPath = new TreePath[1];

	rPath[0] = path;
	removeSelectionPaths(rPath);
	}
	}

	/**
	* Removes paths from the selection. If any of the paths in paths
	* are in the selection the TreeSelectionListeners are notified.
	* This has no effect if <code>paths</code> is null.
	*
	* @param paths the paths to remove from the selection
	*/
	public void removeSelectionPaths(TreePath[] paths) {
	if (paths != null && selection != null && paths.length > 0) {
	if(!canPathsBeRemoved(paths)) {
	/* Could probably do something more interesting here! */
	clearSelection();
	}
	else {
	Vector<PathPlaceHolder> pathsToRemove = null;

	/* Find the paths that can be removed. */
	for (int removeCounter = paths.length - 1; removeCounter >= 0;
	removeCounter--) {
	if(paths[removeCounter] != null) {
	if (uniquePaths.get(paths[removeCounter]) != null) {
	if(pathsToRemove == null)
	pathsToRemove = new Vector<PathPlaceHolder>(paths.length);
	uniquePaths.remove(paths[removeCounter]);
	pathsToRemove.addElement(new PathPlaceHolder
	(paths[removeCounter], false));
	}
	}
	}
	if(pathsToRemove != null) {
	int removeCount = pathsToRemove.size();
	TreePath beginLeadPath = leadPath;

	if(removeCount == selection.length) {
	selection = null;
	}
	else {
	Enumeration<TreePath> pEnum = uniquePaths.keys();
	int validCount = 0;

	selection = new TreePath[selection.length -
	removeCount];
	while (pEnum.hasMoreElements()) {
	selection[validCount++] = pEnum.nextElement();
	}
	}
	if (leadPath != null &&
	uniquePaths.get(leadPath) == null) {
	if (selection != null) {
	leadPath = selection[selection.length - 1];
	}
	else {
	leadPath = null;
	}
	}
	else if (selection != null) {
	leadPath = selection[selection.length - 1];
	}
	else {
	leadPath = null;
	}
	updateLeadIndex();

	resetRowSelection();

	notifyPathChange(pathsToRemove, beginLeadPath);
	}
	}
	}
	}

	/**
	* Returns the first path in the selection. This is useful if there
	* if only one item currently selected.
	*/
	public TreePath getSelectionPath() {
	if (selection != null && selection.length > 0) {
	return selection[0];
	}
	return null;
	}

	/**
	* Returns the selection.
	*
	* @return the selection
	*/
	public TreePath[] getSelectionPaths() {
	if(selection != null) {
	int pathSize = selection.length;
	TreePath[] result = new TreePath[pathSize];

	System.arraycopy(selection, 0, result, 0, pathSize);
	return result;
	}
	return new TreePath[0];
	}

	/**
	* Returns the number of paths that are selected.
	*/
	public int getSelectionCount() {
	return (selection == null) ? 0 : selection.length;
	}

	/**
	* Returns true if the path, <code>path</code>,
	* is in the current selection.
	*/
	public boolean isPathSelected(TreePath path) {
	return (path != null) ? (uniquePaths.get(path) != null) : false;
	}

	/**
	* Returns true if the selection is currently empty.
	*/
	public boolean isSelectionEmpty() {
	return (selection == null \|\| selection.length == 0);
	}

	/**
	* Empties the current selection. If this represents a change in the
	* current selection, the selection listeners are notified.
	*/
	public void clearSelection() {
	if (selection != null && selection.length > 0) {
	int selSize = selection.length;
	boolean[] newness = new boolean[selSize];

	for(int counter = 0; counter < selSize; counter++)
	newness[counter] = false;

	TreeSelectionEvent event = new TreeSelectionEvent
	(this, selection, newness, leadPath, null);

	leadPath = null;
	leadIndex = leadRow = -1;
	uniquePaths.clear();
	selection = null;
	resetRowSelection();
	fireValueChanged(event);
	}
	}

	/**
	* Adds x to the list of listeners that are notified each time the
	* set of selected TreePaths changes.
	*
	* @param x the new listener to be added
	*/
	public void addTreeSelectionListener(TreeSelectionListener x) {
	listenerList.add(TreeSelectionListener.class, x);
	}

	/**
	* Removes x from the list of listeners that are notified each time
	* the set of selected TreePaths changes.
	*
	* @param x the listener to remove
	*/
	public void removeTreeSelectionListener(TreeSelectionListener x) {
	listenerList.remove(TreeSelectionListener.class, x);
	}

	/**
	* Returns an array of all the tree selection listeners
	* registered on this model.
	*
	* @return all of this model's <code>TreeSelectionListener</code>s
	* or an empty
	* array if no tree selection listeners are currently registered
	*
	* @see #addTreeSelectionListener
	* @see #removeTreeSelectionListener
	*
	* @since 1.4
	*/
	public TreeSelectionListener[] getTreeSelectionListeners() {
	return listenerList.getListeners(TreeSelectionListener.class);
	}

	/**
	* Notifies all listeners that are registered for
	* tree selection events on this object.
	* @see #addTreeSelectionListener
	* @see EventListenerList
	*/
	protected void fireValueChanged(TreeSelectionEvent e) {
	// Guaranteed to return a non-null array
	Object[] listeners = listenerList.getListenerList();
	// TreeSelectionEvent e = null;
	// Process the listeners last to first, notifying
	// those that are interested in this event
	for (int i = listeners.length-2; i>=0; i-=2) {
	if (listeners[i]==TreeSelectionListener.class) {
	// Lazily create the event:
	// if (e == null)
	// e = new ListSelectionEvent(this, firstIndex, lastIndex);
	((TreeSelectionListener)listeners[i+1]).valueChanged(e);
	}
	}
	}

	/**
	* Returns an array of all the objects currently registered
	* as <code><em>Foo</em>Listener</code>s
	* upon this model.
	* <code><em>Foo</em>Listener</code>s are registered using the
	* <code>add<em>Foo</em>Listener</code> method.
	*
	* <p>
	*
	* You can specify the <code>listenerType</code> argument
	* with a class literal,
	* such as
	* <code><em>Foo</em>Listener.class</code>.
	* For example, you can query a
	* <code>DefaultTreeSelectionModel</code> <code>m</code>
	* for its tree selection listeners with the following code:
	*
	* <pre>TreeSelectionListener[] tsls = (TreeSelectionListener[])(m.getListeners(TreeSelectionListener.class));</pre>
	*
	* If no such listeners exist, this method returns an empty array.
	*
	* @param listenerType the type of listeners requested; this parameter
	* should specify an interface that descends from
	* <code>java.util.EventListener</code>
	* @return an array of all objects registered as
	* <code><em>Foo</em>Listener</code>s on this component,
	* or an empty array if no such
	* listeners have been added
	* @exception ClassCastException if <code>listenerType</code>
	* doesn't specify a class or interface that implements
	* <code>java.util.EventListener</code>
	*
	* @see #getTreeSelectionListeners
	* @see #getPropertyChangeListeners
	*
	* @since 1.3
	*/
	public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
	return listenerList.getListeners(listenerType);
	}

	/**
	* Returns the selection in terms of rows. There is not
	* necessarily a one-to-one mapping between the {@code TreePath}s
	* returned from {@code getSelectionPaths} and this method. In
	* particular, if a {@code TreePath} is not viewable (the {@code
	* RowMapper} returns {@code -1} for the row corresponding to the
	* {@code TreePath}), then the corresponding row is not included
	* in the returned array. For example, if the selection consists
	* of two paths, {@code A} and {@code B}, with {@code A} at row
	* {@code 10}, and {@code B} not currently viewable, then this method
	* returns an array with the single entry {@code 10}.
	*
	* @return the selection in terms of rows
	*/
	public int[] getSelectionRows() {
	// This is currently rather expensive. Needs
	// to be better support from ListSelectionModel to speed this up.
	if (rowMapper != null && selection != null && selection.length > 0) {
	int[] rows = rowMapper.getRowsForPaths(selection);

	if (rows != null) {
	int invisCount = 0;

	for (int counter = rows.length - 1; counter >= 0; counter--) {
	if (rows[counter] == -1) {
	invisCount++;
	}
	}
	if (invisCount > 0) {
	if (invisCount == rows.length) {
	rows = null;
	}
	else {
	int[] tempRows = new int[rows.length - invisCount];

	for (int counter = rows.length - 1, visCounter = 0;
	counter >= 0; counter--) {
	if (rows[counter] != -1) {
	tempRows[visCounter++] = rows[counter];
	}
	}
	rows = tempRows;
	}
	}
	}
	return rows;
	}
	return new int[0];
	}

	/**
	* Returns the smallest value obtained from the RowMapper for the
	* current set of selected TreePaths. If nothing is selected,
	* or there is no RowMapper, this will return -1.
	*/
	public int getMinSelectionRow() {
	return listSelectionModel.getMinSelectionIndex();
	}

	/**
	* Returns the largest value obtained from the RowMapper for the
	* current set of selected TreePaths. If nothing is selected,
	* or there is no RowMapper, this will return -1.
	*/
	public int getMaxSelectionRow() {
	return listSelectionModel.getMaxSelectionIndex();
	}

	/**
	* Returns true if the row identified by <code>row</code> is selected.
	*/
	public boolean isRowSelected(int row) {
	return listSelectionModel.isSelectedIndex(row);
	}

	/**
	* Updates this object's mapping from TreePath to rows. This should
	* be invoked when the mapping from TreePaths to integers has changed
	* (for example, a node has been expanded).
	* <p>You do not normally have to call this, JTree and its associated
	* Listeners will invoke this for you. If you are implementing your own
	* View class, then you will have to invoke this.
	* <p>This will invoke <code>insureRowContinuity</code> to make sure
	* the currently selected TreePaths are still valid based on the
	* selection mode.
	*/
	public void resetRowSelection() {
	listSelectionModel.clearSelection();
	if(selection != null && rowMapper != null) {
	int aRow;
	int validCount = 0;
	int[] rows = rowMapper.getRowsForPaths(selection);

	for(int counter = 0, maxCounter = selection.length;
	counter < maxCounter; counter++) {
	aRow = rows[counter];
	if(aRow != -1) {
	listSelectionModel.addSelectionInterval(aRow, aRow);
	}
	}
	if(leadIndex != -1 && rows != null) {
	leadRow = rows[leadIndex];
	}
	else if (leadPath != null) {
	// Lead selection path doesn't have to be in the selection.
	tempPaths[0] = leadPath;
	rows = rowMapper.getRowsForPaths(tempPaths);
	leadRow = (rows != null) ? rows[0] : -1;
	}
	else {
	leadRow = -1;
	}
	insureRowContinuity();

	}
	else
	leadRow = -1;
	}

	/**
	* Returns the lead selection index. That is the last index that was
	* added.
	*/
	public int getLeadSelectionRow() {
	return leadRow;
	}

	/**
	* Returns the last path that was added. This may differ from the
	* leadSelectionPath property maintained by the JTree.
	*/
	public TreePath getLeadSelectionPath() {
	return leadPath;
	}

	/**
	* Adds a PropertyChangeListener to the listener list.
	* The listener is registered for all properties.
	* <p>
	* A PropertyChangeEvent will get fired when the selection mode
	* changes.
	*
	* @param listener the PropertyChangeListener to be added
	*/
	public synchronized void addPropertyChangeListener(
	PropertyChangeListener listener) {
	if (changeSupport == null) {
	changeSupport = new SwingPropertyChangeSupport(this);
	}
	changeSupport.addPropertyChangeListener(listener);
	}

	/**
	* Removes a PropertyChangeListener from the listener list.
	* This removes a PropertyChangeListener that was registered
	* for all properties.
	*
	* @param listener the PropertyChangeListener to be removed
	*/

	public synchronized void removePropertyChangeListener(
	PropertyChangeListener listener) {
	if (changeSupport == null) {
	return;
	}
	changeSupport.removePropertyChangeListener(listener);
	}

	/**
	* Returns an array of all the property change listeners
	* registered on this <code>DefaultTreeSelectionModel</code>.
	*
	* @return all of this model's <code>PropertyChangeListener</code>s
	* or an empty
	* array if no property change listeners are currently registered
	*
	* @see #addPropertyChangeListener
	* @see #removePropertyChangeListener
	*
	* @since 1.4
	*/
	public PropertyChangeListener[] getPropertyChangeListeners() {
	if (changeSupport == null) {
	return new PropertyChangeListener[0];
	}
	return changeSupport.getPropertyChangeListeners();
	}

	/**
	* Makes sure the currently selected <code>TreePath</code>s are valid
	* for the current selection mode.
	* If the selection mode is <code>CONTIGUOUS_TREE_SELECTION</code>
	* and a <code>RowMapper</code> exists, this will make sure all
	* the rows are contiguous, that is, when sorted all the rows are
	* in order with no gaps.
	* If the selection isn't contiguous, the selection is
	* reset to contain the first set, when sorted, of contiguous rows.
	* <p>
	* If the selection mode is <code>SINGLE_TREE_SELECTION</code> and
	* more than one TreePath is selected, the selection is reset to
	* contain the first path currently selected.
	*/
	protected void insureRowContinuity() {
	if(selectionMode == TreeSelectionModel.CONTIGUOUS_TREE_SELECTION &&
	selection != null && rowMapper != null) {
	DefaultListSelectionModel lModel = listSelectionModel;
	int min = lModel.getMinSelectionIndex();

	if(min != -1) {
	for(int counter = min,
	maxCounter = lModel.getMaxSelectionIndex();
	counter <= maxCounter; counter++) {
	if(!lModel.isSelectedIndex(counter)) {
	if(counter == min) {
	clearSelection();
	}
	else {
	TreePath[] newSel = new TreePath[counter - min];
	int selectionIndex[] = rowMapper.getRowsForPaths(selection);
	// find the actual selection pathes corresponded to the
	// rows of the new selection
	for (int i = 0; i < selectionIndex.length; i++) {
	if (selectionIndex[i]<counter) {
	newSel[selectionIndex[i]-min] = selection[i];
	}
	}
	setSelectionPaths(newSel);
	break;
	}
	}
	}
	}
	}
	else if(selectionMode == TreeSelectionModel.SINGLE_TREE_SELECTION &&
	selection != null && selection.length > 1) {
	setSelectionPath(selection[0]);
	}
	}

	/**
	* Returns true if the paths are contiguous,
	* or this object has no RowMapper.
	*/
	protected boolean arePathsContiguous(TreePath[] paths) {
	if(rowMapper == null \|\| paths.length < 2)
	return true;
	else {
	BitSet bitSet = new BitSet(32);
	int anIndex, counter, min;
	int pathCount = paths.length;
	int validCount = 0;
	TreePath[] tempPath = new TreePath[1];

	tempPath[0] = paths[0];
	min = rowMapper.getRowsForPaths(tempPath)[0];
	for(counter = 0; counter < pathCount; counter++) {
	if(paths[counter] != null) {
	tempPath[0] = paths[counter];
	int[] rows = rowMapper.getRowsForPaths(tempPath);
	if (rows == null) {
	return false;
	}
	anIndex = rows[0];
	if(anIndex == -1 \|\| anIndex < (min - pathCount) \|\|
	anIndex > (min + pathCount))
	return false;
	if(anIndex < min)
	min = anIndex;
	if(!bitSet.get(anIndex)) {
	bitSet.set(anIndex);
	validCount++;
	}
	}
	}
	int maxCounter = validCount + min;

	for(counter = min; counter < maxCounter; counter++)
	if(!bitSet.get(counter))
	return false;
	}
	return true;
	}

	/**
	* Used to test if a particular set of <code>TreePath</code>s can
	* be added. This will return true if <code>paths</code> is null (or
	* empty), or this object has no RowMapper, or nothing is currently selected,
	* or the selection mode is <code>DISCONTIGUOUS_TREE_SELECTION</code>, or
	* adding the paths to the current selection still results in a
	* contiguous set of <code>TreePath</code>s.
	*/
	protected boolean canPathsBeAdded(TreePath[] paths) {
	if(paths == null \|\| paths.length == 0 \|\| rowMapper == null \|\|
	selection == null \|\| selectionMode ==
	TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION)
	return true;
	else {
	BitSet bitSet = new BitSet();
	DefaultListSelectionModel lModel = listSelectionModel;
	int anIndex;
	int counter;
	int min = lModel.getMinSelectionIndex();
	int max = lModel.getMaxSelectionIndex();
	TreePath[] tempPath = new TreePath[1];

	if(min != -1) {
	for(counter = min; counter <= max; counter++) {
	if(lModel.isSelectedIndex(counter))
	bitSet.set(counter);
	}
	}
	else {
	tempPath[0] = paths[0];
	min = max = rowMapper.getRowsForPaths(tempPath)[0];
	}
	for(counter = paths.length - 1; counter >= 0; counter--) {
	if(paths[counter] != null) {
	tempPath[0] = paths[counter];
	int[] rows = rowMapper.getRowsForPaths(tempPath);
	if (rows == null) {
	return false;
	}
	anIndex = rows[0];
	min = Math.min(anIndex, min);
	max = Math.max(anIndex, max);
	if(anIndex == -1)
	return false;
	bitSet.set(anIndex);
	}
	}
	for(counter = min; counter <= max; counter++)
	if(!bitSet.get(counter))
	return false;
	}
	return true;
	}

	/**
	* Returns true if the paths can be removed without breaking the
	* continuity of the model.
	* This is rather expensive.
	*/
	protected boolean canPathsBeRemoved(TreePath[] paths) {
	if(rowMapper == null \|\| selection == null \|\|
	selectionMode == TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION)
	return true;
	else {
	BitSet bitSet = new BitSet();
	int counter;
	int pathCount = paths.length;
	int anIndex;
	int min = -1;
	int validCount = 0;
	TreePath[] tempPath = new TreePath[1];
	int[] rows;

	/* Determine the rows for the removed entries. */
	lastPaths.clear();
	for (counter = 0; counter < pathCount; counter++) {
	if (paths[counter] != null) {
	lastPaths.put(paths[counter], Boolean.TRUE);
	}
	}
	for(counter = selection.length - 1; counter >= 0; counter--) {
	if(lastPaths.get(selection[counter]) == null) {
	tempPath[0] = selection[counter];
	rows = rowMapper.getRowsForPaths(tempPath);
	if(rows != null && rows[0] != -1 && !bitSet.get(rows[0])) {
	validCount++;
	if(min == -1)
	min = rows[0];
	else
	min = Math.min(min, rows[0]);
	bitSet.set(rows[0]);
	}
	}
	}
	lastPaths.clear();
	/* Make sure they are contiguous. */
	if(validCount > 1) {
	for(counter = min + validCount - 1; counter >= min;
	counter--)
	if(!bitSet.get(counter))
	return false;
	}
	}
	return true;
	}

	/**
	* Notifies listeners of a change in path. changePaths should contain
	* instances of PathPlaceHolder.
	*
	* @deprecated As of JDK version 1.7
	*/
	@Deprecated
	protected void notifyPathChange(Vector<?> changedPaths,
	TreePath oldLeadSelection) {
	int cPathCount = changedPaths.size();
	boolean[] newness = new boolean[cPathCount];
	TreePath[] paths = new TreePath[cPathCount];
	PathPlaceHolder placeholder;

	for(int counter = 0; counter < cPathCount; counter++) {
	placeholder = (PathPlaceHolder) changedPaths.elementAt(counter);
	newness[counter] = placeholder.isNew;
	paths[counter] = placeholder.path;
	}

	TreeSelectionEvent event = new TreeSelectionEvent
	(this, paths, newness, oldLeadSelection, leadPath);

	fireValueChanged(event);
	}

	/**
	* Updates the leadIndex instance variable.
	*/
	protected void updateLeadIndex() {
	if(leadPath != null) {
	if(selection == null) {
	leadPath = null;
	leadIndex = leadRow = -1;
	}
	else {
	leadRow = leadIndex = -1;
	for(int counter = selection.length - 1; counter >= 0;
	counter--) {
	// Can use == here since we know leadPath came from
	// selection
	if(selection[counter] == leadPath) {
	leadIndex = counter;
	break;
	}
	}
	}
	}
	else {
	leadIndex = -1;
	}
	}

	/**
	* This method is obsolete and its implementation is now a noop. It's
	* still called by setSelectionPaths and addSelectionPaths, but only
	* for backwards compatibility.
	*/
	protected void insureUniqueness() {
	}


	/**
	* Returns a string that displays and identifies this
	* object's properties.
	*
	* @return a String representation of this object
	*/
	public String toString() {
	int selCount = getSelectionCount();
	StringBuffer retBuffer = new StringBuffer();
	int[] rows;

	if(rowMapper != null)
	rows = rowMapper.getRowsForPaths(selection);
	else
	rows = null;
	retBuffer.append(getClass().getName() + " " + hashCode() + " [ ");
	for(int counter = 0; counter < selCount; counter++) {
	if(rows != null)
	retBuffer.append(selection[counter].toString() + "@" +
	Integer.toString(rows[counter])+ " ");
	else
	retBuffer.append(selection[counter].toString() + " ");
	}
	retBuffer.append("]");
	return retBuffer.toString();
	}

	/**
	* Returns a clone of this object with the same selection.
	* This method does not duplicate
	* selection listeners and property listeners.
	*
	* @exception CloneNotSupportedException never thrown by instances of
	* this class
	*/
	public Object clone() throws CloneNotSupportedException {
	DefaultTreeSelectionModel clone = (DefaultTreeSelectionModel)
	super.clone();

	clone.changeSupport = null;
	if(selection != null) {
	int selLength = selection.length;

	clone.selection = new TreePath[selLength];
	System.arraycopy(selection, 0, clone.selection, 0, selLength);
	}
	clone.listenerList = new EventListenerList();
	clone.listSelectionModel = (DefaultListSelectionModel)
	listSelectionModel.clone();
	clone.uniquePaths = new Hashtable<TreePath, Boolean>();
	clone.lastPaths = new Hashtable<TreePath, Boolean>();
	clone.tempPaths = new TreePath[1];
	return clone;
	}

	// Serialization support.
	private void writeObject(ObjectOutputStream s) throws IOException {
	Object[] tValues;

	s.defaultWriteObject();
	// Save the rowMapper, if it implements Serializable
	if(rowMapper != null && rowMapper instanceof Serializable) {
	tValues = new Object[2];
	tValues[0] = "rowMapper";
	tValues[1] = rowMapper;
	}
	else
	tValues = new Object[0];
	s.writeObject(tValues);
	}


	private void readObject(ObjectInputStream s)
	throws IOException, ClassNotFoundException {
	Object[] tValues;

	s.defaultReadObject();

	tValues = (Object[])s.readObject();

	if(tValues.length > 0 && tValues[0].equals("rowMapper"))
	rowMapper = (RowMapper)tValues[1];
	}
	}

	/**
	* Holds a path and whether or not it is new.
	*/
	class PathPlaceHolder {
	protected boolean isNew;
	protected TreePath path;

	PathPlaceHolder(TreePath path, boolean isNew) {
	this.path = path;
	this.isNew = isNew;
	}
	}

Back to index...