Advance Java Programming(CM5I) Event handling

Miss.P.S.Dungarwal
Lecturer in CM Department.
SHHJB Polytechnic, Chandwad.
1
3.Event Handling (12Marks)
Advance Java Programming(22517)

javax
2
 Originally, everything that was part of the standard API was
part of the java package, whereas everything that was
not part of the standard API was released under the
package name javax. Hence, packages essential to the
API was java, while javax contained the extensions to the
API. It can even be said that javax, is just java with an x,
which stands for extension.
 Over time the extensions that were released as javax,
become integral to the Java API. However, moving the
extension from the javax package to the java package
would be too cumbersome and would end up breaking a
bunch of existing code. Hence, eventually it was decided
that the javax packages would become part of the standard
API.
 So, practically there is no difference between Java and

Why is Swing Called Swing?
3
 The story is: The team went to Hobees for lunch, and the topic turned
to what to name the new toolkit we were writing. Up till then the name
was code named KFC, which was chosen by our manager (Rick
Levenson) as a way to ensure we'd come with with a better name
before shipping; he knew there was no way "KFC", aka Kentucky
Fried Chicken, would be allowed by the lawyers.
 Some names that were tossed around included Juliet and Carousel.
There were many more, but none felt "just right."
 Finally after lunch, while driving back to Sun, Amy Fowler (lead
engineer of the team) asked our most hip team member, Georges
Saab, "Georges, you know what's up and coming... what's the new
happening thing in San Francisco?"
 Georges responded with "Swing dancing is getting to be really big."
And that was it, we all knew it was perfect. When we got back to the
office I did a global search and replace of "kfc" with "swing", and the
rest is history.

Event Handling
4
 Any program that uses GUI (graphical user
interface) such as Java application written for
windows, is event driven.
 Event describes the change of state of any
object.
 Events are generated as result of user interaction
with the graphical user interface components.

5
 Changing the state of an object is known as an event.
 For example: clicking on a button, Entering a
character in Textbox, moving the mouse, selecting an
item from list, scrolling the page, etc.
 The java.awt.event package provides many event
classes and Listener interfaces for event handling.

Delegation Event Model
6
 The modern approach to handling events is based on the
delegation event model.
 The delegation event model provides a standard
mechanism for a source to generate an event and
send it to a set of listeners.

Delegation Event Model
7
 Its concept is quite simple: a source generates an event
and sends it to one or more listeners.
 In this scheme, the listener simply waits until it receives
an event. Once received, the listener processes the event
and then returns.
 The advantage of this design is that the application logic
that processes events is cleanly separated from the user
interface logic that generates those events.
 A user interface element is able to “delegate” the
processing of an event to a separate piece of code.

9
 In the delegation event model, listener must
register with a source in order to receive an
event notification.
 Notification are sent only to listeners that want to
receive them.
 There are mainly three parts in delegation event
model.
 Events.
 Event sources.
 Event Listeners.

Components of Event Handling
10
 Events
An event is a change of state of an object.
 It can be generated as a consequence of a person
interacting with the elements in a graphical user
interface.
 Some of the activities that cause events to be generated
are pressing a button, entering a character via the
keyboard, selecting an item in a list, and clicking the
mouse.

Event
11
Events may also occur that are not directly
caused by interactions with a user interface.
For example, an event may be generated
when a timer expires, a counter exceeds
a value, software or hardware failure
occurs, or an operation is completed.
 We are free to define events that are appropriate for
an application.

Event Sources
12
 A source is an object that generates an event. This
occurs when the internal state of that object changes in
some way.
 Sources may generate more than one type of event.
 A source must register listeners in order for the listeners
to receive notifications about a specific type of event.
 Each type of event has its own registration method.

13
 Here is the general form to register listeners:
 public void addTypeListener(TypeListener el)
 For example: b.addActionListener(this);
 Here, type is the name of the event, and el is a
reference to the event listener.
 For example, the method that registers a keyboard
event listener is called addKeyListener().
 The method that registers a mouse motion listener is
called addMouseMotionListener().
 When an event occurs, all registered listeners are
notified and receive a copy of the event object.

14
 The general form of unregister listener method is
this:
 Public void removeTypeListener(TypeListener el)
 Here, type is an object that is notified when an event
listener. For example, to remove a keyboard listener,
you would call removeKeyListener()

Event Listeners
15
 A listener is an object that is notified when an event
occurs.
 It has two major requirements. First, it must have
been registered with one or more sources to receive
notifications about specific types of events.
 Second, it must implement methods to receive and
process these notifications.
 The method that receive and process events are defined
in a set of interfaces found in java.awt.event.

Event Listeners
16
 For example, the MouseMotionListener interface
defines two methods to receive notifications when
the mouse is dragged or moved.
 Any object may receive and process one or both of
these events if it provides an implementation of this
interface.

Important Event Classes
and Interface
18

Event Classes
19
 The classes that represent events are at the core of Java’s
event handling mechanism.
 At the root of the Java event class hierarchy is EventObject,
which is in java.util. It is the superclass for all events.
EventObject contains two methods: getSource( ) and
toString( ).
 The getSource( ) method returns the source of the event. Its
general form is shown here:
 Object getSource( )
 As expected, toString( ) returns the string equivalent of the
event.

Event Classes
20
 The class AWTEvent, defined within the java.awt
package, is a subclass of EventObject.
 It is the superclass (either directly or indirectly) of all
AWT-based events used by the delegation event model.
EventObject is a superclass of all events.
AWTEvent is a superclass of all AWT events
that are handled by the delegation event
model

21
Event Classes Description Listener Interface
ActionEvent generated when button is pressed, menu-item is
selected, list-item is double clicked
ActionListener
MouseEvent generated when mouse is dragged, moved,
clicked, pressed or released and also when it
enters or exit a component
MouseListener
KeyEvent generated when input is received from keyboard KeyListener
ItemEvent generated when check-box or list item is clicked ItemListener
TextEvent generated when value of textarea or textfield is
changed
TextListener
MouseWheelEve
nt
generated when mouse wheel is moved MouseWheelListen
er
WindowEvent generated when window is activated,
deactivated, deiconified, iconified, opened or
closed
WindowListener
ComponentEv
ent
generated when component is hidden, moved,
resized or set visible
ComponentEventLi
stener
ContainerEven
t
generated when component is added or
removed from container
ContainerListener
AdjustmentEv generated when scroll bar is manipulated AdjustmentListene
r

22
 Steps to handle events:
 Implement appropriate interface in the class.
 Register the component with the listener.

Registration Methods
For registering the component with the Listener, many classes
provide the registration methods. For example:
Button
public void addActionListener(ActionListener a){}
MenuItem
TextField
public void addTextListener(TextListener a){}
TextArea
public void addTextListener(TextListener a){}
Checkbox
public void addItemListener(ItemListener a){}
Choice
public void addItemListener(ItemListener a){}
List
public void addItemListener(ItemListener a){}23

ActionEvent
 An ActionEvent is generated when a button is
pressed, a list item is double-clicked, or a menu item
is selected.
 The ActionEvent class defines four integer constants that are used
to identify modifiers associated with an action event:
 public static final int ALT_MASK The alt modifier.
 An indicator that the alt key was held down during the event.
 public static final int SHIFT_MASK The shift modifier.
 An indicator that the shift key was held down during the event.
 public static final int CTRL_MASK The control modifier.
 An indicator that control key was held down during the event.
 public static final int META_MASK The meta modifier.
 An indicator that the meta key was held down during the event.
(The Meta key is a modifier key on certain keyboards)

Constructor-1
25
public
ActionEvent(Object source,int id,String command,int modifiers)
 Constructs an ActionEvent object with modifier keys.
 Parameters: source - the object that originated the event
 id - an integer that identifies the event
 command - a string that may specify a command (possibly
one of several) associated with the event
 modifiers - the modifier keys held down during this action

public
ActionEvent(Object source,int id,String command,long w
hen, int modifiers)
Constructs an ActionEvent object with the specified
modifier keys and timestamp.
Parameters: source - the object that originated the event
id - an integer that identifies the event
command - a string that may specify a command
(possibly one of several) associated with the event
when - the time the event occurred
modifiers - the modifier keys held down during this action
Constructor-2
26

Methods
27
 public String getActionCommand()
 Returns the command string associated with this
action.
 public long getWhen()
 Returns the timestamp of when this event occurred.
 int getModifiers()
 Returns the modifier keys held down during this action
event.
 String paramString()
 Returns a parameter string identifying this action event.

ActionListener Interface
28
 This interface defines the actionPerformed() method
that is invoked when an action event occurs.
 Its general form is shown here:
 void actionPerformed(ActionEvent ae)

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
/* <applet code="ActionEventExample" width=200 height=200>
</applet> */
public class ActionEventExample extends Applet implements
ActionListener
{
String actionMessage="";
public void init()
{
Button Button1 = new Button("Ok");
Button Button2 = new Button("Cancel");
add(Button1);
add(Button2);
Button1.addActionListener(this); //Listener Registered
Button2.addActionListener(this); //Listener Registered
}
29

public void paint(Graphics g)
{
g.drawString(actionMessage,10,50);
}
public void actionPerformed(ActionEvent ae)
{
String action = ae.getActionCommand();
if(action.equals("Ok"))
actionMessage = "Ok Button Pressed";
else if(action.equals("Cancel"))
actionMessage = "Cancel Button Pressed";
repaint();
}
}
30

ComponentEvent class
32
 A low-level event which indicates that a
component moved, changed size, or changed
visibility.
 This class has following constants.
 public static final int COMPONENT_MOVED
 This event indicates that the component's position
changed.
 public static final int COMPONENT_RESIZED
 This event indicates that the component's size changed.
 public static final int COMPONENT_SHOWN
 This event indicates that the component was made visible.
 public static final int COMPONENT_HIDDEN
 This event indicates that the component was become

33
 public ComponentEvent(Component source, int id)
 Constructs a ComponentEvent object.
Parameters:
 source - the Component that originated the event
 id - an integer indicating the type of event
 Component getComponent()
 Returns the creator of the event.
 the Component object that originated the event, or null if
the object is not a Component.

ComponentLIstener interface
34
 The listener interface for receiving component events.
 void componentResized(ComponentEvent e)
 Invoked when the component's size changes.
 void componentMoved(ComponentEvent e)
 Invoked when the component's position changes
 void componentShown(ComponentEvent e)
 Invoked when the component has been made visible.
 void componentHidden(ComponentEvent e)
 Invoked when the component has been made invisible.

import java.awt.*;
import javax.swing.*;
public class ComponentEventExample1
{
public static void main(String[] args)
{
JFrame frame = new JFrame("ComponentEventExample");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
TextArea txtArea = new TextArea();
Checkbox checkbox1 = new Checkbox("Checkbox 1");
Checkbox checkbox2 = new Checkbox("Checkbox 2");
frame.add(txtArea, BorderLayout.CENTER);
frame.add(checkbox1, BorderLayout.NORTH);
frame.add(checkbox2, BorderLayout.SOUTH);
frame.setVisible(true);
ComponentListener componentListener = new MyCompList();
frame.addComponentListener(componentListener);
}
}35

class MyCompList implements ComponentListener
{
public void componentShown(ComponentEvent evt)
{
System.out.println("componentShown");
}
public void componentHidden(ComponentEvent evt)
{
System.out.println("componentHidden");
}
public void componentMoved(ComponentEvent evt)
{
System.out.println("componentMoved");
}
public void componentResized(ComponentEvent evt)
{
System.out.println("componentResized");
}
}36

ContainerEvent class
38
 A low-level event which indicates that a
container's contents changed because a
component was added or removed
 public static final int COMPONENT_ADDED
 This event indicates that a component was added to
the container.
 public static final int COMPONENT_REMOVED
 This event indicates that a component was removed
from the container.

39
 public ContainerEvent(Component source, int id,
Component child)
 Constructs a ContainerEvent object.
Parameters:
 source - the Component object (container) that
originated the event
 child - the component that was added or removed

40
 public Container getContainer()
 Returns the originator of the event.
 Returns the Container object that originated the event,
or null if the object is not a Container.
 public Component getChild()
 Returns the component that was affected by the event.
 Returns the Component object that was added or
removed.

ContainerListener interface
41
 The listener interface for receiving container events.
 void componentAdded(ContainerEvent e)
 Invoked when a component has been added to the
container.
 void componentRemoved (ContainerEvent e)
 Invoked when a component has been removed from the
container.

import java.awt.*;
public class ContainerEventExample
{
public static void main(String args[])
{
JFrame frame = new JFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Container contentPane = frame.getContentPane();
ContainerListener cont = new ContainerListener()
{
ActionListener listener = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
System.out.println("Selected: " + e.getActionCommand());
}
};42

public void componentAdded(ContainerEvent e)
{
Component c = e.getChild();
if (c instanceof JButton)
{
JButton b = (JButton) c;
b.addActionListener(listener);
}
}
public void componentRemoved(ContainerEvent e)
{
Component c = e.getChild();
if (c instanceof JButton)
{
JButton b = (JButton) c;
b.removeActionListener(listener);
}
}
};
43

contentPane.addContainerListener(cont);
contentPane.setLayout(new
GridLayout(3, 2));
contentPane.add(new JButton("First"));
contentPane.add(new
JButton("Second"));
contentPane.add(new JButton("Third"));
contentPane.add(new JButton("Fourth"));
contentPane.add(new JButton("Fifth"));
frame.setSize(300, 200);
frame.show();
}
44

FocusEvent class
46
 A low-level event which indicates that a Component
has gained or lost the input focus.
 public static final int FOCUS_GAINED
 This event indicates that the Component is now the
focus owner.
 public static final int FOCUS_LOST
 This event indicates that the Component is no longer
the focus owner.

Constructors
47
 public
FocusEvent(Component source,int id,boolean temp
orary, Component opposite)
 id - FOCUS_GAINED or FOCUS_LOST
 temporary - true if the focus change is temporary; false
otherwise
 opposite - the other Component involved in the focus
change, or null

48
 public
FocusEvent(Component source,int id,boolean temp
orary)
 temporary - true if the focus change is temporary; false
otherwise.
 public FocusEvent(Component source,int id)

Methods
49
 public boolean isTemporary()
 Identifies the focus change event as temporary or
permanent.
 Returns: true if the focus change is temporary; false
otherwise
 public Component getOppositeComponent()
 Returns the other Component involved in this focus
change.

FocusListener interface
50
 void focusGained(FocusEvent e)
 Invoked when a component gains the keyboard focus.
 void focusLost(FocusEvent e)
 Invoked when a component loses the keyboard focus.

import java.awt.*;
public class FocusListenerExample extends JFrame implements
FocusListener
{
Button b1,b2;
public FocusListenerExample()
{
b1=new Button ("First");
b2=new Button ("Second");
add(b1,BorderLayout.SOUTH);
add(b2,BorderLayout.NORTH);
b1.addFocusListener(this);
b2.addFocusListener(this);
setSize(200,200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}51

public void focusGained(FocusEvent fe) //method of focuslistener
{
if(fe.getSource()==b1)
System.out.println(b1.getLabel()+"gained");
System.out.println(b2.getLabel()+"gained");
if(fe.isTemporary())
System.out.println("Temporary Focus");
}
public void focusLost(FocusEvent fe) //in focusevent "getID()"is a
method
{
System.out.println(b1.getLabel()+"lost");
System.out.println(b2.getLabel()+"lost");
}
public static void main(String a[])
{
new FocusListenerExample();
}52

ItemEvent class
54
 A semantic event which indicates that an item was
selected or deselected.
 This high-level event is generated by an
ItemSelectable object (such as a List) when an item is
selected or deselected by the user.
 public static final int SELECTED
 This state-change value indicates that an item was
selected.
 public static final int DESELECTED
 This state-change-value indicates that a selected item
was deselected

55
 public ItemEvent (ItemSelectable source, int id,
Object item, int stateChange)
 Constructs an ItemEvent object.
 Parameters:
 source - the ItemSelectable object that originated the
event
 id - an integer that identifies the event type
 item - an object -- the item affected by the event
 stateChange - an integer that indicates whether the item
was selected or deselected

Methods of ItemEvent Class
56
 public ItemSelectable getItemSelectable()
 Returns the creator of the event.
 Returns: the ItemSelectable object that originated the event.
 public Object getItem()
 Returns the item affected by the event.
 Returns: the item (object) that was affected by the event.
 public int getStateChange()
 Returns the type of state change (selected or deselected).
 Returns: an integer that indicates whether the item was
selected or deselected

ItemListener interface
57
 The listener interface for receiving item events.
 void itemStateChanged(ItemEvent e)
 Invoked when an item has been selected or deselected
by the user.
 The code written for this method performs the
operations that need to occur when an item is selected
(or deselected).

import java.applet.*;
import java.awt.*;
/* <applet code="ItemListenerExample" width=200 height=200>
</applet> */
public class ItemListenerExample extends Applet implements
ItemListener
{
Checkbox java = null;
Checkbox vb = null;
Checkbox c = null;
58

public void init()
{
java = new Checkbox("Java");
vb = new Checkbox("Visual Basic");
c = new Checkbox("C");
add(java);
add(vb);
add(c);
java.addItemListener(this);
vb.addItemListener(this);
c.addItemListener(this);
}
public void paint(Graphics g)
{
g.drawString("Java: " + java.getState(),10,80);
g.drawString("VB: " + vb.getState(), 10, 100);
g.drawString("C: " + c.getState(), 10, 120);
}
public void itemStateChanged(ItemEvent ie)
{
repaint();
}
}
59

KeyEvent class
61
 An event which indicates that a keystroke occurred in a
component.
 This class has following constant.
 public static final int KEY_PRESSED
 This event is generated when a key is pushed down.
 public static final int KEY_RELEASED
 This event is generated when a key is let up.
 public static final int KEY_TYPED
 This event is generated when a character is entered. In the
simplest case, it is produced by a single key press. Often,
however, characters are produced by series of key presses,
and the mapping from key pressed events to key typed
events may be many-to-one or many-to-many.

62
 There are many other integer constants that are defined
by KeyEvent. For example
 VK_0 to VK_9
 VK_A to VK_Z define the ASCII equivalents of the numbers
and letters.
 Here are some others:
 VK_ENTER, VK_ESCAPE, VK_CANCEL, VK_UP, VK_DOWN,
VK_LEFT, VK_RIGHT, VK_PAGE_DOWN,VK_PAGE_UP,
VK_SHIFT, VK_ALT, VK_CONTROL
 The VK constants specify virtual key codes and are
independent of any modifiers, such as control, shift, or alt.

Methods of KeyEvent class
63
 public int getKeyCode()
 Returns the integer keyCode associated with the key in this
event.
 Returns: the integer code for an actual key on the keyboard.
 public char getKeyChar()
 Returns the character associated with the key in this event.
 For example, the KEY_TYPED event for shift + "a" returns the
value for "A".
• boolean isActionKey()
 Returns true if the key firing the event is an action key.
Examples of action keys include Page Up, Caps Lock, the
arrow and function keys.

KeyListener Interface
64
 Key events indicate when the user is typing at the
keyboard.
 Key events are fired by the component with the
keyboard focus when the user presses or releases
keyboard keys.
 Notifications are sent about two basic kinds of key
events:
 The typing of a Unicode character
 The pressing or releasing of a key on the keyboard

65
 The first kind of event is called a key-typed event.
 To know when the user types a Unicode character ? whether
by pressing one key such as 'a' or by pressing several keys in
sequence ?
 The second kind is either a key-pressed or key-released
event.
 To know when the user presses the F1 key, or whether the user
pressed the '3' key on the number pad, you handle key-pressed
events.

Methods of KeyListener Interface
66
Method Purpose
keyTyped(KeyEvent) Called just after the user types a
Unicode character into the listened-to
component.
keyPressed(KeyEvent) Called just after the user presses a key
while the listened-to component has
the focus.
keyReleased(KeyEvent) Called just after the user releases a
key while the listened-to component
has the focus.

import java.awt.*;
import javax.swing.JApplet;
public class EventDemo6 extends JApplet implements KeyListener
{
String event; // description of keyboard event
public void init() // set up UI
{
setLayout(new FlowLayout());
event = ""; addKeyListener(this); // listen for keyboard events
setFocusable(true); // force applet to receive KeyEvent
}
public void paint(Graphics g) // draw message to applet
{
super.paint(g);
g.drawRect(0, 0, getWidth(), getHeight()); // show bounds of applet
g.drawString(event, 10, 50);
}
67

public void keyPressed(KeyEvent e) // handle key presses
{
event = e.getKeyChar() + " pressed"; repaint();
}
public void keyReleased(KeyEvent e) // handle key releases
{
event = e.getKeyChar() + " released"; repaint();
}
public void keyTyped(KeyEvent e) // handle typing on applet
{
event = e.getKeyChar() + " typed"; repaint();
}
}
68

TextEvent class
69
 A semantic event which indicates that an object's text
changed.
 This high-level event is generated by an object (such as
a TextComponent) when its text changes.
 public TextEvent(Object source,int id)
 Constructs a TextEvent object.
 Parameters:
 source - the (TextComponent) object that originated the
event
 id - an integer that identifies the event type

TextListener interface
70
 The listener interface for receiving text events.
 void textValueChanged(TextEvent e)
 Invoked when the value of the text has changed.
 The code written for this method performs the
operations that need to occur when text changes.

WindowEvent class
71
 A low-level event indicates that a window has changed
its status.
 This event is generated by a Window object when it is
opened, closed, activated, deactivated, iconified, or
deiconified, or when focus is transferred into or out of
the Window.

int constants
72
 WINDOW_ACTIVATED
 WINDOW_CLOSED
 WINDOW_CLOSING
 WINDOW_DEACTIVATED
 WINDOW_DEICONIFIED
 WINDOW_GAINED_FOCUS
 WINDOW_ICONIFIED
 WINDOW_LOST_FOCUS
 WINDOW_OPENED
 WINDOW_STATE_CHANGED

Constructors
73
 public WindowEvent(Window source,int id)
 Constructs a WindowEvent object.
 Parameters: source - the Window object that originated the event
 - public WindowEvent(Window source,int id,Window opposite,int oldState,
int newState)
 Note that passing in an invalid id results in unspecified behavior.
This method throws an IllegalArgumentException if source is null.
 source - the Window object that originated the event
 id - an integer indicating the type of event.
 opposite - the other window involved in the focus or activation
change, or null
 oldState - previous state of the window for window state change
event
 newState - new state of the window for window state change event

74
 public Window getWindow()
 Returns the originator of the event.
 Returns: the Window object that originated the
event

WindowListener interface
75
 void windowOpened(WindowEvent e)
 Invoked the first time a window is made visible.
 void windowClosing(WindowEvent e)
 Invoked when the user attempts to close the window from the
window's system menu.
 void windowClosed(WindowEvent e)
 Invoked when a window has been closed as the result of calling
dispose on the window
 void windowIconified(WindowEvent e)
 Invoked when a window is changed from a normal to a minimized
state. For many platforms, a minimized window is displayed as the
icon specified in the window's iconImage property.
 void windowDeiconified(WindowEvent e)
 Invoked when a window is changed from a minimized to a normal
state.
 void windowActivated(WindowEvent e)
 Invoked when the Window is set to be the active Window.
 void windowDeactivated(WindowEvent e)
 Invoked when a Window is no longer the active Window.

WindowFocusListener interface
76
 The listener interface for receiving WindowEvents,
including WINDOW_GAINED_FOCUS and
WINDOW_LOST_FOCUS events.
 void windowGainedFocus(WindowEvent e)
 Invoked when the Window is set to be the focused Window,
which means that the Window, or one of its subcomponents, will
receive keyboard events.
 void windowLostFocus(WindowEvent e)
 Invoked when the Window is no longer the focused Window,
which means that keyboard events will no longer be delivered to
the Window or any of its subcomponents.

MouseEvent class
77
This event indicates a mouse action occurred in a
component. This low-level event is generated by a
component object for Mouse Events and Mouse
motion events.

Constants for java.awt.event.MouseEvent class:
static int BUTTON1 --Indicates mouse button #1; used by
getButton()
getButton()
getButton()
static int MOUSE_CLICKED --The "mouse clicked" event
static int MOUSE_DRAGGED --The "mouse dragged" event
static int MOUSE_ENTERED --The "mouse entered" event
static int MOUSE_EXITED --The "mouse exited" event
static int MOUSE_MOVED --The "mouse moved" event
static int MOUSE_PRESSED -- The "mouse pressed" event78

Constructor
79
 MouseEvent(Component source, int id, long when,
int modifiers, int x, int y, int clickCount, boolean
popupTrigger)
 Constructs a MouseEvent object with the specified
source- source component,
id- type of event,
when- system time at mouse event occurred
modifiers-to know what modifiers were pressed after
event was occurred,
x & y- coordinates of the mouse ,
clickCount- click count
popupTrigger- whether popup menu appeared

80
Method Purpose
int getClickCount()
Returns the number of quick, consecutive
clicks the user has made (including this
event). For example, returns 2 for a
double click.
int getButton()
Returns which mouse button, if any, has a
changed state. One of the following
constants is returned: NOBUTTON,
BUTTON1, BUTTON2, or BUTTON3.
int getX()
int getY()
Return the (x,y) position at which the
event occurred, relative to the component
that fired the event.
Point getPoint() Returns the x,y position of the event
rlative to the source component.

MouseListener Interface
81
 Mouse events notify when the user uses the mouse (or
similar input device) to interact with a component.
 Mouse events occur when the cursor enters or exits a
component's onscreen area and when the user presses
or releases one of the mouse buttons.

Methods of MouseListener Interface
82
Method Purpose
mouseClicked(MouseEvent) Called just after the user clicks the
listened-to component.
mouseEntered(MouseEvent) Called just after the cursor enters the
bounds of the listened-to component.
mouseExited(MouseEvent) Called just after the cursor exits the
bounds of the listened-to component.
mousePressed(MouseEvent) Called just after the user presses a
mouse button while the cursor is over
the listened-to component.
mouseReleased(MouseEvent) Called just after the user releases a
mouse button after a mouse press over
the listened-to component.

MouseMotionListener Interface
83
 Mouse-motion events notify when the user uses the mouse (or a
similar input device) to move the onscreen cursor.
 If an application requires the detection of both mouse events and
mouse-motion events, use the MouseInputAdapter class.
 It implements the MouseInputListener a convenient interface that
implements both the MouseListener and MouseMotionListener
interfaces.

Methods of MouseMotionListener Interface
84
Method Purpose
mouseDragged(MouseEvent)
Called in response to the user moving the mouse
while holding a mouse button down. This event
is fired by the component that fired the most
recent mouse-pressed event, even if the cursor is
no longer over that component.
mouseMoved(MouseEvent)
Called in response to the user moving the mouse
with no mouse buttons pressed. This event is
fired by the component that's currently under the
cursor.

import java.awt.*;
public class MouseEventDemo extends JApplet implements
MouseListener
{
private int x; // x coordinate of mouse event
private int y; // y coordinate of mouse event
private String event; // description of mouse event
public void init() // set up GUI
{
setLayout(new FlowLayout());
addMouseListener(this); // listen for mouse events
x = -1; // set x negative for no initial
message
}
85

public void paint(Graphics g) // draw message to screen
{
super.paint(g);
g.drawRect(0, 0, getWidth(), getHeight()); // show bounds of applet
if(x != - 1) // display event during repainting only
{
g.drawString("Mouse event " + event +
" at (" + x + ", " + y + ")",
10, 50);
}
}
public void mousePressed(MouseEvent e) // save coordinates of
presses
{
x = e.getX();
y = e.getY();
event = "press";
repaint();
86

public void mouseClicked(MouseEvent e) // save coordinates of
clicks
{
x = e.getX();
y = e.getY();
event = "click";
repaint();
}
public void mouseReleased(MouseEvent e) // save coordinates of
releases
{
x = e.getX();
y = e.getY();
event = "release";
repaint();
}
87

public void mouseEntered(MouseEvent e) // save coordinates when
mouse enters applet
{
x = e.getX();
y = e.getY();
event = "enter";
repaint();
}
public void mouseExited(MouseEvent e) // save coordinates when
mouse leaves applet
{
x = e.getX();
y = e.getY();
event = "exit";
repaint();
}
}
/*<applet code=MouseEventDemo height=300 width=300></applet>*/88

AdjustmentEvent
89
 An AdjustmentEvent is generated by a scroll bar. There are five
types of adjustment events.
 The AdjustmentEvent class defines integer constants that can be
used to identify them.
 BLOCK_DECREMENT
 The user clicked inside the scroll bar to decrease its value.
 BLOCK_INCREMENT
 The user clicked inside the scroll bar to increase its value.
 TRACK
 The slider was dragged.
 UNIT_DECREMENT
 The button at the end of the scroll bar was clicked to decrease its value.
 UNIT_INCREMENT
 The button at the end of the scroll bar was clicked to increase its value.

90
 The type of the adjustment event may be obtained by
the getAdjustmentType( ) method. It returns one of the
constants defined by AdjustmentEvent.
 The general form is shown here:
int getAdjustmentType( )
 The amount of the adjustment can be obtained from
the getValue( ) method, shown here:
int getValue( )
 For example, when a scroll bar is manipulated, this
method returns the value represented by that change.

AdjustmentListener Interface
91
 This interface defines the adjustmentValueChanged( )
method that is invoked when an adjustment event
occurs.
 Its general form is shown here:
 void adjustmentValueChanged(AdjustmentEvent
ae)

92
Summary of Event
Classes & Listeners

Adapter Classes
97
 Java provides a special feature, called an adapter class
that can simplify
 the creation of event handlers in certain situations. An
adapter class provides
 an empty implementation of all methods in an event
listener interface. Adapter
 classes are useful when we want to receive and process
only some of the
 events that are handled by a particular event listener
interface. We can define a
 new class to act as an event listener by extending one of
the adapter classes
 and implementing only those events in which we are
interested. For example,
 the MouseMotionAdapter class has two methods,
mouseDragged( ) and
 mouseMoved( ).

Advance Java Programming(CM5I) Event handling

More Related Content

What's hot (20)

Similar to Advance Java Programming(CM5I) Event handling (20)

Recently uploaded (20)

Advance Java Programming(CM5I) Event handling