Graphische Benutzeroberflächen mit Java Swing - Dr. Beatrice Amrhein
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
Graphische
Benutzeroberflächen mit
Java Swing
Teil 1
Dr. Beatrice Amrhein
Inhaltsverzeichnis
1 Grundlagen................................................................................................................................................ 4
1.1 Kurs Überblick..................................................................................................................................... 4
1.2 Graphik in Java.................................................................................................................................... 5
1.3 Zeichnen in Java.................................................................................................................................. 7
1.4 Das Abstract Windowing Toolkit, Java AWT.......................................................................................8
1.5 Die AWT Komponenten in Java ........................................................................................................... 8
1.6 Container-Komponenten..................................................................................................................... 10
1.7 Primitive AWT Komponenten.............................................................................................................. 10
1.8 Ein AWT Beispiel................................................................................................................................ 11
1.9 Einfügen von Komponenten................................................................................................................ 11
1.10 Java Applets.................................................................................................................................... 12
2 Swing....................................................................................................................................................... 13
2.1 Ein Auszug aus der Klassenstruktur von Swing .................................................................................13
2.2 Die neuen Möglichkeiten mit Swing .................................................................................................. 14
2.3 Setzen des Look and Feel................................................................................................................. 15
2.4 Einfache Swing Komponenten: JLabel, JButton, JCheckBox, ..........................................................16
2.5 Erzeugen von Menus........................................................................................................................ 18
2.6 Swing Text Komponenten................................................................................................................. 20
2.7 Swing Container ................................................................................................................................ 21
2.8 Window Komponenten....................................................................................................................... 23
2.9 Anordnen von Interface Komponenten, Java Layout Manager..........................................................23
2.10 Wie wählt man den Layout Manager................................................................................................ 33
3 Das Java Event Handling......................................................................................................................... 34
3.1 Key Events......................................................................................................................................... 37
3.2 Action Events..................................................................................................................................... 38
3.3 Anonyme Klassen.............................................................................................................................. 39
3.4 Adapter Klassen................................................................................................................................ 39
3.5 Mouse Events.................................................................................................................................... 40
3.6 Events auf Menu Items...................................................................................................................... 41
3.7 Event Listener mit Parameter............................................................................................................ 41
3.8 Window Events.................................................................................................................................. 42
3.9 Die Klasse AbstractAction.................................................................................................................. 43
4 Design Pattern für Graphische Benutzeroberflächen...............................................................................45
4.1 Das Observer Design Pattern............................................................................................................ 45
4.2 Das Model View Controller Design Pattern........................................................................................ 49
4.3 Das Model View Presenter Pattern (MVP)......................................................................................... 54
4.4 Das Command Processor Design Pattern......................................................................................... 55
4.5 Drawing Application Beispiel.............................................................................................................. 57
4.6 Der Swing Undo Manager.................................................................................................................. 59
2
1 Grundlagen
1.1 Kurs Überblick
AWT, das Abstract Windowing Toolkit: Das AWT Paket enthält Klassen um User Interfaces zu erstellen,
Graphiken zu zeichnen und Bilder darzustellen. Zum Erstellen von User Interfaces stellt das AWT
grundlegende Komponenten wie Buttons, Labels, Schiebebalken, Windows, ... zur Verfügung.
Ausserdem können diese Komponenten mittels Event-Handling User-Eingaben verarbeiten und
weiterleiten.
Swing, lightweight AWT, aber mit viel mehr Möglichkeiten: Das Swing Paket stellt eine Menge von
lightweight Komponenten zur Verfügung, welche (so weit wie möglich) auf allen Plattformen gleich
funktionieren und aussehen. Das Swing Paket bietet im Vergleich zum AWT zusätzlich:
eine viel grössere Auswahl an GUI Komponenten
Shortcuts, Accelerators
wählbares Look and Feel
verschiedene mächtige Textkomponenten
Unterstützung von cut, copy, paste, undo, ...
Tabellen und Bäume
usw.
Event Handling: Mit Hilfe von Graphischen Benutzeroberflächen soll der User mit einer Applikation
interagieren können. Interaktion (mit einem GUI) geschieht über Events. Ein Event ist also eine Aktion,
welche durch einen Benutzer initialisiert wurde, sei es durch Drücken eines Buttons, Verschieben der
Maus, Drücken einer Taste ... Wir lernen in diesem Kurs das Java Event Modell kennen und benutzen.
Design Pattern: Im GUI Bereich sind einige Design Pattern besonders wichtig; dazu gehören das
Observer Design Pattern (Publisher-Subscriber), das MVC (Model-View-Controller) und das Command
Processor Design Pattern.
Spezielle Swing Komponenten wie ComboBoxen (Auswahl-Menü), Listen, Tabellen, Bäume: Swing
Komponenten sind nach dem MVC Design Pattern aufgebaut. Einige Swing Komponenten sind
ausserdem adaptierbar, das heisst, Modell, View oder Controller Teile der Komponenten sind
austauschbar.
GUI Komponenten sind vorzugsweise Java Beans, das heisst, sie erfüllen das Java Komponenten
Modell. Dies führt dazu, dass alle GUI Komponenten austauschbar und sehr flexibel einsetzbar sind.
Die Hauptaufgabe der Software Ergonomie ist es, herauszufinden, wie Benutzeroberflächen gestaltet
sein müssen, damit die Applikationen
- anwenderfreundlich,
- leicht bedienbar,
- ansprechend und motivierend
sind.
31.2 Graphik in Java
Graphics
...definiert eine device-unabhängige Schnittstelle
für Graphikobjekte (Graphik-Kontext).
... bietet Methoden für das Zeichnen von Linien,
Rechtecken, Kreisen, Zeichnen von Bildern, Füllen
von Flächen, usw.
drawArc, drawLine, fillOval drawPolygon,
drawRect, draw3DRect, drawString,
setColor, setFont, ...
Verschiedene Plattformen realisieren
Graphikobjekte auf unterschiedliche Art und
Weise
7
Die Java Klasse Graphics dient als Kontext für alle sichtbaren Objekte in Java.
Graphics Objekte können nicht direkt (durch den Konstruktor erzeugt) werden, da der Konstruktor von
Graphics protected ist.
Wenn eine sichtbare Komponente (Frame, Window, Applet, Button, Label, ...) erzeugt wird, wird jeweils
automatisch ein zugehöriges Graphics Objekt erzeugt,
Von jeder sichtbaren Komponente kann das Graphics Objekt (falls nötig) mit der Methode getGraphics()
Graphik-Kontext
angefragt werden.
Jedes Graphik-Objekt kennt seinen Graphik-Kontext.
Dieser besteht aus den Informationen:
In welches Fenster (in welche Komponente) das
Objekt gezeichnet wird
Die aktuelle Zeichenfarbe
Der aktuelle Textfont
Der sichtbare Bereich (clipRect)
Die aktuelle Pixeloperations-Funktion (XOR oder
Paint)
...
Die Methode getGraphics() gibt den aktuellen
Graphik-Kontext zurück.
8
Das Abfragen der gesetzten Attribute geschieht zum Beispiel mittels der folgenden Befehle:
• getGraphics().getColor()
• getGraphics().getFont()
• getGraphics().getClipBounds()
Allerdings ist es normalerweise nicht nötig, Objekt diese Eigenschaften über das Graphics zu erfragen, da
alle sichtbaren Komponenten eigene entsprechende Methoden besitzen, welche bei ihrem Graphics Kontext
diese Eigenschaften abfragen.
4Farben
Es gibt die vordefinierten Farben
Color.white, Color.black, Color.blue,
Color.cyan, Color.darkGray, Color.gray,
Color.green, Color.lightGray,
Color.magenta, Color.orange,
Color.pink, Color.red, Color.yellow
Daneben können beliebige Farben definiert werden:
RGB: setzen des Rot-, Grün-, Blau-Anteils
g.setColor( new Color( 255, 0, 0 ) );
(g ist das aktuelle Graphics-Objekt)
9
Farben können entweder über das Graphics Objekt gesetzt werden, oder direkt in der sichtbaren
Komponente. Dafür gibt es die zwei Befehle
• setBackground(Color c)
• setForeground(Color c)
Setzen von Fonts
Ein Font besteht aus einem Namen,
dem Style und der Grösse.
Font ( "Dialog", Font.PLAIN,
Font.PLAIN, 12 );
Font ( "DialogInput
"DialogInput",
", Font.ITALIC,
Font.ITALIC, 20 );
Font ( "Monospaced
"Monospaced", ", Font.PLAIN,
Font.PLAIN, 18 );
Font ( "Serif
"Serif",
", Font.BOLD,
Font.BOLD, 24 );
Das Setzen des Fonts geschieht durch:
setFont( new Font("Dialog", Font.BOLD, 18 ));
10
AWT Komponenten kennen nur diese sechs verschiedenen Fonts.
Für Swing-Komponenten stehen sämtliche Systemfonts zur Verfügung. Allerdings ist das Setzen von
„exotischen“ Fonts ergonomisch nicht sinnvoll. Empfohlen wird für Benutzeroberflächen ein schnörkelloser
Font wie SansSerif.
5Zeichnen in Java
1.3 Zeichnen in Java
Zum Zeichnen gibt es in Java die (Graphics-)
Methoden
drawLine, drawRect, fillRect, draw3DRect,
drawOval, fillOval, drawArc, fillArc,
drawPolygon, fillPolygon, drawString, ...
drawOval(x,y,wd,ht)
(x,y) wd
(x, y)
ht
height
width
12
Das Zeichnen von Kreisen und Ellipsen ist in Java etwas gewöhnungsbedürftig, da nicht Mittelpunkt und
Zeichnen in Java
Radien angegeben werden müssen, sondern die linke obere Ecke des umschliessenden Rechtecks, sowie
dessen Breite und Höhe.
public void paint(Graphics g)
{
// Kreise zeichnen
g.setColor( new Color( 0,80,160 ) );
g.drawOval( 35,35,110,110 );
g.fillOval( 40,40,100,100 );
// Quadrate zeichnen
g.setColor( Color.white );
g.drawRect( 60,60,60,60 );
g.fillRect( 65,65,50,50 );
// Segment zeichnen
g.setColor( Color.blue );
g.fillArc( -25,80,100,100,10,70 );
// Linien zeichnen
g.setColor( Color.red );
g.drawLine( 25,130,70,30 );
g.drawLine( 25,130,130,25 );
g.drawLine( 25,130,140,70 );
}
13
drawLine(x1, y1, x2, y2)
... zeichnet eine Linie zwischen den Punkten (x1,y1) und (x2,y2) in der aktuellen Farbe und im
Koordinatensystem des aktuellen Graphik-Kontextes.
drawRect(x, y, wd, ht)
fillRect(x, y, wd, ht)
... zeichnet ein (gefülltes) Rechteck an Position (x,y) mit Breite wd und Höhe ht.
drawArc benötigt insgesamt sechs Argumente: die analogen Argumente wie drawOval, plus die zwei
zusätzlichen Argumente Startwinkel und Öffnungswinkel.
6Das Koordinatensystem
(0,0)
x-Achse
(4,3)
y-Achse
Das Koordinatensystem dient zum absoluten Positionieren von14Objekten innerhalb eines Fensters.
Dieses wird zum Beispiel in den Befehlen
setSize() (Grösse der Komponente)
setLocation() (Position der Komponente)
setBounds() (Grösse und Position)
benutzt
Die Einheiten sind jeweils in Pixel.
1.4 Das Abstract Windowing Toolkit, Java AWT
Die wichtigsten Pakete in java.awt sind:
• Components: GUI Komponenten wie Buttons, Menus, Labels, Dialog-Boxen, Container, ...
• Layout Manager: Setzen des Layouts der verschiedenen Komponenten, also arrangieren der
verschiedenen Komponenten innerhalb ihres Containers
• Graphics: Methoden für das Setzen von Farben, Fonts, Bilder, Zeichnen von Polygonen, Linien, ...
Das AWT bietet nur relativ primitive Funktionalität und nicht die vollen Möglichkeiten der unterliegenden
Plattform.
Das java.awt Pakage enthält drei Kategorien von Klassen
• User Interface Komponenten
• Grafik, Hilfsklassen
• Layout Managers
Es ist ein plattform-unabhängiges GUI-Toolkit, wird also gleich benutzt unter allen Plattformen (Unix/Linux,
Windows, iOS, ... gleich verwendet.
AWT ist aber plattform-spezifisch implementiert, das bedeutet, es hat ein plattform-abhängiges Look & Feel,
bietet aber nicht alle Möglichkeiten der Plattform (kleinster gemeinsamer Nenner).
71.5 Die AWT Komponenten in Java
Component ist die abstrakte Basisklasse für die in Java angebotenen User Interface Komponenten (ausser
den Menü-Komponenten).
Ein Canvas ist ein Behälter für Zeichnungen oder Bilder. Choice und Listen dienen zum Auswählen von
Optionen. TextArea ist ein Text-Bereich, TextField ist eine Text-Zeile.
Frame und Dialog erzeugen ein eigenes, neues Fenster (toplevel application window).
In Swing gibt es diese Komponenten nochmals als Lightweight-Komponenten. Diese heissen dann JButton,
JLabel, JTextField, JTextArea, JList, JScrollbar ... Ausserdem gibt es in Swing neue Komponenten wie:
JTextPane, JTree JProgressBar, JToolBar, JTable …
paint ist die wichtigste Methode beim Erzeugen von Graphiken.
Die paint-Methode zeichnet die Komponente (Applet, Frame, Panel, ...), mit welcher sie aufgerufen wird.
g ist der Graphik-Kontext.
update zeichnet die AWT-Komponente neu. Dazu wird sie zuerst mit der Hintergrundfarbe gefüllt, dann wird
die (aktuelle) Vordergrundfarbe gesetzt und die paint-Methode der Komponente aufgerufen.
repaint bewirkt, dass (so bald als möglich) die update-Methode dieser Komponente aufgerufen wird.
setVisible(true)/setVisible(false) macht eine Komponente (un-)sichtbar.
Dies muss bei jedem Window (Frame, JFrame, ...) am Ende des Konstruktors aufgerufen werden, um das
Fenster an den Bildschirm zu schicken.
setEnabled(true)/setEnabled(false) erlaubt/verbietet das Aktivieren von Events.
setLocation(), setSize() setzt die Position/ die Grösse der Komponente.
Für alle diese Eigenschaften (size, location, bounds, height, width, ...) gibt es sowohl set- als auch get-
Methoden. So geben getWidth() und getHeight() jeweils die (aktuelle) Breite und Höhe einer Komponente
zurück.
8java.awt
Container Komponenten
1.6 Container-Komponenten
... können andere Komponenten enthalten.
Komponenten
... werden eingefügt durch
add( component ) am Schluss
add( component, pos ) an der Position pos
... werden gelöscht durch
remove( component ) einzeln
removeAll( ) alle
... werden angeordnet durch setzen eines Layout-
Managers
setLayout( layoutmgr )
20
Container Komponenten dienen als Behälter oder Hülle für andere Komponenten. In AWT gibt es die
Container:
• Frame
... das Hauptfenster einer Applikation mit
MenuBar setMenuBar( mb )
Titel setTitle( )
Icon setIconImage( )
• Panel
... ein Container, der in einen anderen Container platziert wird
• Dialog, FileDialog
... Nebenfenster einer Applikation, für temporäre Informationen
• Window
... ein Fenster ohne Window Dekorationen
1.7 Primitive AWT Komponenten
Button, Canvas, Checkbox, Choice, Label, List, Scrollbar, TextArea und TextField sind primitive AWT
Komponenten. Sie können keine andere Komponenten enthalten.
Sie werden erzeugt durch:
Button b = new Button("ok");
Label l = new Label("Hinweise");
Danach können die Komponenten durch
Panel p = new Panel();
p.add(b); p.add(l);
in die Container-Komponente p eingefügt werden.
91.8 Ein AWT Beispiel
import java.awt.*;
public class AWTBsp extends Frame {
public AWTBsp() {
setFont(new Font( "Serif", Font.BOLD, 16 ));
// create a panel and add it to the frame
Panel p = new Panel(); add(p);
// create a label and add it to the panel
Label l = new Label ("Name" ); p.add(l);
// create a textfield and add it to the panel
TextField t = new TextField(24); p.add(t);
// create a button and add it to the frame
Button b = new Button("Quit");
add(b, BorderLayout.SOUTH);
// set size and make frame visible
setBounds(100,100,300,90); setVisible(true);
}
public static void main( String argv[] ) {
AWTBsp awt = new AWTBsp();
}
}
setFont setzt den zu benutzenden Font für die Applikation (Frame).
Im Konstruktor des Labels kann gleichzeitig der Label-Text (hier “Name”) angegeben werden.
Der Label wird mit p.add(l) in das Panel eingefügt.
Im Konstruktor des Buttons kann auch der Button-Label (hier “Quit“) angegeben werden.
Der Button soll am unteren Rand des Frames (BorderLayout.SOUTH) eingefügt werden.
Zuletzt werden die Grösse und Position des Fensters (setBounds) sowie die Sichtbarkeit (setVisible)
gesetzt.
1.9 Einfügen von Komponenten
public class EasyExam extends Frame {
private Label l; private Button b;
EasyExam() {
Panel p = new Panel(); add(p); // Erzeugen und Einfügen des Panels.
setFont( new Font("Dialog",Font.PLAIN, 16));
l = new Label("Das ist ein Label");
b = new Button("Das ist ein Button");
p.add(b); p.add(l);
}
public static void main( String argv[] ) {
EasyExam e = new EasyExam();
e.setSize(300,90); e.setVisible(true);
}
}
Die Reihenfolge (Anordnung, Tab-Sequence) der Komponenten hängt nicht davon ab, welche Komponente
zuerst erzeugt wurde, sondern einzig davon, welche Komponente als erstes mit add() eingefügt wurde.
101.10 Java Applets
Applets wurden in Java eingeführt, um Programme in Webseiten laufen lassen zu können. und können mit
dem Benutzer interagieren, ohne Daten zum Server senden zu müssen. Java-Applets waren Ende der
1990er Jahre mit ein Grund für den Erfolg und die schnelle Verbreitung von Java.Üblicherweise werden
Java-Applets von HTML-Seiten aufgerufen. Um sie ausführen zu können, muss der Browser über eine
entsprechende Java-VM verfügen.
Das Einbinden eines Applets in den HTML-Code kann zum Beispiel so aussehen:
Alle Java-Applets werden von der Java-Klasse java.applet.Applet abgeleitet. Sie verfügen über die
Methoden:
• init() – wird genau einmal aufgerufen, wenn das Applet erstmals in den Browser geladen wird.
• start() – wird jedes Mal aufgerufen, wenn das Applet sichtbar wird.
• paint() – die Zeichenmethode des Applet
• stop() – wird aufgerufen, wenn das Applet verdeckt wird, z. B. weil das Browser-Fenster
geschlossen oder von einem anderen Fenster überdeckt wird.
• destroy() – wird aufgerufen, wenn das Applet aus dem Hauptspeicher entladen wird.
Applets benötigen keine main()Methode.
Die in die HTML-Oberfläche eingebetteten Fenster können nicht programmgesteuert, sondern nur vom
Benutzer geschlossen werden, man kann aber programmatisch zusätzliche Fenster öffnen.
Ein Beispiel Applet:
public class Animation extends JApplet implements Runnable {
private int delay, num;
private Image im[] = new Image[10];
private Thread animator;
public void init() {
delay = 250;num = 0;
for (int i = 1; i2 Swing
Im Swing-Paket sind alle Oberflächenkomponenten von JComponent abgeleitet, wodurch diese gleichzeitig
Komponenten und Container sind.
Im Gegensatz zu den AWT-Komponenten sind alle Swing-Komponenten (ausser JApplet, JFrame, JDialog
und JWindow) so genannte Lightweight- Komponenten. Die AWT- Komponenten basieren auf den nativen
dem Betriebssystem zugrunde liegenden GUI-Komponenten und werden nicht wie bei Swing von Java
gezeichnet.
AWT Komponenten haben dabei folgende Eigenschaften:
Sie liegen auf der z-Achse über den Lightweight-Komponenten.
Sie haben keine transparenten Bereiche, sind also immer deckend (opaque).
Sie sind immer rechteckig.
Das Vermischen von Lightweight- und AWT Komponenten kann zu Problemen führen.
Die Anzahl Komponenten wurde in Swing massiv erweitert und hat nicht auf einer A4 Seite Platz.
Alle AWT Komponenten sind in Swing neu implementiert worden und beginnen zur Unterscheidung jeweils
mit einem J.
AWT Swing
Label JLabel
Button JButton
2.1 Ein Auszug aus der Klassenstruktur von Swing
122.2 Die neuen Möglichkeiten mit Swing
Mit Swing sind eine ganze Palette von neuen Möglichkeiten in die Java Gui Programmierung eingeflossen.
• Keyboard Accelerators
Alt+F Öffnet das File-Menüs
Ctrl+C -> Kopiert den selektierten Text, ...
• Tool Tips
Hilfetexte, welche erscheinen, wenn die Maus über der entsprechenden Komponente steht.
• Neue LayoutManager, neue Panels
• virtuelle Desktops (MDI, d.h. Multiple Document Interface Applikationen)
• Drag and Drop
automatisch in viele Swing-Komponenten eingebauter Data-Transfer Mechanismus.
• Undo
Die Klasse UndoManager unterstützt das Rückgängig-Machen von User Eingaben
Die Klasse JComponent ist die Basisklasse aller Swing Komponenten, ist von (AWT) Container abgeleitet
und erlaubt:
• Das Einfügen von Komponenten auch in primitive Swing Komponenten (wie JButton, JLabel, ...)
• Das Setzen des Look & Feel (Motif, Window, MacIntosh, Metal, ...) auch zur Laufzeit
• Automatisches Double Buffering
Swing-Komponenten
- sind Lightweight Komponenten
- basieren auf AWT, d.h. sie sind in AWT implement.
Swing Komponenten könnten zwar beliebig mit AWT Komponenten vermischt werden. Allerdings ist dabei
Vorsicht geboten, da sich Swing und AWT Komponenten nicht gleich verhalten.
Da alle sichtbaren Swing Komponenten von JComponent abgeleitet sind, gibt es keine echten primitiven
Komponenten mehr: in jede Komponente kann jede andere eingefügt werden (mit unterschiedlich
sonderbaren Effekten).
Lightweight Komponenten verwalten sich nicht selber, sondern zeichnen sich bloss in den Hintergrund der
Eltern Komponente.
Vergleich AWT Swing
Swing-Komponenten werden genau gleich erzeugt und eingefügt wie AWT Komponenten.
Bloss verhalten sich AWT Komponenten anders und sollten darum nicht mehr benutzt werden.
public class Swing extends JFrame {
Swing() {
setBackground( Color.white );
setLayout( new FlowLayout() );
JLabel hallo = new JLabel("Hello");
JButton quit = new JButton("Quit");
add(hallo); add(quit);
}
public static void main( String argv[] ) {
Swing s = new Swing();
s.setSize(150,70);
s.setVisible(true);
}
}
132.3 Setzen des Look and Feel
Das Look and Feel einer Swing Applikation kann (auch zur Laufzeit) ausgetauscht werden.
UIManager.LookAndFeelInfo laf[] = UIManager.getInstalledLookAndFeels();
gibt die Liste aller verfügbarer Look and Feel zurück.
Setzen des Look and Feel
Weitere Look and Feel können vom Internet herunter geladen werden.
try{ // set Look And Feel
UIManager.setLookAndFeel(
"javax.swing.plaf.metal.MetalLookAndFeel" );
// update Component Tree with new Look and Feel
SwingUtilities.updateComponentTreeUI( this );
}
catch( Exception e ) { }
¨
8
Beispiel LAFFrame.java unter ~amrhein/Swing/Beispiele/Swing/
142.4 Einfache Swing Komponenten: JLabel, JButton, JCheckBox, ...
JLabel
... dienen als Beschriftung und zum Anzeigen von Texten auf der Oberfläche.
... sind sehr vielseitig und können sowohl Texte (sogar HTML) als auch Bilder enthalten.
Die Ausrichtung (Alignment) der Texte und Bilder wird durch SwingConstants definiert.
// by default, the text is aligned left
l1 = new JLabel("JLabel", SwingConstants.CENTER);
l1.setFont( new Font( "Dialog", Font.BOLD, 18 ) );
add( l1 );
Icon image = new ImageIcon( "icon1.gif" );
// create new JLabel with text and image
l2 = new JLabel("Link", image, SwingConstants.RIGHT );
// set position of label text, relative to image.
l2.setVerticalTextPosition( SwingConstants.TOP );
l2.setHorizontalTextPosition(SwingConstants.LEFT);
add( l2 );
setHorizontalTextPosition( int textPosition ) setzt die horizontale Text-Position, relativ zum Bild des JLabels.
Der Defaultwert ist SwingConstants.RIGHT.
setVerticalTextPosition( int textPosition ) setzt die vertikale Text-Position. Der Defaultwert ist CENTER.
JButton
Mit Hilfe eines Buttons kann der Benutzer ein Event auslösen.
Jeder Button hat eine Beschriftung oder ein Bild zur Erklärung, was für ein Event durch den Button
ausgelöst wird.
In Swing sind alle Komponenten, welche auf Maus Klick ein Event auslösen, von AbstractButton abgeleitet
und haben darum die gleiche Grundfunktionalität.
Wie man zu einem Button ein Event verknüpft, wird im Kapitel „Event Handling“ erklärt.
Verschiedene Button-Methoden sind:
• Setzen eines Icon: setIcon(), setPressedIcon(), setRolloverIcon()
Ein Button kann (abhängig vom Zustand: normal, gedrückt, Mouse_over) verschiedene Bilder
anzeigen.
• Setzen des ButtonLabels: setText("label“)
• Setzen eines Hilfetextes (ToolTip): setToolTipText()
Buttons sollten jeweils einen Hilfetext (ToolTip) ausgeben, welcher dem Benutzer mitteilt, was
beim Drücken dieses Buttons passieren wird.
• Setzen von Shortcuts: setMnemonic()
Es ist ergonomisch sinnvoll, für alle häufig benutzten Buttons Shortcuts zu definieren.
• Auslösen eines Button Event: doClick() simuliert ein Button Klick eines Users.
Hinweis zur Ergonomie: Alle Button-Beschriftungen sind verschieden und ändern sich nicht!
15JCheckBox und JRadioButton
Mit Checkboxen und RadioButtons werden verschiedene Optionen ausgewählt. Es können beliebig viele
Checkboxen ausgewählt werden, RadioButtons erlauben nur die Auswahl von einem Element.
JCheckBox(String s)
erzeugt eine Checkbox mit Label s.
JRadioButton(String s)
erzeugt ein RadioButton mit Label s.
Ergonomie: Check Boxen und Radio Button sollten dann verwendet werden, wenn nicht mehr als 5 oder 6
Elemente zur Auswahl stehen. Andernfalls sollte eine JList oder ein JComboBox verwendet werden.
Beispiel: CheckboxFrame
class MyPanel extends JPanel
{
private JCheckBox cB1, cB2, cB3;
private JRadioButton rB1, rB2, rB3;
private ButtonGroup bg;
private ImageIcon icon1, icon2;
public MyPanel()
{
// erzeugen von CheckBoxen mit Anfangswert (true oder false)
cB1 = new JCheckBox("Opt1", true);
cB2 = new JCheckBox("Opt2", false);
cB3 = new JCheckBox("Opt3", true);
add(cB1);add(cB2);add(cB3);
// erzeugen von RadioButtons mit Anfangswert (true oder false)
rB1 = new JRadioButton("Excl1",true);
rB2 = new JRadioButton("Excl2",false);
rB3 = new JRadioButton("Excl3",false);
add(rB1);add(rB2);add(rB3);
// Die ButtonGroup sorgt dafür, dass immer bloss ein RadioButton „true“ ist.
bg = new ButtonGroup();
bg.add(rB1);
bg.add(rB2);
bg.add(rB3);
}
}
16JToolbar
Eine Toolbar bietet einen schnellen Zugriff auf die am häufigsten verwendeten Befehle (Actions).
Sie enthält normalerweise vor allem Buttons, kann aber beliebige Komponenten enthalten.
Die Komponenten darauf dürfen nie den Focus behalten
(setFocusable(false).
Die Toolbar kann zur Laufzeit vom Benutzer verschoben
werden.
public ToolBarDemo() {
//Create the toolbar.
JToolBar toolBar = new JToolBar();
b1 = new JButton(new ImageIcon("left.gif"));
b1.setFocusable(false); toolBar.add(b1);
b2 = new JButton(new ImageIcon("right.gif"));
b2.setFocusable(false); toolBar.add(b2);
toolBar.addSeparator();
b3 = new JButton(new ImageIcon("Cut.gif"));
b3.setFocusable(false); toolBar.add(b3);
toolBar.add(new JLabel(new ImageIcon("Copy.gif")));
b4 = new JButton(new ImageIcon("Paste.gif"));
b4.setFocusable(false); toolBar.add(b4);
toolBar.addSeparator();
toolBar.add(new JTextField(15));
// add toolbar to the frame
add(toolBar, BorderLayout.NORTH);
}
2.5 Erzeugen von Menus
JMenuBar() erzeugt einen Menubalken. Dieser wird mit setJMenuBar() in das Frame eingefügt.
JMenu() erzeugt einen Menueintrag, add() fügt diesen in den Menubalken ein.
JMenuItem() erzeugt einen Menubutton. add() fügt diesen in das JMenu ein.
Die Menueinträge können optisch getrennt werden durch addSeparator()
// create menubar
JMenuBar bar = new JMenuBar();
setJMenuBar(bar);
// create the file menu
JMenu fileMenu = new JMenu("File");
JMenu fileMenu.setMnemonic('F');
JMenuItem quit = new JMenuItem("Quit");
fileMenu.add(quit);
// create insert menu
JMenu insertMenu = new JMenu("Insert");
JMenuItem insText = new JMenuItem("TextField"); insertMenu.add(insText);
JMenu insGraph = new JMenu("Graphic"); insertMenu.add(insGraph);
JMenuItem g1 = new JMenuItem("New"); insGraph.add(g1);
JMenuItem g2 = new JMenuItem("From File"); insGraph.add(g2);
JMenuItem g3 = new JMenuItem("AutoForm"); insGraph.add(g3);
JMenuItem insTab = new JMenuItem("Table");
insertMenu.add(insTab);
// add menus to menu bar
bar.add(fileMenu);
bar.add(insertMenu);
17Anbinden von Shortcuts
Das Aktivieren des File Menus durch 'Alt F' wird ermöglicht
durch:
JMenu fileMenu = new JMenu("File");
fileMenu.setMnemonic('F');
'Alt F' ist also ein Mnemonic.
Aktivieren von "Quit" durch 'Ctrl-Q' geschieht durch:
JMenuItem exitItem = new JmenuItem("Quit");
exitItem.setAccelerator(
KeyStroke.getKeyStroke(KeyEvent.VK_Q,Event.CTRL_MASK));
Mnemonics werden unter Windows normalerweise durch die ALT-Taste (zusammen mit einer Doppeltasten-
Kombination) ausgelöst (z. Bsp. ALT-F+A für SaveAs)
Accelerators werden mit CTRL (STRG) ausgelöst, zum Beispiel CTRL-C für copy.
Die gesetzten Shortcuts werden automatisch im JMenuItem (durch Unterstreichen des entsprechenden
Buchstabens oder durch Angabe des CTRL-Strings) angegeben.
JCheckBoxMenuItem und JRadioMenuItem
Checkboxen und RadioButtons gibt es auch als Menu-Items.
Da sie von JMenuItem abgeleitet sind, verhalten sie sich wie normale Menu-Items.
JCheckBoxMenuItem(String text, Icon icon, boolean b)
JRadioButtonMenuItem(String text, Icon icon, boolean selected)
Vorsicht
• Nur JCheckBoxMenuItem oder JRadioButtonMenuItem und
keine JCheckBox oder JRadioButton Kompontenten in das
Menu einfügen, andernfalls funktioniert das Popup-Menu
nicht richtig.
• Genau wie die JRadioButton benötigen auch die
JRadioButtonMenuItem Komponenten eine Button-Group,
damit nur immer genau eine Komponente der Gruppe
gleichzeitig selektiert ist.
182.6 Swing Text Komponenten
In Swing gibt es die folgenden Text-Komponenten:
JTextArea ist ein einfacher Text Bereich ohne Formatierung. JTextField ist ein einzeiliger Text Bereich.
Ein JPasswordField verbirgt den Text hinter einem Zeichen (typischerweise “*“).
JFormattedTextField ermöglicht durch Angeben einer entsprechenden Maske formatierten Text einzugeben
(Telefon-Nummern, Währungen, ...).
Ein JEditorPane kann Plain-Text, HTML-Text oder RTF-Text darstellen.
Ein JTextPane kann verschiedene Formatierungen (Farben, Fonts, Styles, ...) und auch Bilder darstellen.
In einem Text Bereich können verschiedenste Typen von Events abgefangen werden: KeyEvent,
CaretEvent, FocusEvent... Jede Text Änderung in einem Text Bereich erzeugt ausserdem ein
DocumentEvent.
Bei einem JTextField kann auch ein ActionEvent abgefangen werden. Dies wird durch das Drücken der
Enter-Taste ausgelöst.
Die Editierbarkeit von Text Bereichen kann durch setEditable(true/false); gesetzt werden
text1 = new JTextField("TextField Demo");
text1.setEditable( false );
add(text1, BorderLayout.NORTH);
// text area in scroll pane
text2 = new JTextArea();
add(new JScrollPane(text2));
// editable text field
text3 = new JTextField();
add(text3, BorderLayout.SOUTH);
Das Setzen von verschiedenen Formatierungen (Farben, Styles, ...) in Text Komponenten behandeln wir im
Kapitel „Spezielle Swing Komponenten“
Der Text Bereich muss in ein JScrollPane eingefügt werden, damit er einen Schiebe-Balken (Scrollbar)
bekommt.
192.7 Swing Container
Alle Swing Komponenten sind Container:
JButton hbutton = new JButton("Hintergrund Button");
// set layout manager
hbutton.setLayout(new BorderLayout());
// insert swing label
JLabel oben = new JLabel("Oben");
hbutton.add(oben, BorderLayout.NORTH);
// insert awt label
Label unten = new Label("Unten");
hbutton.add(unten, BorderLayout.SOUTH);
Alle Swing-Komponenten sind (abgeleitet von der Klasse) AWT-Container.
Das bedeutet, dass in Swing nicht nur Container-Komponenten sondern jede Swing Komponente andere
Komponenten (sogar AWT-Komponenten) enthalten kann (mit dem entsprechenden seltsamen Verhalten).
JPanel
JPanel sind die einfachsten Swing Container. Sie dienen vor allem
dazu, andere Container (in logisch zusammengehörige Teile) zu
unterteilen.
JPanel sind unsichtbar. Wir können sie nur sehen, wenn wir einen
anderen Hintergrund oder (wie hier) einen Rahmen (Border)
setzen.
class MyBorderFrame extends JFrame
{
public MyBorderFrame()
{
//Create the panels
Jpanel p1 = new JPanel();
p1.setBorder( new TitledBorder(new LineBorder(Color.blue), "Main Workspace"));
add(p1, BorderLayout.CENTER );
Jpanel p2 = new JPanel();
p2.setBorder(new TitledBorder(new LineBorder(Color.red), "Utilities"));
add(p2, BorderLayout.NORTH);
Jpanel p3 = new JPanel();
p3.setBorder(
new TitledBorder(new LineBorder(Color.black), "Auxilary Informations"));
add(p3, BorderLayout.SOUTH);
}
}
20JSplitPane und JTabbedPane
SplitPane und TabbedPane sind weitere nützliche Swing Panels.
Ein SplitPane enthält verschiebbare Teiler-Balken zum
Vergrössern/Verkleinern der verschiedenen Bereiche. SplitPanes
werden erzeugt durch:
JSplitPane( int unterteilung,
Component leftComponent,
Component rightComponent)
Es gibt die Unterteilungen:
VERTICAL_SPLIT oben/unten
HORIZONTAL_SPLIT rechts/links
Ein JTabbedPane ist eine Komponente, mit welcher der Benutzer zwischen verschiedenen Komponenten
umschalten kann. Dies geschieht durch Drücken des entsprechenden Kartenreiters.
JTabbedPane tabbedPane = new JTabbedPane();
tabbedPane.addTab(" 1 ", new JPanel());
tabbedPane.addTab(" 2 ", new Jbutton("This is Pane 2"));
. . .
tabbedPane.setTabPlacement(SwingConstants.TOP);
Beispiele: MySplitPane.java
MyTabbedPane.java unter ~amrhein/Swing/Beispiele/SwingContainer
2.8 Window Komponenten
Die Komponenten Dialog, Frame, JWindow, JDialog
und JFrame sind von Window und nicht von
JComponent abgeleitet. Diese Komponenten sind
nicht lightweight.
Lightweight Komponenten sind in Java implementiert
und sind darum unabhängig vom unterliegenden
Betriebssystem. Dies funktioniert nicht für die
Komponenten, welche ein neues Fenster erzeugen,
da diese mit dem Window-Manager (Betriebssystem) interagieren müssen. Alle Fenster-Komponenten (von
Window abgeleitet) sind darum nicht Lightweight.
212.9 Anordnen von Interface Komponenten, Java Layout Manager
Es gibt grafische Benutzeroberflächen, bei denen die Anordnung der Komponenten über die Angabe
absoluter Koordinaten erfolgt. Diese Vorgehensweise ist aber aus mehreren Gründen nicht zu empfehlen:
Absolute Angaben sind sehr unflexibel. Beim Einfügen weiterer Komponenten müssen die
Positionen anderer Komponenten angepasst werden, was mit erheblichem Aufwand verbunden sein
kann. Die Layout-Manager nehmen dem Benutzer die Arbeit der absoluten Positionierung ab. Der
Benutzer macht lediglich qualitative Angaben wie „diese Komponente soll links von einer anderen
stehen“ oder „alle Komponenten sollen untereinander stehen“.
Durch Verwenden eines Layout Manager braucht sich der Benutzer auch nicht um die Grösse der
Komponente zu kümmern. Jede Java-Komponente besitzt die Methode getMinimumSize() und
getPreferredSize() zum Bestimmen der Mindestgrösse bzw. der bevorzugten Grösse der
Komponente. Bei Buttons und Labels richten sich diese beispielsweise nach der Breite des Textes,
mit dem sie beschriftet sind. Wenn der Layout-Manager einen Container bearbeitet, berücksichtigt
er die Rückgabewerte dieser Methoden bei allen enthaltenen Komponenten. Mit diesem
Zusammenspiel wird dem Benutzer die Festlegung der Grösse von Komponenten erspart.
Durch die Vermeidung absoluter Grössenangaben ist es möglich, dass eine Komponente ihre
Grösse beim Verändern der Container-Grösse anpassen kann. So kann zum Beispiel ein Text-
Bereich stets das gesamte Fenster ausfüllen, in das es eingebettet ist.
Der grösste Nachteil von absoluten Koordinaten ist, dass das Erscheinungsbild eines Fensters auf
verschiedenen Plattformen stark variieren kann. Ein häufiger Effekt ist beispielsweise ein Abschneiden des
Textes von Eingabefeldern, wenn die Oberfläche unter einem anderen Betriebssystem oder mit einer
anderen Bildschirm-Auflösung entworfen wurde.
Die wichtigsten Layout Manager
FlowLayout
FlowLayout
BorderLayout
BorderLayout
BoxLayout
BoxLayout
CardLayout
CardLayout
GridLayout
GridLayout
GridBagLayout
GridBagLayout
LayoutManager bestimmen die Position und eventuell auch die
Grösse der im Container enthaltenen Komponenten
35
In AWT gibt es fünf verschiedene Layout Manager: FlowLayout, BorderLayout, CardLayout, GridLayout und
GridBagLayout.
In Swing gibt es noch einige weitere Layout Manager, welche zum Teil vor allem intern (also für die Swing
Komponenten selber) gebraucht werden.
Alle Layout Manager können sowohl für AWT wie auch für Swing Komponenten benutzt werden.
22FlowLayout
Der LayoutManager bestimmt die Position und
eventuell auch die Grösse der im Container
enthaltenen Komponenten
FlowLayout ...
... ist geeignet für einfache Anwendungen
... positioniert zeilenweise
Im FlowLayout werden die einzelnen Komponenten zeilenweise, wie Wörter in einem Text, angeordnet: von
links nach rechts und zeilenweise von oben nach unten. Die einzelnen Komponenten können nach links,
nach rechts oder in der Zeile zentriert angeordnet werden. 36
Die Komponente JPanel hat per Default ein FlowLayout als Layout Manager.
Verwenden des FlowLayout
Der Konstruktor von FlowLayout hat die
Parameter
FlowLayoutBsp (){ alignment
// set layout manager and font horizontal spacing
setLayout( vertical spacing
new FlowLayout(FlowLayout.LEFT,5,5));
// create a label and add it to the panel
l = new JLabel("Press Button to Quit" );
add( l );
// create a button and add it to the panel
b = new JButton( "Quit" );
add( b );
}
public class FlowLayoutBsp extends JFrame
{
FlowLayoutBsp() 37
{
// set layout manager
setLayout(new FlowLayout(FlowLayout.LEFT, 5, 5)); // linksbündig mit jeweils 5 Pixel
// Abstand zwischen den Komponenten
// create a label and add it to the panel
JLabel l = new JLabel("Press Button to Quit"); add(l);
// create two buttons and add them to the panel
JButton b1 = new JButton("Cancel"); add(b1); // add bestimmt die Reihenfolge der Button
JButton b2 = new JButton("Quit"); add(b2);
}
. . .
}
23BorderLayout
... ist geeignet für Hauptfenster
... verwaltet Grössen und Positionierung
... erzeugt einen grossen Zentralbereich Center
... und vier schmale Randbereiche NORTH PAGE_START
SOUTH PAGE_END
North, West, South, East WEST LINE_START
EAST LINE_END
38
public class BorderLayoutBsp extends JFrame
{
BorderLayoutBsp()
{
// create panel with border layout, put 5 pixel between every component
JPanel p = new JPanel(new BorderLayout(5, 5));
p.setBackground(Color.white);
add(p);
// create all buttons and add them to the panel
JButton center = new JButton("Center");
p.add(center, BorderLayout.CENTER);
JButton north = new JButton("North");
p.add( north, BorderLayout.PAGE_START );
JButton south = new JButton("South");
p.add(south, BorderLayout.PAGE_END);
JButton west = new JButton("West");
p.add(west, BorderLayout.LINE_START);
JButton east = new JButton("East");
p.add(east, BorderLayout.LINE_END);
north.setFont(new Font("Courier", Font.BOLD, 18));
west.setFont(new Font("Courier", Font.BOLD, 16));
}
}
24Der Konstruktor von GridLayout hat die Parameter:
• Anzahl Zeilen der Tabelle
• Anzahl Spalten der Tabelle
• Horizontaler Abstand zwischen den Komponenten
• Vertikaler Abstand zwischen den Komponenten
public class GridLayoutBsp extends JFrame
{
GridLayoutBsp()
{
// set layout manager
setLayout(new GridLayout(0, 2, 5, 5));
// create two labels and add them to the panel
JLabel l = new Jlabel("Press Button to Quit");
add(l);
add( new JLabel() ); // add empty label to fill empty space
// create two s and add them to the panel
JButton b1 = new JButton("Cancel"); c.add(b1);
JButton b2 = new JButton("Quit"); c.add(b2);
}
. . .
}
Vollständige Beispiele unter
http://www.sws.bfh.ch/~amrhein/Swing/Beispiele/Layout/
25Im CardLayout sind alle eingefügten Komponenten so gross wie der Container, in welchem sie enthalten
sind. Nur jeweils die „oberste“ Komponente ist sichtbar.
Durch die Methoden show(), first(), last(), next() und previous() wird zwischen den verschiedenen Ansichten
navigiert.
public class MyCardLayout extends JFrame
{
JPanel parent;
CardLayout layout = new CardLayout();
Font font = new Font("Dialog", Font.BOLD, 16);
public MyCardLayout()
{
parent = new JPanel( layout );
add(parent);
// create content of cards
MyJPanel p1 = new MyJPanel(Color.green, 1); parent.add(p1, "1");
MyJPanel p2 = new MyJPanel(Color.yellow, 2); parent.add(p2, "2");
MyJPanel p3 = new MyJPanel(Color.red, 3); parent.add(p3, "3");
}
class MyJPanel extends JPanel
{
MyJPanel(Color color, int c)
{
setLayout(new GridLayout(2,1));
setBackground(color);
JLabel l1 = new JLabel("This is Card " + c, SwingConstants.CENTER);
l1.setFont(font); add(l1);
JLabel l2 = new JLabel("Click Mouse to switch to card " + (c%3+1));
add(l2);
addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e)
{ layout.next(parent); }
});
}
}
}
26GridBagLayout
... ist geeignet für komplexe Anordnungen
... verwaltet Grösse und Position
... basiert auf Zeilen und Spalten
... passt die Grösse von Zeilen / Spalten dynamisch an
Jede Komponente kann
... eine oder mehrere Zellen belegen
... ihren Bereich ganz oder nur teilweise ausfüllen
... bei Änderung der Container Grösse
unterschiedlich stark wachsen
41
Das GridBagLayout ist das flexibelste, aber auch das komplizierteste der fünf AWT Layouts.
Der Container wird in ein Gitter von Zeilen und Kolonnen unterteilt. Diese müssen nicht gleich hoch/breit
sein. Jede Komponente wird positioniert durch Setzen verschiedener Variablen aus GridBagContraints.
Das GridBagLayout bietet unter anderem folgende Möglichkeiten:
Eine Komponente kann sich über mehrere Gitterzellen erstrecken.
Spalten und Zeilen können unterschiedlich breit bzw. hoch sein.
Eine Komponente kann die ihr zugewiesenen Gitterzellen voll ausfüllen oder nur zum Teil.
Bei Grössen Änderungen des Containers kann angegeben werden, zu welchen Anteilen die
Höhen-/Breiten Änderung auf die einzelnen Gitterzeilen und -spalten verteilt wird.
Die Einstellung dieser Eigenschaften erfolgt mit Hilfe der Klasse GridBagConstraints.
GridBagConstraints.gridwidth/GridBagConstraints.gridheight definiert die Anzahl
Gitterzellen, über die sich die Komponente horizontal/vertikal erstreckt. Möglich sind die Werte
Absoluter Wert: Anzahl Gitterzellen.
GridBagConstraints.REMAINDER vergibt den Rest der aktuellen Zeile an die Komponente.
GridBagConstraints.RELATIVE platziert die nächste oder die zweitletzte Komponente.
GridBagConstraints.gridx/ GridBagConstraints.gridy positioniert die Komponente in der
Gitterzelle gridx/gridy.
GridBagConstraints.anchor erlaubt die Festlegung der Position einer Komponente innerhalb ihres
Anzeigebereichs, falls sie diesen nicht voll ausfüllt.
Mögliche Werte sind GridBagConstraints.CENTER sowie acht Richtungskonstanten:
GridBagConstraints.NORTH bis GridBagConstraints.NORTHWEST.
GridBagConstraints.fill spezifiziert, ob und wie die Komponente ihren Anzeigebereich ausfüllt:
GridBagConstraints.NONE: Die Komponente erhält ihre bevorzugte Grösse.
GridBagConstraints.HORIZONTAL: Die Komponente füllt die Horizontale
GridBagConstraints.VERTICAL: Die Komponente füllte die Vertikale
GridBagConstraints.BOTH: Die Komponente füllte den ganzen Bereich (Default).
GridBagConstraints.weightx / GridBagConstraints.weighty : ermöglichen eine gewichtete
Verteilung des vorhandenen Platzes auf die einzelnen Gitterzellen.
GridBagConstraints.insets fügt an den Rändern des Bereichs zusätzlichen Zwischenraum ein.
Vollständige Beispiele unter
http://www.sws.bfh.ch/~amrhein/Swing/Beispiele/Layout/
27Mit der Einführung von Swing wurden auch einige neue Layout Manager entwickelt: BoxLayout,
GroupLayout und SpringLayout. Das SpringLayout ist dazu gedacht, in GUI-Builder eingesetzt zu werden.
Das BoxLayout wurde entwickelt, um ähnliche Ergebnisse wie beim GridBagLayout zu erhalten, ohne
dessen Komplexität übernehmen zu müssen. Es ordnet Komponenten entlang einer vorgegebenen Linie an,
wobei folgende Möglichkeiten zur Verfügung stehen:
X_AXIS: Die Komponenten werden horizontal von links nach rechts ausgelegt.
Y_AXIS: Die Komponenten werden vertikal von oben nach unten ausgelegt.
LINE_AXIS: Horizontal, aber abhängig von der ComponentOrientation des Containers.
PAGE_AXIS: Abhängig von der ComponentOrientation (horizontal, vertikal, rechts, links).
Das BoxLayout versucht, die Komponenten gemäss der preferredSize anzuordnen. Füllen die Komponenten
nicht den gesamten zur Verfügung stehenden Platz aus, wird die Ausrichtung durch das alignmentX bzw.
alignmentY der Komponenten bestimmt.
Um die Verwendung des BoxLayout zu vereinfachen, gibt es die Klasse Box, die eine Komponente mit
einem BoxLayout darstellt
Neben den oben erwähnten Möglichkeiten des BoxLayouts bietet die Box drei Konstrukte, um unsichtbare
Komponenten zur Ausrichtung zu verwenden:
Rigid Area: Eine unsichtbare Komponente mit fixer Grösse.
Glue: Ein Glue kann entweder horizontal oder vertikal ausgerichtet sein und nimmt sämtlichen
überschüssigen Platz ein.
Box.Filler: Ein Box.Filler ist eine nach eigenen Angaben gestaltete, flexible unsichtbare Komponente,
welche sich gemäss der angegebenen Dimension skaliert.
28Jede Gruppe besetzt eine Tabellen-Zelle. Komponenten werden zuerst zeilenweise, dann spaltenweise
zugeordnet.
AdressPanel() {
GroupLayout layout = new GroupLayout(this);
this.setLayout(layout);
layout.setAutoCreateGaps(true);
layout.setAutoCreateContainerGaps(true);
layout.setHorizontalGroup(layout.createSequentialGroup() // Definition der
.addGroup(layout.createParallelGroup(TRAILING). // Spalten
.addComponent(name)
.addComponent(geschlecht)
.addComponent(strasse)
.addComponent(gebDatum))
. . .
);
layout.setVerticalGroup(layout.createSequentialGroup() // Definition der
.addGroup(layout.createParallelGroup(BASELINE) // Zeilen
.addComponent(name)
.addComponent(nameField)
.addComponent(vorname)
.addComponent(vornameField))
// . . . analog
);
}
29Forms Layout Manager
Der JGoodies Forms Layout Manager kann
ebenfalls sehr komplexe Anordnungen
verwalten, ohne dass der Code durch viele
Platzierungs-Anweisungen belastet wird.
Der Layout Manager von JGoodies http://www.jgoodies.com/ bietet eine ähnliche Flexibilität wie ein
GridBagLayout, „verschmutzt“ den Code aber viel weniger durch Platzierungs-Anweisungen. Die
Initialisierung geschieht in einem (etwas komplizierten) Konstruktor, danach werden die Komponenten
einfach der Reihe nach in die Zeilen eingefügt.
public LayoutTest()
{
45
FormLayout layout = new FormLayout(
"right:max(40dlu;pref), 3dlu, fill:max(4dlu;pref), 2dlu,
right:max(10dlu;pref), 2dlu, 27dlu:grow, 7dlu, " + // 1st major column
"right:max(40dlu;pref), 3dlu, 80dlu:grow", // 2nd major column
""); // add rows dynamically
DefaultFormBuilder builder = new DefaultFormBuilder(layout);
builder.setDefaultDialogBorder();
builder.appendSeparator("Adresse");
builder.append("Name", new JTextField(20), 5);
builder.append("Vorname", new JTextField());
builder.nextLine();
builder.append("Strasse", new JTextField(), 5);
builder.nextLine();
builder.append("PLZ", new JTextField(4));
builder.append("Ort", new JTextField(10));
String[] str = {"Schweiz","Deutschland"};
builder.append("Land", new JComboBox(str));
builder.nextLine();
builder.appendSeparator("Versand");
...
}
Vollständiges Beispiel unter
http://www.sws.bfh.ch/~amrhein/Swing/Beispiele/Layout/
302.10 Wie wählt man den Layout Manager
In erster Linie soll nicht das Aussehen die Anzahl verwendeter Container bestimmen, sondern die
Anwendung. Versuchen Sie also nicht, verschiedenste Probleme in der gleichen Panel-Klasse zu lösen, nur
weil deren Ausgabe auf der Oberfläche nebeneinander zu liegen kommen muss. Verwenden Sie lieber
mehrere Panels, um die Oberfläche sauber zu gruppieren und versuchen Sie nicht, das ganze Layout auf
einen Schlag zu organisieren.
Wir betrachten anhand verschiedener Szenarios verschiedene Lösungsmöglichkeiten.
1. Es gibt eine Hauptkomponente, welche so viel Platz wie möglich einnehmen soll. --> BorderLayout,
einfügen im CENTER. Die restlichen Komponenten an den Rändern.
2. Es gibt eine Anzahl Komponenten, welche in einer Zeile (oder Spalte) alle gleich gross angeordnet
werden sollen. --> GridLayout.
3. Die Komponenten sollen alle jeweils so klein wie möglich in einer Zeile dargestellt werden.--> ein
JPanel mit FlowLayout.
4. Es gibt eine Anzahl Komponenten, welche in einer Zeile (oder Spalte) angeordnet werden sollen, sie
sind nicht alle gleich gross, oder sie haben verschieden grosse Abstände --> BoxLayout, ev. durch
Zuhilfenahme von unsichtbaren Komponenten für die grossen Abstände.
5. Die Komponente muss je nach Zustand (oder Benutzereingabe) verschiedene, vielleicht
unterschiedlich grosse oder eine verschiedene Anzahl von Komponenten anzeigen. --> CardLayout.
Dabei gibt es pro Zustand je eine Karte.
6. Die Komponente beinhaltet ein Formular (Name, Vorname, Adresse, ...plus je ein TextFeld). -->
SpringLayout, FormsLayout(JGoodies) GridBagLayout oder eigener Layout Manager.
7. Die Komponente enthält verschiedenste Komponenten, welche unterschiedlich gross sind und
unterschiedlich stark wachsten sollen. --> Aufteilen in verschiedene Panels, welche verschiedene
Layout Manager benutzen, FormsLayout oder GridBagLayout.
8. Relativ einfaches Layout, welches aber durch keinen Layout Manager optimal verwaltet wird -->
eigenen Layout Manager schreiben.
313 Das Java Event Handling
Die Interaktion mit einem GUI geschieht über Events. Ein Event ist eine Aktion, welche durch einen
Benutzer initialisiert wurde, sei es durch Drücken eines Buttons, Verschieben der Maus, Drücken einer
Taste ...
Damit Java auf die Aktion eines Benutzers reagiert, muss zuerst ein Event Listener registriert und ein
zugehöriger Event Handler implementiert werden.
Damit ein Event Listener über die eingegangenen Events benachrichtigt wird, muss er sich bei der
entsprechenden Event Source registrieren. Dies geschieht durch Aufruf der addXXXListener-Methode,
wobei »XXX« jeweils für den entsprechenden Event-Typ steht.
Auszug aus dem java.awt.event Package
Die wichtigsten AWT Events
AWTEvent
ActionEvent
AdjustmentEvent
FocusEvent
ComponentEvent KeyEvent
InputEvent
MouseEvent
PaintEvent
WindowEvent
MouseWheelEvent
4
Alle AWTEvent-Objekte bieten die Methoden
isConsumed() liefert true, falls das Event bereits verarbeitet wurde
consume(): verarbeitet (löscht) das Event, falls möglich.
getID(): liefert die ID des Ereignisses
getSource(): gibt die EventSource zurück.
32Jeder Event-Klasse entspricht ein Listener Interface.
Die entsprechenden EventListener
>
>
>
>
>
>
>>
5
Jeder Event Listener ist spezialisiert auf gewisse Arten von Events (Mouse Event, Key Event, Action
Event ...). Der Event Handler ist dann die Methode, welche beim Eintreffen des entsprechenden Events
ausgeführt wird.
Auszug aus dem Swing Event Package
EventObject
CaretEvent
ChangeEvent
ListSelectionEvent
MenuEvent
MenuEvent
Die wichtigsten Klassen
TableModelEvent
aus javax.swing.event
TreeModelEvent
UndoableEditEvent
UndoableEditEvent
6
Dies sind die wichtigsten Events, welche mit dem Swing Paket neu verfügbar sind.
Für die Swing Komponenten können aber auch die üblichen AWT-Events verwendet werden.
33Sie können auch lesen
