The AWT Components

So far I've emphasized more concepts than pragmatic programming. You've become familiar with the concepts and ideas upon which Java GUI programming, and the Swing architecture in particular, are built.

At this point, you know how to organize a GUI program and get it to display. The example GUI screens did not have much on them, however. It's now time to introduce some actual components--real widgets--that you can use to build more functional GUIs.

This chapter introduces the AWT component set. You will look at the basic visual components, how to construct them and add them to a GUI, and how to use their basic features. It is still possible to build complete GUI applications using only the original AWT components. Therefore, it is useful to examine the contents of the AWT package.

This chapter is presented to aid those who must still build Java GUI programs using only the AWT components and not Swing's new lightweight components. However, you are strongly encouraged to use the new lightweight components if you are starting fresh.

The Personal Java platform for embedded programming does not support Swing so you need to use the AWT for that environment.

The AWT Components

The AWT components are defined in the java.awt package. Table 2.2 lists the AWT components defined in the java.awt package. By now you know that this package is part of the JFC since the JDK 1.1 release. All AWT components are JFC components. However, they are implemented as heavyweight components. Each AWT component instance creates a corresponding native platform peer object.

Components appear on the GUI display, so users can interact with them. User actions such as clicking a button, scrolling a scrollbar, typing in a text field, and so on generate events. Even though events are related to components, I do not cover events or how to handle them in this chapter. I devote Chapter 9, "Events and Event Handling," to this topic.

Without further ado, let's look at the basic AWT components.

Buttons

Buttons are simple components that can be clicked. A button can be created with a text label. In Chapter 9, you'll see that clicking a button creates an event to which your program can respond.

Listing 5.1 shows the source code that displays the GUI shown in Figure 5.1. Figure 5.1 shows three buttons with different visual states that represent the different possible visual states of all AWT buttons.

Notice that this application creates its third button with no label, but sets the label with the setLabel() method. There is also a complementary getLabel() method defined in the Button class.

Listing 5.1 The Different Possible States of a Button

import java.awt.Button;
import java.awt.Component;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Panel;
public class Buttons extends Panel
{
  /**
     No-arg constructor. Builds the entire visible GUI before 
     it returns.
  */
  public Buttons()
  {
    Font f18 = new Font("SansSerif", Font.PLAIN, 18);
    Button b1 = new Button("Enabled button");
    Button b2 = new Button("Disabled button");
    Button b3 = new Button();
    b3.setLabel("Depressed button");
    b1.setFont(f18);
    // The second button is initially disabled.
    //
    b2.setFont(f18);
    b2.setEnabled(false);
    b3.setFont(f18);
    add(b1);
    add(b2);
    add(b3);
  }
  public static void main(String [] args)
  {
    Buttons app = new Buttons();
    Frame f = new Frame("Buttons");
    f.add(app);
    f.pack();
    f.setVisible(true);
  }
}

FIGURE 5.1

Buttons are rendered differently depending on their state.

Table 5.1 lists the methods in the Button class that pertain to manipulating the button.

Table 5.1 Button Constructors and Methods

Also note that you did not have to set the visibility of your buttons so that they would appear on screen. Back in Chapter 3, you had to call setVisible(true) and pack() on your frames so that the application would appear on screen. To set a component's visibility to true means that the component should be visible when its parent is visible.

You only have to set visibility for top-level components such as frames. Other components, such as the ones I discuss in this chapter, are visible by default. They will appear on screen when their parent is made visible.

When a component is enabled, it can accept events. In Figure 5.1, the disabled button cannot accept events because it has been disabled.

Check Boxes

A check box is a component that can be either on or off, that is, either selected or not. You toggle a check box's state by clicking on it. Listing 5.2 shows how you can add some check boxes to a panel, and initialize them to be selected or not.

Listing 5.2 Standalone Check Boxes and Grouped Checkboxes

import java.awt.Checkbox;
import java.awt.CheckboxGroup;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Panel;
public class Checkboxes extends Panel
{
  /**
     No-arg constructor.  Builds the complete visible GUI 
     before it returns.
  */
  public Checkboxes()
  {
    setLayout(new GridLayout(2, 3));
    Font f18 = new Font("SansSerif", Font.PLAIN, 18);
    Font f14 = new Font("SansSerif", Font.PLAIN, 14);
    Checkbox c1 = new Checkbox("Checkbox 1");
    Checkbox c2 = new Checkbox();
    c2.setLabel("Checkbox 2");
    c2.setEnabled(false);
    Checkbox c3 = new Checkbox("Checkbox 3");
    // Create a CheckboxGroup object to manage the states of 
    // the second row of check boxes.  
    //
    CheckboxGroup group = new CheckboxGroup();
    Checkbox c4 = new Checkbox("Checkbox 4", group, true);
    Checkbox c5 = new Checkbox("Checkbox 5", group, true);
    Checkbox c6 = new Checkbox("Checkbox 6", group, true);
    // Make the text more readable.
    //
    c1.setFont(f18);
    c2.setFont(f18);
    c3.setFont(f18);
    c4.setFont(f18);
    c5.setFont(f18);
    c6.setFont(f18);
    add(c1);
    add(c2);
    add(c3);
    add(c4);
    add(c5);
    add(c6);
  }
  public static void main(String [] args)
  {
    Checkboxes app = new Checkboxes();
    Frame f = new Frame("Checkboxes");
    f.add(app);
    f.pack();
    f.setVisible(true);
  }
}

Figure 5.2 shows what this program's GUI looks like. The first row contains three check boxes that exist independently of each other. Any combination of them can be selected. The example shows numbers one and three selected, while number two is disabled.

The three checkboxes in the second row are part of a CheckboxGroup. You can see from Listing 5.2 that we added all of them to the group in their enabled state. CheckboxGroup objects are not visible; they serve only an organizational role. In the AWT, a group of check boxes can only have one member selected at any given time.

Also notice that the glyph for the two types of check boxes are different. The independent check boxes have square glyphs, whereas the check boxes that are part of a group have diamond shaped glyphs. This helps you determine their organization and membership.

The actual glyphs used may vary from platform to platform. It is the native peer which dictates the actual look of an AWT component. For example, Windows does not use the diamond glyph to display check boxes.

FIGURE 5.2

Check boxes can be organized in groups that allow only one to be selected at once.

Table 5.2 shows the methods in the Checkbox class.

Table 5.2 Checkbox Constructors and Methods

Choices

The Choice class gives you a way to create a pop-up menu of selections. A choice component looks somewhat like a button, but has a distinctive face. Clicking on a choice component drops down a type of menu (in appearance, but not the same as a real menu). You can select one of the elements in the choice object.

Listing 5.3 shows code that builds such a choice component and Figure 5.3 shows what a choice component looks like. Figure 5.4 shows the choice element when it is expanded.

Listing 5.3 Constructing a Choice Component and Adding Elements to It

import java.awt.Choice;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Panel;
public class Choices extends Panel
{
  public Choices()
  {
    Font f18 = new Font("SansSerif", Font.PLAIN, 18);
    Font f14 = new Font("SansSerif", Font.PLAIN, 14);
    // Create a choice object and add the string items to it.
    // 
    Choice c = new Choice();
    c.addItem(new String("Albinoni"));
    c.addItem(new String("Bach"));
    c.addItem(new String("Beethoven"));
    c.addItem(new String("Brahms"));
    c.addItem(new String("Chopin"));
    c.addItem(new String("Debussey"));
    c.addItem(new String("Gluck"));
    c.addItem(new String("Kachaturian"));
    c.addItem(new String("Mahler"));
    c.setFont(f18);
    add;
  }
  public Dimension getPreferredSize()
  {
    return new Dimension(175, 300);
  }
  public static void main(String [] args)
  {
    Choices app = new Choices();
    Frame f = new Frame("Choices");
    f.add(app);
    f.pack();
    f.setVisible(true);
  }
}

FIGURE 5.3

Choice components let you choose one of a list of choices.

FIGURE 5.4

A choice component after the user has clicked on it.

Table 5.3 shows the constructor and methods of the Choice class.

Table 5.3 Choice Class Constructors and Methods

Dialogs

So far the components you've seen have been direct subclasses of java.awt.Component. Dialogs, however, are direct subclasses of java.awt.Window. A dialog is a window that can be displayed independently of the main window of your application. Dialogs, like frames, have a border and menu bar.

There are some differences between dialogs and frames. Each dialog must have an associated frame, which is its owner. For instance, the main frame of your application might be the owner of any dialog it pops up.

If the associated frame is made into an icon or terminated, any associated dialogs will disappear from the screen. Redisplaying (restoring) the main window will also redisplay any dialogs that were open when the window was minimized.

Dialogs can be modal, which means that the user must dismiss the displayed dialog before interacting with any other part of the application that owns the dialog. Typically, a dialog will have a do and cancel button or equivalents.

Listing 5.4 shows a dialog box in action. Clicking on the button in the main frame of the application will bring up a dialog box. Notice that a reference to the main application frame is passed to the Dialog constructor, specifying the dialog's owner.

Don't worry about any event handling code in this application that looks foreign right now. You will learn about event handling in Chapter 9.

Listing 5.4 Creating a Dialog From a Parent Frame

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Dialog;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/**
   Defines a simple frame.  The dialog created by this
   example must have an associated frame.  An instance of
   this class provides that frame.
   <p> We don't need to specify a getPreferredSize() method
   because we are adding a button to the frame.  The size
   required by the button will be the minimum size allocated
   for the frame.
*/
public class DialogExample extends Frame implements ActionListener
{
  /**
     Constructor. Creates an instance of a frame with a
     button. Pressing the button brings up a dialog.  
     @param title the title of the frame, not the dialog.
  */
  public DialogExample(String title)
  {
    super(title);
    Font f18 = new Font("SansSerif", Font.PLAIN, 18);
    Font f14 = new Font("SansSerif", Font.PLAIN, 14);
    Button b = new Button("Bring up dialog");
    b.setFont(f18);
    b.addActionListener(this);
    Panel p = new Panel();
    p.add;
    add(p);
  }
  public void actionPerformed(ActionEvent e)
  {
    d = new CustomDialog(this, "Make a decision", true);
    d.setVisible(true);
  }
  public static void main(String [] args)
  {
    DialogExample app = new DialogExample("Dialog Example");
    app.pack();
    app.setVisible(true);
  }
  Dialog d; 
}
/**
   Creates a dialog box.  Dialog boxes must be associated
   with a frame.
*/
class CustomDialog extends Dialog
{
  /**
     Constructor.  Builds a dialog box.  A reference to a
     frame is required to create a dialog.
     @param parent the associated parent frame of this dialog.
     @param title this dialog's title.
     @param modal the behavior of the
     dialog. <code>true</code> means modal, otherwise it's
     non-modal.
  */
  CustomDialog(Frame parent, String title, boolean modal)
  {
    super(parent, title, modal);
    Panel p1 = new Panel(new FlowLayout(FlowLayout.LEFT));
    Label question = new Label("And now what?");
    question.setFont(new Font("SansSerif", Font.PLAIN, 18));
    p1.add(question);
    add(p1, BorderLayout.CENTER);
    Panel p2 = new Panel(new FlowLayout(FlowLayout.RIGHT));
    dontknow = new Button("Don't know");
    dontknow.setFont(new Font("SansSerif", Font.PLAIN, 18));
    cancel = new Button("Cancel");
    cancel.setFont(new Font("SansSerif", Font.PLAIN, 18));
    p2.add(dontknow);
    p2.add(cancel);
    add(p2, BorderLayout.SOUTH);
    pack();
  }
  Button dontknow;
  Button cancel;
}

Figure 5.5 displays the main frame and the dialog box that appears after clicking the frame's button. Table 5.4 lists the methods of the Dialog class.

FIGURE 5.5

Dialogs appear in their own native platform frame.

Table 5.4 Dialog Class Constructors and Methods

Labels

Labels are components that contain a simple text string that can appear in a container. Labels are not selectable like the text in text fields or text areas, which I will introduce in the following section. However, because labels are bona fide components, they can be placed in containers like any other component.

You can set the lateral alignment of a label's text to specify that it be anchored at the left, center or right of the area allocated for the label's layout. The valid values for specifying the label's anchor position are the constants Label.LEFT, Label.CENTER, or Label.RIGHT.

Listing 5.5 shows the source code for the program that creates Figure 5.6. Figure 5.6 shows the GUI produced by the program in Listing 5.5. The left column labels are right justified and the right column labels are left justified. The position of the label text doesn't represent the extend of the area allocated for the label component. Most likely, the bounds of the label extends beyond the left edge of the text for right-justified text, and beyond the right edge for left-justified text.

Listing 5.5 Program That Demonstrates Labels With Different Alignments

import java.awt.Choice;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
/**
   Creates a panel of labels with various alignments.  No
   getPreferredSize() method is needed.  The layout manager
   will call the inherited version.  The size of the panel
   will be at least the size required to lay out all of the
   labels that are children of the panel.
*/
public class Labels extends Panel
{
  /**
     No-arg constructor.  
  */
  public Labels()
  {
    Font f18 = new Font("SansSerif", Font.PLAIN, 18);
    Font f14 = new Font("SansSerif", Font.PLAIN, 14);
    // This label's text is aligned to the right edge of its
    // display area.
    Label name = new Label("Name :  ");
    name.setAlignment(Label.RIGHT);
    name.setFont(f14);
    // This label's text is aligned to the left edge of its
    // display area.
    Label nameVal = new Label("Jim Morrison");
    nameVal.setAlignment(Label.LEFT);
    nameVal.setFont(f14);
    Label address = new Label("Address :  ");
    address.setAlignment(Label.RIGHT);
    address.setFont(f14);
    Label addVal = new Label("Cimetiere Pere LaChese");
    addVal.setAlignment(Label.LEFT);
    addVal.setFont(f14);
    Label city = new Label("City/State/Zip :  ");
    city.setAlignment(Label.RIGHT);
    city.setFont(f14);
    Label cityVal = new Label("Paris, France Cedex 01432");
    cityVal.setAlignment(Label.LEFT);
    cityVal.setFont(f14);
    Label phone = new Label("Phone :  ");
    phone.setAlignment(Label.RIGHT);
    phone.setFont(f14);
    Label phoneVal = new Label("213-555-1212");
    phoneVal.setAlignment(Label.LEFT);
    phoneVal.setFont(f14);
    Panel p = new Panel();
    p.setLayout(new GridLayout(0, 2));
    p.add(name);
    p.add(nameVal);
    p.add(address);
    p.add(addVal);
    p.add(city);
    p.add(cityVal);
    p.add(phone);
    p.add(phoneVal);
    add(p);
  }
  public static void main(String [] args)
  {
    Labels app = new Labels();
    Frame f = new Frame("Labels");
    f.add(app);
    f.pack();
    f.setVisible(true);
  }
}
Label name = new Label("Name :  ");
    name.setAlignment(Label.RIGHT);
    Label nameVal = new Label("Jim Morrison");
    nameVal.setAlignment(Label.LEFT);
    Label address = new Label("Address :  ");
    address.setAlignment(Label.RIGHT);
    Label addVal = new Label("Cimetiere Pere LaChese");
    addVal.setAlignment(Label.LEFT);
    Label city = new Label("City/State/Zip :  ");
    city.setAlignment(Label.RIGHT);
    Label cityVal = new Label("Paris, France Cedex 01432");
    cityVal.setAlignment(Label.LEFT);
    Label phone = new Label("Phone :  ");
    phone.setAlignment(Label.RIGHT);
    Label phoneVal = new Label("213-555-1212");
    phoneVal.setAlignment(Label.LEFT);
    Panel p = new Panel();
    p.setLayout(new GridLayout(0, 2));
    p.add(name);
    p.add(nameVal);
    p.add(address);
    p.add(addVal);
    p.add(city);
    p.add(cityVal);
    p.add(phone);
    p.add(phoneVal);
    add(p);

FIGURE 5.6

Labels are simple components that display a string of text. They can be manipulated just like other components.

Table 5.5 shows the constructors and methods of the Label class.

Table 5.5 Dialog Class Constructors and Methods

Lists

Lists are groups of items that are formatted inside of a kind of scrolling pane. The list can be scrolled up and down in order to see all its elements. The list gives you a window in which to view some subset of the list elements.

Lists can be single selection or multiple selection, which means, respectively, that only one, or multiple items can be selected simultaneously. Selected elements can be retrieved from a list component and used for various purposes by your application.

Listing 5.6 shows a program that creates a list in a container. Don't worry about any code that looks unfamiliar; I will get to it soon enough.

The GUI created by this program is shown in Figure 5.7. The left-hand list of Figure 5.7 uses a single selection model, while the right-hand list uses a multiple selection model.

Listing 5.6 Program That Demonstrates Single and Multiple Selection Lists

import java.awt.Choice;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
import java.awt.Insets;
import java.awt.Label;
import java.awt.List;
import java.awt.Panel;
/**
   A class that creates two juxtaposed lists.  The left-hand
   list only supports the selection of a single item.  The
   right-hand list supports the selection of multiple items.
   Again, no getPreferredSize() method is needed.
*/
public class Lists extends Panel
{
  /**
     No-arg constructor.
  */
  public Lists()
  {
    Font f18 = new Font("SansSerif", Font.PLAIN, 18);
    Font f14 = new Font("SansSerif", Font.PLAIN, 14);
    Label single = new Label("A single selection list");
    single.setFont(f14);
    // The single selection list.
    //
    List singleList = new List(6, false);
    singleList.setFont(f14);
    singleList.add(new String("Ludwig von Beethoven"));
    singleList.add(new String("Lee Ritenaur"));
    singleList.add(new String("Thelonious Monk"));
    singleList.add(new String("Elton John"));
    singleList.add(new String("Julio Eglesias"));
    singleList.add(new String("Benny Goodman"));
    Label multiple = new Label("A multiple selection list");
    multiple.setFont(f14);
    // The multiple selection list.
    //
    List multipleList = new List(6);
    multipleList.setMultipleMode(true);
    multipleList.setFont(f14);
    multipleList.add(new String("Classical"));
    multipleList.add(new String("Pop"));
    multipleList.add(new String("Rock"));
    multipleList.add(new String("Swing"));
    multipleList.add(new String("Jazz"));
    GridBagLayout gbl = new GridBagLayout();
    GridBagConstraints gbc = new GridBagConstraints();
    setLayout(gbl);
    gbl.setConstraints(single, gbc);
    add(single);
    gbc.insets = new Insets(5, 5, 5, 5);
    gbc.gridx = GridBagConstraints.RELATIVE;
    gbl.setConstraints(multiple, gbc);
    add(multiple);
    gbc.gridx = 0;
    gbc.gridy = GridBagConstraints.RELATIVE;
    gbl.setConstraints(singleList, gbc);
    add(singleList);
    gbc.gridx = GridBagConstraints.RELATIVE;
    gbc.gridy = 1;
    gbl.setConstraints(multipleList, gbc);
    add(multipleList);
  }
  public static void main(String [] args)
  {
    Lists app = new Lists();
    Frame f = new Frame("Lists");
    f.add(app);
    f.pack();
    f.setVisible(true);
  }
}
Label single = new Label("A single selection list");
    single.setFont(f14);
    List singleList = new List(6, false);
    singleList.setFont(f14);
    singleList.add(new String("Ludwig von Beethoven"));
    singleList.add(new String("Lee Ritenaur"));
    singleList.add(new String("Thelonious Monk"));
    singleList.add(new String("Elton John"));
    singleList.add(new String("Julio Eglesias"));
    singleList.add(new String("Benny Goodman"));
    Label multiple = new Label("A multiple selection list");
    multiple.setFont(f14);
    List multipleList = new List(6);
    multipleList.setMultipleMode(true);
    multipleList.setFont(f14);
    multipleList.add(new String("Classical"));
    multipleList.add(new String("Pop"));
    multipleList.add(new String("Rock"));
    multipleList.add(new String("Swing"));
    multipleList.add(new String("Jazz"));
    GridBagLayout gbl = new GridBagLayout();
    GridBagConstraints gbc = new GridBagConstraints();
    setLayout(gbl);
    gbl.setConstraints(single, gbc);
    add(single);
    gbc.insets = new Insets(5, 5, 5, 5);
    gbc.gridx = GridBagConstraints.RELATIVE;
    gbl.setConstraints(multiple, gbc);
    add(multiple);
    gbc.gridx = 0;
    gbc.gridy = GridBagConstraints.RELATIVE;
    gbl.setConstraints(singleList, gbc);
    add(singleList);
    gbc.gridx = GridBagConstraints.RELATIVE;
    gbc.gridy = 1;
    gbl.setConstraints(multipleList, gbc);
    add(multipleList);
  }

Figure 5.7 shows an example of a list.

FIGURE 5.7

Lists give you a way to aggregate strings. They can support both single and multiple selection behavior.

Table 5.6 lists most of the methods in the List class. Again, I omit methods related to event handling at this time.

Table 5.6 List Constructors and Methods

Menus

Menus are elements that are included as members of menu bars. A menu bar can be placed on a frame. The frame manages its location and layout.

Menus display a list of member menu items when clicked. Selecting the menu item usually results in some action performed by the application. These components behave as their counterparts in other window programming environments.

Menus contain menu items. These two elements are defined by the Menu and MenuItem classes. Menu bars are defined by the MenuBar class.

Menu items can be either simple labels, separators--simply horizontal lines that separate menu items--or other menus. Listing 5.7 shows the program that creates some menus on a menu bar. The menu bar is attached to a frame. The GUI is shown in Figure 5.8.

You can see examples of all the types of menu items, simple labels, separators, and other menus that produce walking menus.

Listing 5.7 Program Which Demonstrates How to Use Menus and Menu Items

View Code

FIGURE 5.8

Menus can contain menu items, which include other menus. This allows menus to be organized in a cascading or walking menu structure.

The program that displays this frame and its menus is shown in Listing 5.7.

In this example, I created three menus and added some menu items to the help menu. The help menu contains another menu, which contains additional menu items.

The capability for menus to contain other menus allows you to create walking or cascading menus. In order for this to be possible, menus must be a type of menu item. The relationship between the Menu and MenuItem classes makes this possible. This relationship follows a pattern that you've seen before. The relationship between the Component and Container classes is conceptually the same.

---

NOTE: Notice the similarity between the relationship shared by the Menu and MenuItem classes, and the relationship shared by the Component and Container classes. Both relationships exhibit the same pattern, namely, one that defines a recursive structure.

In fact, this pattern has been given the name Composite in a popular text that identifies and names patterns that occur commonly in object-oriented design and programming. See Gamma, E. et al, Design Patterns, Addison-Wesley, C. 1995.
Chapter 10, "The Swing Model Architecture," will discuss how to recognize patterns by identifying the underlying abstraction.

---

Figure 5.9 shows the UML static class diagram for the relationship between the Menu and MenuItem classes.

FIGURE 5.9

Menus are menu items, allowing menus to include other menus as their items.

From Figure 5.9 you can see that menus and menu items are somewhat different from other components. Technically, they are not components because they do not extend the Component class. Yet, effectively, they are components in terms of their behavior.

Notice in Figure 5.9 the MenuComponent class. Its presence defines both menus and menu items to be a type of menu component. This class defines attributes and behavior common to all types of menu components.

The reason that the menu classes don't belong to the normal component hierarchy is that they cannot always be treated as true components. For instance, you cannot add a menu to an arbitrary container in your program. So, even though they appear to function like components, they are different in some important ways. In Chapter 7, "The Swing Components," you will see that menus are defined much more flexibly in Swing.

---

CAUTION: Beware that the model for menus and menu items changes in Swing. You should anticipate this if you plan to program in AWT now but later convert your program to use Swing menu components.
Unlike the AWT menu components, Swing menu components are true components. This makes it much more flexible for you to use them in more places within your GUI.

---

Table 5.7 lists the constructors and methods of the Menu class.

Table 5.7 The Menu Class Constructors and Methods

Menus support adding, removing, and inserting menu items that include other menus and separators that help make the menus more readable. You can define a menu to be a "tear-off" menu, which means it will be rendered in a window detached from the frame that contains the menu bar to which the menu belongs.

Table 5.8 lists the constructors and methods of the MenuItem class.

Table 5.8 The MenuItem Class Constructors and Methods

Most of the behavior that you will use is defined in the Menu and MenuItem classes. However, the MenuComponent class defines the common behavior for all menu related types, including MenuBars.

Table 5.9 lists the constructors and methods of the MenuComponent class.

Table 5.9 The MenuComponent Class Constructors and Methods

The MenuComponent class is abstract, so you can't instantiate it. It's purpose is to define common attributes and methods related to all menu classes. From Figure 5.9, you can see that Menus, MenuItems, and MenuBars are all subclasses of MenuComponent.

From Table 5.10, and from the source code in Listing 5.7, you can see that help menus are treated differently from other menus. The MenuBar class interprets a help menu as the menu to be placed to the far right side of the menu bar. You need to specify such a menu by using the setHelpMenu() method. Simply adding menus by using the add() method will add the menus from left to right, always starting at the left hand side, and treat them like regular menus.

Table 5.10 The MenuBar Class Constructors and Methods

Text Areas and Text Fields

Text components are components that store and display text which can be selected and altered. Text components support a number of features including text insertion, editing, selection, and deletion.

The text component classes are subclasses of the TextComponent class, which defines attributes and behavior that is applicable to all text components. The TextComponent class supports text selection, caret positioning, text setting, and toggling of the component's editable state because these features are common to both text fields and text areas.

The AWT defines two types of text components. A text area is a multi-line, multicolumn component that supports typing in its display area. Text fields are similar except that they support only one line of text. Because these two types are so closely related, I will discuss them together.

The TextField and TextArea classes define an echo character. An echo character can be specified as the one that is echoed when the user types in the text field or text area. This is useful for fields such as password fields that want to hide the user's key strokes. For example, a password field could set the echo character to a space or asterisk.

Listing 5.8 shows a program that creates a container that includes various text components. Figure 5.10 shows some text fields and a text area created by the program in Listing 5-8.

Notice in Figure 5.10 that the name text field is gray instead of white like the others. The program disables this field. When a field is not editable, the peer component changes the color to gray. This behavior, of course, is dictated by the peer class and not by the text field. Another peer implementation could define a different policy for representing disabled fields. Text areas work the same way incidentally.

Listing 5.8 Program Which Demonstrates Use of the Different Text Component Classes

View Code

FIGURE 5.10

Text areas and text fields are text components that support a variety of text entry and editing functions.

From Tables 5.11-5.13, you can see which classes define which methods.

Table 5.11 shows the constructors and methods of the TextComponent class. You can tell that these methods do represent functions that are common to both TextArea and TextField objects.

Table 5.11 The TextComponent Class Constructors and Methods

Among other things, the TextField and TextArea classes must present methods to set and get their minimum and preferred sizes, based on the number of columns for text areas, and the number of rows and columns for text fields. This behavior is specific to each type of component and is, therefore, overridden from the TextComponent class.

Table 5.12 The TextArea Class Constructors and Methods

Table 5.13 The TextField Class Constructors and Methods

Summary

The java.awt package contains the AWT component classes. Many of these have visual representations and define standard metaphors such as buttons, lists, text fields, and so on.

All the AWT components have heavyweight implementations, which means each instance creates a native peer window object.

You can use these components to build GUI applications. Components can be organized in a variety of configurations to meet the needs of each application. Additional containers like Panels can be used to nest components so that it becomes easier for you to organize and manage the components in your GUI.

Although you can write non-trivial applications using only the AWT components, you are encouraged to use the Swing set of visual components instead. Chapter 7 introduces the Swing components.

Before you look at the Swing components, you need to understand the concepts that surround the Swing component set. The Swing components introduce some new abstractions not found in the AWT components. Therefore, the next chapter introduces the concepts that surround Swing. You will then be ready to tackle the Swing components.