Making a JTreeCellRenderer fill the JTree

Making a JTreeCellRenderer fill to the right edge of a JTree is a herculean task. Something as seemingly innocuous as controlling a cell renderer’s width turns out to be a rather tough job.

Having a cell renderer fill to the right edge of the JTree is useful if you want to have some left aligned content, as well as some right aligned content. By default, renderer’s are queried for their preferred width, so you’ll end up with arbitrarily sized renders like the one’s below (the cell renderer has a red LineBorder for demonstration):

Clearly this won’t work if our renderer wants anything aligned with the right edge of the tree. The most straight forward way I found to override this behavior is by subclassing (something I don’t like to do) BasicTreeUI and overriding this method:

AbstractLayoutCache.NodeDimensions createNodeDimensions()

This method determines how to size a node. The default implementation bases the calculation around the renderer’s preferred size. Sub-classing BasicTreeUI let’s us determine this value ourselves, and we’re in a spot in the code that has access to all the information we need (like node indentation values).

Note that we actually want the renderer to extend to the right edge of the enclosing JScrollPane rather than the actual JTree.

Here’s the code:

public class CustomTreeUI extends BasicTreeUI {

        @Override
        protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
            return new NodeDimensionsHandler() {
                @Override
                public Rectangle getNodeDimensions(
                        Object value, int row, int depth, boolean expanded,
                        Rectangle size) {
                    Rectangle dimensions = super.getNodeDimensions(value, row,
                            depth, expanded, size);
                    dimensions.width =
                            fScrollPane.getWidth() - getRowX(row, depth);
                    return dimensions;
                }
            };
        }

        @Override
        protected void paintHorizontalLine(Graphics g, JComponent c,
                                           int y, int left, int right) {
            // do nothing.
        }

        @Override
        protected void paintVerticalPartOfLeg(Graphics g, Rectangle clipBounds,
                                              Insets insets, TreePath path) {
            // do nothing.
        }
}

Notice that I’m overriding a couple additional methods to prevent the painting of the node-connecting lines. Also, not shown here, I have set my tree to use a large model by calling Tree.setLargeModel(trure). I’ve yet to figure out exactly what all the implications of setting this property are, but it does seem to cause the tree nodes to be relayed out on each repaint. This is important because the renderer widths will change with the size of the containing JScrollPane, whereas normally, the renderer widths are relatively static on a per-node basis.

The above solution works in my case because I’m providing all the painting (to include the disclosure icons) for my JTree. If you know of more componentized way (that is, not involving sub-classing) of accomplishing this, let me know!