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.10 Alles Auslegungssache: die Layoutmanager Ein Layoutmanager ist dafür verantwortlich, Elemente eines Containers nach einem bestimmten Verfahren anzuordnen, zum Beispiel zentriert oder von links nach rechts. Ein Container fragt bei einer Neudarstellung immer seinen Layoutmanager, wie er seine Kinder anordnen soll. Jeder Layout-Manager implementiert eine unterschiedliche Strategie zur Anordnung. ### 15.10.1 Übersicht über Layoutmanager Java bietet bisher folgende Layoutmanager: FlowLayout: Ordnet Komponenten von links nach rechts an. BoxLayout: Ordnet Komponenten horizontal oder vertikal an. GridLayout: Setzt Komponenten in ein Raster, wobei jedes Element die gleichen Ausmaße besitzt. BorderLayout: Setzt Komponenten in vier Himmelsrichtungen oder in der Mitte. GridBagLayout: Sehr flexibler Manager als Erweiterung von GridLayout. [Packer (https://packer.dev.java.net/) ist eine alternative API für die GridBagLayout-Funktionalität. ] CardLayout: Verwaltet Komponenten wie auf einem Stapel, sodass nur eine Komponente sichtbar ist. SpringLayout: Berücksichtigt Abhängigkeiten der Kanten von Komponenten. [SpringLayout wird selten verwendet – wenn, dann von GUI-Buildern. Mehr Informationen dazu gibt die Webseite http://java.sun.com/docs/books/tutorial/uiswing/layout/spring.html. ] GroupLayout: Für GUI-Builder im Allgemeinen die beste Wahl. Hier klicken, um das Bild zu vergrößern #### GroupLayout, GUI-Bilder und Matisse Der Layoutmanager GroupLayout fand zum ersten Mal im GUI-Builder Matisse von NetBeans 5 Platz. Das Publikum hat ihn schnell angenommen, sodass Sun in kurzerhand in Java 6 integrierte. Wer GroupLayout vor Java 5 verwenden möchte – oder eine neuere Version –, der muss das Java-Archiv swing-layout-x.y.z.jar in den Klassenpfad setzen. Die Java-Datei gibt es entweder unter https://swing-layout.dev.java.net/ oder bei einer NetBeans-Installation im modules/ext-Verzeichnis.
Tipp Jeder Entwickler sollte sich mit GUI-Buildern anfreunden, denn sie nehmen viel Arbeit ab. Die Präsentation von Matisse als Flash-Film unter http://tutego.com/go/matisse ist sehr anregend.
In der kommerziellen Plugin-Sammlung MyEclipse findet sich Matisse unter dem Namen Matisse4MyEclipse als Eclipse-Portierung wieder. ### 15.10.2 Zuweisen eines Layoutmanagers Die Methode setLayout(LayoutManager) weist einem Container eine Ausrichtungsstrategie zu.
    class java.awt.Container
    extends Component
void setLayout( LayoutManager mgr ) Setzt einen neuen Layoutmanager für den Container. LayoutManager getLayout() Liefert den aktuellen Layoutmanager. LayoutManager ist eine Schnittstelle, die von unterschiedlichsten konkreten Layoutmanagern implementiert wird. Die zentrale Operation ist layoutContainer(), die dafür verantwortlich ist, die absoluten Positionen via setBounds() zu setzen. #### JPanel mit einem Layout-Manager verbinden Erinnern wir uns, dass die Klasse JPanel ein Container ist und daher auch ein eigenes Layout besitzen kann. Praktisch ist der Konstruktor, der gleich einen Layout-Manager annimmt. (Das JPanel ist bisher die einzige Klasse, der ein Layoutmanager gleich im Konstruktor übergeben werden kann.)
    class javax.swing.JPanel
    extends JComponent
    implements Accessible
JPanel( LayoutManager layout ) Erzeugt ein JPanel mit Doppelpufferung und dem angegebenen Layoutmanager. JPanel( LayoutManager layout, boolean isDoubleBuffered ) Erzeugt ein neues JPanel mit dem angegebenen Layoutmanager und der Puffer-Strategie.
Tipp Fitts’s Law beschreibt die Zeit, die benötigt wird, um von einem Anfangspunkt zu einem Endpunkt zu kommen. Diese Zeit ist abhängig vom Logarithmus der Strecke zwischen dem Start- und dem Endpunkt und der Größe des Ziels. Daher gilt: Platziere die Elemente einer Oberfläche so, dass sie leicht zu erreichen sind. Je weiter das Ziel entfernt und je kleiner der Button ist, desto länger dauert die Operation.
### 15.10.3 Im Fluss mit FlowLayout Der FlowLayout-Manager setzt seine Elemente von links nach rechts in eine Zeile. Die Komponenten behalten ihre Größe, das heißt, der Layoutmanager gibt keine neue Größe vor. Passen nicht alle Elemente in eine Zeile, so werden sie untereinander angeordnet. Ein zusätzlicher Parameter bestimmt, wie die Elemente im Container positioniert werden: zentriert, rechts- oder linksbündig. Ohne Einstellung ist die Anzeige zentriert. Standardmäßig besitzt jedes neue JPanel-Objekt ein FlowLayout als Layoutmanager. Hier klicken, um das Bild zu vergrößern Listing 15.22 com/tutego/insel/ui/layout/FlowLayoutDemo.java
    package com.tutego.insel.ui.layout;

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

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

        f.setLayout( new FlowLayout() );

        JComboBox choice = new JComboBox();
        choice.addItem( "Mike: Mein Gott Walter" );
        choice.addItem( "Sweet: Co Co" );

        f.add( choice );
        f.add( new JButton(
           new ImageIcon( FlowLayoutDemo.class.getResource("/images/play.png" ) ) ) );

        f.pack();
        f.setVisible( true );
      }
    }
Hier klicken, um das Bild zu vergrößern Abbildung 15.7 FlowLayout mit Mike Den Elementen kann zusätzlich mehr Freiraum (engl. gap) gegeben werden. Voreingestellt sind fünf Pixel. Die Ausrichtung (engl. alignment), die beim Umbruch angegeben werden kann, ist eine ganzzahlige Konstante aus FlowLayout. Es stehen drei Klassen-Konstanten zur Verfügung: FlowLayout.LEFT, FlowLayout.CENTER und FlowLayout.RIGHT.
    class java.awt.FlowLayout
    implements LayoutManager, Serializable
FlowLayout() Erzeugt ein Flow-Layout mit fünf Pixeln horizontalem und vertikalem Freiraum. FlowLayout( int align ) Erzeugt ein Flow-Layout mit fünf Pixeln Freiraum und der angegebenen Ausrichtung. FlowLayout( int align, int hgap, int vgap ) Erzeugt ein Flow-Layout mit der angegebenen Ausrichtung und einem horizontalen beziehungsweise vertikalen Freiraum. int getAlignment() Liefert das Alignment des Layoutmanagers. Möglich sind FlowLayout.LEFT, FlowLay-out.RIGHT oder FlowLayout.CENTER. void setAlignment( int align ) Setzt das Alignment mit Hilfe der Konstanten FlowLayout.LEFT, FlowLayout.RIGHT oder FlowLayout.CENTER. int getHgap(), int getVgap() Liefert den horizontalen/vertikalen Abstand der Komponenten. void setHgap( int hgap ), void setVgap( int vgap ) Setzt den horizontalen/vertikalen Abstand zwischen den Komponenten. ### 15.10.4 Mit BorderLayout in allen Himmelsrichtungen Ein BorderLayout unterteilt seine Zeichenfläche in fünf Bereiche: Norden, Osten, Süden, Westen und Mitte (»Center«). Die Elemente im Norden und Süden erstrecken sich immer über die gesamte Länge des Containers. Die Höhe des Nordens und Südens ergibt sich aus der Wunschhöhe der Kinder, und die Breite wird angepasst. Die Elemente rechts und links bekommen ihre gewünschte Breite, werden aber in der Höhe gestreckt. Das Element in der Mitte wird in Höhe und Breite angepasst. Für jeden dieser Bereiche (Richtungen) sieht die Klasse BorderLayout eine Konstante vor: BorderLayout.CENTER, BorderLayout.NORTH, BorderLayout.EAST, BorderLayout.SOUTH und BorderLayout.WEST. Dem Container fügen wir mit der Methode add(Komponente, Richtung) eine Komponente hinzu, wobei das zweite Argument die Angabe der Himmelsrichtung ist. Diese Angabe ist jedoch ungünstig für bidirektionale Anwendungen wie Arabisch oder Hebräisch, da eine Komponente, die für uns links liegt, dort rechts liegen soll. Eine Angabe wie BorderLayout.WEST ist aber statisch. Seit Java 1.4 bietet BorderLayout die Konstanten: LINE_START und LINE_END, was im Fall der Links-nach-Rechts-Anordnung bedeutet: LINE_START ist WEST und LINE_END ist EAST. Eigentlich gibt es auch PAGE_START und PAGE_END, die jedoch nicht beachtet werden, da Java bisher eine Verdrehung der Nord-/Südachse nicht unterstützt.
Beispiel Setze die Schaltfläche button in den Westen.
    container.add( button, BorderLayout.LINE_START );
Wird die Funktion add() mit nur einem Argument aufgerufen, so wird die Komponente automatisch in die Mitte (Center) gesetzt. Listing 15.23 com/tutego/insel/ui/layout/BorderLayoutDemo.java
    package com.tutego.insel.ui.layout;

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

    public class BorderLayoutDemo
    {
      public static void main( String[] args )
      {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
    //    f.applyComponentOrientation( ComponentOrientation.RIGHT_TO_LEFT );

        f.setLayout( new BorderLayout(5, 5) );

        f.add( new JButton("Nie"), BorderLayout.PAGE_START );
        f.add( new JButton("ohne"), BorderLayout.LINE_END );
        f.add( new JButton("Seife"), BorderLayout.PAGE_END );
        f.add( new JButton("waschen"), BorderLayout.LINE_START );
        f.add( new JButton("Center") );

        f.setSize( 400, 150 );
        f.setVisible( true );
      }
    }
Hier klicken, um das Bild zu vergrößern Abbildung 15.8 Der Layoutmanager BorderLayout
Hinweis Beim AWT gilt, dass der Container java.awt.Frame automatisch mit einem BorderLayout verbunden ist. Das gilt bei JFrame, beziehungsweise seinen Content-Panes ebenso. Allerdings verwendet die JRootPane, der Container für die Content-Panes, den internen Manager RootLayout, der nicht mit BorderLayout verwandt ist.
Wer das Vertauschen der Seiten ausprobieren möchte, der muss nur den Kommentar aus der Zeile mit der Methode applyComponentOrientation() herausnehmen. Spannende Informationen zu diesem Thema liefert die Webseite http://tutego.com/go/bidijava.
    class java.awt.BorderLayout
    implements LayoutManager, Serializable
BorderLayout() Erzeugt ein neues BorderLayout, wobei die Komponenten ohne Abstand aneinander liegen. BorderLayout( int hgap, int vgap ) Erzeugt ein BorderLayout, wobei zwischen den Komponenten ein Freiraum eingefügt wird. hgap spezifiziert den Freiraum in der Horizontalen und vgrap den in der Vertikalen. Die Freiräume werden in Pixeln gemessen. int getHgap(), int getVgap() Gibt den horizontalen/vertikalen Raum zwischen den Komponenten zurück. void setHgap( int hgap ), void setVgap( int vgap ) Setzt den horizontalen/vertikalen Zwischenraum.
Hinweis An Stelle von add(Komponente, BorderLayout.Orientierung) lässt sich eine Komponente auch mit der Variante add(Orientierungszeichenkette, Komponente) hinzufügen. Diese Angabe ist jedoch veraltet und sollte nicht mehr verwendet werden.
    class java.awt.Container
    extends Component
void add( Component comp, Object constraints ) Fügt die Komponente in den Container ein. Die Variable constraints wird im Fall vom BorderLayout etwa mit den Konstanten PAGE_START, LINE_END, PAGE_END, LINE_START oder CENTER belegt.
Hinweis Ein einfaches add(comp) auf einem Container mit BorderLayout hat den gleichen Effekt wie add(comp, BorderLayout.CENTER). Werden mehrmals hintereinander Komponenten einfach mit add(comp) dem Container hinzugefügt, so werden sie alle im Zentrum über-einander gestapelt, sodass nur noch die letzte hinzugefügte Komponente sichtbar ist.
### 15.10.5 Rasteranordnung mit GridLayout Das GridLayout ordnet seine Komponenten in Zellen an, wobei die Zeichenfläche rechteckig ist. Jeder Komponente in der Zelle wird dieselbe Größe zugeordnet, also bei drei Elementen in der Breite ein Drittel des Containers. Wird der Container vergrößert, so werden die Elemente gleichmäßig vergrößert. Sie bekommen so viel Platz wie möglich. Hier klicken, um das Bild zu vergrößern Abbildung 15.9 Beispiel für GridLayout Listing 15.24 com/tutego/insel/ui/layout/GridLayoutDemo.java
    package com.tutego.insel.ui.layout;

    import java.awt.*;
    import java.text.*;

    import javax.swing.*;

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

        f.setLayout( new GridLayout(/*3*/ 0, 2, 6, 3) );

        f.add( new JLabel(" Wie heißt du denn mein Kleiner?") );
        f.add( new JTextField() );
        f.add( new JLabel(" Na, wie alt bist du denn?") );
        f.add( new JFormattedTextField(NumberFormat.getIntegerInstance()) );
        f.add( new JLabel(" Dann mal das Passwort eingeben:") );
        f.add( new JPasswordField() );

        f.pack();
        f.setVisible( true );
      }
    }
    class java.awt.GridLayout
    implements LayoutManager, Serializable
GridLayout() Erzeugt ein GridLayout mit einer Spalte pro Komponente in einer Zeile. GridLayout( int rows, int cols ) Erzeugt ein GridLayout mit rows Zeilen oder cols Spalten. Die zu berechnende Anzahl sollte auf 0 gesetzt werden. GridLayout( int rows, int cols, int hgap, int vgap ) Erzeugt ein GridLayout mit rows Zeilen oder cols Spalten. Horizontale Freiräume werden an die rechten und linken Ecken jeder Zeile sowie zwischen den Spalten gesetzt. Vertikale Freiräume werden an die unteren und oberen Ecken gesetzt, zudem zwischen die Reihen. Beim Konstruktor, der Zeilen oder Spalten angibt, reicht es, lediglich eine Angabe für die Anzahl der Elemente in der Zeile oder Spalte zu machen; der Layoutmanager nutzt ohnehin nur eine Angabe und berechnet daraus die verbleibende Anzahl. Ein mit Zeilen oder Spalten parametrisierter Konstruktor erlaubt es – so wie beim BorderLayout –, Zwischenraum einzufügen.
Beispiel Setze ein Layout mit drei Zeilen:
    container.setLayout( new GridLayout(3, 0xcafebabe) );
Bei nur vier Elementen können wir auf diese Anzahl von fiktiven Spalten gar nicht kommen. Bei gegebener Zeilenanzahl wird sie nicht genutzt.
GridLayout berechnet die Anzahl der passenden Spalten für die Anzahl der Komponenten. Das zeigt die Implementierung in der Methode preferredLayoutSize(), minimumLayoutSize() und layoutContainer().
    if ( nrows > 0 )
      ncols = (ncomponents + nrows – 1) / nrows;
    else
      nrows = (ncomponents + ncols – 1) / ncols;
Ist die Anzahl der Zeilen gleich 0, so berechnet der Layoutmanager den Wert aus der Anzahl der Spalten.
Tipp Existiert eine Anzahl Zeilen, so ist die Angabe für die Spalten völlig uninteressant. Der Wert sollte daher der Übersichtlichkeit halber auf 0 gesetzt werden.
### 15.10.6 Der GridBagLayout-Manager Die bisherigen Layoutmanager sind für Teilprobleme zwar einfach, lösen aber komplexe Layoutsituationen nur ungenügend; so blieb bisher nur der Weg über viele geschachtelte Panel-Objekte mit eigenen Layoutmanagern. Mit dem GridBagLayout hat Sun einen sehr flexiblen, aber auch komplizierten Layoutmanager eingefügt, mit dem sich jede Oberfläche gestalten lässt. Die Idee dabei ist wie beim GridLayout, dass die Elemente in Zeilen und Spalten eingeteilt werden. Sind bei einem GridLayout jedoch alle Elemente gleich hoch und gleich breit, lässt sich beim GridBagLayout ein Element über mehrere Zeilen und Spalten ziehen und das Verhältnis bei der Vergrößerung des Containers angeben. Dafür wird ein zusätzliches Objekt eingeführt, das jeder Komponente die Position und Ausrichtung aufzwingt. Dies ist die Klasse GridBagConstraints. Der Name Constraint, zu Deutsch Einschränkung, sagt aus, dass der Container versucht, diese Constraints einzuhalten. #### GridBagConstraints Ein Objekt vom Typ GridBagConstraints schreibt dem Layout ganz unterschiedliche Werte vor. Um eine Komponente in einem GridBagLayout zu positionieren, muss zuerst ein Exemplar von GridBagConstraints konstruiert werden. Anschließend wird eine Komponente mit setConstraints(Komponente, GridBagConstraints) beim GridBagLayout angemeldet. Danach muss nur noch die Komponente, wie bei jedem anderen Container auch, mit add() hinzugefügt werden. Der prinzipielle Weg soll kurz skizziert werden:
    // Am Anfang Container und Layoutmanager besorgen
    Container container;
    ...
    GridBagLayout gbl = new GridBagLayout();
    container.setLayout( gbl );
    // Für alle Komponenten
    Component component;
    ...
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.XXX = YYY;             // notwendige Einstellungen machen
    // Am Manager Constraints für Komponente anmelden
    gbl.setConstraints( component, gbc );

    // Element in den Container einfügen
    container.add( component );
#### GridBagConstraints-Objekt aufbauen Um ein GridBagConstraints-Objekt aufzubauen, gibt es zwei Möglichkeiten. Es lässt sich mit dem Standard-Konstruktor erzeugen oder mit einem parametrisierten Konstruktor, der jedoch gleich elf Werte annehmen möchte. Wir entscheiden uns für den Standard-Konstruktor und setzen die Werte über die Objektvariablen. Die wichtigsten Werte sind: Position der Elemente und Ausmaße. Beim Aufbau eines eigenen Layouts ist es sinnvoll, die Elemente in Zeilen und Spalten einzutragen und dann aufzuschreiben, welche Größe sie einnehmen. Widmen wir uns nun dem Programm, das ein Layout mit fünf Zeilen (0, 1, ..., 4) und drei Spalten (0, 1, 2) realisiert. Gewünscht ist eine Realisierung der folgenden Abbildung: Hier klicken, um das Bild zu vergrößern Abbildung 15.10 Beispiel für ein GridBagLayout Die Schaltfläche »1« nimmt Platz für zwei Spalten ein. Hinsichtlich der Ausdehnung soll die Komponente den ganzen restlichen Platz einnehmen. In der dritten Zeile nimmt die Schaltfläche »4« drei Spalten ein. #### Wichtige Attribute des GridBagConstraints: Breite, Höhe und Ausdehnung Für das GridBagConstraint jeder Komponente sind vier Variablen besonders wichtig:
    class java.awt.GridBagConstraints
    implements Cloneable, Serializable
int gridx, int gridy gridx gibt die Position links vom Anzeigebereich an und gridy die Position direkt über dem Anzeigebereich der Komponente. Das Element ganz links hat den Wert 0, und der obersten Zelle ist der Wert 0 zugeordnet. Wenn die Komponenten automatisch rechts beziehungsweise unter die letzte Komponente platziert werden, wird die Konstante GridBagConstraints.RELATIVE vergeben, das heißt, die Komponente wird direkt an der letzten Komponente in der Zeile oder Spalte positioniert. Der Standardwert ist RELATIVE mit dem Wert –1. Stehen die Werte fest, gilt das für Komponenten, die immer die gleiche Größe von einer Zeile und einer Spalte haben. Das ist aber nicht immer der Fall, und daher lässt sich die Ausdehnung in der Horizontalen und Vertikalen angeben. Dann nimmt ein Element für eine Überschrift etwa zwei Spalten ein. int gridwidth, int gridheight Anzahl der Kästchen in einer Zeile und Spalte, die einer Komponente zur Verfügung stehen. Ist der Wert mit der Konstanten GridBagConstraints.REMAINDER belegt, so bedeutet dies, dass das Element das letzte der Zeile oder Spalte ist. GridBagConstraints.REMAINDER trägt den Wert 0. Der Standard für beide Werte ist 1. Wurde die letzte Komponente allerdings schon mit gridwidth gleich GridBagConstraints.REMAINDER eingefügt, so wird die nächste Komponente als erste in die nächste Zeile eingesetzt. Mit diesen Angaben kann schon ein großer Teil einer grafischen Oberfläche entworfen werden. Eine weitere Variable fill bestimmt, ob überhaupt vergrößert werden darf. Wie die Größenänderung aussehen soll, bestimmen zwei weitere Variablen: int fill Für die Belegung von fill existieren vier Konstanten in GridBagConstraints, die angeben, ob der Bereich für die Komponente variabel ist. Das sind: NONE (nicht vergrößern, der Standard), HORIZONTAL (nur horizontal vergrößern), VERTICAL (nur vertikal vergrößern) und BOTH (vertikal und horizontal vergrößern). double weightx, double weighty Die Werte geben an, wie der freie horizontale und vertikale Platz verteilt wird. Der Standard ist 0. Ist in diesem Modus die Summe aller Komponenten einer Zeile beziehungsweise Spalte 0, so wird Freiraum rechts und links beziehungsweise oben und unten zwischen den Zeilen und dem Container eingefügt. Soll die Komponente den überschüssigen Platz verwenden, wird ein Wert größer 0 zugeteilt. Damit vergrößert oder verkleinert sie sich bei Veränderungen und behält ihre bevorzugte Größe nicht. Wenn nur ein Element einen Wert größer 0 besitzt, wird genau dieses vergrößert, und die restlichen Komponenten behalten ihre Größe bei. #### Programmierung vereinfachen Mit diesen Informationen wollen wir nun ein Beispiel implementieren. Doch bevor wir uns einem vollständigen Layout zuwenden, ist es sinnvoll, für den Umgang mit GridBagLayout und GridBagConstraints eine Hilfsfunktion zu schreiben, und zwar mit folgender Signatur:
    static void addComponent( Container cont,
                              GridBagLayout gbl,
                              Component c,
                              int x, int y,
                              int width, int height,
                              double weightx, double weighty )
Die Funktion soll ein GridBagConstraints-Objekt erstellen, die Werte zuweisen und dem Container dieses Constraint-Objekt zuteilen. Mit einer Komponente ist also eine Einschränkung verbunden. Zusätzlich soll die Methode die Komponenten in den Container legen. Die Informationen über das Layout und unsere Abbildung wollen wir nun in einem Programm abbilden: Listing 15.25 com/tutego/insel/ui/layout/GridBagLayoutDemo.java
    package com.tutego.insel.ui.layout;

    import java.awt.*;

    import javax.swing.*;

    class GridBagLayoutDemo
    {
      static void addComponent( Container cont,
                                GridBagLayout gbl,
                                Component c,

                                int x, int y,
                                int width, int height,
                                double weightx, double weighty )
      {
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.fill = GridBagConstraints.BOTH;
        gbc.gridx = x; gbc.gridy = y;
        gbc.gridwidth = width; gbc.gridheight = height;
        gbc.weightx = weightx; gbc.weighty = weighty;
        gbl.setConstraints( c, gbc );
        cont.add( c );
      }

      public static void main( String[] args )
      {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        Container c = f.getContentPane();

        GridBagLayout gbl = new GridBagLayout();
        c.setLayout( gbl );

        //                                      x  y  w  h  wx   wy

        addComponent( c, gbl, new JButton("1"), 0, 0, 2, 2, 1.0, 1.0 );
        addComponent( c, gbl, new JButton("2"), 2, 0, 1, 1, 0  , 1.0 );
        addComponent( c, gbl, new JButton("3"), 2, 1, 1, 1, 0  , 0   );
        addComponent( c, gbl, new JButton("4"), 0, 2, 3, 1, 0  , 1.0 );
        addComponent( c, gbl, new JButton("5"), 0, 3, 2, 1, 0  , 0   );
        addComponent( c, gbl, new JButton("6"), 0, 4, 2, 1, 0  , 0   );
        addComponent( c, gbl, new JButton("7"), 2, 3, 1, 2, 0  , 0   );

        f.setSize( 300, 200 );
        f.setVisible( true );
      }
    }
#### Die restlichen Attribute Die bisherigen Eigenschaften reichen aus, um die wichtigsten Layouts zu realisieren. Mit den Constraints lassen sich jedoch noch andere Werte einstellen:
    class java.awt GridBagConstraints
    implements Cloneable, Serializable
> int anchor Wird die Komponente nicht auf die ganze Breite oder Höhe skaliert, muss sie irgendwo hingesetzt werden. Die Variable anchor setzt sie nach einem bestimmten Verfahren in den Container. Folgende Konstanten sind in GridBagConstraints deklariert: CENTER, NORTH, EAST, WEST, SOUTH, SOUTHEAST, NORTHEAST, SOUTHWEST und NORTHWEST. Der Standard ist CENTER. Insets insets Ein Insets-Objekt bestimmt die minimalen Entfernungen der Komponente vom äußeren Rand in ihrem Anzeigebereich. Für ein Insets-Objekt werden vier Werte für top, left, bottom und right vergeben. Der Standard ist Insets(0,0,0,0). int ipadx, ipady Geben die inneren Abstände (engl. internal padding) einer Komponenten zum Rand an. Sie sind standardmäßig 0. Jetzt haben wir alle Informationen zusammen, um uns noch einmal mit den beiden Konstruktoren zu beschäftigen. GridBagConstraints () Der Standard-Konstruktor; er belegt die Werte, wie die Implementierung zeigt:
>     public GridBagConstraints()
>     {
>       gridx = RELATIVE;  gridy = RELATIVE;
>       gridwidth = 1;     gridheight = 1;
>       weightx = 0;       weighty = 0;
>       anchor = CENTER;
>       fill = NONE;
>       insets = new Insets( 0, 0, 0, 0 );
>       ipadx = 0;         ipady = 0;
>     }
GridBagConstraints( int gridx, int gridy, int gridwidth, int gridheight, double weightx, double weighty, int anchor, int fill, Insets insets, int ipadx, int ipady ) Belegt das Layout mit den angegebenen Werten. ### 15.10.7 Null-Layout Das Argument null bei setLayout() setzt keinen Layoutmanager, und die Komponenten müssen absolut positioniert werden. Zum Setzen der Position und Ausmaße bietet jede Component die Methode setBounds(int x, int y, int breite, int höhe). Ein üblicher Layout-manager wird mit genau dieser Funktion die Größen zuweisen. Das Setzen vom Null-Layout sollte nicht die Regel sein, da Änderungen an der Zeichensatzgröße hässliche Effekte nach sich ziehen. Eine Oma mit Sehschwierigkeiten, die die Fontgröße auf 40 stellt, sieht dann in einer Schaltfläche vielleicht nur eine halbe, abgeschnittene Zeichenkette.
Beispiel Ordne zwei Schaltflächen mit dem null-Layout an. c soll ein passender Container sein.
    c.setLayout( null );
    JButton b = new JButton( "Snug Weste blau, innen rot" );
    b.setBounds( 0, 0, 200, 50 );
    c.add( b );
    b = new JButton( "HPX Gore-tex Ocean Jacket" );
    b.setBounds( 250, 0, 150, 50 );
    c.add( b );
#### TransparentLayout Das Open-Source-Projekt TransparentLayout (https://transparentlayout.dev.java.net/) bietet etwas Ähnliches wie das Null-Layout. Hier werden nicht die Komponenten selbst mit Größen initialisiert, sondern ein Rectangle- bzw .Point-Objekt bei der add()-Methode mitgegeben:
    container.setLayout( new TransparentLayout() );
    container.add( component, new Point(x, y) );
    container.add( component, new Rectangle(x, y, width, height) );
Im Fall des Argumenttyps Point berücksichtigt TransparentLayout die gewünschte Größe der Komponente, die Preferred-Size. ### 15.10.8 BoxLayout BoxLayout ist vergleichbar mit FlowLayout, nur ordnet dieser in der x- oder y-Achse an und bricht nicht um. Das Layoutmanagement ist etwas seltsam, da setLayout() nicht allein genügt, um den Layoutmanager zuzuweisen. Vielmehr bekommt ein Exemplar von BoxLayout zusätzlich eine Referenz auf den Container.
Beispiel Erzeuge ein JPanel und füge zwei untereinander angeordnete JButton-Objekte hinzu.
    JPanel p = new JPanel();
    p.setLayout( new BoxLayout(p, BoxLayout.Y_AXIS) );
    p.add( new JButton("<") );
    p.add( new JButton(">") );
Swing bringt für das BoxLayout noch eine Abkürzung mit. Die Klasse heißt javax.swing.Box und verhält sich wie ein Container. Dem Box-Objekt ist automatisch der Layoutmanager BoxLayout zugewiesen.
Beispiel Füge in eine Box eine Schaltfläche und ein Textfeld ein.
    Box box = new Box( BoxLayout.Y_AXIS );
    box.add( new JButton("Knopf") );
    box.add( new JTextField() );
### 15.10.9 Weitere Layoutmanager OverlayLayout, ScrollPaneLayout und ViewPortLayout sind weitere Layoutmanager aus der Java SE. Sie sind sehr speziell mit ihren Containern verbunden und spielen hier keine Rolle. Weitere Open-Source-Layoutmanager sind: Sun beschreibt unter http://tutego.com/tablelayout den Layoutmanager TableLayout, mit dem sich ähnlich wie mit dem GridBagLayout Raster aufbauen lassen, nur ist die Programmierung viel einfacher. Er gehört nicht zur Standard-Bibliothek, sondern muss extra eingebunden werden, was aber kein Problem ist. Das ab Java 5 arbeitende DesignGridLayout (https://designgridlayout.dev.java.net/) arbeitet zeilenorientiert und ohne extra Beschreibungsobjekte mit einer einfachen API. Das RiverLayout (http://www.datadosen.se/riverlayout/) ordnet Komponenten über textuelle Beschreibungen an, etwa »center« oder »tab hfill vfill«. Das CircleLayout (https://circlelayout.dev.java.net/) setzt die Komponenten an den Rand eines Kreises bzw. einer Ellipse. ### 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