< 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&trade;
- * 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 >