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.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Used by AbstractLayoutCache to determine the size
and x origin of a particular node.

A DefaultMutableTreeNode is a general-purpose node in a tree data
structure.
For examples of using default mutable tree nodes, see
How to Use Trees
in The Java Tutorial.



A tree node may have at most one parent and 0 or more children.
DefaultMutableTreeNode provides operations for examining and modifying a
node's parent and children and also operations for examining the tree that
the node is a part of.  A node's tree is the set of all nodes that can be
reached by starting at the node and following all the possible links to
parents and children.  A node with no parent is the root of its tree; a
node with no children is a leaf.  A tree may consist of many subtrees,
each node acting as the root for its own subtree.

This class provides enumerations for efficiently traversing a tree or
subtree in various orders or for following the path between two nodes.
A DefaultMutableTreeNode may also hold a reference to a user object, the
use of which is left to the user.  Asking a DefaultMutableTreeNode for its
string representation with toString() returns the string
representation of its user object.

This is not a thread safe class.If you intend to use
a DefaultMutableTreeNode (or a tree of TreeNodes) in more than one thread, you
need to do your own synchronizing. A good convention to adopt is
synchronizing on the root node of a tree.

While DefaultMutableTreeNode implements the MutableTreeNode interface and
will allow you to add in any implementation of MutableTreeNode not all
of the methods in DefaultMutableTreeNode will be applicable to all
MutableTreeNodes implementations. Especially with some of the enumerations
that are provided, using some of these methods assumes the
DefaultMutableTreeNode contains only DefaultMutableNode instances. All
of the TreeNode/MutableTreeNode methods will behave as defined no
matter what implementations are added.


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.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

A TreeCellEditor. You need to supply an
instance of DefaultTreeCellRenderer
so that the icons can be obtained. You can optionally supply
a TreeCellEditor that will be layed out according
to the icon in the DefaultTreeCellRenderer.
If you do not supply a TreeCellEditor,
a TextField will be used. Editing is started
on a triple mouse click, or after a click, pause, click and
a delay of 1200 milliseconds.

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.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Property:
Key:

Displays an entry in a tree.
DefaultTreeCellRenderer is not opaque and
unless you subclass paint you should not change this.
See How to Use Trees
in The Java Tutorial
for examples of customizing node display using this class.

The set of icons and colors used by DefaultTreeCellRenderer
can be configured using the various setter methods. The value for
each property is initialized from the defaults table. When the
look and feel changes (updateUI is invoked), any properties
that have a value of type UIResource are refreshed from the
defaults table. The following table lists the mapping between
DefaultTreeCellRenderer property and defaults table key:


    Property:
    Key:
  "leafIcon""Tree.leafIcon"
  "closedIcon""Tree.closedIcon"
  "openIcon""Tree.openIcon"
  "textSelectionColor""Tree.selectionForeground"
  "textNonSelectionColor""Tree.textForeground"
  "backgroundSelectionColor""Tree.selectionBackground"
  "backgroundNonSelectionColor""Tree.textBackground"
  "borderSelectionColor""Tree.selectionBorderColor"


Implementation Note:
This class overrides
invalidate,
validate,
revalidate,
repaint,
and
firePropertyChange
solely to improve performance.
If not overridden, these frequently called methods would execute code paths
that are unnecessary for the default tree cell renderer.
If you write your own renderer,
take care to weigh the benefits and
drawbacks of overriding these methods.


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.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

A simple tree data model that uses TreeNodes.
For further information and examples that use DefaultTreeModel,
see How to Use Trees
in The Java Tutorial.

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.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Default implementation of TreeSelectionModel.  Listeners are notified
whenever
the paths in the selection change, not the rows. In order
to be able to track row changes you may wish to become a listener
for expansion events on the tree and test for changes from there.
resetRowSelection is called from any of the methods that update
the selected paths. If you subclass any of these methods to
filter what is allowed to be selected, be sure and message
resetRowSelection if you do not message super.

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.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Exception used to stop and expand/collapse from happening.
See How to Write a Tree-Will-Expand Listener
in The Java Tutorial
for further information and examples.

NOTE: This will become more open in a future release.

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.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Defines the requirements for a tree node object that can change --
by adding or removing child nodes, or by changing the contents
of a user object stored in the node.

Defines the requirements for an object that translates paths in
the tree into display rows.

Adds to CellEditor the extensions necessary to configure an editor
in a tree.

Defines the requirements for an object that displays a tree node.
See How to Use Trees
in The Java Tutorial
for an example of implementing a tree cell renderer
that displays custom icons.

The model used by JTree.

JTree and its related classes make extensive use of
TreePaths for identifying nodes in the TreeModel.
If a TreeModel returns the same object, as compared by
equals, at two different indices under the same parent
than the resulting TreePath objects will be considered equal
as well. Some implementations may assume that if two
TreePaths are equal, they identify the same node. If this
condition is not met, painting problems and other oddities may result.
In other words, if getChild for a given parent returns
the same Object (as determined by equals) problems may
result, and it is recommended you avoid doing this.

Similarly JTree and its related classes place
TreePaths in Maps.  As such if
a node is requested twice, the return values must be equal
(using the equals method) and have the same
hashCode.

For further information on tree models,
including an example of a custom implementation,
see How to Use Trees
in The Java Tutorial.

Defines the requirements for an object that can be used as a
tree node in a JTree.

Implementations of TreeNode that override equals
will typically need to override hashCode as well.  Refer
to TreeModel for more information.

For further information and examples of using tree nodes,
see How to Use Tree Nodes
in The Java Tutorial.

TreePath represents an array of objects that uniquely
identify the path to a node in a tree. The elements of the array
are ordered with the root as the first element of the array. For
example, a file on the file system is uniquely identified based on
the array of parent directories and the name of the file. The path
/tmp/foo/bar could be represented by a TreePath as
new TreePath(new Object[] {"tmp", "foo", "bar"}).

TreePath is used extensively by JTree and related classes.
For example, JTree represents the selection as an array of
TreePaths. When used with JTree, the elements of the
path are the objects returned from the TreeModel. When JTree
is paired with DefaultTreeModel, the elements of the
path are TreeNodes. The following example illustrates extracting
the user object from the selection of a JTree:


  DefaultMutableTreeNode root = ...;
  DefaultTreeModel model = new DefaultTreeModel(root);
  JTree tree = new JTree(model);
  ...
  TreePath selectedPath = tree.getSelectionPath();
  DefaultMutableTreeNode selectedNode =
      ((DefaultMutableTreeNode)selectedPath.getLastPathComponent()).
      getUserObject();
Subclasses typically need override only getLastPathComponent, and getParentPath. As JTree
internally creates TreePaths at various points, it's
generally not useful to subclass TreePath and use with
JTree.

While TreePath is serializable, a NotSerializableException is thrown if any elements of the path are
not serializable.

For further information and examples of using tree paths,
see How to Use Trees
in The Java Tutorial.

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.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

This interface represents the current state of the selection for
the tree component.
For information and examples of using tree selection models,
see How to Use Trees
in The Java Tutorial.


The state of the tree selection is characterized by
a set of TreePaths, and optionally a set of integers. The mapping
from TreePath to integer is done by way of an instance of RowMapper.
It is not necessary for a TreeSelectionModel to have a RowMapper to
correctly operate, but without a RowMapper getSelectionRows
will return null.



A TreeSelectionModel can be configured to allow only one
path (SINGLE_TREE_SELECTION) a number of
contiguous paths (CONTIGUOUS_TREE_SELECTION) or a number of
discontiguous paths (DISCONTIGUOUS_TREE_SELECTION).
A RowMapper is used to determine if TreePaths are
contiguous.
In the absence of a RowMapper CONTIGUOUS_TREE_SELECTION and
DISCONTIGUOUS_TREE_SELECTION behave the same, that is they
allow any number of paths to be contained in the TreeSelectionModel.



For a selection model of CONTIGUOUS_TREE_SELECTION any
time the paths are changed (setSelectionPath,
addSelectionPath ...) the TreePaths are again checked to
make they are contiguous. A check of the TreePaths can also be forced
by invoking resetRowSelection. How a set of discontiguous
TreePaths is mapped to a contiguous set is left to implementors of
this interface to enforce a particular policy.



Implementations should combine duplicate TreePaths that are
added to the selection. For example, the following code


  TreePath[] paths = new TreePath[] { treePath, treePath };
  treeSelectionModel.setSelectionPaths(paths);
should result in only one path being selected:
treePath, and
not two copies of treePath.



The lead TreePath is the last path that was added (or set). The lead
row is then the row that corresponds to the TreePath as determined
from the RowMapper.

NOTE: This will become more open in a future release.

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.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.