INTERFACCE GRAFICHE IN JAVA - III

[Per corso su Java vedere http://java.sun.com/docs/books/tutorial/]

Metodi generali sui componenti Java

Gestione degli eventi in Java

• Classi per gli eventi
• Classi event listener, che definiscono modi di reagire a eventi di una certa classe

Classi di eventi

Gli eventi sono classificati a seconda della loro causa scatenante, che puo' essere:

• un'azione fisica: cliccare mouse, muovere mouse, premere tasto su tastiera...
• un'azione "logica", la cui corrispondenza con azione fisica dipende dal sistema su cui il programma Java sara' eseguito: es. eventi di finestra (chiusura, redimensionamento, iconificazione...) si causano con azioni dell'utente diverse a seconda del sistema

Classi di eventi hanno nomi del tipo XXXEvent dove XXX e' la causa. Es: MouseEvent...

Ogni classe di componente e' una potenziale sorgente di certe classi di eventi. Es: un bottone puo' originare eventi di classe "azionamento" (classe ActionEvent).

Event listeners

Posso registrare un event listener per ricevere eventi di una certa classe da una certa componente dell'interfaccia.

Vi e' un'interfaccia event listener per ogni classe di evento:

• classe evento: XXXEvent
• listener: XXXListener

L'interfaccia listener prevede uno o piu' metodi che scattano quando il listener riceve un evento di quella classe.
Essendo un listener interfaccia e non classe, l'implenentazione dei metodi non e' definita.

Stabilita la classe di eventi che voglio catturare, devo creare una classe che implementi il listener corrispondente, fornendo il codice dei suoi metodi.
Poi creo un oggetto di tale classe e lo associo alla componente sulla quale voglio catturare gli eventi.

Esempio: voglio catturare azionamento di un bottone.

• la classe di evento e' ActionEvent
• creo classe che implementa ActionListener definendo implementazione del metodo ActionPerformed con le operazioni che intendo far fare al bottone quando azionato
• creo il bottone (istanza della classe JButton)
• creo un action listener (istanza della classe implementazione di ActionListener da me definita)
• associo questo action listener al bottone
• quando l'utente azionera' il bottone, scattera' l'action listener che eseguira' le operazioni

Questo paradigma si chiama delegation perche' il bottone delega l'azione da eseguire ad un altro oggetto (il listener).

Alternative per definire listener

Riprendiamo l'esempio AWTExample / SwingExample modificandolo un po'.

La finestra contiene due bottoni b1 e b2 e un'etichetta (label) collocati organizzando la finestra come griglia a tre righe e una colonna.
La scritta sull'etichetta cambia a seconda di quale bottone e' stato premuto per ultimo:

• la calklback di b1 scrive "uno" sulla label.
• la callback di b2 scrive "due" sulla label.

Questo si puo' ottenere in vari modi.
Attenzione: la classe e' sempre ListenerExample ma i file si chiamano con 1, 2, 3, 4.

MODO 1

Ricalca esempio AWTExample / SwingExample gia' visto, qui usiamo AWT.
Ciascuno dei due bottoni ha il suo listener ottenuto da una classe creata al volo.
File ListenerExample1.java

class ListenerExample extends Frame
{
  Button b1;
  Button b2;
  Label l;

  public ListenerExample()
  {
    b1 = new Button("bottone b1");
    b2 = new Button("bottone b2");
    l = new Label("---");
    setLayout(new GridLayout(3,1));
    add(b1);
    add(b2);
    add(l);

    b1.addActionListener(new ActionListener()
    {  public void actionPerformed(ActionEvent e)
       { l.setText("uno"); }
    });

    b2.addActionListener(new ActionListener()
    {  public void actionPerformed(ActionEvent e)
       { l.setText("due"); }
    });

    pack();
    setVisible(true);
  }

  public static void main(String[] args)
  {
   ListenerExample app = new ListenerExample();
  }
}

Ma qui abbiamo due classi listener praticamente identiche, cambia solo la stringa che viene scritta nell'etichetta.
Compilando produce ListenerExample.class e altri due file .class per i listener.

MODO 2

Definiamo una sola classe listener parametrica sulla stringa da scrivere nell'etichetta. La classe listener e' classe interna di ListenerExample, in questo modo puo' accedere agli attributi di ListenerExample.
File ListenerExample2.java

class ListenerExample extends Frame
{
  Button b1;
  Button b2;
  Label l;

  // classe listener interna
  class MyListener implements ActionListener
  {
    String s; // la stringa da scrivere
    MyListener(String ss) { s = ss; }
    public void actionPerformed(ActionEvent e)
    { l.setText(s); }
  }

  public ListenerExample()
  {
    b1 = new Button("bottone b1");
    b2 = new Button("bottone b2");
    l = new Label("---");
    setLayout(new GridLayout(3,1));
    add(b1);
    add(b2);
    add(l);

    b1.addActionListener(new MyListener("uno"));
    b2.addActionListener(new MyListener("due"));

    pack();
    setVisible(true);
  }

  public static void main(String[] args)
  {
   ListenerExample app = new ListenerExample();
  }
}

Abbiamo una solae classe listener di cui creiamo due istanze, con diversa stringa.
Compilando produce ListenerExample.class e un altro file .class per la classe listener.

MODO 3

Definiamo una sola classe listener come prima, ma questa volta, invece di memorizzare la stringa, guardiamo da quale dei due bottoni arriva l'evento e in base a quello decidiamo che stringa scrivere.
File ListenerExample3.java

class ListenerExample extends Frame
{
  Button b1;
  Button b2;
  Label l;

  // classe listener interna
  class MyListener implements ActionListener
  {
    public void actionPerformed(ActionEvent e)
    { 
      if (e.getSource()==b1) l.setText("uno");
      else /* deve essere b2 */ l.setText("due");
   }
  }

  public ListenerExample()
  {
    b1 = new Button("bottone b1");
    b2 = new Button("bottone b2");
    l = new Label("---");
    setLayout(new GridLayout(3,1));
    add(b1);
    add(b2);
    add(l);

    ActionListener lis = new MyListener();
    b1.addActionListener(lis);
    b2.addActionListener(lis);

    pack();
    setVisible(true);
  }

  public static void main(String[] args)
  {
   ListenerExample app = new ListenerExample();
  }
}

Abbiamo una solae classe listener di cui creiamo una sola istanza.

MODO 4

Invece di definire una classe listener interna, e' la nostra classe ListenerExample (sotto-classe di Frame) a fungere da listener, implementando l'interfaccia ActionListener.
File ListenerExample4.java

class ListenerExample extends Frame implements ActionListener
{
  Button b1;
  Button b2;
  Label l;

  // implementazione della funzione 
  public void actionPerformed(ActionEvent e)
  { 
    if (e.getSource()==b1) l.setText("uno");
    else /* deve essere b2 */ l.setText("due");
   }

  public ListenerExample()
  {
    b1 = new Button("bottone b1");
    b2 = new Button("bottone b2");
    l = new Label("---");
    setLayout(new GridLayout(3,1));
    add(b1);
    add(b2);
    add(l);

    b1.addActionListener(this);
    b2.addActionListener(this);

    pack();
    setVisible(true);
  }

  public static void main(String[] args)
  {
   ListenerExample app = new ListenerExample();
  }
}

Compilando otteniamo il solo file ListenerExample.class.

Altre note sui listener

Posso associare lo stesso event listener a piu' componenti nell'interfaccia: questi reagiranno allo stesso evento nello stesso modo.

Posso associare piu' event listener allo stesso oggetto: questo avra' piu' reazioni.

Una classe puo' implementare piu' interfacce listener. Potra' essere usata per dare la stessa reazione a componenti sensibili a tipi diversi di eventi.
Esempio (ExQuit.java): bottone quit e chiusura di finestra, entrambi terminano applicazione.

public class ExQuit extends Frame
{
    Button quitButton;

    public ExQuit()
    {
        quitButton = new Button("Click me to quit!");
        add(quitButton);
        QuitListener listener = new QuitListener();
        quitButton.addActionListener(listener);
        addWindowListener(listener);
        pack();
    }

    class QuitListener extends WindowAdapter implements ActionListener
    {
       public void actionPerformed(ActionEvent e) {  System.exit(0);  }
       public void windowClosing(WindowEvent e) {  System.exit(0);  }
    }

    public static void main(String[] args)
    {
        ExQuit app = new ExQuit();
        app.setVisible(true);
    }
}

Implementare un listener

Tutti i metodi dei listener hanno parametri come segue:

public void nomeFunzione(XXXEvent e)

• getSource() e' definita per ogni classe di evento e ritorna l'oggetto su cui l'evento si e' verificato.
• tale oggetto va esplicitamente convertito in componente prima di usarlo: Component c = (Component)e.getSource()
  oppure convertirlo nella particolare classe della componente a cui e' associato il listener dell'evento.

Listener e adapter

Il fatto che i listeners siano interfacce e non classi (cioe' che non implementino i metodi) implica che per i listener che hanno piu' metodi devo fornire un'implementazione di tutti i metodi, inclusi quelli che non mi interessano (l'implementazione di questi non fara' nulla: {}).

Per comodita' sono forniti adapters che forniscono implementazione standard di un listener (dove tutti i metodi non fanno nulla): creo sottoclasse dell'adapter ridefinendo solo i metodi che mi interessano.

Esempio: La classe WindowEvent corrisponde a eventi sulle finestre top-level: apertura / chiusura, iconificazione / deiconificazione...
La classe WindowListener ha un metodo per ciascuno degli eventi di cui sopra. Se voglio reagire solo all'evento di chiusura:

• o uso WindowListener e scrivo codice per tutti i metodi (quelli che non interessano non faranno nulla)
• oppure uso WindowAdapter e scrivo codice solo per il metodo che mi interessa

L'esempio ExJButtons.java mostra tre tipi di bottoni java. Serve anche il file immagine buttonicon.gif.

Bottone di comando cattura evento di azionamento ActionEvent: l'utente ha azionato il bottone, in che modo dipende dalla piattaforma (di solito col mouse).
In ciascuna finestra top-level posso definire al piu' un solo bottone "di default" che e' sensibile anche alla pressione del tasto "return" (il sistema distingue graficamente tale bottone).

Il corrispondente ActionListener ha un solo metodo actionPerformed che scatta quando il bottone e' azionato.

CheckboxGroup cbg = new CheckboxGroup();
add(new Checkbox("uno", cbg, true));
add(new Checkbox("due", cbg, false));
add(new Checkbox("tre", cbg, false));

rb1 = new JRadioButton("uno",true);
rb2 = new JRadioButton("due");
rb3 = new JRadioButton("tre");
ButtonGroup bg = new ButtonGroup();
bg.add(rb1);
bg.add(rb2);
bg.add(rb3);

L'esempio ExButtons.java mostra i tre tipi di bottoni (di comando, check box, radio).

Provare ad aggiungere gestione degli eventi.

Campi ed aree di testo

Testo su una linea (campo) o su piu' linee (area).
Hanno super-classe TextComponent / JTextComponent, molti metodi si trovano nella super-classe.

• TextField / JTextField: una linea di testo
• JPasswordField sotto-classe di JTextField che non mostra la stringa in chiaro (al posto delle lettere sono mostrati caratteri di "echo")
• TextArea / JTextArea: testo su piu' linee, tutto nella stessa font, editabile con tastiera e mouse
• JEditorPane: testo su piu' linee, le varie parti possono essere in font diverse, posso inglobare immagini ed anche componenti Java, complicato da programmare.
  Anche possibile caricare documenti preformattati (HTML,RTF)

Metodi utili (il primo anche su text field, gli altri solo su area):

• setText(String), String getText() per assegnare e leggere il testo contenuto
• append(String) aggiunge testo in coda
• insert(String, int) inserisce testo alla posizione indicata
• void replaceRange(String, int, int) sostituisce testo tra le due posizioni indicate

Per default, l'area di testo non va a capo, ma mostra tutto su linea unica e, se inserita in scroll pane, permette di scorrere orizzontalmente.
In Swing posso controllare le andate a capo:

• setLineWrap abilita l'andata a capo
• setWrapStyleWord indica che le linee devono essere spezzate solo a fine parola

Text component cattura evento ActionEvent quando utente preme il tasto "return".
Inoltre anche:

• In AWT evento TextEvent quando utente interagisce col testo.
• In Swing ha associato un documento, che ottengo con GetDocument() e tale documento cattura eventi CaretEvent che monitorano cursore e selezione di parti del testo.

Combo box

Classe JComboBox. Puo' essere non editabile o editabile (di default non editabile).
Combo box appare come un bottone (se non editabile) o come un campo di testo con un piccolo bottone accanto (se editabile). Se utente agisce sul bottone compare una tendina con lista di scelte, ciascuna scelta puo' essere stringa di testo o immagine. In combo box editabile, l'utente puo' anche digitare direttamente digitare nel campo di testo.

Per creare una combo box, si passa in argomento un array di stringhe (o di icone), e si assegna la stringa (icona) inizialmente selezionata:

String[] scelte = {"una", "due", "tre", "quattro"};
JComboBox cbox = new JComboBox(scelte);
cbox.setSelectedItem(2);

Combo box sono sensibili a eventi ActionEvent e ItemEvent. Di solito e' sufficiente un ActionListener per gestire una combo box.
Combo box editabile genera un ActionEvent quando l'utente sceglie un elemento dalla tendina e anche quando l'utente preme tasto "enter" nel campo di testo.

Liste

Una lista mostra una serie di elementi disposti in colonna da cui l'utente puo' scegliere.

• In AWT: lista mostra un certo numero di righe ed ha barra di scorrimento per accedere alle eventuali ulteriori righe presenti
• In Swing: lista non ha barre di scorrimento di per se', solitamente inserita in uno scrolled pane.

La lista ammette selezione di righe singole o multiple. Swing distingue anche fra selezione multipla limitatamente ad un intervallo di righe contigue oppure multipla con piu' intervalli.

Contenuto di una lista puo' essere cambiato dinamicamente.

Per creare una lista in AWT la creo e le aggiungo le righe:

List list = new List(4);
list.add("una");
list.add("due");
list.add("tre");
list.add("quattro");

Per creare una lista in Swing devo passare l'array di righe:

String[] scelte = {"una", "due", "tre", "quattro"};
JList list = new JList(scelte);

Per stabilire modo di selezione in AWT scelgo tra singolo e multiplo:

list.setMultipleMode(true/false);

Per stabilire modo di selezione in Swing ho tre possibilita':

list.setSelectionMode(modo);

• JList.SINGLE_SELECTION una sola linea
• JList.SINGLE_INTERVAL_SELECTION piu' linee contigue
• JList.MULTIPLE_INTERVAL_SELECTION piu' linee anche non contigue

Lista e' sensibile a eventi di classe ListSelectionEvent. Il corrispondente ListSelectionListener prevede il metodo valueChanged che scatta quando utente esegue una selezione.

Dall'evento di selezione posso ottenere:

• boolean isEmptySelection() se e' selezionato qualcosa o no
• int getSelectedIndex() l'indice dell' elemento correntemente selezionato (se uno)
• int getMinSelectedIndex(), int getMaxSelectedIndex() l'indice minimo e massimo dell'intervallo selezionato (se un intervallo, Swing)
• int[] getSelectedIndices un array contenente gli indici di tutti gli elementi selezionati (anche non contigui)

Potenziometro (slider)

Classe JSlider. Consente di introdurre un valore numerico compreso fra un minimo ed un massimo. Barra con cursore mobile. La barra corrisponde ad un intervallo di valori, il cursore ad un valore corrente nell'intervallo.

Per creare uno slider, stabilisco l'orientamento (orizzontale o verticale) e i valori minimo, massimo e corrente (interi):

slider = new JSlider(direzione,minimo,massimo,corrente);

Per leggere il valore corrente dello slider usare getValue(). Per sapere se utente sta ancora muovendo il cursore o ha finito, chiamare getValueIsAdjusting().

Slider puo' visualizzare righello con due ordini di tacche: maggiore e minore. Ciascun ordine di tacche puo' essere numerato oppure no.

• setMajorTickSpacing(int) e idem con Minor stabilisce l'intervallo numerico fra le tacche
• setPaintTicks(true/false) stabilisce se disegnare le tacche (per default no)
• setPaintLabels(true/false) stabilisce se disegnare le etichette numeriche

Slider e' sensibile a eventi di classe ChangeEvent. Il corrispondente ChangeListener prevede il metodo stateChanged che scatta quando utente muove il cursore dello slider.

Esempio che reagisce solo se utente ha terminato l'interazione:

public void stateChanged(ChangeEvent e)
{
  JSlider source = (JSlider)e.getSource();
  if (!source.getValueIsAdjusting())
    ... fare qualcosa con source.getValue() ...
}

Menu' permette scelta di un'opzione da una lista di voci che e' presentata come una tendina a scomparsa.

Un menu' puo' essere:

• parte della barra di menu' di un frame: il titolo e' permanentemente mostrato sulla barra e quando utente la aziona appare la tendina
• sotto-menu': il titolo appare come voce in un altro menu'
• pop-up: associato ad un altra componente, e' normalmente invisibile, la tendina appare quando utente aziona la componente alla quale il menu' e' associato

CLassi:

• Classe Menu / JMenu per menu' su barra e per sotto-menu (Menu / JMenu e' sotto-classe di MenuItem / JMenuItem, la classe base delle voci di menu')
• Classe PopupMenu / JPopupMenu per menu' pop-up

Esempio di menu' inserito in barra:

bar = new MenuBar();
frame.setMenuBar(bar);
Menu m = new Menu("un menu'");
bar.add(m);

PopupMenu pop = new PopupMenu("pop-up");

menu1 = new Menu("Primo menu'");
menu1.add (new MenuItem("voce semplice"));
menu1.add (new CheckboxMenuItem("voce a due stati"));
menu2 = new Menu("sotto menu'");
menu1.add (menu2);
menu2.add("una voce");  
menu2.add("altra voce");

Per assegnare un menu' pop-up ad un componente, si associa a quel componente un MouseListener che faccia apparire il menu' pop-up quando l'utente aziona il mouse.
Esempio (PopFrame.java): frame con associato menu' pop-up

public class PopFrame extends Frame 
{
    PopupMenu popup;

    public PopFrame()
    {
        popup = new PopupMenu("A Popup Menu");
        add(popup);
        MenuItem mi1 = new MenuItem("aaa");
        popup.add(mi1);
        MenuItem mi2 = new MenuItem("bbb");
        popup.add(mi2);
        setSize(new Dimension(200,100));

        MouseListener listener = new PopupListener();
        addMouseListener(listener);
    }

    class PopupListener extends MouseAdapter 
    {
        public void mousePressed(MouseEvent e) 
        {    maybeShowPopup(e);
        }

        public void mouseReleased(MouseEvent e) 
        {   maybeShowPopup(e);
        }

        private void maybeShowPopup(MouseEvent e) 
        {
            if (e.isPopupTrigger())
                popup.show(e.getComponent(), e.getX(), e.getY());
        }
    }
}