15.19 Menüs
 
Menüs lassen sich in Fenstermenüs, die immer mit einem Fenster verbunden sind, oder Popup-Menüs einteilen, 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 Teil des Fensterrahmens sind, befinden sich die Menüeinträge beim Macintosh immer am oberen Bildschirmrand. Dies bedeutet auch, dass beim Mac jede Anwendung die Menüleiste quasi austauscht, während unter Windows jedes Programm über seine eigene Menüleiste verfügt 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 sich diese Menüart weiter verbreitet.
 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 der Menüleiste einen Menüeintrag 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ügt 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. |
Tipp Hierarchische Menüs dürfen nur für wenig gebrauchte Operationen benutzt werden. Dies gilt noch mehr für Popup-Menüs.
|
15.19.3 Mnemonics und Shortcuts (Accelerator)
 
Die Auswahl der Menüpunkte über die Maus ist nicht die schnellste, weil der Benutzer von der Tastatur zur Maus gehen muss, die Auswahl 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 und definieren Tastaturkürzel, mit denen sich Aktionen direkt ausführen lassen. Eine Abkürzung zum 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 zur Wahl der Shortcuts Auf keinen Fall dürfen wir es verabsäumen, uns an die Vorgaben und Normen bei der Wahl der Shortcuts zu halten. Es ist unsinnig, sich neue Tastatur-Shortcuts zu überlegen, die entgegen allen Erwartungen 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 die Zwischenablage (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 durchwandern.
|
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 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ü, weil 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.19
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 );
|
Das Menü springt beim Mausklick nicht selbstständig auf. Wir müssen selbst auf das Mausereignis hören und 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 Popup-Menü 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, das 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.26
PopMenDemo.java
import java.awt.event.*;
import javax.swing.*;
public class PopMenDemo extends JFrame
{
final JPopupMenu popmen = new JPopupMenu();
public 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.
ActionListener al = new ActionListener() {
public void actionPerformed( ActionEvent e )
{
System.out.println( e.getActionCommand() );
}
};
for ( String s : ("AEG Vampyrino SX, Electrolux Clario Z 1941," +
"Quelle Privileg Piccolino,Siemens Super T120VS12A00," +
"Hoover Micro Power Electronic SC 150,Rowenta dymbo
RS014").split(",") )
{
JMenuItem entry = new JMenuItem( s );
popmen.add( entry );
entry.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 erweitern dazu einen MouseAdapter. In der überschriebenen Methode mouseReleased()öffnet show() das Popup-Menü.
addMouseListener( new MouseAdapter() {
@Override
public void mouseReleased( MouseEvent me ) {
if ( me.isPopupTrigger() )
popmen.show( me.getComponent(), me.getX(), me.getY() );
}
} );
setSize( 300, 300 );
}
public static void main( String[] args )
{
new PopMenDemo().setVisible( true );
}
}
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.
|
|