Realizziamo adesso un esempio meno banale, ovvero un convertitore da Lire in Euro e viceversa. L'intero listato è visibile nel listato 1 , che descriviamo in questo paragrafo. Abbiamo due classi, la classe principale Euro che estende MainWindow , e una classe EuroCvt. La classe principale è un contenitore, che comprende una tab bar e l'area di lavoro della seconda classe. La seconda classe è un generico convertitore da x a y in base ad una costante k.

import waba.ui.*;
import waba.fx.*;
import waba.sys.*;

class EuroCvt extends Container
{

	Label lfrom;
	Label lto;
	Edit from;
	Label to;
	Button cvt;
	float kcvt;


	EuroCvt(String sfrom, String sto, float k)
	{

		kcvt = k;
		lfrom= new Label(sfrom, Label.RIGHT);
		lfrom.setRect(5, 0, 40, 18);
		add(lfrom);

		from = new Edit();
		from.setText("0");
		from.setRect(55, 0, 60, 18);
		add(from);


		lto= new Label(sto, Label.RIGHT);
		lto.setRect(5, 20, 40, 18);
		add(lto);

		to = new Label("0");
		to.setRect(57, 20, 60, 18);
		add(to);

		cvt = new Button("Converti");
		cvt.setRect(40, 40, 60, 18);
		add(cvt);


		Label tmp = new Label("written by Michele Sciabarra'");
		tmp.setRect(2, 60, 60, 18);
		add(tmp);
		tmp = new Label("(c) 1999 SATORI Network Solutions");
		tmp.setRect(2, 80, 60, 18);
		add(tmp);
		//tmp = new Label("k = "+Convert.toString(kcvt));
		//tmp.setRect(2, 100, 60, 18);
		//add(tmp);


	}

	public void onEvent(Event event)
	{
		if (event.type == ControlEvent.PRESSED && event.target==cvt)
		{
			float f = Convert.toInt(from.getText()) * kcvt;
			String s  = Convert.toString((int)(f*100));
			int l = s.length();
			to.setText(s.substring(0, l-2).concat(".").concat(s.substring(l-2,l)));
		}

	}
}



public class Euro extends MainWindow
{
TabBar bar;
Tab euro;
Tab lit;
EuroCvt lit2euro;
EuroCvt euro2lit;


public Euro()
	{
	TabBar bar = new TabBar();
	lit = new Tab("Lit");
	bar.add(lit);
	euro = new Tab("Euro");
	bar.add(euro);

	bar.setRect(0, 0, this.width, 20);
	add(bar);

	float k = (float)1937.26;
	lit2euro = new EuroCvt("Lit", "Euro", 1/k);
	lit2euro.setRect(0, 30, this.width, this.height - 30);
	euro2lit = new EuroCvt("Euro", "Lit", k);
	euro2lit.setRect(0, 30, this.width, this.height - 30);

	add(lit2euro);
	}

public void onPaint(Graphics g)
	{
	g.setColor(0, 0, 0);
	g.drawLine(160, 0, 160, 160);
	g.drawLine(0, 160, 160, 160);
	}


public void onEvent(Event event)
	{

	if (event.type == ControlEvent.PRESS
ED)
		{
		if (event.target == lit)
			{
			remove(euro2lit);
			add(lit2euro);
			}
		else if (event.target == euro)
			{
			remove(lit2euro);
			add(euro2lit);
			}
		}
	}
}
  

A secondo di quale tab si seleziona sceglie appare uno dei due convertitori, ovvero una istanza di EuroCvt inizializzata con opportuni parametri, in modo da convertire da Lire in Euro o viceversa. Nel costruttore, Euro non fa altro che creare due istanze di EuroCvt, e gestire gli eventi di selezione del pannello. Notare attentamente nel listato che ogni elemento di interfaccia viene creato e aggiunto al suo container, ma che la sua posizione viene determinata in coordinate assolute utilizzando setRect(). La gestione di eventi di Euro (metodo onEvent) semplicemente visualizza l'EuroCvt che converte da lire ad euro oppure quella da euro a lire (metodi add e remove del Container). La classe EuroCvt è quella che fa la maggior parte del lavoro. Il costruttore è parametrico in modo da poter specificare i nomi delle valute sorgente e destinazione, compresa una costante moltiplicativa che permette di convertire una valuta nell'altra. Il costruttore definisce e posiziona tutti gli elementi di interfaccia mentre la gestione eventi raccoglie solo la pressione del tasto "Converti" ed effettua la conversione. Notare come l'arrotondamento a due cifre, per carenza di funzioni matematiche adeguate, viene fatto utilizzando la gestione di stringhe.

Il nosto convertitore di Euro e Lire in azione

Figura 4

Java ha attirato da tempo l'attenzione degli sviluppatori di applicazioni per sistemi embedded, dove ancora domina il C, e il C++ si rivela talvolta inadeguato. L'implementazione JDK di Java non è assolutamente pensata per l'uso real-time o in ambienti con stringenti requisiti di memoria, tutt'altro. Ciò nonostante la somiglianza con C e C++ e la semplicità unita alla potenza del linguaggio hanno fatto nascere un movimento di interesse intorno alle prospettive di uso di Java in questi ambiti. Non esiste solo Waba: ci sono numerose altre soluzioni come compilatori nativi o implementazioni real-time di Java (il Perc per esempio). Recentemente Sun e altri hanno costituito un Jconsortium proprio per studiare e standardizzare il Java real-time. Non dimentichiamoci che la prima applicazione di Java è stato proprio un sistema embedded (un telecomando intelligente), che Motorola (e altri) hanno preso in licenza la tecnologia Java, e dunque la prospettiva di avere il Duke nel nostro prossimo telefono cellulare è tutt'altro che campata in aria.