Titel   Inhalt   Suchen   Index   DOC  Handbuch der Java-Programmierung, 3. Auflage
 <<    <     >    >>   API  Kapitel 30 - Menüs

30.5 Action-Events



Ein Action-Event wird generiert, wenn der Anwender einen Menüpunkt selektiert und ausgewählt hat. Das Programm kann den auslösenden Menüeintrag bestimmen und so geeignet darauf reagieren. Action-Events werden von der Klasse MenuItem und drei weiteren Klassen (auf die wir in den folgenden Kapiteln zurückkommen) gesendet:

Ein Empfänger für Action-Events muß das Interface ActionListener implementieren und bekommt Events des Typs ActionEvent übergeben. ActionEvent erweitert die Klasse AWTEvent und stellt neben getID und getSource vor allem die Methode getActionCommand zur Verfügung, mit der die verschiedenen Ereignisquellen unterschieden werden können:

public String getActionCommand()
java.awt.event.ActionEvent

Wird das Action-Event durch ein MenuItem ausgelöst, liefert dessen Methode getActionCommand die Bezeichnung des Menüpunktes, wie sie an den Konstruktor übergeben wurde. Durch einen expliziten Aufruf von setActionCommand kann dieser String auch unabhängig von der Beschriftung des Menüpunkts geändert werden. Ein Aufruf von getActionCommand liefert den aktuellen Inhalt des Menüpunkts bzw. seine Beschriftung, falls setActionCommand noch nicht aufgerufen wurde:

 Hinweis 

public void setActionCommand(String command)

public String getActionCommand()
java.awt.MenuItem

Die Registrierung der Empfängerklasse erfolgt mit der Methode addActionListener, die in den Klassen MenuItem, Button, List und TextField zur Verfügung steht:

public void addActionListener(ActionListener l)
java.awt.Button

Das Interface ActionListener stellt lediglich die Methode actionPerformed zur Verfügung, die beim Aufruf ein ActionEvent übergeben bekommt:

public abstract void actionPerformed(ActionEvent e)
java.awt.event.ActionListener

Üblicherweise wird in actionPerformed zunächst durch Aufruf von getActionCommand und/oder getSource die Quelle des Action-Events ermittelt, bevor der Code folgt, der die Reaktion auf das Ereignis implementiert.

 Tip 

Das folgende Programm zeigt die Reaktion auf Action-Events. Das Programm öffnet ein Fenster, das mit Hilfe von Menüeinträgen auf dem Bildschirm verschoben oder in der Größe verändert werden kann:

001 /* Listing3005.java */
002 
003 import java.awt.*;
004 import java.awt.event.*;
005 
006 class MainMenu4
007 extends MenuBar
008 {
009   private MenuItem miRueck;
010   private CheckboxMenuItem miFarbe;
011 
012   private static void
013   addNewMenuItem(Menu menu, String name, ActionListener listener)
014   {
015     int pos = name.indexOf('&');
016     MenuShortcut shortcut = null;
017     MenuItem mi;
018     if (pos != -1) {
019       if (pos < name.length() - 1) {
020         char c = name.charAt(pos + 1);
021         shortcut=new MenuShortcut(Character.toLowerCase(c));
022         name=name.substring(0,pos)+name.substring(pos + 1);
023       }
024     }
025     if (shortcut != null) {
026       mi = new MenuItem(name, shortcut);
027     } else {
028       mi = new MenuItem(name);
029     }
030     mi.setActionCommand(name);
031     mi.addActionListener(listener);
032     menu.add(mi);
033   }
034 
035   public MainMenu4(ActionListener listener)
036   {
037     Menu m;
038 
039     //Menü "Größe"
040     m = new Menu("Größe");
041     addNewMenuItem(m, "&Größer", listener);
042     addNewMenuItem(m, "&Kleiner", listener);
043     m.addSeparator();
044     addNewMenuItem(m, "B&eenden", listener);
045     add(m);
046 
047     //Menü "Position"
048     m = new Menu("Position");
049     addNewMenuItem(m, "&Links", listener);
050     addNewMenuItem(m, "&Rechts", listener);
051     addNewMenuItem(m, "&Oben", listener);
052     addNewMenuItem(m, "&Unten", listener);
053     add(m);
054   }
055 }
056 
057 public class Listing3005
058 extends Frame
059 implements ActionListener
060 {
061   public static void main(String[] args)
062   {
063     Listing3005 wnd = new Listing3005();
064   }
065 
066   public Listing3005()
067   {
068     super("Menü-ActionEvents");
069     setLocation(100,100);
070     setSize(300,200);
071     setMenuBar(new MainMenu4(this));
072     setVisible(true);
073     addWindowListener(new WindowClosingAdapter(true));
074   }
075 
076   public void paint(Graphics g)
077   {
078     Insets   in = getInsets();
079     Dimension d = getSize();
080     g.setColor(Color.red);
081     g.drawLine(
082       in.left, in.top,
083       d.width - in.right, d.height - in.bottom
084     );
085     g.drawLine(
086       in.left, d.height - in.bottom,
087       d.width - in.right, in.top
088     );
089   }
090 
091   public void actionPerformed(ActionEvent event)
092   {
093     String cmd = event.getActionCommand();
094     if (cmd.equals("Größer")) {
095       Dimension d = getSize();
096       d.height *= 1.05;
097       d.width  *= 1.05;
098       setSize(d);
099     } else if (cmd.equals("Kleiner")) {
100       Dimension d = getSize();
101       d.height *= 0.95;
102       d.width  *= 0.95;
103       setSize(d);
104     } else if (cmd.equals("Beenden")) {
105       setVisible(false);
106       dispose();
107       System.exit(0);
108     } else if (cmd.equals("Links")) {
109       setLocation(getLocation().x-10, getLocation().y);
110     } else if (cmd.equals("Rechts")) {
111       setLocation(getLocation().x+10, getLocation().y);
112     } else if (cmd.equals("Oben")) {
113       setLocation(getLocation().x, getLocation().y-10);
114     } else if (cmd.equals("Unten")) {
115       setLocation(getLocation().x, getLocation().y+10);
116     }
117   }
118 }
Listing3005.java
Listing 30.5: Reaktion auf Action-Events aus einem Menü

Das Programm besitzt eine Klasse MainMenu4, in der das Menü definiert wird. Um die Definition der Menüeinträge zu vereinfachen, wurde die Methode addNewMenuItem implementiert, die einen neuen Menüeintrag erzeugt, ggfs. mit einem Beschleuniger versieht, den ActionListener registriert und schließlich an das übergebene Menü anhängt. Der erste Parameter von addnewMenuItem ist das Menü, für das ein Menüeintrag erstellt werden soll. Der zweite Parameter ist die Bezeichnung des Menüeintrags. Ist darin ein »&« enthalten, so wird dieses als Präfix für die Beschleunigertaste angesehen und der nachfolgende Buchstabe als Beschleuniger registriert. Anschließend wird das »&« entfernt. Als drittes Argument wird der ActionListener übergeben, der beim Menüeintrag registriert werden soll.

Wir verwenden in diesem Beispiel lediglich einen einzigen ActionListener, der bei allen Menüeinträgen registriert wird. Über den this-Zeiger wird das Fenster an den Konstruktor von MainMenu4 übergeben und von dort an addNewMenuItem weitergegeben. Voraussetzung dafür ist, daß das Fenster das Interface ActionListener implementiert und die Methode actionPerformed zur Verfügung stellt.

 Hinweis 

Die Unterscheidung der verschiedenen Ereignisquellen wird innerhalb von actionPerformed durch Aufruf von getActionCommand erledigt. Deren Rückgabewert wird abgefragt, um das passende Kommando auszuführen. Die Größenänderung erfolgt durch Aufruf von getSize und setSize, die Positionierung mit getLocation und setLocation. Zur Kontrolle zeichnet das Programm in paint zwei rote Diagonalen über die volle Länge der Client-Area:

Abbildung 30.3: Ein Programm, das auf Action-Events reagiert


 Titel   Inhalt   Suchen   Index   DOC  Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0.1
 <<    <     >    >>   API  © 1998-2003 Guido Krüger, http://www.javabuch.de