Event Handling 1.02

1
Event Handling - 1.02 Yangjun Chen Dept.
Business Computing University of Winnipeg
2
Outline 1.02 Events

• Events in Java 1.02
• The Event Class
• The Event Hierarchy
• Event Handling
• - handleEvent()
• - helper methods
• Keyboard Events
• Mouse Events
• Other Events

3
Event Driven Programming

• Events can be generated by a lot of things
• moving the mouse, scrolling, clicking on
  buttons, a key press, etc.
• These events have to be recognized and handled by
  the program.
• Java provides methods for handling these events
  in the Event
• class.
• All events dont have to be handled by you, for
  example,
• painting is an event that you dont have to deal
  with.
• There are two event models in Java Java 1.0
  model and Java 1.1 model.
• - We will discuss the Java 1.0 event model and
  then Java 1.1.

4
Event Class

• This class contains a large collection of class
  constants.
• They are used to describe the nature of the
  event.
• other constants provide additional information
  about the events.
• There are 27 class constants. They are used to
  represent different events - Buttons,
  Checkboxes, Choices, Lists, MenuItems, and
  TextFields
• - Key presses - KEY_ PRESS, KEY_ RELEASE ...
• - Mouse actions - MOUSE_ UP, MOUSE_ DOWN ...
• - List selections - LIST_ SELECT, LIST_
  DESELECT
• - Scrollbar actions - SCROLL_ LINE_ UP ...
• - Window actions - WINDOW_ DESTROY ...
• - File related events - LOAD_ FILE, SAVE_ FILE
• - Input focus events - GOT_ FOCUS, LOST_ FOCUS

5
Event Class

• These names are declared to be public static
  final.
• What does this mean?
• There are four constants describing multikey
  combinations
• (SHIFT_ MASK, ALT_ MASK, META_ MASK, CTRL_
  MASK).
• F1 through F12, LEFT, RIGHT, UP, DOWN, HOME,
• END, PGUP, PGDN refer to other keys
• In addition to these class constants, the event
  class has a set of
• public instance variables that provide more
  information about the event. The important ones
  are shown below
• - Object arg - miscellaneous information (i.e.,
  label string)
• - int id - what kind of event it is (i. e. class
  constant)
• - Object target - the object that generated this
  event
• Not all these fields apply to all events.
• - The arg field will contain no useful
  information for mouse events.

6
Event Hierarchy

• When an event is generated, Java creates a new
  Event object
• and places it into an event queue.
• - Event queue a list of events waiting to be
  handled
• When the event is at the front of the list, Java
  will decide which object will get to handle the
  event first.
• - Ex. If a mouse click happens above a Checkbox,
  the
• ACTION_ EVENT event will be generated, so the
  Checkbox will
• be the first object to get that event.
• - The Checkbox might have a handleEvent() method
  that will handle or respond to the event.
• - Now, if the Checkbox didnt have a method to
  handle this event,
• the event gets passed up to the next most
  appropriate object, the
• parent component.

7
Event Hierarchy

• - Eventually, the event will be handled by one
  of the objects in the
• GUI, or it would never be handled and simply
  expire with no
• response.
• Its important to note the path along which an
  event is transferred, from an object to its
  parent, is not up the class hierarchy but up the
  containment hierarchy or GUI hierarchy.
• Normally, an object should handle its own events
  whenever
• possible, but this isnt possible all the time
  or wanted even.
• - Suppose the parent has access to information
  that the child does
• not, then it makes sense that the parent will
  handle the event.

8
Event Hierarchy
appletFrame
panel1
panel1
panel2
checkbox
panel2
checkbox1
checkbox2
checkbox3
applet
9
Event Hierarchy
Event queue
...
previousBttn
nextBttn
Applet
Applet
nextBttn
previousBttn
ltlt
gtgt
panel
nextBttn
previousBttn
panel
10
Event Models

• Events are generated and flow through the system
  in roughly the same manner for both event
  models.
• The difference between the two models is how the
  events are
• processed.
• In the 1.02 event model, events flow through the
  program and are handled by a method called
  handleEvent() while in 1.1 event model the
  concept of listeners is used.
• handEvent() is defined within the Component class
  and must be overridden (writing your own method).

11
handleEvent()

• Notice that handleEvent is made public so that
  the system can
• access it when needed.
• public boolean handleEvent( Event e)
• if (e.id Event.WINDOW_ DESTROY)
• System.exit( 0)
• return true
• else
• return super.handleEvent( e)

12
handleEvent()

• The return from a handleEvent method determines
  what
• happens to the event when the method exits (when
  you are
• finished with it)
• - If handleEvent(e) returns true , then event e
  will die in this
• method and not propagated any further.
• - If false is returned, the event e will be
  passed up the visual
• hierarchy so that the parent objects own
  handleEvent method
• can handle the event.
• super.handleEvent(e) will pass the event to the
  class
• immediately above the object in the class
  hierarchy.
• - Is this different from the GUI hierarchy?
• If handleEvent fails to return true, Java will
  try again by
• looking at the targets helper methods like
  mouseDown or
• action.

13
handleEvent
public class CardTest extends Applet Button
nextBttn new Button(gtgt) Button
previoursBttn new Button(ltlt)
... public boolean action( Event e, Object arg)
if (e. target nextBttn) cdLayout.
next( cardPanel) else if (e. target
previousBttn) cdLayout. previous(
cardPanel) else return false return
true // end of action method // end of
class
14
handleEvent
public class CardTest extends Applet Button
nextBttn new Button(gtgt) B1 previoursBttn
new B1(ltlt) ... // end of
class class B1 extends Button public
boolean action(Event e, Object arg)

15
e.id Event.ACTION_EVENT e.id
Event.KEY_PRESS ...
Button, Checkbox, Choice List, MenuItem, TextField
handleEvent(Event e)
action(Event e, Object arg) keyDown(Event e, int
key) mouseDown(Event e, int x, int
y) gotFocus(Event e)
helper methods
16
Helper Methods

• These are also known as convenience methods
  because they are often more convenient to use
  than the handleEvent method.
• For instance, an ACTION_ EVENT is generated by a
  Button, Checkbox, Choice, List, MenuItem, or
  TextField object. Use the helper method action()
  which responds only to ACTION_ EVENTS.
• The action method takes two arguments, the event
  to be handled and another that has different
  meanings, depending on the event.
• public boolean action( Event e, Object arg)
• // handler for one of the above mentioned
  objects

17
Helper Methods

• Other helper methods
• - public boolean keyDown(Event e, int key)
• - public boolean keyUp(Event e, int key)
• These are invoked by key events with the key
  argument
• containing the code of the key pressed
• - public boolean mouseDown(Event e, int x, int
  y)
• - public boolean mouseDrag(Event e, int x, int
  y)
• - public boolean mouseExit(Event e, int x, int
  y)
• - public boolean mouseMove(Event e, int x, int
  y)
• - public boolean mouseUp(Event e, int x, int y)
• Invoked by the corresponding mouse events with
  x and y specifying the coordinates where the
  pointer was during the event, measured in the
  Components local coordinate system.

18
Helper Methods

• All of these helper methods return a boolean
  value just like the
• handleEvent method.
• Now that we have an event, how do we know what
  type of event it is?
• As mentioned earlier, each Event has associated
  with it a list of fields that provide further
  information about the event.
• They are all public fields, so they can be
  referenced using the
• objects name with the dot operator.
• The arg field is the most complex of them all
  because it
• depends on the type of event. For the
  ACTION_EVENTs in
• buttons, choices, lists, or menu items, the arg
  field is a string
• representing the label or name of the selected
  item.

19
Helper Methods

• If an ACTION_EVENT was generated from a checkbox,
  the arg field would be a boolean value
  representing the new state of the checkbox.
• In a LIST_SELECT or LIST_DESELECT event, the arg
  field
• is the index of the list element that was
  selected.
• Another important field is the target field. This
  field can be
• used to categorize the event by using the
  boolean operator
• instanceof .
• - instanceof takes an operand on either side,
  the left side is a
• variable representing an object, the right side
  is a class name. It returns true if the
  variable is an instance of that type or an
  instance of a subclass of that type.

20
Helper Methods
public boolean action( Event e, Object arg)
if (e. target instanceof List) // Once
we get here, we know the event was
triggered // within one of our three
lists String c (String) arg // get the list
items name if (e. target
sandwiches) System. out. println( Sandwich
chosen c) else if( e. target
drinks) System. out. println( Drink chosen
c) else if( e. target
sides) System. out. println( Side order
chosen c) // end of if block for List
object
21
Helper Methods
// The event wasnt triggered in a list, so we
see if it came // from the superSize checkbox,
the order button, // or the sizes chosen else
if (e. target superSize) System.out.println(
Supersize box clicked!) else if (e. target
order) System.out.println( Order button
clicked!) else if (e. target
sizes) System. out. println( Size choice
clicked!) return true // Weve handled all
possible action events, // so kill the
event // end of action method
22
Helper Methods

• This program deals with possible events that can
  happen in three List objects, a Checkbox object,
  a Button object, and a Choice object.
• To check if the event was one of the list
  objects, we first check to see if the event was
  an instance of a List type
• - e. target instanceof List
• If it is an instance of a List object, then it is
  tested to see which list generated the event.
• Otherwise, we continue and find the appropriate
  object that
• generated the event.

23
Keyboard Events

• To capture a keyboard event in the 1.02 model,
  use the
• keyDown() method
• - public boolean keyDown( Event e, int key)
  
• The key pressed is passed to the keyDown() method
  as the key
• argument, which is of type int. It is a Unicode
  representation
• of the key pressed.
• To use the key as a character, it must be cast to
  type char
• - keypressed ( char) key
• As with mouse clicks, each key down event has a
  corresponding key up event.
• - public boolean keyUp( Event e, int key)

24
Keyboard Events

• Example
• To check the key constants of RIGHT, UP, DOWN,
  etc
• - if (key Event. UP)
• Because the values that these class variables
  hold are constants, a switch statement can be
  used to test for them.

public boolean keyDown( Event e, int key)
System. out. println( ASCII value
key) System. out. println( Character
(char) key) return true
25
Masks

• The modifier masks SHIFT_MASK, ALT_MASK,
  META_MASK, CTRL_MASK are used with key events to
  determine if a modifier key was pressed.
• When a key event is generated, the modifier key,
  if present, will set certain bits in the events
  modifiers field.
• Once a handler has control of an event, the
  modifier field can be tested to determine if any
  modifiers were pressed.
• To inspect these modifiers, we go back to the
  logical operators and .
• For example, suppose we use four bits to
  represent these four
• modifiers, in the order, SHIFT_MASK, ALT_MASK,
• META_MASK, CTRL_MASK.

26
Masks

• We would then have these combinations or masks
• representing the modifiers pressed
• - 0000 no modifiers
• - 1000 Shift key pressed
• - 0100 Alt key pressed
• - 0010 Meta key pressed
• - 0001 Ctrl key pressed
• Other combinations are possible, for example
• - 1101 indicates that Shift- Alt- Ctrl keys were
  pressed.
• Using these masks we can extract a single bit
  from the modifiers field.

27
Logical Operations Revisited

• AND function
• - results in a 1 if both bits that are being
  ANDed together are 1
• - example
• OR function
• - results in 1 if either or both of the
  arguments are 1
• - example

28
Masks

• So if e is an Event, the expression
• - e.modifiers Event.ALT_MASK
• will result in 0 if the Alt key has not been
  pressed.
• We can use the OR operator to test for the
  presence of two or
• more modifiers
• Using the masks that were defined previously, we
  would have
• Event.SHIFT_MASKEvent.CTRL_MASK
• equal to the pattern 1001.
• So to test for the presence of either modifier
• if (( e. modifiers( Event. SHIFT_ MASK Event.
  CTRL_MASK))! 0)
• // One or both modifier keys were pressed
• else
• // neither was pressed

29
Masks

• To check both modifiers simultaneously, we would
  write
• if ((( e.modifiers Event. SHIFT_ MASK) ! 0)
  
• (( e.modifiers Event. CTRL_ MASK) ! 0))
• // Both modifier keys were pressed
• else
• // One wasnt pressed or neither was pressed
• The Event class has methods that allow you to
  determine if a
• modifier key is present controlDown(),
  metaDown(),
• shiftDown(). There is no method to test for the
  Alt key,
• masks must be used for that.

30
Mouse Events

• Clicking the mouse will generate two events in
  the 1.02 AWT a mouse down and a mouse up event.
• Handling mouse events are easy, you just have to
  override the
• right methods that were shown previously.
• Example
• public boolean mouseDown( Event e, int x, int
  y)
• System. out. println( Mouse down at x,
  y)
• return true
• By including this in your applets, every time the
  user clicks on
• the applet, the coordinates will be output.

31
Spots Applet
import java. awt. Graphics import java. awt.
Color import java. awt. Event public class
Spots extends java. applet. Applet final int
MAXSPOTS 10 int xspots new int
MAXSPOTS int yspots new int
MAXSPOTS int currspots 0 public void
init() setBackground( Color.
white) //end of init() method
32
Spots Applet
public boolean mouseDown( Event e, int x, int
y) if (currspots lt MAXSPOTS) addspot(
x, y) return true else
System. out. println( Too many
spots!!) return false // end of
the mouseDown method
33
Spots Applet
void addspot( int x, int y) xspots
currspots x yspots currspots
y currspots repaint() // end of
addspot method public void paint( Graphics g)
g. setColor( Color. blue) for (int i 0
ilt currspots i) g. fillOval( xspots i -
10, yspots i - 10, 20, 20) // end of
paint method // end of class
34
Double Clicks

• The Java Event class provides a variable
  clickCount to
• track double- or triple- clicks.
• clickCount is an integer that represents the
  number of
• consecutive clicks that have occurred.
• You can test this value by the following code
• public boolean mouseDown( Event e, int x, int
  y)
• switch (e. clickCount)
• case 1 // single- click
• case 2 // double- click
• case 3 // triple- click
• ...

35
Focus Events

• There are two helper methods for Focus events
• - gotFocus, lostFocus,
• Focus events are generated when a component has
  received
• input focus (i. e. when a user has clicked in a
  text field)
• This can be useful to implement a user interface
  that allows the
• user to use the Tab key to move from one
  component to the next, or to allow keyboard
  equivalents to button presses

36
Scroll Events

• To catch events that occur in scrollbars, you
  must use the
• handleEvent method.
• You would then trap each of the constants
• - SCROLL_ LINE_ UP, SCROLL_ LINE_ DOWN,
• - SCROLL_ PAGE_ UP, SCROLL_ PAGE_ DOWN, and
• - SCROLL_ ABSOLUTE
• To trap

SCROLL_ PAGE_DOWN
SCROLL_ PAGE_DOWN
SCROLL_ LINE_ down
SCROLL_ LINE_ UP
SCROLL_ ABSOLUTE