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.plaf.basic;

	import javax.swing.*;
	import javax.swing.event.*;
	import java.awt.*;
	import java.awt.event.*;
	import java.awt.datatransfer.*;
	import java.beans.*;
	import java.util.Enumeration;
	import java.util.Hashtable;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import javax.swing.plaf.ComponentUI;
	import javax.swing.plaf.UIResource;
	import javax.swing.plaf.TreeUI;
	import javax.swing.tree.*;
	import javax.swing.text.Position;
	import javax.swing.plaf.basic.DragRecognitionSupport.BeforeDrag;
	import sun.awt.AWTAccessor;
	import sun.swing.SwingUtilities2;

	import sun.swing.DefaultLookup;
	import sun.swing.UIAction;

	/**
	* The basic L&F for a hierarchical data structure.
	* <p>
	*
	* @author Scott Violet
	* @author Shannon Hickey (drag and drop)
	*/

	public class BasicTreeUI extends TreeUI
	{
	private static final StringBuilder BASELINE_COMPONENT_KEY =
	new StringBuilder("Tree.baselineComponent");

	// Old actions forward to an instance of this.
	static private final Actions SHARED_ACTION = new Actions();

	transient protected Icon collapsedIcon;
	transient protected Icon expandedIcon;

	/**
	* Color used to draw hash marks. If <code>null</code> no hash marks
	* will be drawn.
	*/
	private Color hashColor;

	/** Distance between left margin and where vertical dashes will be
	* drawn. */
	protected int leftChildIndent;
	/** Distance to add to leftChildIndent to determine where cell
	* contents will be drawn. */
	protected int rightChildIndent;
	/** Total distance that will be indented. The sum of leftChildIndent
	* and rightChildIndent. */
	protected int totalChildIndent;

	/** Minimum preferred size. */
	protected Dimension preferredMinSize;

	/** Index of the row that was last selected. */
	protected int lastSelectedRow;

	/** Component that we're going to be drawing into. */
	protected JTree tree;

	/** Renderer that is being used to do the actual cell drawing. */
	transient protected TreeCellRenderer currentCellRenderer;

	/** Set to true if the renderer that is currently in the tree was
	* created by this instance. */
	protected boolean createdRenderer;

	/** Editor for the tree. */
	transient protected TreeCellEditor cellEditor;

	/** Set to true if editor that is currently in the tree was
	* created by this instance. */
	protected boolean createdCellEditor;

	/** Set to false when editing and shouldSelectCell() returns true meaning
	* the node should be selected before editing, used in completeEditing. */
	protected boolean stopEditingInCompleteEditing;

	/** Used to paint the TreeCellRenderer. */
	protected CellRendererPane rendererPane;

	/** Size needed to completely display all the nodes. */
	protected Dimension preferredSize;

	/** Is the preferredSize valid? */
	protected boolean validCachedPreferredSize;

	/** Object responsible for handling sizing and expanded issues. */
	// WARNING: Be careful with the bounds held by treeState. They are
	// always in terms of left-to-right. They get mapped to right-to-left
	// by the various methods of this class.
	protected AbstractLayoutCache treeState;


	/** Used for minimizing the drawing of vertical lines. */
	protected Hashtable<TreePath,Boolean> drawingCache;

	/** True if doing optimizations for a largeModel. Subclasses that
	* don't support this may wish to override createLayoutCache to not
	* return a FixedHeightLayoutCache instance. */
	protected boolean largeModel;

	/** Reponsible for telling the TreeState the size needed for a node. */
	protected AbstractLayoutCache.NodeDimensions nodeDimensions;

	/** Used to determine what to display. */
	protected TreeModel treeModel;

	/** Model maintaining the selection. */
	protected TreeSelectionModel treeSelectionModel;

	/** How much the depth should be offset to properly calculate
	* x locations. This is based on whether or not the root is visible,
	* and if the root handles are visible. */
	protected int depthOffset;

	// Following 4 ivars are only valid when editing.

	/** When editing, this will be the Component that is doing the actual
	* editing. */
	protected Component editingComponent;

	/** Path that is being edited. */
	protected TreePath editingPath;

	/** Row that is being edited. Should only be referenced if
	* editingComponent is not null. */
	protected int editingRow;

	/** Set to true if the editor has a different size than the renderer. */
	protected boolean editorHasDifferentSize;

	/** Row correspondin to lead path. */
	private int leadRow;
	/** If true, the property change event for LEAD_SELECTION_PATH_PROPERTY,
	* or ANCHOR_SELECTION_PATH_PROPERTY will not generate a repaint. */
	private boolean ignoreLAChange;

	/** Indicates the orientation. */
	private boolean leftToRight;

	// Cached listeners
	private PropertyChangeListener propertyChangeListener;
	private PropertyChangeListener selectionModelPropertyChangeListener;
	private MouseListener mouseListener;
	private FocusListener focusListener;
	private KeyListener keyListener;
	/** Used for large models, listens for moved/resized events and
	* updates the validCachedPreferredSize bit accordingly. */
	private ComponentListener componentListener;
	/** Listens for CellEditor events. */
	private CellEditorListener cellEditorListener;
	/** Updates the display when the selection changes. */
	private TreeSelectionListener treeSelectionListener;
	/** Is responsible for updating the display based on model events. */
	private TreeModelListener treeModelListener;
	/** Updates the treestate as the nodes expand. */
	private TreeExpansionListener treeExpansionListener;

	/** UI property indicating whether to paint lines */
	private boolean paintLines = true;

	/** UI property for painting dashed lines */
	private boolean lineTypeDashed;

	/**
	* The time factor to treate the series of typed alphanumeric key
	* as prefix for first letter navigation.
	*/
	private long timeFactor = 1000L;

	private Handler handler;

	/**
	* A temporary variable for communication between startEditingOnRelease
	* and startEditing.
	*/
	private MouseEvent releaseEvent;

	public static ComponentUI createUI(JComponent x) {
	return new BasicTreeUI();
	}


	static void loadActionMap(LazyActionMap map) {
	map.put(new Actions(Actions.SELECT_PREVIOUS));
	map.put(new Actions(Actions.SELECT_PREVIOUS_CHANGE_LEAD));
	map.put(new Actions(Actions.SELECT_PREVIOUS_EXTEND_SELECTION));

	map.put(new Actions(Actions.SELECT_NEXT));
	map.put(new Actions(Actions.SELECT_NEXT_CHANGE_LEAD));
	map.put(new Actions(Actions.SELECT_NEXT_EXTEND_SELECTION));

	map.put(new Actions(Actions.SELECT_CHILD));
	map.put(new Actions(Actions.SELECT_CHILD_CHANGE_LEAD));

	map.put(new Actions(Actions.SELECT_PARENT));
	map.put(new Actions(Actions.SELECT_PARENT_CHANGE_LEAD));

	map.put(new Actions(Actions.SCROLL_UP_CHANGE_SELECTION));
	map.put(new Actions(Actions.SCROLL_UP_CHANGE_LEAD));
	map.put(new Actions(Actions.SCROLL_UP_EXTEND_SELECTION));

	map.put(new Actions(Actions.SCROLL_DOWN_CHANGE_SELECTION));
	map.put(new Actions(Actions.SCROLL_DOWN_EXTEND_SELECTION));
	map.put(new Actions(Actions.SCROLL_DOWN_CHANGE_LEAD));

	map.put(new Actions(Actions.SELECT_FIRST));
	map.put(new Actions(Actions.SELECT_FIRST_CHANGE_LEAD));
	map.put(new Actions(Actions.SELECT_FIRST_EXTEND_SELECTION));

	map.put(new Actions(Actions.SELECT_LAST));
	map.put(new Actions(Actions.SELECT_LAST_CHANGE_LEAD));
	map.put(new Actions(Actions.SELECT_LAST_EXTEND_SELECTION));

	map.put(new Actions(Actions.TOGGLE));

	map.put(new Actions(Actions.CANCEL_EDITING));

	map.put(new Actions(Actions.START_EDITING));

	map.put(new Actions(Actions.SELECT_ALL));

	map.put(new Actions(Actions.CLEAR_SELECTION));

	map.put(new Actions(Actions.SCROLL_LEFT));
	map.put(new Actions(Actions.SCROLL_RIGHT));

	map.put(new Actions(Actions.SCROLL_LEFT_EXTEND_SELECTION));
	map.put(new Actions(Actions.SCROLL_RIGHT_EXTEND_SELECTION));

	map.put(new Actions(Actions.SCROLL_RIGHT_CHANGE_LEAD));
	map.put(new Actions(Actions.SCROLL_LEFT_CHANGE_LEAD));

	map.put(new Actions(Actions.EXPAND));
	map.put(new Actions(Actions.COLLAPSE));
	map.put(new Actions(Actions.MOVE_SELECTION_TO_PARENT));

	map.put(new Actions(Actions.ADD_TO_SELECTION));
	map.put(new Actions(Actions.TOGGLE_AND_ANCHOR));
	map.put(new Actions(Actions.EXTEND_TO));
	map.put(new Actions(Actions.MOVE_SELECTION_TO));

	map.put(TransferHandler.getCutAction());
	map.put(TransferHandler.getCopyAction());
	map.put(TransferHandler.getPasteAction());
	}


	public BasicTreeUI() {
	super();
	}

	protected Color getHashColor() {
	return hashColor;
	}

	protected void setHashColor(Color color) {
	hashColor = color;
	}

	public void setLeftChildIndent(int newAmount) {
	leftChildIndent = newAmount;
	totalChildIndent = leftChildIndent + rightChildIndent;
	if(treeState != null)
	treeState.invalidateSizes();
	updateSize();
	}

	public int getLeftChildIndent() {
	return leftChildIndent;
	}

	public void setRightChildIndent(int newAmount) {
	rightChildIndent = newAmount;
	totalChildIndent = leftChildIndent + rightChildIndent;
	if(treeState != null)
	treeState.invalidateSizes();
	updateSize();
	}

	public int getRightChildIndent() {
	return rightChildIndent;
	}

	public void setExpandedIcon(Icon newG) {
	expandedIcon = newG;
	}

	public Icon getExpandedIcon() {
	return expandedIcon;
	}

	public void setCollapsedIcon(Icon newG) {
	collapsedIcon = newG;
	}

	public Icon getCollapsedIcon() {
	return collapsedIcon;
	}

	//
	// Methods for configuring the behavior of the tree. None of them
	// push the value to the JTree instance. You should really only
	// call these methods on the JTree.
	//

	/**
	* Updates the componentListener, if necessary.
	*/
	protected void setLargeModel(boolean largeModel) {
	if(getRowHeight() < 1)
	largeModel = false;
	if(this.largeModel != largeModel) {
	completeEditing();
	this.largeModel = largeModel;
	treeState = createLayoutCache();
	configureLayoutCache();
	updateLayoutCacheExpandedNodesIfNecessary();
	updateSize();
	}
	}

	protected boolean isLargeModel() {
	return largeModel;
	}

	/**
	* Sets the row height, this is forwarded to the treeState.
	*/
	protected void setRowHeight(int rowHeight) {
	completeEditing();
	if(treeState != null) {
	setLargeModel(tree.isLargeModel());
	treeState.setRowHeight(rowHeight);
	updateSize();
	}
	}

	protected int getRowHeight() {
	return (tree == null) ? -1 : tree.getRowHeight();
	}

	/**
	* Sets the TreeCellRenderer to <code>tcr</code>. This invokes
	* <code>updateRenderer</code>.
	*/
	protected void setCellRenderer(TreeCellRenderer tcr) {
	completeEditing();
	updateRenderer();
	if(treeState != null) {
	treeState.invalidateSizes();
	updateSize();
	}
	}

	/**
	* Return currentCellRenderer, which will either be the trees
	* renderer, or defaultCellRenderer, which ever wasn't null.
	*/
	protected TreeCellRenderer getCellRenderer() {
	return currentCellRenderer;
	}

	/**
	* Sets the TreeModel.
	*/
	protected void setModel(TreeModel model) {
	completeEditing();
	if(treeModel != null && treeModelListener != null)
	treeModel.removeTreeModelListener(treeModelListener);
	treeModel = model;
	if(treeModel != null) {
	if(treeModelListener != null)
	treeModel.addTreeModelListener(treeModelListener);
	}
	if(treeState != null) {
	treeState.setModel(model);
	updateLayoutCacheExpandedNodesIfNecessary();
	updateSize();
	}
	}

	protected TreeModel getModel() {
	return treeModel;
	}

	/**
	* Sets the root to being visible.
	*/
	protected void setRootVisible(boolean newValue) {
	completeEditing();
	updateDepthOffset();
	if(treeState != null) {
	treeState.setRootVisible(newValue);
	treeState.invalidateSizes();
	updateSize();
	}
	}

	protected boolean isRootVisible() {
	return (tree != null) ? tree.isRootVisible() : false;
	}

	/**
	* Determines whether the node handles are to be displayed.
	*/
	protected void setShowsRootHandles(boolean newValue) {
	completeEditing();
	updateDepthOffset();
	if(treeState != null) {
	treeState.invalidateSizes();
	updateSize();
	}
	}

	protected boolean getShowsRootHandles() {
	return (tree != null) ? tree.getShowsRootHandles() : false;
	}

	/**
	* Sets the cell editor.
	*/
	protected void setCellEditor(TreeCellEditor editor) {
	updateCellEditor();
	}

	protected TreeCellEditor getCellEditor() {
	return (tree != null) ? tree.getCellEditor() : null;
	}

	/**
	* Configures the receiver to allow, or not allow, editing.
	*/
	protected void setEditable(boolean newValue) {
	updateCellEditor();
	}

	protected boolean isEditable() {
	return (tree != null) ? tree.isEditable() : false;
	}

	/**
	* Resets the selection model. The appropriate listener are installed
	* on the model.
	*/
	protected void setSelectionModel(TreeSelectionModel newLSM) {
	completeEditing();
	if(selectionModelPropertyChangeListener != null &&
	treeSelectionModel != null)
	treeSelectionModel.removePropertyChangeListener
	(selectionModelPropertyChangeListener);
	if(treeSelectionListener != null && treeSelectionModel != null)
	treeSelectionModel.removeTreeSelectionListener
	(treeSelectionListener);
	treeSelectionModel = newLSM;
	if(treeSelectionModel != null) {
	if(selectionModelPropertyChangeListener != null)
	treeSelectionModel.addPropertyChangeListener
	(selectionModelPropertyChangeListener);
	if(treeSelectionListener != null)
	treeSelectionModel.addTreeSelectionListener
	(treeSelectionListener);
	if(treeState != null)
	treeState.setSelectionModel(treeSelectionModel);
	}
	else if(treeState != null)
	treeState.setSelectionModel(null);
	if(tree != null)
	tree.repaint();
	}

	protected TreeSelectionModel getSelectionModel() {
	return treeSelectionModel;
	}

	//
	// TreeUI methods
	//

	/**
	* Returns the Rectangle enclosing the label portion that the
	* last item in path will be drawn into. Will return null if
	* any component in path is currently valid.
	*/
	public Rectangle getPathBounds(JTree tree, TreePath path) {
	if(tree != null && treeState != null) {
	return getPathBounds(path, tree.getInsets(), new Rectangle());
	}
	return null;
	}

	private Rectangle getPathBounds(TreePath path, Insets insets,
	Rectangle bounds) {
	bounds = treeState.getBounds(path, bounds);
	if (bounds != null) {
	if (leftToRight) {
	bounds.x += insets.left;
	} else {
	bounds.x = tree.getWidth() - (bounds.x + bounds.width) -
	insets.right;
	}
	bounds.y += insets.top;
	}
	return bounds;
	}

	/**
	* Returns the path for passed in row. If row is not visible
	* null is returned.
	*/
	public TreePath getPathForRow(JTree tree, int row) {
	return (treeState != null) ? treeState.getPathForRow(row) : null;
	}

	/**
	* Returns the row that the last item identified in path is visible
	* at. Will return -1 if any of the elements in path are not
	* currently visible.
	*/
	public int getRowForPath(JTree tree, TreePath path) {
	return (treeState != null) ? treeState.getRowForPath(path) : -1;
	}

	/**
	* Returns the number of rows that are being displayed.
	*/
	public int getRowCount(JTree tree) {
	return (treeState != null) ? treeState.getRowCount() : 0;
	}

	/**
	* Returns the path to the node that is closest to x,y. If
	* there is nothing currently visible this will return null, otherwise
	* it'll always return a valid path. If you need to test if the
	* returned object is exactly at x, y you should get the bounds for
	* the returned path and test x, y against that.
	*/
	public TreePath getClosestPathForLocation(JTree tree, int x, int y) {
	if(tree != null && treeState != null) {
	// TreeState doesn't care about the x location, hence it isn't
	// adjusted
	y -= tree.getInsets().top;
	return treeState.getPathClosestTo(x, y);
	}
	return null;
	}

	/**
	* Returns true if the tree is being edited. The item that is being
	* edited can be returned by getEditingPath().
	*/
	public boolean isEditing(JTree tree) {
	return (editingComponent != null);
	}

	/**
	* Stops the current editing session. This has no effect if the
	* tree isn't being edited. Returns true if the editor allows the
	* editing session to stop.
	*/
	public boolean stopEditing(JTree tree) {
	if(editingComponent != null && cellEditor.stopCellEditing()) {
	completeEditing(false, false, true);
	return true;
	}
	return false;
	}

	/**
	* Cancels the current editing session.
	*/
	public void cancelEditing(JTree tree) {
	if(editingComponent != null) {
	completeEditing(false, true, false);
	}
	}

	/**
	* Selects the last item in path and tries to edit it. Editing will
	* fail if the CellEditor won't allow it for the selected item.
	*/
	public void startEditingAtPath(JTree tree, TreePath path) {
	tree.scrollPathToVisible(path);
	if(path != null && tree.isVisible(path))
	startEditing(path, null);
	}

	/**
	* Returns the path to the element that is being edited.
	*/
	public TreePath getEditingPath(JTree tree) {
	return editingPath;
	}

	//
	// Install methods
	//

	public void installUI(JComponent c) {
	if ( c == null ) {
	throw new NullPointerException( "null component passed to BasicTreeUI.installUI()" );
	}

	tree = (JTree)c;

	prepareForUIInstall();

	// Boilerplate install block
	installDefaults();
	installKeyboardActions();
	installComponents();
	installListeners();

	completeUIInstall();
	}

	/**
	* Invoked after the <code>tree</code> instance variable has been
	* set, but before any defaults/listeners have been installed.
	*/
	protected void prepareForUIInstall() {
	drawingCache = new Hashtable<TreePath,Boolean>(7);

	// Data member initializations
	leftToRight = BasicGraphicsUtils.isLeftToRight(tree);
	stopEditingInCompleteEditing = true;
	lastSelectedRow = -1;
	leadRow = -1;
	preferredSize = new Dimension();

	largeModel = tree.isLargeModel();
	if(getRowHeight() <= 0)
	largeModel = false;
	setModel(tree.getModel());
	}

	/**
	* Invoked from installUI after all the defaults/listeners have been
	* installed.
	*/
	protected void completeUIInstall() {
	// Custom install code

	this.setShowsRootHandles(tree.getShowsRootHandles());

	updateRenderer();

	updateDepthOffset();

	setSelectionModel(tree.getSelectionModel());

	// Create, if necessary, the TreeState instance.
	treeState = createLayoutCache();
	configureLayoutCache();

	updateSize();
	}

	protected void installDefaults() {
	if(tree.getBackground() == null \|\|
	tree.getBackground() instanceof UIResource) {
	tree.setBackground(UIManager.getColor("Tree.background"));
	}
	if(getHashColor() == null \|\| getHashColor() instanceof UIResource) {
	setHashColor(UIManager.getColor("Tree.hash"));
	}
	if (tree.getFont() == null \|\| tree.getFont() instanceof UIResource)
	tree.setFont( UIManager.getFont("Tree.font") );
	// JTree's original row height is 16. To correctly display the
	// contents on Linux we should have set it to 18, Windows 19 and
	// Solaris 20. As these values vary so much it's too hard to
	// be backward compatable and try to update the row height, we're
	// therefor NOT going to adjust the row height based on font. If the
	// developer changes the font, it's there responsibility to update
	// the row height.

	setExpandedIcon( (Icon)UIManager.get( "Tree.expandedIcon" ) );
	setCollapsedIcon( (Icon)UIManager.get( "Tree.collapsedIcon" ) );

	setLeftChildIndent(((Integer)UIManager.get("Tree.leftChildIndent")).
	intValue());
	setRightChildIndent(((Integer)UIManager.get("Tree.rightChildIndent")).
	intValue());

	LookAndFeel.installProperty(tree, "rowHeight",
	UIManager.get("Tree.rowHeight"));

	largeModel = (tree.isLargeModel() && tree.getRowHeight() > 0);

	Object scrollsOnExpand = UIManager.get("Tree.scrollsOnExpand");
	if (scrollsOnExpand != null) {
	LookAndFeel.installProperty(tree, "scrollsOnExpand", scrollsOnExpand);
	}

	paintLines = UIManager.getBoolean("Tree.paintLines");
	lineTypeDashed = UIManager.getBoolean("Tree.lineTypeDashed");

	Long l = (Long)UIManager.get("Tree.timeFactor");
	timeFactor = (l!=null) ? l.longValue() : 1000L;

	Object showsRootHandles = UIManager.get("Tree.showsRootHandles");
	if (showsRootHandles != null) {
	LookAndFeel.installProperty(tree,
	JTree.SHOWS_ROOT_HANDLES_PROPERTY, showsRootHandles);
	}
	}

	protected void installListeners() {
	if ( (propertyChangeListener = createPropertyChangeListener())
	!= null ) {
	tree.addPropertyChangeListener(propertyChangeListener);
	}
	if ( (mouseListener = createMouseListener()) != null ) {
	tree.addMouseListener(mouseListener);
	if (mouseListener instanceof MouseMotionListener) {
	tree.addMouseMotionListener((MouseMotionListener)mouseListener);
	}
	}
	if ((focusListener = createFocusListener()) != null ) {
	tree.addFocusListener(focusListener);
	}
	if ((keyListener = createKeyListener()) != null) {
	tree.addKeyListener(keyListener);
	}
	if((treeExpansionListener = createTreeExpansionListener()) != null) {
	tree.addTreeExpansionListener(treeExpansionListener);
	}
	if((treeModelListener = createTreeModelListener()) != null &&
	treeModel != null) {
	treeModel.addTreeModelListener(treeModelListener);
	}
	if((selectionModelPropertyChangeListener =
	createSelectionModelPropertyChangeListener()) != null &&
	treeSelectionModel != null) {
	treeSelectionModel.addPropertyChangeListener
	(selectionModelPropertyChangeListener);
	}
	if((treeSelectionListener = createTreeSelectionListener()) != null &&
	treeSelectionModel != null) {
	treeSelectionModel.addTreeSelectionListener(treeSelectionListener);
	}

	TransferHandler th = tree.getTransferHandler();
	if (th == null \|\| th instanceof UIResource) {
	tree.setTransferHandler(defaultTransferHandler);
	// default TransferHandler doesn't support drop
	// so we don't want drop handling
	if (tree.getDropTarget() instanceof UIResource) {
	tree.setDropTarget(null);
	}
	}

	LookAndFeel.installProperty(tree, "opaque", Boolean.TRUE);
	}

	protected void installKeyboardActions() {
	InputMap km = getInputMap(JComponent.
	WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

	SwingUtilities.replaceUIInputMap(tree, JComponent.
	WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
	km);
	km = getInputMap(JComponent.WHEN_FOCUSED);
	SwingUtilities.replaceUIInputMap(tree, JComponent.WHEN_FOCUSED, km);

	LazyActionMap.installLazyActionMap(tree, BasicTreeUI.class,
	"Tree.actionMap");
	}

	InputMap getInputMap(int condition) {
	if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {
	return (InputMap)DefaultLookup.get(tree, this,
	"Tree.ancestorInputMap");
	}
	else if (condition == JComponent.WHEN_FOCUSED) {
	InputMap keyMap = (InputMap)DefaultLookup.get(tree, this,
	"Tree.focusInputMap");
	InputMap rtlKeyMap;

	if (tree.getComponentOrientation().isLeftToRight() \|\|
	((rtlKeyMap = (InputMap)DefaultLookup.get(tree, this,
	"Tree.focusInputMap.RightToLeft")) == null)) {
	return keyMap;
	} else {
	rtlKeyMap.setParent(keyMap);
	return rtlKeyMap;
	}
	}
	return null;
	}

	/**
	* Intalls the subcomponents of the tree, which is the renderer pane.
	*/
	protected void installComponents() {
	if ((rendererPane = createCellRendererPane()) != null) {
	tree.add( rendererPane );
	}
	}

	//
	// Create methods.
	//

	/**
	* Creates an instance of NodeDimensions that is able to determine
	* the size of a given node in the tree.
	*/
	protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
	return new NodeDimensionsHandler();
	}

	/**
	* Creates a listener that is responsible that updates the UI based on
	* how the tree changes.
	*/
	protected PropertyChangeListener createPropertyChangeListener() {
	return getHandler();
	}

	private Handler getHandler() {
	if (handler == null) {
	handler = new Handler();
	}
	return handler;
	}

	/**
	* Creates the listener responsible for updating the selection based on
	* mouse events.
	*/
	protected MouseListener createMouseListener() {
	return getHandler();
	}

	/**
	* Creates a listener that is responsible for updating the display
	* when focus is lost/gained.
	*/
	protected FocusListener createFocusListener() {
	return getHandler();
	}

	/**
	* Creates the listener reponsible for getting key events from
	* the tree.
	*/
	protected KeyListener createKeyListener() {
	return getHandler();
	}

	/**
	* Creates the listener responsible for getting property change
	* events from the selection model.
	*/
	protected PropertyChangeListener createSelectionModelPropertyChangeListener() {
	return getHandler();
	}

	/**
	* Creates the listener that updates the display based on selection change
	* methods.
	*/
	protected TreeSelectionListener createTreeSelectionListener() {
	return getHandler();
	}

	/**
	* Creates a listener to handle events from the current editor.
	*/
	protected CellEditorListener createCellEditorListener() {
	return getHandler();
	}

	/**
	* Creates and returns a new ComponentHandler. This is used for
	* the large model to mark the validCachedPreferredSize as invalid
	* when the component moves.
	*/
	protected ComponentListener createComponentListener() {
	return new ComponentHandler();
	}

	/**
	* Creates and returns the object responsible for updating the treestate
	* when nodes expanded state changes.
	*/
	protected TreeExpansionListener createTreeExpansionListener() {
	return getHandler();
	}

	/**
	* Creates the object responsible for managing what is expanded, as
	* well as the size of nodes.
	*/
	protected AbstractLayoutCache createLayoutCache() {
	if(isLargeModel() && getRowHeight() > 0) {
	return new FixedHeightLayoutCache();
	}
	return new VariableHeightLayoutCache();
	}

	/**
	* Returns the renderer pane that renderer components are placed in.
	*/
	protected CellRendererPane createCellRendererPane() {
	return new CellRendererPane();
	}

	/**
	* Creates a default cell editor.
	*/
	protected TreeCellEditor createDefaultCellEditor() {
	if(currentCellRenderer != null &&
	(currentCellRenderer instanceof DefaultTreeCellRenderer)) {
	DefaultTreeCellEditor editor = new DefaultTreeCellEditor
	(tree, (DefaultTreeCellRenderer)currentCellRenderer);

	return editor;
	}
	return new DefaultTreeCellEditor(tree, null);
	}

	/**
	* Returns the default cell renderer that is used to do the
	* stamping of each node.
	*/
	protected TreeCellRenderer createDefaultCellRenderer() {
	return new DefaultTreeCellRenderer();
	}

	/**
	* Returns a listener that can update the tree when the model changes.
	*/
	protected TreeModelListener createTreeModelListener() {
	return getHandler();
	}

	//
	// Uninstall methods
	//

	public void uninstallUI(JComponent c) {
	completeEditing();

	prepareForUIUninstall();

	uninstallDefaults();
	uninstallListeners();
	uninstallKeyboardActions();
	uninstallComponents();

	completeUIUninstall();
	}

	protected void prepareForUIUninstall() {
	}

	protected void completeUIUninstall() {
	if(createdRenderer) {
	tree.setCellRenderer(null);
	}
	if(createdCellEditor) {
	tree.setCellEditor(null);
	}
	cellEditor = null;
	currentCellRenderer = null;
	rendererPane = null;
	componentListener = null;
	propertyChangeListener = null;
	mouseListener = null;
	focusListener = null;
	keyListener = null;
	setSelectionModel(null);
	treeState = null;
	drawingCache = null;
	selectionModelPropertyChangeListener = null;
	tree = null;
	treeModel = null;
	treeSelectionModel = null;
	treeSelectionListener = null;
	treeExpansionListener = null;
	}

	protected void uninstallDefaults() {
	if (tree.getTransferHandler() instanceof UIResource) {
	tree.setTransferHandler(null);
	}
	}

	protected void uninstallListeners() {
	if(componentListener != null) {
	tree.removeComponentListener(componentListener);
	}
	if (propertyChangeListener != null) {
	tree.removePropertyChangeListener(propertyChangeListener);
	}
	if (mouseListener != null) {
	tree.removeMouseListener(mouseListener);
	if (mouseListener instanceof MouseMotionListener) {
	tree.removeMouseMotionListener((MouseMotionListener)mouseListener);
	}
	}
	if (focusListener != null) {
	tree.removeFocusListener(focusListener);
	}
	if (keyListener != null) {
	tree.removeKeyListener(keyListener);
	}
	if(treeExpansionListener != null) {
	tree.removeTreeExpansionListener(treeExpansionListener);
	}
	if(treeModel != null && treeModelListener != null) {
	treeModel.removeTreeModelListener(treeModelListener);
	}
	if(selectionModelPropertyChangeListener != null &&
	treeSelectionModel != null) {
	treeSelectionModel.removePropertyChangeListener
	(selectionModelPropertyChangeListener);
	}
	if(treeSelectionListener != null && treeSelectionModel != null) {
	treeSelectionModel.removeTreeSelectionListener
	(treeSelectionListener);
	}
	handler = null;
	}

	protected void uninstallKeyboardActions() {
	SwingUtilities.replaceUIActionMap(tree, null);
	SwingUtilities.replaceUIInputMap(tree, JComponent.
	WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
	null);
	SwingUtilities.replaceUIInputMap(tree, JComponent.WHEN_FOCUSED, null);
	}

	/**
	* Uninstalls the renderer pane.
	*/
	protected void uninstallComponents() {
	if(rendererPane != null) {
	tree.remove(rendererPane);
	}
	}

	/**
	* Recomputes the right margin, and invalidates any tree states
	*/
	private void redoTheLayout() {
	if (treeState != null) {
	treeState.invalidateSizes();
	}
	}

	/**
	* Returns the baseline.
	*
	* @throws NullPointerException {@inheritDoc}
	* @throws IllegalArgumentException {@inheritDoc}
	* @see javax.swing.JComponent#getBaseline(int, int)
	* @since 1.6
	*/
	public int getBaseline(JComponent c, int width, int height) {
	super.getBaseline(c, width, height);
	UIDefaults lafDefaults = UIManager.getLookAndFeelDefaults();
	Component renderer = (Component)lafDefaults.get(
	BASELINE_COMPONENT_KEY);
	if (renderer == null) {
	TreeCellRenderer tcr = createDefaultCellRenderer();
	renderer = tcr.getTreeCellRendererComponent(
	tree, "a", false, false, false, -1, false);
	lafDefaults.put(BASELINE_COMPONENT_KEY, renderer);
	}
	int rowHeight = tree.getRowHeight();
	int baseline;
	if (rowHeight > 0) {
	baseline = renderer.getBaseline(Integer.MAX_VALUE, rowHeight);
	}
	else {
	Dimension pref = renderer.getPreferredSize();
	baseline = renderer.getBaseline(pref.width, pref.height);
	}
	return baseline + tree.getInsets().top;
	}

	/**
	* Returns an enum indicating how the baseline of the component
	* changes as the size changes.
	*
	* @throws NullPointerException {@inheritDoc}
	* @see javax.swing.JComponent#getBaseline(int, int)
	* @since 1.6
	*/
	public Component.BaselineResizeBehavior getBaselineResizeBehavior(
	JComponent c) {
	super.getBaselineResizeBehavior(c);
	return Component.BaselineResizeBehavior.CONSTANT_ASCENT;
	}

	//
	// Painting routines.
	//

	public void paint(Graphics g, JComponent c) {
	if (tree != c) {
	throw new InternalError("incorrect component");
	}

	// Should never happen if installed for a UI
	if(treeState == null) {
	return;
	}

	Rectangle paintBounds = g.getClipBounds();
	Insets insets = tree.getInsets();
	TreePath initialPath = getClosestPathForLocation
	(tree, 0, paintBounds.y);
	Enumeration paintingEnumerator = treeState.getVisiblePathsFrom
	(initialPath);
	int row = treeState.getRowForPath(initialPath);
	int endY = paintBounds.y + paintBounds.height;

	drawingCache.clear();

	if(initialPath != null && paintingEnumerator != null) {
	TreePath parentPath = initialPath;

	// Draw the lines, knobs, and rows

	// Find each parent and have them draw a line to their last child
	parentPath = parentPath.getParentPath();
	while(parentPath != null) {
	paintVerticalPartOfLeg(g, paintBounds, insets, parentPath);
	drawingCache.put(parentPath, Boolean.TRUE);
	parentPath = parentPath.getParentPath();
	}

	boolean done = false;
	// Information for the node being rendered.
	boolean isExpanded;
	boolean hasBeenExpanded;
	boolean isLeaf;
	Rectangle boundsBuffer = new Rectangle();
	Rectangle bounds;
	TreePath path;
	boolean rootVisible = isRootVisible();

	while(!done && paintingEnumerator.hasMoreElements()) {
	path = (TreePath)paintingEnumerator.nextElement();
	if(path != null) {
	isLeaf = treeModel.isLeaf(path.getLastPathComponent());
	if(isLeaf)
	isExpanded = hasBeenExpanded = false;
	else {
	isExpanded = treeState.getExpandedState(path);
	hasBeenExpanded = tree.hasBeenExpanded(path);
	}
	bounds = getPathBounds(path, insets, boundsBuffer);
	if(bounds == null)
	// This will only happen if the model changes out
	// from under us (usually in another thread).
	// Swing isn't multithreaded, but I'll put this
	// check in anyway.
	return;
	// See if the vertical line to the parent has been drawn.
	parentPath = path.getParentPath();
	if(parentPath != null) {
	if(drawingCache.get(parentPath) == null) {
	paintVerticalPartOfLeg(g, paintBounds,
	insets, parentPath);
	drawingCache.put(parentPath, Boolean.TRUE);
	}
	paintHorizontalPartOfLeg(g, paintBounds, insets,
	bounds, path, row,
	isExpanded,
	hasBeenExpanded, isLeaf);
	}
	else if(rootVisible && row == 0) {
	paintHorizontalPartOfLeg(g, paintBounds, insets,
	bounds, path, row,
	isExpanded,
	hasBeenExpanded, isLeaf);
	}
	if(shouldPaintExpandControl(path, row, isExpanded,
	hasBeenExpanded, isLeaf)) {
	paintExpandControl(g, paintBounds, insets, bounds,
	path, row, isExpanded,
	hasBeenExpanded, isLeaf);
	}
	paintRow(g, paintBounds, insets, bounds, path,
	row, isExpanded, hasBeenExpanded, isLeaf);
	if((bounds.y + bounds.height) >= endY)
	done = true;
	}
	else {
	done = true;
	}
	row++;
	}
	}

	paintDropLine(g);

	// Empty out the renderer pane, allowing renderers to be gc'ed.
	rendererPane.removeAll();

	drawingCache.clear();
	}

	/**
	* Tells if a {@code DropLocation} should be indicated by a line between
	* nodes. This is meant for {@code javax.swing.DropMode.INSERT} and
	* {@code javax.swing.DropMode.ON_OR_INSERT} drop modes.
	*
	* @param loc a {@code DropLocation}
	* @return {@code true} if the drop location should be shown as a line
	* @since 1.7
	*/
	protected boolean isDropLine(JTree.DropLocation loc) {
	return loc != null && loc.getPath() != null && loc.getChildIndex() != -1;
	}

	/**
	* Paints the drop line.
	*
	* @param g {@code Graphics} object to draw on
	* @since 1.7
	*/
	protected void paintDropLine(Graphics g) {
	JTree.DropLocation loc = tree.getDropLocation();
	if (!isDropLine(loc)) {
	return;
	}

	Color c = UIManager.getColor("Tree.dropLineColor");
	if (c != null) {
	g.setColor(c);
	Rectangle rect = getDropLineRect(loc);
	g.fillRect(rect.x, rect.y, rect.width, rect.height);
	}
	}

	/**
	* Returns a unbounding box for the drop line.
	*
	* @param loc a {@code DropLocation}
	* @return bounding box for the drop line
	* @since 1.7
	*/
	protected Rectangle getDropLineRect(JTree.DropLocation loc) {
	Rectangle rect;
	TreePath path = loc.getPath();
	int index = loc.getChildIndex();
	boolean ltr = leftToRight;

	Insets insets = tree.getInsets();

	if (tree.getRowCount() == 0) {
	rect = new Rectangle(insets.left,
	insets.top,
	tree.getWidth() - insets.left - insets.right,
	0);
	} else {
	TreeModel model = getModel();
	Object root = model.getRoot();

	if (path.getLastPathComponent() == root
	&& index >= model.getChildCount(root)) {

	rect = tree.getRowBounds(tree.getRowCount() - 1);
	rect.y = rect.y + rect.height;
	Rectangle xRect;

	if (!tree.isRootVisible()) {
	xRect = tree.getRowBounds(0);
	} else if (model.getChildCount(root) == 0){
	xRect = tree.getRowBounds(0);
	xRect.x += totalChildIndent;
	xRect.width -= totalChildIndent + totalChildIndent;
	} else {
	TreePath lastChildPath = path.pathByAddingChild(
	model.getChild(root, model.getChildCount(root) - 1));
	xRect = tree.getPathBounds(lastChildPath);
	}

	rect.x = xRect.x;
	rect.width = xRect.width;
	} else {
	rect = tree.getPathBounds(path.pathByAddingChild(
	model.getChild(path.getLastPathComponent(), index)));
	}
	}

	if (rect.y != 0) {
	rect.y--;
	}

	if (!ltr) {
	rect.x = rect.x + rect.width - 100;
	}

	rect.width = 100;
	rect.height = 2;

	return rect;
	}

	/**
	* Paints the horizontal part of the leg. The receiver should
	* NOT modify <code>clipBounds</code>, or <code>insets</code>.<p>
	* NOTE: <code>parentRow</code> can be -1 if the root is not visible.
	*/
	protected void paintHorizontalPartOfLeg(Graphics g, Rectangle clipBounds,
	Insets insets, Rectangle bounds,
	TreePath path, int row,
	boolean isExpanded,
	boolean hasBeenExpanded, boolean
	isLeaf) {
	if (!paintLines) {
	return;
	}

	// Don't paint the legs for the root'ish node if the
	int depth = path.getPathCount() - 1;
	if((depth == 0 \|\| (depth == 1 && !isRootVisible())) &&
	!getShowsRootHandles()) {
	return;
	}

	int clipLeft = clipBounds.x;
	int clipRight = clipBounds.x + clipBounds.width;
	int clipTop = clipBounds.y;
	int clipBottom = clipBounds.y + clipBounds.height;
	int lineY = bounds.y + bounds.height / 2;

	if (leftToRight) {
	int leftX = bounds.x - getRightChildIndent();
	int nodeX = bounds.x - getHorizontalLegBuffer();

	if(lineY >= clipTop
	&& lineY < clipBottom
	&& nodeX >= clipLeft
	&& leftX < clipRight
	&& leftX < nodeX) {

	g.setColor(getHashColor());
	paintHorizontalLine(g, tree, lineY, leftX, nodeX - 1);
	}
	} else {
	int nodeX = bounds.x + bounds.width + getHorizontalLegBuffer();
	int rightX = bounds.x + bounds.width + getRightChildIndent();

	if(lineY >= clipTop
	&& lineY < clipBottom
	&& rightX >= clipLeft
	&& nodeX < clipRight
	&& nodeX < rightX) {

	g.setColor(getHashColor());
	paintHorizontalLine(g, tree, lineY, nodeX, rightX - 1);
	}
	}
	}

	/**
	* Paints the vertical part of the leg. The receiver should
	* NOT modify <code>clipBounds</code>, <code>insets</code>.
	*/
	protected void paintVerticalPartOfLeg(Graphics g, Rectangle clipBounds,
	Insets insets, TreePath path) {
	if (!paintLines) {
	return;
	}

	int depth = path.getPathCount() - 1;
	if (depth == 0 && !getShowsRootHandles() && !isRootVisible()) {
	return;
	}
	int lineX = getRowX(-1, depth + 1);
	if (leftToRight) {
	lineX = lineX - getRightChildIndent() + insets.left;
	}
	else {
	lineX = tree.getWidth() - lineX - insets.right +
	getRightChildIndent() - 1;
	}
	int clipLeft = clipBounds.x;
	int clipRight = clipBounds.x + (clipBounds.width - 1);

	if (lineX >= clipLeft && lineX <= clipRight) {
	int clipTop = clipBounds.y;
	int clipBottom = clipBounds.y + clipBounds.height;
	Rectangle parentBounds = getPathBounds(tree, path);
	Rectangle lastChildBounds = getPathBounds(tree,
	getLastChildPath(path));

	if(lastChildBounds == null)
	// This shouldn't happen, but if the model is modified
	// in another thread it is possible for this to happen.
	// Swing isn't multithreaded, but I'll add this check in
	// anyway.
	return;

	int top;

	if(parentBounds == null) {
	top = Math.max(insets.top + getVerticalLegBuffer(),
	clipTop);
	}
	else
	top = Math.max(parentBounds.y + parentBounds.height +
	getVerticalLegBuffer(), clipTop);
	if(depth == 0 && !isRootVisible()) {
	TreeModel model = getModel();

	if(model != null) {
	Object root = model.getRoot();

	if(model.getChildCount(root) > 0) {
	parentBounds = getPathBounds(tree, path.
	pathByAddingChild(model.getChild(root, 0)));
	if(parentBounds != null)
	top = Math.max(insets.top + getVerticalLegBuffer(),
	parentBounds.y +
	parentBounds.height / 2);
	}
	}
	}

	int bottom = Math.min(lastChildBounds.y +
	(lastChildBounds.height / 2), clipBottom);

	if (top <= bottom) {
	g.setColor(getHashColor());
	paintVerticalLine(g, tree, lineX, top, bottom);
	}
	}
	}

	/**
	* Paints the expand (toggle) part of a row. The receiver should
	* NOT modify <code>clipBounds</code>, or <code>insets</code>.
	*/
	protected void paintExpandControl(Graphics g,
	Rectangle clipBounds, Insets insets,
	Rectangle bounds, TreePath path,
	int row, boolean isExpanded,
	boolean hasBeenExpanded,
	boolean isLeaf) {
	Object value = path.getLastPathComponent();

	// Draw icons if not a leaf and either hasn't been loaded,
	// or the model child count is > 0.
	if (!isLeaf && (!hasBeenExpanded \|\|
	treeModel.getChildCount(value) > 0)) {
	int middleXOfKnob;
	if (leftToRight) {
	middleXOfKnob = bounds.x - getRightChildIndent() + 1;
	} else {
	middleXOfKnob = bounds.x + bounds.width + getRightChildIndent() - 1;
	}
	int middleYOfKnob = bounds.y + (bounds.height / 2);

	if (isExpanded) {
	Icon expandedIcon = getExpandedIcon();
	if(expandedIcon != null)
	drawCentered(tree, g, expandedIcon, middleXOfKnob,
	middleYOfKnob );
	}
	else {
	Icon collapsedIcon = getCollapsedIcon();
	if(collapsedIcon != null)
	drawCentered(tree, g, collapsedIcon, middleXOfKnob,
	middleYOfKnob);
	}
	}
	}

	/**
	* Paints the renderer part of a row. The receiver should
	* NOT modify <code>clipBounds</code>, or <code>insets</code>.
	*/
	protected void paintRow(Graphics g, Rectangle clipBounds,
	Insets insets, Rectangle bounds, TreePath path,
	int row, boolean isExpanded,
	boolean hasBeenExpanded, boolean isLeaf) {
	// Don't paint the renderer if editing this row.
	if(editingComponent != null && editingRow == row)
	return;

	int leadIndex;

	if(tree.hasFocus()) {
	leadIndex = getLeadSelectionRow();
	}
	else
	leadIndex = -1;

	Component component;

	component = currentCellRenderer.getTreeCellRendererComponent
	(tree, path.getLastPathComponent(),
	tree.isRowSelected(row), isExpanded, isLeaf, row,
	(leadIndex == row));

	rendererPane.paintComponent(g, component, tree, bounds.x, bounds.y,
	bounds.width, bounds.height, true);
	}

	/**
	* Returns true if the expand (toggle) control should be drawn for
	* the specified row.
	*/
	protected boolean shouldPaintExpandControl(TreePath path, int row,
	boolean isExpanded,
	boolean hasBeenExpanded,
	boolean isLeaf) {
	if(isLeaf)
	return false;

	int depth = path.getPathCount() - 1;

	if((depth == 0 \|\| (depth == 1 && !isRootVisible())) &&
	!getShowsRootHandles())
	return false;
	return true;
	}

	/**
	* Paints a vertical line.
	*/
	protected void paintVerticalLine(Graphics g, JComponent c, int x, int top,
	int bottom) {
	if (lineTypeDashed) {
	drawDashedVerticalLine(g, x, top, bottom);
	} else {
	g.drawLine(x, top, x, bottom);
	}
	}

	/**
	* Paints a horizontal line.
	*/
	protected void paintHorizontalLine(Graphics g, JComponent c, int y,
	int left, int right) {
	if (lineTypeDashed) {
	drawDashedHorizontalLine(g, y, left, right);
	} else {
	g.drawLine(left, y, right, y);
	}
	}

	/**
	* The vertical element of legs between nodes starts at the bottom of the
	* parent node by default. This method makes the leg start below that.
	*/
	protected int getVerticalLegBuffer() {
	return 0;
	}

	/**
	* The horizontal element of legs between nodes starts at the
	* right of the left-hand side of the child node by default. This
	* method makes the leg end before that.
	*/
	protected int getHorizontalLegBuffer() {
	return 0;
	}

	private int findCenteredX(int x, int iconWidth) {
	return leftToRight
	? x - (int)Math.ceil(iconWidth / 2.0)
	: x - (int)Math.floor(iconWidth / 2.0);
	}

	//
	// Generic painting methods
	//

	// Draws the icon centered at (x,y)
	protected void drawCentered(Component c, Graphics graphics, Icon icon,
	int x, int y) {
	icon.paintIcon(c, graphics,
	findCenteredX(x, icon.getIconWidth()),
	y - icon.getIconHeight() / 2);
	}

	// This method is slow -- revisit when Java2D is ready.
	// assumes x1 <= x2
	protected void drawDashedHorizontalLine(Graphics g, int y, int x1, int x2){
	// Drawing only even coordinates helps join line segments so they
	// appear as one line. This can be defeated by translating the
	// Graphics by an odd amount.
	x1 += (x1 % 2);

	for (int x = x1; x <= x2; x+=2) {
	g.drawLine(x, y, x, y);
	}
	}

	// This method is slow -- revisit when Java2D is ready.
	// assumes y1 <= y2
	protected void drawDashedVerticalLine(Graphics g, int x, int y1, int y2) {
	// Drawing only even coordinates helps join line segments so they
	// appear as one line. This can be defeated by translating the
	// Graphics by an odd amount.
	y1 += (y1 % 2);

	for (int y = y1; y <= y2; y+=2) {
	g.drawLine(x, y, x, y);
	}
	}

	//
	// Various local methods
	//

	/**
	* Returns the location, along the x-axis, to render a particular row
	* at. The return value does not include any Insets specified on the JTree.
	* This does not check for the validity of the row or depth, it is assumed
	* to be correct and will not throw an Exception if the row or depth
	* doesn't match that of the tree.
	*
	* @param row Row to return x location for
	* @param depth Depth of the row
	* @return amount to indent the given row.
	* @since 1.5
	*/
	protected int getRowX(int row, int depth) {
	return totalChildIndent * (depth + depthOffset);
	}

	/**
	* Makes all the nodes that are expanded in JTree expanded in LayoutCache.
	* This invokes updateExpandedDescendants with the root path.
	*/
	protected void updateLayoutCacheExpandedNodes() {
	if(treeModel != null && treeModel.getRoot() != null)
	updateExpandedDescendants(new TreePath(treeModel.getRoot()));
	}

	private void updateLayoutCacheExpandedNodesIfNecessary() {
	if (treeModel != null && treeModel.getRoot() != null) {
	TreePath rootPath = new TreePath(treeModel.getRoot());
	if (tree.isExpanded(rootPath)) {
	updateLayoutCacheExpandedNodes();
	} else {
	treeState.setExpandedState(rootPath, false);
	}
	}
	}

	/**
	* Updates the expanded state of all the descendants of <code>path</code>
	* by getting the expanded descendants from the tree and forwarding
	* to the tree state.
	*/
	protected void updateExpandedDescendants(TreePath path) {
	completeEditing();
	if(treeState != null) {
	treeState.setExpandedState(path, true);

	Enumeration descendants = tree.getExpandedDescendants(path);

	if(descendants != null) {
	while(descendants.hasMoreElements()) {
	path = (TreePath)descendants.nextElement();
	treeState.setExpandedState(path, true);
	}
	}
	updateLeadSelectionRow();
	updateSize();
	}
	}

	/**
	* Returns a path to the last child of <code>parent</code>.
	*/
	protected TreePath getLastChildPath(TreePath parent) {
	if(treeModel != null) {
	int childCount = treeModel.getChildCount
	(parent.getLastPathComponent());

	if(childCount > 0)
	return parent.pathByAddingChild(treeModel.getChild
	(parent.getLastPathComponent(), childCount - 1));
	}
	return null;
	}

	/**
	* Updates how much each depth should be offset by.
	*/
	protected void updateDepthOffset() {
	if(isRootVisible()) {
	if(getShowsRootHandles())
	depthOffset = 1;
	else
	depthOffset = 0;
	}
	else if(!getShowsRootHandles())
	depthOffset = -1;
	else
	depthOffset = 0;
	}

	/**
	* Updates the cellEditor based on the editability of the JTree that
	* we're contained in. If the tree is editable but doesn't have a
	* cellEditor, a basic one will be used.
	*/
	protected void updateCellEditor() {
	TreeCellEditor newEditor;

	completeEditing();
	if(tree == null)
	newEditor = null;
	else {
	if(tree.isEditable()) {
	newEditor = tree.getCellEditor();
	if(newEditor == null) {
	newEditor = createDefaultCellEditor();
	if(newEditor != null) {
	tree.setCellEditor(newEditor);
	createdCellEditor = true;
	}
	}
	}
	else
	newEditor = null;
	}
	if(newEditor != cellEditor) {
	if(cellEditor != null && cellEditorListener != null)
	cellEditor.removeCellEditorListener(cellEditorListener);
	cellEditor = newEditor;
	if(cellEditorListener == null)
	cellEditorListener = createCellEditorListener();
	if(newEditor != null && cellEditorListener != null)
	newEditor.addCellEditorListener(cellEditorListener);
	createdCellEditor = false;
	}
	}

	/**
	* Messaged from the tree we're in when the renderer has changed.
	*/
	protected void updateRenderer() {
	if(tree != null) {
	TreeCellRenderer newCellRenderer;

	newCellRenderer = tree.getCellRenderer();
	if(newCellRenderer == null) {
	tree.setCellRenderer(createDefaultCellRenderer());
	createdRenderer = true;
	}
	else {
	createdRenderer = false;
	currentCellRenderer = newCellRenderer;
	if(createdCellEditor) {
	tree.setCellEditor(null);
	}
	}
	}
	else {
	createdRenderer = false;
	currentCellRenderer = null;
	}
	updateCellEditor();
	}

	/**
	* Resets the TreeState instance based on the tree we're providing the
	* look and feel for.
	*/
	protected void configureLayoutCache() {
	if(treeState != null && tree != null) {
	if(nodeDimensions == null)
	nodeDimensions = createNodeDimensions();
	treeState.setNodeDimensions(nodeDimensions);
	treeState.setRootVisible(tree.isRootVisible());
	treeState.setRowHeight(tree.getRowHeight());
	treeState.setSelectionModel(getSelectionModel());
	// Only do this if necessary, may loss state if call with
	// same model as it currently has.
	if(treeState.getModel() != tree.getModel())
	treeState.setModel(tree.getModel());
	updateLayoutCacheExpandedNodesIfNecessary();
	// Create a listener to update preferred size when bounds
	// changes, if necessary.
	if(isLargeModel()) {
	if(componentListener == null) {
	componentListener = createComponentListener();
	if(componentListener != null)
	tree.addComponentListener(componentListener);
	}
	}
	else if(componentListener != null) {
	tree.removeComponentListener(componentListener);
	componentListener = null;
	}
	}
	else if(componentListener != null) {
	tree.removeComponentListener(componentListener);
	componentListener = null;
	}
	}

	/**
	* Marks the cached size as being invalid, and messages the
	* tree with <code>treeDidChange</code>.
	*/
	protected void updateSize() {
	validCachedPreferredSize = false;
	tree.treeDidChange();
	}

	private void updateSize0() {
	validCachedPreferredSize = false;
	tree.revalidate();
	}

	/**
	* Updates the <code>preferredSize</code> instance variable,
	* which is returned from <code>getPreferredSize()</code>.<p>
	* For left to right orientations, the size is determined from the
	* current AbstractLayoutCache. For RTL orientations, the preferred size
	* becomes the width minus the minimum x position.
	*/
	protected void updateCachedPreferredSize() {
	if(treeState != null) {
	Insets i = tree.getInsets();

	if(isLargeModel()) {
	Rectangle visRect = tree.getVisibleRect();

	if (visRect.x == 0 && visRect.y == 0 &&
	visRect.width == 0 && visRect.height == 0 &&
	tree.getVisibleRowCount() > 0) {
	// The tree doesn't have a valid bounds yet. Calculate
	// based on visible row count.
	visRect.width = 1;
	visRect.height = tree.getRowHeight() *
	tree.getVisibleRowCount();
	} else {
	visRect.x -= i.left;
	visRect.y -= i.top;
	}
	// we should consider a non-visible area above
	Component component = SwingUtilities.getUnwrappedParent(tree);
	if (component instanceof JViewport) {
	component = component.getParent();
	if (component instanceof JScrollPane) {
	JScrollPane pane = (JScrollPane) component;
	JScrollBar bar = pane.getHorizontalScrollBar();
	if ((bar != null) && bar.isVisible()) {
	int height = bar.getHeight();
	visRect.y -= height;
	visRect.height += height;
	}
	}
	}
	preferredSize.width = treeState.getPreferredWidth(visRect);
	}
	else {
	preferredSize.width = treeState.getPreferredWidth(null);
	}
	preferredSize.height = treeState.getPreferredHeight();
	preferredSize.width += i.left + i.right;
	preferredSize.height += i.top + i.bottom;
	}
	validCachedPreferredSize = true;
	}

	/**
	* Messaged from the VisibleTreeNode after it has been expanded.
	*/
	protected void pathWasExpanded(TreePath path) {
	if(tree != null) {
	tree.fireTreeExpanded(path);
	}
	}

	/**
	* Messaged from the VisibleTreeNode after it has collapsed.
	*/
	protected void pathWasCollapsed(TreePath path) {
	if(tree != null) {
	tree.fireTreeCollapsed(path);
	}
	}

	/**
	* Ensures that the rows identified by beginRow through endRow are
	* visible.
	*/
	protected void ensureRowsAreVisible(int beginRow, int endRow) {
	if(tree != null && beginRow >= 0 && endRow < getRowCount(tree)) {
	boolean scrollVert = DefaultLookup.getBoolean(tree, this,
	"Tree.scrollsHorizontallyAndVertically", false);
	if(beginRow == endRow) {
	Rectangle scrollBounds = getPathBounds(tree, getPathForRow
	(tree, beginRow));

	if(scrollBounds != null) {
	if (!scrollVert) {
	scrollBounds.x = tree.getVisibleRect().x;
	scrollBounds.width = 1;
	}
	tree.scrollRectToVisible(scrollBounds);
	}
	}
	else {
	Rectangle beginRect = getPathBounds(tree, getPathForRow
	(tree, beginRow));
	if (beginRect != null) {
	Rectangle visRect = tree.getVisibleRect();
	Rectangle testRect = beginRect;
	int beginY = beginRect.y;
	int maxY = beginY + visRect.height;

	for(int counter = beginRow + 1; counter <= endRow; counter++) {
	testRect = getPathBounds(tree,
	getPathForRow(tree, counter));
	if (testRect == null) {
	return;
	}
	if((testRect.y + testRect.height) > maxY)
	counter = endRow;
	}
	tree.scrollRectToVisible(new Rectangle(visRect.x, beginY, 1,
	testRect.y + testRect.height-
	beginY));
	}
	}
	}
	}

	/** Sets the preferred minimum size.
	*/
	public void setPreferredMinSize(Dimension newSize) {
	preferredMinSize = newSize;
	}

	/** Returns the minimum preferred size.
	*/
	public Dimension getPreferredMinSize() {
	if(preferredMinSize == null)
	return null;
	return new Dimension(preferredMinSize);
	}

	/** Returns the preferred size to properly display the tree,
	* this is a cover method for getPreferredSize(c, true).
	*/
	public Dimension getPreferredSize(JComponent c) {
	return getPreferredSize(c, true);
	}

	/** Returns the preferred size to represent the tree in
	* <I>c</I>. If <I>checkConsistency</I> is true
	* <b>checkConsistency</b> is messaged first.
	*/
	public Dimension getPreferredSize(JComponent c,
	boolean checkConsistency) {
	Dimension pSize = this.getPreferredMinSize();

	if(!validCachedPreferredSize)
	updateCachedPreferredSize();
	if(tree != null) {
	if(pSize != null)
	return new Dimension(Math.max(pSize.width,
	preferredSize.width),
	Math.max(pSize.height, preferredSize.height));
	return new Dimension(preferredSize.width, preferredSize.height);
	}
	else if(pSize != null)
	return pSize;
	else
	return new Dimension(0, 0);
	}

	/**
	* Returns the minimum size for this component. Which will be
	* the min preferred size or 0, 0.
	*/
	public Dimension getMinimumSize(JComponent c) {
	if(this.getPreferredMinSize() != null)
	return this.getPreferredMinSize();
	return new Dimension(0, 0);
	}

	/**
	* Returns the maximum size for this component, which will be the
	* preferred size if the instance is currently in a JTree, or 0, 0.
	*/
	public Dimension getMaximumSize(JComponent c) {
	if(tree != null)
	return getPreferredSize(tree);
	if(this.getPreferredMinSize() != null)
	return this.getPreferredMinSize();
	return new Dimension(0, 0);
	}


	/**
	* Messages to stop the editing session. If the UI the receiver
	* is providing the look and feel for returns true from
	* <code>getInvokesStopCellEditing</code>, stopCellEditing will
	* invoked on the current editor. Then completeEditing will
	* be messaged with false, true, false to cancel any lingering
	* editing.
	*/
	protected void completeEditing() {
	/* If should invoke stopCellEditing, try that */
	if(tree.getInvokesStopCellEditing() &&
	stopEditingInCompleteEditing && editingComponent != null) {
	cellEditor.stopCellEditing();
	}
	/* Invoke cancelCellEditing, this will do nothing if stopCellEditing
	was successful. */
	completeEditing(false, true, false);
	}

	/**
	* Stops the editing session. If messageStop is true the editor
	* is messaged with stopEditing, if messageCancel is true the
	* editor is messaged with cancelEditing. If messageTree is true
	* the treeModel is messaged with valueForPathChanged.
	*/
	protected void completeEditing(boolean messageStop,
	boolean messageCancel,
	boolean messageTree) {
	if(stopEditingInCompleteEditing && editingComponent != null) {
	Component oldComponent = editingComponent;
	TreePath oldPath = editingPath;
	TreeCellEditor oldEditor = cellEditor;
	Object newValue = oldEditor.getCellEditorValue();
	Rectangle editingBounds = getPathBounds(tree,
	editingPath);
	boolean requestFocus = (tree != null &&
	(tree.hasFocus() \|\| SwingUtilities.
	findFocusOwner(editingComponent) != null));

	editingComponent = null;
	editingPath = null;
	if(messageStop)
	oldEditor.stopCellEditing();
	else if(messageCancel)
	oldEditor.cancelCellEditing();
	tree.remove(oldComponent);
	if(editorHasDifferentSize) {
	treeState.invalidatePathBounds(oldPath);
	updateSize();
	}
	else if (editingBounds != null) {
	editingBounds.x = 0;
	editingBounds.width = tree.getSize().width;
	tree.repaint(editingBounds);
	}
	if(requestFocus)
	tree.requestFocus();
	if(messageTree)
	treeModel.valueForPathChanged(oldPath, newValue);
	}
	}

	// cover method for startEditing that allows us to pass extra
	// information into that method via a class variable
	private boolean startEditingOnRelease(TreePath path,
	MouseEvent event,
	MouseEvent releaseEvent) {
	this.releaseEvent = releaseEvent;
	try {
	return startEditing(path, event);
	} finally {
	this.releaseEvent = null;
	}
	}

	/**
	* Will start editing for node if there is a cellEditor and
	* shouldSelectCell returns true.<p>
	* This assumes that path is valid and visible.
	*/
	protected boolean startEditing(TreePath path, MouseEvent event) {
	if (isEditing(tree) && tree.getInvokesStopCellEditing() &&
	!stopEditing(tree)) {
	return false;
	}
	completeEditing();
	if(cellEditor != null && tree.isPathEditable(path)) {
	int row = getRowForPath(tree, path);

	if(cellEditor.isCellEditable(event)) {
	editingComponent = cellEditor.getTreeCellEditorComponent
	(tree, path.getLastPathComponent(),
	tree.isPathSelected(path), tree.isExpanded(path),
	treeModel.isLeaf(path.getLastPathComponent()), row);
	Rectangle nodeBounds = getPathBounds(tree, path);
	if (nodeBounds == null) {
	return false;
	}

	editingRow = row;

	Dimension editorSize = editingComponent.getPreferredSize();

	// Only allow odd heights if explicitly set.
	if(editorSize.height != nodeBounds.height &&
	getRowHeight() > 0)
	editorSize.height = getRowHeight();

	if(editorSize.width != nodeBounds.width \|\|
	editorSize.height != nodeBounds.height) {
	// Editor wants different width or height, invalidate
	// treeState and relayout.
	editorHasDifferentSize = true;
	treeState.invalidatePathBounds(path);
	updateSize();
	// To make sure x/y are updated correctly, fetch
	// the bounds again.
	nodeBounds = getPathBounds(tree, path);
	if (nodeBounds == null) {
	return false;
	}
	}
	else
	editorHasDifferentSize = false;
	tree.add(editingComponent);
	editingComponent.setBounds(nodeBounds.x, nodeBounds.y,
	nodeBounds.width,
	nodeBounds.height);
	editingPath = path;
	AWTAccessor.getComponentAccessor().revalidateSynchronously(editingComponent);
	editingComponent.repaint();
	if(cellEditor.shouldSelectCell(event)) {
	stopEditingInCompleteEditing = false;
	tree.setSelectionRow(row);
	stopEditingInCompleteEditing = true;
	}

	Component focusedComponent = SwingUtilities2.
	compositeRequestFocus(editingComponent);
	boolean selectAll = true;

	if(event != null) {
	/* Find the component that will get forwarded all the
	mouse events until mouseReleased. */
	Point componentPoint = SwingUtilities.convertPoint
	(tree, new Point(event.getX(), event.getY()),
	editingComponent);

	/* Create an instance of BasicTreeMouseListener to handle
	passing the mouse/motion events to the necessary
	component. */
	// We really want similar behavior to getMouseEventTarget,
	// but it is package private.
	Component activeComponent = SwingUtilities.
	getDeepestComponentAt(editingComponent,
	componentPoint.x, componentPoint.y);
	if (activeComponent != null) {
	MouseInputHandler handler =
	new MouseInputHandler(tree, activeComponent,
	event, focusedComponent);

	if (releaseEvent != null) {
	handler.mouseReleased(releaseEvent);
	}

	selectAll = false;
	}
	}
	if (selectAll && focusedComponent instanceof JTextField) {
	((JTextField)focusedComponent).selectAll();
	}
	return true;
	}
	else
	editingComponent = null;
	}
	return false;
	}

	//
	// Following are primarily for handling mouse events.
	//

	/**
	* If the <code>mouseX</code> and <code>mouseY</code> are in the
	* expand/collapse region of the <code>row</code>, this will toggle
	* the row.
	*/
	protected void checkForClickInExpandControl(TreePath path,
	int mouseX, int mouseY) {
	if (isLocationInExpandControl(path, mouseX, mouseY)) {
	handleExpandControlClick(path, mouseX, mouseY);
	}
	}

	/**
	* Returns true if <code>mouseX</code> and <code>mouseY</code> fall
	* in the area of row that is used to expand/collapse the node and
	* the node at <code>row</code> does not represent a leaf.
	*/
	protected boolean isLocationInExpandControl(TreePath path,
	int mouseX, int mouseY) {
	if(path != null && !treeModel.isLeaf(path.getLastPathComponent())){
	int boxWidth;
	Insets i = tree.getInsets();

	if(getExpandedIcon() != null)
	boxWidth = getExpandedIcon().getIconWidth();
	else
	boxWidth = 8;

	int boxLeftX = getRowX(tree.getRowForPath(path),
	path.getPathCount() - 1);

	if (leftToRight) {
	boxLeftX = boxLeftX + i.left - getRightChildIndent() + 1;
	} else {
	boxLeftX = tree.getWidth() - boxLeftX - i.right + getRightChildIndent() - 1;
	}

	boxLeftX = findCenteredX(boxLeftX, boxWidth);

	return (mouseX >= boxLeftX && mouseX < (boxLeftX + boxWidth));
	}
	return false;
	}

	/**
	* Messaged when the user clicks the particular row, this invokes
	* toggleExpandState.
	*/
	protected void handleExpandControlClick(TreePath path, int mouseX,
	int mouseY) {
	toggleExpandState(path);
	}

	/**
	* Expands path if it is not expanded, or collapses row if it is expanded.
	* If expanding a path and JTree scrolls on expand, ensureRowsAreVisible
	* is invoked to scroll as many of the children to visible as possible
	* (tries to scroll to last visible descendant of path).
	*/
	protected void toggleExpandState(TreePath path) {
	if(!tree.isExpanded(path)) {
	int row = getRowForPath(tree, path);

	tree.expandPath(path);
	updateSize();
	if(row != -1) {
	if(tree.getScrollsOnExpand())
	ensureRowsAreVisible(row, row + treeState.
	getVisibleChildCount(path));
	else
	ensureRowsAreVisible(row, row);
	}
	}
	else {
	tree.collapsePath(path);
	updateSize();
	}
	}

	/**
	* Returning true signifies a mouse event on the node should toggle
	* the selection of only the row under mouse.
	*/
	protected boolean isToggleSelectionEvent(MouseEvent event) {
	return (SwingUtilities.isLeftMouseButton(event) &&
	BasicGraphicsUtils.isMenuShortcutKeyDown(event));
	}

	/**
	* Returning true signifies a mouse event on the node should select
	* from the anchor point.
	*/
	protected boolean isMultiSelectEvent(MouseEvent event) {
	return (SwingUtilities.isLeftMouseButton(event) &&
	event.isShiftDown());
	}

	/**
	* Returning true indicates the row under the mouse should be toggled
	* based on the event. This is invoked after checkForClickInExpandControl,
	* implying the location is not in the expand (toggle) control
	*/
	protected boolean isToggleEvent(MouseEvent event) {
	if(!SwingUtilities.isLeftMouseButton(event)) {
	return false;
	}
	int clickCount = tree.getToggleClickCount();

	if(clickCount <= 0) {
	return false;
	}
	return ((event.getClickCount() % clickCount) == 0);
	}

	/**
	* Messaged to update the selection based on a MouseEvent over a
	* particular row. If the event is a toggle selection event, the
	* row is either selected, or deselected. If the event identifies
	* a multi selection event, the selection is updated from the
	* anchor point. Otherwise the row is selected, and if the event
	* specified a toggle event the row is expanded/collapsed.
	*/
	protected void selectPathForEvent(TreePath path, MouseEvent event) {
	/* Adjust from the anchor point. */
	if(isMultiSelectEvent(event)) {
	TreePath anchor = getAnchorSelectionPath();
	int anchorRow = (anchor == null) ? -1 :
	getRowForPath(tree, anchor);

	if(anchorRow == -1 \|\| tree.getSelectionModel().
	getSelectionMode() == TreeSelectionModel.
	SINGLE_TREE_SELECTION) {
	tree.setSelectionPath(path);
	}
	else {
	int row = getRowForPath(tree, path);
	TreePath lastAnchorPath = anchor;

	if (isToggleSelectionEvent(event)) {
	if (tree.isRowSelected(anchorRow)) {
	tree.addSelectionInterval(anchorRow, row);
	} else {
	tree.removeSelectionInterval(anchorRow, row);
	tree.addSelectionInterval(row, row);
	}
	} else if(row < anchorRow) {
	tree.setSelectionInterval(row, anchorRow);
	} else {
	tree.setSelectionInterval(anchorRow, row);
	}
	lastSelectedRow = row;
	setAnchorSelectionPath(lastAnchorPath);
	setLeadSelectionPath(path);
	}
	}

	// Should this event toggle the selection of this row?
	/* Control toggles just this node. */
	else if(isToggleSelectionEvent(event)) {
	if(tree.isPathSelected(path))
	tree.removeSelectionPath(path);
	else
	tree.addSelectionPath(path);
	lastSelectedRow = getRowForPath(tree, path);
	setAnchorSelectionPath(path);
	setLeadSelectionPath(path);
	}

	/* Otherwise set the selection to just this interval. */
	else if(SwingUtilities.isLeftMouseButton(event)) {
	tree.setSelectionPath(path);
	if(isToggleEvent(event)) {
	toggleExpandState(path);
	}
	}
	}

	/**
	* @return true if the node at <code>row</code> is a leaf.
	*/
	protected boolean isLeaf(int row) {
	TreePath path = getPathForRow(tree, row);

	if(path != null)
	return treeModel.isLeaf(path.getLastPathComponent());
	// Have to return something here...
	return true;
	}

	//
	// The following selection methods (lead/anchor) are covers for the
	// methods in JTree.
	//
	private void setAnchorSelectionPath(TreePath newPath) {
	ignoreLAChange = true;
	try {
	tree.setAnchorSelectionPath(newPath);
	} finally{
	ignoreLAChange = false;
	}
	}

	private TreePath getAnchorSelectionPath() {
	return tree.getAnchorSelectionPath();
	}

	private void setLeadSelectionPath(TreePath newPath) {
	setLeadSelectionPath(newPath, false);
	}

	private void setLeadSelectionPath(TreePath newPath, boolean repaint) {
	Rectangle bounds = repaint ?
	getPathBounds(tree, getLeadSelectionPath()) : null;

	ignoreLAChange = true;
	try {
	tree.setLeadSelectionPath(newPath);
	} finally {
	ignoreLAChange = false;
	}
	leadRow = getRowForPath(tree, newPath);

	if (repaint) {
	if (bounds != null) {
	tree.repaint(getRepaintPathBounds(bounds));
	}
	bounds = getPathBounds(tree, newPath);
	if (bounds != null) {
	tree.repaint(getRepaintPathBounds(bounds));
	}
	}
	}

	private Rectangle getRepaintPathBounds(Rectangle bounds) {
	if (UIManager.getBoolean("Tree.repaintWholeRow")) {
	bounds.x = 0;
	bounds.width = tree.getWidth();
	}
	return bounds;
	}

	private TreePath getLeadSelectionPath() {
	return tree.getLeadSelectionPath();
	}

	/**
	* Updates the lead row of the selection.
	* @since 1.7
	*/
	protected void updateLeadSelectionRow() {
	leadRow = getRowForPath(tree, getLeadSelectionPath());
	}

	/**
	* Returns the lead row of the selection.
	*
	* @return selection lead row
	* @since 1.7
	*/
	protected int getLeadSelectionRow() {
	return leadRow;
	}

	/**
	* Extends the selection from the anchor to make <code>newLead</code>
	* the lead of the selection. This does not scroll.
	*/
	private void extendSelection(TreePath newLead) {
	TreePath aPath = getAnchorSelectionPath();
	int aRow = (aPath == null) ? -1 :
	getRowForPath(tree, aPath);
	int newIndex = getRowForPath(tree, newLead);

	if(aRow == -1) {
	tree.setSelectionRow(newIndex);
	}
	else {
	if(aRow < newIndex) {
	tree.setSelectionInterval(aRow, newIndex);
	}
	else {
	tree.setSelectionInterval(newIndex, aRow);
	}
	setAnchorSelectionPath(aPath);
	setLeadSelectionPath(newLead);
	}
	}

	/**
	* Invokes <code>repaint</code> on the JTree for the passed in TreePath,
	* <code>path</code>.
	*/
	private void repaintPath(TreePath path) {
	if (path != null) {
	Rectangle bounds = getPathBounds(tree, path);
	if (bounds != null) {
	tree.repaint(bounds.x, bounds.y, bounds.width, bounds.height);
	}
	}
	}

	/**
	* Updates the TreeState in response to nodes expanding/collapsing.
	*/
	public class TreeExpansionHandler implements TreeExpansionListener {
	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.

	/**
	* Called whenever an item in the tree has been expanded.
	*/
	public void treeExpanded(TreeExpansionEvent event) {
	getHandler().treeExpanded(event);
	}

	/**
	* Called whenever an item in the tree has been collapsed.
	*/
	public void treeCollapsed(TreeExpansionEvent event) {
	getHandler().treeCollapsed(event);
	}
	} // BasicTreeUI.TreeExpansionHandler


	/**
	* Updates the preferred size when scrolling (if necessary).
	*/
	public class ComponentHandler extends ComponentAdapter implements
	ActionListener {
	/** Timer used when inside a scrollpane and the scrollbar is
	* adjusting. */
	protected Timer timer;
	/** ScrollBar that is being adjusted. */
	protected JScrollBar scrollBar;

	public void componentMoved(ComponentEvent e) {
	if(timer == null) {
	JScrollPane scrollPane = getScrollPane();

	if(scrollPane == null)
	updateSize();
	else {
	scrollBar = scrollPane.getVerticalScrollBar();
	if(scrollBar == null \|\|
	!scrollBar.getValueIsAdjusting()) {
	// Try the horizontal scrollbar.
	if((scrollBar = scrollPane.getHorizontalScrollBar())
	!= null && scrollBar.getValueIsAdjusting())
	startTimer();
	else
	updateSize();
	}
	else
	startTimer();
	}
	}
	}

	/**
	* Creates, if necessary, and starts a Timer to check if need to
	* resize the bounds.
	*/
	protected void startTimer() {
	if(timer == null) {
	timer = new Timer(200, this);
	timer.setRepeats(true);
	}
	timer.start();
	}

	/**
	* Returns the JScrollPane housing the JTree, or null if one isn't
	* found.
	*/
	protected JScrollPane getScrollPane() {
	Component c = tree.getParent();

	while(c != null && !(c instanceof JScrollPane))
	c = c.getParent();
	if(c instanceof JScrollPane)
	return (JScrollPane)c;
	return null;
	}

	/**
	* Public as a result of Timer. If the scrollBar is null, or
	* not adjusting, this stops the timer and updates the sizing.
	*/
	public void actionPerformed(ActionEvent ae) {
	if(scrollBar == null \|\| !scrollBar.getValueIsAdjusting()) {
	if(timer != null)
	timer.stop();
	updateSize();
	timer = null;
	scrollBar = null;
	}
	}
	} // End of BasicTreeUI.ComponentHandler


	/**
	* Forwards all TreeModel events to the TreeState.
	*/
	public class TreeModelHandler implements TreeModelListener {

	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.

	public void treeNodesChanged(TreeModelEvent e) {
	getHandler().treeNodesChanged(e);
	}

	public void treeNodesInserted(TreeModelEvent e) {
	getHandler().treeNodesInserted(e);
	}

	public void treeNodesRemoved(TreeModelEvent e) {
	getHandler().treeNodesRemoved(e);
	}

	public void treeStructureChanged(TreeModelEvent e) {
	getHandler().treeStructureChanged(e);
	}
	} // End of BasicTreeUI.TreeModelHandler


	/**
	* Listens for changes in the selection model and updates the display
	* accordingly.
	*/
	public class TreeSelectionHandler implements TreeSelectionListener {

	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.

	/**
	* Messaged when the selection changes in the tree we're displaying
	* for. Stops editing, messages super and displays the changed paths.
	*/
	public void valueChanged(TreeSelectionEvent event) {
	getHandler().valueChanged(event);
	}
	}// End of BasicTreeUI.TreeSelectionHandler


	/**
	* Listener responsible for getting cell editing events and updating
	* the tree accordingly.
	*/
	public class CellEditorHandler implements CellEditorListener {

	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.

	/** Messaged when editing has stopped in the tree. */
	public void editingStopped(ChangeEvent e) {
	getHandler().editingStopped(e);
	}

	/** Messaged when editing has been canceled in the tree. */
	public void editingCanceled(ChangeEvent e) {
	getHandler().editingCanceled(e);
	}
	} // BasicTreeUI.CellEditorHandler


	/**
	* This is used to get multiple key down events to appropriately generate
	* events.
	*/
	public class KeyHandler extends KeyAdapter {

	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.

	// Also note these fields aren't use anymore, nor does Handler have
	// the old functionality. This behavior worked around an old bug
	// in JComponent that has long since been fixed.

	/** Key code that is being generated for. */
	protected Action repeatKeyAction;

	/** Set to true while keyPressed is active. */
	protected boolean isKeyDown;

	/**
	* Invoked when a key has been typed.
	*
	* Moves the keyboard focus to the first element
	* whose first letter matches the alphanumeric key
	* pressed by the user. Subsequent same key presses
	* move the keyboard focus to the next object that
	* starts with the same letter.
	*/
	public void keyTyped(KeyEvent e) {
	getHandler().keyTyped(e);
	}

	public void keyPressed(KeyEvent e) {
	getHandler().keyPressed(e);
	}

	public void keyReleased(KeyEvent e) {
	getHandler().keyReleased(e);
	}
	} // End of BasicTreeUI.KeyHandler


	/**
	* Repaints the lead selection row when focus is lost/gained.
	*/
	public class FocusHandler implements FocusListener {
	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.

	/**
	* Invoked when focus is activated on the tree we're in, redraws the
	* lead row.
	*/
	public void focusGained(FocusEvent e) {
	getHandler().focusGained(e);
	}

	/**
	* Invoked when focus is activated on the tree we're in, redraws the
	* lead row.
	*/
	public void focusLost(FocusEvent e) {
	getHandler().focusLost(e);
	}
	} // End of class BasicTreeUI.FocusHandler


	/**
	* Class responsible for getting size of node, method is forwarded
	* to BasicTreeUI method. X location does not include insets, that is
	* handled in getPathBounds.
	*/
	// This returns locations that don't include any Insets.
	public class NodeDimensionsHandler extends
	AbstractLayoutCache.NodeDimensions {
	/**
	* Responsible for getting the size of a particular node.
	*/
	public Rectangle getNodeDimensions(Object value, int row,
	int depth, boolean expanded,
	Rectangle size) {
	// Return size of editing component, if editing and asking
	// for editing row.
	if(editingComponent != null && editingRow == row) {
	Dimension prefSize = editingComponent.
	getPreferredSize();
	int rh = getRowHeight();

	if(rh > 0 && rh != prefSize.height)
	prefSize.height = rh;
	if(size != null) {
	size.x = getRowX(row, depth);
	size.width = prefSize.width;
	size.height = prefSize.height;
	}
	else {
	size = new Rectangle(getRowX(row, depth), 0,
	prefSize.width, prefSize.height);
	}
	return size;
	}
	// Not editing, use renderer.
	if(currentCellRenderer != null) {
	Component aComponent;

	aComponent = currentCellRenderer.getTreeCellRendererComponent
	(tree, value, tree.isRowSelected(row),
	expanded, treeModel.isLeaf(value), row,
	false);
	if(tree != null) {
	// Only ever removed when UI changes, this is OK!
	rendererPane.add(aComponent);
	aComponent.validate();
	}
	Dimension prefSize = aComponent.getPreferredSize();

	if(size != null) {
	size.x = getRowX(row, depth);
	size.width = prefSize.width;
	size.height = prefSize.height;
	}
	else {
	size = new Rectangle(getRowX(row, depth), 0,
	prefSize.width, prefSize.height);
	}
	return size;
	}
	return null;
	}

	/**
	* @return amount to indent the given row.
	*/
	protected int getRowX(int row, int depth) {
	return BasicTreeUI.this.getRowX(row, depth);
	}

	} // End of class BasicTreeUI.NodeDimensionsHandler


	/**
	* TreeMouseListener is responsible for updating the selection
	* based on mouse events.
	*/
	public class MouseHandler extends MouseAdapter implements MouseMotionListener
	{
	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.

	/**
	* Invoked when a mouse button has been pressed on a component.
	*/
	public void mousePressed(MouseEvent e) {
	getHandler().mousePressed(e);
	}

	public void mouseDragged(MouseEvent e) {
	getHandler().mouseDragged(e);
	}

	/**
	* Invoked when the mouse button has been moved on a component
	* (with no buttons no down).
	* @since 1.4
	*/
	public void mouseMoved(MouseEvent e) {
	getHandler().mouseMoved(e);
	}

	public void mouseReleased(MouseEvent e) {
	getHandler().mouseReleased(e);
	}
	} // End of BasicTreeUI.MouseHandler


	/**
	* PropertyChangeListener for the tree. Updates the appropriate
	* variable, or TreeState, based on what changes.
	*/
	public class PropertyChangeHandler implements
	PropertyChangeListener {

	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.

	public void propertyChange(PropertyChangeEvent event) {
	getHandler().propertyChange(event);
	}
	} // End of BasicTreeUI.PropertyChangeHandler


	/**
	* Listener on the TreeSelectionModel, resets the row selection if
	* any of the properties of the model change.
	*/
	public class SelectionModelPropertyChangeHandler implements
	PropertyChangeListener {

	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.

	public void propertyChange(PropertyChangeEvent event) {
	getHandler().propertyChange(event);
	}
	} // End of BasicTreeUI.SelectionModelPropertyChangeHandler


	/**
	* <code>TreeTraverseAction</code> is the action used for left/right keys.
	* Will toggle the expandedness of a node, as well as potentially
	* incrementing the selection.
	*/
	public class TreeTraverseAction extends AbstractAction {
	/** Determines direction to traverse, 1 means expand, -1 means
	* collapse. */
	protected int direction;
	/** True if the selection is reset, false means only the lead path
	* changes. */
	private boolean changeSelection;

	public TreeTraverseAction(int direction, String name) {
	this(direction, name, true);
	}

	private TreeTraverseAction(int direction, String name,
	boolean changeSelection) {
	this.direction = direction;
	this.changeSelection = changeSelection;
	}

	public void actionPerformed(ActionEvent e) {
	if (tree != null) {
	SHARED_ACTION.traverse(tree, BasicTreeUI.this, direction,
	changeSelection);
	}
	}

	public boolean isEnabled() { return (tree != null &&
	tree.isEnabled()); }
	} // BasicTreeUI.TreeTraverseAction


	/** TreePageAction handles page up and page down events.
	*/
	public class TreePageAction extends AbstractAction {
	/** Specifies the direction to adjust the selection by. */
	protected int direction;
	/** True indicates should set selection from anchor path. */
	private boolean addToSelection;
	private boolean changeSelection;

	public TreePageAction(int direction, String name) {
	this(direction, name, false, true);
	}

	private TreePageAction(int direction, String name,
	boolean addToSelection,
	boolean changeSelection) {
	this.direction = direction;
	this.addToSelection = addToSelection;
	this.changeSelection = changeSelection;
	}

	public void actionPerformed(ActionEvent e) {
	if (tree != null) {
	SHARED_ACTION.page(tree, BasicTreeUI.this, direction,
	addToSelection, changeSelection);
	}
	}

	public boolean isEnabled() { return (tree != null &&
	tree.isEnabled()); }

	} // BasicTreeUI.TreePageAction


	/** TreeIncrementAction is used to handle up/down actions. Selection
	* is moved up or down based on direction.
	*/
	public class TreeIncrementAction extends AbstractAction {
	/** Specifies the direction to adjust the selection by. */
	protected int direction;
	/** If true the new item is added to the selection, if false the
	* selection is reset. */
	private boolean addToSelection;
	private boolean changeSelection;

	public TreeIncrementAction(int direction, String name) {
	this(direction, name, false, true);
	}

	private TreeIncrementAction(int direction, String name,
	boolean addToSelection,
	boolean changeSelection) {
	this.direction = direction;
	this.addToSelection = addToSelection;
	this.changeSelection = changeSelection;
	}

	public void actionPerformed(ActionEvent e) {
	if (tree != null) {
	SHARED_ACTION.increment(tree, BasicTreeUI.this, direction,
	addToSelection, changeSelection);
	}
	}

	public boolean isEnabled() { return (tree != null &&
	tree.isEnabled()); }

	} // End of class BasicTreeUI.TreeIncrementAction

	/**
	* TreeHomeAction is used to handle end/home actions.
	* Scrolls either the first or last cell to be visible based on
	* direction.
	*/
	public class TreeHomeAction extends AbstractAction {
	protected int direction;
	/** Set to true if append to selection. */
	private boolean addToSelection;
	private boolean changeSelection;

	public TreeHomeAction(int direction, String name) {
	this(direction, name, false, true);
	}

	private TreeHomeAction(int direction, String name,
	boolean addToSelection,
	boolean changeSelection) {
	this.direction = direction;
	this.changeSelection = changeSelection;
	this.addToSelection = addToSelection;
	}

	public void actionPerformed(ActionEvent e) {
	if (tree != null) {
	SHARED_ACTION.home(tree, BasicTreeUI.this, direction,
	addToSelection, changeSelection);
	}
	}

	public boolean isEnabled() { return (tree != null &&
	tree.isEnabled()); }

	} // End of class BasicTreeUI.TreeHomeAction


	/**
	* For the first selected row expandedness will be toggled.
	*/
	public class TreeToggleAction extends AbstractAction {
	public TreeToggleAction(String name) {
	}

	public void actionPerformed(ActionEvent e) {
	if(tree != null) {
	SHARED_ACTION.toggle(tree, BasicTreeUI.this);
	}
	}

	public boolean isEnabled() { return (tree != null &&
	tree.isEnabled()); }

	} // End of class BasicTreeUI.TreeToggleAction


	/**
	* ActionListener that invokes cancelEditing when action performed.
	*/
	public class TreeCancelEditingAction extends AbstractAction {
	public TreeCancelEditingAction(String name) {
	}

	public void actionPerformed(ActionEvent e) {
	if(tree != null) {
	SHARED_ACTION.cancelEditing(tree, BasicTreeUI.this);
	}
	}

	public boolean isEnabled() { return (tree != null &&
	tree.isEnabled() &&
	isEditing(tree)); }
	} // End of class BasicTreeUI.TreeCancelEditingAction


	/**
	* MouseInputHandler handles passing all mouse events,
	* including mouse motion events, until the mouse is released to
	* the destination it is constructed with. It is assumed all the
	* events are currently target at source.
	*/
	public class MouseInputHandler extends Object implements
	MouseInputListener
	{
	/** Source that events are coming from. */
	protected Component source;
	/** Destination that receives all events. */
	protected Component destination;
	private Component focusComponent;
	private boolean dispatchedEvent;

	public MouseInputHandler(Component source, Component destination,
	MouseEvent event){
	this(source, destination, event, null);
	}

	MouseInputHandler(Component source, Component destination,
	MouseEvent event, Component focusComponent) {
	this.source = source;
	this.destination = destination;
	this.source.addMouseListener(this);
	this.source.addMouseMotionListener(this);

	SwingUtilities2.setSkipClickCount(destination,
	event.getClickCount() - 1);

	/* Dispatch the editing event! */
	destination.dispatchEvent(SwingUtilities.convertMouseEvent
	(source, event, destination));
	this.focusComponent = focusComponent;
	}

	public void mouseClicked(MouseEvent e) {
	if(destination != null) {
	dispatchedEvent = true;
	destination.dispatchEvent(SwingUtilities.convertMouseEvent
	(source, e, destination));
	}
	}

	public void mousePressed(MouseEvent e) {
	}

	public void mouseReleased(MouseEvent e) {
	if(destination != null)
	destination.dispatchEvent(SwingUtilities.convertMouseEvent
	(source, e, destination));
	removeFromSource();
	}

	public void mouseEntered(MouseEvent e) {
	if (!SwingUtilities.isLeftMouseButton(e)) {
	removeFromSource();
	}
	}

	public void mouseExited(MouseEvent e) {
	if (!SwingUtilities.isLeftMouseButton(e)) {
	removeFromSource();
	}
	}

	public void mouseDragged(MouseEvent e) {
	if(destination != null) {
	dispatchedEvent = true;
	destination.dispatchEvent(SwingUtilities.convertMouseEvent
	(source, e, destination));
	}
	}

	public void mouseMoved(MouseEvent e) {
	removeFromSource();
	}

	protected void removeFromSource() {
	if(source != null) {
	source.removeMouseListener(this);
	source.removeMouseMotionListener(this);
	if (focusComponent != null &&
	focusComponent == destination && !dispatchedEvent &&
	(focusComponent instanceof JTextField)) {
	((JTextField)focusComponent).selectAll();
	}
	}
	source = destination = null;
	}

	} // End of class BasicTreeUI.MouseInputHandler

	private static final TransferHandler defaultTransferHandler = new TreeTransferHandler();

	static class TreeTransferHandler extends TransferHandler implements UIResource, Comparator<TreePath> {

	private JTree tree;

	/**
	* Create a Transferable to use as the source for a data transfer.
	*
	* @param c The component holding the data to be transfered. This
	* argument is provided to enable sharing of TransferHandlers by
	* multiple components.
	* @return The representation of the data to be transfered.
	*
	*/
	protected Transferable createTransferable(JComponent c) {
	if (c instanceof JTree) {
	tree = (JTree) c;
	TreePath[] paths = tree.getSelectionPaths();

	if (paths == null \|\| paths.length == 0) {
	return null;
	}

	StringBuffer plainBuf = new StringBuffer();
	StringBuffer htmlBuf = new StringBuffer();

	htmlBuf.append("<html>\n<body>\n<ul>\n");

	TreeModel model = tree.getModel();
	TreePath lastPath = null;
	TreePath[] displayPaths = getDisplayOrderPaths(paths);

	for (TreePath path : displayPaths) {
	Object node = path.getLastPathComponent();
	boolean leaf = model.isLeaf(node);
	String label = getDisplayString(path, true, leaf);

	plainBuf.append(label + "\n");
	htmlBuf.append(" <li>" + label + "\n");
	}

	// remove the last newline
	plainBuf.deleteCharAt(plainBuf.length() - 1);
	htmlBuf.append("</ul>\n</body>\n</html>");

	tree = null;

	return new BasicTransferable(plainBuf.toString(), htmlBuf.toString());
	}

	return null;
	}

	public int compare(TreePath o1, TreePath o2) {
	int row1 = tree.getRowForPath(o1);
	int row2 = tree.getRowForPath(o2);
	return row1 - row2;
	}

	String getDisplayString(TreePath path, boolean selected, boolean leaf) {
	int row = tree.getRowForPath(path);
	boolean hasFocus = tree.getLeadSelectionRow() == row;
	Object node = path.getLastPathComponent();
	return tree.convertValueToText(node, selected, tree.isExpanded(row),
	leaf, row, hasFocus);
	}

	/**
	* Selection paths are in selection order. The conversion to
	* HTML requires display order. This method resorts the paths
	* to be in the display order.
	*/
	TreePath[] getDisplayOrderPaths(TreePath[] paths) {
	// sort the paths to display order rather than selection order
	ArrayList<TreePath> selOrder = new ArrayList<TreePath>();
	for (TreePath path : paths) {
	selOrder.add(path);
	}
	Collections.sort(selOrder, this);
	int n = selOrder.size();
	TreePath[] displayPaths = new TreePath[n];
	for (int i = 0; i < n; i++) {
	displayPaths[i] = selOrder.get(i);
	}
	return displayPaths;
	}

	public int getSourceActions(JComponent c) {
	return COPY;
	}

	}


	private class Handler implements CellEditorListener, FocusListener,
	KeyListener, MouseListener, MouseMotionListener,
	PropertyChangeListener, TreeExpansionListener,
	TreeModelListener, TreeSelectionListener,
	BeforeDrag {
	//
	// KeyListener
	//
	private String prefix = "";
	private String typedString = "";
	private long lastTime = 0L;

	/**
	* Invoked when a key has been typed.
	*
	* Moves the keyboard focus to the first element whose prefix matches the
	* sequence of alphanumeric keys pressed by the user with delay less
	* than value of <code>timeFactor</code> property (or 1000 milliseconds
	* if it is not defined). Subsequent same key presses move the keyboard
	* focus to the next object that starts with the same letter until another
	* key is pressed, then it is treated as the prefix with appropriate number
	* of the same letters followed by first typed another letter.
	*/
	public void keyTyped(KeyEvent e) {
	// handle first letter navigation
	if(tree != null && tree.getRowCount()>0 && tree.hasFocus() &&
	tree.isEnabled()) {
	if (e.isAltDown() \|\| BasicGraphicsUtils.isMenuShortcutKeyDown(e) \|\|
	isNavigationKey(e)) {
	return;
	}
	boolean startingFromSelection = true;

	char c = e.getKeyChar();

	long time = e.getWhen();
	int startingRow = tree.getLeadSelectionRow();
	if (time - lastTime < timeFactor) {
	typedString += c;
	if((prefix.length() == 1) && (c == prefix.charAt(0))) {
	// Subsequent same key presses move the keyboard focus to the next
	// object that starts with the same letter.
	startingRow++;
	} else {
	prefix = typedString;
	}
	} else {
	startingRow++;
	typedString = "" + c;
	prefix = typedString;
	}
	lastTime = time;

	if (startingRow < 0 \|\| startingRow >= tree.getRowCount()) {
	startingFromSelection = false;
	startingRow = 0;
	}
	TreePath path = tree.getNextMatch(prefix, startingRow,
	Position.Bias.Forward);
	if (path != null) {
	tree.setSelectionPath(path);
	int row = getRowForPath(tree, path);
	ensureRowsAreVisible(row, row);
	} else if (startingFromSelection) {
	path = tree.getNextMatch(prefix, 0,
	Position.Bias.Forward);
	if (path != null) {
	tree.setSelectionPath(path);
	int row = getRowForPath(tree, path);
	ensureRowsAreVisible(row, row);
	}
	}
	}
	}

	/**
	* Invoked when a key has been pressed.
	*
	* Checks to see if the key event is a navigation key to prevent
	* dispatching these keys for the first letter navigation.
	*/
	public void keyPressed(KeyEvent e) {
	if (tree != null && isNavigationKey(e)) {
	prefix = "";
	typedString = "";
	lastTime = 0L;
	}
	}

	public void keyReleased(KeyEvent e) {
	}

	/**
	* Returns whether or not the supplied key event maps to a key that is used for
	* navigation. This is used for optimizing key input by only passing non-
	* navigation keys to the first letter navigation mechanism.
	*/
	private boolean isNavigationKey(KeyEvent event) {
	InputMap inputMap = tree.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
	KeyStroke key = KeyStroke.getKeyStrokeForEvent(event);

	return inputMap != null && inputMap.get(key) != null;
	}


	//
	// PropertyChangeListener
	//
	public void propertyChange(PropertyChangeEvent event) {
	if (event.getSource() == treeSelectionModel) {
	treeSelectionModel.resetRowSelection();
	}
	else if(event.getSource() == tree) {
	String changeName = event.getPropertyName();

	if (changeName == JTree.LEAD_SELECTION_PATH_PROPERTY) {
	if (!ignoreLAChange) {
	updateLeadSelectionRow();
	repaintPath((TreePath)event.getOldValue());
	repaintPath((TreePath)event.getNewValue());
	}
	}
	else if (changeName == JTree.ANCHOR_SELECTION_PATH_PROPERTY) {
	if (!ignoreLAChange) {
	repaintPath((TreePath)event.getOldValue());
	repaintPath((TreePath)event.getNewValue());
	}
	}
	if(changeName == JTree.CELL_RENDERER_PROPERTY) {
	setCellRenderer((TreeCellRenderer)event.getNewValue());
	redoTheLayout();
	}
	else if(changeName == JTree.TREE_MODEL_PROPERTY) {
	setModel((TreeModel)event.getNewValue());
	}
	else if(changeName == JTree.ROOT_VISIBLE_PROPERTY) {
	setRootVisible(((Boolean)event.getNewValue()).
	booleanValue());
	}
	else if(changeName == JTree.SHOWS_ROOT_HANDLES_PROPERTY) {
	setShowsRootHandles(((Boolean)event.getNewValue()).
	booleanValue());
	}
	else if(changeName == JTree.ROW_HEIGHT_PROPERTY) {
	setRowHeight(((Integer)event.getNewValue()).
	intValue());
	}
	else if(changeName == JTree.CELL_EDITOR_PROPERTY) {
	setCellEditor((TreeCellEditor)event.getNewValue());
	}
	else if(changeName == JTree.EDITABLE_PROPERTY) {
	setEditable(((Boolean)event.getNewValue()).booleanValue());
	}
	else if(changeName == JTree.LARGE_MODEL_PROPERTY) {
	setLargeModel(tree.isLargeModel());
	}
	else if(changeName == JTree.SELECTION_MODEL_PROPERTY) {
	setSelectionModel(tree.getSelectionModel());
	}
	else if(changeName == "font") {
	completeEditing();
	if(treeState != null)
	treeState.invalidateSizes();
	updateSize();
	}
	else if (changeName == "componentOrientation") {
	if (tree != null) {
	leftToRight = BasicGraphicsUtils.isLeftToRight(tree);
	redoTheLayout();
	tree.treeDidChange();

	InputMap km = getInputMap(JComponent.WHEN_FOCUSED);
	SwingUtilities.replaceUIInputMap(tree,
	JComponent.WHEN_FOCUSED, km);
	}
	} else if ("dropLocation" == changeName) {
	JTree.DropLocation oldValue = (JTree.DropLocation)event.getOldValue();
	repaintDropLocation(oldValue);
	repaintDropLocation(tree.getDropLocation());
	}
	}
	}

	private void repaintDropLocation(JTree.DropLocation loc) {
	if (loc == null) {
	return;
	}

	Rectangle r;

	if (isDropLine(loc)) {
	r = getDropLineRect(loc);
	} else {
	r = tree.getPathBounds(loc.getPath());
	}

	if (r != null) {
	tree.repaint(r);
	}
	}

	//
	// MouseListener
	//

	// Whether or not the mouse press (which is being considered as part
	// of a drag sequence) also caused the selection change to be fully
	// processed.
	private boolean dragPressDidSelection;

	// Set to true when a drag gesture has been fully recognized and DnD
	// begins. Use this to ignore further mouse events which could be
	// delivered if DnD is cancelled (via ESCAPE for example)
	private boolean dragStarted;

	// The path over which the press occurred and the press event itself
	private TreePath pressedPath;
	private MouseEvent pressedEvent;

	// Used to detect whether the press event causes a selection change.
	// If it does, we won't try to start editing on the release.
	private boolean valueChangedOnPress;

	private boolean isActualPath(TreePath path, int x, int y) {
	if (path == null) {
	return false;
	}

	Rectangle bounds = getPathBounds(tree, path);
	if (bounds == null \|\| y > (bounds.y + bounds.height)) {
	return false;
	}

	return (x >= bounds.x) && (x <= (bounds.x + bounds.width));
	}

	public void mouseClicked(MouseEvent e) {
	}

	public void mouseEntered(MouseEvent e) {
	}

	public void mouseExited(MouseEvent e) {
	}

	/**
	* Invoked when a mouse button has been pressed on a component.
	*/
	public void mousePressed(MouseEvent e) {
	if (SwingUtilities2.shouldIgnore(e, tree)) {
	return;
	}

	// if we can't stop any ongoing editing, do nothing
	if (isEditing(tree) && tree.getInvokesStopCellEditing()
	&& !stopEditing(tree)) {
	return;
	}

	completeEditing();

	pressedPath = getClosestPathForLocation(tree, e.getX(), e.getY());

	if (tree.getDragEnabled()) {
	mousePressedDND(e);
	} else {
	SwingUtilities2.adjustFocus(tree);
	handleSelection(e);
	}
	}

	private void mousePressedDND(MouseEvent e) {
	pressedEvent = e;
	boolean grabFocus = true;
	dragStarted = false;
	valueChangedOnPress = false;

	// if we have a valid path and this is a drag initiating event
	if (isActualPath(pressedPath, e.getX(), e.getY()) &&
	DragRecognitionSupport.mousePressed(e)) {

	dragPressDidSelection = false;

	if (BasicGraphicsUtils.isMenuShortcutKeyDown(e)) {
	// do nothing for control - will be handled on release
	// or when drag starts
	return;
	} else if (!e.isShiftDown() && tree.isPathSelected(pressedPath)) {
	// clicking on something that's already selected
	// and need to make it the lead now
	setAnchorSelectionPath(pressedPath);
	setLeadSelectionPath(pressedPath, true);
	return;
	}

	dragPressDidSelection = true;

	// could be a drag initiating event - don't grab focus
	grabFocus = false;
	}

	if (grabFocus) {
	SwingUtilities2.adjustFocus(tree);
	}

	handleSelection(e);
	}

	void handleSelection(MouseEvent e) {
	if(pressedPath != null) {
	Rectangle bounds = getPathBounds(tree, pressedPath);

	if (bounds == null \|\| e.getY() >= (bounds.y + bounds.height)) {
	return;
	}

	// Preferably checkForClickInExpandControl could take
	// the Event to do this it self!
	if(SwingUtilities.isLeftMouseButton(e)) {
	checkForClickInExpandControl(pressedPath, e.getX(), e.getY());
	}

	int x = e.getX();

	// Perhaps they clicked the cell itself. If so,
	// select it.
	if (x >= bounds.x && x < (bounds.x + bounds.width)) {
	if (tree.getDragEnabled() \|\| !startEditing(pressedPath, e)) {
	selectPathForEvent(pressedPath, e);
	}
	}
	}
	}

	public void dragStarting(MouseEvent me) {
	dragStarted = true;

	if (BasicGraphicsUtils.isMenuShortcutKeyDown(me)) {
	tree.addSelectionPath(pressedPath);
	setAnchorSelectionPath(pressedPath);
	setLeadSelectionPath(pressedPath, true);
	}

	pressedEvent = null;
	pressedPath = null;
	}

	public void mouseDragged(MouseEvent e) {
	if (SwingUtilities2.shouldIgnore(e, tree)) {
	return;
	}

	if (tree.getDragEnabled()) {
	DragRecognitionSupport.mouseDragged(e, this);
	}
	}

	/**
	* Invoked when the mouse button has been moved on a component
	* (with no buttons no down).
	*/
	public void mouseMoved(MouseEvent e) {
	}

	public void mouseReleased(MouseEvent e) {
	if (SwingUtilities2.shouldIgnore(e, tree)) {
	return;
	}

	if (tree.getDragEnabled()) {
	mouseReleasedDND(e);
	}

	pressedEvent = null;
	pressedPath = null;
	}

	private void mouseReleasedDND(MouseEvent e) {
	MouseEvent me = DragRecognitionSupport.mouseReleased(e);
	if (me != null) {
	SwingUtilities2.adjustFocus(tree);
	if (!dragPressDidSelection) {
	handleSelection(me);
	}
	}

	if (!dragStarted) {

	// Note: We don't give the tree a chance to start editing if the
	// mouse press caused a selection change. Otherwise the default
	// tree cell editor will start editing on EVERY press and
	// release. If it turns out that this affects some editors, we
	// can always parameterize this with a client property. ex:
	//
	// if (pressedPath != null &&
	// (Boolean.TRUE == tree.getClientProperty("Tree.DnD.canEditOnValueChange") \|\|
	// !valueChangedOnPress) && ...
	if (pressedPath != null && !valueChangedOnPress &&
	isActualPath(pressedPath, pressedEvent.getX(), pressedEvent.getY())) {

	startEditingOnRelease(pressedPath, pressedEvent, e);
	}
	}
	}

	//
	// FocusListener
	//
	public void focusGained(FocusEvent e) {
	if(tree != null) {
	Rectangle pBounds;

	pBounds = getPathBounds(tree, tree.getLeadSelectionPath());
	if(pBounds != null)
	tree.repaint(getRepaintPathBounds(pBounds));
	pBounds = getPathBounds(tree, getLeadSelectionPath());
	if(pBounds != null)
	tree.repaint(getRepaintPathBounds(pBounds));
	}
	}

	public void focusLost(FocusEvent e) {
	focusGained(e);
	}

	//
	// CellEditorListener
	//
	public void editingStopped(ChangeEvent e) {
	completeEditing(false, false, true);
	}

	/** Messaged when editing has been canceled in the tree. */
	public void editingCanceled(ChangeEvent e) {
	completeEditing(false, false, false);
	}


	//
	// TreeSelectionListener
	//
	public void valueChanged(TreeSelectionEvent event) {
	valueChangedOnPress = true;

	// Stop editing
	completeEditing();
	// Make sure all the paths are visible, if necessary.
	// PENDING: This should be tweaked when isAdjusting is added
	if(tree.getExpandsSelectedPaths() && treeSelectionModel != null) {
	TreePath[] paths = treeSelectionModel
	.getSelectionPaths();

	if(paths != null) {
	for(int counter = paths.length - 1; counter >= 0;
	counter--) {
	TreePath path = paths[counter].getParentPath();
	boolean expand = true;

	while (path != null) {
	// Indicates this path isn't valid anymore,
	// we shouldn't attempt to expand it then.
	if (treeModel.isLeaf(path.getLastPathComponent())){
	expand = false;
	path = null;
	}
	else {
	path = path.getParentPath();
	}
	}
	if (expand) {
	tree.makeVisible(paths[counter]);
	}
	}
	}
	}

	TreePath oldLead = getLeadSelectionPath();
	lastSelectedRow = tree.getMinSelectionRow();
	TreePath lead = tree.getSelectionModel().getLeadSelectionPath();
	setAnchorSelectionPath(lead);
	setLeadSelectionPath(lead);

	TreePath[] changedPaths = event.getPaths();
	Rectangle nodeBounds;
	Rectangle visRect = tree.getVisibleRect();
	boolean paintPaths = true;
	int nWidth = tree.getWidth();

	if(changedPaths != null) {
	int counter, maxCounter = changedPaths.length;

	if(maxCounter > 4) {
	tree.repaint();
	paintPaths = false;
	}
	else {
	for (counter = 0; counter < maxCounter; counter++) {
	nodeBounds = getPathBounds(tree,
	changedPaths[counter]);
	if(nodeBounds != null &&
	visRect.intersects(nodeBounds))
	tree.repaint(0, nodeBounds.y, nWidth,
	nodeBounds.height);
	}
	}
	}
	if(paintPaths) {
	nodeBounds = getPathBounds(tree, oldLead);
	if(nodeBounds != null && visRect.intersects(nodeBounds))
	tree.repaint(0, nodeBounds.y, nWidth, nodeBounds.height);
	nodeBounds = getPathBounds(tree, lead);
	if(nodeBounds != null && visRect.intersects(nodeBounds))
	tree.repaint(0, nodeBounds.y, nWidth, nodeBounds.height);
	}
	}


	//
	// TreeExpansionListener
	//
	public void treeExpanded(TreeExpansionEvent event) {
	if(event != null && tree != null) {
	TreePath path = event.getPath();

	updateExpandedDescendants(path);
	}
	}

	public void treeCollapsed(TreeExpansionEvent event) {
	if(event != null && tree != null) {
	TreePath path = event.getPath();

	completeEditing();
	if(path != null && tree.isVisible(path)) {
	treeState.setExpandedState(path, false);
	updateLeadSelectionRow();
	updateSize();
	}
	}
	}

	//
	// TreeModelListener
	//
	public void treeNodesChanged(TreeModelEvent e) {
	if(treeState != null && e != null) {
	TreePath parentPath = SwingUtilities2.getTreePath(e, getModel());
	int[] indices = e.getChildIndices();
	if (indices == null \|\| indices.length == 0) {
	// The root has changed
	treeState.treeNodesChanged(e);
	updateSize();
	}
	else if (treeState.isExpanded(parentPath)) {
	// Changed nodes are visible
	// Find the minimum index, we only need paint from there
	// down.
	int minIndex = indices[0];
	for (int i = indices.length - 1; i > 0; i--) {
	minIndex = Math.min(indices[i], minIndex);
	}
	Object minChild = treeModel.getChild(
	parentPath.getLastPathComponent(), minIndex);
	TreePath minPath = parentPath.pathByAddingChild(minChild);
	Rectangle minBounds = getPathBounds(tree, minPath);

	// Forward to the treestate
	treeState.treeNodesChanged(e);

	// Mark preferred size as bogus.
	updateSize0();

	// And repaint
	Rectangle newMinBounds = getPathBounds(tree, minPath);
	if (minBounds == null \|\| newMinBounds == null) {
	return;
	}

	if (indices.length == 1 &&
	newMinBounds.height == minBounds.height) {
	tree.repaint(0, minBounds.y, tree.getWidth(),
	minBounds.height);
	}
	else {
	tree.repaint(0, minBounds.y, tree.getWidth(),
	tree.getHeight() - minBounds.y);
	}
	}
	else {
	// Nodes that changed aren't visible. No need to paint
	treeState.treeNodesChanged(e);
	}
	}
	}

	public void treeNodesInserted(TreeModelEvent e) {
	if(treeState != null && e != null) {
	treeState.treeNodesInserted(e);

	updateLeadSelectionRow();

	TreePath path = SwingUtilities2.getTreePath(e, getModel());

	if(treeState.isExpanded(path)) {
	updateSize();
	}
	else {
	// PENDING(sky): Need a method in TreeModelEvent
	// that can return the count, getChildIndices allocs
	// a new array!
	int[] indices = e.getChildIndices();
	int childCount = treeModel.getChildCount
	(path.getLastPathComponent());

	if(indices != null && (childCount - indices.length) == 0)
	updateSize();
	}
	}
	}

	public void treeNodesRemoved(TreeModelEvent e) {
	if(treeState != null && e != null) {
	treeState.treeNodesRemoved(e);

	updateLeadSelectionRow();

	TreePath path = SwingUtilities2.getTreePath(e, getModel());

	if(treeState.isExpanded(path) \|\|
	treeModel.getChildCount(path.getLastPathComponent()) == 0)
	updateSize();
	}
	}

	public void treeStructureChanged(TreeModelEvent e) {
	if(treeState != null && e != null) {
	treeState.treeStructureChanged(e);

	updateLeadSelectionRow();

	TreePath pPath = SwingUtilities2.getTreePath(e, getModel());

	if (pPath != null) {
	pPath = pPath.getParentPath();
	}
	if(pPath == null \|\| treeState.isExpanded(pPath))
	updateSize();
	}
	}
	}



	private static class Actions extends UIAction {
	private static final String SELECT_PREVIOUS = "selectPrevious";
	private static final String SELECT_PREVIOUS_CHANGE_LEAD =
	"selectPreviousChangeLead";
	private static final String SELECT_PREVIOUS_EXTEND_SELECTION =
	"selectPreviousExtendSelection";
	private static final String SELECT_NEXT = "selectNext";
	private static final String SELECT_NEXT_CHANGE_LEAD =
	"selectNextChangeLead";
	private static final String SELECT_NEXT_EXTEND_SELECTION =
	"selectNextExtendSelection";
	private static final String SELECT_CHILD = "selectChild";
	private static final String SELECT_CHILD_CHANGE_LEAD =
	"selectChildChangeLead";
	private static final String SELECT_PARENT = "selectParent";
	private static final String SELECT_PARENT_CHANGE_LEAD =
	"selectParentChangeLead";
	private static final String SCROLL_UP_CHANGE_SELECTION =
	"scrollUpChangeSelection";
	private static final String SCROLL_UP_CHANGE_LEAD =
	"scrollUpChangeLead";
	private static final String SCROLL_UP_EXTEND_SELECTION =
	"scrollUpExtendSelection";
	private static final String SCROLL_DOWN_CHANGE_SELECTION =
	"scrollDownChangeSelection";
	private static final String SCROLL_DOWN_EXTEND_SELECTION =
	"scrollDownExtendSelection";
	private static final String SCROLL_DOWN_CHANGE_LEAD =
	"scrollDownChangeLead";
	private static final String SELECT_FIRST = "selectFirst";
	private static final String SELECT_FIRST_CHANGE_LEAD =
	"selectFirstChangeLead";
	private static final String SELECT_FIRST_EXTEND_SELECTION =
	"selectFirstExtendSelection";
	private static final String SELECT_LAST = "selectLast";
	private static final String SELECT_LAST_CHANGE_LEAD =
	"selectLastChangeLead";
	private static final String SELECT_LAST_EXTEND_SELECTION =
	"selectLastExtendSelection";
	private static final String TOGGLE = "toggle";
	private static final String CANCEL_EDITING = "cancel";
	private static final String START_EDITING = "startEditing";
	private static final String SELECT_ALL = "selectAll";
	private static final String CLEAR_SELECTION = "clearSelection";
	private static final String SCROLL_LEFT = "scrollLeft";
	private static final String SCROLL_RIGHT = "scrollRight";
	private static final String SCROLL_LEFT_EXTEND_SELECTION =
	"scrollLeftExtendSelection";
	private static final String SCROLL_RIGHT_EXTEND_SELECTION =
	"scrollRightExtendSelection";
	private static final String SCROLL_RIGHT_CHANGE_LEAD =
	"scrollRightChangeLead";
	private static final String SCROLL_LEFT_CHANGE_LEAD =
	"scrollLeftChangeLead";
	private static final String EXPAND = "expand";
	private static final String COLLAPSE = "collapse";
	private static final String MOVE_SELECTION_TO_PARENT =
	"moveSelectionToParent";

	// add the lead item to the selection without changing lead or anchor
	private static final String ADD_TO_SELECTION = "addToSelection";

	// toggle the selected state of the lead item and move the anchor to it
	private static final String TOGGLE_AND_ANCHOR = "toggleAndAnchor";

	// extend the selection to the lead item
	private static final String EXTEND_TO = "extendTo";

	// move the anchor to the lead and ensure only that item is selected
	private static final String MOVE_SELECTION_TO = "moveSelectionTo";

	Actions() {
	super(null);
	}

	Actions(String key) {
	super(key);
	}

	public boolean isEnabled(Object o) {
	if (o instanceof JTree) {
	if (getName() == CANCEL_EDITING) {
	return ((JTree)o).isEditing();
	}
	}
	return true;
	}

	public void actionPerformed(ActionEvent e) {
	JTree tree = (JTree)e.getSource();
	BasicTreeUI ui = (BasicTreeUI)BasicLookAndFeel.getUIOfType(
	tree.getUI(), BasicTreeUI.class);
	if (ui == null) {
	return;
	}
	String key = getName();
	if (key == SELECT_PREVIOUS) {
	increment(tree, ui, -1, false, true);
	}
	else if (key == SELECT_PREVIOUS_CHANGE_LEAD) {
	increment(tree, ui, -1, false, false);
	}
	else if (key == SELECT_PREVIOUS_EXTEND_SELECTION) {
	increment(tree, ui, -1, true, true);
	}
	else if (key == SELECT_NEXT) {
	increment(tree, ui, 1, false, true);
	}
	else if (key == SELECT_NEXT_CHANGE_LEAD) {
	increment(tree, ui, 1, false, false);
	}
	else if (key == SELECT_NEXT_EXTEND_SELECTION) {
	increment(tree, ui, 1, true, true);
	}
	else if (key == SELECT_CHILD) {
	traverse(tree, ui, 1, true);
	}
	else if (key == SELECT_CHILD_CHANGE_LEAD) {
	traverse(tree, ui, 1, false);
	}
	else if (key == SELECT_PARENT) {
	traverse(tree, ui, -1, true);
	}
	else if (key == SELECT_PARENT_CHANGE_LEAD) {
	traverse(tree, ui, -1, false);
	}
	else if (key == SCROLL_UP_CHANGE_SELECTION) {
	page(tree, ui, -1, false, true);
	}
	else if (key == SCROLL_UP_CHANGE_LEAD) {
	page(tree, ui, -1, false, false);
	}
	else if (key == SCROLL_UP_EXTEND_SELECTION) {
	page(tree, ui, -1, true, true);
	}
	else if (key == SCROLL_DOWN_CHANGE_SELECTION) {
	page(tree, ui, 1, false, true);
	}
	else if (key == SCROLL_DOWN_EXTEND_SELECTION) {
	page(tree, ui, 1, true, true);
	}
	else if (key == SCROLL_DOWN_CHANGE_LEAD) {
	page(tree, ui, 1, false, false);
	}
	else if (key == SELECT_FIRST) {
	home(tree, ui, -1, false, true);
	}
	else if (key == SELECT_FIRST_CHANGE_LEAD) {
	home(tree, ui, -1, false, false);
	}
	else if (key == SELECT_FIRST_EXTEND_SELECTION) {
	home(tree, ui, -1, true, true);
	}
	else if (key == SELECT_LAST) {
	home(tree, ui, 1, false, true);
	}
	else if (key == SELECT_LAST_CHANGE_LEAD) {
	home(tree, ui, 1, false, false);
	}
	else if (key == SELECT_LAST_EXTEND_SELECTION) {
	home(tree, ui, 1, true, true);
	}
	else if (key == TOGGLE) {
	toggle(tree, ui);
	}
	else if (key == CANCEL_EDITING) {
	cancelEditing(tree, ui);
	}
	else if (key == START_EDITING) {
	startEditing(tree, ui);
	}
	else if (key == SELECT_ALL) {
	selectAll(tree, ui, true);
	}
	else if (key == CLEAR_SELECTION) {
	selectAll(tree, ui, false);
	}
	else if (key == ADD_TO_SELECTION) {
	if (ui.getRowCount(tree) > 0) {
	int lead = ui.getLeadSelectionRow();
	if (!tree.isRowSelected(lead)) {
	TreePath aPath = ui.getAnchorSelectionPath();
	tree.addSelectionRow(lead);
	ui.setAnchorSelectionPath(aPath);
	}
	}
	}
	else if (key == TOGGLE_AND_ANCHOR) {
	if (ui.getRowCount(tree) > 0) {
	int lead = ui.getLeadSelectionRow();
	TreePath lPath = ui.getLeadSelectionPath();
	if (!tree.isRowSelected(lead)) {
	tree.addSelectionRow(lead);
	} else {
	tree.removeSelectionRow(lead);
	ui.setLeadSelectionPath(lPath);
	}
	ui.setAnchorSelectionPath(lPath);
	}
	}
	else if (key == EXTEND_TO) {
	extendSelection(tree, ui);
	}
	else if (key == MOVE_SELECTION_TO) {
	if (ui.getRowCount(tree) > 0) {
	int lead = ui.getLeadSelectionRow();
	tree.setSelectionInterval(lead, lead);
	}
	}
	else if (key == SCROLL_LEFT) {
	scroll(tree, ui, SwingConstants.HORIZONTAL, -10);
	}
	else if (key == SCROLL_RIGHT) {
	scroll(tree, ui, SwingConstants.HORIZONTAL, 10);
	}
	else if (key == SCROLL_LEFT_EXTEND_SELECTION) {
	scrollChangeSelection(tree, ui, -1, true, true);
	}
	else if (key == SCROLL_RIGHT_EXTEND_SELECTION) {
	scrollChangeSelection(tree, ui, 1, true, true);
	}
	else if (key == SCROLL_RIGHT_CHANGE_LEAD) {
	scrollChangeSelection(tree, ui, 1, false, false);
	}
	else if (key == SCROLL_LEFT_CHANGE_LEAD) {
	scrollChangeSelection(tree, ui, -1, false, false);
	}
	else if (key == EXPAND) {
	expand(tree, ui);
	}
	else if (key == COLLAPSE) {
	collapse(tree, ui);
	}
	else if (key == MOVE_SELECTION_TO_PARENT) {
	moveSelectionToParent(tree, ui);
	}
	}

	private void scrollChangeSelection(JTree tree, BasicTreeUI ui,
	int direction, boolean addToSelection,
	boolean changeSelection) {
	int rowCount;

	if((rowCount = ui.getRowCount(tree)) > 0 &&
	ui.treeSelectionModel != null) {
	TreePath newPath;
	Rectangle visRect = tree.getVisibleRect();

	if (direction == -1) {
	newPath = ui.getClosestPathForLocation(tree, visRect.x,
	visRect.y);
	visRect.x = Math.max(0, visRect.x - visRect.width);
	}
	else {
	visRect.x = Math.min(Math.max(0, tree.getWidth() -
	visRect.width), visRect.x + visRect.width);
	newPath = ui.getClosestPathForLocation(tree, visRect.x,
	visRect.y + visRect.height);
	}
	// Scroll
	tree.scrollRectToVisible(visRect);
	// select
	if (addToSelection) {
	ui.extendSelection(newPath);
	}
	else if(changeSelection) {
	tree.setSelectionPath(newPath);
	}
	else {
	ui.setLeadSelectionPath(newPath, true);
	}
	}
	}

	private void scroll(JTree component, BasicTreeUI ui, int direction,
	int amount) {
	Rectangle visRect = component.getVisibleRect();
	Dimension size = component.getSize();
	if (direction == SwingConstants.HORIZONTAL) {
	visRect.x += amount;
	visRect.x = Math.max(0, visRect.x);
	visRect.x = Math.min(Math.max(0, size.width - visRect.width),
	visRect.x);
	}
	else {
	visRect.y += amount;
	visRect.y = Math.max(0, visRect.y);
	visRect.y = Math.min(Math.max(0, size.width - visRect.height),
	visRect.y);
	}
	component.scrollRectToVisible(visRect);
	}

	private void extendSelection(JTree tree, BasicTreeUI ui) {
	if (ui.getRowCount(tree) > 0) {
	int lead = ui.getLeadSelectionRow();

	if (lead != -1) {
	TreePath leadP = ui.getLeadSelectionPath();
	TreePath aPath = ui.getAnchorSelectionPath();
	int aRow = ui.getRowForPath(tree, aPath);

	if(aRow == -1)
	aRow = 0;
	tree.setSelectionInterval(aRow, lead);
	ui.setLeadSelectionPath(leadP);
	ui.setAnchorSelectionPath(aPath);
	}
	}
	}

	private void selectAll(JTree tree, BasicTreeUI ui, boolean selectAll) {
	int rowCount = ui.getRowCount(tree);

	if(rowCount > 0) {
	if(selectAll) {
	if (tree.getSelectionModel().getSelectionMode() ==
	TreeSelectionModel.SINGLE_TREE_SELECTION) {

	int lead = ui.getLeadSelectionRow();
	if (lead != -1) {
	tree.setSelectionRow(lead);
	} else if (tree.getMinSelectionRow() == -1) {
	tree.setSelectionRow(0);
	ui.ensureRowsAreVisible(0, 0);
	}
	return;
	}

	TreePath lastPath = ui.getLeadSelectionPath();
	TreePath aPath = ui.getAnchorSelectionPath();

	if(lastPath != null && !tree.isVisible(lastPath)) {
	lastPath = null;
	}
	tree.setSelectionInterval(0, rowCount - 1);
	if(lastPath != null) {
	ui.setLeadSelectionPath(lastPath);
	}
	if(aPath != null && tree.isVisible(aPath)) {
	ui.setAnchorSelectionPath(aPath);
	}
	}
	else {
	TreePath lastPath = ui.getLeadSelectionPath();
	TreePath aPath = ui.getAnchorSelectionPath();

	tree.clearSelection();
	ui.setAnchorSelectionPath(aPath);
	ui.setLeadSelectionPath(lastPath);
	}
	}
	}

	private void startEditing(JTree tree, BasicTreeUI ui) {
	TreePath lead = ui.getLeadSelectionPath();
	int editRow = (lead != null) ?
	ui.getRowForPath(tree, lead) : -1;

	if(editRow != -1) {
	tree.startEditingAtPath(lead);
	}
	}

	private void cancelEditing(JTree tree, BasicTreeUI ui) {
	tree.cancelEditing();
	}

	private void toggle(JTree tree, BasicTreeUI ui) {
	int selRow = ui.getLeadSelectionRow();

	if(selRow != -1 && !ui.isLeaf(selRow)) {
	TreePath aPath = ui.getAnchorSelectionPath();
	TreePath lPath = ui.getLeadSelectionPath();

	ui.toggleExpandState(ui.getPathForRow(tree, selRow));
	ui.setAnchorSelectionPath(aPath);
	ui.setLeadSelectionPath(lPath);
	}
	}

	private void expand(JTree tree, BasicTreeUI ui) {
	int selRow = ui.getLeadSelectionRow();
	tree.expandRow(selRow);
	}

	private void collapse(JTree tree, BasicTreeUI ui) {
	int selRow = ui.getLeadSelectionRow();
	tree.collapseRow(selRow);
	}

	private void increment(JTree tree, BasicTreeUI ui, int direction,
	boolean addToSelection,
	boolean changeSelection) {

	// disable moving of lead unless in discontiguous mode
	if (!addToSelection && !changeSelection &&
	tree.getSelectionModel().getSelectionMode() !=
	TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION) {
	changeSelection = true;
	}

	int rowCount;

	if(ui.treeSelectionModel != null &&
	(rowCount = tree.getRowCount()) > 0) {
	int selIndex = ui.getLeadSelectionRow();
	int newIndex;

	if(selIndex == -1) {
	if(direction == 1)
	newIndex = 0;
	else
	newIndex = rowCount - 1;
	}
	else
	/* Aparently people don't like wrapping;( */
	newIndex = Math.min(rowCount - 1, Math.max
	(0, (selIndex + direction)));
	if(addToSelection && ui.treeSelectionModel.
	getSelectionMode() != TreeSelectionModel.
	SINGLE_TREE_SELECTION) {
	ui.extendSelection(tree.getPathForRow(newIndex));
	}
	else if(changeSelection) {
	tree.setSelectionInterval(newIndex, newIndex);
	}
	else {
	ui.setLeadSelectionPath(tree.getPathForRow(newIndex),true);
	}
	ui.ensureRowsAreVisible(newIndex, newIndex);
	ui.lastSelectedRow = newIndex;
	}
	}

	private void traverse(JTree tree, BasicTreeUI ui, int direction,
	boolean changeSelection) {

	// disable moving of lead unless in discontiguous mode
	if (!changeSelection &&
	tree.getSelectionModel().getSelectionMode() !=
	TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION) {
	changeSelection = true;
	}

	int rowCount;

	if((rowCount = tree.getRowCount()) > 0) {
	int minSelIndex = ui.getLeadSelectionRow();
	int newIndex;

	if(minSelIndex == -1)
	newIndex = 0;
	else {
	/* Try and expand the node, otherwise go to next
	node. */
	if(direction == 1) {
	TreePath minSelPath = ui.getPathForRow(tree, minSelIndex);
	int childCount = tree.getModel().
	getChildCount(minSelPath.getLastPathComponent());
	newIndex = -1;
	if (!ui.isLeaf(minSelIndex)) {
	if (!tree.isExpanded(minSelIndex)) {
	ui.toggleExpandState(minSelPath);
	}
	else if (childCount > 0) {
	newIndex = Math.min(minSelIndex + 1, rowCount - 1);
	}
	}
	}
	/* Try to collapse node. */
	else {
	if(!ui.isLeaf(minSelIndex) &&
	tree.isExpanded(minSelIndex)) {
	ui.toggleExpandState(ui.getPathForRow
	(tree, minSelIndex));
	newIndex = -1;
	}
	else {
	TreePath path = ui.getPathForRow(tree,
	minSelIndex);

	if(path != null && path.getPathCount() > 1) {
	newIndex = ui.getRowForPath(tree, path.
	getParentPath());
	}
	else
	newIndex = -1;
	}
	}
	}
	if(newIndex != -1) {
	if(changeSelection) {
	tree.setSelectionInterval(newIndex, newIndex);
	}
	else {
	ui.setLeadSelectionPath(ui.getPathForRow(
	tree, newIndex), true);
	}
	ui.ensureRowsAreVisible(newIndex, newIndex);
	}
	}
	}

	private void moveSelectionToParent(JTree tree, BasicTreeUI ui) {
	int selRow = ui.getLeadSelectionRow();
	TreePath path = ui.getPathForRow(tree, selRow);
	if (path != null && path.getPathCount() > 1) {
	int newIndex = ui.getRowForPath(tree, path.getParentPath());
	if (newIndex != -1) {
	tree.setSelectionInterval(newIndex, newIndex);
	ui.ensureRowsAreVisible(newIndex, newIndex);
	}
	}
	}

	private void page(JTree tree, BasicTreeUI ui, int direction,
	boolean addToSelection, boolean changeSelection) {

	// disable moving of lead unless in discontiguous mode
	if (!addToSelection && !changeSelection &&
	tree.getSelectionModel().getSelectionMode() !=
	TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION) {
	changeSelection = true;
	}

	int rowCount;

	if((rowCount = ui.getRowCount(tree)) > 0 &&
	ui.treeSelectionModel != null) {
	Dimension maxSize = tree.getSize();
	TreePath lead = ui.getLeadSelectionPath();
	TreePath newPath;
	Rectangle visRect = tree.getVisibleRect();

	if(direction == -1) {
	// up.
	newPath = ui.getClosestPathForLocation(tree, visRect.x,
	visRect.y);
	if(newPath.equals(lead)) {
	visRect.y = Math.max(0, visRect.y - visRect.height);
	newPath = tree.getClosestPathForLocation(visRect.x,
	visRect.y);
	}
	}
	else {
	// down
	visRect.y = Math.min(maxSize.height, visRect.y +
	visRect.height - 1);
	newPath = tree.getClosestPathForLocation(visRect.x,
	visRect.y);
	if(newPath.equals(lead)) {
	visRect.y = Math.min(maxSize.height, visRect.y +
	visRect.height - 1);
	newPath = tree.getClosestPathForLocation(visRect.x,
	visRect.y);
	}
	}
	Rectangle newRect = ui.getPathBounds(tree, newPath);
	if (newRect != null) {
	newRect.x = visRect.x;
	newRect.width = visRect.width;
	if(direction == -1) {
	newRect.height = visRect.height;
	}
	else {
	newRect.y -= (visRect.height - newRect.height);
	newRect.height = visRect.height;
	}

	if(addToSelection) {
	ui.extendSelection(newPath);
	}
	else if(changeSelection) {
	tree.setSelectionPath(newPath);
	}
	else {
	ui.setLeadSelectionPath(newPath, true);
	}
	tree.scrollRectToVisible(newRect);
	}
	}
	}

	private void home(JTree tree, final BasicTreeUI ui, int direction,
	boolean addToSelection, boolean changeSelection) {

	// disable moving of lead unless in discontiguous mode
	if (!addToSelection && !changeSelection &&
	tree.getSelectionModel().getSelectionMode() !=
	TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION) {
	changeSelection = true;
	}

	final int rowCount = ui.getRowCount(tree);

	if (rowCount > 0) {
	if(direction == -1) {
	ui.ensureRowsAreVisible(0, 0);
	if (addToSelection) {
	TreePath aPath = ui.getAnchorSelectionPath();
	int aRow = (aPath == null) ? -1 :
	ui.getRowForPath(tree, aPath);

	if (aRow == -1) {
	tree.setSelectionInterval(0, 0);
	}
	else {
	tree.setSelectionInterval(0, aRow);
	ui.setAnchorSelectionPath(aPath);
	ui.setLeadSelectionPath(ui.getPathForRow(tree, 0));
	}
	}
	else if(changeSelection) {
	tree.setSelectionInterval(0, 0);
	}
	else {
	ui.setLeadSelectionPath(ui.getPathForRow(tree, 0),
	true);
	}
	}
	else {
	ui.ensureRowsAreVisible(rowCount - 1, rowCount - 1);
	if (addToSelection) {
	TreePath aPath = ui.getAnchorSelectionPath();
	int aRow = (aPath == null) ? -1 :
	ui.getRowForPath(tree, aPath);

	if (aRow == -1) {
	tree.setSelectionInterval(rowCount - 1,
	rowCount -1);
	}
	else {
	tree.setSelectionInterval(aRow, rowCount - 1);
	ui.setAnchorSelectionPath(aPath);
	ui.setLeadSelectionPath(ui.getPathForRow(tree,
	rowCount -1));
	}
	}
	else if(changeSelection) {
	tree.setSelectionInterval(rowCount - 1, rowCount - 1);
	}
	else {
	ui.setLeadSelectionPath(ui.getPathForRow(tree,
	rowCount - 1), true);
	}
	if (ui.isLargeModel()){
	SwingUtilities.invokeLater(new Runnable() {
	public void run() {
	ui.ensureRowsAreVisible(rowCount - 1, rowCount - 1);
	}
	});
	}
	}
	}
	}
	}
	} // End of class BasicTreeUI

Back to index...