UNIT 3

EVENT DRIVEN PROGRAMMING

 Coordinates, Graphics Contexts and
Graphics Objects
• Java 2D coordinate system
– Scheme for identifying every point on screen
• Upper left corner of GUI component has coordinates
(0,0)
• Java graphics context
– Enables drawing on screen
• e.g., font and color manipulation
– Graphics object manages a graphics context
• abstract class for portability
Coordinates, Graphics Contexts and Graphics
Objects (cont.)
(0, 0)
+x x-Axis

(x, y)

+y

y -Axis
 Java 2D API
• Java 2D API
– Provides advanced 2D graphics capabilities
– Part of the Java 2 Platform, Standard Edition
– Includes features for processing line art, text and images
– Class java.awt.Graphics2D
• Enables drawing with Java 2D API
• Offers three graphics primitives: images, text and shapes
• java.awt.Graphics subclass
• Contains seven state attributes
– Clipping, compositing, font, paint, rendering hints, stroke and transforms
 Java 2D Shapes
• Java 2D shape classes
– Package java.awt.geom
• Ellipse2D.Double
• Line2D.Double
• Rectangle2D.Double
• RoundRectangle2D.Double
• Arc2D.Double
 Java 2D Image Processing
• Image processing
– Manipulation of digital images by applying filters
• Filters – mathematical operations that change images
– Compression filters
» Reduce digital image’s memory usage
– Measurement filters
» Collect data from digital images
– Enhancement filters
» Alter certain physical aspects of an image

• Java 2D image processing

– Use java.awt.BufferedImage
AWT - Abstract Windowing Toolkit
• Single Windowing Interface on Multiple Platforms
• Supports functions common to all window
systems
• Uses Underlying Native Window system
• AWT provides
• GUI widgets
• Event Handling
• Containers for widgets
• Layout managers
• Graphic operations
 AWT - Abstract Window Toolkit
• Portable GUI - preserves native look & feel
• Standard GUI Components (buttons…)
• Containers - Panels, Frames, Dialogs
• Graphics class for custom drawing
• Layouts responsible for actual positioning of
components:
• BorderLayout, GridLayout, FlowLayout, null layoit
 Adding Components via Layouts
Button("Cancel"));
add("South",p); setLayout(new BorderLayout());
// Add text field to top
add("North",new TextField());
// Create the panel with buttons at the bottom...
Panel p = new Panel(); // FlowLayout
p.add(new Button("OK"));
p.add(new
Adding Components via Layouts
 Building Graphical User Interfaces

• import java.awt.*;
• Assemble the GUI
– use GUI components,
• basic components (e.g., Button, TextField)
• containers (Frame, Panel)
– set the positioning of the components
• use Layout Managers
• Attach events
 A sample GUI program
Import java.awt.*;
class MyGui {
public static void main(String [] s ) {
Frame f = new Frame (“My Frame”);
Button b = new Button(“OK”);
TextField tf = new TextField(“George”, 20);
f.setLayout(new FlowLayout());
f.add(b);
f.add(tf);
f.setSize(300, 300);
f.setVisible(true);
}
}
output
 Events

b.addActionListener( );

Button
method to add a listener listener object
Frame

f.addWindowListener( );
 Events
• Each GUI component (e.g., a Button) that wishes to
respond to an event type (e.g., click), must register an
event handler, called a Listener.
• The listener is an object of a "Listener" interface.
• A Listener class can be created by subclassing
(through "implements") one of Listener interfaces (all
listener inrefaces are in the java.awt.event package =
> must import java.awt.event.*; )
• The registration of the listener is done by a call to a
method such as addActionListener(<Listener Object>).
Each GUI component class has one or more such
add…() methods, where applicable.
 Listener Interfaces
INTERFACE NAME (IN JAVA.AWT.EVENT )
[1] ActionListener
[2] ItemListener
[3] MouseMotionListener
[4] MouseListener
[5] KeyListener
[6] FocusListener
[7] AdjustmentListener
[8] ComponentListener
[9] WindowListener
[10] ContainerListener
[11] TextListener
 Listener Interfaces
Each listener interface has methods that need to be
implemented for handling different kinds of events.

For example, the MouseMotionListener interface has two

methods:
1) mouseDragged(MouseEvent) - Invoked when a mouse
button is pressed on a component and then dragged.
2) mouseMoved(MouseEvent) - Invoked when the mouse
button has been moved on a component (with no buttons
down).
 WindowListener interface
1) windowActivated(WindowEvent) - Invoked when a window is activated.
2) windowClosed(WindowEvent) - Invoked when a window has been closed.
3) windowClosing(WindowEvent) - Invoked when a window is in the process of
being closed.
4) windowDeactivated(WindowEvent) - Invoked when a window is de-activated.

5) windowDeiconified(WindowEvent) - Invoked when a window is de-iconified.

6) windowIconified(WindowEvent) - Invoked when a window is iconified.

7) windowOpened(WindowEvent) - Invoked when a window has been opened.
How to create an object of a listener
interface ?

• Interfaces cannot be instantiated.

• Therefore, cannot do new WindowListener();

• Instead, have to subclass the interface and

then create object of the subclass
 Implementing the ActionListener Interface
and attaching an event handler to a button
class MyApp implements ActionListener {
Button b = new Button(“OK”);
public static void main(String [] s ) {
(new MyApp()).go();
}
public void go() {
b.addActionListener( this );
}
public void actionPerformed(ActionEvent e ) {
// what to do when the button is clicked
if( e.getSource() == b )
{ System.out.println(“OK pressed"); }
}
}
 Implementing 2 interfaces
class MyApp implements ActionListener, WindowListener {
Button b = new Button(“OK”);
Frame f = new Frame(“My Frame”);
public static void main(String [] s ) {(new MyApp()).go(); }
public void go() {
b.addActionListener( this );
f.addWindowListener( this );
}
public void actionPerformed(ActionEvent e ) { … }
public void windowActivated(WindowEvent e ) { … }
public void windowClosed(WindowEvent e ) { … }
public void windowClosing(WindowEvent e ) { … }
public void windowDeactivated(WindowEvent e) { … }
public void windowDeiconified(WindowEvent e) { … }
public void windowIconified(WindowEvent e) { … }
public void windowOpened(WindowEvent e) { … }
}
 Adapters
class MyApp extends WindowAdapter {
Button b = new Button(“OK”);
Frame f = new Frame(“My Frame”);
public static void main(String [] s ) {(new MyApp()).go(); }
public void go() {
f.addWindowListener( this );
}
public void windowClosing(WindowEvent e ) { … }
}

Need only implement the method(s) that are required,

instead of all seven methods of the WindowListener
interface
But, we can only use one Adapter at a time
(no multiple inheritance)

We cannot use

class MyApp extends WindowAdapter,

MouseAdapter, ... {
… … … ...
}
 use inner classes instead !!!
class MyApp {
Button b = new Button(“OK”);
Frame f = new Frame(“My Frame”);
public static void main(String [] s ) {
((new MyApp()).go(); }
public void go() {
f.addWindowListener( new FrameHandler() );
b.addMouseListener( new ButtonHandler() );
}
class ButtonHandler extends MouseAdapter {
public void mousePressed (MouseEvent e ) { … }
}
class FrameHandler extends WindowAdapter {
public void windowClosing (WindowEvent e ) { … }
}
}
 Popup Menu and Event Handling...
//popup.java: popup menu and event handling
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class popup extends Frame implements ActionListener, MouseListener
{
TextField text1;
PopupMenu popup;
MenuItem menuitem1, menuitem2, menuitem3;
public popup()
{
super( "Popup Menu" );
setLayout(new FlowLayout());
setBounds(10, 10, 300, 200 );
setVisible(true);
init();
}
public void init()
{
popup = new PopupMenu("Resource Usage" );
 Popup Menu and Event Handling...
menuitem1 = new MenuItem("CPU");
menuitem1.addActionListener(this);
menuitem2 = new MenuItem("Disk");
menuitem2.addActionListener(this);
menuitem3 = new MenuItem("Memory");
menuitem3.addActionListener(this);
popup.add(menuitem1);
popup.add(menuitem2);
popup.add(menuitem3);
add(popup);
text1 = new TextField(20);
text1.setBounds(20, 40, 120, 30 );
add(text1);
addMouseListener(this);
}
public void mousePressed(MouseEvent e )
{
if( e.getModifiers() != 0 )
popup.show(this, e.getX(), e.getY() );
}
 Popup Menu and Event Handling
public void mouseReleased( MouseEvent e )
{ System.out.print("Mouse Released\n" ); }
public void mouseEntered( MouseEvent e )
{ System.out.print("Mouse Entered\n" ); }
public void mouseExited( MouseEvent e )
{ System.out.print("Mouse Exited\n" ); }
public void actionPerformed( ActionEvent e )
{
if( e.getSource() == menuitem1 )
{ text1.setText("CPU"); }
if( e.getSource() == menuitem2 )
{ text1.setText("Disk"); }
if( e.getSource() == menuitem3 )
{ text1.setText("Memory"); }
}
public static void main( String args[] )
{
popup p = new popup();
}
}
 AWT & Applets
An Applet is a Java program capable of running from within a web page
(HTML document)

Steps to incorporate and run an applet:

· Have MyApplet.java
· javac MyApplet.java
· Have MyApplet.class
· Create MyApplet.html

<applet code = MyApplet.class width = 200 height = 300 >

</applet>

· appletviewer MyApplet.html (or open MyApplet.html in browsers like

Netscape/IE).
 Applet methods
Unlike Applications, Applets do not have
main().
Instead, they have : init(), start(), stop(),
paint(), update(), repaint(), destroy().

All methods need not be implemented -- there

are default versions for all of them.

• AppletContext
• “Applet” derived from AWT Panel
• Hooks into Browser environment
• Can be used to link to another Web page
 A sample Applet
// HelloApplet.java: for processing applet methods
import java.awt.*;
import java.applet.*;
public class HelloApplet extends Applet
{
public void init() {
setBackground(Color.yellow);
System.out.println("init() method invoked");
}
public void start()
{
System.out.println("start() method invoked");
}
public void paint( Graphics g )
{
System.out.println("paint() method invoked");
g.drawString( "Hi there", 24, 25 );
}
public void stop()
{
System.out.println("stop() method invoked");
}
}
sample Applet
another sample Applet (run in Applet Viewer)
 sample Applet
running within Netscape
 sample Applet code
import java.applet.*; // for Applet class
import java.awt.*; // for Graphics class
public class MyApplet extends Applet {
public void paint( Graphics g ) {
g.drawString("Hi there", 40, 40);
g.drawOval(40, 60, 45, 45);
g.drawRect(100, 60, 50, 50);
g.drawLine(170, 60, 250, 170);
} // end paint()
public void init() {
setBackground(Color.yellow);
}
} // end class MyApplet
 Another example
// MyApplet.java: draws rectangle with yellow color fill
import java.applet.*;
import java.awt.*;
public class MyApplet extends Applet
{
public synchronized void paint(Graphics g)
{
int x,y,width,height;
Dimension dm = size();
x = dm.width/4;
y = dm.height / 4;
width = dm.width / 2;
height = dm.height / 2;
// Draw the rectangle in the center with colors!
g.setColor(Color.blue);
g.drawRect(x,y,width,height);
g.setColor(Color.yellow);
g.fillRect(x + 1,y + 1,width - 2,height - 2);
}
}
 Applet method execution
As soon as the browser (or Appletviewer) accesses the page that contains the
applet:

It calls init(), first

It calls start(), second.

It calls paint(), third.

 Applet method execution (cont’d)
After the above three initial calls, invocation of the other
methods depends on user's activity while in the browser:
no activity => none of the methods is invoked
leave to a different URL => stop() is invoked (and if later
come back to this URL, then start() will be invoked).
close down the browser => destroy() is invoked
none of the above => either paint() or update() or
repaint() is invoked.
Incorporating Images and sound
in Applets
sample Applet with sound

… … … (MyAppletSound.java)
 how to do that ….

Step 1 : LOAD (image of sound file)

Step 2 : DISPLAY -or- PLAY

 Applet that displays image
import java.applet.*;
import java.awt.*;
public class MyApplet1 extends Applet {
Image im;
public void init () {
// load
im = getImage(getDocumentBase(),"BOTTOMDOLLAR.JPG");
setBackground(Color.yellow);
}
public void paint(Graphics g ) {
g.drawImage(im, 50, 50, this); // display
}
} // end class MyApplet1
 Applet that plays sound
import java.applet.*;
import java.awt.*;
public class MyAppletSound extends Applet {
AudioClip ac;
public void init () {
// load
ac = getAudioClip(getDocumentBase(), "chirp1.au");
}
public void start() {
ac.loop(); // play
}
public void stop() {
ac.stop(); // stop the sound upon leaving this web page
}
} // end class MyAppletSound
 Model-View-Controller
• MVC Architecture and it’s application in Swing
– Model-view-controller architecture uses OO design
principles to modularize applications into
• Data components: maintain raw application data
• Presentation components: provide visual representation of
data
• Input-processing components: handle input from the user
• Delegate-model architecture
– Is a variant of the MVC architecture
• Observer design pattern
– A design pattern built into the MVC architecture
 Model-View-Controller Architecture
• The MVC separates application data from the
graphical presentation components and input-
processing logic.
• MVC originally appeared in Smalltalk as a
method for separating user interfaces from
underlying application data
• Model
– Contains application data
– When the model changes, it notifies the view
• View
– Generates a presentation of the data stored in
the model
– The view updates its presentation whenever the
model changes
• Controller
– Implements logic for processing user input
– Use user provided input to modifies model
Model-View-Controller Architecture (Cont.)

• Delegate-model architecture
– Variant of MVC
– Combines the view and controller into a single object - delegate
– The delegate provides both a graphical presentation of the
model and an interface for modifying the model
• Example
– Every JButton has an associated ButtonModel.
• The JButton is the delegate.
• The ButtonModel maintains state information (button is pressed or
enabled) and list of ActionListeners.
• The JButton provides a graphical presentation and modifies the
ButtonModel’s state
 Class AbstractAccountView
• Method updateDisplay() is marked abstract,
requiring each AbstractAccountView subclass
to provide an appropriate implementation for
displaying the Account information
• update() invokes updateDisplay() each time
an Account notifies the AbstarctAccountView
of a change
• Interface Observer defines method update,
which takes as an argument a reference to an
Observable instance that issued the update
• An Observable object issues an update by
invoking notifyObservers() of class Observable
• notifyObservers() invoke update() for each
registered Observer
• An Observer can listen for updates from
multiple Observable objects
 Class AccountController
• AccountController implements the controller
in the MVC architecture
• AccountController provides a user interface
for modifying Account data
• AccountController extends JPanel because it
provides a set of GUI components for
depositing and withdrawing Account funds
 Swing Components
• Swing is a collection of libraries that contains
primitive widgets or controls used for designing
Graphical User Interfaces (GUIs).

• Commonly used classes in javax.swing package:

– JButton, JTextBox, JTextArea, JPanel, JFrame, JMenu,
JSlider, JLabel, JIcon, …
– There are many, many such classes to do anything
imaginable with GUIs
– Here we only study the basic architecture and do simple
examples
 Swing components, cont.
• Each component is a Java class with a fairly extensive
inheritency hierarchy:
Object

Component

Container

JComponent Window

JPanel Frame

JFrame
 Adding components
• Once a component is created, it can be added
to a container by calling the container’s add
method:
Container cp = getContentPane();
cp.add(new JButton(“cancel”));
cp.add(new JButton(“go”));

How these are laid out is determined by the layout manager.

 Laying out components
• Not so difficult but takes a little practice
• Do not use absolute positioning – not very
portable, does not resize well, etc.
 Laying out components
• Use layout managers – basically tells form how
to align components when they’re added.
• Each Container has a layout manager associated
with it.
• A JPanel is a Container – to have different
layout managers associated with different parts
of a form, tile with JPanels and set the desired
layout manager for each JPanel, then add
components directly to panels.
 Layout Managers
• Java comes with 7 or 8. Most common and
easiest to use are
– FlowLayout
– BorderLayout
– GridLayout
• Using just these three it is possible to attain
fairly precise layout for most simple
applications.
 Setting layout managers
• Very easy to associate a layout manager with a
component. Simply call the setLayout method
on the Container:

JPanel p1 = new JPanel();

p1.setLayout(new FlowLayout(FlowLayout.LEFT));

JPanel p2 = new JPanel();

p2.setLayout(new BorderLayout());

As Components are added to the container, the layout

manager determines their size and positioning.