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

## 30.5 Action-Events

- 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:

- `MenuItem` sendet ein `ActionEvent`, wenn der Menüpunkt aufgerufen wurde.
- Ein `Button` sendet ein `ActionEvent`, nachdem er vom Anwender gedrückt wurde.
- Ein Objekt vom Typ `List` sendet ein `ActionEvent` nach einem Doppelklick des Anwenders.
- Ein `TextField` sendet ein `ActionEvent`, wenn der Anwender die Taste `[ENTER]` gedrückt hat.

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
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de