Eventbehandlung

1. Eventbehandlung DVG3 - Eventbehandlung

2. Events • Events sind externe Ereignisse, die parallel zum normalen Programmablauf auftreten. • Beispiele: • Mouse-Events • Tastatur-Events • Externe Unterbrechungen (Interrupts) DVG3 - Eventbehandlung

3. Eventbehandlung Event Behandlung des Events Normaler Programm- ablauf Unterbrechung Fortsetzung DVG3 - Eventbehandlung

4. Gemeinsamkeiten der Eventbehandlung • 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 DVG3 - Eventbehandlung

5. Methoden der Eventbehandlung • 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: • 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 • Ereignisbehandlung nach dem Delegationsmodell • Standardmethode ab JDK 1.1 • Sollte immer verwendet werden, wenn nicht wichtige Gründe dagegen sprechen. • Ereignisbehandlung für die Komponentenentwicklung DVG3 - Eventbehandlung

6. 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

7. In der Klasse Component und damit in allen Klassen des AWT ist die Methodepublic boolean handleEvent(Event evt)definiert. • Diese Methode wird in dem Objekt mit dem entsprechenden Event-Objekt 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; } DVG3 - Eventbehandlung

9. 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. • Für einige Ereignisse existieren keine Hilfsmethoden. handleEvent muss überschrieben werden, um diese Ereignisse zu behandeln DVG3 - Eventbehandlung

10. import java.awt.*; public class Paint1 extends Frame { public static void main(String[] args) { new Paint1("Paint"); } private int x0, y0; 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; } }; DVG3 - Eventbehandlung

11. Paint1 (String title) { super(title); setBounds(0,0,400,400); add(gPanel); setVisible(true); } } 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. DVG3 - Eventbehandlung

13. Delegationsmodell ab JDK 1.1 • 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 (Event-Listener). Diese werden dann über das Auftreten des Ereignisses informiert. DVG3 - Eventbehandlung Event-Listener Programm in dem ein Event ausgelöst wird Registrierung Benachrichtigung Weiterarbeit

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 DVG3 - Eventbehandlung

15. Eventhierarchie DVG3 - Eventbehandlung

16. 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 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); } DVG3 - Eventbehandlung

17. Registrierung • In Klassen in denen das Ereignis XXXEvent auftreten kann existieren Methodenpublic void addXXXListener(XXXListener listener)public void removeXXXListener(XXXListener listener)zur Registrierung bzw. Deregistrierung von XXXListenern. 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) { } }); } } DVG3 - Eventbehandlung

20. 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. 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; } }); DVG3 - Eventbehandlung

21. 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

22. Warum besondere Eventbehandlung? • 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. DVG3 - Eventbehandlung

23. Standardeventbehandlung Button b ActionEvent e b.processEvent(e) Bestimmt Typ des Events DVG3 - Eventbehandlung b.processActionEvent(e) Feststellen des ItemIDs super.processActionEvent(e) actionListener.actionPerformed(e)

24. Beispiel : java.awt.List 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); } } DVG3 - Eventbehandlung

25. Eingriffsmöglichkeit • 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 Methodepublic 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. DVG3 - Eventbehandlung

26. Button im ColorChooser 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); } } DVG3 - Eventbehandlung