All Categories :
Java
Chapter 16
The Windowing (AWT) Package
by David R. Chung
CONTENTS
The Java Abstract Windowing Toolkit (AWT) is a general-purpose,
multiplatform windowing library. The AWT provides classes that
encapsulate many useful graphical user interface (GUI) components
(also called widgets or controls). The AWT also
includes classes to manage component layout and utility classes
to handle fonts, colors, and other GUI-related items. Because
Java is a multiplatform solution, the AWT provides a common interface
to the native GUI components on a wide variety of platforms. This
abstraction makes the AWT highly portable.
The tradeoff is that the AWT does not fully encapsulate the machine-specific
GUI features of any specific platform. Even so, the AWT
is a fully capable GUI, and you can use it to create powerful
user interfaces that run on a wide variety of platforms.
The AWT classes can be divided into three groups:
- Control classes
- Layout classes
- Menu classes
This chapter examines the classes of the AWT and explains how
to incorporate them into your applets and applications. Example
applets demonstrate the various AWT controls.
The control classes of the AWT provide a platform-independent
wrapper for the basic GUI widgets. These classes include
most of the components necessary to create a modern user interface
for your Java applets or applications.
The Component
Class
The AWT component classes are all derived from a common base class:
the Component class. The
Component class is an abstract
class. This class defines the elements common to all GUI components.
The Component class is derived
from the Object class. The
Component class also implements
the ImageObserver interface.
| Note |
An abstract class is a class that contains one or more methods declared to be abstract. (Abstract methods are similar to pure virtual functions in C++.) Abstract classes cannot actually be instantiated. To make use of these classes, you must derive a class from the abstract class and provide an implementation for each abstract method.
|
The Component class provides
a unified interface to all the graphic components of the AWT.
Figure 16.1 shows all the AWT widgets derived from the Component
class.
Figure 16.1: The Java Component class hierarchy.
The components in this hierarchy can be divided into the following
functional groups:
- Simple widgets (buttons, checkboxes, and so on)
- Text controls
- The Canvas class
Simple Widgets
The Java AWT encapsulates many of the controls common to most
GUIs. Specifically, these are the Button,
Checkbox, Choice,
Label, List,
and Scrollbar classes. Figure
16.2 shows an applet that displays the AWT simple widgets.
Figure 16.2: The simple AWT components.
The following code shows the Simple
applet, which contains the simple AWT widgets. The applet's init()
method creates an example of each simple widget and adds it to
the applet.
import java.awt.*;
public class Simple extends java.applet.Applet {
public void init() {
Button button = new Button( "Quit" ) ;
Checkbox checkbox = new Checkbox( "Test" ) ;
Both the Choice and List
objects include addItem()
methods. These methods allow you to fill the control with the
items you specify. Unlike some GUIs, the AWT Choice
and List controls do not
sort the items they contain. They are displayed in the order in
which you add them.
Choice choice = new Choice() ;
// fill the Choice
choice.addItem( "Clinton" ) ;
choice.addItem( "Dole" ) ;
choice.addItem( "Perot" ) ;
choice.addItem( "Browne" ) ;
choice.addItem( "Nader" ) ;
Label label = new Label( "This is a label" ) ;
List list = new List( 5, false ) ;
// fill the List
list.addItem( "Clinton" ) ;
list.addItem( "Dole" ) ;
list.addItem( "Perot" ) ;
list.addItem( "Browne" ) ;
list.addItem( "Nader" ) ;
Scrollbar scrollbar = new Scrollbar( Scrollbar.HORIZONTAL ) ;
To display these controls, you must add them to the applet's layout
using the add() method:
// add the controls to the default layout
add( button ) ;
add( checkbox ) ;
add( choice ) ;
add( label ) ;
add( list ) ;
add( scrollbar ) ;
}
}
This applet displays the simple widgets. To be truly useful, an
applet should do more than just display the controls-the applet
must also be interactive. This brings up the topic of event
handling. The DemoFrame
applet presented later in this chapter demonstrates event handling.
Text Controls
The AWT contains a group of controls whose purpose is to allow
users to enter and display text. Unlike the simple widgets just
discussed, the text controls let users enter freeform text into
applications. The TextField
and TextArea classes are
derived from TextComponent
as shown in Figure 16.3.
Figure 16.3: The AWT text component hierarchy.
TextComponent is an abstract
base class. It provides common methods for displaying text, getting
text from the user, and selecting portions of text. The base class
also allows the control to be made editable or read-only.
The TextField class encapsulates
a nonscrollable text box. TextField
controls are commonly used to allow users to enter single values.
TextArea controls are more
versatile and allow multiple lines and scrolling. Both TextField
and TextArea components can
be used to get user input or to display values.
Now let's work through the code for the Text
applet that shows the use of the AWT text
components:
import java.awt.*;
public class Text extends java.applet.Applet {
public void init() {
Both the TextArea and TextField
classes (and many other Component-derived
classes) have overloaded constructor methods.
| Note |
Overloaded methods are methods with the same name that take different parameters. Constructors are commonly overloaded to provide different types of initialization for a class.
|
This applet uses the TextArea
and TextField constructors
to specify the number of rows and columns displayed in each control.
These constructors also specify the text that will be initially
displayed in the control.
TextArea textarea = new TextArea(
"This text area has 3 rows and 40 columns",
3, 40 ) ;
TextField textfield = new TextField(
"This text field has 30 columns",
30 ) ;
add( textarea ) ;
add( textfield ) ;
}
}
The Text applet demonstrates
the AWT text components. Figure 16.4 shows the Text
applet.
Figure 16.4: The AWT text components.
The Canvas Class
The AWT Canvas class is a
generic Component class.
The Canvas class is most
often used to display images. It is also used as the background
for user drawing. Chapter 21, "Creating
User Interface Components," contains an example that uses
the Canvas class to draw
an image.
The Container
Class
The AWT Container class is
a Component class that can
contain other Component objects.
Although Container is an
abstract class, its derived classes are among the most useful
in the AWT. Figure 16.5 shows the Container
class hierarchy.
Figure 16.5: The container class hierarchy.
Container classes are the
basic framework from which you build the GUI components of your
applets. The Container hierarchy
can be divided into two categories: the Panel
and Window classes.
The Panel Class
The Panel class is a generic
Container class. Panel
is not an abstract class and can be instantiated or subclassed.
Panels are Java's multipurpose containers and do not provide
any special functionality-except for the capability to embed other
GUI objects. Panels give you a convenient method of forming composite
controls. In Chapter 21, you use the
Panel class to combine other
controls. Sample applets in that chapter demonstrate many of the
GUI components available in the AWT.
The Panel class performs
one other important function: It is the superclass of the AWT
Applet class. This makes
sense because one of the things you do with applets is embed controls
in them.
| Note |
The Applet class is not actually part of the java.awt package. Applet is contained in the java.applet package.
|
The Window Class
Like the Panel class, the
Window class is derived from
the Container class. Although
it is not an abstract class, you rarely create Window
objects. However, the Window
class is the root class for two very useful classes: Frame
and Dialog. The Window
class and its derived classes allow you to create windows that
can float over or even outside the browser window. These Window
objects can be resizable and can have their own titles and menus.
Because Frame objects are
derived from the Container
class, they can contain other controls. The FrameTest
applet creates a Frame with
embedded Button and Label
objects. Figure 16.6 shows the FrameTest
applet in operation.
Figure 16.6: The FrameTest applet (with Frame displayed).
This applet has a Button
object that displays or hides a Frame.
The button is an AWT Button;
the Frame object is the DemoFrame
class derived from Frame.
The applet doesn't actually create a Frame,
rather it creates a DemoFrame
object derived from Frame.
class DemoFrame extends Frame {
Label label ;
Button button ;
// variable to store button presses
int count ;
The DemoFrame
Class
The DemoFrame constructor
takes a String parameter.
This string is passed to the superclass constructor. Because
DemoFrame is derived from
Frame, the constructor called
is Frame( String txt ). It
is the Frame constructor
that actually makes the string the window title.
| Note |
Calls to a superclass constructor should be made only from a derived class constructor. They must be the first line of code in the derived class constructor. Other superclass methods can be called from any derived class method. The syntax is super.superclassMethod().
|
The constructor also creates the embedded Label
object and sets its text to an empty string. The Label.CENTER
parameter indicates that the label text should be centered in
the control.
DemoFrame( String title ) {
super( title ) ;
label = new Label( "", Label.CENTER ) ;
The resetCount() and showCount()
methods are defined a little later in this section. These methods
set the value of count and
display it in the embedded Label.
Both of these methods are public
so that the owner of this Frame
(in this case, the FrameTest
applet) can use them to reset and display the count value:
resetCount() ;
showCount() ;
Next, the constructor creates the Button
object. The Button face displays
the label Count. To display the Label
above the Button, you must
set the Frame's Layout
to GridLayout and add the
controls. GridLayout lets
you lay out controls in a regular grid-in this case, two rows
and one column:
button = new Button( "Count" ) ;
setLayout( new GridLayout( 2,1 ) ) ;
add( label ) ;
add( button ) ;
}
The resetCount() method is
a public method. This method
is designed to allow access to the count
variable. Of course, you can make the count
variable public, but then
count could be modified by
anyone. By using a public access method, you can control who accesses
your data members and what they can do with them.
public void resetCount(){
count = 0 ;
}
The showCount() method updates
the Label text. Every time
the Frame's button is pressed,
the count variable is incremented
and the showCount() method
is called to display the results:
public void showCount(){
label.setText( "Button pressed " + count + " times." ) ;
}
Event Handling
In Java, most of the programming you do is event driven.
This means that Java programs spend a lot of time waiting for
someone to do something. For example, when a user presses a button,
your applet must provide a method that is executed in response
to that event. The DemoFrame
class uses the action() method
to respond to events.
The action() method takes
two parameters: an Event
and an Object. Both parameters
are objects. Event provides
information about the type of event and the control that originated
it. The Object argument is
a generic argument that contains information specific to the type
of event that occurs.
| Note |
Object is the superclass to all Java classes; therefore, the Object parameter can be used to pass any type of object. To make use of this parameter, you must cast it to some specific type.
|
The action() method is supposed
to respond to the Frame's
button. The first thing the method must do is determine the type
of event this is. The if
statement checks the target
member of the Event argument
to see whether it is a Button
(or a class derived from Button).
The expression in the if
statement uses the instanceof
operator. This operator is similar to the ==
and > operators. It compares
its right and left operands to see whether they are of the same
type. This is an example of runtime type checking. (C++ is just
now getting runtime type checking.)
If the Event was generated
by a Button, the next if
statement checks to see which Button
was pressed. Because this is a Button
Event, the Object
parameter is a String containing
the text on the Button face.
Because the parameter is of type Object
(remember that all Java classes, including String,
are derived from Object),
you must cast the parameter to a String.
If this Event was generated
by the Count button, the action()
function increments count.
Next, the function calls the showCount()
method to display the new value.
Finally, if the action()
method has completely handled the Event,
it should return true. If
further processing is required, the method returns false.
public boolean action( Event evt, Object arg ) {
if ( evt.target instanceof Button ) {
if ( ((String)arg).equals( "Count" ) ){
count++ ;
showCount() ;
// the event has been handled
return true ;
}
}
// the event has not been handled
return false ;
}
}
The FrameTest Applet
The DemoFrame class is used
to create a Frame for the
applet. The applet creates a button that alternately displays
or hides the Frame:
import java.awt.*;
public class FrameTest extends java.applet.Applet {
DemoFrame frameWindow ;
Button showFrame ;
The applet's init() method
creates the Button and the
DemoFrame. Notice that the
button is added to the applet's Layout
but the DemoFrame is not.
Because Frame objects are
top-level windows, they cannot be embedded in other containers.
Frames actually float outside the applet and browser windows.
They can be hidden by other windows or tiled along with other
top-level windows.
In this example, the Frame
object is created and a String
is passed to the Frame constructor.
The String is used as the
Frame window title.
When you create a Frame,
it is initially invisible. When the user presses the button, the
applet displays (or hides) the Frame.
The Frame must also be given
a size; this is done by calling its resize()
method:
public void init() {
showFrame = new Button( "Show Frame" ) ;
add( showFrame ) ;
frameWindow = new DemoFrame( "This is a Frame" ) ;
frameWindow.resize( 200, 100 ) ;
}
The FrameTest applet handles
Button events the same way
the DemoFrame class does.
A subtle difference is that each time the button is pressed, the
text on its face changes. When the Button
says Show Frame, it resets the count to zero and shows
the Frame. The method also
changes the text on the button to Hide Frame. Likewise,
if the Button face says Hide
Frame, the Frame is hidden.
public boolean action( Event evt, Object arg ) {
if ( evt.target instanceof Button ) {
if (((String)arg).equals( "Show Frame" )){
frameWindow.resetCount() ;
frameWindow.showCount() ;
frameWindow.show() ;
showFrame.setLabel( "Hide Frame" ) ;
// the event has been handled
return true ;
}
else if (((String)arg).equals( "Hide Frame" )){
frameWindow.hide() ;
showFrame.setLabel( "Show Frame" ) ;
// the event has been handled
return true ;
}
}
// the event has not been handled
return false ;
}
}
If you run this applet in a browser, you may notice that the Frame
window has a status bar with the message Untrusted
Applet Window, Warning Applet
Window , or Unsigned Java
Applet Window. These warnings are displayed by browser
implementations of Java whenever a Java applet creates a Frame
window. This prevents Frame
windows from masquerading as a local application.
The AWT contains a group of classes designed to handle placement
of controls in Container objects.
These are the layout classes. All layout classes are derived directly
from Object. These classes
all implement the LayoutManager
interface.
The AWT implements the following layout classes:
- FlowLayout
- BorderLayout
- CardLayout
- GridLayout
- GridBagLayout
These classes provide a flexible, platform-independent means of
arranging Component objects
in your Container objects.
It is possible that these five classes provide all the flexibility
your applets and applications need. If you have specific needs,
you can implement your own layout class by deriving it from Object
and implementing the LayoutManager
interface.
The FlowLayout
Class
The FlowLayout class allows
you to lay out controls in rows. Controls are placed in rows as
long as there is room. After a row has been filled, subsequent
controls are placed in the next row. Figure 16.7 shows the flow
applet.
Figure 16.7: The flow applet.
The flow applet creates a
simple FlowLayout:
import java.awt.*;
public class flow extends java.applet.Applet {
public void init() {
setLayout( new FlowLayout() ) ;
add( new Button( "One" ) ) ;
add( new Button( "Two" ) ) ;
add( new Button( "Three" ) ) ;
add( new Button( "Four" ) ) ;
add( new Button( "Five" ) ) ;
}
}
In this applet, the FlowLayout
constructor is called with no parameters. There are two other
overloaded constructors for the FlowLayout
class. These allow you to fine tune the FlowLayout
to meet your particular needs.
The first constructor takes one parameter. By passing FlowLayout.LEFT,
FlowLayout.CENTER, or FlowLayout.RIGHT,
you specify the alignment for the controls. The default alignment
(when you don't specify one) is FlowLayout.CENTER.
Therefore, to align the buttons on the left in the flow
applet, you replace the call to setLayout()
with this call:
setLayout( new FlowLayout( FlowLayout.LEFT ) ) ;
Layouts also give you control over the amount of space between
controls. The FlowLayout()
method fills the first row and then each subsequent row as necessary.
If the layout requires more than one row, you can specify the
vertical spacing as well. The constructor that does this takes
an alignment parameter followed by two parameters specifying the
spacing between controls. To make the flow
applet place its controls centered with ten pixels of horizontal
gap and five pixels of vertical gap, use the following code:
setLayout( new FlowLayout( FlowLayout.CENTER, 10, 5 ) ) ;
The BorderLayout
Class
The AWT BorderLayout class
places controls so that they fill their Container
object. The controls are placed according to a geographic position
that you specify. Controls can be placed on the north, south,
east, and west edges of the Container.
You can also place a control in the center of the Container.
The centered control is then expanded to fill the remaining space.
Figure 16.8 shows the border
applet with five controls.
Figure 16.8: The border applet.
The border applet creates
a simple BorderLayout:
import java.awt.*;
public class border extends java.applet.Applet {
public void init() {
setLayout( new BorderLayout() ) ;
add( "North", new Button( "NORTH" ) ) ;
add( "South", new Button( "SOUTH" ) ) ;
add( "East", new Button( "EAST" ) ) ;
add( "West", new Button( "WEST" ) ) ;
add( "Center", new Button( "CENTER" ) ) ;
}
}
When you create a BorderLayout,
you can specify vertical and horizontal gap values as you can
with the setLayout() method
(described in the flow applet).
The CardLayout
Class
The AWT CardLayout class
is unique. Rather than placing multiple controls in a Container
object, this layout displays the controls one at a time (much
like the familiar deck of cards in the ubiquitous Solitaire game).
The controls that are displayed may, in fact, be composite controls.
Therefore, you can present entirely different sets of controls
to the user in a manner similar to the tabbed dialog boxes that
Microsoft Windows uses. Figure 16.9 shows an applet with five
buttons laid out in a CardLayout
fashion.
Figure 16.9: The card applet.
The card applet creates a
CardLayout with five buttons:
import java.awt.*;
public class card extends java.applet.Applet {
CardLayout layout ;
public void init() {
layout = new CardLayout() ;
setLayout( layout ) ;
add( new Button( "First" ) ) ;
add( new Button( "Second" ) ) ;
add( new Button( "Third" ) ) ;
add( new Button( "Fourth" ) ) ;
add( new Button( "Fifth" ) ) ;
}
public boolean action( Event evt, Object arg ) {
if ( evt.target instanceof Button ) {
layout.next(this) ;
return true ;
}
return false ;
}
}
The card applet places five
Button objects in a CardLayout.
When any button is pressed, the action()
method calls the CardLayout's
next() method to display
the next card in order. This layout also allows you to label the
various controls that are added.
The add() method takes an
optional String parameter
that labels the controls you add. The following call adds a Button
labeled my button with the
label Push Me:
add( "my button", new Button( "Push Me" ) ;
Once the controls have labels, you can display them without having
to show them in order, without calling the layout's next()
method. To display my button,
simply call the layout's show()
method:
show( this, "my button" ) ;
The show() method displays
a specified control; the next()
method displays the next control in order. The CardLayout
class provides the following functions to navigate the controls
in the layout:
- first( Container )
- last( Container )
- next( Container )
- previous( Container )
- show( Container, String )
All these navigational functions take a reference to a Container
object as a parameter. The show()
method takes a String containing
the label given to the control when it was added.
| Note |
What's this? In Java, this is a keyword that represents a reference to a given object. When an applet calls one of the CardLayout's navigational methods, it needs a Container as a parameter. Because these functions are called in the context of a Container member method, this represents the current Container.
|
The GridLayout
Class
As its name suggests, the GridLayout
class places controls in the Container
in a grid. It is important to note that this is a regular
grid-all the grid cells are the same size. The applet in Figure
16.10 shows a GridLayout.
Figure 16.10: The grid applet.
The grid applet defines a
grid with two rows and three columns. The add()
method adds each control starting with row 1, column 1 followed
by row 1, column 2 and so on.
import java.awt.*;
public class grid extends java.applet.Applet {
public void init() {
setLayout( new GridLayout( 2, 3 ) ) ;
add( new Button( "One" ) ) ;
add( new Button( "Two" ) ) ;
add( new Button( "Three" ) ) ;
add( new Button( "Four" ) ) ;
add( new Button( "Five" ) ) ;
}
}
You can also create a GridLayout
with vertical and horizontal gap values by using the setLayout()
method as you do with the FlowLayout
and BorderLayout classes.
The GridBagLayout
Class
The GridBagLayout class is
complex enough to fill an entire chapter by itself. This class
was added to the AWT very late in the Java beta. Therefore, many
early acceptors of Java didn't use this layout at all. Some early
books omit it completely.
Of all the layouts offered by the AWT, GridBagLayout
is the most versatile. Despite its funny name, once you learn
how to use GridBagLayout,
it will become an indispensable part of your Java toolkit.
Like GridLayout, GridBagLayout
places controls in a Container
in a grid. The difference is that in a GridBagLayout,
controls can span any number of grid cells vertically, horizontally,
or both. Controls can be placed in any grid cell. Cells can be
of differing sizes as well. Figure 16.11 shows the gridbag
applet.
Figure 16.11: The Gridbag applet.
The gridbag applet displays
five buttons in a GridBagLayout
arrangement:
import java.awt.*;
public class gridbag extends java.applet.Applet {
public void init() {
Button b1 = new Button( "One" ) ;
Button b2 = new Button( "Two" ) ;
Button b3 = new Button( "Three" ) ;
Button b4 = new Button( "Four" ) ;
Button b5 = new Button( "Five Thousand" ) ;
GridBagLayout gridbag = new GridBagLayout();
setLayout( gridbag ) ;
{
GridBagConstraints c = new GridBagConstraints();
c.fill = GridBagConstraints.BOTH ;
c.gridx = 1 ;
c.gridy = 1 ;
gridbag.setConstraints(b1, c);
add( b1 ) ;
}
{
GridBagConstraints c = new GridBagConstraints();
c.anchor = GridBagConstraints.WEST ;
c.gridx = 2 ;
c.gridheight = 2 ;
gridbag.setConstraints(b2, c);
add( b2 ) ;
}
{
GridBagConstraints c = new GridBagConstraints();
c.fill = GridBagConstraints.BOTH ;
c.gridx = 1 ;
c.gridy = 2 ;
c.gridwidth = 2 ;
gridbag.setConstraints(b3, c);
add( b3 ) ;
}
{
GridBagConstraints c = new GridBagConstraints();
c.fill = GridBagConstraints.BOTH ;
c.gridx = 1 ;
c.gridy = 3 ;
c.gridwidth = 3 ;
gridbag.setConstraints(b4, c);
add( b4 ) ;
}
{
GridBagConstraints c = new GridBagConstraints();
c.fill = GridBagConstraints.VERTICAL ;
c.gridx = 3 ;
c.gridy = 1 ;
c.gridheight = 2 ;
gridbag.setConstraints(b5, c);
add( b5 ) ;
}
}
}
The key to using GridBagLayout
is the GridBagConstraints
class. This class is used to encapsulate information about each
control that is added to the layout. Setting the class data members
determines how the controls will be placed.
To use a GridBagLayout, you
must create a GridBagConstraints
object. Then set the data members of the GridBagConstraints
object to appropriately lay out the given control. Next, call
the GridBagLayout's setConstraints()
method to associate a GridBagConstraints
object with a control. Finally, add the control.
| Note |
C and C++ programmers may be asking why GridBagConstraints is a class. It appears to have only data members. In fact, if this were C or C++, GridBagConstraints would be a structure. Because Java does not support structures, GridBagConstraints must be implemented as a class.
|
The following GridBagConstraints
public data members determine how your controls are placed:
- The anchor member specifies
how a control is displayed if it is smaller than the grid cell
in which it is placed. This member can be set to CENTER,
NORTH, SOUTH,
EAST, WEST,
NORTHEAST, SOUTHEAST,
NORTHWEST, or SOUTHWEST.
- The fill member lets
a control grow to fill its allotted grid cells if the cells are
larger than the control's default size. The choices for this member
are BOTH, HORIZONTAL,
VERTICAL, and NONE.
- The gridheight and gridweight
members determine how many grid cells a control takes up.
- The gridx and gridy
members specify the row and column (in grid coordinates) at which
to place the control.
- The ipadx and ipady
members specify the vertical and horizontal gap (or padding) for
components.
- The weightx and weighty
members specify how excess space is assigned to the various
components if the container in which they are embedded is resized.
- The Insets member is
a class that specifies the margins of a Container
that has a GridBagLayout.
By using the GridBagLayout
and GridBagConstraints classes,
you can produce layouts to meet nearly all your needs. If these
are not flexible enough for you, there is always the option of
creating your own LayoutManager.
You create your own LayoutManager
by creating a class (subclassed from Object)
that implements the LayoutManager
interface.
The AWT provides a hierarchy of classes that allow you to include
menus in your applets and applications. Figure 16.12 shows the
AWT menu classes.
Figure 16.12: The AWT menu class hierarchy.
All the menu classes are derived from the MenuComponent
class. The MenuBar and Menu
classes both implement the MenuContainer
interface.
The MenuFrame applet shows
a Frame with a menu. Selecting
Hide Frame from the menu closes the frame window. Figure 16.13
shows the MenuFrame applet.
Figure 16.13: The MenuFrame applet.
The MenuFrame applet creates
MenuItem, Menu,
and MenuBar objects. The
Frame's action()
method determines whether the Hide Frame menu item has been selected.
import java.awt.*;
public class MenuFrame extends java.applet.Applet {
DemoFrame frameWindow ;
Button showFrame ;
public void init() {
showFrame = new Button( "Show Frame" ) ;
add( showFrame ) ;
frameWindow = new DemoFrame( "This is a Frame" ) ;
frameWindow.resize( 200, 100 ) ;
}
public boolean action( Event evt, Object arg ) {
if ( evt.target instanceof Button ) {
if ( !frameWindow.isShowing() ) {
frameWindow.show() ;
return true ;
}
}
return false ;
}
}
class DemoFrame extends Frame {
MenuItem menuItem ;
Menu menu ;
MenuBar menuBar ;
Label label ;
DemoFrame( String title ) {
super( title ) ;
menuItem = new MenuItem( "Hide Frame" ) ;
menu = new Menu( "My Menu" ) ;
menu.add( menuItem ) ;
menuBar = new MenuBar() ;
menuBar.add( menu ) ;
setMenuBar( menuBar ) ;
}
public boolean action( Event evt, Object arg ) {
if ( evt.target instanceof MenuItem ) {
if ( ((String)arg).equals( "Hide Frame" ) ) {
hide() ;
return true ;
}
}
return false ;
}
The Java AWT contains a rich collection of controls. By using
these controls, you can create a variety of truly multiplatform
GUI applications. The AWT also provides generic container and
window classes you can use to create your own custom controls.
The layout classes of the AWT answer the question of how to place
controls so that they appear properly on all platforms. You can
even create custom layout managers.
Java and the AWT provide a credible solution to developing fully
featured GUI applications for a wide variety of target platforms.
Contact
reference@developer.com with questions or comments.
Copyright 1998
EarthWeb Inc., All rights reserved.
PLEASE READ THE ACCEPTABLE USAGE STATEMENT.
Copyright 1998 Macmillan Computer Publishing. All rights reserved.
SHOPPING
JOB BANK
REFERENCE
JOURNAL
COMMUNITY
ABOUT US
