|
Java™ Platform Standard Ed. 6 |
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES All Classes | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectjava.util.EventObject
javax.swing.event.TreeModelEvent
public class TreeModelEvent
Encapsulates information describing changes to a tree model, and used to notify tree model listeners of the change. For more information and examples see How to Write a Tree Model Listener, a section 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 JavaBeansTM
has been added to the java.beans
package.
Please see XMLEncoder
.
Field Summary | |
---|---|
protected int[] |
childIndices
Indices identifying the position of where the children were. |
protected Object[] |
children
Children that have been removed. |
protected TreePath |
path
Path to the parent of the nodes that have changed. |
Fields inherited from class java.util.EventObject |
---|
source |
Constructor Summary | |
---|---|
TreeModelEvent(Object source,
Object[] path)
Used to create an event when the node structure has changed in some way, identifying the path to the root of a modified subtree as an array of Objects. |
|
TreeModelEvent(Object source,
Object[] path,
int[] childIndices,
Object[] children)
Used to create an event when nodes have been changed, inserted, or removed, identifying the path to the parent of the modified items as an array of Objects. |
|
TreeModelEvent(Object source,
TreePath path)
Used to create an event when the node structure has changed in some way, identifying the path to the root of the modified subtree as a TreePath object. |
|
TreeModelEvent(Object source,
TreePath path,
int[] childIndices,
Object[] children)
Used to create an event when nodes have been changed, inserted, or removed, identifying the path to the parent of the modified items as a TreePath object. |
Method Summary | |
---|---|
int[] |
getChildIndices()
Returns the values of the child indexes. |
Object[] |
getChildren()
Returns the objects that are children of the node identified by getPath at the locations specified by
getChildIndices . |
Object[] |
getPath()
Convenience method to get the array of objects from the TreePath instance that this event wraps. |
TreePath |
getTreePath()
For all events, except treeStructureChanged, returns the parent of the changed nodes. |
String |
toString()
Returns a string that displays and identifies this object's properties. |
Methods inherited from class java.util.EventObject |
---|
getSource |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Field Detail |
---|
protected TreePath path
protected int[] childIndices
protected Object[] children
Constructor Detail |
---|
public TreeModelEvent(Object source, Object[] path, int[] childIndices, Object[] children)
int
. The indexes in that array
must be in order, from lowest to highest.
For changes, the indexes in the model correspond exactly to the indexes of items currently displayed in the UI. As a result, it is not really critical if the indexes are not in their exact order. But after multiple inserts or deletes, the items currently in the UI no longer correspond to the items in the model. It is therefore critical to specify the indexes properly for inserts and deletes.
For inserts, the indexes represent the final state of the tree,
after the inserts have occurred. Since the indexes must be specified in
order, the most natural processing methodology is to do the inserts
starting at the lowest index and working towards the highest. Accumulate
a Vector of Integer
objects that specify the
insert-locations as you go, then convert the Vector to an
array of int
to create the event. When the postition-index
equals zero, the node is inserted at the beginning of the list. When the
position index equals the size of the list, the node is "inserted" at
(appended to) the end of the list.
For deletes, the indexes represent the initial state of the tree,
before the deletes have occurred. Since the indexes must be specified in
order, the most natural processing methodology is to use a delete-counter.
Start by initializing the counter to zero and start work through the
list from lowest to higest. Every time you do a delete, add the current
value of the delete-counter to the index-position where the delete occurred,
and append the result to a Vector of delete-locations, using
addElement()
. Then increment the delete-counter. The index
positions stored in the Vector therefore reflect the effects of all previous
deletes, so they represent each object's position in the initial tree.
(You could also start at the highest index and working back towards the
lowest, accumulating a Vector of delete-locations as you go using the
insertElementAt(Integer, 0)
.) However you produce the Vector
of initial-positions, you then need to convert the Vector of Integer
objects to an array of int
to create the event.
Notes:
insertNodeInto
method in the
DefaultTreeModel
class, insertElementAt
appends to the Vector
when the index matches the size
of the vector. So you can use insertElementAt(Integer, 0)
even when the vector is empty.
null
.
source
- the Object responsible for generating the event (typically
the creator of the event object passes this
for its value)path
- an array of Object identifying the path to the
parent of the modified item(s), where the first element
of the array is the Object stored at the root node and
the last element is the Object stored at the parent nodechildIndices
- an array of int
that specifies the
index values of the removed items. The indices must be
in sorted order, from lowest to highestchildren
- an array of Object containing the inserted, removed, or
changed objectsTreePath
public TreeModelEvent(Object source, TreePath path, int[] childIndices, Object[] children)
TreeModelEvent(Object,Object[],int[],Object[])
.
source
- the Object responsible for generating the event (typically
the creator of the event object passes this
for its value)path
- a TreePath object that identifies the path to the
parent of the modified item(s)childIndices
- an array of int
that specifies the
index values of the modified itemschildren
- an array of Object containing the inserted, removed, or
changed objectsTreeModelEvent(Object,Object[],int[],Object[])
public TreeModelEvent(Object source, Object[] path)
Note:
JTree collapses all nodes under the specified node, so that only its immediate children are visible.
source
- the Object responsible for generating the event (typically
the creator of the event object passes this
for its value)path
- an array of Object identifying the path to the root of the
modified subtree, where the first element of the array is
the object stored at the root node and the last element
is the object stored at the changed nodeTreePath
public TreeModelEvent(Object source, TreePath path)
TreeModelEvent(Object,Object[])
.
source
- the Object responsible for generating the event (typically
the creator of the event object passes this
for its value)path
- a TreePath object that identifies the path to the
change. In the DefaultTreeModel,
this object contains an array of user-data objects,
but a subclass of TreePath could use some totally
different mechanism -- for example, a node ID numberTreeModelEvent(Object,Object[])
Method Detail |
---|
public TreePath getTreePath()
getChildIndices
are used to get a list of the effected
nodes.
The one exception to this is a treeNodesChanged event that is to
identify the root, in which case this will return the root
and getChildIndices
will return null.
TreePath.getLastPathComponent()
public Object[] getPath()
public Object[] getChildren()
getPath
at the locations specified by
getChildIndices
. If this is a removal event the
returned objects are no longer children of the parent node.
getPath()
,
getChildIndices()
public int[] getChildIndices()
int
containing index locations for
the children specified by the eventpublic String toString()
toString
in class EventObject
|
Java™ Platform Standard Ed. 6 |
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES All Classes | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Copyright © 1993, 2015, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.
Scripting on this page tracks web page traffic, but does not change the content in any way.