Part II , Part I is here
Tips on choosing the layout manager
Layout managers have different strengths and weaknesses. This section discusses
some common layout scenarios and which layout managers might work for each scenario.
If none of the layout managers we discuss is right for your situation, feel free to use other
layout managers that you write or find. Also keep in mind that flexible layout managers such
as GridBagLayout and SpringLayout can fulfill many layout needs.
You need to display a component in as much space as it can get. If it's the
only component in its container, use GridLayout or BorderLayout.
BorderLayout or GridBagLayout might be a good match. If you use BorderLayout,
you'll need to put the space-hungry component in the center.
You need to display a few components in a compact row at their natural size.
Consider using a JPanel to group the components and using either the JPanel's default
FlowLayout manager or the BoxLayout manager. SpringLayout is also good for this.
You need to display a few components of the same size in rows and columns.
GridLayout is perfect for this.
You need to display a few components in a row or column, possibly with varying amounts of space between them, custom alignment, or custom component sizes.
BoxLayout is perfect for this.
You need to display aligned columns, as in a form-like interface where a column oflabels is used to describe text fields in an adjacent column. SpringLayout is a
natural choice for this. The SpringUtilities class used by several Tutorial examples
defines a makeCompactGrid method that lets you easily align multiple rows and columns
You have a complex layout with many components. Consider either using a very flexible
layout manager such as GridBagLayout or SpringLayout, or grouping the components
into one or more JPanels to simplify layout. If you take the latter approach, each JPanel
might use a different layout manager.
How to use BorderLayout
Here's a snapshot of an application that uses a BorderLayout.
As the preceding picture shows, a BorderLayout has five areas. These areas are
specified by the BorderLayout constants PAGE_START, PAGE_END, LINE_START, LINE_END,
If you enlarge the window, the center area gets as much of the available space as
possible. The other areas expand only as much as necessary to fill all available space. Often,
a container uses only one or two of the areas of the BorderLayout -- just the center, or center
and bottom, for example.
The following code adds components to a frame's content pane. Because content panes
use BorderLayout by default, the code doesn't need to set the layout manager.
JButton button = new JButton("Button 1 (PAGE_START)");
//Make the center component big, since that's the
//typical usage of BorderLayout.
button = new JButton("Button 2 (CENTER)");
button.setPreferredSize(new Dimension(200, 100));
button = new JButton("Button 3 (LINE_START)");
button = new JButton("Long-Named Button 4 (PAGE_END)");
button = new JButton("5 (LINE_END)");
We strongly recommend that you specify the component's location (for example,
BorderLayout.LINE_END) as one of the arguments to the add method. If you leave it out,
the component will be added to the center, but your code will be much less clear. If you find
that a component is missing from a container controlled by a BorderLayout, make sure that
you specified the component's location and that you didn't put another component in the same
All our examples that use BorderLayout specify the component as the first argument to
the add method. For example:
By default, a BorderLayout puts no gap between the components it manages. You can
specify gaps (in pixels) using the following constructor:
BorderLayout(int horizontalGap, int verticalGap)
You can also use the following methods to set the horizontal and vertical gaps,
How to use BoxLayout
The Swing packages include a general purpose layout manager named BoxLayout.
BoxLayout either stacks its components on top of each other or places them in a row -- your
choice. You might think of it as a full-featured version of FlowLayout. Here is a picture of an
application that demonstrates using BoxLayout to display a centred column of components:
By creating one or more lightweight containers that use BoxLayout, you can achieve
some layouts for which the more complex GridBagLayout is often used. BoxLayout is also
useful in some situations where you might consider using GridLayout or BorderLayout.
One big difference between BoxLayout and many earlier layout managers is that BoxLayout
respects each component's maximum size and X/Y alignment. We'll discuss that later.
The following figure shows a GUI that uses two instances of BoxLayout. In the top part
of the GUI, a top-to-bottom box layout places a label above a scroll pane. In the bottom part
of the GUI, a left-to-right box layout places two buttons next to each other. A BorderLayout
combines the two parts of the GUI and ensures that any excess space is given to the scroll
The following code, taken from ListDialog.java, lays out the GUI. This code is in the
constructor for the dialog, which is implemented as a JDialog subclass. The bold lines of
code set up the box layouts and add components to them.
JScrollPane listScroller = new JScrollPane(list);
listScroller.setPreferredSize(new Dimension(250, 80));
//Lay out the label and scroll pane from top to bottom.
JPanel listPane = new JPanel();
JLabel label = new JLabel(labelText);
//Lay out the buttons from left to right.
JPanel buttonPane = new JPanel();
(0, 10, 10, 10));
buttonPane.add(Box.createRigidArea(new Dimension(10, 0)));
//Put everything together, using the content pane's BorderLayout.
Container contentPane = getContentPane();
The first bold line creates a top-to-bottom box layout and sets it up as the layout manager
for listPane. The two arguments to the BoxLayout constructor are the container that it
manages and the axis along with the components will be laid out. The next three bold lines
add the label and scroll pane to the container, separating them with a rigid area -- an invisible
lightweight component used to add space between components. In this case, the rigid area
has no width and puts exactly 5 pixels between the label and scroll pane.
The next chunk of bold code creates a left-to-right box layout and sets it up for the
buttonPane container. Then the code adds two buttons to the container, using a rigid area to
put 10 pixels between the buttons. To place the buttons at the right side of their container, the
first component added to the container is glue. This glue is an invisible lightweight component
that grows as necessary to absorb any extra space in its container.
As an alternative to using invisible components, you can sometimes use empty borders
to create space around components. For example, the preceding code snippet uses empty
borders to put 10 pixels between all sides of the dialog and its contents, and between the two
parts of the contents. Borders are completely independent of layout managers. They're simply
how Swing components draw their edges.
8955 bytes more | comments? | | Score: 0