Object-Oriented Programming with Java Lecture Notes

8 April 2008 • Event Handling

Outline

• Event-driven programming.

• Java event abstractions.

  • Events and listeners.

• Interacitve graphics programming.

  • Mouse and keyboard.

Sequential Programming

• A many programs follow the sequential processing model:

  main()
    data = input()
    data = process data()
    output(data)
  

  

• The sequential model is useful, but limited.

Sequential Breakdown

• Can you write a sequential program to drive a car?

  • Probably not. Why not?

  The car inputs are Varied Unscheduled Continuous

• What does a car-driving program look like?

Sequential Rehabilitation

• Reinterpret the sequential model slightly:

• This is known as reactive programming.

So What?

$ echo 100 400 100 100 400 400 100 400 | 
  java DCShow 15

This is a sequential program.

Improving the Viewer

• Interactive toys are more fun:

  • Input points on the curve.

  • View the curve at various orders.

  without jumping in and out of the program.

• Use the mouse to pick curve points, and the keyboard to specify dragon-curve order.

  

Interactive Programs

• The improved viewer is an example of an interactive program.

  • Interactive programs are a subclass of reactive programs.

  • One of the earliest and most widespread forms of reactive programs.

• The techniques and abstractions around reactive programming may be useful for interactive programming.

Events

• One more slight reinterpretation provides the key abstraction:

  

  • Abstract the action as an event.

  • Abstract the program as an event handler.

• Java (and many other system) organize interactive (and reactive) programming around the event and event handler abstractions.

The Event Class

• The EventObject class is the event hierarchy root.

  public class EventObject
  
    protected Object source
  
    EventObject(Object source)
  
    Object getSource()
    String toString()
  

• The source is the abstraction of the environmental cause of the event.

Mouse Events

Event Handlers

• Java calls event handlers event listeners.

• The EventListener is the root of the event-listener hierarchy.

  • The event-listener hierarchy roughly parallels the event hierarchy.

• The EventListener interface is a tagging interface.

  • It defines no methods or constants.

• By convention, Handlers implement Listeners.

The Mouse Listener

interface MouseListener
extends EventListener

  void mouseClicked(MouseEvent e)

  void mouseEntered(MouseEvent e)

  void mouseExited(MouseEvent e)

  void mousePressed(MouseEvent e)

  void mouseReleased(MouseEvent e)

Point Picking

• Each mouse click selects a point on the curve, extending it by one line segment.

  class LineMaker
  implements MouseListener
  
    mouseClicked(MouseEvent e) 
      xCoords[n] = e.getX()
      yCoords[n++] = e.getY()
      repaint()
  

• Are we done?

Completing The Listener

• Interfaces are abstract classes; methods are abstract.

  • No instances until all methods are defined.

  mouseEntered(MouseEvent e)
    System.err.println("Enter the mouse")
  
  mouseExited(MouseEvent e)
    System.err.println("Exit the mouse")
  
  mousePressed(MouseEvent e)
    System.err.println("Mouse pressed")
  
  mouseReleased(MouseEvent e)
    System.err.println("Mouse released")

Attaching the Listener

• A event-handler instance has to be introduced somewhere so it can be called.

  • addMouseListener() is defined in Component.

  • Finding the right descendant can be tricky.

• Adding a handler too high risks stealing events from downstream handlers.

• Adding a handler too low risks having upstream handlers stealing events.

Attaching the Listener

• In the dragon-curve shower it's either the frame or the panel.

  • Clues:

    • An applet has no frame.

    • A frame has not direct graphics.

• It seems the panel’s the winner.

Mousing Around

In Action

The Current State

Handling Scope

• How can the mouse-handler instance get access to panel-instance features?

  • They're shared, so moving them doesn't solve anything.

• There's lots of possibilities, three of them are

  1. Share the state.

  2. Use inner classes.

  3. Mush everything into one class.

Sharing State

• The panel class gives features package scope.

• The handler instance gets a reference to the panel.

In the panel: private int xCoord[], yCoord[], n DragonPanel() setMouseListener( new MouseHandler(this)) addPoint(int x, int y) xCoord[n] = x xCoord[n++] = y repaint()

In the handler: private JPanel panel MouseHandler(JPanel p) panel = p mouseClicked(MouseEvent e) panel.addPoint( e.getX(), e.getY())

Sharing Analysis

• Clean sharing between class instances creates a well-defined separation of concerns.

  • But the sharing has to be clean and well-defined.

• It may require some extra design to provide a good event-handler interface.

  • But not much for a well-designed class.

• Sharing unveils details which are better off kept internal.

Inner Classes

Inner-Class Analysis

• Inner classes keep internal details veiled thanks to outer-class scope.

  • At the cost of bloating the host class with the inner class.

• There may be a tendency to skip internal design because “everything’s global anyway.”

  • The path to maintenance hell.

Mushed Classes

• The panel implements the mouse listener itself.

  class DragonPanel
  extends JPanel
  implements MouseListener
  
    private int 
      xCoord[], yCoord[], n
  
    DragonPanel()
      setMouseListener(this)
  
    mouseClicked(MouseEvent e)
      xCoord[n] = x
      xCoord[n++] = y
      repaint()
  

Mushed-Class Analysis

• Mushed classes are roughly equivalent to inner classes.

  • Inner classes have better name-space control, in the unlikely event that's a problem.

• Mushed classes don't introduce the overhead that inner classes do.

  • Both syntatic and semantic overhead.

Changing Order

• The dragon-curve toy should present the curve at different orders.

• Typing digit d on the keyboard should display the curve of order d.

  • And also stop inputting points for the current curve.

  

Keyboard Events

The Keyboard Listener

• As a keying device, the keyboard is similar to the mouse.

  interface KeyListener
  extends EventListener
  
    void keyPressed(KeyEvent e)
  
    void keyReleased(KeyEvent e)
  
    void keyTyped(KeyEvent e)
  

Key Handling

• Each digit draws the dragon curve at the given order.

  class KeyHandler
  implements KeyListener
  
    keyTyped(KeyEvent e) 
      int d = 
        Character.digit(e.getKeyChar(), 16)
      if (d > -1)
        curveOrder(d)
        repaint()
  

• And the rest of the KeyListener abstract methods.

New Curve Orders

• See the the code.