GUI-Programmierung mit JControl/Vole

V. Messinstrumente

JControl/Vole stellt im Package jcontrol.ui.vole.meter verschiedene Messinstrumente mit vielfältigen Konfigurations-Optionen zur Verfügung. In diesem Kapitel werden die einzelnen Komponenten vorgestellt. Die Programmierung wird dabei anhand von Quelltext-Beispielen dargestellt.



AnalogMeter

Die GUI-Komponente AnalogMeter stellt ein analoges Zeiger-Messinstrument grafisch dar. Die Größe des Messinstruments ist dabei frei skalierbar, wahlweise können Beschriftungen hinzugefügt werden. Außerdem sind der Öffnungswinkel und die Orientierung der Skala sowie die Anzahl der Teilstriche einstellbar. Tabelle 1 fasst die wichtigsten Methoden von AnalogMeter zusammen:

MethodeBeschreibung
AnalogMeter(int x, int y, int width, int height, int min, int max, int openAngle, int orientation, int dials)Erzeugt ein neues AnalogMeter an den angegebenen Koordinaten. Die Parameter min und max spezifizieren den Wertebereich der Skala, dials gibt die gewünschte Anzahl Teilstriche an. openAngle ist der gewünschte Öffnungswinkel und orientation beschreibt die Ausrichtung des AnalogMeters (mögliche Werte sind ORIENTATION_CENTER, ORIENTATION_LEFT oder ORIENTATION_RIGHT). Bei ORIENTATION_LEFT und ORIENTATION_RIGHT ist der Öffnungswinkel auf 90° begrenzt.
setCaption(String captionMin, String captionMax)Fügt dem AnalogMeter eine Beschriftung hinzu. Die beiden übergebenen Strings werden am Anfang und am Ende der Skala dargestellt.
setNumericDisplay(int digits, int decimals, String unit)Mittels dieser Methode kann die alphanumerische Messwertanzeige konfiguriert werden. Der Parameter digits definiert die Anzahl der anzuzeigenden Stellen. Der Parameter decimals bestimmt, wieviele Nachkommanstellen angezeigt werden sollen (diese sind im Wert von digits enthalten). Beispiel: digits=4 und decimals=3 ergibt die Zahlendarstellung: x,xxx. Im Fall decimals=0 wird kein Komma eingefügt. Diese Funktion ist nützlich, wenn die an das AnalogMeter übermittelten Werte z.B. in mV angegeben sind, bei der Visualisierung aber V angezeigt werden sollen. Der String unit schließlich gibt die Einheit der Messwerte an (z.B. "V").
setValue(int value)Übergibt einen neuen Messwert an das AnalogMeter, welches daraufhin aktualisiert wird. Liegt der Wert von value außerhalb des Wertebereichs, so wird er entsprechend durch den minimal, bzw. maximal anzeigbaren Wert ersetzt.
Tabelle 1: Methoden der Klasse jcontrol.ui.vole.meter.AnalogMeter

Das unten gelistete Beispielprogramm VoleAnalogMeterExample demonstriert den Umgang mit dem AnalogMeter und einiger der in Tabelle 1 aufgeführten Methoden. Es ist in dem ZIP-Archiv VoleAnalogMeterExample.zip http://www.jcontrol.org/examples/VoleAnalogMeterExample.zip zusammen mit einem gleichnamigen JControl/IDE-Projekt enthalten. Starten Sie den Simulator, um das Beispielprogramm auszuprobieren.

Bild 1: Das VoleAnalogMeterExample

1    import jcontrol.lang.Math;
2    import jcontrol.lang.ThreadExt;
3    import jcontrol.ui.vole.Border;
4    import jcontrol.ui.vole.Container;
5    import jcontrol.ui.vole.Frame;
6    import jcontrol.ui.vole.Label;
7    import jcontrol.ui.vole.meter.AnalogMeter;
8    
9    /**
10     * <p>This example demonstrates how to use the
11     * component AnalogMeter within the GUI framework
12     * JControl/Vole.</p>
13     *
14     * <p>(C) DOMOLOGIC Home Automation GmbH 2003-2005</p>
15     */
16    public class VoleAnalogMeterExample extends Frame {
17      AnalogMeter am1, am2, am3;
18     
19      /**
20       * Create three AnalogMeters with different configurations.
21       */
22      public VoleAnalogMeterExample() {
23        Container container = new Container();
24        jcontrol.io.Backlight.setBrightness(255);
25        // create the first AnalogMeter
26        am1 = new AnalogMeter(0, 10, 30, 30, 0, 70, 90,
27                              AnalogMeter.ORIENTATION_LEFT, 10);
28        am1.setNumericDisplay(4, 1, null);
29               
30        container.add(am1);
31        container.add(new Label("RPM", 0, 42, 30, 10,
32                                Label.ALIGN_CENTER));
33     
34        // create the second AnalogMeter
35        am2 = new AnalogMeter(35, 10, 58, 30, 0, 120, 180,
36                              AnalogMeter.ORIENTATION_CENTER, 20);
37        am2.setNumericDisplay(4, 1, null);
38       
39        container.add(am2);
40        container.add(new Label("Volt", 35, 42, 58, 10,
41                                Label.ALIGN_CENTER));
42       
43        // create the third AnalogMeter
44        am3 = new AnalogMeter(100, 10, 30, 30, 0, 200, 90,
45                              AnalogMeter.ORIENTATION_RIGHT, 10);
46        am3.setNumericDisplay(4, 2, null);
47       
48        container.add(am3);
49        container.add(new Label("Ampere", 95, 42, 30, 10,
50                                Label.ALIGN_CENTER));
51    
52        // add a border
53        container.add(new Border("AnalogMeters", 0, 0, 128, 51));
54       
55        // add the container to the frame
56        this.add(container);
57       
58        // make us visible
59        show();
60       
61       
62        // create some random values
63        for (;;) {
64          am1.setValue(Math.rnd(70));
65          am2.setValue(Math.rnd(120));
66          am3.setValue(Math.rnd(200));
67         
68          try {
69            ThreadExt.sleep(1000);
70          } catch (InterruptedException e) {}
71        }   
72      }
73    
74      // Instantiate and show the VoleAnalogMeterExample
75      public static void main(String[] args) {
76        new VoleAnalogMeterExample();
77      }
78    }
Listing 1: VoleAnalogMeterExample.java


DigitalMeter und SevenSegmentMeter

Die beiden UI-Komponenten DigitalMeter und SevenSegmentMeter dienen der alphanumerischen Darstellung von Messwerten. Sie unterscheiden sich hauptsächlich in der Art der Darstellung voneinander: Während beim DigitalMeter benutzerspezifische Schriftarten (Fonts) eingesetzt werden können, zeichnet SevenSegmentMeter die Ziffern als Polygone auf das Display, die dem Erscheinungsbild einer (LED-)Siebensegmentanzeige ähneln.

Das SevenSegmentMeter ist -- bis zu einer gewissen Mindestgröße -- frei skalierbar. Die Größe des DigitalMeter hängt von der eingestellten Schriftart ab (Methode setFont(Resource font)). Neben den Konstruktoren, die in Tabelle 2 aufgeführt sind, spielt bei beiden Komponenten im Wesentlichen nur die Methode setValue(int value) eine Rolle, mit der der aktuell anzuzeigende Messwert übergeben werden kann.

MethodeBeschreibung
DigitalMeter(int x, int y, int digits, int decimals)Erstellt ein neues DigitalMeter an der angegebenen Position. Der Parameter digits bestimmt die Anzahl der angezeigten Dezimalziffern. Breite und Höhe der GUI-Komponente ergeben sich aus der Anzahl Ziffern und der mittels setFont eingestellten Schriftart. decimals gibt die Anzahl der Nachkommastellen an, die in digits enthalten sind (an entsprechender Stelle wird ein Komma eingefügt).
SevenSegmentMeter(int x, int y, int width, int height, int digits, int decimals)Dieser Konstruktor erzeugt ein neues SevenSegmentMeter mit den angebenen Koordinaten und Maßen. Der Parameter digits gibt die gewünschte Anzahl Dezimalstellen an. decimals gibt die Anzahl der Nachkommastellen an, die in digits enthalten sind (an entsprechender Stelle wird ein Komma eingefügt).
setValue(int value)Übergibt einen neuen Messwert an das SevenSegmentMeter, bzw. DigitalMeter, welches daraufhin aktualisiert wird.
Tabelle 2: Methoden der Klassen jcontrol.ui.vole.meter.SevenSegmentMeter und DigitalMeter

Der in Bild 2 dargestellte Screenshot zeigt das im Folgenden abgedruckte Beispielprogramm VoleDigitalMeterExample, welches ein DigitalMeter und ein SevenSegmentMeter instantiiert und auf dem Display darstellt.

Bild 2: Das VoleDigitalMeterExample

1    import java.io.IOException;
2    
3    import jcontrol.io.Resource;
4    import jcontrol.lang.Math;
5    import jcontrol.lang.ThreadExt;
6    import jcontrol.ui.vole.Border;
7    import jcontrol.ui.vole.Frame;
8    import jcontrol.ui.vole.meter.DigitalMeter;
9    import jcontrol.ui.vole.meter.SevenSegmentMeter;
10    
11    /**
12     * <p>This example demonstrates how to use the
13     * component DigitalMeter within the GUI framework
14     * JControl/Vole.
15     * This example needs the font resource
16     * "arial24.jcfd".</p>
17     *
18     * <p>(C) DOMOLOGIC Home Automation GmbH 2003-2005</p>
19     */
20    public class VoleDigitalMeterExample extends Frame {
21     
22      public VoleDigitalMeterExample() {
23        // create the DigitalMeter
24        DigitalMeter dm = new DigitalMeter(13, 20, 3, 1);
25    
26        // set the Font of the DigitalMeter
27        try {
28          dm.setFont(new Resource("arial24.jcfd"));
29        } catch (IOException e) {}
30    
31        // add the DigitalMeter to the Frame
32        this.add(dm);
33       
34        // create the LCDMeter
35        SevenSegmentMeter sm = new SevenSegmentMeter(70, 10, 50,
36                                                     50, 2, 0);
37        this.add(sm);
38       
39        // make some pretty borders
40        this.add(new Border("DigitalMeter", 0, 0, 63, 60));
41        this.add(new Border("SevenSegment", 64, 0, 63, 60));
42       
43        // make the frame visible
44        show();
45       
46       
47        // produce some random values
48        for (;;) {
49          dm.setValue(Math.rnd(2000)-1000);
50          sm.setValue(Math.rnd(150)-50);
51          try{ ThreadExt.sleep(1000); }catch(InterruptedException e){}
52        }
53      }
54    
55      // start the demonstration
56      public static void main(String[] args) {
57        new VoleDigitalMeterExample();
58      }
59    }
Listing 2: VoleDigitalMeterExample.java


BarMeter

Das BarMeter kann entweder horizontal oder vertikal dargestellt werden und unterstützt zwei verschiedene Texturen (gefüllt oder liniert).

Neben den Standardmethoden wie setValue oder setBounds bietet das BarMeter noch einige spezielle Konfigurationsoptionen an. Diese sind in Tabelle 3 aufgeführt.

MethodeBeschreibung
BarMeter(int x, int y, int width, int height, int min, int max, boolean orientation, int style)Erzeugt ein neues BarMeter mit den angegebenen Ausmaßen. Die Werte min und max beschreiben den Wertebereich der Messwertanzeige. Der Wert von style legt den Füllstil fest. Mit Hilfe des Parameters orientation kann konfiguriert werden, ob das BarMeter liegend (ORIENTATION_HORIZONTAL) oder stehend (ORIENTATION_VERTICAL) dargestellt werden soll.
setCaption(String captionMin, String captionMax)Gibt Strings zur Beschriftung des BarMeters an.
setNumericDisplay(int digits, int decimals, String unit)Mittels dieser Methode kann die alphanumerische Messwertanzeige konfiguriert werden. Der Parameter digits definiert die Anzahl der anzuzeigenden Stellen. Der Parameter decimals bestimmt, wieviele Nachkommanstellen angezeigt werden sollen (diese sind im Wert von digits enthalten). Beispiel: digits=4 und decimals=3 ergibt die Zahlendarstellung: x,xxx. Im Fall decimals=0 wird kein Komma eingefügt. Der String unit schließlich gibt die Einheit der Messwerte an (z.B. "V").
setValue(int value)Übergibt einen neuen Messwert an das BarMeter, welches daraufhin aktualisiert wird. Liegt der Wert von value außerhalb des Wertebereichs, so wird er entsprechend durch den minimal, bzw. maximal anzeigbaren Wert ersetzt.
Tabelle 3: Methoden der Klasse jcontrol.ui.vole.meter.BarMeter

Im Folgenden ist das Beispielprogramm VoleBarMeterExample abgedruckt. Wenn Sie das Programm aus der ZIP-Datei VoleBarMeterExample.zip http://www.jcontrol.org/examples/VoleBarMeterExample.zip in Ihre JControl/IDE laden und dann den Simulator starten, müsste sich ein Bild ähnlich Abbildung 3 ergeben.

Bild 3: Das VoleBarMeterExample

1    import jcontrol.lang.Math;
2    import jcontrol.lang.ThreadExt;
3    import jcontrol.ui.vole.Frame;
4    import jcontrol.ui.vole.meter.BarMeter;
5    
6    /**
7     * <p>This example demonstrates how to use the
8     * components BarMeter and Thermometer within
9     * the GUI framework JControl/Vole.</p>
10     *
11     * <p>(C) DOMOLOGIC Home Automation GmbH 2003-2005</p>
12     */
13    public class VoleBarMeterExample extends Frame {
14     
15      /**
16       * Draw two BarMeters and a Thermometer
17       */
18      public VoleBarMeterExample() {
19        // create a vertical BarMeter with solid fill and inscriptions
20        BarMeter bm1 = new BarMeter(5, 0, 30, 35, 0, 20,
21                                    BarMeter.ORIENTATION_VERTICAL,
22                                    BarMeter.FILL_SOLID);
23        bm1.setCaption("Min", "Max");
24        this.add(bm1);
25       
26        // create a horizontal BarMeter with line-style fill
27        BarMeter bm2 = new BarMeter(5, 40, 100, 20, 0, 100,
28                                    BarMeter.ORIENTATION_HORIZONTAL,
29                                    BarMeter.FILL_LINE);
30        bm2.setCaption("0", "20");
31        bm2.setNumericDisplay(5, 0, "%");
32        this.add(bm2);
33       
34        // make the frame visible
35        show();
36       
37        // generate random values
38        for (;;) {
39          bm1.setValue(Math.rnd(20));
40          bm2.setValue(Math.rnd(100));
41         
42          try { ThreadExt.sleep(1000); } catch (InterruptedException e) {}
43        }
44      }
45    
46      /**
47       * Start the example
48       */
49      public static void main(String[] args) {
50        new VoleBarMeterExample();
51      }
52    }
Listing 3: VoleBarMeterExample.java


Thermometer

Für die Anzeige von Temperaturwerten ist das Thermometer besonders gut geeignet. Die Darstellung als Quecksilberthermometer sorgt für eine intuitive Interpretation als Temperaturanzeige. Im Gegensatz hierzu steht z.B. das AnalogMeter, bei welchem erst der String unit Aufschluss über den angezeigten Wert gibt.

Neben den Standardmethoden wie setValue oder setBounds bietet das Thermometer noch einige spezielle Konfigurationsoptionen an. Diese sind in Tabelle 4 aufgeführt.

MethodeBeschreibung
Thermometer(int x, int y, int width, int height, int min, int max)Erstellt ein neues Thermometer mit der spezifizierten Größe an den angegebenen Koordinaten. Die Parameter min und max geben den Wertebereich vor.
setCaption(String captionMin, String captionMax)Ändert die Beschriftung des Thermometers. Hier können Strings für den minimalen und den maximalen Messwert angegeben werden, diese werden rechts unten und rechts oben der Skala gezeichnet.
setNumericDisplay(int digits, int decimals, String unit)Mittels dieser Methode kann die alphanumerische Messwertanzeige konfiguriert werden. Der Parameter digits definiert die Anzahl der anzuzeigenden Stellen. Der Parameter decimals bestimmt, wieviele Nachkommanstellen angezeigt werden sollen (diese sind im Wert von digits enthalten). Beispiel: digits=4 und decimals=3 ergibt die Zahlendarstellung: x,xxx. Im Fall decimals=0 wird kein Komma eingefügt. Der String unit schließlich gibt die Einheit der Messwerte an (z.B. "V").
setValue(int value)Übergibt einen neuen Messwert an das Thermometer, welches daraufhin aktualisiert wird. Liegt der Wert von value außerhalb des Wertebereichs, so wird er entsprechend durch den minimal, bzw. maximal anzeigbaren Wert ersetzt.
Tabelle 4: Methoden der Klasse jcontrol.ui.vole.meter.Thermometer

Im Folgenden ist das Beispielprogramm VoleThermometerExample abgedruckt. Wenn Sie das Programm aus der ZIP-Datei VoleBarMeterExample.zip http://www.jcontrol.org/examples/VoleThermometerExample.zip in Ihre JControl/IDE laden und dann den Simulator starten, müsste sich ein Bild ähnlich Abbildung 4 ergeben.

Bild 4: Das VoleThermometerExample

1    import jcontrol.lang.Math;
2    import jcontrol.lang.ThreadExt;
3    import jcontrol.ui.vole.Border;
4    import jcontrol.ui.vole.Container;
5    import jcontrol.ui.vole.Frame;
6    import jcontrol.ui.vole.Label;
7    import jcontrol.ui.vole.meter.Thermometer;
8    
9    /**
10     * <p>This example demonstrates how to use the
11     * component Thermometer within the GUI framework
12     * JControl/Vole.</p>
13     *
14     * <p>(C) DOMOLOGIC Home Automation GmbH 2003-2005</p>
15     */
16    public class VoleThermometerExample extends Frame {
17      Thermometer tm1, tm2;
18     
19      /**
20       * Create three AnalogMeters with different configurations.
21       */
22      public VoleThermometerExample() {
23        Container container = new Container();
24        jcontrol.io.Backlight.setBrightness(255);
25       
26        // create the first Thermometer
27        //
28        // NOTE: The String "\u00b0" hereby represents the
29        //       UTF8 version of the 'degree' character
30        tm1 = new Thermometer(8, 10, 50, 45, 0, 400);
31        tm1.setNumericDisplay(5, 1, "\u00b0C"); 
32        tm1.setCaption("0\u00b0C", "+40\u00b0C");
33    
34        container.add(tm1);
35        container.add(new Label("Inside Temp.", 8, 55, 50, 8,
36                                Label.ALIGN_CENTER));
37     
38        // create the second Thermometer
39        //
40        // NOTE: The String "\u00b0" hereby represents the
41        //       UTF8 version of the 'degree' character
42        tm2 = new Thermometer(68, 10, 50, 45, -300, 500);
43        tm2.setNumericDisplay(5, 1, "\u00b0C");
44        tm2.setCaption("-30\u00b0C", "+50\u00b0C");
45       
46        container.add(tm2);
47        container.add(new Label("Outside Temp.", 68, 55, 50, 8,
48                                Label.ALIGN_CENTER));
49       
50        // add a border
51        container.add(new Border("Thermometers", 0, 0, 128, 64));
52       
53        // add the container to the frame
54        this.add(container);
55       
56        // make us visible
57        show();   
58       
59        // create some random values
60        for (;;) {
61          tm1.setValue(Math.rnd(400));
62          tm2.setValue(Math.rnd(800)-300);
63         
64          try {
65            ThreadExt.sleep(1000);
66          } catch (InterruptedException e) {}
67        }   
68      }
69    
70      // Instantiate and show the VoleAnalogMeterExample
71      public static void main(String[] args) {
72        new VoleThermometerExample();
73      }
74    }
Listing 4: VoleThermometerExample.java

Anmerkung: Die Zeichenkette "\u00b0C" in Zeile 42 steht für "°C". Bei der Sequenz "\u00b0" handelt es sich um die hexadezimale UTF-8-Schreibweise des Grad-Zeichens. Wir verwenden diese, weil manche Editoren das (Sonder-)Zeichen "°" beim Speichern leider modifizieren und es dann auf dem JControl-Gerät nicht mehr richtig dargestellt werden kann.


AnalogClock

AnalogClock ist eine GUI-Komponente zur einfachen grafischen Darstellung einer analogen Uhr mit Stunden-, Minuten- und Sekundenzeiger. Die AnalogClock ist frei skalierbar. Da sie aber nicht animiert ist, muss diese Aufgabe von der Anwendung übernommen werden. Dazu kann die Methode setValue aufgerufen werden, womit die Zeigerposition aktualisiert wird.

Bild 5 zeigt einen Screenshot der JControl-Anwendung VoleAnalogClockExample. Der Quelltext ist unten aufgelistet. Das Beispielprogramm demonstriert die Befehle zur Instantiierung einer AnalogClock und zeigt, wie die Uhrzeit durch eine einfache Schleife fortlaufend aktualisiert werden kann.

Bild 5: Das VoleAnalogClockExample

1    import jcontrol.lang.ThreadExt;
2    import jcontrol.system.Time;
3    import jcontrol.ui.vole.Border;
4    import jcontrol.ui.vole.Frame;
5    import jcontrol.ui.vole.meter.AnalogClock;
6    
7    /**
8     * <p>This example demonstrates how to use the
9     * component AnalogClock within the GUI framework
10     * JControl/Vole.</p>
11     *
12     * <p>(C) DOMOLOGIC Home Automation GmbH 2003-2005</p>
13     */
14    public class VoleAnalogClockExample extends Frame {
15     
16      /**
17       * Create and continuosly update an AnalogClock
18       */
19      public VoleAnalogClockExample() {
20        // create a new AnalogClock
21        AnalogClock ac = new AnalogClock(35, 7, 26, true);
22        this.add(ac);
23       
24        // add a border
25        this.add(new Border("Analog Clock", 26, 0, 70, 64));
26       
27        // make us visible
28        show();
29       
30        // update the AnalogClock's time once a second
31        for (;;) {
32          Time t = new Time();
33          ac.setValue(t.hour, t.minute, t.second);
34          try {
35            ThreadExt.sleep(1000);
36          } catch (InterruptedException e) {}
37        }     
38      }
39    
40      /**
41       * Instantiate the example
42       */
43      public static void main(String[] args) {
44        new VoleAnalogClockExample();
45      }
46    }
Listing 5: VoleAnalogClockExample.java


FanMeter

Die GUI-Komponente FanMeter symbolisiert einen Ventilator, der automatisch animiert werden kann. Dazu implementiert FanMeter das speziell für animierte Komponenten gedachte Interface Animateable. Fügt man ein FanMeter-Objekt einem AnimationContainer hinzu, sorgt dieser automatisch für die Bewegung des FanMeters.

Das FanMeter ist mit einer Dezimalwert-Anzeige versehen und kann zusätzlich eine Beschriftung erhalten. Dazu stehen die in Tabelle 6 aufgelisteten Methoden zur Verfügung. Die Animation des Ventilators erfolgt nur, wenn der angezeigte Wert größer als Null ist.

MethodeBeschreibung
FanMeter(int x, int y)Instantiiert einen neuen FanMeter an der angebenen Position.
animate()Bewegt die Ventilatorblätter des Ventilators, so dass ein Animationseffekt entsteht. Diese Methode kann zwar durch das Anwendungsprogramm aufgerufen werden, sollte aber im Normalfall einem AnimationContainer überlassen werden.
setCaption(String caption)Mit dem Parameter caption kann eine Beschriftung übergeben werden, die rechts von dem Ventilator-Sinnbild dargestellt wird.
setNumericDisplay(int digits, int decimals, String unit)Mittels dieser Methode kann die alphanumerische Messwertanzeige konfiguriert werden. Der Parameter digits definiert die Anzahl der anzuzeigenden Stellen. Der Parameter decimals bestimmt, wieviele Nachkommanstellen angezeigt werden sollen (diese sind im Wert von digits enthalten). Beispiel: digits=4 und decimals=3 ergibt die Zahlendarstellung: x,xxx. Im Fall decimals = 0 wird kein Komma eingefügt. Der String unit schließlich gibt die Einheit der Messwerte an (z.B. "V").
setValue(int value)Übergibt einen neuen Messwert an das FanMeter, welches daraufhin aktualisiert wird.
Tabelle 6: Methoden der Klasse jcontrol.ui.vole.meter.FanMeter

Das im Folgenden gelistete Beispielprogramm demonstriert die Verwendung der GUI-Komponente FanMeter im Zusammenhang mit einem AnimationContainer. Letzterer unterscheidet sich nur wenig von einem normalen Container, erkennt aber automatisch animierbare GUI-Komponenten und erzeugt nach ihrem Hinzufügen einen Prozess, der regelmäßig deren Methode animate aufruft. Dem Programmierer stellt die Klasse AnimationContainer zwei zusätzliche Methoden bereit:

MethodeBeschreibung
setAnimation(boolean animate)Mit dieser Methode kann die Animation der im AnimationContainer enthaltenen GUI-Komponenten ein- und ausgeschaltet werden.
setAnimationInterval(int interval)Stellt die Geschwindigkeit der Animation ein. Der Parameter interval gibt dabei den Zeitraum zwischen zwei Animations-Schritten in Millisekunden an.
Tabelle 7: Methoden der Klasse jcontrol.ui.vole.AnimationContainer

Abgesehen von den Zusatzfunktionen für animierte GUI-Komponenten verhalten sich AnimationContainer genau wie normale Container. Sie können übrigens eine animierbare GUI-Komponente wie den FanMeter auch einem normalen Container hinzufügen, dann wird es allerdings nicht animiert. Ebenso können einem AnimationContainer auch nicht-animierbare GUI-Komponenten hinzugefügt werden.

Laden Sie das VoleFanMeterExample in Ihre JControl/IDE und starten Sie den Simulator. Dann sollten Sie ein ähnliches Bild wie in Abbildung 6 präsentiert bekommen mit dem Unterschied, dass sich die Ventilatorblätter drehen.

Bild 6: Das VoleFanMeterExample

1    import jcontrol.lang.Math;
2    import jcontrol.lang.ThreadExt;
3    import jcontrol.ui.vole.AnimationContainer;
4    import jcontrol.ui.vole.Border;
5    import jcontrol.ui.vole.Frame;
6    import jcontrol.ui.vole.meter.FanMeter;
7    
8    /**
9     * <p>This example demonstrates how to use the
10     * component FanMeter within the GUI framework
11     * JControl/Vole.</p>
12     *
13     * <p>(C) DOMOLOGIC Home Automation GmbH 2003-2005</p>
14     */
15    public class VoleFanMeterExample extends Frame {
16     
17      /**
18       * Create an animateable Fan and add it to an AnimationContainer
19       */
20      public VoleFanMeterExample() {
21        // create two Fans
22        FanMeter fan1 = new FanMeter(10, 10);
23        fan1.setCaption("The 1st Fan");
24        fan1.setNumericDisplay(5,0,"RPM");
25        FanMeter fan2 = new FanMeter(10, 30);
26        fan2.setCaption("Another Fan");
27        fan2.setNumericDisplay(5,0,"RPM");
28       
29        // create a Border around them
30        this.add(new Border("The Fans", 5, 0, 70, 50));
31       
32        // create an AnimationContainer and add the Fans
33        AnimationContainer ac = new AnimationContainer();
34        ac.add(fan1);
35        ac.add(fan2);
36       
37        // add the AnimationContainer to the Frame
38        this.add(ac);
39        show();
40       
41        // create some random values
42        for (;;) {
43          fan1.setValue(4800+Math.rnd(500));
44          fan2.setValue(3400+Math.rnd(200));
45          try {
46            ThreadExt.sleep(1000);
47          } catch (InterruptedException e) {}
48        }
49      }
50    
51      /**
52       * Instantiate the VoleFanExample
53       */
54      public static void main(String[] args) {
55        new VoleFanMeterExample();
56      }
57    }
Listing 6: VoleFanMeterExample.java


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