The Tree Control: Managing Data with JTree
- The Tree Control
- Tree Appearance
- The TreeNode Interface
- The MutableTreeNode Interface
- The DefaultMutableTreeNode Class
- The TreePath Class
- What is a Leaf?
- Tree Expansion and Traversal
- Expanding and Collapsing Nodes under Program Control
- Tree Expansion Events
- Making Nodes Visible
- Controlling Node Expansion and Collapse
- Tree Model Events
- Implementation Plan for the File System Control
- File System Tree Control Implementation
- Using the File System Tree Control
- Custom Tree Rendering and Editing
- Customizing the Default Tree Cell Renderer
- ToolTips and Renderers
- Custom Cell Editors
- Controlling Which Nodes Can Be Edited
- Controlling Editability by Subclassing JTree
- Programmatic Control of Editors
- Editing Trees with Custom User Objects
- The valueForPathChanged Method
- The Tree Implementation
- The Cell Editor
- The Cell Renderer
- Summary
This chapter is from the book
This chapter is from the book
This chapter is from the book
Topics in This Chapter
Creating and Working with Trees
A File System Tree Control
Creating Customized Tree Renderers
Trees and Tooltips
Tree Editing and Customized Editors
This chapter takes an in-depth look at JTree, one of the two complex Swing components that manage collections of related data. JTree is intended to represent information that has a hierarchical structure, of which the prototypical and probably most familiar example might be a file system. You'll see how simple it is to create a basic JTree and look at the ways in which the user can interact with the control to expose and hide data and to have the application operate on the objects that the tree's content represents.
A large part of this chapter is devoted to developing a control that allows you to display the contents of a file system in the form of a tree. While building this control, you'll learn how to use many of the tree's powerful features and, when it's finished, you'll have a component that you can extend or use directly in your own applications.
Finally, JTree allows you to take over the job of rendering individual display elements. The second half of this chapter looks at how this can be achieved and how to allow the user to directly edit the tree's data.
The Tree Control
The JTree component is the first of two controls that you'll meet in this book that are intended to present views of large amounts of data. The difference between JTree and the other control, JTable, is that the former is well-suited to handling data that is hierarchical in nature, while the latter is used with information that can be organized into rows and columns. The most familiar example of a tree control is probably the one in the left pane of Windows Explorer, which shows a directory view of a file system. Later in this section, you'll see how to implement a Java version of this control, which is pictured in Figure 10–1.
){kind=link}
Figure 10–1 A tree showing a file system.
Tree Nodes
All trees start with a root node, which is customarily shown at the top left of the control. By default, when you create a JTree, the root is visible, together with the objects in the level immediately below it. Figure 10–1 shows a view of part of the C: drive of my laptop. In this case, the C:\WINDOWS directory is the root and the directories that reside within it are shown below and to the right of it. The Metal, Motif, and Windows look-and-feel classes all represent each node in the tree using both an icon and a text string. In the case of a file system, the natural way to use the text string is to display the name of the directory that corresponds to the node, while the icon shows either an open or closed folder, depending on whether the contents of the directory are visible or not.
In Java 2 version 1.3, JTree is sensitive to its component orientation so that, in a right-to-left locale, the root node will appear at the top right instead of the top left and the tree expands from right to left. Within each node, the left-to-right order of the expansion handle, the icon and the text is reversed, producing a complete mirror image.
Core Note
The descriptions that are given in this section, unless otherwise qualified, relate to the appearance of the control when the Metal look-and-feel is installed. Installing a different look-and-feel can have a radical effect on the way the tree looks and there can even be variations within a single look-and-feel, as you'll see.
It is simple and routine to change the text string that describes the node. Changing the icon is a topic that will be left until the end of the chapter, so most of the examples will have the usual folder representation, whether or not they represent a file system.
Tree nodes may or may not have other nodes, known as child nodes, linked beneath them. Each node that has child nodes can be considered to be the root of a subtree. For example, in Figure 10–1, the node C:\WINDOWS\SYS-TEM has several child nodes beneath it and can be thought of as the root of the subtree composed of itself and those nodes.
Nodes that are at the same level of the tree are displayed in a vertical line so that, in the case of a file system tree, all of the directories directly below the root are shown one above the other. As you move further to the right on the screen, you are moving further down the file system hierarchy, until you reach a node that doesn't have any nodes attached below it. Such nodes are often called leaf nodes, because they reside at the very end of a sequence of branches (otherwise known as branch nodes) that join nodes to each other. In the case of JTree, however, a node that doesn't have any nodes below it need not be a leaf node, as you'll see. As far as the tree is concerned, whether or not a given node is a leaf matters only so far as it affects the icon used to represent it—depending on the look-and-feel, leaf nodes are typically represented by a folded sheet of paper instead of the folder used to represent the other nodes.
The tree may be configured to join its child nodes with lines to make the hierarchy easier to see. Whether this is possible depends on the look-and-feel in use. When this option is enabled, nodes at the same level are typically connected to each other by a vertical ine as shown in Figure 10–1; each node at that level connects to the vertical line with a small horizontal dashed line. If the node does not have any nodes below it, the horizontal and vertical lines just meet at a point, as is the case with the node C:\WINDOWS\SYS-TEM\DTCLOG in Figure 10–1. At the intersection point for a node that does have other nodes below it in the hierarchy is a small control known as an expansion handle, which may be rendered differently depending on whether these nodes are visible. Assuming these nodes are not visible, clicking on the expansion handle makes the tree expand to the right to show the next level of nodes, and downward to make room for the nodes that have just become visible to be stacked vertically. In Figure 10–1, the node C:\WINDOWS\SYSTEM has been expanded in this way to show its child nodes. Notice that the node C:\WINDOWS\WEB has moved downward to make room for the children of C:\WINDOWS\SYSTEM, and that the expansion handle to the left of the expanded node has been drawn with the "handle" part pointing downwards, whereas the handle for nodes that have not been expanded points to the right. Clicking on the expansion handle when the node is already expanded will cause the child nodes to disappear and the nodes at C:\WINDOWS\WEB and below to move upward to occupy the free space. There is never more than one node on any given row.