THE JAVA ABSTRACT WINDOWING TOOLKIT (AWT)

Overview

Here is a new version of the "Hello World" program. Rather than writing to the screen, this version opens a new window and displays "Hello World!" in that window.

import java.awt.*;

public class HelloWorld extends Frame {
    private Label text;

    // constructor
    public HelloWorld() {

	// create a label containing "Hello World!", with the text centered
	text = new Label("Hello World!", Label.CENTER);

	// add the label to the Frame
	add(text);

	// set the size of the frame and make it visible
	setSize( 300, 100 );
	setVisible( true );
    }

    // main
    public static void main( String[] args ) {
	new HelloWorld();
    }
}

Things to note:

Example Using Listeners

Below is another version of the HelloWorld program (called Hello1) that demonstrates more of the power of the AWT. This program creates a Frame with two sub-components:

1. A label containing "Hello World!" as before.
2. A button labeled "exit". When the user clicks this button with the mouse, the program halts, and the new window is closed.

import java.awt.*;
import java.awt.event.*;

public class Hello1 extends Frame {
    private Label text;
    private Button exitButton;

    // constructor
    public Hello1() {

	// create a label containing "Hello World!", with the text centered
	// and add the label to the top of the Frame
	text = new Label("Hello World!", Label.CENTER);
	add(text, "North");

	// create the exit button and add it to the bottom of the Frame
	exitButton = new Button("exit");
	add(exitButton, "South");

	// create a listener for the exit button that will cause a
	// reaction when the button is clicked (using the mouse), and
	// associate that listener with the exit button
	ExitButtonListener exitListener = new ExitButtonListener();
	exitButton.addActionListener(exitListener);
	
	// set the size of the frame and make it visible
	setSize( 300, 100 );
	setVisible( true );
    }

    // define the listener for the exit button
    class ExitButtonListener implements ActionListener {
	public void actionPerformed(ActionEvent e) {
	    // this method will be called when the exit button is clicked;
	    // end execution of this program
	    System.exit(0);
	}
    }

    // main
    public static void main( String[] args ) {
	new Hello1();
    }
}

Listeners

When you write a Graphical User Interface, you usually want your program to respond to user actions, like pushing a button or typing in text. The mechanism that the Java AWT provides to support this is the creation of Listeners, which have methods that are invoked in response to user actions. Each component can have an associated Listener of the appropriate type that will respond to user actions involving that component.

Example Using Layout

Below is a more complicated example program. This program creates a Frame with three sub-components:

1. A Label, containing the string "This text will change font".
2. A List, containing three items: the strings "bold", "italic", and "bold italic".
3. A Panel, which in turn contains two sub-components, both Buttons (a "reset font" button and an "exit" button).

Selecting one of the List items (by clicking on it with the mouse) causes the text in the Label to change to the corresponding font. Clicking on the "reset font" button causes the text to change back to plain font. Clicking on the "exit" button terminates the program.

import java.awt.*;
import java.awt.event.*;

public class ChangeFont extends Frame {
    private Font plainFont, boldFont, italicFont, boldItalicFont;
    private List fontList;
    private Panel buttonPanel;
    private Button resetButton, exitButton;
    private Label msgLabel;
    
    // constructor
    public ChangeFont() {

	// create the actual fonts to be used
	plainFont = new Font("plain", Font.PLAIN, 10);
	boldFont = new Font("bold", Font.BOLD, 10);
	italicFont = new Font("italic", Font.ITALIC, 10);
	boldItalicFont = new Font("bolditalic", Font.BOLD + Font.ITALIC, 10);

	// create the Label whose font will change and add it at the
	// top of the Frame
	msgLabel = new Label("This text will change font");
	msgLabel.setFont(plainFont);
	add(msgLabel, "North");

	// create the List of fonts and add it in the middle of the Frame
	fontList = new List();
	fontList.add("bold");
	fontList.add("italic");
	fontList.add("bold italic");
	add(fontList, "Center");

	// create the reset and exit buttons
	resetButton = new Button("reset font");
	exitButton = new Button("exit");

	// create a panel to hold the two buttons;
	// put the buttons on the panel and add the panel to the bottom of
	// the Frame
	buttonPanel = new Panel();
	buttonPanel.setLayout(new GridLayout(1,2));
	buttonPanel.add(resetButton);
	buttonPanel.add(exitButton);
	add(buttonPanel, "South");

	// create listeners for the list of fonts and for the two buttons
	ResetButtonListener resetListener = new ResetButtonListener();
	ExitButtonListener exitListener = new ExitButtonListener();
	ListItemListener listListener = new ListItemListener();
	
	// use the addXXXListener methods of the font list and the buttons
	// to associate each listener with the appropriate object
	resetButton.addActionListener(resetListener);
	exitButton.addActionListener(exitListener);
	fontList.addItemListener(listListener);

	// arrange the components in the Frame and make it visible
	pack();
	setVisible(true);
    }

    class ResetButtonListener implements ActionListener {
	public void actionPerformed(ActionEvent e) {
	    // this method will be called when the reset button is clicked;
	    // change the font back to plain
	    msgLabel.setFont(plainFont);
	}
    }

    class ExitButtonListener implements ActionListener {
	public void actionPerformed(ActionEvent e) {
	    // this method will be called when the exit button is clicked;
	    // end execution of this program
	    System.exit(0);
	}
    }

    class ListItemListener implements ItemListener {
	public void itemStateChanged(ItemEvent e) {
	    // this method will be called when one item on the list is
	    // selected using the mouse;
	    // get the selected list item and set the label's font accordingly
	    String S = fontList.getSelectedItem();
	    if (S.equals("bold")) {
		msgLabel.setFont(boldFont);
	    }
	    else if (S.equals("italic")) {
		msgLabel.setFont(italicFont);
	    }
	    else if (S.equals("bold italic")) {
		msgLabel.setFont(boldItalicFont);
	    }
	}
    }

    public static void main(String [] args) {
	new ChangeFont();
    }
}

This example uses more components, uses Listeners more extensively, and also introduces layouts, discussed below. First, though, consider the following issue, brought up by this example:

If you have several components of the same type (e.g., several Buttons) and you want to respond to user actions involving each of those components, you have two choices:

1. Write a different Listener for each component, specialized to respond to user actions on that particular component. This is the approach that was taken in the ChangeFont program, where two different ActionListeners were defined for the two buttons (the "reset font" button and the "exit" button).

2. Write a single Listener for all of the components. In the method that is called in response to a user action, determine which component was actually involved, and respond accordingly. Each Listener method (actionPerformed, itemStateChanged, and textValueChanged) has a parameter that is a subclass of the class java.util.EventObject. This class includes the method getSource, which returns the actual object to which the user action was applied. For example, the following ActionListener could be associated with both the "reset font" and the "exit" buttons:

          
       class ButtonListener implements ActionListener {
   	public void actionPerformed(ActionEvent e) {
   	    // determine which button was clicked and do the right thing
   	    Object source = e.getSource();
   	    if (source == resetButton) msgLabel.setFont(plainFont);
   	    else System.exit(0);
   	}
       }
          

Layouts

Frames and Panels are both subclasses of the Container class. These classes can contain sub-components (like Buttons, Lists, and Panels), and they have associated layout mechanisms (schemes for organizing their sub-components).

There are 5 kinds of layouts (only the first 3 will be discussed here):

1. Border Layouts
2. Flow Layouts
3. Grid Layouts
4. Grid-Bag Layouts
5. Card Layouts

 +----------------------+
 |                      |
 |         North        |
 |                      |
 +----------------------+
 |      |        |      |
 | West | Center | East |
 |      |        |      |
 +----------------------+
 |                      |
 |         South        |
 |                      |
 +----------------------+

A container that uses the Flow Layout can contain any number of sub-components. They are organized in rows across the container. If there is not enough room for all of the sub-components in a single row, then a second row is started, etc. Whether the items in an incomplete row are left-justified, right-justified, or centered can be specified when the Flow Layout is selected (see below). The Flow Layout is the default layout for Panels.

The sub-components in a Grid Layout are organized into an N-by-M grid, where N and M are specified when the Grid Layout is selected. When a component is added to a container using the Grid Layout, it goes into the next column of the current row (or the first column of the next row if the current row is full); it is not possible to leave empty spaces or to add components out of order.

A particular layout is selected for a container using the container's setLayout method. The argument to setLayout is a LayoutManager object. For example, the statement:

buttonPanel.setLayout(new GridLayout(1,2));

buttonPanel.setLayout(new FlowLayout( FlowLayout.CENTER ));

Graphics

Java.awt also provides support for simple graphics. In particular, every component has a paint method, which is called to display the component on the screen. It is possible to redefine the paint method for any class that extends a component class. For example, here is a program that defines the class Draw as a subclass of Frame, and redefines the paint method to draw a stick figure:

import java.awt.*;

public class Draw extends Frame {

    // constructor
    public Draw() {

	// set the size of the frame and make it visible
	setSize( 300, 300 );
	setVisible( true );
    }


    public void paint(Graphics g) {
	g.setColor(Color.red);
	g.fillArc(150, 40, 20, 20, 0, 360);
	g.drawLine(160, 60, 160, 110);
	g.drawLine(160, 110, 145, 160);
	g.drawLine(160, 110, 175, 160);
	g.drawLine(130, 75, 190, 75);
	g.setColor(Color.green);
	g.drawString("This is George", 110, 180);
    }

    // main
    public static void main( String[] args ) {
	new Draw();
    }
}

As mentioned above, you can redefine the paint method of any subclass of a Component. So, for example, you could create a button with the stick figure on it (in addition to the button label) by defining a subclass of Button, and redefining its paint method:

import java.awt.*;

class MyButton extends Button {

    // 1-arg constructor: s is the button label
    public MyButton(String s) {
	super(s);
    }

    public void paint(Graphics g) {
	g.setColor(Color.red);
	g.fillArc(150, 20, 20, 20, 0, 360);
	g.drawLine(160, 40, 160, 90);
	g.drawLine(160, 90, 145, 140);
	g.drawLine(160, 90, 175, 140);
	g.drawLine(130, 55, 190, 55);
    }
}

public class PaintButton extends Frame {
    private MyButton b = new MyButton("George");

    // constructor
    public PaintButton() {
	// add the button
	add(b);

	// set the size of the frame and make it visible
	setSize( 300, 300 );
	setVisible( true );
    }

    // main
    public static void main( String[] args ) {
	new PaintButton();
    }
}

Question 1.

// modified HelloWorld program that writes the (single) command-line arg
// instead of writing Hello World!

import java.awt.*;

public class HelloWorld1 extends Frame {
    private Label text;

    // constructor
    public HelloWorld1(String arg) {

        // create a label containing "Hello World!", with the text centered
        text = new Label(arg, Label.CENTER);

        // add the label to the Frame
        add(text);

        // set the size of the frame and make it visible
        setSize( 300, 100 );
        setVisible( true );
    }

    // main
    public static void main( String[] args ) {
        new HelloWorld1(args[0]);
    }
}

Question 2.

// modified HelloWorld program in which the background color is red
// and the color of the text is blue

import java.awt.*;

public class HelloWorld2 extends Frame {
    private Label text;

    // constructor
    public HelloWorld2() {

	// create a label containing "Hello World!", with the text centered
	text = new Label("Hello World!", Label.CENTER);

	// set the background and foreground colors of the label
	text.setBackground(Color.red);
	text.setForeground(Color.blue);

	// add the label to the Frame
	add(text);

	// set the size of the frame and make it visible
	setSize( 300, 100 );
	setVisible( true );
    }

    // main
    public static void main( String[] args ) {
	new HelloWorld2();
    }
}

// modified Hello1 program that includes a TextField instead of a Label, and
// a "reset" button to change the displayed text back to "Hello World!"
import java.awt.*;
import java.awt.event.*;

public class Hello1 extends Frame {
    private TextField text;
    private Button resetButton;

    
    // constructor
    public Hello1() {

	// create a TextField containing "Hello World!",
        // and add it to the top of the Frame
        text = new TextField("Hello World!");
        add(text, "North");

	// create the reset button and add it to the bottom of the Frame
	resetButton = new Button("reset");
	add(resetButton, "South");

	// create a listener for the reset button, and associate that
	// listener with the reset button
	ResetButtonListener resetListener = new ResetButtonListener();
	resetButton.addActionListener(resetListener);
       
        // set the size of the frame and make it visible
        setSize( 300, 100 );
	setVisible(true);
    }

    // define the listener for the reset button
    class ResetButtonListener implements ActionListener {
	public void actionPerformed(ActionEvent e) {
	    // this method will be called when the reset button is clicked;
	    // change the text back to "Hello World!"
	    text.setText("Hello World!");
	}
    }

    public static void main(String [] args) {
	new Hello1();
    }
}

Question 1.

// modified ChangeFont program that uses a Flow Layout for the Frame
// instead of the default Border Layout
import java.awt.*;
import java.awt.event.*;

public class ChangeFont1 extends Frame {
    private Font plainFont, boldFont, italicFont, boldItalicFont;
    private List fontList;
    private Panel buttonPanel;
    private Button resetButton, exitButton;
    private Label msgLabel;
    
    // constructor
    public ChangeFont1() {

	// give this frame a Flow Layout
	setLayout( new FlowLayout(FlowLayout.LEFT));

	// create the actual fonts to be used
	plainFont = new Font("plain", Font.PLAIN, 10);
	boldFont = new Font("bold", Font.BOLD, 10);
	italicFont = new Font("italic", Font.ITALIC, 10);
	boldItalicFont = new Font("bolditalic", Font.BOLD + Font.ITALIC, 10);

	// create the Label whose font will change and add it to the frame
	msgLabel = new Label("This text will change font");
	msgLabel.setFont(plainFont);
	add(msgLabel);

	// create the List of fonts and add it to the Frame
	fontList = new List();
	fontList.add("bold");
	fontList.add("italic");
	fontList.add("bold italic");
	add(fontList);

	// create the reset and exit buttons
	resetButton = new Button("reset font");
	exitButton = new Button("exit");

	// create a panel to hold the two buttons;
	// put the buttons on the panel and add the panel to the Frame
	buttonPanel = new Panel();
	buttonPanel.setLayout(new GridLayout(1,2));
	buttonPanel.add(resetButton);
	buttonPanel.add(exitButton);
	add(buttonPanel);

	// create listeners for the list of fonts and for the two buttons
	ResetButtonListener resetListener = new ResetButtonListener();
	ExitButtonListener exitListener = new ExitButtonListener();
	ListItemListener listListener = new ListItemListener();
	
	// use the addXXXListener methods of the font list and the buttons
	// to associate each listener with the appropriate object
	resetButton.addActionListener(resetListener);
	exitButton.addActionListener(exitListener);
	fontList.addItemListener(listListener);

	// arrange the components in the Frame and make it visible
	pack();
	setVisible(true);
    }

    class ResetButtonListener implements ActionListener {
	public void actionPerformed(ActionEvent e) {
	    // this method will be called when the reset button is clicked;
	    // change the font back to plain
	    msgLabel.setFont(plainFont);
	}
    }

    class ExitButtonListener implements ActionListener {
	public void actionPerformed(ActionEvent e) {
	    // this method will be called when the exit button is clicked;
	    // end execution of this program
	    System.exit(0);
	}
    }

    class ListItemListener implements ItemListener {
	public void itemStateChanged(ItemEvent e) {
	    // this method will be called when one item on the list is
	    // selected using the mouse;
	    // get the selected list item and set the label's font accordingly
	    String S = fontList.getSelectedItem();
	    if (S.equals("bold")) {
		msgLabel.setFont(boldFont);
	    }
	    else if (S.equals("italic")) {
		msgLabel.setFont(italicFont);
	    }
	    else if (S.equals("bold italic")) {
		msgLabel.setFont(boldItalicFont);
	    }
	}
    }

    public static void main(String [] args) {
	new ChangeFont1();
    }
}

Question 2.

// modified ChangeFon program that uses checkboxes instead of a list to
// display the font choices

import java.awt.*;
import java.awt.event.*;

public class ChangeFont2 extends Frame {
    private Font plainFont, boldFont, italicFont, boldItalicFont;
    private Panel buttonPanel;
    private Panel fontPanel;
    private Button resetButton, exitButton;
    private Label msgLabel;
    private CheckboxGroup checkBoxes;
    private Checkbox boldBox, italicBox, boldItalicBox;
    
    // constructor
    public ChangeFont2() {

	// create the actual fonts to be used
	plainFont = new Font("plain", Font.PLAIN, 10);
	boldFont = new Font("bold", Font.BOLD, 10);
	italicFont = new Font("italic", Font.ITALIC, 10);
	boldItalicFont = new Font("bolditalic", Font.BOLD + Font.ITALIC, 10);

	// create the Label whose font will change and add it at the
	// top of the Frame
	msgLabel = new Label("This text will change font");
	msgLabel.setFont(plainFont);
	add(msgLabel, "North");

	// create a Panel to hold the CheckboxGroup
	// and add it in the middle of the Frame
	fontPanel = new Panel();
	add(fontPanel, "Center");

	// create the CheckboxGroup and its Checkboxes
	// all Checkboxes are initially "off" (unpushed)
	checkBoxes = new CheckboxGroup();
	boldBox = new Checkbox("bold font", checkBoxes, false);
	italicBox = new Checkbox("italic font", checkBoxes, false);
	boldItalicBox = new Checkbox("bold italic font", checkBoxes, false);

	// add the Checkboxs to the Panel
	fontPanel.add(boldBox);
	fontPanel.add(italicBox);
	fontPanel.add(boldItalicBox);

	// create the reset and exit buttons
	resetButton = new Button("reset font");
	exitButton = new Button("exit");

	// create a panel to hold the two buttons;
	// put the buttons on the panel and add the panel to the bottom of
	// the Frame
	buttonPanel = new Panel();
	buttonPanel.setLayout(new GridLayout(1,2));
	buttonPanel.add(resetButton);
	buttonPanel.add(exitButton);
	add(buttonPanel, "South");

	// create listeners for the checkboxes and for the two buttons
	ResetButtonListener resetListener = new ResetButtonListener();
	ExitButtonListener exitListener = new ExitButtonListener();
	BoxListener boxListener = new BoxListener();
	
	// use the addXXXListener methods of the checkboxes and the buttons
	// to associate each listener with the appropriate object
	resetButton.addActionListener(resetListener);
	exitButton.addActionListener(exitListener);
	boldBox.addItemListener(boxListener);
	italicBox.addItemListener(boxListener);
	boldItalicBox.addItemListener(boxListener);

	// arrange the components in the Frame and make it visible
	pack();
	setVisible(true);
    }

    class ResetButtonListener implements ActionListener {
	public void actionPerformed(ActionEvent e) {
	    // this method will be called when the reset button is clicked;
	    // change the font back to plain
	    msgLabel.setFont(plainFont);
	}
    }

    class ExitButtonListener implements ActionListener {
	public void actionPerformed(ActionEvent e) {
	    // this method will be called when the exit button is clicked;
	    // end execution of this program
	    System.exit(0);
	}
    }

    class BoxListener implements ItemListener {
	public void itemStateChanged(ItemEvent e) {
	    // this method will be called when one checkbox is
	    // pushed using the mouse;
	    // determine which checkbox it was and set the font accordingly
	    Checkbox source = (Checkbox)e.getSource();
	    if (source == boldBox) {
		msgLabel.setFont(boldFont);
	    }
	    else if (source == italicBox) {
		msgLabel.setFont(italicFont);
	    }
	    else if (source == boldItalicBox) {
		msgLabel.setFont(boldItalicFont);
	    }
	    else {
		// shouldn't get here
		System.err.println("unknown checkbox");
		System.exit(1);
	    }
	}
    }

    public static void main(String [] args) {
	new ChangeFont2();
    }
}