Lezione 09:

INTERFACCE GRAFICHE IN JAVA - III

Esempio: ExJScrollPane.java
Definisce una finestra con un pannello a barre che contiene un'etichetta (JLabel).
L'etichetta ha come scritta una stringa lunga in carattere grande, in modo che il suo preferred size sia grande (vedere il codice anche come esempio di come si imposta la font di carattere per un componente).
Inoltre l'etichetta disegna i suoi bordi, in modo che possiamo vederne l'estensione.
Il pannello a barre contiene l'etichetta e imposta il proprio preferred size a dimensione minore del preferred size dell'etichetta.
Provate a vedere che succede lasciando che il pannello a barre si dimensioni come da default (commentare setPreferredSize); e provate a impostare esplicitamente il preferred size di entrambi gli oggetti (es. l'etichetta 300x300 pixel e il pannello a barre 200x200).

Menu' e voci di menu' in Java

Un Menu' permette di scegliere un'opzione da una lista di voci prefissata.

Un menu' consiste di:

• etichetta = titolo del menu'
• tendina a scomparsa che presenta una lista di alternative dette voci o elementi di menu' (menu items)

In condizioni normali ha l'aspetto di un'etichetta (titolo del menu'). Quando l'utente preme il mouse sul rettangolo, appare una tendina con una lista di scelte (le voci del menu') rappresentate da etichette testuali o grafiche.
L'utente si sposta col mouse all'interno della tendina e seleziona la voce desiderata.
La selezione genera un evento.

Tipi di menu'

Un menu' puo' essere:

• Pull-down (o drop-down):
  La sua etichetta e' permanentemente visibile sulla barra di menu' di una finestra; quando l'utente la aziona appare la tendina
• A cascata (o sotto-menu'):
  La sua etichetta appare come voce in un altro menu'; quando tale voce viene selezionata appare la tendina con le voci di questo menu'.
  La presenza di un menu' a cascata e' indicata graficamente (es: da una freccia) in corrispondenza dell'elemento a cui e' attaccato il sotto-menu'.
• Pop-up (o menu' contestuale):
  Normalmente invisibile, la tendina appare quando utente clicca su un certo componente al quale il menu' e' stato prima associato

Voci di menu'

I tipi di voci di menu' ricalcano i tipi di bottoni (bottone semplice, check box o radio).
Gli ultimi due tipi di voci hanno due stati possibili (selezionato o non selezionato) graficamente hanno associato un riquadro o altro elemento, visualizzato di lato, che puo' essere selezionato oppure no.

Classi Java Swing per i menu'

• JMenuItem: voce di menu' semplice
• JCheckBoxMenuItem: voce a due stati non esclusiva
• JRadioButtonMenuItem: voce a due stati esclusiva
• JMenu: menu' semplice, puo' essere usato come voce di un altro menu' (e' infatti sotto-classe di JMenuItem), realizzando in tal modo menu' a cascata, oppure puo' essere aggiunto alla barra di menu' di una finestra
• JPopupMenu: menu' contestuale a scomparsa o pop-up (non lo vediamo)
• JMenuBar: barra di menu' di una finestra, nella quale possono essere collocati menu'

Costruzione di menu'

1. costruire il singolo menu'
2. collegare il menu' al resto dell'interfaccia mettendolo nella barra di menu' della finestra oppure inserendolo come sotto-menu' di un altro menu' (per realizzare menu' a cascata)

Passo 1) Costruisco un menu' vuoto, costruisco le voci e le aggiungo al menu', esempio:

  menu1 = new JMenu("Primo menu'");
  menu1.add (new JMenuItem("voce semplice"));
  menu1.add (new JCheckBoxMenuItem("voce check box"));
  menu1.add (new JRadioButton("voce radio"));

Attenzione: anche i radio button menu item devono essere aggiunti allo stesso gruppo per diventare mutuamente esclusivi (come i radio button, ved. lezione 8).

Passo 2a) Inserisco il menu' sulla barra di menu' di una finestra:

  bar = new JMenuBar();    // crea la barra
  frame.setJMenuBar(bar);  // la mette sulla finestra
  bar.add(menu1);          // aggiunge il menu' alla barra

Passo 2b) Inserisco invece il menu' come sotto-menu' di un altro, realizzando in tal modo un menu' a cascata. Basta aggiungerlo come se fosse una voce di menu':

  menu2 = new JMenu("super menu'");
  menu2.add (menu1);       // voce costituita da sotto menu'
  menu2.add("una voce");   // voce normale
  menu2.add("altra voce"); // voce normale

Eventi nei menu'

Quelle che reagiscono a eventi sono le singole voci dei menu', con gli stessi action listener previsti per i bottoni dei tipi corrispondenti, ved. lezione 8.

Le voci che sono sottomenu' le gestisce automaticamente il sistema (la loro reazione e' mostrare la tendina del sottomenu').

Esempio

Il programma ExJMenu.java costruisce una finestra con tre menu': due posti sulla barra e uno posto come sotto-menu' del primo di questi. Ogni scelta ha come callback la stampa dell'etichetta della voce di menu' selezionata.

Un'interfaccia utente ha una o piu' finestre:

• Finestra principale o primaria:
  Appare quando parte l'applicazione e resta per tutto il tempo in cui essa e' in esecuzione
• Finestra secondaria di dialogo:
  Appare in seguito ad azioni dell'utente (es. finestra per scelta di quale file caricare appare quando l'utente invoca l'operazione di apertura file) e di solito resta per poco tempo

Java definisce solo l'interno (il contenuto) della finestra.
A questo il sistema (es. Windows) aggiunge il bordo con barra del titolo, dispositivi di controllo per chiusura, redimensionamento, iconificazione. Queste parti aggiunte si chiamano decorazioni.

Java non ha il controllo sul bordo, lo ha il sistema. Java puo' dare suggerimenti (hints) al sistema, che a sua discrezione li considera oppure no.

Per default il layout manager di una finestra e' BorderLayout.

Una finestra viene creata vuota, le dovro' aggiungere componenti (dispositivi con eventuali contenitori intermedi).

Finestra adatta ad essere usata come finestra primaria di un'applicazione.
Verra' mostrata dal sistema con tutte le decorazioni.

Costruttori della classe JFrame:

• JFrame() -- finestra senza titolo
• JFrame(String title) -- finestra con titolo specificato, il titolo e' mostrato sulla barra del titolo nel bordo della finestra

Un frame puo' avere una barra di menu' (classe "JMenuBar"). Aggiungere la barra di menu' ad un frame f:

  JMenuBar bar = new JMenuBar();
  f.setJMenuBar(bar);

Finestra di dialogo (classe JDialog e altre)

Finestra secondaria di un'applicazione, serve per mostrare informazioni e/o richiedere informazioni all'utente.
E' intesa come finestra temporanea, percio' il sistema puo' mostrarla con tutte le decorazioni o con un sotto-insieme (es. senza i dispositivi di controllo per redimensionamento).
Viene mostrata in seguito a una azione dell'utente su una finestra chiamante. Esempio: se aziono il bottone per la stampa mi appare la finestra di dialogo che chiede quale stampante, quante pagine...
La finestra di dialogo deve contenere dispositivi (es. bottoni) con cui l'utente la possa chiudere dopo aver ricevuto e/o dato le informazioni stabilite.

Un dialogo dipende funzionalmente dalla finestra chiamante. La finestra chiamante di solito e' la finestra principale (frame) dell'applicazione, ma puo' essere anche un'altra finestra di dialogo, che a sua volta dipende, direttamente o tramite altre finestre di dialogo, dalla finestra principale (dialoghi a cascata).

La dipendenza funzionale comporta che:

• Quando chiudo un frame, chiudo anche tutti i suoi dialoghi.
• Quando iconifico / deiconifico il frame, spariscono / riappaiono i suoi dialoghi.
• Se un dialogo e' stato dichiarato come modale allora impedisce all'utente di interagire con la finestra chiamante finche' il dialogo rimane sullo schermo

Una finestra di dialogo viene costruita come dipendente da un'altra finestra specificata in argomento al costruttore.

Costruttori della classe JDialog:

• JDialog(finestra da cui dipende) -- dialogo non modale dipendente dalla finestra specificata
• JDialog(finestra da cui dipende, stringa titolo) -- idem con titolo specificato, che sara' mostrato sulla barra del titolo
• JDialog(finestra da cui dipende, stringa titolo, booleano) -- finestra di dialogo dipendente dalla finestra specificata, con titolo dato, che e' modale o no secondo come specificato dal booleano

Un dialogo viene creato vuoto. Poi bisogna riempirlo esattamente come si fa con i frame (aggiungere con "add" tutti i componenti e poi dimensionare con "pack") poiche' entrambi sono finestre.

In ExJDialog.java abbiamo un'applicazione con due finestre:

• un frame contenente un bottone che fa apparire il dialogo
• un dialogo contenente un'etichetta ed un bottone per chiudere il dialogo

La classe ExJDialog realizza la finestra principale, sotto-classe di JFrame. Il costruttore della classe ExJDialog costruisce anche il dialogo e lo tiene nella variabile mioDialogo.
La callback del bottone apriDialogo, presente sulla finestra principale, mostra il dialogo; la callback del bottone chiudiDialogo, presente sul dialogo, lo nasconde.
La finestra principale invece viene mostrata direttamente dal main.

Ci sono tipologie di finestre di dialogo ricorrenti, per esempio molte hanno questa struttura:

• al centro una stringa e/o un'icona intesa come messaggio per l'utente, eventuali elementi per chiedere input all'utente (es. un campo di testo...)
• in basso un numero di bottoni che l'utente puo' udare per chiudere la finestra, con diversi significati (es. un bottone "ok"; due bottoni "ok", "cancel"; tre bottoni "ok", "no", "cancel"...)

Percio' Java Swing offre una serie di finestre di dialogo gia' fatte, con struttura fissa e dettagli personalizzabili (es. quale messaggio, quanti bottoni, quali stringhe sui bottoni).
Queste sono fornite dalla classe JOptionPane, la quale ha metodi chiamati "showXXXDialog", ciascuno dei quali si comporta cosi':

1. costruisce al volo una finestra di dialogo modale con certe caratteristiche (messaggio, numero di bottoni...), che variano secondo cosa e' XXX
2. e al volo la mostra, lasciandola su schermo fino a che l'utente non la chiude premendo uno dei bottoni presenti sulla finestra di dialogo stessa (per tutto questo tempo l'esecuzione del programma principale viene bloccata)
3. se la finestra di dialogo aveva piu' di un bottone, il metodo showXXXDialog ritorna un numero corrispondente al bottone che l'utente ha premuto per chiudere la finestra di dialogo
4. tale valore di ritorno posso usarlo nel codice che segue la chiamata a showXXXDialog per decidere cosa fare

Elenco dei metodi:

• showMessageDialog -- con messaggio e bottone ok.
• showConfirmDialog -- con messaggio e bottoni yes/no/cancel.
• showInputDialog -- con anche richiesta di input.
• showOptionDialog -- generalizza i tre sopra, piu' versatile e piu' complicato da configurare (non lo vediamo)

Il layout di base e' il seguente:

+-----+------------------+
|     |   messaggio      |
|icona|------------------+
|     |   campo input    |
+-----+------------------+
|  bottoni per chiudere  |
+------------------------+

Dialogo con solo messaggio

showMessageDialog(finestra da cui dipende, messaggio, stringa titolo, tipo, icona)

Solo i primi due parametri sono obbligatori.
Il tipo e' una delle seguenti costanti di classe JOptionPane: ERROR_MESSAGE, INFORMATION_MESSAGE, WARNING_MESSAGE, QUESTION_MESSAGE, PLAIN_MESSAGE, e determina quale e' l'icona di default.
L'ultimo parametro (icona) si puo' omettere e verra' messa l'icona di default.

Esempio:

JOptionPane.showMessageDialog(f, "Attenzione:\nparametro errato",
            "Errore", JOptionPane.ERROR_MESSAGE,
            new ImageIcon("error_icon.gif"));

Dialogo con richiesta di conferma

showConfirmDialog(finestra da cui dipende, messaggio, stringa titolo, tipo dei bottoni, tipo, icona)

Solo i primi due parametri sono obbligatori.
Il tipo dei bottoni e' una delle seguenti costanti di classe JOptionPane: YES_NO_OPTION, YES_NO_CANCEL_OPTION e determina quali bottoni saranno presenti.
Il tipo e' come in ShowMessageDialog (ved. sopra).
Il metodo ritorna un valore intero, che e' una delle seguenti costanti di classe JOptionPane: YES_OPTION, NO_OPTION, CANCEL_OPTION, OK_OPTION (quando il dialogo e' stato chiuso premendo il bottone indicato), CLOSED_OPTION (quando il dialogo e' stato chiuso col dispositivo di chiusura presente sul bordo della finestra). Il valore di ritorno e' usato per decidere cosa fare...

Esempio:

int n = JOptionPane.showConfirmDialog(f, "Vuoi continuare?",
            "Errore", JOptionPane.YES_NO_OPTION);
if (n==JOptionPane.YES_OPTION) ... azioni da fare se bottone "yes"...
else ...azioni da fare se bottone no...

Dialogo con richiesta di input

Forma 1: showInputDialog(finestra da cui dipende, messaggio, titolo, tipo, icona)

Solo i primi due parametri sono obbligatori.
Sotto il messaggio compare un campo di testo editabile in cui l'utente puo' scrivere una stringa.
Il tipo e' come in ShowMessageDialog (ved. sopra).

Il metodo ritorna la stringa presente nel campo quando l'utente chiude la finestra (null se finestra chiusa con cancel).

Forma 2: showInputDialog(finestra da cui dipende, messaggio, titolo, tipo, icona, array di oggetti da scegliere, scelta di default)

Il tipo e' come in ShowMessageDialog (ved. sopra).
l'array di oggetti da scegliere contiene stringhe o icone, che verranno visualizzare in un combo box.
la scelta di default e' l'indice nell'array dell'elemento inizialmente scelto.

Esempio 1:

String s = JOptionPane.showInputDialog(f, "Please input a value");

Esempio 2:

Object[] possibleValues = { "First", "Second", "Third" };
Object selectedValue = JOptionPane.showInputDialog(f,
       "Choose one", "Input", JOptionPane.INFORMATION_MESSAGE,
       null, possibleValues, possibleValues[0]);