GUI-Programmierung mit JControl/Wombat

III. Standard-Komponenten

Das Package jcontrol.ui.wombat enthält eine Sammlung von GUI-Komponenten, die die Anforderungen an eine komfortable grafische Benutzeroberfläche für die meisten Aufgaben abdeckt. Dieses Kapitel beschreibt Funktion und Arbeitsweise dieser Standardkomponenten und liefert Beispielprogramme, die den Umgang mit dem GUI-Framework JControl/Wombat demonstrieren.

Buttons Buttons bilden eine anschauliche und intuitiv benutzbare Methode, um dem Benutzer die Interaktion mit einem Programm zu ermöglichen. Interessant für den Programmierer ist hier vor allem das interne Verhalten dieser Buttons, wie z.B. das Auslösen von ActionEvents oder die Aktualisierung der Darstellung.

In JControl/Wombat gibt es vier verschiedene Arten von Buttons: Den einfachen Button, den RadioButton, die CheckBox und den Toggelswitch. Diese Varianten werden im weiteren Verlauf dieses Tutorials näher betrachtet und anhand eines Beispiels deren Funktionsweise verdeutlicht.

• Button: Die Klasse Button erzeugt eine Standard-Schaltfläche, die wahlweise einen String oder ein Bild (Resource) darstellen kann. Der Inhalt der Schaltfläche wird automatisch zentriert. Werden die Angaben width und height beim Konstruktor weggelassen, berechnet der Button automatisch seine bevorzugte Größe. Buttons feuern BUTTON_PRESSED-ActionEvents, wenn sie gedrückt werden.

  

  
  
• RadioButton: Der RadioButton ist eine spezielle Form von Button, bestehend aus einem grafischen Schalter, der ein- oder ausgeschaltet sein kann, und einem nachfolgenden String. Fügt man mehrere RadioButtons einem Container hinzu, sorgt dieser selbständig dafür, dass immer nur ein RadioButton aktiviert ist. RadioButtons feuern STATE_CHANGED-ActionEvents, wenn sie betätigt werden.

  

  
  
• CheckBox: Eine CheckBox ist ein Button, der aktiviert oder deaktiviert sein kann. Der aktuelle Zustand wird durch das Vorhandensein eines "Check"-Hakens symbolisiert. Bei Betätigung feuert die CheckBox ein STATE_CHANGED-ActionEvent.

  

  
  

Der folgende Quelltext zeigt ein Beispielprogramm, dass alle drei Button-Typen verwendet, um eine ansonsten zweckfreie Benutzeroberfläche zu erstellen.

In Bild 1 ist ein Screenshot des WombatButtonExample-Programms dargestellt. Um das Beispielprogramm selbst auszuprobieren, öffnen Sie das Projekt WombatButtonExample, welches sich im Installationsverzeichnis der JControl/IDE unter "demos/cobra5329/WombatTutorial/WombatButtonExample" befindet (unter Windows: "C:\Programme\JControl\demos\cobra5329\WombatTutorial\WombatButtonExample).

Bild 1: Das WombatButtonExample

1	/**
2	* <p>This example demonstrates how to use buttons and similar components
3	* within the GUI framework JControl/Wombat.</p>
4	*
5	* <p>(C) DOMOLOGIC Home Automation GmbH 2007</p>
6	*
7	*/
8	import jcontrol.ui.wombat.Frame;
9	import jcontrol.ui.wombat.Container;
10	import jcontrol.ui.wombat.event.ActionListener;
11	import jcontrol.ui.wombat.Border;
12	import jcontrol.ui.wombat.RadioButton;
13	import jcontrol.ui.wombat.CheckBox;
14	import jcontrol.ui.wombat.Button;
15	import jcontrol.ui.wombat.ToggleSwitch;
16	import jcontrol.ui.wombat.event.ActionEvent;
17
18	public class WombatButtonExample extends Frame implements ActionListener {
19
20
21	/**
22	* Constructor WombatButtonExample
23	*/
24	public WombatButtonExample() {
25	// create a container for the content of this frame
26	Container content = new Container();
27
28	// create borders and add them to the content
29	Border border1 = new Border("Radiobuttons", 40, 40, 120, 80,
30	Border.STYLE_ETCHED_BORDER);
31	content.add(border1);
32	Border border2 = new Border("Checkboxes", 160, 40, 120, 80,
33	Border.STYLE_ETCHED_BORDER);
34	content.add(border2);
35	Border border3 = new Border("Buttons", 40, 120, 120, 80,
36	Border.STYLE_ETCHED_BORDER);
37	content.add(border3);
38	Border border4 = new Border("Toggleswitches", 160, 120, 120, 80,
39	Border.STYLE_ETCHED_BORDER);
40	content.add(border4);
41
42	/* create all components
43	add them to the content
44	and define an actionlistener for each component */
45
46	// Radiobuttons
47	RadioButton radioButton1 = new RadioButton("RadioButton 1",
48	65, 56, 0, 0);
49	content.add(radioButton1);
50	radioButton1.setActionListener(this);
51	RadioButton radioButton2 = new RadioButton("RadioButton 2",
52	65, 76, 0, 0);
53	content.add(radioButton2);
54	radioButton2.setActionListener(this);
55	RadioButton radioButton3 = new RadioButton("RadioButton 3",
56	65, 96, 0, 0);
57	content.add(radioButton3);
58	radioButton3.setActionListener(this);
59
60	// Checkboxes
61	CheckBox checkBox1 = new CheckBox("CheckBox 1",
62	190, 56, 0, 0);
63	content.add(checkBox1);
64	checkBox1.setActionListener(this);
65	CheckBox checkBox2 = new CheckBox("CheckBox 2",
66	190, 76, 0, 0);
67	content.add(checkBox2);
68	checkBox2.setActionListener(this);
69	CheckBox checkBox3 = new CheckBox("CheckBox 3",
70	190, 96, 0, 0);
71	content.add(checkBox3);
72	checkBox3.setActionListener(this);
73
74	// Buttons
75	Button button1 = new Button("Press me!",
76	57, 142, 90, 20);
77	content.add(button1);
78	button1.setActionListener(this);
79	Button button2 = new Button("Push the button",
80	57, 162, 90, 20);
81	content.add(button2);
82	button2.setActionListener(this);
83
84	// Toggleswitches
85	ToggleSwitch toggleSwitch1 = new ToggleSwitch(190, 140);
86	toggleSwitch1.setText("On", "Off");
87	content.add(toggleSwitch1);
88	toggleSwitch1.setActionListener(this);
89	ToggleSwitch toggleSwitch2 = new ToggleSwitch(220, 140);
90	toggleSwitch2.setText("On", "Off");
91	content.add(toggleSwitch2);
92	toggleSwitch2.setActionListener(this);
93	/* */
94
95	// set the content to this frame
96	setContent(content);
97	// finally, make the frame visible
98	setVisible(true);
99	}
100
101	/**
102	* This method is called every time any component declared above fires an
103	* action event.
104	*
105	* @param e the ActionEvent
106	*/
107	public void onActionEvent(ActionEvent e) {
108	// add some code if you want to
109	}
110
111
112	/**
113	* The main method.
114	*
115	* @param args
116	*        The main arguments
117	*/
118	public static void main(String[] args) {
119	new WombatButtonExample();
120	}
121	}

Listing 1: WombatButtonExample.java

Selektoren

ComboBox

Die ComboBox ist eine interaktive GUI-Komponente, die dem Benutzer mehrere Texteinträge zur Auswahl anbietet. Im deaktivierten Zustand ist sie zugeklappt und zeigt den derzeitig ausgewählten Eintrag an. Hat sie den Eingabefokus, kann die ComboBox vom Benutzer durch Betätigen der Select-Taste oder durch Drücken auf dem Touch-Screen geöffnet werden. Nun kann ein anderer Eintrag ausgewählt werden, wobei die Liste der Einträge herauf- oder herunterscrollt, wenn sie länger als der darstellbare Bereich ist.

Die wichtigsten Methoden der Klasse jcontrol.ui.wombat.ComboBox sind in der folgenden Tabelle 1 aufgeführt:

Methode	Beschreibung
ComboBox(int x, int y, int width)	Erzeugt eine neue ComboBox an der angegebenen Position mit der angegebenen Breite.
add(String item)	Fügt der ComboBox einen neuen Eintrag hinzu.
String getSelectedItem()	Gibt den momentan selektierten Eintrag der ComboBox als String zurück.
int getSelectedIndex()	Gibt den Index des momentan selektierten Eintrags der ComboBox zurück.
remove(String item)	Entfernt einen Eintrag aus der ComboBox.
setSelection(int index)	Selektiert den als Index übergebenen Eintrag in der ComboBox.

Tabelle 1: Methoden der Klasse jcontrol.ui.wombat.Container

Installiert man mit Hilfe der Methode setActionListener(ActionListener listener) einen ActionListener auf die ComboBox, feuert sie ITEM_SELECTED-ActionEvents, wenn der Benutzer eine Auswahl tätigt.

NumberChooser

Der NumberChooser ist eine GUI-Komponente bestehend aus einem Textfeld und zwei Schaltflächen. Das Textfeld zeigt eine Dezimalzahl an, deren Wert durch Betätigen der beiden Pfeiltasten eingestellt werden kann. Dabei wird der Wert jeweils um 1 erhöht, bzw. reduziert (der Benutzer kann diese Schrittweite nicht direkt verändern). Minimaler und maximaler Wert müssen dem Konstruktor übergeben werden. Vom Programmierer beeinflussbar sind ferner die verwendete Schriftart sowie Größe und Position der GUI-Komponente. Folgende Methoden stehen zur Verfügung:

Methode	Beschreibung
NumberChooser(int x, int y, int min, int max)	Erzeugt einen neuen NumberChooser an der angegebenen Position mit dem durch die Parameter min und max abgegrenzten Wertebereich.
int getValue()	Gibt den aktuellen Wert der GUI-Komponente NumberChooser zurück.
setValue(int value)	Ändert den Wert des der GUI-Komponente NumberChooser. Der neue Wert muss innerhalb des dem Konstruktor übergebenen Wertebereichs liegen.

Tabelle 2: Methoden der Klasse jcontrol.ui.wombat.NumberChooser

MultiImageMenu

Das MultiImageMenu ist eine Kompontente, die dem Benutzer eine Auswahlmöglichkeit in Form von Bildsymbolen, alternativ Texteinträgen, anbietet. Diese werden in Tabellenform ausgerichtet, die Zeilen- und Spaltenanzahl ist frei wählbar. Der Abstand der Symbole zueinander richtet sich nach dem verfügbaren Platz. Das MultiImageMenu besitzt keinen Scrollbar. Es muß also darauf geachtet werden, daß die Größe und Anzahl der anzuzeigenden Symbole den verfügbaren Platz nicht überschreitet. Folgende Methoden stehen zur Verfügung:

Methode	Beschreibung
MultiImageMenu(int x, int y, int width, int height, int horizontalCount, int verticalCount, int style)	Erzeugt ein neues MultiImageMenu mit angegebener Position und Größe. Die Parameter horizontalCount und verticalCount geben die gewünschte Anzahl von Spalten bzw. Zeilen an. Für den style-Parameter stehen die beiden Konstanten STYLE_SHOW_BORDER und STYLE_NONE zur Verfügung.
setImageItems(Resource[] imageItems)	Füllt das MultiImageMenu mit der angegebenen Liste aus Image-Ressourcen. Es dürfen null-Werte vorkommen, die als leere Felder im MultiImageMenu erscheinen.
setTextItems(String[] textItems)	Füllt das MultiImageMenu mit der angegebenen Liste aus Strings. Es dürfen null-Werte vorkommen, die als leere Felder im MultiImageMenu erscheinen.
int addMenuItem(String item)	Fügt einen Eintrag in das MultiImageMenu hinzu. Ist zu dem angegebenen String eine Resource dieses Namens verfügbar, so wird diese als Symbol angezeigt. Ansonsten wird der String selbst angezeigt. Der Rückgabewert entspricht dem Index im Menü.
int insertMenuItem(String item, int index)	Fügt einen Eintrag in das MultiImageMenu an der angegebenen Position hinzu. Ein eventuell bereits vorhandener Eintrag wird überschrieben. Ist zu dem angegebenen String eine Resource dieses Namens verfügbar, so wird diese als Symbol angezeigt. Ansonsten wird der String selbst angezeigt. Der Rückgabewert entspricht dem Index im Menü.
int getFirstFreeIndex()	Gibt den ersten Index im MultiImageMenu zurück, an dem noch kein Symbol vorhanden ist.
setTouchMargin(int margin)	Gibt die Größe des nicht-touchsensitiven Bereichs um die Menüeinträge herum an. Standardwert ist 5.

Tabelle 3: Methoden der Klasse jcontrol.ui.wombat.menu.MultiImageMenu

Zum Abschluss dieses Kapitels soll ein kurzer Quelltext gezeigt werden, der den Umgang mit den GUI-Komponenten ComboBox, NumberChooser und MultiImageMenu demonstriert. Er ist ebenfalls im Projekt WombatSelectorExample im Verzeichnis "demos/cobra5329/WombatTutorial/WombatSelectorExample" Ihrer JControl/IDE-Installation befindet (unter Windows "C:\Programme\JControl\demos\cobra5329\WombatTutorial\WombatSelectorExample"). Bild 2 zeigt einen Screenshot des Beispielprogramms.

Bild 2: Das WombatSelectorExample

1	/**
2	* <p>This example demonstrates how to use the
3	* components ComboBox, NumberChooser and MultiImageMenu within
4	* the GUI framework JControl/Wombat.</p>
5	*
6	* <p>(C) DOMOLOGIC Home Automation GmbH 2007</p>
7	*/
8	import jcontrol.ui.wombat.Frame;
9	import jcontrol.ui.wombat.Container;
10	import jcontrol.ui.wombat.event.ActionListener;
11	import jcontrol.ui.wombat.Border;
12	import jcontrol.ui.wombat.ComboBox;
13	import jcontrol.ui.wombat.NumberChooser;
14	import jcontrol.ui.wombat.menu.MultiImageMenu;
15	import jcontrol.io.Resource;
16	import java.io.IOException;
17	import jcontrol.graphics.Color;
18	import jcontrol.ui.wombat.event.ActionEvent;
19
20	public class WombatSelectorExample extends Frame implements ActionListener {
21
22	/**
23	* Constructor WombatComboNumberExample
24	*/
25	public WombatSelectorExample() {
26	// create a container for the content of this frame
27	Container content = new Container();
28
29	// create borders and add them to the content
30	Border border1 = new Border("ComboBox", 60, 40, 180, 40,
31	Border.STYLE_ETCHED_BORDER);
32	content.add(border1);
33	Border border2 = new Border("NumberChooser", 60, 80, 180, 40,
34	Border.STYLE_ETCHED_BORDER);
35	content.add(border2);
36	Border border3 = new Border("MultiImageMenu", 60, 120, 180, 70,
37	Border.STYLE_ETCHED_BORDER);
38	content.add(border3);
39
40	/* create all components
41	add them to the content
42	and define an actionlistener for each component */
43
44	// ComboBox
45	ComboBox comboBox = new ComboBox(new String[]{
46	"Entry 1", "Entry 2", "Entry 3"}, 110, 56, 80);
47	content.add(comboBox);
48	comboBox.setActionListener(this);
49
50	// NumberChooser
51	NumberChooser numberChooserDay = new NumberChooser(112, 96, 1, 31);
52	numberChooserDay.setValue(1);
53	content.add(numberChooserDay);
54	numberChooserDay.setActionListener(this);
55	NumberChooser numberChooserMonth = new NumberChooser(136, 96, 1, 12);
56	numberChooserMonth.setValue(1);
57	content.add(numberChooserMonth);
58	numberChooserMonth.setActionListener(this);
59	NumberChooser numberChooserYear = new NumberChooser(160, 96, 2000, 2100);
60	numberChooserYear.setValue(1);
61	content.add(numberChooserYear);
62	numberChooserYear.setActionListener(this);
63
64	// MultiImageMenu
65	MultiImageMenu multiImageMenu = new MultiImageMenu(70, 136, 160, 44,
66	3, 1, MultiImageMenu.STYLE_SHOW_BORDER);
67	try {
68	multiImageMenu.setImageItems(new Resource[]{
69	new Resource("item1.jcif"),
70	new Resource("item2.jcif"),
71	new Resource("item3.jcif")});
72	} catch(IOException ioe) {}
73	multiImageMenu.setBackgroundColor(Color.WHITE);
74	content.add(multiImageMenu);
75	multiImageMenu.setActionListener(this);
76
77	// set the content to this frame
78	setContent(content);
79	// finally, make the frame visible
80	setVisible(true);
81	}
82
83	/**
84	* This method is called every time any component declared above
85	* fires an action event.
86	*
87	* @param e the ActionEvent
88	*/
89	public void onActionEvent(ActionEvent e) {
90	// add some code if you want to
91	}
92
93	/**
94	* The main method.
95	*
96	* @param args
97	*        The main arguments
98	*/
99	public static void main(String[] args) {
100	new WombatSelectorExample();
101	}
102	}

Listing 2: WombatSelectorExample.java

Slider

Slider

Mit der GUI-Komponente Slider ist es möglich, Zahlenwerte grafisch als Schieberegler darzustellen. Bewegt der Benutzer den Slider, so wird ein VALUE_CHANGED-ActionEvent mit dem neuen Wert generiert. Folgende Methoden werden von der Klasse jcontrol.ui.wombat.Slider angeboten:

Methode	Beschreibung
Slider(int x, int y, int width, int height, int min, int max, int orientation)	Erzeugt einen neuen Slider mit angegebener Position und Größe. Durch die Parameter min und max wird der Wertebereich angegeben. Für den Parameter orientation stehen die beiden Konstanten ORIENTATION_HORIZONTAL und ORIENTATION_VERTICAL zur Verfügung.
setStep(int step)	Bestimmt die Schrittweite beim Verschieben des Sliders.
int getValue()	Gibt den aktuellen Wert der GUI-Komponente Slider zurück.
setValue(int value)	Ändert den Wert der GUI-Komponente Slider. Wenn der neue Wert nicht innerhalb des bei der Erzeugung des Sliders angegebenen Bereichs liegt, so wird er entsprechend angepasst.

Tabelle 3: Methoden der Klasse jcontrol.ui.wombat.Slider

Der nachfolgend gelistete Quelltext implementiert ein kleines Beispielprogramm, das zwei Slider darstellt. Bild 3 zeigt einen Screenshot dieses Programms. Wie alle Beispiele dieses Tutorials liegt es Ihrer JControl/IDE-Installation bereits bei. Sie finden es im Installationsverzeichnis unter "demos/cobra5329/WombatTutorial/WombatSliderExample" (unter Windows "C:\Programme\JControl\demos\cobra5329\WombatTutorial\WombatSliderExample").

Bild 3: Das WombatSliderExample

1	/**
2	* <p>This example demonstrates how to use the
3	* component Slider within
4	* the GUI framework JControl/Wombat.</p>
5	*
6	* <p>(C) DOMOLOGIC Home Automation GmbH 2007</p>
7	*/
8	import jcontrol.ui.wombat.Frame;
9	import jcontrol.ui.wombat.Container;
10	import jcontrol.ui.wombat.event.ActionListener;
11	import jcontrol.ui.wombat.Border;
12	import jcontrol.ui.wombat.Slider;
13	import jcontrol.ui.wombat.event.ActionEvent;
14
15	public class WombatSliderExample extends Frame implements ActionListener {
16
17	/**
18	* Constructor WombatSliderExample
19	*/
20	public WombatSliderExample() {
21	// create a container for the content of this frame
22	Container content = new Container();
23
24	// create borders and add them to the content
25	Border border = new Border("Slider", 70, 40, 180, 140,
26	Border.STYLE_SIMPLE_BORDER);
27	content.add(border);
28
29
30	/* create all Sliders
31	add them to the content
32	and define an actionlistener for each component */
33	Slider horizontalSlider = new Slider(90, 57, 140, 18, 0, 100,
34	Slider.ORIENTATION_HORIZONTAL);
35	horizontalSlider.setEnabled(false);
36	content.add(horizontalSlider);
37	horizontalSlider.setActionListener(this);
38	Slider verticalSlider = new Slider(150, 80, 18, 90, 0, 100,
39	Slider.ORIENTATION_VERTICAL);
40	content.add(verticalSlider);
41	verticalSlider.setActionListener(this);
42
43	// set the content to this frame
44	setContent(content);
45	// finally, make the frame visible
46	setVisible(true);
47	}
48
49	/**
50	* This method is called every time any component declared above fires an
51	* action event.
52	*
53	* @param e the ActionEvent
54	*/
55	public void onActionEvent(ActionEvent e) {
56	// add some code if you want to
57	}
58
59
60	/**
61	* The main method.
62	*
63	* @param args
64	*        The main arguments
65	*/
66	public static void main(String[] args) {
67	new WombatSliderExample();
68	}
69	}

Listing 3: WombatSliderExample.java

ListBox und TextViewer

ListBox

Die GUI-Komponente ListBox zeigt eine Liste von Strings an und ermöglicht die grafische Auswahl eines Eintrags. Enthält die Liste mehr Einträge als auf Grund ihrer Größe gleichzeitig darstellbar sind, kann am rechten Rand eine ScrollBar eingeblendet werden. Der momentan durch den Benutzer ausgewählte Eintrag wird durch die Invertierung der entsprechenden Zeile hervorgehoben. Die GUI-Komponente ListBox "feuert" ActionEvents vom Typ ITEM_SELECTED. Die folgenden Methoden sind zur Erstellung einer Liste verfügbar:

Methode	Beschreibung
ListBox(String[] items, int x, int y, int width, int height, int style)	Erzeugt eine neue GUI-Komponente ListBox mit der angegebenen Position und Größe. Der Parameter items enthält eine initiale Belegung der ListBox. Der Parameter style bestimmt das Aussehen und Verhalten. Hierfür besitzt die Klasse ListBox die Konstanten STYLE_NONE, STYLE_SHOW_BORDER, STYLE_SHOW_SCROLLBAR, STYLE_ALIGN_TOP und STYLE_ALIGN_CENTER, welche einzeln oder in sinnvoller Kombination durch | verknüpft angegeben werden.
ListBox(int x, int y, int width, int height, int style)	Dieser Konstruktor arbeitet genau wie sein o.a. Pendant mit dem Unterschied, daß die ListBox leer bleibt.
add(String item)	Fügt der Liste einen neuen Eintrag hinzu.
remove(String item)	Entfernt einen Eintrag aus der Liste.

Tabelle 5: Methoden der Klasse jcontrol.ui.wombat.ListBox

TextViewer

Mit dem TextViewer ist es möglich, längere Texte mit Scroll-Funktionalität anzuzeigen. Der Inhalt der TextViewer kann entweder statisch im Konstruktor oder dynamisch mit der set-Methode übergeben werden. Die Methode add fügt neuen Text an den bereits vorhandenen an. Tabelle 6 fasst die Methoden der TextViewer zusammen:

Methode	Beschreibung
TextViewer(int x, int y, int width, int height, int style)	Erzeugt eine neue TextViewer mit der angegebenen Position und Größe. Der Parameter style bestimmt das Aussehen und Verhalten. Hierfür besitzt die Klasse TextViewer die Konstanten STYLE_NONE, STYLE_SHOW_BORDER, STYLE_SHOW_SCROLLBAR.
TextViewer(String text, int x, int y, int width, int height, int style)	Bei diesem Konstruktor kann neben den o.g. Parametern noch ein String mit dem initialen Textinhalt dem TextViewer übergeben werden.
setText(String text)	Weist dem TextViewer den angegebenen Text zu. Eventuell bereits vorhandener Text wird verworfen.
add(String text)	Konkateniert den angegeben String an den eventuell bereits im TextViewer enhaltenen Text. Enthält der TextViewer noch keinen Text ist diese Methode identisch mit setText(String text).

Tabelle 6: Methoden der Klasse jcontrol.ui.wombat.TextViewer

Im Folgenden ist ein Quelltext-Beispiel aufgeführt, dass sowohl ein ListBox-Objekt als auch eine TextViewer anlegt, mit einigen Einträgen füllt und auf dem Display darstellt. Das Projekt finden Sie im Installationsverzeichnis der JControl/IDE unter "demos/cobra5329/WombatTutorial/WombatListTextviewerExample" (unter Windows "C:\Programme\JControl\demos\cobra5329\WombatTutorial\WombatListTextviewerExample"). Bild 4 zeigt einen Screenshot des Programms.

Bild 4: Das WombatListTextviewerExample

1	/**
2	* <p>This example demonstrates how to use the
3	* components ListBox and TextViewer within the GUI
4	* framework JControl/Wombat.</p>
5	*
6	* <p>(C) DOMOLOGIC Home Automation GmbH 2007</p>
7	*/
8	import jcontrol.ui.wombat.Frame;
9	import jcontrol.ui.wombat.Container;
10	import jcontrol.ui.wombat.event.ActionListener;
11	import jcontrol.ui.wombat.TextViewer;
12	import jcontrol.io.Resource;
13	import java.io.IOException;
14	import jcontrol.ui.wombat.ListBox;
15	import jcontrol.ui.wombat.event.ActionEvent;
16
17
18	public class WombatListTextviewerExample extends Frame implements ActionListener  {
19	/**
20	* Constructor WombatListTextviewerExample
21	*/
22	public WombatListTextviewerExample() {
23	// create a container for the content of this frame
24	Container content = new Container();
25	try {
26	// set a larger Font to the content, all components in the
27	// content will get this font, too
28	content.setFont(new Resource("Arial.jcfd"));
29	} catch(IOException ioe) {}
30
31	// create a TextViewer
32	TextViewer textViewer = new TextViewer(
33	"The TextViewer can show any text you want.\n" +
34	"Line-breaks are performed autmatically.",
35	70, 40, 180, 70, TextViewer.STYLE_SHOW_SCROLLBAR);
36	content.add(textViewer);
37
38	// create a ListBox
39	ListBox listBox = new ListBox(new String[]{
40	"North", "Eath", "South", "West",
41	"North-Eath", "South-West", "South-Eath", "North-West"},
42	70, 110, 180, 70, ListBox.STYLE_SHOW_SCROLLBAR);
43	content.add(listBox);
44	listBox.setActionListener(this);
45
46	// set the content to this frame
47	setContent(content);
48	// finally, make the frame visible
49	setVisible(true);
50	}
51
52	/**
53	* This method is called every time an item in the listbox declared
54	* above is selected be the user.
55	*
56	* @param e the ActionEvent fired by the listbox
57	*/
58	public void onActionEvent(ActionEvent e) {
59	// add some code if you want to
60	}
61
62	/**
63	* The main method.
64	*
65	* @param args
66	*        The main arguments
67	*/
68	public static void main(String[] args) {
69	new WombatListTextviewerExample();
70	}
71	}

Listing 4: WombatListTextviewerExample.java

Statische Komponenten Neben den vielfältigen GUI-Komponenten, die mit dem Benutzer interagieren, bietet JControl/Wombat auch noch einige andere statische Komponenten, die zur Darstellung von Texten, Bildern oder grafischen Layout-Elementen verwendet werden können.

Label

Die Klasse Label stellt eine GUI-Komponente zur Verfügung, die einen mehrzeiligen Text oder eine Bild-Ressource darstellt. Dabei können verschiedene horizontale Ausrichtungen (links, rechts und zentriert) vorgegeben werden. Mit Labels lassen sich Texte und Bilder ohne großen Programmieraufwand komfortabel positionieren und ausrichten. In der Tabelle 7 sind die wichtigsten Methoden von Label aufgeführt.

Methode	Beschreibung
Label(String text, int x, int y)	Erstellt ein Label an Position x,y mit dem angegebenen Text. Die Größe der Komponente wird durch den Text in Verbindung mit der verwendeten Schriftart festgelegt. Ein späteres Verändern des Textes oder der Schriftart kann eine Größenänderung des Labels nach sich ziehen.
Label(Resource image, int x, int y)	Erstellt ein Label an Position x,y mit dem angegebenen Bild. Die Größe der Komponente wird durch die Größe des Bildes bestimmt. Ein Austauschen des Bildes kann eine Größenänderung des Labels nach sich ziehen.
Label(String text, int x, int y, int width, int height, int style) {	Erzeugt ein neues Label wie mit o.a. Konstruktor, allerdings können hier Breite und Höhe des Labels fest vorgegeben werden (für Werte >0), d.h. auch ein nachträgliches Ändern der Beschriftung ändert die Größe des Labels nicht. Der Parameter style kann einen der konstanten Werte STYLE_ALIGN_LEFT, STYLE_ALIGN_CENTER oder STYLE_ALIGN_RIGHT annehmen. Dieser Wert kann optional mit den Werten STYLE_SHOW_BORDER und STYLE_DRAW_INVERSE oder STYLE_DRAW_NORMAL durch Anwenden der OR-Verknüpfung kombiniert werden.
Label(Resource image, int x, int y, int width, int height, int style)	Erzeugt ein neues Label wie oben, nur mit einem Bild anstatt eines Textes.
setText(String text)	Ersetzt den Inhalt des Labels mit dem angegebenen Text.
setImage(Resource image)	Ändert den Inhalt des Labels mit dem angegebenen Bild.
setStyle(int style)	Ändert den Stil des Label. Der Parameter entspricht der Benutzung im Konstruktor.

Tabelle 7: Methoden der Klasse jcontrol.ui.wombat.Label

Border

Mit der Klasse Border, die auch schon in den vorhergehenden Beispielprogrammen zum Einsatz kam, können verschiedene Rahmentypen auf das Display gezeichnet werden. Die Rahmen sind transparent und überdecken somit nicht schon vorhandene UI-Komponenten. Wahlweise kann bei der Konstruktion ein String übergeben werden, der am linken oberen Rand des Rahmens dargestellt wird.

Methode	Beschreibung
Border(String label, int x, int y, int width, int height, int style)	Erzeugt eine neue Border mit der angegebenen Beschriftung, Position und Größe. Für den style-Parameter stehen folgende Kostanten zur Auswahl: STYLE_SIMPLE_BORDER, STYLE_ROUND_BORDER und STYLE_ETCHED_BORDER.
setText(String text)	Ändert die Beschriftung des Rahmens.

Tabelle 8: Methoden der Klasse jcontrol.ui.wombat.Border

Das Beispielprogramm WombatLabelBorderExample.java demonstriert die Verwendung von Label und Border. Es befindet sich im Verzeichnis "demos/cobra5329/WombatTutorial/WombatLabelBorderExample" Ihrer JControl/IDE-Installation (unter Windows "C:\Programme\JControl\demos\cobra5329\WombatTutorial\WombatLabelBorderExample"). Bild 5 zeigt einen Screenshot.

Bild 5: Das WombatLabelBorderExample

1	/**
2	* <p>This example demonstrates how to use the
3	* components Label and Border within the GUI
4	* framework JControl/Wombat.
5	* This program needs the image resource
6	* 'smile.jcif'.</p>
7	*
8	* <p>(C) DOMOLOGIC Home Automation GmbH 2007/p>
9	*/
10	import jcontrol.ui.wombat.Frame;
11	import jcontrol.ui.wombat.Container;
12	import jcontrol.ui.wombat.Border;
13	import jcontrol.ui.wombat.Label;
14	import jcontrol.io.Resource;
15	import java.io.IOException;
16	import jcontrol.graphics.Color;
17
18	public class WombatLabelBorderExample extends Frame  {
19
20	/**
21	* Constructor WombatLabelBorderExample
22	*/
23	public WombatLabelBorderExample() {
24	// create a container for the content of this frame
25	Container content = new Container();
26
27	// create some borders of different kind
28	Border simpleBorder = new Border("Simple Border", 70, 30, 160, 50,
29	Border.STYLE_SIMPLE_BORDER);
30	content.add(simpleBorder);
31	Border roundBorder = new Border("Round Border", 70, 80, 160, 50,
32	Border.STYLE_ROUND_BORDER);
33	content.add(roundBorder);
34	Border etchedBorder = new Border("Etched Border", 70, 130, 160, 50,
35	Border.STYLE_ETCHED_BORDER);
36	content.add(etchedBorder);
37
38	// create some labels of different kind
39	try {
40	Label label1 = new Label(new Resource("smile.jcif"), 140, 47, 0, 0,
41	Label.STYLE_ALIGN_LEFT);
42	content.add(label1);
43	} catch(IOException ioe) {
44	// must be caught as the Resource-constructor may throw this exception
45	}
46	Label label2 = new Label("Hello World!", 120, 97, 60, 20,
47	Label.STYLE_ALIGN_CENTER);
48	label2.setForegroundColor(Color.WHITE);
49	label2.setBackgroundColor(Color.RED);
50	content.add(label2);
51	Label label3 = new Label("Hello World!", 120, 147, 60, 20,
52	Label.STYLE_ALIGN_CENTER|Label.STYLE_SHOW_BORDER);
53	label3.setBackgroundColor(Color.WHITE);
54	content.add(label3);
55
56	// set the content to this frame
57	setContent(content);
58	// finally, make the frame visible
59	setVisible(true);
60	}
61
62	/**
63	* The main method.
64	*
65	* @param args
66	*        The main arguments
67	*/
68	public static void main(String[] args) {
69	new WombatLabelBorderExample();
70	}
71	}

Listing 5: WombatLabelBorderExample.java

---

© 2000-2006 DOMOLOGIC Home Automation GmbH. All Rights Reserved.