In this chapter:

• JTree
• Basic JTree example
• Directories tree: part I - Dynamic node retrieval
• Directories tree: part II - Popup menus and programmatic navigation
• Directories tree: part III - Tooltips
• JTree and XML documents
• Custom editors and renderers

The tree is a very important and heavily used data structure throughout computer science (e.g. compiler design, graphics, artificial intelligence, etc.). This data structure consists of a logically arranged set of nodes, which are containers for data. Each tree contains one root node, which serves as that tree’s top-most node. Any node can have an arbitrarty number of child (descendant) nodes. In this way, each descendant node is the root of a subtree.

Each node is connected by an edge. An edge signifies the relationship between two nodes. A node’s direct predecessor is called its parent, and all predecesors (above and including the parent) are called its ancestors. A node that has no descendants is called a leaf node. All direct child nodes of a given node are siblings.

A path from one node to another is a sequence of nodes with edges from one node to the next. The level of a node is the number of nodes visited in the path between the root and that node. The height of a tree is its largest level--the length of its longest path.

It is essential that we be able to systematically visit each and every node of a tree. (The term ‘visit’ here refers to performing some task before moving on.) There are three common traversal orders used for performing such an operation: preoder, inorder, and postorder. Each is recursive and can be summarized as follows:

A TreePath represents the path to a node as a set of nodes starting from the root. (Recall that nodes are Objects, not necessarily TreeNodes.) TreePaths are read-only objects and provide functionality for comparison between other TreePaths. The getLastPathComponent() gives us the final node in the path, equals() compares two paths, getPathCount() ! gives the number of nodes in a path, isDescendant() checks whether a given path is a descendant of (i.e. is completely contained in) a given path, and pathByAddingChild() returns a new TreePath instance resulting from adding the given node to the path. See the example of section 17.2 for more about working with TreePaths.

This interface describes the component used to render a cell of the tree. The getTreeCellRendererComponent() method is called to return the component to render corresponding to a given cell and that cell’s selection, focus, and tree state (i.e. whether it is a leaf or a parent, and whether it is expanded or collapsed). This works similar to custom cell rendering in JList and JComboBox (see chapters 9 and 10). To assign a renderer to JTree we use its setCellRenderer() method. Recall that renderer components are not at all interactive and simply act as "rubber! stamps" for display purposes only.

DefaultTreeCellRenderer is the default concrete implementation of the TreeCellRenderer interface. It extends JLabel and maintains several properties used to render a tree cell based on its current state, as described above. These properties include Icons used to represent the node in any of its possible states (leaf, parent collapsed, parent expanded) and background and foreground colors to use based on whether the node is selected or unselected. Each of these properties is self-explanitory and typical get/set accessors are provided.

In chapter 2 we discussed the painting and validation process in detail, but we purposely avoided the discussion of how renderers actually work behind the scenes because they are only used be a few specific components. The component returned by a renderer’s getXXRendererComponent() method is placed in an instance of CellRenderPane. The CellRenderPane is used to act as the component’s parent so that any validation and repaint requests that occur do not propogate up the ancestry tree of the container it resides in. It does this by overriding the paint() and invalidate() with empty implementations.

Several paintComponent() methods are provided to render a given component onto a given graphical context. These are used by the JList, JTree, and JTable UI delegates to actually paint each cell, which results in the "rubber stamp" behavior we have referred to.

Unlike renderers, cell editors for JTree and JTable are defined from a generic interface. This interface is CellEditor and it declares methods for controlling when editing will start and stop, retrieving a new value resulting from an edit, and whether or not an edit request changes the component’s current selection.

This interface also declares methods for adding and removing CellEditorListeners which should recieve ChangeEvents whenever an edit is stopped or canceled. So stopCellEditing() and cancelCellEditing() are responsible for firing ChangeEvents to any registered listeners.

Normally cell editing starts with the user clicking on a cell a specified number of times which can be defined in the isCellEditable() method. The component containing the cell then replaces the current renderer pane with its editor component (JTree’s editor component is that returned by TreeCellEditor’s getTreeCellEditorComponent() method). If shouldSelectCell() returns true then the component’s selection state changes to only contain the cell being edited. A new value is entered using the editor and an appropriate action takes place which invokes either stopCellEditi! ng() or cancelCellEditing(). Finally, if the edit was stopped and not canceled, the component retrieves the new value from the editor, using getCellEditorValue(), and overwrites the old value. The editor is then replaced by the renderer pane which is updated to reflect the new data value.

This interface extends CellEditor and describes the behavior of a component to be used in editing the cells of a tree. Method getTreeCellEditorComponent() is called prior to the editing of a new cell to set the initial data for the component it returns as the editor, based on a given cell and that cell’s selection, focus, and its expanded/collapsed states. We can use any component we like as an editor. To assign a TreeCellEditor to JTree we use its setCellEditor() method.

This is a concrete implementation of the TreeCellEditor interface as well as the TableCellEditor interface (see 18.1.11). This editor allows the use of JTextField, JComboBox, or JCheckBox components to edit data. It defines a protected inner class called EditorDelegate which is responsible for returning the current value of the editor component in use when the getCellEditorValue() method is invoked. DefaultCellEditor is limited to three constructors for creating a JTextField, JComboBox, or a JCheckBox editor.

DefaultCellEditor maintains an int property called clickCountToStart which specifies how many mouse click events should trigger an edit. By default this is 2 for JTextFields and 1 for JComboBox and JCheckBox editors. As expected ChangeEvents are fired when stopCellEditing() and cancelCellEditing() are invoked.

DefaultTreeCellEditor extends DefaultCellEditor, and is the default concrete implementation of the TreeCellEditor interface. It uses a JTextField for editing a node's data (an instance of DefaultTreeCellEditor.DefaultTextField). stopCellEditing() is called when ENTER is pressed in this text field.

An instance of DefaultTreeCellRenderer is needed to construct this editor, allowing renderer icons to remain visible while editing (accomplished by embedding the editor in an instance of DefaultTreeCellEditor.EditorContainer), and fires ChangeEvents when editing begins and ends. As expected, we can add CellEditorListeners to intercept and process these events.

By default, editing starts (if it is enabled) when a cell is triple-clicked or a pause of 1200ms occurs between two single mouse clicks (the latter is accomplished using an internal Timer). We can set the click count requirement using the setClickCountToStart() method, or check for it directly by overriding isCellEditable().

RowMapper describes a single method, getRowsForPaths(), which maps an array of tree paths to array of tree rows. A tree row corrsponds to a tree cell, and as we discussed, these are organized similar to JList cells. JTree selections are based on rows and tree paths, and we can choose which to deal with depending on the needs of our application. We aren’t expected to implement this interface unless we decide to build our own JTree UI delegate.

The TreeSelectionModel interface describes a base interface for a tree's selection model. Three modes of selection are supported, similar to JList (see chapter 10), and implementations allow setting this mode through the setSelectionMode() method: SINGLE_TREE_SELECTION, DISCONTIGUOUS_TREE_SELECTION, and CONTIGUOUS_TREE_SELECTION. Implementations are expected to maintain a RowMapper instance. The getSelectionPath() and getSelectionPaths() methods are intended to return a TreePath and an array of TreePaths respectively, allowing access to the currently selected paths. The getSelectionRows() method should return an int array representing the indices of all rows currently selected. The lead selection refers to the most recently added path to the current selection. Whenever the selection changes, implementations of this interface should fire TreeSelectionEvents. Appropriately, add/remove TreeSelectionListener methods are also declared. All other metho! ds! are, for the most part, self explanitory (see API docs). The tree selection model can be retrieved using JTree‘s getSelectionModel() method.

DefaultTreeSelectionModel is the default concrete implementation of the TreeSelectionModel interface. This model supports TreeSelectionListener notification when changes are made to a tree's path selection. Several methods are defined for, among other things, modifying a selection, testing if it can be modified, and firing TreeSelectionEvents when a modification occurs.

The TreeModelListener interface describes a listener which receives notifications about changes in a tree's model. TreeModelEvents are normally fired from a TreeModel when nodes are modified, added, or removed. We can register/unregsiter a TreeModelListener with a JTree’s model using TreeModel’s addTreeModelListener() and removeTreeModelListener()! methods respectively.

The TreeSelectionListener interface describes a listener which receives notifications about changes in a tree's selection. It declares only one method, valueChanged(), accepting a TreeSelectionEvent. These events are normally fired whenever a tree’s selection changes. We can register/unregister a TreeSelectionListener with a tree’s selection model using JTree’s addTreeSelectionListener() and removeTreeSelectionListener() methods respectively.

The TreeExpansionListener interface describes a listener which receives notifications about tree expansions and collapses. Implementations must define treeExpanded() and treeCollapsed() events, which take a TreeExpansionEvent as parameter. We can register/unregister a TreeExpansionListener with a tree using JTree’s addTreeExpansionListener() and removeTreeExpansionListener() methods respectively.

myJTree.putClientProperty("JTree.lineStyle", "Angled");

We can also set this property such that each tree cell is separated by a horizontal line:

myJTree.putClientProperty("JTree.lineStyle", "Horizontal");

To disable the line style:

myJTree.putClientProperty("JTree.lineStyle", "None");

UIManager.put("Tree.hash",

new ColorUIResource(Color.lightGray));

To modify the open node icons used by all trees when a node’s children are shown:

UIManager.put("Tree.openIcon", new IconUIResource(

new ImageIcon("myOpenIcon.gif")));

As we know very well by now, JTree is suitable for the display and editing of a hierarchical set of objects. To demonstrate this in an introductory-level example, we will consider a set of Object Identifiers (OIDs) used in the Simple Network Management Protocol (SNMP). In the following example, we show how to build a simple JTree displaying the initial portion of the OID tree.

import java.awt.*;
import java.awt.event.*;
import java.util.*;

import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;

public class Tree1 extends JFrame 
{
	protected JTree  m_tree = null;
	protected DefaultTreeModel m_model = null;
	protected JTextField m_display;

	public Tree1()
	{
		super("Sample Tree [OID]");
		setSize(400, 300);

        Object[] nodes = new Object[5];
		DefaultMutableTreeNode top = new DefaultMutableTreeNode(
			new OidNode(1, "ISO"));
		DefaultMutableTreeNode parent = top;
		nodes[0] = top;

		DefaultMutableTreeNode node = new DefaultMutableTreeNode(
			new OidNode(0, "standard"));
		parent.add(node);
		node = new DefaultMutableTreeNode(new OidNode(2, 
			"member-body"));
		parent.add(node);
		node = new DefaultMutableTreeNode(new OidNode(3, "org"));
		parent.add(node);
		parent = node;
		nodes[1] = parent;

		node = new DefaultMutableTreeNode(new OidNode(6, "dod"));
		parent.add(node);
		parent = node;
		nodes[2] = parent;

		node = new DefaultMutableTreeNode(new OidNode(1, 
			"internet"));
		parent.add(node);
		parent = node;
		nodes[3] = parent;

		node = new DefaultMutableTreeNode(new OidNode(1, 
			"directory"));
		parent.add(node);
		node = new DefaultMutableTreeNode(new OidNode(2, 
			"mgmt"));
		parent.add(node);
		nodes[4] = node;
		node.add(new DefaultMutableTreeNode(new OidNode(1, 
			"mib-2")));
		node = new DefaultMutableTreeNode(new OidNode(3, 
			"experimental"));
		parent.add(node);
		node = new DefaultMutableTreeNode(new OidNode(4, 
			"private"));
		node.add(new DefaultMutableTreeNode(new OidNode(1, 
			"enterprises")));
		parent.add(node);
		node = new DefaultMutableTreeNode(new OidNode(5, 
			"security"));
		parent.add(node);
		node = new DefaultMutableTreeNode(new OidNode(6, 
			"snmpV2"));
		parent.add(node);
		node = new DefaultMutableTreeNode(new OidNode(7, 
			"mail"));
		parent.add(node);

		m_model = new DefaultTreeModel(top);
		m_tree = new JTree(m_model);

		DefaultTreeCellRenderer renderer = new 
			DefaultTreeCellRenderer();
		renderer.setOpenIcon(new ImageIcon("opened.gif"));
		renderer.setClosedIcon(new ImageIcon("closed.gif"));
		renderer.setLeafIcon(new ImageIcon("leaf.gif"));
		m_tree.setCellRenderer(renderer);

		m_tree.setShowsRootHandles(true); 
		m_tree.setEditable(false);
		TreePath path = new TreePath(nodes);
		m_tree.setSelectionPath(path);

		m_tree.addTreeSelectionListener(new 
			OidSelectionListener());

		JScrollPane s = new JScrollPane();
		s.getViewport().add(m_tree);
		getContentPane().add(s, BorderLayout.CENTER);

		m_display = new JTextField();
		m_display.setEditable(false);
		getContentPane().add(m_display, BorderLayout.SOUTH);

		WindowListener wndCloser = new WindowAdapter()
		{
			public void windowClosing(WindowEvent e) 
			{
				System.exit(0);
			}
		};
		addWindowListener(wndCloser);
		
		setVisible(true);
	}

	public static void main(String argv[]) 
	{
		new Tree1();
	}

	class OidSelectionListener implements TreeSelectionListener 
	{
		public void valueChanged(TreeSelectionEvent e)
		{
			TreePath path = e.getPath();
			Object[] nodes = path.getPath();
			String oid = "";
			for (int k=0; k < nodes.length; k++)
			{
				DefaultMutableTreeNode node = 
					(DefaultMutableTreeNode)nodes[k];
				OidNode nd = (OidNode)node.getUserObject();
				oid += "."+nd.getId();
			}
			m_display.setText(oid);
		}
	}
}

class OidNode
{
	protected int    m_id;
	protected String m_name;

	public OidNode(int id, String name)
	{
		m_id = id;
		m_name = name;
	}

	public int getId() 
	{ 
		return m_id;
	}

	public String getName() 
	{ 
		return m_name;
	}

	public String toString() 
	{ 
		return m_name;
	}
}

This class extends JFrame to implement the frame container for our JTree. Three instance variables are declared:

The constructor first initializes the parent frame object. Then a number of DefaultMutableTreeNodes encapsulating OidNodes (see below) are created. These objects form a hierarchical structure with DefaultMutableTreeNode top at the root. Note that during the construction of these nodes, the Object[] nodes array is populated with a path of nodes leading to the "mgmt" node.

DefaultTreeModel m_model is created with the top node as the root, and JTree m_tree is created to manage this model. Then some specific options are set for this tree component. First, we replace the default icons for opened, closed and leaf icons with our custom icons, using a DefaultTreeCellRenderer as our tree’s cell renderer:

        DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
        renderer.setOpenIcon(new ImageIcon("opened.gif"));
        renderer.setClosedIcon(new ImageIcon("closed.gif"));
        renderer.setLeafIcon(new ImageIcon("leaf.gif"));
        m_tree.setCellRenderer(renderer);

Then we set the showsRootHandles property to true, the Editable property to false, and select the path determined by the nodes array formed above:

        m_tree.setShowsRootHandles(true);
        m_tree.setEditable(false);
        TreePath path = new TreePath(nodes);
        m_tree.setSelectionPath(path);

Our custom OidSelectionListener (see below) TreeSelectionListener is added to the tree to receive notification when our tree’s selection changes.

A JScrollPane is created to provide scrolling capabilities, and our tree is added to its JViewport. This JScrollPane is then added to the center of our frame. A non-editable JTextField m_display is created and added to the south region of our frame’s content pane to display the currently selected OID.

This inner class implements the TreeSelectionListener interface to receive notifications about when our tree’s selection changes. Our valueChanged() implementation extracts TreePath for the current selection and visits each node, starting from the root, accumulating the OID in .N.N.N form as it goes (where N is a digit). This method ends by displaying the resulting OID in our text field status bar.

This class encapsulates a single object identifier as a number and a String name describing the associated object. Both values are passed to the OidNode constructor. Instances of this class are passed directly to the DefaultMutableTreeNode constructor to act as a node’s user object. The overridden toString() method is used to return the name String so that our tree’s cell renderer will display each node correctly. Recall that, by default, DefaultTreeCellRenderer will call a node’s user object! toString() method for rendering.

The example in this section uses the JTree component to display and navigate through a tree of directories located on drives accessible from the user’s machine. We will show how to build a custom tree cell renderer as well as create and insert tree nodes dynamically.

The main problem encountered in building this application is the fact that it is not practical to read all directories for all accessible drives before displaying our tree component. This would take an extremely long time. To deal with this issue we initially display only the roots (i.e. disk partitions or network drives), and then dynamically expand the tree as the user navigates through it. This requires the use of threads and SwingUtilities.invokeLater() for thread-safe updating of our tree.

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;

public class FileTree1 extends JFrame 
{
	public static final ImageIcon ICON_COMPUTER = 
		new ImageIcon("computer.gif");
	public static final ImageIcon ICON_DISK = 
		new ImageIcon("disk.gif");
	public static final ImageIcon ICON_FOLDER = 
		new ImageIcon("folder.gif");
	public static final ImageIcon ICON_EXPANDEDFOLDER = 
		new ImageIcon("expandedfolder.gif");

	protected JTree  m_tree;
	protected DefaultTreeModel m_model;
	protected JTextField m_display;

	public FileTree1()
	{
		super("Directories Tree");
		setSize(400, 300);

		DefaultMutableTreeNode top = new DefaultMutableTreeNode(
			new IconData(ICON_COMPUTER, null, "Computer"));

		DefaultMutableTreeNode node;
		File[] roots = File.listRoots();
		for (int k=0; k < roots.length; k++)
		{
			node = new DefaultMutableTreeNode(new IconData(ICON_DISK, 
				null, new FileNode(roots[k])));
			top.add(node);
                        node.add( new DefaultMutableTreeNode(new Boolean(true)));
		}

		m_model = new DefaultTreeModel(top);
		m_tree = new JTree(m_model);

                m_tree.putClientProperty("JTree.lineStyle", "Angled");

		TreeCellRenderer renderer = new	IconCellRenderer();
		m_tree.setCellRenderer(renderer);

		m_tree.addTreeExpansionListener(new DirExpansionListener());

		m_tree.addTreeSelectionListener(new DirSelectionListener());

		m_tree.getSelectionModel().setSelectionMode(
			TreeSelectionModel.SINGLE_TREE_SELECTION); 
		m_tree.setShowsRootHandles(true); 
		m_tree.setEditable(false);

		JScrollPane s = new JScrollPane();
		s.getViewport().add(m_tree);
		getContentPane().add(s, BorderLayout.CENTER);

		m_display = new JTextField();
		m_display.setEditable(false);
		getContentPane().add(m_display, BorderLayout.NORTH);

		WindowListener wndCloser = new WindowAdapter()
		{
			public void windowClosing(WindowEvent e) 
			{
				System.exit(0);
			}
		};
		addWindowListener(wndCloser);
		
		setVisible(true);
	}

	DefaultMutableTreeNode getTreeNode(TreePath path)
	{
		return (DefaultMutableTreeNode)(path.getLastPathComponent());
	}

	FileNode getFileNode(DefaultMutableTreeNode node)
	{
		if (node == null)
			return null;
		Object obj = node.getUserObject();
		if (obj instanceof IconData)
		  obj = ((IconData)obj).getObject();
		if (obj instanceof FileNode)
		  return (FileNode)obj;
		else
		  return null;
	}

    // Make sure expansion is threaded and updating the tree model
    // only occurs within the event dispatching thread.
    class DirExpansionListener implements TreeExpansionListener
    {
        public void treeExpanded(TreeExpansionEvent event)
        {
            final DefaultMutableTreeNode node = getTreeNode(
                event.getPath());
            final FileNode fnode = getFileNode(node);

            Thread runner = new Thread() 
            {
              public void run() 
              {
                if (fnode != null && fnode.expand(node)) 
                {
                  Runnable runnable = new Runnable() 
                  {
                    public void run() 
                    {
                       m_model.reload(node);
                    }
                  };
                  SwingUtilities.invokeLater(runnable);
                }
              }
            };
            runner.start();
        }

        public void treeCollapsed(TreeExpansionEvent event) {}
    }


	class DirSelectionListener implements TreeSelectionListener 
	{
		public void valueChanged(TreeSelectionEvent event)
		{
			DefaultMutableTreeNode node = getTreeNode(
				event.getPath());
			FileNode fnode = getFileNode(node);
			if (fnode != null)
				m_display.setText(fnode.getFile().
					getAbsolutePath());
			else
				m_display.setText("");
		}
	}

	public static void main(String argv[]) 
	{
		new FileTree1();
	}
}

class IconCellRenderer 	extends    JLabel implements TreeCellRenderer
{
	protected Color m_textSelectionColor;
	protected Color m_textNonSelectionColor;
	protected Color m_bkSelectionColor;
	protected Color m_bkNonSelectionColor;
	protected Color m_borderSelectionColor;

	protected boolean m_selected;

	public IconCellRenderer()
	{
		super();
		m_textSelectionColor = UIManager.getColor(
			"Tree.selectionForeground");
		m_textNonSelectionColor = UIManager.getColor(
			"Tree.textForeground");
		m_bkSelectionColor = UIManager.getColor(
			"Tree.selectionBackground");
		m_bkNonSelectionColor = UIManager.getColor(
			"Tree.textBackground");
		m_borderSelectionColor = UIManager.getColor(
			"Tree.selectionBorderColor");
		setOpaque(false);
	}

	public Component getTreeCellRendererComponent(JTree tree, 
		Object value, boolean sel, boolean expanded, boolean leaf, 
		int row, boolean hasFocus) 
		
	{
		DefaultMutableTreeNode node = 
			(DefaultMutableTreeNode)value;
		Object obj = node.getUserObject();
		setText(obj.toString());

                if (obj instanceof Boolean)
                  setText("Retrieving data...");

		if (obj instanceof IconData)
		{
			IconData idata = (IconData)obj;
			if (expanded)
			  setIcon(idata.getExpandedIcon());
			else
			  setIcon(idata.getIcon());
		}
		else
			setIcon(null);

		setFont(tree.getFont());
		setForeground(sel ? m_textSelectionColor : m_textNonSelectionColor);
		setBackground(sel ? m_bkSelectionColor : m_bkNonSelectionColor);
		m_selected = sel;
		return this;
	}
    
	public void paintComponent(Graphics g) 
	{
		Color bColor = getBackground();
		Icon icon = getIcon();

		g.setColor(bColor);
		int offset = 0;
		if(icon != null && getText() != null) 
			offset = (icon.getIconWidth() + getIconTextGap());
		g.fillRect(offset, 0, getWidth() - 1 - offset,
			getHeight() - 1);
		
		if (m_selected) 
		{
			g.setColor(m_borderSelectionColor);
			g.drawRect(offset, 0, getWidth()-1-offset, getHeight()-1);
		}
		super.paintComponent(g);
    }
}

class IconData
{
	protected Icon   m_icon;
	protected Icon   m_expandedIcon;
	protected Object m_data;

	public IconData(Icon icon, Object data)
	{
		m_icon = icon;
		m_expandedIcon = null;
		m_data = data;
	}

	public IconData(Icon icon, Icon expandedIcon, Object data)
	{
		m_icon = icon;
		m_expandedIcon = expandedIcon;
		m_data = data;
	}

	public Icon getIcon() 
	{ 
		return m_icon;
	}

	public Icon getExpandedIcon() 
	{ 
		return m_expandedIcon!=null ? m_expandedIcon : m_icon;
	}

	public Object getObject() 
	{ 
		return m_data;
	}

	public String toString() 
	{ 
		return m_data.toString();
	}
}

class FileNode
{
	protected File m_file;

	public FileNode(File file)
	{
		m_file = file;
	}

	public File getFile() 
	{ 
		return m_file;
	}

	public String toString() 
	{ 
		return m_file.getName().length() > 0 ? m_file.getName() : 
			m_file.getPath();
	}

	public boolean expand(DefaultMutableTreeNode parent)
	{
		DefaultMutableTreeNode flag = 
			(DefaultMutableTreeNode)parent.getFirstChild();
		if (flag==null)	  // No flag
			return false;
		Object obj = flag.getUserObject();
		if (!(obj instanceof Boolean))
			return false;      // Already expanded

		parent.removeAllChildren();  // Remove Flag

		File[] files = listFiles();
		if (files == null)
			return true;

		Vector v = new Vector();

		for (int k = 0; k < files.length; k++)
		{
			File f = files[k];
			if (!(f.isDirectory()))
				continue;

			FileNode newNode = new FileNode(f);
			
			boolean isAdded = false;
			for (int i = 0; i < v.size(); i++)
			{
				FileNode nd = (FileNode)v.elementAt(i);
				if (newNode.compareTo(nd) < 0)
				{
					v.insertElementAt(newNode, i);
					isAdded = true;
					break;
				}
			}
			if (!isAdded)
				v.addElement(newNode);
		}

		for (int i = 0; i < v.size(); i++)
		{
			FileNode nd = (FileNode)v.elementAt(i);
			IconData idata = new IconData(FileTree1.ICON_FOLDER, 
				FileTree1.ICON_EXPANDEDFOLDER, nd);
			DefaultMutableTreeNode node = new 
				DefaultMutableTreeNode(idata);
			parent.add(node);
				
			if (nd.hasSubDirs())
				node.add(new DefaultMutableTreeNode( 
					new Boolean(true) ));
		}

		return true;
	}

	public boolean hasSubDirs()
	{
		File[] files = listFiles();
		if (files == null)
			return false;
		for (int k = 0; k < files.length; k++)
		{
			if (files[k].isDirectory())
				return true;
		}
		return false;
	}
	
	public int compareTo(FileNode toCompare)
	{ 
		return  m_file.getName().compareToIgnoreCase(
			toCompare.m_file.getName() ); 
	}

	protected File[] listFiles()
	{
		if (!m_file.isDirectory())
			return null;
		try
		{
			return m_file.listFiles();
		}
		catch (Exception ex)
		{
			JOptionPane.showMessageDialog(null, 
				"Error reading directory "+m_file.getAbsolutePath(),
				"Warning", JOptionPane.WARNING_MESSAGE);
			return null;
		}
	}
}

Four custom icons are loaded as static ImageIcon variables: ICON_COMPUTER, ICON_DISK, ICON_FOLDER, and ICON_EXPANDEDFOLDER, and three instance variables are declared:

The FileTree1 constructor creates and initializes all GUI components. A root node "Computer" hosts child nodes for all disk partitions and network drives in the system. These nodes encapsulate Files retrieved with the static File.listRoots() method (a valuable addition to the File class in Java 2). Note that IconData objects (see below) encapsulate Files in the tree. Also note that each newly created child node immediately receives a child node containing a Boolean user object. This Boolean object allows us to display an expanding message for nodes when they are in the process of being expanded. Exactly how we expand them will be explained soon enough.

We then create a DefaultTreeModel and pass our "Computer" node as the root. This model is used to instantiate our JTree object:

We then set the lineStyle client property so that angled lines will represent the edges between parent and child nodes:

We also use a custom tree cell renderer, as well as a tree exapansion listener and a tree selection listener, (each of which in detail below): IconCellRenderer, DirExpansionListener, and DirSelectionListener respectively.

The actual contents of our tree nodes represent directories. Each node is a DefaultMutableTreeNode with an IconData user object. Each user object is an instance of IconData, and each IconData contains an instance of FileNode. Each FileNode contain a java.io.File object. Thus we have a four layered nested structure:

To keep things simple, two helper methods are provided to work with these encapsulated nodes: getTreeNode() retrieves a DefaultMutableTreeNode from a given TreePath, and getFileNode() retrieves the FileNode (or null) from a DefaultMutableTreeNode. We will see where these methods are needed soon enough.

This inner class implements TreeExpansionListener to listen for tree expansion events. When a node is expanded, method treeExpanded() retrieves the FileNode instance for that node, and, if it's not null, calls the expand() method on it (see below). This is wrapped in a separate thread because it can often be a very time consuming process and we do not want the application to freeze. Inside this thread, once expand() has completed, we need to update the tree model with any new nodes retrieved. As we learned in chapter 2, updating the state of a component should on! ly occur within the event dispatching thread. For this reason we wrap the call to reload() in a Runnable and send it the event dispatching queue using SwingUtilities.invokeLater():

    Runnable runnable = new Runnable() {
      public void run() {
        m_model.reload(node);
      }
    };
    SwingUtilities.invokeLater(runnable);

As we will see below in our discussion of IconCellRenderer, by placing a Boolean user object in a dummy child node of each non-expanded node, we allow a certain String to be displayed while a node is in the process of being expanded. In our case, "Retreiving data..." is shown below a node until finished expanding.

This inner class implements TreeSelectionListener to listen for tree selection events. When a node is selected, the valueChanged() method extracts the FileNode instance contained in that node, and, if it is not null, displays the absolute path to that directory in the m_display text field.

This class implements the TreeCellRenderer interface and extends JLabel. The purpose of this renderer is to display custom icons and access FileNodes contained in IconData instances.

First we declare five Colors and retrieve them from the current look-and-feel in use through UIManager’s getColor() method. The getTreeCellRendererComponent() method is then implemented to set the proper text and icon (retrieved from the underlying IconData object). If the user object happens to be a Boolean, this signifies that a node is in the process of being expanded:

        if (obj instanceof Boolean) 
          setText("Retrieving data...");

When a node is expanded, its list of children is examined. Three situations are possible:

    DefaultMutableTreeNode flag =  (DefaultMutableTreeNode)parent.getFirstChild();
    if (flag==null)      // No flag
      return false;
    Object obj = flag.getUserObject();
    if (!(obj instanceof Boolean))
      return false;    // Already expanded

    parent.removeAllChildren();  // Remove Flag

    Vector v = new Vector();

    for (int k=0; k<files.length; k++) {
      File f = files[k];
      if (!(f.isDirectory()))
        continue;

      FileNode newNode = new FileNode(f);
           

      boolean isAdded = false;
      for (int i=0; i<v.size(); i++) {
        FileNode nd = (FileNode)v.elementAt(i);
        if (newNode.compareTo(nd) < 0) {
          v.insertElementAt(newNode, i);
          isAdded = true;
           break;
        }
      }
      if (!isAdded)
      v.addElement(newNode);
    }

    for (int i=0; i<v.size(); i++) {
      FileNode nd = (FileNode)v.elementAt(i);
      IconData idata = new IconData(FileTree1.ICON_FOLDER, 
      FileTree1.ICON_EXPANDEDFOLDER, nd);
      DefaultMutableTreeNode node = new 
        DefaultMutableTreeNode(idata);
      parent.add(node);
      if (nd.hasSubDirs())
        node.add(new DefaultMutableTreeNode( 
          new Boolean(true) ));
    }
    return true;

The example in the previous section can be extended in numerous ways to serve as a framework for a much more flexible application. In this section we'll add simple popup menus to our tree, displayed in response to a right mouse click, with content dependant on the click location. (We discussed popup menus in chapter 12.)

Our popup menu either contains an "Expand" or "Collapse" item depending on the status of the corresponding node nearest to the mouse click. These items will programatically invoke an expand or collapse of the given node. Our popup menu also contains "Delete" and "Rename" dummy items that are not completely implemented, but explicitly illustrate how we might continue to build upon this example to create a more complete directory explorer application.

<<file figure17-4.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.text.SimpleDateFormat;

import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;

public class FileTree2 	extends JFrame 
{
	public static final ImageIcon ICON_COMPUTER = 
		new ImageIcon("computer.gif");
	public static final ImageIcon ICON_DISK = 
		new ImageIcon("disk.gif");
	public static final ImageIcon ICON_FOLDER = 
		new ImageIcon("folder.gif");
	public static final ImageIcon ICON_EXPANDEDFOLDER = 
		new ImageIcon("expandedfolder.gif");

	protected JTree  m_tree;
	protected DefaultTreeModel m_model;
	protected JTextField m_display;

	// NEW
	protected JPopupMenu m_popup;
	protected Action m_action;
	protected TreePath m_clickedPath;

	public FileTree2()
	{
		super("Directories Tree [Popup Menus]");
		setSize(400, 300);

		DefaultMutableTreeNode top = new DefaultMutableTreeNode(
			new IconData(ICON_COMPUTER, null, "Computer"));

		DefaultMutableTreeNode node;
		File[] roots = File.listRoots();
		for (int k=0; k < roots.length; k++)
		{
			node = new DefaultMutableTreeNode(new IconData(ICON_DISK, 
				null, new FileNode(roots[k])));
			top.add(node);
			node.add(new DefaultMutableTreeNode( new Boolean(true) ));
		}

		m_model = new DefaultTreeModel(top);
		m_tree = new JTree(m_model);

                m_tree.putClientProperty("JTree.lineStyle", "Angled");

		TreeCellRenderer renderer = new 
			IconCellRenderer();
		m_tree.setCellRenderer(renderer);

		m_tree.addTreeExpansionListener(new 
			DirExpansionListener());

		m_tree.addTreeSelectionListener(new 
			DirSelectionListener());

		m_tree.getSelectionModel().setSelectionMode(
			TreeSelectionModel.SINGLE_TREE_SELECTION); 
		m_tree.setShowsRootHandles(true); 
		m_tree.setEditable(false);

		JScrollPane s = new JScrollPane();
		s.getViewport().add(m_tree);
		getContentPane().add(s, BorderLayout.CENTER);

		m_display = new JTextField();
		m_display.setEditable(false);
		getContentPane().add(m_display, BorderLayout.NORTH);

		// NEW
		m_popup = new JPopupMenu();
		m_action = new AbstractAction() 
		{ 
			public void actionPerformed(ActionEvent e)
			{
				if (m_clickedPath==null)
					return;
				if (m_tree.isExpanded(m_clickedPath))
					m_tree.collapsePath(m_clickedPath);
				else
					m_tree.expandPath(m_clickedPath);
			}
		};
		m_popup.add(m_action);
		m_popup.addSeparator();

		Action a1 = new AbstractAction("Delete") 
		{ 
			public void actionPerformed(ActionEvent e)
			{
                                m_tree.repaint();
				JOptionPane.showMessageDialog(FileTree2.this, 
					"Delete option is not implemented",
					"Info", JOptionPane.INFORMATION_MESSAGE);
			}
		};
		m_popup.add(a1);

		Action a2 = new AbstractAction("Rename") 
		{ 
			public void actionPerformed(ActionEvent e)
			{
                                m_tree.repaint();
				JOptionPane.showMessageDialog(FileTree2.this, 
					"Rename option is not implemented",
					"Info", JOptionPane.INFORMATION_MESSAGE);
			}
		};
		m_popup.add(a2);
		m_tree.add(m_popup);
		m_tree.addMouseListener(new PopupTrigger());

		WindowListener wndCloser = new WindowAdapter()
		{
			public void windowClosing(WindowEvent e) 
			{
				System.exit(0);
			}
		};
		addWindowListener(wndCloser);
		
		setVisible(true);
	}

	DefaultMutableTreeNode getTreeNode(TreePath path)
	{
		return (DefaultMutableTreeNode)(path.getLastPathComponent());
	}

	FileNode getFileNode(DefaultMutableTreeNode node)
	{
		if (node == null)
			return null;
		Object obj = node.getUserObject();
		if (obj instanceof IconData)
			obj = ((IconData)obj).getObject();
		if (obj instanceof FileNode)
			return (FileNode)obj;
		else
			return null;
	}

	// NEW
	class PopupTrigger extends MouseAdapter
	{
		public void mouseReleased(MouseEvent e)
		{
			if (e.isPopupTrigger())
			{
				int x = e.getX();
				int y = e.getY();
				TreePath path = m_tree.getPathForLocation(x, y);
				if (path != null)
				{
					if (m_tree.isExpanded(path))
						m_action.putValue(Action.NAME, "Collapse");
					else
						m_action.putValue(Action.NAME, "Expand");
					m_popup.show(m_tree, x, y);
					m_clickedPath = path;
				}
			}
		}
	}

    // Make sure expansion is threaded and updating the tree model
    // only occurs within the event dispatching thread.
    class DirExpansionListener implements TreeExpansionListener
    {
        public void treeExpanded(TreeExpansionEvent event)
        {
            final DefaultMutableTreeNode node = getTreeNode(
                event.getPath());
            final FileNode fnode = getFileNode(node);

            Thread runner = new Thread() 
            {
              public void run() 
              {
                if (fnode != null && fnode.expand(node)) 
                {
                  Runnable runnable = new Runnable() 
                  {
                    public void run() 
                    {
                       m_model.reload(node);
                    }
                  };
                  SwingUtilities.invokeLater(runnable);
                }
              }
            };
            runner.start();
        }

        public void treeCollapsed(TreeExpansionEvent event) {}
    }

	class DirSelectionListener implements TreeSelectionListener 
	{
		public void valueChanged(TreeSelectionEvent event)
		{
			DefaultMutableTreeNode node = getTreeNode(
				event.getPath());
			FileNode fnode = getFileNode(node);
			if (fnode != null)
				m_display.setText(fnode.getFile().
					getAbsolutePath());
			else
				m_display.setText("");
		}
	}

	public static void main(String argv[]) 
	{
		new FileTree2();
	}
}

This example adds three new instance variables:

Figure 17.4 shows our directories tree application displaying a context sensitive popup menu. Note how the first menu item is changed depending on whether the selected tree node is collapsed or expanded. Also note that the tree can be manipulated (expanded or collapsed) programmatically by choosing the "Collapse" or "Expand" popup menu item.

ToolTipManager.sharedInstance().registerComponent(myTree);

Without doing this, no tooltips will appear over our tree (refer back to chapter 2, section 2.5, for more about shared instances and service classes).

<<file figure17-5.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;

public class FileTree3 extends JFrame 
{
  // Unchanged code from section 17.4

public FileTree3() {
    super("Directories Tree [Tool Tips]");
    setSize(400, 300);
    getContentPane().setLayout(new BorderLayout());

    // Unchanged code

    m_model = new DefaultTreeModel(top);
    m_tree = new JTree(m_model) {
     public String getToolTipText(MouseEvent ev) {
         if (ev == null)
           return null;
         TreePath path = m_tree.getPathForLocation(ev.getX(), ev.getY());
         if (path != null) {
           FileNode fnode = getFileNode(getTreeNode(path));
           if (fnode==null)
             return null;
           File f = fnode.getFile();
           return (f==null ? null : f.getPath());
         }
         return null;
    }
};

ToolTipManager.sharedInstance().registerComponent(m_tree);

  // The rest of the code is unchanged

Figure 17.5 shows our directories tree application displaying a tooltip with text specifying the full path of the directory corresponding to the node nearest to the current mouse location.

Many see the future of the web in XML™ (Extensible Markup Language). This standard will most likely replace HTML. Unlike HTML, XML allows the definition of custom document tags, allowing the transmition of virtually any type of information over the web. Many sources of information about XML are available, including the standard definition at http://www.w3.org/TR/WD-xml-lang-970331.html.

<<file figure17-6.gif>>

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.io.*;
import java.net.*;

import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;

import com.sun.xml.tree.*;
import com.sun.xml.parser.*;
import org.w3c.dom.*;

public class XmlTree extends JFrame 
{

	protected JTree  m_tree;
	protected DefaultTreeModel m_model;
	protected JTextField m_location;

	public XmlTree()
	{
		super("XML Tree");
		setSize(400, 300);
		getContentPane().setLayout(new BorderLayout());

		m_location = new JTextField();
		m_location.setText("samples\\book-order.xml");
		ActionListener lst = new ActionListener() 
		{ 
			public void actionPerformed(ActionEvent e)
			{
				readXml(m_location.getText());
			}
		};
		m_location.addActionListener(lst);
		getContentPane().add(m_location, BorderLayout.NORTH);

		DefaultMutableTreeNode top = new DefaultMutableTreeNode(
			"Empty");
		m_model = new DefaultTreeModel(top);
		m_tree = new JTree(m_model);

		m_tree.getSelectionModel().setSelectionMode(
			TreeSelectionModel.SINGLE_TREE_SELECTION);            
		m_tree.setShowsRootHandles(true); 
		m_tree.setEditable(false);

		JScrollPane s = new JScrollPane();
		s.getViewport().add(m_tree);
		getContentPane().add(s, BorderLayout.CENTER);

		WindowListener wndCloser = new WindowAdapter()
		{
			public void windowClosing(WindowEvent e) 
			{
				System.exit(0);
			}
		};
		addWindowListener(wndCloser);
		
		setVisible(true);
	}

	public void readXml(String sUrl)
	{
		setCursor( Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR) );
		try
		{
			URL source;
			try
			{
				File f = new File(sUrl);
				source = f.toURL();
			}
			catch (Exception ex)
			{
				source = new URL(sUrl);
			}

			XmlDocument doc = XmlDocumentBuilder.createXmlDocument(
				source.toString());

			ElementNode root = (ElementNode)doc.getDocumentElement();
			root.normalize();

			DefaultMutableTreeNode top = createTreeNode(root);

			m_model.setRoot(top);
			m_tree.treeDidChange();
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
			JOptionPane.showMessageDialog(this, 
				ex.toString(), "Warning", 
				JOptionPane.WARNING_MESSAGE);
		}
		setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
	}

	protected DefaultMutableTreeNode createTreeNode(ElementNode root)
	{
		DefaultMutableTreeNode node = new DefaultMutableTreeNode(
			root.getNodeName());
		for (int k = 0; k < root.getLength(); k++)
		{
			Node nd = root.item(k);

			if (nd instanceof DataNode)
			{
				DataNode dn = (DataNode)nd;

				String data = dn.getData().trim();
				if (data.equals("\n") || data.equals("\r\n"))
					data = "";
				if (data.length() > 0)
					node.add(new DefaultMutableTreeNode(data));
			}
			else if (nd instanceof ElementNode)
			{
				ElementNode en = (ElementNode)nd;
				node.add(createTreeNode(en));
			}
		}
		return node;
	}

	public static void main(String argv[]) 
	{
		new XmlTree();
	}
}

Instance variables:

          URL source;
          try {
            File f = new File(sUrl);
            source = f.toURL();
          }
          catch (Exception ex) {
            source = new URL(sUrl);
          }

          XmlDocument doc = XmlDocumentBuilder.createXmlDocument(source.toString());

          ElementNode root = (ElementNode)doc.getDocumentElement();
          root.normalize();

          DefaultMutableTreeNode top = createTreeNode(root);
          m_model.setRoot(top);
          m_tree.treeDidChange();

    DefaultMutableTreeNode node = new DefaultMutableTreeNode(root.getNodeName());
    for (int k=0; k<root.getLength(); k++) {
      Node nd = root.item(k);

Figure 17.6 shows our XML Tree example displaying the contents of "The Two Gentlemen of Verona" XML document which can be found at ftp://sunsite.unc.edu/pub/sun-info/standards/xml/eg/.

In this section we'll construct a simple family tree application. We will show how to use a custom cell editor for name entry, as well as a custom cell renderer which displays an icon corresponding to a node’s data rather than its state. This example allows dynamic node insertion, and each node can have no more than two children.

<<file figure17-7.gif>>

import java.awt.*;
import java.awt.event.*;
import java.util.*;

import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import javax.swing.tree.*;

public class AncestorTree extends JFrame
{
  public static ImageIcon ICON_SELF = 
    new ImageIcon("myself.gif");
  public static ImageIcon ICON_MALE = 
    new ImageIcon("male.gif");
  public static ImageIcon ICON_FEMALE = 
    new ImageIcon("female.gif");

  protected JTree  m_tree;
  protected DefaultTreeModel m_model;
  protected IconCellRenderer m_renderer;
  protected IconCellEditor m_editor;

  public AncestorTree() {
    super("Ancestor Tree");
    setSize(500, 400);

    DefaultMutableTreeNode top = new DefaultMutableTreeNode(
      new IconData(ICON_SELF, "Myself"));
    addAncestors(top);
    m_model = new DefaultTreeModel(top);
    m_tree = new JTree(m_model);
    m_tree.getSelectionModel().setSelectionMode(
      TreeSelectionModel.SINGLE_TREE_SELECTION);
    m_tree.setShowsRootHandles(true); 
    m_tree.setEditable(true);

    m_renderer = new IconCellRenderer();
    m_tree.setCellRenderer(m_renderer); 
    m_editor = new IconCellEditor(m_tree);
    m_tree.setCellEditor(m_editor);
    m_tree.setInvokesStopCellEditing(true);

    m_tree.addMouseListener(new TreeExpander()); 

    JScrollPane s = new JScrollPane();
    s.getViewport().add(m_tree);
    getContentPane().add(s, BorderLayout.CENTER);

    WindowListener wndCloser = new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    };
    addWindowListener(wndCloser);

    setVisible(true);
  }

  public boolean addAncestors(DefaultMutableTreeNode node) {
    if (node.getChildCount() > 0)
      return false;

    Object obj = node.getUserObject();
    if (obj == null)
      return false;
    node.add(new DefaultMutableTreeNode( new IconData(
      ICON_MALE, "Father of: "+obj.toString()) ));
    node.add(new DefaultMutableTreeNode( new IconData(
      ICON_FEMALE, "Mother of: "+obj.toString()) ));
    return true;
  }

  public static void main(String argv[]) { new AncestorTree(); }

  class TreeExpander extends MouseAdapter 
  {
    public void mouseClicked(MouseEvent e) {
      if (e.getClickCount() == 2) {
        TreePath selPath = m_tree.getPathForLocation(
          e.getX(), e.getY());
        if (selPath == null)
          return;
        DefaultMutableTreeNode node = 
          (DefaultMutableTreeNode)(selPath.
             getLastPathComponent());
        if (node!=null && addAncestors(node)) {
          m_tree.expandPath(selPath);
          m_tree.repaint();
        }
      }
    }
  }
}

// Classes IconCellRenderer and IconData are
// unchanged from previous examples, and are 
// not listed here to conserve space.

class IconCellEditor extends JLabel 
 implements TreeCellEditor, ActionListener
{
  protected JTree m_tree = null;
  protected JTextField m_editor = null;
  protected IconData m_item = null;
  protected int m_lastRow = -1;
  protected long m_lastClick = 0;
  protected Vector m_listeners = null;

  public IconCellEditor(JTree tree) {
    super();
    m_tree = tree;
    m_listeners = new Vector();
  }

  public Component getTreeCellEditorComponent(JTree tree, 
   Object value, boolean isSelected, boolean expanded, 
   boolean leaf, int row)
  {
    if (value instanceof DefaultMutableTreeNode) {
      DefaultMutableTreeNode node = 
        (DefaultMutableTreeNode)value;
      Object obj = node.getUserObject();
      if (obj instanceof IconData) {
        IconData idata = (IconData)obj;
        m_item = idata;
        // Reserve some more space...
        setText(idata.toString()+"     "); 
        setIcon(idata.m_icon);
        setFont(tree.getFont());
        return this;
      }
    }
    // We don't support other objects...
    return null;
  }

  public Object getCellEditorValue() { 
    if (m_item != null && m_editor != null)
      m_item.m_data = m_editor.getText();
    return m_item; 
  }

  public boolean isCellEditable(EventObject evt) { 
    if (evt instanceof MouseEvent) {
      MouseEvent mEvt = (MouseEvent)evt;
      if (mEvt.getClickCount() == 1) {
        int row = m_tree.getRowForLocation(mEvt.getX(), mEvt.getY());
        if (row != m_lastRow) {
          m_lastRow = row;
          m_lastClick = System.currentTimeMillis();
          return false;
        }
        else if (System.currentTimeMillis()-m_lastClick > 1000)
        {
          m_lastRow = -1;
          m_lastClick = 0;
          prepareEditor();
          mEvt.consume();
          return true;
        }
        else
          return false; 
      }
    }
    return false; 
  }

  protected void prepareEditor() {
    if (m_item == null)
      return;
    String str = m_item.toString();

    m_editor = new JTextField(str);
    m_editor.addActionListener(this);
    m_editor.selectAll();
    m_editor.setFont(m_tree.getFont());
        
    add(m_editor);
    revalidate();

    TreePath path = m_tree.getPathForRow(m_lastRow);
    m_tree.startEditingAtPath(path);
  }

  protected void removeEditor() {
    if (m_editor != null) {
      remove(m_editor);
      m_editor.setVisible(false);
      m_editor = null;
      m_item = null;
    }
  }

  public void doLayout() {
    super.doLayout();
    if (m_editor != null) {
      int offset = getIconTextGap();
      if (getIcon() != null)
        offset += getIcon().getIconWidth();
      Dimension cSize = getSize();
      m_editor.setBounds(offset, 0, cSize.width - offset,
        cSize.height);
    }
  }

  public boolean shouldSelectCell(EventObject evt) { return true; }

  public boolean stopCellEditing() {
    if (m_item != null)
      m_item.m_data = m_editor.getText();

    ChangeEvent e = new ChangeEvent(this);
    for (int k=0; k<m_listeners.size(); k++) {
      CellEditorListener l = (CellEditorListener)m_listeners.
        elementAt(k);
      l.editingStopped(e);
    }
    removeEditor();
    return true; 
  }

  public void cancelCellEditing() {
    ChangeEvent e = new ChangeEvent(this);
    for (int k=0; k<m_listeners.size(); k++) {
      CellEditorListener l = (CellEditorListener)m_listeners.
        elementAt(k);
      l.editingCanceled(e);
    }
    removeEditor();
  }

  public void addCellEditorListener(CellEditorListener l) {
    m_listeners.addElement(l);
  }

  public void removeCellEditorListener(CellEditorListener l) {
    m_listeners.removeElement(l);
  }

  public void actionPerformed(ActionEvent e) {
    stopCellEditing();
    m_tree.stopEditing();
  }
}

Instance variables:

Instance variables:

      if (m_item != null && m_editor != null)
        m_item.m_data = m_editor.getText();
      return m_item; 

      if (evt instanceof MouseEvent) {
        MouseEvent mEvt = (MouseEvent)evt;
        if (mEvt.getClickCount() == 1) {

      if (m_item != null)
        m_item.m_data = m_editor.getText();

      m_editor = new JTextField(str);
      m_editor.addActionListener(this);
      m_editor.selectAll();
      m_editor.setFont(m_tree.getFont());
        
      add(m_editor);
      revalidate();

          remove(m_editor);
          m_editor.setVisible(false);
          m_editor = null;
          m_item = null;

Perform a single click on a tree cell, wait about a second, then click it again to enter editing mode. Note that there is no limit to how far back we can go with this ancestor tree, and all nodes can have either no children, or two children (representing the parents of the individual represented by that node). Try creating your own ancestor tree as far back as you can go (if you end with monkey or gorilla please contact us). Figure 17.7 shows the ancestor tree of Prince William of Wales, the oldest son of the heir of the British monarchy.