Module java.desktop
Package javax.swing.plaf.basic

Class BasicTreeUI

java.lang.Object
javax.swing.plaf.ComponentUI
javax.swing.plaf.TreeUI
javax.swing.plaf.basic.BasicTreeUI
Direct Known Subclasses:
MetalTreeUI, SynthTreeUI
public class BasicTreeUI extends TreeUI
The basic L&F for a hierarchical data structure.

  • Field Details

    • collapsedIcon

      protected transient Icon collapsedIcon
      The collapsed icon.

    • expandedIcon

      protected transient Icon expandedIcon
      The expanded icon.

    • leftChildIndent

      protected int leftChildIndent
      Distance between left margin and where vertical dashes will be drawn.

    • rightChildIndent

      protected int rightChildIndent
      Distance to add to leftChildIndent to determine where cell contents will be drawn.

    • totalChildIndent

      protected int totalChildIndent
      Total distance that will be indented. The sum of leftChildIndent and rightChildIndent.

    • preferredMinSize

      protected Dimension preferredMinSize
      Minimum preferred size.

    • lastSelectedRow

      protected int lastSelectedRow
      Index of the row that was last selected.

    • tree

      protected JTree tree
      Component that we're going to be drawing into.

    • currentCellRenderer

      protected transient TreeCellRenderer currentCellRenderer
      Renderer that is being used to do the actual cell drawing.

    • createdRenderer

      protected boolean createdRenderer
      Set to true if the renderer that is currently in the tree was created by this instance.

    • cellEditor

      protected transient TreeCellEditor cellEditor
      Editor for the tree.

    • createdCellEditor

      protected boolean createdCellEditor
      Set to true if editor that is currently in the tree was created by this instance.

    • stopEditingInCompleteEditing

      protected boolean stopEditingInCompleteEditing
      Set to false when editing and shouldSelectCell() returns true meaning the node should be selected before editing, used in completeEditing.

    • rendererPane

      protected CellRendererPane rendererPane
      Used to paint the TreeCellRenderer.

    • preferredSize

      protected Dimension preferredSize
      Size needed to completely display all the nodes.

    • validCachedPreferredSize

      protected boolean validCachedPreferredSize
      Is the preferredSize valid?

    • treeState

      protected AbstractLayoutCache treeState
      Object responsible for handling sizing and expanded issues.

    • drawingCache

      protected Hashtable<TreePath,Boolean> drawingCache
      Used for minimizing the drawing of vertical lines.

    • largeModel

      protected boolean largeModel
      True if doing optimizations for a largeModel. Subclasses that don't support this may wish to override createLayoutCache to not return a FixedHeightLayoutCache instance.

    • nodeDimensions

      protected AbstractLayoutCache.NodeDimensions nodeDimensions
      Responsible for telling the TreeState the size needed for a node.

    • treeModel

      protected TreeModel treeModel
      Used to determine what to display.

    • treeSelectionModel

      protected TreeSelectionModel treeSelectionModel
      Model maintaining the selection.

    • depthOffset

      protected int depthOffset
      How much the depth should be offset to properly calculate x locations. This is based on whether or not the root is visible, and if the root handles are visible.

    • editingComponent

      protected Component editingComponent
      When editing, this will be the Component that is doing the actual editing.

    • editingPath

      protected TreePath editingPath
      Path that is being edited.

    • editingRow

      protected int editingRow
      Row that is being edited. Should only be referenced if editingComponent is not null.

    • editorHasDifferentSize

      protected boolean editorHasDifferentSize
      Set to true if the editor has a different size than the renderer.

  • Constructor Details

    • BasicTreeUI

      public BasicTreeUI()
      Constructs a new instance of BasicTreeUI.

  • Method Details

    • createUI

      public static ComponentUI createUI(JComponent x)
      Constructs a new instance of BasicTreeUI.
      Parameters:
      x - a component
      Returns:
      a new instance of BasicTreeUI

    • getHashColor

      protected Color getHashColor()
      Returns the hash color.
      Returns:
      the hash color

    • setHashColor

      protected void setHashColor(Color color)
      Sets the hash color.
      Parameters:
      color - the hash color

    • setLeftChildIndent

      public void setLeftChildIndent(int newAmount)
      Sets the left child indent.
      Parameters:
      newAmount - the left child indent

    • getLeftChildIndent

      public int getLeftChildIndent()
      Returns the left child indent.
      Returns:
      the left child indent

    • setRightChildIndent

      public void setRightChildIndent(int newAmount)
      Sets the right child indent.
      Parameters:
      newAmount - the right child indent

    • getRightChildIndent

      public int getRightChildIndent()
      Returns the right child indent.
      Returns:
      the right child indent

    • setExpandedIcon

      public void setExpandedIcon(Icon newG)
      Sets the expanded icon.
      Parameters:
      newG - the expanded icon

    • getExpandedIcon

      public Icon getExpandedIcon()
      Returns the expanded icon.
      Returns:
      the expanded icon

    • setCollapsedIcon

      public void setCollapsedIcon(Icon newG)
      Sets the collapsed icon.
      Parameters:
      newG - the collapsed icon

    • getCollapsedIcon

      public Icon getCollapsedIcon()
      Returns the collapsed icon.
      Returns:
      the collapsed icon

    • setLargeModel

      protected void setLargeModel(boolean largeModel)
      Sets the largeModel. Called when the largeModel property is changed in the drawn tree component.
      Parameters:
      largeModel - the new value of the largeModel property

    • isLargeModel

      protected boolean isLargeModel()
      Returns true if large model is set.
      Returns:
      true if large model is set

    • setRowHeight

      protected void setRowHeight(int rowHeight)
      Sets the row height, this is forwarded to the treeState. Called when the rowHeight property is changed in the drawn tree component.
      Parameters:
      rowHeight - the new value of the rowHeight property

    • getRowHeight

      protected int getRowHeight()
      Returns the height of each row in the drawn tree component. If the returned value is less than or equal to 0 the height for each row is determined by the renderer.
      Returns:
      the height of each row, in pixels

    • setCellRenderer

      protected void setCellRenderer(TreeCellRenderer tcr)
      Sets the TreeCellRenderer to tcr. This invokes updateRenderer. Called when the cellRenderer property is changed in the drawn tree component.
      Parameters:
      tcr - the new value of the cellRenderer property

    • getCellRenderer

      protected TreeCellRenderer getCellRenderer()
      Returns the current instance of the TreeCellRenderer that is rendering each cell.
      Returns:
      the TreeCellRenderer instance

    • setModel

      protected void setModel(TreeModel model)
      Sets the TreeModel.
      Parameters:
      model - the new value

    • getModel

      protected TreeModel getModel()
      Returns the tree model.
      Returns:
      the tree model

    • setRootVisible

      protected void setRootVisible(boolean newValue)
      Sets the root to being visible. Called when the rootVisible property is changed in the drawn tree component.
      Parameters:
      newValue - the new value of the rootVisible property

    • isRootVisible

      protected boolean isRootVisible()
      Returns whether the root node of the drawn tree component should be displayed.
      Returns:
      true if the root node of the tree is displayed

    • setShowsRootHandles

      protected void setShowsRootHandles(boolean newValue)
      Determines whether the node handles are to be displayed. Called when the showsRootHandles property is changed in the drawn tree component.
      Parameters:
      newValue - the new value of the showsRootHandles property

    • getShowsRootHandles

      protected boolean getShowsRootHandles()
      Returns true if the root handles are to be displayed.
      Returns:
      true if the root handles are to be displayed

    • setCellEditor

      protected void setCellEditor(TreeCellEditor editor)
      Sets the cell editor. Called when the cellEditor property is changed in the drawn tree component.
      Parameters:
      editor - the new value of the cellEditor property

    • getCellEditor

      protected TreeCellEditor getCellEditor()
      Returns the editor used to edit entries in the drawn tree component, or null if the tree cannot be edited.
      Returns:
      the TreeCellEditor instance, or null

    • setEditable

      protected void setEditable(boolean newValue)
      Configures the receiver to allow, or not allow, editing. Called when the editable property is changed in the drawn tree component.
      Parameters:
      newValue - the new value of the editable property

    • isEditable

      protected boolean isEditable()
      Returns whether the drawn tree component should be enabled for editing.
      Returns:
      true if the tree is editable

    • setSelectionModel

      protected void setSelectionModel(TreeSelectionModel newLSM)
      Resets the selection model. The appropriate listener are installed on the model. Called when the selectionModel property is changed in the drawn tree component.
      Parameters:
      newLSM - the new value of the selectionModel property

    • getSelectionModel

      protected TreeSelectionModel getSelectionModel()
      Returns the current instance of the TreeSelectionModel which is the model for selections.
      Returns:
      the TreeSelectionModel instance

    • getPathBounds

      public Rectangle getPathBounds(JTree tree, TreePath path)
      Returns the Rectangle enclosing the label portion that the last item in path will be drawn into. Will return null if any component in path is currently invalid.
      Specified by:
      getPathBounds in class TreeUI
      Parameters:
      tree - the JTree for path
      path - the TreePath identifying the node
      Returns:
      the Rectangle enclosing the label portion that the last item in path will be drawn into, null if any component in path is currently valid.

    • getPathForRow

      public TreePath getPathForRow(JTree tree, int row)
      Returns the path for passed in row. If row is not visible null is returned.
      Specified by:
      getPathForRow in class TreeUI
      Parameters:
      tree - a JTree object
      row - an integer specifying a row
      Returns:
      the path for row or null if row is not visible

    • getRowForPath

      public int getRowForPath(JTree tree, TreePath path)
      Returns the row that the last item identified in path is visible at. Will return -1 if any of the elements in path are not currently visible.
      Specified by:
      getRowForPath in class TreeUI
      Parameters:
      tree - the JTree for path
      path - the TreePath object to look in
      Returns:
      an integer specifying the row at which the last item identified is visible, -1 if any of the elements in path are not currently visible

    • getRowCount

      public int getRowCount(JTree tree)
      Returns the number of rows that are being displayed.
      Specified by:
      getRowCount in class TreeUI
      Parameters:
      tree - the JTree for which to count rows
      Returns:
      an integer specifying the number of row being displayed

    • getClosestPathForLocation

      public TreePath getClosestPathForLocation(JTree tree, int x, int y)
      Returns the path to the node that is closest to x,y. If there is nothing currently visible this will return null, otherwise it'll always return a valid path. If you need to test if the returned object is exactly at x, y you should get the bounds for the returned path and test x, y against that.
      Specified by:
      getClosestPathForLocation in class TreeUI
      Parameters:
      tree - a JTree object
      x - an integer giving the number of pixels horizontally from the left edge of the display area
      y - an integer giving the number of pixels vertically from the top of the display area, minus any top margin
      Returns:
      the TreePath node closest to x,y or null if there is nothing currently visible

    • isEditing

      public boolean isEditing(JTree tree)
      Returns true if the tree is being edited. The item that is being edited can be returned by getEditingPath().
      Specified by:
      isEditing in class TreeUI
      Parameters:
      tree - a JTree object
      Returns:
      true if tree is being edited

    • stopEditing

      public boolean stopEditing(JTree tree)
      Stops the current editing session. This has no effect if the tree isn't being edited. Returns true if the editor allows the editing session to stop.
      Specified by:
      stopEditing in class TreeUI
      Parameters:
      tree - a JTree object
      Returns:
      true if the editor allows the editing session to stop

    • cancelEditing

      public void cancelEditing(JTree tree)
      Cancels the current editing session.
      Specified by:
      cancelEditing in class TreeUI
      Parameters:
      tree - a JTree object

    • startEditingAtPath

      public void startEditingAtPath(JTree tree, TreePath path)
      Selects the last item in path and tries to edit it. Editing will fail if the CellEditor won't allow it for the selected item.
      Specified by:
      startEditingAtPath in class TreeUI
      Parameters:
      tree - the JTree being edited
      path - the TreePath to be edited

    • getEditingPath

      public TreePath getEditingPath(JTree tree)
      Returns the path to the element that is being edited.
      Specified by:
      getEditingPath in class TreeUI
      Parameters:
      tree - the JTree for which to return a path
      Returns:
      a TreePath containing the path to tree

    • prepareForUIInstall

      protected void prepareForUIInstall()
      Invoked after the tree instance variable has been set, but before any defaults/listeners have been installed.

    • completeUIInstall

      protected void completeUIInstall()
      Invoked from installUI after all the defaults/listeners have been installed.

    • installDefaults

      protected void installDefaults()
      Installs default properties.

    • installListeners

      protected void installListeners()
      Registers listeners.

    • installKeyboardActions

      protected void installKeyboardActions()
      Registers keyboard actions.

    • installComponents

      protected void installComponents()
      Intalls the subcomponents of the tree, which is the renderer pane.

    • createNodeDimensions

      protected AbstractLayoutCache.NodeDimensions createNodeDimensions()
      Creates an instance of NodeDimensions that is able to determine the size of a given node in the tree.
      Returns:
      an instance of NodeDimensions

    • createPropertyChangeListener

      protected PropertyChangeListener createPropertyChangeListener()
      Creates a listener that is responsible that updates the UI based on how the tree changes.
      Returns:
      an instance of the PropertyChangeListener

    • createMouseListener

      protected MouseListener createMouseListener()
      Creates the listener responsible for updating the selection based on mouse events.
      Returns:
      an instance of the MouseListener

    • createFocusListener

      protected FocusListener createFocusListener()
      Creates a listener that is responsible for updating the display when focus is lost/gained.
      Returns:
      an instance of the FocusListener

    • createKeyListener

      protected KeyListener createKeyListener()
      Creates the listener responsible for getting key events from the tree.
      Returns:
      an instance of the KeyListener

    • createSelectionModelPropertyChangeListener

      protected PropertyChangeListener createSelectionModelPropertyChangeListener()
      Creates the listener responsible for getting property change events from the selection model.
      Returns:
      an instance of the PropertyChangeListener

    • createTreeSelectionListener

      protected TreeSelectionListener createTreeSelectionListener()
      Creates the listener that updates the display based on selection change methods.
      Returns:
      an instance of the TreeSelectionListener

    • createCellEditorListener

      protected CellEditorListener createCellEditorListener()
      Creates a listener to handle events from the current editor.
      Returns:
      an instance of the CellEditorListener

    • createComponentListener

      protected ComponentListener createComponentListener()
      Creates and returns a new ComponentHandler. This is used for the large model to mark the validCachedPreferredSize as invalid when the component moves.
      Returns:
      an instance of the ComponentListener

    • createTreeExpansionListener

      protected TreeExpansionListener createTreeExpansionListener()
      Creates and returns the object responsible for updating the treestate when nodes expanded state changes.
      Returns:
      an instance of the TreeExpansionListener

    • createLayoutCache

      protected AbstractLayoutCache createLayoutCache()
      Creates the object responsible for managing what is expanded, as well as the size of nodes.
      Returns:
      the object responsible for managing what is expanded

    • createCellRendererPane

      protected CellRendererPane createCellRendererPane()
      Returns the renderer pane that renderer components are placed in.
      Returns:
      an instance of the CellRendererPane

    • createDefaultCellEditor

      protected TreeCellEditor createDefaultCellEditor()
      Creates a default cell editor.
      Returns:
      a default cell editor

    • createDefaultCellRenderer

      protected TreeCellRenderer createDefaultCellRenderer()
      Returns the default cell renderer that is used to do the stamping of each node.
      Returns:
      an instance of TreeCellRenderer

    • createTreeModelListener

      protected TreeModelListener createTreeModelListener()
      Returns a listener that can update the tree when the model changes.
      Returns:
      an instance of the TreeModelListener.

    • prepareForUIUninstall

      protected void prepareForUIUninstall()
      Invoked before uninstallation of UI.

    • completeUIUninstall

      protected void completeUIUninstall()
      Uninstalls UI.

    • uninstallDefaults

      protected void uninstallDefaults()
      Uninstalls default properties.

    • uninstallListeners

      protected void uninstallListeners()
      Unregisters listeners.

    • uninstallKeyboardActions

      protected void uninstallKeyboardActions()
      Unregisters keyboard actions.

    • uninstallComponents

      protected void uninstallComponents()
      Uninstalls the renderer pane.

    • getBaseline

      public int getBaseline(JComponent c, int width, int height)
      Returns the baseline.
      Overrides:
      getBaseline in class ComponentUI
      Parameters:
      c - JComponent baseline is being requested for
      width - the width to get the baseline for
      height - the height to get the baseline for
      Returns:
      baseline or a value < 0 indicating there is no reasonable baseline
      Throws:
      NullPointerException - if c is null
      IllegalArgumentException - if width or height is < 0
      Since:
      1.6
      See Also:

    • getBaselineResizeBehavior

      public Component.BaselineResizeBehavior getBaselineResizeBehavior(JComponent c)
      Returns an enum indicating how the baseline of the component changes as the size changes.
      Overrides:
      getBaselineResizeBehavior in class ComponentUI
      Parameters:
      c - JComponent to return baseline resize behavior for
      Returns:
      an enum indicating how the baseline changes as the component size changes
      Throws:
      NullPointerException - if c is null
      Since:
      1.6
      See Also:

    • isDropLine

      protected boolean isDropLine(JTree.DropLocation loc)
      Tells if a DropLocation should be indicated by a line between nodes. This is meant for javax.swing.DropMode.INSERT and javax.swing.DropMode.ON_OR_INSERT drop modes.
      Parameters:
      loc - a DropLocation
      Returns:
      true if the drop location should be shown as a line
      Since:
      1.7

    • paintDropLine

      protected void paintDropLine(Graphics g)
      Paints the drop line.
      Parameters:
      g - Graphics object to draw on
      Since:
      1.7

    • getDropLineRect

      protected Rectangle getDropLineRect(JTree.DropLocation loc)
      Returns a unbounding box for the drop line.
      Parameters:
      loc - a DropLocation
      Returns:
      bounding box for the drop line
      Since:
      1.7

    • paintHorizontalPartOfLeg

      protected void paintHorizontalPartOfLeg(Graphics g, Rectangle clipBounds, Insets insets, Rectangle bounds, TreePath path, int row, boolean isExpanded, boolean hasBeenExpanded, boolean isLeaf)
      Paints the horizontal part of the leg. The receiver should NOT modify clipBounds, or insets.

      NOTE: parentRow can be -1 if the root is not visible.

      Parameters:
      g - a graphics context
      clipBounds - a clipped rectangle
      insets - insets
      bounds - a bounding rectangle
      path - a tree path
      row - a row
      isExpanded - true if the path is expanded
      hasBeenExpanded - true if the path has been expanded
      isLeaf - true if the path is leaf

    • paintVerticalPartOfLeg

      protected void paintVerticalPartOfLeg(Graphics g, Rectangle clipBounds, Insets insets, TreePath path)
      Paints the vertical part of the leg. The receiver should NOT modify clipBounds, insets.
      Parameters:
      g - a graphics context
      clipBounds - a clipped rectangle
      insets - insets
      path - a tree path

    • paintExpandControl

      protected void paintExpandControl(Graphics g, Rectangle clipBounds, Insets insets, Rectangle bounds, TreePath path, int row, boolean isExpanded, boolean hasBeenExpanded, boolean isLeaf)
      Paints the expand (toggle) part of a row. The receiver should NOT modify clipBounds, or insets.
      Parameters:
      g - a graphics context
      clipBounds - a clipped rectangle
      insets - insets
      bounds - a bounding rectangle
      path - a tree path
      row - a row
      isExpanded - true if the path is expanded
      hasBeenExpanded - true if the path has been expanded
      isLeaf - true if the row is leaf

    • paintRow

      protected void paintRow(Graphics g, Rectangle clipBounds, Insets insets, Rectangle bounds, TreePath path, int row, boolean isExpanded, boolean hasBeenExpanded, boolean isLeaf)
      Paints the renderer part of a row. The receiver should NOT modify clipBounds, or insets.
      Parameters:
      g - a graphics context
      clipBounds - a clipped rectangle
      insets - insets
      bounds - a bounding rectangle
      path - a tree path
      row - a row
      isExpanded - true if the path is expanded
      hasBeenExpanded - true if the path has been expanded
      isLeaf - true if the path is leaf

    • shouldPaintExpandControl

      protected boolean shouldPaintExpandControl(TreePath path, int row, boolean isExpanded, boolean hasBeenExpanded, boolean isLeaf)
      Returns true if the expand (toggle) control should be drawn for the specified row.
      Parameters:
      path - a tree path
      row - a row
      isExpanded - true if the path is expanded
      hasBeenExpanded - true if the path has been expanded
      isLeaf - true if the row is leaf
      Returns:
      true if the expand (toggle) control should be drawn for the specified row

    • paintVerticalLine

      protected void paintVerticalLine(Graphics g, JComponent c, int x, int top, int bottom)
      Paints a vertical line.
      Parameters:
      g - a graphics context
      c - a component
      x - an X coordinate
      top - an Y1 coordinate
      bottom - an Y2 coordinate

    • paintHorizontalLine

      protected void paintHorizontalLine(Graphics g, JComponent c, int y, int left, int right)
      Paints a horizontal line.
      Parameters:
      g - a graphics context
      c - a component
      y - an Y coordinate
      left - an X1 coordinate
      right - an X2 coordinate

    • getVerticalLegBuffer

      protected int getVerticalLegBuffer()
      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.
      Returns:
      the vertical leg buffer

    • getHorizontalLegBuffer

      protected int getHorizontalLegBuffer()
      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.
      Returns:
      the horizontal leg buffer

    • drawCentered

      protected void drawCentered(Component c, Graphics graphics, Icon icon, int x, int y)
      Draws the icon centered at (x,y).
      Parameters:
      c - a component
      graphics - a graphics context
      icon - an icon
      x - an X coordinate
      y - an Y coordinate

    • drawDashedHorizontalLine

      protected void drawDashedHorizontalLine(Graphics g, int y, int x1, int x2)
      Draws a horizontal dashed line. It is assumed x1 <= x2. If x1 is greater than x2, the method draws nothing.
      Parameters:
      g - an instance of Graphics
      y - an Y coordinate
      x1 - an X1 coordinate
      x2 - an X2 coordinate

    • drawDashedVerticalLine

      protected void drawDashedVerticalLine(Graphics g, int x, int y1, int y2)
      Draws a vertical dashed line. It is assumed y1 <= y2. If y1 is greater than y2, the method draws nothing.
      Parameters:
      g - an instance of Graphics
      x - an X coordinate
      y1 - an Y1 coordinate
      y2 - an Y2 coordinate

    • getRowX

      protected int getRowX(int row, int depth)
      Returns the location, along the x-axis, to render a particular row at. The return value does not include any Insets specified on the JTree. This does not check for the validity of the row or depth, it is assumed to be correct and will not throw an Exception if the row or depth doesn't match that of the tree.
      Parameters:
      row - Row to return x location for
      depth - Depth of the row
      Returns:
      amount to indent the given row.
      Since:
      1.5

    • updateLayoutCacheExpandedNodes

      protected void updateLayoutCacheExpandedNodes()
      Makes all the nodes that are expanded in JTree expanded in LayoutCache. This invokes updateExpandedDescendants with the root path.

    • updateExpandedDescendants

      protected void updateExpandedDescendants(TreePath path)
      Updates the expanded state of all the descendants of path by getting the expanded descendants from the tree and forwarding to the tree state.
      Parameters:
      path - a tree path

    • getLastChildPath

      protected TreePath getLastChildPath(TreePath parent)
      Returns a path to the last child of parent.
      Parameters:
      parent - a tree path
      Returns:
      a path to the last child of parent

    • updateDepthOffset

      protected void updateDepthOffset()
      Updates how much each depth should be offset by.

    • updateCellEditor

      protected void updateCellEditor()
      Updates the cellEditor based on the editability of the JTree that we're contained in. If the tree is editable but doesn't have a cellEditor, a basic one will be used.

    • updateRenderer

      protected void updateRenderer()
      Messaged from the tree we're in when the renderer has changed.

    • configureLayoutCache

      protected void configureLayoutCache()
      Resets the TreeState instance based on the tree we're providing the look and feel for.

    • updateSize

      protected void updateSize()
      Marks the cached size as being invalid, and messages the tree with treeDidChange.

    • updateCachedPreferredSize

      protected void updateCachedPreferredSize()
      Updates the preferredSize instance variable, which is returned from getPreferredSize().

      For left to right orientations, the size is determined from the current AbstractLayoutCache. For RTL orientations, the preferred size becomes the width minus the minimum x position.

    • pathWasExpanded

      protected void pathWasExpanded(TreePath path)
      Messaged from the VisibleTreeNode after it has been expanded.
      Parameters:
      path - a tree path

    • pathWasCollapsed

      protected void pathWasCollapsed(TreePath path)
      Messaged from the VisibleTreeNode after it has collapsed.
      Parameters:
      path - a tree path

    • ensureRowsAreVisible

      protected void ensureRowsAreVisible(int beginRow, int endRow)
      Ensures that the rows identified by beginRow through endRow are visible.
      Parameters:
      beginRow - the begin row
      endRow - the end row

    • setPreferredMinSize

      public void setPreferredMinSize(Dimension newSize)
      Sets the preferred minimum size.
      Parameters:
      newSize - the new preferred size

    • getPreferredMinSize

      public Dimension getPreferredMinSize()
      Returns the minimum preferred size.
      Returns:
      the minimum preferred size

    • getPreferredSize

      public Dimension getPreferredSize(JComponent c)
      Returns the preferred size to properly display the tree, this is a cover method for getPreferredSize(c, true).
      Overrides:
      getPreferredSize in class ComponentUI
      Parameters:
      c - a component
      Returns:
      the preferred size to represent the tree in the component
      See Also:

    • getPreferredSize

      public Dimension getPreferredSize(JComponent c, boolean checkConsistency)
      Returns the preferred size to represent the tree in c. If checkConsistency is true checkConsistency is messaged first.
      Parameters:
      c - a component
      checkConsistency - if true consistency is checked
      Returns:
      the preferred size to represent the tree in the component

    • getMinimumSize

      public Dimension getMinimumSize(JComponent c)
      Returns the minimum size for this component. Which will be the min preferred size or 0, 0.
      Overrides:
      getMinimumSize in class ComponentUI
      Parameters:
      c - the component whose minimum size is being queried; this argument is often ignored, but might be used if the UI object is stateless and shared by multiple components
      Returns:
      a Dimension object or null
      See Also:

    • getMaximumSize

      public Dimension getMaximumSize(JComponent c)
      Returns the maximum size for this component, which will be the preferred size if the instance is currently in a JTree, or 0, 0.
      Overrides:
      getMaximumSize in class ComponentUI
      Parameters:
      c - the component whose maximum size is being queried; this argument is often ignored, but might be used if the UI object is stateless and shared by multiple components
      Returns:
      a Dimension object or null
      See Also:

    • completeEditing

      protected void completeEditing()
      Messages to stop the editing session. If the UI the receiver is providing the look and feel for returns true from getInvokesStopCellEditing, stopCellEditing will invoked on the current editor. Then completeEditing will be messaged with false, true, false to cancel any lingering editing.

    • completeEditing

      protected void completeEditing(boolean messageStop, boolean messageCancel, boolean messageTree)
      Stops the editing session. If messageStop is true the editor is messaged with stopEditing, if messageCancel is true the editor is messaged with cancelEditing. If messageTree is true the treeModel is messaged with valueForPathChanged.
      Parameters:
      messageStop - message to stop editing
      messageCancel - message to cancel editing
      messageTree - message to tree

    • startEditing

      protected boolean startEditing(TreePath path, MouseEvent event)
      Will start editing for node if there is a cellEditor and shouldSelectCell returns true.

      This assumes that path is valid and visible.

      Parameters:
      path - a tree path
      event - a mouse event
      Returns:
      true if the editing is successful

    • checkForClickInExpandControl

      protected void checkForClickInExpandControl(TreePath path, int mouseX, int mouseY)
      If the mouseX and mouseY are in the expand/collapse region of the row, this will toggle the row.
      Parameters:
      path - a tree path
      mouseX - an X coordinate
      mouseY - an Y coordinate

    • isLocationInExpandControl

      protected boolean isLocationInExpandControl(TreePath path, int mouseX, int mouseY)
      Returns true if mouseX and mouseY fall in the area of row that is used to expand/collapse the node and the node at row does not represent a leaf.
      Parameters:
      path - a tree path
      mouseX - an X coordinate
      mouseY - an Y coordinate
      Returns:
      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.

    • handleExpandControlClick

      protected void handleExpandControlClick(TreePath path, int mouseX, int mouseY)
      Messaged when the user clicks the particular row, this invokes toggleExpandState.
      Parameters:
      path - a tree path
      mouseX - an X coordinate
      mouseY - an Y coordinate

    • toggleExpandState

      protected void toggleExpandState(TreePath 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 is invoked to scroll as many of the children to visible as possible (tries to scroll to last visible descendant of path).
      Parameters:
      path - a tree path

    • isToggleSelectionEvent

      protected boolean isToggleSelectionEvent(MouseEvent event)
      Returning true signifies a mouse event on the node should toggle the selection of only the row under mouse.
      Parameters:
      event - a mouse event
      Returns:
      true if a mouse event on the node should toggle the selection

    • isMultiSelectEvent

      protected boolean isMultiSelectEvent(MouseEvent event)
      Returning true signifies a mouse event on the node should select from the anchor point.
      Parameters:
      event - a mouse event
      Returns:
      true if a mouse event on the node should select from the anchor point

    • isToggleEvent

      protected boolean isToggleEvent(MouseEvent event)
      Returning true indicates the row under the mouse should be toggled based on the event. This is invoked after checkForClickInExpandControl, implying the location is not in the expand (toggle) control.
      Parameters:
      event - a mouse event
      Returns:
      true if the row under the mouse should be toggled

    • selectPathForEvent

      protected void selectPathForEvent(TreePath path, MouseEvent event)
      Messaged to update the selection based on a 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.
      Parameters:
      path - the selected path
      event - the mouse event

    • isLeaf

      protected boolean isLeaf(int row)
      Returns true if the node at row is a leaf.
      Parameters:
      row - a row
      Returns:
      true if the node at row is a leaf

    • updateLeadSelectionRow

      protected void updateLeadSelectionRow()
      Updates the lead row of the selection.
      Since:
      1.7

    • getLeadSelectionRow

      protected int getLeadSelectionRow()
      Returns the lead row of the selection.
      Returns:
      selection lead row
      Since:
      1.7