[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home] [volume] [parte]


Capitolo 162.   Un esercizio con Dialog

In questo capitolo viene proposto uno script basato sull'uso di Dialog, per realizzare un piccolo programma frontale con uno scopo preciso: facilitare la scrittura di testi come lo si potrebbe fare con una macchina da scrivere.

Questo tipo di lavoro, così come è impostato, è organizzato in modo da definire prima l'azione, poi gli oggetti coinvolti, come succedeva spesso nei programmi gestionali dei primi anni 1980.

162.1   Installazione e organizzazione

Lo script è pensato per l'uso da parte di chi non vuole sapere come si usa un sistema operativo, a costo di accontentarsi di poche cose. Per questa ragione, lo script è pensato per sostituire il file ~/.profile, in modo che dopo l'identificazione dell'utente, ciò che appare sia un menù di funzioni.

Questo script deve organizzare la gestione di file di testo, cercando di evitare che l'utente incorra in errori gravi, dovuti all'assoluta ignoranza di questioni che generalmente sono ritenute banali. Per questo, all'avvio verifica l'esistenza di una directory che ha lo scopo di raccogliere i documenti testuali e di sottodirectory per la conservazione di diverse versioni precedenti. Se queste directory mancano, provvede a crearle.

Figura 162.1. All'avvio, lo script mostra il menù delle funzioni disponibili.

.----------------------------Menu` principale------------------------------.
| Funzioni disponibili:                                                    |
| .----------------------------------------------------------------------. |
| |   new     crea un documento nuovo                                    | |
| |   view    visualizza un documento gia` esistente                     | |
| |   edit    modifica un documento gia` esistente                       | |
| |   copy    copia un documento                                         | |
| |   rename  cambia nome a un documento                                 | |
| |   delete  elimina un documento che non serve piu`                    | |
| |   list    elenca il contenuto di un disco rimovibile                 | |
| |   view2   visualizza un documento contenuto in un disco rimovibile   | |
| |   erase   cancella un disco rimovibile                               | |
| |   format  inizializza un disco rimovibile                            | |
| |   export  esporta dei documenti in un disco rimovibile               | |
| |   import  importa dei documenti da un disco rimovibile               | |
| |   print   stampa un documento                                        | |
| |   startx  avvia la grafica                                           | |
| |   quit    fine lavoro                                                | |
| `----------------------------------------------------------------------' |
|--------------------------------------------------------------------------|
|                       <  OK  >            <Cancel>                       |
`--------------------------------------------------------------------------'

Come si può vedere, le lettere accentate sono state realizzate con l'uso di un apostrofo inverso, per evitare qualunque problema di compatibilità con la configurazione della console.

Nella parte iniziale dello script vengono inseriti i comandi che dovrebbero trovarsi invece nel file ~/.profile, quindi vengono dichiarate delle variabili di ambiente il cui valore iniziale può essere modificato:

umask 022
alias cp="cp -f"
alias rm="rm -f"
alias mv="mv -f"
alias ln="ln -f"
#
#
DATA_DIRECTORY="$HOME/Documenti"
DATA_BACKUP_LEVELS="77"
DATA_NAME_DEFAULT="Nuovo"
DATA_EDITOR_COMMAND="luit -encoding ISO-8859-1 mcedit"
PRINTER_FILTER="\
| enscript -1 -M a4 -f CourierBold@9.1/9.5 \
    --margin=72:72:72:72 --header=||$% -o -
PRINTER_COMMAND="lpr"
IMPORT_EXPORT_MOUNT_POINTS_LIST="\
/mnt/a dischetto \
/mnt/d penna_USB"
IMPORT_EXPORT_DEVICES_LIST="/dev/fd0 dischetto"

La tabella successiva riepiloga il significato di queste variabili di ambiente:

Variabile Descrizione
DATA_DIRECTORY
La directory da usare per la gestione dei file di testo.
DATA_BACKUP_LEVELS
Il numero di livelli per la conservazione delle versioni precedenti.
DATA_NAME_DEFAULT
La radice del nome predefinito da usare per i documenti nuovi.
DATA_EDITOR_COMMAND
Il comando da usare per accedere alla modifica di un file. Il nome del file viene fornito alla fine.
PRINTER_FILTER
Il comando per trasformare un file di testo in un file PostScript con un'impaginazione corretta, che comprenda dei margini e possibilmente la numerazione delle pagine.
PRINTER_COMMAND
Il comando per stampare, che riceve il file dallo standard input.
IMPORT_EXPORT_MOUNT_POINTS_LIST
L'elenco dei punti di innesto per innestare unità di memorizzazione esterne. Queste directory devono essere state previste nel file /etc/fstab, in modo da consentire all'utente in questione di poter eseguire il comando mount. L'elenco è composto da coppie di «parole», dove la prima è la directory e la seconda è la descrizione da visualizzare nel menù.
IMPORT_EXPORT_DEVICES_LIST
L'elenco dei file di dispositivo delle unità di memorizzazione esterne da usare per il trasferimento dei dati. Attraverso questi nomi è possibile inizializzare tali unità, ammesso che l'utente disponga dei permessi necessari. L'elenco è composto da coppie di «parole», dove la prima è il file di dispositivo e la seconda è la descrizione da visualizzare nel menù.

162.2   Gestione dei file di testo

Per la gestione dei file di testo, ci si avvale di un programma esterno, definito dalla variabile di ambiente DATA_EDITOR_COMMAND, che viene usato solo per modificare un file, mentre il resto può essere gestito esternamente, attraverso le voci previste nel menù.

La creazione di un nuovo documento, si ottiene con la selezione della voce {new}, a cui segue la richiesta di specificare il nome che si preferisce:

.--crea un documento nuovo---.
| Inserisci il nome del      |
| documento da creare:       |
| .------------------------. |
| |Nuovo-1                 | |
| `------------------------' |
|----------------------------|
|   <  OK  >  <Cancel>       |
`----------------------------'

Inizialmente viene proposto un nome predefinito, in base all'indicazione della variabile di ambiente DATA_NAME_DEFAULT. Il nome può essere modificato e lo si può scrivere come si vuole: se il nome contiene simboli diversi dalle lettere alfabetiche latine, da numeri e da trattini (- o _), questo viene aggiustato in qualche modo; se il nome esiste già, viene modificato in modo da evitare il conflitto. Il file viene creato vuoto e viene avviato il programma di modifica per consentire la scrittura di ciò che si desidera.

Per visualizzare il contenuto di un documento, ovvero di un file di testo contenuto nella directory prevista, si può selezionare la voce {view}, ottenendo così la richiesta di selezionare il nome di questo:

.-visualizza un documento gia` esistente-.
| Seleziona il documento da              |
| visualizzare:                          |
| .------------------------------------. |
| |       appunti-1            .       | |
| |       appunti-2            .       | |
| |       da-fare              .       | |
| |       cose-vecchie         .       | |
| `------------------------------------' |
|----------------------------------------|
|         <  OK  >     <Cancel>          |
`----------------------------------------'

Si osservi che dall'elenco sono esclusi volutamente i nomi che contengono una tilde (~), che normalmente rappresenta una copia di sicurezza generata dal programma usato per modificare i file.

La modifica si ottiene selezionando la voce {edit} e il comportamento è simile a quanto già descritto a proposito della visualizzazione, con la differenza che viene avviato il programma per modificare i file di testo. Si presume che l'utente si limiti a salvare, senza modificare il nome, altrimenti questo script potrebbe essere inutile.

.-modifica un documento gia` esistente-.
| Seleziona il documento da            |
| modificare:                          |
| .----------------------------------. |
| |       appunti-1            .     | |
| |       appunti-2            .     | |
| |       da-fare              .     | |
| |       cose-vecchie         .     | |
| `----------------------------------' |
|--------------------------------------|
|        <  OK  >     <Cancel>         |
`--------------------------------------'

Selezionando dal menù la voce copy è possibile fare una copia di un file esistente, all'interno della stessa directory. In pratica, questa copia potrebbe servire per realizzare un documento a partire dai contenuti di un altro già scritto in precedenza. Viene richiesto di selezionare il file da copiare, quindi viene chiesto il nome da assegnare: se il nome nuovo va in conflitto con un altro file già esistente, la copia viene annullata.

.-------copia un documento-------.
| Seleziona il documento da      |
| copiare:                       |
| .----------------------------. |
| |     appunti-1            . | |
| |     appunti-2            . | |
| |     da-fare              . | |
| |     cose-vecchie         . | |
| `----------------------------' |
|--------------------------------|
|     <  OK  >     <Cancel>      |
`--------------------------------'

In questo esempio si suppone di avere selezionato il nome {appunti-1}, perciò è lo stesso nome appunti-1 che viene proposto inizialmente per la copia, ma ovviamente deve essere modificato:

.-----copia un documento-----.
| Inserisci il nome per la   |
| copia del documento:       |
| .------------------------. |
| |appunti-1               | |
| `------------------------' |
|----------------------------|
|   <  OK  >  <Cancel>       |
`----------------------------'

Dal menù è possibile selezionare la voce {rename} per essere guidati alla modifica del nome di uno dei file che compongono i documenti. Come già per la copia, viene richiesto di selezionare un nome esistente, quindi viene offerta una mascherina per inserire il nome nuovo. Il nome che si attribuisce non può essere uguale a uno già presente; in caso contrario, l'operazione non viene eseguita.

.---cambia nome a un documento---.
| Seleziona il documento da      |
| rinominare:                    |
| .----------------------------. |
| |     appunti-1            . | |
| |     appunti-2            . | |
| |     da-fare              . | |
| |     cose-vecchie         . | |
| `----------------------------' |
|--------------------------------|
|     <  OK  >     <Cancel>      |
`--------------------------------'
.-cambia nome a un documento-.
| Inserisci il nome nuovo    |
| per il documento:          |
| .------------------------. |
| |appunti-1               | |
| `------------------------' |
|----------------------------|
|   <  OK  >  <Cancel>       |
`----------------------------'

Per cancellare un file è possibile selezionare la voce {delete}, a cui segue la richiesta di selezionare il nome da eliminare. Prima di procedere alla cancellazione, una copia del file viene conservata nelle directory usate per le versioni precedenti; per questo, l'utente deve chiedere un aiuto da persona più preparata.

.-elimina un documento che non serve piu`-.
| Seleziona il documento da cancellare    |
| .-------------------------------------. |
| |     appunti-1            .          | |
| |     appunti-2            .          | |
| |     da-fare              .          | |
| |     cose-vecchie         .          | |
| `-------------------------------------' |
|-----------------------------------------|
|          <  OK  >      <Cancel>         |
`-----------------------------------------'
.--elimina un documento che non serve piu`--.
| Vuoi cancellare il documento "appunti-1"? |
|                                           |
|-------------------------------------------|
|          <  Yes  >      <  No  >          |
`-------------------------------------------'

162.3   Copie delle versioni precedenti

Lo script prevede che per alcune operazioni delicate venga fatta la copia dei documenti che devono essere modificati, cancellati o sostituiti. Questa copia viene eseguita all'interno di sottodirectory con il nome ~backup.n/, dove la tilde (~) fa parte del nome e il numero finale rappresenta il livello della copia. In pratica, la sottodirectory ~backup.1/ contiene le copie più recenti.

Il numero di livelli di copia è definito dalla variable di ambiente DATA_BACKUP_LEVELS e può essere modificato liberamente: lo script, a ogni avvio, verifica la presenza di queste sottodirectory e in caso siano assenti le crea senza fare domande all'utente.

Lo script non prevede un sistema di recupero dei documenti nelle loro versioni precedenti.

162.4   Esportazione e importazione dati

Pur trattandosi di un lavoro molto semplice, si presume che la persona che lo utilizza abbia la necessità di trasferire i propri documenti da e verso un disco rimovibile. Per poter fare questo, è necessario che sia stato previsto nel file /etc/fstab il modo di accedere a dei dischi esterni anche a un utente comune. In base a questa configurazione è necessario modificare la variabile di ambiente IMPORT_EXPORT_MOUNT_POINTS_LIST.

La variabile di ambiente IMPORT_EXPORT_MOUNT_POINTS_LIST deve contenere un elenco di coppie di «parole», secondo la forma:

directory_innesto descrizione

Per esempio, ammesso che la directory /mnt/fd0/ serva per innestare un dischetto e che la directory /mnt/sda1/ serva per innestare la prima partizione di una «penna» USB, si potrebbe inizializzare la variabile nel modo seguente:

IMPORT_EXPORT_MOUNT_POINTS_LIST="/mnt/a dischetto /mnt/d penna_USB"

Si osservi che non si possono inserire spazi nella descrizione.

Sulla base di questo esempio, il file /etc/fstab potrebbe contenere le righe seguenti, dove si dà per scontato che il file system sia di tipo Dos-FAT:

/dev/fd0  /mnt/a  vfat  defaults,user,noauto,exec,sync,umask=0000  0  0
/dev/sda1 /mnt/d  vfat  defaults,user,noauto,exec,sync,umask=0000  0  0

Oltre a questo è necessario che l'utente possa inizializzare i dischetti, pertanto deve avere i privilegi per poterlo fare. Nella variabile di ambiente IMPORT_EXPORT_DEVICES_LIST si mette l'elenco dei file di dispositivo che l'utente può inizializzare. Anche in questo caso i nomi sono associati a una descrizione. Supponendo che sia concesso di inizializzare solo il dischetto, la variabile può essere inizializzata così:

IMPORT_EXPORT_DEVICES_LIST="/dev/fd0 dischetto"

Anche per questa situazione, non si possono inserire spazi nella descrizione.

Attraverso le voci del menù è possibile: ottenere l'elenco del contenuto di un'unità di memorizzazione esterna; vedere il contenuto di un file di tale unità; cancellare il contenuto dell'unità esterna o inizializzarla. Inoltre, è possibile copiare file da o verso l'unità esterna.

Per tutte queste funzioni è richiesto di specificare l'unità esterna. In tutti i casi, escluso quello dell'inizializzazione, viene mostrato l'elenco contenuto nella variabile di ambiente IMPORT_EXPORT_MOUNT_POINTS_LIST, mentre per l'inizializzazione vale l'altra variabile (IMPORT_EXPORT_DEVICES_LIST).

Viene mostrato il caso dell'esportazione, che si ottiene con la voce {export} del menù. Si comincia dalla selezione dell'unità che deve accogliere la copia:

.esporta dei documenti in un disco rimovibile--.
| Seleziona l'unita` da usare per              |
| l'esportazione dei documenti:                |
| .------------------------------------------. |
| |            /mnt/a  dischetto             | |
| |            /mnt/d  penna_USB             | |
| `------------------------------------------' |
|----------------------------------------------|
|           <  OK  >      <Cancel>             |
`----------------------------------------------'

Si selezionano i documenti da esportare, con l'aiuto della barra spaziatrice:

.esporta dei documenti in un disco rimovibile--.
| Seleziona o deseleziona i documenti da       |
| esportare, con l'aiuto della barra           |
| spaziatrice:                                 |
| .------------------------------------------. |
| |      [X] appunti-2            .          | |
| |      [X] da-fare              .          | |
| |      [ ] cose-vecchie         .          | |
| `----------------v(+)----------------------' |
|----------------------------------------------|
|           <  OK  >      <Cancel>             |
`----------------------------------------------'

Alla conferma inizia la copia; se ci sono file con lo stesso nome, lo script verifica se il contenuto è lo stesso, altrimenti chiede conferma per procedere alla sovrascrittura.

L'importazione avviene nello stesso modo, con la differenza che se viene richiesta la sovrascrittura, i documenti precedenti vengono salvati attraverso il sistema di rotazione delle versioni.

162.5   Stampa

La stampa si ottiene selezionando la voce {print} dal menù principale. A questo segue la richiesta di selezionare un solo documento dall'elenco di quelli esistenti. La stampa avviene con i comandi indicati nelle variabili di ambiente PRINTER_FILTER e PRINTER_COMMAND.

162.6   Sorgente

Nel listato successivo, appare integralmente lo script descritto in questo capitolo. Una copia di questo file, dovrebbe essere disponibile anche qui: <allegati/a2/shell-testi.sh>.

#!/bin/sh
#
# Initial setup.
#
umask 022
alias cp="cp -f"
alias rm="rm -f"
alias mv="mv -f"
alias ln="ln -f"
#
# Configuration public variables.
#
DATA_DIRECTORY="$HOME/Documenti"
DATA_BACKUP_LEVELS="77"
DATA_NAME_DEFAULT="Nuovo"
DATA_EDITOR_COMMAND="luit -encoding ISO-8859-1 mcedit"
PRINTER_FILTER="enscript -1 -M a4 -f CourierBold@9.1/9.5 \
                --margin=72:72:72:72 \
                --header=||$% -o -"
PRINTER_COMMAND="lpr"
IMPORT_EXPORT_MOUNT_POINTS_LIST="/mnt/a dischetto \
                                 /mnt/d penna_USB"
IMPORT_EXPORT_DEVICES_LIST="/dev/fd0 dischetto"
#
# Other public variables.
#
TEMPORARY=`tempfile`
touch $TEMPORARY
#
DOCUMENT_LIST=""
#
# Intro.
#
function_intro () {
    #
    # Check data directory.
    #
    if [ -d "$DATA_DIRECTORY" ]
    then
        #
        # The directory is there.
        #
        echo -n ""
    else
        #
        # Make directory with parents if necessary.
        #
        if mkdir -p "$DATA_DIRECTORY"
        then
            #
            # Data directory created.
            #
            echo -n ""
        else
            #
            # Sorry, cannot create the data directory.
            #
            dialog --msgbox "Sono spiacente, ma non mi e\` possibile creare l\
a directory \"$DATA_DIRECTORY\" che serve a contenere i documenti." 0 0
            #
            function_quit
        fi
    fi
    #
    # If we are here, the data directory is there.
    #
    chmod +rwx "$DATA_DIRECTORY"        2> /dev/null
    #
    if [ -r "$DATA_DIRECTORY" ] \
       && [ -w "$DATA_DIRECTORY" ] \
       && [ -x "$DATA_DIRECTORY" ]
    then
        #
        # The directory is accessible.
        #
        echo -n ""
    else
        #
        # Sorry, cannot access the data directory.
        #
        dialog --msgbox "Sono spiacente, ma i permessi della directory \
\"$DATA_DIRECTORY\" non mi permettono di accedere." 0 0
        #
        function_quit
    fi
    #
    # If we are here, the directory has permissions;
    # backup subdirectories must be checked.
    #
    for b in `seq 1 $DATA_BACKUP_LEVELS`
    do
        #
        chmod +rwx "$DATA_DIRECTORY/~backup.$b" 2> /dev/null
        #
        if    [ -d "$DATA_DIRECTORY/~backup.$b" ] \
           && [ -r "$DATA_DIRECTORY/~backup.$b" ] \
           && [ -w "$DATA_DIRECTORY/~backup.$b" ] \
           && [ -x "$DATA_DIRECTORY/~backup.$b" ]
        then
            #
            # Ok.
            #
            echo -n ""
        else
            #
            # Try to remove and replace.
            #               
            rm -fr "$DATA_DIRECTORY/~backup.$b" 2> /dev/null
            if mkdir "$DATA_DIRECTORY/~backup.$b"
            then
                #
                # Ok.
                #
                echo -n ""
            else
                #
                # Sorry.
                #
                dialog --msgbox "Sono spiacente, ma non mi e\` possibile \
creare le directory \"$DATA_DIRECTORY/~backup.$b\" che servono a contenere \
le versioni vecchie dei documenti." 0 0
                #
                function_quit
            fi
        fi
    done
}
#
# Quit the script.
#
function_quit () {
    exit
}
#
# New default name.
#
function_new_document_name () {
    #
    for n in `seq 1 999`
    do
        if ! [ -e "$DATA_DIRECTORY/$DATA_NAME_DEFAULT-$n" ]
        then
            #
            # Name found.
            #
            echo "$DATA_NAME_DEFAULT-$n"
            return 0
        fi
    done
    #
    # No available name was found.
    #
    basename `tempfile -d "$DATA_DIRECTORY"`
    return 0
}
#
# Edit.
#
function_edit_document () {
    #
    $DATA_EDITOR_COMMAND $1
}
#
# Backup document.
#
function_backup_document () {
    #
    local DOCUMENT_NAME="$1"
    local n=""
    #
    DOCUMENT_NAME=`basename $DOCUMENT_NAME`
    #
    # Scroll previous levels.
    #
    for n in `seq $(($DATA_BACKUP_LEVELS-1)) -1 1`
    do
        mv "$DATA_DIRECTORY/~backup.$n/$DOCUMENT_NAME" \
           "$DATA_DIRECTORY/~backup.$(($n+1))" 2> /dev/null
    done
    #
    # Save last version.
    #
    cp -f "$DATA_DIRECTORY/$DOCUMENT_NAME" \
          "$DATA_DIRECTORY/~backup.1/$DOCUMENT_NAME"
}
#
# Build a document list to be used with dialog.
# The variabile DOCUMENT_LIST is public and
# will contain the resulting list.
#
function_document_list () {
    #
    local DOCUMENT_NAME=""
          DOCUMENT_LIST=""
    #
    for f in $DATA_DIRECTORY/*
    do
        if echo $f | grep "~" > /dev/null 2> /dev/null
        then
            #
            # This seems to be a backup copy: don't show.
            #
            echo -n
        else
            #
            # It seems to be a valid name.
            #
            if [ -f $f ]
            then
                DOCUMENT_NAME=`basename $f`
                DOCUMENT_LIST="$DOCUMENT_LIST $DOCUMENT_NAME . "
            fi
        fi
    done
}
#
# Main menu.
#
function_menu () {
    #
    local SELECTION=""
    #
    if dialog   \
        --clear \
        --title "Menu\` principale" \
        --menu "Funzioni disponibili:" \
        0 0 0 \
        "new"           "crea un documento nuovo" \
        "view"          "visualizza un documento gia\` esistente" \
        "edit"          "modifica un documento gia\` esistente" \
        "copy"          "copia un documento" \
        "rename"        "cambia nome a un documento" \
        "delete"        "elimina un documento che non serve piu\`" \
        "list"          "elenca il contenuto di un disco rimovibile" \
        "view2"         "visualizza un documento contenuto in un disco \
rimovibile" \
        "erase"         "cancella un disco rimovibile" \
        "format"        "inizializza un disco rimovibile" \
        "export"        "esporta dei documenti in un disco rimovibile" \
        "import"        "importa dei documenti da un disco rimovibile" \
        "print"         "stampa un documento" \
        "startx"        "avvia la grafica" \
        "quit"          "fine lavoro" \
        2> $TEMPORARY
    then
        SELECTION=`cat $TEMPORARY`
        echo "" > $TEMPORARY
        #
        # Continue as run with this command name (arguments included).
        #
        if   [ "$SELECTION" = "new" ]
        then
            function_new
        elif [ "$SELECTION" = "view" ]
        then
            function_view
        elif [ "$SELECTION" = "edit" ]
        then
            function_edit
        elif [ "$SELECTION" = "copy" ]
        then
            function_copy
        elif [ "$SELECTION" = "rename" ]
        then
            function_rename
        elif [ "$SELECTION" = "delete" ]
        then
            function_delete
        elif [ "$SELECTION" = "list" ]
        then
            function_list
        elif [ "$SELECTION" = "view2" ]
        then
            function_view2
        elif [ "$SELECTION" = "erase" ]
        then
            function_erase
        elif [ "$SELECTION" = "format" ]
        then
            function_format
        elif [ "$SELECTION" = "export" ]
        then
            function_export
        elif [ "$SELECTION" = "import" ]
        then
            function_import
        elif [ "$SELECTION" = "print" ]
        then
            function_print
        elif [ "$SELECTION" = "startx" ]
        then
            function_startx
        elif [ "$SELECTION" = "quit" ]
        then
            function_quit
        else
            function_quit
        fi
    fi
}
#
# Create e a new document.
#
function_new () {
    #
    local DOCUMENT_NAME=`function_new_document_name`
    #
    if dialog                                                   \
        --clear                                                 \
        --title "crea un documento nuovo"                       \
        --inputbox "Inserisci il nome del documento da creare:" \
        0 0                                                     \
        "$DOCUMENT_NAME"                                        \
        2> $TEMPORARY
    then
        DOCUMENT_NAME=`cat $TEMPORARY`
        echo "" > $TEMPORARY
        #
        # Check and adapt the name.
        #
        DOCUMENT_NAME=`echo "$DOCUMENT_NAME" | sed "s/[^a-zA-Z0-9_-]/_/g"`
        #
        if [ -e "$DATA_DIRECTORY/$DOCUMENT_NAME" ]
        then
            for n in `seq 1 999`
            do
                if ! [ -e "$DATA_DIRECTORY/$DOCUMENT_NAME-$n" ]
                then
                    #
                    # Ok.
                    #
                    DOCUMENT_NAME="$DOCUMENT_NAME-$n"
                    break
                fi
            done
        fi
        #
        if [ -e "$DATA_DIRECTORY/$DOCUMENT_NAME" ]
        then
            #
            # Sorry, cannot create the file.
            #
            dialog --msgbox "Sono spiacente, ma non mi e\` possibile creare \
il documento \"$DOCUMENT_NAME\"." 0 0
        else
            touch "$DATA_DIRECTORY/$DOCUMENT_NAME"
            #
            #
            #
            function_edit_document "$DATA_DIRECTORY/$DOCUMENT_NAME"
        fi
    fi
}
#
# View document.
#
function_view () {
    #
    local DOCUMENT_NAME=""
    #
    function_document_list
    #
    if dialog                                                   \
        --clear                                                 \
        --title "visualizza un documento gia\` esistente"       \
        --menu "Seleziona il documento da visualizzare:"        \
        0 0 0                                                   \
        $DOCUMENT_LIST                                          \
        2> $TEMPORARY
    then
        DOCUMENT_NAME=`cat $TEMPORARY`
        echo "" > $TEMPORARY
        #
        if [ -f "$DATA_DIRECTORY/$DOCUMENT_NAME" ]
        then
            #
            # Ok, view.
            #
            dialog                                              \
                --clear                                         \
                --title "$DOCUMENT_NAME"                        \
                --textbox "$DATA_DIRECTORY/$DOCUMENT_NAME"      \
                0 0                                             \
                2> /dev/null
        fi
    fi
}
#
# Edit a file.
#
function_edit () {
    #
    local DOCUMENT_NAME=""
    #
    function_document_list
    #
    if dialog                                                   \
        --clear                                                 \
        --title "modifica un documento gia\` esistente"         \
        --menu "Seleziona il documento da modificare:"          \
        0 0 0                                                   \
        $DOCUMENT_LIST                                          \
        2> $TEMPORARY
    then
        DOCUMENT_NAME=`cat $TEMPORARY`
        echo "" > $TEMPORARY
        #
        if [ -f "$DATA_DIRECTORY/$DOCUMENT_NAME" ]
        then
            #
            # Ok, edit.
            #
            function_backup_document "$DATA_DIRECTORY/$DOCUMENT_NAME"
            function_edit_document "$DATA_DIRECTORY/$DOCUMENT_NAME"
        fi
    fi
}
#
# Copy a file.
#
function_copy () {
    #
    local DOCUMENT_NAME=""
    local NEW_DOCUMENT_NAME=""
    #
    function_document_list
    #
    if dialog                                           \
        --clear                                         \
        --title "copia un documento"                    \
        --menu "Seleziona il documento da copiare:"     \
        0 0 0                                           \
        $DOCUMENT_LIST                                  \
        2> $TEMPORARY
    then
        DOCUMENT_NAME=`cat $TEMPORARY`
        echo "" > $TEMPORARY
        #
        if [ -f "$DATA_DIRECTORY/$DOCUMENT_NAME" ]
        then
            #
            # Ok, rename.
            #
            if dialog                                                   \
                --clear                                                 \
                --title "copia un documento"                            \
                --inputbox                                              \
                        "Inserisci il nome per la copia del documento:" \
                0 0                                                     \
                "$DOCUMENT_NAME"                                        \
                2> $TEMPORARY
            then
                NEW_DOCUMENT_NAME=`cat $TEMPORARY`
                echo "" > $TEMPORARY
                #
                # Check and adapt the name.
                #
                NEW_DOCUMENT_NAME=`echo "$NEW_DOCUMENT_NAME" \
| sed "s/[^a-zA-Z0-9_-]/_/g"`
                #
                if [ -e "$DATA_DIRECTORY/$NEW_DOCUMENT_NAME" ]
                then
                    #
                    # Already present.
                    #
                    dialog --msgbox "Sono spiacente, ma il nome richiesto, \
\"$NEW_DOCUMENT_NAME\" e\` gia\` assegnato a un documento esistente e non \
posso usarlo per fare la copia di \"$DOCUMENT_NAME\"." 0 0
                else
                    cp -f "$DATA_DIRECTORY/$DOCUMENT_NAME" \
                          "$DATA_DIRECTORY/$NEW_DOCUMENT_NAME"
                fi
            fi
        fi
    fi
}
#
# Rename a file.
#
function_rename () {
    #
    local DOCUMENT_NAME=""
    local NEW_DOCUMENT_NAME=""
    #
    function_document_list
    #
    if dialog                                           \
        --clear                                         \
        --title "cambia nome a un documento"            \
        --menu "Seleziona il documento da rinominare:"  \
        0 0 0                                           \
        $DOCUMENT_LIST                                  \
        2> $TEMPORARY
    then
        DOCUMENT_NAME=`cat $TEMPORARY`
        echo "" > $TEMPORARY
        #
        if [ -f "$DATA_DIRECTORY/$DOCUMENT_NAME" ]
        then
            #
            # Ok, rename.
            #
            if dialog                                                   \
                --clear                                                 \
                --title "cambia nome a un documento"                    \
                --inputbox "Inserisci il nome nuovo per il documento:"  \
                0 0                                                     \
                "$DOCUMENT_NAME"                                        \
                2> $TEMPORARY
            then
                NEW_DOCUMENT_NAME=`cat $TEMPORARY`
                echo "" > $TEMPORARY
                #
                # Check and adapt the name.
                #
                NEW_DOCUMENT_NAME=`echo "$NEW_DOCUMENT_NAME" \
| sed "s/[^a-zA-Z0-9_-]/_/g"`
                #
                if [ -e "$DATA_DIRECTORY/$NEW_DOCUMENT_NAME" ]
                then
                    #
                    # Already present.
                    #
                    dialog --msgbox "Sono spiacente, ma il nome richiesto, \
\"$NEW_DOCUMENT_NAME\" e\` gia\` assegnato a un documento esistente e non \
posso usarlo per cambiare il nome di \"$DOCUMENT_NAME\"." 0 0
                else
                    mv -f "$DATA_DIRECTORY/$DOCUMENT_NAME" \
                          "$DATA_DIRECTORY/$NEW_DOCUMENT_NAME"
                fi
            fi
        fi
    fi
}
#
# Delete a file.
#
function_delete () {
    #
    local DOCUMENT_NAME=""
    #
    function_document_list
    #
    if dialog                                                   \
        --clear                                                 \
        --title "elimina un documento che non serve piu\`"      \
        --menu "Seleziona il documento da cancellare:"          \
        0 0 0                                                   \
        $DOCUMENT_LIST                                          \
        2> $TEMPORARY
    then
        DOCUMENT_NAME=`cat $TEMPORARY`
        echo "" > $TEMPORARY
        #
        if [ -f "$DATA_DIRECTORY/$DOCUMENT_NAME" ]
        then
            #
            # Ok, delete.
            #
            function_backup_document "$DATA_DIRECTORY/$DOCUMENT_NAME"
            #
            if dialog                                                   \
                --clear                                                 \
                --title "elimina un documento che non serve piu\`"      \
                --yesno "Vuoi cancellare il documento \"$DOCUMENT_NAME\"?" \
                0 0                                                     \
                2> /dev/null
            then
                rm -f "$DATA_DIRECTORY/$DOCUMENT_NAME"
            fi
        fi
    fi
}
#
# List external files.
#
function_list () {
    #
    local MOUNT_POINT=""
    #
    if ! [ "$IMPORT_EXPORT_MOUNT_POINTS_LIST" = "" ]
    then
        if dialog                                                       \
            --clear                                                     \
            --title "elenca il contenuto di un disco rimovibile"        \
            --menu "Seleziona l'unita\` di memorizzazione esterna \
di cui vuoi conoscere l'elenco del contenuto:"                          \
            0 0 0                                                       \
            $IMPORT_EXPORT_MOUNT_POINTS_LIST                            \
            2> $TEMPORARY
        then
            #
            MOUNT_POINT=`cat $TEMPORARY`
            echo "" > $TEMPORARY
            #
            # Try to mount.
            #
            umount "$MOUNT_POINT" 2> /dev/null
            if mount "$MOUNT_POINT"
            then
                #
                # Ok, list
                #
                ls -l $MOUNT_POINT
                #
                # Read
                #
                echo "Premi [Invio] per continuare"
                read
                #
                # Unmount.
                #
                umount "$MOUNT_POINT"
            else
                dialog --msgbox "Sono spiacente: mi e\` impossibile \
accedere all'unita\` \"$MOUNT_POINT\"." 0 0
                #
                umount "$MOUNT_POINT"   2> /dev/null
            fi
        fi
    else
        dialog --msgbox "Non e\` possibile eseguire l'operazione." 0 0
    fi
}
#
# View and external file.
#
function_view2 () {
    #
    local MOUNT_POINT=""
    local DOCUMENT_LIST=""
    local DOCUMENT_NAME=""
    #
    if ! [ "$IMPORT_EXPORT_MOUNT_POINTS_LIST" = "" ]
    then
        if dialog                               \
            --clear                             \
            --title "visualizza un documento contenuto in un disco \
rimovibile"                                     \
            --menu "Seleziona l'unita\` da usare per la visualizzazione \
dei documenti:"                                 \
            0 0 0                               \
            $IMPORT_EXPORT_MOUNT_POINTS_LIST    \
            2> $TEMPORARY
        then
            #
            MOUNT_POINT=`cat $TEMPORARY`
            echo "" > $TEMPORARY
            #
            # Try to mount.
            #
            umount "$MOUNT_POINT" 2> /dev/null
            if mount "$MOUNT_POINT"
            then
                #
                # Ok, go on.
                #
                for f in $MOUNT_POINT/*
                do
                    if [ -f $f ]
                    then
                        DOCUMENT_NAME=`basename $f`
                        DOCUMENT_LIST="$DOCUMENT_LIST $DOCUMENT_NAME . "
                    fi
                done
                #
                if dialog                                       \
                        --clear                                 \
                        --title "visualizza un documento contenuto in un \
disco rimovibile"                                               \
                        --menu "Seleziona il file da visualizzare:\n" \
                        0 0 0                                   \
                        $DOCUMENT_LIST                          \
                        2> $TEMPORARY
                then
                    DOCUMENT_NAME=`cat $TEMPORARY`
                    echo "" > $TEMPORARY
                    #
                    # Ok, view.
                    #
                    dialog                                      \
                        --clear                                 \
                        --title "$DOCUMENT_NAME"                \
                        --textbox "$MOUNT_POINT/$DOCUMENT_NAME" \
                        0 0                                     \
                        2> /dev/null
                fi
                #
                umount "$MOUNT_POINT"
            else
                dialog --msgbox "Sono spiacente: mi e\` impossibile \
accedere all'unita\` \"$MOUNT_POINT\"." 0 0
                #
                umount "$MOUNT_POINT"   2> /dev/null
            fi
        fi
    else
        dialog --msgbox "Non e\` possibile eseguire l'operazione." 0 0
    fi
}
#
# Erase an external device.
#
function_erase () {
    #
    local MOUNT_POINT=""
    local NAME=""
    #
    if ! [ "$IMPORT_EXPORT_MOUNT_POINTS_LIST" = "" ]
    then
        if dialog                                       \
            --clear                                     \
            --title "cancella un disco rimovibile"      \
            --menu "Seleziona l'unita\` di memorizzazione esterna \
da cancellare:"                                         \
            0 0 0                                       \
            $IMPORT_EXPORT_MOUNT_POINTS_LIST            \
            2> $TEMPORARY
        then
            #
            MOUNT_POINT=`cat $TEMPORARY`
            echo "" > $TEMPORARY
            #
            # Try to mount.
            #
            umount "$MOUNT_POINT" 2> /dev/null
            if mount "$MOUNT_POINT"
            then
                #
                # Ok, delete
                #
                for d in $MOUNT_POINT/*
                do
                    NAME=`basename $d`
                    if dialog                                   \
                        --clear                                 \
                        --title "cancella un disco rimovibile"  \
                        --yesno "L'unita\` esterna \"$MOUNT_POINT\" \
contiene il file \"$NAME\". Vuoi cancellarlo?"                  \
                        0 0                                     \
                        2> /dev/null
                    then
                        if rm -fr $d
                        then
                            echo -n
                        else
                            dialog --msgbox "Non riesco a cancellare \
\"$d\"." 0 0
                        fi
                    fi
                done
                #
                # Unmount.
                #
                umount "$MOUNT_POINT"
            else
                dialog --msgbox "Sono spiacente: mi e\` impossibile \
accedere all'unita\` \"$MOUNT_POINT\"." 0 0
                #
                umount "$MOUNT_POINT" 2> /dev/null
            fi
        fi
    else
        dialog --msgbox "Non e\` possibile eseguire l'operazione." 0 0
    fi
}
#
# Format an external device.
#
function_format () {
    #
    local FORMAT_DEVICE=""
    #
    #
    #
    if ! [ "$IMPORT_EXPORT_DEVICES_LIST" = "" ]
    then
        if dialog                                                       \
            --clear                                                     \
            --title "inizializza un disco rimovibile"                   \
            --menu "Seleziona l'unita\` di memorizzazione esterna \
da inizializzare (azzerare):"                                           \
            0 0 0                                                       \
            $IMPORT_EXPORT_DEVICES_LIST                                 \
            2> $TEMPORARY
        then
            #
            FORMAT_DEVICE=`cat $TEMPORARY`
            echo "" > $TEMPORARY
            #
            if dialog                                           \
                --clear                                         \
                --title "inizializza un disco rimovibile"       \
                --yesno "Vuoi inizializzare l'unita\` esterna \
\"$FORMAT_DEVICE\"?"                                            \
                0 0                                             \
                2> /dev/null
            then
                #
                # Try to fdformat.
                #
                fdformat "$FORMAT_DEVICE"
                if /sbin/mkfs.msdos -c "$FORMAT_DEVICE"
                then
                    #
                    # Ok, done.
                    #
                    dialog --msgbox "Ho inizializzato l'unita\` \
\"$FORMAT_DEVICE\"." 0 0
                else
                    dialog --msgbox "Sono spiacente: mi e\` impossibile \
eseguire o completare l'operazione per l'unita\` \"$FORMAT_DEVICE\"." 0 0
                fi
            fi
        fi
    else
        dialog --msgbox "Non e\` possibile eseguire l'operazione." 0 0
    fi
}
#
# Export files.
#
function_export () {
    #
    local MOUNT_POINT=""
    local DOCUMENT_LIST=""
    local DOCUMENT_NAME=""
    #
    if ! [ "$IMPORT_EXPORT_MOUNT_POINTS_LIST" = "" ]
    then
        if dialog                                                       \
            --clear                                                     \
            --title "esporta dei documenti in un disco rimovibile"      \
            --menu "Seleziona l'unita\` da usare per l'esportazione dei \
documenti:"                                                             \
            0 0 0                                                       \
            $IMPORT_EXPORT_MOUNT_POINTS_LIST                            \
            2> $TEMPORARY
        then
            #
            MOUNT_POINT=`cat $TEMPORARY`
            echo "" > $TEMPORARY
            #
            # Try to mount.
            #
            umount "$MOUNT_POINT" 2> /dev/null
            if mount "$MOUNT_POINT"
            then
                #
                # Ok, go on: build the "dialog" list.
                #
                for f in $DATA_DIRECTORY/*
                do
                    if [ -f $f ]
                    then
                        DOCUMENT_NAME=`basename $f`
                        DOCUMENT_LIST="$DOCUMENT_LIST $DOCUMENT_NAME . off "
                    fi
                done
                #
                if dialog                                       \
                        --clear                                 \
                        --title "esporta dei documenti in un disco \
rimovibile"                                                     \
                        --checklist "Seleziona o deseleziona i documenti \
da esportare, con l'aiuto della barra spaziatrice:\n"           \
                        0 0 0                                   \
                        $DOCUMENT_LIST                          \
                        2> $TEMPORARY
                then
                    DOCUMENT_LIST=`cat $TEMPORARY`
                    echo "" > $TEMPORARY
                    #
                    # Do something.
                    #
                    if ! [ "$DOCUMENT_LIST" = "" ]
                    then
                        #
                        # Must clean from double quotes.
                        #
                        DOCUMENT_LIST=`echo $DOCUMENT_LIST | sed "s/\"//g"`
                        #
                        # Export.
                        #
                        for n in $DOCUMENT_LIST
                        do
                            if [ -e "$MOUNT_POINT/$n" ]
                            then
                                #
                                # There is already a name like this.
                                #
                                # Check if the documents are the same.
                                #
                                if diff "$DATA_DIRECTORY/$n" \
                                        "$MOUNT_POINT/$n" \
                                        > /dev/null 2> /dev/null
                                then
                                    #
                                    # Files are identical.
                                    #
                                    echo -n
                                else
                                    #
                                    # There is already a name like this and
                                    # the content is different.
                                    #
                                    if dialog                       \
                                        --clear                     \
                                        --title "esporta dei documenti in \
un disco rimovibile"                                            \
                                        --yesno "Nel disco esterno esiste \
gia\` un file con il nome \"$n\". Vuoi rimpiazzarlo con quello che \
stai esportando?"                                               \
                                        0 0                         \
                                        2> /dev/null
                                    then
                                        if cp -f "$DATA_DIRECTORY/$n" \
                                                 "$MOUNT_POINT"
                                        then
                                            dialog --infobox "Ho copiato il \
documento \"$n\" in \"$MOUNT_POINT\"." 0 0
                                        else
                                            dialog --msgbox "Sono spiacente: \
non riesco a copiare il documento \"$n\" in \"$MOUNT_POINT\"." 0 0
                                        fi
                                    fi
                                fi
                            else
                                if cp -f "$DATA_DIRECTORY/$n" "$MOUNT_POINT"
                                then
                                    dialog --infobox "Ho copiato il \
documento \"$n\" in \"$MOUNT_POINT\"." 0 0
                                else
                                    dialog --msgbox "Sono spiacente: \
non riesco a copiare il documento \"$n\" in \"$MOUNT_POINT\"." 0 0
                                fi
                            fi
                        done
                    fi
                fi
                #
                # Unmount.
                #
                umount "$MOUNT_POINT"
                #
            else
                #
                # Sorry: cannot mount.
                #
                dialog --msgbox "Sono spiacente, ma non mi e\` possibile \
accedere all'unita\` \"$MOUNT_POINT\"." 0 0
                #
                umount "$MOUNT_POINT" 2> /dev/null
            fi
        fi
    else
        dialog --msgbox "Non e\` possibile eseguire l'operazione." 0 0
    fi
}
#
# Import an external file.
#
function_import () {
    #
    local MOUNT_POINT=""
    local DOCUMENT_LIST=""
    local DOCUMENT_NAME=""
    #
    if ! [ "$IMPORT_EXPORT_MOUNT_POINTS_LIST" = "" ]
    then
        if dialog                                                       \
            --clear                                                     \
            --title "importa dei documenti da un disco rimovibile"      \
            --menu "Seleziona l'unita\` da usare per l'importazione dei \
documenti:"                                                             \
            0 0 0                                                       \
            $IMPORT_EXPORT_MOUNT_POINTS_LIST                            \
            2> $TEMPORARY
        then
            #
            MOUNT_POINT=`cat $TEMPORARY`
            echo "" > $TEMPORARY
            #
            # Try to mount.
            #
            umount "$MOUNT_POINT" 2> /dev/null
            if mount "$MOUNT_POINT"
            then
                #
                # Ok, go on.
                #
                for f in $MOUNT_POINT/*
                do
                    if [ -f $f ]
                    then
                        DOCUMENT_NAME=`basename $f`
                        DOCUMENT_LIST="$DOCUMENT_LIST $DOCUMENT_NAME . off "
                    fi
                done
                #
                if dialog                                       \
                        --clear                                 \
                        --title "importa dei documenti da un disco \
rimovibile"                                                     \
                        --checklist "Seleziona o deseleziona i documenti \
da importare, con l'aiuto della barra spaziatrice:\n"           \
                        0 0 0                                   \
                        $DOCUMENT_LIST                          \
                        2> $TEMPORARY
                then
                    DOCUMENT_LIST=`cat $TEMPORARY`
                    echo "" > $TEMPORARY
                    #
                    # Do something.
                    #
                    if ! [ "$DOCUMENT_LIST" = "" ]
                    then
                        #
                        # Must clean from double quotes.
                        #
                        DOCUMENT_LIST=`echo $DOCUMENT_LIST | sed "s/\"//g"`
                        #
                        # Import.
                        #
                        for n in $DOCUMENT_LIST
                        do
                            if [ -e "$DATA_DIRECTORY/$n" ]
                            then
                                #
                                # Check if the documents are the same.
                                #
                                if diff "$MOUNT_POINT/$n" \
                                        "$DATA_DIRECTORY/$n" \
                                        > /dev/null 2> /dev/null
                                then
                                    #
                                    # Files are identical.
                                    #
                                    echo -n
                                else
                                    #
                                    # There is already a name like this and
                                    # the content is different.
                                    #
                                    if dialog                           \
                                        --clear                         \
                                        --title "importa dei documenti \
da un disco rimovibile"                                                 \
                                        --yesno "Tu possiedi gia\` un \
documento con il nome \"$n\". Vuoi cancellarlo e sostituirlo con quello \
che stai importando?"                                                   \
                                        0 0                             \
                                        2> /dev/null
                                    then
                                        #
                                        # Must backup and copy.
                                        #
                                        function_backup_document \
                                            "$DATA_DIRECTORY/$n"
                                        #
                                        if cp -f "$MOUNT_POINT/$n" \
                                                 "$DATA_DIRECTORY"
                                        then
                                            dialog --infobox "Ho importato \
il documento \"$n\" eliminando la copia preesistente." 0 0
                                        else
                                            dialog --msgbox "Sono spiacente: \
non riesco a importare il documento \"$n\" da \"$MOUNT_POINT\"." 0 0
                                        fi
                                    fi
                                fi
                            else
                                #
                                # Copy.
                                #
                                if cp -f "$MOUNT_POINT/$n" "$DATA_DIRECTORY"
                                then
                                    dialog --infobox "Ho importato il \
documento \"$n\"." 0 0
                                else
                                    dialog --msgbox "Sono spiacente: \
non riesco a importare il documento \"$n\" da \"$MOUNT_POINT\"." 0 0
                                fi
                            fi
                        done
                    fi
                fi
                #
                # Unmount.
                #
                umount "$MOUNT_POINT"
                #
            else
                #
                # Sorry: cannot mount.
                #
                dialog --msgbox "Sono spiacente, ma non mi e\` \
possibile accedere all'unita\` \"$MOUNT_POINT\"." 0 0
                #
                umount "$MOUNT_POINT" 2> /dev/null
            fi
        fi
    else
        dialog --msgbox "Non e\` possibile eseguire l'operazione." 0 0
    fi
}
#
# Print.
#
function_print () {
    #
    local DOCUMENT_LIST=""
    local DOCUMENT_NAME=""
    #
    for f in $DATA_DIRECTORY/*
    do
        if [ -f $f ]
        then
            DOCUMENT_NAME=`basename $f`
            DOCUMENT_LIST="$DOCUMENT_LIST $DOCUMENT_NAME . "
        fi
    done
    #
    #
    #
    if dialog                           \
        --clear                         \
        --title "stampa un documento" \
        --menu "Seleziona il documento da stampare:" \
        0 0 0 \
        $DOCUMENT_LIST  \
        2> $TEMPORARY
    then
        DOCUMENT_NAME=`cat $TEMPORARY`
        echo "" > $TEMPORARY
        #
        if [ -f "$DATA_DIRECTORY/$DOCUMENT_NAME" ]
        then
            #
            # Ok, print, but fold before.
            #
            cat "$DATA_DIRECTORY/$DOCUMENT_NAME" \
                | fold -s \
                | $PRINTER_FILTER \
                | $PRINTER_COMMAND
        fi
    fi
}
#
# Start X Window System.
#
function_startx () {
    #
    startx
}
#
# Start of program.
#
function_intro
while true
do
    function_menu
done

Appunti di informatica libera 2008 --- Copyright © 2000-2008 Daniele Giacomini -- <appunti2 (ad) gmail·com>


Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome un_esercizio_con_dialog.htm

[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home]

Valid ISO-HTML!

CSS validator!

Gjlg Metamotore e Web Directory