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.
Beispiel Wir bauen ein Menü mit drei Einträgen und einem Sparator auf.
JMenu m = new JMenu( "Datei" );
m.add( new JMenuItem("Öffnen...") );
m.addSeparator();
m.add( new JMenuItem("Beenden") );
|
Tipp Die Ellipse »...« hinter dem Menüeintrag deutet an, dass der Benutzer einen Dialog erhält, bevor eine Aktion ausgelöst wird.
|
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). |
Tipp Die Wahl der Shortcuts: Auf keinen Fall dürfen wir vergessen, uns an die Vorgaben und Normen bei der Wahl der Shortcuts zu halten. Es ist unsinnig, sich neue Tastatur-Shortcuts zu überlegen, die entgegen aller Erwartung funktionieren. Es haben sich im Laufe der Zeit verschiedene Styleguides eingebürgert: So wird beispielsweise für »Datei öffnen« der Shortcut (Strg)+(O) verwendet und nicht etwa (Strg)+(C), der eine getätigte Selektion in den Zwischenspeicher (engl. clipboard) kopiert.
|
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.
Beispiel Definiere für einen Menüeintrag item die Abkürzung (Strg)+(C).
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). |
Tipp Alle Shortcuts sollten vom Benutzer geändert werden können – der Designer gibt lediglich Standardwerte vor. Diese vorgegebenen Werte sollten aber nicht einfach das Alphabet abgehen.
|
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
Tipp Hierarchische Menüs dürfen nur für wenig gebrauchte Operationen benutzt werden. Dies gilt noch mehr für Popup-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.
Tipp Popup-Menüs müssen kurz gehalten werden. Zu viele Ebenen sind ebenso zu vermeiden wie lange Auswahllisten. Wenn der Benutzer am unteren Rand ist, so ist nicht abzuschätzen, wo die Auswahlliste angezeigt wird.
|
 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.
Beispiel Erzeuge ein Popup-Menü mit zwei Einträgen.
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.
Beispiel Ist unsere Klasse von JFrame abgeleitet, so tragen wir in den Konstruktor folgende Zeile ein, um das Popup-Menü hinzuzufügen:
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.
Beispiel Die Maustaste für das Kontextmenü kann jedes System unterschiedlich definieren und der Benutzer kann das auch umdefinieren. Das MouseEvent aus dem Ereignis bietet aber über isPopupTrigger() die Information, ob die Maustaste aktiviert wurde, mit der im Allgemeinen das PopupMenu erscheint. Die Anzeige erfolgt mit show().
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();
}
}
Tipp Popup-Menüs sollten einen ersten nicht selektierbaren Eintrag besitzen. Dies macht die Auswahl nicht wesentlich langsamer, lässt aber das Abbrechen einer Operation einfacher zu.
|
|