Chris Johnson

• Part One: Introduction
  
  
  
• Part Two: AWT Components
  
  • The AWT Classes
  • Event Handling
  
  
• Part Three: Text and Labels...
• Part Four: Setting Things Out...
• Part Five: Selection Components
• Part Six: Graphics...
• Part Seven: Additional information
  
  
• Main Index

This section goes on to describe the key features of the Java AWT environment. The initial section describes how events are used to inform application programs about user input and for application programs to affect the display. This purely technical descriptions leads onto section that explore both the design and the programming aspects of various interface features including buttons, menus and forms.

                                     Object
                                        |
                                    Component
                                        |
--------------------------------------------------------------------------------
Canvas  Scrollbar  Container  Button  Checkbox  TextComponent  Label  List  Choice
                       |                             |
                  -----------                   -----------
              Panel         Window       TextArea        TextField
                              |
                          ----------
                     Dialog       Frame
                        |
                     FileDialog

              Object
                 |
           MenuComponent
                 |
            ------------
           |            |
        MenuItem     MenuBar
           |
          ----
         |    |
       Menu CheckboxMenuItem

Each component has a corresponding native peer so that it can be implemented on particular platforms. They also have a number of attributes that can be summarised as follows:

• a graphical image;
• background colour;
• a location;
• actual size;
• minimum, maximum and prefered sizes.
• font metrics (discussed in the section on text);
• a parent container (see below);

As the names suggests, the container class provides a means of "grouping" multiple components. For instance, an applet may contain a number of buttons. Components can be added to a container. This can be thought of as a list. The order of the list determine the front to back order in which the components are presented on the screen. This is important is one component is not to obscure another. If no index is specified when adding a component to a container, it will be added to the end of the list which represents the bottom of the stacking order. There are a number of different subclasses to Container.

        Container
            |
        --------------------------------------------
     Window           Applet         Panel     Scrollpane
	|
  -------------
Frame       Dialog
               |
           FileDialog

/*
* A frame 
*
* Author: Chris Johnson (johnson@dcs.gla.ac.uk)
* Last revision date: 11/10/98
*
* Produces a warning window on the screen
*
* Beware - there is no way of closing the frame!
* see later section on event handling...
*/
 
import java.awt.*;
 
public class SimpleWarningFrame extends Frame {
 
static private final int frame_height = 150;
static private final int frame_width = 250;
 
public SimpleWarningFrame () {
        setBackground(Color.red);
        setForeground(Color.black);
}
 
   public static void main (String[] args){
 
        Frame f= new SimpleWarning();
        f.setTitle("Warning");
        f.resize(frame_width, frame_height);
        f.show();
   }
}

Containers simply provide a grouping mechanism for interface objects. LayoutManagers provide means of positioning and sizing these objects. This class will be discussed in later sections.

while Input_Event != Quit loop
	
	read(Input_Event);            -- user types or click something
	perform_command(Input_Event); -- system executes corresponding command

end loop;

while Input_Event != Quit loop
        
        read(Input_Event);            -- user types or click something

	switch Input_Event
	
		case Home_Icon: load_URL(Home); break;  -- click on the home icon

		case Back_Icon: load_URL(Previous_Page); break; -- click to go back

		case File_Menu: display(File_Menu.Options); break; -- display file options
			 
	/* etc etc etc */
 
end loop;

It is important that all event handler methods execute as quickly as possible. Otherwise the system may appear to hang - any subsequent input by the user may have no effect as the system handles previous events. Eventually, the relevant methods will complete and the system will appear to "catch up" in an extremely unpredictable manner.

Word of warning - the event model was one of the major changes that occured between AWT version 1.0 and 1.1. Although the fundamental concepts remain the same, the detailed implementation of these systems is different (1.0 uses an inheritance-based approach to event handling, 1.1 uses a cleaner delegation approach). We will focus on the 1.1 event mechanisms, full details about the 1.0 system are provided here.

Each event results in the creation of an Event object. These have the following attributes:

• type e.g., keystroke or mouse up/down;
• target of the event e.g., icon/button the user selected;
• time when the event occurred;
• (x,y) location relative to origin of target event handler;
• key that was pressed for keyboard events;
• arbitrary argument e.g., string displayed on a Component;
• state of modifier keys, such as Shift and Control, when event occured.

 public void actionPerformed(ActionEvent e) {
        String command = e.getActionCommand();
         
        if (command == DISABLE) { //They clicked "Disable middle button"
            b2.setEnabled(false);
            b1.setEnabled(false);
            b3.setEnabled(true);
        } else { //They clicked "Enable middle button"
            b2.setEnabled(true);
            b1.setEnabled(true);
            b3.setEnabled(false);
        }
    }

Each event is first passed to the handleEvent method. This, in turn, calls the associated methods from the previous list. The Component class provides a number of methods, such as setSize in the previous example, that are called in response to particular events. The associated events appear in parentheses after the method:

• action() (Event.ACTION_EVENT) - an action event.
• mouseEnter() (Event.MOUSE_ENTER) - mouse enters component
• mouseExit() (Event.MOUSE_EXIT) - mouse exits component
• mouseMove() (Event.MOUSE_MOVE) - mouse moves
• mouseDown() (Event.MOUSE_DOWN) - mouse button down
• mouseDrag() (Event.MOUSE_DRAG) - mouse drags component
• mouseUp() (Event.MOUSE_UP) - mouse button up
• keyDown() (Event.KEY_PRESS or Event.KEY_ACTION) - key press
• keyUp() (Event.KEY_RELEASE or Event.KEY_ACTION_RELEASE) - key release
• gotFocus() (Event.GOT_FOCUS) - component has focus (see below)
• lostFocus() (Event.LOST_FOCUS) - component loses focus (see below)
• handleEvent() (all event types) -

Only Button, Checkbox,Choice, List, MenuItem, and TextField produce action() events. They do so when the user indicates somehow that the control should perform an action. For example, when the user clicks a button, an action event is generated. By implementing the action() method, you can react to user actions on controls without worrying about the low-level events, such as key presses and mouse clicks, that caused the action. Here is an example from a simple program:

public boolean action(Event e, Object what){
/*
*   The what parameter varies depending on the object associated with
*   the event, in the case of a button it provides the textual label (String)
*   that is displayed on the button. 
*/
        if (e.target == quitButton)
        {
                        System.exit(0);
        }
        return true;

Each of the previous methods returns a Boolean value to indicate whether or not the method successfully handled the event. If False is returned then the event is handed up to components higher in the hierarchy. Again, this was illustrated in the previous example.

The following example shows how the handleEvent method can be overridden in order to close the warning window that was generated in the Frame example from the previous section. Here is the output from this application viewed on a Macintosh. What are the problems with the design of this warning?

/*
* Simple warning program 
*
* Author: Chris Johnson (johnson@dcs.gla.ac.uk)
* Last revision date: 11/10/98
*
* Produces a simple warning on the screen.   Illustrates the
* use of a frame and of a simple event handler in AWT 1.0
* Based on an example by Judy Bishop, JavaGentely,
* Addison Wesley 1998, p. 310
 */
/*
 * 1.0 version.
 */
 
import java.awt.*;
public class SimpleWarning extends Frame {
 
static private final int horigap = 15;
static private final int vertigap = 10;
 
public SimpleWarning (String[] message, int n) {
        setBackground(Color.red);
        setForeground(Color.black);
 
        setLayout(new FlowLayout(FlowLayout.CENTER, horigap, vertigap));
        for (int i=0; n>i; i++)
                        add (new Label(message[i]));
}
 
public boolean handleEvent(Event e){
 
        if (e.id == Event.WINDOW_DESTROY)
        {
                        System.exit(0);
        }
        return super.handleEvent(e);
}
 
   public static void main (String[] args){
 
        String[] message = {
                "WARNING",
                "Something has gone badly wrong",
                "I'd go home..."
        };
 
        Frame f= new SimpleWarning(message, 3);
 
 
        f.setTitle("Warning");
        f.resize(240, 100);
    f.show(true);
   }
}

/*
* Warning program with a Cancel button
*
* Author: Chris Johnson (johnson@dcs.gla.ac.uk)
* Last revision date: 11/10/98
*
* Produces a simple warning on the screen.   Illustrates the
* use of a frame and of a simple event handler in AWT 1.0
* Based on an example by Judy Bishop
 */
/*
 * 1.0 version.
 */
 
import java.awt.*;
public class ButtonWarning extends Frame {
 
static private final int horigap = 15;
static private final int vertigap = 10;
private Button quitButton;
 
public ButtonWarning (String[] message, int n) {
        setBackground(Color.white);
        setForeground(Color.black);
 
        setLayout(new FlowLayout(FlowLayout.CENTER, horigap, vertigap));
        for (int i=0; n>i; i++)
                        add (new Label(message[i]));
        quitButton = new Button("Quit");
        add(quitButton);
}
 
public boolean handleEvent(Event e){
 
        if (e.id == Event.WINDOW_DESTROY || e.target == quitButtton)
        {
                        System.exit(0);
        }
        return super.handleEvent(e);
}
 
   public static void main (String[] args){
 
        String[] message = {
                "WARNING",
                "Something has gone badly wrong",
                "I'd go home..."
        };
 
        Frame f= new ButtonWarning(message, 3);
        f.setTitle("Warning");
        f.resize(240, 100);
        f.show(true);
   }
}

And now on to part three...