Transcript Document 7537827

Chapter 18
Building 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 interface
Enter number of Sticks.
3
Player 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 0
1
Enter 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
public
public
public
Color getForeground ();
Color getBackground ();
Point getLocation ();
Dimension getSize ();
public
public
public
public
void
void
void
void
Color setForeground(Color fg);
Color setBackground(Color bg);
Point setLocation(Point p);
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.
Example
import 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.
Example
class 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
public
public
public

void
void
void
void
pack()
toFront()
toBack()
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
public
public
public
Container getContentPane ()
JMenuBar getJMenuBar ()
JRootPane get JRootPane ()
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.)