JAVA 3D – Seminar Wintersemester 2002/2003 Christian Schneider

AWT – Detailbetrachtung Das Abstract Window Toolkit

Fachhochschule Fulda – University of Applied Sciences Fachbereich Angewandte Informatik Marquardstraße 35, 36039 Fulda Postfach 2254, 36012 Fulda

Inhalt 0

EINLEITUNG ................................................................................................................................... 1

1

EINFÜHRUNG INS AWT ................................................................................................................ 2

2

1.1

Was ist das AWT? ................................................................................................................... 2

1.2

Plattformunabhängigkeit.......................................................................................................... 2

1.3

Komponenten – Die Grundlage des AWT ............................................................................... 3

1.4

Klassendiagramme des AWT .................................................................................................. 4

DIE BAUSTEINE DER GRAFISCHEN BENUTZEROBERFLÄCHE DES AWT IM DETAIL ........ 6 2.1

2.1.1

Knöpfe (Button) ............................................................................................................. 7

2.1.2

Schalter (Checkbox)....................................................................................................... 8

2.1.3

Auswahlfelder (Choice)................................................................................................ 10

2.1.4

Listenfelder (List) ........................................................................................................ 11

2.1.5

Menüs (Menu, MenuItem etc.) .................................................................................. 12

2.1.6

Textmarken (Label) ..................................................................................................... 13

2.1.7

Textfelder (TextField)................................................................................................ 14

2.2

3

4

Die Basis-Bausteine ................................................................................................................ 6

Weitere Bausteine, um Benutzereingaben zu ermöglichen .................................................. 15

2.2.1

Textbereiche (TextArea) ............................................................................................. 15

2.2.2

Bildlaufleisten und Schiebebalken (Scrollbar).......................................................... 16

2.3

Containers: Windows, Panels und Scroll Panes ................................................................... 18

2.4

Canvas................................................................................................................................... 18

DAS EVENT-MODELL DES AWT ................................................................................................ 20 3.1

Event-Lauscher definieren..................................................................................................... 21

3.2

Lauscher für Quelle registrieren ............................................................................................ 22

3.3

Adapter .................................................................................................................................. 22

3.4

Eventverarbeitung durch Listener und Adapter..................................................................... 23

3.5

Ein einfaches Beispiel für Eventbehandlung ......................................................................... 24

GRAFIKAUSGABE....................................................................................................................... 25 4.1

Graphics-Klasse .................................................................................................................... 25

4.2

Methoden allgemein .............................................................................................................. 25

4.3

Zeichengebiete ...................................................................................................................... 26

4.3.1

Koordinatensystem........................................................................................................ 26

4.3.2

Clipping.......................................................................................................................... 26

4.4

Farbe ..................................................................................................................................... 27

4.5

Grafikfiguren .......................................................................................................................... 27

4.6

Übersicht über die Methoden der Graphics-Klasse............................................................... 28

5

LITERATUR- UND QUELLENANGABE ...................................................................................... 29

6

ANHANG ....................................................................................................................................... 29

Christian Schneider

AWT - Detailbetrachtung 0

Einleitung

Diese Arbeit entstand im Rahmen der Lehrveranstaltung „Java3D – Seminar“ bei Prof. Dr. Heinzel. Ziel der Ausarbeitung ist es, dem Teilnehmer der Veranstaltung eine Übersicht über die verschiedenen Möglichkeiten des AWT-Packages zu geben. AWT (Abstrakt Window Toolkit) ist die Grundlage aller Grafikanwendungen in Java, so dass der Programmierer dieses Package auf jeden Fall kennen sollte. Diese Einführung stellt nicht den Anspruch der absoluten Vollständigkeit, da es im zur Verfügung stehenden Zeitrahmen unmöglich wäre, alle Aspekte des AWT zu behandeln. Die folgende Ausarbeitung dient als Leitfaden durch die große Welt des AWT von Java. Es sei auch auf Fachliteratur verwiesen (s. Absatz 5. Literatur- und Quellenangabe).

Christian Schneider

1

AWT - Detailbetrachtung 1

Einführung ins AWT

1.1

Was ist das AWT?

Zur Entwicklung von Applets und grafischen Applikationen in Java™ benötigt man zu einem gewissen Grad das Abstract Window Toolkit, im Nachfolgenden AWT genannt. Es ist ein Teil des frei verfügbaren Java 2 SDK, des Java 2 Software Development Kits. Auch in den früheren Versionen der Java-Entwicklungsumgebungen, dem JDK (Java Development Kit) war das AWT bereits vorhanden. In den folgenden Ausführungen werden die alten JDK-1.0Standards nicht mehr berücksichtigt. Das AWT beinhaltet verschiedene Klassen, welche alle mit java.awt beginnen. Mit ihnen werden dem Programmierer hunderte von Klassen und Methoden zur Verfügung gestellt, aus denen er sich, einem Baukasten ähnlich, die gewünschte Oberfläche und Funktion holen kann. Es ist also nicht schwer, in einer Applikation oder einem Applet eine grafische Benutzeroberfläche zu nutzen, man muss „nur“ die richtige Klasse zur Hand nehmen und sie nach seinen Wünschen (um-)gestalten. 1.2

Plattformunabhängigkeit

Das AWT ist eine der wichtigsten Klassenbibliotheken von Java, wenn nicht sogar die wichtigste. Es ist plattformunabhängig und stellt das GUI auf jeder Plattform etwas anders dar. Was ist das GUI? Unter GUI (Graphical User Interface) versteht man die grafische Benutzerschnittstelle einer Anwendung (Applikation oder Applet). Das AWT stellt eine GUI-Bibliothek dar und „vermittelt“ quasi zwischen dem Java-Programm und dem GUI des Betriebssystems. Das AWT wurde von Anfang an so entworfen, dass es ein plattformunabhängiges API (engl. application programming interface) haben und dennoch der Applikation das jeweilige betriebssystemspezifische Aussehen geben sollte. Zum Beispiel hat das AWT nur ein API für Knöpfe (in der Button-Klasse), aber es sieht auf einem Macintosh anders aus als auf einem PC, auf dem z.B. Windows XP läuft. Das AWT nutzt die Standardsteuerelemente der jeweiligen Plattform, was zur Folge hat, dass sich die Funktionalität der AWT-Komponenten an diesen Standardsteuerelementen orientiert. Für jedes Standardsteuerelement des Betriebssystems gibt es im AWT eine eigene Klasse. Die AWT-Komponenten setzten als so genannte „heavyweight“-Komponenten auf den betriebssystemspezifischen Implementierungen (auch „peers“ (auf deutsch „Gleiche“) genannt) auf.

Java

Java

Native GUI

Programm

AWT

(WinXP, etc.)

Christian Schneider

Display

2

AWT - Detailbetrachtung 1.3

Komponenten – Die Grundlage des AWT

Ein Programm, das auf Fenster basiert, wird vom AWT als eine Hierarchie von ineinander verschachtelten Bausteinen angesehen, den so genannten Komponenten. Für jede Komponente gibt es im AWT eine eigene Klasse, von der der Programmierer entweder direkt eine Instanz bilden oder eigene Klassen ableiten kann. Man kann folgende wichtigen Gruppen von Klassen unterscheiden, je nach dem, welche Aufgabe den einzelnen Bausteinen beim Aufbau der grafischen Benutzeroberfläche zukommt: •

Component: Das AWT ist eine Welt von Komponenten. Die java.awt.ComponentKlasse ist eine abstrakte Klasse für Komponenten wie Buttons, Labels, Lists usw. Die meisten Klassen im AWT sind Unterklassen der java.awt.Component-Klase. Auf ihr baut das AWT auf. Siehe Klassendiagramm unter 1.4.

•

Container ist eine abstrakte Klasse, die von Component erbt. Container sind Bausteine, die mehrere andere Komponenten enthalten (engl. contain) können. In ihnen werden die Oberflächenelemente gruppiert und die Oberfläche wird so strukturiert. Die wichtigsten Unterklassen von Container sind Panel, Applet, Window, Dialog und Frame.

•

LayoutManager ist ein Interface, das Methoden zur Positionierung und Größeneinteilung von Objekten innerhalb eines Containers definiert. Java™ definiert mehrere Standard-Layout-Manager. (Hierzu gibt es im Rahmen der Veranstaltung einen gesonderten Beitrag.)

•

Die Klasse Graphics ist die abstrakte Oberklasse aller Grafikkontexte, die Anwendungen ermöglichen, auf Komponenten usw. zu zeichnen.

•

Eine Komponente der Klasse Canvas (dt. Zeichenfläche) ist ein spezieller Baustein, der zum Malen und zur Anzeige von Bildern und Grafiken verwendet wird.

Christian Schneider

3

AWT - Detailbetrachtung 1.4

Klassendiagramme des AWT

Abbildung 1-1 Klassendiagramm - java.awt

Christian Schneider

4

AWT - Detailbetrachtung

Abbildung 1-2 Klassendiagramm - java.awt-components

Wie in dem Klassendiagramm

(aus Java™ API, Band 2, der offiziellen Dokumentation von JavaSoft)

zu sehen

ist, erben die meisten Komponenten der grafischen Benutzeroberfläche von der AWT Component-Klasse, mit Ausnahme der Menü-Komponenten. Aufgrund von Plattform übergreifenden Einschränkungen (z.B. die fehlende Möglichkeit, die Menü-Hintergrund-Farbe zu setzen) erben die Menü-Komponenten von der AWT-Klasse MenuComponent. Christian Schneider

5

AWT - Detailbetrachtung 2

Die Bausteine der grafischen Benutzeroberfläche des AWT im Detail

2.1

Die Basis-Bausteine

Die Klassen (besser gesagt die Instanzen/Objekte der Klassen) Button, Checkbox, Choice, List, MenuItem und TextField stellen „klassische“ Kontrollmittel dar. Sie sind die am meisten genutzten Arten, einem Java-Programm Instruktionen zu geben. Wenn ein Benutzer einen dieser Bausteine aktiviert – z.B. durch Klicken eines Knopfes oder durch Drücken der Eingabetaste in einem Textfeld – dann erzeugt er ein sog. ActionEvent. Damit können mittels des entsprechenden Event-Listeners Befehle ausgeführt werden. Das Event-Modell von AWT wird später in Abschnitt 3 betrachtet. Das Label stellt eine Ausnahme dar. Es stellt lediglich eine nicht auswählbare Textzeile dar.

Abbildung 2-1 Überblick über alle wichtigen AWT-Komponenten

Christian Schneider

6

AWT - Detailbetrachtung 2.1.1

Knöpfe (Button)

public class java.awt.Button extends java.awt.Component { // Konstruktoren public Button(); public Button(String label); // Methoden public void addNotify(); public String getLabel();

// Die Button-Klasse

// erzeugt Knopf unbeschriftet // erzeugt Knopf mit Beschriftung

// hier nicht betrachtet /* Rückgabe der Beschriftung oder null, wenn kein Label vorh.*/ protected String paramString(); /* Rückgabe des Zustands des Knopfes als Zeichenkette */ public void setLabel(String label);

} Diese Klasse erzeugt eine beschriftete Schaltfläche (engl. labeled button), auch kurz Knopf genannt. Die Anwendung kann reagieren, wenn auf die Schaltfläche gedrückt wird. Nachfolgend sehen wir drei verschiedene Ansichten eines „Abbrechen“-Knopfes unter Windows:

Abbildung 2-2 Knopfzustände

Das erste Bild zeigt den Knopf im Normalzustand. In der zweiten Ansicht hat der Knopf den Eingabefokus, d.h. der dunkle Rand zeigt dem Benutzer, dass der Knopf aktiv ist. Und im dritten Fall wird gerade vom Benutzer auf den Knopf per Maus geklickt. So werden die damit verbundenen Aktionen ausgelöst. Wird ein Knopf gedrückt und danach wieder losgelassen, so sendet das AWT ein entsprechendes Ereignis (Event) an das Knopfobjekt1. Das EventHandling wird in Abschnitt 3 noch eingehender betrachtet. Im Folgenden ist das Bild eines (einfachen) Applets zu sehen, das drei Knöpfe zeigt.

Abbildung 2-3 ButtonDemo – Applet

//In der Initialisierung des Applets steht folgendes: public void init() { b1 = new Button(); b1.setLabel("Mittleren Knopf deaktivieren"); b2 = new Button("Mittleren Knopf"); b3 = new Button("Mittleren Knopf aktivieren"); b3.disable(); . . . 1 In Java 1.1 sendet das AWT alle Maus-, Tastatur und Fokusereignisse, die über dem Knopf auftreten. In Java 1.0 sendet das AWT keine Maus- oder Fokusereignisse.

Christian Schneider

7

AWT - Detailbetrachtung Hier kann man gut sehen, wie ein Knopf angelegt wird. In der init()-Funktion des Applets, d.h. bei seiner Initialisierung, werden drei Instanzen der Klasse Button angelegt, nämlich b1, b2 und b3. Der Knopf b1 wird mittels des einfachen Konstruktors instanziiert, ohne ihm eine Beschriftung zu verpassen. Dies wird mit b1.setLabel("Mittleren

Knopf

deaktivieren"); nachgeholt. Den Knöpfen b2 und b3 werden mittels des Konstruktors Beschriftungen übergeben. „b3.disable();“ bedeutet, wie oben leicht zu sehen, dass der dritte Knopf zu Beginn des Applets deaktiviert wird, d.h. nicht der Benutzer kann ihn nicht anklicken. Nun müssen die Knöpfe nur noch dem Applet, welches ja auch einen Container darstellt, hinzugefügt werden. . . . // und hier werden die Knöpfe dem Applet (Container) hinzugefügt. add(b1); add(b2); add(b3);

}

2.1.2

Schalter (Checkbox)

Die Klasse Checkbox stellt Checkboxen oder auch Schalter zur Verfügung, die zwei Zustände annehmen können, entweder „ein“ oder „aus“. Diese Zustände werden durch eine boolsche Variable beschrieben (z.B.: boolean state). Ist der Schalter aktiviert, so sein Status „true“. Das folgende Bild zeigt ein (einfaches) Applet, das die Funktionsweise von Schaltern demonstriert:

Abbildung 2-4 Checkbox-Demo

Wie leicht auf dem Bild zu sehen ist, gibt es zwei „Arten“ von Schaltern. Auf der linken Seite sind voneinander unabhängige Schalter zu sehen, die alle entweder „ein“ oder „aus“ sein können. Die Schalter auf der rechten Seite sind in einer sog. CheckboxGroup angeordnet, also einer Gruppierung von Schaltern. Wenn Schalter zu einer Schaltergruppe gehören, kann immer nur einer dieser Schalter „ein“ (true) sein. Die Schaltergruppe CheckboxGroup ist eine selbständige Klasse.

Christian Schneider

8

AWT - Detailbetrachtung Der folgende Code-Ausschnitt zeigt, wie in das Applet in Abbildung 2-4 die Schalter hinzugefügt werden: . . . Panel p1, p2; //Diesen Panels werden die Schalter hinzugefügt. Checkbox cb1, cb2, cb3; //Dies sind die unabhängigen Schalter. Checkbox cb4, cb5, cb6; //Diese Schalter gehören zu der Gruppe. CheckboxGroup cbg; //Checkboxgruppe cbg wird deklariert. cb1 = new Checkbox(); //Konstruktor. Default Status ist "aus" (false). cb1.setLabel("Checkbox 1"); //Schalter wird beschriftet. cb2 = new Checkbox("Checkbox 2"); //In der Klammer steht die Beschriftung. cb3 = new Checkbox("Checkbox 3"); cb3.setState(true); //Den Schalter auf “an” schalten (true). . . . cbg = new CheckboxGroup(); cb4 = new Checkbox("Checkbox 4", cbg, false); //Status: “aus” (false) cb5 = new Checkbox("Checkbox 5", cbg, false); // Status: “aus” cb6 = new Checkbox("Checkbox 6", cbg, true); // Status: “ein” (true) . . . /* cb4, cb5 und cb6 werden im Konstruktor bereits der CheckboxGroup cbg hinzugefügt.*/ p1 = new Panel(); p1.setLayout(new FlowLayout()); p1.add(cb1); // Schalter zu Panel 1 hinzufügen p1.add(cb2); // Schalter zu Panel 1 hinzufügen p1.add(cb3); // Schalter zu Panel 1 hinzufügen // usw...

Für Checkboxen gibt es auch interessante Methoden, z.B. liefert public

boolean

getState() den Wert des Schalters, also seinen Zustand zurück. Angewendet auf den dritten Schalter (auf dem Bild unten links), würde cb3.getState() den Wert „true“ zurückgeben. Mit der Methode void setState(boolean state) kann man einem Schalter einen Zustand zuweisen, z.B. mit cb1.setState(true) würde man den Schalter links oben aktivieren. Mit setLabel(String s) kann man dem Schalter eine neue Beschriftung verpassen. Dann wird die Beschriftung mit dem Wert des Labels (Parameter in der Klammer der Methode) mit dem neuen String überschrieben. Mit getCheckboxGroup() erhält man als Rückgabewert die CheckboxGroup, in der sich der aufrufende Schalter befindet oder null, wenn er keiner Gruppe angehört. Mit setCheckboxGroup(CheckboxGroup g) kann man den Schalter in eine Gruppe hinzufügen, indem man ihn in dem Argument in der Klammer der Methode die entsprechende CheckboxGroup übergibt. Befindet er sich bereits in einer Gruppe, wird er aus dieser entfernt. Die CheckboxGroup überwacht den Status der in ihr enthaltenen Schalter.

Christian Schneider

9

AWT - Detailbetrachtung 2.1.3

Auswahlfelder (Choice)

Die Klasse Choice bietet ein aufblendbares Menü, das dem Benutzer Auswahlmöglichkeiten zur Verfügung stellt. Daher heißt die Klasse Choice oder Auswahlmenü (engl. choice menu). Die aktuelle Auswahl wird als Titel des Menüs angezeigt. Auswahlmenüs sind nützlich, um eine (große) Anzahl von Alternativen mit begrenztem Platz darzustellen, für den Fall, dass der Nutzer nicht alle Möglichkeiten gleichzeitig sehen muss. Ein anderer Name für Choices sind Pop-Up-Listen. Im Folgenden wird ein Beispiel eines (einfachen) Applets behandelt, das wie folgt aussieht, das volle Beispiel ist im Anhang enthalten.

Abbildung 2-5 ChoiceDemo

//...Hier werden Instanzen der Variablen definiert: Choice choice; //pop-up list of choices //...Hier wird initialisiert: choice = new Choice(); //neue Auswahl choice.addItem("ichi"); //neues Auswahlelement “ichi”, index = 0!!! choice.addItem("ni"); //neues Auswahlelement “ni” choice.addItem("san"); //neues Auswahlelement “san” choice.addItem("yon"); //neues Auswahlelement “yon” label = new Label(); //Text neben der Auswahl setLabelText(choice.getSelectedIndex(), choice.getSelectedItem()); //. . . usw...

Es gibt noch weitere nützliche Methoden, die von der Klasse bereitgestellt werden: int countItems() String getItem(int) void select(int) void select(String)

Christian Schneider

Æ gibt die Anzahl der Elemente in der Auswahl zurück Æ gibt den String zurück, der an Position (int) der Auswahl steht !!!Zu beachten: Die Nr. des ersten Elements der Liste ist 0!!! Æ wählt das Element aus, das an Position (int) der Auswahl steht Æ wählt das Element aus, das den spezifizierten String anzeigt

10

AWT - Detailbetrachtung 2.1.4

Listenfelder (List)

Die Komponente List stellt sich dem Anwender als eine verschiebbare Liste (engl. scrolling list) von Texteinträgen (engl. text items) dar. Die Liste kann so konfiguriert werden, dass der Benutzer nur einen oder mehrere Einträge auswählen kann. Das Anklicken eines noch nicht gewählten Eintrages wählt ihn aus (engl. select) Das Anklicken eines bereits ausgewählten Eintrages nimmt die Auswahl wieder zurück (engl. deselect). Ist bei der Erzeugung der Liste mittels des Konstruktors public List(int rows, boolean multipleSelections); das zweite Argument false, so kann maximal ein Eintrag der Liste ausgewählt werden. z.B.: List l = new List(4, false); //4 Eintr. sichtbar, ein Element auswählbar.

Wird ein Element der Liste ausgewählt, so sendet das AWT der Liste ein LIST_SELECTEreignis. Gilt das Element als nicht ausgewählt, dann sendet das AWT der verschiebbaren Liste ein LIST_DESELECT-Ereignis. Wird ein Doppelklick auf dem Element ausgeführt (oder die Returntaste gedrückt), schickt das AWT dem LIST_SELECT- oder LIST_DESELECTEreignis ein ACTION_EVENT hinterher. Mit entsprechenden ActionListener und ItemListener können dann Events auf der Liste abgefangen werden und Anweisungen aufgerufen werden. List spanish = new List(4, true); spanish.addItem("uno"); spanish.addItem("dos"); spanish.addItem("tres"); spanish.addItem("cuatro"); spanish.addItem("cinco"); //usw. Abbildung 2-6 ListDemo

Außer addItem(String item) (s.o.) gibt es noch weitere wichtige Methoden: public String getItem(int index) int countItems() void addItem(String, int) void replaceItem(String, int) void clear() void delItem(int) void delItems(int, int)

Æ gibt den String der Liste an der angegebenen Position zurück Æ gibt die Anzahl der Elemente in der Liste zurück Æ fügt einen String an der angegebenen Position ein (index) Æ ersetzt den Eintrag an der angegebenen Position ein (index) Æ leert die Liste Æ löscht den Eintrag an der angegebenenPosition Æ löscht Einträge zwischen den angegebenen Positionen (inklusiv der „Ränder“) int getSelectedIndex() Æ gibt den Index des ausgewählten Elements zurück, -1, wenn nichts gewählt ist. int[] getSelectedIndexes() Æ gibt den Index der ausgewählten Elemente zurück String getSelectedItem() Æ wie getSelectedIndex(), liefert nur den String des Items String[] getSelectedItems() Æ vgl. getSelectedIndexes() void select(int), Æ Selektiert oder deselektiert das Element an der angegebenen void deselect(int) Position boolean isSelected(int) Æ liefert “true”, wenn das angegebene Item ausgewählt ist. int getRows() Æ liefert Anzahl der sichtbaren Zeilen boolean allowsMultipleSelections() Æ liefert “true”, wenn mehrfache Auswahl möglich ist boolean setMultipleSelections(true) Æ ermöglicht mehrfache Auswahl (bei true, bei false nicht) void makeVisible(int) Æ zwingt angegeben Eintrag, sichtbar zu sein int getVisibleIndex() Æ liefert Pos. des Eintrags, der zuletzt durch makeVisible() sichtbar gemacht wurde

Christian Schneider

11

AWT - Detailbetrachtung 2.1.5

Menüs (Menu, MenuItem etc.)

Menüs sind mit Auswahlfelder (Choice) vergleichbar, jedoch sind sie wesentlich umfassender. Im Gegensatz zu den bisher erklärten Komponenten erben Menüs ihre Funktionalität nicht von der Klasse Component, sondern von MenuComponent, weil einige Plattformen Menüs schwerwiegende Einschränkungen auferlegen. Im AWT stehen folgende Subklassen von MenuComponent zur Realisierung von Menüs zur Verfügung: •

MenuItem zur Darstellung eines Menüeintrags

•

CheckboxMenuItem, denen eine Checkbox zugeordnet ist. So kann ein solches Menüelement ähnlich einer Checkbox ausgewählt werden. CheckboxMenuItem ist eine Subklasse von MenuItem.

•

Menu repräsentiert ein vollständiges Menü-Objekt und ist eine Subklasse der Klasse MenuItem, so dass Submenüs leicht erzeugt werden können, indem ein Menü einfach einem anderen hinzugefügt wird.

•

MenuBar repräsentiert die Zuweisung einer Gruppe von Menüs an ein Fenster.

Für jede Menükomponente können Events abgefangen werden, es kann auf Klicks entsprechend reagiert werden. Dieses Event-Handling wird hier nicht weiter beachtet. EventHandling siehe Abschnitt 3 (Das Event-Modell des AWT). Im Folgenden wird ein Beispielprogramm wird die Verwendung eines Menüs demonstriert:

Menu

MenuBar

MenuItem

Abbildung 2-7 Menü Demo

public class Menus extends Frame {// eigene Klasse Menus von Frame ableiten public Menus(String s) { // String s für Fenster Titel super(s); //Aufruf des Konstruktors der Oberklasse (für Titel) MenuBar mb; // Deklaration einer Menüleiste Menu m1, m2; // Deklaration der Menüs m1 und m2 MenuItem m1_1, m1_2,m2_1, m2_2; // Deklaration der Menükomponenten mb = new MenuBar();// Instanziierung der Menüleiste mb Christian Schneider

12

AWT - Detailbetrachtung setMenuBar(mb); // Aktivierung der Menüleiste im Fenster m1 = new Menu("Menü 1"); // Instanziierung des Menüs m1 mb.add(m1); // Hinzufügen des 1. Menüs zur Menüleiste m1_1 = new MenuItem("Menüeintrag 1_1"); // Instanziierung der Menükomponente m1_1 m1.add(m1_1); // Hinzufügen von m1_1 zum Menü 1 m1_2 = new MenuItem("Menüeintrag 1_2"); // usw. wie oben m1.add(m1_2); m2 = new Menu("Menü 2"); mb.add(m2); m2_1 = new MenuItem("Menüeintrag 2_1"); m2.add(m2_1); m2_2 = new MenuItem("Menüeintrag 2_2"); m2.add(m2_2); } ...

2.1.6

Textmarken (Label)

Eine Textmarke (engl. label) ist eine Komponente, die einen Text in einem (beliebigen) Container platziert. Der Text kann von der Anwendung verändert werden, der Benutzer kann ihn jedoch nicht direkt editieren. Das Layout der Textmarke wird automatisch gesetzt. Zur Definition eines Labels können folgende Konstruktoren verwendet werden: •

Label() erzeugt eine leere Textmarke, in der der Text linksbündig angeordnet wird.

•

Label(String) erzeugt eine Textmarke mit dem als Parameter übergebenen Text. Der Text wird ebenfalls linksbündig dargestellt.

•

Label(String, int) erzeugt die gleiche Ausgabe wie Label(String), nur legt der zweite Parameter die Ausrichtung des Textes innerhalb der Textmarke fest. Hierzu

können

die

Integer-Konstanten

(aus

der

Klasse

Label)

Label.LEFT,

Label.CENTER und Label.RIGHT verwendet werden.

Abbildung 2-8 Label Beispiel

Das folgende Applet stellt ein Beispiel für die Verwendung von Textmarken dar, wie sie in Abbildung 2-8 zu sehen ist: import java.awt.*; import java.applet.*; public class Textmarke extends Applet { Label links = new Label("Label 1", Label.LEFT); // neue Textmarke Label zentriert = new Label("Label 2", Label.CENTER); // neue Textmarke Label rechts = new Label("Label 3", Label.RIGHT); // neue Textmarke Font f = new Font("Times", Font.BOLD, 20); public void init() { setFont(f); // Einstellen der Schriftart Times, Fett, Größe 20 add(links); // 1. Textmarke hinzufügen add(zentriert); // 2. Textmarke hinzufügen Christian Schneider

13

AWT - Detailbetrachtung

}

}

2.1.7

add(rechts);

// 3. Textmarke hinzufügen

Textfelder (TextField)

Im Gegensatz zu Textmarken (s. 2.1.6) sind Textfelder vom Benutzer editierbar. Hierzu stellt Java die Klasse TextField zur Verfügung, deren Instanzen mit den folgenden Konstruktoren angelegt werden können: •

TextField() erzeugt ein leeres Texteingabefeld ohne Größenangabe.

•

TextField(String) erzeugt ein Texteingabefeld, das mit dem als Parameter übergebenen Text gefüllt wird. Es erfolgt ebenfalls keine Größenangabe.

•

TextField(String, int) erzeugt ein Textfeld, wobei der Integer-Parameter die Breite des Feldes in der Anzahl der möglichen Buchstaben angibt. Es kann hier auch ein leerer String als String-Parameter übergeben werden.

Die Klasse TextField stellt einige Methoden zur Verfügung, mit denen man die Textfelder kontrollieren kann: •

getText() gibt den im Textfeld enthaltenen Text zurück,

•

setText(String) setzt diesen Text entsprechend,

•

isEditable() gibt einen booleschen Wert zurück, der angibt, ob das Textfeld editierbar ist (true) oder nicht (false),

•

setEditable(boolean) erlaubt (true) oder erlaubt nicht (false) das Editieren des Feldes.

•

setEchoChar(Char) ersetzt den eingegebenen Text durch das Zeichen Char.

Abbildung 2-9 Textfeld-Demo

Der folgende Code erzeugt ein Applet, das Textfelder demonstriert. Die Ausgabe ist in Abbildung 2-9 zu sehen.

Christian Schneider

14

AWT - Detailbetrachtung import java.awt.*; import java.applet.*; public class Textfeld extends Applet { Label benutzerLabel = new Label("Benutzername"); TextField benutzerFeld = new TextField(50);

// Textfeld Demo // Beschriftung // Textfeld erzeugen

Label passwortLabel = new Label("Passwort"); TextField passwortFeld = new TextField(50);

// Beschriftung // Textfeld erzeugen

public void init() { add(benutzerLabel); add(benutzerFeld); add(passwortLabel); passwortFeld.setEchoChar('$'); add(passwortFeld); }

hinzufügen hinzufügen hinzufügen als $ darstellen hinzufügen

// // // // //

Komponenten Komponenten Komponenten Textausgabe Komponenten

}

2.2

Weitere Bausteine, um Benutzereingaben zu ermöglichen

Sollten die unter 2.1 genannten Bausteine nicht geeignet oder ausreichend sein, kann man auch noch die Klassen Scrollbar (engl. für Bildlaufleiste) und TextArea (engl. für Textflächen) nutzen. Die Scrollbar-Klasse kann sowohl als Bildlaufleiste als auch als Schiebebalken (zum Regeln z.B.) genutzt werden. Bildlaufleisten sind automatisch integriert in Listen und Textflächen sowie in sog. Scrollfeldern (ScrollPane, s. 2.3). 2.2.1

Textbereiche (TextArea)

Mittels der Klasse TextArea können mehrzeilige Textbereiche erzeugt werden, die größere Textmengen aufnehmen können als Textfelder. In einem Textbereich stehen horizontale und vertikale Schiebebalken zur Verfügung, mit denen man den gewünschten Anzeigebereich sichtbar machen kann. Folgende Konstruktoren dienen zur Erzeugung von Textbereichen: •

TextArea() erzeugt einen leeren Textbereich ohne Angabe der Höhe und Breite.

•

TextArea() erzeugt einen Textbereich mit Angabe der Höhe und Breite. Der erste Parameter gibt die Anzahl der Zeilen und der zweite die Anzahl der Zeichen pro Zeile an.

•

TextArea(String) erzeugt einen Textbereich mit einem festgelegtem Text (String), aber ohne Angabe der Höhe und Breite.

•

TextArea(String, int, int) erzeugt den gleichen Textbereich wie TextArea(String) nur mit Größenangabe.

Die Klasse TextArea stellt einige Methoden zur Verfügung, mit denen man die Textbereiche kontrollieren kann:

Christian Schneider

15

AWT - Detailbetrachtung •

getText(), setText(String), isEditable() und setEditable(boolean) analog zu Textfeldern (2.1.7)

•

insert(String, int) fügt den Text, der durch den ersten Parameter angegeben wird, an der Indexposition in das Feld ein, die durch den zweiten Parameter angegeben wird (gemessen in Zeichen).

•

replace(String, int, int) ersetzt den Text zwischen den Positionen, die durch den zweiten und dritten Parameter bestimmt werden, durch den als erstes Argument übergebenen String.

Das folgende Beispiel zeigt die Handhabung eines Textbereichs:

Abbildung 2-10 Textbereich Demo

import java.awt.*; import java.applet.*; public class Textbereich extends Applet { // Textbereich Demo String inhalt = "Mittels der Klasse TextArea können mehrzeilige " +"Textbereiche erzeugt werden,\ndie größere Textmengen aufnehmen können " +"als Textfelder.\nIn einem Textbereich stehen horizontale und vertikale " +"Schiebebalken zur Verfügung,\nmit denen man den gewünschten " +"Anzeigebereich sichtbar machen kann."; // Text für den Inhalt TextArea textFeld;

// Deklaration von textFeld

public void init() { textFeld = new TextArea(inhalt, 3, 20); // Instanz von textFeld add(textFeld); // textFeld hinzufügen } }

2.2.2

Bildlaufleisten und Schiebebalken (Scrollbar)

Mittels der Scrollbar-Komponenten kann man einen Wert in der Form auswählen, dass man einen Schiebebalken (auch Slider genannt) horizontal oder vertikal verschiebt. Die jeweilige Position des Schiebebalkens repräsentiert dann den Wert einer Variablen. Beim Generieren des Schiebebalkens werden in der Regel der minimale und der maximale Wert angegeben, welche die Auswahl begrenzen. Es stehen folgende Konstruktoren zur Verfügung: •

Scrollbar() erzeugt eine vertikale Scrollbar, bei der sowohl Minimum, als auch Maximum 0 sind.

Christian Schneider

16

AWT - Detailbetrachtung •

Scrollbar(int) erzeugt genau wie Scrollbar()eine Scrollbar, bei der sowohl Minimum, als auch Maximum 0 sind, wobei der Parameter die Orientierung des Schiebebalkens angibt. Man kann hier die in der Klasse Scrollbar enthaltenen Integer-Konstanten Scrollbar.VERTICAL und Scrollbar.HORIZONTAL verwenden.

•

Scrollbar(int, int, int, int, int) erzeugt eine Scrollbar mit folgenden Parametern:

Orientierung

(Scrollbar.VERTICAL

oder

Scroll-

bar.HORIZONTAL), Anfangswert des Schiebebalkens, Breite und Höhe der Box, die zur Veränderung der Scrollbar verwendet wird, und der minimale und maximale Wert, zwischen denen die Scrollbar selektiert.

Abbildung 2-11 Scrollbars

Das folgende Beispiel zeigt die Verwendung der Klasse Scrollbar. Die Ausgabe ist in Abbildung 2-11 dargestellt. import java.awt.*; import java.applet.*; public class Scroll extends Applet { Scrollbar sbar0 = new Scrollbar(Scrollbar.HORIZONTAL, 0, 10, 10, 200); Scrollbar sbar1 = new Scrollbar(Scrollbar.VERTICAL, 100, 10, 10, 200); public void init() { add(sbar0); add(sbar1); } }

Christian Schneider

17

AWT - Detailbetrachtung 2.3

Containers: Windows, Panels und Scroll Panes

Das AWT stellt drei Typen von Containern zur Verfügung, die alle als Unterklassen der Container-Klasse implementiert sind (welche wiederum eine Unterklasse von Component ist). Die von der Klasse Window abgeleiteten Klassen Dialog, FileDialog und Frame stellen Fensterfunktionalitäten bereit, die Komponenten aufnehmen können. Frames erzeugen vollständige Fenster mit allen Eigenschaften, die wir es z.B. von Windows her kennen. Im Gegensatz dazu erzeugen Dialogs Fenster, die von Frames abhängen und die modal sein können (d.h. dass z.B. einige Fensterkomponenten nicht vorhanden sind, wie z.B. „Maximieren“, je nach Initialisierung). Nutzt man einen FileDialog, so erzeugt das Programm einen Dialog zum öffnen oder speichern von Dateien. (Bekannt aus diversen Anwendungen, z.B. unter Menüpunkt „öffnen“ oder „speichern unter“ usw.) Ein Panel gruppiert Komponenten im Bereich eines bereits bestehenden Fensters. Ein ScrollPane ist einem Panel sehr ähnlich, aber sein Zweck ist etwas anders. In einem ScrollPane werden (mitunter sehr große) Komponenten dargestellt, wenn nur ein beschränkter Raum zur Verfügung steht. Ist der Platz zu klein für das dargestellte Objekt, so kann man mittels Bildlaufleisten im ScrollPane scrollen, um sich den gewünschten Ausschnitt anzeigen zu lassen. 2.4

Canvas

Eine Canvas-Komponente (dt. Zeichenfläche, s. auch Abbildung 2-1) ist eine rechteckige Fläche des Bildschirms, in die die Anwendung zeichnen kann oder darin auftretende Eingabeereignisse des Benutzers abfangen kann. Um eine sinnvolle (d.h. nicht leere) Ausgabe auf dem Bildschirm zu erreichen, muss der Programmierer eine Unterklasse von Canvas bilden. Dabei muss er die paint-Methode der Klasse überschreiben, damit eine beliebige Zeichnung, z.B. ein Dreieck, in die Zeichenfläche gesetzt werden kann. Das AWT sendet der Zeichenfläche alle Maus-, Tastatur- und Fokusereignisse, die über ihr auftreten. Die Methoden gotFocus, lostFocus, keyDown, keyUp, mouseEnter, mouseExit, mouseMove, mouseDrag, mouseDown und mouseUp der übergeordneten Klasse Component können überschrieben werden, um auf etwaige Ereignisse, die der Benutzer hervorruft, reagieren zu können.

Christian Schneider

18

AWT - Detailbetrachtung Nun folgt ein Code-Beispiel (Auszug) für eine Canvas, welche den Code für die Canvas aus dem Fenster in Abbildung 2-1 darstellt. class MeineCanvas extends Canvas {

...

... }

// Eigene Klasse von Canvas ableiten

public void paint(Graphics g) { // paint(...)-Methode überschreiben int w = getSize().width; // Integer-Wert für die Breite int h = getSize().height; // Integer-Wert für die Höhe g.drawRect(0, 0, w - 1, h - 1);// Canvas einen "Rahmen" geben g.drawString("Canvas", (w g.getFontMetrics().stringWidth("Canvas"))/2,10);

}

g.drawLine(10,10, 100,100); // Linie zeichnen g.fillRect(9,9,3,3); // Rechteck zeichnen g.drawString("(10,10)", 13, 10);// Beschriftung zeichnen g.fillRect(49,49,3,3); // Rechteck zeichnen g.drawString("(50,50)", 53, 50);// Beschriftung zeichnen g.fillRect(99,99,3,3); // Rechteck zeichnen g.drawString("(100,100)", 103, 100); //usw.

Die Methode public void paint(Graphics g) wird aufgerufen, um den Inhalt der Zeichenfläche erneut zu zeichnen. Der Punkt des Graphikkontexts ist die obere linke Ecke der Zeichenfläche. Zum Koordinaten-System innerhalb der Canvas bzw. des AWT allgemein wird noch in Abschnitt 4 (Grafikausgabe) Stellung genommen.

Christian Schneider

19

AWT - Detailbetrachtung 3

Das Event-Modell des AWT

Jede Benutzeraktion (z.B. Mausklick, Mausbewegung oder Tastaturanschlag) veranlasst das im Hintergrund laufende Windowing-System (z.B. Windows XP) dazu, ein der Aktion entsprechendes Ereignis (engl. Event) zu erzeugen. Dieses wird an das Programm weitergeleitet, das gerade den Fokus hatte, d.h. in dessen Fensterbereich das Event ausgelöst worden ist. Nun kommt das AWT ins Spiel, es verwendet zur Behandlung von Events ein sog. Delegation Event Modell.

ActionListener

MouseListener

KeyListener

Quelle

Lauscher

mit der der Anwender interagiert

der Ereignis bearbeitet

Abbildung 3-1 Event-Quelle und Event-Lauscher

In dem Event-Modell wird zwischen Event-Quelle (event source) und Event-Lauscher (event listener) unterschieden. Die Quellen sind die Komponenten der GUI, z.B. ein Knopf oder ein Fenster. Die Event-Lauscher sind Klassen, die zum Abfangen und Behandeln der Events erzeugt werden. Will man ein Ereignis über einer bestimmten Komponente abfangen, so muss man einen passenden Event-Listener definieren und diesen für die betreffende Quelle mit entsprechenden Methoden registrieren. Der erste Schritt zur Ereignisbehandlung besteht darin, das Package java.awt.event zu importieren. In diesem sind einige Klassen und Interfaces zusammengefasst, die für die Ereignisbehandlung benötigt werden. Prinzipiell ist das Ziel der Ereignisbehandlung, dass das Programm immer entsprechend reagiert, wenn der Benutzer z.B. auf einen Schalter drückt. Daher müssen für jede Komponente Methoden definiert werden, die immer dann aufgerufen werden, wenn das zugehörige Ereignis über der Komponente eintritt. Christian Schneider

20

AWT - Detailbetrachtung 3.1

Event-Lauscher definieren

Lauscher sind Klassen, die bestimmte Listener-Interfaces implementieren. In den Interfaces werden die Methoden deklariert, die dann beim Eintreten des Events ausgeführt werden sollen. Für jede Art von Ereignissen (Maus-, Tastatur-, Fensterereignisse) gibt es eigene Listener-Interfaces (s. Tabelle 3-1). Der Programmierer muss nun eigene Klassen definieren, die diese Interfaces implementieren. Die beispielhafte Syntax zur Definition einer eigenen Klasse, die das „einfachste“ Listener-Interface, den ActionListener, implementiert, sieht so aus: class MeinActionLauscher implements ActionListener { // Definiton der Methoden des Interface }

Das Interface ActionListener deklariert eine einzige Methode: public abstract void actionPerformed(ActionEvent e)

Da die in den Interfaces deklarierten Methoden abstrakt sind, müssen sie noch definiert werden, damit das Ereignis eine „Wirkung“ hervorruft. Ohne eine passende Implementierung dieser Methoden ist eine Ereignisbehandlung nicht möglich. Eine beispielhafte Implementierung der Methode actionPerformed aus dem kleinen Beispiel sieht wie folgt aus: class MeinActionLauscher implements ActionListener { public void actionPerformed(ActionEvent e) { // das Ereignis ruft ein einmaliges Piepen hervor java.awt.Toolkit.getDefaultToolkit().beep(); } }

Man kann an diesem kleinen Beispiel mehrere interessante Punkte feststellen: •

actionPerformed ist die Methode, die später beim entsprechenden Ereignis (z.B.

Button drücken) aufgerufen wird. •

Die Signatur der Methode wird vom Interface vorgegeben, implementiert wird sie vom Programmierer erst in der eigenen Klasse. D.h. die Methode im Interface ist abstrakt und wird erst definiert, wenn der Programmierer das Interface nutzen will.

•

Die Methode definiert einen Parameter e, dem zur Laufzeit vom Betriebssystem eine Instanz der Klasse ActionEvent übergeben wird. In dieser Instanz sind alle wichtigen Informationen zum auslösenden Event enthalten.

Christian Schneider

21

AWT - Detailbetrachtung 3.2

Lauscher für Quelle registrieren

Wenn nun ein Lauscher und eine Quelle vorhanden sind, müssen diese nur noch adäquat zusammengeführt werden. Man spricht davon, dass man einen Listener für eine Quelle registriert.

Die

Komponenten,

also

die

Quellen,

definieren

hierfür

passende

add...Listener()-Methoden, für jedes der verschiedenen Listener-Interfaces eine.

Zum Beispiel wird nun die entsprechende Methode für einen Knopf (button) aufgerufen, um ihm eine Instanz der oben exemplarisch definierten Lauscher-Klasse zu übergeben: MeinActionLauscher abc = new MeinActionLauscher(); // Lauscher-Instanz button.addActionListener(abc); // Lauscher beim Knopf registrieren

Man kann bei einer Komponente jede Art von Lauscher-Objekten registrieren. Die verschiedenen Lauscher sind in Tabelle 3-1 dargestellt. 3.3

Adapter

Da die in den Interfaces deklarierten Methoden abstrakt sind, müssen sie immer implementiert werden. In dem kleinen Beispiel mit dem ActionListener musste nur eine Methode definiert werden, actionPerformed. Es gibt jedoch weitere Interfaces (s. Tabelle 3-1), die mehrere Methoden deklarieren. Z.B. deklariert der WindowListener sieben Ereignisbehandlungsmethoden. Da der Benutzer aber alle Methoden definieren muss (da sie abstrakt sind), sind manche Interfaces ziemlich „unhandlich“. Um den Zwang zu umgehen, alle Methoden der Interfaces einzeln definieren zu müssen, kann der Programmierer auf sog. AdapterKlassen zurückgreifen. Diese Adapter-Klassen sehen eine Implementierung aller Methoden eines Listener-Interfaces ohne Anweisungen vor. Also sind alle Methoden eines Interfaces in der dazugehörigen Adapter-Klasse bereits definiert, so dass der Programmierer sie nicht explizit definieren muss. Wenn er eine Adapter-Klasse verwendet, kann er alle Methoden neu definieren, muss es aber nicht. Wenn nur eine Methode gebraucht wird (z.B. windowClosing), dann muss nur diese neu definiert werden.

Um dies an einem Beispiel zu verdeutlichen, wird nun das Interface WindowListener betrachtet. Es deklariert sieben Ereignisbehandlungsmethoden: windowOpend(), windowClosing(), windowClosed(), windowActivated(), windowDeactivated(), windowIconfied(), windowDeiconfied()

Wenn man seine Lauscher-Klasse selbst erstellt, welche das Interface WindowListener implementiert, dann muss man alle sieben Ereignisbehandlungsmethoden definieren, egal, ob sie gebraucht werden oder nicht. Leitet man aber stattdessen seinen Lauscher von der Adapter-Klasse WindowAdapter ab, dann ist es lediglich notwendig, die benötigten Methoden zu überschreiben. Alle anderen Methoden können ignoriert werden. Christian Schneider

22

AWT - Detailbetrachtung Ein Beispiel für eine selbst erstellte Lauscher-Klasse, die von der Klasse WindowAdapter abgeleitet wird: class MeinWindowLauscher extends WindowAdapter { public void windowClosing(WindowEvent e) { // Das Programm beenden System.exit(0); } }

In diesem Beispiel wird nur eine Methode der insgesamt sieben Methoden des WindowListene-Interfaces benötigt, so dass der Programmierer auf die zugehörige Adapter-Klasse zurückgegriffen hat, um sich so eine Definition der anderen sechs Methoden zu ersparen. 3.4

Eventverarbeitung durch Listener und Adapter

Eine Übersicht über die verschiedenen Event-Arten gibt folgende Tabelle: Listener-Interface ActionListener AdjustmentListener

ComponentListener

ContainerListener FocusListener ItemListener

Funktion Erfassung allgemeiner Aktionen Erfassung von Größenänderungen von Komponenten Erfassung von Komponentenaktionen Erfassung von Containeraktionen Erfassung von Fokusänderungen Erfassung von Zustandsänderungen

Adapterklasse

Methoden

keine

actionPerformed

keine

adjustmentValueChanged

ComponentAdapter

ContainerAdapter FocusAdapter keine

KeyListener

Erfassung von Tastaturaktionen

KeyAdapter

MouseListener

Erfassung von Mausaktionen

MouseAdapter

MouseMotionListener TextListener

WindowListener

Erfassung von Mausbewegungen Erfassung von Textänderungen

Erfassung von Fensteraktionen

MouseMotionAdapter

componentHidden componentMoved componendResized componendShown componentAdded componentRemoved focusGained focusLost itemStateChanged keyPressed keyReleased keyTyped mouseClicked mouseEntered mouseExited mousePressed mouseReleased mouseDragged mouseMoved

keine

textValueChanged

WindowAdapter

windowOpend windowClosing windowClosed windowActivated windowDeactivated windowIconfied windowDeiconfied

Tabelle 3-1 Event-Verarbeitung

Christian Schneider

23

AWT - Detailbetrachtung 3.5

Ein einfaches Beispiel für Eventbehandlung

Hier nun ein einfaches Beispiel für Eventbehandlung. Es zeigt drei Knöpfe, die jeweils unterschiedlich auf Klicks durch den Benutzer reagieren. Der mittlere Knopf erzeugt ein Piepen, der linke Knopf deaktiviert den mittleren Knopf und der rechte Knopf aktiviert den mittleren Knopf. In den Kommentaren sind Hinweise zur Funktionsweise des Applets:

Abbildung 3-2 ButtonDemo import import import import

java.awt.*; java.awt.event.ActionListener; java.awt.event.ActionEvent; java.applet.Applet;

public class ButtonDemo Button b1, b2, static final String static final String static final String

// Import der benötigten Klassen

extends Applet // Eigene Klasse ButtonDemo implements ActionListener {

b3; DISABLE = "disable"; ENABLE = "enable"; BEEP = "beep";

// // // //

Knöpfe String String String

werden deklariert Konstanten werden definiert Konstanten werden definiert Konstanten werden definiert

public void init() { // Initialisierung des Applets b1 = new Button(); // neuer Knopf b1 wird angelegt b1.setLabel("BEEP Knopf deaktivieren"); // b1 wird beschriftet b1.setActionCommand(DISABLE); // bei Event "sendet" der Knopf // "disable" b2 = new Button("BEEP"); // neuer Knopf b2 wird angelegt b2.setActionCommand(BEEP); // bei einem Event "sendet" der Knopf // "beep" b3 = new Button("BEEP Knopf aktivieren");// neuer Knopf b3 b3.setEnabled(false); // Knopf wird deaktiviert b3.setActionCommand(ENABLE); // bei Event "sendet" der Knopf // "ENABLE" b1.addActionListener(this); // Lauscher für b1 registrieren b2.addActionListener(this); // Lauscher für b2 registrieren b3.addActionListener(this); // Lauscher für b3 registrieren add(b1); // b1 zum Applet hinzufügen add(b2); // b2 zum Applet hinzufügen add(b3); // b3 zum Applet hinzufügen }

}

public void actionPerformed(ActionEvent e) {// Definition der Methode String command = e.getActionCommand(); //Welches Event ist passiert? if (command.equals(DISABLE)) { // "BEEP Knopf deaktivieren" geklickt b2.setEnabled(false); // b2 deaktivieren b1.setEnabled(false); // b1 deaktivieren b3.setEnabled(true); // b3 aktivieren } else if (command.equals(ENABLE)) {//"BEEP Knopf aktivieren" geklickt b2.setEnabled(true); // b2 aktivieren b1.setEnabled(true); // b1 aktivieren b3.setEnabled(false); // b3 deaktivieren } else // Beep!!! java.awt.Toolkit.getDefaultToolkit().beep(); }

Christian Schneider

24

AWT - Detailbetrachtung 4

Grafikausgabe

Da nicht nur Komponenten (also Knöpfe, Schiebebalken etc.) beim Design von grafischen Benutzeroberflächen von Bedeutung sind, wird im Folgenden die Grafikausgabe mittels AWT betrachtet. Das Hauptaugenmerk liegt hierbei bei der Klasse Graphics. Mit dieser stehen unterschiedlichste Funktionen zur Verfügung, z.B. zum Zeichnen von Figuren oder die Ausgabe von Text. 4.1

Graphics-Klasse

Im AWT stehen durch die Graphics-Klasse viele Grafikmöglichkeiten zur Verfügung. Mit ihr können Linien, Formen, Text und Bilder auf dem Bildschirm ausgegeben werden. Die Graphics-Klasse ist Teil des java.awt-Packages und wird mit der import Anweisung (import java.awt.* oder import java.awt.Graphics) am Anfang der Quelldatei importiert.

Die Klasse Graphics ist die abstrakte Oberklasse aller Grafikkontexte, die es ermöglicht auf prinzipiell allen Oberflächen zu zeichnen, d.h auf den Komponenten oder nicht dargestellten Bildern (engl. off-screen images). Falls nichts anderes angegeben wird, ändern die mit einem Grafikobjekt durchgeführten Grafikoperationen nur die Bits, die innerhalb des Ausschnittbereichs (engl. clipping area) des Grafikkontextes liegen. Alles Zeichnen und Schreiben erfolgt in der aktuellen Farbe, dem aktuellen Zeichenmodus (engl. paint mode) und in der aktuellen Schrift. 4.2

Methoden allgemein

Grafikmethoden sind Methoden innerhalb der Graphics-Klasse, welche meistens innerhalb der paint-Methode des Applets, der Komponente oder einer Zeichenfläche (Canvas, s. 2.4) ausgeführt werden. Auf die verschiedensten Zeichnungsfunktionen wird unter 4.5 noch eingegangen. Beispiel: Eine Linie zwischen den Koordinaten x1=30, y1=20 und x2=80, y2=100: public void paint(Graphics g) { g.drawLine(30,20,80,100); }

Der paint-Methode wird hier ein Graphics-Objekt übergeben. Es ist nicht nötig, eine Instanz dieses Objektes zu erzeugen, es steht vielmehr innerhalb von paint automatisch zur Verfügung. Die folgende Abbildung 4-1 zeigt das Ergebnis dieser Grafikoperation:

Christian Schneider

25

AWT - Detailbetrachtung

X (0,0)

Bereich, in dem gezeichnet wird. (30,20)

drawLine(30,20,80,100)

(80,100)

(width-1, height-1)

Y Abbildung 4-1 Zeichnen einer Linie und Koordinatensystem

4.3

Zeichengebiete

4.3.1

Koordinatensystem

Wie in Abbildung 4-1 angedeutet ist, hat eine jede Komponente ein eigenes Koordinatensystem, das von (0,0) bis (width-1, height-1) reicht. Jede Einheit entspricht einer Pixelgröße. Im Normalfall ist, wie in der Abbildung, der Ursprung, d.h. (0,0), in der oberen linken Ecke zu finden. Die x-Werte wachsen zunehmend nach rechts, die y-Werte nach unten. Mit der Funktion translate(int x, int y) kann man den Ursprung aber auch umsetzen. 4.3.2

Clipping

Man kann das Zeichengebiet auch durch das sog. Clipping verkleinern. clipRect(int x, int y, int width, int height)

Grafikoperationen außerhalb des so festgelegten Bereichs haben keine Auswirkung. Zum Beispiel erlaubt g.clipRect(70, 50, 260, 100); das Zeichnen nur in einem Bereich, der 260 Pixel breit und 100 Pixel hoch ist. Die linke obere Ecke dieses Bereiches ist durch x=70, y=50 festgelegt.

Christian Schneider

26

AWT - Detailbetrachtung 4.4

Farbe

Farben sind in Java eigene Objekte und es gibt eine Vielzahl von Methoden, um sie zu benutzen oder ändern. Zum Beispiel setzt die Anweisung setBackground(Color.black) die Hintergrundfarbe einer Komponente auf Schwarz. Color.black ist dabei eine statische Klassenvariable, die die Farbe Schwarz definiert. Die meisten Grundfarben sind auf diese Weise direkt verfügbar (Color.green, Color.blue usw.). Natürlich kann auch jede beliebige andere Farbe erzeugt werden, z.B. mit g.setColor(new Color(255,255,0). Dies erzeugt die Farbe Gelb nach dem RGBSystem. Auf dieses wird hier aber nicht explizit eingegangen. 4.5

Grafikfiguren

Grafikfiguren im AWT sind Linien, Rechtecke, Rechtecke mit runden Ecken, 3D-Rundecke, Ovale, Kreisbögen und Polygone.

Abbildung 4-2 Grafikfiguren mit Methoden

In der Abbildung 4-2 sieht man den Satz von Grund-Zeichenfunktionen, den die die Graphics-Klasse zur Verfügung stellt. Die einzelne Implementierung der jeweiligen Methoden und deren Handhabung sollte man in der Java API und der Online-Dokumentation von Sun nachschlagen, eine ausgiebige Behandlung würde nun zu weit führen. Auch in der Methoden-Übersicht unter 4.6 erhält man Informationen zu den gängigsten Funktionen.

Christian Schneider

27

AWT - Detailbetrachtung 4.6

Übersicht über die Methoden der Graphics-Klasse

Hier die wichtigsten Methoden der Graphics-Klasse in der Übersicht: Methode

Beschreibung

clearRect(int, int, int, int)

Füllt einen spezifizierten Bereich mit der Hintergrundfarbe

drawArc(int, int, int, int, int, int)

Zeichnet einen Bogen ein

drawImage(Image, int, int, ImageObserver)

Zeichnet ein Bild an die angegebene Position

drawLine(int, int, int, int)

Zeichnet eine Linie ein

drawOval(int, int, int, int)

Zeichnet ein Oval ein

drawPolygon(int[], int[], int)

Zeichnet ein Polygon ein

drawPolyline(int[], int[], int)

Zeichnet einen Linienzug ein

drawRect(int, int, int, int)

Zeichnet ein Rechteck ein

drawRoundRect(int, int, int, int, int, int)

Zeichnet ein Rechteck mit abgerundeten Ecken ein

drawString(String, int, int)

Gibt String an der angegebenen Koordinate aus

fillArc(), fillOval(), fillPolygon()... getClip()

Eine Reihe von Methoden zum Zeichnen ausgefüllter Formen (vgl. draw...()) Liefert ein Shape-Objekt zurück, das den aktuellen Clip-Bereich repräsentiert

getColor()

Liefert die aktuelle Zeichenfarbe zurück

getFont()

Liefert die aktuell verwendete Schriftart zurück

setClip(Shape)

Definiert einen neuen Clipping-Bereich

setColor(Color)

Definiert die beim Zeichnen verwendete Farbe

setFont(Font)

Definiert die zu verwendende Schriftart

translate(int, int)

Verschiebung des Nullpunktes

Tabelle 4-1 Überblick über die Methoden der Graphics-Klasse

Christian Schneider

28

AWT - Detailbetrachtung

Literatur- und Quellenangabe

5

Als Informationsquellen wurden für diese Ausarbeitung verwendet:

6

•

Open Java, Fischer/El Saddik, Springer-Verlag

•

Java – Programmierung interaktiver WWW-Seiten, Doberenz/Druckenmüller, Hanser-Verlag

•

JavaTM API – Band 2: Das Window Toolkit und Applets, Die offizielle Dokumentation von JavaSoft Gosling/Yellin/Java-Team, Addison-Wesley-Verlag

•

graphic Java – Mastering the AWT 2nd edition Geary

•

http://sun.java.com Java-Online-Dokumentation von Sun

•

Jetzt lerne ich Java Dirk Louis / Peter Müller, Verlag Markt und Technik

Anhang

Im Anhang befindet sich eine CD mit Dateien und Quelltexten zu den meisten Beispielen. Es wurde darauf verzichtet, diese alle auszudrucken. Außerdem sind auf der CD ausführbare Beispiel-Applets, die den Sachverhalt deutlich machen sollen. Man kann sie durch öffnen der jeweiligen HTML-Files betrachten. Wenn dieses Dokument von CD geöffnet wurde, dann kann man durch anklicken der Links (s.u.) zu den Beispielen gelangen.

Die folgenden Hyperlinks führen zu den Beispielen (auf CD): ButtonDemo.html

ButtonDemo.java

Demo zu Knöpfen und Ereignisbehandlung

FontDemo.html

FontDemo.java

Demo der verschiedenen Grafikformen

GUIWindow.html

GUIWindow.java

Demo der verschiedenen Komponenten des AWT

Scrollbar.html

Scroll.java

Demo für einen Scrollbalken

Textfeld.html

Textfeld.java

Demo für Textfelder

Textbereich.html

Textbereich.java

Demo für Textbereiche

Textmarke.html

Textmarke.java

Demo für Textmarken (Label)

Christian Schneider

29