Controlling layout

The

way that you place components on a form in Java is probably different from any

other GUI system you’ve used. First, it’s all code; there are no

“resources” that control placement of components. Second, the way

components are placed on a form is controlled by a “

Both

the

In

this section we’ll explore the various layout managers by placing buttons

in them (since that’s the simplest thing to do). There won’t be any

capturing of button events since this is just intended to show how the buttons

are laid out.

FlowLayout

So

far, all the applets that have been created seem to have laid out their

components using some mysterious internal logic. That’s because the

applet uses a default layout scheme: the

Here’s

an example that explicitly (redundantly) sets the layout manager in an applet to

and then places buttons on the form. You’ll notice that with

the components take on their “natural” size. A

//: FlowLayout1.java
// Demonstrating the FlowLayout
import java.awt.*;
import java.applet.*;
 
public class FlowLayout1 extends Applet {
  public void init() {
    setLayout(new FlowLayout());
    for(int i = 0; i < 20; i++)
      add(new Button("Button " + i));
  }
} ///:~ 

All

components will be compacted to their smallest size in a

,

so you might get a little bit of surprising behavior. For example, a label will

be the size of its string, so right-justifying it yields an unchanged display.

BorderLayout

This

layout manager has the concept of four border regions and a center area. When

you add something to a panel that’s using a

Here’s

a simple example:

//: BorderLayout1.java
// Demonstrating the BorderLayout
import java.awt.*;
import java.applet.*;
 
public class BorderLayout1 extends Applet {
  public void init() {
    int i = 0;
    setLayout(new BorderLayout());
    add("North", new Button("Button " + i++));
    add("South", new Button("Button " + i++));
    add("East", new Button("Button " + i++));
    add("West", new Button("Button " + i++));
    add("Center", new Button("Button " + i++));
  }
} ///:~ 

For

every placement but “Center,” the element that you add is

compressed to fit in the smallest amount of space along one dimension while it

is stretched to the maximum along the other dimension. “Center,”

however, spreads out along both dimensions to occupy the middle.

The

is the default layout manager for applications and dialogs.

GridLayout

A

//: GridLayout1.java
// Demonstrating the FlowLayout
import java.awt.*;
import java.applet.*;
 
public class GridLayout1 extends Applet {
  public void init() {
    setLayout(new GridLayout(7,3));
    for(int i = 0; i < 20; i++)
      add(new Button("Button " + i));
  }
} ///:~ 

In

this case there are 21 slots but only 20 buttons. The last slot is left empty;

no “balancing” goes on with a

.

CardLayout

The

Combining
layouts

This

example will combine more than one layout type, which seems rather difficult at

first since only one layout manager can be operating for an applet or

application. This is true, but if you create more

//: CardLayout1.java
// Demonstrating the CardLayout
import java.awt.*;
import java.applet.Applet;
 
class ButtonPanel extends Panel {
  ButtonPanel(String id) {
    setLayout(new BorderLayout());
    add("Center", new Button(id));
  }
}
 
public class CardLayout1 extends Applet {
  Button
    first = new Button("First"),
    second = new Button("Second"),
    third = new Button("Third");
  Panel cards = new Panel();
  CardLayout cl = new CardLayout();
  public void init() {
    setLayout(new BorderLayout());
    Panel p = new Panel();
    p.setLayout(new FlowLayout());
    p.add(first);
    p.add(second);
    p.add(third);
    add("North", p);
    cards.setLayout(cl);
    cards.add("First card",
      new ButtonPanel("The first one"));
    cards.add("Second card",
      new ButtonPanel("The second one"));
    cards.add("Third card",
      new ButtonPanel("The third one"));
    add("Center", cards);
  }
  public boolean action(Event evt, Object arg) {
    if (evt.target.equals(first)) {
      cl.first(cards);
    }
    else if (evt.target.equals(second)) {
      cl.first(cards);
      cl.next(cards);
    }
    else if (evt.target.equals(third)) {
      cl.last(cards);
    }
    else
      return super.action(evt, arg);
    return true;
  }
} ///:~ 

This

example begins by creating a new kind of

:

a

.

This contains a single button, placed at the center of a

,

which means that it will expand to fill the entire panel. The label on the

button will let you know which panel you’re on in the

.

In

the applet, both the

where the cards will live and the layout manager

for the

must be members of the class because you need to have access to those handles

when you want to manipulate the cards.

The

applet is changed to use a

instead of its default

,

a

is created to hold three buttons (using a

),

and this panel is placed at the “North” end of the applet. The

panel is added to the “Center” of the applet, effectively occupying

the rest of the real estate.

When

you add the

s

(or whatever other components you want) to the panel of cards, the

method’s first argument is not “North,” “South,”

etc. Instead, it’s a string that describes the card. Although this string

doesn’t show up anywhere on the card, you can use it if you want to flip

that card using the string. This approach is not used in

;

instead the

,

and

methods are used. Check your documentation for the other approach.

In

Java, the use of some sort of “tabbed panel” mechanism is quite

important because (as you’ll see later) in applet programming the use of

pop-up dialogs is heavily discouraged. For Java 1.0

GridBagLayout

Some

time ago, it was believed that all the stars, planets, the sun, and the moon

revolved around the earth. It seemed intuitive from observation. But then

astronomers became more sophisticated and started tracking the motion of

individual objects, some of which seemed at times to go backward in their

paths. Since it was known that everything revolved around the earth, those

astronomers spent large amounts of time coming up with equations and theories

to explain the motion of the stellar objects.

When

trying to work with

My

recommendation is to avoid

.

Instead, use the other layout managers and especially the technique of

combining several panels using different layout managers within a single

program. Your applets won’t look

different; at least not enough to justify the trouble that

entails. For my part, it’s just too painful to come up with an example

for this (and I wouldn’t want to encourage this kind of library design).

Instead, I’ll refer you to

by Cornell

&

Horstmann (2

nd

ed., Prentice-Hall, 1997) to get started.

There’s

another light on the horizon: in the JFC/Swing library there is a new layout

manager that uses Smalltalk’s popular “Springs and Struts,”

and this could significantly reduce the need for

.

|

|