Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 31 - GUI-Dialoge

## 31.1 Erstellen eines Dialogs

- 31.1 Erstellen eines Dialogs
  - 31.1.1 Anlegen eines Dialogfensters
  - 31.1.2 Zuordnen eines Layoutmanagers
  - 31.1.3 Einfügen von Dialogelementen
  - 31.1.4 Anzeigen des Dialogfensters

In diesem Kapitel soll das Erzeugen von Fenstern mit eingebetteten Dialogelementen vorgestellt werden. Derartige Fenster werden in der Praxis sehr viel häufiger benötigt als Fenster, deren Ausgabe mit primitiven Grafikoperationen erzeugt wurde, wie sie in den Kapiteln 23, 24 und 25 vorgestellt wurden. Der Einfachheit halber wollen wir derartige Fenster in diesem Kapitel als Dialoge bezeichnen. Sie dienen dazu, Programmdaten anzuzeigen, und geben dem Anwender die Möglichkeit, diese zu ändern.

Das Erstellen eines Dialogs erfolgt in vier Schritten:

- Anlegen eines Fensters
- Zuordnen eines Layoutmanagers
- Einfügen von Dialogelementen
- Anzeigen des Fensters

### 31.1.1 Anlegen eines Dialogfensters

Das Anlegen eines Fensters zur Aufnahme von Dialogelementen erfolgt genauso wie das Anlegen eines normalen Fensters. Üblicherweise wird dazu eine eigene Fensterklasse abgeleitet, um die Steuerung des Dialogs zu kapseln.

|  | Da Java prinzipiell keinen Unterschied zwischen Fenstern zur Ausgabe eines Dialogs und solchen zur Anzeige von Grafiken macht, ist es möglich, ein Dialogfenster wahlweise aus `Frame` oder `Dialog` abzuleiten. Die Klasse `Dialog` erlaubt es, das Verändern der Fenstergröße durch den Anwender zu unterbinden, und bietet die Möglichkeit, den Dialog modal zu machen. Dadurch wird die Interaktion des Anwenders mit anderen Fenstern der Anwendung bis zum Schließen des Dialogfensters blockiert. Im Gegensatz zu `Frame` fehlt jedoch die Möglichkeit, eine Menüleiste zu erzeugen oder dem Fenster ein Icon zuzuordnen. Wir werden in den nachfolgenden Beispielen meist die Klasse `Frame` verwenden, um Dialoge zu erzeugen. Die Klasse `Dialog` werden wir am Ende dieses Kapitels vorstellen. Dabei werden wir insbesondere das Erzeugen modaler Dialoge und die Rückgabe von Ergebniswerten aufzeigen. |  |
Hinweis

### 31.1.2 Zuordnen eines Layoutmanagers

Wie bereits erwähnt, sind die Layoutmanager in Java für die Anordnung der Dialogelemente im Fenster verantwortlich. Jeder Layoutmanager verfolgt dabei eine eigene Strategie, Elemente zu plazieren und in der Größe so anzupassen, daß sie aus seiner Sicht optimal präsentiert werden.

Die Zuordnung eines Layoutmanagers zu einem Fenster wird in der Klasse `Container` realisiert. `Container` ist direkt aus `Component` abgeleitet, und beide zusammen bilden das Gerüst für alle anderen Fensterklassen. Die Klasse `Container` stellt eine Methode `setLayout` zur Verfügung, mit der der gewünschte Layoutmanager dem Fenster zugeordnet werden kann:

    public void setLayout(LayoutManager mgr)
| java.awt.Container

Java stellt standardmäßig die fünf Layoutmanager `FlowLayout`, `GridLayout`, `BorderLayout`, `CardLayout` und `GridBagLayout` zur Verfügung. Der einfachste Layoutmanager ist `FlowLayout`, er positioniert die Dialogelemente zeilenweise hintereinander. Paßt ein Element nicht mehr in die aktuelle Zeile, so wird es in der nächsten plaziert usw. Die genaue Funktionsweise der Layoutmanager wird später in diesem Kapitel vorgestellt.

### 31.1.3 Einfügen von Dialogelementen

Das Einfügen von Dialogelementen in das Fenster erfolgt mit der Methode `add` der Klasse `Container`:

    public Component add(Component comp)
    public Component add(Component comp, int pos)
    public void add(Component comp, Object constraints)
| java.awt.Container

Bei der ersten Variante wird lediglich die einzufügende Komponente übergeben und vom Layoutmanager an der dafür vorgesehenen Position untergebracht. Die zweite Variante erlaubt das Einfügen der aktuellen Komponente an beliebiger Stelle in der Liste der Komponenten.

Die dritte Variante erwartet zusätzlich ein Constraints-Objekt, der bei bestimmten Layoutmanagern weitere Informationen zur Positionierung der Komponente angibt. Wird beispielsweise die Klasse `BorderLayout` zur Anordnung der Dialogelemente verwendet, kann hier eine der Konstanten `SOUTH`, `NORTH`, `WEST`, `EAST` oder `CENTER` übergeben werden, um anzuzeigen, an welcher Stelle des Fensters das Element plaziert werden soll.

Sollen Komponenten, die bereits an das Fenster übergeben wurden, wieder daraus entfernt werden, so kann dazu die Methode `remove` verwendet werden. Als Parameter ist dabei das zu löschende Objekt zu übergeben:

    public void remove(Component comp)
| java.awt.Container

`Container` stellt auch Methoden zur Verfügung, um auf die bereits eingefügten Dialogelemente zuzugreifen:

    public int getComponentCount()
    public Component getComponent(int n)
    public Component[] getComponents()
| java.awt.Container

Mit `getComponentCount` kann die Anzahl aller eingefügten Komponenten ermittelt werden. `getComponent` liefert die Komponente mit dem angegebenen Index, und `getComponents` gibt ein Array mit allen eingefügten Komponenten zurück.

### 31.1.4 Anzeigen des Dialogfensters

Wurden alle Komponenten an den Container übergeben, kann der Dialog formatiert und durch einen Aufruf von `setVisible` angezeigt werden. Zweckmäßigerweise sollte vorher die Methode `pack` der Klasse `Window` aufgerufen werden, um die Größe des Fensters an den zur Darstellung der Dialogelemente erforderlichen Platz anzupassen:

    public void pack()
| java.awt.Window

Wir wollen uns ein einfaches Beispiel ansehen, das diese vier Schritte demonstriert:

    001 /* Listing3101.java */
    002
    003 import java.awt.*;
    004 import java.awt.event.*;
    005
    006 public class Listing3101
    007 extends Frame
    008 {
    009   public static void main(String[] args)
    010   {
    011     Listing3101 wnd = new Listing3101();
    012     wnd.setVisible(true);
    013   }
    014
    015   public Listing3101()
    016   {
    017     super("Dialogtest");
    018     addWindowListener(new WindowClosingAdapter(true));
    019     setLayout(new FlowLayout());
    020     add(new Button("Abbruch"));
    021     add(new Button("OK"));
    022     pack();
    023   }
    024 }
| Listing3101.java

Listing 31.1: Ein Dialog mit zwei Buttons

|  | Das Programm erzeugt ein kleines Fenster, das nur die beiden Buttons enthält. Da wir für das Fenster keine Größe angegeben haben, sondern diese durch Aufruf von `pack` automatisch berechnen lassen, ist das Fenster gerade so groß, daß beide Buttons darin Platz finden: |  |
Hinweis

Abbildung 31.1: Ein Dialog mit zwei Buttons

|  | In vielen Beispielen in diesem Buch wird der Einfachheit halber die in Abschnitt 23.2.4 vorgestellte Klasse `WindowClosingAdapter` verwendet, um einen Listener zum Schließen des Fensters zu registrieren. Damit ein solches Beispiel sich kompilieren läßt, muß die Datei WindowClosingAdapter.java im aktuellen Verzeichnis vorhanden sein. Sie befindet sich auf der CD-ROM zum Buch oder in Listing 23.2. |  |
Hinweis

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de