Le interfacce utente grafiche1 (Graphical User Interface)
Il primo package Java che gestisce gli elementi di una GUI è awt. Gli elementi di una GUI si
distinguono in oggetti di due tipi:
• oggetti contenitori
• oggetti componenti
Java usa un sistema generico per gestire la grafica, definendo elementi grafici comuni (oggetti
componenti che possono essere contenitori) in modo da costruire programmi eseguibili su varie
piattaforme e con ambienti grafici differenti (Windows ha un modo di visualizzare le finestre e gli
altri elementi grafici diverso da quello usato da Linux o da MacOs cioè il sistema operativo della
Applet). Il secondo pakage Java che gestisce gli elementi di una GUI, detto swing, è un'estensione
di awt e permette la vera indipendenza dalla piattaforma.
Tra i tipici oggetti contenitori il package awt rende disponibili:
•
•
•
frame (finestra): la classica finestra costituita da un’area rettangolare e da una barra del titolo
panel (pannello): la forma più comune di contenitore che può essere visualizzato sullo schermo.
canvas (area di disegno): una semplice superficie di disegno particolarmente utile per
visualizzare immagini o per effettuare altre operazioni grafiche.
I componenti sono oggetti con una propria rappresentazione grafica. Alcuni importanti componenti
della GUI di Java sono:
• Label (etichette)
• Button (pulsanti)
• TextField (campi di testo)
• TextArea (aree di testo)
• Checkbox (caselle di controllo)
Nella gerarchia di classi per i componenti ed i contenitori in Java si può notare che la radice della
maggior parte degli elementi dei packages grafici è rappresentata dalla classe astratta Component
(che a sua volta eredita dalla superclasse Object, superclasse di tutti gli oggetti Java).
La classe Frame eredita da Window che eredita da Container2.
Le classi TextField e TextArea ereditano da TextComponent con radice Component.
Le classi Canvas, Button, CheckBox ereditano direttamente da Component.
A differenza delle applicazioni, un’applet, non necessita di una finestra per essere eseguita infatti la
finestra è quella del browser a cui si aggiunge un pannello che rappresenta l’applet.
La classe Applet, infatti, eredita da Panel che eredita da Container la cui radice è appunto
Component.
1 Da libro Gallo-Salerno “Java – La programmazione a oggetti” ed. Minerva Italica [UD C3]
2 Containers http://java.sun.com/docs/books/tutorial/uiswing/components/components.html
Creazione e uso dei contenitori standard3
La classe Frame ha i seguenti metodi costruttori:
•
•
Frame()
Frame(“Stringa”)
Crea una finestra senza titolo
Crea una finestra senza titolo specificato in Stringa
Altri metodi che si applicano ad un oggetto della classe Frame:
•
•
•
•
•
•
setSize(larghezza, altezza)
setLocation( x, y)
pack()
setVisible(boolean)
setResizable(boolean)
dispose()
Dimensiona la finestra
Posiziona la finestra (coordinate del punto in alto a sinistra)
Ottimizza le dimensioni della finestra a seconda del contenuto
Per rendere visibile la finestra se true (deprecato il metodo show())
Per rendere ridimensionabile con mouse se true
Per chiudere la finestra, deallocando le risorse
La classe Panel ha il seguente metodo costruttore:
•
Panel ()
Crea un pannello per inserire componenti GUI
L’inserimento degli oggetti all’interno dei contenitori si realizza con il metodo add() con la
sintassi:
OggettoContenitore.add (OggettoDaAggiungere)
Tale metodo è polimorfo cioè opera su argomenti di diverse classi.
// esempio di Applicazione con uso di oggetti GUI
//
Frame: la finestra con barra del titolo
//
nella barra del titolo l'icona di chiusura
//
non interrompe l’esecuzione à chiudere da shell
//
Pannello: la forma più comune di contenitore
import java.awt.*;
public class Finestra {
public Finestra ()
{
// costruttore
Frame f = new Frame("Visualizza sfondo colorato"); // crea frame invisibile
f.setSize(300,150);
f.setLocation(200,100);
// per impostare le dimensioni e la posizione:
// misure in pixel: larghezza, altezza
// (0,0) angolo sup. sin.
Panel p = new Panel();
p.setBackground(Color. lightGray);
f.add(p);
f.setVisible(true);
// sfondo del pannello colorato
// mostra il frame (dimensioni 300x150)
}
public static void main(String [] args) {
Finestra o = new Finestra();
}
}
3 Per gli stessi esercizi con uso swing
// creo oggetto che "ha - un" Frame ed un Panel
Creazione e uso dei componenti standard
La classe Label : un esempio
// Applicazione con uso dei Componenti di una GUI
// Uso di Panel per introdurre componenti Label e gestione di layout con allineamento in griglia
import java.awt.*;
public class Gui {
public Gui () {
// costruttore
Frame f = new Frame("Finestra con componenti"); // crea frame invisibile
// per impostare le dimensioni e la posizione(misure in pixel) :
f.setSize(300,150);
f.setLocation(200,100);
// (0,0) angolo sup. sin.
f.setResizable(true);
// per ridimensionare con mouse
Panel p = new Panel();
// per inserimento componenti con layout di tipo FlowLayout
// cioè uno di seguito all’altro da sinistra a destra
p.setBackground (Color.lightGray);
p.setLayout(new GridLayout (4,1)); // per evidenziare allineamento 4 RIGHE, 1 COLONNA
f.add(p); // aggiunge al frame il pannello colorato
Label L1 = new Label ("Etichetta con sfondo colorato");
Label L2 = new Label ("Allineata al centro", Label.CENTER);
Label L3 = new Label ("Allineata a sinistra", Label.LEFT);
Label L4 = new Label ("Allineata a destra", Label.RIGHT);
L1.setBackground (Color.cyan);
p.add(L2);
p.add(L3);
p.add(L4);
p.add(L1);
// aggiunge al pannello un'etichetta allineata al centro
// aggiunge al pannello un'etichetta allineata a sinistra
// aggiunge al pannello un'etichetta allineata a destra
// aggiunge al pannello un'etichetta
f.setVisible(true); // mostra il frame (dimensioni 300x150)
}
public static void main(String [] args) {
Gui o = new Gui(); // creo oggetto che "ha - un" Frame ed un Panel e componenti Gui
}
}
Altri metodi :
• String getText()
• setText (“Stringa”)
• int getAlignment()
• int setAlignment(int)
•
setFont(Oggetto_classe_Font)
restituisce il testo dell’etichetta
modifica il testo dell’etichetta
restituisce l’allineamento dell’etichetta (0 o 1 o 2)
modifica l’allineamento dell’etichetta ad esempio:
L.setAlignment (1) con 0 per left , 1 per center, 2 per right
modifica il tipo di carattere dell’etichetta
Le classi Button, TextField, TextArea, Checkbox e CheckboxGroup: un esempio
// Applicazione per illustrare creazione di Componenti di una GUI
// Uso di classe Panel per introdurre componenti (per default con layout di tipo FlowLayout
// cioè i componenti sono aggiunti uno di seguito all’altro da sinistra a destra )
import java.awt.*;
public class Gui2 {
public Gui2 () {
// costruttore
Frame f = new Frame("Finestra con componenti"); // crea frame invisibile
// per impostare le dimensioni e la posizione:
f.setSize(400,400);
// misure in pixel
f.setLocation(200,100);
// (0,0) angolo sup. sin.
f.setResizable(true);
// per ridimensionare con mouse
Panel p = new Panel();
p.setBackground (Color.lightGray); // sfondo colorato
f.add(p); // aggiunge al frame il pannello colorato
Label L = new Label ("Etichetta");
Button B1 = new Button ();
Button B2 = new Button ("Bottone");
B1.setBackground (Color.cyan);
B1.setLabel("Bottone con etichetta"); // imposta il valore dell’etichetta
TextField T1 = new TextField (30);
TextField T2 = new TextField ("immetti il nome", 20);
TextArea A1 = new TextArea(5, 20);
TextArea A2 = new TextArea("immetti una lista di nomi ", 5, 20);
A1.append("Dimensionata con 5 righe e 20 colonne");
Checkbox C1 = new Checkbox();
Checkbox C2 = new Checkbox("Testo");
Checkbox C3 = new Checkbox("Testo attivato", true);
// Per creare pulsanti di opzione (uno solo selezionabile) detti Radio Button
CheckboxGroup cbg = new CheckboxGroup();
Checkbox RB1 = new Checkbox("Lingua Francese", false, cbg);
Checkbox RB2 = new Checkbox("Lingua Inglese", true, cbg);
p.add(L); // aggiunge al pannello un'etichetta con testo
p.add(B1); // aggiunge al pannello un bottone colorato con etichetta
p.add(B2); // aggiunge al pannello un bottone con testo
p.add(T1); // aggiunge al pannello un campo di testo con ampiezza specificata
p.add(T2); // aggiunge al pannello un campo di testo con inizializzazione
// ed ampiezza specificata
p.add(A1); // aggiunge al pannello un' area di testo con Righe e Colonne specificate
p.add(A2); // aggiunge al pannello un'area di testo con inizializzazione
// e Righe e Colonne specificate
p.add(C1); // aggiunge al pannello una casella di controllo vuota e disattivata
p.add(C2); // aggiunge al pannello una casella di controllo con stringa
p.add(C3); // aggiunge al pannello una casella di controllo con stringa ed attivata
p.add(RB1); // aggiunge al pannello i Radio Button
p.add(RB2);
f.setVisible(true);
}
// mostra il frame (dimensioni 400x400)
public static void main(String [] args) {
Gui2 o = new Gui2();
}
}
Altri metodi della classe Button:
• String getLabel()
per ottenere il valore dell’etichetta dell’oggetto
Altri metodi della classe TextField:
• String getText()
per ottenere il testo contenuto nel campo
• setText(“Stringa”)
inserisce nel campo la stringa specificata
Altri metodi della classe Checkbox:
• String getLabel()
restituisce il valore dell’etichetta
• setLabel(“Stringa”)
imposta il valore dell’etichetta
• boolean getState()
restituisce true se la casella è attivata, false altrimenti
• setState(boolean)
imposta lo stato della casella: attivato (true) o disattivato (false)
Altri metodi della classe CheckboxGroup:
• getSelectedCheckbox() serve ad ottenere il valore del Radio Button attualmente selezionato
• setSelectedCheckbox () serve a impostare a selezionato un dato pulsante tra i Radio Button
Posizionamento diretto di un elemento GUI o tramite gestori di layout4
Nel posizionamento diretto (dipendente dalle impostazioni grafiche del sistema) non abbiamo
bisogno di un gestore di layout (layout manager) e dobbiamo indicare questo fatto con l’istruzione:
setLayout (null);
Definiremo poi le dimensioni dell’elemento e lo posizioneremo mediante il metodo setBounds()
con sintassi:
setBounds(x,y,larghezza,altezza) // x,y dell’angolo sup. sin.
Per default il gestore di layout per tutti i contenitori è la classe FlowLayout che aggiunge i
componenti uno di seguito all’altro da sinistra a destra (nello stesso ordine in cui vengono aggiunti
col metodo add ): riempita la prima riga si inizia la seconda e così via.
Abbiamo già fatto uso della classe GridLayout con costruttore GridLayout (numero righe,
numero colonne) per posizionare i componenti nelle celle di una tabella tutte caratterizzate dalla
stessa dimensione. Un altro costruttore permette di impostare anche la spaziatura verticale e quella
orizzontale: GridLayout (num_righe, num_colonne, spaziatura_verticale, spaziatura_orizzontale)
BorderLayout
BorderLayout divide lo schermo in cinque regioni: North, East, West, South, Center.
BorderLayout assicura a North, South, East e West tanto spazio quanto richiedono, lo spazio
rimanente viene assegnato a Center.
BorderLayout può essere costruito con costruttore BorderLayout () oppure con BorderLayout
(spaziatura_orizzontale, spaziatura_verticale) specificano lo spazio orizzontale e verticale tra due
componenti.
nb: nel package swing tali regioni vengono definite dalle costanti BorderLayout.PAGE_START,
BorderLayout.LINE_START,
BorderLayout.LINE_END,
BorderLayout.PAGE_END
e
BorderLayout.CENTER rispettivamente per indicare in alto, a sinistra, a destra, in basso e centro.
4 Gestori di Layout http://java.sun.com/docs/books/tutorial/uiswing/layout/visual.html (guida visuale)
// Lo stesso esempio di Applicazione con uso GUI già usato per introdurre componenti GUI
// in un pannello. Posizionamento tramite gestori di layout: allineamento in griglia
import java.awt.*;
public class Gui2L {
public Gui2L() {
Frame f = new Frame("Finestra con componenti"); // crea frame invisibile
// per impostare le dimensioni e la posizione:
f.setSize(400,400);
// misure in pixel
f.setLocation(200,100);
// (0,0) angolo sup. sin.
f.setResizable(true);
// per ridimensionare con mouse la finestra
Panel p = new Panel();
p.setBackground (Color.lightGray);
p.setLayout(new GridLayout(6,2)); // righe, colonne
f.add(p);
// aggiunge al frame il pannello colorato
Label L = new Label ("Etichetta");
Button B1 = new Button ();
Button B2 = new Button ("Bottone");
B1.setBackground (Color.cyan);
B1.setLabel("Bottone con etichetta");
TextField T1 = new TextField (30);
TextField T2 = new TextField ("immetti il nome", 20);
TextArea A1 = new TextArea(5, 20);
TextArea A2 = new TextArea("immetti una lista di nomi ", 5, 20);
Checkbox C1 = new Checkbox();
Checkbox C2 = new Checkbox("Testo");
Checkbox C3 = new Checkbox("Testo attivato", true);
// Per creare pulsanti di opzione (uno solo selezionabile) detti Radio Button
CheckboxGroup cbg = new CheckboxGroup();
Checkbox RB1 = new Checkbox("Lingua Francese", false, cbg);
Checkbox RB2 = new Checkbox("Lingua Inglese", true, cbg);
p.add(L); // aggiunge al pannello un'etichetta con testo
p.add(B1); // aggiunge al pannello un bottone colorato con etichetta
p.add(B2); // aggiunge al pannello un bottone con testo
p.add(T1); // aggiunge al pannello un campo di testo con ampiezza specificata
p.add(T2); // aggiunge un campo di testo con anche inizializzazione
p.add(A1); // aggiunge al pannello un' area di testo con Righe e Colonne specificate
p.add(A2); // aggiunge al pannello un'area di testo anche con inizializzazione
p.add(C1); // aggiunge al pannello una casella di controllo vuota e disattivata
p.add(C2); // aggiunge al pannello una casella di controllo con stringa
p.add(C3); // aggiunge al pannello una casella di controllo con stringa ed attivata
p.add(RB1); // aggiunge al pannello i Radio Button
p.add(RB2);
f.setVisible(true); // mostra il frame (dimensioni 400x400)
}
public static void main(String [] args) {
Gui2L o = new Gui2L();
}
}
Lo stesso modo di introdurre componenti GUI si può realizzare con Applet. Vediamo un esempio
che crea una finestra diversa da quella del browser (confrontare con l’applicazione Gui):
// esempio di Applet con uso dei Componenti di una GUI (chiusura finestra browser per uscire)
import java.awt.*;
import java.applet.*;
public class GuiA extends Applet
{
public void init()
{
Frame f = new Frame("Finestra con componenti"); // crea frame invisibile
// per impostare le dimensioni e la posizione:
f.setSize(300,150);
// misure in pixel
f.setLocation(200,100);
// (0,0) angolo sup. sin.
// per ridimensionare con mouse
f.setResizable(true);
Panel p = new Panel();
p.setBackground (Color.gray); // sfondo colorato
p.setLayout(new GridLayout(4,4)); // per evidenziare allineamento
f.add(p); // aggiunge al frame il pannello colorato
Label L1 = new Label ("Etichetta con sfondo colorato");
Label L2 = new Label ("Allineata al centro", Label.CENTER);
Label L3 = new Label ("Allineata a sinistra", Label.LEFT);
Label L4 = new Label ("Allineata a destra", Label.RIGHT);
L1.setBackground (Color.cyan);
p.add(L2); // aggiunge al pannello un'etichetta allineata al centro
p.add(L3); // aggiunge al pannello un'etichetta allineata a sinistra
p.add(L4); // aggiunge al pannello un'etichetta allineata a destra
p.add(L1); // aggiunge al pannello un'etichetta
f.setVisible(true); // mostra il frame (dimensioni 300x150)
}
}
Nel codice HTML:
<object code ="GuiA.class" ></object>
NB: Un’ applet dunque può aprire un'altra finestra ma in essa compare automaticamente un avviso
( Java Applet Window)
Esercizio:
Creare un’applet che disegni il cruscotto di un’automobile in una finestra separata.
Nel cruscotto devono apparire
• 4 bottoni con testo: Freccia Sx, Freccia Dx, Freno Manuale, Avvia Motore
• un’etichetta con testo Luci con associate 3 caselle opzione con testo posizioni, anabbaglianti,
abbaglianti , tutte non attivate
• un’etichetta carburante
ed un TextField largo 30 pixel
150 pixel
Soluzione:
370 pixel
// esempio di Applet con uso contenitori e componenti GUI
import java.awt.*;
import java.applet.*;
public class Cruscotto extends Applet {
public void init()
{
Frame f = new Frame ("Cruscotto di un auto");
CheckboxGroup luci = new CheckboxGroup();
Button FrecciaSx = new Button ("Freccia Sx");
Button FrecciaDx = new Button ("Freccia Dx");
Button FrenoManuale = new Button ("Freno Manuale");
Button AvviaMotore = new Button ("Avvia Motore");
TextField carburante = new TextField (30);
f.setSize (370, 150);
f.setLocation (100,100);
f.setLayout (new GridLayout (3,4,10,10));
f.setResizable(true); // con mouse ridimensionabile
f.add(FrecciaSx);
f.add(FrecciaDx);
f.add(AvviaMotore);
f.add(FrenoManuale);
f.add(new Label("Luci"));
f.add(new Checkbox ("posizioni", false, luci));
f.add(new Checkbox ("anabbaglianti", false, luci));
f.add(new Checkbox ("abbaglianti", false, luci));
f.add(new Label("Carburante"));
f.add(carburante);
f.setVisible(true);
}
}
Nel codice HTML:
<object code ="Cruscotto.class" ></object>
I Canvas
Tra i vari contenitori Java il Canvas (area di disegno o tela) è una semplice superficie di disegno
particolarmente utile per visualizzare immagini o per effettuare altre operazioni grafiche.
Un oggetto di tipo Canvas è semplicemente una porzione rettangolare di schermo, una specie di
pannello che possiede un proprio metodo paint() che, pur diverso dall’omonimo metodo di un
Applet, usa anch’esso oggetti della classe Graphics ed è richiamato dal sistema in fase di creazione
e aggiornamento in modo che l’oggetto Graphics associato possa aggiornarsi .
Una istanza della classe Canvas non è molto utile: riceve eventi da tastiera e da mouse, ma non li
tratta, ed il metodo paint() non disegna alcunché.
Generalmente la classe Canvas è usata solo come base per subclassi, che possono generare oggetti più utili: una
subclasse di Canvas generalmente farà almeno un’override del metodo paint() e possibilmente anche dei metodi di
gestione degli eventi come quelli del mouse e della tastiera.
Quando il contenuto del canvas dovrà essere modificato al di fuori del metodo paint(), sarà possibile richiamare il
contesto grafico con i metodi getGraphics().
Vedremo come questi metodi (nella gestione di eventi) possono essere usati per i canvas creando ad esempio un bottone
di forma personalizzata.
Pur se è possibile disegnare direttamente in ogni Component, ed è comune disegnare
direttamente su applet e finestre, è di solito meglio collocare ogni operazione di disegno nelle sottoclassi del Canvas:
nei casi in cui sia necessario disegnare su un’applet che contiene anche dei bottoni, l'uso di un canvas è pressochè
inevitabile.
// esempio di Applicazione con uso GUI (necessita una finestra o Frame)
// Per disegnare uso di classe che eredita da Canvas
import java.awt.*;
public class Graf{
public Graf () {
Frame f = new Frame("Finestra"); // crea frame invisibile
// per impostare le dimensioni e la posizione:
f.setSize(300,150);
// misure in pixel
f.setLocation(200,100);
// (0,0) angolo sup. sin.
// per ridimensionare (per default non ridimensionabili) con mouse
f.setResizable(true);
Disegno d = new Disegno();
f.add (d);
f.setVisible(true);
// classe esterna che eredita da Canvas
// mostra il frame (dimensioni 300x150)
}
public static void main(String [] args) {
Graf ogg = new Graf();
}
}// fine classe principale
// classe esterna nello stesso file Graf.java
class Disegno extends Canvas {
public void paint(Graphics g) {
g.setColor(Color.red);
g.fillRect(20,20,100,80); // rettangolo pieno
g.setColor(Color.blue);
g.drawRect(30,30,80,60);
// linea rettangolare
g.setColor(Color.black);
g.drawString("ciao", 50,60);
Font f1 = new Font("Times", Font.PLAIN, 20); // cambiare font
g.setFont(f1);
g.drawString("ciao", 200,60);
// per recuperare le proprietà del font
f1 = g.getFont();
int size = f1.getSize();
int style = f1.getStyle();
String name = f1.getName();
g.drawString("Font di dimensioni " + size, 50,120);
System.out.println("Font di dimensioni "+ size +" stile " + style + " e nome " + name);
}
}// fine classe che eredita da Canvas
Esercizio: Creare un Applet che disegni un’automobile in modo stilizzato:
1) direttamente nella finestra del browser.
2) con un canvas in una finestra separata. Si costruisca una classe AutoC con gli
opportuni metodi grafici già usati per disegnarla direttamente nella finestra del
browser.
Gli Eventi
Quando l’utente di una GUI digita caratteri o usa il mouse o un componente dell’interfaccia grafica,
il gestore delle finestre di Java invia una comunicazione al programma per segnalare che si è
verificato un evento.
Esistono classi d’ascolto di eventi (event listener) per permettere ad un programma di indicare
quali eventi gradisce ricevere.
Ogni programma dovrà creare un oggetto per ognuna delle classi cui è interessato; tali oggetti
prendono il nome di ascoltatori (oggetto di una classe di ascolto).
La classe di ascolto deve implementare almeno una interfaccia di ascolto (interfacce di tipo
listener).
Un ascoltatore di eventi è un oggetto di una classe di ascolto che implementa almeno una interfaccia
di ascolto. Tali interfacce sono contenute nel package java.awt.event che deve essere importato.
Per creare un ascoltatore bisogna conoscere l’origine dell’evento che può essere l’intera applet o
una sua parte. Per origine dell’evento si intende il contenitore o il componente che può generare
l’evento (ad esempio un pulsante è l’origine dell’evento tipo “clic su pulsante”).
Esempio con gestione eventi del mouse:
// ClickMe.java
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
// classe di ascolto
public class ClickMe extends Applet implements MouseListener {
// tipo di evento ad esempio
// pressione del mouse
private Spot spot = null;
private static final int RADIUS = 7;
public void init() {
addMouseListener(this); // per collegare ascoltatore all’origine dell’evento: tutta l’applet
}
public void paint(Graphics g) {
//draw a black border and a white background
g.setColor(Color.white);
g.fillRect(0, 0, getSize().width - 1, getSize().height - 1);
g.setColor(Color.black);
g.drawRect(0, 0, getSize().width - 1, getSize().height - 1);
//draw the spot
g.setColor(Color.red);
if (spot != null) {
g.fillOval(spot.x - RADIUS, spot.y - RADIUS, RADIUS * 2, RADIUS * 2);
}
}
public void mousePressed(MouseEvent event) {
// tipo evento: pressione del mouse
if (spot == null) { spot = new Spot(RADIUS); }
spot.x = event.getX();
spot.y = event.getY();
repaint();
}
public void mouseClicked(MouseEvent event) {}
public void mouseReleased(MouseEvent event) {}
public void mouseEntered(MouseEvent event) {}
public void mouseExited(MouseEvent event) {}
// altri metodi dell’interfaccia di ascolto
// per evitare di scrivere tali segnature
// di metodi si usa classe Adapter che
// implementa interfaccia MouseListener
}
// Spot.java
public class Spot {
public int size;
public int x, y;
public Spot(int intSize) {
size = intSize;
x = -1;
y = -1;
}}
Con codice HTML per caricare ed eseguire Applet con "Java Plug in", che consente al browser di
usare un interprete Java esterno (più aggiornato)
<html>
<head><title>Uso Eventi</title></head>
<body>
<P>Carica ed esegue Applet con uso di Java Plug-in (anche per NN versioni precedenti alla 6):
<P>appare uno spot rosso nel punto dove fai click col mouse
<P><object classid="clsid:8AD9C840-044E-11D1-B3E9-00805F499D93"
width="200" height="100">
<param name="code" value="ClickMe.class">
<param name="type" value="application/x-java-applet;version=1.4">
<comment><embed type="application/x-java-applet" width="200" height="100"
code="ClickMe.class"></embed></comment>
</object>
</body>
</html>
NB: getWidth() e getHeight() per recupero dimensioni senza creare oggetto Dimension con
getSize()
Esempio con gestione eventi del mouse con adattatore (classe di raccordo Adapter):
// Pallini.java
import java.awt.event.*;
import java.awt.*;
import java.applet.*;
public class Pallini extends Applet{
int X,Y;
public void init() {
MiaClasseAscoltoMouse A1 = new MiaClasseAscoltoMouse ();
addMouseListener (A1); // lega la classe di ascolto all’origine dell’evento: cioè
// tutta l’applet (è sottinteso this : manca oggetto origine)
}
public void paint(Graphics g) {
g.setColor(Color.red);
g.fillOval(X,Y,20,20);
}
// classe interna
private class MiaClasseAscoltoMouse extends MouseAdapter
{
public void mousePressed (MouseEvent E) {
X = E.getX(); // accede alla variabili istanza x e y della classe esterna
Y =E.getY();
repaint();
}
}
}// fine classe Pallini
Con codice HTML:
<html>
<head>
<title>Uso Classe Adapter</title>
</head>
<body>
Dove premi con il mouse compare un pallino rosso
<object code ="Pallini.class" width = 500 height = 400 >
</object>
</body>
</html>
NB: per estrarre coordinate sullo schermo getLocationOnScreen().x e getLocationOnScreen().y
Infatti getLocationOnScreen() della classe java.awt.Component può essere invocato per
recuperare le coordinate di qualsiasi contenitore
Point p = getLocationOnScreen();
int x = p.x ;
int y = p.y;
Esercizio: Disegno di un auto in altra finestra alla pressione di un pulsante (evento della GUI)
Con codice HTML:
<html>
<head>
<title>Disegno di un Auto come evento </title>
</head>
<body>
<object code ="Autoe.class" width = 500 height = 400 >
</object>
</body>
</html>
Applet Autoe.java
// esempio di Applet con gestione eventi della GUI: creazione di eventi personalizzati
// Uso canvas
import java.awt.event.*;
import java.awt.*;
import java.applet.*;
public class Autoe extends Applet
{
Auto A;
public void init()
{
Button B = new Button ("Disegna un auto");
GestiscePulsante A1 = new GestiscePulsante(); // crea ascoltatore
B.addActionListener (A1);
// lega la classe di ascolto all’origine dell’evento: cioè
// il pulsante B
add(B);
}
public void Disegna()
{
Frame f1 = new Frame("Disegna auto");
A = new Auto();
f1.setSize (300, 200);
f1.setLocation (50,50);
f1.setResizable(true);
f1.add(A);
f1.setVisible(true);
}
// con mouse ridimensionabile
// definizione classe d'ascolto interna
private class GestiscePulsante implements ActionListener // interfaccia per eventi di azione
{
public void actionPerformed (ActionEvent e) // unico metodo da ridefinire
{
Disegna();
}
} // fine classe d'ascolto interna
}
class Auto extends Canvas {
// classe esterna per disegnare auto
public void paint(Graphics g) {
Font f = new Font("Times Roman", Font.BOLD, 20);
// tipo, aspetto, dimensione carattere
g.setFont(f);
g.fillOval(120, 220, 60,60); // una ruota piena
g.fillOval(320, 220, 60,60); // altra ruota piena
g.setColor(Color.blue);
// carrozzeria blu
g.drawRect(50, 150, 400, 70);
g.drawLine(170,150,200,100);
g.drawLine(330,150,300,100);
g.drawLine(300,100,200,100);
g.setColor(Color.yellow);
// luci gialle
g.fillRect(50, 170, 20, 30);
g.setColor(Color.red);
// luci rosse
g.fillRect(430, 150, 20, 20);
g.setColor(Color.cyan);
// testo cyan
g.drawString("Automobile", 200, 350);
}
}
Esercizio:
pulsanti con stessa classe di ascolto e stesso metodo actionPerformed()
// esempio di Applet con gestione eventi della GUI
// Uso di due pulsanti
import java.awt.event.*;
import java.awt.*;
import java.applet.*;
public class Pulsanti extends Applet {
TextField T = new TextField (30);
Button B1 = new Button("sinistro");
Button B2 = new Button("destro");
Frame f1 = new Frame("Pulsanti");
public void init() {
f1.setSize (400, 200);
f1.setLocation (50,50);
f1.setResizable(true);
// con mouse ridimensionabile
f1.setLayout(new GridLayout (1,3,50,0));
B1.addActionListener (new Ascolta());
B2.addActionListener (new Ascolta());
f1.add(B1);
f1.add(T);
f1.add(B2);
f1.setVisible(true);
}
private class Ascolta implements ActionListener {
public void actionPerformed (ActionEvent e) {
String Bottone = e.getActionCommand(); // testo mostrato da pulsante
if (Bottone.equals ("sinistro") )
T.setText("pulsante sinistro");
else
T.setText("pulsante destro");
}
}
}
Leggere testo di input con applicazioni GUI e il package swing5
Esempio di Applet che usa una semplice finestra modale:
// da eseguire con appletviewer
// > appletviewer Finestra.html
// oppure con opportune selezioni nel Plug-in (da Pannello di controllo)
import javax.swing.*;
import java.awt.*;
import java.applet.*;
public class Finestra extends JApplet
{
String nome="";
public void init ()
{
nome = JOptionPane.showInputDialog("Inserisci il tuo nome: ");
}
public void paint(Graphics g)
{
g.drawString("Ciao " + nome, 10, 50);
}
}
Con codice HTML (file Finestra.html ):
<html>
<head>
<title>Finestra per input </title>
</head>
<body>
<object code ="Finestra.class" width = 500 height = 400 >
</object>
</body>
</html>
5 SWING http://java.sun.com/docs/books/tutorial/uiswing/index.html
APPENDICE: APPLET6
Java si è diffuso storicamente, e trae forza, dal concetto di applet come piccola (almeno all’inizio
dei tempi) applicazione da eseguirsi dentro un browser Internet
· grafica portabile ed eseguibile ovunque
· modello di sicurezza “sandbox”
Una applet ("applicazioncina") è una applicazione non autonoma, ma pensata per far parte di una
pagina Internet
· porta dinamicità alle pagine HTML "statiche"
· viene eseguita dal browser, che quindi deve incorporare un interprete Java
e questo può causare un tempo di visualizzazione più alto
In quanto applicazione non autonoma, un'applet:
· non ha un main, perché la sua vita è dipendente dalla pagina in cui è visualizzata
· non deve creare un frame principale, perché usa la finestra del browser che la ospita (in effetti,
Applet deriva direttamente da Panel e quindi è essa stessa un pannello)
· è organizzata intorno a 4 metodi standard:
· init(), che gioca il ruolo del costruttore
· start() e stop(), chiamati dal browser ogni volta che occorre avviare /fermare l'applet
· destroy(), invocato quando il browser viene chiuso.
Esistono due versioni di Applet:
· la classe Applet dell'AWT standard (da Java 1.0 in poi)
· la classe JApplet di Swing (da Java 1.1.6 in poi)
Se si usano componenti Swing, occorre necessariamente usare JApplet infatti una Applet con
componenti Swing non viene disegnata correttamente
6 Da http://www33.brinkster.com/4binf/dispense/java/JavaApplet.pdf
APPLET e SICUREZZA
Un'applet non può fare tutto quello che fa una applicazione. Poiché può essere scaricata dalla rete,
sarebbe troppo pericoloso permettere a un'applet di fare qualunque cosa ed è costretta a rispettare
un ben preciso modello di sicurezza ("sandbox")
– è eseguita in una "scatola" da cui non può uscire
– non può contaminare (o spiare) i dati del computer dell'utente
Un'applet di norma non può:
• accedere al file system locale (neppure per leggere un file)
• eseguire un altro programma
• ottenere informazioni sull'utente
• connettersi via rete a un computer diverso da quello da cui è stata scaricata7
• caricare la libreria Java, chiamare System.exit()
In molte situazioni, questi vincoli sono troppo rigidi e rischierebbero di rendere impossibile la
costruzioni di applet utili.
APPLET FIRMATE
Attraverso tecnologie di cifratura, un'applet può essere firmata, ossia a essa può essere allegato un
certificato che ne garantisce l'origine. A tali applet firmate, cui si attribuisce maggiore fiducia,
l'utente può consentire di svolgere alcune o tutte le operazioni sottoposte a vincolo.
Ogni browser può essere configurato per gestire le applet firmate.
POLITICHE DI SICUREZZA
A partire da Java 2, l'utente può decidere caso per caso quali politiche di sicurezza applicare, con
una granularità molto fine
Esiste il concetto di policy file, che elenca le politiche locali e si può stabilire che una certa applet,
proveniente da un ben preciso sito, ha diritti particolari. Un tale file può essere fornito da chi
sviluppa l'applet, o modificato dall'utente con lo strumento PolicyTool.
7 Per questo motivo si preferisce lavorare con applicazioni quando ci si connette a Internet e se ne usano le risorse.
