IT. Expert System.

Java Standard Edition (SE)



Class BasicTreeUI

  • Direct Known Subclasses:
    MetalTreeUI, SynthTreeUI

    public class BasicTreeUI
    extends TreeUI
    The basic L&F for a hierarchical data structure.

    • Field Detail

      • collapsedIcon

        protected transient Icon collapsedIcon
      • expandedIcon

        protected transient Icon expandedIcon
      • 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.
      • 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.
      • 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 Detail

      • BasicTreeUI

        public BasicTreeUI()
    • Method Detail

      • getHashColor

        protected Color getHashColor()
      • setHashColor

        protected void setHashColor(Color color)
      • setLeftChildIndent

        public void setLeftChildIndent(int newAmount)
      • getLeftChildIndent

        public int getLeftChildIndent()
      • setRightChildIndent

        public void setRightChildIndent(int newAmount)
      • getRightChildIndent

        public int getRightChildIndent()
      • setExpandedIcon

        public void setExpandedIcon(Icon newG)
      • getExpandedIcon

        public Icon getExpandedIcon()
      • setCollapsedIcon

        public void setCollapsedIcon(Icon newG)
      • getCollapsedIcon

        public Icon getCollapsedIcon()
      • setLargeModel

        protected void setLargeModel(boolean largeModel)
        Updates the componentListener, if necessary.
      • isLargeModel

        protected boolean isLargeModel()
      • setRowHeight

        protected void setRowHeight(int rowHeight)
        Sets the row height, this is forwarded to the treeState.
      • getRowHeight

        protected int getRowHeight()
      • setCellRenderer

        protected void setCellRenderer(TreeCellRenderer tcr)
        Sets the TreeCellRenderer to tcr. This invokes updateRenderer.
      • getCellRenderer

        protected TreeCellRenderer getCellRenderer()
        Return currentCellRenderer, which will either be the trees renderer, or defaultCellRenderer, which ever wasn't null.
      • setModel

        protected void setModel(TreeModel model)
        Sets the TreeModel.
      • setRootVisible

        protected void setRootVisible(boolean newValue)
        Sets the root to being visible.
      • isRootVisible

        protected boolean isRootVisible()
      • setShowsRootHandles

        protected void setShowsRootHandles(boolean newValue)
        Determines whether the node handles are to be displayed.
      • getShowsRootHandles

        protected boolean getShowsRootHandles()
      • setCellEditor

        protected void setCellEditor(TreeCellEditor editor)
        Sets the cell editor.
      • setEditable

        protected void setEditable(boolean newValue)
        Configures the receiver to allow, or not allow, editing.
      • isEditable

        protected boolean isEditable()
      • setSelectionModel

        protected void setSelectionModel(TreeSelectionModel newLSM)
        Resets the selection model. The appropriate listener are installed on the model.
      • 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 valid.
        Specified by:
        getPathBounds in class TreeUI
      • 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
      • 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
      • getRowCount

        public int getRowCount(JTree tree)
        Returns the number of rows that are being displayed.
        Specified by:
        getRowCount in class TreeUI
      • 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
      • 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
      • 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
      • cancelEditing

        public void cancelEditing(JTree tree)
        Cancels the current editing session.
        Specified by:
        cancelEditing in class TreeUI
      • 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
      • installUI

        public void installUI(JComponent c)
        Description copied from class: ComponentUI
        Configures the specified component appropriately for the look and feel. This method is invoked when the ComponentUI instance is being installed as the UI delegate on the specified component. This method should completely configure the component for the look and feel, including the following:
        1. Install default property values for color, fonts, borders, icons, opacity, etc. on the component. Whenever possible, property values initialized by the client program should not be overridden.
        2. Install a LayoutManager on the component if necessary.
        3. Create/add any required sub-components to the component.
        4. Create/install event listeners on the component.
        5. Create/install a PropertyChangeListener on the component in order to detect and respond to component property changes appropriately.
        6. Install keyboard UI (mnemonics, traversal, etc.) on the component.
        7. Initialize any appropriate instance data.
        installUI in class ComponentUI
        c - the component where this UI delegate is being installed
        See Also:
        ComponentUI.uninstallUI(javax.swing.JComponent), JComponent.setUI(javax.swing.plaf.ComponentUI), JComponent.updateUI()
      • 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()
      • installListeners

        protected void installListeners()
      • installKeyboardActions

        protected void installKeyboardActions()
      • 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.
      • createPropertyChangeListener

        protected PropertyChangeListener createPropertyChangeListener()
        Creates a listener that is responsible that updates the UI based on how the tree changes.
      • createMouseListener

        protected MouseListener createMouseListener()
        Creates the listener responsible for updating the selection based on mouse events.
      • createFocusListener

        protected FocusListener createFocusListener()
        Creates a listener that is responsible for updating the display when focus is lost/gained.
      • createKeyListener

        protected KeyListener createKeyListener()
        Creates the listener reponsible for getting key events from the tree.
      • createSelectionModelPropertyChangeListener

        protected PropertyChangeListener createSelectionModelPropertyChangeListener()
        Creates the listener responsible for getting property change events from the selection model.
      • createTreeSelectionListener

        protected TreeSelectionListener createTreeSelectionListener()
        Creates the listener that updates the display based on selection change methods.
      • createCellEditorListener

        protected CellEditorListener createCellEditorListener()
        Creates a listener to handle events from the current editor.
      • 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.
      • createTreeExpansionListener

        protected TreeExpansionListener createTreeExpansionListener()
        Creates and returns the object responsible for updating the treestate when nodes expanded state changes.
      • createLayoutCache

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

        protected CellRendererPane createCellRendererPane()
        Returns the renderer pane that renderer components are placed in.
      • createDefaultCellEditor

        protected TreeCellEditor createDefaultCellEditor()
        Creates a default cell editor.
      • createDefaultCellRenderer

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

        protected TreeModelListener createTreeModelListener()
        Returns a listener that can update the tree when the model changes.
      • uninstallUI

        public void uninstallUI(JComponent c)
        Description copied from class: ComponentUI
        Reverses configuration which was done on the specified component during installUI. This method is invoked when this UIComponent instance is being removed as the UI delegate for the specified component. This method should undo the configuration performed in installUI, being careful to leave the JComponent instance in a clean state (no extraneous listeners, look-and-feel-specific property objects, etc.). This should include the following:
        1. Remove any UI-set borders from the component.
        2. Remove any UI-set layout managers on the component.
        3. Remove any UI-added sub-components from the component.
        4. Remove any UI-added event/property listeners from the component.
        5. Remove any UI-installed keyboard UI from the component.
        6. Nullify any allocated instance data objects to allow for GC.
        uninstallUI in class ComponentUI
        c - the component from which this UI delegate is being removed; this argument is often ignored, but might be used if the UI object is stateless and shared by multiple components
        See Also:
        ComponentUI.installUI(javax.swing.JComponent), JComponent.updateUI()
      • prepareForUIUninstall

        protected void prepareForUIUninstall()
      • completeUIUninstall

        protected void completeUIUninstall()
      • uninstallDefaults

        protected void uninstallDefaults()
      • uninstallListeners

        protected void uninstallListeners()
      • uninstallKeyboardActions

        protected void uninstallKeyboardActions()
      • uninstallComponents

        protected void uninstallComponents()
        Uninstalls the renderer pane.
      • paint

        public void paint(Graphics g,
                          JComponent c)
        Description copied from class: ComponentUI
        Paints the specified component appropriately for the look and feel. This method is invoked from the ComponentUI.update method when the specified component is being painted. Subclasses should override this method and use the specified Graphics object to render the content of the component.
        paint in class ComponentUI
        g - the Graphics context in which to paint
        c - the component being painted; this argument is often ignored, but might be used if the UI object is stateless and shared by multiple components
        See Also:
        ComponentUI.update(java.awt.Graphics, javax.swing.JComponent)
      • 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.
        loc - a DropLocation
        true if the drop location should be shown as a line
      • paintDropLine

        protected void paintDropLine(Graphics g)
        Paints the drop line.
        g - Graphics object to draw on
      • getDropLineRect

        protected Rectangle getDropLineRect(JTree.DropLocation loc)
        Returns a unbounding box for the drop line.
        loc - a DropLocation
        bounding box for the drop line
      • 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.

      • 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.
      • 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.
      • 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.
      • 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.
      • paintVerticalLine

        protected void paintVerticalLine(Graphics g,
                                         JComponent c,
                                         int x,
                                         int top,
                                         int bottom)
        Paints a vertical line.
      • paintHorizontalLine

        protected void paintHorizontalLine(Graphics g,
                                           JComponent c,
                                           int y,
                                           int left,
                                           int right)
        Paints a horizontal line.
      • 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.
      • 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.
      • drawCentered

        protected void drawCentered(Component c,
                                    Graphics graphics,
                                    Icon icon,
                                    int x,
                                    int y)
      • drawDashedHorizontalLine

        protected void drawDashedHorizontalLine(Graphics g,
                                                int y,
                                                int x1,
                                                int x2)
      • drawDashedVerticalLine

        protected void drawDashedVerticalLine(Graphics g,
                                              int x,
                                              int y1,
                                              int y2)
      • 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.
        row - Row to return x location for
        depth - Depth of the row
        amount to indent the given row.
      • 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.
      • getLastChildPath

        protected TreePath getLastChildPath(TreePath parent)
        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.
      • pathWasCollapsed

        protected void pathWasCollapsed(TreePath path)
        Messaged from the VisibleTreeNode after it has collapsed.
      • ensureRowsAreVisible

        protected void ensureRowsAreVisible(int beginRow,
                                            int endRow)
        Ensures that the rows identified by beginRow through endRow are visible.
      • setPreferredMinSize

        public void setPreferredMinSize(Dimension newSize)
        Sets the preferred minimum size.
      • getPreferredMinSize

        public Dimension getPreferredMinSize()
        Returns the minimum preferred size.
      • 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.
      • 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.
      • 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.

      • 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.
      • 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.
      • handleExpandControlClick

        protected void handleExpandControlClick(TreePath path,
                                                int mouseX,
                                                int mouseY)
        Messaged when the user clicks the particular row, this invokes toggleExpandState.
      • 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).
      • 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.
      • isMultiSelectEvent

        protected boolean isMultiSelectEvent(MouseEvent event)
        Returning true signifies 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
      • 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.
      • isLeaf

        protected boolean isLeaf(int row)
        true if the node at row is a leaf.
      • updateLeadSelectionRow

        protected void updateLeadSelectionRow()
        Updates the lead row of the selection.
      • getLeadSelectionRow

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


Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)





Java Script








Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 189 / 159524065. Delta: 0.07876 с