Entwicklung von E-Learning Komponenten zur Computergrafik

F Entwicklung von E-Learning Komponenten zur Computergrafik Development of E-learning components for computer graphics Markus Stollenwerk, Rainer Friesen und Daniel Valentin Master Projektstudium Betreuer: Prof. Dr. Ing. Fritz Nikolai Rudolph Trier, 28.02.2007

Kurzfassung Ziel dieses Tutorials ist es die grundlegenden Techniken der Computergrafik zu erklären. Dazu werden zunächst die Grundlagen der Programmiersprachen Java und C# erklärt. Diese Grundlagen befassen sich mit dem Erstellen von grafischen Benutzeroberflächen und der Verwendung von diesen. Ein weiterer Bereich beschäftigt sich mit den verschiedenen Arten von Softwarepatterns bzw. Softwareentwurfsmustern. Hier werden exemplarisch die wichtigsten Entwurfsmuster erläutert. Im letzten Abschnitt wird die Verwendung der Java2D Umgebung erklärt. Dies beinhaltet die grundliegende Möglichkeit zu Zeichnen und diese Zeichnungen zu manipulieren. Des Weiteren wird auf die Verwendung von Schriften und Transparenz eingegangen.

Inhaltsverzeichnis 1 Einleitung..................................................... 1 2 Grundlagen Java.............................................. 3 2.1 Fenster und grafische Oberflächen.............................. 3 2.1.1 Erstellen eines JFrames.................................. 3 2.1.2 Hinzufügen von grafischen Elementen...................... 6 2.1.3 Anordnen von Objekten mit Layouts...................... 8 2.1.4 Verwenden von Listenern................................ 28 2.1.5 Erstellen von Menüleisten................................ 39 2.2 Applets..................................................... 42 2.3 GUI Elemente............................................... 49 2.3.1 Buttons............................................... 49 2.3.2 Textelemente........................................... 52 2.3.3 Slider................................................. 53 2.3.4 ComboBox............................................. 53 2.3.5 Menüs................................................. 56 2.3.6 Listen................................................. 56 2.3.7 Bäume................................................ 60 2.3.8 weitere GUI Elemente................................... 62 3 Grundlagen C#............................................... 63 3.1 Erstellung eines Projekts in Visual Studio....................... 63 3.1.1 Verweise............................................... 64 3.2 Fenster und GUI-Elemente.................................... 65 3.2.1 Beispiel 1 - ein einfaches Fenster in C#.................... 65 3.2.2 Beispiel 2 - Buttons und EventHandler.................... 67 3.2.3 Beispiel 3 - Labels...................................... 69 3.2.4 Beispiel 4 - Maus-Events................................. 71 3.2.5 Beispiel 5 - Web-Browser................................ 73 3.2.6 Beispiel 6 - Menü- und Statusbars......................... 75 3.2.7 Beispiel 7 - ComboBox.................................. 80 3.2.8 Beispiel 8 - MDI........................................ 84 3.2.9 Beispiel 9 - Radiobuttons und Checkboxen................. 85

Inhaltsverzeichnis IV 3.2.10Beispiel 10 - TreeView................................... 87 4 Grundlagen Patterns.......................................... 91 4.1 Observer Pattern............................................ 91 4.2 MVC Pattern............................................... 96 4.3 Singleton Pattern............................................ 101 4.4 State Pattern................................................ 103 4.5 Factory Pattern.............................................. 107 5 Grundlagen Java 2D........................................... 110 5.1 Zeichnen.................................................... 110 5.1.1 Zeichnen vor Java2D.................................... 110 5.1.2 Zeichnen mit Java2D.................................... 113 5.2 Translation, Rotation und Skalierung........................... 117 5.3 Fonts....................................................... 121 5.4 Transparenz................................................. 123 6 2D-Grafik in C#.............................................. 126 6.1 Einführung.................................................. 126 6.2 2D-Grafik in C#............................................. 126 6.2.1 Initialisierung des Grafikkontexts......................... 126 6.2.2 Beispiel 1 - Die erste 2D-Grafik........................... 128 6.2.3 Beispiel 2 - Ellipsen und Rechtecke........................ 130 6.2.4 Beispiel 3 - Brushes..................................... 131 6.2.5 Beispiel 4 - Polygone.................................... 133 6.2.6 Beispiel 5 - GraphicsPath................................ 135 6.2.7 Beispiel 6 - Transformationen............................. 136 6.2.8 Einführung Splines...................................... 138 6.2.9 Splines 1 - Hermite-Splines............................... 138 6.2.10Splines 2 - Bézier-Splines................................ 140 6.2.11Splines 3 - Cardinal Splines.............................. 142 6.3 Fonts in C#................................................. 145 6.4 Bitmaps in C#.............................................. 146 Literatur......................................................... 147

Abbildungsverzeichnis 2.1 JFrames stellen die Fenster in Java dar......................... 3 2.2 JFrame, bei welchem die Größe mit pack automatisch angepasst wird........................................................ 6 2.3 Der zweite JButton überschreibt den ersten JButton im JFrame.... 9 2.4 Ein FlowLayout ordnet die JLabels nebeneinander an............. 11 2.5 Ein GridLayout ordnet die JLabels wie in einem Gitter an......... 11 2.6 Ein BorderLayout ordnet die JPanels so an, dass ein Zentrum und ein Rand entstehen........................................... 14 2.7 Verwendung eines BoxLayouts zur Erstellung eines Login-Bildschirms. 18 2.8 Mit einem GridBagLayout kann man komplexere grafische Oberflächen erstellen......................................... 23 2.9 Das CardLayout ist das einzige Layout in Java, welches Interaktionen des Benutzers zulässt............................. 27 2.10 Eine Menüleiste, wie sie in fast jedem Programm vorkommt....... 39 2.11 Hello World Applet in einem Webbrowser....................... 43 2.12 Anzeige der verschiedenen Meilensteine......................... 45 2.13 Ansicht eines Frames aus einem JApplet........................ 48 2.14 Ansicht der verschiedenen Buttons............................. 50 2.15 SicherePassworteingabe....................................... 52 2.16 Slider und ComboBox........................................ 54 2.17 Menüs und Listen........................................... 57 2.18 Ein Baum.................................................. 61 3.1 Neues Projekt............................................... 64 3.2 Verweise.................................................... 65 3.3 Beispielprogramm frames01................................... 66 3.4 Anwendung Frames02........................................ 68 3.5 Anwendung Frames03........................................ 70 3.6 Anwendung Frames04........................................ 72 3.7 Anwendung Frames05........................................ 75 3.8 Menüaufbau................................................ 76 3.9 Anwendung Frames07........................................ 83 3.10 Anwendung Frames08........................................ 85

Abbildungsverzeichnis VI 3.11 Anwendung Frames09........................................ 87 3.12 TreeView................................................... 87 3.13 Anwendung Frames10........................................ 90 4.1 Observer-Pattern............................................ 92 4.2 Model-View-Control-Pattern.................................. 96 4.3 Singleton-Pattern............................................ 101 4.4 State-Pattern............................................... 103 4.5 Automatenmodell eines Toröffners............................. 104 5.1 Ausgabe des Programms Draw01.............................. 110 5.2 Ausgabe des Programms Draw02.............................. 114 5.3 Transition des Rechtecks...................................... 120 5.4 Ausgabe des Programms Font01............................... 122 5.5 Ausgabe des Programms Transparency01....................... 124 6.1 Neue Windows Form......................................... 127 6.2 Beispielprogramm 1.......................................... 129 6.3 Beispielprogramm 2.......................................... 131 6.4 Beispielprogramm 3.......................................... 133 6.5 Beispiel 4................................................... 134 6.6 GraphicsPath............................................... 135 6.7 Rotation eines GraphicsPath.................................. 137 6.8 Bezier-Kurve................................................ 138 6.9 Hermite-Kurve.............................................. 140 6.10 Bezierkurve................................................. 142 6.11 Auswirkung des Tensionwerts................................. 142 6.12 Cardinal Splines............................................. 144 6.13 Fonts in C#................................................ 145 6.14 Bitmaps in C#.............................................. 146

1 Einleitung Ziel dieser Ausarbeitung ist es, einen Einblick in die Verwendung der Computergrafik zu geben. In der heutigen Zeit gibt es immer mehr Anwendungsgebiete für die Computergrafik. Angefangen bei der computerunterstützten Designarbeit über die Spiele-Industrie bis hin zu der Entwicklung von Grafiken für Bilder und Filme. Bei all diesen Aufgaben werden die Grundlagen der Computergrafik benötigt. Um zu diesen komplexen Themengebieten einen Einstieg zu finden werden zunächst die grundlegenden Funktionen der Programmiersprachen Java und C# erläutert. Im ersten Kapitel Grundlagen Java werden die ersten Schritte bei der Programmierung einer grafischen Benutzeroberfläche mit Java beschrieben. Dazu gehört als erstes das Erstellen eines Fensters mit Hilfe eines JFrames, das Hinzufügen von grafischen Elementen und Anordnen mit Hilfe von LayoutManagern, sowie die Verwendung von Listenern und Menülistenern. Der zweite Schritt beim Umgang mit Java ist die Verwendung von Applets. Dazu gehören der allgemeine Aufbau eines Applets und die Einbindung in eine Webseite. Der dritte Abschnitt befasst sich mit den verschiedenen, in Java verfügbaren, GUI-Elementen. Hier werden die Funktionsweise und die Verwendung beschrieben. Bei den GUI-Elementen handelt es sich um die verschiedenen Arten von Buttons, Textbausteinen und anderen grafischen Ein- und Ausgabemöglichkeiten. Das zweite Kapitel Grundlagen C# gibt einen Einblick in den Umgang mit der Programmiersprache C#. Dazu wird zunächst erklärt wie mit Hilfe der Entwicklungsumgebung Visual Studio neue Projekte erstellt werden können. Daran schließt sich eine Einführung in die ersten Schritte beim Umgang mit C# an. Als letzter Abschnitt in diesem Kapitel werden die verschiedenen Fenster und GUI- Elemente erklärt. Dazu zählen neben den Standardelementen, wie Buttons und Labels, auch Besonderheiten wie der Webbrowser. Zusätzlich wird hier der Umgang mit Mausevents sowie Menüs und Statusanzeigen erläutert. Das nächste Kapitel Grundlagen Patterns beschäftigt sich mit den wichtigsten Entwurfsmustern in der Softwareentwicklung. Dazu wird der Aufbau und die Verwendung der Entwurfsmuster Observer, Model-View-Control, Singleton, State

1 Einleitung 2 sowie Factory beschrieben. Im letzten Kapitel Grundlagen Java2D wird der Umgang mit der Java2D Umgebung beschrieben. Dazu wird in einem ersten Schritt ein Vergleich zwischen dem Zeichnen vor und nach Java2D gezogen. Im weiteren Verlauf werden die Möglichkeiten bei der Grafikprogrammierung mit Java2D aufgezeigt. Dazu gehört als einer der wichtigsten Punkte die Möglichkeit der Bildmanipulation durch Translation, Rotation und Skalierung. Als Abschluss wird dann noch auf die Verwendung von Schriften eingegangen und das Konzept der Transparenz erläutert.

2 Grundlagen Java 2.1 Fenster und grafische Oberflächen Im folgenden Abschnitt wird gezeigt, wie man mit Java eigene Fenster erstellt und komplette grafische Benutzeroberflächen aufbaut. Dazu gehört die Erzeugung von Buttons, Listen etc. und das Einfügen dieser Objekte in ein Fenster, sowie die Verwendung von Listenern, zum Abfangen von Benutzereingaben. Dazu werden die Java-Packages javax.swing und java.awt verwendet. Es ist also in jedem Beispiel nötig diese Packages oder zumindest Teile davon zu importieren, da diese die wichtigsten Elemente einer grafischen Oberfläche zur Verfügung stellen. Um weitere Informationen und Hilfe zu erhalten, ist es sehr hilfreich einen Blick in das Java Swing Tutorial [SUNb] zu werfen. 2.1.1 Erstellen eines JFrames In der Abbildung 2.1 sieht man ein JFrame, aus dem Package javax.swing. Dieses JFrame stellt ein Fenster dar, wie es üblicherweise in den heutigen Betriebssystemen verwendet wird um grafische Oberflächen zu erzeugen. Abbildung 2.1. JFrames stellen die Fenster in Java dar

2.1 Fenster und grafische Oberflächen 4 Ein solches JFrame zu Erstellen ist ziemlich simpel. Man erstellt einfach ein Objekt der Klasse JFrame und führt die passenden Methoden zum Konfigurieren des JFrames aus. Zuerst sollte man eine Klasse mit beliebigem Namen und einer Main-Methode erstellen. Zusätzlich muss man noch die Klasse JFrame importieren, welche sich in dem Package javax.swing befindet. Als nächstes sollte man dann das JFrame-Objekt erstellen und konfigurieren. Dies geschieht mit dem folgenden Quellcode. public static void main ( S t r i n g [ ] args ){ JFrame frm = new JFrame ( ) ; frm. s e t T i t l e ( JFrame mit s e t S i z e ( ) ) ; frm. s e tdefaultcloseoperation ( JFrame. EXIT ON CLOSE ) ; frm. s e t S i z e ( 3 0 0, 2 0 0 ) ; frm. s e t L o c a t i o n ( 5 0, 5 0 ) ; frm. s e t V i s i b l e ( true ) ; Hier wird ein JFrame-Objekt erstellt und danach dessen Titel eingestellt. Der Titel ist der Text der in der oberen Fensterleiste erscheint. Der Methode setdefaultcloseoperation wird dann noch die Konstante JFrame.EXIT ON CLOSE übergeben. Diese sorgt dafür, dass das komplette Programm beendet wird, wenn man das Fenster schließt. Es gibt unterschiedliche Konstanten, welche verwendet werden können um verschiedene Effekte beim Schließen eines Fensters zu erzeugen. JFrame.DO NOTHING ON CLOSE Beim Schließen passiert einfach nichts. JFrame.EXIT ON CLOSE Beendet das Programm, wenn man dieses Fenster schließt. JFrame.HIDE ON CLOSE (Standard bei JFrame und JDialog) Versteckt das Fenster anstatt es zu schließen. JFrame.DISPOSE ON CLOSE (Standard bei JInternalFrame) Verwirft das Fenster komplett und entfernt es aus dem Speicher. Nachdem nun die defaultcloseoperation festgelegt wurde stellen wir noch die Größe und die Position des Fensters mit den Methoden setsize() und setlocation() ein. Der Methode setsize() kann man entweder zwei int-werte für Breite und Höhe übergeben oder ein Dimension-Objekt. Die Methode setlocation() erhält als Parameter zwei int-werte oder ein Objekt der Klasse Point.

2.1 Fenster und grafische Oberflächen 5 Zu guter Letzt wird das Fenster dann noch angezeigt. Dies geschieht mit dem Aufruf setvisible(true). Der Beispielquellcode für dieses Beispiel kann auch noch einmal in der Datei FrameCreator01.java gefunden werden. Wenn er kompiliert und gestartet wird, wird das Fenster aus der Abbildung 2.1 erzeugt. Man sieht also, dass man mit minimalem Aufwand ein Fenster erstellen kann. In diesem Fall wurde jedoch nur ein sehr einfaches JFrame erstellt und dieses mit den dazugehörigen Methoden verändert. Üblicherweise erzeugt man jedoch eine eigene Fensterklasse, von welcher man dann auch mehrere Instanzen erstellen kann. Dazu schreibt man eine neue Klasse, welche von der Klasse JFrame erbt und passt dann in dieser Klasse, beispielsweise im Konstruktor, die jeweiligen Einstellungen an. Das ganze sieht dann folgendermaßen aus. import javax. swing. JFrame ; / E r s t e l l e n e i n e s Fensters mit e i n e r automatischen Groesse / c l a s s MyFrame extends JFrame{ public MyFrame(){ // Einen T i t e l e i n s t e l l e n super ( JFrame mit pack ( ) ) ; / Das JFrame so e i n s t e l l e n, dass das Programm beim S c h l i e ß e n des JFrames beendet wird / s e tdefaultcloseoperation ( JFrame. EXIT ON CLOSE ) ; // Groesse wird automatisch angepasst pack ( ) ; // Die P o s i t i o n e i n s t e l l e n s e t L o c a t i o n ( 5 0, 5 0 ) ; //Das JFrame anzeigen s e t V i s i b l e ( true ) ;

2.1 Fenster und grafische Oberflächen 6 public c l a s s FrameCreator02{ public static void main ( S t r i n g [ ] args ){ new MyFrame ( ) ; In diesem Beispiel wird die neue Klasse MyFrame erstellt, welche von JFrame erbt. In ihrem Konstruktor wird der Superkonstruktor, also der Konstruktor der Klasse JFrame, aufgerufen um den Titel einzustellen. Danach werden, wie im vorherigen Beispiel, die Einstellungen für das JFrame vorgenommen, indem die vererbten Methoden verwendet werden. Eine kleine Änderung wurde jedoch noch zusätzlich vorgenommen. Statt der Methode setsize() verwenden wir, in diesem Beispiel die parameterlose Methode pack(), welche eine Methode der Oberklasse Window (java.awt.window) ist, von welcher JFrame erbt. Die Methode pack() passt die Größe des Fensters automatisch so an, dass alle Elemente des JFrames hineinpassen aber trotz allem das Fenster möglichst klein ist. In unserem Beispiel (siehe Abb.2.2), sieht man nur die Titelleiste, da sich kein anderes Element auf dem Fenster befindet. Abbildung 2.2. JFrame, bei welchem die Größe mit pack automatisch angepasst wird. Der Quellcode zu diesem Beispiel befindet sich in der Datei FrameCreator02.java und kann ebenfalls kompiliert und ausgeführt werden. 2.1.2 Hinzufügen von grafischen Elementen Im vorherigen Abschnitt wurde nun erläutert, wie man ein eigenes Fenster erstellt, in der Größe verändert und anzeigt. In der folgenden Passage wird nun gezeigt wie man ein grafisches Element zu diesem Fenster hinzufügt. Welche verschiedenen grafischen Elemente es in Java gibt wird in einem späteren Abschnitt näher erläutert (Abschnitt 2.3). Jedes JFrame in Java besitzt ein so genanntes ContentPane. Das ContentPane ist ein Container, in welchen man verschiedene grafische Elemente einfügen kann. Zu diesen Elementen gehören Buttons, Textfelder, sowie andere Container, welche wiederum Elemente enthalten können. Um nun auf das ContentPane zugreifen zu können, kann man ganz einfach die Methode getcontentpane, des JFrames verwenden. Das passende ContentPa-

2.1 Fenster und grafische Oberflächen 7 ne kann dann dazu verwendet werden um Elemente aufzunehmen, welche auf dem JFrame angezeigt werden sollen. Das Hinzufügen eines Elements wird durch die Methode add(component comp) ausgeführt. Der folgende Quellcode zeigt wie man ein Element erstellt, welches man hinzufügen kann und wie man es dann auch dem ContentPane übergibt. In diesem Beispiel handelt es sich bei dem Objekt um einen JButton, einen Knopf, auf welchen man klicken kann. import java. awt. event. ActionEvent ; import java. awt. event. A c t i o n L i s t e n e r ; import javax. swing. JButton ; import javax. swing. JFrame ; import javax. swing. JOptionPane ; / Hinzufügen e i n e s Buttons in ein JFrame und verwenden e i n e s L i s t e n e r s / class MyButtonFrame extends JFrame implements A c t i o n L i s t e n e r { public MyButtonFrame (){ super ( JFrame mit Button ) ; s e tdefaultcloseoperation ( JFrame. EXIT ON CLOSE ) ; / E r s t e l l e n e i n e s JButtons mit e i n e r B e s c h r i f t u n g / JButton btn = new JButton ( Drück mich ) ; btn. addactionlistener ( this ) ; / Einfügen des Buttons auf das ContentPane d e s JFrames / getcontentpane ( ). add ( btn ) ; pack ( ) ; s e t L o c a t i o n ( 5 0, 5 0 ) ; s e t V i s i b l e ( true ) ;

2.1 Fenster und grafische Oberflächen 8 public void actionperformed ( ActionEvent evt ){ JOptionPane. showmessagedialog ( null, Der Button f u n k t i o n i e r t!, Button f u n k t i o n i e r t, JOptionPane.INFORMATION MESSAGE) ; public c l a s s FrameCreator03 { public static void main ( S t r i n g [ ] args ){ new MyButtonFrame ( ) ; Zuerst wird wieder der Standardkonstruktor von JFrame aufgerufen, um den Titel einzustellen und es wird die DefaultCloseOperation eingerichtet (wie in Abschnitt 2.1.1 beschrieben). Daraufhin wird ein neuer JButton erstellt und diesem wird ein ActionListener, welcher in der gleichen Klasse implementiert wurde, übergeben. Nähere Informationen zu Listenern werden im Abschnitt 2.1.4 dargestellt. Durch diesen ActionListener wird die Methode actionperformed(actionevent evt) ausgeführt, sobald der Benutzer auf den Knopf drückt und es wird ein JOptionPane angezeigt, welches eine Meldung ausgibt. Nachdem nun der JButton erstellt wurde, wird er noch zu dem Fenster hinzugefügt. Um dies durchzuführen nimmt sich das Programm, mit der Methode getcontentpane(), das Container-Objekt des JFrames und fügt mit der Methode add(btn) den JButton zu dem Fenster hinzu. Danach wird wie bereits erklärt, dass Fenster in der Größe angepasst und angezeigt. 2.1.3 Anordnen von Objekten mit Layouts Wenn man nicht nur ein einzelnes grafisches Element, sondern gleich mehrere zu einem JFrame hinzufügen möchte, muss man so genannte Layouts verwenden. Layouts sind Strukturen, welche grafische Elemente in einem JFrame oder einer anderen Containerklasse so anordnen, wie man es gerne möchte. Ohne diese Layouts ist es beispielsweise nicht möglich, Buttons o.ä. nebeneinander anzuordnen oder sie in einer anderen Anordnung auf einem JFrame zu verteilen. Würde man beispielsweise den folgenden Quellcode in einem Programm einfügen, würde nur der zuletzt hinzugefügte Button angezeigt werden. Das Programm würde zuerst den ersten Button einfügen und der zweite würde diesen dann überzeichnen (Abb. 2.3).

2.1 Fenster und grafische Oberflächen 9 // E r s t e l l e n der JButtons mit e i n e r B e s c h r i f t u n g JButton btn = new JButton ( Drück mich ) ; btn. addactionlistener ( this ) ; JButton btn2 = new JButton ( Button 2 ) ; btn2. addactionlistener ( this ) ; // Einfügen der Buttons auf das ContentPane des JFrames getcontentpane ( ). add ( btn ) ; getcontentpane ( ). add ( btn2 ) ; Abbildung 2.3. Der zweite JButton überschreibt den ersten JButton im JFrame. Um eine möglichst große Vielfalt an verschiedenen grafischen Oberflächen zu ermöglichen gibt es unterschiedliche Arten von Layouts, welche man verwenden und auch kombinieren kann. Die einzelnen Layouts werden in den folgenden Abschnitten näher erläutert und es wird gezeigt, welche Art von Oberflächen man mit welchem Layout erstellen kann. Die Quellcodes der Beispielprogramme, in den folgenden Layoutabschnitten sind in den Dateien FrameCreator4.java bis Frame- Creator9.java enthalten. FlowLayout Das erste Layout, welches hier vorgestellt wird, ist das so genannte FlowLayout. Dieses ermöglicht Objekte nebeneinander zu platzieren. Um das FlowLayout zu verwenden kann man genauso vorgehen, wie in den Kapiteln zuvor beschrieben. Der einzige Unterschied besteht darin, dass man dem Container des JFrames ein FlowLayout zuweist. Dies geschieht über die Methode setlayout(layout) des jeweiligen Containers. Im folgenden Quellcode sieht man eine passende Anwendung, welche zeigt wie man ein Layout einstellt und danach mehrere JLabels zu dem Container hinzufügt. JLabels sind Objekte, welche einen einfachen Text anzeigen können.

2.1 Fenster und grafische Oberflächen 10 import java. awt. FlowLayout ; import javax. swing. JFrame ; import javax. swing. JLabel ; / Hinzufügen mehrerer Labels mit H i l f e e i n e s FlowLayouts / c l a s s FlowLayoutFrame extends JFrame{ public FlowLayoutFrame (){ super ( FlowLayout ) ; s e tdefaultcloseoperation ( JFrame. EXIT ON CLOSE ) ; // E i n s t e l l e n e i n e s FlowLayouts getcontentpane ( ). setlayout (new FlowLayout ( ) ) ; // Hinzufügen von e i n i g e n JLabels JLabel l b l ; for ( int i =0; i <5; i ++){ l b l = new JLabel ( JLabel + ( i +1)); getcontentpane ( ). add ( l b l ) ; pack ( ) ; s e t L o c a t i o n ( 5 0, 5 0 ) ; s e t V i s i b l e ( true ) ; public c l a s s FrameCreator04 { public static void main ( S t r i n g [ ] args ){ new FlowLayoutFrame ( ) ; Der gezeigte Quellcode unterscheidet sich nur in wenigen Punkten von dem Quellcode aus dem Abschnitt 2.1.2. Zum Einen werden hier keine JButtons, sondern JLabels hinzugefügt und zum Anderen wird hier, wie oben beschrieben, ein Layout mit new FlowLayout() erstellt und dieses dem Container des JFrames übergeben. Dieses Layout regelt dann selbstständig die Anordnung der einzelnen, mit der For-Schleife erstellten, JLabels. Ein passendes Bild, welches solch ein Flow- Layout zeigt, ist die Abbildung 2.4.

2.1 Fenster und grafische Oberflächen 11 Abbildung 2.4. Ein FlowLayout ordnet die JLabels nebeneinander an. GridLayout Das GridLayout ist dem FlowLayout sehr ähnlich. Der eigentliche Unterschied besteht darin, dass man sich die Anordnung nicht als Linie vorstellen sollte, wie bei dem FlowLayout, sondern als Gitter. Daher kommt auch der Name des Grid- Layouts. In dem GridLayout können alle Objekte in einer Art Raster oder Gitter angeordnet werden, wobei man die Anzahl der Spalten und Zeilen angeben kann. Dabei muss man nur eine sehr kleine Änderung am Quellcode des FlowLayouts, aus dem Abschnitt 2.1.3, vornehmen. Es wird einfach statt dem FlowLayout ein GridLayout an die Methode setlayout(layout) übergeben. Des Weiteren kann über den Konstruktor des GridLayouts angegeben werden, wieviele Spalten und Zeilen das Raster haben soll. Der erste Wert gibt die Anzahl der Zeilen an und der zweite Wert logischerweise die Anzahl der Spalten. Übergibt man den Wert 0 an den Konstruktor werden endlos viele Spalten bzw. Zeilen verwendet. Der Aufruf der setlayout(layout) Methode sieht dann folgendermaßen aus. getcontentpane ( ). setlayout (new GridLayout ( 2, 3 ) ) ; Ein Screenshot von solch einem GridLayout Beispielprogramm zeigt die Abbildung 2.5. Abbildung 2.5. Ein GridLayout ordnet die JLabels wie in einem Gitter an. BorderLayout Das BorderLayout ist etwas komplexer als die bisher vorgestellten Layouts. Es wird normalerweise nicht dazu verwendet JButtons oder JLabels anzuordnen. Stattdessen fügt man in einen Container, welcher ein BorderLayout verwendet, normalerweise JPanels ein. Ein JPanel ist wiederum ein Container, ähnlich wie das ContentPane eines JFrames. In solch ein JPanel kann man also wiederum JButtons oder JLabels etc. einfügen. Im folgenden Beispielprogramm sieht man wie man ein BorderLayout dazu verwendet um JPanels anzuordnen. Dabei besteht ein BorderLayout immer aus einem Zentrum und vier Rändern. Der Quellcode zeigt wie man einzelne JPanels, in den

2.1 Fenster und grafische Oberflächen 12 einzelnen Bereichen anordnet. Dabei wird der zweite Übergabewert der add()- Funktion eines Containers verwendet. An diesen wird eine Konstante übergeben, welche in der Klasse BorderLayout definiert ist und angibt, wo sich ein grafisches Elemente befindet. Es gibt die Konstanten CENTER, NORTH, EAST, SOUTH und WEST. Dabei bedeutet beispielsweise die Konstante NORTH, dass das jeweilige Objekt am nördlichen Rand eingefügt werden soll. import java. awt. BorderLayout ; import java. awt. Color ; import javax. swing. JFrame ; import javax. swing. JLabel ; import javax. swing. JPanel ; / Hinzufügen von JPanels und JLabels und verwenden e i n e s BorderLayout / c l a s s BorderLayoutFrame extends JFrame{ public BorderLayoutFrame (){ super ( BorderLayout ) ; s e tdefaultcloseoperation ( JFrame. EXIT ON CLOSE ) ; // E i n s t e l l e n e i n e s BorderLayouts getcontentpane ( ). setlayout (new BorderLayout ( ) ) ; Color [ ] c o l o r s = { Color.RED, Color.BLUE, Color.YELLOW, Color.GREEN, Color.ORANGE ; S t r i n g [ ] s t r i n g s = { Center, Norden, Osten, Süden, Westen ; S t r i n g [ ] p o s i t i o n s = { BorderLayout.CENTER, BorderLayout.NORTH, BorderLayout.EAST,

2.1 Fenster und grafische Oberflächen 13 BorderLayout.SOUTH, BorderLayout.WEST ; // E r s t e l l e n der JPanels und der JLabels JPanel panel ; JLabel l b l ; for ( int i =0; i <5; i ++){ panel = new JPanel ( ) ; panel. setbackground ( c o l o r s [ i ] ) ; l b l = new JLabel ( s t r i n g s [ i ] ) ; panel. add ( l b l ) ; getcontentpane ( ). add ( panel, p o s i t i o n s [ i ] ) ; s e t S i z e ( 4 0 0, 3 0 0 ) ; s e t L o c a t i o n ( 5 0, 5 0 ) ; s e t V i s i b l e ( true ) ; public c l a s s FrameCreator06 { public static void main ( S t r i n g [ ] args ){ new BorderLayoutFrame ( ) ; In diesem Beispiel werden die Hintergrundfarben der JPanels in verschiedenen Farben angezeigt, um deutlich zu machen, wo sich welches JPanel befindet. Dazu wird ein Array colors erstellt, welches verschiedene Farben enthält. Des Weiteren wird ein Array positions mit Strings erstellt, welche die Positionen der JPanels beinhalten. Danach werden dann mit einer For-Schleife neue JPanels erstellt und diese in der passenden Farbe und an der passenden Position angezeigt. Hier sieht man gut, dass die Methode add(), in diesem Beispiel, zwei Argumente übergeben bekommt. Das erste ist das hinzuzufügende Objekt und das zweite die Position des Objekts in dem Container. Natürlich darf man auch hier nicht vergessen vorher das Layout einzustellen. Dies geht hier genauso wie bei dem FlowLayout oder dem GridLayout, indem man eine Instanz von BorderLayout an die Methode set- Layout(Layout) übergibt. Auch hier gibt es wieder eine Beispielabbildung (Abb. 2.6).

2.1 Fenster und grafische Oberflächen 14 Abbildung 2.6. Ein BorderLayout ordnet die JPanels so an, dass ein Zentrum und ein Rand entstehen. BoxLayout Ein so genanntes BoxLayout bietet dem Programmierer schon wesentlich mehr Gestaltungsmöglichkeiten, als alle bisher vorgestellten Layouts und lässt sich trotz dieser Möglichkeiten relativ einfach verwenden. Die grobe Ausrichtung aller Objekte in einem BoxLayout wird über Konstanten festgelegt. Dabei orientieren sich alle Objekte in einem Container, welcher ein BoxLayout verwendet, an einer horizontalen oder einer vertikalen Linie. Es gibt vier verschiedene Konstanten, welche verwendet werden können: X AXIS - Hier werden die Objekte von links nach rechts angeordnet Y AXIS - Hier werden die Objekte von oben nach unten angeordnet LINE AXIS - Diese Konstante existiert erst seit Java 1.4 und ordnet die Objekte von links nach rechts oder von rechts nach links an, je nachdem, welche Sprache im System eingestellt ist. Dabei haben bestimmte Sprachen eine umgekehrte Orientierung, im Vergleich mit der Konstanten X AXIS. PAGE AXIS - Diese Konstante existiert ebenfalls erst seit Java 1.4 und ordnet die Objekte von oben nach unten oder von unten nach oben an. Genau wie bei LINE AXIS gibt es hier eine sprachenabhängige Orientierung. Des Weiteren bietet ein BoxLayout die Möglichkeit leere Bereiche in einen Container einzufügen und somit die Objekte einfach anzuordnen. Es gibt hier drei verschiedene Arten von Objekten: RigidArea - Eine RigidArea bekommt eine Breite und Höhe übergeben, welche sie ausfüllen soll. Diese wird beispielsweise verwendet, wenn man zwischen zwei Objekten einen bestimmten Abstand einhalten möchte.

2.1 Fenster und grafische Oberflächen 15 Glue - Bei einem Glue kann es sich um einen horizontalglue oder um einen verticalglue handeln. Diese füllen soviel Platz aus, wie sie bekommen können. Box.Filler - Ein Filler kann eine minimale, maximale und eine gewünschte Größe besitzen. So kann man beispielsweise ein Objekt erstellen, welches mindestens 5 Pixel und höchstens 50 Pixel breit sein sollte. Im folgenden Quellcode sieht man ein kleines Beispielprogramm, welches ein Loginfenster darstellen soll. Es verwendet dazu zwei verschiedene Layouttypen. Zum Einen das BorderLayout, um die Trennung zwischen dem Hauptbereich und dem Bereich mit den JButtons durchzuführen und zum Anderen zwei BoxLayouts, welche den Hauptbereich und den Knöpfebereich am unteren Rand organisieren. import java. awt. BorderLayout ; import java. awt. Dimension ; import javax. swing. BorderFactory ; import javax. swing. Box ; import javax. swing. BoxLayout ; import javax. swing. JButton ; import javax. swing. JFrame ; import javax. swing. JLabel ; import javax. swing. JPanel ; import javax. swing. JPasswordField ; import javax. swing. JTextField ; / Hinzufügen von JPanels und JLabels und verwenden e i n e s BoxLayouts / c l a s s BoxLayoutFrame extends JFrame{ public BoxLayoutFrame (){ super ( BoxLayout ) ; s e tdefaultcloseoperation ( JFrame. EXIT ON CLOSE ) ; // BorderLayout f ü r das Fenster e i n s t e l l e n getcontentpane ( ). setlayout ( new BorderLayout ( ) ) ; / Hauptbereich des JFrames e i n s t e l l e n / // JPanel f ü r den Hauptbereich des JFrames JPanel mainpanel = new JPanel ( ) ;

2.1 Fenster und grafische Oberflächen 16 // BoxLayout f ü r das mainpanel e i n s t e l l e n mainpanel. setlayout ( new BoxLayout ( mainpanel, BoxLayout. PAGE AXIS ) ) ; // JLabels und J T e x t f i e l d s zur Eingabe JLabel l b l U s e r = new JLabel ( Login : ) ; JTextField txtuser = new JTextField ( User ) ; JLabel l b l P a s s = new JLabel ( Password : ) ; JPasswordField txtpass = new JPasswordField ( pass ) ; mainpanel. add ( l b l U s e r ) ; mainpanel. add ( Box. createrigidarea (new Dimension ( 0, 5 ) ) ) ; mainpanel. add ( txtuser ) ; mainpanel. add ( Box. createrigidarea (new Dimension ( 0, 5 ) ) ) ; mainpanel. add ( l b l P a s s ) ; mainpanel. add ( Box. createrigidarea (new Dimension ( 0, 5 ) ) ) ; mainpanel. add ( txtpass ) ; / Buttonbereich des JFrames e i n s t e l l e n / // JPanel f ü r d i e Buttons JPanel buttonpanel = new JPanel ( ) ; // BoxLayout f ü r das buttonpanel e i n s t e l l e n buttonpanel. setlayout ( new BoxLayout ( buttonpanel, BoxLayout. LINE AXIS ) ) ; //oben, l i n k s, unten, r e c h t s buttonpanel. setborder ( BorderFactory. createemptyborder ( 5, 0, 5, 0 ) ) ; // JButtons e r s t e l l e n

2.1 Fenster und grafische Oberflächen 17 JButton btnok = new JButton ( Ok ) ; JButton btncancel = new JButton ( Cancel ) ; buttonpanel. add ( Box. c r e a t e H o r i z o n t a l G l u e ( ) ) ; buttonpanel. add ( btnok ) ; buttonpanel. add ( Box. createrigidarea ( new Dimension ( 5, 0 ) ) ) ; buttonpanel. add ( btncancel ) ; // Hinzufügen der JPanels zum BorderLayout getcontentpane ( ). add ( mainpanel ) ; getcontentpane ( ). add ( buttonpanel, BorderLayout.SOUTH) ; s e t S i z e ( 2 2 0, 1 6 0 ) ; s e t L o c a t i o n ( 5 0, 5 0 ) ; s e t V i s i b l e ( true ) ; public c l a s s FrameCreator07 { public static void main ( S t r i n g [ ] args ){ new BoxLayoutFrame ( ) ; Nachdem in dem Quellcode ein JFrame erstellt wurde und für das ContentPane des JFrames das BorderLayout eingestellt wurde, erstellt das Programm das JPanel mainpanel. Dieses bekommt über setlayout() ein BoxLayout zugewiesen. Der Konstruktor erhält dazu das JPanel, welches vom Layout organisiert werden soll, sowie die grobe Orientierung als Konstante. Danach werden die JLabels und das JTextField, sowie das JPasswordField erstellt, welche zur Texteingabe verwendet werden können. Danach werden sie zum mainpanel hinzugefügt und mit RigidAreas voneinander etwas abgetrennt. Die RigidAreas sorgen dafür, dass das Objekt, welches vorher eingefügt wurde 5 Pixel von dem Objekt entfernt liegt, welches danach eingefügt wird. Die selbe Prozedur wird für das buttonpanel durchgeführt, nur dass man hier eine horizontale Orientierung über den BoxLayout-Konstruktor einstellt und vor den JButtons einen horizontalglue einfügt. Dieser erstreckt sich über den kompletten nicht genutzten Bereich der vor den JButtons liegt. Des weiteren wird für

2.1 Fenster und grafische Oberflächen 18 das buttonpanel eine Border eingestellt. Dabei handelt es sich um einen Rand, welcher um alle Objekte des buttonpanels gezogen wird, so dass ein Abstand zwischen dem Rand des Fensters und dem mainpanel entsteht. Zu guter letzt werden dann noch die beiden JPanels in das JFrame eingefügt. Dabei kommt das mainpanel in den zentralen Bereich des BorderLayouts und das buttonpanel in den südlichen Bereich. Das Ergebnis wird in Abbildung 2.7 dargestellt. Abbildung 2.7. Verwendung eines BoxLayouts zur Erstellung eines Login- Bildschirms. GridBagLayout Das GridBagLayout ist wohl das Layout, welches am schwierigsten zu verwenden ist, jedoch bietet es dem Programmierer wohl die meisten Möglicheiten um grafische Elemente auszurichten. Dabei verwendet das GridBagLayout ein Gitter, ähnlich wie das GridLayout. Der Unterschied besteht jedoch darin, dass sich in einem GridBagLayout die Objekte über mehrere Gitterzellen erstrecken können. Dabei berechnet Java automatisch anhand der minimalen und maximalen Größen der Objekte wie hoch und breit die Zellen sein sollen. Zusätzlich kann man noch Constraints angeben, welche die Darstellung der einzelnen Objekte beeinflussen können. Anders als bei den bisher verwendeten Layouts wird hier nicht einfach das Layout zu einem Container hinzugefügt, sondern es wird noch weiterhin verwendet, um die Constraints zu jedem grafischen Objekt hinzufügen zu können. Es gibt folgende Constraints: gridx & gridy - Geben an in welcher Zelle ein grafisches Objekt seinen Ursprung besitzen soll. gridwidth & gridheight - Gibt an über wieviele Zellen sich ein Objekt erstrecken soll. weightx & weighty - Gibt an wie breit und hoch die Zelle im Vergleich zu den anderen ist.

2.1 Fenster und grafische Oberflächen 19 ipadx & ipady - Vergrößert ein Objekt in breite und/oder Höhe. Dabei ist die Vergrößerung ein Pixelwert und wird mit 2 multipliziert, da die Vergrößerung nach links und nach rechts bzw. nach oben und nach unten durchgeführt wird. fill - Falls ein Objekt kleiner ist als der Bereich den es ausfüllen soll kann man angeben wie es sich vergrößern soll um den Bereich auszufüllen. Es gibt die konstanten Werte NONE, HORIZONTAL, VERTICAL und BOTH, welche alles statische Konstanten der Klasse GridBagLayout sind. insets - Mit Insets kann man einen Rahmen um ein Objekt legen. Diesen Abstand hält das Objekt dann als Rand zu den Zellen ein in denen sich das Objekt befindet. anchor - Dieser Wert gibt an, an welcher Stelle sich ein Objekt in seinen Zellen befinden soll, wenn es kleiner als die Zellen ist. Es gibt neun Konstanten die übergeben werden können und die jeweils eine Ecke der Zelle oder das Zentrum darstellen. Die Konstanten sind FIRST LINE START, PAGE START, FIRST LINE END, LINE START, CENTER, LINE END, LAST LINE START, PAGE END und LAST LINE END, wobei beispielsweise FIRST LINE START oben links wäre und LAST LINE END unten rechts. Im folgenden Beispiel sieht man dann wie man das Layout nutzen kann. Wegen der Komplexität des Layouts sollte man aber am besten einfach mit dem Layout rumspielen um ein besseres Verständnis für dieses zu erhalten. import java. awt. GridBagConstraints ; import java. awt. GridBagLayout ; import java. awt. I n s e t s ; import javax. swing. JButton ; import javax. swing. JComboBox ; import javax. swing. JFrame ; import javax. swing. JLabel ; import javax. swing. JScrollPane ; import javax. swing. JTextArea ; import javax. swing. JTextField ; / Hinzufügen von JPanels und JLabels und verwenden e i n e s GridBagLayouts / c l a s s GridBagLayoutFrame extends JFrame{ public GridBagLayoutFrame (){ super ( GridBagLayout ) ; s e tdefaultcloseoperation ( JFrame. EXIT ON CLOSE ) ; // E i n s t e l l e n e i n e s GridBagLayouts

2.1 Fenster und grafische Oberflächen 20 GridBagLayout g b l = new GridBagLayout ( ) ; getcontentpane ( ). setlayout ( gbl ) ; Hier sieht man einen gewissen Unterschied zu den vorherigen Layouts. Es wird nicht nur eine Instanz von GridBagLayout erstellt, welche an die Methode set- Layout(Layout) übergeben wird. Es wird stattdessen auch eine Variable gbl vom Typ GridBagLayout erstellt, an welche die Instanz vorher übergeben wird. Dies ist nötig da man später noch öfters auf das GridBagLayout zugreifen muss. / Hier wird e i n GridBagConstraint O b j e k t e r s t e l l t / GridBagConstraints gbc = new GridBagConstraints ( ) ; / E i n s t e l l e n der Constraints und Hinzufügen der Objekte / // Label gbc. gridwidth = GridBagConstraints.REMAINDER; gbc. g r i d h e i g h t = 1 ; gbc. weightx = 1 ; gbc. weighty = 1 ; gbc. anchor = GridBagConstraints. LINE START ; // Konstruktor I n s e t s : oben, l i n k s, unten, r e c h t s gbc. i n s e t s = new I n s e t s ( 0, 0, 5, 0 ) ; JLabel label = new JLabel ( Autobörse : Kfz Verkauf ) ; gbl. s e t C o n s t r a i n t s ( label, gbc ) ; getcontentpane ( ). add ( label ) ; Hier sieht man nun wie ein Constraint erstellt wird. Dieser wird vor jedem Hinzufügen eines Objekts, in die grafische Oberfläche, eingestellt und für das jeweilige Objekt angepasst. Es wird beispielsweise die Anzahl der Zellen, welche das Objekt belegen soll über das Constraint eingestellt und auch das Gewicht sowie der Anker werden festgelegt. Zusätzlich wird mit gbc.insets ein Rand um das Objekt erstellt. Das einzufügende Objekt soll ein JLabel sein, welches erstellt wird und dann zu-

2.1 Fenster und grafische Oberflächen 21 sammen mit dem Constraint an das Layout übergeben wird. Zu guter letzt wird das Objekt dann in den Container des JFrames eingefügt. // Label gbc. gridwidth = 1 ; gbc. i n s e t s = new I n s e t s ( 0, 0, 0, 0 ) ; label = new JLabel ( Fahrzeugtyp : ) ; gbl. s e t C o n s t r a i n t s ( label, gbc ) ; getcontentpane ( ). add ( label ) ; //ComboBox f ü r Fahrzeugtyp gbc. gridwidth = GridBagConstraints.REMAINDER; gbc. f i l l = GridBagConstraints.HORIZONTAL; gbc. weightx = 3 ; gbc. i n s e t s = new I n s e t s ( 0, 5, 0, 5 ) ; S t r i n g [ ] strarray = { Sportwagen, Limosine, Coupe, Transporter, Bus, Lkw, Motorrad ; JComboBox cmbtype = new JComboBox( strarray ) ; gbl. s e t C o n s t r a i n t s (cmbtype, gbc ) ; getcontentpane ( ). add (cmbtype ) ; // Label gbc. gridwidth = 1 ; gbc. i n s e t s = new I n s e t s ( 0, 0, 0, 0 ) ; gbc. weightx = 1 ; label = new JLabel ( Beschreibung : ) ; gbl. s e t C o n s t r a i n t s ( label, gbc ) ; getcontentpane ( ). add ( label ) ; // TextArea f ü r d i e Beschreibung gbc. gridwidth = GridBagConstraints.REMAINDER; gbc. g r i d h e i g h t = 3 ; gbc. f i l l = GridBagConstraints.BOTH; gbc. weightx = 1 0 ;

2.1 Fenster und grafische Oberflächen 22 gbc. weighty = 1 0 ; gbc. i n s e t s = new I n s e t s ( 0, 5, 0, 5 ) ; JTextArea txtexpl = new JTextArea ( Beschreibung ) ; JScrollPane s c r o l l P a n e = new JScrollPane ( txtexpl ) ; s c r o l l P a n e. s e t V e r t i c a l S c r o l l B a r P o l i c y ( JScrollPane.VERTICAL SCROLLBAR ALWAYS) ; s c r o l l P a n e. s e t H o r i z o n t a l S c r o l l B a r P o l i c y ( JScrollPane.HORIZONTAL SCROLLBAR AS NEEDED) ; gbl. s e t C o n s t r a i n t s ( scrollpane, gbc ) ; getcontentpane ( ). add ( s c r o l l P a n e ) ; // Label gbc. gridwidth = 1 ; gbc. i n s e t s = new I n s e t s ( 0, 0, 0, 0 ) ; gbc. weightx = 1 ; gbc. weighty = 1 ; gbc. f i l l = GridBagConstraints.NONE; label = new JLabel ( P r e i s : ) ; gbl. s e t C o n s t r a i n t s ( label, gbc ) ; getcontentpane ( ). add ( label ) ; // T e x t f e l d f ü r den Preis gbc. gridwidth = GridBagConstraints.REMAINDER; gbc. f i l l = GridBagConstraints.HORIZONTAL; gbc. weightx = 3 ; gbc. i n s e t s = new I n s e t s ( 0, 5, 0, 5 ) ; JTextField t x t P r i c e = new JTextField ( 0,00 ) ; gbl. s e t C o n s t r a i n t s ( txtprice, gbc ) ; getcontentpane ( ). add ( t x t P r i c e ) ; // Buttons gbc. gridwidth = 1 ; gbc. i n s e t s = new I n s e t s ( 0, 0, 0, 0 ) ; gbc. weightx = 1 ; gbc. weighty = 1 ; gbc. f i l l = GridBagConstraints.NONE; JButton btnsend = new JButton ( Senden ) ; gbl. s e t C o n s t r a i n t s ( btnsend, gbc ) ; getcontentpane ( ). add ( btnsend ) ;

2.1 Fenster und grafische Oberflächen 23 JButton btncancel = new JButton ( Abbrechen ) ; gbl. s e t C o n s t r a i n t s ( btncancel, gbc ) ; getcontentpane ( ). add ( btncancel ) ; s e t S i z e ( 3 0 0, 4 0 0 ) ; s e t L o c a t i o n ( 5 0, 5 0 ) ; s e t V i s i b l e ( true ) ; public c l a s s FrameCreator08 { public static void main ( S t r i n g [ ] args ){ new GridBagLayoutFrame ( ) ; Die gesamte Prozedur wird für jedes Objekt, der grafischen Oberfläche durchgeführt. Es ist also möglich mit einem GridBagLayout wesentlich komplexere Oberflächen zu erstellen, als mit den vorher dargestellten Layouts. Aus diesem Grund ist das Layout jedoch etwas schwieriger zugänglich. Einen Screenshot von der Oberfläche, welche von dem obigen Quellcode erzeugt wird zeigt die Abbildung 2.8. Abbildung 2.8. Mit einem GridBagLayout kann man komplexere grafische Oberflächen erstellen.

2.1 Fenster und grafische Oberflächen 24 CardLayout Das folgende CardLayout ist das einzige Layout in Java, welches mit dem Benutzer der grafischen Oberfläche interagiert. Man kann sich das System dahinter so vorstellen, dass verschiedene Container, beispielsweise ein JPanel, Karten eines Kartenspiels darstellen. Nimmt man nun die erste Karte vom Stapel kann man die zweite sehen usw.. Dies gibt dem Benutzer die Möglichkeit die verschiedenen JPanels durchzublättern. Das Layout an sich ist relativ einfach zu implementieren. Es wird ganz normal an die Methode setlayout(layout) übergeben, sollte jedoch vorher in einer Variablen gespeichert werden, so dass man später noch Zugriff darauf hat, um die Benutzerinteraktionen durchzuführen. Danach können dann über add(object,string) die Containerklassen oder beliebige grafische Objekte zu dem Container, welcher das CardLayout verwendet, übergeben werden. Dabei kann über den Stringparameter jedem Objekt ein Name zugewiesen werden, über welchen man das Objekt später direkt anzeigen lassen kann. Die Objekte werden dann hintereinander dargestellt und können nun über die folgenden Funktionen durchgeblättert werden. next(container) - Zeigt das nächste Element an previous(container) - Zeigt das vorherige Element an first(container) - Zeigt das erste Element an last(container) - Zeigt das letzte Element an show(container, String) - Zeigt ein bestimmtes Element direkt an Der folgende Quellcode zeigt wie man relativ einfach, solch ein CardLayout verwenden kann. import java. awt. BorderLayout ; import java. awt. CardLayout ; import java. awt. FlowLayout ; import java. awt. event. ActionEvent ; import java. awt. event. A c t i o n L i s t e n e r ; import javax. swing. JButton ; import javax. swing. JFrame ; import javax. swing. JPanel ; import javax. swing. JTextArea ; / Hinzufügen von JPanels und JLabels und verwenden e i n e s CardLayouts / class CardFrame extends JFrame implements A c t i o n L i s t e n e r { private JButton btnprev ; private JButton btnnext ; private JButton b t n F i r s t ; private JButton btnlast ;

2.1 Fenster und grafische Oberflächen 25 private JButton btn5 ; private CardLayout cardlayout ; Es ist wichtig, dass das CardLayout, wie hier gezeigt, für die gesamte Klasse verfügbar ist, da in der Methode actionperformed(actionevent) später nochmal darauf zugegriffen werden muss. private JPanel pnlmain ; public CardFrame (){ s e t T i t l e ( CardLayout ) ; s e tdefaultcloseoperation ( JFrame. EXIT ON CLOSE ) ; // E i n s t e l l e n e i n e s BorderLayouts getcontentpane ( ). setlayout ( new BorderLayout ( ) ) ; // Einfügen von ButtonPanel und ShowPanel JPanel pnlbutton = new JPanel ( ) ; pnlmain = new JPanel ( ) ; getcontentpane ( ). add ( pnlbutton, BorderLayout.SOUTH) ; getcontentpane ( ). add ( pnlmain, BorderLayout.CENTER) ; / E i n s t e l l e n der Layouts von pnlbutton und pnlmain / pnlbutton. setlayout (new FlowLayout ( ) ) ; cardlayout = new CardLayout ( ) ; pnlmain. setlayout ( cardlayout ) ; Hier wird für das JPanel pnlmain das CardLayout eingerichtet. Es handelt sich dabei um das JPanel, welches die Textfelder anzeigt. Das CardLayout wird dabei in die globale Variable cardlayout geschrieben, um später noch darauf zugreifen zu können. // Hinzufügen der Objekte zu den Panels btnprev = new JButton ( < ) ;

2.1 Fenster und grafische Oberflächen 26 btnnext = new JButton ( > ) ; b t n F i r s t = new JButton ( S t a r t ) ; btnlast = new JButton ( Ende ) ; btn5 = new JButton ( Mitte ) ; pnlbutton. add ( btnprev ) ; pnlbutton. add ( btnnext ) ; pnlbutton. add ( b t n F i r s t ) ; pnlbutton. add ( btnlast ) ; pnlbutton. add ( btn5 ) ; btnprev. addactionlistener ( this ) ; btnnext. addactionlistener ( this ) ; b t n F i r s t. addactionlistener ( this ) ; btnlast. addactionlistener ( this ) ; btn5. addactionlistener ( this ) ; for ( int i =0; i <10; i ++){ pnlmain. add (new JTextArea ( Karte + i ), + i ) ; Hier werden die einzelnen JButtons erzeugt, mit welchen man die JPanels durchblättern kann. Ihnen werden ActionListener hinzugefügt. ActionListener werden zur Interaktion mit grafischen Elementen benötigt und werden im Abschnitt 2.1.4 näher erläutert. Des Weiteren werden JTextAreas erzeugt, welche in das pnlmain hinzugefügt werden. Diese Stellen später die einzelnen Seiten unseres CardLayouts dar. s e t S i z e ( 4 0 0, 5 0 0 ) ; s e t L o c a t i o n ( 5 0, 5 0 ) ; s e t V i s i b l e ( true ) ; public void actionperformed ( ActionEvent evt ){ i f ( evt. getsource ( ). e q u als ( btnnext )){ cardlayout. next ( pnlmain ) ; else i f ( evt. getsource ( ). e q u als ( btnprev )){ cardlayout. p revious ( pnlmain ) ; else i f ( evt. getsource ( ). e q u als ( b t n F i r s t )){ cardlayout. f i r s t ( pnlmain ) ; else i f ( evt. getsource ( ). e q u als ( btnlast )){ cardlayout. l a s t ( pnlmain ) ; else { cardlayout. show ( pnlmain, 5 ) ;

2.1 Fenster und grafische Oberflächen 27 public c l a s s FrameCreator09 { public static void main ( S t r i n g [ ] args ){ new CardFrame ( ) ; In der Methode actionperformed(actionevent) werden Benutzereingaben abgefangen und ausgewertet. Hier wird festgelegt, dass beispielsweise ein Klick auf den JButton btnnext die nächste Karte des CardLayouts anzeigt. Wie die Oberfläche aussieht, wenn man den Quellcode ausführt zeigt die Abbildung 2.9. Abbildung 2.9. Das CardLayout ist das einzige Layout in Java, welches Interaktionen des Benutzers zulässt. Weitere Informationen zu den hier erläuterten Layouts können in A Visual Guide to Layout Managers ([Javb]) von Sun nachgeschlagen werden.