15.17 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 Fenster-Architekturen 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.17.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üliste 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.17.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.17.3 Mnemonics und Short-Cuts (Accelerator) 

Die Auwahl 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 Tastatur möglich ist. Dazu definieren Swing und die meisten grafischen Oberflächen zwei unterschiedliche Techniken:

Tastatur-Shortcuts. Sie werden auch Accelerator gennant. 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. Parameter 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 Short-Cuts bleiben 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.17.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.21   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.

Abbildung 15.15   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.22   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.show();
  }
}