giáo trình Java By Example phần 3 pot

MenuBar menuBar = new MenuBar( );
As you can see, the MenuBar( ) constructor requires no arguments.
After you've created the MenuBar object, you have to tell Java to associate the menu bar with the frame
window. You do this by calling the window's setMenuBar( ) method:
setMenuBar(menuBar);
At this point, you have an empty menu bar associated with the window. In the next steps, you add menus
to the menu bar.
Adding Menus to a Menu Bar
A menu bar is the horizontal area near the top of a window that contains the names of the menus
contained in the menu bar. After creating and setting the MenuBar object, you have the menu bar, but it
contains no menus. To add these menus, you first create objects of the Menu class for each menu you
want in the menu bar, like this:
Menu fileMenu = new Menu("File");
Menu editMenu = new Menu("Edit");
Menu optionMenu = new Menu("Options");
The Menu class's constructor takes a single argument, which is the string that'll appear as the menu's
name on the menu bar. The example lines above create three menus for the menu bar.
After creating the Menu objects, you have to add them to the menu bar, which you do by calling the
MenuBar object's add( ) method, like this:
menuBar.add(fileMenu);
menuBar.add(editMenu);
menuBar.add(optionMenu);
After Java executes the above three lines, you have a menu bar with three menus, as shown in Figure
23.4. Note, however, that at this point the menus contain no commands. If you were to click on the menu
o
names, no pop-up menus would appear.
Figure 23.4 : This window's menu bar contains three empty menus.
Adding Menu Items to Menus
You may have empty menus at this point, but you're about to remedy that problem. To add items to your
menus, you first create objects of the MenuItem or CheckboxMenuItem classes for each menu item
you need. To add items to the Options menus you made previously, you might use Java code something

like this:
MenuItem option1 = new MenuItem("Option 1");
MenuItem option2 = new MenuItem("Option 2");
MenuItem option3 = new MenuItem("Option 3");
The MenuItem constructor takes as its single argument the string that'll be displayed in the menu for
this item.
If you're thinking that, after you create the menu items, you must call the appropriate Menu object's
add( ) method, you're be exactly right. Those lines might look like this:
optionMenu.add(option1);
optionMenu.add(option2);
optionMenu.add(option3);
Now, when you display the frame window sporting the menu bar you've just created, you'll see that the
Options menu contains a number of selections from which the user can choose, as shown in Figure 23.5.
Figure 23.5 : Now the Options menu contains menu items.
TIP
Sometimes, you may have several groups of related commands that
you'd like to place under a single menu. You can separate these
command groups by using menu separators, which appear as
horizontal lines in a pop-up menu. To create a menu separator, just
create a regular MenuItem object with a string of "-". That is, the
string should contain a single hyphen.
o
Example: Using a Menu Bar in a Frame Window
Now that you have this menu bar business mastered, it's time to put what you've learned to work. Listing
23.4 is an applet called MenuBarApplet. This applet displays a single button, which, when selected,
displays a frame window with a menu bar. This menu bar contains a single menu with three items. The
first two items are regular MenuItem objects. The third item is CheckboxMenuItem, which is a
menu item that can display a check mark. Figure 23.6 shows MenuBarApplet with its frame window
displayed and the Test menu visible. (Notice the menu separator above the checked item.)
Figure 23.6 : This is MenuBarApplet's frame window and menu bar.

Listing 23.4 MenuBarApplet.java: An Applet That Uses a Menu Bar.
import java.awt.*;
import java.applet.*;
public class MenuBarApplet extends Applet
{
MenuBarFrame frame;
Button button;
public void init()
{
frame = new MenuBarFrame("MenuBar Window");
button = new Button("Show Window");
add(button);
}
o
public boolean action(Event evt, Object arg)
{
boolean visible = frame.isShowing();
if (visible)
{
frame.hide();
button.setLabel("Show Window");
}
else
{
frame.show();
button.setLabel("Hide Window");
}
return true;
}
}

class MenuBarFrame extends Frame
{
MenuBar menuBar;
String str;
o
MenuBarFrame(String title)
{
super(title);
menuBar = new MenuBar();
setMenuBar(menuBar);
Menu menu = new Menu("Test");
menuBar.add(menu);
MenuItem item = new MenuItem("Command 1");
menu.add(item);
item = new MenuItem("Command 2");
menu.add(item);
item = new MenuItem("-");
menu.add(item);
CheckboxMenuItem checkItem =
new CheckboxMenuItem("Check");
menu.add(checkItem);
str = "";
Font font = new Font("TimesRoman", Font.BOLD, 20);
o

setFont(font);
}
public void paint(Graphics g)
{
resize(300, 250);

g.drawString(str, 20, 100);
}
public boolean action(Event evt, Object arg)
{
if (evt.target instanceof MenuItem)
{
if (arg == "Command 1")
str = "You selected Command 1";
else if (arg == "Command 2")
str = "You selected Command 2";
else if (arg == "Check")
str = "You selected the Check item";
repaint();
return true;
o
}
else
return false;
}
}
Tell Java that the applet uses the classes in the awt package.
Tell Java that the applet uses the classes in the applet package.
Derive the MenuBarApplet class from Java's Applet class.
Declare the custom frame-window and button objects.
Override the init( ) method.
Create the custom frame window.
Create and add the button component.
Override the action( ) method.
Determine whether the window is visible.
If the window is visible

Hide the window.
Change the button's label to "Show Window."
Else if the window is hidden
Show the window.
Change the button's label to "Hide Window."
Tell Java that the message was handled okay.
Derive the MenuBarFrame class from Java's Frame class.
Declare the class's menu bar and string objects.
Define the class's constructor.
Pass the title string on to the Frame class.
Create and set the menu bar.
Create and add the Test menu.
Create and add two regular menu items.
Create and add a menu separator.
Create and add a checkmark menu item.
Initialize the class's display string and font.
Override the window's paint( ) method.
Resize the window.
Show the display string in the window.
Override the action( ) method.
if a menu item was selected
Respond to the selected menu.
Repaint the window, so the new string is displayed.
o
Return true if the message was handled.
Or else return false so Java knows the event is unhandled.
NOTE
To determine the state (checked or unchecked) of a
CheckboxMenuItem object, you can call its getState( )
method. This method returns true if the item is checked and false

if the item is unchecked. In addition, you can set the item's state by
calling its setState( ) method.
As you can see from MenuBarApplet's source code, you respond to menu-item selections in the same
way you respond to other events in applets. This time, however, you have overridden two action( )
methods. The first is in the MenuBarApplet class and handles the applet's single button. The second
overridden action( ) method, which is the one that handles the menu items, is in the
MenuBarFrame class.
Summary
Although it's an ability you may not frequently take advantage of, Java applets can display windows. The
Frame class makes this possible, by providing the functionality for frame windows, which can be sized,
moved, used to display components, and much more. A frame window can, in fact, even have a
full-featured menu bar, just like the menu bars you see in many Windows applications. Creating a menu
bar, however, requires knowing how to create and manipulate MenuBar, Menu, MenuItem, and
CheckboxMenuItem objects. Luckily, you learned about those classes in this chapter, so you're all
ready to amaze the world with your Java frame windows.
Review Questions
How do you create a frame window?1.
How do you display a frame window after you create it?2.
How can you determine whether a frame window is currently visible?3.
What's the difference between MenuItem and CheckboxMenuItem objects?4.
Which Java class must you extend to create a custom frame-window class?5.
How do you ensure that a custom frame-window class has properly initialized its superclass?6.
How do you draw text or graphics in a frame window?7.
What are the six steps that must be completed in order to add a menu bar to a frame window?8.
How do you add components, such as controls, to a frame window?9.
How do you respond to selected menu items?10.
How do you create a menu separator object?11.
o
Review Exercises
Write an applet that displays a frame window as soon as the applet runs.1.

Write an applet that displays a frame window containing a 2x2 grid of buttons.2.
Modify the applet you wrote in exercise 2 so that the frame window contains a menu bar with two
menus. Each menu should have a single menu item.
3.
Modify the MenuBarApplet so that the menu bar has an additional menu called View. This menu
should contain a single checkmarked option called Window that determines whether a second
frame window is visible on the screen. When the user selects the Window command, the command
should be checkmarked and the second window should appear. When the user clicks this command
a second time, the second window should disappear and the command should be unchecked.
Figure 23.7 shows the resultant applet in action. (You can find the solution to this exercise in the
CHAP23 folder of this book's CD-ROM.)
Figure 23.7 : This is MenuFrameApplet running under Appletviewer.
4.

o
Chapter 22
Panels and Layout Managers
CONTENTS
Panels
Example: Creating and Using Panels❍
●
Layout Managers●
The FlowLayout Manager
Example: Creating a FlowLayout Manager❍
●
The GridLayout Manager
Creating a GridLayout Manager❍
●
The BorderLayout Manager
Creating a BorderLayout Manager❍

●
The CardLayout Manager
The CardLayout Manager Methods❍
Example: Creating a CardLayout Manager❍
●
The GridBagLayout Manager
Creating and Setting the GridBagLayout Manager❍
Creating and Setting a GridBagConstraints Object❍
Example: Using a GridBagLayout Manager in an Applet❍
Understanding the GridBagApplet Applet❍
●
Summary●
Review Questions●
Review Exercises●
Up until the previous chapter, when you've added controls to your applets, you've let Java place those
controls wherever it felt like it. The only way you could control positioning was by changing the size of
the applet. Obviously, if you're going to produce attractive applets that are organized logically, you need
some way to tell Java exactly where you want things placed. Java's layout managers were created for
exactly this purpose. Working in conjunction with layout managers are components called panels, which
enable you to organize other applet components. In this chapter, you learn about these two important
layout components.
o
Panels
A panel is a special type of container object that acts as a parent to other components that you want to
organize in your applet. For example, you can add several panels to an applet, each with their own
layout. By using panels in this way, you can create many different creative displays. Creating a panel is
as easy as calling the Panel class's constructor, like this:
Panel panel = new Panel();
As you can see, the Panel class's constructor requires no arguments.
Once you create a panel, you add it to the applet in the normal way, by calling the add() method:

add(panel);
Example: Creating and Using Panels
Using panels can be a little confusing at first, so an example is in order. Suppose you need to create an
applet that displays four buttons, but you don't want Java to place the buttons one after the other in the
display, which Java will do with its default layout. Instead, you want the buttons displayed in two rows
of two. One way to accomplish this feat is to add two panels to the applet and then add two buttons to
each panel. Listing 22.1 shows how this is done, whereas Figure 22.1 shows what the display looks like.
Figure 22.1 : Using panels, you can more easily organize components in an applet.
Listing 22.1 PanelApplet.java: Using Panels.
import java.awt.*;
import java.applet.*;
public class PanelApplet extends Applet
{
Panel panel1, panel2;
o
Button button1, button2, button3, button4;
public void init()
{
panel1 = new Panel();
panel2 = new Panel();
add(panel1);
add(panel2);
button1 = new Button("Button1");
button2 = new Button("Button2");
button3 = new Button("Button3");
button4 = new Button("Button4");
panel1.add(button1);
panel1.add(button2);
panel2.add(button3);
panel2.add(button4);

}
}
Tell Java that the applet uses the classes in the awt package.
Tell Java that the applet uses the classes in the applet package.
o
Derive the PanelApplet class from Java's Applet class.
Declare the panel and button objects.
Override the init() method.
Create the panels.
Add the panels to the applet.
Create the four buttons.
Add the buttons to the panels.
Notice how, when adding the panels to the applet, the program calls the PanelApplet class's add()
method (which adds the panels to the applet's display). However, when adding the buttons, the program
calls the panel objects' add() method (which adds the buttons to the panels). This is how you build a
hierarchy of components into your applets. In this case, you've got a stack of components three high, with
the applet's display on the bottom, the two panels on top of that, and the four buttons on top of the panels.
As you create more sophisticated applets, this type of component stacking will be more common.
Panels are kind of a "plain vanilla" container for organizing components in an applet. As you'll discover
in the next section, you can combine panels with layout managers to create truly complex displays.
Layout Managers
Layout Managers are special objects that determine how elements of your applet are organized in the
applet's display. When you create an applet, Java automatically creates and assigns a default layout
manager. In many of the applets you've created so far in this book, it's the default layout manager that's
determined where your controls appear. You can, however, create different types of layout managers in
order to better control how your applets look. The layout managers you can use are listed below:
FlowLayout●
GridLayout●
BorderLayout●
CardLayout●

GridBagLayout●
Each of these layout managers is represented by a class of the same name. To create a layout manager for
your applet, you first create an instance of the appropriate layout class and then call the setLayout()
method to tell Java which layout object you want to use. In the following sections, you get a chance to
see the various layout managers in action.
The FlowLayout Manager
In the previous section, I mentioned that, when you create an applet, Java assigns to it a default layout
manager. It just so happens that this default manager is an object of the FlowLayout class. The
FlowLayout manager places controls, in the order in which they're added, one after the other in
horizontal rows. When the layout manager reaches the right border of the applet, it begins placing
controls on the next row. In its default state, the FlowLayout manager centers controls on each row.
However, you can set the alignment when you create the layout manager for your applet, like this:
o
FlowLayout layout = new FlowLayout(align, hor, ver);
SetLayout(layout);
The FlowLayout constructor takes three arguments, which are the alignment (FlowLayout.LEFT,
FlowLayout.CENTER, or FlowLayout.RIGHT), the horizontal spacing between components, and
the vertical spacing.
Example: Creating a FlowLayout Manager
Suppose that you want to arrange three buttons in an applet using a FlowLayout manager set to left
alignment. Listing 22.2 shows how you'd create the manager and the buttons for the applet. Figure 22.2
shows the resultant control layout. Figures 22.3, and 22.4 show the center and right alignments for the
same controls.
Figure 22.2 : These buttons are left aligned by the FlowLayout manager.
Figure 22.3 : These buttons are center aligned by the FlowLayout manager.
Figure 22.4 : These buttons are right aligned by the FlowLayout manager.
Listing 22.2 LST22_2.TXT: Creating a FlowLayout Manager.
FlowLayout layout =
new FlowLayout(FlowLayout.LEFT, 10, 10);
setLayout(layout);

button1 = new Button("Button1");
button2 = new Button("Button2");
button3 = new Button("Button3");
add(button1);
add(button2);
add(button3);
o
NOTE
The FlowLayout() constructor shown in this chapter takes four
arguments. However, you can actually construct a FlowLayout
object with no arguments, FlowLayout(), or with a single
argument for the alignment, FlowLayout(FlowLayout.LEFT).
Many of Java's classes have multiple constructors.
The GridLayout Manager
Once you start creating more sophisticated applets, you'll quickly discover that the FlowLayout
manager may not give you the control you need to create the kind of display you want for your applet.
When you need more control over the placement of components, you can try out the GridLayout
manager.
Java's GridLayout manager organizes your applet's display into a rectangular grid, similar to the grid
used in a spreadsheet. Java then places the components you create for the applet into each cell of the grid,
working from left to right and top to bottom. You create a GridLayout manager like this:
GridLayout layout = new GridLayout(rows, cols, hor, ver);
SetLayout(layout);
The constructor's four arguments are the number of rows in the grid, the number of columns, and the
horizontal and vertical space between the grid cells.
Creating a GridLayout Manager
To test the GridLayout manager, suppose you want to place four buttons into a 2x2 grid, with no
space between the buttons. Listing 22.3 shows how you'd create the manager and the buttons for the
applet. Figure 22.5 shows the resultant control layout. Figure 22.6 shows the same layout manager,
except created with horizontal and vertical spacing of 10, and Figure 22.7 shows the layout with a single

row of four cells.
Figure 22.5 : This GridLayout manager is set to two rows and two columns.
Figure 22.6 : This is the same GridLayout manager with horizontal and vertical spacing.
Figure 22.7 : This GridLayout manager has one row and four columns.
Listing 22.3 LST22_3.TXT: Creating a GridLayout Manager.
o
GridLayout layout =
new GridLayout(2, 2, 0, 0);
setLayout(layout);
button1 = new Button("Button1");
button2 = new Button("Button2");
button3 = new Button("Button3");
button4 = new Button("Button4");
add(button1);
add(button2);
add(button3);
add(button4);
The BorderLayout Manager
You'll probably use the GridLayout manager most of the time, but there may be cases where you need
to put together something a little more unusual. One layout you can try is provided by the
BorderLayout manager, which enables you to position components using the directions north, south,
east, west, and center. You create a BorderLayout manager object like this:
BorderLayout layout = new BorderLayout(hor, ver);
setLayout(layout);
This constructor's two arguments are the horizontal and vertical spacing between the cells in the layout.
After you create the BorderLayout object, you must add the components using a different version of
the add() method:
add(position, object);
o
Here, position is where to place the component and must be the string North, South, East,

West, or Center. The second argument, object, is the component you want to add to the applet.
Creating a BorderLayout Manager
Suppose you have five buttons that you want to place in the five areas supported by a BorderLayout
manager. First, you create and set the manager. Then, you create the five buttons and add them to the
applet, using the special version of add() that includes the object's position as the first argument.
Listing 22.4 shows how this is done. Figure 22.8 shows the resultant display, whereas Figure 22.9 shows
the same applet with the BorderLayout manager with horizontal and vertical spacing.
Figure 22.9 : This is the same applet with horizontal and vertical spacing.
Figure 22.8 : This applet displays five buttons using a BorderLayout manager.
Listing 22.4 LST22_4.TXT: Creating a BorderLayout Manager.
BorderLayout layout = new BorderLayout(0, 0);
setLayout(layout);
button1 = new Button("Button1");
button2 = new Button("Button2");
button3 = new Button("Button3");
button4 = new Button("Button4");
button5 = new Button("Button5");
add("North", button1);
add("South", button2);
add("East", button3);
add("West", button4);
add("Center", button5);
o
The CardLayout Manager
One of the most complex layout managers is CardLayout. Using this manager, you can create a stack
of layouts not unlike a stack of cards and then flip from one layout to another. This type of display
organization is not unlike Windows 95's tabbed dialogs, usually called property sheets. To create a layout
with the CardLayout manager, you first create a parent panel to hold the "cards." Then, you create the
CardLayout object and set it as the panel's layout manager. Finally, you add each "card" to the layout
by creating the components and adding them to the panel.

To create a CardLayout manager, call its constructor and then add it to the applet, like this:
CardLayout cardLayout = new CardLayout(hor, ver);
panel.setLayout(cardLayout);
The constructor's two arguments are the horizontal and vertical spacing.
The CardLayout Manager Methods
Because the CardLayout manager enables you to switch between a stack of layouts, you need some
way to tell the manager what to do. For this reason, the CardLayout manager has a number of public
methods that you can call to specify which card is visible on the screen. Table 22.1 lists the most useful
of these methods along with their descriptions.
Table 22.1 CardLayout Manager Methods.
Method Description
first(Container parent) Displays the first card.
last(Container parent) Displays the last card.
next(Container parent) Displays the next card.
previous(Container parent) Displays the previous card.
show(Container parent, String name) Displays the specified card.
Example: Creating a CardLayout Manager
Putting the CardLayout manager to work is a lot easier if you always keep in mind the hierarchy of
components. At the bottom of the stack is the applet's display area. On top of this stack is the component
(usually a panel) that will hold the "cards." On top of the parent component is the CardLayout
manager, which you can think of as a deck of cards. The cards in this deck are the components that you
add to the panel.
Listing 22.5 is an applet that demonstrates how all this works. The cards in this applet are the three
buttons. When you run the applet, you see a single button in the display (Figure 22.10). Click the button
o
to switch to the next button in the stack. When you get to button three and click it, you end up back at
button one. You can cycle through the buttons as often as you like.
Figure 22.10 : Clicking the button switches the manager to a new card.
Listing 22.5 CardApplet.java: Using a CardLayout Manager.
import java.awt.*;

import java.applet.*;
public class CardApplet extends Applet
{
CardLayout cardLayout;
Panel panel;
Button button1, button2, button3;
public void init()
{
panel = new Panel();
add(panel);
cardLayout = new CardLayout(0, 0);
panel.setLayout(cardLayout);
button1 = new Button("Button1");
button2 = new Button("Button2");
o
button3 = new Button("Button3");
panel.add("Button1", button1);
panel.add("Button2", button2);
panel.add("Button3", button3);
}
public boolean action(Event evt, Object arg)
{
cardLayout.next(panel);
return true;
}
}
Tell Java that the applet uses the classes in the awt package.
Tell Java that the applet uses the classes in the applet package.
Derive the CardApplet class from Java's Applet class.
Declare the layout, panel, and button objects.

Override the init() method.
Create and add the parent panel.
Create and set the layout.
Create the buttons (which act as the cards).
Add the buttons to the panel.
Override the action() method.
Switch to the next card (button).
Tell Java that the event was handled okay.
NOTE
o
The stack of cards that are arranged by a CardLayout manager can
be any type of component. For example, you can create several
different panels, each with their own controls, and switch between the
panels. This enables you to switch between whole sets of controls,
just like Windows 95's property sheets.
The GridBagLayout Manager
The most complex of the layout managers is GridBagLayout, which pretty much lets you organize
objects any way you like. However, the price for this power is meticulous planning and a lot of
experimentation. At the time of this writing, the documentation for the GridBagLayout manager was
sketchy and incomplete. I did the best I could to figure out exactly how this layout manager worked, but
there's no question that to get the best out of GridBagLayout, you're going to have to spend some
time experimenting with different layouts.
To create a layout using GridBagLayout, you must follow these steps:
Create a GridBagLayout object.1.
Set the layout manager.2.
Create a GridBagConstraints object.3.
Initialize and set the constraints for the object about to be added to the layout.4.
Add the object to the layout.5.
Repeat steps 4 and 5 for each object you're adding to the layout.6.
Yep, there's much to be done to use a GridBagLayout manager. In the sections that follow, you'll

learn how to perform each of the required steps.
Creating and Setting the GridBagLayout Manager
To create a GridBagLayout manager, call the class's constructor, like this:
GridBagLayout layout = new GridBagLayout();
The constructor requires no arguments. When you've created the GridBagLayout() object, set the
manager by calling setLayout():
setLayout(layout);
This method's single argument is a reference to the layout object.
o
Creating and Setting a GridBagConstraints Object
Because the position of each component in a layout controlled by a GridBagLayout object is
determined by the currently set GridBagConstraints object, you must create the
GridBagConstraints object before you can start building your layout. To do this, call the class's
constructor:
GridBagConstraints constraints = new GridBagConstraints();
Like the GridBagLayout class, the GridBagConstraints constructor requires no arguments.
However, although the class's fields start off initialized to default values, you'll almost always change
some of those values before adding components to the layout. You perform this task with lines
something like this:
constraints.fill = GridBagConstraints.BOTH;
This line sets the GridBagConstraints object's fill field to a constant defined in the class. Table
22.2 shows the fields of the GridBagConstraints class and what they mean.
Table 22.2 Fields of the GridBagConstraints Class.
Field Description
anchor
Where within a component's area the component should be
placed. Predefined values are
GridBagConstraints.NORTH,
GridBagConstraints.NORTHEAST,
GridBagConstraints.EAST,

GridBagConstraints.SOUTHEAST,
GridBagConstraints.SOUTH,
GridBagConstraints.SOUTHWEST,
GridBagConstraints.WEST,
GridBagConstraints.NORTHWEST, and
GridBagConstraints.CENTER.
fill
Determines how to size a component when the display area is
larger than the component. Predefined values you can use are
GridBagConstraint.NONE,
GridBagConstraint.HORIZONTAL,
GridBagConstraint.VERTICAL, and
GridBagConstraint.BOTH.
gridheight
The number of cells in each column of a component's display
area.
o
gridwidth
The number of cells in each row of a component's display area.
gridx
The X coordinate of the cell at the upper left of a component's
display area.
gridy
The Y coordinate of the cell at the upper left of the component's
display area.
insets
The minimum amount of space between a component and the
edges of its display area.
ipadx
The amount of horizontal space around a component.

ipady
The amount of vertical space around a component.
weightx
Determines whether components stretch horizontally to fill the
applet's display area.
weighty
Determines whether components stretch vertically to fill the
applet's display area.
Once you have the GridBagConstraints object created and initialized, you must set the constraints
by calling the layout object's setConstraints() method:
layout.setConstraints(component, constraints);
This method's two arguments are a reference to the component whose constraints you're setting and a
reference to the constraints object. You need to call setConstraints() for each component you add
to the layout. After setting the constraints for the component, you add the component to the layout in the
normal way, by calling the add() method.
Example: Using a GridBagLayout Manager in an Applet
As I said before, the only way to really understand how the GridBagLayout manager works is to
experiment with it on your own. This book just doesn't have the room to cover every detail of using this
complex manager. Still, I won't send you off without at least the basics. So, Listing 22.6 is an applet,
called GridBagApplet, that demonstrates how to create and use a GridBagLayout manager. Figure
22.11 shows what the applet looks like when it's run under Appletviewer.
Figure 22.11 : GridBagLayout manager enables you to create unusual layouts.
Listing 22.6 GridBagApplet.java: A GridBagLayout Applet.
import java.awt.*;
import java.applet.*;
o
public class GridBagApplet extends Applet
{
public void init()

{
GridBagLayout layout = new GridBagLayout();
setLayout(layout);
GridBagConstraints constraints = new GridBagConstraints();
Button button1 = new Button("Button1");
Button button2 = new Button("Button2");
Button button3 = new Button("Button3");
Button button4 = new Button("Button4");
Button button5 = new Button("Button5");
Button button6 = new Button("Button6");
Button button7 = new Button("Button7");
Button button8 = new Button("Button8");
Button button9 = new Button("Button9");

constraints.fill = GridBagConstraints.BOTH;
o
layout.setConstraints(button1, constraints);
add(button1);
constraints.gridwidth = GridBagConstraints.RELATIVE;
layout.setConstraints(button2, constraints);
add(button2);
constraints.gridwidth = GridBagConstraints.REMAINDER;
layout.setConstraints(button3, constraints);
add(button3);
constraints.gridwidth = GridBagConstraints.REMAINDER;
layout.setConstraints(button4, constraints);
add(button4);

constraints.gridwidth = GridBagConstraints.RELATIVE;
layout.setConstraints(button5, constraints);

add(button5);

constraints.gridwidth = GridBagConstraints.REMAINDER;
layout.setConstraints(button6, constraints);
add(button6);

o