Relative Layout

Layout managers are a great feature of Java. I am not a big fan of layout managers that use multiple constraints to achieve a layout. This entry will propose a simple layout manager that will use a single constraint, yet provide flexibility. It was designed around the notion that you want a container that will use all the space available to it. As a component is added to the container you specify the relative amount of space that component requires. You could divide your container 50/50, or like most cars today you could provide a 60/40 split.

This RelativeLayout currently supports two layout orientations:

• RelativeLayout.X_AXIS – components are aligned on the X axis from left to right
• RelativeLayout.Y_AXIS – components are aligned on the Y axis from top to bottom

When using the RelativeLayout as the layout manager you will specify a single constraint as each component is added to the container.

The following shows how 3 equal sized components could be added:

RelativeLayout rl = new RelativeLayout(RelativeLayout.X_AXIS, 5);
JPanel panel = new JPanel( rl );
panel.add(red, new Float(1));
panel.add(green, new Float(1));
panel.add(blue, new Float(1));

Or, this example shows how to allocate more space to the middle component:

RelativeLayout rl = new RelativeLayout(RelativeLayout.X_AXIS);
JPanel panel = new JPanel( rl );
panel.add(red, new Float(1));
panel.add(green, new Float(3));
panel.add(blue, new Float(1));

But the flexibility doesn’t stop there. You are not forced to use a relative constraint. If you don’t use a constraint, then the component is added at its preferred size. In this case the preferred size of the component is subtracted from the space available to the container. The remaining space is then allocated to the components using relative spacing. This gives you a pseudo BorderLayout look:

RelativeLayout rl = new RelativeLayout(RelativeLayout.X_AXIS);
JPanel panel = new JPanel( rl );
panel.add(red);
panel.add(green, new Float(3));
panel.add(blue);

For what its worth if none of the components added to the container contain a constraint then the layout will be like a FlowLayout.

You can also use the RelativeLayout to mimic a BoxLayout. The Box invisible components can be added to the container like any other component. For example, you can center a component in the container using:

RelativeLayout rl = new RelativeLayout(RelativeLayout.X_AXIS);
JPanel panel = new JPanel( rl );
panel.add(Box.createGlue(), new Float(1));
panel.add(green, new Float(3));
panel.add(Box.createGlue(), new Float(1));

By default the RelativeLayout will layout components without a gap between each component. However, following in the footsteps of the FlowLayout you can provide a gap before and after every component by using the setGap(…) method. As an added feature you can use the setBorderGap(…) method to control the gap before the leading component and after the trailing component. The border gap will default to the gap value at class construction time. Afterwards the two methods work independently of one another.

The RelativeLayout class will also allow you to customize the layout at the container level. You can control the alignment of the components on the opposite axis using the setAlignment(…) method. Four common values are listed below:

• RelativeLayout.LEADING – component is aligned to the Left or Top depending on the layout axis
• RelativeLayout.CENTER (default) – component is aligned in the center
• RelativeLayout.TRAILING – component is aligned to the Right or Bottom depending on the layout axis
• RelativeLayout.COMPONENT – the value specified in the setAligntmentX/Y method of the component is used

The size of the component on the opposite axis can be filled to occupy the entire space available using the setFill(true) method. In addition, you can prevent the component from completely filling the space available by using the setFillGap(int) method.

When allocating space to components using relative sizing it can’t be guaranteed that all the space will be allocated due to rounding errors. You can control how the few remaining pixels should be allocated by using the setRoundingPolicy(…) method. The following polices are currently supported:

• RelativeLayout.DO_NOTHING -remaining pixels will not be allocated to any component
• RelativeLayout.FIRST – rounding pixels applied to the first relative component.
• RelativeLayout.LAST – rounding pixels applied to the last relative component
• RelativeLayout.LARGEST (default) – rounding pixels applied to the largest relative component. When more than one component is the same size, then the last one found will be used.
• RelativeLayout.EQUAL – a single pixel will be applied to each relative component (starting at the first) until the rounding pixels have been used

The RelativeLayout started out as a simple layout manager to allocate relative sizes dynamically to components. However by additionally supporting invisible components and components with preferred sizes you may find other interesting uses for it as well.

Get The Code

RelativeLayout.java

Related Reading

Using Layout Managers