jdk-sandbox: comparison jdk/src/share/classes/javax/swing/plaf/basic/BasicTreeUI.java

equal deleted inserted replaced

-:21b78da4b2df
+:6a6fd62bc6d5
 new StringBuilder("Tree.baselineComponent");
 // Old actions forward to an instance of this.
 static private final Actions SHARED_ACTION = new Actions();
+/**
+* The collapsed icon.
+*/
 transient protected Icon        collapsedIcon;
+/**
+* The expanded icon.
+*/
 transient protected Icon        expandedIcon;
 /**
 * Color used to draw hash marks.  If <code>null</code> no hash marks
 * will be drawn.
 * A temporary variable for communication between startEditingOnRelease
 * and startEditing.
 */
 private MouseEvent releaseEvent;
+/**
+* Constructs a new instance of {@code BasicTreeUI}.
+*
+* @param x a component
+* @return a new instance of {@code BasicTreeUI}
+*/
 public static ComponentUI createUI(JComponent x) {
 return new BasicTreeUI();
 }
 map.put(TransferHandler.getCutAction());
 map.put(TransferHandler.getCopyAction());
 map.put(TransferHandler.getPasteAction());
 }
+/**
+* Constructs a new instance of {@code BasicTreeUI}.
+*/
 public BasicTreeUI() {
 super();
 }
+/**
+* Returns the hash color.
+*
+* @return the hash color
+*/
 protected Color getHashColor() {
 return hashColor;
 }
+/**
+* Sets the hash color.
+*
+* @param color the hash color
+*/
 protected void setHashColor(Color color) {
 hashColor = color;
 }
+/**
+* Sets the left child indent.
+*
+* @param newAmount the left child indent
+*/
 public void setLeftChildIndent(int newAmount) {
 leftChildIndent = newAmount;
 totalChildIndent = leftChildIndent + rightChildIndent;
 if(treeState != null)
 treeState.invalidateSizes();
 updateSize();
 }
+/**
+* Returns the left child indent.
+*
+* @return the left child indent
+*/
 public int getLeftChildIndent() {
 return leftChildIndent;
 }
+/**
+* Sets the right child indent.
+*
+* @param newAmount the right child indent
+*/
 public void setRightChildIndent(int newAmount) {
 rightChildIndent = newAmount;
 totalChildIndent = leftChildIndent + rightChildIndent;
 if(treeState != null)
 treeState.invalidateSizes();
 updateSize();
 }
+/**
+* Returns the right child indent.
+*
+* @return the right child indent
+*/
 public int getRightChildIndent() {
 return rightChildIndent;
 }
+/**
+* Sets the expanded icon.
+*
+* @param newG the expanded icon
+*/
 public void setExpandedIcon(Icon newG) {
 expandedIcon = newG;
 }
+/**
+* Returns the expanded icon.
+*
+* @return the expanded icon
+*/
 public Icon getExpandedIcon() {
 return expandedIcon;
 }
+/**
+* Sets the collapsed icon.
+*
+* @param newG the collapsed icon
+*/
 public void setCollapsedIcon(Icon newG) {
 collapsedIcon = newG;
 }
+/**
+* Returns the collapsed icon.
+*
+* @return the collapsed icon
+*/
 public Icon getCollapsedIcon() {
 return collapsedIcon;
 }
 //
 // call these methods on the JTree.
 //
 /**
 * Updates the componentListener, if necessary.
+*
+* @param largeModel the new value
 */
 protected void setLargeModel(boolean largeModel) {
 if(getRowHeight() < 1)
 largeModel = false;
 if(this.largeModel != largeModel) {
 updateLayoutCacheExpandedNodesIfNecessary();
 updateSize();
 }
 }
+/**
+* Returns {@code true} if large model is set.
+*
+* @return {@code true} if large model is set
+*/
 protected boolean isLargeModel() {
 return largeModel;
 }
 /**
 * Sets the row height, this is forwarded to the treeState.
+*
+* @param rowHeight the row height
 */
 protected void setRowHeight(int rowHeight) {
 completeEditing();
 if(treeState != null) {
 setLargeModel(tree.isLargeModel());
 treeState.setRowHeight(rowHeight);
 updateSize();
 }
 }
+/**
+* Returns the row height.
+*
+* @return the row height
+*/
 protected int getRowHeight() {
 return (tree == null) ? -1 : tree.getRowHeight();
 }
 /**
-* Sets the TreeCellRenderer to <code>tcr</code>. This invokes
+* Sets the {@code TreeCellRenderer} to {@code tcr}. This invokes
-* <code>updateRenderer</code>.
+* {@code updateRenderer}.
+*
+* @param tcr the new value
 */
 protected void setCellRenderer(TreeCellRenderer tcr) {
 completeEditing();
 updateRenderer();
 if(treeState != null) {
 updateSize();
 }
 }
 /**
-* Return currentCellRenderer, which will either be the trees
+* Return {@code currentCellRenderer}, which will either be the trees
-* renderer, or defaultCellRenderer, which ever wasn't null.
+* renderer, or {@code defaultCellRenderer}, which ever wasn't null.
+*
+* @return an instance of {@code TreeCellRenderer}
 */
 protected TreeCellRenderer getCellRenderer() {
 return currentCellRenderer;
 }
 /**
-* Sets the TreeModel.
+* Sets the {@code TreeModel}.
+*
+* @param model the new value
 */
 protected void setModel(TreeModel model) {
 completeEditing();
 if(treeModel != null && treeModelListener != null)
 treeModel.removeTreeModelListener(treeModelListener);
 updateLayoutCacheExpandedNodesIfNecessary();
 updateSize();
 }
 }
+/**
+* Returns the tree model.
+*
+* @return the tree model
+*/
 protected TreeModel getModel() {
 return treeModel;
 }
 /**
 * Sets the root to being visible.
+*
+* @param newValue the new value
 */
 protected void setRootVisible(boolean newValue) {
 completeEditing();
 updateDepthOffset();
 if(treeState != null) {
 treeState.invalidateSizes();
 updateSize();
 }
 }
+/**
+* Returns {@code true} if the tree root is visible.
+*
+* @return {@code true} if the tree root is visible
+*/
 protected boolean isRootVisible() {
 return (tree != null) ? tree.isRootVisible() : false;
 }
 /**
 * Determines whether the node handles are to be displayed.
+*
+* @param newValue the new value
 */
 protected void setShowsRootHandles(boolean newValue) {
 completeEditing();
 updateDepthOffset();
 if(treeState != null) {
 treeState.invalidateSizes();
 updateSize();
 }
 }
+/**
+* Returns {@code true} if the root handles are to be displayed.
+*
+* @return {@code true} if the root handles are to be displayed
+*/
 protected boolean getShowsRootHandles() {
 return (tree != null) ? tree.getShowsRootHandles() : false;
 }
 /**
 * Sets the cell editor.
+*
+* @param editor the new cell editor
 */
 protected void setCellEditor(TreeCellEditor editor) {
 updateCellEditor();
 }
+/**
+* Returns an instance of {@code TreeCellEditor}.
+*
+* @return an instance of {@code TreeCellEditor}
+*/
 protected TreeCellEditor getCellEditor() {
 return (tree != null) ? tree.getCellEditor() : null;
 }
 /**
 * Configures the receiver to allow, or not allow, editing.
+*
+* @param newValue the new value
 */
 protected void setEditable(boolean newValue) {
 updateCellEditor();
 }
+/**
+* Returns {@code true} if the tree is editable.
+*
+* @return {@code true} if the tree is editable
+*/
 protected boolean isEditable() {
 return (tree != null) ? tree.isEditable() : false;
 }
 /**
 * Resets the selection model. The appropriate listener are installed
 * on the model.
+*
+* @param newLSM new selection model
 */
 protected void setSelectionModel(TreeSelectionModel newLSM) {
 completeEditing();
 if(selectionModelPropertyChangeListener != null &&
 treeSelectionModel != null)
 treeState.setSelectionModel(null);
 if(tree != null)
 tree.repaint();
 }
+/**
+* Returns the tree selection model.
+*
+* @return the tree selection model
+*/
 protected TreeSelectionModel getSelectionModel() {
 return treeSelectionModel;
 }
 //
 completeUIInstall();
 }
 /**
-* Invoked after the <code>tree</code> instance variable has been
+* Invoked after the {@code tree} instance variable has been
 * set, but before any defaults/listeners have been installed.
 */
 protected void prepareForUIInstall() {
 drawingCache = new Hashtable<TreePath,Boolean>(7);
 configureLayoutCache();
 updateSize();
 }
+/**
+* Installs default properties.
+*/
 protected void installDefaults() {
 if(tree.getBackground() == null ||
 tree.getBackground() instanceof UIResource) {
 tree.setBackground(UIManager.getColor("Tree.background"));
 }
 LookAndFeel.installProperty(tree,
 JTree.SHOWS_ROOT_HANDLES_PROPERTY, showsRootHandles);
 }
 }
+/**
+* Registers listeners.
+*/
 protected void installListeners() {
 if ( (propertyChangeListener = createPropertyChangeListener())
 != null ) {
 tree.addPropertyChangeListener(propertyChangeListener);
 }
 }
 LookAndFeel.installProperty(tree, "opaque", Boolean.TRUE);
 }
+/**
+* Registers keyboard actions.
+*/
 protected void installKeyboardActions() {
 InputMap km = getInputMap(JComponent.
 WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
 SwingUtilities.replaceUIInputMap(tree, JComponent.
 //
 // Create methods.
 //
 /**
-* Creates an instance of NodeDimensions that is able to determine
+* Creates an instance of {@code NodeDimensions} that is able to determine
 * the size of a given node in the tree.
+*
+* @return an instance of {@code NodeDimensions}
 */
 protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
 return new NodeDimensionsHandler();
 }
 /**
 * Creates a listener that is responsible that updates the UI based on
 * how the tree changes.
+*
+* @return an instance of the {@code PropertyChangeListener}
 */
 protected PropertyChangeListener createPropertyChangeListener() {
 return getHandler();
 }
 }
 /**
 * Creates the listener responsible for updating the selection based on
 * mouse events.
+*
+* @return an instance of the {@code MouseListener}
 */
 protected MouseListener createMouseListener() {
 return getHandler();
 }
 /**
 * Creates a listener that is responsible for updating the display
 * when focus is lost/gained.
+*
+* @return an instance of the {@code FocusListener}
 */
 protected FocusListener createFocusListener() {
 return getHandler();
 }
 /**
-* Creates the listener reponsible for getting key events from
+* Creates the listener responsible for getting key events from
 * the tree.
+*
+* @return an instance of the {@code KeyListener}
 */
 protected KeyListener createKeyListener() {
 return getHandler();
 }
 /**
 * Creates the listener responsible for getting property change
 * events from the selection model.
+*
+* @return an instance of the {@code PropertyChangeListener}
 */
 protected PropertyChangeListener createSelectionModelPropertyChangeListener() {
 return getHandler();
 }
 /**
 * Creates the listener that updates the display based on selection change
 * methods.
+*
+* @return an instance of the {@code TreeSelectionListener}
 */
 protected TreeSelectionListener createTreeSelectionListener() {
 return getHandler();
 }
 /**
 * Creates a listener to handle events from the current editor.
+*
+* @return an instance of the {@code CellEditorListener}
 */
 protected CellEditorListener createCellEditorListener() {
 return getHandler();
 }
 /**
 * Creates and returns a new ComponentHandler. This is used for
 * the large model to mark the validCachedPreferredSize as invalid
 * when the component moves.
+*
+* @return an instance of the {@code ComponentListener}
 */
 protected ComponentListener createComponentListener() {
 return new ComponentHandler();
 }
 /**
 * Creates and returns the object responsible for updating the treestate
 * when nodes expanded state changes.
+*
+* @return an instance of the {@code TreeExpansionListener}
 */
 protected TreeExpansionListener createTreeExpansionListener() {
 return getHandler();
 }
 /**
 * Creates the object responsible for managing what is expanded, as
 * well as the size of nodes.
+*
+* @return the object responsible for managing what is expanded
 */
 protected AbstractLayoutCache createLayoutCache() {
 if(isLargeModel() && getRowHeight() > 0) {
 return new FixedHeightLayoutCache();
 }
 return new VariableHeightLayoutCache();
 }
 /**
 * Returns the renderer pane that renderer components are placed in.
+*
+* @return an instance of the {@code CellRendererPane}
 */
 protected CellRendererPane createCellRendererPane() {
 return new CellRendererPane();
 }
 /**
 * Creates a default cell editor.
-*/
+*
+* @return a default cell editor
+*/
 protected TreeCellEditor createDefaultCellEditor() {
 if(currentCellRenderer != null &&
 (currentCellRenderer instanceof DefaultTreeCellRenderer)) {
 DefaultTreeCellEditor editor = new DefaultTreeCellEditor
 (tree, (DefaultTreeCellRenderer)currentCellRenderer);
 }
 return new DefaultTreeCellEditor(tree, null);
 }
 /**
 * Returns the default cell renderer that is used to do the
 * stamping of each node.
-*/
+*
+* @return an instance of {@code TreeCellRenderer}
+*/
 protected TreeCellRenderer createDefaultCellRenderer() {
 return new DefaultTreeCellRenderer();
 }
 /**
 * Returns a listener that can update the tree when the model changes.
+*
+* @return an instance of the {@code TreeModelListener}.
 */
 protected TreeModelListener createTreeModelListener() {
 return getHandler();
 }
 uninstallComponents();
 completeUIUninstall();
 }
+/**
+* Invoked before unstallation of UI.
+*/
 protected void prepareForUIUninstall() {
 }
+/**
+* Uninstalls UI.
+*/
 protected void completeUIUninstall() {
 if(createdRenderer) {
 tree.setCellRenderer(null);
 }
 if(createdCellEditor) {
 treeSelectionModel = null;
 treeSelectionListener = null;
 treeExpansionListener = null;
 }
+/**
+* Uninstalls default properties.
+*/
 protected void uninstallDefaults() {
 if (tree.getTransferHandler() instanceof UIResource) {
 tree.setTransferHandler(null);
 }
 }
+/**
+* Unregisters listeners.
+*/
 protected void uninstallListeners() {
 if(componentListener != null) {
 tree.removeComponentListener(componentListener);
 }
 if (propertyChangeListener != null) {
 (treeSelectionListener);
 }
 handler = null;
 }
+/**
+* Unregisters keyboard actions.
+*/
 protected void uninstallKeyboardActions() {
 SwingUtilities.replaceUIActionMap(tree, null);
 SwingUtilities.replaceUIInputMap(tree, JComponent.
 WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
 null);
 return rect;
 }
 /**
 * Paints the horizontal part of the leg. The receiver should
-* NOT modify <code>clipBounds</code>, or <code>insets</code>.<p>
+* NOT modify {@code clipBounds}, or {@code insets}.<p>
-* NOTE: <code>parentRow</code> can be -1 if the root is not visible.
+* NOTE: {@code parentRow} can be -1 if the root is not visible.
+*
+* @param g a graphics context
+* @param clipBounds a clipped rectangle
+* @param insets insets
+* @param bounds a bounding rectangle
+* @param path a tree path
+* @param row a row
+* @param isExpanded {@code true} if the path is expanded
+* @param hasBeenExpanded {@code true} if the path has been expanded
+* @param isLeaf {@code true} if the path is leaf
 */
 protected void paintHorizontalPartOfLeg(Graphics g, Rectangle clipBounds,
 Insets insets, Rectangle bounds,
 TreePath path, int row,
 boolean isExpanded,
 }
 }
 /**
 * Paints the vertical part of the leg. The receiver should
-* NOT modify <code>clipBounds</code>, <code>insets</code>.
+* NOT modify {@code clipBounds}, {@code insets}.
+*
+* @param g a graphics context
+* @param clipBounds a clipped rectangle
+* @param insets insets
+* @param path a tree path
 */
 protected void paintVerticalPartOfLeg(Graphics g, Rectangle clipBounds,
 Insets insets, TreePath path) {
 if (!paintLines) {
 return;
 }
 }
 /**
 * Paints the expand (toggle) part of a row. The receiver should
-* NOT modify <code>clipBounds</code>, or <code>insets</code>.
+* NOT modify {@code clipBounds}, or {@code insets}.
+*
+* @param g a graphics context
+* @param clipBounds a clipped rectangle
+* @param insets insets
+* @param bounds a bounding rectangle
+* @param path a tree path
+* @param row a row
+* @param isExpanded {@code true} if the path is expanded
+* @param hasBeenExpanded {@code true} if the path has been expanded
+* @param isLeaf {@code true} if the row is leaf
 */
 protected void paintExpandControl(Graphics g,
 Rectangle clipBounds, Insets insets,
 Rectangle bounds, TreePath path,
 int row, boolean isExpanded,
 }
 }
 /**
 * Paints the renderer part of a row. The receiver should
-* NOT modify <code>clipBounds</code>, or <code>insets</code>.
+* NOT modify {@code clipBounds}, or {@code insets}.
+*
+* @param g a graphics context
+* @param clipBounds a clipped rectangle
+* @param insets insets
+* @param bounds a bounding rectangle
+* @param path a tree path
+* @param row a row
+* @param isExpanded {@code true} if the path is expanded
+* @param hasBeenExpanded {@code true} if the path has been expanded
+* @param isLeaf {@code true} if the path is leaf
 */
 protected void paintRow(Graphics g, Rectangle clipBounds,
 Insets insets, Rectangle bounds, TreePath path,
 int row, boolean isExpanded,
 boolean hasBeenExpanded, boolean isLeaf) {
 rendererPane.paintComponent(g, component, tree, bounds.x, bounds.y,
 bounds.width, bounds.height, true);
 }
 /**
-* Returns true if the expand (toggle) control should be drawn for
+* Returns {@code true} if the expand (toggle) control should be drawn for
 * the specified row.
+*
+* @param path a tree path
+* @param row a row
+* @param isExpanded {@code true} if the path is expanded
+* @param hasBeenExpanded {@code true} if the path has been expanded
+* @param isLeaf {@code true} if the row is leaf
+* @return {@code true} if the expand (toggle) control should be drawn
+*         for the specified row
 */
 protected boolean shouldPaintExpandControl(TreePath path, int row,
 boolean isExpanded,
 boolean hasBeenExpanded,
 boolean isLeaf) {
 return true;
 }
 /**
 * Paints a vertical line.
+*
+* @param g a graphics context
+* @param c a component
+* @param x an X coordinate
+* @param top an Y1 coordinate
+* @param bottom an Y2 coordinate
 */
 protected void paintVerticalLine(Graphics g, JComponent c, int x, int top,
 int bottom) {
 if (lineTypeDashed) {
 drawDashedVerticalLine(g, x, top, bottom);
 }
 }
 /**
 * Paints a horizontal line.
+*
+* @param g a graphics context
+* @param c a component
+* @param y an Y coordinate
+* @param left an X1 coordinate
+* @param right an X2 coordinate
 */
 protected void paintHorizontalLine(Graphics g, JComponent c, int y,
 int left, int right) {
 if (lineTypeDashed) {
 drawDashedHorizontalLine(g, y, left, right);
 }
 /**
 * The vertical element of legs between nodes starts at the bottom of the
 * parent node by default.  This method makes the leg start below that.
+*
+* @return the vertical leg buffer
 */
 protected int getVerticalLegBuffer() {
 return 0;
 }
 /**
 * The horizontal element of legs between nodes starts at the
 * right of the left-hand side of the child node by default.  This
 * method makes the leg end before that.
+*
+* @return the horizontal leg buffer
 */
 protected int getHorizontalLegBuffer() {
 return 0;
 }
 //
 // Generic painting methods
 //
-// Draws the icon centered at (x,y)
+/**
+* Draws the {@code icon} centered at (x,y).
+*
+* @param c a component
+* @param graphics a graphics context
+* @param icon an icon
+* @param x an X coordinate
+* @param y an Y coordinate
+*/
 protected void drawCentered(Component c, Graphics graphics, Icon icon,
 int x, int y) {
 icon.paintIcon(c, graphics,
 findCenteredX(x, icon.getIconWidth()),
 y - icon.getIconHeight() / 2);
 }
 }
 }
 /**
-* Updates the expanded state of all the descendants of <code>path</code>
+* Updates the expanded state of all the descendants of {@code path}
 * by getting the expanded descendants from the tree and forwarding
 * to the tree state.
+*
+* @param path a tree path
 */
 protected void updateExpandedDescendants(TreePath path) {
 completeEditing();
 if(treeState != null) {
 treeState.setExpandedState(path, true);
 updateSize();
 }
 }
 /**
-* Returns a path to the last child of <code>parent</code>.
+* Returns a path to the last child of {@code parent}.
+*
+* @param parent a tree path
+* @return a path to the last child of {@code parent}
 */
 protected TreePath getLastChildPath(TreePath parent) {
 if(treeModel != null) {
 int         childCount = treeModel.getChildCount
 (parent.getLastPathComponent());
 }
 validCachedPreferredSize = true;
 }
 /**
-* Messaged from the VisibleTreeNode after it has been expanded.
+* Messaged from the {@code VisibleTreeNode} after it has been expanded.
-*/
+*
+* @param path a tree path
+*/
 protected void pathWasExpanded(TreePath path) {
 if(tree != null) {
 tree.fireTreeExpanded(path);
 }
 }
 /**
-* Messaged from the VisibleTreeNode after it has collapsed.
+* Messaged from the {@code VisibleTreeNode} after it has collapsed.
-*/
+*
+* @param path a tree path
+*/
 protected void pathWasCollapsed(TreePath path) {
 if(tree != null) {
 tree.fireTreeCollapsed(path);
 }
 }
 /**
-* Ensures that the rows identified by beginRow through endRow are
+* Ensures that the rows identified by {@code beginRow} through
-* visible.
+* {@code endRow} are visible.
-*/
+*
+* @param beginRow the begin row
+* @param endRow the end row
+*/
 protected void ensureRowsAreVisible(int beginRow, int endRow) {
 if(tree != null && beginRow >= 0 && endRow < getRowCount(tree)) {
 boolean scrollVert = DefaultLookup.getBoolean(tree, this,
 "Tree.scrollsHorizontallyAndVertically", false);
 if(beginRow == endRow) {
 }
 }
 }
 }
-/** Sets the preferred minimum size.
+/**
-*/
+* Sets the preferred minimum size.
+*
+* @param newSize the new preferred size
+*/
 public void setPreferredMinSize(Dimension newSize) {
 preferredMinSize = newSize;
 }
-/** Returns the minimum preferred size.
+/**
-*/
+* Returns the minimum preferred size.
+*
+* @return the minimum preferred size
+*/
 public Dimension getPreferredMinSize() {
 if(preferredMinSize == null)
 return null;
 return new Dimension(preferredMinSize);
 }
-/** Returns the preferred size to properly display the tree,
+/**
-* this is a cover method for getPreferredSize(c, true).
+* Returns the preferred size to properly display the tree,
-*/
+* this is a cover method for {@code getPreferredSize(c, true)}.
+*
+* @param c a component
+* @return the preferred size to represent the tree in the component
+*/
 public Dimension getPreferredSize(JComponent c) {
 return getPreferredSize(c, true);
 }
-/** Returns the preferred size to represent the tree in
+/**
-* <I>c</I>.  If <I>checkConsistency</I> is true
+* Returns the preferred size to represent the tree in
-* <b>checkConsistency</b> is messaged first.
+* <I>c</I>.  If <I>checkConsistency</I> is {@code true}
-*/
+* <b>checkConsistency</b> is messaged first.
+*
+* @param c a component
+* @param checkConsistency if {@code true} consistency is checked
+* @return the preferred size to represent the tree in the component
+*/
 public Dimension getPreferredSize(JComponent c,
 boolean checkConsistency) {
 Dimension       pSize = this.getPreferredMinSize();
 if(!validCachedPreferredSize)
 was successful. */
 completeEditing(false, true, false);
 }
 /**
-* Stops the editing session.  If messageStop is true the editor
+* Stops the editing session. If {@code messageStop} is {@code true} the editor
-* is messaged with stopEditing, if messageCancel is true the
+* is messaged with {@code stopEditing}, if {@code messageCancel}
-* editor is messaged with cancelEditing. If messageTree is true
+* is {@code true} the editor is messaged with {@code cancelEditing}.
-* the treeModel is messaged with valueForPathChanged.
+* If {@code messageTree} is {@code true} the {@code treeModel} is messaged
-*/
+* with {@code valueForPathChanged}.
+*
+* @param messageStop message to stop editing
+* @param messageCancel message to cancel editing
+* @param messageTree message to tree
+*/
 protected void completeEditing(boolean messageStop,
 boolean messageCancel,
 boolean messageTree) {
 if(stopEditingInCompleteEditing && editingComponent != null) {
 Component             oldComponent = editingComponent;
 this.releaseEvent = null;
 }
 }
 /**
-* Will start editing for node if there is a cellEditor and
+* Will start editing for node if there is a {@code cellEditor} and
-* shouldSelectCell returns true.<p>
+* {@code shouldSelectCell} returns {@code true}.<p>
 * This assumes that path is valid and visible.
-*/
+*
+* @param path a tree path
+* @param event a mouse event
+* @return {@code true} if the editing is successful
+*/
 protected boolean startEditing(TreePath path, MouseEvent event) {
 if (isEditing(tree) && tree.getInvokesStopCellEditing() &&
 !stopEditing(tree)) {
 return false;
 }
 //
 // Following are primarily for handling mouse events.
 //
 /**
-* If the <code>mouseX</code> and <code>mouseY</code> are in the
+* If the {@code mouseX} and {@code mouseY} are in the
-* expand/collapse region of the <code>row</code>, this will toggle
+* expand/collapse region of the {@code row}, this will toggle
 * the row.
+*
+* @param path a tree path
+* @param mouseX an X coordinate
+* @param mouseY an Y coordinate
 */
 protected void checkForClickInExpandControl(TreePath path,
 int mouseX, int mouseY) {
 if (isLocationInExpandControl(path, mouseX, mouseY)) {
 handleExpandControlClick(path, mouseX, mouseY);
 }
 }
 /**
-* Returns true if <code>mouseX</code> and <code>mouseY</code> fall
+* Returns {@code true} if {@code mouseX} and {@code mouseY} fall
 * in the area of row that is used to expand/collapse the node and
-* the node at <code>row</code> does not represent a leaf.
+* the node at {@code row} does not represent a leaf.
+*
+* @param path a tree path
+* @param mouseX an X coordinate
+* @param mouseY an Y coordinate
+* @return {@code true} if the mouse cursor fall in the area of row that
+*         is used to expand/collapse the node and the node is not a leaf.
 */
 protected boolean isLocationInExpandControl(TreePath path,
 int mouseX, int mouseY) {
 if(path != null && !treeModel.isLeaf(path.getLastPathComponent())){
 int                     boxWidth;
 return false;
 }
 /**
 * Messaged when the user clicks the particular row, this invokes
-* toggleExpandState.
+* {@code toggleExpandState}.
+*
+* @param path a tree path
+* @param mouseX an X coordinate
+* @param mouseY an Y coordinate
 */
 protected void handleExpandControlClick(TreePath path, int mouseX,
 int mouseY) {
 toggleExpandState(path);
 }
 /**
 * Expands path if it is not expanded, or collapses row if it is expanded.
-* If expanding a path and JTree scrolls on expand, ensureRowsAreVisible
+* If expanding a path and {@code JTree} scrolls on expand,
-* is invoked to scroll as many of the children to visible as possible
+* {@code ensureRowsAreVisible} is invoked to scroll as many of the children
-* (tries to scroll to last visible descendant of path).
+* to visible as possible (tries to scroll to last visible descendant of path).
+*
+* @param path a tree path
 */
 protected void toggleExpandState(TreePath path) {
 if(!tree.isExpanded(path)) {
 int       row = getRowForPath(tree, path);
 updateSize();
 }
 }
 /**
-* Returning true signifies a mouse event on the node should toggle
+* Returning {@code true} signifies a mouse event on the node should toggle
 * the selection of only the row under mouse.
+*
+* @param event a mouse event
+* @return {@code true} if a mouse event on the node should toggle the selection
 */
 protected boolean isToggleSelectionEvent(MouseEvent event) {
 return (SwingUtilities.isLeftMouseButton(event) &&
 BasicGraphicsUtils.isMenuShortcutKeyDown(event));
 }
 /**
-* Returning true signifies a mouse event on the node should select
+* Returning {@code true} signifies a mouse event on the node should select
 * from the anchor point.
+*
+* @param event a mouse event
+* @return {@code true} if a mouse event on the node should select
+*         from the anchor point
 */
 protected boolean isMultiSelectEvent(MouseEvent event) {
 return (SwingUtilities.isLeftMouseButton(event) &&
 event.isShiftDown());
 }
 /**
-* Returning true indicates the row under the mouse should be toggled
+* Returning {@code true} indicates the row under the mouse should be toggled
-* based on the event. This is invoked after checkForClickInExpandControl,
+* based on the event. This is invoked after {@code checkForClickInExpandControl},
-* implying the location is not in the expand (toggle) control
+* implying the location is not in the expand (toggle) control.
+*
+* @param event a mouse event
+* @return {@code true} if the row under the mouse should be toggled
 */
 protected boolean isToggleEvent(MouseEvent event) {
 if(!SwingUtilities.isLeftMouseButton(event)) {
 return false;
 }
 }
 return ((event.getClickCount() % clickCount) == 0);
 }
 /**
-* Messaged to update the selection based on a MouseEvent over a
+* Messaged to update the selection based on a {@code MouseEvent} over a
 * particular row. If the event is a toggle selection event, the
 * row is either selected, or deselected. If the event identifies
 * a multi selection event, the selection is updated from the
 * anchor point. Otherwise the row is selected, and if the event
 * specified a toggle event the row is expanded/collapsed.
+*
+* @param path the selected path
+* @param event the mouse event
 */
 protected void selectPathForEvent(TreePath path, MouseEvent event) {
 /* Adjust from the anchor point. */
 if(isMultiSelectEvent(event)) {
 TreePath    anchor = getAnchorSelectionPath();
 }
 }
 }
 /**
-* @return true if the node at <code>row</code> is a leaf.
+* Returns {@code true} if the node at {@code row} is a leaf.
+*
+* @param row a row
+* @return {@code true} if the node at {@code row} is a leaf
 */
 protected boolean isLeaf(int row) {
 TreePath          path = getPathForRow(tree, row);
 if(path != null)
 }
 timer.start();
 }
 /**
-* Returns the JScrollPane housing the JTree, or null if one isn't
+* Returns the {@code JScrollPane} housing the {@code JTree},
-* found.
+* or null if one isn't found.
+*
+* @return the {@code JScrollPane} housing the {@code JTree}
 */
 protected JScrollPane getScrollPane() {
 Component       c = tree.getParent();
 while(c != null && !(c instanceof JScrollPane))
 }
 return null;
 }
 /**
-* @return amount to indent the given row.
+* Returns amount to indent the given row.
+*
+* @param row a row
+* @param depth a depth
+* @return amount to indent the given row
 */
 protected int getRowX(int row, int depth) {
 return BasicTreeUI.this.getRowX(row, depth);
 }
 protected int direction;
 /** True if the selection is reset, false means only the lead path
 * changes. */
 private boolean changeSelection;
+/**
+* Constructs a new instance of {@code TreeTraverseAction}.
+*
+* @param direction the direction
+* @param name the name of action
+*/
 public TreeTraverseAction(int direction, String name) {
 this(direction, name, true);
 }
 private TreeTraverseAction(int direction, String name,
 protected int         direction;
 /** True indicates should set selection from anchor path. */
 private boolean       addToSelection;
 private boolean       changeSelection;
+/**
+* Constructs a new instance of {@code TreePageAction}.
+*
+* @param direction the direction
+* @param name the name of action
+*/
 public TreePageAction(int direction, String name) {
 this(direction, name, false, true);
 }
 private TreePageAction(int direction, String name,
 /** If true the new item is added to the selection, if false the
 * selection is reset. */
 private boolean       addToSelection;
 private boolean       changeSelection;
+/**
+* Constructs a new instance of {@code TreeIncrementAction}.
+*
+* @param direction the direction
+* @param name the name of action
+*/
 public TreeIncrementAction(int direction, String name) {
 this(direction, name, false, true);
 }
 private TreeIncrementAction(int direction, String name,
 * Scrolls either the first or last cell to be visible based on
 * direction.
 */
 @SuppressWarnings("serial") // Superclass is not serializable across versions
 public class TreeHomeAction extends AbstractAction {
+/**
+* The direction.
+*/
 protected int            direction;
 /** Set to true if append to selection. */
 private boolean          addToSelection;
 private boolean          changeSelection;
+/**
+* Constructs a new instance of {@code TreeHomeAction}.
+*
+* @param direction the direction
+* @param name the name of action
+*/
 public TreeHomeAction(int direction, String name) {
 this(direction, name, false, true);
 }
 private TreeHomeAction(int direction, String name,
 /**
 * For the first selected row expandedness will be toggled.
 */
 @SuppressWarnings("serial") // Superclass is not serializable across versions
 public class TreeToggleAction extends AbstractAction {
+/**
+* Constructs a new instance of {@code TreeToggleAction}.
+*
+* @param name the name of action
+*/
 public TreeToggleAction(String name) {
 }
 public void actionPerformed(ActionEvent e) {
 if(tree != null) {
 /**
 * ActionListener that invokes cancelEditing when action performed.
 */
 @SuppressWarnings("serial") // Superclass is not serializable across versions
 public class TreeCancelEditingAction extends AbstractAction {
+/**
+* Constructs a new instance of {@code TreeCancelEditingAction}.
+*
+* @param name the name of action
+*/
 public TreeCancelEditingAction(String name) {
 }
 public void actionPerformed(ActionEvent e) {
 if(tree != null) {
 /** Destination that receives all events. */
 protected Component        destination;
 private Component          focusComponent;
 private boolean            dispatchedEvent;
+/**
+* Constructs a new instance of {@code MouseInputHandler}.
+*
+* @param source a source component
+* @param destination a destination component
+* @param event a mouse event
+*/
 public MouseInputHandler(Component source, Component destination,
 MouseEvent event){
 this(source, destination, event, null);
 }
 public void mouseMoved(MouseEvent e) {
 removeFromSource();
 }
+/**
+* Removes an event from the source.
+*/
 protected void removeFromSource() {
 if(source != null) {
 source.removeMouseListener(this);
 source.removeMouseMotionListener(this);
 if (focusComponent != null &&

changeset 25775	6a6fd62bc6d5
parent 25565	ce603b34c98d
child 25784	656f7d3eef5f