Home » openjdk-7 » javax » swing » plaf » basic » [javadoc | source]
public class: BasicTreeUI [javadoc | source]

Direct Known Subclasses:
    SynthTreeUI, MetalTreeUI

The basic L&F for a hierarchical data structure.

Nested Class Summary:
public class  BasicTreeUI.TreeExpansionHandler  Updates the TreeState in response to nodes expanding/collapsing. 
public class  BasicTreeUI.ComponentHandler  Updates the preferred size when scrolling (if necessary). 
public class  BasicTreeUI.TreeModelHandler  Forwards all TreeModel events to the TreeState. 
public class  BasicTreeUI.TreeSelectionHandler  Listens for changes in the selection model and updates the display accordingly. 
public class  BasicTreeUI.CellEditorHandler  Listener responsible for getting cell editing events and updating the tree accordingly. 
public class  BasicTreeUI.KeyHandler  This is used to get mutliple key down events to appropriately generate events. 
public class  BasicTreeUI.FocusHandler  Repaints the lead selection row when focus is lost/gained. 
public class  BasicTreeUI.NodeDimensionsHandler  Class responsible for getting size of node, method is forwarded to BasicTreeUI method. X location does not include insets, that is handled in getPathBounds. 
public class  BasicTreeUI.MouseHandler  TreeMouseListener is responsible for updating the selection based on mouse events. 
public class  BasicTreeUI.PropertyChangeHandler  PropertyChangeListener for the tree. Updates the appropriate varaible, or TreeState, based on what changes. 
public class  BasicTreeUI.SelectionModelPropertyChangeHandler  Listener on the TreeSelectionModel, resets the row selection if any of the properties of the model change. 
public class  BasicTreeUI.TreeTraverseAction  TreeTraverseAction is the action used for left/right keys. Will toggle the expandedness of a node, as well as potentially incrementing the selection. 
public class  BasicTreeUI.TreePageAction  TreePageAction handles page up and page down events. 
public class  BasicTreeUI.TreeIncrementAction  TreeIncrementAction is used to handle up/down actions. Selection is moved up or down based on direction. 
public class  BasicTreeUI.TreeHomeAction  TreeHomeAction is used to handle end/home actions. Scrolls either the first or last cell to be visible based on direction. 
public class  BasicTreeUI.TreeToggleAction  For the first selected row expandedness will be toggled. 
public class  BasicTreeUI.TreeCancelEditingAction  ActionListener that invokes cancelEditing when action performed. 
public class  BasicTreeUI.MouseInputHandler  MouseInputHandler handles passing all mouse events, including mouse motion events, until the mouse is released to the destination it is constructed with. It is assumed all the events are currently target at source. 
static class  BasicTreeUI.TreeTransferHandler   
Field Summary
protected transient  Icon collapsedIcon     
protected transient  Icon expandedIcon     
protected  int leftChildIndent    Distance between left margin and where vertical dashes will be drawn. 
protected  int rightChildIndent    Distance to add to leftChildIndent to determine where cell contents will be drawn. 
protected  int totalChildIndent    Total distance that will be indented. The sum of leftChildIndent and rightChildIndent. 
protected  Dimension preferredMinSize    Minimum preferred size. 
protected  int lastSelectedRow    Index of the row that was last selected. 
protected  JTree tree    Component that we're going to be drawing into. 
protected transient  TreeCellRenderer currentCellRenderer    Renderer that is being used to do the actual cell drawing. 
protected  boolean createdRenderer    Set to true if the renderer that is currently in the tree was created by this instance. 
protected transient  TreeCellEditor cellEditor    Editor for the tree. 
protected  boolean createdCellEditor    Set to true if editor that is currently in the tree was created by this instance. 
protected  boolean stopEditingInCompleteEditing    Set to false when editing and shouldSelectCell() returns true meaning the node should be selected before editing, used in completeEditing. 
protected  CellRendererPane rendererPane    Used to paint the TreeCellRenderer. 
protected  Dimension preferredSize    Size needed to completely display all the nodes. 
protected  boolean validCachedPreferredSize    Is the preferredSize valid? 
protected  AbstractLayoutCache treeState    Object responsible for handling sizing and expanded issues. 
protected  Hashtable<TreePath, Boolean> drawingCache    Used for minimizing the drawing of vertical lines. 
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. 
protected  NodeDimensions nodeDimensions    Reponsible for telling the TreeState the size needed for a node. 
protected  TreeModel treeModel    Used to determine what to display. 
protected  TreeSelectionModel treeSelectionModel    Model maintaing the selection. 
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. 
protected  Component editingComponent    When editing, this will be the Component that is doing the actual editing. 
protected  TreePath editingPath    Path that is being edited. 
protected  int editingRow    Row that is being edited. Should only be referenced if editingComponent is not null. 
protected  boolean editorHasDifferentSize    Set to true if the editor has a different size than the renderer. 
 public BasicTreeUI() 
Method from javax.swing.plaf.basic.BasicTreeUI Summary:
cancelEditing,   checkForClickInExpandControl,   completeEditing,   completeEditing,   completeUIInstall,   completeUIUninstall,   configureLayoutCache,   createCellEditorListener,   createCellRendererPane,   createComponentListener,   createDefaultCellEditor,   createDefaultCellRenderer,   createFocusListener,   createKeyListener,   createLayoutCache,   createMouseListener,   createNodeDimensions,   createPropertyChangeListener,   createSelectionModelPropertyChangeListener,   createTreeExpansionListener,   createTreeModelListener,   createTreeSelectionListener,   createUI,   drawCentered,   drawDashedHorizontalLine,   drawDashedVerticalLine,   ensureRowsAreVisible,   getBaseline,   getBaselineResizeBehavior,   getCellEditor,   getCellRenderer,   getClosestPathForLocation,   getCollapsedIcon,   getDropLineRect,   getEditingPath,   getExpandedIcon,   getHashColor,   getHorizontalLegBuffer,   getInputMap,   getLastChildPath,   getLeadSelectionRow,   getLeftChildIndent,   getMaximumSize,   getMinimumSize,   getModel,   getPathBounds,   getPathForRow,   getPreferredMinSize,   getPreferredSize,   getPreferredSize,   getRightChildIndent,   getRowCount,   getRowForPath,   getRowHeight,   getRowX,   getSelectionModel,   getShowsRootHandles,   getVerticalLegBuffer,   handleExpandControlClick,   installComponents,   installDefaults,   installKeyboardActions,   installListeners,   installUI,   isDropLine,   isEditable,   isEditing,   isLargeModel,   isLeaf,   isLocationInExpandControl,   isMultiSelectEvent,   isRootVisible,   isToggleEvent,   isToggleSelectionEvent,   loadActionMap,   paint,   paintDropLine,   paintExpandControl,   paintHorizontalLine,   paintHorizontalPartOfLeg,   paintRow,   paintVerticalLine,   paintVerticalPartOfLeg,   pathWasCollapsed,   pathWasExpanded,   prepareForUIInstall,   prepareForUIUninstall,   selectPathForEvent,   setCellEditor,   setCellRenderer,   setCollapsedIcon,   setEditable,   setExpandedIcon,   setHashColor,   setLargeModel,   setLeftChildIndent,   setModel,   setPreferredMinSize,   setRightChildIndent,   setRootVisible,   setRowHeight,   setSelectionModel,   setShowsRootHandles,   shouldPaintExpandControl,   startEditing,   startEditingAtPath,   stopEditing,   toggleExpandState,   uninstallComponents,   uninstallDefaults,   uninstallKeyboardActions,   uninstallListeners,   uninstallUI,   updateCachedPreferredSize,   updateCellEditor,   updateDepthOffset,   updateExpandedDescendants,   updateLayoutCacheExpandedNodes,   updateLeadSelectionRow,   updateRenderer,   updateSize
Methods from javax.swing.plaf.TreeUI:
cancelEditing,   getClosestPathForLocation,   getEditingPath,   getPathBounds,   getPathForRow,   getRowCount,   getRowForPath,   isEditing,   startEditingAtPath,   stopEditing
Methods from javax.swing.plaf.ComponentUI:
contains,   createUI,   getAccessibleChild,   getAccessibleChildrenCount,   getBaseline,   getBaselineResizeBehavior,   getMaximumSize,   getMinimumSize,   getPreferredSize,   installUI,   paint,   uninstallUI,   update
Methods from java.lang.Object:
clone,   equals,   finalize,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait
Method from javax.swing.plaf.basic.BasicTreeUI Detail:
 public  void cancelEditing(JTree tree) 
    Cancels the current editing session.
 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.
 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.
 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.
 protected  void completeUIInstall() 
    Invoked from installUI after all the defaults/listeners have been installed.
 protected  void completeUIUninstall() 
 protected  void configureLayoutCache() 
    Resets the TreeState instance based on the tree we're providing the look and feel for.
 protected CellEditorListener createCellEditorListener() 
    Creates a listener to handle events from the current editor.
 protected CellRendererPane createCellRendererPane() 
    Returns the renderer pane that renderer components are placed in.
 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.
 protected TreeCellEditor createDefaultCellEditor() 
    Creates a default cell editor.
 protected TreeCellRenderer createDefaultCellRenderer() 
    Returns the default cell renderer that is used to do the stamping of each node.
 protected FocusListener createFocusListener() 
    Creates a listener that is responsible for updating the display when focus is lost/gained.
 protected KeyListener createKeyListener() 
    Creates the listener reponsible for getting key events from the tree.
 protected AbstractLayoutCache createLayoutCache() 
    Creates the object responsible for managing what is expanded, as well as the size of nodes.
 protected MouseListener createMouseListener() 
    Creates the listener responsible for updating the selection based on mouse events.
 protected NodeDimensions createNodeDimensions() 
    Creates an instance of NodeDimensions that is able to determine the size of a given node in the tree.
 protected PropertyChangeListener createPropertyChangeListener() 
    Creates a listener that is responsible that updates the UI based on how the tree changes.
 protected PropertyChangeListener createSelectionModelPropertyChangeListener() 
    Creates the listener responsible for getting property change events from the selection model.
 protected TreeExpansionListener createTreeExpansionListener() 
    Creates and returns the object responsible for updating the treestate when nodes expanded state changes.
 protected TreeModelListener createTreeModelListener() 
    Returns a listener that can update the tree when the model changes.
 protected TreeSelectionListener createTreeSelectionListener() 
    Creates the listener that updates the display based on selection change methods.
 public static ComponentUI createUI(JComponent x) 
 protected  void drawCentered(Component c,
    Graphics graphics,
    Icon icon,
    int x,
    int y) 
 protected  void drawDashedHorizontalLine(Graphics g,
    int y,
    int x1,
    int x2) 
 protected  void drawDashedVerticalLine(Graphics g,
    int x,
    int y1,
    int y2) 
 protected  void ensureRowsAreVisible(int beginRow,
    int endRow) 
    Ensures that the rows identified by beginRow through endRow are visible.
 public int getBaseline(JComponent c,
    int width,
    int height) 
    Returns the baseline.
 public BaselineResizeBehavior getBaselineResizeBehavior(JComponent c) 
    Returns an enum indicating how the baseline of the component changes as the size changes.
 protected TreeCellEditor getCellEditor() 
 protected TreeCellRenderer getCellRenderer() 
    Return currentCellRenderer, which will either be the trees renderer, or defaultCellRenderer, which ever wasn't null.
 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.
 public Icon getCollapsedIcon() 
 protected Rectangle getDropLineRect(DropLocation loc) 
    Returns a ubounding box for the drop line.
 public TreePath getEditingPath(JTree tree) 
    Returns the path to the element that is being edited.
 public Icon getExpandedIcon() 
 protected Color getHashColor() 
 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.
 InputMap getInputMap(int condition) 
 protected TreePath getLastChildPath(TreePath parent) 
    Returns a path to the last child of parent.
 protected int getLeadSelectionRow() 
    Returns the lead row of the selection.
 public int getLeftChildIndent() 
 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.
 public Dimension getMinimumSize(JComponent c) 
    Returns the minimum size for this component. Which will be the min preferred size or 0, 0.
 protected TreeModel getModel() 
 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.
 public TreePath getPathForRow(JTree tree,
    int row) 
    Returns the path for passed in row. If row is not visible null is returned.
 public Dimension getPreferredMinSize() 
    Returns the minimum preferred size.
 public Dimension getPreferredSize(JComponent c) 
    Returns the preferred size to properly display the tree, this is a cover method for getPreferredSize(c, true).
 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.
 public int getRightChildIndent() 
 public int getRowCount(JTree tree) 
    Returns the number of rows that are being displayed.
 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.
 protected int getRowHeight() 
 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.
 protected TreeSelectionModel getSelectionModel() 
 protected boolean getShowsRootHandles() 
 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.
 protected  void handleExpandControlClick(TreePath path,
    int mouseX,
    int mouseY) 
    Messaged when the user clicks the particular row, this invokes toggleExpandState.
 protected  void installComponents() 
    Intalls the subcomponents of the tree, which is the renderer pane.
 protected  void installDefaults() 
 protected  void installKeyboardActions() 
 protected  void installListeners() 
 public  void installUI(JComponent c) 
 protected boolean isDropLine(DropLocation loc) 
    Tells if a {@code DropLocation} should be indicated by a line between nodes. This is meant for {@code javax.swing.DropMode.INSERT} and {@code javax.swing.DropMode.ON_OR_INSERT} drop modes.
 protected boolean isEditable() 
 public boolean isEditing(JTree tree) 
    Returns true if the tree is being edited. The item that is being edited can be returned by getEditingPath().
 protected boolean isLargeModel() 
 protected boolean isLeaf(int row) 
 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.
 protected boolean isMultiSelectEvent(MouseEvent event) 
    Returning true signifies a mouse event on the node should select from the anchor point.
 protected boolean isRootVisible() 
 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
 protected boolean isToggleSelectionEvent(MouseEvent event) 
    Returning true signifies a mouse event on the node should toggle the selection of only the row under mouse.
 static  void loadActionMap(LazyActionMap map) 
 public  void paint(Graphics g,
    JComponent c) 
 protected  void paintDropLine(Graphics g) 
    Paints the drop line.
 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.
 protected  void paintHorizontalLine(Graphics g,
    JComponent c,
    int y,
    int left,
    int right) 
    Paints a horizontal line.
 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.

 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.
 protected  void paintVerticalLine(Graphics g,
    JComponent c,
    int x,
    int top,
    int bottom) 
    Paints a vertical line.
 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.

 protected  void pathWasCollapsed(TreePath path) 
    Messaged from the VisibleTreeNode after it has collapsed.
 protected  void pathWasExpanded(TreePath path) 
    Messaged from the VisibleTreeNode after it has been expanded.
 protected  void prepareForUIInstall() 
    Invoked after the tree instance variable has been set, but before any defaults/listeners have been installed.
 protected  void prepareForUIUninstall() 
 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.
 protected  void setCellEditor(TreeCellEditor editor) 
    Sets the cell editor.
 protected  void setCellRenderer(TreeCellRenderer tcr) 
    Sets the TreeCellRenderer to tcr. This invokes updateRenderer.
 public  void setCollapsedIcon(Icon newG) 
 protected  void setEditable(boolean newValue) 
    Configures the receiver to allow, or not allow, editing.
 public  void setExpandedIcon(Icon newG) 
 protected  void setHashColor(Color color) 
 protected  void setLargeModel(boolean largeModel) 
    Updates the componentListener, if necessary.
 public  void setLeftChildIndent(int newAmount) 
 protected  void setModel(TreeModel model) 
    Sets the TreeModel.
 public  void setPreferredMinSize(Dimension newSize) 
    Sets the preferred minimum size.
 public  void setRightChildIndent(int newAmount) 
 protected  void setRootVisible(boolean newValue) 
    Sets the root to being visible.
 protected  void setRowHeight(int rowHeight) 
    Sets the row height, this is forwarded to the treeState.
 protected  void setSelectionModel(TreeSelectionModel newLSM) 
    Resets the selection model. The appropriate listener are installed on the model.
 protected  void setShowsRootHandles(boolean newValue) 
    Determines whether the node handles are to be displayed.
 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.
 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.

 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.
 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.
 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).
 protected  void uninstallComponents() 
    Uninstalls the renderer pane.
 protected  void uninstallDefaults() 
 protected  void uninstallKeyboardActions() 
 protected  void uninstallListeners() 
 public  void uninstallUI(JComponent c) 
 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.

 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.
 protected  void updateDepthOffset() 
    Updates how much each depth should be offset by.
 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.
 protected  void updateLayoutCacheExpandedNodes() 
    Makes all the nodes that are expanded in JTree expanded in LayoutCache. This invokes updateExpandedDescendants with the root path.
 protected  void updateLeadSelectionRow() 
    Updates the lead row of the selection.
 protected  void updateRenderer() 
    Messaged from the tree we're in when the renderer has changed.
 protected  void updateSize() 
    Marks the cached size as being invalid, and messages the tree with treeDidChange.