Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Die Funktionsbibliothek
10 Threads und nebenläufige Programmierung
11 Raum und Zeit
12 Datenstrukturen und Algorithmen
13 Dateien und Datenströme
14 Die eXtensible Markup Language (XML)
15 Grafische Oberflächen mit Swing
16 Grafikprogrammierung
17 Netzwerkprogrammierung
18 Verteilte Programmierung mit RMI und Web-Services
19 JavaServer Pages und Servlets
20 Applets
21 Midlets und die Java ME
22 Datenbankmanagement mit JDBC
23 Reflection und Annotationen
24 Logging und Monitoring
25 Sicherheitskonzepte
26 Java Native Interface (JNI)
27 Dienstprogramme für die Java-Umgebung
A Die Begleit-DVD
Stichwort
Download: - ZIP, ca. 12,5 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> /Java-Insel | vor >>
Java ist auch eine Insel von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel 7., aktualisierte Auflage geb., mit DVD (November 2007) 1.492 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1146-8 |
| 15 Grafische Oberflächen mit Swing
|  | 15.1 Das Abstract Window Toolkit und Swing
|  |  | 15.1.1 Abstract Window Toolkit (AWT)
|  |  | 15.1.2 Java Foundation Classes
|  |  | 15.1.3 Was Swing von AWT unterscheidet
|  |  | 15.1.4 Die Klasse Toolkit
|  | 15.2 Fenster unter grafischen Oberflächen
|  |  | 15.2.1 Swing-Fenster darstellen
|  |  | 15.2.2 AWT-Fenster darstellen
|  |  | 15.2.3 Sichtbarkeit des Fensters
|  |  | 15.2.4 Größe und Position des Fensters verändern
|  |  | 15.2.5 Unterklassen der Fenster-Klassen bilden
|  |  | 15.2.6 Fenster- und Dialog-Dekoration
|  |  | 15.2.7 Dynamisches Layout während einer Größenänderung
|  | 15.3 Beschriftungen (JLabel)
|  |  | 15.3.1 Mehrzeiliger Text, HTML in der Darstellung
|  | 15.4 Icon und ImageIcon für Bilder auf Swing-Komponenten
|  |  | 15.4.1 Die Schnittstelle Icon
|  | 15.5 Es tut sich was – Ereignisse beim AWT
|  |  | 15.5.1 Die Klasse AWTEvent
|  |  | 15.5.2 Events auf verschiedenen Ebenen
|  |  | 15.5.3 Swings Ereignisquellen und Horcher (Listener)
|  |  | 15.5.4 Listener implementieren
|  |  | 15.5.5 Listener bei dem Ereignisauslöser anmelden/abmelden
|  |  | 15.5.6 Aufrufen der Listener im AWT-Event-Thread
|  |  | 15.5.7 Adapterklassen nutzen
|  |  | 15.5.8 Innere Mitgliedsklassen und innere anonyme Klassen
|  | 15.6 Schaltflächen
|  |  | 15.6.1 Normale Schaltflächen (JButton)
|  |  | 15.6.2 Der aufmerksame ActionListener
|  |  | 15.6.3 Basisklasse AbstractButton
|  |  | 15.6.4 Wechselknopf (JToggleButton)
|  | 15.7 Swing Action
|  |  | 15.7.1 javax.swing.Action
|  |  | 15.7.2 Eigenschaften der Action-Objekte
|  | 15.8 JComponent und Component als Basis aller Komponenten
|  |  | 15.8.1 Tooltips
|  |  | 15.8.2 Rahmen (Border)
|  |  | 15.8.3 Fokus und Navigation
|  |  | 15.8.4 Ereignisse jeder Komponente
|  |  | 15.8.5 Die Größe und Position einer Komponente
|  |  | 15.8.6 Komponenten-Ereignisse
|  |  | 15.8.7 Hinzufügen von Komponenten
|  |  | 15.8.8 UI-Delegate – der wahre Zeichner
|  |  | 15.8.9 Undurchsichtige (opak) Komponente
|  |  | 15.8.10 Properties und Listener für Änderungen
|  |  | 15.8.11 Swing-Beschriftungen eine andere Sprache geben
|  | 15.9 Container
|  |  | 15.9.1 Standardcontainer (JPanel)
|  |  | 15.9.2 Bereich mit automatischen Rollbalken (JScrollPane)
|  |  | 15.9.3 Reiter (JTabbedPane)
|  |  | 15.9.4 Teilung-Komponente (JSplitPane)
|  | 15.10 Alles Auslegungssache: die Layoutmanager
|  |  | 15.10.1 Übersicht über Layoutmanager
|  |  | 15.10.2 Zuweisen eines Layoutmanagers
|  |  | 15.10.3 Im Fluss mit FlowLayout
|  |  | 15.10.4 Mit BorderLayout in allen Himmelsrichtungen
|  |  | 15.10.5 Rasteranordnung mit GridLayout
|  |  | 15.10.6 Der GridBagLayout-Manager
|  |  | 15.10.7 Null-Layout
|  |  | 15.10.8 BoxLayout
|  |  | 15.10.9 Weitere Layoutmanager
|  | 15.11 Rollbalken und Schieberegler
|  |  | 15.11.1 Schieberegler (JSlider)
|  |  | 15.11.2 Rollbalken (JScrollBar)
|  | 15.12 Kontrollfelder, Optionsfelder, Kontrollfeldgruppen
|  |  | 15.12.1 Kontrollfelder (JCheckBox)
|  |  | 15.12.2 ItemSelectable, ItemListener und das ItemEvent
|  |  | 15.12.3 Sich gegenseitig ausschließende Optionen (JRadioButton)
|  | 15.13 Fortschritte bei Operationen überwachen
|  |  | 15.13.1 Fortschrittsbalken (JProgressBar)
|  |  | 15.13.2 Dialog mit Fortschrittsanzeige (ProgressMonitor)
|  | 15.14 Menüs und Symbolleisten
|  |  | 15.14.1 Die Menüleisten und die Einträge
|  |  | 15.14.2 Menüeinträge definieren
|  |  | 15.14.3 Einträge durch Action-Objekte beschreiben
|  |  | 15.14.4 Mit der Tastatur: Mnemonics und Shortcut
|  |  | 15.14.5 Der Tastatur-Shortcut (Accelerator)
|  |  | 15.14.6 Tastenkürzel (Mnemonics)
|  |  | 15.14.7 Symbolleisten alias Toolbars
|  |  | 15.14.8 Popup-Menüs
|  |  | 15.14.9 System-Tray nutzen
|  | 15.15 Das Model-View-Controller-Konzept
|  | 15.16 Auswahlmenüs, Listen und Spinner
|  |  | 15.16.1 Auswahlmenü (JComboBox)
|  |  | 15.16.2 Zuordnung einer Taste mit einem Eintrag
|  |  | 15.16.3 Datumsauswahl
|  |  | 15.16.4 Listen (JList)
|  |  | 15.16.5 Drehfeld (JSpinner)
|  | 15.17 Texteingabefelder
|  |  | 15.17.1 Text in einer Eingabezeile
|  |  | 15.17.2 Die Oberklasse der Text-Komponenten (JTextComponent)
|  |  | 15.17.3 Geschützte Eingaben (JPasswordField)
|  |  | 15.17.4 Validierende Eingabefelder (JFormattedTextField)
|  |  | 15.17.5 Einfache mehrzeilige Textfelder (JTextArea)
|  |  | 15.17.6 Editor-Klasse (JEditorPane)
|  | 15.18 Tabellen (JTable)
|  |  | 15.18.1 Ein eigenes Tabellen-Model
|  |  | 15.18.2 Basisklasse für eigene Modelle (AbstractTableModel)
|  |  | 15.18.3 Vorgefertigtes Standard-Modell (DefaultTableModel)
|  |  | 15.18.4 Ein eigener Renderer für Tabellen
|  |  | 15.18.5 Zell-Editoren
|  |  | 15.18.6 Größe und Umrandung der Zellen
|  |  | 15.18.7 Spalteninformationen
|  |  | 15.18.8 Tabellenkopf von Swing-Tabellen
|  |  | 15.18.9 Selektionen einer Tabelle
|  |  | 15.18.10 Automatisches Sortieren und Filtern mit RowSorter
|  |  | 15.18.11 Ein professionelles Tabellenlayout mit JGrid
|  | 15.19 Bäume (JTree)
|  |  | 15.19.1 JTree und sein TreeModel und TreeNode
|  |  | 15.19.2 Selektionen bemerken
|  |  | 15.19.3 Das TreeModel von JTree
|  | 15.20 JRootPane, JLayeredPane und JDesktopPane
|  |  | 15.20.1 Wurzelkomponente der Top-Level-Komponenten (JRootPane)
|  |  | 15.20.2 JLayeredPane
|  |  | 15.20.3 JDesktopPane und die Kinder JInternalFrame
|  | 15.21 Dialoge und Window-Objekte
|  |  | 15.21.1 JWindow und JDialog
|  |  | 15.21.2 Modal oder nicht-modal
|  |  | 15.21.3 Standarddialoge mit JOptionPane
|  |  | 15.21.4 Der Farbauswahldialog JColorChooser
|  |  | 15.21.5 Der Dateiauswahldialog
|  | 15.22 Flexibles Java-Look
|  |  | 15.22.1 L & F global setzen
|  |  | 15.22.2 UIManager
|  |  | 15.22.3 Verbessern des Aussehens unter Windows mit JGoodies Looks
|  | 15.23 Die Zwischenablage (Clipboard)
|  |  | 15.23.1 Clipboard-Objekte
|  |  | 15.23.2 Auf den Inhalt zugreifen mit Transferable
|  |  | 15.23.3 DataFlavor ist das Format der Daten in der Zwischenablage
|  |  | 15.23.4 Einfügungen in der Zwischenablage erkennen
|  |  | 15.23.5 Drag
|  | 15.24 Undo durchführen
|  | 15.25 AWT, Swing und die Threads
|  |  | 15.25.1 Ereignisschlange (EventQueue) und AWT-Event-Thread
|  |  | 15.25.2 Swing ist nicht Thread-sicher
|  |  | 15.25.3 Swing-Elemente mit invokeLater() und invokeAndWait() bedienen
|  |  | 15.25.4 SwingWorker
|  |  | 15.25.5 Eigene Ereignisse in die Queue setzen
|  |  | 15.25.6 Auf alle Ereignisse hören
|  | 15.26 Barrierefreiheit mit der Java Accessibility API
|  | 15.27 Benutzerinteraktionen automatisieren
|  |  | 15.27.1 Automatisch in die Tasten hauen
|  |  | 15.27.2 Mausoperationen
|  |  | 15.27.3 Methoden zur Zeitsteuerung
|  |  | 15.27.4 Screenshots
|  |  | 15.27.5 MouseInfo und PointerInfo
|  | 15.28 Zeitliches Ausführen mit dem javax.swing.Timer
|  | 15.29 Alternativen zu AWT und Swing
|  |  | 15.29.1 XML-Beschreibungen der Oberfläche: Swixml, XUL/Luxor
|  |  | 15.29.2 SWT (Standard Widget Toolkit)
|  | 15.30 Zum Weiterlesen
## 15.14 Menüs und Symbolleisten 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 an keine feste 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.14.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. Er sitzt auf einem Toplevel-Container außerhalb der Content-Pane. Ein Menü enthält Einträge (engl. items), die eine Aktion auslösen. Jeder Eintrag kann weitere Einträge enthalten. Diese werden dann »Untermenü« (engl. submenu) genannt. Hier klicken, um das Bild zu vergrößern Zunächst müssen wir einen Menübalken erzeugen. Dazu dient die Klasse JMenuBar. Die Einträge erzeugen wir mit der Klasse JMenu.
Beispiel Erzeuge eine Menüzeile mit einem Menü. Hänge die Menüzeile an ein Fenster f: Listing 15.32 JMenuDemo.java, Ausschnitt
    JMenuBar menuBar = new JMenuBar();
    JMenu fileMenu = new JMenu( "Datei" );
    menuBar.add( fileMenu );
    f.setJMenuBar( menuBar );
Die add()-Methode der Klasse JMenuBar fügt der Menüzeile einen Eintrag hinzu. Dieser befindet sich dann direkt unter dem Titel des Fensters und ist immer sichtbar. setJMenuBar(), eine Methode von JFrame, weist den Menübalken einem Fenster zu. 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.
    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.
    class javax.swing.JFrame
    extends Frame
    implements WindowConstants, Accessible, RootPaneContainer
void setJMenuBar( JMenuBar menubar ) Setzt die Menüleiste des Fensters. ### 15.14.2 Menüeinträge definieren Auf jedem horizontalen Eintrag der Menüzeile, den JMenu-Objekten, lassen sich mit add() die vertikalen Elemente hinzufügen. Der Parametertyp ist JMenuItem und umfasst damit: JMenuItem als direkte Menüelemente, die den typischen Schaltflächen entsprechen JMenu als Unterklasse von JMenuItem für Untermenüs JCheckBoxMenuItem und JRadioButtonMenuItem sind ebenfalls zwei Unterklassen von JMenuItem, die einen angewählten Status anzeigen.
Tipp Hierarchische Menüs dürfen nur für wenig gebrauchte Operationen benutzt werden. Dies gilt noch mehr für Popup-Menüs.
Beispiel Erzeuge ein neues Menü-Element für die Hilfe und hänge ihm einen Eintrag an Listing 15.33 JMenuDemo.java, Ausschnitt
    JMenu helpMenu = new JMenu( "Hilfe" );
    menuBar.add( helpMenu );
    helpMenu.add( new JMenuItem("Über das Programm") );
Im Beispiel erzeugt ein mit String parametrisierter Konstruktor das JMenuItem und bestimmt auf diese Weise den Namen der Schaltfläche. Die Klasse bietet jedoch außerdem überladene Konstruktoren, die an JButton erinnern – kein Wunder, da JMenuItem eine Unterklasse von AbstractButton ist.
    class javax.swing.JMenu
    extends JMenuItem
    implements Accessible, MenuElement
MenuItem add( JMenuItem menuItem ) MenuItem add( String s ) Fügt dem Menüeintrag ein neues Element hinzu. void addSeparator() Fügt eine Menütrennlinie ein.
    class javax.swing.JMenuItem
    extends AbstractButton
    implements Accessible, MenuElement
JMenuItem() Erzeugt ein MenuItem ohne Text und Bild. JMenuItem( Icon icon ) 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 Mnemonic. 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.14.3 Einträge durch Action-Objekte beschreiben Menüeinträge lassen sich sehr gut mit Action-Objekten beschreiben, unter anderem deswegen, weil einige Operationen auch über die Symbolleiste aktiviert werden und dahinter der gleiche Programmcode sowie die gleichen Tooltips und Icons stehen. In unserem Menü-Beispiel sieht ein Action-Objekt für den Menü-Eintrag Datei • Beenden am Menü fileMenu so aus: Listing 15.34 JMenuDemo.java, Ausschnitt
    Action exitAction = new AbstractAction( "Beenden" ) {
      public void actionPerformed( ActionEvent e ) {
        System.exit( 0 );
      }
    };
    fileMenu.add( exitAction );
Der mit einem String parametrisierte Konstruktor von AbstractAction setzt direkt das Property »name«. #### Icons in Menüs und Symbolleisten Das Setzen von Icons übernehmen zwei Properties: SMALL_ICON und LARGE_ICON_KEY. Swing wählt für den passenden Fall das richtige Icon: für Menüs das kleinere SMALL_ICON und für Symbolleisten das LARGE_ICON_KEY.
Beispiel Die Properties eines Action-Objekts für die Aktion »Öffnen«: Listing 15.35 JMenuDemo.java, Ausschnitt
    final Icon smallIcon = new ImageIcon(
                         JMenuDemo.class.getResource("/images/fileopen16x16.png") );
    final Icon largeIcon = new ImageIcon(
                         JMenuDemo.class.getResource("/images/fileopen22x22.png") );

    Action openAction = new AbstractAction() {
      { putValue( Action.NAME, "Öffnen" );
        putValue( Action.DISPLAYED_MNEMONIC_INDEX_KEY, 1 );
        putValue( Action.SMALL_ICON,     smallIcon );
        putValue( Action.LARGE_ICON_KEY, largeIcon ); }
      public void actionPerformed( ActionEvent e ) {
        System.out.println( "Öffnen..." );
      }
    };
Tipp Die Ellipse »...« hinter dem Menüeintrag deutet an, dass der Benutzer einen Dialog erhält, bevor er eine Aktion auslöst.
### 15.14.4 Mit der Tastatur: Mnemonics und Shortcut Die Auswahl der Menüpunkte über die Maus ist nicht die schnellste (und gesündeste) [http://de.wikipedia.org/wiki/Mausarm ] , weil der Benutzer von der Tastatur auf die Maus übergehen muss, die Auswahl trifft und dann wieder zurück zur Tastatur geht. Dies ist ein Kontextwechsel, der Zeit kostet. Besser – und für Behinderte von großem Vorteil –, ist die zusätzliche Möglichkeit der Menüauswahl über die Tastatur. Dazu definieren Swing und die meisten grafischen Oberflächen zwei unterschiedliche Techniken: Tastatur-Shortcuts werden auch Accelerator genannt und definieren Tastenkombinationen, mit denen sich Aktionen direkt ausführen lassen. Die Tastatur-Shortcuts werden immer mit einer Steuerungstaste (üblich ist Strg) und einem anderen Buchstaben aktiviert. Eine Abkürzung zum Markieren des gesamten Textes kann zum Beispiel + sein, zum Speichern des Textes + . Shortcuts beschleunigen die Arbeit ungemein und sollten für häufig benötigte Aktionen immer vergeben werden. Die Funktionstaste zählt auch zu den Tastatur-Shortcuts. Tastenkürzel, auch Mnemonic s genannt. Sie gibt es bei allen Schaltflächen, also auch bei Menüs. Dabei ist ein Buchstabe unterstrichen, zum Beispiel in »Alles markieren«. Bei geöffnetem Menü aktiviert ein Druck auf die Taste dann den Menüpunkt. Die Hauptmenüpunkte werden unter Windows mit der Metataste angezeigt. Möchten wir etwa das Menü unter »Datei« öffnen, so drücken wir + . #### Zwei Arten der Zuweisung Für die Zuweisung eines Accelerators und von Mnemonics gibt es zwei Möglichkeiten: Einmal das Action-Objekt – mit den Möglichkeiten wie oben beschrieben – oder über Setter vom JMenuItem. ### 15.14.5 Der Tastatur-Shortcut (Accelerator) Die Methode setAccelerator() verbindet ein JMenuItem oder ein JMenu mit einem Accelerator. Ein Argument der Methode ist ein KeyStroke-Objekt, das das Tastenkürzel definiert.
Beispiel Definiere für einen Menüeintrag item die Abkürzung + :
    item.setAccelerator(
      KeyStroke.getKeyStroke('C', InputEvent.CTRL_MASK)
    );
Die Klasse KeyStroke definiert keine Konstruktoren, nur einige Fabrik-Methoden, die Key-Stroke-Objekte zurückliefern. Neben den normalen Zeichen können auch andere Zeichen – zum Beispiel die Funktionstasten – Aktionen auslösen. Die Taste 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 deklariert 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(Key-Event.VK_DELETE, InputEvent.CTRL_MASK) und »alt shift Q« gleichwertig mit getKey-Stroke(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. #### Standards wahren Auf keinen Fall dürfen wir es versä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. Im Laufe der Zeit haben sich verschiedene Styleguides eingebürgert: So wird beispielsweise für »Datei öffnen« der Shortcut + verwendet und nicht etwa + , der eine getätigte Selektion in die Zwischenablage (engl. clipboard) kopiert. Die folgende Tabelle listet einige Shortcuts auf:
Sequenz | Bedeutung
+ | Neu Datei
+ | Datei öffnen
+ | Datei speichern
+ | Drucken
+ | Selektion in die Zwischenablage
+ | Der Zwischenablage entnehmen
+ | Selektion ausschneiden und in die Zwischenablage legen
+ | Suchen
| Hilfe
| Darstellung aktualisieren
-Taste | Selektiertes Element löschen
Tipp Der Benutzer sollte alle Shortcuts ändern können – der Designer gibt lediglich Standardwerte vor. Diese vorgegebenen Werte sollten aber nicht einfach das Alphabet durchwandern.
### 15.14.6 Tastenkürzel (Mnemonics) Neben den Shortcuts gibt es die unterstrichenen Buchstaben bei Beschriftungen: 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
void setMnemonic( int mnemonic ) Setzt ein Tastatur-Mnemonic. int getMnemonic() Liefert den gesetzten Mnemonic. ### 15.14.7 Symbolleisten alias Toolbars Mit der Klasse JToolBar, die unter dem AWT keine Entsprechung besitzt, lassen sich Symbolleisten erstellen. Diese Symbolleisten erhalten häufig eine Menge von Schaltflächen, die horizontal oder vertikal angeordnet sein dürfen. Für die JToolBar-Klasse ist dies aber unerheblich, da sie beliebige Swing-Komponenten annimmt. Schöner sieht es jedoch aus, wenn alle Komponenten die gleiche Größe aufweisen. Für die JToolBar wollen wir unser Programm JMenuDemo vervollständigen. Es soll die Möglichkeit bieten, eine Datei zu öffnen und in einem Textbereich anzuzeigen. Listing 15.36 com/tutego/insel/ui/swing/JMenuDemo.java
    package com.tutego.insel.ui.swing;

    import java.awt.BorderLayout;
    import java.awt.event.ActionEvent;
    import java.io.FileReader;
    import java.io.IOException;
    import javax.swing.*;

    public class JMenuDemo
    {
      public static void main( String[] args )
      {
        JFrame f = new JFrame();

        final JTextArea textArea = new JTextArea();
        f.add( new JScrollPane(textArea) );

        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        f.setSize( 300, 200 );

        JMenuBar menuBar = new JMenuBar();
        JMenu fileMenu = new JMenu( "Datei" );
        menuBar.add( fileMenu );
        JMenu helpMenu = new JMenu( "Hilfe" );
        menuBar.add( helpMenu );
        f.setJMenuBar( menuBar );

        helpMenu.add( new JMenuItem("Über das Programm") );

        final Icon smallIcon = new ImageIcon(
                           JMenuDemo.class.getResource("/images/fileopen16x16.png") );
        final Icon largeIcon = new ImageIcon(
                           JMenuDemo.class.getResource("/images/fileopen22x22.png") );

        Action openAction = new AbstractAction() {
          { putValue( Action.NAME, "Öffnen" );
            putValue( Action.DISPLAYED_MNEMONIC_INDEX_KEY, 1 );
            putValue( Action.SMALL_ICON, smallIcon );
            putValue( Action.LARGE_ICON_KEY, largeIcon ); }
          public void actionPerformed( ActionEvent e ) {

            JFileChooser fileChooser = new JFileChooser();
            if ( fileChooser.showOpenDialog( null ) == JFileChooser.APPROVE_OPTION )
            {
              try {
                textArea.read( new FileReader(fileChooser.getSelectedFile()), null );
              }
              catch ( IOException ex ) {
                textArea.setText( ex.getMessage() );
              }
            }
          }
        };

        fileMenu.add( openAction );
        fileMenu.addSeparator();

        Action exitAction = new AbstractAction() {
          { putValue( Action.NAME, "Beenden" );
            putValue( Action.DISPLAYED_MNEMONIC_INDEX_KEY, 0 ); }
          public void actionPerformed( ActionEvent e ) {
            System.exit( 0 );
          }
        };
        fileMenu.add( exitAction );

        JToolBar toolbar = new JToolBar();
        toolbar.add( openAction );

        f.add( toolbar, BorderLayout.PAGE_START );

        f.setVisible( true );
      }
    }
Hinweis Das Laden eines Textes sollte in einem Hintergrund-Thread geschehen, um den AWT-Event-Thread nicht zu blockieren. Das zeigt das Beispiel auf Grund der Kürze nicht, wird jedoch im späteren Kapitel »AWT, Swing und die Threads« näher beleuchtet.
Der Benutzer kann die Symbolleisten frei verschieben. Dann erscheinen die aufgenommenen Komponenten in einem eigenen Fenster mit einem Titel, der sich im Konstruktor festlegen lässt. Diese Eigenschaft kann mit der Methode setFloatable(false) aber ausgeschaltet werden. Das kleine Fenster ist schwergewichtig.
    class javax.swing.JToolBar
    extends JComponent
    implements SwingConstants, Accessible
JToolBar() Erstellt eine neue horizontale Toolbar. JToolBar( String name ) Erstellt eine neue Toolbar, die einen Namen in der Titelleiste anzeigt, wenn die Toolbar als Fenster dargestellt wird. JToolBar( String name, int orientation ) Eine neue Toolbar mit Namen und Orientierung (entweder JToolBar.HORIZONTAL oder VERTICAL). Aus der Oberklasse Container erben wir die Möglichkeit, mittels add() Elemente aufzunehmen. Dennoch kommen weitere Funktionen hinzu. Zu ihnen zählen: void addSeparator(), void addSeparator( Dimension d ) Fügt einen Freiraum ein. Bei der parameterlosen Variante bestimmt das aktuelle Look & Feel das Aussehen. void setRollover( boolean rollover ) Stellt die Elemente mit einem Roll-over-Effekt dar. Die Methode getRollover() erfragt diesen Zustand. void setFloatable( boolean f ) Lässt sich die Toolbar zu einem Fenster abreißen? Standardmäßig ja. getFloatable() erfragt das Flag. Dazu muss die Komponente allerdings in einem Container liegen, der BorderLayout nutzt. ### 15.14.8 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. Eine andere häufig gebrauchte Bezeichnung ist Kontextmenü, weil das Menü je nach dem Kontext, in dem es aufgerufen wird, verschiedene Einträge 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.
Tipp Popup-Menüs sollen die Navigation erleichtern, deshalb sollten sie nicht zu lang sein oder zu viele Ebenen besitzen. Gleiches gilt übrigens für die Menüstruktur. Wenn es mehr als drei Ebenen werden, sollte über eine Neugestaltung nachgedacht werden. 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.16 Ein Popup-Menü auf einem Textfeld #### Popup-Menüs (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ügt, doch springt es 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 diese Einstellung auch umdefinieren. Das MouseEvent aus dem Ereignis bietet über isPopupTrigger()aber 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 ), 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. #### Ein allgemeiner Listener Es wäre praktisch, wenn Swing eine Standard-Implementierung mitbrächte, die auf Grund eines Mausklicks gleich ein Popup-Menü öffnet, doch leider müssen wir eine solche kleine Klasse selbst schreiben. Listing 15.37 com/tutego/insel/ui/swing/PopupMenuMouseListener.java
    package com.tutego.insel.ui.swing;

    import java.awt.event.*;

    import javax.swing.JPopupMenu;

    public class PopupMenuMouseListener extends MouseAdapter
    {
      private final JPopupMenu popmen;

      public PopupMenuMouseListener( JPopupMenu popmen )
      {
        this.popmen = popmen;
      }

      @Override
      public void mouseReleased( MouseEvent me ) {
        if ( me.isPopupTrigger() )
          popmen.show( me.getComponent(), me.getX(), me.getY() );
      }
    }
Unser PopupMenuMouseListener erweitert einen MouseAdapter und prüft in der überschriebenen Methode mouseReleased(), ob die richtige Maustaste gedrückt wurde. Wenn sie gedrückt wurde, öffnet show() das Popup-Menü. (Es gibt schon eine Schnittstelle PopupMenuListener, die jedoch für das Popup einer JComboBox bestimmt ist.) #### Beispiel für ein JPopupMenu Wir wollen nun ein Beispiel implementieren, das ein Popup-Menü anzeigt. Das Programm soll bei der Auswahl eines Elements den Menüeintrag in ein Textfeld schreiben. Listing 15.38 com/tutego/insel/ui/swing/JPopupMenuDemo.java
    package com.tutego.insel.ui.swing;

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

    public class JPopupMenuDemo
    {
      public static void main( String[] args )
      {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

        final JPopupMenu popmen = new JPopupMenu();
        final JTextArea textArea = new JTextArea();

        f.add( new JScrollPane(textArea) );

        JMenuItem entryHead = new JMenuItem( "Kompaktstaubsauger" );
        popmen.add( entryHead );
        popmen.addSeparator();
Der erste Eintrag im Menü ist eine Überschrift ohne verbundenen Listener. Dann sollen einige Einträge in das Popup-Menü folgen; eine Swing-Action enthält den Listener und den Anzeigetext. Damit reagieren wir auf die Ereignisse, wenn der Benutzer einen Eintrag im Menü auswählt.
        for ( String s : ("AEG Vampyrino SX,Electrolux Clario Z 1941," +
                          "Quelle Privileg Piccolino,Siemens Super T120VS12A00," +
                          "Hoover Micro Power Electronic,Rowenta dymbo").split(",") )
        {
          popmen.add( new AbstractAction(s) {
            public void actionPerformed( ActionEvent e ) {
              textArea.append( e.getActionCommand() + "\n" );
            }
          } );
        }
Der letzte Schritt besteht nun darin, der JTextArea einen Listener mitzugeben, der auf die Maustaste hört, damit das Kontextmenü aufgerufen werden kann. Mit unserem PopupMenuMouseListener ist das ein Einzeiler:
        textArea.addMouseListener( new PopupMenuMouseListener(popmen) );

        f.setSize( 300, 300 );
        f.setVisible( true );
      }
    }
Tipp Popup-Menüs sollten einen ersten nicht selektierbaren Eintrag besitzen. Dies macht die Auswahl nicht wesentlich langsamer, ermöglicht aber das Abbrechen einer Operation auf einfachere Weise
### 15.14.9 System-Tray nutzen Seit Java 6 lassen sich Icons in die System-Tray setzen und zusätzlich mit Popup-Menüs ausstatten. Im Zentrum stehen dabei zwei neue Klassen aus dem java.awt-Paket: TrayIcon repräsentiert die Symbole und Meldungen, die in die Tray kommen, und SystemTray repräsentiert die System-Tray selbst. Um Symbole mit Popup-Menü in die Tray zu legen, sollte mit der statischen Funktion isSupported() zunächst das Vorhandensein der Tray getestet werden. Im nächsten Schritt ist ein TrayIcon zu bauen, was drei Argumente erwartet: ein java.awt.Image, einen String für den Tooltip und ein Exemplar eines java.awt.PopupMenu, wenn denn ein Menü definiert werden soll. Listing 15.39 com/tutego/insel/ui/awt/SystemTrayDemo,java, main()
    Image image = Toolkit.getDefaultToolkit().getImage(
                    SystemTrayDemo.class.getResource( "/images/javabean.gif") );

    PopupMenu popup = new PopupMenu();
    MenuItem item = new MenuItem("Exit");
    item.addActionListener( new ActionListener() {
      public void actionPerformed( ActionEvent e ) {
        System.exit( 0 );
      }
    } );
    popup.add( item );

    TrayIcon trayIcon = new TrayIcon( image, "Java-Tray ", popup );
    trayIcon.setImageAutoSize( true );
Die Methode setImageAutoSize() passt das Icon der Größe des Containers an. Die skalierte Variante sieht nicht immer gut aus, ist aber bei verschiedenen vom Benutzer beliebig vorgebbaren Größen sinnvoll. Dieses TrayIcon wird anschließend der System-Tray hinzugefügt:
    SystemTray tray = SystemTray.getSystemTray();
    tray.add( trayIcon );
Mit der Methode setImage() auf einem TrayIcon lässt sich die Grafik ändern und auf diese Weise eine Animation erzeugen. Den Tooltip ändert setTooltip(). Zum Anzeigen einer Meldung eignet sich displayMessage(), wie die folgenden Zeilen aus dem Demo-Programm zeigen:
    trayIcon.displayMessage( "Formatierung beendet.",
                             "Sie können den Rechner jetzt neu installieren.",
                             TrayIcon.MessageType.INFO );
Neben TrayIcon.MessageType.INFO für eine Informationsmeldung existieren die Aufzählungen ERROR, NONE und WARNING. ### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.
Name |
E-Mail |
Ihr Kommentar |
<< zurück | <top> | vor >>

Copyright © Galileo Press 2008
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de