![[A screen shot of a JTree]](../doc-files/TreeUI-1.png)
*
* JTree
* according to the Basic look and feel. The current implementation
* of GNU Classpath does really work; it is just a stub that allows
* compiling the code.
*
* @see javax.swing.JTree
*
* @author Sascha Brawer (brawer@dandelis.ch)
*/
public class BasicTreeUI
extends TreeUI
{
/**
* Determines the geometric extent of the label that is
* drawn for a path.
*
* @param tree the JTree for which this delegate
* object provides the user interface.
*
* @param path the path whose label extent is requested.
*
* @return a rectangle enclosing the label, or null
* if path contains invalid nodes.
*/
public Rectangle getPathBounds(JTree tree, TreePath path)
{
return null; // FIXME: not implemented
}
/**
* Creates a TreePath for the specified row.
*
* @param tree the JTree for which this delegate
* object provides the user interface.
*
* @param row the index of the row, which should be a number
* in the range [0, getRowCount(tree) - 1].
*
* @return a TreePath for the specified row, or
* null if row is outside
* the valid range.
*/
public TreePath getPathForRow(JTree tree, int row)
{
return null; // FIXME: not implemented
}
/**
* Determines in which row a TreePath is currently
* being displayed.
*
* @param tree the JTree for which this delegate
* object provides the user interface.
*
* @param path the path for which the caller wants to know
* in which row it is being displayed.
*
* @return a number in the range [0, getRowCount(tree)
* - 1] if the path is currently on display;
* -1 if the path is not shown to the
* user.
*/
public int getRowForPath(JTree tree, TreePath path)
{
return -1; // FIXME: not implemented
}
/**
* Counts how many rows are currently displayed.
*
* @param tree the JTree for which this delegate
* object provides the user interface.
*
* @return the number of visible rows.
*/
public int getRowCount(JTree tree)
{
return 0; // FIXME: not implemented
}
/**
* Finds the path that is closest to the specified position.
*
*
*
*
As shown by the above illustration, the bounds of the
* closest path do not necessarily need to contain the passed
* location.
*
* @param tree the JTree for which this delegate
* object provides the user interface.
*
* @param x the horizontal location, relative to the origin
* of tree.
*
* @param y the vertical location, relative to the origin
* of tree.
*
* @return the closest path, or null if the
* tree is currenlty not displaying any paths at all.
*/
public TreePath getClosestPathForLocation(JTree tree,
int x, int y)
{
return null; // FIXME: not implemented
}
/**
* Determines whether the user is currently editing a tree cell.
*
* @param tree the JTree for which this delegate
* object provides the user interface.
*
* @see #getEditingPath
*/
public boolean isEditing(JTree tree)
{
return false; // FIXME: not implemented
}
/**
* Stops editing a tree cell, committing the entered value into the
* tree’s model. If no editing session is active, or if the
* active editor does not agree to stopping, nothing happens. In
* some look and feels, this action happens when the user has
* pressed the enter key.
*
* @param tree the JTree for which this delegate
* object provides the user interface.
*
* @return false if the editing still goes on because
* the cell editor has objected to stopping the session;
* true if editing has been stopped.
*/
public boolean stopEditing(JTree tree)
{
return true; // FIXME: not implemented
}
/**
* Cancels editing a tree cell, discarding any entered value.
* If no editing session is active, nothing happens. The cell
* editor is not given an opportunity to veto the canceling.
* In some look and feels, this action happens when the user has
* pressed the escape key.
*
* @param tree the JTree for which this delegate
* object provides the user interface.
*/
public void cancelEditing(JTree tree)
{
// FIXME: not implemented
}
/**
* Starts a session to edit a tree cell. If the cell editor
* rejects editing the cell, it will just be selected.
*
* @param tree the JTree for which this delegate
* object provides the user interface.
*
* @param path the cell to edit.
*/
public void startEditingAtPath(JTree tree, TreePath path)
{
// FIXME: not implemented
}
/**
* Retrieves the tree cell that is currently being edited.
*
* @return the currently edited path, or null
* if no editing session is currently active.
*/
public TreePath getEditingPath(JTree tree)
{
return null; // FIXME: not implemented
}
public static ComponentUI createUI(JComponent c)
{
return new BasicTreeUI();
}
int rightChildIndent;
int leftChildIndent;
int rowHeight;
Color hashColor;
protected void installDefaults(JTree tree)
{
UIDefaults defaults = UIManager.getLookAndFeelDefaults();
tree.setFont(defaults.getFont("Tree.font"));
tree.setForeground(defaults.getColor("Tree.foreground"));
tree.setBackground(defaults.getColor("Tree.background"));
tree.setOpaque(true);
hashColor = defaults.getColor("Tree.hash");
rightChildIndent = defaults.getInt("Tree.rightChildIndent");
leftChildIndent = defaults.getInt("Tree.leftChildIndent");
rowHeight = defaults.getInt("Tree.rowHeight");
}
protected void installKeyboardActions()
{
}
protected void installListeners()
{
}
public void installUI(JComponent c)
{
installDefaults((JTree) c);
}
protected void uninstallDefaults(JTree tree)
{
tree.setFont(null);
tree.setForeground(null);
tree.setBackground(null);
tree.setCellRenderer(null);
}
public void uninstallUI(JComponent c)
{
uninstallDefaults((JTree) c);
}
public Dimension getPreferredSize(JComponent c)
{
return new Dimension(200,200);
}
protected void paintLeaf(Graphics g, int x, int y, JTree tree, Object leaf)
{
Component c = tree.getCellRenderer().getTreeCellRendererComponent(tree,
leaf,
false, // selected
false, // expanded
true, // leaf
0, // row
false // hasFocus
);
g.translate(x, y);
c.paint(g);
g.translate(-x, -y);
}
protected void paintNonLeaf(Graphics g, int x, int y, JTree tree, Object nonLeaf)
{
Component c = tree.getCellRenderer().getTreeCellRendererComponent(tree,
nonLeaf,
false, // selected
false, // expanded
false, // leaf
0, // row
false // hasFocus
);
g.translate(x, y);
c.paint(g);
g.translate(-x, -y);
}
protected int paintRecursive(Graphics g,
int indentation,
int descent,
int childNumber,
int depth,
JTree tree,
TreeModel mod,
Object curr)
{
Rectangle clip = g.getClipBounds();
if (indentation > clip.x + clip.width + rightChildIndent ||
descent > clip.y + clip.height + rowHeight)
return descent;
int halfHeight = rowHeight / 2;
int halfWidth = rightChildIndent / 2;
int y0 = descent + halfHeight;
if (mod.isLeaf(curr))
{
paintLeaf(g, indentation, descent, tree, curr);
descent += rowHeight;
}
else
{
if (depth > 0 || tree.isRootVisible())
{
paintNonLeaf(g, indentation, descent, tree, curr);
descent += rowHeight;
y0 += halfHeight;
}
int max = mod.getChildCount(curr);
for (int i = 0; i < max; ++i)
{
g.setColor(hashColor);
g.drawLine(indentation + halfWidth, descent + halfHeight,
indentation + rightChildIndent, descent + halfHeight);
descent = paintRecursive(g,
indentation + rightChildIndent, descent,
i, depth+1,
tree, mod, mod.getChild(curr, i));
}
}
int y1 = descent - halfHeight;
if (y0 != y1)
{
g.setColor(hashColor);
g.drawLine(indentation + halfWidth, y0,
indentation + halfWidth, y1);
}
return descent;
}
public void paint(Graphics g, JComponent c)
{
JTree tree = (JTree) c;
TreeModel mod = tree.getModel();
g.translate(10, 10);
paintRecursive(g, 0, 0, 0, 0, tree, mod, mod.getRoot());
g.translate(-10, -10);
}
}