Gestione di interfacce grafiche (gui) con Swing di Java



Scaricare 140.18 Kb.
10.12.2017
Dimensione del file140.18 Kb.

Gestione di interfacce grafiche (GUI) con Swing di Java.
Introduzione

Verranno presentati i passi indispensabili per costruire GUI (Graphics User Interface) utilizzando gli elementi grafici di Swing che fanno parte del package javax.swing.



Swing:

  • è stato introdotto dalla versione 1.2 di Java ed è costruito sopra un altro package per la gestione delle GUI che è AWT: Abstract Windowing Toolkit) rilasciato nel package java.awt.

  • si appoggia sulle classi AWT e tutti i suoi elementi grafici derivano dall’oggetto Container di AWT

java.lang.Object

java.awt.Component

java.awt.Container

java.awt.Window

java.awt.Frame

javax.swing.JFrame


  • amplia il numero di componenti grafici a disposizione.

  • completamente scritto in Java, in modo da assicurarne un perfetto porting interpiattaforma.

  • utilizza la struttura di gestione degli eventi di AWT

  • utilizza gli stessi Layout Manager standard di AWT

Gli elementi fondamentali di una GUI sono classificati in Swing nel seguente modo:



    • i contenitori principali (top-level container):

      • la semplice finestra dalle funzionalità limitate: JWindow

      • una finestra con caratteristiche avanzate (maggiormente usata): JFrame

      • le finestre di dialogo di ogni tipo: JDialog

      • le finestre di applet: JApplet

    • i contenitori intermedi (intermediate container o pane):

      • pannello: JPanel

      • pannello con barre di scorrimento. JScrollPane

      • scheda con etichette: JTabbedPane

    • i componenti finali (component):

      • etichette: JLabel

      • caselle di testo: JTextField

      • area di testo: JTextArea

      • caselle combinate (combo box): JComboBox

      • bottoni: JButton

      • ecc


J


Content pane

Barra dei menu

Frame



JPanel


JButton

JLabel


Ogni contenitore top-level contiene, per default, un contenitore intermedio detto content pane (pannello del contenuto)


I componenti finali non possono essere inseriti direttamente nel contenitore di alto livello ma solo in un contenitore intermedio.
L’eventuale barra dei menu deve essere inserita direttamente nel contenitore di alto livello, automaticamente è messa in una predefinita posizione.


Creare una semplice finestra (Esercizio: LezioniSwing->FrameVuoto)
Per utilizzare una classe Swing occorre importare le classi dal relativo package:
import javax.swing.*; // rende accessibili tutte le classi Swing
Dato che possono essere necessarie anche classi di awt e di awt.event è opportuno anche importare i relativi package:

import java.awt.*; // rende accessibili tutte le classi awt

import java.awt.event.*; // rende accessibili tutte le classi di awt.event

I passi essenziali per creare una semplice finestra di base sulla quale andremo a piazzare dei semplici componenti sono:



  1. rendere la nostra interfaccia una sottoclasse di JFrame

  2. inizializzarla invocando un opportuno metodo costruttore

  3. impostarne le dimensioni esprimendole in pixel

  4. associare un evento alla chiusura del frame

  5. visualizzare il frame



Look & feel (Esercizio: LezioniSwing->CiaoMondoSwing)

In Swing vi è anche la possibilità di definire tramite il codice l’aspetto grafico dell’interfaccia (look and fell) tramite un metodo statico della classe JFrame:



JFrame.setDefaultLookAndFeelDecorated(false);

imposta il look in modo tale che si adatti all’ambiente dove è eseguita l’applicazione (windows like)


JFrame.setDefaultLookAndFeelDecorated(true);

imposta il look uguale per tutte le piattaforme (java like)



I Pannelli (Esercizio: LezioniSwing->PannelliColorati)

I pannelli, contenitori intermedi, hanno lo scopo di contenere i componenti finali e raggrupparli per poterli posizionare e riposizionare all’interno del content pane del frame




Utilizzo dei componenti Testo (Esercizio: LezioniSwing->FrameConComponenti)
Per inserire componenti (etichette, campi testo, aree testo, ecc.) in un frame sono necessari i seguenti passi:

  1. creare ed inizializzare opportunamente i componenti da inserire

  2. inserire i componenti creati in un pannello

  3. far diventare tale pannello il riquadro del contenuto del frame
    oppure inserire il pannello nel contenuto del frame

Descriverò il funzionamento basilare di Etichette, campi di testo e aree di testo elementi indispensabili per rendere la nostra applicazione interattiva ed operante su dati inseriti dall'utente:




  • ETICHETTA ( JLabel ) è un componente che contiene semplicemente del testo informativo (di solo output) con capacità inglobare anche un'icona o, al limite, contenerli entrambi.

I costruttori di base sono :



  1. JLabel(String); // Crea un'etichetta visualizzante la stringa passata come parametro

  2. JLabel(String, int); // Crea un'etichetta visualizzante la stringa passata come parametro definendone l'allineamento a mezzo di un flag

  3. JLabel(String, Icon, int); // Crea un'etichetta visualizzante la stringa passata come parametro e l'icona associata definendone l'allineamento a mezzo di un flag

I tre flag che definiscono l'allineamento sono :



SwingConstants.LEFT

SwingConstants.RIGHT

SwingConstants.CENTER (comportamento di default)
I metodi più importanti sono:

String getText();

Icon getIcon();

void setText(String s);

void setIcon(Icon i);



  • CAMPO DI TESTO (JTextField, JPasswordField ) è un componente che gestisce una riga di input da tastiera.

I costruttori di base sono:



  1. JtextField(); // Genera un campo di testo vuoto

  2. JtextField(int); // Genera un campo di testo di larghezza specificata

  3. JtextField(String, int); // Genera un campo di testo contenente una stringa e di larghezza specificata.

I metodi indispensabili per l'utilizzo :



  1. setEditable(boolean); // posto a “true” permette la modifica del testo contenuto, al contrario “false” non permette l'immissione di input da tastiera

  2. boolean isEditable(); // restituisce lo stato di modifica del componente

  3. setText(String); // permette di immettere testo nel componente

  4. String getText(); // restituisce ovviamente il contenuto in forma di stringa

  5. String getSelectedText(); // restituisce il solo testo selezionato dall'utente

Un’utile classe è il campo password con la capacità di criptare l'output a video con un carattere a nostra scelta durante la digitazione.

Si tratta della classe JpasswordField che permette di creare un campo ad hoc per lo scopo definendone le dimensioni e mediante un opportuno metodo impostare il carattere per l'echo a video:

JpasswordField pf = new JpasswordField(10); // istanzia un oggetto campo password di dimensione 10

pf.setEchoChar('*'); // il classico asterisco!



  • AREA DI TESTO ( JTextArea ) rappresenta in pratica un campo di testo in forma matriciale, con un certo numero di righe e di colonne.

I costruttori di base sono :



  1. JTextArea(int, int); // Crea un'area di testo di dimensioni righe, colonne

  2. JtextArea(String, int ,int); // Come sopra solo che inserisce una stringa da codice

I metodi più usati sono:



getText(); getSelectedText() e setText(String) funzionanti come per i campi di testo

ed alcune funzionalità di editing come :



append(String); // accoda del testo

insert(String, int); // inserisce del testo alla posizione specificata

setLineWrap( boolean); // specifica se “true” di andare a capo automaticamente a fine riga

setWrapStyleWord( boolean ); // va a capo con la parola se “true” o col singolo carattere se “false”
I componenti per la scelta (Esercizio: LezioniSwing->FrameConScelte)
I componenti che presento ora sono necessari quando è opportuno effettuare delle scelte all’interno di opzioni predeterminate. I componenti a disposizione sono:

    • JList: lista scrollabile con scelta multipla

    • JComboBox: menu a discesa con scelta di un solo valore

    • JCheckBox: casella spuntabile con etichetta, sono possibili più scelte

    • JRadioButton: casella spuntabile con etichetta, le scelte sono in alternativa

(esiste anche il componente menu e i suoi accessori, che non trattiamo in queste lezioni)


  • LISTA SCROLLABILE (Jlist)

I costruttori di base sono:



  1. JList() // Crea una JList con nessun valore inserito

  2. JList(Object[] listData) //Crea una JList che visualizza gli elementi contenuti nell’array listData.

  3. JList(Vector listData) //Crea una JList che visualizza gli elementi contenuti nel Vector listData.

I metodi più usati sono:



  1. int getSelectedIndex() //Ritorna il valore del primo indice selezionato; -1 se non ci sono selezioni

  2. int[] getSelectedIndices() //Ritorna un array contenente tutti gli indici selezionati, in ordine crescente.

  3. Object getSelectedValue() //Ritorna il primo elemento selezionato; null se non ci sono selezioni.

  4. Object[] getSelectedValues() //Ritorna un array di elementi selezionati.

  5. boolean isSelectedIndex(int index) //Ritorna true se lo specificato indice è selezionato.

  6. boolean isSelectionEmpty() //Ritorna true se non ci sono selezioni.

  7. void setListData(Object[] listData) //Setta il contenuto della JList con i dati contenuti nell’array listData.

  8. void setListData(Vector listData) //Setta il contenuto della JList con i dati contenuti nel Vector listData.




  • MENU A DISCESA CON SCELTA SINGOLA (JComboBox)

I costruttori più usati sono:



    1. JComboBox() // Crea un JComboBox con nessun valore inserito

    2. JComboBox(Object[] listData) //Crea una JComboBox che visualizza gli elementi contenuti nell’array listData.

    3. JComboBox(Vector listData) //Crea una JComboBox che visualizza gli elementi contenuti nel Vector listData.

I metodi più usati sono:



  1. void addItem(Object anObject) //Aggiunge una voce alla lista.

  2. Object getItemAt(int index) //Ritorna l’oggetto della lista alla specifica posizione index.

  3. int getItemCount() //Ritorna il numero di elementi nella lista.

  4. int getSelectedIndex() //Ritorna il primo elemento della lista che è stato selezionato.

  5. Object getSelectedItem() //Ritorna il corrente oggetto selezionato.

  6. Object[] getSelectedObjects() //Ritorna un array contenente gli elementi selezionati.

  7. void insertItemAt(Object anObject, int index) //Inserisce una nuova voce, nella posizione index, nella Combo.

  8. boolean isEditable() //Ritorna true se JComboBox is editabile.

  9. void removeAllItems() //Rimuove tutte le voci dalla JComboBox

  10. void removeItem(Object anObject) //Rimuove la voce specificata dalla JComboBox.

  11. void removeItemAt(int anIndex) //Rimuove la voce di posizione anIndex dalla Combo.

  12. void setEditable(boolean aFlag) //Determina se la JComboBox è editabile.

  13. void setEnabled(boolean b) //Abilita la possibilità di selezionare voci dalla JComboBox

  14. void setSelectedIndex(int anIndex) //Seleziona la voce alla posizione anIndex.

  15. void setSelectedItem(Object anObject) //Setta la voce selezionata alla voce anObject.



  • CASELLE SPUNTABILI (JCheckBox)

I costruttori più usati sono:



    1. JCheckBox() // Crea un JCheckBox con nessun testo

    2. JCheckBox(String text) //Crea un JCheckBox con uno specificato testo non selezionato.

    3. JCheckBox(String text, boolean selected) //Crea un JCheckBox con uno specifico testo e se è o meno selezionato.

I metodi più usati sono:

(la determinazione della scelta effettuata è demandata alla gestione degli eventi)


  • CASELLE SPUNTABILI A SCELTA ESCLUSIVA (JRadioButton)

I costruttori più usati sono:



    1. JRadioButton() // Crea un JRadioButton con nessun testo

    2. JRadioButton() (String text) //Crea un JRadioButton con uno specificato testo non selezionato.

    3. JRadioButton(String text, boolean selected) //Crea un JRadioButton con uno specifico testo e se è o meno selezionato.

I metodi più usati sono:

(la determinazione della scelta effettuata è demandata alla gestione degli eventi)
I JRadioButton usati con un oggetto ButtonGroup creano un gruppo di bottoni nel quale solo un bottone alla volta può essere selezionato. Per realizzare questo è necessario prima creare un oggetto ButtonGroup e poi utilizzare il metodo add di ButtonGroup per includere i componenti JRadioButton nel gruppo.
I Pulsanti (Esercizio: LezioniSwing->FrameConPulsanti)
I pulsanti (bottoni) sono i componenti dell’interfaccia Swing per confermare, annullare, le scelte effettuate in una finestra oppure per entrare o uscire da una finestra.
I costruttori di base sono:

JButton() // Crea un bottone senza nessun testo o icona sopra.

JButton(Icon icon) //Crea un bottone con una icona sopra.

JButton(String text) //Crea un bottone con testo sopra.

JButton(String text, Icon icon) //Crea un bottone con testo e icona sopra.


Gestione del Layout (Esercizio: LezioniSwing->FrameConLayout)
Per gestire al meglio la dislocazione dei componenti nei contenitori Java ha previsto vari tipi di Layout, cioè vari tipi di dislocazioni dei componenti gestiti da un oggetto associato al contenitore per il quale stiamo definendo il layout, chiamato LayoutManager.

In Java esistono vari tipi di layout che possono essere concatenati ed usati in maniera innestata, ne presentiamo solo i più utilizzati:



  • FlowLayout (assunto per difetto da JPanel): i componenti vengono aggiunti uno accanto all’altro centrati su una “riga”, separati da 5 pixel. Si può andare a capo occupando la riga successiva.

  • BorderLayout (assunto per difetto da JFrame): i componenti vengono dislocati a scelta del programmatore in una delle 5 regioni previsto per questo layout con il comando del tipo add(comp1, BorderLayout.EAST) oppure add(comp1, BorderLayout.SOUTH)





  • GridLayout: il contenitore viene idealmente diviso in una griglia di celle, tutte della stessa dimensione, ciascuna delle quali può ospitare un componente.




( 0 , 0 )

( 1 , 0 )

( 2 , 0 )

( 0 , 1 )

( 1 , 1 )

( 2 , 1 )

( 0 , 2 )

( 1 , 2 )

( 2 , 2 )




  • GridBagLayout: come il precedente, ma le celle possono essere di dimensione differenti. Molto flessibile ma più complicato da utilizzare (specificazione di alcuni vincoli). Daremo maggior spazio a questo gestore in quanto è il più versatile ed adatto ai più comuni scopi.

Si tratta in linea di principio di suddividere un pannello in una griglia (righe e colonne), le cui celle saranno in grado di ospitare i componenti desiderati ; la peculiarità di questo metodo consiste nel fatto che un componente può occupare più di una cella della griglia (N.B. Una cella non può contenere più di un componente), le proporzioni tra le dimensioni di riga e di colonna possono essere differenti ed i componenti possono assumere orientamenti diversi all'interno delle celle.

Bisogna prima di tutto stabilire il mappaggio delle celle all'interno del pannello, la notazione è quella classica (n° colonna, n° riga) a partire dall'angolo in alto a sinistra della griglia :

Ora bisognerà dividere il progetto del layout in 3 fasi :



  1. Creazione di un gestore di layout (classi GridBagLayout e GridBagConstrait)

  2. Definizione dei vincoli di ciascun componente

  3. Comunicare i vincoli del punto 2 al gestore ed aggiungere quest'ultimo al contenitore

La classe GridBagLayout è capace di istanziare il vero e proprio gestore di tutta la matrice ed è proprio una sua istanza che verrà agganciata al nostro panello, la classe GridBagConstrait invece si occupa di definire le regole di layout inerenti alle singole celle; essa si avvale di 6 variabili di tipo int :

  1. gridx : n° di colonna della cella da riferire

  2. gridy : n° di riga della cella da riferire

  3. gridwidth : n° di colonne occupate dal componente (si considera sempre l'espansione del componente verso destra)

  4. gridheight : n° di righe occupate dal componente ( si considera l'espansione del componente verso il basso)

  5. weightx : definisce le proporzioni delle colonne

  6. weighty : definisce le proporzioni delle righe

I parametri dei punti 5 e 6 sono da considerarsi dei pesi ponderati. Per comprendere il concetto occorre rendersi conto che per fissare le ampiezze di una colonna basta fissare l'ampiezza di una cella della colonna stessa e per fissare l'altezza di una riga basta fissare l'altezza di una cella della riga stessa, le altre celle si adatteranno espandendosi all'area disponibile restante.

Per pesi ponderati si intende che se abbiamo una griglia 2 x 2 e vogliamo che l'ampiezza della prima cella sia il 30% dell'ampiezza della seconda, devo impostare weightx della cella (0,0) a 30 e weightx della cella (1,0) a 100, gli stessi valori delle celle sottostanti relativi allo stesso campo weightx posso lasciarli a 0 il che sta a significare che il layout per quella cella è stato definito altrove (nel nostro caso sulle celle soprastanti).

In definitiva si fa una somma dei parametri passati a tutte le celle di una riga o di una colonna e si applicano delle proporzioni con l'unica eccezione che uno 0 non vuol dire ampiezza o altezza nulla se in qualche altra parte ne è stato definito il layout.

Un trucchetto per scrivere velocemente codice può essere quello di fare in modo che le celle che definiscono il layout abbiano la somma dei valori dei campi pari a 100, così basterà limitarsi a scrivere il valore percentuale della larghezza dell'intero pannello o della sua altezza; questo è il metodo che useremo negli esempi.

Si potrebbe pensare inoltre di inserire inizialmente solo pulsanti a posto dei componenti reali per via della loro semplicità gestionale e per la loro proprietà di riempire l'intera area ; in seguito si potranno sostituire semplicemente i componenti con quelli reali.

Rimangono da trattare solo due attributi per avere una gestione soddisfacente di questo layout dinamico e sono contenuti all'interno della classe GridBagConstraints:



  • limit : definisce il tipo di espansione del componente all'interno della cella che può essere di 4 tipi

  1. GridBagConstraints.BOTH : espande in entrambe le direzioni (default)

  2. GridBagConstraints.NONE : nessuna espansione

  3. GridBagConstraints.HORIZONTAL : solo espansione orizzontale

  4. GridBagConstraints.VERTICAL : solo espansione verticale

  • anchor : definisce l'orientazione del componente all'interno della cella , si hanno intuitivamente 8 costanti : GridBagConstraints.XYZ dove al posto di XYZ sono possibili i seguenti : NORTH , NORTHEAST, EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, NORTHWEST.


Guardiamo l’esempio (Esercizio: LezioniSwing->FrameConLayoutAvanzato)


In generale per la scelta di un layout si richiede che il contenitore esegua il metodo setLayout:


mioContenitore.setLayout(new tipoLayout(evParametri))

Gestione degli eventi (Esercizi: LezioniEventi->*)
Cos’è un Evento:

tutto ciò che accade nella nostra interfaccia è interpretato come un evento (click del mouse, ecc), pertanto dobbiamo imparare a gestire e classificare gli eventi.


Che modello utilizza java per gestire gli eventi?

Il modello utilizzato da Java per la gestione degli eventi è detto modello a delegazione:

ogni componente visuale è una potenziale sorgente di eventi la cui gestione è delegata ad un oggetto ascoltatore con il compito di “ascoltare” e gestire gli eventi provenienti da quella sorgente.


Cosa succede nella JVM quando avviene un evento?

Quando si verifica un evento la successione delle azioni che la JVM intraprende è la seguente:



  1. i bassi livelli della libreria AWTsentonol’evento e lo accodano in una coda generale degli eventi;

  2. l’evento viene prima o poi estratto dalla coda e trasmesso alla sorgente, cioè al componente che era attivo o che aveva il fuoco, quando l’evento si è verificato;

  3. l’evento viene automaticamente trasformato dalla sorgente in un oggetto Event della (sotto)classe opportuna; l’oggetto Event contiene tutte le informazioni sull’evento (chi l’ha creato, cosa è successo, etc)

  4. l’evento viene così passato all’ascoltatore che si era precedentemente registrato per gestire gli eventi provenienti da quella sorgente; l’attività non è più algoritmica (input / computazione / output) ma è interattiva e reattiva;

  5. l’ascoltatore gestisce l’evento, esegue cioè il codice predisposto come reazione all’evento;

  6. al termine della gestione l’evento si considera consumato (evaso) ed il sistema è di nuovo pronto a ricevere ed elaborare nuovi eventi, estraendoli dalla coda generale (questo punto fa dipendere l’efficienza generale del sistema)

Gli ascoltatori di eventi sono oggetti che sono registrati ad una sorgente, sono possibili due situazioni:


ascoltatore1

sorgente ascoltatore2

.



ascoltatoreN

sogente1

sorgente2

. ascoltatore1



sorgenteN

La prima è preferibile perché estende la delega a + ascoltatori.


Cosa devo fare concretamente per gestire gli eventi?


  1. creare uno o più ascoltatori, in base agli eventi che si vogliono gestire per un componente;

    class mioAscoltatore implements TipoAscoltatore{

………

………


}


  1. registrare l’ascoltatore presso un oggetto origine (componente) che si vuole controllare;



mioComponente.addTipoAscoltatore(new mioAscoltatore());



  1. gestire l’evento eseguendo il codice associato; cioè è necessario iserire, in mioAscoltatore, tutti i metodi astratti presenti nell’interfaccia TipoAscoltatore scelta ed implementare (aggiungere codice) a quelli che si intende effettivamente gestire.

(un’interfaccia è una classe con soli metodi e tutti astratti, pertanto l’ascoltatore che implementa una certa interfaccia deve occuparsi di definirli tutt).



  1. inserire il componente in un pannello;



Tipi di eventi

descrizione

Oggetto ascoltatore associato

Nome del metodo, presente nei componenti che possono usare l’evento, per registrarsi

Metodi presenti nell’interfaccia

Descrizione del metodo

ActionEvent

eventi di azione: sono provocati dall'utente che agisce su un componente (click su un pulsante); vale per gli oggetti istanza delle classi (scelta): JButton, JCheckBox, JComboBox, JTextField, JRadioButton.


ActionListener

addActionListener();

actionPerformed(ActionEvent ev)

viene comandata l’azione

AdjustmentEvent

eventi di modifica: generati dalla modifica apportata ad un componente (barre di scorrimento); vale quindi per istanze della classe JScrollBar




addAdjustementListener();

adjustmentValueChanged(AdjustmentEvent e)
          

Viene comandato quando il valore di una barra di scorrimento viene modifcato

ComponentEvent
















ContainerEvent
















FocusEvent

eventi di selezione: generati da un componente che guadagna o perde la selezione (focus); vale per tutti i componenti di Swing

FocusListener

addFocusListener();

focusGained(FocusEvent ev)

Quando guadagna il focus













focusLost(FocusEvent ev)

Quando perde il focus

ItemEvent

eventi di elemento: si generano quando un componente viene modificato; interessa le classi JButton, JCheckBox, JComboBox, JRadioButton

ItemListener

addItemListener();

itemStateChanged(ItemEvent ev)

Viene cambiata la scelta di un dato

KeyEvent

eventi della tastiera: generati dalla pressione dei tasti della tastiera; interessa tutti i componenti Swing.

KeyListener

addKeyListener();

keyPressed(KeyEvent ev)

Viene premuto un tasto













keyReleased(KeyEvent ev)

Viene rilasciato un tasto













keyTyped(KeyEvent ev)

La tastiera comunica un carattere

( leggere con ev.getKeyChar(), ev.getKeyCode() )



MouseEvent

eventi del mouse: generati dal passaggio del puntatore del mouse su un'area del componente, o da un click su di essa; interessano tutte le classi Swing.

MouseListener

addMouseListener();

mouseClicked(MouseEvent ev)

Pressione e rilascio di un bottone del mouse













mouseEntered(MouseEvent ev)

Il mouse entra nell’area del componente













mouseExited(MouseEvent ev)

Il mouse esce dall’area del componente













mousePressed(MouseEvent ev)

Viene premuto un bottone del mouse













mouseReleased(MouseEvent ev)

Viene rilasciato un bottone del mouse

MouseMotionEvent

eventi di movimento

del mouse: tengono traccia del movimento del puntatore del mouse sopra un componente e come sopra interessano tutte le classi Swing.

MouseMotionListener

addMouseMotionListener();

mouseDragged(MouseEvent ev)

Il mouse si muove con un bottone premuto













mouseMoved(MouseEvent ev)

Il mouse si muove

TextEvent

eventi di digitazione: immissione di testo da parte dell'utente nei componenti testuali quali JTextField, JTextArea, ecc.

TextListener

addTextListener();

textValueChanged(TextEvent ev)

Viene modificato il testo del componente

WindowEvent

eventi di finestra:

ci avvertono riguardo lo stato della finestra che contiene la nostra applicazione ad esempio quando si cerca di chiudere, ridimensionare o ridurre ad icona una finestra, interessano le classi di tipo JWindow e JFrame.



WindowListener

addWindowListener

windowActivated(WindowEvent ev)

La finestra diventa attiva













windowClosed(WindowEvent ev)

Viene chiamata la dispose sulla finestra













windowClosing(WindowEvent ev)

L’utente chiude la finestra













windowDeactivated(WindowEvent ev)

La finestra diventa inattiva













windowDeiconified(WindowEvent ev)

La finestra viene ingrandita













windowIconified(WindowEvent ev)

La finestra viene minimizzata













windowOpened(WindowEvent ev)

La finestra appare per la prima volta

I più usati sono ActionEvent, MouseEvent e MouseMotionEvent.


Riconoscimento del componente che ha generato l’evento

Se nella GUI sono presenti più di un componente reso interattivo, dobbiamo occuparci del riconoscimento di quale di essi ha generato l'evento prima di intraprendere un'azione.


a) Eventi di Azione

Per quanto riguarda gli eventi di azione, ad esempio se abbiamo due pulsanti ai quali corrispondono due diversi comandi, ci si deve incaricare di intercettare quale sia stato il pulsante premuto e richiamare la relativa routine associata ; a tale scopo ci viene incontro il metodo getSource(), che ci rivelerà informazioni riguardo la natura del componente che ha segnalato di essere gestito.

Tale metodo dovrà essere invocato dall'oggetto che viene automaticamente passato come parametro alla/e funzione/i dell'interfaccia che dobbiamo implementare (di tipo EventObject).

L'interfaccia actionListener ha un solo evento: actionPerformed(), quindi dovremo implementare solo il suo codice.


Esempio di due pulsanti :
public void actionPerformed(ActionEvent evt){
Object src = evt.getSource();
// individuiamo il mittente della segnalazione e scegliamo il giusto gestore dell'evento
if (src == pulsante1) funzionePulsante1();

else if (src == pulsante2) funzionePulsante2();

}
Se ad esempio abbiamo due componenti di diversa natura, ad esempio un pulsante ed un campo di testo che sono entrambi in grado di generare un evento “in azione”, il seguente codice può esserci utile ad intercettare il mittente della segnalazione :
public void actionPerformed(ActionEvent evt){
Object src = evt.getSource();
// individuiamo il mittente della segnalazione e scegliamo il giusto gestore dell'evento

if (src istanceOf JtextField) funzioneCampoDiTesto();

else if (src istanceOf JButton) funzionePulsante();

}

Un ulteriore modo di intercettare il segnalante è quello di utilizzare il metodo getActionCommand() che ritorna informazioni riguardo il componente, informazioni sotto forma di stringa che possono essere impostate con setActionCommand(String) .

Tale metodo risulta molto utile nel caso in cui più di un componente deve effettuare la stessa funzione.


      1. Eventi di Selezione

Per quanto riguarda gli eventi di selezione (focus) che si manifestano quando un componente ottiene o perde lo stato di elemento attivo, gli unici metodi che occorre implementare sono :
public void focusGained(FocusEvent evt) e

public void focusLost(FocusEvent evt)
e gestire il tutto come visto sopra.

c) Eventi di Elemento

Gli eventi di elemento devono essere implementati sviluppando il metodo:



void itemStateChanged(ItemEvent evt)

e per determinare l'oggetto che lo ha invocato occorre invocare:



getItem() sull'oggetto ItemEvent ;
si può anche controllare se l'elemento è stato selezionato o deselezionato richiamando getStateChange() che ritorna due costanti : ItemEvent.DESELECTED o ItemEvent.SELECTED.

d) Eventi Tastiera

Gli eventi della tastiera vanno gestiti implementando le seguenti :



public void keyPressed(KeyEvent evt)

public void KeyReleased(KeyEvent evt)

public void KeyTyped(KeyEvent evt)

il metodo getKeyChar() dell'oggetto KeyEvent restituisce il codice del carattere del tasto associato all'evento e se non esiste un carattere UNICODE da associargli, ritorna la costante KeyEvent.CHAR_UNDEFINED.



e) Eventi Mouse

Per quanto riguarda gli eventi del mouse, che sono generati da componenti che interagiscono col puntatore del mouse, occorre gestire i seguenti metodi :



mouseClicked(MouseEvent evt);

mouseEntered(MouseEvent evt);

mouseExited(MouseEvent evt);

mousePressed(MouseEvent evt);

mouseReleased(MouseEvent evt);
ognuno del tipo public void.

Associate alla classe Mouse Event le seguenti funzioni : getClickCount() che ritorna il n° di click effettuati su un componente, getPoint() che ritorna le coordinate, a mezzo di un oggetto di tipo Point, del componente sopra il quale è stato effettuato il click del mouse, getX() e getY() che restituiscono le rispettive posizioni.

Se si vuole intercettare il passaggio del puntatore del mouse sopra un componente ci si deve servire dell'interfaccia MouseMotionListener che implementa i seguenti metodi:

mouseDragged(MouseEvent evt) e

mouseMoved(MouseEvent evt) ;

con gli argomenti di tali funzioni è possibile richiamare i metodi sopra detti.



f) Eventi Finestra

Per gestire gli eventi di finestra che si manifestano quando un utente apre o chiude una JWindow o un JFrame, si devono utilizzare i seguenti metodi :



windowActivated(WindowEvent evt)

windowClosed(WindowEvent evt) // dopo che la finestra è stata chiusa

windowClosing(WindowEvent evt) // al momento di chiusura della finestra

windowDeactivated(WindowEvent evt)

windowDeiconified(WindowEvent evt)

windowIconified(WindowEvent evt)

windowOpened(WindowEvent evt)

ad esempio con windowClosing si può impedire la chiusura di una finestra.



Esempi: http://java.sun.com/docs/books/tutorial/uiswing/learn/index.html


Pagina di





©astratto.info 2017
invia messaggio

    Pagina principale