< prev index next >
src/java.desktop/share/classes/javax/swing/event/TreeModelEvent.java
Print this page
@@ -41,11 +41,11 @@
* 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 <code>java.beans</code> package.
+ * has been added to the {@code java.beans} package.
* Please see {@link java.beans.XMLEncoder}.
*
* @author Rob Davis
* @author Ray Ryan
* @author Scott Violet
@@ -63,11 +63,11 @@
* 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. All of the modified objects are siblings which are
* direct descendents (not grandchildren) of the specified parent.
* The positions at which the inserts, deletes, or changes occurred are
- * specified by an array of <code>int</code>. The indexes in that array
+ * specified by an array of {@code int}. The indexes in that array
* must be in order, from lowest to highest.
* <p>
* 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
@@ -77,13 +77,13 @@
* <p>
* For inserts, the indexes represent the <i>final</i> 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 <code>Integer</code> objects that specify the
+ * a Vector of {@code Integer} objects that specify the
* insert-locations as you go, then convert the Vector to an
- * array of <code>int</code> to create the event. When the postition-index
+ * array of {@code 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.
* <p>
* For deletes, the indexes represent the <i>initial</i> state of the tree,
@@ -91,37 +91,37 @@
* 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 highest. 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
- * <code>addElement()</code>. Then increment the delete-counter. The index
+ * {@code 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
- * <code>insertElementAt(Integer, 0)</code>.) However you produce the Vector
- * of initial-positions, you then need to convert the Vector of <code>Integer</code>
- * objects to an array of <code>int</code> to create the event.
+ * {@code insertElementAt(Integer, 0)}.) However you produce the Vector
+ * of initial-positions, you then need to convert the Vector of {@code Integer}
+ * objects to an array of {@code int} to create the event.
* <p>
* <b>Notes:</b><ul style="list-style-type:none">
- * <li>Like the <code>insertNodeInto</code> method in the
- * <code>DefaultTreeModel</code> class, <code>insertElementAt</code>
- * appends to the <code>Vector</code> when the index matches the size
- * of the vector. So you can use <code>insertElementAt(Integer, 0)</code>
+ * <li>Like the {@code insertNodeInto} method in the
+ * {@code DefaultTreeModel} class, {@code insertElementAt}
+ * appends to the {@code Vector} when the index matches the size
+ * of the vector. So you can use {@code insertElementAt(Integer, 0)}
* even when the vector is empty.</li>
* <li>To create a node changed event for the root node, specify the parent
- * and the child indices as <code>null</code>.</li>
+ * and the child indices as {@code null}.</li>
* </ul>
*
* @param source the Object responsible for generating the event (typically
- * the creator of the event object passes <code>this</code>
+ * the creator of the event object passes {@code this}
* for its value)
* @param 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 node
- * @param childIndices an array of <code>int</code> that specifies the
+ * @param childIndices an array of {@code int} that specifies the
* index values of the removed items. The indices must be
* in sorted order, from lowest to highest
* @param children an array of Object containing the inserted, removed, or
* changed objects
* @see TreePath
@@ -135,18 +135,18 @@
/**
* 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. For more information on how to specify the indexes
* and objects, see
- * <code>TreeModelEvent(Object,Object[],int[],Object[])</code>.
+ * {@code TreeModelEvent(Object,Object[],int[],Object[])}.
*
* @param source the Object responsible for generating the event (typically
- * the creator of the event object passes <code>this</code>
+ * the creator of the event object passes {@code this}
* for its value)
* @param path a TreePath object that identifies the path to the
* parent of the modified item(s)
- * @param childIndices an array of <code>int</code> that specifies the
+ * @param childIndices an array of {@code int} that specifies the
* index values of the modified items
* @param children an array of Object containing the inserted, removed, or
* changed objects
*
* @see #TreeModelEvent(Object,Object[],int[],Object[])
@@ -172,11 +172,11 @@
* JTree collapses all nodes under the specified node, so that only its
* immediate children are visible.
* </blockquote>
*
* @param source the Object responsible for generating the event (typically
- * the creator of the event object passes <code>this</code>
+ * the creator of the event object passes {@code this}
* for its value)
* @param 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 node
@@ -189,14 +189,14 @@
/**
* 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. For more information on this event specification, see
- * <code>TreeModelEvent(Object,Object[])</code>.
+ * {@code TreeModelEvent(Object,Object[])}.
*
* @param source the Object responsible for generating the event (typically
- * the creator of the event object passes <code>this</code>
+ * the creator of the event object passes {@code this}
* for its value)
* @param 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
@@ -214,16 +214,16 @@
/**
* For all events, except treeStructureChanged,
* returns the parent of the changed nodes.
* For treeStructureChanged events, returns the ancestor of the
* structure that has changed. This and
- * <code>getChildIndices</code> are used to get a list of the effected
+ * {@code getChildIndices} are used to get a list of the effected
* nodes.
* <p>
* The one exception to this is a treeNodesChanged event that is to
* identify the root, in which case this will return the root
- * and <code>getChildIndices</code> will return null.
+ * and {@code getChildIndices} will return null.
*
* @return the TreePath used in identifying the changed nodes.
* @see TreePath#getLastPathComponent
*/
public TreePath getTreePath() { return path; }
@@ -242,12 +242,12 @@
return null;
}
/**
* Returns the objects that are children of the node identified by
- * <code>getPath</code> at the locations specified by
- * <code>getChildIndices</code>. If this is a removal event the
+ * {@code getPath} at the locations specified by
+ * {@code getChildIndices}. If this is a removal event the
* returned objects are no longer children of the parent node.
*
* @return an array of Object containing the children specified by
* the event
* @see #getPath
@@ -269,11 +269,11 @@
* the indexes point to locations in the initial list where items
* were removed. If it is an insert, the indices point to locations
* in the final list where the items were added. For node changes,
* the indices point to the locations of the modified nodes.
*
- * @return an array of <code>int</code> containing index locations for
+ * @return an array of {@code int} containing index locations for
* the children specified by the event
*/
public int[] getChildIndices() {
if(childIndices != null) {
int cCount = childIndices.length;
< prev index next >