Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Swing 1.1
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## javax.swing
Class JTree

    java.lang.Object
      |
      +--java.awt.Component
            |
            +--java.awt.Container
                  |
                  +--javax.swing.JComponent
                        |
                        +--javax.swing.JTree

public class JTree
extends JComponent
implements Scrollable, Accessible

A control that displays a set of hierarchical data as an outline. A specific node can be identified either by a TreePath (an object that encapsulates a node and all of its ancestors), or by its display row, where each row in the display area displays one node.

An expanded node is one displays its children. A collapsed node is one which hides them. A hidden node is one which is under a collapsed parent. A viewable node is under a collapsed parent, but may or may not be displayed. A displayed node is both viewable and in the display area, where it can be seen.

These JTree methods use "visible" to mean "displayed":

- `isRootVisible()`
- `setRootVisible()`
- `scrollPathToVisible()`
- `scrollRowToVisible()`
- `getVisibleRowCount()`
- `setVisibleRowCount()`

These JTree methods use "visible" to mean "viewable" (under an expanded parent):

- `isVisible()`
- `makeVisible()`

If you are interested in knowing when the selection changes implement the TreeSelectionListener interface and add the instance using the method addTreeSelectionListener. valueChanged will be invoked when the selection changes, that is if the user clicks twice on the same node valueChanged will only be invoked once.

If you are interested in knowing either double clicks events or when a user clicks on a node, regardless of whether or not it was selected it is recommended you do the following:

     final JTree tree = ...;

     MouseListener ml = new MouseAdapter() {
         public void mouseClicked(MouseEvent e) {
             int selRow = tree.getRowForLocation(e.getX(), e.getY());
             TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
             if(selRow != -1) {
                 if(e.getClickCount() == 1) {
                     mySingleClick(selRow, selPath);
                 }
                 else if(e.getClickCount() == 2) {
                     myDoubleClick(selRow, selPath);
                 }
             }
         }
     };
     tree.addMouseListener(ml);

NOTE: This example obtains both the path and row, but you only need to get the one you're interested in.

To use JTree to display compound nodes (for example, nodes containing both a graphic icon and text), subclass `TreeCellRenderer` and use `#setTreeCellRenderer` to tell the tree to use it. To edit such nodes, subclass `TreeCellEditor` and use `#setTreeCellEditor`.

Like all JComponent classes, you can use `JComponent.registerKeyboardAction(java.awt.event.ActionListener, java.lang.String, javax.swing.KeyStroke, int)` to associate an `Action` object with a `KeyStroke` and execute the action under specified conditions.

See How to Use Trees in The Java Tutorial for further documentation.

For the keyboard keys used by this component in the standard Look and Feel (L&F) renditions, see the JTree key assignments.

Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. A future release of Swing will provide support for long term persistence.

See Also:
  Serialized Form

Inner Class Summary
`protected class` | `JTree.AccessibleJTree` The class used to obtain the accessible role for this object.
`static class` | `JTree.DynamicUtilTreeNode` DynamicUtilTreeNode can wrap vectors/hashtables/arrays/strings and create the appropriate children tree nodes as necessary.
`protected static class` | `JTree.EmptySelectionModel` EmptySelectionModel is a TreeSelectionModel that does not allow anything to be selected.
`protected class` | `JTree.TreeModelHandler` Listens to the model and updates the expandedState accordingly when nodes are removed, or changed.
`protected class` | `JTree.TreeSelectionRedirector` Handles creating a new TreeSelectionEvent with the JTree as the source and passing it off to all the listeners.

Inner classes inherited from class javax.swing.JComponent
`JComponent.AccessibleJComponent`

Field Summary
`static java.lang.String` | `CELL_EDITOR_PROPERTY` Bound property name for cellEditor.
`static java.lang.String` | `CELL_RENDERER_PROPERTY` Bound property name for cellRenderer.
`protected TreeCellEditor` | `cellEditor` Editor for the entries.
`protected TreeCellRenderer` | `cellRenderer` The cell used to draw nodes.
`protected boolean` | `editable` Is the tree editable? Default is false.
`static java.lang.String` | `EDITABLE_PROPERTY` Bound property name for editable.
`static java.lang.String` | `INVOKES_STOP_CELL_EDITING_PROPERTY` Bound property name for messagesStopCellEditing.
`protected boolean` | `invokesStopCellEditing` If true, when editing is to be stopped by way of selection changing, data in tree changing or other means stopCellEditing is invoked, and changes are saved.
`static java.lang.String` | `LARGE_MODEL_PROPERTY` Bound property name for largeModel.
`protected boolean` | `largeModel` Is this tree a large model? This is a code-optimization setting.
`static java.lang.String` | `ROOT_VISIBLE_PROPERTY` Bound property name for rootVisible.
`protected boolean` | `rootVisible` True if the root node is displayed, false if its children are the highest visible nodes.
`static java.lang.String` | `ROW_HEIGHT_PROPERTY` Bound property name for rowHeight.
`protected int` | `rowHeight` Height to use for each display row.
`static java.lang.String` | `SCROLLS_ON_EXPAND_PROPERTY` Bound property name for scrollsOnExpand.
`protected boolean` | `scrollsOnExpand` If true, when a node is expanded, as many of the descendants are scrolled to be visible.
`static java.lang.String` | `SELECTION_MODEL_PROPERTY` Bound property name for selectionModel.
`protected TreeSelectionModel` | `selectionModel` Models the set of selected nodes in this tree.
`protected JTree.TreeSelectionRedirector` | `selectionRedirector` Creates a new event and passed it off the selectionListeners.
`static java.lang.String` | `SHOWS_ROOT_HANDLES_PROPERTY` Bound property name for showsRootHandles.
`protected boolean` | `showsRootHandles` True if handles are displayed at the topmost level of the tree.
`protected int` | `toggleClickCount` Number of mouse clicks before a node is expanded.
`static java.lang.String` | `TREE_MODEL_PROPERTY` Bound property name for treeModel.
`protected TreeModel` | `treeModel` The model that defines the tree displayed by this object.
`protected TreeModelListener` | `treeModelListener` Updates the expandedState.
`static java.lang.String` | `VISIBLE_ROW_COUNT_PROPERTY` Bound property name for visibleRowCount.
`protected int` | `visibleRowCount` Number of rows to make visible at one time.

Fields inherited from class javax.swing.JComponent
`accessibleContext, listenerList, TOOL_TIP_TEXT_KEY, ui, UNDEFINED_CONDITION, WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, WHEN_FOCUSED, WHEN_IN_FOCUSED_WINDOW`

Fields inherited from class java.awt.Component
`BOTTOM_ALIGNMENT, CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT, TOP_ALIGNMENT`

Constructor Summary
`JTree()` Returns a JTree with a sample model.
`JTree(java.util.Hashtable value)` Returns a JTree created from a Hashtable which does not display the root.
`JTree(java.lang.Object[] value)` Returns a JTree with each element of the specified array as the child of a new root node which is not displayed.
`JTree(TreeModel newModel)` Returns an instance of JTree which displays the root node -- the tree is created using the specified data model.
`JTree(TreeNode root)` Returns a JTree with the specified TreeNode as its root, which displays the root node.
`JTree(TreeNode root, boolean asksAllowsChildren)` Returns a JTree with the specified TreeNode as its root, which displays the root node and which decides whether a node is a leaf node in the specified manner.
`JTree(java.util.Vector value)` Returns a JTree with each element of the specified Vector as the child of a new root node which is not displayed.

Method Summary
`void` | `addSelectionInterval(int index0, int index1)` Adds the paths between index0 and index1, inclusive, to the selection.
`void` | `addSelectionPath(TreePath path)` Adds the node identified by the specified TreePath to the current selection.
`void` | `addSelectionPaths(TreePath[] paths)` Adds each path in the array of paths to the current selection.
`void` | `addSelectionRow(int row)` Adds the path at the specified row to the current selection.
`void` | `addSelectionRows(int[] rows)` Adds the paths at each of the specified rows to the current selection.
`void` | `addTreeExpansionListener(TreeExpansionListener tel)` Adds a listener for TreeExpansion events.
`void` | `addTreeSelectionListener(TreeSelectionListener tsl)` Adds a listener for TreeSelection events.
`void` | `addTreeWillExpandListener(TreeWillExpandListener tel)` Adds a listener for TreeWillExpand events.
`void` | `cancelEditing()` Cancels the current editing session.
`void` | `clearSelection()` Clears the selection.
`protected void` | `clearToggledPaths()` Clears the cache of toggled tree paths.
`void` | `collapsePath(TreePath path)` Ensures that the node identified by the specified path is collapsed and viewable.
`void` | `collapseRow(int row)` Ensures that the node in the specified row is collapsed.
`java.lang.String` | `convertValueToText(java.lang.Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus)` Called by the renderers to convert the specified value to text.
`protected static TreeModel` | `createTreeModel(java.lang.Object value)` Returns a TreeModel wrapping the specified object.
`protected TreeModelListener` | `createTreeModelListener()` Creates and returns an instance of TreeModelHandler.
`void` | `expandPath(TreePath path)` Ensures that the node identified by the specified path is expanded and viewable.
`void` | `expandRow(int row)` Ensures that the node in the specified row is expanded and viewable.
`void` | `fireTreeCollapsed(TreePath path)` Notify all listeners that have registered interest for notification on this event type.
`void` | `fireTreeExpanded(TreePath path)` Notify all listeners that have registered interest for notification on this event type.
`void` | `fireTreeWillCollapse(TreePath path)` Notify all listeners that have registered interest for notification on this event type.
`void` | `fireTreeWillExpand(TreePath path)` Notify all listeners that have registered interest for notification on this event type.
`protected void` | `fireValueChanged(TreeSelectionEvent e)` Notify all listeners that have registered interest for notification on this event type.
`AccessibleContext` | `getAccessibleContext()` Get the AccessibleContext associated with this JComponent
`TreeCellEditor` | `getCellEditor()` Returns the editor used to edit entries in the tree.
`TreeCellRenderer` | `getCellRenderer()` Returns the current TreeCellRenderer that is rendering each cell.
`TreePath` | `getClosestPathForLocation(int x, int y)` Returns the path to the node that is closest to x,y.
`int` | `getClosestRowForLocation(int x, int y)` Returns the row to the node that is closest to x,y.
`protected static TreeModel` | `getDefaultTreeModel()` Creates and returns a sample TreeModel.
`protected java.util.Enumeration` | `getDescendantToggledPaths(TreePath parent)` Returns an Enumeration of TreePaths that have been expanded that are descendants of `parent`.
`TreePath` | `getEditingPath()` Returns the path to the element that is currently being edited.
`java.util.Enumeration` | `getExpandedDescendants(TreePath parent)` Returns an Enumeration of the descendants of `path` that are currently expanded.
`boolean` | `getInvokesStopCellEditing()` Returns the indicator that tells what happens when editing is interrupted.
`java.lang.Object` | `getLastSelectedPathComponent()` Returns the last path component in the first node of the current selection.
`TreePath` | `getLeadSelectionPath()` Returns the path of the last node added to the selection.
`int` | `getLeadSelectionRow()` Returns the row index of the last node added to the selection.
`int` | `getMaxSelectionRow()` Gets the last selected row.
`int` | `getMinSelectionRow()` Gets the first selected row.
`TreeModel` | `getModel()` Returns the TreeModel that is providing the data.
`protected TreePath[]` | `getPathBetweenRows(int index0, int index1)` Returns JTreePath instances representing the path between index0 and index1 (including index1).
`java.awt.Rectangle` | `getPathBounds(TreePath path)` Returns the Rectangle that the specified node will be drawn into.
`TreePath` | `getPathForLocation(int x, int y)` Returns the path for the node at the specified location.
`TreePath` | `getPathForRow(int row)` Returns the path for the specified row.
`java.awt.Dimension` | `getPreferredScrollableViewportSize()` Returns the preferred display size of a JTree.
`java.awt.Rectangle` | `getRowBounds(int row)` Returns the Rectangle that the node at the specified row is drawn in.
`int` | `getRowCount()` Returns the number of rows that are currently being displayed.
`int` | `getRowForLocation(int x, int y)` Returns the row for the specified location.
`int` | `getRowForPath(TreePath path)` Returns the row that displays the node identified by the specified path.
`int` | `getRowHeight()` Returns the height of each row.
`int` | `getScrollableBlockIncrement(java.awt.Rectangle visibleRect, int orientation, int direction)` Returns the amount for a block inrecment, which is the height or width of `visibleRect`, based on `orientation`.
`boolean` | `getScrollableTracksViewportHeight()` Returns false to indicate that the height of the viewport does not determine the height of the table, unless the preferred height of the tree is smaller than the viewports height.
`boolean` | `getScrollableTracksViewportWidth()` Returns false to indicate that the width of the viewport does not determine the width of the table, unless the preferred width of the tree is smaller than the viewports width.
`int` | `getScrollableUnitIncrement(java.awt.Rectangle visibleRect, int orientation, int direction)` Returns the amount to increment when scrolling.
`boolean` | `getScrollsOnExpand()` Returns true if the tree scrolls to show previously hidden children.
`int` | `getSelectionCount()` Returns the number of nodes selected.
`TreeSelectionModel` | `getSelectionModel()` Returns the model for selections.
`TreePath` | `getSelectionPath()` Returns the path to the first selected node.
`TreePath[]` | `getSelectionPaths()` Returns the paths of all selected values.
`int[]` | `getSelectionRows()` Returns all of the currently selected rows.
`boolean` | `getShowsRootHandles()` Returns true if handles for the root nodes are displayed.
`java.lang.String` | `getToolTipText(java.awt.event.MouseEvent event)` Overrides JComponent's getToolTipText method in order to allow renderer's tips to be used if it has text set.
`TreeUI` | `getUI()` Returns the L&F object that renders this component.
`java.lang.String` | `getUIClassID()` Returns the name of the L&F class that renders this component.
`int` | `getVisibleRowCount()` Returns the number of rows that are displayed in the display area.
`boolean` | `hasBeenExpanded(TreePath path)` Returns true if the node identified by the path has ever been expanded.
`boolean` | `isCollapsed(int row)` Returns true if the node at the specified display row is collapsed.
`boolean` | `isCollapsed(TreePath path)` Returns true if the value identified by path is currently collapsed, this will return false if any of the values in path are currently not being displayed.
`boolean` | `isEditable()` Returns true if the tree is editable.
`boolean` | `isEditing()` Returns true if the tree is being edited.
`boolean` | `isExpanded(int row)` Returns true if the node at the specified display row is currently expanded.
`boolean` | `isExpanded(TreePath path)` Returns true if the node identified by the path is currently expanded,
`boolean` | `isFixedRowHeight()` Returns true if the height of each display row is a fixed size.
`boolean` | `isLargeModel()` Returns true if the tree is configured for a large model.
`boolean` | `isPathEditable(TreePath path)` Returns `isEditable`.
`boolean` | `isPathSelected(TreePath path)` Returns true if the item identified by the path is currently selected.
`boolean` | `isRootVisible()` Returns true if the root node of the tree is displayed.
`boolean` | `isRowSelected(int row)` Returns true if the node identitifed by row is selected.
`boolean` | `isSelectionEmpty()` Returns true if the selection is currently empty.
`boolean` | `isVisible(TreePath path)` Returns true if the value identified by path is currently viewable, which means it is either the root or all of its parents are exapnded , Otherwise, this method returns false.
`void` | `makeVisible(TreePath path)` Ensures that the node identified by path is currently viewable.
`protected java.lang.String` | `paramString()` Returns a string representation of this JTree.
`protected void` | `removeDescendantToggledPaths(java.util.Enumeration toRemove)` Removes any descendants of the TreePaths in `toRemove` that have been expanded.
`void` | `removeSelectionInterval(int index0, int index1)` Removes the nodes between index0 and index1, inclusive, from the selection.
`void` | `removeSelectionPath(TreePath path)` Removes the node identified by the specified path from the current selection.
`void` | `removeSelectionPaths(TreePath[] paths)` Removes the nodes identified by the specified paths from the current selection.
`void` | `removeSelectionRow(int row)` Removes the path at the index `row` from the current selection.
`void` | `removeSelectionRows(int[] rows)` Removes the paths that are selected at each of the specified rows.
`void` | `removeTreeExpansionListener(TreeExpansionListener tel)` Removes a listener for TreeExpansion events.
`void` | `removeTreeSelectionListener(TreeSelectionListener tsl)` Removes a TreeSelection listener.
`void` | `removeTreeWillExpandListener(TreeWillExpandListener tel)` Removes a listener for TreeWillExpand events.
`void` | `scrollPathToVisible(TreePath path)` Makes sure all the path components in path are expanded (except for the last path component) and scrolls so that the node identified by the path is displayed.
`void` | `scrollRowToVisible(int row)` Scrolls the item identified by row until it is displayed.
`void` | `setCellEditor(TreeCellEditor cellEditor)` Sets the cell editor.
`void` | `setCellRenderer(TreeCellRenderer x)` Sets the TreeCellRenderer that will be used to draw each cell.
`void` | `setEditable(boolean flag)` Determines whether the tree is editable.
`protected void` | `setExpandedState(TreePath path, boolean state)` Sets the expanded state of the receiver.
`void` | `setInvokesStopCellEditing(boolean newValue)` Determines what happens when editing is interrupted by selecting another node in the tree, a change in the tree's data, or by some other means.
`void` | `setLargeModel(boolean newValue)` Specifies whether the UI should use a large model.
`void` | `setModel(TreeModel newModel)` Sets the TreeModel that will provide the data.
`void` | `setRootVisible(boolean rootVisible)` Determines whether or not the root node from the TreeModel is visible.
`void` | `setRowHeight(int rowHeight)` Sets the height of each cell.
`void` | `setScrollsOnExpand(boolean newValue)` Determines whether or not when a node is expanded, as many of the descendants are scrolled to be inside the viewport as possible.
`void` | `setSelectionInterval(int index0, int index1)` Selects the nodes between index0 and index1, inclusive.
`void` | `setSelectionModel(TreeSelectionModel selectionModel)` Sets the tree's selection model.
`void` | `setSelectionPath(TreePath path)` Selects the node identified by the specified path.
`void` | `setSelectionPaths(TreePath[] paths)` Selects the nodes identified by the specified array of paths.
`void` | `setSelectionRow(int row)` Selects the node at the specified row in the display.
`void` | `setSelectionRows(int[] rows)` Selects the nodes corresponding to each of the specified rows in the display.
`void` | `setShowsRootHandles(boolean newValue)` Determines whether the node handles are to be displayed.
`void` | `setUI(TreeUI ui)` Sets the L&F object that renders this component.
`void` | `setVisibleRowCount(int newCount)` Sets the number of rows that are to be displayed.
`void` | `startEditingAtPath(TreePath path)` Selects the node identified by the specified path and initiates editing.
`boolean` | `stopEditing()` Ends the current editing session.
`void` | `treeDidChange()` Sent when the tree has changed enough that we need to resize the bounds, but not enough that we need to remove the expanded node set (e.g nodes were expanded or collapsed, or nodes were inserted into the tree).
`void` | `updateUI()` Notification from the UIManager that the L&F has changed.

Methods inherited from class javax.swing.JComponent
`addAncestorListener, addNotify, addPropertyChangeListener, addVetoableChangeListener, computeVisibleRect, contains, createToolTip, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, fireVetoableChange, getActionForKeyStroke, getAlignmentX, getAlignmentY, getAutoscrolls, getBorder, getBounds, getClientProperty, getComponentGraphics, getConditionForKeyStroke, getDebugGraphicsOptions, getGraphics, getHeight, getInsets, getInsets, getLocation, getMaximumSize, getMinimumSize, getNextFocusableComponent, getPreferredSize, getRegisteredKeyStrokes, getRootPane, getSize, getToolTipLocation, getToolTipText, getTopLevelAncestor, getVisibleRect, getWidth, getX, getY, grabFocus, hasFocus, isDoubleBuffered, isFocusCycleRoot, isFocusTraversable, isLightweightComponent, isManagingFocus, isOpaque, isOptimizedDrawingEnabled, isPaintingTile, isRequestFocusEnabled, isValidateRoot, paint, paintBorder, paintChildren, paintComponent, paintImmediately, paintImmediately, processComponentKeyEvent, processFocusEvent, processKeyEvent, processMouseMotionEvent, putClientProperty, registerKeyboardAction, registerKeyboardAction, removeAncestorListener, removeNotify, removePropertyChangeListener, removeVetoableChangeListener, repaint, repaint, requestDefaultFocus, requestFocus, resetKeyboardActions, reshape, revalidate, scrollRectToVisible, setAlignmentX, setAlignmentY, setAutoscrolls, setBackground, setBorder, setDebugGraphicsOptions, setDoubleBuffered, setEnabled, setFont, setForeground, setMaximumSize, setMinimumSize, setNextFocusableComponent, setOpaque, setPreferredSize, setRequestFocusEnabled, setToolTipText, setUI, setVisible, unregisterKeyboardAction, update`

Methods inherited from class java.awt.Container
`add, add, add, add, add, addContainerListener, addImpl, countComponents, deliverEvent, doLayout, getComponent, getComponentAt, getComponentAt, getComponentCount, getComponents, getLayout, insets, invalidate, isAncestorOf, layout, list, list, locate, minimumSize, paintComponents, preferredSize, print, printComponents, processContainerEvent, processEvent, remove, remove, removeAll, removeContainerListener, setLayout, validate, validateTree`

Methods inherited from class java.awt.Component
`action, add, addComponentListener, addFocusListener, addKeyListener, addMouseListener, addMouseMotionListener, bounds, checkImage, checkImage, contains, createImage, createImage, disable, disableEvents, dispatchEvent, enable, enable, enableEvents, getBackground, getBounds, getColorModel, getCursor, getFont, getFontMetrics, getForeground, getLocale, getLocation, getLocationOnScreen, getName, getParent, getPeer, getSize, getToolkit, getTreeLock, gotFocus, handleEvent, hide, imageUpdate, inside, isEnabled, isShowing, isValid, isVisible, keyDown, keyUp, list, list, list, location, lostFocus, mouseDown, mouseDrag, mouseEnter, mouseExit, mouseMove, mouseUp, move, nextFocus, paintAll, postEvent, prepareImage, prepareImage, printAll, processComponentEvent, processMouseEvent, remove, removeComponentListener, removeFocusListener, removeKeyListener, removeMouseListener, removeMouseMotionListener, repaint, repaint, repaint, resize, resize, setBounds, setBounds, setCursor, setLocale, setLocation, setLocation, setName, setSize, setSize, show, show, size, toString, transferFocus`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### treeModel

    protected transient TreeModel treeModel

  The model that defines the tree displayed by this object.

### selectionModel

    protected transient TreeSelectionModel selectionModel

  Models the set of selected nodes in this tree.

### rootVisible

    protected boolean rootVisible

  True if the root node is displayed, false if its children are the highest visible nodes.

### cellRenderer

    protected transient TreeCellRenderer cellRenderer

  The cell used to draw nodes. If null, the UI uses a default cellRenderer.

### rowHeight

    protected int rowHeight

  Height to use for each display row. If this is <= 0 the renderer determines the height for each row.

### showsRootHandles

    protected boolean showsRootHandles

  True if handles are displayed at the topmost level of the tree.

  A handle is a small icon that displays adjacent to the node which allows the user to click once to expand or collapse the node. A common interface shows a plus sign (+) for a node which can be expanded and a minus sign (-) for a node which can be collapsed. Handles are always shown for nodes below the topmost level.

  If the `rootVisible` setting specifies that the root node is to be displayed, then that is the only node at the topmost level. If the root node is not displayed, then all of its children are at the topmost level of the tree. Handles are always displayed for nodes other than the topmost.

  If the root node isn't visible, it is generally a good to make this value true. Otherwise, the tree looks exactly like a list, and users may not know that the "list entries" are actually tree nodes.

  See Also:
    `rootVisible`

### selectionRedirector

    protected transient JTree.TreeSelectionRedirector selectionRedirector

  Creates a new event and passed it off the selectionListeners.

### cellEditor

    protected transient TreeCellEditor cellEditor

  Editor for the entries. Default is null (tree is not editable).

### editable

    protected boolean editable

  Is the tree editable? Default is false.

### largeModel

    protected boolean largeModel

  Is this tree a large model? This is a code-optimization setting. A large model can be used when the cell height is the same for all nodes. The UI will then cache very little information and instead continually message the model. Without a large model the UI caches most of the information, resulting in fewer method calls to the model.

  This value is only a suggestion to the UI. Not all UIs will take advantage of it. Default value is false.

### visibleRowCount

    protected int visibleRowCount

  Number of rows to make visible at one time. This value is used for the Scrollable interface. It determines the preferred size of the display area.

### invokesStopCellEditing

    protected boolean invokesStopCellEditing

  If true, when editing is to be stopped by way of selection changing, data in tree changing or other means stopCellEditing is invoked, and changes are saved. If false, cancelCellEditing is invoked, and changes are discarded. Default is false.

### scrollsOnExpand

    protected boolean scrollsOnExpand

  If true, when a node is expanded, as many of the descendants are scrolled to be visible.

### toggleClickCount

    protected int toggleClickCount

  Number of mouse clicks before a node is expanded.

### treeModelListener

    protected transient TreeModelListener treeModelListener

  Updates the expandedState.

### CELL_RENDERER_PROPERTY

    public static final java.lang.String CELL_RENDERER_PROPERTY

  Bound property name for cellRenderer.

### TREE_MODEL_PROPERTY

    public static final java.lang.String TREE_MODEL_PROPERTY

  Bound property name for treeModel.

### ROOT_VISIBLE_PROPERTY

    public static final java.lang.String ROOT_VISIBLE_PROPERTY

  Bound property name for rootVisible.

### SHOWS_ROOT_HANDLES_PROPERTY

    public static final java.lang.String SHOWS_ROOT_HANDLES_PROPERTY

  Bound property name for showsRootHandles.

### ROW_HEIGHT_PROPERTY

    public static final java.lang.String ROW_HEIGHT_PROPERTY

  Bound property name for rowHeight.

### CELL_EDITOR_PROPERTY

    public static final java.lang.String CELL_EDITOR_PROPERTY

  Bound property name for cellEditor.

### EDITABLE_PROPERTY

    public static final java.lang.String EDITABLE_PROPERTY

  Bound property name for editable.

### LARGE_MODEL_PROPERTY

    public static final java.lang.String LARGE_MODEL_PROPERTY

  Bound property name for largeModel.

### SELECTION_MODEL_PROPERTY

    public static final java.lang.String SELECTION_MODEL_PROPERTY

  Bound property name for selectionModel.

### VISIBLE_ROW_COUNT_PROPERTY

    public static final java.lang.String VISIBLE_ROW_COUNT_PROPERTY

  Bound property name for visibleRowCount.

### INVOKES_STOP_CELL_EDITING_PROPERTY

    public static final java.lang.String INVOKES_STOP_CELL_EDITING_PROPERTY

  Bound property name for messagesStopCellEditing.

### SCROLLS_ON_EXPAND_PROPERTY

    public static final java.lang.String SCROLLS_ON_EXPAND_PROPERTY

  Bound property name for scrollsOnExpand.

Constructor Detail

### JTree

    public JTree()

  Returns a JTree with a sample model. The default model used by the tree defines a leaf node as any node without children.
  See Also:
    `DefaultTreeModel.asksAllowsChildren`

### JTree

    public JTree(java.lang.Object[] value)

  Returns a JTree with each element of the specified array as the child of a new root node which is not displayed. By default, the tree defines a leaf node as any node without children.
  Parameters:
    `value` - an array of Objects
  See Also:
    `DefaultTreeModel.asksAllowsChildren`

### JTree

    public JTree(java.util.Vector value)

  Returns a JTree with each element of the specified Vector as the child of a new root node which is not displayed. By default, the tree defines a leaf node as any node without children.
  Parameters:
    `value` - a Vector
  See Also:
    `DefaultTreeModel.asksAllowsChildren`

### JTree

    public JTree(java.util.Hashtable value)

  Returns a JTree created from a Hashtable which does not display the root. Each value-half of the key/value pairs in the HashTable becomes a child of the new root node. By default, the tree defines a leaf node as any node without children.
  Parameters:
    `value` - a Hashtable
  See Also:
    `DefaultTreeModel.asksAllowsChildren`

### JTree

    public JTree(TreeNode root)

  Returns a JTree with the specified TreeNode as its root, which displays the root node. By default, the tree defines a leaf node as any node without children.
  Parameters:
    `root` - a TreeNode object
  See Also:
    `DefaultTreeModel.asksAllowsChildren`

### JTree

    public JTree(TreeNode root,
                 boolean asksAllowsChildren)

  Returns a JTree with the specified TreeNode as its root, which displays the root node and which decides whether a node is a leaf node in the specified manner.
  Parameters:
    `root` - a TreeNode object
    `asksAllowsChildren` - if false, any node without children is a leaf node. If true, only nodes that do not allow children are leaf nodes.
  See Also:
    `DefaultTreeModel.asksAllowsChildren`

### JTree

    public JTree(TreeModel newModel)

  Returns an instance of JTree which displays the root node -- the tree is created using the specified data model.
  Parameters:
    `newModel` - the TreeModel to use as the data model

Method Detail

### getDefaultTreeModel

    protected static TreeModel getDefaultTreeModel()

  Creates and returns a sample TreeModel. Used primarily for beanbuilders. to show something interesting.
  Returns:
    the default TreeModel

### createTreeModel

    protected static TreeModel createTreeModel(java.lang.Object value)

  Returns a TreeModel wrapping the specified object. If the object is:
  - an array of Objects,
  - a Hashtable, or
  - a Vector
  then a new root node is created with each of the incoming objects as children. Otherwise, a new root is created with the specified object as its value.
  Parameters:
    `value` - the Object used as the foundation for the TreeModel
  Returns:
    a TreeModel wrapping the specified object

### getUI

    public TreeUI getUI()

  Returns the L&F object that renders this component.
  Returns:
    the TreeUI object that renders this component

### setUI

    public void setUI(TreeUI ui)

  Sets the L&F object that renders this component.
  Parameters:
    `ui` - the TreeUI L&F object
  See Also:
    `UIDefaults.getUI(javax.swing.JComponent)`

### updateUI

    public void updateUI()

  Notification from the UIManager that the L&F has changed. Replaces the current UI object with the latest version from the UIManager.
  Overrides:
    updateUI in class JComponent
  See Also:
    `JComponent.updateUI()`

### getUIClassID

    public java.lang.String getUIClassID()

  Returns the name of the L&F class that renders this component.
  Returns:
    "TreeUI"
  Overrides:
    getUIClassID in class JComponent
  See Also:
    `JComponent.getUIClassID()`, `UIDefaults.getUI(javax.swing.JComponent)`

### getCellRenderer

    public TreeCellRenderer getCellRenderer()

  Returns the current TreeCellRenderer that is rendering each cell.
  Returns:
    the TreeCellRenderer that is rendering each cell

### setCellRenderer

    public void setCellRenderer(TreeCellRenderer x)

  Sets the TreeCellRenderer that will be used to draw each cell.
  Parameters:
    `x` - the TreeCellRenderer that is to render each cell

### setEditable

    public void setEditable(boolean flag)

  Determines whether the tree is editable. Fires a property change event if the new setting is different from the existing setting.
  Parameters:
    `flag` - a boolean value, true if the tree is editable

### isEditable

    public boolean isEditable()

  Returns true if the tree is editable.
  Returns:
    true if the tree is editable.

### setCellEditor

    public void setCellEditor(TreeCellEditor cellEditor)

  Sets the cell editor. A null value implies that the tree cannot be edited. If this represents a change in the cellEditor, the propertyChange method is invoked on all listeners.
  Parameters:
    `cellEditor` - the TreeCellEditor to use

### getCellEditor

    public TreeCellEditor getCellEditor()

  Returns the editor used to edit entries in the tree.
  Returns:
    the TreeCellEditor in use, or null if the tree cannot be edited

### getModel

    public TreeModel getModel()

  Returns the TreeModel that is providing the data.
  Returns:
    the TreeModel that is providing the data

### setModel

    public void setModel(TreeModel newModel)

  Sets the TreeModel that will provide the data.
  Parameters:
    `newModel` - the TreeModel that is to provide the data

### isRootVisible

    public boolean isRootVisible()

  Returns true if the root node of the tree is displayed.
  Returns:
    true if the root node of the tree is displayed
  See Also:
    `rootVisible`

### setRootVisible

    public void setRootVisible(boolean rootVisible)

  Determines whether or not the root node from the TreeModel is visible.
  Parameters:
    `rootVisible` - true if the root node of the tree is to be displayed
  See Also:
    `rootVisible`

### setShowsRootHandles

    public void setShowsRootHandles(boolean newValue)

  Determines whether the node handles are to be displayed.
  Parameters:
    `newValue` - true if root handles are to be displayed
  See Also:
    `showsRootHandles`

### getShowsRootHandles

    public boolean getShowsRootHandles()

  Returns true if handles for the root nodes are displayed.
  Returns:
    true if root handles are displayed
  See Also:
    `showsRootHandles`

### setRowHeight

    public void setRowHeight(int rowHeight)

  Sets the height of each cell. If the specified value is less than or equal to zero the current cell renderer is queried for each row's height.
  Parameters:
    `rowHeight` - the height of each cell, in pixels

### getRowHeight

    public int getRowHeight()

  Returns the height of each row. If the returned value is less than or equal to 0 the height for each row is determined by the renderer.
  Parameters:
    `the` - height of each cell, in pixels. Zero or negative if the height of each row is determined by the tree cell renderer

### isFixedRowHeight

    public boolean isFixedRowHeight()

  Returns true if the height of each display row is a fixed size.
  Returns:
    true if the height of each row is a fixed size

### setLargeModel

    public void setLargeModel(boolean newValue)

  Specifies whether the UI should use a large model. (Not all UIs will implement this.) Fires a property change for the LARGE_MODEL_PROPERTY.
  Parameters:
    `newValue` - true to suggest a large model to the UI
  See Also:
    `largeModel`

### isLargeModel

    public boolean isLargeModel()

  Returns true if the tree is configured for a large model.
  Returns:
    true if a large model is suggested
  See Also:
    `largeModel`

### setInvokesStopCellEditing

    public void setInvokesStopCellEditing(boolean newValue)

  Determines what happens when editing is interrupted by selecting another node in the tree, a change in the tree's data, or by some other means. Setting this property to `true` causes the changes to be automatically saved when editing is interrupted.

  Fires a property change for the INVOKES_STOP_CELL_EDITING_PROPERTY.

  Parameters:
    `newValue` - true means that stopCellEditing is invoked when editing is interruped, and data is saved. False means that cancelCellEditing is invoked, and changes are lost.

### getInvokesStopCellEditing

    public boolean getInvokesStopCellEditing()

  Returns the indicator that tells what happens when editing is interrupted.
  Returns:
    the indicator that tells what happens when editing is interrupted
  See Also:
    `setInvokesStopCellEditing(boolean)`

### setScrollsOnExpand

    public void setScrollsOnExpand(boolean newValue)

  Determines whether or not when a node is expanded, as many of the descendants are scrolled to be inside the viewport as possible. The default is true.

### getScrollsOnExpand

    public boolean getScrollsOnExpand()

  Returns true if the tree scrolls to show previously hidden children.
  Returns:
    true if when a node is expanded as many of the descendants as possible are scrolled to be visible.

### isPathEditable

    public boolean isPathEditable(TreePath path)

  Returns `isEditable`. This is invoked from the UI before editing begins to insure that the given path can be edited. This is provided as an entry point for subclassers to add filtered editing without having to resort to creating a new editor.
  Returns:
    true if every parent node and the node itself is editabled
  See Also:
    `isEditable()`

### getToolTipText

    public java.lang.String getToolTipText(java.awt.event.MouseEvent event)

  Overrides JComponent's getToolTipText method in order to allow renderer's tips to be used if it has text set.

  NOTE: For JTree to properly display tooltips of its renderers JTree must be a registered component with the ToolTipManager. This can be done by invoking `ToolTipManager.sharedInstance().registerComponent(tree)`. This is not done automaticly!

  Parameters:
    `event` - the MouseEvent that initiated the ToolTip display
  Overrides:
    getToolTipText in class JComponent

### convertValueToText

    public java.lang.String convertValueToText(java.lang.Object value,
                                               boolean selected,
                                               boolean expanded,
                                               boolean leaf,
                                               int row,
                                               boolean hasFocus)

  Called by the renderers to convert the specified value to text. This implementation returns value.toString(), ignoring all other arguments. To control the conversion, subclass this method and use any of the arguments you need.
  Parameters:
    `value` - the Object to convert to text
    `selected` - true if the node is selected
    `expanded` - true if the node is expanded
    `leaf` - true if the node is a leaf node
    `row` - an int specifying the node's display row, where 0 is the first row in the display
    `hasFocus` - true if the node has the focus
  Returns:
    the String representation of the node's value

### getRowCount

    public int getRowCount()

  Returns the number of rows that are currently being displayed.
  Returns:
    the number of rows that are being displayed

### setSelectionPath

    public void setSelectionPath(TreePath path)

  Selects the node identified by the specified path. If any component of the path is hidden (under a collapsed node), it is exposed (made viewable).
  Parameters:
    `path` - the TreePath specifying the node to select

### setSelectionPaths

    public void setSelectionPaths(TreePath[] paths)

  Selects the nodes identified by the specified array of paths. If any component in any of the paths is hidden (under a collapsed node), it is exposed (made viewable).
  Parameters:
    `paths` - an array of TreePath objects that specifies the nodes to select

### setSelectionRow

    public void setSelectionRow(int row)

  Selects the node at the specified row in the display.
  Parameters:
    `row` - the row to select, where 0 is the first row in the display

### setSelectionRows

    public void setSelectionRows(int[] rows)

  Selects the nodes corresponding to each of the specified rows in the display. If a particular element of `rows` is < 0 or >= getRowCount, it will be ignored. If none of the elements in `rows` are valid rows, the selection will be cleared. That is it will be as if `clearSelection` was invoked.
  Parameters:
    `rows` - an array of ints specifying the rows to select, where 0 indicates the first row in the display

### addSelectionPath

    public void addSelectionPath(TreePath path)

  Adds the node identified by the specified TreePath to the current selection. If any component of the path isn't viewable, it is made viewable.
  Parameters:
    `path` - the TreePath to add

### addSelectionPaths

    public void addSelectionPaths(TreePath[] paths)

  Adds each path in the array of paths to the current selection. If any component of any of the paths isn't viewable, it is made viewable.
  Parameters:
    `paths` - an array of TreePath objects that specifies the nodes to add

### addSelectionRow

    public void addSelectionRow(int row)

  Adds the path at the specified row to the current selection.
  Parameters:
    `row` - an int specifying the row of the node to add, where 0 is the first row in the display

### addSelectionRows

    public void addSelectionRows(int[] rows)

  Adds the paths at each of the specified rows to the current selection.
  Parameters:
    `rows` - an array of ints specifying the rows to add, where 0 indicates the first row in the display

### getLastSelectedPathComponent

    public java.lang.Object getLastSelectedPathComponent()

  Returns the last path component in the first node of the current selection.
  Returns:
    the last Object in the first selected node's TreePath, or null if nothing is selected
  See Also:
    `TreePath.getLastPathComponent()`

### getSelectionPath

    public TreePath getSelectionPath()

  Returns the path to the first selected node.
  Returns:
    the TreePath for the first selected node, or null if nothing is currently selected

### getSelectionPaths

    public TreePath[] getSelectionPaths()

  Returns the paths of all selected values.
  Returns:
    an array of TreePath objects indicating the selected nodes, or null if nothing is currently selected.

### getSelectionRows

    public int[] getSelectionRows()

  Returns all of the currently selected rows. This method is simply forwarded to the TreeSelectionModel. If nothing is selected null or an empty array with be returned, based on the TreeSelectionModel implementation.
  Returns:
    an array of ints that identifies all currently selected rows where 0 is the first row in the display

### getSelectionCount

    public int getSelectionCount()

  Returns the number of nodes selected.
  Returns:
    the number of nodes selected

### getMinSelectionRow

    public int getMinSelectionRow()

  Gets the first selected row.
  Returns:
    an int designating the first selected row, where 0 is the first row in the display

### getMaxSelectionRow

    public int getMaxSelectionRow()

  Gets the last selected row.
  Returns:
    an int designating the last selected row, where 0 is the first row in the display

### getLeadSelectionRow

    public int getLeadSelectionRow()

  Returns the row index of the last node added to the selection.
  Returns:
    an int giving the row index of the last node added to the selection, where 0 is the first row in the display

### getLeadSelectionPath

    public TreePath getLeadSelectionPath()

  Returns the path of the last node added to the selection.
  Returns:
    the TreePath of the last node added to the selection.

### isPathSelected

    public boolean isPathSelected(TreePath path)

  Returns true if the item identified by the path is currently selected.
  Parameters:
    `path` - a TreePath identifying a node
  Returns:
    true if the node is selected

### isRowSelected

    public boolean isRowSelected(int row)

  Returns true if the node identitifed by row is selected.
  Parameters:
    `row` - an int specifying a display row, where 0 is the first row in the display
  Returns:
    true if the node is selected

### getExpandedDescendants

    public java.util.Enumeration getExpandedDescendants(TreePath parent)

  Returns an Enumeration of the descendants of `path` that are currently expanded. If `path` is not currently expanded, this will return null. If you expand/collapse nodes while iterating over the returned Enumeration this may not return all the expanded paths, or may return paths that are no longer expanded.

### hasBeenExpanded

    public boolean hasBeenExpanded(TreePath path)

  Returns true if the node identified by the path has ever been expanded.

### isExpanded

    public boolean isExpanded(TreePath path)

  Returns true if the node identified by the path is currently expanded,
  Parameters:
    `path` - the TreePath specifying the node to check
  Returns:
    false if any of the nodes in the node's path are collapsed, true if all nodes in the path are expanded

### isExpanded

    public boolean isExpanded(int row)

  Returns true if the node at the specified display row is currently expanded.
  Parameters:
    `row` - the row to check, where 0 is the first row in the display
  Returns:
    true if the node is currently expanded, otherwise false

### isCollapsed

    public boolean isCollapsed(TreePath path)

  Returns true if the value identified by path is currently collapsed, this will return false if any of the values in path are currently not being displayed.
  Parameters:
    `path` - the TreePath to check
  Returns:
    true if any of the nodes in the node's path are collapsed, false if all nodes in the path are expanded

### isCollapsed

    public boolean isCollapsed(int row)

  Returns true if the node at the specified display row is collapsed.
  Parameters:
    `row` - the row to check, where 0 is the first row in the display
  Returns:
    true if the node is currently collapsed, otherwise false

### makeVisible

    public void makeVisible(TreePath path)

  Ensures that the node identified by path is currently viewable.
  Parameters:
    `path` - the TreePath to make visible

### isVisible

    public boolean isVisible(TreePath path)

  Returns true if the value identified by path is currently viewable, which means it is either the root or all of its parents are exapnded , Otherwise, this method returns false.
  Returns:
    true if the node is viewable, otherwise false

### getPathBounds

    public java.awt.Rectangle getPathBounds(TreePath path)

  Returns the Rectangle that the specified node will be drawn into. Returns null if any component in the path is hidden (under a collapsed parent).

  Note:
  This method returns a valid rectangle, even if the specified node is not currently displayed.

  Parameters:
    `path` - the TreePath identifying the node
  Returns:
    the Rectangle the node is drawn in, or null

### getRowBounds

    public java.awt.Rectangle getRowBounds(int row)

  Returns the Rectangle that the node at the specified row is drawn in.
  Parameters:
    `row` - the row to be drawn, where 0 is the first row in the display
  Returns:
    the Rectangle the node is drawn in

### scrollPathToVisible

    public void scrollPathToVisible(TreePath path)

  Makes sure all the path components in path are expanded (except for the last path component) and scrolls so that the node identified by the path is displayed. Only works when this JTree is contained in a JSrollPane.
  Parameters:
    `path` - the TreePath identifying the node to bring into view

### scrollRowToVisible

    public void scrollRowToVisible(int row)

  Scrolls the item identified by row until it is displayed. The minimum of amount of scrolling necessary to bring the row into view is performed. Only works when this JTree is contained in a JSrollPane.
  Parameters:
    `row` - an int specifying the row to scroll, where 0 is the first row in the display

### getPathForRow

    public TreePath getPathForRow(int row)

  Returns the path for the specified row. If row is not visible null is returned.<-->
  Parameters:
    `row` - an int specifying a row
  Returns:
    the TreePath to the specified node, null if row < 0 or row > getRowCount()

### getRowForPath

    public int getRowForPath(TreePath path)

  Returns the row that displays the node identified by the specified path.
  Parameters:
    `path` - the TreePath identifying a node
  Returns:
    an int specifying the display row, where 0 is the first row in the display, or -1 if any of the elements in path are hidden under a collapsed parent.

### expandPath

    public void expandPath(TreePath path)

  Ensures that the node identified by the specified path is expanded and viewable.
  Parameters:
    `path` - the TreePath identifying a node

### expandRow

    public void expandRow(int row)

  Ensures that the node in the specified row is expanded and viewable.

  If `row` is < 0 or >= getRowCount this will have no effect.

  Parameters:
    `row` - an int specifying a display row, where 0 is the first row in the display

### collapsePath

    public void collapsePath(TreePath path)

  Ensures that the node identified by the specified path is collapsed and viewable.
  Parameters:
    `path` - the TreePath identifying a node

### collapseRow

    public void collapseRow(int row)

  Ensures that the node in the specified row is collapsed.

  If `row` is < 0 or >= getRowCount this will have no effect.

  Parameters:
    `row` - an int specifying a display row, where 0 is the first row in the display

### getPathForLocation

    public TreePath getPathForLocation(int x,
                                       int y)

  Returns the path for the node at the specified location.
  Parameters:
    `x` - an int giving the number of pixels horizontally from the left edge of the display area, minus any left margin
    `y` - an int giving the number of pixels vertically from the top of the display area, minus any top margin
  Returns:
    the TreePath for the node at that location

### getRowForLocation

    public int getRowForLocation(int x,
                                 int y)

  Returns the row for the specified location.
  Parameters:
    `x` - an int giving the number of pixels horizontally from the left edge of the display area, minus any left margin
    `y` - an int giving the number of pixels vertically from the top of the display area, minus any top margin
  Returns:
    the row corresponding to the location, or -1 if the location is not within the bounds of a displayed cell
  See Also:
    `getClosestRowForLocation(int, int)`

### getClosestPathForLocation

    public TreePath getClosestPathForLocation(int x,
                                              int y)

  Returns the path to the node that is closest to x,y. If no nodes are currently viewable, or there is no model, returns null, otherwise it always returns a valid path. To test if the node is exactly at x, y, get the node's bounds and test x, y against that.
  Parameters:
    `x` - an int giving the number of pixels horizontally from the left edge of the display area, minus any left margin
    `y` - an int giving the number of pixels vertically from the top of the display area, minus any top margin
  Returns:
    the TreePath for the node closest to that location, null if nothing is viewable or there is no model
  See Also:
    `getPathForLocation(int, int)`, `getPathBounds(javax.swing.tree.TreePath)`

### getClosestRowForLocation

    public int getClosestRowForLocation(int x,
                                        int y)

  Returns the row to the node that is closest to x,y. If no nodes are viewable or there is no model, returns -1. Otherwise, it always returns a valid row. To test if the returned object is exactly at x, y, get the bounds for the node at the returned row and test x, y against that.
  Parameters:
    `x` - an int giving the number of pixels horizontally from the left edge of the display area, minus any left margin
    `y` - an int giving the number of pixels vertically from the top of the display area, minus any top margin
  Returns:
    the row closest to the location, -1 if nothing is viewable or there is no model
  See Also:
    `getRowForLocation(int, int)`, `getRowBounds(int)`

### isEditing

    public boolean isEditing()

  Returns true if the tree is being edited. The item that is being edited can be obtained using `getSelectionPath`.
  Returns:
    true if the user is currently editing a node
  See Also:
    `getSelectionPath()`

### stopEditing

    public boolean stopEditing()

  Ends the current editing session. (The DefaultTreeCellEditor object saves any edits that are currently in progress on a cell. Other implementations may operate differently.) Has no effect if the tree isn't being edited.

  > Note:
  > To make edit-saves automatic whenever the user changes their position in the tree, use `setInvokesStopCellEditing(boolean)`.

  Returns:
    true if editing was in progress and is now stopped, false if editing was not in progress

### cancelEditing

    public void cancelEditing()

  Cancels the current editing session. Has no effect if the tree isn't being edited.

### startEditingAtPath

    public void startEditingAtPath(TreePath path)

  Selects the node identified by the specified path and initiates editing. The edit-attempt fails if the CellEditor does not allow editing for the specified item.
  Parameters:
    `path` - the TreePath identifying a node

### getEditingPath

    public TreePath getEditingPath()

  Returns the path to the element that is currently being edited.
  Returns:
    the TreePath for the node being edited

### setSelectionModel

    public void setSelectionModel(TreeSelectionModel selectionModel)

  Sets the tree's selection model. When a null value is specified an empty electionModel is used, which does not allow selections.
  Parameters:
    `selectionModel` - the TreeSelectionModel to use, or null to disable selections
  See Also:
    `TreeSelectionModel`

### getSelectionModel

    public TreeSelectionModel getSelectionModel()

  Returns the model for selections. This should always return a non-null value. If you don't want to allow anything to be selected set the selection model to null, which forces an empty selection model to be used.
  Parameters:
    `the` - TreeSelectionModel in use
  See Also:
    `setSelectionModel(javax.swing.tree.TreeSelectionModel)`

### getPathBetweenRows

    protected TreePath[] getPathBetweenRows(int index0,
                                            int index1)

  Returns JTreePath instances representing the path between index0 and index1 (including index1). Returns null if there is no tree.
  Parameters:
    `index0` - an int specifying a display row, where 0 is the first row in the display
    `index0` - an int specifying a second display row
  Returns:
    an array of TreePath objects, one for each node between index0 and index1, inclusive

### setSelectionInterval

    public void setSelectionInterval(int index0,
                                     int index1)

  Selects the nodes between index0 and index1, inclusive.
  Parameters:
    `index0` - an int specifying a display row, where 0 is the first row in the display
    `index0` - an int specifying a second display row

### addSelectionInterval

    public void addSelectionInterval(int index0,
                                     int index1)

  Adds the paths between index0 and index1, inclusive, to the selection.
  Parameters:
    `index0` - an int specifying a display row, where 0 is the first row in the display
    `index0` - an int specifying a second display row

### removeSelectionInterval

    public void removeSelectionInterval(int index0,
                                        int index1)

  Removes the nodes between index0 and index1, inclusive, from the selection.
  Parameters:
    `index0` - an int specifying a display row, where 0 is the first row in the display
    `index0` - an int specifying a second display row

### removeSelectionPath

    public void removeSelectionPath(TreePath path)

  Removes the node identified by the specified path from the current selection.
  Parameters:
    `path` - the TreePath identifying a node

### removeSelectionPaths

    public void removeSelectionPaths(TreePath[] paths)

  Removes the nodes identified by the specified paths from the current selection.
  Parameters:
    `paths` - an array of TreePath objects that specifies the nodes to remove

### removeSelectionRow

    public void removeSelectionRow(int row)

  Removes the path at the index `row` from the current selection.
  Parameters:
    `path` - the TreePath identifying the node to remove

### removeSelectionRows

    public void removeSelectionRows(int[] rows)

  Removes the paths that are selected at each of the specified rows.
  Parameters:
    `row` - an array of ints specifying display rows, where 0 is the first row in the display

### clearSelection

    public void clearSelection()

  Clears the selection.

### isSelectionEmpty

    public boolean isSelectionEmpty()

  Returns true if the selection is currently empty.
  Returns:
    true if the selection is currently empty

### addTreeExpansionListener

    public void addTreeExpansionListener(TreeExpansionListener tel)

  Adds a listener for TreeExpansion events.
  Parameters:
    `tel` - a TreeExpansionListener that will be notified when a tree node is expanded or collapsed (a "negative expansion")

### removeTreeExpansionListener

    public void removeTreeExpansionListener(TreeExpansionListener tel)

  Removes a listener for TreeExpansion events.
  Parameters:
    `tel` - the TreeExpansionListener to remove

### addTreeWillExpandListener

    public void addTreeWillExpandListener(TreeWillExpandListener tel)

  Adds a listener for TreeWillExpand events.
  Parameters:
    `tel` - a TreeWillExpandListener that will be notified when a tree node will be expanded or collapsed (a "negative expansion")

### removeTreeWillExpandListener

    public void removeTreeWillExpandListener(TreeWillExpandListener tel)

  Removes a listener for TreeWillExpand events.
  Parameters:
    `tel` - the TreeWillExpandListener to remove

### fireTreeExpanded

    public void fireTreeExpanded(TreePath path)

  Notify all listeners that have registered interest for notification on this event type. The event instance is lazily created using the parameters passed into the fire method.
  Parameters:
    `path` - the TreePath indicating the node that was expanded
  See Also:
    `EventListenerList`

### fireTreeCollapsed

    public void fireTreeCollapsed(TreePath path)

  Notify all listeners that have registered interest for notification on this event type. The event instance is lazily created using the parameters passed into the fire method.
  Parameters:
    `path` - the TreePath indicating the node that was collapsed
  See Also:
    `EventListenerList`

### fireTreeWillExpand

    public void fireTreeWillExpand(TreePath path)
                            throws ExpandVetoException

  Notify all listeners that have registered interest for notification on this event type. The event instance is lazily created using the parameters passed into the fire method.
  Parameters:
    `path` - the TreePath indicating the node that was expanded
  See Also:
    `EventListenerList`

### fireTreeWillCollapse

    public void fireTreeWillCollapse(TreePath path)
                              throws ExpandVetoException

  Notify all listeners that have registered interest for notification on this event type. The event instance is lazily created using the parameters passed into the fire method.
  Parameters:
    `path` - the TreePath indicating the node that was expanded
  See Also:
    `EventListenerList`

### addTreeSelectionListener

    public void addTreeSelectionListener(TreeSelectionListener tsl)

  Adds a listener for TreeSelection events.
  Parameters:
    `tsl` - the TreeSelectionListener that will be notified when a node is selected or deselected (a "negative selection")

### removeTreeSelectionListener

    public void removeTreeSelectionListener(TreeSelectionListener tsl)

  Removes a TreeSelection listener.
  Parameters:
    `tsl` - the TreeSelectionListener to remove

### fireValueChanged

    protected void fireValueChanged(TreeSelectionEvent e)

  Notify all listeners that have registered interest for notification on this event type. The event instance is lazily created using the parameters passed into the fire method.
  Parameters:
    `e` - the TreeSelectionEvent generated by the TreeSelectionModel when a node is selected or deselected
  See Also:
    `EventListenerList`

### treeDidChange

    public void treeDidChange()

  Sent when the tree has changed enough that we need to resize the bounds, but not enough that we need to remove the expanded node set (e.g nodes were expanded or collapsed, or nodes were inserted into the tree). You should never have to invoke this, the UI will invoke this as it needs to.

### setVisibleRowCount

    public void setVisibleRowCount(int newCount)

  Sets the number of rows that are to be displayed. This will only work if the reciever is contained in a JScrollPane, and will adjust the preferred size and size of that scrollpane.
  Parameters:
    `newCount` - the number of rows to display

### getVisibleRowCount

    public int getVisibleRowCount()

  Returns the number of rows that are displayed in the display area.
  Returns:
    the number of rows displayed

### getPreferredScrollableViewportSize

    public java.awt.Dimension getPreferredScrollableViewportSize()

  Returns the preferred display size of a JTree. The height is determined from `getVisibleRowCount` and the width is the current preferred width.
  Specified by:
    getPreferredScrollableViewportSize in interface Scrollable
  Returns:
    a Dimension object containing the preferred size

### getScrollableUnitIncrement

    public int getScrollableUnitIncrement(java.awt.Rectangle visibleRect,
                                          int orientation,
                                          int direction)

  Returns the amount to increment when scrolling. The amount is the height of the first displayed row that isn't completely in view or, if it is totally displayed, the height of the next row in the scrolling direction.
  Specified by:
    getScrollableUnitIncrement in interface Scrollable
  Parameters:
    `visibleRect` - The view area visible within the viewport
    `orientation` - Either SwingConstants.VERTICAL or SwingConstants.HORIZONTAL.
    `direction` - Less than zero to scroll up/left, greater than zero for down/right.
  Returns:
    The "unit" increment for scrolling in the specified direction
  See Also:
    `JScrollBar.setUnitIncrement(int)`

### getScrollableBlockIncrement

    public int getScrollableBlockIncrement(java.awt.Rectangle visibleRect,
                                           int orientation,
                                           int direction)

  Returns the amount for a block inrecment, which is the height or width of `visibleRect`, based on `orientation`.
  Specified by:
    getScrollableBlockIncrement in interface Scrollable
  Parameters:
    `visibleRect` - The view area visible within the viewport
    `orientation` - Either SwingConstants.VERTICAL or SwingConstants.HORIZONTAL.
    `direction` - Less than zero to scroll up/left, greater than zero for down/right.
  Returns:
    The "block" increment for scrolling in the specified direction.
  See Also:
    `JScrollBar.setBlockIncrement(int)`

### getScrollableTracksViewportWidth

    public boolean getScrollableTracksViewportWidth()

  Returns false to indicate that the width of the viewport does not determine the width of the table, unless the preferred width of the tree is smaller than the viewports width. In other words: ensure that the tree is never smaller than its viewport.
  Specified by:
    getScrollableTracksViewportWidth in interface Scrollable
  Returns:
    false
  See Also:
    `Scrollable.getScrollableTracksViewportWidth()`

### getScrollableTracksViewportHeight

    public boolean getScrollableTracksViewportHeight()

  Returns false to indicate that the height of the viewport does not determine the height of the table, unless the preferred height of the tree is smaller than the viewports height. In other words: ensure that the tree is never smaller than its viewport.
  Specified by:
    getScrollableTracksViewportHeight in interface Scrollable
  Returns:
    false
  See Also:
    `Scrollable.getScrollableTracksViewportHeight()`

### setExpandedState

    protected void setExpandedState(TreePath path,
                                    boolean state)

  Sets the expanded state of the receiver. If `state` is true, all parents of `path` and path are marked as expanded. If `state` is false, all parents of `path` are marked EXPANDED, but `path` itself is marked collapsed.

  This will fail if a TreeWillExpandListener vetos it.

### getDescendantToggledPaths

    protected java.util.Enumeration getDescendantToggledPaths(TreePath parent)

  Returns an Enumeration of TreePaths that have been expanded that are descendants of `parent`.

### removeDescendantToggledPaths

    protected void removeDescendantToggledPaths(java.util.Enumeration toRemove)

  Removes any descendants of the TreePaths in `toRemove` that have been expanded.

### clearToggledPaths

    protected void clearToggledPaths()

  Clears the cache of toggled tree paths. This does NOT send out any TreeExpansionListener events.

### createTreeModelListener

    protected TreeModelListener createTreeModelListener()

  Creates and returns an instance of TreeModelHandler. The returned object is responsible for updating the expanded state when the TreeModel changes.

### paramString

    protected java.lang.String paramString()

  Returns a string representation of this JTree. This method is intended to be used only for debugging purposes, and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be `null`.

  Overriding paramString() to provide information about the specific new aspects of the JFC components.

  Returns:
    a string representation of this JTree.
  Overrides:
    paramString in class JComponent

### getAccessibleContext

    public AccessibleContext getAccessibleContext()

  Get the AccessibleContext associated with this JComponent
  Specified by:
    getAccessibleContext in interface Accessible
  Returns:
    the AccessibleContext of this JComponent
  Overrides:
    getAccessibleContext in class JComponent

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Swing 1.1
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Submit a bug or feature
Java is a trademark or registered trademark of Sun Microsystems, Inc. in the US and other countries.
Copyright 1993-1998 Sun Microsystems, Inc. 901 San Antonio Road,
Palo Alto, California, 94303, U.S.A. All Rights Reserved.