15.19 Menüs 

Menüs sind einteilbar in Fenstermenüs, die immer mit einem Fenster verbunden sind, oder Popup-Menüs, die an bestimmten Stellen auftauchen und nicht an eine Stelle gebunden sind. An diesem Punkt ist ein Unterschied in den Fensterarchitekturen zu verzeichnen. Während bei den meisten Windows-Systemen die Menüs ein Teil des Fensterrahmens sind, befinden sich die Menüeinträge beim Macintosh immer am oberen Bildschirmrand. Das bedeutet auch, dass beim Mac jede Anwendung die Menüleiste quasi austauscht, während unter Windows jedes Programm seine eigene Menüleiste besitzt und problemlos mehrere verschiedene Programme mit verschiedenen Menüleisten nebeneinander laufen können. Inzwischen macht sich aber eine neue Tendenz bei den Menüleisten bemerkbar: der Weg von den fest verankerten Menüpunkten hin zur flexiblen Anordnung am Fensterrahmen oder als eigenes Fenster. Die Menüs sind somit beweglich geworden, und die Zukunft wird zeigen, ob diese Menüart sich weiter verbreiten wird.

15.19.1 Die Menüleisten und die Einträge 

Der Menübalken nimmt Menüeinträge auf und dient als Container für weitere Menüs. Diese enthalten erst die Einträge (engl. item), die eine Aktion auslösen. Jeder Eintrag kann weitere Einträge enthalten. Diese werden dann »Untermenü« (engl. submenu) genannt.

Zunächst müssen wir einen Menübalken erzeugen. Dazu dient die Klasse MenuBar. Die Einträge erzeugen wir mit der Klasse Menu. Ein Menu ist eine Komponente von MenuBar. Das folgende Programmstückchen können wir direkt in den Konstruktor der Fenster-Darstellungsprogramme einbetten.

JMenuBar mbar = new JMenuBar();
JMenu m1 = new JMenu( "Datei" );
mbar.add( m1 );
mbar.add( new JMenu("Bearbeiten") );
mbar.add( new JMenu("Hilfe") );
f.setJMenuBar( mbar );

Über die add()-Methode der JMenuBar-Klasse fügen wir einen Eintrag hinzu. Dieser befindet sich dann direkt unter dem Titel des Fensters und ist immer sichtbar. Mit setJMenuBar(), einer Methode von JFrame, fügen wir den Menübalken dem Fenster hinzu. Auch Applets können unter Swing einen Menübalken besitzen, eine Fähigkeit, die Applets unter dem AWT versagt blieb.

class javax.swing.JMenuBar
extends JComponent
implements Accessible, MenuElement

JMenuBar() Erzeugt einen neuen Menübalken.

JMenu add( JMenu c ) Fügt einen Menüeintrag der Menüleiste hinzu. Er wird in die vertikale Menüleiste am Ende eingefügt.

int getMenuCount() Liefert die Anzahl der Menüeinträge.

void setHelpMenu( JMenu menu ) Das Hilfe-Menü wird mit dieser Funktion ausgezeichnet.

class javax.swing.  JFrame  
extends Frame
implements WindowConstants, Accessible, RootPaneContainer

void setJMenuBar( JMenuBar menubar )

Setzt die Menüleiste des Fensters.

class javax.swing.  JMenu  
extends JMenuItem
implements Accessible, MenuElement

JMenu( String s ) Erzeugt einen Menüeintrag mit einem bestimmten Text. Das Menü kann nicht abgezogen werden (kein Tear-off-Menü).

JMenu() Erzeugt einen Menüeintrag ohne Text (kein Tear-off-Menü).

JMenu( String s, boolean b ) Erzeugt ein Menu-Objekt mit gesetztem Namen, das durch den booleschen Parameter gesteuert abziehbar ist (Tear-off-Menü). Diese Möglichkeit muss nicht in jeder Implementierung gegeben sein.

15.19.2 Menüeinträge definieren 

Auf jedem Menüpunkt der Klasse JMenu kann eine Funktion add() aufgerufen werden, die Untermenüs hinzufügt. add() ist eine allgemeine Container-Funktion und findet sich bei vielen grafischen Container-Objekten.

Das Objekt, das add() hinzufügt, ist ein Objekt vom Typ JMenuItem. Ein Trenner kann durch die Funktion addSeparator() hinzugefügt werden.

JMenu m = new JMenu( "Datei" );
m.add( new JMenuItem("Öffnen...") );
m.addSeparator();
m.add( new JMenuItem("Beenden") );

class javax.swing.  JMenu  
extends JMenuItem
implements Accessible, MenuElement

MenuItem add( JMenuItem menuItem ) MenuItem add( String s ) Component add( Component c ) Fügt einen Menüeintrag am Ende des Menüs hinzu.

Component add( Component c, int index ) Für die Komponente c an der Position index ein.

void addSeparator() Fügt eine Trennlinie in das Menü ein.

class javax.swing.  JMenuItem  
extends AbstractButton
implements Accessible, MenuElement

JMenuItem() Erzeugt ein MenuItem ohne Text und Bild.

JMenuItem( String text ) Erzeugt einen neuen Eintrag mit Text.

JMenuItem( String text ) Erzeugt einen neuen Eintrag mit Bild.

JMenuItem( String text, Icon icon ) Erzeugt einen neuen Eintrag mit vorgeschriebenem Text und Bild.

JMenuItem( String text, int mnemonic ) Erzeugt MenuItem mit Text und Tastatur-Shortcut.

void setEnabled( boolean b ) Aktiviert oder deaktiviert den Menüeintrag.

void setText( String text ) Setzt den Text des Eintrags. Die Methode wird von AbstractButton geerbt.

15.19.3 Mnemonics und Shortcuts (Accelerator) 

Die Auswahl der Menüpunkte über die Maus ist nicht die schnellste, da der Benutzer von der Tastatur zur Maus gehen muss, die Auwahl trifft und dann wieder zurück zur Tastatur geht. Dies ist ein Kontextwechsel, der Zeit kostet. Besser ist, wenn die Menüauswahl auch über die Tastatur möglich ist. Dazu definieren Swing und die meisten grafischen Oberflächen zwei unterschiedliche Techniken:

Tastatur-Shortcuts. Sie werden auch Accelerator genannt. Sie definieren Tastaturkürzel, mit denen sich Aktionen direkt ausführen lassen. Eine Abkürzung für das Markieren des gesamten Textes kann zum Beispiel (Strg)+(A) sein. Dann steht in der Menüzeile »Alles markieren Strg+A«. Shortcuts beschleunigen die Arbeit ungemein und sollten für häufig benötigte Aktionen immer vergeben werden.

Tastenkürzel, auch Mnemonics genannt. Sie gibt es nicht nur in Menüs, sondern auch bei Schaltflächen. Dabei ist ein Buchstabe unterstrichen, zum Beispiel »Alles markieren«. Bei geöffnetem Menü aktiviert ein Druck auf die Taste (A) dann den Menüpunkt. Die Hauptmenüpunkte werden mit der Metataste (Alt) ausgefaltet. Möchten wir etwa das Menü unter »Datei« ausfahren, so drücken wir (Alt)+(D).

Der Accelerator

Die Methode setAccelerator() verbindet ein JMenuItem oder ein JMenu mit einem Accelerator. Argument der Methode ist ein KeyStroke-Objekt, welches das Tastenkürzel definiert.

item.setAccelerator(
  KeyStroke.getKeyStroke(’C’, InputEvent.CTRL_MASK)
);

Die Klasse KeyStroke definiert keine Konstruktoren, nur einige Fabrik-Methoden, die KeyStroke-Objekte zurückliefern. Neben den normalen Zeichen können auch andere Zeichen – zum Beispiel die Funktionstasten – Aktionen auslösen. Die Taste (F1) ist oft mit einer Hilfe verbunden.

class javax.swing.  KeyStroke  
extends AWTKeyStroke

static KeyStroke getKeyStroke( char keyChar ) Erzeugt ein KeyStroke-Objekt mit dem definierten Zeichen.

static KeyStroke getKeyStroke( int keyCode, int modifiers ) Erzeugt ein KeyStroke-Objekt mit dem definierten Zeichen und gegebenen Modifizierern. Dafür definiert die Klasse java.awt.event.InputEvent die Konstanten SHIFT_MASK, CTRL_MASK, META_MASK und ALT_MASK.

static KeyStroke getKeyStroke( String s ) Parst s und liefert einen String zurück. Der String beschreibt die Tastenkombination. Der allgemeine Aufbau ist <modifiers>* (<typedID> | <pressedReleasedID>). Zu den Modifizierer-Strings zählen shift, control, ctrl, meta, alt, button1, button2 und button3. So ist zum Beispiel die Zeichenkette »control DELETE« gleichwertig mit getKeyStroke(KeyEvent.VK_DELETE, InputEvent.CTRL_MASK) und »alt shift Q« gleichwertig mit getKeyStroke(KeyEvent.VK_Q, InputEvent.ALT_MASK | InputEvent.SHIFT_MASK).

class javax.swing.  JMenuItem  
extends AbstractButton
implements Accessible, MenuElement

void setAccelerator( KeyStroke keyStroke ) Setzt einen neuen Accelerator.

KeyStroke getAccelerator() Liefert den aktuell zugewiesenen KeyStroke, der als Accelerator eingetragen ist.

Mnemonics

Neben den Shortcuts gibt es die unterstrichenen Buchstaben, die Mnemonics. Sie werden einfach mit der Methode setMnemonic(char) gesetzt. Da Menüs spezielle Schaltflächen sind, wird auch die Methode von AbstractButton geerbt.

abstract class javax.swing.  AbstractButton  
extends JComponent
implements ItemSelectable, SwingConstants

int getMnemonic() Liefert den gesetzten Mnemonic.

void setMnemonic( int mnemonic ) Setzt ein Tastatur-Mnemonic.

15.19.4 Beispiel für ein Programm mit Menüleisten 

Es folgt nun ein vollständiges Programm, welches ein Menü mit Menüeinträgen füllt. Um ein flexibles Programm für viele Fälle zu erzeugen, werden wir eine Art Menü-Framework bauen. Beginnen wir mit einer Funktion addMenuBarItem(JMenuBar, String), die einen neuen Menüeintrag erzeugt und in die Menüleiste einbaut. Das erzeugte JMenuItem-Objekt wird gleichfalls zurückgegeben. Die Zeichenkette kann ein Text mit Unterstrich sein. Dann wird das nachfolgende Zeichen als Mnemonik gesetzt. So steht der String »E_infügen« für den Eintrag »Einfügen« und ein unterstrichenes i. Fehler wie den Unterstrich an der letzten Stelle oder doppelte Unterstriche berücksichtigt die Funktion nicht.

Listing 15.26   JMenuDemo.java, Teil 1

import java.io.*;
import java.awt.event.*;
import javax.swing.*;

class JMenuHelper
{
  /**
   * Add an element to the menubar.
   *
   * @param    menuBar             a  JMenuBar
   * @param    s                   a  String
   *
   * @return   added JMenu
   *
   */
  public static JMenu addMenuBarItem( JMenuBar menuBar, String s )
  {
    JMenu menu;

    if ( s.indexOf("_") > –1 )
    {
      int pos = s.indexOf("_");
      char c = s.charAt( pos+1 );
      StringBuffer sb = new StringBuffer(s).delete(pos,pos+1);
      menu =  new JMenu( sb.toString() );
      menu.setMnemonic( c );
    }
    else
      menu = new JMenu( s );

    menuBar.add( menu );
    return menu;
  }

// gleich geht’s weiter...

Als Nächstes müssen wir auch Einträge in den Hauptmenüs erzeugen. Wir wollen mehrere Möglichkeiten vorsehen, namentlich:

JMenuItem addMenuItem( JMenu m, String s, char keyChar, ActionListener al )

JMenuItem addMenuItem( JMenu m, String s, char c )

JMenuItem addMenuItem( JMenu m, String s )

JMenuItem addMenuItem( JMenu m, String s, ActionListener al )

Letztendlich realisiert nur die erste Funktion die Implementierung. Die anderen leiten an die erste Funktion weiter. Es soll möglich sein, in einem existierenden JMenu einen Eintrag als Zeichenkette hinzuzufügen. Optional sind ein Abkürzungszeichen, welches mit (Strg) assoziiert wird, und ein ActionListener erlaubt. Auf die Möglichkeiten eines Icons verzichtet das Programm aus Gründen der Übersichtlichkeit.

private static JMenuItem processMnemonic( String s )
  {
    if ( s.indexOf("_") > –1 )
    {
      int pos = s.indexOf("_");
      char c = s.charAt( pos+1 );
      StringBuffer sb = new StringBuffer(s).delete(pos,pos+1);
      return new JMenuItem( sb.toString(), c );
    }
    else
      return new JMenuItem( s );
  }

  /**
   * Insert a JMenuItem to a given JMenu.
   *
   * @param    m                   a  JMenu
   * @param    s                   a  String
   * @param    keyChar             a  char
   * @param    al                  an ActionListener
   *
   * @return   a JMenuItem
   */
  public static JMenuItem addMenuItem( JMenu m, String s, char keyChar,
                                       ActionListener al )
  {
    if ( s.startsWith("-") )
    {
      m.addSeparator();
      return null;
    }

    JMenuItem menuItem = processMnemonic( s );

    m.add( menuItem  );

    if ( keyChar != 0 )
      menuItem.setAccelerator(
        KeyStroke.getKeyStroke(keyChar, InputEvent.CTRL_MASK) );

    if ( al != null )
      menuItem.addActionListener( al );

    return menuItem;
  }

  public static JMenuItem addMenuItem( JMenu m, String s, char c )
  {
    return addMenuItem( m, s, c, null );
  }

  public static JMenuItem addMenuItem( JMenu m, String s )
  {
    return addMenuItem( m, s, (char)0, null );
  }

  public static JMenuItem addMenuItem( JMenu m, String s,
                                       ActionListener al )
  {
    return addMenuItem( m, s, (char)0, al );
  }
}

Nun benötigen wir nur noch ein kleines Hauptprogramm, welches eine Menüstruktur aufbaut. Unter einem Menüpunkt Datei soll sich noch ein Untermenü verbergen. Untermenüs lassen sich ebenso mit add() in ein JMenu einfügen.

Hier klicken, um das Bild zu Vergrößern

Abbildung 15.19   Ein komplettes Programm für Menüs

Als Einträge finden sich dort die Dateien des aktuellen Verzeichnisses wieder.

Es folgt nun der zweite Teil:

Listing 15.27   JMenuDemo.java, Teil 2

//  ... Fortsetzung

public class JMenuDemo
{
  public static void main( String args[] )
  {
    JMenuBar mbar;
    JMenu menuDatei, menuBearbeiten, menuHilfe;
    JMenuItem item;    // Konstruieren der Menüzeile

    // Hauptmenü einrichten

    mbar = new JMenuBar();
    menuDatei = JMenuHelper.addMenuBarItem( mbar, "_Datei" );
    menuBearbeiten = JMenuHelper.addMenuBarItem( mbar, "_Bearbeiten" );
    menuHilfe = JMenuHelper.addMenuBarItem( mbar, "?" );

    ActionListener actionProcCmd = new ActionListener()
    {
      public void actionPerformed( ActionEvent e )
      {
        String action = e.getActionCommand();
        System.out.println( "e.getActionCommand() = " + action );
      }
    };

    // Einträge für Datei

    item = JMenuHelper.addMenuItem( menuDatei, "Ö_ffnen", ’O’, actionProcCmd );
    item = JMenuHelper.addMenuItem( menuDatei, "_Speichern", ’S’, actionProcCmd );
    JMenuHelper.addMenuItem( menuDatei, "-" );

    JMenu dateien = new JMenu( "Datei(en)" );
    menuDatei.add( dateien );

    menuDatei.addSeparator();

    item = JMenuHelper.addMenuItem( menuDatei, "_Beenden", ’B’ );
    item.addActionListener( new ActionListener() {
          public void actionPerformed( ActionEvent e ) {
            System.exit(0);
          }
        });

    // Einträge für Bearbeiten

    JMenuHelper.addMenuItem( menuBearbeiten, "Ausschnei_den", ’X’, 
actionProcCmd );
    JMenuHelper.addMenuItem( menuBearbeiten, "_Kopieren", ’C’, actionProcCmd );
    JMenuHelper.addMenuItem( menuBearbeiten, "E_infügen", ’V’, actionProcCmd );

    // Einträge für Hilfe

    JMenuHelper.addMenuItem( menuHilfe, "Index", actionProcCmd );
    JMenuHelper.addMenuItem( menuHilfe, "Über dieses Programm", actionProcCmd );

    // Menü abschließen

    // fülle das Untermenü von Dateien
    File userdir = new File( System.getProperty("user.dir") );
    String entries[] = userdir.list();
    for ( int i = 0; i < entries.length; i++ )
      JMenuHelper.addMenuItem( dateien, entries[i], actionProcCmd  );

    JFrame f = new JFrame();
    f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
    f.setJMenuBar( mbar );
    f.setSize( 300, 200 );
    f.setVisible( true );
  }
}

15.19.5 Popup-Menüs 

Popup-Menüs sind nicht wie normale Menüs an eine bestimmte Position gebunden, sondern tauchen meistens dort auf, wo der Benutzer mit der rechten Maustaste geklickt hat. Ein anderer oft gebrauchter Name ist Kontextmenü, da das Menü verschiedene Einträge bei unterschiedlichen Kontexten besitzt. Ein Beispiel sind grafische Oberflächen. Wenn wir dort auf einer Datei das Kontextmenü bemühen, findet sich ein Eintrag wie »Öffnen« und »Bearbeiten«. Auf einem Verzeichnis fehlen jedoch solche Bearbeitungsmöglichkeiten.

Popup-Menüs sollen die Navigation erleichtern, deshalb sollten sie nicht zu lang sein oder zu viele Ebenen besitzen. Gleiches gilt übrigens auch für die Menüstruktur. Wenn es mehr als drei Ebenen werden, sollte über eine Neugestaltung nachgedacht werden.

Hier klicken, um das Bild zu Vergrößern

Abbildung 15.20   Ein Popup-Menü

Die Klasse JPopupMenu

Für Popup-Menüs ist die Klasse JPopupMenu zuständig. Beim AWT ist es die Klasse java.awt.PopupMenu. JPopupMenu ist eine normale JComponent, während PopupMenu eine Unterklasse von java.awt.Menu ist.

Popup-Menüs unterscheiden sich vom Aufbau her nicht von normalen Menüs. Die Menüeinträge vom Typ JMenuItem sowie Trennlinien werden wie bekannt eingefügt.

JPopupMenu popmen = new JPopupMenu();
JMenuItem menu1 = new JMenuItem( "Eintrag 1");
popmen.add( menu1 );
popmen.add( new JMenuItem( "Eintrag 2") );

Ein Popup-Menü wird mit der Methode add() einer Komponente hinzugeführt.

getContentPane().add( popmen );

Allerdings springt das Menü nicht selbständig beim Mausklick auf. Wir müssen selbst auf das Mausereignis hören und müssen eigenständig das Menü mit der show()-Methode aufspringen lassen --- daher der Name »Popup«. Der Methode müssen die Komponente, auf der das Menü aufspringen soll, und die Koordinaten übergeben werden.

addMouseListener( new MouseAdapter()
{
  public void mouseReleased( MouseEvent me ) {
    if ( me.isPopupTrigger() )
      popmen.show( me.getComponent(), me.getX(), me.getY() );
  }
 } );

Class javax.swing.  JPopupMenu  
extends JComponent
implements Accessible, MenuElement

JPopupMenu() Erzeugt ein Popup-Menü.

JMenuItem add( String s ) Fügt dem Popup-Menü einen Eintrag hinzu.

JMenuItem add( JMenuItem menuItem ) Fügt dem Popup-Menü einen Eintrag hinzu.

void addSeparator() Fügt einen Trenner hinzu.

void show( Component invoker, int x, int y) Lässt das PopupMenu auf der Komponente invoker an der Position x, y aufspringen.

Beispiel für ein JPopupMenu

Wir wollen nun ein Beispiel implementieren, welches ein Popup-Menü anzeigt. Gehen wir Schritt für Schritt durch das Programm. Zuerst binden wir die nötigen Pakete ein. Wir definieren eine Variable popmen für den Zugriff auf das Popup-Menü. Im Konstruktor definieren wir das ganze Verhalten.

Listing 15.28   PopMenDemo.java

import java.awt.event.*;
import javax.swing.*;

public class PopMenDemo extends JFrame
{
  JPopupMenu popmen = new JPopupMenu();

  PopMenDemo()
  {
    setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

    JMenuItem entryHead = new JMenuItem( "Kompaktstaubsauger" );
    popmen.add( entryHead );
    popmen.addSeparator();

Der erste Eintrag im Menü soll eine Überschrift sein. Dann sollen einige Einträge in das Popup-Menü folgen und mit einem ActionListener verbunden werden. Damit reagieren wir auf die Ereignisse, wenn der Benutzer einen Eintrag im Menü auswählt.

String staubsauger[] = {
      "AEG Vampyrino SX", "Electrolux Clario Z 1941",
      "Quelle Privileg Piccolino", "Siemens Super T120VS12A00",
      "Hoover Micro Power Electronic SC 150", "Rowenta dymbo RS 014" };

    JMenuItem entry[] = new JMenuItem[staubsauger.length];

    ActionListener al = new ActionListener() {
      public void actionPerformed( ActionEvent e )
      {
        System.out.println( e.getActionCommand() );
      }
    };

    for ( int i = 0; i < staubsauger.length; i++ )
    {
      popmen.add( entry[i] = new JMenuItem( staubsauger[i] ) );
      entry[i].addActionListener( al );
    }

Der letzte Teil ist nun, dem JFrame einen Listener mitzugeben, der auf die Maustaste hört, damit das Kontextmenü aufgerufen werden kann. Wir ergänzen einen MouseListener. Im mouseReleased() werden wir dann mit show() das Menü öffnen.

addMouseListener( new MouseAdapter() {
          public void mouseReleased( MouseEvent me ) {
            if ( me.isPopupTrigger() )
              popmen.show( me.getComponent(), me.getX(), me.getY() );
          }
        } );
    setSize( 300,300 );
    setVisible( true );
  }

  public static void main( String args[] )
  {
    new PopMenDemo();
  }
}