Chapter 18Building the user interface

This chapter discusses

Java’s graphical user interface. Swing: an enhancement of a

library called the Abstract Window Toolkit (AWT).

Event-driven, window-based applications.

Swing as a case study of how large libraries are organized.

The system interface

The interface and the model are two of the principal components of a software system.

The interface handles interaction with the external world.

When the external world is a person, the interface is called a user interface.

Algorithm-driven interfaces In an algorithm-driven approach,

the application determines exactly what information it needs from the environment, and when it needs it.

The application has access to several streams of data.

A stream is a sequence of bytes.

Algorithm-driven interfaces (cont.) A character stream is a set of ASCII

characters. Otherwise it is a binary stream. Input stream sources can be a user’s

keyboard, a file, another program, an external device, etc.

Output stream targets can be a user’s display screen, a file, another program, an external device, etc.

Java compiler stream

1 input stream 2 output streams

Nim game user interfaceEnter number of Sticks.3Player Player1 takes 2 leaving 1 sticks.Player Player2 takes 1 leaving 0 sticks.Game over. Player 1 won.To Play again, enter 1; to stop enter 01Enter number of sticks.

This game writes output and reads input.

Filters

Where input data comes from and where output data goes often is not important to the application.

Filters read input from a single stream called standard input, write output to an output stream called standard output, and write error messages to a stream called standard error.

Event-driven interfaces

The application is “active” in an algorithm-driven interface; it is “passive” in an event-driven system.

An event-driven system waits for something to happen (an event) in the environment.

event-driven: an input-output model in which the application waits for an event to occur, responds to the event, and waits for the next event.

Event-driven interfaces (cont.) An application with a window-based

interface provides a graphical “control panel” containing a range of options.

Event-driven interfaces (cont.) In a window-based system, we assume that

there is a native windowing system that actually detects events like mouse clicks, mouse movement, key strokes, etc., and manages the display.

Java applications interact with the native windowing system.

Swing

A graphical user interface is made up of components (widgets). windows buttons menus, etc.

Each components has attributes of location, size, shape, color, etc.

Components are defined in a class library contained in the package javax.swing

JComponent abstract class

JComponent abstract class (cont.)

JComponent abstract class (cont.) JComponent is a subclass of the AWT.public Color getForeground ();

public Color getBackground ();

public Point getLocation ();

public Dimension getSize ();

public void Color setForeground(Color fg);

public void Color setBackground(Color bg);

public void Point setLocation(Point p);

public void Dimension setSize(Dimension d;)

JComponent abstract class (cont.) Many of the methods are overloaded.

For instance, there are versions of setLocation and setSize that take two int arguments rather than a Point or Dimension.

JComponent abstract class (cont.) Color, Point, and Dimension are

AWT classes. Instances of Color are immutable. The class Color defines a number

of constant references. i.e. Color.red

Class Dimension encapsulates width and height.

Containers

Objects that contain components are containers.

JComponent is a subclass of Container. component: a distinct element of a

graphical user interface, such as a button, text field, etc.

container: a graphical user interface component that can contain other components.

Containers (cont.)

JPanel

Used as a place to put a collection of other components.

Jpanel p = new Jpanel();

p.add(new Jbutton(“on”));

p.add(new Jbutton(“off”));

Manipulating content Class Container defines an extensive set of

methods for manipulating its content.

public int getComponentCount()The number of Components in this Container.

public Component getComponent (int n)The Component with the specified index.require: 0 <= n < this.getComponentCount()

public void remove (Component comp)Remove the specified Component.

public void remove (int index);Remove the Component with the specified index.require: 0 <= index < this.getComponentCount()

Top-level containers

A top-level container is one that is not contained in any other container. i.e. JApplet, JDialog, JFrame, and JWindow.

JFrame

A window with a title and a border. JFrame is a subclass of

java.awt.Container, not JComponent. It delegates the responsibility of

managing its components to another object--JRootPane.

JRootPane

JRootPane is a JComponent whose principal responsibility is to manage the content of some other container.

It is a composite object, including a content pane. The content pane is usually a JPanel, and is the

working area of the JFrame, excluding title, border, menu.

Components are not added directly to the JFrame, but to the content pane.

JRootPane (cont.)

getContentPane returns a Container.

JFrame f = new JFrame(“A Frame”);

JButton b = new JButton(“Press”);

Container cp = f.getContentPane();

cp.add(b);

JApplet, JDialog, JWindow and JInternalFrame also use JRootPane to manage components.

Peers

JApplet, JDialog, JFrame, JWindow are heavyweight components.

Instances of subclasses of JComponent are lightweight components.

When a heavyweight component is created, the AWT also creates an associated native GUI component called a “peer.” i.e. Creation of JFrame, also creates a “frame peer.”

Peers (cont.)

Peers actually do the work of capturing user input and managing the screen area in which the component is displayed.

Lightweights are implemented completely by Java.

Lightweights are drawn on the space provided by their heavyweight parent containers.

Top-level frame

import javax.swing.*;

public class DisplayFrame {

public static void main (String[] args){

JFrame f = new JFrame (“A Frame”);

f.setSize(300,200);

f.setVisible(true);

}

}

Adding components

Adding components to the frame won’t cause the component to appear suddenly on the display.

A LayoutManager is an object responsible for positioning and sizing the components in a container.

A LayoutManager is specified in the interface java.awt.LayoutManager.

public LayoutManager getLayout();

public void setLayout (LayoutManager manager);

LayoutManager implementations FlowLayout: left to right, top to bottom. BorderLayout: “north”, “south”, “east”, “west”,

“center.” GridLayout: two-dimensional grid. CardLayout: one at a time from a “deck” GridBagLayout: vertically and horizontally

according to constraints. BoxLayout: either a single horizontal row or

single vertical column. OverlayLayout: specified components align in the

same place; components are laid out on top of each other.

FlowLayout

BorderLayout

GridLayout

When the GridLayout is created, we specify that we want a grid of 3 rows and 2 columns. Since there is more than 6 components, GridLayout expands the number of columns, while keeping the number of rows at 3.

Container validity A Container is valid if it does not need

to be laid out. i.e. size is known to the system, and the layout manager knows about all its components.

A Container is invalid if its state is inconsistent with its appearance.

A Container to which a component has been added after it was last laid out is invalid.

Container validity (cont.) Any number of things can cause the

layout manager to lay out the Container. validate explicitly sets the

Container’s valid property to true, and instructs the layout manager to lay out the Container.

isValid returns the value of this property.

public boolean isValid();

public void validate();

Capturing and handling events event: the occurrence of an action,

typically external to the system, that the system is aware of and must respond to.

low-level events: pressing or releasing a key, moving the mouse, pressing a mouse button.

high-level events: selecting an item on the menu, pressing a button, entering text in a field. High-level events usually involve one or

more low-level events.

Some high-level events key event: a keyboard key pressed or

released. mouse event: the mouse is moved or

dragged, a button pressed or released, the mouse cursor enters or exits component.

component event: a component is hidden, shown, resized, or moved.

container event: a component is added to or removed from a container.

window event: a window is opened, closed, iconified, de-iconified, activated, deactivated.

Some high-level events (cont.) focus event: a component gains or

loses focus. action event: a high-level event occurs. adjustment event: a high-level event

occurs representing scrollbar motions. item event: a high-level event occurs

when user selects a checkbox, choice, or list item.

document event: a TextComponent’s content changes.

Java event classes

Java event classes (cont.) The source of an event is

determined with:public Object getSource(); An object that monitors when an event

occurs is called a listener. To be notified of an event, a listener

must register with the event’s source. The relation between a listener and an

event source is the observes relation.

Exampleimport java.awt.*;import javax.swing.*;import java.awt.event.*;

public class OnOffTest {public static void main (String[] args){ OnOffSwitch sw = new OnOffSwitch();}

}

class OnOffSwitch extends JFrame {public OnOffSwitch() { super(“On/Off Switch”); JButton button= new JButton(“On/Off”); Container cp = this.getContentPane(); button.setForground(Color.black); button.setBackground(Color.white); cp.add(button,BorderLayout.Center); this.setSize(300,200); this.setVisible(true);}

}

Example

EventListener classes

Adding a listener

There is only one method specified in the interface ActionListener.

public void actionPerformed(ActionEvent e);

class Switcher implements ActionListener {

public void actionPerformed

(ActionEvent e) {…}

}

When the user presses the button, an ActionEvent is generated.

Exampleclass OnOffSwitch extends JFrame {

public OnOffSwitch() { super(“On/Off Switch”); JButton button= new JButton(“On/Off”); Switcher control = new Switcher(); button.addActionListener(control); Container cp = this.getContentPane(); button.setForground(Color.black); button.setBackground(Color.white); cp.add(button,BorderLayout.Center); this.setSize(300,200); this.setVisible(true);}

}

Example (cont.)public void actionPerformed(ActionEvent e){

Component source =

(Component)e.getSource();Color oldForeground =

source.getForegound();source.setForeground

(source.getBackground());source.setBackground(oldForeground);

}

Example (cont.)

Example (cont.)

Since the listener explicitly determines the source of the event, it could handle events from several sources without modification.

class OnOffSwitch extends JFrame {public OnOffSwitch() { super(“On/Off Switch”); JButton button1= new JButton(“On/Off”); JButton button2= new JButton(“On/Off”); Switcher control = new Switcher(); button1.addActionListener(control); button2.addActionListener(control); … }

}

Adding a window listener We would like to terminate the application

when the user selects the “Close” option from the top-level window menu.

Selecting “Close” generates a WindowEvent in the JFrame, specifically a “window closing” event.

The WindowListener interface is a bit more complicated than the ActionListener interface; it specifies seven methods.

Adding a window listener (cont.)void windowActiviated (WindowEvent e) Invoked when window becomes the active window.

void windowClosed (WindowEvent e) Invoked when window has been closed.

void windowClosing (WindowEvent e) Invoked when user attempts to close window.

void windowDeactiviated (WindowEvent e) Invoked when window becomes no-longer-active window.

void windowDeiconified (WindowEvent e) Invoked when window changes from minimized to normal.

void windowIconified (WindowEvent e) Invoked when window changes from normal to minimized.

void windowOpened (WindowEvent e) Invoked when window is first made visible.

Adding a window listener (cont.) To simplify the implementation, Java

provides “event adapter” classes.

class Terminator extends WindowAdapter {

public void windowClosing(WindowEvent e) {

Window w = e.getWindow();

w.dispose();

}

public void windowClosed(WindowEvent e) {

System.exit(0);

}

}

Adding a window listener (cont.) We must create a Terminator instance

and register it with the top-level JFrame.

public OnOffSwitch() { super(“On/Off Switch”); JButton button= new JButton(“On/Off”); Switcher control = new Switcher(); Terminator arnold = new Terminator(); button.addActionListener(control); this.addWindowListener(arnold); …}

Adding a window listener (cont.) Terminator is an ideal candidate for being

made an anonymous inner class.

this.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {

e.getWindow().dispose(); } public void windowClosed(WindowEvent e) {

System.exit(0);

}

}

);

Some class features

Component Background color: public Color getBackground() public void setBackground(Color c) Foreground color: public Color getForeground() public void setForeground(Color c) Location: public Point getLocation() public void setLocation(int x, int y) public void setLocation(Point p) Location on screen: public Point getLocationOnScreen() Size: public Dimension getSize() public void setSize(int height,int width) public void setSize(Dimension d)

Component (cont.) Preferred size: public Dimension getPreferredSize()

Minimum size: public Dimension getMinimumSize()

Parent: public Container getParent()

Enable: public boolean isEnabled() public void setEnabled(boolean enabled) Valid: public boolean isValid() public void validate() public void invalidate()

Component (cont.) Visible and Showing: public boolean isVisible() public boolean isShowing() public void setVisible(boolean visible)

Font: public Font getFont() public void setFont(Font f)

Graphics: public Graphics getGraphics()

Listeners: public void addComponentListener(

ComponentListener listener) public void removeComponentListener(

ComponentListener listener)

Component (cont.)

Listeners (cont.):

public void addFocusListener( FocusListener

listener) public void removeFocusListener(

FocusListener listener) public void addKeyListener( KeyListener

listener) public void removeKeyListener( KeyListener

listener) public void addMouseListener( MouseListener

listener) public void removeMouseListener(

MouseListener listener) public void addMouseListener(

MouseMotionListener listener)

public void removeMouseListener( MouseMotionListener

listener)

Containers

Component Manipulation:

public int getComponentCount() public Component getComponent(int

position) public Component getComponentAt(int x,

int y) public Component getComponent(Point p)

Component Manipulation (cont.):

public Component add(Component component) public Component add(Component component,

int position) public Component add(Component component,

Object constraints) public void remove(Component component) public void remove(int position)

Containers (cont.)

Layout Manager:

public int getLayout() public void setLayout(LayoutManager

manager) Listeners:

public void addContainerListener( ContainerListener

listener) public void removeContainerListener(

ContainerListener listener)

Window public void pack() public void toFront() public void toBack() public void dispose()

Listeners:

public void addWindowListener( WindowListener

listener) public void removeWindowListener(

WindowListener listener)

Frame Title: public String getTitle() public void setTitle(String title)

Resizable: public boolean isResizable() public void setResizable(boolean visible)

Border: public Border getBorder() public void setBorder(Border border)

Ancestors: public JRootPane getRootPane() public Container getTopLevelAncestor()

Transparency: public void setOpaque(boolean isOpaque) public boolean isOpaque()

JFrame

Components: public Container getContentPane () public JMenuBar getJMenuBar () public JRootPane get JRootPane () public void setContentPane(Container

contentPane) public void setJMenuBar(JMenuBar menubar) Default close operation: public int getDefaultCloseOperation () public void setDefaultCloseOperation (int

operation) One of the following must be passed to

setDefaultCloseOperation. WindowConstants.DO_NOTHING_ON_CLOSE WindowConstants.HIDE_ON_CLOSE WindowConstants.DISPOSE_ON_CLOSE

We’ve covered

Building a user interface. Event-driven, graphical user

interfaces. Java’s facilities for user interfaces. Events. Listeners.

Glossary

Glossary (cont.)