-
Le interfacce utente grafiche (Graphical User Interface)
Il primo package Java che gestisce gli elementi di una GUI1 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 unarea
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
del package awt rappresentata dalla classe astratta Component (che
a sua volta eredita dalla superclasse Object, superclasse di tutti
gli oggetti Java).
In realt le classi TextField e TextArea ereditano da
TextComponent con radice Component.
La classe Frame Le classi per creare controlli eredita da
Windowe la classeCanvas che eredita da ereditano direttamente da
Component. Container2.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/index.html
http://java.sun.com/docs/books/tutorial/uiswing/components/index.html
-
A differenza delle applicazioni, un Applet, non necessita di una
finestra per essere eseguito infatti la finestra quella del browser
a cui si aggiunge un pannello che rappresenta lapplet.
La classe Applet, infatti, eredita da Panel che eredita da
Container la cui radice appunto Component.
Creazione e uso dei contenitori standard
La classe JFrame ha i seguenti metodi costruttori:
JFrame() Crea una finestra senza titolo JFrame(Stringa) Crea una
finestra senza titolo specificato in Stringa
Altri metodi che si applicano ad un oggetto della classe
JFrame:
setSize(larghezza, altezza) Dimensiona la finestra setLocation(
x, y) Posiziona la finestra (coordinate del punto in alto a
sinistra) pack() Ottimizza le dimensioni della finestra a seconda
del contenuto setVisible(boolean) Per rendere visibile la finestra
se true (deprecato il metodo
show()) setResizable(boolean) Per rendere ridimensionabile con
mouse se true dispose() Per chiudere la finestra, deallocando le
risorse
La classe JPanel ha il seguente metodo costruttore:
JPanel () Crea un pannello per inserire componenti GUI
Linserimento degli oggetti allinterno dei contenitori si
realizza con il metodo add() con la sintassi:
oggettoContenitore.add (oggettoDaAggiungere)
Tale metodo polimorfo cio opera su argomenti di diverse
classi.
nb: possibile aggiungere un componente e contemporaneamente
sceglierne la posizione nel contenitore (con possibili West, North,
East, South e Center o equivalenti costanti in swing)
oggettoContenitore.add (orientamento, oggettoDaAggiungere )
es: nomePannello.add (West, nomeComponente); nomePannello.add
(North, nomeComponente);
http://www33.brinkster.com/4binf/dispense/java/JavaApplet.pdf
-
// esempio di Applicazione con uso di oggetti GUI in ambiente
JCreatorimport java.awt.*;import javax.swing.*;
public class Finestra {
private JFrame f ; private Container c; private JPanel p;
public Finestra () { // costruttore
f = new JFrame("Visualizza sfondo colorato"); // crea frame o
cornice invisibile c = f.getContentPane(); // recupera il "muro
grezzo" // cio il riquadro dei contenuti senza barra dei men
// per impostare le dimensioni e la posizione:
f.setSize(300,150); // misure in pixel: larghezza, altezza
f.setLocation(200,100); // (0,0) angolo sup. sin p = new JPanel();
p.setBackground(Color. lightGray); // sfondo del pannello
colorato
c.add(p); // aggiunge il pannello
f.setVisible(true); // mostra il frame (dimensioni 300x150) -
deprecato show()
f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); // rende
attiva l'icona di chiusura // nella barra del titolo }
public static void main(String [] args) { Finestra o = new
Finestra(); // creo oggetto che "ha - un" oggetto JFrame ed un
oggetto JPanel } }
nb:setDefaultCloseOperation(JFrame.FLAG); questo metodo permette
di modificare l'azione di default di Java di continuare ad eseguire
l'applicazione che ha generato il frame anche dopo aver clickato
sull'apposito bottone di chiusura del frame; segue un elenco del
significato del campo flag :EXIT_ON_CLOSE : terminazione del
programma quando il frame viene chiuso
DISPOSE_ON_CLOSE : chiude e libera il solo oggetto frame, il
processo continua
DO_NOTHING_ON_CLOSE : mantiene aperto il frame e continua il
processo (ignoriamo l'evento)
HIDE_ON_CLOSE : chiude il frame e continua l'esecuzione
Per nascondere i frames: setVisible(false) - deprecato
hide()
-
Creazione e uso dei componenti standard
La classe JLabel : un esempio// Applicazione con uso dei
componenti di una GUI// in ambiente JCreator// Uso di un pannello
per introdurre // componenti JLabel // e gestione di layout con
allineamento in griglia
import java.awt.*;import javax.swing.*;
public class MiaFinestra extends JFrame{
private Container c; private JPanel p; private JLabel l1, l2,
l3, l4;
public MiaFinestra () { // costruttore super ("Finestra con
componenti"); // imposta il titolo del frame invisibile
setSize(300,150); // per impostare le dimensioni e la
posizione(misure in pixel) : setLocation(200,100); // (0,0) angolo
sup. sin. setResizable(true); // per ridimensionare con mouse
c = getContentPane(); // recupera il "muro grezzo" p = new
JPanel(); // per inserimento componenti con layout di tipo
FlowLayout // cio uno di seguito allaltro da sinistra a destra
p.setBackground (Color.lightGray); p.setLayout(new GridLayout
(4,1)); // per evidenziare allineamento 4 RIGHE, 1 COLONNA
JLabel l1 = new JLabel ("Etichetta con sfondo colorato"); JLabel
l2 = new JLabel ("Allineata al centro", JLabel.CENTER); JLabel l3 =
new JLabel ("Allineata a sinistra", JLabel.LEFT); JLabel l4 = new
JLabel ("Allineata a destra", JLabel.RIGHT);
l1.setBackground (Color.cyan); l1.setOpaque(true); // per vedere
sfondo su sfondo
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 con sfondo
colorato
c.add(p); // aggiunge il pannello
setVisible(true); // mostra il frame (dimensioni 300x150)
setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); } public static
void main(String [] args) { MiaFinestra o = new MiaFinestra(); //
creo oggetto che "ha" componenti Gui }}
Altri metodi : String getText() restituisce il testo
delletichetta o del JComponent setText (Stringa) modifica il testo
delletichetta o del JComponent int getHorizontalAlignment()
restituisce come intero lallineamento delletichetta (0 o 1 o 2)
setHorizontalAlignment (int) modifica lallineamento delletichetta a
seconda della costante
intera: JLabel.CENTER o LEFT, RIGHT, LEADING, TRAILING (per
default) setFont(Oggetto_classe_Font) modifica il tipo di carattere
delletichetta
-
Le classi JButton, JTextField, JTextArea, JCheckBox,
JRadioButton e ButtonGroup// Applicazione per illustrare creazione
di componenti di una GUI in ambiente JCreator// Uso di pannello per
introdurre componenti (per default con layout di tipo FlowLayout //
cio i componenti sono aggiunti uno di seguito allaltro da sinistra
a destra)import java.awt.*;import javax.swing.*;
public class Gui2 {
private JFrame f ; private Container c; private JPanel p;
private JLabel l; private JButton b1, b2; private JTextField t1,
t2; private JTextArea a1, a2; private JCheckBox c1, c2, c3; private
ButtonGroup g; // per creare pulsanti di opzione (uno solo
selezionabile) detti Radio Button private JRadioButton rb1,
rb2;
public Gui2 () { // costruttore f = new JFrame("Finestra con
componenti"); // crea frame invisibile f.setSize(450,330); //
misure in pixel per impostare le dimensioni f.setLocation(200,100);
// e la posizione con (0,0) angolo sup. sin. f.setResizable(true);
// per ridimensionare con mouse c = f.getContentPane(); p = new
JPanel(); p.setBackground (Color.lightGray); // sfondo colorato l =
new JLabel ("Etichetta"); b1 = new JButton (); b2 = new JButton
("Bottone"); t1 = new JTextField (30); t2 = new JTextField
("immetti il nome", 20); a1 = new JTextArea(5, 20); // senza barre
a scorrimento se non si inserisce in JScrollPane a2 = new
JTextArea("immetti una lista di nomi ", 5, 20); a1.append
("Dimensionata con 5 righe e 20 colonne"); c1 = new JCheckBox(); c2
= new JCheckBox("Testo"); c3 = new JCheckBox("Testo attivato",
true); c1.setToolTipText("Senza testo"); // per visualizzare, al
passaggio del mouse, testo esplicativo g = new ButtonGroup(); //
per gestire selezione rb1 = new JRadioButton("Lingua Francese",
false); rb2 = new JRadioButton("Lingua Francese", true);
g.add(rb1); g.add(rb2); 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); c.add(p); //
aggiunge il pannello f.setVisible(true); // mostra il frame
(dimensioni 400x400) f.setDefaultCloseOperation
(JFrame.EXIT_ON_CLOSE); } public static void main(String [] args) {
Gui2 o = new Gui2(); }}
-
Altri metodi della classe JButton: String getText() per ottenere
il valore delletichetta delloggetto, deprecato getLabel()
Altri metodi della classe JCheckBox: String getText()
restituisce il valore delletichetta, deprecato getLabel()
setText(Stringa) imposta il valore delletichetta, deprecato
setLabel()
Altri metodi delle classi che ereditano da JComponent: String
getToolTipText() restituisce il valore del testo settato con
setToolTipText
Altri metodi della classe JRadioButton ereditati dalla classe
AbstractButton: isSelected() ritorna il valore booleano che indica
lo stato del radio-bottone setSelected (stato) per settare lo stato
del radio-bottone
Posizionamento diretto di un elemento GUI o tramite gestori di
layout
Nel posizionamento diretto (dipendente dalle impostazioni
grafiche del sistema) non abbiamo bisogno di un gestore di layout
(layout manager3) e dobbiamo indicare questo fatto con
listruzione:
setLayout (null);
Definiremo poi le dimensioni dellelemento e lo posizioneremo
mediante il metodo setBounds() con sintassi:
setBounds(x,y,larghezza,altezza) // x,y dellangolo sup. sin.
Per default il gestore di layout per tutti i contenitori di tipo
pannello la classe FlowLayout che aggiunge i componenti uno di
seguito allaltro 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. , di default il gestore di layout per i
contenitori ad alto livello come i Content Pane.
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.
Oltre alle numerose classi che gi awt introduceva per gestire il
posizionamento, swing rende disponibile anche la classe BoxLayout
per una scelta general purpose nellimpilare i vari elementi.3
Gestori di Layout
http://java.sun.com/docs/books/tutorial/uiswing/layout/visual.html
(guida visuale)
http://java.sun.com/docs/books/tutorial/uiswing/layout/box.htmlhttp://java.sun.com/docs/books/tutorial/uiswing/layout/visual.html
-
/******************************************************************//*
GESTIONE DI UN LAYOUT SEMPLICE MEDIANTE USO DI SWING
****//******************************************************************/
import javax.swing.*;import java.awt.*;
public class SempliceLayout extends JFrame {
//Creiamo i componenti
JLabel ipLabel = new JLabel("IP host", SwingConstants.LEFT); //
per default a sinistraJLabel passwordLabel = new JLabel("Password",
SwingConstants.LEFT);JLabel fileDaInviareLabel = new JLabel("File
da inviare", SwingConstants.LEFT);
JTextField ipText = new JTextField(20); // impostiamo numero
caratteriJPasswordField passwordText = new JPasswordField(20); //
impostiamo numero caratteriJTextField fileDaInviareText = new
JTextField(20); // impostiamo numero caratteriJButton pulsante =
new JButton("Inizia TX");
public SempliceLayout() { // costruttore dell'applicazione
super("File transfer appz");setSize(320, 150); // dimensioni
adatte [*]setDefaultCloseOperation(EXIT_ON_CLOSE);JPanel pannello =
new JPanel();
// impostiamo le propriet dei componenti
ipText.setEditable(true);fileDaInviareText.setEditable(true);passwordText.setEchoChar('*');
// usiamo il Layout di default di JPanel di tipo FlowLayout
pannello.add(ipLabel);pannello.add(ipText);pannello.add(passwordLabel);pannello.add(passwordText);pannello.add(fileDaInviareLabel);pannello.add(fileDaInviareText);
pannello.add(pulsante);setContentPane(pannello); // rendiamo il
pannello parte del nostro framesetResizable(false); //
immodificabili dimensioni [*]setVisible(true); // visualizziamo il
tutto}
public static void main(String argv[]) {
new SempliceLayout();
}}
-
/*****************************************************************************//*
GESTIONE DI UN LAYOUT A GRIGLIA AVANZATA MEDIANTE USO DI SWING
****//*****************************************************************************/
import javax.swing.*;import java.awt.*;
public class Layout extends JFrame {
//Creiamo i componenti
JLabel ipLabel = new JLabel("IP host", SwingConstants.LEFT); //
per default a sinistraJLabel passwordLabel = new JLabel("Password",
SwingConstants.LEFT);JLabel fileDaInviareLabel = new JLabel("File
da inviare", SwingConstants.LEFT);JTextField ipText = new
JTextField(); // non ci preoccupiamo di impostare numero
caratteriJPasswordField passwordText = new JPasswordField();
JTextField fileDaInviareText = new JTextField();JButton pulsante =
new JButton("Inizia TX");
// Definiamo un metodo che ci servir per definire i limiti di
layout
void impostaLimite(GridBagConstraints gbc, int gx, int gy, int
gw, int gh, int wx, int wy) {gbc.gridx = gx;gbc.gridy =
gy;gbc.gridwidth = gw;gbc.gridheight = gh;gbc.weightx =
wx;gbc.weighty = wy;}
public Layout() { // costruttore dell'applicazione
super("File transfer appz");setSize(300,
120);setDefaultCloseOperation(EXIT_ON_CLOSE);JPanel pannello = new
JPanel();
// impostiamo le propriet dei componenti
ipText.setEditable(true);fileDaInviareText.setEditable(true);passwordText.setEchoChar('*');
//definiamo il gestore di layout
GridBagLayout grigliaAvanzata = new GridBagLayout(); // griglia
personalizzataGridBagConstraints limite = new GridBagConstraints();
pannello.setLayout(grigliaAvanzata);
//definiamo i limiti di ogni componente e lo aggiungiamo al
pannello
impostaLimite(limite,0,0,1,1,35,0); //etichetta IP
hostlimite.fill = GridBagConstraints.NONE;limite.anchor =
GridBagConstraints.EAST;grigliaAvanzata.setConstraints(ipLabel,limite);
pannello.add(ipLabel);
impostaLimite(limite,1,0,1,1,65,100); //campo IP hostlimite.fill
=
GridBagConstraints.HORIZONTAL;grigliaAvanzata.setConstraints(ipText,limite);
pannello.add(ipText);
http://www.tukano.it/GridBagLayout.pdf
-
impostaLimite(limite,0,1,1,1,0,0); //etichetta
passwordlimite.fill = GridBagConstraints.NONE;limite.anchor =
GridBagConstraints.EAST;grigliaAvanzata.setConstraints(passwordLabel,limite);
pannello.add(passwordLabel);
impostaLimite(limite,1,1,1,1,0,100); //campo passwordlimite.fill
=
GridBagConstraints.HORIZONTAL;grigliaAvanzata.setConstraints(passwordText,limite);
pannello.add(passwordText);
impostaLimite(limite,0,2,1,1,0,0); //etichetta File da
inviarelimite.fill = GridBagConstraints.NONE;limite.anchor =
GridBagConstraints.EAST;grigliaAvanzata.setConstraints(fileDaInviareLabel,limite);
pannello.add(fileDaInviareLabel);
impostaLimite(limite,1,2,1,1,0,100); //campo File da
inviarelimite.fill =
GridBagConstraints.HORIZONTAL;grigliaAvanzata.setConstraints(fileDaInviareText,limite);
pannello.add(fileDaInviareText);
impostaLimite(limite,0,3,2,1,0,50); // Pulsantelimite.fill =
GridBagConstraints.NONE;limite.anchor =
GridBagConstraints.CENTER;grigliaAvanzata.setConstraints(pulsante,limite);
pannello.add(pulsante);
setContentPane(pannello); // rendiamo il pannello parte del
nostro framesetVisible(true); // Visualizziamo il tutto!}
public static void main(String argv[]) {
Layout nf = new Layout();
}
}
GridBagLayout pu organizzare interfacce grafiche complesse
rendendo possibile dividere il container in una griglia e, a
differenza del GridLayout, pu disporre i suoi componenti in modo
tale che si estendano anche oltre ununica cella, attraverso la
classe GridBagConstraints.
-
/******************************************************************************//*
SEMPLICI ETICHETTE, CAMPI ED AREE DI TESTO MEDIANTE USO DI SWING
****//******************************************************************************/
import javax.swing.*;import java.awt.GridLayout;
public class EtichetteEcampi extends JFrame {
JLabel etichetta1 = new JLabel("Allineamento a sinistra
",SwingConstants.LEFT);JLabel etichetta2 = new JLabel("Allineamento
al centro",SwingConstants.CENTER);JLabel etichetta3 = new
JLabel("Allineamento a destra ", SwingConstants.RIGHT);JTextField
campoDiTesto = new JTextField("Immetti qui una
stringa...",30);JTextArea areaDiTesto = new JTextArea("Questa
un'area di testo di\n5 righe e 30 colonne",5,30);
public EtichetteEcampi() {
super("Etichette e campi");setSize(350,
300);setDefaultCloseOperation(EXIT_ON_CLOSE);JPanel pannello = new
JPanel();
// impostiamo le propriet dei componenti
campoDiTesto.setEditable(true);areaDiTesto.setLineWrap(true);areaDiTesto.setWrapStyleWord(true);
// ora aggiungiamo i componenti al
pannellopannello.setLayout(new
GridLayout(0,1));pannello.add(etichetta1);pannello.add(etichetta2);pannello.add(etichetta3);
pannello.add(campoDiTesto);
pannello.add(areaDiTesto);
// rendiamo il pannello parte del nostro frame
setContentPane(pannello);setVisible(true); // Visualizziamo il
tutto!
}
public static void main(String argv[]) {
EtichetteEcampi ec = new EtichetteEcampi();
}}nb: public GridLayout (int rows, int cols) crea un layout a
griglia dove tutti i componenti sono delle stesse dimensioni. Uno
tra numero rige e colonne - ma non entrtambi - pu essere zero:
significa che un qualsiasi numero di oggetti pu essere inserito o
nell'unica riga o nell'unica colonna
// da
http://www.java2s.com/Code/JavaAPI/javax.swing/SwingConstantsRIGHT.htm
http://www.java2s.com/Code/JavaAPI/javax.swing/SwingConstantsRIGHT.htm
-
Etichette e bordiimport java.awt.Color;import
java.awt.GridLayout;
import javax.swing.BorderFactory;import
javax.swing.JFrame;import javax.swing.JLabel;import
javax.swing.JPanel;import javax.swing.SwingConstants;
public class EtichetteBordi {
private JLabel label1, label2,label3; private JFrame frame;
private JPanel p;
public EtichetteBordi(){
label1 = new JLabel("BottomRight", SwingConstants.RIGHT); label2
= new JLabel("CenterLeft", SwingConstants.LEFT); label3 = new
JLabel("TopCenter", SwingConstants.CENTER);
label1.setVerticalAlignment(SwingConstants.BOTTOM);
label2.setVerticalAlignment(SwingConstants.CENTER);
label3.setVerticalAlignment(SwingConstants.TOP);
label1.setBorder(BorderFactory.createLineBorder(Color.black));
label2.setBorder(BorderFactory.createLineBorder(Color.black));
label3.setBorder(BorderFactory.createLineBorder(Color.black));
frame = new JFrame("AlignmentExample");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); p = new
JPanel(new GridLayout(3, 1, 0, 8)); // righe, colonne, pixel tra
colonne, pixel tra righe // in questa applicazione, con unica
colonna, // indifferente hgap che p valere anche 0 p.add(label1);
p.add(label2); p.add(label3);
p.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8)); // top,
left, bottom, right frame.setContentPane(p); frame.setSize(300,
200); frame.setVisible(true);}
public static void main(String[] args) { new
EtichetteBordi();
}}
nb: public GridLayout (int rows, int cols, int hgap, int vgap)
crea un layout a griglia dove tutti i componenti sono delle stesse
dimensioni e rende possibile impostare il numero di pixel tra le
colonne come per il margine destro e sinistro dai bordi (horizontal
gap) ed il numero di pixel tra le righe come per i margini in alto
e basso dai bordi (vertical gap).
-
/** * @(#)Gui.java * Gui application * @author 3AI * @version
1.00 2009/4/4 */import java.awt.*;import javax.swing.*;
class MioPanel extends JPanel{public MioPanel(){
this.setPreferredSize(new Dimension(180, 150)); // per reimpostare
dinamicamente } public void paintComponent(Graphics g){
super.paintComponent(g); g.setColor(Color.red);g.fillRect(20,20,
100,80);g.setColor(Color.blue);g.drawRect(30,30,
80,60);g.setColor(Color.black);g.drawString("ciao",50,60);}
}class Bottone extends JPanel{
private JButton b;public Bottone(){
b = new JButton("label del
bottone");b.setBackground(Color.white);b. setPreferredSize(new
Dimension(130, 15));
this.add(b); // oggetto corrente}
}public class Gui {
private JFrame f;private Container c; private MioPanel p; //
pannelli personalizzatiprivate Bottone p2;
public Gui(){ f = new JFrame("Due pannelli"); // crea un nuovo
JFrame Inizialmente invisibile con titolo c = f.getContentPane();
// recupera il "muro grezzo" p = new MioPanel(); // crea pannello
personalizzato adattabile alle dimensioni della finestra p2 = new
Bottone(); // crea altro pannello personalizzato adattabile alle
dimensioni di bottone e finestra p2.setBackground(Color.blue);
c.setLayout(new BorderLayout()); // scelta di Layout che distingue
tra alto, basso, destra, sinistra e centro
c.add(p,BorderLayout.CENTER); // al centro il pannello con disegno
c.add(p2,BorderLayout.PAGE_END); // in basso il bottone (per
retrocompatibilt anche SOUTH)
f.pack(); // ottimizza le dimensioni della finestra
f.setLocation(400,150); f.setVisible(true); // mostra il JFrame
f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); }public static
void main(String[] v){
Gui gui = new Gui(); }
}
http://java.sun.com/docs/books/tutorial/uiswing/layout/visual.html
-
// Lo stesso esempio di Applicazione con uso GUI gi usato per
introdurre componenti GUI // in un pannello. Posizionamento tramite
gestori di layout: impilando in verticaleimport java.awt.*;import
javax.swing.*;public class Gui2 {
private JFrame f ; private Container c; private JPanel p;
private JLabel l; private JButton b1, b2; private JTextField t1,
t2; private JTextArea a1, a2, a3; private JScrollPane sp; // con
barre a scorrimento inserendo JTextArea in JScrollPane private
JCheckBox c1, c2, c3: private ButtonGroup g; // per creare pulsanti
di opzione (uno solo selezionabile) detti Radio Button private
JRadioButton rb1, rb2;
public Gui2 () { // costruttore f = new JFrame("Finestra con
componenti"); // crea frame invisibile // per impostare le
dimensioni e la posizione: f.setSize(450,330); // misure in pixel
f.setLocation(200,100); // (0,0) angolo sup. sin.
f.setResizable(true); // per ridimensionare con mouse c =
f.getContentPane(); // recupera il "muro grezzo" p = new JPanel();
p.setBackground (Color.lightGray); // sfondo colorato
p.setLayout (new BoxLayout (p, BoxLayout.PAGE_AXIS)); // impila
gli elementi in verticale nel pannello l = new JLabel
("Etichetta"); b1 = new JButton (); b2 = new JButton ("Bottone");
b1.setBackground (Color.cyan); b1.setText("Bottone con etichetta");
// imposta il valore delletichetta ( deprecato setLabel (testo)
)
t1 = new JTextField (30); t2 = new JTextField ("immetti il
nome", 20); a1 = new JTextArea(5, 20); a1.append("Dimensionata con
5 righe e 20 colonne"); a2 = new JTextArea("immetti una lista di
nomi ", 5, 20); a3 = new JTextArea("immetti un commento personale
", 2, 15); sp = new JScrollPane(a3); // per vedere barre a
scorrimento in JTextArea c1 = new JCheckBox(); c2 = new
JCheckBox("Testo"); c3 = new JCheckBox("Testo attivato", true);
c1.setToolTipText("Senza testo"); // per visualizzare, al
passaggio del mouse, testo esplicativo // Per creare pulsanti di
opzione (uno solo selezionabile) detti Radio Button g = new
ButtonGroup(); // per gestire selezione rb1 = new
JRadioButton("Lingua Francese", false); rb2 = new
JRadioButton("Lingua Francese", true); g.add(rb1); g.add(rb2);
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(sp); //
aggiunge al pannello un Pannello a scorrimento che contiene //
un'area di testo con inizializzazione e Righe e Colonne ridotte per
visualizzare barre a scorrimento 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);
c.add(p); // aggiunge il pannello f.setVisible(true); // mostra
il frame (dimensioni 400x400) f.setDefaultCloseOperation (
JFrame.EXIT_ON_CLOSE); }
public static void main(String [] args) { Gui2 o = new Gui2();
}}
nb: per impilare in orizzontale BoxLayout (nomeContenitore,
BoxLayout.LINE_AXIS)
Impilando gli elementi in verticale nel pannello
Impostando 6 Righe e 2 colonne (con solo 12 componenti) Default:
un componente dopo laltro
-
Lo stesso modo di introdurre componenti GUI si pu realizzare con
Applet o piuttosto JApplet se si usano JComponent. Vediamo un
esempio che crea una finestra diversa da quella del browser
(confrontare con lapplicazione Gui):
// esempio di JApplet con uso dei componenti di una GUI
(chiusura finestra browser per uscire)
import java.awt.*;
import javax.swing.*;
import java.applet.*;
public class GuiA extends JApplet {
public void init() { JFrame f = new JFrame("Finestra con
componenti"); // crea frame invisibile f.setSize(300,150); //
misure in pixel per impostare le dimensioni f.setLocation(200,100);
// e la posizione con (0,0) angolo sup. sin. f.setResizable(true);
// per ridimensionare con mouse Container c = f.getContentPane();
// recupera il "muro grezzo" JPanel p = new JPanel();
p.setBackground (Color.gray); // sfondo colorato
p.setLayout(new GridLayout(4,4)); // per evidenziare
allineamento
JLabel l1 = new JLabel ("Etichetta con sfondo colorato"); JLabel
l2 = new JLabel ("Allineata al centro", JLabel.CENTER); JLabel l3 =
new JLabel ("Allineata a sinistra", JLabel.LEFT); JLabel l4 = new
JLabel ("Allineata a destra", JLabel.RIGHT);
l1.setBackground (Color.cyan); l1.setOpaque(true); // vedere
sfondo su sfondo 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 con sfondo colorato c.add(p); // aggiunge al frame il
pannello colorato
f.setVisible(true); // mostra il frame (dimensioni 300x150) //
NB: si noti come per ragioni di sicurezza sia proibito luso di
// f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); }
}
Nel codice HTML:
le dimensioni obbligatorie pur se nulle, qui sono scelte in modo
da permettere di leggere completamente, eseguendo in ambiente
JCreator, il titolo della cornice del visualizzatore della Java
Applet Window con messaggio di Applet avviato o non avviato.
http://java.sun.com/docs/books/tutorial/deployment/applet/index.html
-
NB: Un applet dunque pu aprire un'altra finestra ma compare
automaticamente un avviso anche solo come piccola icona di allerta
in alto a sinistra della nuova finestra che ricorda come la Java
Applet Window non sia mai completamente invisibile.
nb: per eseguire la pagina html con opzione Run in JCreator,
salvare tale pagina web nella stessa cartella del bytecode
(classes). Si noti che,scegliendo come progetto Basic Java Appletsi
crea nella sottocartella classes la seguente pagina
con uso di tag obsoleto
Esercizio:
Creare unapplet che disegni il cruscotto di unautomobile in una
finestra separata.
Nel cruscotto devono apparire
4 bottoni con testo: Freccia Sx, Freccia Dx, Freno Manuale,
Avvia Motore unetichetta con testo Luci con associate 3 caselle
opzione (esclusiva) con testo posizioni,
anabbaglianti, abbaglianti , tutte non attivate unetichetta
carburante ed un JTextField largo 30 pixel
150 pixel
570 pixel
-
Soluzione:
// esempio di JApplet con uso contenitori e componenti GUI
import java.awt.*;import javax.swing.*;import java.applet.*;
public class Cruscotto extends JApplet { public void init()
{
JFrame f = new JFrame ("Cruscotto di un auto"); f.setSize (570,
150);
f.setLocation (100,100); f.setResizable(true); // con mouse
ridimensionabile
Container c = f.getContentPane(); // recupera il "muro
grezzo"
ButtonGroup luci = new ButtonGroup(); JRadioButton rb1 = new
JRadioButton("posizioni", false); JRadioButton rb2 = new
JRadioButton("anabbaglianti", false); JRadioButton rb3 = new
JRadioButton("abbaglianti", false); luci.add(rb1); luci.add(rb2);
JButton FrecciaSx = new JButton ("Freccia Sx"); JButton FrecciaDx =
new JButton ("Freccia Dx"); JButton FrenoManuale = new JButton
("Freno Manuale"); JButton AvviaMotore = new JButton ("Avvia
Motore");
JTextField carburante = new JTextField (30);
c.setLayout (new GridLayout (3,4,10,10)); c.add(FrecciaSx);
c.add(FrecciaDx); c.add(AvviaMotore); c.add(FrenoManuale);
c.add(new Label("Luci")); c.add(rb1); c.add(rb2); c.add(rb3);
c.add(new Label("Carburante")); c.add(carburante);
f.setVisible(true); } }
Nel codice HTML:
nb: per eseguire la pagina html con opzione Run in JCreator,
salvare tale pagina web nella stessa cartella del bytecode
(classes).
-
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 dallomonimo metodo di un
Applet, usa anchesso oggetti della classe Graphics ed richiamato
dal sistema in fase di creazione e aggiornamento in modo che
loggetto 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 unoverride 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
possono essere usati per i canvas creando ad esempio un bottone di
forma personalizzata e colore modificato da eventi
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 unapplet che
contiene anche dei bottoni, l'uso di un canvas pressoch
inevitabile.
// esempio di Applicazione con uso GUI (necessita una finestra o
JFrame)// Per disegnare uso di classe che eredita da Canvas import
java.awt.*;import javax.swing.*;
public class Graf{
public Graf () {
JFrame f = new JFrame("Finestra"); // crea frame invisibile
Container c = f.getContentPane(); // recupera il "muro grezzo"
Disegno d = new Disegno(); // classe esterna che eredita da
Canvas
c.add (d); f.setSize(300,180); // per impostare le dimensioni e
la posizione: misure in pixel f.setLocation(200,100); // (0,0)
angolo sup. sin. f.setResizable(true); // per ridimensionare (per
default non ridimensionabili) con mouse f.setVisible(true); //
mostra il frame (dimensioni 300x150) f.setDefaultCloseOperation
(JFrame.EXIT_ON_CLOSE); } public static void main(String [] args) {
Graf ogg = new Graf(); }}// fine classe principale
-
// classe esterna eventualmente 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,140);
System.out.println("Font di dimensioni "+ size +" stile " +
style + " e nome " + name); } }// fine classe che eredita da
Canvas
Esercizio:
Creare un Applet che disegni unautomobile 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.
-
Soluzione: esempio di Applet che usa canvas in una finestra
separata
import java.awt.*;import java.applet.*;import javax.swing.*;
public class AutoC extends JApplet { Auto A; public void init()
{
JFrame f1 = new JFrame ("Disegna auto"); A = new Auto(); //
istanza che eredita da Canvas f1.setSize (500, 420); f1.setLocation
(50,50); f1.setResizable(true); // con mouse ridimensionabile
Container c =f1.getContentPane(); c.add(A); f1.setVisible(true); }
}
class Auto extends Canvas { public void paint(Graphics g) { Font
f = new Font("Times Roman", Font.BOLD, 20); 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);
}}
Codice HTML: Disegno di un Auto >
nb: per eseguire la pagina html con opzione Run in JCreator,
salvare tale pagina web nella stessa cartella del bytecode
(classes).
-
Gli Eventi
Quando lutente di una GUI digita caratteri o usa il mouse o un
componente dellinterfaccia grafica, il gestore delle finestre di
Java invia una comunicazione al programma per segnalare che si
verificato un evento. Esistono classi dascolto 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 lorigine dellevento
che pu essere lintera applet o una sua parte. Per origine
dellevento si intende il contenitore o il componente che pu
generare levento (ad esempio un pulsante lorigine dellevento tipo
clic su pulsante).
Eventi del mouse
Esempio con gestione eventi del mouse:// ClickMe.java import
java.applet.*;import javax.swing.*;import java.awt.*;import
java.awt.event.*;
// classe di ascolto public class ClickMe extends JApplet
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 allorigine dellevento: tutta lapplet }
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);
//oppure g.fillRect(0, 0, getWidth() - 1, getHeight()- 1);
g.setColor(Color.black);g.drawRect(0, 0, getSize().width - 1,
getSize().height - 1);
//oppure g. drawRect(0, 0, getWidth() - 1, getHeight()-
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) {} // altri metodi
dellinterfaccia di ascolto public void mouseReleased(MouseEvent
event) {} // per evitare di scrivere tali segnature public void
mouseEntered(MouseEvent event) {} // di metodi si usa classe
Adapter che public void mouseExited(MouseEvent event) {} //
implementa interfaccia MouseListener}
// Spot.javapublic class Spot { public int size; public int x,
y;
public Spot(int intSize) { size = intSize; x = -1; y = -1;
}}
Nel codice HTML le dimensioni obbligatorie non saranno
nulle:
con codice pi datato (IE):
>
con codice HTML che carica ed esegue Applet con "Java Plug in"
per consentire al browser di usare un interprete Java esterno (pi
aggiornato) e adatta anche a Mozilla FireFox ed altri browser che
non supportano il tag :
Uso Eventi
Carica ed esegue Applet con uso di Java Plug-in (anche per NN
versioni precedenti alla 6):
appare uno spot rosso nel punto dove fai click col mouse
NB: getWidth() e getHeight() per recupero dimensioni senza
creare oggetto Dimension con getSize()
http://www33.brinkster.com/4binf/dispense/java/Introduzione%20ad%20Applet.doc
-
Esempio con gestione eventi del mouse con adattatore (classe di
raccordo Adapter) che evita di dover scrivere tutte le segnature
dei metodi dell'interfaccia di ascolto :
// Pallini.java versione Appletimport java.applet.*;import
javax.swing.*;import java.awt.*;import java.awt.event.*;
public class Pallini extends JApplet{
private int xP,yP; public void init() {
MiaClasseAscoltoMouse A1 = new MiaClasseAscoltoMouse ();
addMouseListener (A1); // lega la classe di ascolto allorigine
dellevento: cio // tutta lapplet ( sottinteso this : manca oggetto
origine) }
public void paint(Graphics g) { g.setColor(Color.red);
g.fillOval(xP,yP,20,20); }
public void test() { // per test in ambiente JCreator int x =
getLocationOnScreen().x; // ritorna lascissa del punto int y =
getLocationOnScreen().y; // ritorna lordinata del punto
System.out.println( "punto (" + xP + "," + yP +")" ); }
// classe interna cio innestata non staticaprivate class
MiaClasseAscoltoMouse extends MouseAdapter {
public void mousePressed (MouseEvent e) { xP = e.getX(); //
accede alla variabili istanza xP e yP della classe esterna yP =
e.getY(); // recupera gli attributi delloggetto di tipo Point
puntato dal mouse // cio le coordinate x ed y repaint();
test(); // per visualizzare coordinate } }}// fine classe
Pallini
Con codice HTML:
Uso Classe Adapter
Se premi con il mouse (all'interno di una zona) compare un
pallino rosso
NB: per estrarre coordinate sullo schermo getLocationOnScreen()
della classe java.awt.Component pu essere invocato per recuperare
le coordinate del punto in alto a sinistra ad esempio dellapplet;
il metodo ritorna infatti un oggetto di tipo Point con attributi x
ed y ed applicabile al componente corrente
-
/** * @(#)Pallini.java * * Pallini application * * @author
classi * @version 1.00 2011/4/14 */import java.awt.event.*;import
java.awt.*;import javax.swing.*;
public class Pallini extends JPanel{
private int x,y; private JFrame f ; public Pallini() {
f= new JFrame(); f.setContentPane(this);
MiaClasseAscoltoMouse A1 = new MiaClasseAscoltoMouse ();
addMouseListener (A1); // lega la classe di ascolto allorigine
dellevento: cio tutta // lapplicazione (this sottinteso)
f.setTitle("Sposta e Premi Mouse"); f.setLocation(300,300);
f.setSize(320,300); f.setVisible(true); f.setDefaultCloseOperation
(JFrame.EXIT_ON_CLOSE);
}
public void paintComponent(Graphics g) { //
super.paintComponent(g); // senza ricostruzione dello sfondo: non
aggiorna g.setColor(Color.red); g.fillOval(x,y,20,20); } private
class MiaClasseAscoltoMouse extends MouseAdapter { // classe
interna
public void mousePressed (MouseEvent e) { x = e.getX(); //
accede alla variabili istanza x e y della classe y = e.getY();
repaint(); }
}
public static void main(String[] args) { new Pallini();
}
}// fine applicazione Pallini
-
Eventi di azione
(Interfaces ActionListener, Classes ActionEvent)
Sono generati quando si premono bottoni, si selezionano voci di
men, si preme invio mentre si scrive in un campo di testo. In awt
sono generati da componenti delle classi Button, TextField, List e
MenuItem
Molti controlli Swing oltre a JButton generano eventi che
possono essere catturati da un actionListener cio sono sorgente di
eventi ActionEvent
Eventi di azione sono provocati dall'utente che agisce su un
componente (click su un pulsante); vale per gli oggetti istanza
delle classi JButton, JCheckBox, JComboBox, JRadioButton (controlli
derivati da AbstractButton) e JTextField.
I seguenti eventi ad esempio notificano un evento azione:
Quando si premere INVIO in un campo di testo Quando si seleziona
una checkbox, un radiobutton o una voce in un combobox Quando si
seleziona una voce di un menu o si clicca su un bottone
Esempio di struttura di applicazione con gestione eventi
generati4 da interazione con interfaccia grafica:
un pulsante (parte della GUI) origine dellevento (di
azione)tutta la classe ascoltatore dellevento (di azione)esiste un
solo metodo nellinterfaccia
import java.awt.event.*;import java.awt.*;import
javax.swing.*;
public class NomeClasse implements ActionListener { // classe
ascoltatore // con interfaccia per eventi di azione private JFrame
f; private Container c; private JPanel p; private JButton b; public
NomeClasse(){ // costruttore
f = new JFrame ("Cambio di colore"); c = f.getContentPane(); p =
new JPanel(); b = new JButton("Premi"); b.addActionListener (this);
// lega la classe di ascolto cio lapplicazione stessa // allorigine
dellevento cio il pulsante b.setBackground (Color.red); p.add(b);
c.add(p); f.setLocation(200,200); f.setSize(250,70);
f.setBackground(Color.white); f.setVisible(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // senza
esplicita gestione di eventi di finestra}
4 Altre applicazioni a eventi in Java: applicazioni embedded
basate su interrupt (ad esempio i driver di dispositivo) ed
applicazioni distribuite basate su scambio asincrono di eventi (ad
esempio quelle di network management)
http://java.sun.com/j2se/1.5.0/docs/api/java/awt/event/ActionEvent.htmlhttp://java.sun.com/j2se/1.5.0/docs/api/java/awt/event/ActionListener.html
-
// implemento il metodo dellinterfaccia di ascolto
public void actionPerformed (ActionEvent e) { // unico metodo da
ridefinire b.setBackground (Color.cyan); // cambia colore di sfondo
del bottone }
public static void main (String [] args) {
NomeClasse o = new NomeClasse (); } }// fine applicazione
Eventi metodi utili
Object getSource() restituisce la componente su cui si
verificato levento e si pu scoprire con instanceof a quale classe
appartiene.
getSelectedObjects()[0] ritorna array (length 1) con label o
null se non selezionato; usato con operatore di cast (String); in
alternativa, per classe Checkbox, anche getText() ActionEvent:
String getActionCommand() se levento generato su un TextField
restituisce la stringa contenuta nel TextField in alternativa a
getText() KeyEvent:
char getChar() restituisce il carattere associato al tasto che
ha generato levento char getKeyChar() int getKeyCode() restituisce
il numero corrispondente (ad esempio il tasto ESC 27)
MouseEvent:
int getX(), int getY() restituiscono le coordinate del
cursore
Definizione e Registrazione di Listeners
Definizione, due possibilit
implementando il Listenerclass MyXXXListener implements
XXXListener { // definizione dei metodi definiti da
XXXListener}
estendendo ladapter
class MyXXXListener extends XXXAdapter { // override i metodi
definiti da XXXAdapter}
Registrazione:
ogni event source ha un metodo per registrare un corrispondente
listener addXXXListener (XXXListener listenerObject)
-
possibile installare uno stesso ascoltatore, ad esempio, per
diversi bottoni di una toolbar il vantaggio risiede nel fatto che i
diversi bottoni hanno lo stesso ascoltatore (invece che pi
ascoltatori separati che fanno la stessa cosa)
Esercizio: pulsanti con stessa classe di ascolto e stesso metodo
actionPerformed()// esempio di Applet con gestione eventi della
GUI// Uso di due pulsanti
import javax.swing.*;import java.awt.event.*;import
java.awt.*;import java.applet.*;
public class Pulsanti extends JApplet {
JTextField T = new JTextField (30); JButton B1 = new
JButton("sinistro"); JButton B2 = new JButton("destro"); JFrame f1
= new JFrame("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)); Container c =
f1.getContentPane(); // recupera il "muro grezzo"
B1.addActionListener (new Ascolta()); B2.addActionListener (new
Ascolta()); c.add(B1); c.add(T); c.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"); } } } // fine
applet
Problema: scrivere un ascoltatore (listener) che alla pressione
di bottoni diversi mostri il contenuto della JTextField inserita
nella finestra istanza dell'applicazione MyFrame Lascoltatore deve
aver accesso al riferimento a quel JTextField di quella particolare
istanza
Prima soluzione: si pu utilizzare una classe interna come
ActionListenerTecnica accettabile se lascoltatore f poco altrimenti
la classe cresce sensibilmente in dimensioniSvantaggio: si
accorpano due classi che rappresentano due aspetti concettualmente
diversi
Seconda soluzione: si pu progettare lascoltatore prevedendo un
costruttore che prende in ingresso il riferimento alla finestra
contenente il bottone. La classe resta esterna ma pu accedere a
tutti gli oggetti della finestra (a patto che questi non siano
privati)
-
Un Listener per N Controlli
Primo caso: uso classe Listener interna cio innestata non
statica
public class MyFrame extends JFrame { // .....
JButton up= new JButton(Up);JButton down= new
JButton(Down);JButton random= new JButton(Random);
Listener ascoltatore = new Listener();
public MyFrame() { ... up.addActionListener(ascoltatore); //
componenti attivi della stessa natura
down.addActionListener(ascoltatore);
random.addActionListener(ascoltatore);
// ....... }
private class Listener implements ActionListener { // classe
interna
public void actionPerformed (ActionEvent e) {
Object src = e.getSource(); // si individua loggetto mittente
della segnalazioneif (src == up) { codice associato alla pressione
del bottone Up }else if (src == down) { codice associato alla
pressione del bottone Down }else if (src == random) { codice
associato alla pressione del bottone Random }
} }}
Se i componenti sono di diversa natura, ad esempio un pulsante
ed un campo di testo, entrambi in grado di generare un evento di
azione, il seguente codice pu essere utile ad intercettare il
mittente della segnalazione :
public void actionPerformed (ActionEvent evt){ Object src =
evt.getSource(); // si individua il mittente della segnalazione if
(src instanceof JTextField) funzioneCampoDiTesto(); // scelta del
giusto gestore dell'evento else if (src instanceof JButton)
funzionePulsante();}
Quando si usano classi esterne, possibile capire il componente
che ha notificato levento associando ai diversi componenti un
diverso valore della propriet actionCommand
nb: but[i]=new JButton (mess[i]); but[i].setToolTipText
(mtool[i]);
but[i].setActionCommand (mtool[i] ); // per modificare la
stringa identificativa delloggetto // registrato (associato) al
gestore devento
e.getActionCommand () ritorna String default letichetta
associata al bottone (mess[i])
-
Secondo caso: classe Listener esterna.
Nellesempio seguente i possibili diversi valori della propriet
actionCommand sono memorizzati come costanti della classe
ascoltatore Listener esternapublic class MyFrame extends JFrame {//
........
JButton up= new JButton(Up);JButton down= new
JButton(Down);JButton random= new JButton(Random);
Listener ascolt = new Listener();
public MyFrame() {//
......up.addActionListener(ascolt);up.setActionCommand(ascolt.UPOPT);down.addActionListener(ascolt);down.setActionCommand(ascolt.DOWNOPT);random.addActionListener(ascolt);random.setAction
Command(ascolt.RANDOMOPT);// ......}}// classe esternapublic class
Listener implements ActionListener {
public final static String UPOPT = Up; // costantipublic final
static String DOWNOPT = Down;public final static String RANDOMOPT =
Random;
public void actionPerformed(ActionEvent e) {String com =
e.getActionCommand(); // recupero della stringa-etichetta associata
al bottoneif (com == UPOPT) upOpt();else if (com == DOWNOPT)
downOpt(); else if (com == RANDOMOPT) randomOpt();}private void
upOpt() { ... }private void randomOpt(){ ... }private void
downOpt(){ ... }
}
Confronto soluzioni:
In senso assoluto, le prestazioni migliori si ottengono usando
l'implementazione diretta dell'interfaccia-ascoltatore, poich non
sono generate n classi n oggetti ulteriori, rispetto all'unica
concretizzazione del Tipo ascoltatore.
Le classi interne hanno il pregio di consentire una migliore
gestione della struttura interna dell'oggetto (comportamenti adatti
in ambito OO), appesantendo il caricamento dell'applicazione di
quel (tanto o poco) necessario al ClassLoader per caricare e
risolvere un certo numero di classi in pi, rispetto alla soluzione
dell'implementazione diretta.
Quale che sia la scelta adottata, ci che importa la
consapevolezza degli effetti.
-
Esercizi non risolti
Esercizio (non risolto): realizzare un'applicazione grafica con
dimensione della finestra 200x200 pixel come da layout in Fig.1
Fig. 1: GUI da progettare Fig. 2: Effetto che si vuole premendo
il pulsante Red
Alla pressione di ogni pulsante si vuole che lo sfondo cambi
colore come da Fig.2
Esercizio (non risolto): realizzare un'applet EuroConvertitore
implementando sia TextListener sia FocusListener
Esercizio: progettare un pannello che sia maschera di input che
consenta allutente di :
inserire articoli (e relativo prezzo), sia in lire che in euro
avere sempre sottocchio il totale, sia in lire che in euro poter
salvare su file, in qualunque momento, lelenco degli ordini
inseriti.
Di seguito realizzare l'applicazione di test che crea una
finestra di dimensioni 300x300 pixel e permette di visualizzare
tale maschera col layout di figura
Esercizio: prenotazione di biglietto di sola andataper una data
destinazione con soluzione online
http://www.scribd.com/doc/29332215/Esercizio7-Gui-Prenotazioni-Soluzione
-
Progetto con array (senza soluzione)Progettare unapplicazione in
Java che presenti allutente una finestra (simile a quella in
figura) con la possibilit di gestire un array di interi; la
pressione di ogni bottone determiner una delle seguenti
elaborazioni:
Reset
Riempimento con valori generati casualmente e visualizzazione
nellarea di testo sulla destra Riempimento con valori
decrescenti
Ricerca del valore massimo scritto a fondo pagina
Ordinamento non decrescente (Sort)Ricerca del valor medio
scritto a fondo paginaRicerca della prima occorrenza di un numero
digitato da Dialog box con scrittura a fondo pagina dellaposizione
o messaggio di avviso dellesito negativo su Dialog
boxVisualizzazione dei valori originari
-
Lettura da file di testo con Scanner, visualizzazione in area di
testo, salvataggio di modifiche
// lettura da file con visualizzazione in area di testo//
modifica del testo// salvataggio su file del contenuto dell'area di
testo
import java.io.*;import java.util.*;import java.awt.*;import
javax.swing.*;import java.awt.event.*;
class GUI {
private JTextArea ta = new JTextArea();private String sl;
public void leggiFile() { // LETTURA da file di testo
try {FileReader fr = new FileReader("FileIni.txt");Scanner sc =
new Scanner(fr);while(sc.hasNext()) { ta.append(sc.nextLine());
ta.append("\n"); }fr.close(); // chiusura File
} catch (IOException e) {}}
public void scriviFile() { // SCRITTURA su file di testo
try {FileWriter fw = new FileWriter("FileOut.txt"); PrintWriter
out = new PrintWriter(fw);
sl = ta.getText(); // salva in String tutto il testo
out.print(sl);fw.close(); // chiusura File } catch (IOException e)
{}
}public void visualizza(){
JFrame f = new JFrame("Finestra con area di testo");Container c
= f.getContentPane();JPanel p = new JPanel();JButton b1 = new
JButton ("salva");JButton b2 = new JButton
("cancella");b1.addActionListener (new mioAscoltatore()); //
gestione eventi di azioneb2.addActionListener (new
mioAscoltatore());p.add (b1);p.add (b2);p.setPreferredSize(new
Dimension(180, 35));ta.setEditable (true); JScrollPane listPane =
new JScrollPane(ta);
listPane.setPreferredSize(new Dimension(180, 120));
c.setLayout(new FlowLayout()); //Layout the content pane
c.setPreferredSize(new Dimension(280, 180)); c.add(p);
c.add(listPane); f.pack(); f.setVisible(true); }
-
// classe interna class mioAscoltatore implements ActionListener
{ public void actionPerformed (ActionEvent ev) {
String Bottone = ev.getActionCommand(); // testo mostrato da
pulsante if (Bottone.equals ("salva") )
scriviFile(); else if (Bottone.equals ("cancella") )
ta.setText (""); }
} } // fine class GUI
public class EsempioEventi {
public static void main(String[] args) {
GUI o = new GUI();o.leggiFile(); o.visualizza();
} } // fine applicazione che usa class GUI
Effetto alla pressione del bottone cancella:
Effetto di modifiche (uso Ctr C e Ctr V per copia/incolla):
Effetto alla pressione del bottone salva :salvataggio su file di
testo FileOut.txt
Testo : pagina iniziale
Modifica Modifica ModificaModifica Modifica ModificaModifica
Modifica ModificaModifica Modifica ModificaModifica Modifica
Modifica
Attivit: migliorare il progetto prevedendo uso di dialog box per
scegliere il nome del file
-
Gestione Thread : scritta scorrevole che si modifica da campo di
testo
Esercizio: realizzare unapplicazione con una scritta scorrevole
che si modifica da campo di testo con uso di contenitori/componenti
Swing evitando sfarfallio.
Possibile soluzione: si possono inserire due PANNELLI (in un
Container impilando in verticale); il secondo per disegnare con
interfaccia Runnable; gestione di evento di azione con interfaccia
tipo ActionListener associata al campo di testo (alla pressione di
INVIO) per cancellare il testo stesso. Nella colonna di destra le
modifiche per gestire la possibilit che la scritta scorra per tutta
la larghezza della cornice anche se l'utente ridimensiona la
finestra.
import java.awt.*;import java.awt.event.*;import
javax.swing.*;
public class TestoS implements ActionListener { private String
nome; private JTextField t; private MioPanel disegno; private
JPanel p; private JFrame f ; private Container c; private JLabel
l;
public TestoS() { // costruttore nome = "a tutti"; f = new
JFrame ("Saluto"); c = f.getContentPane(); c.setLayout (new
BoxLayout (c, BoxLayout.PAGE_AXIS)); // impila gli elementi in
verticale // nel Container p = new JPanel(); l = new JLabel
("Digita il tuo nome"); t = new JTextField(nome, 10);
t.setForeground(Color.red); // testo rosso
t.setBackground(Color.lightGray); // sfondo grigio chiaro per la
casella di testo t.addActionListener(this); disegno = new
MioPanel(t); p.add(l); p.add(t); c.add(p); c.add(disegno);
f.setSize(200,200); // con f.pack() bisogna ingrandire la finestra
per vedere il disegno f.setLocation(0,0); // se non se ne impostano
le dimensioni f.setResizable(false); f.setResizable(true);
f.setVisible(true); Thread runner = new Thread (disegno);
runner.start(); // richiama il metodo run() del thread disegno
f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); } public void
actionPerformed(ActionEvent e) { t.setText(""); // alla pressione
di INVIO } public static void main(String [] args) { new TestoS();
} } // fine applicazione TestoS
-
// classe esternaclass MioPanel extends JPanel implements
Runnable {
private String nome; private JTextField testo; private int
Xpos;
public MioPanel (JTextField t) { testo = t;
setForeground(Color.black); // scrive in nero }
// metodo obbligatorio per eseguire il thread public void run ()
{ while (true) { for (Xpos =0; Xpos
-
Confronto: scritta scorrevole che si modifica da campo di testo
(unico thread associato al main)
import java.awt.*;import java.awt.event.*;import
javax.swing.*;
public class SenzaThread implements ActionListener { private
String nome; private JTextField t; private MioPanel disegno;
private JPanel p; private JFrame f ; private Container c; private
JLabel l;
public SenzaThread() { // costruttore nome = "a tutti"; f = new
JFrame ("Saluto"); c = f.getContentPane(); c.setLayout (new
BoxLayout (c, BoxLayout.PAGE_AXIS)); // impila gli elementi in
verticale p = new JPanel(); l = new JLabel ("Digita il tuo nome");
t = new JTextField(nome, 10); t.setForeground(Color.red); // testo
rosso t.setBackground(Color.lightGray); // sfondo grigio chiaro per
la casella di testo t.addActionListener(this); disegno = new
MioPanel(t); p.add(l); p.add(t); c.add(p); c.add(disegno);
f.setSize(200,200); // con fpack bisogna ingrandire la finestra per
vedere il "disegno" f.setLocation(0,0); // se non se ne impostano
le dimensioni f.setResizable(true); f.setVisible(true);
-
f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); // deve
essere posta prima del ciclo di disegno while(true) disegno.go();
// senza craere thread }
public void cancellaNome() { t.setText(""); } public void
actionPerformed(ActionEvent e) { cancellaNome(); // alla pressione
di INVIO } public static void main(String [] args) { new
SenzaThread(); } }
// classe esternaclass MioPanel extends JPanel { private String
nome; private JTextField testo; private int Xpos;
public MioPanel (JTextField t) { testo = t; }
public void go () { // servizio richiesto for (Xpos =0; Xpos
-
Esempio d'uso JComboBox, eventi di azione, pi pannelli e
threadsimport java.awt.*;import java.awt.event.*;import
javax.swing.*;
public class Pannelli implements ActionListener { private JLabel
l; private JComboBox cbx; private String[] nome = {"produttore",
"consumatore"}; private JTextField t; private MioPanel disegno;
private JPanel p1, p2; private JFrame f ; private Container c;
public Pannelli() { // costruttore f = new JFrame ("Uso threads");
c = f.getContentPane(); //c.setLayout (new BoxLayout (c,
BoxLayout.PAGE_AXIS)); // impila gli elementi in verticale in c
c.setLayout(new GridLayout(3,1)); // unica colonna con stesso
effetto p1 = new JPanel(); p2 = new JPanel(); l = new JLabel
("Scegli"); cbx = new JComboBox(); for (int k = 0; k <
nome.length; k++) cbx.addItem (nome[k]); cbx.setEditable (false);
cbx.addActionListener (this); cbx.setForeground(Color.red); //
testo rosso cbx.setBackground(Color.lightGray); // sfondo grigio
chiaro per combobox cbx.setToolTipText("Seleziona una voce"); t =
new JTextField (nome[0],7); t.setEditable (false); disegno = new
MioPanel(t); p1.add(l); p1.add(cbx); p2.add(t);
p2.setBackground(Color.yellow); // per evidenziare le dimensioni
del secondo pannello c.add(p1); c.add(p2); c.add(disegno);
f.setSize(200,200); // con fpack bisogna ingrandire la finestra per
vedere "disegno" f.setLocation(300, 100); // se non se ne impostano
le dimensioni f.setResizable(false); f.setVisible(true); Thread
runner = new Thread (disegno); runner.start(); // richiama il
metodo run() del thread disegno f.setDefaultCloseOperation
(JFrame.EXIT_ON_CLOSE); } public void actionPerformed(ActionEvent
e) { t.setText ("" +((JComboBox) e.getSource()).getSelectedItem());
// alla pressione di INVIO } public static void main(String []
args) { new Pannelli(); } }
-
// classe esternaclass MioPanel extends JPanel implements
Runnable{ private String nome; private JTextField testo; private
int Xpos;
public MioPanel (JTextField t) { testo = t;
setForeground(Color.black); // scrive in nero }
public void run () { // metodo obbligatorio per eseguire thread
while (true) { for (Xpos =0; Xpos
-
JTextField e documento: eventi swing
Associato ad ogni campo di testo c un documento che gestisce il
testo presente e ad ogni modifica del contenuto questo documento
genera un DocumentEvent per segnalare l'avvenuto cambiamento.Tale
evento dev'essere gestito da un opportuno DocumentListener
L'interfaccia DocumentListener dichiara tre metodi:
void insertUpdate(DocumentEvent e);void
removeUpdate(DocumentEvent e);void changedUpdate(DocumentEvent
e);
Il terzo non mai chiamato da un JtextField, serve solo per altri
tipi di componenti L'oggetto DocumentEvent passato come parametro
non ha nessuna utilit nel nostro esempio.
Nel nostro caso l'azione da svolgere in caso di inserimento o
rimozione di caratteri identica, quindi i due metodi
void insertUpdate(DocumentEvent e);void
removeUpdate(DocumentEvent e);
saranno identici (purtroppo vanno comunque implementati
entrambi)Anche metodo il changedUpdate(DocumentEvent e) inutile,
dato che JTextField non lo chiama ma va comunque formalmente
implementato.
import javax.swing.event.*;import java.awt.*;import
javax.swing.*; class Es12Panel extends JPanel implements
DocumentListener{JTextField txt1, txt2;public
Es12Panel(){super();txt1 = new JTextField("Scrivere qui il testo",
25);txt2 = new JTextField(25);
txt2.setEditable(false);txt1.getDocument().addDocumentListener(this);
// ricava il documento di cui il campo di testo txt1 fa parte, e
gli // associa come listener il pannelloadd(txt1);add(txt2);}public
void insertUpdate(DocumentEvent e){ txt2.setText(txt1.getText());
}public void removeUpdate(DocumentEvent e){
txt2.setText(txt1.getText());
}public void changedUpdate(DocumentEvent e){ }}
public class DocumentP{public static void main(String []
args){
JFrame f = new JFrame ("Testo"); Container c =
f.getContentPane();
Es12Panel guiP = new Es12Panel(); guiP.setBackground(Color.
lightGray); // sfondo del pannello colorato
c.add(guiP); // aggiunge il pannello f.setSize(300,100);
f.setVisible(true); f.setDefaultCloseOperation
(JFrame.EXIT_ON_CLOSE);
}}
-
ADTJList (da Tutorial Sun)
import java.awt.*;import java.awt.event.*;import
javax.swing.*;import javax.swing.event.*;
public class ListDemo extends JPanel implements
ListSelectionListener { private JList list; private
DefaultListModel listModel; // in javax.swing
private static final String hireString = "Hire"; private static
final String fireString = "Fire"; private JButton fireButton;
private JTextField employeeName;
public ListDemo() { super(new BorderLayout());
listModel = new DefaultListModel(); listModel.addElement("Debbie
Scott"); listModel.addElement("Scott Hommel");
listModel.addElement("Sharon Zakhour");
//Create the list and put it in a scroll pane. list = new
JList(listModel);
list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
list.setSelectedIndex(0); list.addListSelectionListener(this);
list.setVisibleRowCount(5); JScrollPane listScrollPane = new
JScrollPane(list);
JButton hireButton = new JButton(hireString); HireListener
hireListener = new HireListener(hireButton);
hireButton.setActionCommand(hireString);
hireButton.addActionListener(hireListener);
hireButton.setEnabled(false);
fireButton = new JButton(fireString);
fireButton.setActionCommand(fireString);
fireButton.addActionListener(new FireListener());
employeeName = new JTextField(10);
employeeName.addActionListener(hireListener);
employeeName.getDocument().addDocumentListener(hireListener);
String name = listModel.getElementAt(
list.getSelectedIndex()).toString();
//Create a panel that uses BoxLayout. JPanel buttonPane = new
JPanel(); buttonPane.setLayout(new BoxLayout(buttonPane,
BoxLayout.LINE_AXIS));
buttonPane.add(fireButton);
buttonPane.add(Box.createHorizontalStrut(5)); buttonPane.add(new
JSeparator(SwingConstants.VERTICAL));
buttonPane.add(Box.createHorizontalStrut(5));
buttonPane.add(employeeName); buttonPane.add(hireButton);
buttonPane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
add(listScrollPane, BorderLayout.CENTER); add(buttonPane,
BorderLayout.PAGE_END); }
http://java.sun.com/docs/books/tutorial/uiswing/components/list.html
-
class FireListener implements ActionListener { public void
actionPerformed(ActionEvent e) { //This method can be called only
if there's a valid selection //so go ahead and remove whatever's
selected. int index = list.getSelectedIndex();
listModel.remove(index);
int size = listModel.getSize();
if (size == 0) { //Nobody's left, disable firing.
fireButton.setEnabled(false);
} else { //Select an index. if (index == listModel.getSize()) {
//removed item in last position index--; }
list.setSelectedIndex(index); list.ensureIndexIsVisible(index);
} } }
//This listener is shared by the text field and the hire button.
class HireListener implements ActionListener, DocumentListener {
private boolean alreadyEnabled = false; private JButton button;
public HireListener(JButton button) { this.button = button;
}
//Required by ActionListener public void
actionPerformed(ActionEvent e) { String name =
employeeName.getText();
//User didn't type in a unique name... if (name.equals("") ||
alreadyInList(name)) { Toolkit.getDefaultToolkit().beep();
employeeName.requestFocusInWindow(); employeeName.selectAll();
return; }
int index = list.getSelectedIndex(); //get selected index if
(index == -1) { //no selection, so insert at beginning index = 0; }
else { //add after the selected item index++; }
listModel.insertElementAt(employeeName.getText(), index); //If
we just wanted to add to the end, we'd do this:
//listModel.addElement(employeeName.getText());
//Reset the text field. employeeName.requestFocusInWindow();
employeeName.setText("");
//Select the new item and make it visible.
list.setSelectedIndex(index); list.ensureIndexIsVisible(index);
}
-
//This method tests for string equality. You could certainly
//get more sophisticated about the algorithm. For example, //you
might want to ignore white space and capitalization. protected
boolean alreadyInList(String name) { return
listModel.contains(name); }
//Required by DocumentListener public void
insertUpdate(DocumentEvent e) { enableButton(); }
//Required by DocumentListener. public void
removeUpdate(DocumentEvent e) { handleEmptyTextField(e); }
//Required by DocumentListener. public void
changedUpdate(DocumentEvent e) { if (!handleEmptyTextField(e)) {
enableButton(); } }
private void enableButton() { if (!alreadyEnabled) {
button.setEnabled(true); } }
private boolean handleEmptyTextField(DocumentEvent e) { if
(e.getDocument().getLength()
-
/** * Create the GUI and show it. For thread safety, * this
method should be invoked from the * event-dispatching thread. */
private static void createAndShowGUI() { //Create and set up the
window. JFrame frame = new JFrame("ListDemo");
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE);
//Create and set up the content pane. JComponent newContentPane
= new ListDemo(); newContentPane.setOpaque(true); //content panes
must be opaque frame.setContentPane(newContentPane);
//Display the window. frame.pack(); frame.setVisible(true);
}
public static void main(String[] args) {
//Schedule a job for the event-dispatching thread: //creating
and showing this application's GUI.
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() { createAndShowGUI(); } }); }}Inserimento:
automaticamente ordinato
Cancellazione della voce selezionata:
prima
dopo .
-
Esercizio: Disegno di un auto in altra finestra alla pressione
di un pulsante (evento della GUI)
Con codice HTML:
Disegno di un Auto come evento
// Applet Autoe.java// esempio di Applet con gestione eventi
della GUI: creazione di eventi personalizzati// Uso canvasimport
java.applet.*;import javax.swing.*;import java.awt.*;import
java.awt.event.*;
public class Autoe extends JApplet {
Auto A;
public void init() {
JButton B = new JButton ("Disegna un auto"); GestiscePulsante A1
= new GestiscePulsante(); // crea ascoltatore B.addActionListener
(A1); // lega la classe di ascolto al