All Packages  Class Hierarchy  This Package  Previous  Next  Index

Class com.sun.java.swing.basic.BasicTreeUI

java.lang.Object
   |
   +----com.sun.java.swing.basic.AbstractTreeUI
           |
           +----com.sun.java.swing.basic.BasicTreeUI

public class BasicTreeUI

extends AbstractTreeUI

implements CellEditorListener, FocusListener, KeyListener, MouseListener, PropertyChangeListener, TreeUI

cellEditor

Editor for the tree.

collapsedIcon

currentCellRenderer

Renderer that is being used to do the actual cell drawing.

editingComponent

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

editingNode

Node that is being edited.

expandedIcon

hashColor

Color used to draw hash marks.

isKeyDown

Set to true while keyPressed is active.

lastSelectedRow

Index of the row that was last selected.

leftChildIndent

Distance between left margin and where verical dashes will be drawn.

preferredMinSize

Minimum preferred size.

rendererPane

Used to paint the TreeCellRenderer.

repeatKeyAction

Key code that is being generated for.

rightChildIndent

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

stopEditingInCompleteEditing

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

totalChildIndent

Total distance that will be indented.

tree

Component that we're going to be drawing into.

BasicTreeUI()

cancelEditing()

Cancels the current editing session.

checkConsistency()

Checks to insure that the all the sizes of the nodes are valid, and if there isn't a valid node size, as determined by updateNodeSizes in our superclass, than updateNodeSizes() is messaged.

completeEditing(boolean, boolean, boolean)

Stops the editing session.

createNodeForValue(Object)

Creates an instance of BasicVisibleTreeNode.

createUI(JTree)

deinstallUI(JComponent)

editingCanceled(ChangeEvent)

Stops the editing session by messaging cancelEditing(false).

editingStarted(ChangeEvent)

Does nothing.

editingStopped(ChangeEvent)

Stops the editing session by messaging stopEditing(false).

ensureRectIsVisible(Rectangle)

If the tree is contained in a JViewport and any portion of rect is not visible the location of the tree is adjusted to make as much of rect visible as is possible.

ensureRowsAreVisible(int, int)

Ensures that the rows identified by beginRow throug endRow are visible.

focusGained(FocusEvent)

Invoked when focus is activated on the tree we're in, should redraw for selected component.

focusLost(FocusEvent)

Invoked when focus is removed on the tree we're in, should redraw for selected component.

getCellRenderer()

Return currentCellRenderer, which will either be the trees renderer, or defaultCellRenderer, which ever wasn't null.

getCollapsedIcon()

getDefaultCellEditor()

Creates a default cell editor.

getDefaultCellRenderer()

Returns the default cell renderer that is used to do the stamping of each node.

getEditingPath()

Returns the path to the element that is being edited.

getExpandedIcon()

getHashColor()

getInsets(JComponent)

getLeftChildIndent()

getMaximumSize(JComponent)

Returns the maximum size for this component, which will be the preferred size if the instance is currently in a JTree, or 0, 0.

getMinimumSize(JComponent)

Returns the minimum size for this component.

getPreferredMinSize()

Returns the minimum preferred size.

getPreferredSize(JComponent)

Returns the preferred size to properly display the tree, this is a cover method for getPreferredSize(c, false).

getPreferredSize(JComponent, boolean)

Returns the preferred size to represent the tree in c.

getRightChildIndent()

getSizeOfNode(AbstractTreeUI. VisibleTreeNode)

Messages the tree to configure the cell, and returns the the size of the component.

getXOriginOfNode(AbstractTreeUI. VisibleTreeNode)

Returns the x origin of the given node, which is based on whether or not we're showing handles and the visible level of the node multiplied by the right and left indent factor.

installUI(JComponent)

isEditing()

Returns true if the tree is being edited.

keyPressed(KeyEvent)

keyReleased(KeyEvent)

keyTyped(KeyEvent)

mouseClicked(MouseEvent)

Invoked when the mouse has been clicked on a component.

mouseEntered(MouseEvent)

Invoked when the mouse enters a component.

mouseExited(MouseEvent)

Invoked when the mouse exits a component.

mousePressed(MouseEvent)

Invoked when a mouse button has been pressed on a component.

mouseReleased(MouseEvent)

Invoked when a mouse button has been released on a component.

nodeWasCollapsed(AbstractTreeUI. VisibleTreeNode)

Messaged from the VisibleTreeNode after it has collapsed.

nodeWasExpanded(AbstractTreeUI. VisibleTreeNode)

Messaged from the VisibleTreeNode after it has been expanded.

paint(Graphics, JComponent)

propertyChange(PropertyChangeEvent)

Based on the value has changed will message the appropriate method.

rebuild()

Stops editing and messags super.

repaintNode(AbstractTreeUI. VisibleTreeNode)

Repaints the particular node by getting its bounds.

scrollPathToVisible(JTreePath)

Makes sure all the path components in path are expanded (accept for the last path component) and tries to scroll the resulting path to be visible (the scrolling will only work if the JTree is contained in a JScrollPane).

scrollRowToVisible(int)

Scrolls the item identified by row to be visible.

setCollapsedIcon(Icon)

setExpandedIcon(Icon)

setHashColor(Color)

setLeftChildIndent(int)

setModel(TreeModel)

Stops editing and messages super.

setPreferredMinSize(Dimension)

Sets the preferred minimum size.

setRightChildIndent(int)

setSelectedPath(JTreePath, boolean)

Stops editing and messags super.

setSelectedRow(int, boolean)

Stops editing and messags super.

setSelectionModel(TreeSelectionModel)

Stops editing and messags super.

setupKeyboard()

Registers for keyboard events to manipulate the current selection.

startEditing(AbstractTreeUI. VisibleTreeNode, MouseEvent)

Will start editing for node if there is a cellEditor and startEditing returns true.

startEditingAtPath(JTreePath)

Selects the last item in path and tries to edit it.

stopEditing()

Stops the current editing session, returns true if the tree is current editing and the editor returns true from stopEditing().

treeRendererChanged(JTree)

Messaged from the tree we're in when the renderer has changed.

unsetKeyboard()

Unregisters for keyboard events that were previously registered for in setupKeyboard.

updateCellEditor()

Updates the cellEditor based on the editability of the JTree that we're contained in.

valueChanged(TreeSelectionEvent)

Messaged when the selection changes in the tree we're displaying for.

visibleNodesChanged()

Messaged whenever nodes are added/removed from the visible list, or the height/width of a node changes.

 protected Icon collapsedIcon

 protected Icon expandedIcon

 protected Color hashColor

Color used to draw hash marks. If null no hash marks will be drawn.

 protected int leftChildIndent

Distance between left margin and where verical 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 TreeCellRenderer currentCellRenderer

Renderer that is being used to do the actual cell drawing.

 protected TreeCellEditor cellEditor

Editor for the tree.

 protected Component editingComponent

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

 protected AbstractTreeUI. VisibleTreeNode editingNode

Node that is being edited.

 protected JAction repeatKeyAction

Key code that is being generated for.

 protected boolean isKeyDown

Set to true while keyPressed is active.

 protected boolean stopEditingInCompleteEditing

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

 protected CellRendererPane rendererPane

Used to paint the TreeCellRenderer.

 public BasicTreeUI()

 public static TreeUI createUI(JTree x)

 public void setLeftChildIndent(int newAmount)

 public int getLeftChildIndent()

 public void setRightChildIndent(int newAmount)

 public int getRightChildIndent()

 public void setExpandedIcon(Icon newG)

 public Icon getExpandedIcon()

 public void setCollapsedIcon(Icon newG)

 public Icon getCollapsedIcon()

 public void setHashColor(Color newColor)

 public Color getHashColor()

 public void installUI(JComponent c)

 public void deinstallUI(JComponent c)

 public void propertyChange(PropertyChangeEvent event)

Based on the value has changed will message the appropriate method. Which is one of treeRendererChanged, setModel, setRootVisible, setShowsRootHandles, or setRowHeight.

 protected void setupKeyboard()

Registers for keyboard events to manipulate the current selection.

 protected void unsetKeyboard()

Unregisters for keyboard events that were previously registered for in setupKeyboard.

 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.

 public void treeRendererChanged(JTree tree)

Messaged from the tree we're in when the renderer has changed. Updates the size if necessary.

 public boolean checkConsistency()

Checks to insure that the all the sizes of the nodes are valid, and if there isn't a valid node size, as determined by updateNodeSizes in our superclass, than updateNodeSizes() is messaged.

 protected TreeCellEditor getDefaultCellEditor()

Creates a default cell editor.

 public TreeCellRenderer getDefaultCellRenderer()

Returns the default cell renderer that is used to do the stamping of each node.

 public int getXOriginOfNode(AbstractTreeUI. VisibleTreeNode node)

Returns the x origin of the given node, which is based on whether or not we're showing handles and the visible level of the node multiplied by the right and left indent factor.

Overrides:

getXOriginOfNode in class AbstractTreeUI

 public Dimension getSizeOfNode(AbstractTreeUI. VisibleTreeNode node)

Messages the tree to configure the cell, and returns the the size of the component.

Overrides:

getSizeOfNode in class AbstractTreeUI

 public void visibleNodesChanged()

Messaged whenever nodes are added/removed from the visible list, or the height/width of a node changes. This updates the size of the JTree we're drawing for based on the dimension returned from getPreferredSize.

Overrides:

visibleNodesChanged in class AbstractTreeUI

 protected void nodeWasExpanded(AbstractTreeUI. VisibleTreeNode node)

Messaged from the VisibleTreeNode after it has been expanded.

Overrides:

nodeWasExpanded in class AbstractTreeUI

 protected void nodeWasCollapsed(AbstractTreeUI. VisibleTreeNode node)

Messaged from the VisibleTreeNode after it has collapsed.

Overrides:

nodeWasCollapsed in class AbstractTreeUI

 public void ensureRowsAreVisible(int beginRow,
                                  int endRow)

Ensures that the rows identified by beginRow throug endRow are visible.

 public void ensureRectIsVisible(Rectangle rect)

If the tree is contained in a JViewport and any portion of rect is not visible the location of the tree is adjusted to make as much of rect visible as is possible.

 public void scrollPathToVisible(JTreePath path)

Makes sure all the path components in path are expanded (accept for the last path component) and tries to scroll the resulting path to be visible (the scrolling will only work if the JTree is contained in a JScrollPane).

 public void scrollRowToVisible(int row)

Scrolls the item identified by row to be visible. This will only work if the JTree is contained in a JSrollPane.

 public TreeCellRenderer getCellRenderer()

Return currentCellRenderer, which will either be the trees renderer, or defaultCellRenderer, which ever wasn't null. currentCellRenderer is set as part of checkConsistency().

 public void paint(Graphics g,
                   JComponent c)

 public void setPreferredMinSize(Dimension newSize)

Sets the preferred minimum size.

 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, false).

 public Dimension getPreferredSize(JComponent c,
                                   boolean checkConsistancy)

Returns the preferred size to represent the tree in c. If checkConsistancy is true checkConsistancy is messaged first.

 public Dimension getMinimumSize(JComponent c)

Returns the minimum size for this component. Which will be the min preferred size or 0, 0.

 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 Insets getInsets(JComponent c)

 public void valueChanged(TreeSelectionEvent event)

Messaged when the selection changes in the tree we're displaying for. Stops editing, messages super and displays the changed paths.

Overrides:

valueChanged in class AbstractTreeUI

 public void editingStarted(ChangeEvent e)

Does nothing.

 public void editingStopped(ChangeEvent e)

Stops the editing session by messaging stopEditing(false).

 public void editingCanceled(ChangeEvent e)

Stops the editing session by messaging cancelEditing(false).

 public boolean isEditing()

Returns true if the tree is being edited. The item that is being edited can be returned by getSelectionPath().

 public boolean stopEditing()

Stops the current editing session, returns true if the tree is current editing and the editor returns true from stopEditing().

 public void cancelEditing()

Cancels the current editing session.

 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.

 public void startEditingAtPath(JTreePath 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.

 protected boolean startEditing(AbstractTreeUI. VisibleTreeNode node,
                                MouseEvent event)

Will start editing for node if there is a cellEditor and startEditing returns true.

 public JTreePath getEditingPath()

Returns the path to the element that is being edited.

 public void mouseClicked(MouseEvent e)

Invoked when the mouse has been clicked on a component.

 public void mousePressed(MouseEvent e)

Invoked when a mouse button has been pressed on a component.

 public void mouseReleased(MouseEvent e)

Invoked when a mouse button has been released on a component.

 public void mouseEntered(MouseEvent e)

Invoked when the mouse enters a component.

 public void mouseExited(MouseEvent e)

Invoked when the mouse exits a component.

 public void focusGained(FocusEvent e)

Invoked when focus is activated on the tree we're in, should redraw for selected component.

 public void focusLost(FocusEvent e)

Invoked when focus is removed on the tree we're in, should redraw for selected component.

 public void keyPressed(KeyEvent e)

 public void keyReleased(KeyEvent e)

 public void keyTyped(KeyEvent e)

 public void setModel(TreeModel newModel)

Stops editing and messages super.

Overrides:

setModel in class AbstractTreeUI

 public void rebuild()

Stops editing and messags super.

Overrides:

rebuild in class AbstractTreeUI

 public void setSelectedPath(JTreePath path,
                             boolean addToSelection)

Stops editing and messags super.

Overrides:

setSelectedPath in class AbstractTreeUI

 public void setSelectedRow(int row,
                            boolean addToSelection)

Stops editing and messags super.

Overrides:

setSelectedRow in class AbstractTreeUI

 public void setSelectionModel(TreeSelectionModel newLSM)

Stops editing and messags super.

Overrides:

setSelectionModel in class AbstractTreeUI

 protected AbstractTreeUI. VisibleTreeNode createNodeForValue(Object value)

Creates an instance of BasicVisibleTreeNode.

Overrides:

createNodeForValue in class AbstractTreeUI

 protected void repaintNode(AbstractTreeUI. VisibleTreeNode node)

Repaints the particular node by getting its bounds.

All Packages  Class Hierarchy  This Package  Previous  Next  Index