[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]


50. Strumenti per la realizzazione di script di shell

Lo script di shell è un programma molto semplice, che di solito ha solo lo scopo di automatizzare delle operazioni banali, ma ripetitive. Tuttavia, con l'uso di programmi di utilità realizzati appositamente per questi scopi, si possono costruire degli script piuttosto sofisticati con poca fatica.

50.1 Scansione delle opzioni della riga di comando

Se si realizza uno script che deve essere richiamato fornendogli degli argomenti (dei parametri), e questi sono in forma di opzione, come si è abituati con i programmi di utilità comuni, può essere conveniente l'utilizzo di programmi o comandi appositi. Tradizionalmente si fa riferimento a `getopt', del quale esistono però diverse interpretazioni; in particolare, la shell Bash fornisce il comando interno `getopts' (simile, ma non compatibile con `getopt'), descritto nella sezione 48.19. È importante osservare che anche tra una distribuzione GNU/Linux e l'altra ci possono essere differenze tra i programmi di utilità `getopt'.

50.1.1 Versione tradizionale di getopt

Il programma di utilità `getopt' tradizionale ha la sintassi seguente:

getopt <stringa-di-opzioni> <parametro>...

La stringa di opzioni è un elenco di lettere che rappresentano le opzioni ammissibili; se ci sono opzioni che richiedono un argomento, le lettere corrispondenti di questa stringa devono essere seguite dal simbolo due punti (`:'). Gli argomenti successivi sono i valori dei parametri da analizzare. Lo scopo del programma è solo quello di controllare che tutto sia in ordine, e di mettere a posto quello che è possibile sistemare, emettendo l'elenco delle opzioni, nel modo «corretto». Per esempio:

getopt ab:c -a uno -b due -c tre quattro

Potrebbe restituire il testo seguente:

-a -b due -c -- uno tre quattro

Infatti, avendo utilizzato la definizione `ab:c', è stato stabilito che solo l'opzione `-b' ha un argomento, per cui, l'argomento `uno' è stato spostato alla fine delle opzioni, dopo il trattino doppio (`--').

Se il programma `getopt' di cui si dispone è aderente strettamente alle specifiche POSIX, il risultato che si ottiene è diverso, dal momento che la scansione termina nel momento in cui si trova il primo argomento che non riguarda le opzioni:

<meno>a <meno><meno> uno <meno>b due <meno>c tre quattro

L'esempio seguente dovrebbe chiarire in che modo si può utilizzare `getopt' per scandire gli argomenti della riga di comando:

#!/bin/sh
# scansione_1.sh

# Si raccoglie la stringa generata da getopt.
STRINGA_ARGOMENTI=`getopt ab:c "$@"`

# Si trasferisce nei parametri $1, $2,...
eval set -- "$STRINGA_ARGOMENTI"

while true ; do
    case "$1" in
	-a) echo "Opzione a"
	    shift
	    ;;
	-b) echo "Opzione b, argomento «$2»"
	    shift 2
	    ;;
	-c) echo "Opzione c"
	    shift
	    ;;
	--) shift
	    break
	    ;;
	*)  echo "Errore imprevisto!"
	    exit 1
	    ;;
	esac
done

echo "Argomenti rimanenti:"
for argomento in "$@"
do
    echo "$argomento"
done

In pratica, si comprende che lo scopo di `getopt' è solo quello di fare un po' di ordine tra le opzioni, e di stabilire cosa sia un'opzione e cosa non lo sia. Supponendo che il nome dello script sia `scansione_1.sh', se si utilizza come nell'esempio già visto,

./scansione_1.sh -a uno -b due -c tre quattro

si dovrebbe ottenere il risultato seguente:

Opzione a
Opzione b, argomento «due»
Opzione c
Argomenti rimanenti:
uno
tre
quattro

Se invece, `getopt' è strettamente aderente alle specifiche POSIX, il risultato cambia come segue:

Opzione a
Argomenti rimanenti:
uno
-b
due
-c
tre
quattro

50.1.2 getopt nella versione dei programmi di utilità Linux

I programmi di utilità Linux si compongono anche di una versione di `getopt' un po' più evoluta dello standard, che comunque è compatibile con il passato. È ammissibile l'uso della stessa sintassi vista nella sezione precedente, e in particolare si può anche forzare l'aderenza alle specifiche POSIX definendo la variabile di ambiente `POSIXLY_CORRECT'. Questa edizione di `getopt' è in grado di identificare anche le opzioni «lunghe». Oltre allo schema sintattico già visto, si può utilizzare in particolare quello seguente:

[getopt <opzioni-di-getopt>] -o|--options <stringa-di-opzioni-corte> [<opzioni-di-getopt>] -- <parametro-da-scandire>...

In pratica, questa versione di `getopt' può avere delle opzioni per conto proprio, che ne regolano il funzionamento, e tra queste, `-o' è obbligatoria, dal momento che il suo argomento è proprio la stringa che definisce quali opzioni possono essere presenti nei parametri. Eventualmente, per indicare opzioni lunghe, si utilizza l'opzione `-l'.

La stringa che definisce le opzioni corte, si comporta fondamentalmente come già spiegato nella sezione precedente. In particolare, se si usano due volte i due punti (`::'), si specifica che l'opzione ha un argomento facoltativo, e non obbligatorio. La stringa che definisce le opzioni lunghe, è simile a quella delle opzioni corte, con la differenza che, dovendo indicare dei nomi, e non solo delle lettere singole, questi sono separati attraverso una virgola; per quanto riguarda l'uso dei due punti, la modalità è la stessa.

Questa versione di `getopt' ha anche la particolarità di essere in grado di proteggere gli argomenti che ne hanno bisogno, ma per arrivare a questo deve sapere con quale shell si sta operando. Infatti, dal momento che `getopt' restituisce una stringa che poi deve essere scandita nuovamente, se un argomento contiene caratteri particolari che richiedono una qualche forma di protezione (come gli spazi), è necessario che venga fatta una trasformazione opportuna, che non può essere unica per tutte le situazioni. In condizioni normali, il risultato che si ottiene è adatto per Bash, altrimenti occorre utilizzare l'opzione `-s'.

Alcune opzioni

-o <stringa-di-opzioni-corte> | --options <stringa-di-opzioni-corte>

Definisce le opzioni normali che devono essere cercate tra i parametri, specificando anche se queste hanno un argomento, obbligatorio o facoltativo.

-l <stringa-di-opzioni-lunghe> | --longoptions <stringa-di-opzioni-lunghe>

Definisce le opzioni lunghe che devono essere cercate tra i parametri, specificando anche se queste hanno un argomento, obbligatorio o facoltativo.

-s {sh|bash|csh|tcsh}

--shell {sh|bash|csh|tcsh}

Definisce il tipo di shell che si sta utilizzando, permettendo di definire il modo migliore per proteggere i caratteri che richiedono questo tipo di accortezza.

-l <nome-del-programma> | --name <nome-del-programma>

Dal momento che `getopt' può segnalare gli errori, con questa opzione è possibile definire il nome del programma al quale attribuire l'errore generato.

Esempi

Come esempio viene mostrata una variante dello script proposto nella sezione precedente, dove si scandiscono anche le opzioni lunghe, e l'ultima ha un argomento facoltativo.

#!/bin/sh
# scansione_1.sh

# Si raccoglie la stringa generata da getopt.
STRINGA_ARGOMENTI=`getopt -o ab:c:: -l a-lunga,b-lunga:,c-lunga:: -- "$@"`

# Si trasferisce nei parametri $1, $2,...
eval set -- "$STRINGA_ARGOMENTI"

while true ; do
    case "$1" in
	-a|--a-lunga)
	    echo "Opzione a"
	    shift
	    ;;
	-b|--b-lunga)
	    echo "Opzione b, argomento «$2»"
	    shift 2
	    ;;
	-c|--c-lunga)
	    case "$2" in
		"") echo "Opzione c, senza argomenti"
		    shift 2
		    ;;
		*)  echo "Opzione c, argomento «$2»"
		    shift 2
		    ;;
	    esac
	    ;;
	--) shift
	    break
	    ;;
	*)  echo "Errore imprevisto!"
	    exit 1
	    ;;
	esac
done

echo "Argomenti rimanenti:"
for argomento in "$@"
do
    echo "$argomento"
done

Supponendo che il nome dello script sia `scansione_2.sh', se si utilizza come nell'esempio seguente,

./scansione_2.sh -auno -bdue -ctre quattro

oppure

./scansione_2.sh --a-lunga=uno --b-lunga=due --c-lunga=tre quattro

si dovrebbe ottenere il risultato seguente:

Opzione a
Opzione b, argomento «due»
Opzione c, argomento «tre»
Argomenti rimanenti:
uno
quattro

Tuttavia, se utilizzando le opzioni corte, gli argomenti di queste non vengono attaccati alle lettere rispettive, come nell'esempio seguente,

./scansione_2.sh -a uno -b due -c tre quattro

gli argomenti facoltativi non vengono presi in considerazione:

Opzione a
Opzione b, argomento «due»
Opzione c, senza argomenti
Argomenti rimanenti:
uno
tre
quattro

50.2 File temporanei

Quando si realizzano degli script, si ha spesso la necessità di realizzare dei file temporanei, magari solo per accumulare il risultato di un'elaborazione senza tentare di fare altri tipi di acrobazie. Il programma di utilità che si usa per queste cose è `tempfile':

tempfile [<opzioni>]

Nella maggior parte dei casi, `tempfile' viene usato senza argomenti, e quello che si ottiene è la creazione di un file vuoto nella directory temporanea (`/tmp/'), con permessi normali (lettura e scrittura per tutti, meno quanto filtrato dalla maschera dei permessi), e il percorso assoluto di questo file viene emesso attraverso lo standard output.

Alcune opzioni

-d <directory> | --directory <directory>

Se non si vuole usare la directory temporanea standard, si può specificare la directory di destinazione del file temporaneo con questa opzione.

-m <modalità-dei-permessi> | --mode <modalità-dei-permessi>

Se si vuole evitare che il file temporaneo che viene creato abbia dei permessi di accesso troppo ampi, si può utilizzare questa opzione per stabilire qualcosa di diverso.

Esempi

tempfile

Crea un file temporaneo nella directory temporanea, e ne restituisce il nome attraverso lo standard output.

#!/bin/sh
TEMPORANEO=`tempfile`
ls -l / > $TEMPORANEO
...
rm -r $TEMPORANEO

Quello che si vede è l'esempio tipico di uno script, incompleto, in cui si crea un file temporaneo accumulandone il nome in una variabile di ambiente; quindi si fa qualcosa con questo file (in questo caso si inserisce il risultato del comando `ls -l'), e infine, si elimina il file, sempre utilizzando l'espansione della variabile che ne contiene il nome.

50.3 Ambiente

In situazioni determinate, può essere importante avviare un programma, o un altro script con un insieme di variabili di ambiente diverso da quello che si erediterebbe normalmente. Per questo si può usare il programma di utilità `env':

env [<opzioni>] <comando> [<argomenti-del-comando>]

Come si può intuire, le opzioni di `env' servono a eliminare o ad aggiungere delle variabili di ambiente, senza interferire con l'ambiente dello script.

Alcune opzioni

-u <variabile> | --unset=<variabile>

Permette di eliminare la variabile di ambiente nominata.

- | -i | --ignore-environment

Azzera completamente tutto l'ambiente.

Esempi

Si supponga di avere due script: nel primo viene dichiarata la variabile di ambiente `CIAO', e viene chiamato il secondo eliminando questa variabile dall'ambiente; il secondo script si limita a mostrare il contenuto di questa variabile, se è disponibile.

#!/bin/sh
# ./primo.sh
CIAO="ciao a tutti"
export CIAO
env -u CIAO ./secondo.sh
echo $CIAO

#!/bin/sh
# ./secondo.sh
echo $CIAO

Il risultato è che funziona solo la visualizzazione della variabile che avviene con il comando `echo' del primo script, perché nel secondo non è disponibile. Sarebbe stato diverso se il primo e unico script fosse stato quello seguente:

#!/bin/sh
# ./primo.sh
CIAO="ciao a tutti"
export CIAO
env -u CIAO echo $CIAO
echo $CIAO

In questo caso, anche se il comando `echo' viene avviato senza la disponibilità della variabile `CIAO', si otterrebbe ugualmente la sua visualizzazione, dal momento che l'espansione della stessa avviene prima della chiamata del programma `env'.

50.4 Interazione con l'utente

Spesso, la realizzazione di uno script di shell interattivo, è molto difficile; o meglio, è difficile realizzare qualcosa di pratico da usare. La shell offre il comando interno `read', per leggere ciò che viene inserito attraverso la tastiera, ma questo permette di ottenere un'interazione molto banale, a livello di riga di comando. In alternativa si possono usare dei programmi realizzati appositamente per abbellire gli script, come nel caso di `dialog'.

50.4.1 $ read

Di norma, `read' è un comando interno della shell Bash, anche se potrebbe essere disponibile un programma di utilità equivalente, da utilizzare con una shell differente. Il modello sintattico seguente rappresenta una semplificazione di quello relativo al comando interno di Bash, e ciò volutamente per generalizzare la descrizione di questo comando che potrebbe essere disponibile in forma differente.

read [-p <invito>] [<variabile>...]

`read' potrebbe essere utilizzato da solo, senza argomenti, e in questo caso servirebbe soltanto per attendere la pressione del tasto [Invio], permettendo all'utente di leggere un'informazione che appare sullo schermo, prima di proseguire con altre operazioni.

L'opzione `-p' dovrebbe essere abbastanza chiara: permette di definire una stringa di invito all'inserimento di qualcosa. Infine, i nomi che vengono collocati in coda alla riga di comando, rappresentano altrettante variabili di ambiente che vengono create appositamente, assegnando loro le parole inserite attraverso `read'; in particolare, l'ultima variabile dell'elenco raccoglie tutte le parole rimanenti.

#!/bin/bash

echo -n "Inserisci una frase: "
read UNO DUE TRE
echo "La prima parola inserita è «$UNO»"
echo "La seconda parola inserita è «$DUE»"
echo "Il resto della frase è «$TRE»"

L'esempio dovrebbe permettere di capire il funzionamento di `read'. Si osservi in particolare il fatto che l'invito viene ottenuto attraverso il comando `echo', utilizzato con l'opzione `-n'. Supponendo che si tratti dello script `read.sh':

./read.sh[Invio]

Inserisci una frase: ciao come stai? io sto bene[Invio]

La prima parola inserita è «ciao»
La seconda parola inserita è «come»
Il resto della frase è «stai? io sto bene»

50.4.2 $ select

La shell Korn e la shell Bash offrono una struttura di controllo particolare, utile per la selezione interattiva di un elemento da un elenco. Si tratta di `select', la cui sintassi si riassume nello schema sintattico seguente:

select <variabile> [in <valore>...]
do
    <lista-di-comandi>
done

L'elenco di parole che segue `in' viene espanso, generando una lista di elementi. L'insieme delle parole espanse viene emesso attraverso lo standard error, ognuna preceduta da un numero. Se `in' (e i suoi argomenti) viene omesso, vengono utilizzati i parametri posizionali (`$1', `$2',...). In pratica è come se fosse stato usato `in $@'.

Dopo l'emissione dell'elenco, viene mostrato l'invito contenuto nella variabile `PS3' e viene letta una riga dallo standard input. Se la riga consiste del numero corrispondente a una delle parole mostrate, allora il valore della variabile indicata dopo `select' viene posto a quella parola (cioè quella parola viene assegnata alla variabile). Se la riga è vuota (probabilmente è stato premuto soltanto [Invio]), l'elenco e l'invito vengono emessi nuovamente. Se viene letto il codice di EOF ([Ctrl+d]), il comando termina. Qualsiasi altro valore letto fa sì che la variabile sia posta al valore della stringa nulla. La riga letta viene salvata nella variabile `REPLY'. La lista di comandi che segue `do' viene eseguita dopo ciascuna selezione fino a che non viene incontrato un comando `break' o `return'.

Il valore restituito da `select' è quello dell'ultimo comando eseguito all'interno della lista `do', oppure zero se nessun comando è stato eseguito.

Viene mostrato nuovamente lo stesso esempio già presentato in occasione della descrizione di `select' fatta nell'ambito dei capitoli dedicati a Bash: fa apparire un menu composto dagli argomenti fornitigli; a ogni selezione mostra quello scelto.

#!/bin/bash
select i in $*
do
    echo "hai selezionato $i premendo $REPLY"
    echo ""
    echo "premi Ctrl+c per terminare"
done

L'esempio seguente proviene dagli script di nanoLinux, e rappresenta la selezione del nome di un'interfaccia di rete, che viene accumulato nella variabile di ambiente `INTERFACCIA':

echo "Selezionare l'interfaccia."
select i in eth0 eth1 eth2 plip0 plip1 plip2
do
    INTERFACCIA=$i
    break
done

50.4.3 $ dialog

Il programma di utilità `dialog' è quello che permette di ottenere gli effetti più appariscenti in uno script di shell, dal momento che interagisce con l'utilizzatore attraverso schermate colorate e finestre di dialogo, anche se solo a livello di carattere, e senza una grafica vera e propria.

dialog [<opzioni-generali>] [<definizione-del-tipo-di-interazione>]

La riga di comando di `dialog' distingue due tipi di opzioni: quelle che hanno valore in senso generale influenzando il comportamento del programma, e quelle che definiscono un tipo di interazione con l'utilizzatore. Nella documentazione originale, queste ultime sono definite box-options, perché si riferiscono ai riquadri che vengono mostrati sullo schermo. Evidentemente, si può utilizzare al massimo una sola opzione che definisca una finestra di dialogo.

Dovendo definire delle finestre su uno schermo a caratteri, le opzioni che permettono di descriverle, fanno riferimento a delle dimensioni in caratteri. Questi valori non possono essere omessi, e in caso si voglia fare riferimento alle dimensioni ottimali, in base alla disponibilità dello schermo, basta indicare il valore zero, tenendo conto però che questa possibilità non funziona sempre.

La documentazione di `dialog' è accompagnata da esempi di script più completi quelli che si vedono qui. Vale la pena di studiarli per apprendere bene il funzionamento di questo programma di utilità. In generale, dovrebbero trovarsi a partire dalla directory `/usr/doc/dialog/'.

Alcune opzioni generali

--clear

Se si utilizza questa opzione generale, si fa in modo di ripulire lo schermo prima di mostrare il riquadro della finestra di dialogo.

--title <titolo-finestra>

Permette di dare un titolo alla finestra di dialogo.

--backtitle <sottotitolo-finestra>

Permette di dare un titolo allo sfondo, che appare nella parte superiore dello schermo, al di fuori della finestra di dialogo relativa.

--separate-output

Questa opzione altera il modo in cui viene emesso il risultato di un'interazione con `dialog'. Per la precisione serve quando si utilizza una finestra di dialogo contenente una lista di caselline da barrare. Si veda a questo proposito l'opzione `--checklist'.

Alcune opzioni per la definizione della finestra di dialogo

--yesno <testo> <altezza> <larghezza>

Fa apparire una finestra di dialogo molto semplice, in cui viene mostrato il testo indicato, e al quale si deve rispondere con un «sì», oppure con un «no», rappresentati da due pulsanti grafici: >Yes< e >No<. Se la risposta è «sì», `dialog' restituisce Vero (il valore zero), altrimenti restituisce Falso (un valore diverso da zero).

--msgbox <testo> <altezza> <larghezza>

La finestra di dialogo che si ottiene, serve a mostrare un messaggio, per il quale si attende la conferma da parte dell'utilizzatore. Alla base della finestra appare il pulsante grafico >Ok<, selezionando il quale si conclude il funzionamento di `dialog'.

--infobox <testo> <altezza> <larghezza>

In questo caso, più che di una finestra di dialogo, si tratta di una finestra contenente un messaggio, per il quale non viene attesa alcuna azione da parte dell'utente. In pratica, `dialog' mostra il messaggio e termina immediatamente di funzionare. Può essere paragonato a un comando `echo', molto più appariscente.

--inputbox <testo> <altezza> <larghezza> [<risposta-predefinita>]

Questa finestra di dialogo permette all'utilizzatore di inserire un testo libero, ed eventualmente è possibile mostrare inizialmente una risposta predefinita. Alla base della finestra appaiono i pulsanti grafici >Ok< e >Cancel<. Se si seleziona >Ok<, si conferma il testo inserito, che viene emesso da `dialog' attraverso lo standard output; altrimenti, con >Cancel<, non si ottiene alcun risultato. È importante osservare una cosa che può essere delicata per l'utilizzatore: di solito, sulla riga da inserire non appare un cursore (come ci si aspetterebbe), e forse è il caso di spiegare nel messaggio che è sufficiente iniziare a scrivere per vederne apparire uno.

--textbox <file> <altezza> <larghezza>

Questa finestra di dialogo serve a permettere la visualizzazione di un file di testo. L'utilizzatore può usare intuitivamente i tasti [Pagina su], [Pagina giù], e i tasti freccia, anche per degli spostamenti orizzontali. Alla base della finestra si vede il pulsante grafico >Exit<, che permette di concludere la visualizzazione.

--menu <testo> <altezza> <larghezza> <altezza-menu> [<elemento> <descrizione>]...

Questo tipo di finestra di dialogo comincia a essere un po' più complicato. Il suo scopo è quello di mostrare un menu, composto da coppie di valori, dove il primo è ciò che viene restituito attraverso lo standard output nel caso di selezione, e il secondo è la sua descrizione. Il menu, ovvero l'elenco di queste voci, può avere un'altezza determinata, ma anche in questo caso si può stabilire una larghezza predefinita utilizzando semplicemente lo zero. Sulle voci del menu appare un cursore in forma di barra di scorrimento, che può essere spostata con i tasti freccia o i tasti pagina, e alla base della finestra appaiono i pulsanti grafici >Ok< e >Cancel<. Selezionando >Ok<, `dialog' termina emettendo la stringa corrispondente all'elemento che si trova evidenziato dalla barra di scorrimento; selezionando >Cancel<, non si ottiene alcun risultato.

--checklist <testo> <altezza> <larghezza> <altezza-menu> [<elemento> <descrizione> on|off]...

Questo tipo di finestra di dialogo è simile a quella che si ottiene con l'opzione `--menu'. La differenza fondamentale sta nel fatto che in questo caso è possibile selezionare più voci, attraverso delle caselle di selezione: anche qui c'è una barra di scorrimento, e quando ci si trova sopra la voce desiderata, la [barra spaziatrice] mette o toglie il segno di selezione. A differenza dell'opzione `--menu', le voci del menu possono essere già attivate o meno, e per questo si aggiunge la parola chiave `on' oppure `off'.

La particolarità di questo tipo di selezione, richiede attenzione nel modo in cui deve essere interpretato il risultato emesso attraverso lo standard output. Infatti, in condizioni normali, vengono restituite le stringhe corrispondenti alle voci di menù selezionate, delimitate tra apici doppi. Se questo sistema crea difficoltà, si può abbinare l'uso dell'opzione `--separate-output' perché queste stringhe siano separate dal codice di interruzione di riga, senza l'uso di delimitatori di altro tipo.

--radiolist <testo> <altezza> <larghezza> <altezza-menu> [<elemento> <descrizione> on|off]...

Questo tipo di finestra di dialogo si comporta in modo simile a quella ottenuta con l'opzione `--checklist'. La differenza sta nel fatto che si può selezionare solo una voce dall'elenco, per cui il risultato non comporta difficoltà nell'interpretazione. Evidentemente, si può preselezionare solo una delle voci del menu.

Esempi

#/bin/sh

if dialog --yesno "Ti piace dialog?" 0 0
then
    echo "Ottimo!"
else
    echo "Peccato :-)"
fi

In questo script, viene mostrata la finestra di dialogo che si vede nella figura 50.1, e in base alla scelta affermativa o negativa, si ottiene la visualizzazione di un messaggio differente.

                          +-----------------------+
                          |   Ti piace dialog?    |
                          +-----------------------+
                          | < Yes >      <  No  > |
                          +-----------------------+

Figura 50.1: Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione `--yesno'.

dialog --title "Domanda" --yesno "Ti piace dialog?" 0 0

Questo comando rappresenta solo una variante dell'esempio precedente (a parte il fatto che manca il contorno dello script), e si vede l'aggiunta dell'indicazione di un titolo della finestra.

#!/bin/sh

RISULTATO=`tempfile`

dialog --title "Menu" \
--menu "Scegli il colore che preferisci" \
0 0 0 \
0 nero \
1 marrone \
2 rosso \
3 arancio \
4 giallo \
5 verde \
6 blu \
7 viola \
8 grigio \
9 bianco 2> $RISULTATO

echo `cat $RISULTATO`

In questo script viene mostrata la finestra di dialogo che si vede nella figura 50.2, e in base alla scelta del colore, si ottiene il numero corrispondente.

                     +------------- Menu --------------+
                     | Scegli il colore che preferisci |
                     | +-----------------------------+ |
                     | |         0  nero             | |
                     | |         1  marrone          | |
                     | |         2  rosso            | |
                     | |         3  arancio          | |
                     | |         4  giallo           | |
                     | |         5  verde            | |
                     | |         6  blu              | |
                     | |         7  viola            | |
                     | |         8  grigio           | |
                     | |         9  bianco           | |
                     | +-----------------------------+ |
                     |---------------------------------|
                     |     <  OK  >      <Cancel>      |
                     +---------------------------------+

Figura 50.2: Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione `--menu'.

#!/bin/sh

RISULTATO=`tempfile`

dialog --separate-output --title "Selezione" \
--checklist "Scegli i colori che preferisci" \
0 0 10 \
0 nero on \
1 marrone off \
2 rosso off \
3 arancio off \
4 giallo off \
5 verde off \
6 blu off \
7 viola off \
8 grigio off \
9 bianco on \
    2> $RISULTATO

echo `cat $RISULTATO`

Questo script è una variante di quello precedente in cui si possono selezionare più colori assieme. Nella figura 50.3 si vede la finestra di dialogo che si ottiene.

                     +------------- Menu -------------+
                     | Scegli i colori che preferisci |
                     | +----------------------------+ |
                     | |      [X] 0  nero           | |
                     | |      [ ] 1  marrone        | |
                     | |      [ ] 2  rosso          | |
                     | |      [ ] 3  arancio        | |
                     | |      [ ] 4  giallo         | |
                     | |      [ ] 5  verde          | |
                     | |      [ ] 6  blu            | |
                     | |      [ ] 7  viola          | |
                     | |      [ ] 8  grigio         | |
                     | |      [X] 9  bianco         | |
                     | +----------------------------+ |
                     |--------------------------------|
                     |     <  OK  >      <Cancel>     |
                     +--------------------------------+

Figura 50.3: Esempio del funzionamento della finestra di dialogo ottenuta con l'opzione `--checklist'.

---------------------------

Appunti Linux 2000.04.12 --- Copyright © 1997-2000 Daniele Giacomini --  daniele @ pluto.linux.it


[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]