< prev index next >
src/java.desktop/share/classes/javax/swing/JTree.java
Print this page
@@ -46,43 +46,43 @@
* You can find task-oriented documentation and examples of using trees in
* <a href="http://docs.oracle.com/javase/tutorial/uiswing/components/tree.html">How to Use Trees</a>,
* a section in <em>The Java Tutorial.</em>
* <p>
* A specific node in a tree can be identified either by a
- * <code>TreePath</code> (an object
+ * {@code TreePath} (an object
* that encapsulates a node and all of its ancestors), or by its
* display row, where each row in the display area displays one node.
* An <i>expanded</i> node is a non-leaf node (as identified by
- * <code>TreeModel.isLeaf(node)</code> returning false) that will displays
+ * {@code TreeModel.isLeaf(node)} returning false) that will displays
* its children when all its ancestors are <i>expanded</i>.
* A <i>collapsed</i>
* node is one which hides them. A <i>hidden</i> node is one which is
* under a collapsed ancestor. All of a <i>viewable</i> nodes parents
* are expanded, but may or may not be displayed. A <i>displayed</i> node
* is both viewable and in the display area, where it can be seen.
* </p>
- * The following <code>JTree</code> methods use "visible" to mean "displayed":
+ * The following {@code JTree} methods use "visible" to mean "displayed":
* <ul>
- * <li><code>isRootVisible()</code>
- * <li><code>setRootVisible()</code>
- * <li><code>scrollPathToVisible()</code>
- * <li><code>scrollRowToVisible()</code>
- * <li><code>getVisibleRowCount()</code>
- * <li><code>setVisibleRowCount()</code>
+ * <li>{@code isRootVisible()}
+ * <li>{@code setRootVisible()}
+ * <li>{@code scrollPathToVisible()}
+ * <li>{@code scrollRowToVisible()}
+ * <li>{@code getVisibleRowCount()}
+ * <li>{@code setVisibleRowCount()}
* </ul>
- * The next group of <code>JTree</code> methods use "visible" to mean
+ * The next group of {@code JTree} methods use "visible" to mean
* "viewable" (under an expanded parent):
* <ul>
- * <li><code>isVisible()</code>
- * <li><code>makeVisible()</code>
+ * <li>{@code isVisible()}
+ * <li>{@code makeVisible()}
* </ul>
* If you are interested in knowing when the selection changes implement
- * the <code>TreeSelectionListener</code> interface and add the instance
- * using the method <code>addTreeSelectionListener</code>.
- * <code>valueChanged</code> will be invoked when the
+ * the {@code TreeSelectionListener} interface and add the instance
+ * using the method {@code addTreeSelectionListener}.
+ * {@code valueChanged} will be invoked when the
* selection changes, that is if the user clicks twice on the same
- * node <code>valueChanged</code> will only be invoked once.
+ * node {@code valueChanged} will only be invoked once.
* <p>
* If you are interested in detecting either double-click events or when
* a user clicks on a node, regardless of whether or not it was selected,
* we recommend you do the following:
* </p>
@@ -106,18 +106,18 @@
* tree.addMouseListener(ml);
* </pre>
* NOTE: This example obtains both the path and row, but you only need to
* get the one you're interested in.
* <p>
- * To use <code>JTree</code> to display compound nodes
+ * To use {@code JTree} to display compound nodes
* (for example, nodes containing both
* a graphic icon and text), subclass {@link TreeCellRenderer} and use
* {@link #setCellRenderer} to tell the tree to use it. To edit such nodes,
* subclass {@link TreeCellEditor} and use {@link #setCellEditor}.
* </p>
* <p>
- * Like all <code>JComponent</code> classes, you can use {@link InputMap} and
+ * Like all {@code JComponent} classes, you can use {@link InputMap} and
* {@link ActionMap}
* to associate an {@link Action} object with a {@link KeyStroke}
* and execute the action under specified conditions.
* </p>
* <strong>Warning:</strong> Swing is not thread safe. For more
@@ -129,11 +129,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}.
*</p>
* @beaninfo
* attribute: isContainer false
* description: A component that displays a set of hierarchical data as an outline.
@@ -167,12 +167,12 @@
* the highest visible nodes.
*/
protected boolean rootVisible;
/**
- * The cell used to draw nodes. If <code>null</code>, the UI uses a default
- * <code>cellRenderer</code>.
+ * The cell used to draw nodes. If {@code null}, the UI uses a default
+ * {@code cellRenderer}.
*/
protected transient TreeCellRenderer cellRenderer;
/**
* Height to use for each display row. If this is <= 0 the renderer
@@ -180,11 +180,11 @@
*/
protected int rowHeight;
private boolean rowHeightSet = false;
/**
- * Maps from <code>TreePath</code> to <code>Boolean</code>
+ * Maps from {@code TreePath} to {@code Boolean}
* indicating whether or not the
* particular path is expanded. This ONLY indicates whether a
* given path is expanded, and NOT if it is visible or not. That
* information must be determined by visiting all the parent
* paths and seeing if they are visible.
@@ -199,11 +199,11 @@
* allows the user to click once to expand or collapse the node. A
* common interface shows a plus sign (+) for a node which can be
* expanded and a minus sign (-) for a node which can be collapsed.
* Handles are always shown for nodes below the topmost level.
* <p>
- * If the <code>rootVisible</code> setting specifies that the root
+ * If the {@code rootVisible} setting specifies that the root
* node is to be displayed, then that is the only node at the topmost
* level. If the root node is not displayed, then all of its
* children are at the topmost level of the tree. Handles are
* always displayed for nodes other than the topmost.
* <p>
@@ -217,16 +217,16 @@
protected boolean showsRootHandles;
private boolean showsRootHandlesSet = false;
/**
* Creates a new event and passed it off the
- * <code>selectionListeners</code>.
+ * {@code selectionListeners}.
*/
protected transient TreeSelectionRedirector selectionRedirector;
/**
- * Editor for the entries. Default is <code>null</code>
+ * Editor for the entries. Default is {@code null}
* (tree is not editable).
*/
protected transient TreeCellEditor cellEditor;
/**
@@ -246,20 +246,20 @@
*/
protected boolean largeModel;
/**
* Number of rows to make visible at one time. This value is used for
- * the <code>Scrollable</code> interface. It determines the preferred
+ * the {@code Scrollable} interface. It determines the preferred
* size of the display area.
*/
protected int visibleRowCount;
/**
* If true, when editing is to be stopped by way of selection changing,
- * data in tree changing or other means <code>stopCellEditing</code>
+ * data in tree changing or other means {@code stopCellEditing}
* is invoked, and changes are saved. If false,
- * <code>cancelCellEditing</code> is invoked, and changes
+ * {@code cancelCellEditing} is invoked, and changes
* are discarded. Default is false.
*/
protected boolean invokesStopCellEditing;
/**
@@ -273,22 +273,22 @@
* Number of mouse clicks before a node is expanded.
*/
protected int toggleClickCount;
/**
- * Updates the <code>expandedState</code>.
+ * Updates the {@code expandedState}.
*/
protected transient TreeModelListener treeModelListener;
/**
- * Used when <code>setExpandedState</code> is invoked,
- * will be a <code>Stack</code> of <code>Stack</code>s.
+ * Used when {@code setExpandedState} is invoked,
+ * will be a {@code Stack} of {@code Stack}s.
*/
private transient Stack<Stack<TreePath>> expandedStack;
/**
- * Lead selection path, may not be <code>null</code>.
+ * Lead selection path, may not be {@code null}.
*/
private TreePath leadPath;
/**
* Anchor path.
@@ -299,11 +299,11 @@
* True if paths in the selection should be expanded.
*/
private boolean expandsSelectedPaths;
/**
- * This is set to true for the life of the <code>setUI</code> call.
+ * This is set to true for the life of the {@code setUI} call.
*/
private boolean settingUI;
/** If true, mouse presses on selections initiate a drag operation. */
private boolean dragEnabled;
@@ -317,12 +317,12 @@
* The drop location.
*/
private transient DropLocation dropLocation;
/**
- * A subclass of <code>TransferHandler.DropLocation</code> representing
- * a drop location for a <code>JTree</code>.
+ * A subclass of {@code TransferHandler.DropLocation} representing
+ * a drop location for a {@code JTree}.
*
* @see #getDropLocation
* @since 1.6
*/
public static final class DropLocation extends TransferHandler.DropLocation {
@@ -335,27 +335,27 @@
this.index = index;
}
/**
* Returns the index where the dropped data should be inserted
- * with respect to the path returned by <code>getPath()</code>.
+ * with respect to the path returned by {@code getPath()}.
* <p>
- * For drop modes <code>DropMode.USE_SELECTION</code> and
- * <code>DropMode.ON</code>, this index is unimportant (and it will
- * always be <code>-1</code>) as the only interesting data is the
+ * For drop modes {@code DropMode.USE_SELECTION} and
+ * {@code DropMode.ON}, this index is unimportant (and it will
+ * always be {@code -1}) as the only interesting data is the
* path over which the drop operation occurred.
* <p>
- * For drop mode <code>DropMode.INSERT</code>, this index
+ * For drop mode {@code DropMode.INSERT}, this index
* indicates the index at which the data should be inserted into
- * the parent path represented by <code>getPath()</code>.
- * <code>-1</code> indicates that the drop occurred over the
+ * the parent path represented by {@code getPath()}.
+ * {@code -1} indicates that the drop occurred over the
* parent itself, and in most cases should be treated as inserting
* into either the beginning or the end of the parent's list of
* children.
* <p>
- * For <code>DropMode.ON_OR_INSERT</code>, this value will be
- * an insert index, as described above, or <code>-1</code> if
+ * For {@code DropMode.ON_OR_INSERT}, this value will be
+ * an insert index, as described above, or {@code -1} if
* the drop occurred over the path itself.
*
* @return the child index
* @see #getPath
*/
@@ -366,36 +366,36 @@
/**
* Returns the path where dropped data should be placed in the
* tree.
* <p>
* Interpretation of this value depends on the drop mode set on the
- * component. If the drop mode is <code>DropMode.USE_SELECTION</code>
- * or <code>DropMode.ON</code>, the return value is the path in the
+ * component. If the drop mode is {@code DropMode.USE_SELECTION}
+ * or {@code DropMode.ON}, the return value is the path in the
* tree over which the data has been (or will be) dropped.
- * <code>null</code> indicates that the drop is over empty space,
+ * {@code null} indicates that the drop is over empty space,
* not associated with a particular path.
* <p>
- * If the drop mode is <code>DropMode.INSERT</code>, the return value
+ * If the drop mode is {@code DropMode.INSERT}, the return value
* refers to the path that should become the parent of the new data,
- * in which case <code>getChildIndex()</code> indicates where the
+ * in which case {@code getChildIndex()} indicates where the
* new item should be inserted into this parent path. A
- * <code>null</code> path indicates that no parent path has been
+ * {@code null} path indicates that no parent path has been
* determined, which can happen for multiple reasons:
* <ul>
* <li>The tree has no model
* <li>There is no root in the tree
* <li>The root is collapsed
* <li>The root is a leaf node
* </ul>
* It is up to the developer to decide if and how they wish to handle
- * the <code>null</code> case.
+ * the {@code null} case.
* <p>
- * If the drop mode is <code>DropMode.ON_OR_INSERT</code>,
- * <code>getChildIndex</code> can be used to determine whether the
- * drop is on top of the path itself (<code>-1</code>) or the index
+ * If the drop mode is {@code DropMode.ON_OR_INSERT},
+ * {@code getChildIndex} can be used to determine whether the
+ * drop is on top of the path itself ({@code -1}) or the index
* at which it should be inserted into the path (values other than
- * <code>-1</code>).
+ * {@code -1}).
*
* @return the drop path
* @see #getChildIndex
*/
public TreePath getPath() {
@@ -439,14 +439,14 @@
* A timer to expand nodes during drop.
*/
private TreeTimer dropTimer;
/**
- * When <code>addTreeExpansionListener</code> is invoked,
- * and <code>settingUI</code> is true, this ivar gets set to the passed in
- * <code>Listener</code>. This listener is then notified first in
- * <code>fireTreeCollapsed</code> and <code>fireTreeExpanded</code>.
+ * When {@code addTreeExpansionListener} is invoked,
+ * and {@code settingUI} is true, this ivar gets set to the passed in
+ * {@code Listener}. This listener is then notified first in
+ * {@code fireTreeCollapsed} and {@code fireTreeExpanded}.
* <p>This is an ugly workaround for a way to have the UI listener
* get notified before other listeners.
*/
private transient TreeExpansionListener uiTreeExpansionListener;
@@ -456,37 +456,37 @@
private static int TEMP_STACK_SIZE = 11;
//
// Bound property names
//
- /** Bound property name for <code>cellRenderer</code>. */
+ /** Bound property name for {@code cellRenderer}. */
public static final String CELL_RENDERER_PROPERTY = "cellRenderer";
- /** Bound property name for <code>treeModel</code>. */
+ /** Bound property name for {@code treeModel}. */
public static final String TREE_MODEL_PROPERTY = "model";
- /** Bound property name for <code>rootVisible</code>. */
+ /** Bound property name for {@code rootVisible}. */
public static final String ROOT_VISIBLE_PROPERTY = "rootVisible";
- /** Bound property name for <code>showsRootHandles</code>. */
+ /** Bound property name for {@code showsRootHandles}. */
public static final String SHOWS_ROOT_HANDLES_PROPERTY = "showsRootHandles";
- /** Bound property name for <code>rowHeight</code>. */
+ /** Bound property name for {@code rowHeight}. */
public static final String ROW_HEIGHT_PROPERTY = "rowHeight";
- /** Bound property name for <code>cellEditor</code>. */
+ /** Bound property name for {@code cellEditor}. */
public static final String CELL_EDITOR_PROPERTY = "cellEditor";
- /** Bound property name for <code>editable</code>. */
+ /** Bound property name for {@code editable}. */
public static final String EDITABLE_PROPERTY = "editable";
- /** Bound property name for <code>largeModel</code>. */
+ /** Bound property name for {@code largeModel}. */
public static final String LARGE_MODEL_PROPERTY = "largeModel";
/** Bound property name for selectionModel. */
public static final String SELECTION_MODEL_PROPERTY = "selectionModel";
- /** Bound property name for <code>visibleRowCount</code>. */
+ /** Bound property name for {@code visibleRowCount}. */
public static final String VISIBLE_ROW_COUNT_PROPERTY = "visibleRowCount";
- /** Bound property name for <code>messagesStopCellEditing</code>. */
+ /** Bound property name for {@code messagesStopCellEditing}. */
public static final String INVOKES_STOP_CELL_EDITING_PROPERTY = "invokesStopCellEditing";
- /** Bound property name for <code>scrollsOnExpand</code>. */
+ /** Bound property name for {@code scrollsOnExpand}. */
public static final String SCROLLS_ON_EXPAND_PROPERTY = "scrollsOnExpand";
- /** Bound property name for <code>toggleClickCount</code>. */
+ /** Bound property name for {@code toggleClickCount}. */
public static final String TOGGLE_CLICK_COUNT_PROPERTY = "toggleClickCount";
- /** Bound property name for <code>leadSelectionPath</code>.
+ /** Bound property name for {@code leadSelectionPath}.
* @since 1.3 */
public static final String LEAD_SELECTION_PATH_PROPERTY = "leadSelectionPath";
/** Bound property name for anchor selection path.
* @since 1.3 */
public static final String ANCHOR_SELECTION_PATH_PROPERTY = "anchorSelectionPath";
@@ -494,14 +494,14 @@
* @since 1.3 */
public static final String EXPANDS_SELECTED_PATHS_PROPERTY = "expandsSelectedPaths";
/**
- * Creates and returns a sample <code>TreeModel</code>.
+ * Creates and returns a sample {@code TreeModel}.
* Used primarily for beanbuilders to show something interesting.
*
- * @return the default <code>TreeModel</code>
+ * @return the default {@code TreeModel}
*/
protected static TreeModel getDefaultTreeModel() {
DefaultMutableTreeNode root = new DefaultMutableTreeNode("JTree");
DefaultMutableTreeNode parent;
@@ -527,22 +527,22 @@
parent.add(new DefaultMutableTreeNode("bananas"));
return new DefaultTreeModel(root);
}
/**
- * Returns a <code>TreeModel</code> wrapping the specified object.
+ * Returns a {@code TreeModel} wrapping the specified object.
* If the object is:<ul>
- * <li>an array of <code>Object</code>s,
- * <li>a <code>Hashtable</code>, or
- * <li>a <code>Vector</code>
+ * <li>an array of {@code Object}s,
+ * <li>a {@code Hashtable}, or
+ * <li>a {@code Vector}
* </ul>then a new root node is created with each of the incoming
* objects as children. Otherwise, a new root is created with
* a value of {@code "root"}.
*
- * @param value the <code>Object</code> used as the foundation for
- * the <code>TreeModel</code>
- * @return a <code>TreeModel</code> wrapping the specified object
+ * @param value the {@code Object} used as the foundation for
+ * the {@code TreeModel}
+ * @return a {@code TreeModel} wrapping the specified object
*/
protected static TreeModel createTreeModel(Object value) {
DefaultMutableTreeNode root;
if((value instanceof Object[]) || (value instanceof Hashtable) ||
@@ -555,104 +555,104 @@
}
return new DefaultTreeModel(root, false);
}
/**
- * Returns a <code>JTree</code> with a sample model.
+ * Returns a {@code JTree} with a sample model.
* The default model used by the tree defines a leaf node as any node
* without children.
*
* @see DefaultTreeModel#asksAllowsChildren
*/
public JTree() {
this(getDefaultTreeModel());
}
/**
- * Returns a <code>JTree</code> with each element of the
+ * Returns a {@code JTree} with each element of the
* specified array as the
* child of a new root node which is not displayed.
* By default, the tree defines a leaf node as any node without
* children.
*
- * @param value an array of <code>Object</code>s
+ * @param value an array of {@code Object}s
* @see DefaultTreeModel#asksAllowsChildren
*/
public JTree(Object[] value) {
this(createTreeModel(value));
this.setRootVisible(false);
this.setShowsRootHandles(true);
expandRoot();
}
/**
- * Returns a <code>JTree</code> with each element of the specified
- * <code>Vector</code> as the
+ * Returns a {@code JTree} with each element of the specified
+ * {@code Vector} as the
* child of a new root node which is not displayed. By default, the
* tree defines a leaf node as any node without children.
*
- * @param value a <code>Vector</code>
+ * @param value a {@code Vector}
* @see DefaultTreeModel#asksAllowsChildren
*/
public JTree(Vector<?> value) {
this(createTreeModel(value));
this.setRootVisible(false);
this.setShowsRootHandles(true);
expandRoot();
}
/**
- * Returns a <code>JTree</code> created from a <code>Hashtable</code>
+ * Returns a {@code JTree} created from a {@code Hashtable}
* which does not display with root.
- * Each value-half of the key/value pairs in the <code>HashTable</code>
+ * Each value-half of the key/value pairs in the {@code HashTable}
* becomes a child of the new root node. By default, the tree defines
* a leaf node as any node without children.
*
- * @param value a <code>Hashtable</code>
+ * @param value a {@code Hashtable}
* @see DefaultTreeModel#asksAllowsChildren
*/
public JTree(Hashtable<?,?> value) {
this(createTreeModel(value));
this.setRootVisible(false);
this.setShowsRootHandles(true);
expandRoot();
}
/**
- * Returns a <code>JTree</code> with the specified
- * <code>TreeNode</code> as its root,
+ * Returns a {@code JTree} with the specified
+ * {@code TreeNode} as its root,
* which displays the root node.
* By default, the tree defines a leaf node as any node without children.
*
- * @param root a <code>TreeNode</code> object
+ * @param root a {@code TreeNode} object
* @see DefaultTreeModel#asksAllowsChildren
*/
public JTree(TreeNode root) {
this(root, false);
}
/**
- * Returns a <code>JTree</code> with the specified <code>TreeNode</code>
+ * Returns a {@code JTree} with the specified {@code TreeNode}
* as its root, which
* displays the root node and which decides whether a node is a
* leaf node in the specified manner.
*
- * @param root a <code>TreeNode</code> object
+ * @param root a {@code TreeNode} object
* @param asksAllowsChildren if false, any node without children is a
* leaf node; if true, only nodes that do not allow
* children are leaf nodes
* @see DefaultTreeModel#asksAllowsChildren
*/
public JTree(TreeNode root, boolean asksAllowsChildren) {
this(new DefaultTreeModel(root, asksAllowsChildren));
}
/**
- * Returns an instance of <code>JTree</code> which displays the root node
+ * Returns an instance of {@code JTree} which displays the root node
* -- the tree is created using the specified data model.
*
- * @param newModel the <code>TreeModel</code> to use as the data model
+ * @param newModel the {@code TreeModel} to use as the data model
*/
@ConstructorProperties({"model"})
public JTree(TreeModel newModel) {
super();
expandedStack = new Stack<Stack<TreePath>>();
@@ -672,22 +672,22 @@
}
/**
* Returns the L&F object that renders this component.
*
- * @return the <code>TreeUI</code> object that renders this component
+ * @return the {@code TreeUI} object that renders this component
*/
public TreeUI getUI() {
return (TreeUI)ui;
}
/**
* Sets the L&F object that renders this component.
* <p>
* This is a bound property.
*
- * @param ui the <code>TreeUI</code> L&F object
+ * @param ui the {@code TreeUI} L&F object
* @see UIDefaults#getUI
* @beaninfo
* bound: true
* hidden: true
* attribute: visualUpdate true
@@ -705,13 +705,13 @@
}
}
}
/**
- * Notification from the <code>UIManager</code> that the L&F has changed.
+ * Notification from the {@code UIManager} that the L&F has changed.
* Replaces the current UI object with the latest version from the
- * <code>UIManager</code>.
+ * {@code UIManager}.
*
* @see JComponent#updateUI
*/
public void updateUI() {
setUI((TreeUI)UIManager.getUI(this));
@@ -732,26 +732,26 @@
return uiClassID;
}
/**
- * Returns the current <code>TreeCellRenderer</code>
+ * Returns the current {@code TreeCellRenderer}
* that is rendering each cell.
*
- * @return the <code>TreeCellRenderer</code> that is rendering each cell
+ * @return the {@code TreeCellRenderer} that is rendering each cell
*/
public TreeCellRenderer getCellRenderer() {
return cellRenderer;
}
/**
- * Sets the <code>TreeCellRenderer</code> that will be used to
+ * Sets the {@code TreeCellRenderer} that will be used to
* draw each cell.
* <p>
* This is a bound property.
*
- * @param x the <code>TreeCellRenderer</code> that is to render each cell
+ * @param x the {@code TreeCellRenderer} that is to render each cell
* @beaninfo
* bound: true
* description: The TreeCellRenderer that will be used to draw
* each cell.
*/
@@ -796,18 +796,18 @@
public boolean isEditable() {
return editable;
}
/**
- * Sets the cell editor. A <code>null</code> value implies that the
+ * Sets the cell editor. A {@code null} value implies that the
* tree cannot be edited. If this represents a change in the
- * <code>cellEditor</code>, the <code>propertyChange</code>
+ * {@code cellEditor}, the {@code propertyChange}
* method is invoked on all listeners.
* <p>
* This is a bound property.
*
- * @param cellEditor the <code>TreeCellEditor</code> to use
+ * @param cellEditor the {@code TreeCellEditor} to use
* @beaninfo
* bound: true
* description: The cell editor. A null value implies the tree
* cannot be edited.
*/
@@ -820,32 +820,32 @@
}
/**
* Returns the editor used to edit entries in the tree.
*
- * @return the <code>TreeCellEditor</code> in use,
- * or <code>null</code> if the tree cannot be edited
+ * @return the {@code TreeCellEditor} in use,
+ * or {@code null} if the tree cannot be edited
*/
public TreeCellEditor getCellEditor() {
return cellEditor;
}
/**
- * 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;
}
/**
- * Sets the <code>TreeModel</code> that will provide the data.
+ * Sets the {@code TreeModel} that will provide the data.
* <p>
* This is a bound property.
*
- * @param newModel the <code>TreeModel</code> that is to provide the data
+ * @param newModel the {@code TreeModel} that is to provide the data
* @beaninfo
* bound: true
* description: The TreeModel that will provide the data.
*/
public void setModel(TreeModel newModel) {
@@ -895,11 +895,11 @@
return rootVisible;
}
/**
* Determines whether or not the root node from
- * the <code>TreeModel</code> is visible.
+ * the {@code TreeModel} is visible.
* <p>
* This is a bound property.
*
* @param rootVisible true if the root node of the tree is to be displayed
* @see #rootVisible
@@ -917,21 +917,21 @@
((AccessibleJTree)accessibleContext).fireVisibleDataPropertyChange();
}
}
/**
- * Sets the value of the <code>showsRootHandles</code> property,
+ * Sets the value of the {@code showsRootHandles} property,
* which specifies whether the node handles should be displayed.
* The default value of this property depends on the constructor
- * used to create the <code>JTree</code>.
+ * used to create the {@code JTree}.
* Some look and feels might not support handles;
* they will ignore this property.
* <p>
* This is a bound property.
*
- * @param newValue <code>true</code> if root handles should be displayed;
- * otherwise, <code>false</code>
+ * @param newValue {@code true} if root handles should be displayed;
+ * otherwise, {@code false}
* @see #showsRootHandles
* @see #getShowsRootHandles
* @beaninfo
* bound: true
* description: Whether the node handles are to be
@@ -950,13 +950,13 @@
}
invalidate();
}
/**
- * Returns the value of the <code>showsRootHandles</code> property.
+ * Returns the value of the {@code showsRootHandles} property.
*
- * @return the value of the <code>showsRootHandles</code> property
+ * @return the value of the {@code showsRootHandles} property
* @see #showsRootHandles
*/
public boolean getShowsRootHandles()
{
return showsRootHandles;
@@ -1038,18 +1038,18 @@
}
/**
* Determines what happens when editing is interrupted by selecting
* another node in the tree, a change in the tree's data, or by some
- * other means. Setting this property to <code>true</code> causes the
+ * other means. Setting this property to {@code true} causes the
* changes to be automatically saved when editing is interrupted.
* <p>
* Fires a property change for the INVOKES_STOP_CELL_EDITING_PROPERTY.
*
- * @param newValue true means that <code>stopCellEditing</code> is invoked
+ * @param newValue true means that {@code stopCellEditing} is invoked
* when editing is interrupted, and data is saved; false means that
- * <code>cancelCellEditing</code> is invoked, and changes are lost
+ * {@code cancelCellEditing} is invoked, and changes are lost
* @beaninfo
* bound: true
* description: Determines what happens when editing is interrupted,
* selecting another node in the tree, a change in the
* tree's data, or some other means.
@@ -1073,24 +1073,24 @@
public boolean getInvokesStopCellEditing() {
return invokesStopCellEditing;
}
/**
- * Sets the <code>scrollsOnExpand</code> property,
+ * Sets the {@code scrollsOnExpand} property,
* which determines whether the
* tree might scroll to show previously hidden children.
- * If this property is <code>true</code> (the default),
+ * If this property is {@code true} (the default),
* when a node expands
* the tree can use scrolling to make
* the maximum possible number of the node's descendants visible.
* In some look and feels, trees might not need to scroll when expanded;
* those look and feels will ignore this property.
* <p>
* This is a bound property.
*
- * @param newValue <code>false</code> to disable scrolling on expansion;
- * <code>true</code> to enable it
+ * @param newValue {@code false} to disable scrolling on expansion;
+ * {@code true} to enable it
* @see #getScrollsOnExpand
*
* @beaninfo
* bound: true
* description: Indicates if a node descendant should be scrolled when expanded.
@@ -1103,13 +1103,13 @@
firePropertyChange(SCROLLS_ON_EXPAND_PROPERTY, oldValue,
newValue);
}
/**
- * Returns the value of the <code>scrollsOnExpand</code> property.
+ * Returns the value of the {@code scrollsOnExpand} property.
*
- * @return the value of the <code>scrollsOnExpand</code> property
+ * @return the value of the {@code scrollsOnExpand} property
*/
public boolean getScrollsOnExpand() {
return scrollsOnExpand;
}
@@ -1142,24 +1142,24 @@
public int getToggleClickCount() {
return toggleClickCount;
}
/**
- * Configures the <code>expandsSelectedPaths</code> property. If
+ * Configures the {@code expandsSelectedPaths} property. If
* true, any time the selection is changed, either via the
- * <code>TreeSelectionModel</code>, or the cover methods provided by
- * <code>JTree</code>, the <code>TreePath</code>s parents will be
+ * {@code TreeSelectionModel}, or the cover methods provided by
+ * {@code JTree}, the {@code TreePath}s parents will be
* expanded to make them visible (visible meaning the parent path is
* expanded, not necessarily in the visible rectangle of the
- * <code>JTree</code>). If false, when the selection
+ * {@code JTree}). If false, when the selection
* changes the nodes parent is not made visible (all its parents expanded).
* This is useful if you wish to have your selection model maintain paths
* that are not always visible (all parents expanded).
* <p>
* This is a bound property.
*
- * @param newValue the new value for <code>expandsSelectedPaths</code>
+ * @param newValue the new value for {@code expandsSelectedPaths}
*
* @since 1.3
* @beaninfo
* bound: true
* description: Indicates whether changes to the selection should make
@@ -1172,11 +1172,11 @@
firePropertyChange(EXPANDS_SELECTED_PATHS_PROPERTY, oldValue,
newValue);
}
/**
- * Returns the <code>expandsSelectedPaths</code> property.
+ * Returns the {@code expandsSelectedPaths} property.
* @return true if selection changes result in the parent path being
* expanded
* @since 1.3
* @see #setExpandsSelectedPaths
*/
@@ -1202,13 +1202,13 @@
* begin a drag and drop operation by calling {@code exportAsDrag} on the
* tree's {@code TransferHandler}.
*
* @param b whether or not to enable automatic drag handling
* @exception HeadlessException if
- * <code>b</code> is <code>true</code> and
- * <code>GraphicsEnvironment.isHeadless()</code>
- * returns <code>true</code>
+ * {@code b} is {@code true} and
+ * {@code GraphicsEnvironment.isHeadless()}
+ * returns {@code true}
* @see java.awt.GraphicsEnvironment#isHeadless
* @see #getDragEnabled
* @see #setTransferHandler
* @see TransferHandler
* @since 1.4
@@ -1239,30 +1239,30 @@
return dragEnabled;
}
/**
* Sets the drop mode for this component. For backward compatibility,
- * the default for this property is <code>DropMode.USE_SELECTION</code>.
+ * the default for this property is {@code DropMode.USE_SELECTION}.
* Usage of one of the other modes is recommended, however, for an
- * improved user experience. <code>DropMode.ON</code>, for instance,
+ * improved user experience. {@code DropMode.ON}, for instance,
* offers similar behavior of showing items as selected, but does so without
* affecting the actual selection in the tree.
* <p>
- * <code>JTree</code> supports the following drop modes:
+ * {@code JTree} supports the following drop modes:
* <ul>
- * <li><code>DropMode.USE_SELECTION</code></li>
- * <li><code>DropMode.ON</code></li>
- * <li><code>DropMode.INSERT</code></li>
- * <li><code>DropMode.ON_OR_INSERT</code></li>
+ * <li>{@code DropMode.USE_SELECTION}</li>
+ * <li>{@code DropMode.ON}</li>
+ * <li>{@code DropMode.INSERT}</li>
+ * <li>{@code DropMode.ON_OR_INSERT}</li>
* </ul>
* <p>
* The drop mode is only meaningful if this component has a
- * <code>TransferHandler</code> that accepts drops.
+ * {@code TransferHandler} that accepts drops.
*
* @param dropMode the drop mode to use
* @throws IllegalArgumentException if the drop mode is unsupported
- * or <code>null</code>
+ * or {@code null}
* @see #getDropMode
* @see #getDropLocation
* @see #setTransferHandler
* @see TransferHandler
* @since 1.6
@@ -1301,11 +1301,11 @@
/**
* Calculates a drop location in this component, representing where a
* drop at the given point should insert data.
*
* @param p the point to calculate a drop location for
- * @return the drop location, or <code>null</code>
+ * @return the drop location, or {@code null}
*/
DropLocation dropLocationForPoint(Point p) {
DropLocation location = null;
int row = getClosestRowForLocation(p.x, p.y);
@@ -1423,24 +1423,24 @@
* a drop index). It can return a state object to the caller encapsulating
* any saved selection state. On a second call, let's say the drop location
* is being changed to something else. The component doesn't need to
* restore anything yet, so it simply passes back the same state object
* to have the DnD system continue storing it. Finally, let's say this
- * method is messaged with <code>null</code>. This means DnD
+ * method is messaged with {@code null}. This means DnD
* is finished with this component for now, meaning it should restore
* state. At this point, it can use the state parameter to restore
- * said state, and of course return <code>null</code> since there's
+ * said state, and of course return {@code null} since there's
* no longer anything to store.
*
* @param location the drop location (as calculated by
- * <code>dropLocationForPoint</code>) or <code>null</code>
+ * {@code dropLocationForPoint}) or {@code null}
* if there's no longer a valid drop location
* @param state the state object saved earlier for this component,
- * or <code>null</code>
+ * or {@code null}
* @param forDrop whether or not the method is being called because an
* actual drop occurred
- * @return any saved state for this component, or <code>null</code> if none
+ * @return any saved state for this component, or {@code null} if none
*/
Object setDropLocation(TransferHandler.DropLocation location,
Object state,
boolean forDrop) {
@@ -1492,11 +1492,11 @@
* as the drop location during a DnD operation over the component,
* or {@code null} if no location is to currently be shown.
* <p>
* This method is not meant for querying the drop location
* from a {@code TransferHandler}, as the drop location is only
- * set after the {@code TransferHandler}'s <code>canImport</code>
+ * set after the {@code TransferHandler}'s {@code canImport}
* has returned and has allowed for the location to be shown.
* <p>
* When this property changes, a property change event with
* name "dropLocation" is fired by the component.
*
@@ -1522,11 +1522,11 @@
dropTimer.stop();
}
}
/**
- * Returns <code>isEditable</code>. This is invoked from the UI before
+ * Returns {@code isEditable}. This is invoked from the UI before
* editing begins to insure that the given path can be edited. This
* is provided as an entry point for subclassers to add filtered
* editing without having to resort to creating a new editor.
*
* @param path a {@code TreePath} identifying a node
@@ -1536,24 +1536,24 @@
public boolean isPathEditable(TreePath path) {
return isEditable();
}
/**
- * Overrides <code>JComponent</code>'s <code>getToolTipText</code>
+ * Overrides {@code JComponent}'s {@code getToolTipText}
* method in order to allow
* renderer's tips to be used if it has text set.
* <p>
- * NOTE: For <code>JTree</code> to properly display tooltips of its
- * renderers, <code>JTree</code> must be a registered component with the
- * <code>ToolTipManager</code>. This can be done by invoking
- * <code>ToolTipManager.sharedInstance().registerComponent(tree)</code>.
+ * NOTE: For {@code JTree} to properly display tooltips of its
+ * renderers, {@code JTree} must be a registered component with the
+ * {@code ToolTipManager}. This can be done by invoking
+ * {@code ToolTipManager.sharedInstance().registerComponent(tree)}.
* This is not done automatically!
*
- * @param event the <code>MouseEvent</code> that initiated the
- * <code>ToolTip</code> display
- * @return a string containing the tooltip or <code>null</code>
- * if <code>event</code> is null
+ * @param event the {@code MouseEvent} that initiated the
+ * {@code ToolTip} display
+ * @return a string containing the tooltip or {@code null}
+ * if {@code event} is null
*/
public String getToolTipText(MouseEvent event) {
String tip = null;
if(event != null) {
@@ -1595,22 +1595,22 @@
return tip;
}
/**
* Called by the renderers to convert the specified value to
- * text. This implementation returns <code>value.toString</code>, ignoring
+ * text. This implementation returns {@code value.toString}, ignoring
* all other arguments. To control the conversion, subclass this
* method and use any of the arguments you need.
*
- * @param value the <code>Object</code> to convert to text
+ * @param value the {@code Object} to convert to text
* @param selected true if the node is selected
* @param expanded true if the node is expanded
* @param leaf true if the node is a leaf node
* @param row an integer specifying the node's display row, where 0 is
* the first row in the display
* @param hasFocus true if the node has the focus
- * @return the <code>String</code> representation of the node's value
+ * @return the {@code String} representation of the node's value
*/
public String convertValueToText(Object value, boolean selected,
boolean expanded, boolean leaf, int row,
boolean hasFocus) {
if(value != null) {
@@ -1644,35 +1644,35 @@
}
/**
* Selects the node identified by the specified path. If any
* component of the path is hidden (under a collapsed node), and
- * <code>getExpandsSelectedPaths</code> is true it is
+ * {@code getExpandsSelectedPaths} is true it is
* exposed (made viewable).
*
- * @param path the <code>TreePath</code> specifying the node to select
+ * @param path the {@code TreePath} specifying the node to select
*/
public void setSelectionPath(TreePath path) {
getSelectionModel().setSelectionPath(path);
}
/**
* Selects the nodes identified by the specified array of paths.
* If any component in any of the paths is hidden (under a collapsed
- * node), and <code>getExpandsSelectedPaths</code> is true
+ * node), and {@code getExpandsSelectedPaths} is true
* it is exposed (made viewable).
*
- * @param paths an array of <code>TreePath</code> objects that specifies
+ * @param paths an array of {@code TreePath} objects that specifies
* the nodes to select
*/
public void setSelectionPaths(TreePath[] paths) {
getSelectionModel().setSelectionPaths(paths);
}
/**
* Sets the path identifies as the lead. The lead may not be selected.
- * The lead is not maintained by <code>JTree</code>,
+ * The lead is not maintained by {@code JTree},
* rather the UI will update it.
* <p>
* This is a bound property.
*
* @param newPath the new lead path
@@ -1696,11 +1696,11 @@
}
}
/**
* Sets the path identified as the anchor.
- * The anchor is not maintained by <code>JTree</code>, rather the UI will
+ * The anchor is not maintained by {@code JTree}, rather the UI will
* update it.
* <p>
* This is a bound property.
*
* @param newPath the new anchor path
@@ -1728,15 +1728,15 @@
setSelectionRows(rows);
}
/**
* Selects the nodes corresponding to each of the specified rows
- * in the display. If a particular element of <code>rows</code> is
- * < 0 or >= <code>getRowCount</code>, it will be ignored.
+ * in the display. If a particular element of {@code rows} is
+ * < 0 or >= {@code getRowCount}, it will be ignored.
* If none of the elements
- * in <code>rows</code> are valid rows, the selection will
- * be cleared. That is it will be as if <code>clearSelection</code>
+ * in {@code rows} are valid rows, the selection will
+ * be cleared. That is it will be as if {@code clearSelection}
* was invoked.
*
* @param rows an array of ints specifying the rows to select,
* where 0 indicates the first row in the display
*/
@@ -1753,36 +1753,36 @@
setSelectionPaths(paths);
}
}
/**
- * Adds the node identified by the specified <code>TreePath</code>
+ * Adds the node identified by the specified {@code TreePath}
* to the current selection. If any component of the path isn't
- * viewable, and <code>getExpandsSelectedPaths</code> is true it is
+ * viewable, and {@code getExpandsSelectedPaths} is true it is
* made viewable.
* <p>
- * Note that <code>JTree</code> does not allow duplicate nodes to
+ * Note that {@code JTree} does not allow duplicate nodes to
* exist as children under the same parent -- each sibling must be
* a unique object.
*
- * @param path the <code>TreePath</code> to add
+ * @param path the {@code TreePath} to add
*/
public void addSelectionPath(TreePath path) {
getSelectionModel().addSelectionPath(path);
}
/**
* Adds each path in the array of paths to the current selection. If
* any component of any of the paths isn't viewable and
- * <code>getExpandsSelectedPaths</code> is true, it is
+ * {@code getExpandsSelectedPaths} is true, it is
* made viewable.
* <p>
- * Note that <code>JTree</code> does not allow duplicate nodes to
+ * Note that {@code JTree} does not allow duplicate nodes to
* exist as children under the same parent -- each sibling must be
* a unique object.
*
- * @param paths an array of <code>TreePath</code> objects that specifies
+ * @param paths an array of {@code TreePath} objects that specifies
* the nodes to add
*/
public void addSelectionPaths(TreePath[] paths) {
getSelectionModel().addSelectionPaths(paths);
}
@@ -1823,11 +1823,11 @@
* a convenience method for
* {@code getSelectionModel().getSelectionPath().getLastPathComponent()}.
* This is typically only useful if the selection has one path.
*
* @return the last path component of the selected path, or
- * <code>null</code> if nothing is selected
+ * {@code null} if nothing is selected
* @see TreePath#getLastPathComponent
*/
public Object getLastSelectedPathComponent() {
TreePath selPath = getSelectionModel().getSelectionPath();
@@ -1854,34 +1854,34 @@
}
/**
* Returns the path to the first selected node.
*
- * @return the <code>TreePath</code> for the first selected node,
- * or <code>null</code> if nothing is currently selected
+ * @return the {@code TreePath} for the first selected node,
+ * or {@code null} if nothing is currently selected
*/
public TreePath getSelectionPath() {
return getSelectionModel().getSelectionPath();
}
/**
* Returns the paths of all selected values.
*
- * @return an array of <code>TreePath</code> objects indicating the selected
- * nodes, or <code>null</code> if nothing is currently selected
+ * @return an array of {@code TreePath} objects indicating the selected
+ * nodes, or {@code null} if nothing is currently selected
*/
public TreePath[] getSelectionPaths() {
TreePath[] selectionPaths = getSelectionModel().getSelectionPaths();
return (selectionPaths != null && selectionPaths.length > 0) ? selectionPaths : null;
}
/**
* Returns all of the currently selected rows. This method is simply
- * forwarded to the <code>TreeSelectionModel</code>.
- * If nothing is selected <code>null</code> or an empty array will
- * be returned, based on the <code>TreeSelectionModel</code>
+ * forwarded to the {@code TreeSelectionModel}.
+ * If nothing is selected {@code null} or an empty array will
+ * be returned, based on the {@code TreeSelectionModel}
* implementation.
*
* @return an array of integers that identifies all currently selected rows
* where 0 is the first row in the display
*/
@@ -1921,11 +1921,11 @@
/**
* Returns the row index corresponding to the lead path.
*
* @return an integer giving the row index of the lead path,
* where 0 is the first row in the display; or -1
- * if <code>leadPath</code> is <code>null</code>
+ * if {@code leadPath} is {@code null}
*/
public int getLeadSelectionRow() {
TreePath leadPath = getLeadSelectionPath();
if (leadPath != null) {
@@ -1935,11 +1935,11 @@
}
/**
* Returns true if the item identified by the path is currently selected.
*
- * @param path a <code>TreePath</code> identifying a node
+ * @param path a {@code TreePath} identifying a node
* @return true if the node is selected
*/
public boolean isPathSelected(TreePath path) {
return getSelectionModel().isPathSelected(path);
}
@@ -1954,23 +1954,23 @@
public boolean isRowSelected(int row) {
return getSelectionModel().isRowSelected(row);
}
/**
- * Returns an <code>Enumeration</code> of the descendants of the
- * path <code>parent</code> that
- * are currently expanded. If <code>parent</code> is not currently
- * expanded, this will return <code>null</code>.
+ * Returns an {@code Enumeration} of the descendants of the
+ * path {@code parent} that
+ * are currently expanded. If {@code parent} is not currently
+ * expanded, this will return {@code null}.
* If you expand/collapse nodes while
- * iterating over the returned <code>Enumeration</code>
+ * iterating over the returned {@code Enumeration}
* this may not return all
* the expanded paths, or may return paths that are no longer expanded.
*
* @param parent the path which is to be examined
- * @return an <code>Enumeration</code> of the descendents of
- * <code>parent</code>, or <code>null</code> if
- * <code>parent</code> is not currently expanded
+ * @return an {@code Enumeration} of the descendents of
+ * {@code parent}, or {@code null} if
+ * {@code parent} is not currently expanded
*/
public Enumeration<TreePath> getExpandedDescendants(TreePath parent) {
if(!isExpanded(parent))
return null;
@@ -2006,20 +2006,20 @@
/**
* Returns true if the node identified by the path has ever been
* expanded.
*
* @param path a {@code TreePath} identifying a node
- * @return true if the <code>path</code> has ever been expanded
+ * @return true if the {@code path} has ever been expanded
*/
public boolean hasBeenExpanded(TreePath path) {
return (path != null && expandedState.get(path) != null);
}
/**
* Returns true if the node identified by the path is currently expanded,
*
- * @param path the <code>TreePath</code> specifying the node to check
+ * @param path the {@code TreePath} specifying the node to check
* @return false if any of the nodes in the node's path are collapsed,
* true if all nodes in the path are expanded
*/
public boolean isExpanded(TreePath path) {
@@ -2062,11 +2062,11 @@
/**
* Returns true if the value identified by path is currently collapsed,
* this will return false if any of the values in path are currently
* not being displayed.
*
- * @param path the <code>TreePath</code> to check
+ * @param path the {@code TreePath} to check
* @return true if any of the nodes in the node's path are collapsed,
* false if all nodes in the path are expanded
*/
public boolean isCollapsed(TreePath path) {
return !isExpanded(path);
@@ -2084,11 +2084,11 @@
}
/**
* Ensures that the node identified by path is currently viewable.
*
- * @param path the <code>TreePath</code> to make visible
+ * @param path the {@code TreePath} to make visible
*/
public void makeVisible(TreePath path) {
if(path != null) {
TreePath parentPath = path.getParentPath();
@@ -2117,49 +2117,49 @@
}
return false;
}
/**
- * Returns the <code>Rectangle</code> that the specified node will be drawn
- * into. Returns <code>null</code> if any component in the path is hidden
+ * Returns the {@code Rectangle} that the specified node will be drawn
+ * into. Returns {@code null} if any component in the path is hidden
* (under a collapsed parent).
* <p>
* Note:<br>
* This method returns a valid rectangle, even if the specified
* node is not currently displayed.
*
- * @param path the <code>TreePath</code> identifying the node
- * @return the <code>Rectangle</code> the node is drawn in,
- * or <code>null</code>
+ * @param path the {@code TreePath} identifying the node
+ * @return the {@code Rectangle} the node is drawn in,
+ * or {@code null}
*/
public Rectangle getPathBounds(TreePath path) {
TreeUI tree = getUI();
if(tree != null)
return tree.getPathBounds(this, path);
return null;
}
/**
- * Returns the <code>Rectangle</code> that the node at the specified row is
+ * Returns the {@code Rectangle} that the node at the specified row is
* drawn in.
*
* @param row the row to be drawn, where 0 is the first row in the
* display
- * @return the <code>Rectangle</code> the node is drawn in
+ * @return the {@code Rectangle} the node is drawn in
*/
public Rectangle getRowBounds(int row) {
return getPathBounds(getPathForRow(row));
}
/**
* Makes sure all the path components in path are expanded (except
* for the last path component) and scrolls so that the
* node identified by the path is displayed. Only works when this
- * <code>JTree</code> is contained in a <code>JScrollPane</code>.
+ * {@code JTree} is contained in a {@code JScrollPane}.
*
- * @param path the <code>TreePath</code> identifying the node to
+ * @param path the {@code TreePath} identifying the node to
* bring into view
*/
public void scrollPathToVisible(TreePath path) {
if(path != null) {
makeVisible(path);
@@ -2176,29 +2176,29 @@
}
/**
* Scrolls the item identified by row until it is displayed. The minimum
* of amount of scrolling necessary to bring the row into view
- * is performed. Only works when this <code>JTree</code> is contained in a
- * <code>JScrollPane</code>.
+ * is performed. Only works when this {@code JTree} is contained in a
+ * {@code JScrollPane}.
*
* @param row an integer specifying the row to scroll, where 0 is the
* first row in the display
*/
public void scrollRowToVisible(int row) {
scrollPathToVisible(getPathForRow(row));
}
/**
- * Returns the path for the specified row. If <code>row</code> is
- * not visible, or a {@code TreeUI} has not been set, <code>null</code>
+ * Returns the path for the specified row. If {@code row} is
+ * not visible, or a {@code TreeUI} has not been set, {@code null}
* is returned.
*
* @param row an integer specifying a row
- * @return the <code>TreePath</code> to the specified node,
- * <code>null</code> if <code>row < 0</code>
- * or <code>row >= getRowCount()</code>
+ * @return the {@code TreePath} to the specified node,
+ * {@code null} if {@code row < 0}
+ * or {@code row >= getRowCount()}
*/
public TreePath getPathForRow(int row) {
TreeUI tree = getUI();
if(tree != null)
@@ -2208,11 +2208,11 @@
/**
* Returns the row that displays the node identified by the specified
* path.
*
- * @param path the <code>TreePath</code> identifying a node
+ * @param path the {@code TreePath} identifying a node
* @return an integer specifying the display row, where 0 is the first
* row in the display, or -1 if any of the elements in path
* are hidden under a collapsed parent.
*/
public int getRowForPath(TreePath path) {
@@ -2226,11 +2226,11 @@
/**
* Ensures that the node identified by the specified path is
* expanded and viewable. If the last item in the path is a
* leaf, this will have no effect.
*
- * @param path the <code>TreePath</code> identifying a node
+ * @param path the {@code TreePath} identifying a node
*/
public void expandPath(TreePath path) {
// Only expand if not leaf!
TreeModel model = getModel();
@@ -2242,11 +2242,11 @@
/**
* Ensures that the node in the specified row is expanded and
* viewable.
* <p>
- * If <code>row</code> is < 0 or >= <code>getRowCount</code> this
+ * If {@code row} is {@code < 0} or {@code >= getRowCount} this
* will have no effect.
*
* @param row an integer specifying a display row, where 0 is the
* first row in the display
*/
@@ -2256,20 +2256,20 @@
/**
* Ensures that the node identified by the specified path is
* collapsed and viewable.
*
- * @param path the <code>TreePath</code> identifying a node
+ * @param path the {@code TreePath} identifying a node
*/
public void collapsePath(TreePath path) {
setExpandedState(path, false);
}
/**
* Ensures that the node in the specified row is collapsed.
* <p>
- * If <code>row</code> is < 0 or >= <code>getRowCount</code> this
+ * If {@code row} is {@code < 0} or {@code >= getRowCount} this
* will have no effect.
*
* @param row an integer specifying a display row, where 0 is the
* first row in the display
*/
@@ -2282,11 +2282,11 @@
*
* @param x an integer giving the number of pixels horizontally from
* the left edge of the display area, minus any left margin
* @param y an integer giving the number of pixels vertically from
* the top of the display area, minus any top margin
- * @return the <code>TreePath</code> for the node at that location
+ * @return the {@code TreePath} for the node at that location
*/
public TreePath getPathForLocation(int x, int y) {
TreePath closestPath = getClosestPathForLocation(x, y);
if(closestPath != null) {
@@ -2316,20 +2316,20 @@
}
/**
* Returns the path to the node that is closest to x,y. If
* no nodes are currently viewable, or there is no model, returns
- * <code>null</code>, otherwise it always returns a valid path. To test if
+ * {@code null}, otherwise it always returns a valid path. To test if
* the node is exactly at x, y, get the node's bounds and
* test x, y against that.
*
* @param x an integer giving the number of pixels horizontally from
* the left edge of the display area, minus any left margin
* @param y an integer giving the number of pixels vertically from
* the top of the display area, minus any top margin
- * @return the <code>TreePath</code> for the node closest to that location,
- * <code>null</code> if nothing is viewable or there is no model
+ * @return the {@code TreePath} for the node closest to that location,
+ * {@code null} if nothing is viewable or there is no model
*
* @see #getPathForLocation
* @see #getPathBounds
*/
public TreePath getClosestPathForLocation(int x, int y) {
@@ -2361,11 +2361,11 @@
return getRowForPath(getClosestPathForLocation(x, y));
}
/**
* Returns true if the tree is being edited. The item that is being
- * edited can be obtained using <code>getSelectionPath</code>.
+ * edited can be obtained using {@code getSelectionPath}.
*
* @return true if the user is currently editing a node
* @see #getSelectionPath
*/
public boolean isEditing() {
@@ -2376,11 +2376,11 @@
return false;
}
/**
* Ends the current editing session.
- * (The <code>DefaultTreeCellEditor</code>
+ * (The {@code DefaultTreeCellEditor}
* object saves any edits that are currently in progress on a cell.
* Other implementations may operate differently.)
* Has no effect if the tree isn't being edited.
* <blockquote>
* <b>Note:</b><br>
@@ -2410,15 +2410,15 @@
tree.cancelEditing(this);
}
/**
* Selects the node identified by the specified path and initiates
- * editing. The edit-attempt fails if the <code>CellEditor</code>
+ * editing. The edit-attempt fails if the {@code CellEditor}
* does not allow
* editing for the specified item.
*
- * @param path the <code>TreePath</code> identifying a node
+ * @param path the {@code TreePath} identifying a node
*/
public void startEditingAtPath(TreePath path) {
TreeUI tree = getUI();
if(tree != null)
@@ -2426,11 +2426,11 @@
}
/**
* Returns the path to the element that is currently being edited.
*
- * @return the <code>TreePath</code> for the node being edited
+ * @return the {@code TreePath} for the node being edited
*/
public TreePath getEditingPath() {
TreeUI tree = getUI();
if(tree != null)
@@ -2446,18 +2446,18 @@
// Since row based selections require a UI many of these won't work
// without one.
//
/**
- * Sets the tree's selection model. When a <code>null</code> value is
+ * Sets the tree's selection model. When a {@code null} value is
* specified an empty
- * <code>selectionModel</code> is used, which does not allow selections.
+ * {@code selectionModel} is used, which does not allow selections.
* <p>
* This is a bound property.
*
- * @param selectionModel the <code>TreeSelectionModel</code> to use,
- * or <code>null</code> to disable selections
+ * @param selectionModel the {@code TreeSelectionModel} to use,
+ * or {@code null} to disable selections
* @see TreeSelectionModel
* @beaninfo
* bound: true
* description: The tree's selection model.
*/
@@ -2490,13 +2490,13 @@
}
}
/**
* Returns the model for selections. This should always return a
- * non-<code>null</code> value. If you don't want to allow anything
+ * non-{@code null} value. If you don't want to allow anything
* to be selected
- * set the selection model to <code>null</code>, which forces an empty
+ * set the selection model to {@code null}, which forces an empty
* selection model to be used.
*
* @return the model for selections
* @see #setSelectionModel
*/
@@ -2637,29 +2637,29 @@
/**
* Removes the node identified by the specified path from the current
* selection.
*
- * @param path the <code>TreePath</code> identifying a node
+ * @param path the {@code TreePath} identifying a node
*/
public void removeSelectionPath(TreePath path) {
this.getSelectionModel().removeSelectionPath(path);
}
/**
* Removes the nodes identified by the specified paths from the
* current selection.
*
- * @param paths an array of <code>TreePath</code> objects that
+ * @param paths an array of {@code TreePath} objects that
* specifies the nodes to remove
*/
public void removeSelectionPaths(TreePath[] paths) {
this.getSelectionModel().removeSelectionPaths(paths);
}
/**
- * Removes the row at the index <code>row</code> from the current
+ * Removes the row at the index {@code row} from the current
* selection.
*
* @param row the row to remove
*/
public void removeSelectionRow(int row) {
@@ -2703,11 +2703,11 @@
public boolean isSelectionEmpty() {
return getSelectionModel().isSelectionEmpty();
}
/**
- * Adds a listener for <code>TreeExpansion</code> events.
+ * Adds a listener for {@code TreeExpansion} events.
*
* @param tel a TreeExpansionListener that will be notified when
* a tree node is expanded or collapsed (a "negative
* expansion")
*/
@@ -2717,71 +2717,71 @@
}
listenerList.add(TreeExpansionListener.class, tel);
}
/**
- * Removes a listener for <code>TreeExpansion</code> events.
+ * Removes a listener for {@code TreeExpansion} events.
*
- * @param tel the <code>TreeExpansionListener</code> to remove
+ * @param tel the {@code TreeExpansionListener} to remove
*/
public void removeTreeExpansionListener(TreeExpansionListener tel) {
listenerList.remove(TreeExpansionListener.class, tel);
if (uiTreeExpansionListener == tel) {
uiTreeExpansionListener = null;
}
}
/**
- * Returns an array of all the <code>TreeExpansionListener</code>s added
+ * Returns an array of all the {@code TreeExpansionListener}s added
* to this JTree with addTreeExpansionListener().
*
- * @return all of the <code>TreeExpansionListener</code>s added or an empty
+ * @return all of the {@code TreeExpansionListener}s added or an empty
* array if no listeners have been added
* @since 1.4
*/
public TreeExpansionListener[] getTreeExpansionListeners() {
return listenerList.getListeners(TreeExpansionListener.class);
}
/**
- * Adds a listener for <code>TreeWillExpand</code> events.
+ * Adds a listener for {@code TreeWillExpand} events.
*
- * @param tel a <code>TreeWillExpandListener</code> that will be notified
+ * @param tel a {@code TreeWillExpandListener} that will be notified
* when a tree node will be expanded or collapsed (a "negative
* expansion")
*/
public void addTreeWillExpandListener(TreeWillExpandListener tel) {
listenerList.add(TreeWillExpandListener.class, tel);
}
/**
- * Removes a listener for <code>TreeWillExpand</code> events.
+ * Removes a listener for {@code TreeWillExpand} events.
*
- * @param tel the <code>TreeWillExpandListener</code> to remove
+ * @param tel the {@code TreeWillExpandListener} to remove
*/
public void removeTreeWillExpandListener(TreeWillExpandListener tel) {
listenerList.remove(TreeWillExpandListener.class, tel);
}
/**
- * Returns an array of all the <code>TreeWillExpandListener</code>s added
+ * Returns an array of all the {@code TreeWillExpandListener}s added
* to this JTree with addTreeWillExpandListener().
*
- * @return all of the <code>TreeWillExpandListener</code>s added or an empty
+ * @return all of the {@code TreeWillExpandListener}s added or an empty
* array if no listeners have been added
* @since 1.4
*/
public TreeWillExpandListener[] getTreeWillExpandListeners() {
return listenerList.getListeners(TreeWillExpandListener.class);
}
/**
* Notifies all listeners that have registered interest for
* notification on this event type. The event instance
- * is lazily created using the <code>path</code> parameter.
+ * is lazily created using the {@code path} parameter.
*
- * @param path the <code>TreePath</code> indicating the node that was
+ * @param path the {@code TreePath} indicating the node that was
* expanded
* @see EventListenerList
*/
public void fireTreeExpanded(TreePath path) {
// Guaranteed to return a non-null array
@@ -2806,13 +2806,13 @@
}
/**
* Notifies all listeners that have registered interest for
* notification on this event type. The event instance
- * is lazily created using the <code>path</code> parameter.
+ * is lazily created using the {@code path} parameter.
*
- * @param path the <code>TreePath</code> indicating the node that was
+ * @param path the {@code TreePath} indicating the node that was
* collapsed
* @see EventListenerList
*/
public void fireTreeCollapsed(TreePath path) {
// Guaranteed to return a non-null array
@@ -2837,13 +2837,13 @@
}
/**
* Notifies all listeners that have registered interest for
* notification on this event type. The event instance
- * is lazily created using the <code>path</code> parameter.
+ * is lazily created using the {@code path} parameter.
*
- * @param path the <code>TreePath</code> indicating the node that was
+ * @param path the {@code TreePath} indicating the node that was
* expanded
* @throws ExpandVetoException if the expansion is prevented from occurring
* @see EventListenerList
*/
public void fireTreeWillExpand(TreePath path) throws ExpandVetoException {
@@ -2864,13 +2864,13 @@
}
/**
* Notifies all listeners that have registered interest for
* notification on this event type. The event instance
- * is lazily created using the <code>path</code> parameter.
+ * is lazily created using the {@code path} parameter.
*
- * @param path the <code>TreePath</code> indicating the node that was
+ * @param path the {@code TreePath} indicating the node that was
* expanded
* @throws ExpandVetoException if the collapse is prevented from occurring
* @see EventListenerList
*/
public void fireTreeWillCollapse(TreePath path) throws ExpandVetoException {
@@ -2889,13 +2889,13 @@
}
}
}
/**
- * Adds a listener for <code>TreeSelection</code> events.
+ * Adds a listener for {@code TreeSelection} events.
*
- * @param tsl the <code>TreeSelectionListener</code> that will be notified
+ * @param tsl the {@code TreeSelectionListener} that will be notified
* when a node is selected or deselected (a "negative
* selection")
*/
public void addTreeSelectionListener(TreeSelectionListener tsl) {
listenerList.add(TreeSelectionListener.class,tsl);
@@ -2905,13 +2905,13 @@
selectionModel.addTreeSelectionListener(selectionRedirector);
}
}
/**
- * Removes a <code>TreeSelection</code> listener.
+ * Removes a {@code TreeSelection} listener.
*
- * @param tsl the <code>TreeSelectionListener</code> to remove
+ * @param tsl the {@code TreeSelectionListener} to remove
*/
public void removeTreeSelectionListener(TreeSelectionListener tsl) {
listenerList.remove(TreeSelectionListener.class,tsl);
if(listenerList.getListenerCount(TreeSelectionListener.class) == 0
&& selectionRedirector != null) {
@@ -2920,14 +2920,14 @@
selectionRedirector = null;
}
}
/**
- * Returns an array of all the <code>TreeSelectionListener</code>s added
+ * Returns an array of all the {@code TreeSelectionListener}s added
* to this JTree with addTreeSelectionListener().
*
- * @return all of the <code>TreeSelectionListener</code>s added or an empty
+ * @return all of the {@code TreeSelectionListener}s added or an empty
* array if no listeners have been added
* @since 1.4
*/
public TreeSelectionListener[] getTreeSelectionListeners() {
return listenerList.getListeners(TreeSelectionListener.class);
@@ -2935,13 +2935,13 @@
/**
* Notifies all listeners that have registered interest for
* notification on this event type.
*
- * @param e the <code>TreeSelectionEvent</code> to be fired;
+ * @param e the {@code TreeSelectionEvent} to be fired;
* generated by the
- * <code>TreeSelectionModel</code>
+ * {@code TreeSelectionModel}
* when a node is selected or deselected
* @see EventListenerList
*/
protected void fireValueChanged(TreeSelectionEvent e) {
// Guaranteed to return a non-null array
@@ -2972,11 +2972,11 @@
}
/**
* Sets the number of rows that are to be displayed.
* This will only work if the tree is contained in a
- * <code>JScrollPane</code>,
+ * {@code JScrollPane},
* and will adjust the preferred size and size of that scrollpane.
* <p>
* This is a bound property.
*
* @param newCount the number of rows to display
@@ -3016,11 +3016,11 @@
}
/**
* Returns the TreePath to the next tree element that
* begins with a prefix. To handle the conversion of a
- * <code>TreePath</code> into a String, <code>convertValueToText</code>
+ * {@code TreePath} into a String, {@code convertValueToText}
* is used.
*
* @param prefix the string to test for a match
* @param startingRow the row for starting the search
* @param bias the search direction, either
@@ -3217,11 +3217,11 @@
return null;
}
/**
* Updates the expanded state of nodes in the tree based on the
- * previously archived state <code>state</code>.
+ * previously archived state {@code state}.
*/
private void unarchiveExpandedState(Object state) {
if(state instanceof Vector) {
Vector<?> paths = (Vector)state;
@@ -3238,13 +3238,13 @@
}
}
/**
* Returns an array of integers specifying the indexs of the
- * components in the <code>path</code>. If <code>path</code> is
- * the root, this will return an empty array. If <code>path</code>
- * is <code>null</code>, <code>null</code> will be returned.
+ * components in the {@code path}. If {@code path} is
+ * the root, this will return an empty array. If {@code path}
+ * is {@code null}, {@code null} will be returned.
*/
private int[] getModelIndexsForPath(TreePath path) {
if(path != null) {
TreeModel model = getModel();
int count = path.getPathCount();
@@ -3262,14 +3262,14 @@
}
return null;
}
/**
- * Returns a <code>TreePath</code> created by obtaining the children
- * for each of the indices in <code>indexs</code>. If <code>indexs</code>
- * or the <code>TreeModel</code> is <code>null</code>, it will return
- * <code>null</code>.
+ * Returns a {@code TreePath} created by obtaining the children
+ * for each of the indices in {@code indexs}. If {@code indexs}
+ * or the {@code TreeModel} is {@code null}, it will return
+ * {@code null}.
*/
private TreePath getPathForIndexs(int[] indexs) {
if(indexs == null)
return null;
@@ -3293,20 +3293,20 @@
}
return parentPath;
}
/**
- * <code>EmptySelectionModel</code> is a <code>TreeSelectionModel</code>
+ * {@code EmptySelectionModel} is a {@code TreeSelectionModel}
* that does not allow anything to be selected.
* <p>
* <strong>Warning:</strong>
* 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}.
*/
@SuppressWarnings("serial")
protected static class EmptySelectionModel extends
DefaultTreeSelectionModel
@@ -3414,33 +3414,33 @@
}
}
/**
- * Handles creating a new <code>TreeSelectionEvent</code> with the
- * <code>JTree</code> as the
+ * Handles creating a new {@code TreeSelectionEvent} with the
+ * {@code JTree} as the
* source and passing it off to all the listeners.
* <p>
* <strong>Warning:</strong>
* 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}.
*/
@SuppressWarnings("serial")
protected class TreeSelectionRedirector implements Serializable,
TreeSelectionListener
{
/**
- * Invoked by the <code>TreeSelectionModel</code> when the
+ * Invoked by the {@code TreeSelectionModel} when the
* selection changes.
*
- * @param e the <code>TreeSelectionEvent</code> generated by the
- * <code>TreeSelectionModel</code>
+ * @param e the {@code TreeSelectionEvent} generated by the
+ * {@code TreeSelectionModel}
*/
public void valueChanged(TreeSelectionEvent e) {
TreeSelectionEvent newE;
newE = (TreeSelectionEvent)e.cloneWithSource(JTree.this);
@@ -3451,15 +3451,15 @@
//
// Scrollable interface
//
/**
- * Returns the preferred display size of a <code>JTree</code>. The height is
- * determined from <code>getVisibleRowCount</code> and the width
+ * Returns the preferred display size of a {@code JTree}. The height is
+ * determined from {@code getVisibleRowCount} and the width
* is the current preferred width.
*
- * @return a <code>Dimension</code> object containing the preferred size
+ * @return a {@code Dimension} object containing the preferred size
*/
public Dimension getPreferredScrollableViewportSize() {
int width = getPreferredSize().width;
int visRows = getVisibleRowCount();
int height = -1;
@@ -3497,12 +3497,12 @@
* the height of the first displayed row that isn't completely in view
* or, if it is totally displayed, the height of the next row in the
* scrolling direction.
*
* @param visibleRect the view area visible within the viewport
- * @param orientation either <code>SwingConstants.VERTICAL</code>
- * or <code>SwingConstants.HORIZONTAL</code>
+ * @param orientation either {@code SwingConstants.VERTICAL}
+ * or {@code SwingConstants.HORIZONTAL}
* @param direction less than zero to scroll up/left,
* greater than zero for down/right
* @return the "unit" increment for scrolling in the specified direction
* @see JScrollBar#setUnitIncrement(int)
*/
@@ -3538,15 +3538,15 @@
}
/**
* Returns the amount for a block increment, which is the height or
- * width of <code>visibleRect</code>, based on <code>orientation</code>.
+ * width of {@code visibleRect}, based on {@code orientation}.
*
* @param visibleRect the view area visible within the viewport
- * @param orientation either <code>SwingConstants.VERTICAL</code>
- * or <code>SwingConstants.HORIZONTAL</code>
+ * @param orientation either {@code SwingConstants.VERTICAL}
+ * or {@code SwingConstants.HORIZONTAL}
* @param direction less than zero to scroll up/left,
* greater than zero for down/right.
* @return the "block" increment for scrolling in the specified direction
* @see JScrollBar#setBlockIncrement(int)
*/
@@ -3589,17 +3589,17 @@
}
return false;
}
/**
- * Sets the expanded state of this <code>JTree</code>.
- * If <code>state</code> is
- * true, all parents of <code>path</code> and path are marked as
- * expanded. If <code>state</code> is false, all parents of
- * <code>path</code> are marked EXPANDED, but <code>path</code> itself
+ * Sets the expanded state of this {@code JTree}.
+ * If {@code state} is
+ * true, all parents of {@code path} and path are marked as
+ * expanded. If {@code state} is false, all parents of
+ * {@code path} are marked EXPANDED, but {@code path} itself
* is marked collapsed.<p>
- * This will fail if a <code>TreeWillExpandListener</code> vetos it.
+ * This will fail if a {@code TreeWillExpandListener} vetos it.
*
* @param path a {@code TreePath} identifying a node
* @param state if {@code true}, all parents of @{code path} and path are marked as expanded.
* Otherwise, all parents of {@code path} are marked EXPANDED,
* but {@code path} itself is marked collapsed.
@@ -3721,12 +3721,12 @@
}
return descendants.elements();
}
/**
- * Removes any descendants of the <code>TreePaths</code> in
- * <code>toRemove</code>
+ * Removes any descendants of the {@code TreePaths} in
+ * {@code toRemove}
* that have been expanded.
*
* @param toRemove an enumeration of the paths to remove; a value of
* {@code null} is ignored
* @throws ClassCastException if {@code toRemove} contains an
@@ -3750,21 +3750,21 @@
}
}
/**
* Clears the cache of toggled tree paths. This does NOT send out
- * any <code>TreeExpansionListener</code> events.
+ * any {@code TreeExpansionListener} events.
*/
protected void clearToggledPaths() {
expandedState.clear();
}
/**
- * Creates and returns an instance of <code>TreeModelHandler</code>.
+ * Creates and returns an instance of {@code TreeModelHandler}.
* The returned
* object is responsible for updating the expanded state when the
- * <code>TreeModel</code> changes.
+ * {@code TreeModel} changes.
* <p>
* For more information on what expanded state means, see the
* <a href=#jtree_description>JTree description</a> above.
*
* @return the instance of {@code TreeModelHandler}
@@ -3773,12 +3773,12 @@
return new TreeModelHandler();
}
/**
* Removes any paths in the selection that are descendants of
- * <code>path</code>. If <code>includePath</code> is true and
- * <code>path</code> is selected, it will be removed from the selection.
+ * {@code path}. If {@code includePath} is true and
+ * {@code path} is selected, it will be removed from the selection.
*
* @param path a path
* @param includePath is {@code true} and {@code path} is selected,
* it will be removed from the selection.
* @return true if a descendant was selected
@@ -3795,11 +3795,11 @@
return false;
}
/**
* Returns an array of paths in the selection that are descendants of
- * <code>path</code>. The returned array may contain <code>null</code>s.
+ * {@code path}. The returned array may contain {@code null}s.
*/
private TreePath[] getDescendantSelectedPaths(TreePath path,
boolean includePath) {
TreeSelectionModel sm = getSelectionModel();
TreePath[] selPaths = (sm != null) ? sm.getSelectionPaths() :
@@ -3824,11 +3824,11 @@
return null;
}
/**
* Removes any paths from the selection model that are descendants of
- * the nodes identified by in <code>e</code>.
+ * the nodes identified by in {@code e}.
*/
void removeDescendantSelectedPaths(TreeModelEvent e) {
TreePath pPath = SwingUtilities2.getTreePath(e, getModel());
Object[] oldChildren = e.getChildren();
TreeSelectionModel sm = getSelectionModel();
@@ -3845,11 +3845,11 @@
}
}
/**
- * Listens to the model and updates the <code>expandedState</code>
+ * Listens to the model and updates the {@code expandedState}
* accordingly when nodes are removed, or changed.
*/
protected class TreeModelHandler implements TreeModelListener {
public void treeNodesChanged(TreeModelEvent e) { }
@@ -3930,42 +3930,42 @@
}
}
/**
- * <code>DynamicUtilTreeNode</code> can wrap
+ * {@code DynamicUtilTreeNode} can wrap
* vectors/hashtables/arrays/strings and
* create the appropriate children tree nodes as necessary. It is
* dynamic in that it will only create the children as necessary.
* <p>
* <strong>Warning:</strong>
* 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}.
*/
@SuppressWarnings("serial")
public static class DynamicUtilTreeNode extends DefaultMutableTreeNode {
/**
- * Does the this <code>JTree</code> have children?
+ * Does the this {@code JTree} have children?
* This property is currently not implemented.
*/
protected boolean hasChildren;
/** Value to create children with. */
protected Object childValue;
/** Have the children been loaded yet? */
protected boolean loadedChildren;
/**
- * Adds to parent all the children in <code>children</code>.
- * If <code>children</code> is an array or vector all of its
- * elements are added is children, otherwise if <code>children</code>
+ * Adds to parent all the children in {@code children}.
+ * If {@code children} is an array or vector all of its
+ * elements are added is children, otherwise if {@code children}
* is a hashtable all the key/value pairs are added in the order
- * <code>Enumeration</code> returns them.
+ * {@code Enumeration} returns them.
*
* @param parent the parent node
* @param children the children
*/
public static void createChildren(DefaultMutableTreeNode parent,
@@ -4002,21 +4002,21 @@
/**
* Creates a node with the specified object as its value and
* with the specified children. For the node to allow children,
* the children-object must be an array of objects, a
- * <code>Vector</code>, or a <code>Hashtable</code> -- even
+ * {@code Vector}, or a {@code Hashtable} -- even
* if empty. Otherwise, the node is not
* allowed to have children.
*
- * @param value the <code>Object</code> that is the value for the
+ * @param value the {@code Object} that is the value for the
* new node
- * @param children an array of <code>Object</code>s, a
- * <code>Vector</code>, or a <code>Hashtable</code>
+ * @param children an array of {@code Object}s, a
+ * {@code Vector}, or a {@code Hashtable}
* used to create the child nodes; if any other
* object is specified, or if the value is
- * <code>null</code>,
+ * {@code null},
* then the node is not allowed to have children
*/
public DynamicUtilTreeNode(Object value, Object children) {
super(value);
loadedChildren = false;
@@ -4056,16 +4056,16 @@
loadChildren();
return super.getChildCount();
}
/**
- * Loads the children based on <code>childValue</code>.
- * If <code>childValue</code> is a <code>Vector</code>
+ * Loads the children based on {@code childValue}.
+ * If {@code childValue} is a {@code Vector}
* or array each element is added as a child,
- * if <code>childValue</code> is a <code>Hashtable</code>
+ * if {@code childValue} is a {@code Hashtable}
* each key/value pair is added in the order that
- * <code>Enumeration</code> returns the keys.
+ * {@code Enumeration} returns the keys.
*/
protected void loadChildren() {
loadedChildren = true;
createChildren(this, childValue);
}
@@ -4110,18 +4110,18 @@
}
}
/**
- * Returns a string representation of this <code>JTree</code>.
+ * Returns a string representation of this {@code JTree}.
* This method
* is intended to be used only for debugging purposes, and the
* content and format of the returned string may vary between
* implementations. The returned string may be empty but may not
- * be <code>null</code>.
+ * be {@code null}.
*
- * @return a string representation of this <code>JTree</code>.
+ * @return a string representation of this {@code JTree}.
*/
protected String paramString() {
String rootVisibleString = (rootVisible ?
"true" : "false");
String showsRootHandlesString = (showsRootHandles ?
@@ -4167,20 +4167,20 @@
return accessibleContext;
}
/**
* This class implements accessibility support for the
- * <code>JTree</code> class. It provides an implementation of the
+ * {@code JTree} class. It provides an implementation of the
* Java Accessibility API appropriate to tree user-interface elements.
* <p>
* <strong>Warning:</strong>
* 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}.
*/
@SuppressWarnings("serial")
protected class AccessibleJTree extends AccessibleJComponent
implements AccessibleSelection, TreeSelectionListener,
@@ -4402,17 +4402,17 @@
public AccessibleRole getAccessibleRole() {
return AccessibleRole.TREE;
}
/**
- * Returns the <code>Accessible</code> child, if one exists,
- * contained at the local coordinate <code>Point</code>.
- * Otherwise returns <code>null</code>.
- *
- * @param p point in local coordinates of this <code>Accessible</code>
- * @return the <code>Accessible</code>, if it exists,
- * at the specified location; else <code>null</code>
+ * Returns the {@code Accessible} child, if one exists,
+ * contained at the local coordinate {@code Point}.
+ * Otherwise returns {@code null}.
+ *
+ * @param p point in local coordinates of this {@code Accessible}
+ * @return the {@code Accessible}, if it exists,
+ * at the specified location; else {@code null}
*/
public Accessible getAccessibleAt(Point p) {
TreePath path = getClosestPathForLocation(p.x, p.y);
if (path != null) {
// JTree.this is NOT the parent; parent will get computed later
@@ -4649,11 +4649,11 @@
}
}
/**
* This class implements accessibility support for the
- * <code>JTree</code> child. It provides an implementation of the
+ * {@code JTree} child. It provides an implementation of the
* Java Accessibility API appropriate to tree nodes.
*/
protected class AccessibleJTreeNode extends AccessibleContext
implements Accessible, AccessibleComponent, AccessibleSelection,
AccessibleAction {
@@ -5372,18 +5372,18 @@
}
}
}
/**
- * Returns the <code>Accessible</code> child, if one exists,
- * contained at the local coordinate <code>Point</code>.
- * Otherwise returns <code>null</code>.
+ * Returns the {@code Accessible} child, if one exists,
+ * contained at the local coordinate {@code Point}.
+ * Otherwise returns {@code null}.
*
* @param p point in local coordinates of this
- * <code>Accessible</code>
- * @return the <code>Accessible</code>, if it exists,
- * at the specified location; else <code>null</code>
+ * {@code Accessible}
+ * @return the {@code Accessible}, if it exists,
+ * at the specified location; else {@code null}
*/
public Accessible getAccessibleAt(Point p) {
AccessibleContext ac = getCurrentAccessibleContext();
if (ac instanceof AccessibleComponent) {
return ((AccessibleComponent) ac).getAccessibleAt(p);
< prev index next >