My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/javax/swing/plaf/basic/BasicTreeUI.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/swing/plaf/basic/BasicTreeUI.java+4557−0

@@ -0,0 +1,4557 @@
	1	+/*
	2	+ * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package javax.swing.plaf.basic;
	27	+
	28	+import javax.swing.*;
	29	+import javax.swing.event.*;
	30	+import java.awt.*;
	31	+import java.awt.event.*;
	32	+import java.awt.datatransfer.*;
	33	+import java.beans.*;
	34	+import java.util.Enumeration;
	35	+import java.util.Hashtable;
	36	+import java.util.ArrayList;
	37	+import java.util.Collections;
	38	+import java.util.Comparator;
	39	+import javax.swing.plaf.ComponentUI;
	40	+import javax.swing.plaf.UIResource;
	41	+import javax.swing.plaf.TreeUI;
	42	+import javax.swing.tree.*;
	43	+import javax.swing.text.Position;
	44	+import javax.swing.plaf.basic.DragRecognitionSupport.BeforeDrag;
	45	+import sun.swing.SwingUtilities2;
	46	+
	47	+import sun.swing.DefaultLookup;
	48	+import sun.swing.UIAction;
	49	+
	50	+/**
	51	+ * The basic L&F for a hierarchical data structure.
	52	+ * <p>
	53	+ *
	54	+ * @author Scott Violet
	55	+ * @author Shannon Hickey (drag and drop)
	56	+ */
	57	+
	58	+public class BasicTreeUI extends TreeUI
	59	+{
	60	+ private static final StringBuilder BASELINE_COMPONENT_KEY =
	61	+ new StringBuilder("Tree.baselineComponent");
	62	+
	63	+ // Old actions forward to an instance of this.
	64	+ static private final Actions SHARED_ACTION = new Actions();
	65	+
	66	+ transient protected Icon collapsedIcon;
	67	+ transient protected Icon expandedIcon;
	68	+
	69	+ /**
	70	+ * Color used to draw hash marks. If <code>null</code> no hash marks
	71	+ * will be drawn.
	72	+ */
	73	+ private Color hashColor;
	74	+
	75	+ /** Distance between left margin and where vertical dashes will be
	76	+ * drawn. */
	77	+ protected int leftChildIndent;
	78	+ /** Distance to add to leftChildIndent to determine where cell
	79	+ * contents will be drawn. */
	80	+ protected int rightChildIndent;
	81	+ /** Total distance that will be indented. The sum of leftChildIndent
	82	+ * and rightChildIndent. */
	83	+ protected int totalChildIndent;
	84	+
	85	+ /** Minimum preferred size. */
	86	+ protected Dimension preferredMinSize;
	87	+
	88	+ /** Index of the row that was last selected. */
	89	+ protected int lastSelectedRow;
	90	+
	91	+ /** Component that we're going to be drawing into. */
	92	+ protected JTree tree;
	93	+
	94	+ /** Renderer that is being used to do the actual cell drawing. */
	95	+ transient protected TreeCellRenderer currentCellRenderer;
	96	+
	97	+ /** Set to true if the renderer that is currently in the tree was
	98	+ * created by this instance. */
	99	+ protected boolean createdRenderer;
	100	+
	101	+ /** Editor for the tree. */
	102	+ transient protected TreeCellEditor cellEditor;
	103	+
	104	+ /** Set to true if editor that is currently in the tree was
	105	+ * created by this instance. */
	106	+ protected boolean createdCellEditor;
	107	+
	108	+ /** Set to false when editing and shouldSelectCell() returns true meaning
	109	+ * the node should be selected before editing, used in completeEditing. */
	110	+ protected boolean stopEditingInCompleteEditing;
	111	+
	112	+ /** Used to paint the TreeCellRenderer. */
	113	+ protected CellRendererPane rendererPane;
	114	+
	115	+ /** Size needed to completely display all the nodes. */
	116	+ protected Dimension preferredSize;
	117	+
	118	+ /** Is the preferredSize valid? */
	119	+ protected boolean validCachedPreferredSize;
	120	+
	121	+ /** Object responsible for handling sizing and expanded issues. */
	122	+ // WARNING: Be careful with the bounds held by treeState. They are
	123	+ // always in terms of left-to-right. They get mapped to right-to-left
	124	+ // by the various methods of this class.
	125	+ protected AbstractLayoutCache treeState;
	126	+
	127	+
	128	+ /** Used for minimizing the drawing of vertical lines. */
	129	+ protected Hashtable<TreePath,Boolean> drawingCache;
	130	+
	131	+ /** True if doing optimizations for a largeModel. Subclasses that
	132	+ * don't support this may wish to override createLayoutCache to not
	133	+ * return a FixedHeightLayoutCache instance. */
	134	+ protected boolean largeModel;
	135	+
	136	+ /** Reponsible for telling the TreeState the size needed for a node. */
	137	+ protected AbstractLayoutCache.NodeDimensions nodeDimensions;
	138	+
	139	+ /** Used to determine what to display. */
	140	+ protected TreeModel treeModel;
	141	+
	142	+ /** Model maintaing the selection. */
	143	+ protected TreeSelectionModel treeSelectionModel;
	144	+
	145	+ /** How much the depth should be offset to properly calculate
	146	+ * x locations. This is based on whether or not the root is visible,
	147	+ * and if the root handles are visible. */
	148	+ protected int depthOffset;
	149	+
	150	+ // Following 4 ivars are only valid when editing.
	151	+
	152	+ /** When editing, this will be the Component that is doing the actual
	153	+ * editing. */
	154	+ protected Component editingComponent;
	155	+
	156	+ /** Path that is being edited. */
	157	+ protected TreePath editingPath;
	158	+
	159	+ /** Row that is being edited. Should only be referenced if
	160	+ * editingComponent is not null. */
	161	+ protected int editingRow;
	162	+
	163	+ /** Set to true if the editor has a different size than the renderer. */
	164	+ protected boolean editorHasDifferentSize;
	165	+
	166	+ /** Row correspondin to lead path. */
	167	+ private int leadRow;
	168	+ /** If true, the property change event for LEAD_SELECTION_PATH_PROPERTY,
	169	+ * or ANCHOR_SELECTION_PATH_PROPERTY will not generate a repaint. */
	170	+ private boolean ignoreLAChange;
	171	+
	172	+ /** Indicates the orientation. */
	173	+ private boolean leftToRight;
	174	+
	175	+ // Cached listeners
	176	+ private PropertyChangeListener propertyChangeListener;
	177	+ private PropertyChangeListener selectionModelPropertyChangeListener;
	178	+ private MouseListener mouseListener;
	179	+ private FocusListener focusListener;
	180	+ private KeyListener keyListener;
	181	+ /** Used for large models, listens for moved/resized events and
	182	+ * updates the validCachedPreferredSize bit accordingly. */
	183	+ private ComponentListener componentListener;
	184	+ /** Listens for CellEditor events. */
	185	+ private CellEditorListener cellEditorListener;
	186	+ /** Updates the display when the selection changes. */
	187	+ private TreeSelectionListener treeSelectionListener;
	188	+ /** Is responsible for updating the display based on model events. */
	189	+ private TreeModelListener treeModelListener;
	190	+ /** Updates the treestate as the nodes expand. */
	191	+ private TreeExpansionListener treeExpansionListener;
	192	+
	193	+ /** UI property indicating whether to paint lines */
	194	+ private boolean paintLines = true;
	195	+
	196	+ /** UI property for painting dashed lines */
	197	+ private boolean lineTypeDashed;
	198	+
	199	+ /**
	200	+ * The time factor to treate the series of typed alphanumeric key
	201	+ * as prefix for first letter navigation.
	202	+ */
	203	+ private long timeFactor = 1000L;
	204	+
	205	+ private Handler handler;
	206	+
	207	+ /**
	208	+ * A temporary variable for communication between startEditingOnRelease
	209	+ * and startEditing.
	210	+ */
	211	+ private MouseEvent releaseEvent;
	212	+
	213	+ public static ComponentUI createUI(JComponent x) {
	214	+ return new BasicTreeUI();
	215	+ }
	216	+
	217	+
	218	+ static void loadActionMap(LazyActionMap map) {
	219	+ map.put(new Actions(Actions.SELECT_PREVIOUS));
	220	+ map.put(new Actions(Actions.SELECT_PREVIOUS_CHANGE_LEAD));
	221	+ map.put(new Actions(Actions.SELECT_PREVIOUS_EXTEND_SELECTION));
	222	+
	223	+ map.put(new Actions(Actions.SELECT_NEXT));
	224	+ map.put(new Actions(Actions.SELECT_NEXT_CHANGE_LEAD));
	225	+ map.put(new Actions(Actions.SELECT_NEXT_EXTEND_SELECTION));
	226	+
	227	+ map.put(new Actions(Actions.SELECT_CHILD));
	228	+ map.put(new Actions(Actions.SELECT_CHILD_CHANGE_LEAD));
	229	+
	230	+ map.put(new Actions(Actions.SELECT_PARENT));
	231	+ map.put(new Actions(Actions.SELECT_PARENT_CHANGE_LEAD));
	232	+
	233	+ map.put(new Actions(Actions.SCROLL_UP_CHANGE_SELECTION));
	234	+ map.put(new Actions(Actions.SCROLL_UP_CHANGE_LEAD));
	235	+ map.put(new Actions(Actions.SCROLL_UP_EXTEND_SELECTION));
	236	+
	237	+ map.put(new Actions(Actions.SCROLL_DOWN_CHANGE_SELECTION));
	238	+ map.put(new Actions(Actions.SCROLL_DOWN_EXTEND_SELECTION));
	239	+ map.put(new Actions(Actions.SCROLL_DOWN_CHANGE_LEAD));
	240	+
	241	+ map.put(new Actions(Actions.SELECT_FIRST));
	242	+ map.put(new Actions(Actions.SELECT_FIRST_CHANGE_LEAD));
	243	+ map.put(new Actions(Actions.SELECT_FIRST_EXTEND_SELECTION));
	244	+
	245	+ map.put(new Actions(Actions.SELECT_LAST));
	246	+ map.put(new Actions(Actions.SELECT_LAST_CHANGE_LEAD));
	247	+ map.put(new Actions(Actions.SELECT_LAST_EXTEND_SELECTION));
	248	+
	249	+ map.put(new Actions(Actions.TOGGLE));
	250	+
	251	+ map.put(new Actions(Actions.CANCEL_EDITING));
	252	+
	253	+ map.put(new Actions(Actions.START_EDITING));
	254	+
	255	+ map.put(new Actions(Actions.SELECT_ALL));
	256	+
	257	+ map.put(new Actions(Actions.CLEAR_SELECTION));
	258	+
	259	+ map.put(new Actions(Actions.SCROLL_LEFT));
	260	+ map.put(new Actions(Actions.SCROLL_RIGHT));
	261	+
	262	+ map.put(new Actions(Actions.SCROLL_LEFT_EXTEND_SELECTION));
	263	+ map.put(new Actions(Actions.SCROLL_RIGHT_EXTEND_SELECTION));
	264	+
	265	+ map.put(new Actions(Actions.SCROLL_RIGHT_CHANGE_LEAD));
	266	+ map.put(new Actions(Actions.SCROLL_LEFT_CHANGE_LEAD));
	267	+
	268	+ map.put(new Actions(Actions.EXPAND));
	269	+ map.put(new Actions(Actions.COLLAPSE));
	270	+ map.put(new Actions(Actions.MOVE_SELECTION_TO_PARENT));
	271	+
	272	+ map.put(new Actions(Actions.ADD_TO_SELECTION));
	273	+ map.put(new Actions(Actions.TOGGLE_AND_ANCHOR));
	274	+ map.put(new Actions(Actions.EXTEND_TO));
	275	+ map.put(new Actions(Actions.MOVE_SELECTION_TO));
	276	+
	277	+ map.put(TransferHandler.getCutAction());
	278	+ map.put(TransferHandler.getCopyAction());
	279	+ map.put(TransferHandler.getPasteAction());
	280	+ }
	281	+
	282	+
	283	+ public BasicTreeUI() {
	284	+ super();
	285	+ }
	286	+
	287	+ protected Color getHashColor() {
	288	+ return hashColor;
	289	+ }
	290	+
	291	+ protected void setHashColor(Color color) {
	292	+ hashColor = color;
	293	+ }
	294	+
	295	+ public void setLeftChildIndent(int newAmount) {
	296	+ leftChildIndent = newAmount;
	297	+ totalChildIndent = leftChildIndent + rightChildIndent;
	298	+ if(treeState != null)
	299	+ treeState.invalidateSizes();
	300	+ updateSize();
	301	+ }
	302	+
	303	+ public int getLeftChildIndent() {
	304	+ return leftChildIndent;
	305	+ }
	306	+
	307	+ public void setRightChildIndent(int newAmount) {
	308	+ rightChildIndent = newAmount;
	309	+ totalChildIndent = leftChildIndent + rightChildIndent;
	310	+ if(treeState != null)
	311	+ treeState.invalidateSizes();
	312	+ updateSize();
	313	+ }
	314	+
	315	+ public int getRightChildIndent() {
	316	+ return rightChildIndent;
	317	+ }
	318	+
	319	+ public void setExpandedIcon(Icon newG) {
	320	+ expandedIcon = newG;
	321	+ }
	322	+
	323	+ public Icon getExpandedIcon() {
	324	+ return expandedIcon;
	325	+ }
	326	+
	327	+ public void setCollapsedIcon(Icon newG) {
	328	+ collapsedIcon = newG;
	329	+ }
	330	+
	331	+ public Icon getCollapsedIcon() {
	332	+ return collapsedIcon;
	333	+ }
	334	+
	335	+ //
	336	+ // Methods for configuring the behavior of the tree. None of them
	337	+ // push the value to the JTree instance. You should really only
	338	+ // call these methods on the JTree.
	339	+ //
	340	+
	341	+ /**
	342	+ * Updates the componentListener, if necessary.
	343	+ */
	344	+ protected void setLargeModel(boolean largeModel) {
	345	+ if(getRowHeight() < 1)
	346	+ largeModel = false;
	347	+ if(this.largeModel != largeModel) {
	348	+ completeEditing();
	349	+ this.largeModel = largeModel;
	350	+ treeState = createLayoutCache();
	351	+ configureLayoutCache();
	352	+ updateLayoutCacheExpandedNodesIfNecessary();
	353	+ updateSize();
	354	+ }
	355	+ }
	356	+
	357	+ protected boolean isLargeModel() {
	358	+ return largeModel;
	359	+ }
	360	+
	361	+ /**
	362	+ * Sets the row height, this is forwarded to the treeState.
	363	+ */
	364	+ protected void setRowHeight(int rowHeight) {
	365	+ completeEditing();
	366	+ if(treeState != null) {
	367	+ setLargeModel(tree.isLargeModel());
	368	+ treeState.setRowHeight(rowHeight);
	369	+ updateSize();
	370	+ }
	371	+ }
	372	+
	373	+ protected int getRowHeight() {
	374	+ return (tree == null) ? -1 : tree.getRowHeight();
	375	+ }
	376	+
	377	+ /**
	378	+ * Sets the TreeCellRenderer to <code>tcr</code>. This invokes
	379	+ * <code>updateRenderer</code>.
	380	+ */
	381	+ protected void setCellRenderer(TreeCellRenderer tcr) {
	382	+ completeEditing();
	383	+ updateRenderer();
	384	+ if(treeState != null) {
	385	+ treeState.invalidateSizes();
	386	+ updateSize();
	387	+ }
	388	+ }
	389	+
	390	+ /**
	391	+ * Return currentCellRenderer, which will either be the trees
	392	+ * renderer, or defaultCellRenderer, which ever wasn't null.
	393	+ */
	394	+ protected TreeCellRenderer getCellRenderer() {
	395	+ return currentCellRenderer;
	396	+ }
	397	+
	398	+ /**
	399	+ * Sets the TreeModel.
	400	+ */
	401	+ protected void setModel(TreeModel model) {
	402	+ completeEditing();
	403	+ if(treeModel != null && treeModelListener != null)
	404	+ treeModel.removeTreeModelListener(treeModelListener);
	405	+ treeModel = model;
	406	+ if(treeModel != null) {
	407	+ if(treeModelListener != null)
	408	+ treeModel.addTreeModelListener(treeModelListener);
	409	+ }
	410	+ if(treeState != null) {
	411	+ treeState.setModel(model);
	412	+ updateLayoutCacheExpandedNodesIfNecessary();
	413	+ updateSize();
	414	+ }
	415	+ }
	416	+
	417	+ protected TreeModel getModel() {
	418	+ return treeModel;
	419	+ }
	420	+
	421	+ /**
	422	+ * Sets the root to being visible.
	423	+ */
	424	+ protected void setRootVisible(boolean newValue) {
	425	+ completeEditing();
	426	+ updateDepthOffset();
	427	+ if(treeState != null) {
	428	+ treeState.setRootVisible(newValue);
	429	+ treeState.invalidateSizes();
	430	+ updateSize();
	431	+ }
	432	+ }
	433	+
	434	+ protected boolean isRootVisible() {
	435	+ return (tree != null) ? tree.isRootVisible() : false;
	436	+ }
	437	+
	438	+ /**
	439	+ * Determines whether the node handles are to be displayed.
	440	+ */
	441	+ protected void setShowsRootHandles(boolean newValue) {
	442	+ completeEditing();
	443	+ updateDepthOffset();
	444	+ if(treeState != null) {
	445	+ treeState.invalidateSizes();
	446	+ updateSize();
	447	+ }
	448	+ }
	449	+
	450	+ protected boolean getShowsRootHandles() {
	451	+ return (tree != null) ? tree.getShowsRootHandles() : false;
	452	+ }
	453	+
	454	+ /**
	455	+ * Sets the cell editor.
	456	+ */
	457	+ protected void setCellEditor(TreeCellEditor editor) {
	458	+ updateCellEditor();
	459	+ }
	460	+
	461	+ protected TreeCellEditor getCellEditor() {
	462	+ return (tree != null) ? tree.getCellEditor() : null;
	463	+ }
	464	+
	465	+ /**
	466	+ * Configures the receiver to allow, or not allow, editing.
	467	+ */
	468	+ protected void setEditable(boolean newValue) {
	469	+ updateCellEditor();
	470	+ }
	471	+
	472	+ protected boolean isEditable() {
	473	+ return (tree != null) ? tree.isEditable() : false;
	474	+ }
	475	+
	476	+ /**
	477	+ * Resets the selection model. The appropriate listener are installed
	478	+ * on the model.
	479	+ */
	480	+ protected void setSelectionModel(TreeSelectionModel newLSM) {
	481	+ completeEditing();
	482	+ if(selectionModelPropertyChangeListener != null &&
	483	+ treeSelectionModel != null)
	484	+ treeSelectionModel.removePropertyChangeListener
	485	+ (selectionModelPropertyChangeListener);
	486	+ if(treeSelectionListener != null && treeSelectionModel != null)
	487	+ treeSelectionModel.removeTreeSelectionListener
	488	+ (treeSelectionListener);
	489	+ treeSelectionModel = newLSM;
	490	+ if(treeSelectionModel != null) {
	491	+ if(selectionModelPropertyChangeListener != null)
	492	+ treeSelectionModel.addPropertyChangeListener
	493	+ (selectionModelPropertyChangeListener);
	494	+ if(treeSelectionListener != null)
	495	+ treeSelectionModel.addTreeSelectionListener
	496	+ (treeSelectionListener);
	497	+ if(treeState != null)
	498	+ treeState.setSelectionModel(treeSelectionModel);
	499	+ }
	500	+ else if(treeState != null)
	501	+ treeState.setSelectionModel(null);
	502	+ if(tree != null)
	503	+ tree.repaint();
	504	+ }
	505	+
	506	+ protected TreeSelectionModel getSelectionModel() {
	507	+ return treeSelectionModel;
	508	+ }
	509	+
	510	+ //
	511	+ // TreeUI methods
	512	+ //
	513	+
	514	+ /**
	515	+ * Returns the Rectangle enclosing the label portion that the
	516	+ * last item in path will be drawn into. Will return null if
	517	+ * any component in path is currently valid.
	518	+ */
	519	+ public Rectangle getPathBounds(JTree tree, TreePath path) {
	520	+ if(tree != null && treeState != null) {
	521	+ return getPathBounds(path, tree.getInsets(), new Rectangle());
	522	+ }
	523	+ return null;
	524	+ }
	525	+
	526	+ private Rectangle getPathBounds(TreePath path, Insets insets,
	527	+ Rectangle bounds) {
	528	+ bounds = treeState.getBounds(path, bounds);
	529	+ if (bounds != null) {
	530	+ if (leftToRight) {
	531	+ bounds.x += insets.left;
	532	+ } else {
	533	+ bounds.x = tree.getWidth() - (bounds.x + bounds.width) -
	534	+ insets.right;
	535	+ }
	536	+ bounds.y += insets.top;
	537	+ }
	538	+ return bounds;
	539	+ }
	540	+
	541	+ /**
	542	+ * Returns the path for passed in row. If row is not visible
	543	+ * null is returned.
	544	+ */
	545	+ public TreePath getPathForRow(JTree tree, int row) {
	546	+ return (treeState != null) ? treeState.getPathForRow(row) : null;
	547	+ }
	548	+
	549	+ /**
	550	+ * Returns the row that the last item identified in path is visible
	551	+ * at. Will return -1 if any of the elements in path are not
	552	+ * currently visible.
	553	+ */
	554	+ public int getRowForPath(JTree tree, TreePath path) {
	555	+ return (treeState != null) ? treeState.getRowForPath(path) : -1;
	556	+ }
	557	+
	558	+ /**
	559	+ * Returns the number of rows that are being displayed.
	560	+ */
	561	+ public int getRowCount(JTree tree) {
	562	+ return (treeState != null) ? treeState.getRowCount() : 0;
	563	+ }
	564	+
	565	+ /**
	566	+ * Returns the path to the node that is closest to x,y. If
	567	+ * there is nothing currently visible this will return null, otherwise
	568	+ * it'll always return a valid path. If you need to test if the
	569	+ * returned object is exactly at x, y you should get the bounds for
	570	+ * the returned path and test x, y against that.
	571	+ */
	572	+ public TreePath getClosestPathForLocation(JTree tree, int x, int y) {
	573	+ if(tree != null && treeState != null) {
	574	+ // TreeState doesn't care about the x location, hence it isn't
	575	+ // adjusted
	576	+ y -= tree.getInsets().top;
	577	+ return treeState.getPathClosestTo(x, y);
	578	+ }
	579	+ return null;
	580	+ }
	581	+
	582	+ /**
	583	+ * Returns true if the tree is being edited. The item that is being
	584	+ * edited can be returned by getEditingPath().
	585	+ */
	586	+ public boolean isEditing(JTree tree) {
	587	+ return (editingComponent != null);
	588	+ }
	589	+
	590	+ /**
	591	+ * Stops the current editing session. This has no effect if the
	592	+ * tree isn't being edited. Returns true if the editor allows the
	593	+ * editing session to stop.
	594	+ */
	595	+ public boolean stopEditing(JTree tree) {
	596	+ if(editingComponent != null && cellEditor.stopCellEditing()) {
	597	+ completeEditing(false, false, true);
	598	+ return true;
	599	+ }
	600	+ return false;
	601	+ }
	602	+
	603	+ /**
	604	+ * Cancels the current editing session.
	605	+ */
	606	+ public void cancelEditing(JTree tree) {
	607	+ if(editingComponent != null) {
	608	+ completeEditing(false, true, false);
	609	+ }
	610	+ }
	611	+
	612	+ /**
	613	+ * Selects the last item in path and tries to edit it. Editing will
	614	+ * fail if the CellEditor won't allow it for the selected item.
	615	+ */
	616	+ public void startEditingAtPath(JTree tree, TreePath path) {
	617	+ tree.scrollPathToVisible(path);
	618	+ if(path != null && tree.isVisible(path))
	619	+ startEditing(path, null);
	620	+ }
	621	+
	622	+ /**
	623	+ * Returns the path to the element that is being edited.
	624	+ */
	625	+ public TreePath getEditingPath(JTree tree) {
	626	+ return editingPath;
	627	+ }
	628	+
	629	+ //
	630	+ // Install methods
	631	+ //
	632	+
	633	+ public void installUI(JComponent c) {
	634	+ if ( c == null ) {
	635	+ throw new NullPointerException( "null component passed to BasicTreeUI.installUI()" );
	636	+ }
	637	+
	638	+ tree = (JTree)c;
	639	+
	640	+ prepareForUIInstall();
	641	+
	642	+ // Boilerplate install block
	643	+ installDefaults();
	644	+ installKeyboardActions();
	645	+ installComponents();
	646	+ installListeners();
	647	+
	648	+ completeUIInstall();
	649	+ }
	650	+
	651	+ /**
	652	+ * Invoked after the <code>tree</code> instance variable has been
	653	+ * set, but before any defaults/listeners have been installed.
	654	+ */
	655	+ protected void prepareForUIInstall() {
	656	+ drawingCache = new Hashtable<TreePath,Boolean>(7);
	657	+
	658	+ // Data member initializations
	659	+ leftToRight = BasicGraphicsUtils.isLeftToRight(tree);
	660	+ stopEditingInCompleteEditing = true;
	661	+ lastSelectedRow = -1;
	662	+ leadRow = -1;
	663	+ preferredSize = new Dimension();
	664	+
	665	+ largeModel = tree.isLargeModel();
	666	+ if(getRowHeight() <= 0)
	667	+ largeModel = false;
	668	+ setModel(tree.getModel());
	669	+ }
	670	+
	671	+ /**
	672	+ * Invoked from installUI after all the defaults/listeners have been
	673	+ * installed.
	674	+ */
	675	+ protected void completeUIInstall() {
	676	+ // Custom install code
	677	+
	678	+ this.setShowsRootHandles(tree.getShowsRootHandles());
	679	+
	680	+ updateRenderer();
	681	+
	682	+ updateDepthOffset();
	683	+
	684	+ setSelectionModel(tree.getSelectionModel());
	685	+
	686	+ // Create, if necessary, the TreeState instance.
	687	+ treeState = createLayoutCache();
	688	+ configureLayoutCache();
	689	+
	690	+ updateSize();
	691	+ }
	692	+
	693	+ protected void installDefaults() {
	694	+ if(tree.getBackground() == null \|\|
	695	+ tree.getBackground() instanceof UIResource) {
	696	+ tree.setBackground(UIManager.getColor("Tree.background"));
	697	+ }
	698	+ if(getHashColor() == null \|\| getHashColor() instanceof UIResource) {
	699	+ setHashColor(UIManager.getColor("Tree.hash"));
	700	+ }
	701	+ if (tree.getFont() == null \|\| tree.getFont() instanceof UIResource)
	702	+ tree.setFont( UIManager.getFont("Tree.font") );
	703	+ // JTree's original row height is 16. To correctly display the
	704	+ // contents on Linux we should have set it to 18, Windows 19 and
	705	+ // Solaris 20. As these values vary so much it's too hard to
	706	+ // be backward compatable and try to update the row height, we're
	707	+ // therefor NOT going to adjust the row height based on font. If the
	708	+ // developer changes the font, it's there responsibility to update
	709	+ // the row height.
	710	+
	711	+ setExpandedIcon( (Icon)UIManager.get( "Tree.expandedIcon" ) );
	712	+ setCollapsedIcon( (Icon)UIManager.get( "Tree.collapsedIcon" ) );
	713	+
	714	+ setLeftChildIndent(((Integer)UIManager.get("Tree.leftChildIndent")).
	715	+ intValue());
	716	+ setRightChildIndent(((Integer)UIManager.get("Tree.rightChildIndent")).
	717	+ intValue());
	718	+
	719	+ LookAndFeel.installProperty(tree, "rowHeight",
	720	+ UIManager.get("Tree.rowHeight"));
	721	+
	722	+ largeModel = (tree.isLargeModel() && tree.getRowHeight() > 0);
	723	+
	724	+ Object scrollsOnExpand = UIManager.get("Tree.scrollsOnExpand");
	725	+ if (scrollsOnExpand != null) {
	726	+ LookAndFeel.installProperty(tree, "scrollsOnExpand", scrollsOnExpand);
	727	+ }
	728	+
	729	+ paintLines = UIManager.getBoolean("Tree.paintLines");
	730	+ lineTypeDashed = UIManager.getBoolean("Tree.lineTypeDashed");
	731	+
	732	+ Long l = (Long)UIManager.get("Tree.timeFactor");
	733	+ timeFactor = (l!=null) ? l.longValue() : 1000L;
	734	+
	735	+ Object showsRootHandles = UIManager.get("Tree.showsRootHandles");
	736	+ if (showsRootHandles != null) {
	737	+ LookAndFeel.installProperty(tree,
	738	+ JTree.SHOWS_ROOT_HANDLES_PROPERTY, showsRootHandles);
	739	+ }
	740	+ }
	741	+
	742	+ protected void installListeners() {
	743	+ if ( (propertyChangeListener = createPropertyChangeListener())
	744	+ != null ) {
	745	+ tree.addPropertyChangeListener(propertyChangeListener);
	746	+ }
	747	+ if ( (mouseListener = createMouseListener()) != null ) {
	748	+ tree.addMouseListener(mouseListener);
	749	+ if (mouseListener instanceof MouseMotionListener) {
	750	+ tree.addMouseMotionListener((MouseMotionListener)mouseListener);
	751	+ }
	752	+ }
	753	+ if ((focusListener = createFocusListener()) != null ) {
	754	+ tree.addFocusListener(focusListener);
	755	+ }
	756	+ if ((keyListener = createKeyListener()) != null) {
	757	+ tree.addKeyListener(keyListener);
	758	+ }
	759	+ if((treeExpansionListener = createTreeExpansionListener()) != null) {
	760	+ tree.addTreeExpansionListener(treeExpansionListener);
	761	+ }
	762	+ if((treeModelListener = createTreeModelListener()) != null &&
	763	+ treeModel != null) {
	764	+ treeModel.addTreeModelListener(treeModelListener);
	765	+ }
	766	+ if((selectionModelPropertyChangeListener =
	767	+ createSelectionModelPropertyChangeListener()) != null &&
	768	+ treeSelectionModel != null) {
	769	+ treeSelectionModel.addPropertyChangeListener
	770	+ (selectionModelPropertyChangeListener);
	771	+ }
	772	+ if((treeSelectionListener = createTreeSelectionListener()) != null &&
	773	+ treeSelectionModel != null) {
	774	+ treeSelectionModel.addTreeSelectionListener(treeSelectionListener);
	775	+ }
	776	+
	777	+ TransferHandler th = tree.getTransferHandler();
	778	+ if (th == null \|\| th instanceof UIResource) {
	779	+ tree.setTransferHandler(defaultTransferHandler);
	780	+ // default TransferHandler doesn't support drop
	781	+ // so we don't want drop handling
	782	+ if (tree.getDropTarget() instanceof UIResource) {
	783	+ tree.setDropTarget(null);
	784	+ }
	785	+ }
	786	+
	787	+ LookAndFeel.installProperty(tree, "opaque", Boolean.TRUE);
	788	+ }
	789	+
	790	+ protected void installKeyboardActions() {
	791	+ InputMap km = getInputMap(JComponent.
	792	+ WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
	793	+
	794	+ SwingUtilities.replaceUIInputMap(tree, JComponent.
	795	+ WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
	796	+ km);
	797	+ km = getInputMap(JComponent.WHEN_FOCUSED);
	798	+ SwingUtilities.replaceUIInputMap(tree, JComponent.WHEN_FOCUSED, km);
	799	+
	800	+ LazyActionMap.installLazyActionMap(tree, BasicTreeUI.class,
	801	+ "Tree.actionMap");
	802	+ }
	803	+
	804	+ InputMap getInputMap(int condition) {
	805	+ if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {
	806	+ return (InputMap)DefaultLookup.get(tree, this,
	807	+ "Tree.ancestorInputMap");
	808	+ }
	809	+ else if (condition == JComponent.WHEN_FOCUSED) {
	810	+ InputMap keyMap = (InputMap)DefaultLookup.get(tree, this,
	811	+ "Tree.focusInputMap");
	812	+ InputMap rtlKeyMap;
	813	+
	814	+ if (tree.getComponentOrientation().isLeftToRight() \|\|
	815	+ ((rtlKeyMap = (InputMap)DefaultLookup.get(tree, this,
	816	+ "Tree.focusInputMap.RightToLeft")) == null)) {
	817	+ return keyMap;
	818	+ } else {
	819	+ rtlKeyMap.setParent(keyMap);
	820	+ return rtlKeyMap;
	821	+ }
	822	+ }
	823	+ return null;
	824	+ }
	825	+
	826	+ /**
	827	+ * Intalls the subcomponents of the tree, which is the renderer pane.
	828	+ */
	829	+ protected void installComponents() {
	830	+ if ((rendererPane = createCellRendererPane()) != null) {
	831	+ tree.add( rendererPane );
	832	+ }
	833	+ }
	834	+
	835	+ //
	836	+ // Create methods.
	837	+ //
	838	+
	839	+ /**
	840	+ * Creates an instance of NodeDimensions that is able to determine
	841	+ * the size of a given node in the tree.
	842	+ */
	843	+ protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
	844	+ return new NodeDimensionsHandler();
	845	+ }
	846	+
	847	+ /**
	848	+ * Creates a listener that is responsible that updates the UI based on
	849	+ * how the tree changes.
	850	+ */
	851	+ protected PropertyChangeListener createPropertyChangeListener() {
	852	+ return getHandler();
	853	+ }
	854	+
	855	+ private Handler getHandler() {
	856	+ if (handler == null) {
	857	+ handler = new Handler();
	858	+ }
	859	+ return handler;
	860	+ }
	861	+
	862	+ /**
	863	+ * Creates the listener responsible for updating the selection based on
	864	+ * mouse events.
	865	+ */
	866	+ protected MouseListener createMouseListener() {
	867	+ return getHandler();
	868	+ }
	869	+
	870	+ /**
	871	+ * Creates a listener that is responsible for updating the display
	872	+ * when focus is lost/gained.
	873	+ */
	874	+ protected FocusListener createFocusListener() {
	875	+ return getHandler();
	876	+ }
	877	+
	878	+ /**
	879	+ * Creates the listener reponsible for getting key events from
	880	+ * the tree.
	881	+ */
	882	+ protected KeyListener createKeyListener() {
	883	+ return getHandler();
	884	+ }
	885	+
	886	+ /**
	887	+ * Creates the listener responsible for getting property change
	888	+ * events from the selection model.
	889	+ */
	890	+ protected PropertyChangeListener createSelectionModelPropertyChangeListener() {
	891	+ return getHandler();
	892	+ }
	893	+
	894	+ /**
	895	+ * Creates the listener that updates the display based on selection change
	896	+ * methods.
	897	+ */
	898	+ protected TreeSelectionListener createTreeSelectionListener() {
	899	+ return getHandler();
	900	+ }
	901	+
	902	+ /**
	903	+ * Creates a listener to handle events from the current editor.
	904	+ */
	905	+ protected CellEditorListener createCellEditorListener() {
	906	+ return getHandler();
	907	+ }
	908	+
	909	+ /**
	910	+ * Creates and returns a new ComponentHandler. This is used for
	911	+ * the large model to mark the validCachedPreferredSize as invalid
	912	+ * when the component moves.
	913	+ */
	914	+ protected ComponentListener createComponentListener() {
	915	+ return new ComponentHandler();
	916	+ }
	917	+
	918	+ /**
	919	+ * Creates and returns the object responsible for updating the treestate
	920	+ * when nodes expanded state changes.
	921	+ */
	922	+ protected TreeExpansionListener createTreeExpansionListener() {
	923	+ return getHandler();
	924	+ }
	925	+
	926	+ /**
	927	+ * Creates the object responsible for managing what is expanded, as
	928	+ * well as the size of nodes.
	929	+ */
	930	+ protected AbstractLayoutCache createLayoutCache() {
	931	+ if(isLargeModel() && getRowHeight() > 0) {
	932	+ return new FixedHeightLayoutCache();
	933	+ }
	934	+ return new VariableHeightLayoutCache();
	935	+ }
	936	+
	937	+ /**
	938	+ * Returns the renderer pane that renderer components are placed in.
	939	+ */
	940	+ protected CellRendererPane createCellRendererPane() {
	941	+ return new CellRendererPane();
	942	+ }
	943	+
	944	+ /**
	945	+ * Creates a default cell editor.
	946	+ */
	947	+ protected TreeCellEditor createDefaultCellEditor() {
	948	+ if(currentCellRenderer != null &&
	949	+ (currentCellRenderer instanceof DefaultTreeCellRenderer)) {
	950	+ DefaultTreeCellEditor editor = new DefaultTreeCellEditor
	951	+ (tree, (DefaultTreeCellRenderer)currentCellRenderer);
	952	+
	953	+ return editor;
	954	+ }
	955	+ return new DefaultTreeCellEditor(tree, null);
	956	+ }
	957	+
	958	+ /**
	959	+ * Returns the default cell renderer that is used to do the
	960	+ * stamping of each node.
	961	+ */
	962	+ protected TreeCellRenderer createDefaultCellRenderer() {
	963	+ return new DefaultTreeCellRenderer();
	964	+ }
	965	+
	966	+ /**
	967	+ * Returns a listener that can update the tree when the model changes.
	968	+ */
	969	+ protected TreeModelListener createTreeModelListener() {
	970	+ return getHandler();
	971	+ }
	972	+
	973	+ //
	974	+ // Uninstall methods
	975	+ //
	976	+
	977	+ public void uninstallUI(JComponent c) {
	978	+ completeEditing();
	979	+
	980	+ prepareForUIUninstall();
	981	+
	982	+ uninstallDefaults();
	983	+ uninstallListeners();
	984	+ uninstallKeyboardActions();
	985	+ uninstallComponents();
	986	+
	987	+ completeUIUninstall();
	988	+ }
	989	+
	990	+ protected void prepareForUIUninstall() {
	991	+ }
	992	+
	993	+ protected void completeUIUninstall() {
	994	+ if(createdRenderer) {
	995	+ tree.setCellRenderer(null);
	996	+ }
	997	+ if(createdCellEditor) {
	998	+ tree.setCellEditor(null);
	999	+ }
	1000	+ cellEditor = null;
	1001	+ currentCellRenderer = null;
	1002	+ rendererPane = null;
	1003	+ componentListener = null;
	1004	+ propertyChangeListener = null;
	1005	+ mouseListener = null;
	1006	+ focusListener = null;
	1007	+ keyListener = null;
	1008	+ setSelectionModel(null);
	1009	+ treeState = null;
	1010	+ drawingCache = null;
	1011	+ selectionModelPropertyChangeListener = null;
	1012	+ tree = null;
	1013	+ treeModel = null;
	1014	+ treeSelectionModel = null;
	1015	+ treeSelectionListener = null;
	1016	+ treeExpansionListener = null;
	1017	+ }
	1018	+
	1019	+ protected void uninstallDefaults() {
	1020	+ if (tree.getTransferHandler() instanceof UIResource) {
	1021	+ tree.setTransferHandler(null);
	1022	+ }
	1023	+ }
	1024	+
	1025	+ protected void uninstallListeners() {
	1026	+ if(componentListener != null) {
	1027	+ tree.removeComponentListener(componentListener);
	1028	+ }
	1029	+ if (propertyChangeListener != null) {
	1030	+ tree.removePropertyChangeListener(propertyChangeListener);
	1031	+ }
	1032	+ if (mouseListener != null) {
	1033	+ tree.removeMouseListener(mouseListener);
	1034	+ if (mouseListener instanceof MouseMotionListener) {
	1035	+ tree.removeMouseMotionListener((MouseMotionListener)mouseListener);
	1036	+ }
	1037	+ }
	1038	+ if (focusListener != null) {
	1039	+ tree.removeFocusListener(focusListener);
	1040	+ }
	1041	+ if (keyListener != null) {
	1042	+ tree.removeKeyListener(keyListener);
	1043	+ }
	1044	+ if(treeExpansionListener != null) {
	1045	+ tree.removeTreeExpansionListener(treeExpansionListener);
	1046	+ }
	1047	+ if(treeModel != null && treeModelListener != null) {
	1048	+ treeModel.removeTreeModelListener(treeModelListener);
	1049	+ }
	1050	+ if(selectionModelPropertyChangeListener != null &&
	1051	+ treeSelectionModel != null) {
	1052	+ treeSelectionModel.removePropertyChangeListener
	1053	+ (selectionModelPropertyChangeListener);
	1054	+ }
	1055	+ if(treeSelectionListener != null && treeSelectionModel != null) {
	1056	+ treeSelectionModel.removeTreeSelectionListener
	1057	+ (treeSelectionListener);
	1058	+ }
	1059	+ handler = null;
	1060	+ }
	1061	+
	1062	+ protected void uninstallKeyboardActions() {
	1063	+ SwingUtilities.replaceUIActionMap(tree, null);
	1064	+ SwingUtilities.replaceUIInputMap(tree, JComponent.
	1065	+ WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
	1066	+ null);
	1067	+ SwingUtilities.replaceUIInputMap(tree, JComponent.WHEN_FOCUSED, null);
	1068	+ }
	1069	+
	1070	+ /**
	1071	+ * Uninstalls the renderer pane.
	1072	+ */
	1073	+ protected void uninstallComponents() {
	1074	+ if(rendererPane != null) {
	1075	+ tree.remove(rendererPane);
	1076	+ }
	1077	+ }
	1078	+
	1079	+ /**
	1080	+ * Recomputes the right margin, and invalidates any tree states
	1081	+ */
	1082	+ private void redoTheLayout() {
	1083	+ if (treeState != null) {
	1084	+ treeState.invalidateSizes();
	1085	+ }
	1086	+ }
	1087	+
	1088	+ /**
	1089	+ * Returns the baseline.
	1090	+ *
	1091	+ * @throws NullPointerException {@inheritDoc}
	1092	+ * @throws IllegalArgumentException {@inheritDoc}
	1093	+ * @see javax.swing.JComponent#getBaseline(int, int)
	1094	+ * @since 1.6
	1095	+ */
	1096	+ public int getBaseline(JComponent c, int width, int height) {
	1097	+ super.getBaseline(c, width, height);
	1098	+ UIDefaults lafDefaults = UIManager.getLookAndFeelDefaults();
	1099	+ Component renderer = (Component)lafDefaults.get(
	1100	+ BASELINE_COMPONENT_KEY);
	1101	+ if (renderer == null) {
	1102	+ TreeCellRenderer tcr = createDefaultCellRenderer();
	1103	+ renderer = tcr.getTreeCellRendererComponent(
	1104	+ tree, "a", false, false, false, -1, false);
	1105	+ lafDefaults.put(BASELINE_COMPONENT_KEY, renderer);
	1106	+ }
	1107	+ int rowHeight = tree.getRowHeight();
	1108	+ int baseline;
	1109	+ if (rowHeight > 0) {
	1110	+ baseline = renderer.getBaseline(Integer.MAX_VALUE, rowHeight);
	1111	+ }
	1112	+ else {
	1113	+ Dimension pref = renderer.getPreferredSize();
	1114	+ baseline = renderer.getBaseline(pref.width, pref.height);
	1115	+ }
	1116	+ return baseline + tree.getInsets().top;
	1117	+ }
	1118	+
	1119	+ /**
	1120	+ * Returns an enum indicating how the baseline of the component
	1121	+ * changes as the size changes.
	1122	+ *
	1123	+ * @throws NullPointerException {@inheritDoc}
	1124	+ * @see javax.swing.JComponent#getBaseline(int, int)
	1125	+ * @since 1.6
	1126	+ */
	1127	+ public Component.BaselineResizeBehavior getBaselineResizeBehavior(
	1128	+ JComponent c) {
	1129	+ super.getBaselineResizeBehavior(c);
	1130	+ return Component.BaselineResizeBehavior.CONSTANT_ASCENT;
	1131	+ }
	1132	+
	1133	+ //
	1134	+ // Painting routines.
	1135	+ //
	1136	+
	1137	+ public void paint(Graphics g, JComponent c) {
	1138	+ if (tree != c) {
	1139	+ throw new InternalError("incorrect component");
	1140	+ }
	1141	+
	1142	+ // Should never happen if installed for a UI
	1143	+ if(treeState == null) {
	1144	+ return;
	1145	+ }
	1146	+
	1147	+ Rectangle paintBounds = g.getClipBounds();
	1148	+ Insets insets = tree.getInsets();
	1149	+ TreePath initialPath = getClosestPathForLocation
	1150	+ (tree, 0, paintBounds.y);
	1151	+ Enumeration paintingEnumerator = treeState.getVisiblePathsFrom
	1152	+ (initialPath);
	1153	+ int row = treeState.getRowForPath(initialPath);
	1154	+ int endY = paintBounds.y + paintBounds.height;
	1155	+
	1156	+ drawingCache.clear();
	1157	+
	1158	+ if(initialPath != null && paintingEnumerator != null) {
	1159	+ TreePath parentPath = initialPath;
	1160	+
	1161	+ // Draw the lines, knobs, and rows
	1162	+
	1163	+ // Find each parent and have them draw a line to their last child
	1164	+ parentPath = parentPath.getParentPath();
	1165	+ while(parentPath != null) {
	1166	+ paintVerticalPartOfLeg(g, paintBounds, insets, parentPath);
	1167	+ drawingCache.put(parentPath, Boolean.TRUE);
	1168	+ parentPath = parentPath.getParentPath();
	1169	+ }
	1170	+
	1171	+ boolean done = false;
	1172	+ // Information for the node being rendered.
	1173	+ boolean isExpanded;
	1174	+ boolean hasBeenExpanded;
	1175	+ boolean isLeaf;
	1176	+ Rectangle boundsBuffer = new Rectangle();
	1177	+ Rectangle bounds;
	1178	+ TreePath path;
	1179	+ boolean rootVisible = isRootVisible();
	1180	+
	1181	+ while(!done && paintingEnumerator.hasMoreElements()) {
	1182	+ path = (TreePath)paintingEnumerator.nextElement();
	1183	+ if(path != null) {
	1184	+ isLeaf = treeModel.isLeaf(path.getLastPathComponent());
	1185	+ if(isLeaf)
	1186	+ isExpanded = hasBeenExpanded = false;
	1187	+ else {
	1188	+ isExpanded = treeState.getExpandedState(path);
	1189	+ hasBeenExpanded = tree.hasBeenExpanded(path);
	1190	+ }
	1191	+ bounds = getPathBounds(path, insets, boundsBuffer);
	1192	+ if(bounds == null)
	1193	+ // This will only happen if the model changes out
	1194	+ // from under us (usually in another thread).
	1195	+ // Swing isn't multithreaded, but I'll put this
	1196	+ // check in anyway.
	1197	+ return;
	1198	+ // See if the vertical line to the parent has been drawn.
	1199	+ parentPath = path.getParentPath();
	1200	+ if(parentPath != null) {
	1201	+ if(drawingCache.get(parentPath) == null) {
	1202	+ paintVerticalPartOfLeg(g, paintBounds,
	1203	+ insets, parentPath);
	1204	+ drawingCache.put(parentPath, Boolean.TRUE);
	1205	+ }
	1206	+ paintHorizontalPartOfLeg(g, paintBounds, insets,
	1207	+ bounds, path, row,
	1208	+ isExpanded,
	1209	+ hasBeenExpanded, isLeaf);
	1210	+ }
	1211	+ else if(rootVisible && row == 0) {
	1212	+ paintHorizontalPartOfLeg(g, paintBounds, insets,
	1213	+ bounds, path, row,
	1214	+ isExpanded,
	1215	+ hasBeenExpanded, isLeaf);
	1216	+ }
	1217	+ if(shouldPaintExpandControl(path, row, isExpanded,
	1218	+ hasBeenExpanded, isLeaf)) {
	1219	+ paintExpandControl(g, paintBounds, insets, bounds,
	1220	+ path, row, isExpanded,
	1221	+ hasBeenExpanded, isLeaf);
	1222	+ }
	1223	+ paintRow(g, paintBounds, insets, bounds, path,
	1224	+ row, isExpanded, hasBeenExpanded, isLeaf);
	1225	+ if((bounds.y + bounds.height) >= endY)
	1226	+ done = true;
	1227	+ }
	1228	+ else {
	1229	+ done = true;
	1230	+ }
	1231	+ row++;
	1232	+ }
	1233	+ }
	1234	+
	1235	+ paintDropLine(g);
	1236	+
	1237	+ // Empty out the renderer pane, allowing renderers to be gc'ed.
	1238	+ rendererPane.removeAll();
	1239	+
	1240	+ drawingCache.clear();
	1241	+ }
	1242	+
	1243	+ /**
	1244	+ * Tells if a {@code DropLocation} should be indicated by a line between
	1245	+ * nodes. This is meant for {@code javax.swing.DropMode.INSERT} and
	1246	+ * {@code javax.swing.DropMode.ON_OR_INSERT} drop modes.
	1247	+ *
	1248	+ * @param loc a {@code DropLocation}
	1249	+ * @return {@code true} if the drop location should be shown as a line
	1250	+ * @since 1.7
	1251	+ */
	1252	+ protected boolean isDropLine(JTree.DropLocation loc) {
	1253	+ return loc != null && loc.getPath() != null && loc.getChildIndex() != -1;
	1254	+ }
	1255	+
	1256	+ /**
	1257	+ * Paints the drop line.
	1258	+ *
	1259	+ * @param g {@code Graphics} object to draw on
	1260	+ * @since 1.7
	1261	+ */
	1262	+ protected void paintDropLine(Graphics g) {
	1263	+ JTree.DropLocation loc = tree.getDropLocation();
	1264	+ if (!isDropLine(loc)) {
	1265	+ return;
	1266	+ }
	1267	+
	1268	+ Color c = UIManager.getColor("Tree.dropLineColor");
	1269	+ if (c != null) {
	1270	+ g.setColor(c);
	1271	+ Rectangle rect = getDropLineRect(loc);
	1272	+ g.fillRect(rect.x, rect.y, rect.width, rect.height);
	1273	+ }
	1274	+ }
	1275	+
	1276	+ /**
	1277	+ * Returns a ubounding box for the drop line.
	1278	+ *
	1279	+ * @param loc a {@code DropLocation}
	1280	+ * @return bounding box for the drop line
	1281	+ * @since 1.7
	1282	+ */
	1283	+ protected Rectangle getDropLineRect(JTree.DropLocation loc) {
	1284	+ Rectangle rect;
	1285	+ TreePath path = loc.getPath();
	1286	+ int index = loc.getChildIndex();
	1287	+ boolean ltr = leftToRight;
	1288	+
	1289	+ Insets insets = tree.getInsets();
	1290	+
	1291	+ if (tree.getRowCount() == 0) {
	1292	+ rect = new Rectangle(insets.left,
	1293	+ insets.top,
	1294	+ tree.getWidth() - insets.left - insets.right,
	1295	+ 0);
	1296	+ } else {
	1297	+ TreeModel model = getModel();
	1298	+ Object root = model.getRoot();
	1299	+
	1300	+ if (path.getLastPathComponent() == root
	1301	+ && index >= model.getChildCount(root)) {
	1302	+
	1303	+ rect = tree.getRowBounds(tree.getRowCount() - 1);
	1304	+ rect.y = rect.y + rect.height;
	1305	+ Rectangle xRect;
	1306	+
	1307	+ if (!tree.isRootVisible()) {
	1308	+ xRect = tree.getRowBounds(0);
	1309	+ } else if (model.getChildCount(root) == 0){
	1310	+ xRect = tree.getRowBounds(0);
	1311	+ xRect.x += totalChildIndent;
	1312	+ xRect.width -= totalChildIndent + totalChildIndent;
	1313	+ } else {
	1314	+ TreePath lastChildPath = path.pathByAddingChild(
	1315	+ model.getChild(root, model.getChildCount(root) - 1));
	1316	+ xRect = tree.getPathBounds(lastChildPath);
	1317	+ }
	1318	+
	1319	+ rect.x = xRect.x;
	1320	+ rect.width = xRect.width;
	1321	+ } else {
	1322	+ rect = tree.getPathBounds(path.pathByAddingChild(
	1323	+ model.getChild(path.getLastPathComponent(), index)));
	1324	+ }
	1325	+ }
	1326	+
	1327	+ if (rect.y != 0) {
	1328	+ rect.y--;
	1329	+ }
	1330	+
	1331	+ if (!ltr) {
	1332	+ rect.x = rect.x + rect.width - 100;
	1333	+ }
	1334	+
	1335	+ rect.width = 100;
	1336	+ rect.height = 2;
	1337	+
	1338	+ return rect;
	1339	+ }
	1340	+
	1341	+ /**
	1342	+ * Paints the horizontal part of the leg. The receiver should
	1343	+ * NOT modify <code>clipBounds</code>, or <code>insets</code>.<p>
	1344	+ * NOTE: <code>parentRow</code> can be -1 if the root is not visible.
	1345	+ */
	1346	+ protected void paintHorizontalPartOfLeg(Graphics g, Rectangle clipBounds,
	1347	+ Insets insets, Rectangle bounds,
	1348	+ TreePath path, int row,
	1349	+ boolean isExpanded,
	1350	+ boolean hasBeenExpanded, boolean
	1351	+ isLeaf) {
	1352	+ if (!paintLines) {
	1353	+ return;
	1354	+ }
	1355	+
	1356	+ // Don't paint the legs for the root'ish node if the
	1357	+ int depth = path.getPathCount() - 1;
	1358	+ if((depth == 0 \|\| (depth == 1 && !isRootVisible())) &&
	1359	+ !getShowsRootHandles()) {
	1360	+ return;
	1361	+ }
	1362	+
	1363	+ int clipLeft = clipBounds.x;
	1364	+ int clipRight = clipBounds.x + clipBounds.width;
	1365	+ int clipTop = clipBounds.y;
	1366	+ int clipBottom = clipBounds.y + clipBounds.height;
	1367	+ int lineY = bounds.y + bounds.height / 2;
	1368	+
	1369	+ if (leftToRight) {
	1370	+ int leftX = bounds.x - getRightChildIndent();
	1371	+ int nodeX = bounds.x - getHorizontalLegBuffer();
	1372	+
	1373	+ if(lineY >= clipTop
	1374	+ && lineY < clipBottom
	1375	+ && nodeX >= clipLeft
	1376	+ && leftX < clipRight
	1377	+ && leftX < nodeX) {
	1378	+
	1379	+ g.setColor(getHashColor());
	1380	+ paintHorizontalLine(g, tree, lineY, leftX, nodeX - 1);
	1381	+ }
	1382	+ } else {
	1383	+ int nodeX = bounds.x + bounds.width + getHorizontalLegBuffer();
	1384	+ int rightX = bounds.x + bounds.width + getRightChildIndent();
	1385	+
	1386	+ if(lineY >= clipTop
	1387	+ && lineY < clipBottom
	1388	+ && rightX >= clipLeft
	1389	+ && nodeX < clipRight
	1390	+ && nodeX < rightX) {
	1391	+
	1392	+ g.setColor(getHashColor());
	1393	+ paintHorizontalLine(g, tree, lineY, nodeX, rightX - 1);
	1394	+ }
	1395	+ }
	1396	+ }
	1397	+
	1398	+ /**
	1399	+ * Paints the vertical part of the leg. The receiver should
	1400	+ * NOT modify <code>clipBounds</code>, <code>insets</code>.<p>
	1401	+ */
	1402	+ protected void paintVerticalPartOfLeg(Graphics g, Rectangle clipBounds,
	1403	+ Insets insets, TreePath path) {
	1404	+ if (!paintLines) {
	1405	+ return;
	1406	+ }
	1407	+
	1408	+ int depth = path.getPathCount() - 1;
	1409	+ if (depth == 0 && !getShowsRootHandles() && !isRootVisible()) {
	1410	+ return;
	1411	+ }
	1412	+ int lineX = getRowX(-1, depth + 1);
	1413	+ if (leftToRight) {
	1414	+ lineX = lineX - getRightChildIndent() + insets.left;
	1415	+ }
	1416	+ else {
	1417	+ lineX = tree.getWidth() - lineX - insets.right +
	1418	+ getRightChildIndent() - 1;
	1419	+ }
	1420	+ int clipLeft = clipBounds.x;
	1421	+ int clipRight = clipBounds.x + (clipBounds.width - 1);
	1422	+
	1423	+ if (lineX >= clipLeft && lineX <= clipRight) {
	1424	+ int clipTop = clipBounds.y;
	1425	+ int clipBottom = clipBounds.y + clipBounds.height;
	1426	+ Rectangle parentBounds = getPathBounds(tree, path);
	1427	+ Rectangle lastChildBounds = getPathBounds(tree,
	1428	+ getLastChildPath(path));
	1429	+
	1430	+ if(lastChildBounds == null)
	1431	+ // This shouldn't happen, but if the model is modified
	1432	+ // in another thread it is possible for this to happen.
	1433	+ // Swing isn't multithreaded, but I'll add this check in
	1434	+ // anyway.
	1435	+ return;
	1436	+
	1437	+ int top;
	1438	+
	1439	+ if(parentBounds == null) {
	1440	+ top = Math.max(insets.top + getVerticalLegBuffer(),
	1441	+ clipTop);
	1442	+ }
	1443	+ else
	1444	+ top = Math.max(parentBounds.y + parentBounds.height +
	1445	+ getVerticalLegBuffer(), clipTop);
	1446	+ if(depth == 0 && !isRootVisible()) {
	1447	+ TreeModel model = getModel();
	1448	+
	1449	+ if(model != null) {
	1450	+ Object root = model.getRoot();
	1451	+
	1452	+ if(model.getChildCount(root) > 0) {
	1453	+ parentBounds = getPathBounds(tree, path.
	1454	+ pathByAddingChild(model.getChild(root, 0)));
	1455	+ if(parentBounds != null)
	1456	+ top = Math.max(insets.top + getVerticalLegBuffer(),
	1457	+ parentBounds.y +
	1458	+ parentBounds.height / 2);
	1459	+ }
	1460	+ }
	1461	+ }
	1462	+
	1463	+ int bottom = Math.min(lastChildBounds.y +
	1464	+ (lastChildBounds.height / 2), clipBottom);
	1465	+
	1466	+ if (top <= bottom) {
	1467	+ g.setColor(getHashColor());
	1468	+ paintVerticalLine(g, tree, lineX, top, bottom);
	1469	+ }
	1470	+ }
	1471	+ }
	1472	+
	1473	+ /**
	1474	+ * Paints the expand (toggle) part of a row. The receiver should
	1475	+ * NOT modify <code>clipBounds</code>, or <code>insets</code>.
	1476	+ */
	1477	+ protected void paintExpandControl(Graphics g,
	1478	+ Rectangle clipBounds, Insets insets,
	1479	+ Rectangle bounds, TreePath path,
	1480	+ int row, boolean isExpanded,
	1481	+ boolean hasBeenExpanded,
	1482	+ boolean isLeaf) {
	1483	+ Object value = path.getLastPathComponent();
	1484	+
	1485	+ // Draw icons if not a leaf and either hasn't been loaded,
	1486	+ // or the model child count is > 0.
	1487	+ if (!isLeaf && (!hasBeenExpanded \|\|
	1488	+ treeModel.getChildCount(value) > 0)) {
	1489	+ int middleXOfKnob;
	1490	+ if (leftToRight) {
	1491	+ middleXOfKnob = bounds.x - getRightChildIndent() + 1;
	1492	+ } else {
	1493	+ middleXOfKnob = bounds.x + bounds.width + getRightChildIndent() - 1;
	1494	+ }
	1495	+ int middleYOfKnob = bounds.y + (bounds.height / 2);
	1496	+
	1497	+ if (isExpanded) {
	1498	+ Icon expandedIcon = getExpandedIcon();
	1499	+ if(expandedIcon != null)
	1500	+ drawCentered(tree, g, expandedIcon, middleXOfKnob,
	1501	+ middleYOfKnob );
	1502	+ }
	1503	+ else {
	1504	+ Icon collapsedIcon = getCollapsedIcon();
	1505	+ if(collapsedIcon != null)
	1506	+ drawCentered(tree, g, collapsedIcon, middleXOfKnob,
	1507	+ middleYOfKnob);
	1508	+ }
	1509	+ }
	1510	+ }
	1511	+
	1512	+ /**
	1513	+ * Paints the renderer part of a row. The receiver should
	1514	+ * NOT modify <code>clipBounds</code>, or <code>insets</code>.
	1515	+ */
	1516	+ protected void paintRow(Graphics g, Rectangle clipBounds,
	1517	+ Insets insets, Rectangle bounds, TreePath path,
	1518	+ int row, boolean isExpanded,
	1519	+ boolean hasBeenExpanded, boolean isLeaf) {
	1520	+ // Don't paint the renderer if editing this row.
	1521	+ if(editingComponent != null && editingRow == row)
	1522	+ return;
	1523	+
	1524	+ int leadIndex;
	1525	+
	1526	+ if(tree.hasFocus()) {
	1527	+ leadIndex = getLeadSelectionRow();
	1528	+ }
	1529	+ else
	1530	+ leadIndex = -1;
	1531	+
	1532	+ Component component;
	1533	+
	1534	+ component = currentCellRenderer.getTreeCellRendererComponent
	1535	+ (tree, path.getLastPathComponent(),
	1536	+ tree.isRowSelected(row), isExpanded, isLeaf, row,
	1537	+ (leadIndex == row));
	1538	+
	1539	+ rendererPane.paintComponent(g, component, tree, bounds.x, bounds.y,
	1540	+ bounds.width, bounds.height, true);
	1541	+ }
	1542	+
	1543	+ /**
	1544	+ * Returns true if the expand (toggle) control should be drawn for
	1545	+ * the specified row.
	1546	+ */
	1547	+ protected boolean shouldPaintExpandControl(TreePath path, int row,
	1548	+ boolean isExpanded,
	1549	+ boolean hasBeenExpanded,
	1550	+ boolean isLeaf) {
	1551	+ if(isLeaf)
	1552	+ return false;
	1553	+
	1554	+ int depth = path.getPathCount() - 1;
	1555	+
	1556	+ if((depth == 0 \|\| (depth == 1 && !isRootVisible())) &&
	1557	+ !getShowsRootHandles())
	1558	+ return false;
	1559	+ return true;
	1560	+ }
	1561	+
	1562	+ /**
	1563	+ * Paints a vertical line.
	1564	+ */
	1565	+ protected void paintVerticalLine(Graphics g, JComponent c, int x, int top,
	1566	+ int bottom) {
	1567	+ if (lineTypeDashed) {
	1568	+ drawDashedVerticalLine(g, x, top, bottom);
	1569	+ } else {
	1570	+ g.drawLine(x, top, x, bottom);
	1571	+ }
	1572	+ }
	1573	+
	1574	+ /**
	1575	+ * Paints a horizontal line.
	1576	+ */
	1577	+ protected void paintHorizontalLine(Graphics g, JComponent c, int y,
	1578	+ int left, int right) {
	1579	+ if (lineTypeDashed) {
	1580	+ drawDashedHorizontalLine(g, y, left, right);
	1581	+ } else {
	1582	+ g.drawLine(left, y, right, y);
	1583	+ }
	1584	+ }
	1585	+
	1586	+ /**
	1587	+ * The vertical element of legs between nodes starts at the bottom of the
	1588	+ * parent node by default. This method makes the leg start below that.
	1589	+ */
	1590	+ protected int getVerticalLegBuffer() {
	1591	+ return 0;
	1592	+ }
	1593	+
	1594	+ /**
	1595	+ * The horizontal element of legs between nodes starts at the
	1596	+ * right of the left-hand side of the child node by default. This
	1597	+ * method makes the leg end before that.
	1598	+ */
	1599	+ protected int getHorizontalLegBuffer() {
	1600	+ return 0;
	1601	+ }
	1602	+
	1603	+ private int findCenteredX(int x, int iconWidth) {
	1604	+ return leftToRight
	1605	+ ? x - (int)Math.ceil(iconWidth / 2.0)
	1606	+ : x - (int)Math.floor(iconWidth / 2.0);
	1607	+ }
	1608	+
	1609	+ //
	1610	+ // Generic painting methods
	1611	+ //
	1612	+
	1613	+ // Draws the icon centered at (x,y)
	1614	+ protected void drawCentered(Component c, Graphics graphics, Icon icon,
	1615	+ int x, int y) {
	1616	+ icon.paintIcon(c, graphics,
	1617	+ findCenteredX(x, icon.getIconWidth()),
	1618	+ y - icon.getIconHeight() / 2);
	1619	+ }
	1620	+
	1621	+ // This method is slow -- revisit when Java2D is ready.
	1622	+ // assumes x1 <= x2
	1623	+ protected void drawDashedHorizontalLine(Graphics g, int y, int x1, int x2){
	1624	+ // Drawing only even coordinates helps join line segments so they
	1625	+ // appear as one line. This can be defeated by translating the
	1626	+ // Graphics by an odd amount.
	1627	+ x1 += (x1 % 2);
	1628	+
	1629	+ for (int x = x1; x <= x2; x+=2) {
	1630	+ g.drawLine(x, y, x, y);
	1631	+ }
	1632	+ }
	1633	+
	1634	+ // This method is slow -- revisit when Java2D is ready.
	1635	+ // assumes y1 <= y2
	1636	+ protected void drawDashedVerticalLine(Graphics g, int x, int y1, int y2) {
	1637	+ // Drawing only even coordinates helps join line segments so they
	1638	+ // appear as one line. This can be defeated by translating the
	1639	+ // Graphics by an odd amount.
	1640	+ y1 += (y1 % 2);
	1641	+
	1642	+ for (int y = y1; y <= y2; y+=2) {
	1643	+ g.drawLine(x, y, x, y);
	1644	+ }
	1645	+ }
	1646	+
	1647	+ //
	1648	+ // Various local methods
	1649	+ //
	1650	+
	1651	+ /**
	1652	+ * Returns the location, along the x-axis, to render a particular row
	1653	+ * at. The return value does not include any Insets specified on the JTree.
	1654	+ * This does not check for the validity of the row or depth, it is assumed
	1655	+ * to be correct and will not throw an Exception if the row or depth
	1656	+ * doesn't match that of the tree.
	1657	+ *
	1658	+ * @param row Row to return x location for
	1659	+ * @param depth Depth of the row
	1660	+ * @return amount to indent the given row.
	1661	+ * @since 1.5
	1662	+ */
	1663	+ protected int getRowX(int row, int depth) {
	1664	+ return totalChildIndent * (depth + depthOffset);
	1665	+ }
	1666	+
	1667	+ /**
	1668	+ * Makes all the nodes that are expanded in JTree expanded in LayoutCache.
	1669	+ * This invokes updateExpandedDescendants with the root path.
	1670	+ */
	1671	+ protected void updateLayoutCacheExpandedNodes() {
	1672	+ if(treeModel != null && treeModel.getRoot() != null)
	1673	+ updateExpandedDescendants(new TreePath(treeModel.getRoot()));
	1674	+ }
	1675	+
	1676	+ private void updateLayoutCacheExpandedNodesIfNecessary() {
	1677	+ if (treeModel != null && treeModel.getRoot() != null) {
	1678	+ TreePath rootPath = new TreePath(treeModel.getRoot());
	1679	+ if (tree.isExpanded(rootPath)) {
	1680	+ updateLayoutCacheExpandedNodes();
	1681	+ } else {
	1682	+ treeState.setExpandedState(rootPath, false);
	1683	+ }
	1684	+ }
	1685	+ }
	1686	+
	1687	+ /**
	1688	+ * Updates the expanded state of all the descendants of <code>path</code>
	1689	+ * by getting the expanded descendants from the tree and forwarding
	1690	+ * to the tree state.
	1691	+ */
	1692	+ protected void updateExpandedDescendants(TreePath path) {
	1693	+ completeEditing();
	1694	+ if(treeState != null) {
	1695	+ treeState.setExpandedState(path, true);
	1696	+
	1697	+ Enumeration descendants = tree.getExpandedDescendants(path);
	1698	+
	1699	+ if(descendants != null) {
	1700	+ while(descendants.hasMoreElements()) {
	1701	+ path = (TreePath)descendants.nextElement();
	1702	+ treeState.setExpandedState(path, true);
	1703	+ }
	1704	+ }
	1705	+ updateLeadSelectionRow();
	1706	+ updateSize();
	1707	+ }
	1708	+ }
	1709	+
	1710	+ /**
	1711	+ * Returns a path to the last child of <code>parent</code>.
	1712	+ */
	1713	+ protected TreePath getLastChildPath(TreePath parent) {
	1714	+ if(treeModel != null) {
	1715	+ int childCount = treeModel.getChildCount
	1716	+ (parent.getLastPathComponent());
	1717	+
	1718	+ if(childCount > 0)
	1719	+ return parent.pathByAddingChild(treeModel.getChild
	1720	+ (parent.getLastPathComponent(), childCount - 1));
	1721	+ }
	1722	+ return null;
	1723	+ }
	1724	+
	1725	+ /**
	1726	+ * Updates how much each depth should be offset by.
	1727	+ */
	1728	+ protected void updateDepthOffset() {
	1729	+ if(isRootVisible()) {
	1730	+ if(getShowsRootHandles())
	1731	+ depthOffset = 1;
	1732	+ else
	1733	+ depthOffset = 0;
	1734	+ }
	1735	+ else if(!getShowsRootHandles())
	1736	+ depthOffset = -1;
	1737	+ else
	1738	+ depthOffset = 0;
	1739	+ }
	1740	+
	1741	+ /**
	1742	+ * Updates the cellEditor based on the editability of the JTree that
	1743	+ * we're contained in. If the tree is editable but doesn't have a
	1744	+ * cellEditor, a basic one will be used.
	1745	+ */
	1746	+ protected void updateCellEditor() {
	1747	+ TreeCellEditor newEditor;
	1748	+
	1749	+ completeEditing();
	1750	+ if(tree == null)
	1751	+ newEditor = null;
	1752	+ else {
	1753	+ if(tree.isEditable()) {
	1754	+ newEditor = tree.getCellEditor();
	1755	+ if(newEditor == null) {
	1756	+ newEditor = createDefaultCellEditor();
	1757	+ if(newEditor != null) {
	1758	+ tree.setCellEditor(newEditor);
	1759	+ createdCellEditor = true;
	1760	+ }
	1761	+ }
	1762	+ }
	1763	+ else
	1764	+ newEditor = null;
	1765	+ }
	1766	+ if(newEditor != cellEditor) {
	1767	+ if(cellEditor != null && cellEditorListener != null)
	1768	+ cellEditor.removeCellEditorListener(cellEditorListener);
	1769	+ cellEditor = newEditor;
	1770	+ if(cellEditorListener == null)
	1771	+ cellEditorListener = createCellEditorListener();
	1772	+ if(newEditor != null && cellEditorListener != null)
	1773	+ newEditor.addCellEditorListener(cellEditorListener);
	1774	+ createdCellEditor = false;
	1775	+ }
	1776	+ }
	1777	+
	1778	+ /**
	1779	+ * Messaged from the tree we're in when the renderer has changed.
	1780	+ */
	1781	+ protected void updateRenderer() {
	1782	+ if(tree != null) {
	1783	+ TreeCellRenderer newCellRenderer;
	1784	+
	1785	+ newCellRenderer = tree.getCellRenderer();
	1786	+ if(newCellRenderer == null) {
	1787	+ tree.setCellRenderer(createDefaultCellRenderer());
	1788	+ createdRenderer = true;
	1789	+ }
	1790	+ else {
	1791	+ createdRenderer = false;
	1792	+ currentCellRenderer = newCellRenderer;
	1793	+ if(createdCellEditor) {
	1794	+ tree.setCellEditor(null);
	1795	+ }
	1796	+ }
	1797	+ }
	1798	+ else {
	1799	+ createdRenderer = false;
	1800	+ currentCellRenderer = null;
	1801	+ }
	1802	+ updateCellEditor();
	1803	+ }
	1804	+
	1805	+ /**
	1806	+ * Resets the TreeState instance based on the tree we're providing the
	1807	+ * look and feel for.
	1808	+ */
	1809	+ protected void configureLayoutCache() {
	1810	+ if(treeState != null && tree != null) {
	1811	+ if(nodeDimensions == null)
	1812	+ nodeDimensions = createNodeDimensions();
	1813	+ treeState.setNodeDimensions(nodeDimensions);
	1814	+ treeState.setRootVisible(tree.isRootVisible());
	1815	+ treeState.setRowHeight(tree.getRowHeight());
	1816	+ treeState.setSelectionModel(getSelectionModel());
	1817	+ // Only do this if necessary, may loss state if call with
	1818	+ // same model as it currently has.
	1819	+ if(treeState.getModel() != tree.getModel())
	1820	+ treeState.setModel(tree.getModel());
	1821	+ updateLayoutCacheExpandedNodesIfNecessary();
	1822	+ // Create a listener to update preferred size when bounds
	1823	+ // changes, if necessary.
	1824	+ if(isLargeModel()) {
	1825	+ if(componentListener == null) {
	1826	+ componentListener = createComponentListener();
	1827	+ if(componentListener != null)
	1828	+ tree.addComponentListener(componentListener);
	1829	+ }
	1830	+ }
	1831	+ else if(componentListener != null) {
	1832	+ tree.removeComponentListener(componentListener);
	1833	+ componentListener = null;
	1834	+ }
	1835	+ }
	1836	+ else if(componentListener != null) {
	1837	+ tree.removeComponentListener(componentListener);
	1838	+ componentListener = null;
	1839	+ }
	1840	+ }
	1841	+
	1842	+ /**
	1843	+ * Marks the cached size as being invalid, and messages the
	1844	+ * tree with <code>treeDidChange</code>.
	1845	+ */
	1846	+ protected void updateSize() {
	1847	+ validCachedPreferredSize = false;
	1848	+ tree.treeDidChange();
	1849	+ }
	1850	+
	1851	+ private void updateSize0() {
	1852	+ validCachedPreferredSize = false;
	1853	+ tree.revalidate();
	1854	+ }
	1855	+
	1856	+ /**
	1857	+ * Updates the <code>preferredSize</code> instance variable,
	1858	+ * which is returned from <code>getPreferredSize()</code>.<p>
	1859	+ * For left to right orientations, the size is determined from the
	1860	+ * current AbstractLayoutCache. For RTL orientations, the preferred size
	1861	+ * becomes the width minus the minimum x position.
	1862	+ */
	1863	+ protected void updateCachedPreferredSize() {
	1864	+ if(treeState != null) {
	1865	+ Insets i = tree.getInsets();
	1866	+
	1867	+ if(isLargeModel()) {
	1868	+ Rectangle visRect = tree.getVisibleRect();
	1869	+
	1870	+ if (visRect.x == 0 && visRect.y == 0 &&
	1871	+ visRect.width == 0 && visRect.height == 0 &&
	1872	+ tree.getVisibleRowCount() > 0) {
	1873	+ // The tree doesn't have a valid bounds yet. Calculate
	1874	+ // based on visible row count.
	1875	+ visRect.width = 1;
	1876	+ visRect.height = tree.getRowHeight() *
	1877	+ tree.getVisibleRowCount();
	1878	+ } else {
	1879	+ visRect.x -= i.left;
	1880	+ visRect.y -= i.top;
	1881	+ }
	1882	+ preferredSize.width = treeState.getPreferredWidth(visRect);
	1883	+ }
	1884	+ else {
	1885	+ preferredSize.width = treeState.getPreferredWidth(null);
	1886	+ }
	1887	+ preferredSize.height = treeState.getPreferredHeight();
	1888	+ preferredSize.width += i.left + i.right;
	1889	+ preferredSize.height += i.top + i.bottom;
	1890	+ }
	1891	+ validCachedPreferredSize = true;
	1892	+ }
	1893	+
	1894	+ /**
	1895	+ * Messaged from the VisibleTreeNode after it has been expanded.
	1896	+ */
	1897	+ protected void pathWasExpanded(TreePath path) {
	1898	+ if(tree != null) {
	1899	+ tree.fireTreeExpanded(path);
	1900	+ }
	1901	+ }
	1902	+
	1903	+ /**
	1904	+ * Messaged from the VisibleTreeNode after it has collapsed.
	1905	+ */
	1906	+ protected void pathWasCollapsed(TreePath path) {
	1907	+ if(tree != null) {
	1908	+ tree.fireTreeCollapsed(path);
	1909	+ }
	1910	+ }
	1911	+
	1912	+ /**
	1913	+ * Ensures that the rows identified by beginRow through endRow are
	1914	+ * visible.
	1915	+ */
	1916	+ protected void ensureRowsAreVisible(int beginRow, int endRow) {
	1917	+ if(tree != null && beginRow >= 0 && endRow < getRowCount(tree)) {
	1918	+ boolean scrollVert = DefaultLookup.getBoolean(tree, this,
	1919	+ "Tree.scrollsHorizontallyAndVertically", false);
	1920	+ if(beginRow == endRow) {
	1921	+ Rectangle scrollBounds = getPathBounds(tree, getPathForRow
	1922	+ (tree, beginRow));
	1923	+
	1924	+ if(scrollBounds != null) {
	1925	+ if (!scrollVert) {
	1926	+ scrollBounds.x = tree.getVisibleRect().x;
	1927	+ scrollBounds.width = 1;
	1928	+ }
	1929	+ tree.scrollRectToVisible(scrollBounds);
	1930	+ }
	1931	+ }
	1932	+ else {
	1933	+ Rectangle beginRect = getPathBounds(tree, getPathForRow
	1934	+ (tree, beginRow));
	1935	+ Rectangle visRect = tree.getVisibleRect();
	1936	+ Rectangle testRect = beginRect;
	1937	+ int beginY = beginRect.y;
	1938	+ int maxY = beginY + visRect.height;
	1939	+
	1940	+ for(int counter = beginRow + 1; counter <= endRow; counter++) {
	1941	+ testRect = getPathBounds(tree,
	1942	+ getPathForRow(tree, counter));
	1943	+ if((testRect.y + testRect.height) > maxY)
	1944	+ counter = endRow;
	1945	+ }
	1946	+ tree.scrollRectToVisible(new Rectangle(visRect.x, beginY, 1,
	1947	+ testRect.y + testRect.height-
	1948	+ beginY));
	1949	+ }
	1950	+ }
	1951	+ }
	1952	+
	1953	+ /** Sets the preferred minimum size.
	1954	+ */
	1955	+ public void setPreferredMinSize(Dimension newSize) {
	1956	+ preferredMinSize = newSize;
	1957	+ }
	1958	+
	1959	+ /** Returns the minimum preferred size.
	1960	+ */
	1961	+ public Dimension getPreferredMinSize() {
	1962	+ if(preferredMinSize == null)
	1963	+ return null;
	1964	+ return new Dimension(preferredMinSize);
	1965	+ }
	1966	+
	1967	+ /** Returns the preferred size to properly display the tree,
	1968	+ * this is a cover method for getPreferredSize(c, true).
	1969	+ */
	1970	+ public Dimension getPreferredSize(JComponent c) {
	1971	+ return getPreferredSize(c, true);
	1972	+ }
	1973	+
	1974	+ /** Returns the preferred size to represent the tree in
	1975	+ * <I>c</I>. If <I>checkConsistency</I> is true
	1976	+ * <b>checkConsistency</b> is messaged first.
	1977	+ */
	1978	+ public Dimension getPreferredSize(JComponent c,
	1979	+ boolean checkConsistency) {
	1980	+ Dimension pSize = this.getPreferredMinSize();
	1981	+
	1982	+ if(!validCachedPreferredSize)
	1983	+ updateCachedPreferredSize();
	1984	+ if(tree != null) {
	1985	+ if(pSize != null)
	1986	+ return new Dimension(Math.max(pSize.width,
	1987	+ preferredSize.width),
	1988	+ Math.max(pSize.height, preferredSize.height));
	1989	+ return new Dimension(preferredSize.width, preferredSize.height);
	1990	+ }
	1991	+ else if(pSize != null)
	1992	+ return pSize;
	1993	+ else
	1994	+ return new Dimension(0, 0);
	1995	+ }
	1996	+
	1997	+ /**
	1998	+ * Returns the minimum size for this component. Which will be
	1999	+ * the min preferred size or 0, 0.
	2000	+ */
	2001	+ public Dimension getMinimumSize(JComponent c) {
	2002	+ if(this.getPreferredMinSize() != null)
	2003	+ return this.getPreferredMinSize();
	2004	+ return new Dimension(0, 0);
	2005	+ }
	2006	+
	2007	+ /**
	2008	+ * Returns the maximum size for this component, which will be the
	2009	+ * preferred size if the instance is currently in a JTree, or 0, 0.
	2010	+ */
	2011	+ public Dimension getMaximumSize(JComponent c) {
	2012	+ if(tree != null)
	2013	+ return getPreferredSize(tree);
	2014	+ if(this.getPreferredMinSize() != null)
	2015	+ return this.getPreferredMinSize();
	2016	+ return new Dimension(0, 0);
	2017	+ }
	2018	+
	2019	+
	2020	+ /**
	2021	+ * Messages to stop the editing session. If the UI the receiver
	2022	+ * is providing the look and feel for returns true from
	2023	+ * <code>getInvokesStopCellEditing</code>, stopCellEditing will
	2024	+ * invoked on the current editor. Then completeEditing will
	2025	+ * be messaged with false, true, false to cancel any lingering
	2026	+ * editing.
	2027	+ */
	2028	+ protected void completeEditing() {
	2029	+ /* If should invoke stopCellEditing, try that */
	2030	+ if(tree.getInvokesStopCellEditing() &&
	2031	+ stopEditingInCompleteEditing && editingComponent != null) {
	2032	+ cellEditor.stopCellEditing();
	2033	+ }
	2034	+ /* Invoke cancelCellEditing, this will do nothing if stopCellEditing
	2035	+ was successful. */
	2036	+ completeEditing(false, true, false);
	2037	+ }
	2038	+
	2039	+ /**
	2040	+ * Stops the editing session. If messageStop is true the editor
	2041	+ * is messaged with stopEditing, if messageCancel is true the
	2042	+ * editor is messaged with cancelEditing. If messageTree is true
	2043	+ * the treeModel is messaged with valueForPathChanged.
	2044	+ */
	2045	+ protected void completeEditing(boolean messageStop,
	2046	+ boolean messageCancel,
	2047	+ boolean messageTree) {
	2048	+ if(stopEditingInCompleteEditing && editingComponent != null) {
	2049	+ Component oldComponent = editingComponent;
	2050	+ TreePath oldPath = editingPath;
	2051	+ TreeCellEditor oldEditor = cellEditor;
	2052	+ Object newValue = oldEditor.getCellEditorValue();
	2053	+ Rectangle editingBounds = getPathBounds(tree,
	2054	+ editingPath);
	2055	+ boolean requestFocus = (tree != null &&
	2056	+ (tree.hasFocus() \|\| SwingUtilities.
	2057	+ findFocusOwner(editingComponent) != null));
	2058	+
	2059	+ editingComponent = null;
	2060	+ editingPath = null;
	2061	+ if(messageStop)
	2062	+ oldEditor.stopCellEditing();
	2063	+ else if(messageCancel)
	2064	+ oldEditor.cancelCellEditing();
	2065	+ tree.remove(oldComponent);
	2066	+ if(editorHasDifferentSize) {
	2067	+ treeState.invalidatePathBounds(oldPath);
	2068	+ updateSize();
	2069	+ }
	2070	+ else {
	2071	+ editingBounds.x = 0;
	2072	+ editingBounds.width = tree.getSize().width;
	2073	+ tree.repaint(editingBounds);
	2074	+ }
	2075	+ if(requestFocus)
	2076	+ tree.requestFocus();
	2077	+ if(messageTree)
	2078	+ treeModel.valueForPathChanged(oldPath, newValue);
	2079	+ }
	2080	+ }
	2081	+
	2082	+ // cover method for startEditing that allows us to pass extra
	2083	+ // information into that method via a class variable
	2084	+ private boolean startEditingOnRelease(TreePath path,
	2085	+ MouseEvent event,
	2086	+ MouseEvent releaseEvent) {
	2087	+ this.releaseEvent = releaseEvent;
	2088	+ try {
	2089	+ return startEditing(path, event);
	2090	+ } finally {
	2091	+ this.releaseEvent = null;
	2092	+ }
	2093	+ }
	2094	+
	2095	+ /**
	2096	+ * Will start editing for node if there is a cellEditor and
	2097	+ * shouldSelectCell returns true.<p>
	2098	+ * This assumes that path is valid and visible.
	2099	+ */
	2100	+ protected boolean startEditing(TreePath path, MouseEvent event) {
	2101	+ if (isEditing(tree) && tree.getInvokesStopCellEditing() &&
	2102	+ !stopEditing(tree)) {
	2103	+ return false;
	2104	+ }
	2105	+ completeEditing();
	2106	+ if(cellEditor != null && tree.isPathEditable(path)) {
	2107	+ int row = getRowForPath(tree, path);
	2108	+
	2109	+ if(cellEditor.isCellEditable(event)) {
	2110	+ editingComponent = cellEditor.getTreeCellEditorComponent
	2111	+ (tree, path.getLastPathComponent(),
	2112	+ tree.isPathSelected(path), tree.isExpanded(path),
	2113	+ treeModel.isLeaf(path.getLastPathComponent()), row);
	2114	+ Rectangle nodeBounds = getPathBounds(tree, path);
	2115	+
	2116	+ editingRow = row;
	2117	+
	2118	+ Dimension editorSize = editingComponent.getPreferredSize();
	2119	+
	2120	+ // Only allow odd heights if explicitly set.
	2121	+ if(editorSize.height != nodeBounds.height &&
	2122	+ getRowHeight() > 0)
	2123	+ editorSize.height = getRowHeight();
	2124	+
	2125	+ if(editorSize.width != nodeBounds.width \|\|
	2126	+ editorSize.height != nodeBounds.height) {
	2127	+ // Editor wants different width or height, invalidate
	2128	+ // treeState and relayout.
	2129	+ editorHasDifferentSize = true;
	2130	+ treeState.invalidatePathBounds(path);
	2131	+ updateSize();
	2132	+ // To make sure x/y are updated correctly, fetch
	2133	+ // the bounds again.
	2134	+ nodeBounds = getPathBounds(tree, path);
	2135	+ }
	2136	+ else
	2137	+ editorHasDifferentSize = false;
	2138	+ tree.add(editingComponent);
	2139	+ editingComponent.setBounds(nodeBounds.x, nodeBounds.y,
	2140	+ nodeBounds.width,
	2141	+ nodeBounds.height);
	2142	+ editingPath = path;
	2143	+ if (editingComponent instanceof JComponent) {
	2144	+ ((JComponent)editingComponent).revalidate();
	2145	+ } else {
	2146	+ editingComponent.validate();
	2147	+ }
	2148	+ editingComponent.repaint();
	2149	+ if(cellEditor.shouldSelectCell(event)) {
	2150	+ stopEditingInCompleteEditing = false;
	2151	+ tree.setSelectionRow(row);
	2152	+ stopEditingInCompleteEditing = true;
	2153	+ }
	2154	+
	2155	+ Component focusedComponent = SwingUtilities2.
	2156	+ compositeRequestFocus(editingComponent);
	2157	+ boolean selectAll = true;
	2158	+
	2159	+ if(event != null) {
	2160	+ /* Find the component that will get forwarded all the
	2161	+ mouse events until mouseReleased. */
	2162	+ Point componentPoint = SwingUtilities.convertPoint
	2163	+ (tree, new Point(event.getX(), event.getY()),
	2164	+ editingComponent);
	2165	+
	2166	+ /* Create an instance of BasicTreeMouseListener to handle
	2167	+ passing the mouse/motion events to the necessary
	2168	+ component. */
	2169	+ // We really want similar behavior to getMouseEventTarget,
	2170	+ // but it is package private.
	2171	+ Component activeComponent = SwingUtilities.
	2172	+ getDeepestComponentAt(editingComponent,
	2173	+ componentPoint.x, componentPoint.y);
	2174	+ if (activeComponent != null) {
	2175	+ MouseInputHandler handler =
	2176	+ new MouseInputHandler(tree, activeComponent,
	2177	+ event, focusedComponent);
	2178	+
	2179	+ if (releaseEvent != null) {
	2180	+ handler.mouseReleased(releaseEvent);
	2181	+ }
	2182	+
	2183	+ selectAll = false;
	2184	+ }
	2185	+ }
	2186	+ if (selectAll && focusedComponent instanceof JTextField) {
	2187	+ ((JTextField)focusedComponent).selectAll();
	2188	+ }
	2189	+ return true;
	2190	+ }
	2191	+ else
	2192	+ editingComponent = null;
	2193	+ }
	2194	+ return false;
	2195	+ }
	2196	+
	2197	+ //
	2198	+ // Following are primarily for handling mouse events.
	2199	+ //
	2200	+
	2201	+ /**
	2202	+ * If the <code>mouseX</code> and <code>mouseY</code> are in the
	2203	+ * expand/collapse region of the <code>row</code>, this will toggle
	2204	+ * the row.
	2205	+ */
	2206	+ protected void checkForClickInExpandControl(TreePath path,
	2207	+ int mouseX, int mouseY) {
	2208	+ if (isLocationInExpandControl(path, mouseX, mouseY)) {
	2209	+ handleExpandControlClick(path, mouseX, mouseY);
	2210	+ }
	2211	+ }
	2212	+
	2213	+ /**
	2214	+ * Returns true if <code>mouseX</code> and <code>mouseY</code> fall
	2215	+ * in the area of row that is used to expand/collapse the node and
	2216	+ * the node at <code>row</code> does not represent a leaf.
	2217	+ */
	2218	+ protected boolean isLocationInExpandControl(TreePath path,
	2219	+ int mouseX, int mouseY) {
	2220	+ if(path != null && !treeModel.isLeaf(path.getLastPathComponent())){
	2221	+ int boxWidth;
	2222	+ Insets i = tree.getInsets();
	2223	+
	2224	+ if(getExpandedIcon() != null)
	2225	+ boxWidth = getExpandedIcon().getIconWidth();
	2226	+ else
	2227	+ boxWidth = 8;
	2228	+
	2229	+ int boxLeftX = getRowX(tree.getRowForPath(path),
	2230	+ path.getPathCount() - 1);
	2231	+
	2232	+ if (leftToRight) {
	2233	+ boxLeftX = boxLeftX + i.left - getRightChildIndent() + 1;
	2234	+ } else {
	2235	+ boxLeftX = tree.getWidth() - boxLeftX - i.right + getRightChildIndent() - 1;
	2236	+ }
	2237	+
	2238	+ boxLeftX = findCenteredX(boxLeftX, boxWidth);
	2239	+
	2240	+ return (mouseX >= boxLeftX && mouseX < (boxLeftX + boxWidth));
	2241	+ }
	2242	+ return false;
	2243	+ }
	2244	+
	2245	+ /**
	2246	+ * Messaged when the user clicks the particular row, this invokes
	2247	+ * toggleExpandState.
	2248	+ */
	2249	+ protected void handleExpandControlClick(TreePath path, int mouseX,
	2250	+ int mouseY) {
	2251	+ toggleExpandState(path);
	2252	+ }
	2253	+
	2254	+ /**
	2255	+ * Expands path if it is not expanded, or collapses row if it is expanded.
	2256	+ * If expanding a path and JTree scrolls on expand, ensureRowsAreVisible
	2257	+ * is invoked to scroll as many of the children to visible as possible
	2258	+ * (tries to scroll to last visible descendant of path).
	2259	+ */
	2260	+ protected void toggleExpandState(TreePath path) {
	2261	+ if(!tree.isExpanded(path)) {
	2262	+ int row = getRowForPath(tree, path);
	2263	+
	2264	+ tree.expandPath(path);
	2265	+ updateSize();
	2266	+ if(row != -1) {
	2267	+ if(tree.getScrollsOnExpand())
	2268	+ ensureRowsAreVisible(row, row + treeState.
	2269	+ getVisibleChildCount(path));
	2270	+ else
	2271	+ ensureRowsAreVisible(row, row);
	2272	+ }
	2273	+ }
	2274	+ else {
	2275	+ tree.collapsePath(path);
	2276	+ updateSize();
	2277	+ }
	2278	+ }
	2279	+
	2280	+ /**
	2281	+ * Returning true signifies a mouse event on the node should toggle
	2282	+ * the selection of only the row under mouse.
	2283	+ */
	2284	+ protected boolean isToggleSelectionEvent(MouseEvent event) {
	2285	+ return (SwingUtilities.isLeftMouseButton(event) &&
	2286	+ BasicGraphicsUtils.isMenuShortcutKeyDown(event));
	2287	+ }
	2288	+
	2289	+ /**
	2290	+ * Returning true signifies a mouse event on the node should select
	2291	+ * from the anchor point.
	2292	+ */
	2293	+ protected boolean isMultiSelectEvent(MouseEvent event) {
	2294	+ return (SwingUtilities.isLeftMouseButton(event) &&
	2295	+ event.isShiftDown());
	2296	+ }
	2297	+
	2298	+ /**
	2299	+ * Returning true indicates the row under the mouse should be toggled
	2300	+ * based on the event. This is invoked after checkForClickInExpandControl,
	2301	+ * implying the location is not in the expand (toggle) control
	2302	+ */
	2303	+ protected boolean isToggleEvent(MouseEvent event) {
	2304	+ if(!SwingUtilities.isLeftMouseButton(event)) {
	2305	+ return false;
	2306	+ }
	2307	+ int clickCount = tree.getToggleClickCount();
	2308	+
	2309	+ if(clickCount <= 0) {
	2310	+ return false;
	2311	+ }
	2312	+ return ((event.getClickCount() % clickCount) == 0);
	2313	+ }
	2314	+
	2315	+ /**
	2316	+ * Messaged to update the selection based on a MouseEvent over a
	2317	+ * particular row. If the event is a toggle selection event, the
	2318	+ * row is either selected, or deselected. If the event identifies
	2319	+ * a multi selection event, the selection is updated from the
	2320	+ * anchor point. Otherwise the row is selected, and if the event
	2321	+ * specified a toggle event the row is expanded/collapsed.
	2322	+ */
	2323	+ protected void selectPathForEvent(TreePath path, MouseEvent event) {
	2324	+ /* Adjust from the anchor point. */
	2325	+ if(isMultiSelectEvent(event)) {
	2326	+ TreePath anchor = getAnchorSelectionPath();
	2327	+ int anchorRow = (anchor == null) ? -1 :
	2328	+ getRowForPath(tree, anchor);
	2329	+
	2330	+ if(anchorRow == -1 \|\| tree.getSelectionModel().
	2331	+ getSelectionMode() == TreeSelectionModel.
	2332	+ SINGLE_TREE_SELECTION) {
	2333	+ tree.setSelectionPath(path);
	2334	+ }
	2335	+ else {
	2336	+ int row = getRowForPath(tree, path);
	2337	+ TreePath lastAnchorPath = anchor;
	2338	+
	2339	+ if (isToggleSelectionEvent(event)) {
	2340	+ if (tree.isRowSelected(anchorRow)) {
	2341	+ tree.addSelectionInterval(anchorRow, row);
	2342	+ } else {
	2343	+ tree.removeSelectionInterval(anchorRow, row);
	2344	+ tree.addSelectionInterval(row, row);
	2345	+ }
	2346	+ } else if(row < anchorRow) {
	2347	+ tree.setSelectionInterval(row, anchorRow);
	2348	+ } else {
	2349	+ tree.setSelectionInterval(anchorRow, row);
	2350	+ }
	2351	+ lastSelectedRow = row;
	2352	+ setAnchorSelectionPath(lastAnchorPath);
	2353	+ setLeadSelectionPath(path);
	2354	+ }
	2355	+ }
	2356	+
	2357	+ // Should this event toggle the selection of this row?
	2358	+ /* Control toggles just this node. */
	2359	+ else if(isToggleSelectionEvent(event)) {
	2360	+ if(tree.isPathSelected(path))
	2361	+ tree.removeSelectionPath(path);
	2362	+ else
	2363	+ tree.addSelectionPath(path);
	2364	+ lastSelectedRow = getRowForPath(tree, path);
	2365	+ setAnchorSelectionPath(path);
	2366	+ setLeadSelectionPath(path);
	2367	+ }
	2368	+
	2369	+ /* Otherwise set the selection to just this interval. */
	2370	+ else if(SwingUtilities.isLeftMouseButton(event)) {
	2371	+ tree.setSelectionPath(path);
	2372	+ if(isToggleEvent(event)) {
	2373	+ toggleExpandState(path);
	2374	+ }
	2375	+ }
	2376	+ }
	2377	+
	2378	+ /**
	2379	+ * @return true if the node at <code>row</code> is a leaf.
	2380	+ */
	2381	+ protected boolean isLeaf(int row) {
	2382	+ TreePath path = getPathForRow(tree, row);
	2383	+
	2384	+ if(path != null)
	2385	+ return treeModel.isLeaf(path.getLastPathComponent());
	2386	+ // Have to return something here...
	2387	+ return true;
	2388	+ }
	2389	+
	2390	+ //
	2391	+ // The following selection methods (lead/anchor) are covers for the
	2392	+ // methods in JTree.
	2393	+ //
	2394	+ private void setAnchorSelectionPath(TreePath newPath) {
	2395	+ ignoreLAChange = true;
	2396	+ try {
	2397	+ tree.setAnchorSelectionPath(newPath);
	2398	+ } finally{
	2399	+ ignoreLAChange = false;
	2400	+ }
	2401	+ }
	2402	+
	2403	+ private TreePath getAnchorSelectionPath() {
	2404	+ return tree.getAnchorSelectionPath();
	2405	+ }
	2406	+
	2407	+ private void setLeadSelectionPath(TreePath newPath) {
	2408	+ setLeadSelectionPath(newPath, false);
	2409	+ }
	2410	+
	2411	+ private void setLeadSelectionPath(TreePath newPath, boolean repaint) {
	2412	+ Rectangle bounds = repaint ?
	2413	+ getPathBounds(tree, getLeadSelectionPath()) : null;
	2414	+
	2415	+ ignoreLAChange = true;
	2416	+ try {
	2417	+ tree.setLeadSelectionPath(newPath);
	2418	+ } finally {
	2419	+ ignoreLAChange = false;
	2420	+ }
	2421	+ leadRow = getRowForPath(tree, newPath);
	2422	+
	2423	+ if (repaint) {
	2424	+ if (bounds != null) {
	2425	+ tree.repaint(getRepaintPathBounds(bounds));
	2426	+ }
	2427	+ bounds = getPathBounds(tree, newPath);
	2428	+ if (bounds != null) {
	2429	+ tree.repaint(getRepaintPathBounds(bounds));
	2430	+ }
	2431	+ }
	2432	+ }
	2433	+
	2434	+ private Rectangle getRepaintPathBounds(Rectangle bounds) {
	2435	+ if (UIManager.getBoolean("Tree.repaintWholeRow")) {
	2436	+ bounds.x = 0;
	2437	+ bounds.width = tree.getWidth();
	2438	+ }
	2439	+ return bounds;
	2440	+ }
	2441	+
	2442	+ private TreePath getLeadSelectionPath() {
	2443	+ return tree.getLeadSelectionPath();
	2444	+ }
	2445	+
	2446	+ /**
	2447	+ * Updates the lead row of the selection.
	2448	+ * @since 1.7
	2449	+ */
	2450	+ protected void updateLeadSelectionRow() {
	2451	+ leadRow = getRowForPath(tree, getLeadSelectionPath());
	2452	+ }
	2453	+
	2454	+ /**
	2455	+ * Returns the lead row of the selection.
	2456	+ *
	2457	+ * @return selection lead row
	2458	+ * @since 1.7
	2459	+ */
	2460	+ protected int getLeadSelectionRow() {
	2461	+ return leadRow;
	2462	+ }
	2463	+
	2464	+ /**
	2465	+ * Extends the selection from the anchor to make <code>newLead</code>
	2466	+ * the lead of the selection. This does not scroll.
	2467	+ */
	2468	+ private void extendSelection(TreePath newLead) {
	2469	+ TreePath aPath = getAnchorSelectionPath();
	2470	+ int aRow = (aPath == null) ? -1 :
	2471	+ getRowForPath(tree, aPath);
	2472	+ int newIndex = getRowForPath(tree, newLead);
	2473	+
	2474	+ if(aRow == -1) {
	2475	+ tree.setSelectionRow(newIndex);
	2476	+ }
	2477	+ else {
	2478	+ if(aRow < newIndex) {
	2479	+ tree.setSelectionInterval(aRow, newIndex);
	2480	+ }
	2481	+ else {
	2482	+ tree.setSelectionInterval(newIndex, aRow);
	2483	+ }
	2484	+ setAnchorSelectionPath(aPath);
	2485	+ setLeadSelectionPath(newLead);
	2486	+ }
	2487	+ }
	2488	+
	2489	+ /**
	2490	+ * Invokes <code>repaint</code> on the JTree for the passed in TreePath,
	2491	+ * <code>path</code>.
	2492	+ */
	2493	+ private void repaintPath(TreePath path) {
	2494	+ if (path != null) {
	2495	+ Rectangle bounds = getPathBounds(tree, path);
	2496	+ if (bounds != null) {
	2497	+ tree.repaint(bounds.x, bounds.y, bounds.width, bounds.height);
	2498	+ }
	2499	+ }
	2500	+ }
	2501	+
	2502	+ /**
	2503	+ * Updates the TreeState in response to nodes expanding/collapsing.
	2504	+ */
	2505	+ public class TreeExpansionHandler implements TreeExpansionListener {
	2506	+ // NOTE: This class exists only for backward compatability. All
	2507	+ // its functionality has been moved into Handler. If you need to add
	2508	+ // new functionality add it to the Handler, but make sure this
	2509	+ // class calls into the Handler.
	2510	+
	2511	+ /**
	2512	+ * Called whenever an item in the tree has been expanded.
	2513	+ */
	2514	+ public void treeExpanded(TreeExpansionEvent event) {
	2515	+ getHandler().treeExpanded(event);
	2516	+ }
	2517	+
	2518	+ /**
	2519	+ * Called whenever an item in the tree has been collapsed.
	2520	+ */
	2521	+ public void treeCollapsed(TreeExpansionEvent event) {
	2522	+ getHandler().treeCollapsed(event);
	2523	+ }
	2524	+ } // BasicTreeUI.TreeExpansionHandler
	2525	+
	2526	+
	2527	+ /**
	2528	+ * Updates the preferred size when scrolling (if necessary).
	2529	+ */
	2530	+ public class ComponentHandler extends ComponentAdapter implements
	2531	+ ActionListener {
	2532	+ /** Timer used when inside a scrollpane and the scrollbar is
	2533	+ * adjusting. */
	2534	+ protected Timer timer;
	2535	+ /** ScrollBar that is being adjusted. */
	2536	+ protected JScrollBar scrollBar;
	2537	+
	2538	+ public void componentMoved(ComponentEvent e) {
	2539	+ if(timer == null) {
	2540	+ JScrollPane scrollPane = getScrollPane();
	2541	+
	2542	+ if(scrollPane == null)
	2543	+ updateSize();
	2544	+ else {
	2545	+ scrollBar = scrollPane.getVerticalScrollBar();
	2546	+ if(scrollBar == null \|\|
	2547	+ !scrollBar.getValueIsAdjusting()) {
	2548	+ // Try the horizontal scrollbar.
	2549	+ if((scrollBar = scrollPane.getHorizontalScrollBar())
	2550	+ != null && scrollBar.getValueIsAdjusting())
	2551	+ startTimer();
	2552	+ else
	2553	+ updateSize();
	2554	+ }
	2555	+ else
	2556	+ startTimer();
	2557	+ }
	2558	+ }
	2559	+ }
	2560	+
	2561	+ /**
	2562	+ * Creates, if necessary, and starts a Timer to check if need to
	2563	+ * resize the bounds.
	2564	+ */
	2565	+ protected void startTimer() {
	2566	+ if(timer == null) {
	2567	+ timer = new Timer(200, this);
	2568	+ timer.setRepeats(true);
	2569	+ }
	2570	+ timer.start();
	2571	+ }
	2572	+
	2573	+ /**
	2574	+ * Returns the JScrollPane housing the JTree, or null if one isn't
	2575	+ * found.
	2576	+ */
	2577	+ protected JScrollPane getScrollPane() {
	2578	+ Component c = tree.getParent();
	2579	+
	2580	+ while(c != null && !(c instanceof JScrollPane))
	2581	+ c = c.getParent();
	2582	+ if(c instanceof JScrollPane)
	2583	+ return (JScrollPane)c;
	2584	+ return null;
	2585	+ }
	2586	+
	2587	+ /**
	2588	+ * Public as a result of Timer. If the scrollBar is null, or
	2589	+ * not adjusting, this stops the timer and updates the sizing.
	2590	+ */
	2591	+ public void actionPerformed(ActionEvent ae) {
	2592	+ if(scrollBar == null \|\| !scrollBar.getValueIsAdjusting()) {
	2593	+ if(timer != null)
	2594	+ timer.stop();
	2595	+ updateSize();
	2596	+ timer = null;
	2597	+ scrollBar = null;
	2598	+ }
	2599	+ }
	2600	+ } // End of BasicTreeUI.ComponentHandler
	2601	+
	2602	+
	2603	+ /**
	2604	+ * Forwards all TreeModel events to the TreeState.
	2605	+ */
	2606	+ public class TreeModelHandler implements TreeModelListener {
	2607	+
	2608	+ // NOTE: This class exists only for backward compatability. All
	2609	+ // its functionality has been moved into Handler. If you need to add
	2610	+ // new functionality add it to the Handler, but make sure this
	2611	+ // class calls into the Handler.
	2612	+
	2613	+ public void treeNodesChanged(TreeModelEvent e) {
	2614	+ getHandler().treeNodesChanged(e);
	2615	+ }
	2616	+
	2617	+ public void treeNodesInserted(TreeModelEvent e) {
	2618	+ getHandler().treeNodesInserted(e);
	2619	+ }
	2620	+
	2621	+ public void treeNodesRemoved(TreeModelEvent e) {
	2622	+ getHandler().treeNodesRemoved(e);
	2623	+ }
	2624	+
	2625	+ public void treeStructureChanged(TreeModelEvent e) {
	2626	+ getHandler().treeStructureChanged(e);
	2627	+ }
	2628	+ } // End of BasicTreeUI.TreeModelHandler
	2629	+
	2630	+
	2631	+ /**
	2632	+ * Listens for changes in the selection model and updates the display
	2633	+ * accordingly.
	2634	+ */
	2635	+ public class TreeSelectionHandler implements TreeSelectionListener {
	2636	+
	2637	+ // NOTE: This class exists only for backward compatability. All
	2638	+ // its functionality has been moved into Handler. If you need to add
	2639	+ // new functionality add it to the Handler, but make sure this
	2640	+ // class calls into the Handler.
	2641	+
	2642	+ /**
	2643	+ * Messaged when the selection changes in the tree we're displaying
	2644	+ * for. Stops editing, messages super and displays the changed paths.
	2645	+ */
	2646	+ public void valueChanged(TreeSelectionEvent event) {
	2647	+ getHandler().valueChanged(event);
	2648	+ }
	2649	+ }// End of BasicTreeUI.TreeSelectionHandler
	2650	+
	2651	+
	2652	+ /**
	2653	+ * Listener responsible for getting cell editing events and updating
	2654	+ * the tree accordingly.
	2655	+ */
	2656	+ public class CellEditorHandler implements CellEditorListener {
	2657	+
	2658	+ // NOTE: This class exists only for backward compatability. All
	2659	+ // its functionality has been moved into Handler. If you need to add
	2660	+ // new functionality add it to the Handler, but make sure this
	2661	+ // class calls into the Handler.
	2662	+
	2663	+ /** Messaged when editing has stopped in the tree. */
	2664	+ public void editingStopped(ChangeEvent e) {
	2665	+ getHandler().editingStopped(e);
	2666	+ }
	2667	+
	2668	+ /** Messaged when editing has been canceled in the tree. */
	2669	+ public void editingCanceled(ChangeEvent e) {
	2670	+ getHandler().editingCanceled(e);
	2671	+ }
	2672	+ } // BasicTreeUI.CellEditorHandler
	2673	+
	2674	+
	2675	+ /**
	2676	+ * This is used to get mutliple key down events to appropriately generate
	2677	+ * events.
	2678	+ */
	2679	+ public class KeyHandler extends KeyAdapter {
	2680	+
	2681	+ // NOTE: This class exists only for backward compatability. All
	2682	+ // its functionality has been moved into Handler. If you need to add
	2683	+ // new functionality add it to the Handler, but make sure this
	2684	+ // class calls into the Handler.
	2685	+
	2686	+ // Also note these fields aren't use anymore, nor does Handler have
	2687	+ // the old functionality. This behavior worked around an old bug
	2688	+ // in JComponent that has long since been fixed.
	2689	+
	2690	+ /** Key code that is being generated for. */
	2691	+ protected Action repeatKeyAction;
	2692	+
	2693	+ /** Set to true while keyPressed is active. */
	2694	+ protected boolean isKeyDown;
	2695	+
	2696	+ /**
	2697	+ * Invoked when a key has been typed.
	2698	+ *
	2699	+ * Moves the keyboard focus to the first element
	2700	+ * whose first letter matches the alphanumeric key
	2701	+ * pressed by the user. Subsequent same key presses
	2702	+ * move the keyboard focus to the next object that
	2703	+ * starts with the same letter.
	2704	+ */
	2705	+ public void keyTyped(KeyEvent e) {
	2706	+ getHandler().keyTyped(e);
	2707	+ }
	2708	+
	2709	+ public void keyPressed(KeyEvent e) {
	2710	+ getHandler().keyPressed(e);
	2711	+ }
	2712	+
	2713	+ public void keyReleased(KeyEvent e) {
	2714	+ getHandler().keyReleased(e);
	2715	+ }
	2716	+ } // End of BasicTreeUI.KeyHandler
	2717	+
	2718	+
	2719	+ /**
	2720	+ * Repaints the lead selection row when focus is lost/gained.
	2721	+ */
	2722	+ public class FocusHandler implements FocusListener {
	2723	+ // NOTE: This class exists only for backward compatability. All
	2724	+ // its functionality has been moved into Handler. If you need to add
	2725	+ // new functionality add it to the Handler, but make sure this
	2726	+ // class calls into the Handler.
	2727	+
	2728	+ /**
	2729	+ * Invoked when focus is activated on the tree we're in, redraws the
	2730	+ * lead row.
	2731	+ */
	2732	+ public void focusGained(FocusEvent e) {
	2733	+ getHandler().focusGained(e);
	2734	+ }
	2735	+
	2736	+ /**
	2737	+ * Invoked when focus is activated on the tree we're in, redraws the
	2738	+ * lead row.
	2739	+ */
	2740	+ public void focusLost(FocusEvent e) {
	2741	+ getHandler().focusLost(e);
	2742	+ }
	2743	+ } // End of class BasicTreeUI.FocusHandler
	2744	+
	2745	+
	2746	+ /**
	2747	+ * Class responsible for getting size of node, method is forwarded
	2748	+ * to BasicTreeUI method. X location does not include insets, that is
	2749	+ * handled in getPathBounds.
	2750	+ */
	2751	+ // This returns locations that don't include any Insets.
	2752	+ public class NodeDimensionsHandler extends
	2753	+ AbstractLayoutCache.NodeDimensions {
	2754	+ /**
	2755	+ * Responsible for getting the size of a particular node.
	2756	+ */
	2757	+ public Rectangle getNodeDimensions(Object value, int row,
	2758	+ int depth, boolean expanded,
	2759	+ Rectangle size) {
	2760	+ // Return size of editing component, if editing and asking
	2761	+ // for editing row.
	2762	+ if(editingComponent != null && editingRow == row) {
	2763	+ Dimension prefSize = editingComponent.
	2764	+ getPreferredSize();
	2765	+ int rh = getRowHeight();
	2766	+
	2767	+ if(rh > 0 && rh != prefSize.height)
	2768	+ prefSize.height = rh;
	2769	+ if(size != null) {
	2770	+ size.x = getRowX(row, depth);
	2771	+ size.width = prefSize.width;
	2772	+ size.height = prefSize.height;
	2773	+ }
	2774	+ else {
	2775	+ size = new Rectangle(getRowX(row, depth), 0,
	2776	+ prefSize.width, prefSize.height);
	2777	+ }
	2778	+ return size;
	2779	+ }
	2780	+ // Not editing, use renderer.
	2781	+ if(currentCellRenderer != null) {
	2782	+ Component aComponent;
	2783	+
	2784	+ aComponent = currentCellRenderer.getTreeCellRendererComponent
	2785	+ (tree, value, tree.isRowSelected(row),
	2786	+ expanded, treeModel.isLeaf(value), row,
	2787	+ false);
	2788	+ if(tree != null) {
	2789	+ // Only ever removed when UI changes, this is OK!
	2790	+ rendererPane.add(aComponent);
	2791	+ aComponent.validate();
	2792	+ }
	2793	+ Dimension prefSize = aComponent.getPreferredSize();
	2794	+
	2795	+ if(size != null) {
	2796	+ size.x = getRowX(row, depth);
	2797	+ size.width = prefSize.width;
	2798	+ size.height = prefSize.height;
	2799	+ }
	2800	+ else {
	2801	+ size = new Rectangle(getRowX(row, depth), 0,
	2802	+ prefSize.width, prefSize.height);
	2803	+ }
	2804	+ return size;
	2805	+ }
	2806	+ return null;
	2807	+ }
	2808	+
	2809	+ /**
	2810	+ * @return amount to indent the given row.
	2811	+ */
	2812	+ protected int getRowX(int row, int depth) {
	2813	+ return BasicTreeUI.this.getRowX(row, depth);
	2814	+ }
	2815	+
	2816	+ } // End of class BasicTreeUI.NodeDimensionsHandler
	2817	+
	2818	+
	2819	+ /**
	2820	+ * TreeMouseListener is responsible for updating the selection
	2821	+ * based on mouse events.
	2822	+ */
	2823	+ public class MouseHandler extends MouseAdapter implements MouseMotionListener
	2824	+ {
	2825	+ // NOTE: This class exists only for backward compatability. All
	2826	+ // its functionality has been moved into Handler. If you need to add
	2827	+ // new functionality add it to the Handler, but make sure this
	2828	+ // class calls into the Handler.
	2829	+
	2830	+ /**
	2831	+ * Invoked when a mouse button has been pressed on a component.
	2832	+ */
	2833	+ public void mousePressed(MouseEvent e) {
	2834	+ getHandler().mousePressed(e);
	2835	+ }
	2836	+
	2837	+ public void mouseDragged(MouseEvent e) {
	2838	+ getHandler().mouseDragged(e);
	2839	+ }
	2840	+
	2841	+ /**
	2842	+ * Invoked when the mouse button has been moved on a component
	2843	+ * (with no buttons no down).
	2844	+ * @since 1.4
	2845	+ */
	2846	+ public void mouseMoved(MouseEvent e) {
	2847	+ getHandler().mouseMoved(e);
	2848	+ }
	2849	+
	2850	+ public void mouseReleased(MouseEvent e) {
	2851	+ getHandler().mouseReleased(e);
	2852	+ }
	2853	+ } // End of BasicTreeUI.MouseHandler
	2854	+
	2855	+
	2856	+ /**
	2857	+ * PropertyChangeListener for the tree. Updates the appropriate
	2858	+ * varaible, or TreeState, based on what changes.
	2859	+ */
	2860	+ public class PropertyChangeHandler implements
	2861	+ PropertyChangeListener {
	2862	+
	2863	+ // NOTE: This class exists only for backward compatability. All
	2864	+ // its functionality has been moved into Handler. If you need to add
	2865	+ // new functionality add it to the Handler, but make sure this
	2866	+ // class calls into the Handler.
	2867	+
	2868	+ public void propertyChange(PropertyChangeEvent event) {
	2869	+ getHandler().propertyChange(event);
	2870	+ }
	2871	+ } // End of BasicTreeUI.PropertyChangeHandler
	2872	+
	2873	+
	2874	+ /**
	2875	+ * Listener on the TreeSelectionModel, resets the row selection if
	2876	+ * any of the properties of the model change.
	2877	+ */
	2878	+ public class SelectionModelPropertyChangeHandler implements
	2879	+ PropertyChangeListener {
	2880	+
	2881	+ // NOTE: This class exists only for backward compatability. All
	2882	+ // its functionality has been moved into Handler. If you need to add
	2883	+ // new functionality add it to the Handler, but make sure this
	2884	+ // class calls into the Handler.
	2885	+
	2886	+ public void propertyChange(PropertyChangeEvent event) {
	2887	+ getHandler().propertyChange(event);
	2888	+ }
	2889	+ } // End of BasicTreeUI.SelectionModelPropertyChangeHandler
	2890	+
	2891	+
	2892	+ /**
	2893	+ * <code>TreeTraverseAction</code> is the action used for left/right keys.
	2894	+ * Will toggle the expandedness of a node, as well as potentially
	2895	+ * incrementing the selection.
	2896	+ */
	2897	+ public class TreeTraverseAction extends AbstractAction {
	2898	+ /** Determines direction to traverse, 1 means expand, -1 means
	2899	+ * collapse. */
	2900	+ protected int direction;
	2901	+ /** True if the selection is reset, false means only the lead path
	2902	+ * changes. */
	2903	+ private boolean changeSelection;
	2904	+
	2905	+ public TreeTraverseAction(int direction, String name) {
	2906	+ this(direction, name, true);
	2907	+ }
	2908	+
	2909	+ private TreeTraverseAction(int direction, String name,
	2910	+ boolean changeSelection) {
	2911	+ this.direction = direction;
	2912	+ this.changeSelection = changeSelection;
	2913	+ }
	2914	+
	2915	+ public void actionPerformed(ActionEvent e) {
	2916	+ if (tree != null) {
	2917	+ SHARED_ACTION.traverse(tree, BasicTreeUI.this, direction,
	2918	+ changeSelection);
	2919	+ }
	2920	+ }
	2921	+
	2922	+ public boolean isEnabled() { return (tree != null &&
	2923	+ tree.isEnabled()); }
	2924	+ } // BasicTreeUI.TreeTraverseAction
	2925	+
	2926	+
	2927	+ /** TreePageAction handles page up and page down events.
	2928	+ */
	2929	+ public class TreePageAction extends AbstractAction {
	2930	+ /** Specifies the direction to adjust the selection by. */
	2931	+ protected int direction;
	2932	+ /** True indicates should set selection from anchor path. */
	2933	+ private boolean addToSelection;
	2934	+ private boolean changeSelection;
	2935	+
	2936	+ public TreePageAction(int direction, String name) {
	2937	+ this(direction, name, false, true);
	2938	+ }
	2939	+
	2940	+ private TreePageAction(int direction, String name,
	2941	+ boolean addToSelection,
	2942	+ boolean changeSelection) {
	2943	+ this.direction = direction;
	2944	+ this.addToSelection = addToSelection;
	2945	+ this.changeSelection = changeSelection;
	2946	+ }
	2947	+
	2948	+ public void actionPerformed(ActionEvent e) {
	2949	+ if (tree != null) {
	2950	+ SHARED_ACTION.page(tree, BasicTreeUI.this, direction,
	2951	+ addToSelection, changeSelection);
	2952	+ }
	2953	+ }
	2954	+
	2955	+ public boolean isEnabled() { return (tree != null &&
	2956	+ tree.isEnabled()); }
	2957	+
	2958	+ } // BasicTreeUI.TreePageAction
	2959	+
	2960	+
	2961	+ /** TreeIncrementAction is used to handle up/down actions. Selection
	2962	+ * is moved up or down based on direction.
	2963	+ */
	2964	+ public class TreeIncrementAction extends AbstractAction {
	2965	+ /** Specifies the direction to adjust the selection by. */
	2966	+ protected int direction;
	2967	+ /** If true the new item is added to the selection, if false the
	2968	+ * selection is reset. */
	2969	+ private boolean addToSelection;
	2970	+ private boolean changeSelection;
	2971	+
	2972	+ public TreeIncrementAction(int direction, String name) {
	2973	+ this(direction, name, false, true);
	2974	+ }
	2975	+
	2976	+ private TreeIncrementAction(int direction, String name,
	2977	+ boolean addToSelection,
	2978	+ boolean changeSelection) {
	2979	+ this.direction = direction;
	2980	+ this.addToSelection = addToSelection;
	2981	+ this.changeSelection = changeSelection;
	2982	+ }
	2983	+
	2984	+ public void actionPerformed(ActionEvent e) {
	2985	+ if (tree != null) {
	2986	+ SHARED_ACTION.increment(tree, BasicTreeUI.this, direction,
	2987	+ addToSelection, changeSelection);
	2988	+ }
	2989	+ }
	2990	+
	2991	+ public boolean isEnabled() { return (tree != null &&
	2992	+ tree.isEnabled()); }
	2993	+
	2994	+ } // End of class BasicTreeUI.TreeIncrementAction
	2995	+
	2996	+ /**
	2997	+ * TreeHomeAction is used to handle end/home actions.
	2998	+ * Scrolls either the first or last cell to be visible based on
	2999	+ * direction.
	3000	+ */
	3001	+ public class TreeHomeAction extends AbstractAction {
	3002	+ protected int direction;
	3003	+ /** Set to true if append to selection. */
	3004	+ private boolean addToSelection;
	3005	+ private boolean changeSelection;
	3006	+
	3007	+ public TreeHomeAction(int direction, String name) {
	3008	+ this(direction, name, false, true);
	3009	+ }
	3010	+
	3011	+ private TreeHomeAction(int direction, String name,
	3012	+ boolean addToSelection,
	3013	+ boolean changeSelection) {
	3014	+ this.direction = direction;
	3015	+ this.changeSelection = changeSelection;
	3016	+ this.addToSelection = addToSelection;
	3017	+ }
	3018	+
	3019	+ public void actionPerformed(ActionEvent e) {
	3020	+ if (tree != null) {
	3021	+ SHARED_ACTION.home(tree, BasicTreeUI.this, direction,
	3022	+ addToSelection, changeSelection);
	3023	+ }
	3024	+ }
	3025	+
	3026	+ public boolean isEnabled() { return (tree != null &&
	3027	+ tree.isEnabled()); }
	3028	+
	3029	+ } // End of class BasicTreeUI.TreeHomeAction
	3030	+
	3031	+
	3032	+ /**
	3033	+ * For the first selected row expandedness will be toggled.
	3034	+ */
	3035	+ public class TreeToggleAction extends AbstractAction {
	3036	+ public TreeToggleAction(String name) {
	3037	+ }
	3038	+
	3039	+ public void actionPerformed(ActionEvent e) {
	3040	+ if(tree != null) {
	3041	+ SHARED_ACTION.toggle(tree, BasicTreeUI.this);
	3042	+ }
	3043	+ }
	3044	+
	3045	+ public boolean isEnabled() { return (tree != null &&
	3046	+ tree.isEnabled()); }
	3047	+
	3048	+ } // End of class BasicTreeUI.TreeToggleAction
	3049	+
	3050	+
	3051	+ /**
	3052	+ * ActionListener that invokes cancelEditing when action performed.
	3053	+ */
	3054	+ public class TreeCancelEditingAction extends AbstractAction {
	3055	+ public TreeCancelEditingAction(String name) {
	3056	+ }
	3057	+
	3058	+ public void actionPerformed(ActionEvent e) {
	3059	+ if(tree != null) {
	3060	+ SHARED_ACTION.cancelEditing(tree, BasicTreeUI.this);
	3061	+ }
	3062	+ }
	3063	+
	3064	+ public boolean isEnabled() { return (tree != null &&
	3065	+ tree.isEnabled() &&
	3066	+ isEditing(tree)); }
	3067	+ } // End of class BasicTreeUI.TreeCancelEditingAction
	3068	+
	3069	+
	3070	+ /**
	3071	+ * MouseInputHandler handles passing all mouse events,
	3072	+ * including mouse motion events, until the mouse is released to
	3073	+ * the destination it is constructed with. It is assumed all the
	3074	+ * events are currently target at source.
	3075	+ */
	3076	+ public class MouseInputHandler extends Object implements
	3077	+ MouseInputListener
	3078	+ {
	3079	+ /** Source that events are coming from. */
	3080	+ protected Component source;
	3081	+ /** Destination that receives all events. */
	3082	+ protected Component destination;
	3083	+ private Component focusComponent;
	3084	+ private boolean dispatchedEvent;
	3085	+
	3086	+ public MouseInputHandler(Component source, Component destination,
	3087	+ MouseEvent event){
	3088	+ this(source, destination, event, null);
	3089	+ }
	3090	+
	3091	+ MouseInputHandler(Component source, Component destination,
	3092	+ MouseEvent event, Component focusComponent) {
	3093	+ this.source = source;
	3094	+ this.destination = destination;
	3095	+ this.source.addMouseListener(this);
	3096	+ this.source.addMouseMotionListener(this);
	3097	+
	3098	+ SwingUtilities2.setSkipClickCount(destination,
	3099	+ event.getClickCount() - 1);
	3100	+
	3101	+ /* Dispatch the editing event! */
	3102	+ destination.dispatchEvent(SwingUtilities.convertMouseEvent
	3103	+ (source, event, destination));
	3104	+ this.focusComponent = focusComponent;
	3105	+ }
	3106	+
	3107	+ public void mouseClicked(MouseEvent e) {
	3108	+ if(destination != null) {
	3109	+ dispatchedEvent = true;
	3110	+ destination.dispatchEvent(SwingUtilities.convertMouseEvent
	3111	+ (source, e, destination));
	3112	+ }
	3113	+ }
	3114	+
	3115	+ public void mousePressed(MouseEvent e) {
	3116	+ }
	3117	+
	3118	+ public void mouseReleased(MouseEvent e) {
	3119	+ if(destination != null)
	3120	+ destination.dispatchEvent(SwingUtilities.convertMouseEvent
	3121	+ (source, e, destination));
	3122	+ removeFromSource();
	3123	+ }
	3124	+
	3125	+ public void mouseEntered(MouseEvent e) {
	3126	+ if (!SwingUtilities.isLeftMouseButton(e)) {
	3127	+ removeFromSource();
	3128	+ }
	3129	+ }
	3130	+
	3131	+ public void mouseExited(MouseEvent e) {
	3132	+ if (!SwingUtilities.isLeftMouseButton(e)) {
	3133	+ removeFromSource();
	3134	+ }
	3135	+ }
	3136	+
	3137	+ public void mouseDragged(MouseEvent e) {
	3138	+ if(destination != null) {
	3139	+ dispatchedEvent = true;
	3140	+ destination.dispatchEvent(SwingUtilities.convertMouseEvent
	3141	+ (source, e, destination));
	3142	+ }
	3143	+ }
	3144	+
	3145	+ public void mouseMoved(MouseEvent e) {
	3146	+ removeFromSource();
	3147	+ }
	3148	+
	3149	+ protected void removeFromSource() {
	3150	+ if(source != null) {
	3151	+ source.removeMouseListener(this);
	3152	+ source.removeMouseMotionListener(this);
	3153	+ if (focusComponent != null &&
	3154	+ focusComponent == destination && !dispatchedEvent &&
	3155	+ (focusComponent instanceof JTextField)) {
	3156	+ ((JTextField)focusComponent).selectAll();
	3157	+ }
	3158	+ }
	3159	+ source = destination = null;
	3160	+ }
	3161	+
	3162	+ } // End of class BasicTreeUI.MouseInputHandler
	3163	+
	3164	+ private static final TransferHandler defaultTransferHandler = new TreeTransferHandler();
	3165	+
	3166	+ static class TreeTransferHandler extends TransferHandler implements UIResource, Comparator<TreePath> {
	3167	+
	3168	+ private JTree tree;
	3169	+
	3170	+ /**
	3171	+ * Create a Transferable to use as the source for a data transfer.
	3172	+ *
	3173	+ * @param c The component holding the data to be transfered. This
	3174	+ * argument is provided to enable sharing of TransferHandlers by
	3175	+ * multiple components.
	3176	+ * @return The representation of the data to be transfered.
	3177	+ *
	3178	+ */
	3179	+ protected Transferable createTransferable(JComponent c) {
	3180	+ if (c instanceof JTree) {
	3181	+ tree = (JTree) c;
	3182	+ TreePath[] paths = tree.getSelectionPaths();
	3183	+
	3184	+ if (paths == null \|\| paths.length == 0) {
	3185	+ return null;
	3186	+ }
	3187	+
	3188	+ StringBuffer plainBuf = new StringBuffer();
	3189	+ StringBuffer htmlBuf = new StringBuffer();
	3190	+
	3191	+ htmlBuf.append("<html>\n<body>\n<ul>\n");
	3192	+
	3193	+ TreeModel model = tree.getModel();
	3194	+ TreePath lastPath = null;
	3195	+ TreePath[] displayPaths = getDisplayOrderPaths(paths);
	3196	+
	3197	+ for (TreePath path : displayPaths) {
	3198	+ Object node = path.getLastPathComponent();
	3199	+ boolean leaf = model.isLeaf(node);
	3200	+ String label = getDisplayString(path, true, leaf);
	3201	+
	3202	+ plainBuf.append(label + "\n");
	3203	+ htmlBuf.append(" <li>" + label + "\n");
	3204	+ }
	3205	+
	3206	+ // remove the last newline
	3207	+ plainBuf.deleteCharAt(plainBuf.length() - 1);
	3208	+ htmlBuf.append("</ul>\n</body>\n</html>");
	3209	+
	3210	+ tree = null;
	3211	+
	3212	+ return new BasicTransferable(plainBuf.toString(), htmlBuf.toString());
	3213	+ }
	3214	+
	3215	+ return null;
	3216	+ }
	3217	+
	3218	+ public int compare(TreePath o1, TreePath o2) {
	3219	+ int row1 = tree.getRowForPath(o1);
	3220	+ int row2 = tree.getRowForPath(o2);
	3221	+ return row1 - row2;
	3222	+ }
	3223	+
	3224	+ String getDisplayString(TreePath path, boolean selected, boolean leaf) {
	3225	+ int row = tree.getRowForPath(path);
	3226	+ boolean hasFocus = tree.getLeadSelectionRow() == row;
	3227	+ Object node = path.getLastPathComponent();
	3228	+ return tree.convertValueToText(node, selected, tree.isExpanded(row),
	3229	+ leaf, row, hasFocus);
	3230	+ }
	3231	+
	3232	+ /**
	3233	+ * Selection paths are in selection order. The conversion to
	3234	+ * HTML requires display order. This method resorts the paths
	3235	+ * to be in the display order.
	3236	+ */
	3237	+ TreePath[] getDisplayOrderPaths(TreePath[] paths) {
	3238	+ // sort the paths to display order rather than selection order
	3239	+ ArrayList<TreePath> selOrder = new ArrayList<TreePath>();
	3240	+ for (TreePath path : paths) {
	3241	+ selOrder.add(path);
	3242	+ }
	3243	+ Collections.sort(selOrder, this);
	3244	+ int n = selOrder.size();
	3245	+ TreePath[] displayPaths = new TreePath[n];
	3246	+ for (int i = 0; i < n; i++) {
	3247	+ displayPaths[i] = selOrder.get(i);
	3248	+ }
	3249	+ return displayPaths;
	3250	+ }
	3251	+
	3252	+ public int getSourceActions(JComponent c) {
	3253	+ return COPY;
	3254	+ }
	3255	+
	3256	+ }
	3257	+
	3258	+
	3259	+ private class Handler implements CellEditorListener, FocusListener,
	3260	+ KeyListener, MouseListener, MouseMotionListener,
	3261	+ PropertyChangeListener, TreeExpansionListener,
	3262	+ TreeModelListener, TreeSelectionListener,
	3263	+ BeforeDrag {
	3264	+ //
	3265	+ // KeyListener
	3266	+ //
	3267	+ private String prefix = "";
	3268	+ private String typedString = "";
	3269	+ private long lastTime = 0L;
	3270	+
	3271	+ /**
	3272	+ * Invoked when a key has been typed.
	3273	+ *
	3274	+ * Moves the keyboard focus to the first element whose prefix matches the
	3275	+ * sequence of alphanumeric keys pressed by the user with delay less
	3276	+ * than value of <code>timeFactor</code> property (or 1000 milliseconds
	3277	+ * if it is not defined). Subsequent same key presses move the keyboard
	3278	+ * focus to the next object that starts with the same letter until another
	3279	+ * key is pressed, then it is treated as the prefix with appropriate number
	3280	+ * of the same letters followed by first typed another letter.
	3281	+ */
	3282	+ public void keyTyped(KeyEvent e) {
	3283	+ // handle first letter navigation
	3284	+ if(tree != null && tree.getRowCount()>0 && tree.hasFocus() &&
	3285	+ tree.isEnabled()) {
	3286	+ if (e.isAltDown() \|\| BasicGraphicsUtils.isMenuShortcutKeyDown(e) \|\|
	3287	+ isNavigationKey(e)) {
	3288	+ return;
	3289	+ }
	3290	+ boolean startingFromSelection = true;
	3291	+
	3292	+ char c = e.getKeyChar();
	3293	+
	3294	+ long time = e.getWhen();
	3295	+ int startingRow = tree.getLeadSelectionRow();
	3296	+ if (time - lastTime < timeFactor) {
	3297	+ typedString += c;
	3298	+ if((prefix.length() == 1) && (c == prefix.charAt(0))) {
	3299	+ // Subsequent same key presses move the keyboard focus to the next
	3300	+ // object that starts with the same letter.
	3301	+ startingRow++;
	3302	+ } else {
	3303	+ prefix = typedString;
	3304	+ }
	3305	+ } else {
	3306	+ startingRow++;
	3307	+ typedString = "" + c;
	3308	+ prefix = typedString;
	3309	+ }
	3310	+ lastTime = time;
	3311	+
	3312	+ if (startingRow < 0 \|\| startingRow >= tree.getRowCount()) {
	3313	+ startingFromSelection = false;
	3314	+ startingRow = 0;
	3315	+ }
	3316	+ TreePath path = tree.getNextMatch(prefix, startingRow,
	3317	+ Position.Bias.Forward);
	3318	+ if (path != null) {
	3319	+ tree.setSelectionPath(path);
	3320	+ int row = getRowForPath(tree, path);
	3321	+ ensureRowsAreVisible(row, row);
	3322	+ } else if (startingFromSelection) {
	3323	+ path = tree.getNextMatch(prefix, 0,
	3324	+ Position.Bias.Forward);
	3325	+ if (path != null) {
	3326	+ tree.setSelectionPath(path);
	3327	+ int row = getRowForPath(tree, path);
	3328	+ ensureRowsAreVisible(row, row);
	3329	+ }
	3330	+ }
	3331	+ }
	3332	+ }
	3333	+
	3334	+ /**
	3335	+ * Invoked when a key has been pressed.
	3336	+ *
	3337	+ * Checks to see if the key event is a navigation key to prevent
	3338	+ * dispatching these keys for the first letter navigation.
	3339	+ */
	3340	+ public void keyPressed(KeyEvent e) {
	3341	+ if (tree != null && isNavigationKey(e)) {
	3342	+ prefix = "";
	3343	+ typedString = "";
	3344	+ lastTime = 0L;
	3345	+ }
	3346	+ }
	3347	+
	3348	+ public void keyReleased(KeyEvent e) {
	3349	+ }
	3350	+
	3351	+ /**
	3352	+ * Returns whether or not the supplied key event maps to a key that is used for
	3353	+ * navigation. This is used for optimizing key input by only passing non-
	3354	+ * navigation keys to the first letter navigation mechanism.
	3355	+ */
	3356	+ private boolean isNavigationKey(KeyEvent event) {
	3357	+ InputMap inputMap = tree.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
	3358	+ KeyStroke key = KeyStroke.getKeyStrokeForEvent(event);
	3359	+
	3360	+ return inputMap != null && inputMap.get(key) != null;
	3361	+ }
	3362	+
	3363	+
	3364	+ //
	3365	+ // PropertyChangeListener
	3366	+ //
	3367	+ public void propertyChange(PropertyChangeEvent event) {
	3368	+ if (event.getSource() == treeSelectionModel) {
	3369	+ treeSelectionModel.resetRowSelection();
	3370	+ }
	3371	+ else if(event.getSource() == tree) {
	3372	+ String changeName = event.getPropertyName();
	3373	+
	3374	+ if (changeName == JTree.LEAD_SELECTION_PATH_PROPERTY) {
	3375	+ if (!ignoreLAChange) {
	3376	+ updateLeadSelectionRow();
	3377	+ repaintPath((TreePath)event.getOldValue());
	3378	+ repaintPath((TreePath)event.getNewValue());
	3379	+ }
	3380	+ }
	3381	+ else if (changeName == JTree.ANCHOR_SELECTION_PATH_PROPERTY) {
	3382	+ if (!ignoreLAChange) {
	3383	+ repaintPath((TreePath)event.getOldValue());
	3384	+ repaintPath((TreePath)event.getNewValue());
	3385	+ }
	3386	+ }
	3387	+ if(changeName == JTree.CELL_RENDERER_PROPERTY) {
	3388	+ setCellRenderer((TreeCellRenderer)event.getNewValue());
	3389	+ redoTheLayout();
	3390	+ }
	3391	+ else if(changeName == JTree.TREE_MODEL_PROPERTY) {
	3392	+ setModel((TreeModel)event.getNewValue());
	3393	+ }
	3394	+ else if(changeName == JTree.ROOT_VISIBLE_PROPERTY) {
	3395	+ setRootVisible(((Boolean)event.getNewValue()).
	3396	+ booleanValue());
	3397	+ }
	3398	+ else if(changeName == JTree.SHOWS_ROOT_HANDLES_PROPERTY) {
	3399	+ setShowsRootHandles(((Boolean)event.getNewValue()).
	3400	+ booleanValue());
	3401	+ }
	3402	+ else if(changeName == JTree.ROW_HEIGHT_PROPERTY) {
	3403	+ setRowHeight(((Integer)event.getNewValue()).
	3404	+ intValue());
	3405	+ }
	3406	+ else if(changeName == JTree.CELL_EDITOR_PROPERTY) {
	3407	+ setCellEditor((TreeCellEditor)event.getNewValue());
	3408	+ }
	3409	+ else if(changeName == JTree.EDITABLE_PROPERTY) {
	3410	+ setEditable(((Boolean)event.getNewValue()).booleanValue());
	3411	+ }
	3412	+ else if(changeName == JTree.LARGE_MODEL_PROPERTY) {
	3413	+ setLargeModel(tree.isLargeModel());
	3414	+ }
	3415	+ else if(changeName == JTree.SELECTION_MODEL_PROPERTY) {
	3416	+ setSelectionModel(tree.getSelectionModel());
	3417	+ }
	3418	+ else if(changeName == "font") {
	3419	+ completeEditing();
	3420	+ if(treeState != null)
	3421	+ treeState.invalidateSizes();
	3422	+ updateSize();
	3423	+ }
	3424	+ else if (changeName == "componentOrientation") {
	3425	+ if (tree != null) {
	3426	+ leftToRight = BasicGraphicsUtils.isLeftToRight(tree);
	3427	+ redoTheLayout();
	3428	+ tree.treeDidChange();
	3429	+
	3430	+ InputMap km = getInputMap(JComponent.WHEN_FOCUSED);
	3431	+ SwingUtilities.replaceUIInputMap(tree,
	3432	+ JComponent.WHEN_FOCUSED, km);
	3433	+ }
	3434	+ } else if ("dropLocation" == changeName) {
	3435	+ JTree.DropLocation oldValue = (JTree.DropLocation)event.getOldValue();
	3436	+ repaintDropLocation(oldValue);
	3437	+ repaintDropLocation(tree.getDropLocation());
	3438	+ }
	3439	+ }
	3440	+ }
	3441	+
	3442	+ private void repaintDropLocation(JTree.DropLocation loc) {
	3443	+ if (loc == null) {
	3444	+ return;
	3445	+ }
	3446	+
	3447	+ Rectangle r;
	3448	+
	3449	+ if (isDropLine(loc)) {
	3450	+ r = getDropLineRect(loc);
	3451	+ } else {
	3452	+ r = tree.getPathBounds(loc.getPath());
	3453	+ }
	3454	+
	3455	+ if (r != null) {
	3456	+ tree.repaint(r);
	3457	+ }
	3458	+ }
	3459	+
	3460	+ //
	3461	+ // MouseListener
	3462	+ //
	3463	+
	3464	+ // Whether or not the mouse press (which is being considered as part
	3465	+ // of a drag sequence) also caused the selection change to be fully
	3466	+ // processed.
	3467	+ private boolean dragPressDidSelection;
	3468	+
	3469	+ // Set to true when a drag gesture has been fully recognized and DnD
	3470	+ // begins. Use this to ignore further mouse events which could be
	3471	+ // delivered if DnD is cancelled (via ESCAPE for example)
	3472	+ private boolean dragStarted;
	3473	+
	3474	+ // The path over which the press occurred and the press event itself
	3475	+ private TreePath pressedPath;
	3476	+ private MouseEvent pressedEvent;
	3477	+
	3478	+ // Used to detect whether the press event causes a selection change.
	3479	+ // If it does, we won't try to start editing on the release.
	3480	+ private boolean valueChangedOnPress;
	3481	+
	3482	+ private boolean isActualPath(TreePath path, int x, int y) {
	3483	+ if (path == null) {
	3484	+ return false;
	3485	+ }
	3486	+
	3487	+ Rectangle bounds = getPathBounds(tree, path);
	3488	+ if (y > (bounds.y + bounds.height)) {
	3489	+ return false;
	3490	+ }
	3491	+
	3492	+ return (x >= bounds.x) && (x <= (bounds.x + bounds.width));
	3493	+ }
	3494	+
	3495	+ public void mouseClicked(MouseEvent e) {
	3496	+ }
	3497	+
	3498	+ public void mouseEntered(MouseEvent e) {
	3499	+ }
	3500	+
	3501	+ public void mouseExited(MouseEvent e) {
	3502	+ }
	3503	+
	3504	+ /**
	3505	+ * Invoked when a mouse button has been pressed on a component.
	3506	+ */
	3507	+ public void mousePressed(MouseEvent e) {
	3508	+ if (SwingUtilities2.shouldIgnore(e, tree)) {
	3509	+ return;
	3510	+ }
	3511	+
	3512	+ // if we can't stop any ongoing editing, do nothing
	3513	+ if (isEditing(tree) && tree.getInvokesStopCellEditing()
	3514	+ && !stopEditing(tree)) {
	3515	+ return;
	3516	+ }
	3517	+
	3518	+ completeEditing();
	3519	+
	3520	+ pressedPath = getClosestPathForLocation(tree, e.getX(), e.getY());
	3521	+
	3522	+ if (tree.getDragEnabled()) {
	3523	+ mousePressedDND(e);
	3524	+ } else {
	3525	+ SwingUtilities2.adjustFocus(tree);
	3526	+ handleSelection(e);
	3527	+ }
	3528	+ }
	3529	+
	3530	+ private void mousePressedDND(MouseEvent e) {
	3531	+ pressedEvent = e;
	3532	+ boolean grabFocus = true;
	3533	+ dragStarted = false;
	3534	+ valueChangedOnPress = false;
	3535	+
	3536	+ // if we have a valid path and this is a drag initiating event
	3537	+ if (isActualPath(pressedPath, e.getX(), e.getY()) &&
	3538	+ DragRecognitionSupport.mousePressed(e)) {
	3539	+
	3540	+ dragPressDidSelection = false;
	3541	+
	3542	+ if (BasicGraphicsUtils.isMenuShortcutKeyDown(e)) {
	3543	+ // do nothing for control - will be handled on release
	3544	+ // or when drag starts
	3545	+ return;
	3546	+ } else if (!e.isShiftDown() && tree.isPathSelected(pressedPath)) {
	3547	+ // clicking on something that's already selected
	3548	+ // and need to make it the lead now
	3549	+ setAnchorSelectionPath(pressedPath);
	3550	+ setLeadSelectionPath(pressedPath, true);
	3551	+ return;
	3552	+ }
	3553	+
	3554	+ dragPressDidSelection = true;
	3555	+
	3556	+ // could be a drag initiating event - don't grab focus
	3557	+ grabFocus = false;
	3558	+ }
	3559	+
	3560	+ if (grabFocus) {
	3561	+ SwingUtilities2.adjustFocus(tree);
	3562	+ }
	3563	+
	3564	+ handleSelection(e);
	3565	+ }
	3566	+
	3567	+ void handleSelection(MouseEvent e) {
	3568	+ if(pressedPath != null) {
	3569	+ Rectangle bounds = getPathBounds(tree, pressedPath);
	3570	+
	3571	+ if(e.getY() >= (bounds.y + bounds.height)) {
	3572	+ return;
	3573	+ }
	3574	+
	3575	+ // Preferably checkForClickInExpandControl could take
	3576	+ // the Event to do this it self!
	3577	+ if(SwingUtilities.isLeftMouseButton(e)) {
	3578	+ checkForClickInExpandControl(pressedPath, e.getX(), e.getY());
	3579	+ }
	3580	+
	3581	+ int x = e.getX();
	3582	+
	3583	+ // Perhaps they clicked the cell itself. If so,
	3584	+ // select it.
	3585	+ if (x >= bounds.x && x < (bounds.x + bounds.width)) {
	3586	+ if (tree.getDragEnabled() \|\| !startEditing(pressedPath, e)) {
	3587	+ selectPathForEvent(pressedPath, e);
	3588	+ }
	3589	+ }
	3590	+ }
	3591	+ }
	3592	+
	3593	+ public void dragStarting(MouseEvent me) {
	3594	+ dragStarted = true;
	3595	+
	3596	+ if (BasicGraphicsUtils.isMenuShortcutKeyDown(me)) {
	3597	+ tree.addSelectionPath(pressedPath);
	3598	+ setAnchorSelectionPath(pressedPath);
	3599	+ setLeadSelectionPath(pressedPath, true);
	3600	+ }
	3601	+
	3602	+ pressedEvent = null;
	3603	+ pressedPath = null;
	3604	+ }
	3605	+
	3606	+ public void mouseDragged(MouseEvent e) {
	3607	+ if (SwingUtilities2.shouldIgnore(e, tree)) {
	3608	+ return;
	3609	+ }
	3610	+
	3611	+ if (tree.getDragEnabled()) {
	3612	+ DragRecognitionSupport.mouseDragged(e, this);
	3613	+ }
	3614	+ }
	3615	+
	3616	+ /**
	3617	+ * Invoked when the mouse button has been moved on a component
	3618	+ * (with no buttons no down).
	3619	+ */
	3620	+ public void mouseMoved(MouseEvent e) {
	3621	+ }
	3622	+
	3623	+ public void mouseReleased(MouseEvent e) {
	3624	+ if (SwingUtilities2.shouldIgnore(e, tree)) {
	3625	+ return;
	3626	+ }
	3627	+
	3628	+ if (tree.getDragEnabled()) {
	3629	+ mouseReleasedDND(e);
	3630	+ }
	3631	+
	3632	+ pressedEvent = null;
	3633	+ pressedPath = null;
	3634	+ }
	3635	+
	3636	+ private void mouseReleasedDND(MouseEvent e) {
	3637	+ MouseEvent me = DragRecognitionSupport.mouseReleased(e);
	3638	+ if (me != null) {
	3639	+ SwingUtilities2.adjustFocus(tree);
	3640	+ if (!dragPressDidSelection) {
	3641	+ handleSelection(me);
	3642	+ }
	3643	+ }
	3644	+
	3645	+ if (!dragStarted) {
	3646	+
	3647	+ // Note: We don't give the tree a chance to start editing if the
	3648	+ // mouse press caused a selection change. Otherwise the default
	3649	+ // tree cell editor will start editing on EVERY press and
	3650	+ // release. If it turns out that this affects some editors, we
	3651	+ // can always parameterize this with a client property. ex:
	3652	+ //
	3653	+ // if (pressedPath != null &&
	3654	+ // (Boolean.TRUE == tree.getClientProperty("Tree.DnD.canEditOnValueChange") \|\|
	3655	+ // !valueChangedOnPress) && ...
	3656	+ if (pressedPath != null && !valueChangedOnPress &&
	3657	+ isActualPath(pressedPath, pressedEvent.getX(), pressedEvent.getY())) {
	3658	+
	3659	+ startEditingOnRelease(pressedPath, pressedEvent, e);
	3660	+ }
	3661	+ }
	3662	+ }
	3663	+
	3664	+ //
	3665	+ // FocusListener
	3666	+ //
	3667	+ public void focusGained(FocusEvent e) {
	3668	+ if(tree != null) {
	3669	+ Rectangle pBounds;
	3670	+
	3671	+ pBounds = getPathBounds(tree, tree.getLeadSelectionPath());
	3672	+ if(pBounds != null)
	3673	+ tree.repaint(getRepaintPathBounds(pBounds));
	3674	+ pBounds = getPathBounds(tree, getLeadSelectionPath());
	3675	+ if(pBounds != null)
	3676	+ tree.repaint(getRepaintPathBounds(pBounds));
	3677	+ }
	3678	+ }
	3679	+
	3680	+ public void focusLost(FocusEvent e) {
	3681	+ focusGained(e);
	3682	+ }
	3683	+
	3684	+ //
	3685	+ // CellEditorListener
	3686	+ //
	3687	+ public void editingStopped(ChangeEvent e) {
	3688	+ completeEditing(false, false, true);
	3689	+ }
	3690	+
	3691	+ /** Messaged when editing has been canceled in the tree. */
	3692	+ public void editingCanceled(ChangeEvent e) {
	3693	+ completeEditing(false, false, false);
	3694	+ }
	3695	+
	3696	+
	3697	+ //
	3698	+ // TreeSelectionListener
	3699	+ //
	3700	+ public void valueChanged(TreeSelectionEvent event) {
	3701	+ valueChangedOnPress = true;
	3702	+
	3703	+ // Stop editing
	3704	+ completeEditing();
	3705	+ // Make sure all the paths are visible, if necessary.
	3706	+ // PENDING: This should be tweaked when isAdjusting is added
	3707	+ if(tree.getExpandsSelectedPaths() && treeSelectionModel != null) {
	3708	+ TreePath[] paths = treeSelectionModel
	3709	+ .getSelectionPaths();
	3710	+
	3711	+ if(paths != null) {
	3712	+ for(int counter = paths.length - 1; counter >= 0;
	3713	+ counter--) {
	3714	+ TreePath path = paths[counter].getParentPath();
	3715	+ boolean expand = true;
	3716	+
	3717	+ while (path != null) {
	3718	+ // Indicates this path isn't valid anymore,
	3719	+ // we shouldn't attempt to expand it then.
	3720	+ if (treeModel.isLeaf(path.getLastPathComponent())){
	3721	+ expand = false;
	3722	+ path = null;
	3723	+ }
	3724	+ else {
	3725	+ path = path.getParentPath();
	3726	+ }
	3727	+ }
	3728	+ if (expand) {
	3729	+ tree.makeVisible(paths[counter]);
	3730	+ }
	3731	+ }
	3732	+ }
	3733	+ }
	3734	+
	3735	+ TreePath oldLead = getLeadSelectionPath();
	3736	+ lastSelectedRow = tree.getMinSelectionRow();
	3737	+ TreePath lead = tree.getSelectionModel().getLeadSelectionPath();
	3738	+ setAnchorSelectionPath(lead);
	3739	+ setLeadSelectionPath(lead);
	3740	+
	3741	+ TreePath[] changedPaths = event.getPaths();
	3742	+ Rectangle nodeBounds;
	3743	+ Rectangle visRect = tree.getVisibleRect();
	3744	+ boolean paintPaths = true;
	3745	+ int nWidth = tree.getWidth();
	3746	+
	3747	+ if(changedPaths != null) {
	3748	+ int counter, maxCounter = changedPaths.length;
	3749	+
	3750	+ if(maxCounter > 4) {
	3751	+ tree.repaint();
	3752	+ paintPaths = false;
	3753	+ }
	3754	+ else {
	3755	+ for (counter = 0; counter < maxCounter; counter++) {
	3756	+ nodeBounds = getPathBounds(tree,
	3757	+ changedPaths[counter]);
	3758	+ if(nodeBounds != null &&
	3759	+ visRect.intersects(nodeBounds))
	3760	+ tree.repaint(0, nodeBounds.y, nWidth,
	3761	+ nodeBounds.height);
	3762	+ }
	3763	+ }
	3764	+ }
	3765	+ if(paintPaths) {
	3766	+ nodeBounds = getPathBounds(tree, oldLead);
	3767	+ if(nodeBounds != null && visRect.intersects(nodeBounds))
	3768	+ tree.repaint(0, nodeBounds.y, nWidth, nodeBounds.height);
	3769	+ nodeBounds = getPathBounds(tree, lead);
	3770	+ if(nodeBounds != null && visRect.intersects(nodeBounds))
	3771	+ tree.repaint(0, nodeBounds.y, nWidth, nodeBounds.height);
	3772	+ }
	3773	+ }
	3774	+
	3775	+
	3776	+ //
	3777	+ // TreeExpansionListener
	3778	+ //
	3779	+ public void treeExpanded(TreeExpansionEvent event) {
	3780	+ if(event != null && tree != null) {
	3781	+ TreePath path = event.getPath();
	3782	+
	3783	+ updateExpandedDescendants(path);
	3784	+ }
	3785	+ }
	3786	+
	3787	+ public void treeCollapsed(TreeExpansionEvent event) {
	3788	+ if(event != null && tree != null) {
	3789	+ TreePath path = event.getPath();
	3790	+
	3791	+ completeEditing();
	3792	+ if(path != null && tree.isVisible(path)) {
	3793	+ treeState.setExpandedState(path, false);
	3794	+ updateLeadSelectionRow();
	3795	+ updateSize();
	3796	+ }
	3797	+ }
	3798	+ }
	3799	+
	3800	+ //
	3801	+ // TreeModelListener
	3802	+ //
	3803	+ public void treeNodesChanged(TreeModelEvent e) {
	3804	+ if(treeState != null && e != null) {
	3805	+ TreePath parentPath = e.getTreePath();
	3806	+ int[] indices = e.getChildIndices();
	3807	+ if (indices == null \|\| indices.length == 0) {
	3808	+ // The root has changed
	3809	+ treeState.treeNodesChanged(e);
	3810	+ updateSize();
	3811	+ }
	3812	+ else if (treeState.isExpanded(parentPath)) {
	3813	+ // Changed nodes are visible
	3814	+ // Find the minimum index, we only need paint from there
	3815	+ // down.
	3816	+ int minIndex = indices[0];
	3817	+ for (int i = indices.length - 1; i > 0; i--) {
	3818	+ minIndex = Math.min(indices[i], minIndex);
	3819	+ }
	3820	+ Object minChild = treeModel.getChild(
	3821	+ parentPath.getLastPathComponent(), minIndex);
	3822	+ TreePath minPath = parentPath.pathByAddingChild(minChild);
	3823	+ Rectangle minBounds = getPathBounds(tree, minPath);
	3824	+
	3825	+ // Forward to the treestate
	3826	+ treeState.treeNodesChanged(e);
	3827	+
	3828	+ // Mark preferred size as bogus.
	3829	+ updateSize0();
	3830	+
	3831	+ // And repaint
	3832	+ Rectangle newMinBounds = getPathBounds(tree, minPath);
	3833	+ if (indices.length == 1 &&
	3834	+ newMinBounds.height == minBounds.height) {
	3835	+ tree.repaint(0, minBounds.y, tree.getWidth(),
	3836	+ minBounds.height);
	3837	+ }
	3838	+ else {
	3839	+ tree.repaint(0, minBounds.y, tree.getWidth(),
	3840	+ tree.getHeight() - minBounds.y);
	3841	+ }
	3842	+ }
	3843	+ else {
	3844	+ // Nodes that changed aren't visible. No need to paint
	3845	+ treeState.treeNodesChanged(e);
	3846	+ }
	3847	+ }
	3848	+ }
	3849	+
	3850	+ public void treeNodesInserted(TreeModelEvent e) {
	3851	+ if(treeState != null && e != null) {
	3852	+ treeState.treeNodesInserted(e);
	3853	+
	3854	+ updateLeadSelectionRow();
	3855	+
	3856	+ TreePath path = e.getTreePath();
	3857	+
	3858	+ if(treeState.isExpanded(path)) {
	3859	+ updateSize();
	3860	+ }
	3861	+ else {
	3862	+ // PENDING(sky): Need a method in TreeModelEvent
	3863	+ // that can return the count, getChildIndices allocs
	3864	+ // a new array!
	3865	+ int[] indices = e.getChildIndices();
	3866	+ int childCount = treeModel.getChildCount
	3867	+ (path.getLastPathComponent());
	3868	+
	3869	+ if(indices != null && (childCount - indices.length) == 0)
	3870	+ updateSize();
	3871	+ }
	3872	+ }
	3873	+ }
	3874	+
	3875	+ public void treeNodesRemoved(TreeModelEvent e) {
	3876	+ if(treeState != null && e != null) {
	3877	+ treeState.treeNodesRemoved(e);
	3878	+
	3879	+ updateLeadSelectionRow();
	3880	+
	3881	+ TreePath path = e.getTreePath();
	3882	+
	3883	+ if(treeState.isExpanded(path) \|\|
	3884	+ treeModel.getChildCount(path.getLastPathComponent()) == 0)
	3885	+ updateSize();
	3886	+ }
	3887	+ }
	3888	+
	3889	+ public void treeStructureChanged(TreeModelEvent e) {
	3890	+ if(treeState != null && e != null) {
	3891	+ treeState.treeStructureChanged(e);
	3892	+
	3893	+ updateLeadSelectionRow();
	3894	+
	3895	+ TreePath pPath = e.getTreePath();
	3896	+
	3897	+ if (pPath != null) {
	3898	+ pPath = pPath.getParentPath();
	3899	+ }
	3900	+ if(pPath == null \|\| treeState.isExpanded(pPath))
	3901	+ updateSize();
	3902	+ }
	3903	+ }
	3904	+ }
	3905	+
	3906	+
	3907	+
	3908	+ private static class Actions extends UIAction {
	3909	+ private static final String SELECT_PREVIOUS = "selectPrevious";
	3910	+ private static final String SELECT_PREVIOUS_CHANGE_LEAD =
	3911	+ "selectPreviousChangeLead";
	3912	+ private static final String SELECT_PREVIOUS_EXTEND_SELECTION =
	3913	+ "selectPreviousExtendSelection";
	3914	+ private static final String SELECT_NEXT = "selectNext";
	3915	+ private static final String SELECT_NEXT_CHANGE_LEAD =
	3916	+ "selectNextChangeLead";
	3917	+ private static final String SELECT_NEXT_EXTEND_SELECTION =
	3918	+ "selectNextExtendSelection";
	3919	+ private static final String SELECT_CHILD = "selectChild";
	3920	+ private static final String SELECT_CHILD_CHANGE_LEAD =
	3921	+ "selectChildChangeLead";
	3922	+ private static final String SELECT_PARENT = "selectParent";
	3923	+ private static final String SELECT_PARENT_CHANGE_LEAD =
	3924	+ "selectParentChangeLead";
	3925	+ private static final String SCROLL_UP_CHANGE_SELECTION =
	3926	+ "scrollUpChangeSelection";
	3927	+ private static final String SCROLL_UP_CHANGE_LEAD =
	3928	+ "scrollUpChangeLead";
	3929	+ private static final String SCROLL_UP_EXTEND_SELECTION =
	3930	+ "scrollUpExtendSelection";
	3931	+ private static final String SCROLL_DOWN_CHANGE_SELECTION =
	3932	+ "scrollDownChangeSelection";
	3933	+ private static final String SCROLL_DOWN_EXTEND_SELECTION =
	3934	+ "scrollDownExtendSelection";
	3935	+ private static final String SCROLL_DOWN_CHANGE_LEAD =
	3936	+ "scrollDownChangeLead";
	3937	+ private static final String SELECT_FIRST = "selectFirst";
	3938	+ private static final String SELECT_FIRST_CHANGE_LEAD =
	3939	+ "selectFirstChangeLead";
	3940	+ private static final String SELECT_FIRST_EXTEND_SELECTION =
	3941	+ "selectFirstExtendSelection";
	3942	+ private static final String SELECT_LAST = "selectLast";
	3943	+ private static final String SELECT_LAST_CHANGE_LEAD =
	3944	+ "selectLastChangeLead";
	3945	+ private static final String SELECT_LAST_EXTEND_SELECTION =
	3946	+ "selectLastExtendSelection";
	3947	+ private static final String TOGGLE = "toggle";
	3948	+ private static final String CANCEL_EDITING = "cancel";
	3949	+ private static final String START_EDITING = "startEditing";
	3950	+ private static final String SELECT_ALL = "selectAll";
	3951	+ private static final String CLEAR_SELECTION = "clearSelection";
	3952	+ private static final String SCROLL_LEFT = "scrollLeft";
	3953	+ private static final String SCROLL_RIGHT = "scrollRight";
	3954	+ private static final String SCROLL_LEFT_EXTEND_SELECTION =
	3955	+ "scrollLeftExtendSelection";
	3956	+ private static final String SCROLL_RIGHT_EXTEND_SELECTION =
	3957	+ "scrollRightExtendSelection";
	3958	+ private static final String SCROLL_RIGHT_CHANGE_LEAD =
	3959	+ "scrollRightChangeLead";
	3960	+ private static final String SCROLL_LEFT_CHANGE_LEAD =
	3961	+ "scrollLeftChangeLead";
	3962	+ private static final String EXPAND = "expand";
	3963	+ private static final String COLLAPSE = "collapse";
	3964	+ private static final String MOVE_SELECTION_TO_PARENT =
	3965	+ "moveSelectionToParent";
	3966	+
	3967	+ // add the lead item to the selection without changing lead or anchor
	3968	+ private static final String ADD_TO_SELECTION = "addToSelection";
	3969	+
	3970	+ // toggle the selected state of the lead item and move the anchor to it
	3971	+ private static final String TOGGLE_AND_ANCHOR = "toggleAndAnchor";
	3972	+
	3973	+ // extend the selection to the lead item
	3974	+ private static final String EXTEND_TO = "extendTo";
	3975	+
	3976	+ // move the anchor to the lead and ensure only that item is selected
	3977	+ private static final String MOVE_SELECTION_TO = "moveSelectionTo";
	3978	+
	3979	+ Actions() {
	3980	+ super(null);
	3981	+ }
	3982	+
	3983	+ Actions(String key) {
	3984	+ super(key);
	3985	+ }
	3986	+
	3987	+ public boolean isEnabled(Object o) {
	3988	+ if (o instanceof JTree) {
	3989	+ if (getName() == CANCEL_EDITING) {
	3990	+ return ((JTree)o).isEditing();
	3991	+ }
	3992	+ }
	3993	+ return true;
	3994	+ }
	3995	+
	3996	+ public void actionPerformed(ActionEvent e) {
	3997	+ JTree tree = (JTree)e.getSource();
	3998	+ BasicTreeUI ui = (BasicTreeUI)BasicLookAndFeel.getUIOfType(
	3999	+ tree.getUI(), BasicTreeUI.class);
	4000	+ if (ui == null) {
	4001	+ return;
	4002	+ }
	4003	+ String key = getName();
	4004	+ if (key == SELECT_PREVIOUS) {
	4005	+ increment(tree, ui, -1, false, true);
	4006	+ }
	4007	+ else if (key == SELECT_PREVIOUS_CHANGE_LEAD) {
	4008	+ increment(tree, ui, -1, false, false);
	4009	+ }
	4010	+ else if (key == SELECT_PREVIOUS_EXTEND_SELECTION) {
	4011	+ increment(tree, ui, -1, true, true);
	4012	+ }
	4013	+ else if (key == SELECT_NEXT) {
	4014	+ increment(tree, ui, 1, false, true);
	4015	+ }
	4016	+ else if (key == SELECT_NEXT_CHANGE_LEAD) {
	4017	+ increment(tree, ui, 1, false, false);
	4018	+ }
	4019	+ else if (key == SELECT_NEXT_EXTEND_SELECTION) {
	4020	+ increment(tree, ui, 1, true, true);
	4021	+ }
	4022	+ else if (key == SELECT_CHILD) {
	4023	+ traverse(tree, ui, 1, true);
	4024	+ }
	4025	+ else if (key == SELECT_CHILD_CHANGE_LEAD) {
	4026	+ traverse(tree, ui, 1, false);
	4027	+ }
	4028	+ else if (key == SELECT_PARENT) {
	4029	+ traverse(tree, ui, -1, true);
	4030	+ }
	4031	+ else if (key == SELECT_PARENT_CHANGE_LEAD) {
	4032	+ traverse(tree, ui, -1, false);
	4033	+ }
	4034	+ else if (key == SCROLL_UP_CHANGE_SELECTION) {
	4035	+ page(tree, ui, -1, false, true);
	4036	+ }
	4037	+ else if (key == SCROLL_UP_CHANGE_LEAD) {
	4038	+ page(tree, ui, -1, false, false);
	4039	+ }
	4040	+ else if (key == SCROLL_UP_EXTEND_SELECTION) {
	4041	+ page(tree, ui, -1, true, true);
	4042	+ }
	4043	+ else if (key == SCROLL_DOWN_CHANGE_SELECTION) {
	4044	+ page(tree, ui, 1, false, true);
	4045	+ }
	4046	+ else if (key == SCROLL_DOWN_EXTEND_SELECTION) {
	4047	+ page(tree, ui, 1, true, true);
	4048	+ }
	4049	+ else if (key == SCROLL_DOWN_CHANGE_LEAD) {
	4050	+ page(tree, ui, 1, false, false);
	4051	+ }
	4052	+ else if (key == SELECT_FIRST) {
	4053	+ home(tree, ui, -1, false, true);
	4054	+ }
	4055	+ else if (key == SELECT_FIRST_CHANGE_LEAD) {
	4056	+ home(tree, ui, -1, false, false);
	4057	+ }
	4058	+ else if (key == SELECT_FIRST_EXTEND_SELECTION) {
	4059	+ home(tree, ui, -1, true, true);
	4060	+ }
	4061	+ else if (key == SELECT_LAST) {
	4062	+ home(tree, ui, 1, false, true);
	4063	+ }
	4064	+ else if (key == SELECT_LAST_CHANGE_LEAD) {
	4065	+ home(tree, ui, 1, false, false);
	4066	+ }
	4067	+ else if (key == SELECT_LAST_EXTEND_SELECTION) {
	4068	+ home(tree, ui, 1, true, true);
	4069	+ }
	4070	+ else if (key == TOGGLE) {
	4071	+ toggle(tree, ui);
	4072	+ }
	4073	+ else if (key == CANCEL_EDITING) {
	4074	+ cancelEditing(tree, ui);
	4075	+ }
	4076	+ else if (key == START_EDITING) {
	4077	+ startEditing(tree, ui);
	4078	+ }
	4079	+ else if (key == SELECT_ALL) {
	4080	+ selectAll(tree, ui, true);
	4081	+ }
	4082	+ else if (key == CLEAR_SELECTION) {
	4083	+ selectAll(tree, ui, false);
	4084	+ }
	4085	+ else if (key == ADD_TO_SELECTION) {
	4086	+ if (ui.getRowCount(tree) > 0) {
	4087	+ int lead = ui.getLeadSelectionRow();
	4088	+ if (!tree.isRowSelected(lead)) {
	4089	+ TreePath aPath = ui.getAnchorSelectionPath();
	4090	+ tree.addSelectionRow(lead);
	4091	+ ui.setAnchorSelectionPath(aPath);
	4092	+ }
	4093	+ }
	4094	+ }
	4095	+ else if (key == TOGGLE_AND_ANCHOR) {
	4096	+ if (ui.getRowCount(tree) > 0) {
	4097	+ int lead = ui.getLeadSelectionRow();
	4098	+ TreePath lPath = ui.getLeadSelectionPath();
	4099	+ if (!tree.isRowSelected(lead)) {
	4100	+ tree.addSelectionRow(lead);
	4101	+ } else {
	4102	+ tree.removeSelectionRow(lead);
	4103	+ ui.setLeadSelectionPath(lPath);
	4104	+ }
	4105	+ ui.setAnchorSelectionPath(lPath);
	4106	+ }
	4107	+ }
	4108	+ else if (key == EXTEND_TO) {
	4109	+ extendSelection(tree, ui);
	4110	+ }
	4111	+ else if (key == MOVE_SELECTION_TO) {
	4112	+ if (ui.getRowCount(tree) > 0) {
	4113	+ int lead = ui.getLeadSelectionRow();
	4114	+ tree.setSelectionInterval(lead, lead);
	4115	+ }
	4116	+ }
	4117	+ else if (key == SCROLL_LEFT) {
	4118	+ scroll(tree, ui, SwingConstants.HORIZONTAL, -10);
	4119	+ }
	4120	+ else if (key == SCROLL_RIGHT) {
	4121	+ scroll(tree, ui, SwingConstants.HORIZONTAL, 10);
	4122	+ }
	4123	+ else if (key == SCROLL_LEFT_EXTEND_SELECTION) {
	4124	+ scrollChangeSelection(tree, ui, -1, true, true);
	4125	+ }
	4126	+ else if (key == SCROLL_RIGHT_EXTEND_SELECTION) {
	4127	+ scrollChangeSelection(tree, ui, 1, true, true);
	4128	+ }
	4129	+ else if (key == SCROLL_RIGHT_CHANGE_LEAD) {
	4130	+ scrollChangeSelection(tree, ui, 1, false, false);
	4131	+ }
	4132	+ else if (key == SCROLL_LEFT_CHANGE_LEAD) {
	4133	+ scrollChangeSelection(tree, ui, -1, false, false);
	4134	+ }
	4135	+ else if (key == EXPAND) {
	4136	+ expand(tree, ui);
	4137	+ }
	4138	+ else if (key == COLLAPSE) {
	4139	+ collapse(tree, ui);
	4140	+ }
	4141	+ else if (key == MOVE_SELECTION_TO_PARENT) {
	4142	+ moveSelectionToParent(tree, ui);
	4143	+ }
	4144	+ }
	4145	+
	4146	+ private void scrollChangeSelection(JTree tree, BasicTreeUI ui,
	4147	+ int direction, boolean addToSelection,
	4148	+ boolean changeSelection) {
	4149	+ int rowCount;
	4150	+
	4151	+ if((rowCount = ui.getRowCount(tree)) > 0 &&
	4152	+ ui.treeSelectionModel != null) {
	4153	+ TreePath newPath;
	4154	+ Rectangle visRect = tree.getVisibleRect();
	4155	+
	4156	+ if (direction == -1) {
	4157	+ newPath = ui.getClosestPathForLocation(tree, visRect.x,
	4158	+ visRect.y);
	4159	+ visRect.x = Math.max(0, visRect.x - visRect.width);
	4160	+ }
	4161	+ else {
	4162	+ visRect.x = Math.min(Math.max(0, tree.getWidth() -
	4163	+ visRect.width), visRect.x + visRect.width);
	4164	+ newPath = ui.getClosestPathForLocation(tree, visRect.x,
	4165	+ visRect.y + visRect.height);
	4166	+ }
	4167	+ // Scroll
	4168	+ tree.scrollRectToVisible(visRect);
	4169	+ // select
	4170	+ if (addToSelection) {
	4171	+ ui.extendSelection(newPath);
	4172	+ }
	4173	+ else if(changeSelection) {
	4174	+ tree.setSelectionPath(newPath);
	4175	+ }
	4176	+ else {
	4177	+ ui.setLeadSelectionPath(newPath, true);
	4178	+ }
	4179	+ }
	4180	+ }
	4181	+
	4182	+ private void scroll(JTree component, BasicTreeUI ui, int direction,
	4183	+ int amount) {
	4184	+ Rectangle visRect = component.getVisibleRect();
	4185	+ Dimension size = component.getSize();
	4186	+ if (direction == SwingConstants.HORIZONTAL) {
	4187	+ visRect.x += amount;
	4188	+ visRect.x = Math.max(0, visRect.x);
	4189	+ visRect.x = Math.min(Math.max(0, size.width - visRect.width),
	4190	+ visRect.x);
	4191	+ }
	4192	+ else {
	4193	+ visRect.y += amount;
	4194	+ visRect.y = Math.max(0, visRect.y);
	4195	+ visRect.y = Math.min(Math.max(0, size.width - visRect.height),
	4196	+ visRect.y);
	4197	+ }
	4198	+ component.scrollRectToVisible(visRect);
	4199	+ }
	4200	+
	4201	+ private void extendSelection(JTree tree, BasicTreeUI ui) {
	4202	+ if (ui.getRowCount(tree) > 0) {
	4203	+ int lead = ui.getLeadSelectionRow();
	4204	+
	4205	+ if (lead != -1) {
	4206	+ TreePath leadP = ui.getLeadSelectionPath();
	4207	+ TreePath aPath = ui.getAnchorSelectionPath();
	4208	+ int aRow = ui.getRowForPath(tree, aPath);
	4209	+
	4210	+ if(aRow == -1)
	4211	+ aRow = 0;
	4212	+ tree.setSelectionInterval(aRow, lead);
	4213	+ ui.setLeadSelectionPath(leadP);
	4214	+ ui.setAnchorSelectionPath(aPath);
	4215	+ }
	4216	+ }
	4217	+ }
	4218	+
	4219	+ private void selectAll(JTree tree, BasicTreeUI ui, boolean selectAll) {
	4220	+ int rowCount = ui.getRowCount(tree);
	4221	+
	4222	+ if(rowCount > 0) {
	4223	+ if(selectAll) {
	4224	+ if (tree.getSelectionModel().getSelectionMode() ==
	4225	+ TreeSelectionModel.SINGLE_TREE_SELECTION) {
	4226	+
	4227	+ int lead = ui.getLeadSelectionRow();
	4228	+ if (lead != -1) {
	4229	+ tree.setSelectionRow(lead);
	4230	+ } else if (tree.getMinSelectionRow() == -1) {
	4231	+ tree.setSelectionRow(0);
	4232	+ ui.ensureRowsAreVisible(0, 0);
	4233	+ }
	4234	+ return;
	4235	+ }
	4236	+
	4237	+ TreePath lastPath = ui.getLeadSelectionPath();
	4238	+ TreePath aPath = ui.getAnchorSelectionPath();
	4239	+
	4240	+ if(lastPath != null && !tree.isVisible(lastPath)) {
	4241	+ lastPath = null;
	4242	+ }
	4243	+ tree.setSelectionInterval(0, rowCount - 1);
	4244	+ if(lastPath != null) {
	4245	+ ui.setLeadSelectionPath(lastPath);
	4246	+ }
	4247	+ if(aPath != null && tree.isVisible(aPath)) {
	4248	+ ui.setAnchorSelectionPath(aPath);
	4249	+ }
	4250	+ }
	4251	+ else {
	4252	+ TreePath lastPath = ui.getLeadSelectionPath();
	4253	+ TreePath aPath = ui.getAnchorSelectionPath();
	4254	+
	4255	+ tree.clearSelection();
	4256	+ ui.setAnchorSelectionPath(aPath);
	4257	+ ui.setLeadSelectionPath(lastPath);
	4258	+ }
	4259	+ }
	4260	+ }
	4261	+
	4262	+ private void startEditing(JTree tree, BasicTreeUI ui) {
	4263	+ TreePath lead = ui.getLeadSelectionPath();
	4264	+ int editRow = (lead != null) ?
	4265	+ ui.getRowForPath(tree, lead) : -1;
	4266	+
	4267	+ if(editRow != -1) {
	4268	+ tree.startEditingAtPath(lead);
	4269	+ }
	4270	+ }
	4271	+
	4272	+ private void cancelEditing(JTree tree, BasicTreeUI ui) {
	4273	+ tree.cancelEditing();
	4274	+ }
	4275	+
	4276	+ private void toggle(JTree tree, BasicTreeUI ui) {
	4277	+ int selRow = ui.getLeadSelectionRow();
	4278	+
	4279	+ if(selRow != -1 && !ui.isLeaf(selRow)) {
	4280	+ TreePath aPath = ui.getAnchorSelectionPath();
	4281	+ TreePath lPath = ui.getLeadSelectionPath();
	4282	+
	4283	+ ui.toggleExpandState(ui.getPathForRow(tree, selRow));
	4284	+ ui.setAnchorSelectionPath(aPath);
	4285	+ ui.setLeadSelectionPath(lPath);
	4286	+ }
	4287	+ }
	4288	+
	4289	+ private void expand(JTree tree, BasicTreeUI ui) {
	4290	+ int selRow = ui.getLeadSelectionRow();
	4291	+ tree.expandRow(selRow);
	4292	+ }
	4293	+
	4294	+ private void collapse(JTree tree, BasicTreeUI ui) {
	4295	+ int selRow = ui.getLeadSelectionRow();
	4296	+ tree.collapseRow(selRow);
	4297	+ }
	4298	+
	4299	+ private void increment(JTree tree, BasicTreeUI ui, int direction,
	4300	+ boolean addToSelection,
	4301	+ boolean changeSelection) {
	4302	+
	4303	+ // disable moving of lead unless in discontiguous mode
	4304	+ if (!addToSelection && !changeSelection &&
	4305	+ tree.getSelectionModel().getSelectionMode() !=
	4306	+ TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION) {
	4307	+ changeSelection = true;
	4308	+ }
	4309	+
	4310	+ int rowCount;
	4311	+
	4312	+ if(ui.treeSelectionModel != null &&
	4313	+ (rowCount = tree.getRowCount()) > 0) {
	4314	+ int selIndex = ui.getLeadSelectionRow();
	4315	+ int newIndex;
	4316	+
	4317	+ if(selIndex == -1) {
	4318	+ if(direction == 1)
	4319	+ newIndex = 0;
	4320	+ else
	4321	+ newIndex = rowCount - 1;
	4322	+ }
	4323	+ else
	4324	+ /* Aparently people don't like wrapping;( */
	4325	+ newIndex = Math.min(rowCount - 1, Math.max
	4326	+ (0, (selIndex + direction)));
	4327	+ if(addToSelection && ui.treeSelectionModel.
	4328	+ getSelectionMode() != TreeSelectionModel.
	4329	+ SINGLE_TREE_SELECTION) {
	4330	+ ui.extendSelection(tree.getPathForRow(newIndex));
	4331	+ }
	4332	+ else if(changeSelection) {
	4333	+ tree.setSelectionInterval(newIndex, newIndex);
	4334	+ }
	4335	+ else {
	4336	+ ui.setLeadSelectionPath(tree.getPathForRow(newIndex),true);
	4337	+ }
	4338	+ ui.ensureRowsAreVisible(newIndex, newIndex);
	4339	+ ui.lastSelectedRow = newIndex;
	4340	+ }
	4341	+ }
	4342	+
	4343	+ private void traverse(JTree tree, BasicTreeUI ui, int direction,
	4344	+ boolean changeSelection) {
	4345	+
	4346	+ // disable moving of lead unless in discontiguous mode
	4347	+ if (!changeSelection &&
	4348	+ tree.getSelectionModel().getSelectionMode() !=
	4349	+ TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION) {
	4350	+ changeSelection = true;
	4351	+ }
	4352	+
	4353	+ int rowCount;
	4354	+
	4355	+ if((rowCount = tree.getRowCount()) > 0) {
	4356	+ int minSelIndex = ui.getLeadSelectionRow();
	4357	+ int newIndex;
	4358	+
	4359	+ if(minSelIndex == -1)
	4360	+ newIndex = 0;
	4361	+ else {
	4362	+ /* Try and expand the node, otherwise go to next
	4363	+ node. */
	4364	+ if(direction == 1) {
	4365	+ TreePath minSelPath = ui.getPathForRow(tree, minSelIndex);
	4366	+ int childCount = tree.getModel().
	4367	+ getChildCount(minSelPath.getLastPathComponent());
	4368	+ newIndex = -1;
	4369	+ if (!ui.isLeaf(minSelIndex)) {
	4370	+ if (!tree.isExpanded(minSelIndex)) {
	4371	+ ui.toggleExpandState(minSelPath);
	4372	+ }
	4373	+ else if (childCount > 0) {
	4374	+ newIndex = Math.min(minSelIndex + 1, rowCount - 1);
	4375	+ }
	4376	+ }
	4377	+ }
	4378	+ /* Try to collapse node. */
	4379	+ else {
	4380	+ if(!ui.isLeaf(minSelIndex) &&
	4381	+ tree.isExpanded(minSelIndex)) {
	4382	+ ui.toggleExpandState(ui.getPathForRow
	4383	+ (tree, minSelIndex));
	4384	+ newIndex = -1;
	4385	+ }
	4386	+ else {
	4387	+ TreePath path = ui.getPathForRow(tree,
	4388	+ minSelIndex);
	4389	+
	4390	+ if(path != null && path.getPathCount() > 1) {
	4391	+ newIndex = ui.getRowForPath(tree, path.
	4392	+ getParentPath());
	4393	+ }
	4394	+ else
	4395	+ newIndex = -1;
	4396	+ }
	4397	+ }
	4398	+ }
	4399	+ if(newIndex != -1) {
	4400	+ if(changeSelection) {
	4401	+ tree.setSelectionInterval(newIndex, newIndex);
	4402	+ }
	4403	+ else {
	4404	+ ui.setLeadSelectionPath(ui.getPathForRow(
	4405	+ tree, newIndex), true);
	4406	+ }
	4407	+ ui.ensureRowsAreVisible(newIndex, newIndex);
	4408	+ }
	4409	+ }
	4410	+ }
	4411	+
	4412	+ private void moveSelectionToParent(JTree tree, BasicTreeUI ui) {
	4413	+ int selRow = ui.getLeadSelectionRow();
	4414	+ TreePath path = ui.getPathForRow(tree, selRow);
	4415	+ if (path != null && path.getPathCount() > 1) {
	4416	+ int newIndex = ui.getRowForPath(tree, path.getParentPath());
	4417	+ if (newIndex != -1) {
	4418	+ tree.setSelectionInterval(newIndex, newIndex);
	4419	+ ui.ensureRowsAreVisible(newIndex, newIndex);
	4420	+ }
	4421	+ }
	4422	+ }
	4423	+
	4424	+ private void page(JTree tree, BasicTreeUI ui, int direction,
	4425	+ boolean addToSelection, boolean changeSelection) {
	4426	+
	4427	+ // disable moving of lead unless in discontiguous mode
	4428	+ if (!addToSelection && !changeSelection &&
	4429	+ tree.getSelectionModel().getSelectionMode() !=
	4430	+ TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION) {
	4431	+ changeSelection = true;
	4432	+ }
	4433	+
	4434	+ int rowCount;
	4435	+
	4436	+ if((rowCount = ui.getRowCount(tree)) > 0 &&
	4437	+ ui.treeSelectionModel != null) {
	4438	+ Dimension maxSize = tree.getSize();
	4439	+ TreePath lead = ui.getLeadSelectionPath();
	4440	+ TreePath newPath;
	4441	+ Rectangle visRect = tree.getVisibleRect();
	4442	+
	4443	+ if(direction == -1) {
	4444	+ // up.
	4445	+ newPath = ui.getClosestPathForLocation(tree, visRect.x,
	4446	+ visRect.y);
	4447	+ if(newPath.equals(lead)) {
	4448	+ visRect.y = Math.max(0, visRect.y - visRect.height);
	4449	+ newPath = tree.getClosestPathForLocation(visRect.x,
	4450	+ visRect.y);
	4451	+ }
	4452	+ }
	4453	+ else {
	4454	+ // down
	4455	+ visRect.y = Math.min(maxSize.height, visRect.y +
	4456	+ visRect.height - 1);
	4457	+ newPath = tree.getClosestPathForLocation(visRect.x,
	4458	+ visRect.y);
	4459	+ if(newPath.equals(lead)) {
	4460	+ visRect.y = Math.min(maxSize.height, visRect.y +
	4461	+ visRect.height - 1);
	4462	+ newPath = tree.getClosestPathForLocation(visRect.x,
	4463	+ visRect.y);
	4464	+ }
	4465	+ }
	4466	+ Rectangle newRect = ui.getPathBounds(tree, newPath);
	4467	+
	4468	+ newRect.x = visRect.x;
	4469	+ newRect.width = visRect.width;
	4470	+ if(direction == -1) {
	4471	+ newRect.height = visRect.height;
	4472	+ }
	4473	+ else {
	4474	+ newRect.y -= (visRect.height - newRect.height);
	4475	+ newRect.height = visRect.height;
	4476	+ }
	4477	+
	4478	+ if(addToSelection) {
	4479	+ ui.extendSelection(newPath);
	4480	+ }
	4481	+ else if(changeSelection) {
	4482	+ tree.setSelectionPath(newPath);
	4483	+ }
	4484	+ else {
	4485	+ ui.setLeadSelectionPath(newPath, true);
	4486	+ }
	4487	+ tree.scrollRectToVisible(newRect);
	4488	+ }
	4489	+ }
	4490	+
	4491	+ private void home(JTree tree, BasicTreeUI ui, int direction,
	4492	+ boolean addToSelection, boolean changeSelection) {
	4493	+
	4494	+ // disable moving of lead unless in discontiguous mode
	4495	+ if (!addToSelection && !changeSelection &&
	4496	+ tree.getSelectionModel().getSelectionMode() !=
	4497	+ TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION) {
	4498	+ changeSelection = true;
	4499	+ }
	4500	+
	4501	+ int rowCount = ui.getRowCount(tree);
	4502	+
	4503	+ if (rowCount > 0) {
	4504	+ if(direction == -1) {
	4505	+ ui.ensureRowsAreVisible(0, 0);
	4506	+ if (addToSelection) {
	4507	+ TreePath aPath = ui.getAnchorSelectionPath();
	4508	+ int aRow = (aPath == null) ? -1 :
	4509	+ ui.getRowForPath(tree, aPath);
	4510	+
	4511	+ if (aRow == -1) {
	4512	+ tree.setSelectionInterval(0, 0);
	4513	+ }
	4514	+ else {
	4515	+ tree.setSelectionInterval(0, aRow);
	4516	+ ui.setAnchorSelectionPath(aPath);
	4517	+ ui.setLeadSelectionPath(ui.getPathForRow(tree, 0));
	4518	+ }
	4519	+ }
	4520	+ else if(changeSelection) {
	4521	+ tree.setSelectionInterval(0, 0);
	4522	+ }
	4523	+ else {
	4524	+ ui.setLeadSelectionPath(ui.getPathForRow(tree, 0),
	4525	+ true);
	4526	+ }
	4527	+ }
	4528	+ else {
	4529	+ ui.ensureRowsAreVisible(rowCount - 1, rowCount - 1);
	4530	+ if (addToSelection) {
	4531	+ TreePath aPath = ui.getAnchorSelectionPath();
	4532	+ int aRow = (aPath == null) ? -1 :
	4533	+ ui.getRowForPath(tree, aPath);
	4534	+
	4535	+ if (aRow == -1) {
	4536	+ tree.setSelectionInterval(rowCount - 1,
	4537	+ rowCount -1);
	4538	+ }
	4539	+ else {
	4540	+ tree.setSelectionInterval(aRow, rowCount - 1);
	4541	+ ui.setAnchorSelectionPath(aPath);
	4542	+ ui.setLeadSelectionPath(ui.getPathForRow(tree,
	4543	+ rowCount -1));
	4544	+ }
	4545	+ }
	4546	+ else if(changeSelection) {
	4547	+ tree.setSelectionInterval(rowCount - 1, rowCount - 1);
	4548	+ }
	4549	+ else {
	4550	+ ui.setLeadSelectionPath(ui.getPathForRow(tree,
	4551	+ rowCount - 1), true);
	4552	+ }
	4553	+ }
	4554	+ }
	4555	+ }
	4556	+ }
	4557	+} // End of class BasicTreeUI