Eventbehandlung

Eventbehandlung
DVG3 - Eventbehandlung
1
Events
DVG3 - Eventbehandlung
2
Events sind externe Ereignisse, die parallel zum normalen
Programmablauf auftreten.
Beispiele:
Mouse-Events
Tastatur-Events
Externe Unterbrechungen (Interrupts)
Eventbehandlung
Event
DVG3 - Eventbehandlung
3
Normaler
Programmablauf
Behandlung
des
Events
Gemeinsamkeiten der Eventbehandlung
DVG3 - Eventbehandlung
4
In einer bestimmten Komponente wird das Ereignis ausgelöst.
In einer anderen Komponente wird das Ereignis behandelt.
Beim Eintreten eine Ereignisses wird ein Objekt erzeugt, das alle
Informationen über das Ereignis enthält. Dieses Objekt wird der
Behandlungskomponente übergeben. Z.B.:
Drücken einer Mouse-Taste:
• wie oft wurde die Taste gedrückt
• x- und y- Koordinate des Mouse-Zeigers zum Zeitpunkt des
Eintreten des Ereignisses
Drücken einer Taste der Tastatur
• Welche Taste wurde gedrückt
• Welche Modifikationstaste wurde gleichzeitig gedrückt
• Wird die Taste lange gedrückt
Methoden der Eventbehandlung
DVG3 - Eventbehandlung
5
Methoden unterscheiden sich in folgenden Punkten
Welche Komponente wird über das Auftreten eines Ereignisses
informiert ?
Wie werden aufgetretene Ereignisse unterschieden?
In JAVA sind drei Methoden implementiert:
1. Ereignisbehandlung nach dem Event-Modell des JDK 1.0
Standardmethode im JDK 1.0
Bedeutung bei der Entwicklung von Applets
Sollte nicht mehr verwendet werden
2. Ereignisbehandlung nach dem Delegationsmodell
Standardmethode ab JDK 1.1
Sollte immer verwendet werden, wenn nicht wichtige Gründe
dagegen sprechen.
3. Ereignisbehandlung für die Komponentenentwicklung
Event-Modell des JDK 1.0
Beim Auftreten eines Ereignisses wird ein Objekt der Klasse Event
erzeugt. Dieses enthält alle Informationen darüber
welches Ereignis aufgetreten ist
und Daten des Ereignisses
Es sind nur die für das Ereignis interessanten Attribute belegt.
DVG3 - Eventbehandlung
6
Attribut
Bedeutung
Event.id
Art des Ereignisses
Event.arg
Zusatzinformation, abhängig von der Art
Event.clickCount
Anzahl der Mausklicks
Event.key
Tastencode der gedrückten taste
Event.modifiers
Status der Modifizierungstasten "Strg","Shift","Alt"
Event.target
Komponente, in der das Ereignis ausgelöst wurde
Event.when
Zeit der Auslösung des Ereignisses
Event.x
x-Koordinate des Ereignisses
Event.y
y-Koordinate des Ereignisses
DVG3 - Eventbehandlung
7
In der Klasse Component und damit in allen Klassen des AWT ist die
Methode
public boolean handleEvent(Event evt)
definiert.
Diese Methode wird in dem Objekt mit dem entsprechenden EventObjekt aufgerufen in dem das Ereignis aufgetreten ist.
handleEvent liefert einen boolean-Wert:
true : Ereignis wurde erfolgreich behandelt
false : Ereignis wurde nicht behandelt
Wenn ein Ereignis nicht behandelt wurde (handleEvent liefert
false) wird die Methode handleEvent in dem Objekt aufgerufen,
das in der AWT-Objekthierarchie eine Stufe höher steht.
Zur Vereinfachung der Nutzung existieren Hilfsmethoden für häufig
auftretende Ereignisse.
DVG3 - Eventbehandlung
8
public boolean handleEvent(Event evt) {
switch (evt.id) {
case Event.MOUSE_ENTER:return mouseEnter(evt, evt.x, evt.y);
case Event.MOUSE_EXIT: return mouseExit(evt, evt.x, evt.y);
case Event.MOUSE_MOVE: return mouseMove(evt, evt.x, evt.y);
case Event.MOUSE_DOWN: return mouseDown(evt, evt.x, evt.y);
case Event.MOUSE_DRAG: return mouseDrag(evt, evt.x, evt.y);
case Event.MOUSE_UP:
return mouseUp(evt, evt.x, evt.y);
case Event.KEY_PRESS:
case Event.KEY_ACTION: return keyDown(evt, evt.key);
case Event.KEY_RELEASE:
case Event.KEY_ACTION_RELEASE: return keyUp(evt, evt.key);
case Event.ACTION_EVENT:return action(evt, evt.arg);
case Event.GOT_FOCUS: return gotFocus(evt, evt.arg);
case Event.LOST_FOCUS: return lostFocus(evt, evt.arg);
}
return false;
}
Die Hilfsmethoden in Component sind leer und liefern den Wert
false.
Zur Behandlung eines Ereignisses muss entweder die entsprechende
Hilfsmethode oder die Methode handleEvent überschrieben werden.
DVG3 - Eventbehandlung
9
Für einige Ereignisse existieren keine Hilfsmethoden.
 handleEvent muss überschrieben werden, um diese Ereignisse
zu behandeln
import java.awt.*;
public class Paint1 extends Frame
{
public static void main(String[] args)
{ new Paint1("Paint"); }
private int x0, y0;
DVG3 - Eventbehandlung
10
private Panel gPanel = new Panel(){
public boolean mouseDown(Event e, int x, int y)
{
x0 = x;
y0 = y;
return true;
}
public boolean mouseDrag(Event e, int x, int y)
{
gPanel.getGraphics().drawLine(x0,y0,x,y);
x0 = x;
y0 = y;
return true;
}
};
Paint1 (String title)
{
super(title);
setBounds(0,0,400,400);
add(gPanel);
setVisible(true);
}
}
DVG3 - Eventbehandlung
11
DVG3 - Eventbehandlung
12
Vorteile des Event-Modells
Relativ leicht nutzbar
Geringer Programmieraufwand
Nachteile des Event-Modells
Komponentenhierarchie bestimmt den Ereignisfluss
Nichtbehandelte Ereignisse werden immer weitergereicht
 Performance-Verlust bei oft auftretenden Ereignissen, z.B.
Maus-Events.
Delegationsmodell ab JDK 1.1
DVG3 - Eventbehandlung
Das Delegationsmodell ist das ab JDK 1.1 bevorzugte
Ereignisbehandlungsmodell.
Es gibt eine Klassenhierarchie von Ereignissen. Dadurch ist die
Unterscheidung der Ereignisse einfacher.
Objekte in denen Ereignisse auftreten können, ermöglichen die
Anmeldung (Registrierung) von Ereignisbehandlungsobjekten (EventListener). Diese werden dann über das Auftreten des Ereignisses
informiert.
Registrierung
Event-Listener
Benachrichtigung
Weiterarbeit
13
Programm
in dem ein
Event
ausgelöst wird
DVG3 - Eventbehandlung
14
Vorteile:
Es können sich bei einem Programm beliebig viele Event-Listener
anmelden. Alle werden dann über das Eintreten des Ereignisses
informiert. Die Reihenfolge ist allerdings nicht definiert.
Für das gleiche Ereignis in verschiedenen Programmen können die
selben oder verschiedene Event-Listener eingesetzt werden. Dadurch ist
es möglich, die Programme in denen die Events aufgetreten sind zu
unterscheiden.
Es kann einfacher unterschieden werden zwischen den Events (viele
unterschiedliche Arten von Events).
Es ist einfacher, JAVA durch eigene Events zu erweitern.
Die Behandlung von Ereignissen ist unabhängig von der Objekthierarchie.
Wenn kein Event-Listener registriert ist, ist der Aufwand minimal.
Nachteil:
größerer Programmieraufwand:
• Event-Listener (Implementierung von Interfaces, alle abstrakten
Methoden müssen implementiert werden)
• Registrierung
Eventhierarchie
EventObject
AWTEvent
DVG3 - Eventbehandlung
ActionEvent
ContainerEvent
AdjustmentEvent
FocusEvent
MouseEvent
15
ComponentEvent
ItemEvent
InputEvent
TextEvent
KeyEvent
WindowEvent
PaintEvent
Event-Listener
Um auf ein bestimmtes Ereignis XXXEvent reagieren zu können,
muss ein Objekt zu einer Klasse gehören, die das Interface
XXXListener implementiert. Dabei müssen alle Methoden
implementiert werden. Z.B.: MouseEvent
DVG3 - Eventbehandlung
package java.awt.event;
import java.util.EventListener;
public interface MouseListener extends EventListener {
public void mouseClicked(MouseEvent e);
public void mousePressed(MouseEvent e);
public void mouseReleased(MouseEvent e);
public void mouseEntered(MouseEvent e);
public void mouseExited(MouseEvent e);
}
16
Registrierung
In Klassen in denen das Ereignis XXXEvent auftreten kann existieren
Methoden
public void addXXXListener(XXXListener listener)
public void removeXXXListener(XXXListener listener)
zur Registrierung bzw. Deregistrierung von XXXListenern.
DVG3 - Eventbehandlung
17
DVG3 - Eventbehandlung
18
import java.awt.*;
import java.awt.event.*;
public class Paint2 extends Frame
{
public static void main(String[] args)
{ new Paint2("Paint"); }
private int x0, y0;
private Panel gPanel = new Panel();
Paint2 (String title)
{
super(title);
setBounds(0,0,400,400);
add(gPanel);
setVisible(true);
gPanel.addMouseListener(new MouseListener()
{
public void mouseClicked(MouseEvent e) { }
public void mouseEntered(MouseEvent e) { }
public void mouseExited(MouseEvent e) { }
public void mousePressed(MouseEvent e)
{
x0 = e.getX();
y0 = e.getY();
}
public void mouseReleased(MouseEvent e) { }
});
DVG3 - Eventbehandlung
19
gPanel.addMouseMotionListener(new MouseMotionListener()
{
public void mouseDragged(MouseEvent e)
{
int x = e.getX();
int y = e.getY();
gPanel.getGraphics().drawLine(x0,y0,x,y);
x0=x;
y0=y;
}
public void mouseMoved(MouseEvent e) { }
});
}
}
Adapter
Um nicht alle Methoden eines XXXListeners implementieren zu
müssen, gibt es XXXAdapter. Diese sind von den Interfaces
XXXListener abgeleitet und implementieren alle Methoden durch leere
Methoden. Es brauchen dann nur noch die interessierenden
Methoden überschrieben zu werden.
DVG3 - Eventbehandlung
20
gPanel.addMouseListener(new MouseAdapter()
{
public void mousePressed(MouseEvent e)
{
x0 = e.getX();
y0 = e.getY();
}
});
gPanel.addMouseMotionListener(new MouseMotionAdapter()
{
public void mouseDragged(MouseEvent e)
{
int x = e.getX();
int y = e.getY();
gPanel.getGraphics().drawLine(x0,y0,x,y);
x0=x;
y0=y;
}
});
Ereignisse in Komponenten
Wird hauptsächlich bei der Erweiterung von AWT durch eigene
Komponenten verwendet.
Beispiel: ColorChooser besteht aus mehreren Standardkomponenten,
Button, TextField, Scrollbar
DVG3 - Eventbehandlung
21
Warum besondere Eventbehandlung?
DVG3 - Eventbehandlung
22
Events der Buttons, TextFields, Scrollbars ... müssen behandelt
werden, um die gewünschte Funktion zu realisieren.
Standardmethode: EventListener implementieren und bei der
Komponente registrieren.
Problem: Nutzer der Komponente könnten die Listener überschreiben
oder eigene hinzufügen.  Funktion würde beeinflusst oder zerstört
Eine Behandlung der internen Events durch Anwendungsprogramme
ist weder notwendig noch wünschenswert.
In den Standardweg der Eventbehandlung muss eingegriffen werden
mit dem Ziel, eine Fehlanwendung durch zusätzlich registrierte
Listener zu verhindern.
Standardeventbehandlung
Button b
DVG3 - Eventbehandlung
b.processEvent(e)
Bestimmt Typ des Events
b.processActionEvent(e)
Feststellen des ItemIDs
actionListener.actionPerformed(e)
23
ActionEvent e
super.processActionEvent(e)
Beispiel : java.awt.List
DVG3 - Eventbehandlung
24
protected void processEvent(AWTEvent e) {
if (e instanceof ItemEvent) {
processItemEvent((ItemEvent)e);
return;
} else if (e instanceof ActionEvent) {
processActionEvent((ActionEvent)e);
return;
}
super.processEvent(e);
}
protected void processItemEvent(ItemEvent e) {
if (itemListener != null) {
itemListener.itemStateChanged(e);
}
}
protected void processActionEvent(ActionEvent e) {
if (actionListener != null) {
actionListener.actionPerformed(e);
}
}
Eingriffsmöglichkeit
DVG3 - Eventbehandlung
25
Durch Überschreiben der Methode
public void processXXXEvent(XXXEvent e)
kann verhindert werden, dass die registrierten XXXEventListener
aufgerufen werden. Dazu muss von der entsprechenden Klasse
(Button, Scrollbar, ...) eine Klasse abgeleitet werden, die die Methode
processXXXEvent überschreibt.
Standardmäßig werden Events nicht behandelt. Beim Registrieren
eines XXXListeners wird gleichzeitig die Behandlung des Events in
der Komponente eingeschaltet.
Die Aktivierung eines Events erfolgt mit der Methode
public void enableEvents(int eventMask)
Es können Konstruktoren definiert werden, die der Anwendung besser
angepasst sind als die standardmäßig vorhandenen.
Falls kein Konstruktor definiert wird, wird nur der parameterlose
automatisch erzeugt.
Implementierung in internen Klassen hat den Vorteil, dass auf alle
internen Attribute einfach zugegriffen werden kann.
Button im ColorChooser
DVG3 - Eventbehandlung
26
private class Button extends java.awt.Button
{
Button () { this("",""); }
Button (String label) { this(label,label); }
Button (String label, String command) {
super(label);
setActionCommand(command);
enableEvents(AWTEvent.ACTION_EVENT_MASK);
}
public void processActionEvent(ActionEvent e) {
doAction(e);
super.processActionEvent(e);
}
}