< prev index next >

src/java.desktop/share/classes/javax/swing/tree/AbstractLayoutCache.java

Print this page

        

@@ -35,11 +35,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 Scott Violet
  */
 @SuppressWarnings("serial") // Same-version serialization only

@@ -69,48 +69,48 @@
     /**
      * Sets the renderer that is responsible for drawing nodes in the tree
      * and which is therefore responsible for calculating the dimensions of
      * individual nodes.
      *
-     * @param nd a <code>NodeDimensions</code> object
+     * @param nd a {@code NodeDimensions} object
      */
     public void setNodeDimensions(NodeDimensions nd) {
         this.nodeDimensions = nd;
     }
 
     /**
      * Returns the object that renders nodes in the tree, and which is
      * responsible for calculating the dimensions of individual nodes.
      *
-     * @return the <code>NodeDimensions</code> object
+     * @return the {@code NodeDimensions} object
      */
     public NodeDimensions getNodeDimensions() {
         return nodeDimensions;
     }
 
     /**
-     * Sets the <code>TreeModel</code> that will provide the data.
+     * Sets the {@code TreeModel} that will provide the data.
      *
-     * @param newModel the <code>TreeModel</code> that is to
+     * @param newModel the {@code TreeModel} that is to
      *          provide the data
      */
     public void setModel(TreeModel newModel) {
         treeModel = newModel;
     }
 
     /**
-     * Returns the <code>TreeModel</code> that is providing the data.
+     * Returns the {@code TreeModel} that is providing the data.
      *
-     * @return the <code>TreeModel</code> that is providing the data
+     * @return the {@code TreeModel} that is providing the data
      */
     public TreeModel getModel() {
         return treeModel;
     }
 
     /**
      * Determines whether or not the root node from
-     * the <code>TreeModel</code> is visible.
+     * the {@code TreeModel} is visible.
      *
      * @param rootVisible true if the root node of the tree is to be displayed
      * @see #rootVisible
      * @beaninfo
      *        bound: true

@@ -155,14 +155,14 @@
     public int getRowHeight() {
         return rowHeight;
     }
 
     /**
-     * Sets the <code>TreeSelectionModel</code> used to manage the
+     * Sets the {@code TreeSelectionModel} used to manage the
      * selection to new LSM.
      *
-     * @param newLSM  the new <code>TreeSelectionModel</code>
+     * @param newLSM  the new {@code TreeSelectionModel}
      */
     public void setSelectionModel(TreeSelectionModel newLSM) {
         if(treeSelectionModel != null)
             treeSelectionModel.setRowMapper(null);
         treeSelectionModel = newLSM;

@@ -171,11 +171,11 @@
     }
 
     /**
      * Returns the model used to maintain the selection.
      *
-     * @return the <code>treeSelectionModel</code>
+     * @return the {@code treeSelectionModel}
      */
     public TreeSelectionModel getSelectionModel() {
         return treeSelectionModel;
     }
 

@@ -199,13 +199,13 @@
     }
 
     /**
      * Returns the preferred width for the passed in region.
      * The region is defined by the path closest to
-     * <code>(bounds.x, bounds.y)</code> and
-     * ends at <code>bounds.height + bounds.y</code>.
-     * If <code>bounds</code> is <code>null</code>,
+     * {@code (bounds.x, bounds.y)} and
+     * ends at {@code bounds.height + bounds.y}.
+     * If {@code bounds} is {@code null},
      * the preferred width for all the nodes
      * will be returned (and this may be a VERY expensive
      * computation).
      *
      * @param bounds the region being queried

@@ -272,61 +272,61 @@
     public abstract boolean isExpanded(TreePath path);
 
     /**
      * Returns a rectangle giving the bounds needed to draw path.
      *
-     * @param path     a <code>TreePath</code> specifying a node
-     * @param placeIn  a <code>Rectangle</code> object giving the
+     * @param path     a {@code TreePath} specifying a node
+     * @param placeIn  a {@code Rectangle} object giving the
      *          available space
-     * @return a <code>Rectangle</code> object specifying the space to be used
+     * @return a {@code Rectangle} object specifying the space to be used
      */
     public abstract Rectangle getBounds(TreePath path, Rectangle placeIn);
 
     /**
       * Returns the path for passed in row.  If row is not visible
-      * <code>null</code> is returned.
+      * {@code null} is returned.
       *
       * @param row  the row being queried
-      * @return the <code>TreePath</code> for the given row
+      * @return the {@code TreePath} for the given row
       */
     public abstract TreePath getPathForRow(int row);
 
     /**
       * Returns the row that the last item identified in path is visible
       * at.  Will return -1 if any of the elements in path are not
       * currently visible.
       *
-      * @param path the <code>TreePath</code> being queried
+      * @param path the {@code TreePath} being queried
       * @return the row where the last item in path is visible or -1
       *         if any elements in path aren't currently visible
       */
     public abstract int getRowForPath(TreePath path);
 
     /**
       * Returns the path to the node that is closest to x,y.  If
-      * there is nothing currently visible this will return <code>null</code>,
+      * there is nothing currently visible this will return {@code null},
       * otherwise it'll always return a valid path.
       * If you need to test if the
       * returned object is exactly at x, y you should get the bounds for
       * the returned path and test x, y against that.
       *
       * @param x the horizontal component of the desired location
       * @param y the vertical component of the desired location
-      * @return the <code>TreePath</code> closest to the specified point
+      * @return the {@code TreePath} closest to the specified point
       */
     public abstract TreePath getPathClosestTo(int x, int y);
 
     /**
-     * Returns an <code>Enumerator</code> that increments over the visible
+     * Returns an {@code Enumerator} that increments over the visible
      * paths starting at the passed in location. The ordering of the
      * enumeration is based on how the paths are displayed.
      * The first element of the returned enumeration will be path,
      * unless it isn't visible,
-     * in which case <code>null</code> will be returned.
+     * in which case {@code null} will be returned.
      *
      * @param path the starting location for the enumeration
-     * @return the <code>Enumerator</code> starting at the desired location
+     * @return the {@code Enumerator} starting at the desired location
      */
     public abstract Enumeration<TreePath> getVisiblePathsFrom(TreePath path);
 
     /**
      * Returns the number of visible children for row.

@@ -335,12 +335,12 @@
      * @return the number of visible children for the specified path
      */
     public abstract int getVisibleChildCount(TreePath path);
 
     /**
-     * Marks the path <code>path</code> expanded state to
-     * <code>isExpanded</code>.
+     * Marks the path {@code path} expanded state to
+     * {@code isExpanded}.
      *
      * @param path  the path being expanded or collapsed
      * @param isExpanded true if the path should be expanded, false otherwise
      */
     public abstract void setExpandedState(TreePath path, boolean isExpanded);

@@ -359,18 +359,18 @@
      * @return the number of rows being displayed
      */
     public abstract int getRowCount();
 
     /**
-     * Informs the <code>TreeState</code> that it needs to recalculate
+     * Informs the {@code TreeState} that it needs to recalculate
      * all the sizes it is referencing.
      */
     public abstract void invalidateSizes();
 
     /**
-     * Instructs the <code>LayoutCache</code> that the bounds for
-     * <code>path</code> are invalid, and need to be updated.
+     * Instructs the {@code LayoutCache} that the bounds for
+     * {@code path} are invalid, and need to be updated.
      *
      * @param path the path being updated
      */
     public abstract void invalidatePathBounds(TreePath path);
 

@@ -391,22 +391,22 @@
      *
      * <p>e.path() returns the path the parent of the changed node(s).</p>
      *
      * <p>e.childIndices() returns the index(es) of the changed node(s).</p>
      *
-     * @param e  the <code>TreeModelEvent</code>
+     * @param e  the {@code TreeModelEvent}
      */
     public abstract void treeNodesChanged(TreeModelEvent e);
 
     /**
      * <p>Invoked after nodes have been inserted into the tree.</p>
      *
      * <p>e.path() returns the parent of the new nodes</p>
      * <p>e.childIndices() returns the indices of the new nodes in
      * ascending order.</p>
      *
-     * @param e the <code>TreeModelEvent</code>
+     * @param e the {@code TreeModelEvent}
      */
     public abstract void treeNodesInserted(TreeModelEvent e);
 
     /**
      * <p>Invoked after nodes have been removed from the tree.  Note that

@@ -416,45 +416,45 @@
      *
      * <p>e.path() returns the former parent of the deleted nodes.</p>
      *
      * <p>e.childIndices() returns the indices the nodes had before they were deleted in ascending order.</p>
      *
-     * @param e the <code>TreeModelEvent</code>
+     * @param e the {@code TreeModelEvent}
      */
     public abstract void treeNodesRemoved(TreeModelEvent e);
 
     /**
      * <p>Invoked after the tree has drastically changed structure from a
-     * given node down.  If the path returned by <code>e.getPath()</code>
+     * given node down.  If the path returned by {@code e.getPath()}
      * is of length one and the first element does not identify the
      * current root node the first element should become the new root
      * of the tree.</p>
      *
      * <p>e.path() holds the path to the node.</p>
      * <p>e.childIndices() returns null.</p>
      *
-     * @param e the <code>TreeModelEvent</code>
+     * @param e the {@code TreeModelEvent}
      */
     public abstract void treeStructureChanged(TreeModelEvent e);
 
     //
     // RowMapper
     //
 
     /**
-     * Returns the rows that the <code>TreePath</code> instances in
-     * <code>path</code> are being displayed at.
+     * Returns the rows that the {@code TreePath} instances in
+     * {@code path} are being displayed at.
      * This method should return an array of the same length as that passed
-     * in, and if one of the <code>TreePaths</code>
-     * in <code>path</code> is not valid its entry in the array should
+     * in, and if one of the {@code TreePaths}
+     * in {@code path} is not valid its entry in the array should
      * be set to -1.
      *
-     * @param paths the array of <code>TreePath</code>s being queried
+     * @param paths the array of {@code TreePath}s being queried
      * @return an array of the same length that is passed in containing
      *          the rows that each corresponding where each
-     *          <code>TreePath</code> is displayed; if <code>paths</code>
-     *          is <code>null</code>, <code>null</code> is returned
+     *          {@code TreePath} is displayed; if {@code paths}
+     *          is {@code null}, {@code null} is returned
      */
     public int[] getRowsForPaths(TreePath[] paths) {
         if(paths == null)
             return null;
 

@@ -470,25 +470,25 @@
     // Local methods that subclassers may wish to use that are primarly
     // convenience methods.
     //
 
     /**
-     * Returns, by reference in <code>placeIn</code>,
-     * the size needed to represent <code>value</code>.
-     * If <code>inPlace</code> is <code>null</code>, a newly created
-     * <code>Rectangle</code> should be returned, otherwise the value
-     * should be placed in <code>inPlace</code> and returned. This will
-     * return <code>null</code> if there is no renderer.
+     * Returns, by reference in {@code placeIn},
+     * the size needed to represent {@code value}.
+     * If {@code inPlace} is {@code null}, a newly created
+     * {@code Rectangle} should be returned, otherwise the value
+     * should be placed in {@code inPlace} and returned. This will
+     * return {@code null} if there is no renderer.
      *
-     * @param value the <code>value</code> to be represented
+     * @param value the {@code value} to be represented
      * @param row  row being queried
      * @param depth the depth of the row
      * @param expanded true if row is expanded, false otherwise
-     * @param placeIn  a <code>Rectangle</code> containing the size needed
-     *          to represent <code>value</code>
-     * @return a <code>Rectangle</code> containing the node dimensions,
-     *          or <code>null</code> if node has no dimension
+     * @param placeIn  a {@code Rectangle} containing the size needed
+     *          to represent {@code value}
+     * @return a {@code Rectangle} containing the node dimensions,
+     *          or {@code null} if node has no dimension
      */
     protected Rectangle getNodeDimensions(Object value, int row, int depth,
                                           boolean expanded,
                                           Rectangle placeIn) {
         NodeDimensions            nd = getNodeDimensions();

@@ -508,29 +508,29 @@
         return (rowHeight > 0);
     }
 
 
     /**
-     * Used by <code>AbstractLayoutCache</code> to determine the size
+     * Used by {@code AbstractLayoutCache} to determine the size
      * and x origin of a particular node.
      */
     public abstract static class NodeDimensions {
         /**
          * Returns, by reference in bounds, the size and x origin to
          * place value at. The calling method is responsible for determining
-         * the Y location. If bounds is <code>null</code>, a newly created
-         * <code>Rectangle</code> should be returned,
+         * the Y location. If bounds is {@code null}, a newly created
+         * {@code Rectangle} should be returned,
          * otherwise the value should be placed in bounds and returned.
          *
-         * @param value the <code>value</code> to be represented
+         * @param value the {@code value} to be represented
          * @param row row being queried
          * @param depth the depth of the row
          * @param expanded true if row is expanded, false otherwise
-         * @param bounds  a <code>Rectangle</code> containing the size needed
-         *              to represent <code>value</code>
-         * @return a <code>Rectangle</code> containing the node dimensions,
-         *              or <code>null</code> if node has no dimension
+         * @param bounds  a {@code Rectangle} containing the size needed
+         *              to represent {@code value}
+         * @return a {@code Rectangle} containing the node dimensions,
+         *              or {@code null} if node has no dimension
          */
         public abstract Rectangle getNodeDimensions(Object value, int row,
                                                     int depth,
                                                     boolean expanded,
                                                     Rectangle bounds);
< prev index next >