# azionicreazione manualeCreazione delle azioni con la procedura manuale

Esistono due metodi per creare le azioni:

- Usare l'applicazione del desktop Creare azione

- Creare manualmente la definizione dell'azione

Per creare un'azione manualmente è necessario editare un file del database. Questo capitolo spiega come creare manualmente le definizioni delle azioni.

sag.cract.mkr.2
sag.cract.mkr.4
sag.cract.mkr.13
sag.cract.mkr.24
sag.cract.mkr.29
sag.cract.mkr.32
sag.cract.mkr.34
sag.cract.mkr.37
sag.cract.mkr.39
sag.cract.mkr.40

## Vedere anche

- Per una descrizione introduttiva delle azioni, vedere il sag.intac.mkr.1.

- Per informazioni sull'uso di Creare azione, vedere il sag.dtcra.mkr.1.

- Per informazioni sulle definizioni delle azioni, vedere la pagina di spiegazioni `dtactionfile(4)`.

## Casi in cui occorre creare le azioni manualmente

Esistono tre tipi di azioni:

- `COMMAND`

- `MAP`

- `TT_MSG`

L'applicazione Creare azione permette di creare alcuni tipi di azioni `COMMAND` e `MAP`. Tutte le azioni `TT_MSG` devono essere create manualmente.

Per maggiori informazioni, vedere sag.dtcra.mkr.3.

###
Azioni COMMAND

Si definisce azione di comando un'azione che esegue un comando di avvio di un'applicazione o di un'utility, uno script di una shell o un comando del sistema operativo. La definizione di questo tipo di azioni include sempre il comando da eseguire (`EXEC_STRING`).

Le azioni di comando più comuni possono essere create con lo strumento Creare azione. Tuttavia, in presenza di alcune condizioni è necessario crearle manualmente; ad esempio, quando l'azione specifica:

- Più argomenti (file) con una richiesta diversa per ognuno.

- Il richiamo di un'azione — un'azione che avvii altre azioni.

- Un comportamento dipendente dal numero degli argomenti — un'azione che si comporti in modo diverso a seconda del numero di file specificati come argomenti.

- Un host di esecuzione remoto — un'azione che avvii un'applicazione su un sistema diverso da quello in cui si trova la definizione dell'azione.

- Un cambiamento di utente — un'azione che debba essere eseguita con un nome utente diverso (ad esempio, che richieda la password di superutente).

###
Azioni MAP

Si definisce azione di mappatura un'azione che viene “mappata” in un'altra azione anziché specificare direttamente un comando o un messaggio ToolTalk.

La mappatura offre la possibilità di specificare nomi alternativi per le azioni. Ad esempio, il database include un'azione di comando predefinita di nome “Editor delle icone” che avvia l'applicazione corrispondente; esso include però anche un'azione Aprire, la cui applicazione è limitata ai file a mappa di bit e a mappa di pixel (con il campo `ARG_TYPE`), che viene mappata nell'azione Editor delle icone. Questo permette di avviare l'Editor delle icone selezionando un file a mappa di bit o a mappa di pixel dalla Gestione di file e quindi scegliendo Aprire dal menu Selezioni.

Le possibilità di mappatura offerte da Creare azione sono limitate alle azioni Aprire e Stampare. Tutte le altre azioni di mappatura devono essere create manualmente.

###
Azioni TT_MSG (messaggi ToolTalk)

Le azioni `TT_MSG` inviano un messaggio ToolTalk. Tutte le azioni di tipo `TT_MSG` devono essere create manualmente.

## Creazione manuale di un'azione: procedura generale

Questa sezione descrive come creare un file di configurazione per la definizione di un'azione.

### File di configurazione per le azioni

I file di configurazione contenenti le definizioni delle azioni devono rispondere ai seguenti requisiti:

- Il nome del file deve avere il formato nome`.dt`

- I file devono trovarsi nel percorso di ricerca del database (per le azioni e i tipi di dati). Il percorso di ricerca predefinito comprende le directory seguenti:

  Azioni personali | DirectoryIniziale`/.dt/types`
  Azioni di sistema | `/etc/dt/appconfig/types/`lingua
  Azioni predefinite | `/usr/dt/appconfig/types/`lingua. Questa directory non dovrebbe essere utilizzata.

Per informazioni su come modificare il percorso di ricerca delle azioni e dei tipi di dati, vedere sag.datab.mkr.6.

### Come creare un'azione manualmente

1. Aprire un file del database o crearne uno nuovo. Vedere la sezione seguente, sag.cract.mkr.5.

2. Creare la definizione dell'azione usando la sintassi:

       ACTION nome_azione
       {
          TYPE    tipo_azione
        campo_azione
          …
       }

   dove:

   nome_azione | È il nome usato per eseguire l'azione.
   tipo_azione | È `COMMAND` (il tipo predefinito), `MAP` o `TT_MSG.`
   campo_azione | È uno dei campi necessari o opzionali per il tipo di azione specificato. Tutti i campi sono formati da una parola chiave e da un valore. In questo capitolo sono descritti molti dei campi usati per la definizione delle azioni. Per maggiori informazioni, vedere la pagina di spiegazioni dtactionfile(4).

3. Salvare il file.

4. Se si desidera associare all'icona dell'azione un'immagine che la identifichi in modo specifico, creare le icone appropriate. Le posizioni predefinite per le icone sono le seguenti:

   - Icone personali: DirectoryIniziale`/.dt/icons`

   - Icone di sistema: `/etc/dt/appconfig/icons/`lingua. La lingua predefinita è l'inglese (C).

     Per maggiori informazioni, vedere sag.cract.mkr.10.

5. Fare doppio clic su “Ricaricare azioni” nel gruppo Strumenti_desktop.

6. Creare un file per l'azione. Questo file creerà un'icona per la rappresentazione dell'azione nella Gestione di file e nella Gestione di applicazioni. (Se l'azione produce l'avvio dell'applicazione, l'icona verrà detta
   icona dell'applicazione.)

   Per creare il file dell'azione, creare un file eseguibile il cui nome coincida con il nome_azione. Il file potrà essere creato in qualunque directory per la quale si possieda l'autorizzazione di scrittura. Si potrà creare qualsiasi numero di file dell'azione.

### Esempio di creazione di un'azione COMMAND

La procedura seguente crea un'azione personale che avvia un'applicazione fax sul sistema remoto AppServerA. Il comando per l'avvio dell'applicazione fax è:

    /usr/fax/bin/faxcompose [nomefile]

1. Creare il file DirectoryIniziale`/.dt/types/Fax.dt`.

2. Inserire nel file la seguente definizione dell'azione:

       ACTION ComporreFax
       {
               TYPE         COMMAND
               ICON         fax
               WINDOW_TYPE  NO_STDIO
               EXEC_STRING  /usr/fax/bin/faxcompose-c %Arg_1
               EXEC_HOST    AppServerA
               DESCRIPTION  Esegue il programma di composizione fax
       }

   I campi `WINDOW_TYPE` e `EXEC_STRING` descrivono il comportamento dell'azione.

   `WINDOW_TYPE` | La parola chiave `NO_STDIO` specifica che l'azione non deve essere eseguita in una finestra di emulazione di terminale. Vedere sag.cract.mkr.25
   `EXEC_STRING` | La sintassi `%Arg_1%` accetta un file come argomento. Facendo doppio clic sull'icona dell'azione, verrà aperta una finestra vuota per la composizione dei fax. Vedere sag.cract.mkr.13.

3. Salvara il file

4. Usare l'editor delle icone per creare i file grafici seguenti in `DirectoryIniziale/.dt/icons`:

   - `fax.m.pm`, con dimensione 32x32 pixel

   - `fax.t.pm`, con dimensione 16x16 pixel

5. Fare doppio clic su "Ricaricare azioni" nel gruppo `Strumenti_desktop`.

6. Creare un file eseguibile di nome `ComporreFax` in una dirctory per la quale si possieda l'autorizzazione di scrittura (ad esempio, nella directory iniziale).

### Esempio di creazione di un'azione MAP

Si supponga che i file da inviare via fax vengano in genere creati con l'Editor di testo e contengano il tipo di dati TEXTFILE (con nome *`.txt`).

Questa procedura aggiunge un'opzione “Fax” al menu Selezioni associato al tipo di dati.

1. Aprire il file DirectoryIniziale`/.dt/types/Fax.dt` creato nell'esempio precedente.

2. Aggiungere al file la seguente definizione dell'azione di mappatura:

       ACTION Fax
       {
          ARG_TYPE   TEXTFILE
          TYPE       MAP
          MAP_ACTION ComporreFax
       }

3. Salvare il file.

4. Copiare la definizione degli attributi per il tipo di dati TEXTFILE da /`usr/dt/appconfig/types/`lingua`/dtpad.dt` nel nuovo file DirectoryIniziale`/.dt/types/textfile.dt`. Aggiungere l'azione Fax al campo `ACTIONS`.

       DATA_ATTRIBUTES TEXTFILE
       {
          ACTIONS  Open,Print,Fax
          ICON     Dtpenpd
          …
       }

5. Salvare il file.

6. Aprire la Gestione di applicazioni e fare doppio clic su “Ricaricare azioni” nel gruppo Strumenti_desktop.

### Come ricaricare il database delle azioni e dei tipi di dati

Perché la definizioni delle azioni nuove o modificate abbiano effetto, è necessario che il desktop rilegga il database.

- Aprire il gruppo Strumenti_desktop e fare doppio clic su “Ricaricare azioni”.

- Oppure, eseguire il comando:

  `dtaction ReloadActions`

ReloadActions è il nome dell'azione rappresentata dall'icona “Ricaricare azioni”.

Il database delle azioni viene riletto anche quando l'utente:

- Effettua il login

- Riavvia la Gestione dello spazio di lavoro

- Salva un'azione nella finestra di Creare azione scegliendo Salvare dal menu File

###
Creazione del file (icona) dell'azione

Si definisce
file dell'azione il file creato per fornire una rappresentazione visiva dell'azione nella Gestione di file o nella Gestione di applicazioni.

#### File delle azioni (detti anche icone delle azioni o icone delle applicazioni) nella Gestione di applicazioni

Poiché l'icona di questo file rappresenta un'azione, essa viene detta anche
icona dell'azione. Se l'azione produce l'avvio di un'applicazione, la stessa icona può essere chiamata icona dell'applicazione.

Facendo doppio clic sull'icona viene eseguita l'azione rappresentata. L'icona dell'azione può fungere anche da area di rilascio.

#### Come creare il file (l'icona) dell'azione

1. Creare un file eseguibile con lo stesso nome dell'azione
   . Il contenuto del file è irrilevante.

Ad esempio, se la definizione dell'azione fosse la seguente:

    ACTION App_preferita
    {
      EXEC_STRING  Appp -file %Arg_1%
      DESCRIPTION  Avvia App_preferita
      ICON         App_pref
    }

il file dell'azione sarà un file eseguibile di nome `App_preferita`. Nella Gestione di file e nella Gestione di applicazioni, il file `App_preferita` userà l'immagine dell'icona `App_pref.dimensione.tipo`. Facendo doppio clic sull'icona di `App_preferita` verrà eseguita la stringa di esecuzione dell'azione, e il testo di aiuto relativo all'icona sarà il contenuto del campo
`DESCRIPTION` (`Avvia App_preferita`).

####
Etichette delle azioni

Se la definizione dell'azione include il campo `LABEL`, il file dell'azione comparirà nella Gestione di file e nella Gestione di applicazioni con l'etichetta specificata da questo campo anziché con il nome effettivo del file (nome_azione). Ad esempio, se la definizione dell'azione contiene quanto segue:

    ACTION App_preferita
    {
       LABEL Applicazione preferita
       …
    }

l'icona dell'azione comparirà con l'etichetta “Applicazione preferita”.

### Scelta dell'icona da utilizzare per un'azione

Usare il campo `ICON` per specificare l'icona da utilizzare nella Gestione di file e nella Gestione di applicazioni per rappresentare l'azione.

Se non viene specificata alcuna icona, il sistema userà l'immagine predefinita per i file delle
azioni, `/usr/dt/appconfig/icons/`lingua`/Dtactn.*`.

#### Icona predefinita per le azioni

L'icona predefinita per le azioni può essere modificata usando la risorsa:

    *actionIcon: file_icona

dove file_icona può essere un nome base o un percorso assoluto.

Il valore del campo `ICON` può essere:

- Il nome base di un file.

  Con il termine
  nome base si intende il nome del file contenente l'immagine dell'icona esclusi i suffissi per la dimensione (`m` e `t`) e per il tipo di immagine (`bm` e `pm`). Ad esempio, per i file `IconaGiochi.m.pm` e `IconaGiochi.t.pm` il nome base sarà `IconaGiochi`.

  Se si utilizza il nome base, i file delle icone devono trovarsi in directory incluse nel percorso di ricerca delle icone:

  - Per le icone personali: DirectoryIniziale`/.dt/icons`

  - Per le icone di sistema: `/etc/dt/appconfig/icons/`lingua

- Il percorso assoluto del file dell'icona, incluso il nome completo del file.

  L'uso del percorso assoluto è necessario solo se il file dell'icona non si trova in una directory del percorso di ricerca. Ad esempio, se il file `IconaGiochi.m.pm` si trova nella directory `/doc/progetti`, che non è inclusa nel percorso di ricerca delle icone, il valore del campo `ICON` dovrà essere `/doc/progetti/IconaGiochi.m.pm`.

La sag.cract.mkr.11 indica le dimensioni con cui creare le icone e i nomi da utilizzare per i rispettivi file.

### Nomi e dimensioni per le icone delle azioni

`Dimensioni in pixel` | `Nome del file a mappa di bit` | `Nome del file a mappa di pixel`
48 x 48 | nome`.l.bm` | nome`.l.pm`
32 x 32 | nome`.m.bm` | nome`.m.pm`
16 x 16 | nome`.t.bm` | nome`.t.pm`

### Come modificare la definizione di un'azione esistente

È possibile modificare qualsiasi azione disponibile sul sistema, incluse le azioni predefinite.

Prestare molta attenzione nel modificare il database delle azioni predefinite. Queste azioni sono state realizzate specificamente per applicazioni del desktop.

1. Localizzare la definizione dell'azione da modificare.

   Le directory predefinite per le definizioni delle azioni sono le seguenti:

   - Azioni predefinite: `/usr/dt/appconfig/types/`lingua

   - Azioni di sistema: `/etc/dt/appconfig/types/`lingua

   - Azioni personali: DirectoryIniziale`/.dt/types`

     Il sistema in uso potrebbe usare altre directory. Per visualizzare un elenco delle directory utilizzate dal sistema per le azioni, eseguire il comando:

     `dtsearchpath -v`

     Il sistema in uso utilizza le directory elencate sotto
     `DTDATABASESEARCHPATH`.

2. Se necessario, copiare il testo della definizione dell'azione in un file nuovo o esistente in una delle directory seguenti:

   - Azioni di sistema: `/etc/dt/appconfig/types/`lingua

   - Azioni personali: DirectoryIniziale`/.dt/types`

     Creare una copia delle azioni predefinite, evitando di editare i file della directory `/usr/dt/appconfig/types/`lingua.

3. Editare la definizione dell'azione. Al termine, salvare il file.

4. Fare doppio clic su “Ricaricare azioni” nel gruppo Strumenti_desktop.

### Precedenza nelle definizioni delle azioni

Quando un utente richiama un'azione, il sistema ricerca nel database un'azione con un nome corrispondente. Se sono presenti più azioni con quel nome, il sistema utilizzerà determinate regole di precedenza per decidere quale utilizzare.

- Se non specificato diversamente, la precedenza si basa sulla posizione (directory) in cui si trova la definizione. L'elenco seguente riporta l'ordine di precedenza utilizzato:

  - Azioni personali (DirectoryIniziale`/.dt/types`)

  - Azioni del sistema locale (`/etc/dt/appconfig/types/`lingua)

  - Azioni di un sistema remoto (nomehost:`/etc/dt/appconfig/types/`lingua). Gli host remoti su cui viene effettuata la ricerca sono quelli inclusi nel percorso di ricerca delle applicazioni.

  - Azioni predefinite (`/usr/dt/appconfig/types/`lingua)

- All'interno di ogni directory, i file `*.dt` vengono letti in ordine alfabetico.

- Le azioni limitate da `
  ARG_CLASS`, `
  ARG_TYPE`, `
  ARG_MODE` o `
  ARG_COUNT` hanno la precedenza sulle azioni non limitate. (L'impostazione predefinita per questi quattro campi è `*`.)

  Quando vengono applicate due o più di queste limitazioni, l'ordine di precedenza è il seguente:

  - `ARG_CLASS`

  - `ARG_TYPE`

  - `ARG_MODE`

  - `ARG_COUNT`

    Quando esistono due o più limitazioni di tipo `ARG_COUNT`, l'ordine di precedenza è il seguente:

  - Valore intero specifico n

  - `<`n

  - `>`n

  - `*`

Ad esempio, si considerino le seguenti parti della definizione dell'azione ModificaIllustrazioni:

    ACTION ModificaIllustrazioni
    # ModificaIllustrazioni-1
    {
       ARG_TYPE   XWD
       …
    }

    ACTION ModificaIllustrazioni
    # ModificaIllustrazioni-2
    {
       ARG_COUNT  0
       …
    }

    ACTION ModificaIllustrazioni
    # ModificaIllustrazioni-3
    {
       ARG_TYPE   *
       …
    }

Facendo semplicemente doppio clic sull'icona dell'azione ModificaIllustrazioni, senza specificare alcun argomento, verrà eseguito ModificaIllustrazioni-2, perché `ARG_COUNT 0` ha la precedenza. Specificando come argomento un file di tipo XWD verrà usato ModificaIllustrazioni-1, poiché è specificato l'`ARG_TYPE` XWD. Specificando come argomento un file di qualsiasi altro tipo verrà eseguito ModificaIllustrazioni-3.

## Creazione di una stringa di esecuzione per un'azione COMMAND

Un'azione di tipo `
COMMAND` deve contenere necessariamente almeno due campi: `ACTION` ed `EXEC_STRING`.

    ACTION nome_azione
    {
        EXEC_STRING stringa_di_esecuzione
    }

La stringa di esecuzione è la parte più importante della definizione di un'azione `COMMAND`. Essa utilizza una sintassi simile a quella usata per le righe comandi nelle finestre di terminale, ma include alcuni componenti aggiuntivi per la gestione dei file e delle stringhe usate come argomenti.

###
Caratteristiche generali delle stringhe di esecuzione

Le stringhe di esecuzione possono includere:

- Argomenti in forma di file o di altro tipo

- Componenti della sintassi delle shell

- Nomi o percorsi assoluti di file eseguibili

#### Argomenti delle azioni

Un argomento è un'informazione richiesta da un comando o da un'applicazione per essere eseguita correttamente. Ad esempio, si consideri la riga comandi usata per aprire un file nell'Editor di testo:

    dtpad nomefile

In questo comando, nomefile è un argomento del comando `dtpad`.

Come i comandi e le applicazioni, anche le azioni possono avere argomenti. Un'azione `COMMAND` può usare due tipi di dati:

- File

- Stringhe

#### Uso di una shell nelle stringhe di esecuzione

Le stringhe di esecuzione vengono eseguite direttamente, non attraverso una shell. È possibile, tuttavia, specificare una stringa che preveda l'uso di una shell.

Ad esempio:

    EXEC_STRING \
            /bin/sh -c \
            'tar -tvf %(File)Arg_1% 2>&1 | \${PAGER:-more};\
            echo “\\n*** Scegliere Chiudere per uscire ***“'

#### Nome o percorso assoluto dell'eseguibile

Se l'applicazione si trova in una directory inclusa nella variabile
PATH si può usare semplicemente il nome del file eseguibile. Se si trova in un'altra posizione occorre specificare il
percorso assoluto dell'eseguibile.

### Creazione di un'azione che non utilizzi argomenti

Usare per l'`EXEC_STRING` la stessa sintassi richiesta per avviare l'applicazione da una riga comandi.

#### Esempi

- Questa stringa di esecuzione fa parte di un'azione che avvia il client X `xcutsel`.

  `EXEC_STRING xcutsel`

- Questa stringa di esecuzione avvia il client `xclock` come orologio digitale. La riga comandi include un'opzione ma non richiede argomenti.

  `EXEC_STRING xclock -digital`

### Creazione di un'azione che accetti il rilascio di un file

Specificare l'argomento usando la seguente sintassi:

    %Arg_n%

oppure

    %(File)Arg_n%

Il componente `(File)` è opzionale, poiché nell'impostazione predefinita gli argomenti forniti ad `Arg_`n vengono interpretati automaticamente come file. (Per informazioni sull'uso della sintassi `%(String)Arg_`n`%`, vedere sag.cract.mkr.19.)

Questa sintassi permette di rilasciare un file di dati sull'icona dell'azione per avviare l'azione usando quel file come argomento. Essa sostituisce l'argomento n nella riga comandi. Il file può essere sia locale che remoto.

#### Esempi

- Questa stringa di esecuzione esegue il comando `wc -w` usando un file rilasciato come parametro.

  `EXEC_STRING wc -w %Arg_1%`

- Questo esempio mostra una parte della definizione di un'azione che accetta solo directory come argomenti. Rilasciando una directory sull'icona dell'azione, viene visualizzato l'elenco di tutti i file della directory che possiedono le autorizzazioni di lettura e scrittura.

      ACTION Elenco_file_scrivibili
      {
              ARG_TYPE FOLDER
              EXEC_STRING /bin/sh -c  'ls  -l  %Arg_1%  |  grep rw-'
              …
      }

### Creazione di un'azione che richieda un file come argomento

Inserire la richiesta dell'argomento nella stringa di esecuzione usando la seguente sintassi:

    %(File)"richiesta"%

Questa sintassi crea un'azione che chiede di specificare il un nome di un file quando l'utente fa doppio clic sull'icona.

Ad esempio, questa stringa di esecuzione visualizza un riquadro di dialogo che richiede un argomento per il comando `wc -w`:

    EXEC_STRING wc -w %(File)"Contare le parole del file:"%

### Creazione di un'azione che accetti il rilascio di un file o che richieda un file

Inserire la richiesta dell'argomento nella stringa di esecuzione usando la seguente sintassi:

    %Arg_n“richiesta“%

oppure

    %(File)Arg_n“richiesta“%

Questa sintassi produce un'azione che:

- Accetta come argomento un file rilasciato sull'icona dell'azione.

- Visualizza un riquadro di dialogo che chiede di specificare il un nome di un file quando l'utente fa doppio clic sull'icona.

Ad esempio, questa stringa di esecuzione esegue il comando `lp -oraw` sul file rilasciato sull'icona dell'azione. Se l'azione viene avviata facendo doppio clic sull'icona, compare un riquadro di dialogo che chiede di inserire il nome del file.

    EXEC_STRING lp -oraw %Arg_1"File da stampare:"%

### Creazione di un'azione che richieda un argomento diverso da un file

Per specificare un parametro diverso da un file, usare la sintassi:

    %"richiesta"%

oppure

    %(String)"richiesta"%

Il componente `(String)` è opzionale, poiché nell'impostazione predefinita il testo tra virgolette viene interpretato automaticamente come una stringa. Questa sintassi visualizza un riquadro di dialogo che richiede un parametro diverso da un file; non usare questa sintassi per richiedere il nome di un file.

Ad esempio, questa stringa di esecuzione esegue il comando `xwd` e richiede di aggiungere un valore ad ogni pixel:

    EXEC_STRING xwd -add %"Aggiungere un valore:"% -out %Arg_1"File:"%

### Interpretazione di un argomento file come stringa

Usare per l'argomento la seguente sintassi:

    %(String)Arg_n%

Ad esempio, questa stringa di esecuzione stampa un file usando come intestazione il nome del file con il comando `lp -t` intestazione nomefile.

    EXEC_STRING lp -t%(String)Arg_1% %(File)Arg_1"File da stampare:"%

### Aggiunta dell'utilizzo di una shell in un'azione

Specificare l'uso della shell nella stringa di esecuzione:

    /bin/sh -c 'comando'
    /bin/ksh -c 'comando'
    /bin/csh -c 'comando'

#### Esempi

- Questa stringa di esecuzione produce un'azione che utilizza il piping di una shell.

    EXEC_STRING /bin/sh -c 'ps | lp'

- La stringa di esecuzione seguente è più complessa, poiché richiede l'uso di una shell ed accetta un file come argomento.

    EXEC_STRING /bin/sh -c 'tbl %Arg_1“Pagina man:“% | troff -man'

- Questa stringa di esecuzione richiede come argomento un file in formato compresso. L'azione decomprime il file e lo stampa usando `lp -oraw`.

    EXEC_STRING  /bin/sh -c 'cat %Arg_1 “File da stampare:“% | \
                 uncompress | lp -oraw'

- Questa stringa di esecuzione esegue uno script di una shell.

    EXEC_STRING /usr/local/bin/AvviaClientGnu

### Creazione di azioni COMMAND che accettino più argomenti (file)

Le azioni possono gestire più file specificati come argomenti in tre modi:

- L'azione viene eseguita ripetutamente, una volta per ogni argomento. Quando l'`EXEC_STRING` contiene la specifica di un unico argomento e l'utente rilascia un gruppo di due o più file sull'icona dell'azione, l'azione viene eseguita separatamente per ognuno dei file accettati come argomenti.

  Ad esempio, se vengono forniti più argomenti per un'azione con la seguente definizione:

      ACTION VisualizzaImmagine
      {
         EXEC_STRING xwud -in %Arg_1%
         …
      }

  l'azione VisualizzaImmagine verrà eseguita ripetutamente su tutti i file.

- L'azione può usare due o più argomenti non intercambiabili. Ad esempio, l'azione:

  `xsetroot -cursor filecursore filemaschera`

  richiede due file diversi in un ordine specifico.

- L'azione può eseguire lo stesso comando sul complesso dei file specificati come argomento. Ad esempio, l'azione:

  `pr file [file …]`

  stamperà uno o più file in un unico lavoro di stampa.

#### Creazione di un'azione con argomenti non intercambiabili

Usare una delle seguenti convenzioni di sintassi:

- Per fare in modo che l'azione richieda i nomi dei file, usare questa sintassi per ognuno degli argomenti:

  `%(File)“richiesta”%`

  Usare una stringa di richiesta diversa per ogni argomento.

  Ad esempio, questa stringa di esecuzione richiede due file.

  `EXEC_STRING xsetroot -cursor %(File)“Bitmap del cursore:”% \ %(File)“Bitmap della maschera:”%`

- Per fare in modo che l'azione accetti il rilascio dei file, usare questa sintassi per ognuno degli argomenti:

  `%Arg_n%`

  usando valori diversi di n per ogni argomento. Ad esempio:

  `EXEC_STRING diff %Arg_1% %Arg_2%`

#### Creazione di un'azione con argomenti intercambiabili

Usare una delle seguenti convenzioni di sintassi:

- Per creare un'azione che accetti il rilascio dei file ed esegua un comando nella forma

  comando file 1 file 2 …, usare questa sintassi per i file di argomento:

  `%Args%`

- Per creare un'azione che accetti il rilascio di due o più file, o che facendo doppio clic sull'icona visualizzi una richiesta per un singolo file, usare questa sintassi per gli argomenti:

  `%Arg_1“richiesta”% %Args%`

  L'azione eseguirà il comando nella forma: comando file 1 file 2 ….

##### Esempi

- Questa stringa di esecuzione crea un'azione che esegue il comando

    pr file1 file2

accettando più file come argomenti.

    EXEC_STRING pr %Args%

- Questa stringa di esecuzione crea un'azione simile a quella dell'esempio precedente, ma in questo caso facendo doppio clic sull'icona (senza specificare argomenti) viene visualizzata una richiesta.

    EXEC_STRING pr %Arg_1"File da stampare:"% %Args%

#### Creazione di un'azione che accetti il rilascio di più file

Per fare in modo che l'azione accetti il rilascio di più file ed esegua un comando nella forma:

    comando file 1file
    2 …

usare la sintassi:

    %Args%

##### Esempi

- Questa stringa di esecuzione esegue uno script di nome Controllo su più file:

    EXEC_STRING   /usr/local/bin/Controllo \
                  %Arg_1“File da controllare:“% %Args%

- Questa stringa di esecuzione esegue il comando `lp -oraw` su più file:

    EXEC_STRING lp -oraw %Arg_1“File da stampare:“% %Args%

## Supporto di finestre ed emulatori di terminale per le azioni COMMAND

Le azioni `COMMAND` supportano le finestre del desktop in diversi modi.

- Se l'applicazione dispone di una propria finestra, l'azione può essere scritta in modo da non richiedere alcun supporto aggiuntivo. Questa opzione viene usata anche quando un'azione esegue un comando che non richiede un input diretto dell'utente e non produce alcun output.

- Se l'applicazione deve essere eseguita in una finestra di emulazione di terminale, l'azione può essere scritta in modo da aprire una finestra e quindi eseguirvi l'applicazione. Esistono diverse opzioni per la scelta del terminale.

### Indicazione del supporto di finestre per l'azione

Usare il campo `WINDOW_TYPE` per specificare il tipo di supporto delle finestre richiesto dall'azione.

TIPO DI FINESTRA | Supporto di finestre fornito
`NO_STDIO` | Nessuno. Usare `NO_STDIO` se l'applicazione ha una propria finestra, o se il comando non produce alcun output visibile.
`PERM_TERMINAL` | Finestra di emulazione di terminale permanente. L'azione apre una finestra di terminale che rimane aperta fino a quando non viene chiusa esplicitamente, e in cui l'utente ha la possibilità di inserire informazioni. Usare questa opzione con i comandi che accettano un input, producono un output e quindi terminano (ad esempio, `ls` directory).
`TERMINAL` | Finestra di emulazione di terminale temporanea. L'azione apre una finestra di terminale che si chiude non appena il comando è completato. Usare questa opzione con i comandi eseguiti a schermo intero (ad esempio, `vi`).

### Indicazione di opzioni per l'emulatore di terminale

Usare il campo `TERM_OPTS` nella definizione dell'azione per specificare opzioni precise per il comando di avvio dell'emulatore di terminale.

Ad esempio, l'azione seguente richiede di specificare l'host di esecuzione:

    ACTION TermSuSistemaScelto
    {
       WINDOW_TYPE    PERM_TERMINAL
       EXEC_HOST      %(String)"Terminale remoto su:"%
       TERM_OPTS      -title %(String)"Titolo della finestra:"%
       EXEC_STRING    $SHELL
    }

### Modifica dell'emulatore di terminale predefinito

L'emulatore di terminale predefinito per le azioni è `dtterm`. È tuttavia possibile impostare un diverso emulatore di terminale da usare quando l'azione non specifica il tipo richiesto in modo esplicito.

La riga comandi dell'emulatore di terminale usato dalle azioni deve comprendere le seguenti opzioni:

- `-title` titolo_finestra

- `-e` comando

L'emulatore di terminale predefinito per le azioni viene determinato da due risorse:

- La risorsa `localTerminal` specifica l'emulatore di terminale usato dalle applicazioni locali.

  `*localTerminal: terminale`

  Ad esempio:

  *localTerminal: xterm

- La risorsa `remoteTerminal` specifica l'emulatore di terminale usato dalle applicazioni remote.

    *remoteTerminal: host:terminale [,host:terminale…]

Ad esempio:

    *remoteTerminal: sysibm1:/usr/bin/xterm,syshp2:/usr/bin/yterm

##
Restrizione delle azioni a determinati argomenti

La restrizione di un'azione a un determinato tipo di argomenti la rende più precisa. Ad esempio, può essere utile restringere un'azione che richiami un visualizzatore di file PostScript specificando che l'azione può accettare come argomenti solo file PostScript; con la restrizione, l'azione restituirà un messaggio di errore se verrà specificato un file non PostScript.

Si possono restringere le azioni in base ai seguenti fattori:

- Il tipo di dati del file da specificare come argomento.

- Il numero degli argomenti — ad esempio, nessun argomento oppure uno o più argomenti. Questo permette di ottenere un comportamento diverso quando si fa doppio clic sull'icona e quando si rilasciano due o più file.

- La modalità di lettura/scrittura dell'argomento.

### Restrizione di un'azione a un tipo di dati specifico

Usare il campo `ARG_TYPE` per specificare i tipi di dati accettati dall'azione. Usare il nome dell'attributo dei dati.

È anche possibile inserire un elenco di tipi di dati separati da virgole.

Ad esempio, nella seguente definizione si presume che sia stato creato un tipo di dati Gif.

    ACTION Aprire_Gif
    {
       TYPE           COMMAND
       LABEL          "Visualizzazione Gif"
       WINDOW_TYPE    NO_STDIO
       ARG_TYPE       xgif
       DESCRIPTION    Visualizza file gif
       EXEC_STRING    xgif
    }

### Restrizione di un'azione in base al numero degli argomenti

Usare il campo `ARG_COUNT` per specificare il numero di argomenti che l'azione può accettare. Sono ammessi i seguenti valori:

`*` | (Valore predefinito) Qualsiasi numero di argomenti. Gli altri valori hanno la precedenza su `*`.
n | Qualsiasi intero non negativo, incluso lo zero.
`>`n | Più di n argomenti.
`<`n | Meno di n argomenti.

Una delle funzioni per cui può essere utilizzato `ARG_COUNT` è quella di ottenere un comportamento diverso dell'azione a seconda che l'utente faccia doppio clic sulla sua icona o vi rilasci un file. Vedere la sezione seguente, sag.cract.mkr.31.

### Come ottenere un comportamento diverso al doppio clic sull'icona e al rilascio di un file

La procedura descritta qui di seguito permette di creare un'azione che accetti il rilascio di un file ma non richieda alcun argomento facendo doppio clic sull'icona.

1. Inserire nella definizione dell'azione la funzionalità relativa al doppio clic.

   Usare il campo `ARG_COUNT` per specificare `0` argomenti. Usare per `EXEC_STRING` una sintassi che non accetti il rilascio degli argomenti.

2. Creare una seconda definizione per la funzionalità di rilascio.

   Usare il campo `ARG_COUNT` per specificare `>0` argomenti. Usare per `EXEC_STRING` una sintassi che accetti il rilascio di un file.

Ad esempio, si supponga di poter usare le due righe comandi seguenti per avviare un editor di nome `vedit`:

- Per avviare l'editor senza specificare argomenti:

  `vedit`

- Per avviare l'editor specificando come argomento un file da aprire in modalità di sola lettura:

  `vedit -R` nomefile

Le due azioni seguenti creano le funzionalità di doppio clic e rilascio per un'azione di nome Vedit. La prima azione ha la precedenza quando si cerca una corrispondenza nel database, poiché il campo `ARG_COUNT` `0` è più specifico rispetto al valore predefinito `ARG_COUNT` `*` che verrà usato per il rilascio.

    # Funzionalità del doppio clic
    ACTION Vedit
    {
       TYPE          COMMAND
       ARG_COUNT     0
       WINDOW_TYPE   PERM_TERMINAL
       EXEC_STRING   vedit
    }

    # Funzionalità di rilascio
    ACTION Vedit
    {
       TYPE           COMMAND
       WINDOW_TYPE    PERM_TERMINAL
       EXEC_STRING    vedit -R %Arg_1%
    }

### Restrizione di un'azione in base alla modalità dell'argomento

Si può utilizzare il campo `ARG_MODE` per specificare la modalità di lettura/scrittura dell'argomento. I valori ammessi sono:

`*` | (Valore predefinito) Qualsiasi modalità
`!w` | Non-scrivibile
`w` | Scrivibile

## Creazione di azioni che eseguano applicazioni su sistemi remoti

Nel descrivere l'esecuzione remota delle azioni, si farà spesso riferimento ai due termini seguenti:

host del database | Il sistema in cui si trova la definizione dell'azione
host di esecuzione | Il sistema su cui viene avviato l'eseguibile

In genere, le azioni e le relative applicazioni si trovano sullo stesso sistema; in questi casi non è richiesta alcuna sintassi particolare, perché l'host di esecuzione predefinito per le azioni è l'host del database.

Tuttavia, quando l'host di esecuzione non coincide con l'host del database, la definizione dell'azione deve specificare la posizione in cui eseguire il comando contenuto nella stringa di esecuzione.

La possibilità di collocare le azioni e le applicazioni su sistemi diversi è una caratteristica dell'architettura client/server del desktop. Per una trattazione più approfondita delle applicazioni di rete, vedere sag.clsrv.mkr.15.

### Creazione di un'azione che esegua un'applicazione remota

Usare il campo `EXEC_HOST` nella definizione dell'azione per specificare la posizione dell'applicazione.

I valori ammessi per `EXEC_HOST` sono:

`%DatabaseHost%` | L'host che contiene la definizione dell'azione.
`%LocalHost%` | L'host da cui viene avviata l'azione (il server della sessione).
`%DisplayHost%` | L'host che esegue il server X (non previsto per i terminal X).
`%SessionHost%` | L'host su cui viene eseguita la Gestione del login.
nomehost | L'host specificato. Usare questo valore per gli ambienti in cui l'azione deve essere sempre eseguita su un host particolare.
`%“`richiesta`“%` | Richiesta di inserimento del nome host visualizzata ad ogni esecuzione dell'azione.

Il valore predefinito è `%DatabaseHost%`, `%LocalHost%`.
Con questa impostazione, se si omette il campo `EXEC_HOST` l'azione cerca inizialmente di eseguire il comando sull'host che contiene la sua definizione. Se l'operazione non riesce, l'azione cerca di eseguire il comando sul server della sessione.

#### Esempi

- Questo campo specifica l'host `ddsyd`:

    EXEC_HOST ddsyd

- Questo campo richiede un nome host:

    EXEC_HOST %"Host contenente l'applicazione:"%

- Questo campo specifica che l'azione cercherà inizialmente di eseguire l'applicazione sull'host contenente la definizione dell'azione. Se non dovesse riuscire, essa cercherà di eseguire l'applicazione sull'host `ddsyd`.

    EXEC_HOST %DatabaseHost%, ddsyd

## Uso delle variabili nelle definizioni delle azioni e dei tipi di dati

Le definizioni delle azioni e dei tipi di dati possono comprendere variabili in forma di stringa e variabili d'ambiente.

### Uso di variabili stringa in un'azione

La definizione di una variabile stringa ha effetto dal punto della definizione fino alla fine del file. Non esistono variabili stringa globali per il database.

Se una variabile stringa e una variabile d'ambiente hanno lo stesso nome, la variabile stringa avrà la precedenza.

#### Come definire una variabile stringa

1. Usare la sintassi:

   `set nome_variabile=valore`

I nomi delle variabili possono contenere qualsiasi carattere alfanumerico e il carattere di sottolineatura (`_`). Ogni definizione deve occupare una riga diversa.

Ad esempio:

    set Server_applicazioni_remoto=sysapp
    set Server_file_remoto=sysdata

#### Come impostare un riferimento a una variabile stringa

1. Usare la sintassi:

   `$[{]nome_variabile[}]`

Ad esempio:

    EXEC-HOST $Server_applicazioni_remoto
    CWD /net/${Server_file_remoto}/doc/project

### Uso delle variabili d'ambiente nelle azioni e nei tipi di dati

1. Per impostare un riferimento a una variabile d'ambiente, usare la sintassi:

   `$[{]variabile[}]`.

La variabile viene espansa (cioè sostituita dal suo valore) al momento del caricamento del database. Se una variabile stringa e una variabile d'ambiente hanno lo stesso nome, la variabile stringa avrà la precedenza.

Ad esempio, questa stringa di esecuzione stampa un file usando il nome di login dell'utente come intestazione.

    EXEC-STRING lp -t$LOGNAME %(File)Arg_1%

## Avvio di un'azione dalla riga comandi

Il comando del desktop `dtaction` permette di eseguire le azioni da una riga comandi. Questo comando può essere usato per eseguire le azioni da:

- Script

- Altre azioni

- Una riga comandi di un emulatore di terminale

### Sintassi di dtaction

`dtaction [-user nome_utente] [-execHost nomehost] nome_azione [argomento [argomento]…]`

`-user` nome_utente | Permette di eseguire l'azione operando con un nome utente diverso. Se `dtaction` viene richiamato da un utente diverso da quello specificato con nome_utente, viene visualizzata la richiesta di una parola chiave.
-`execHost` nomehost | Solo per le azioni `COMMAND`; specifica l'host su cui verrà eseguito il comando.
argomento | Argomento/i da usare per l'azione, in genere file.

Il client `dtaction` dispone di altre opzioni per la riga comandi. Per maggiori informazioni, vedere la pagina di spiegazioni `dtaction(1)`.

### Creazione di un'azione che esegua un'altra azione

Usare `dtaction` nella `EXEC_STRING` dell'azione.

Ad esempio, l'azione seguente utilizza un'azione predefinita di nome Spell (presentata come “Controllare ortografia” nella Gestione di applicazioni). La nuova azione eseguirà l'Editor di testo e l'azione Spell, visualizzando gli errori riscontrati in una finestra di emulazione di terminale separata.

    ACTION ApriECorreggi
    {
        WINDOW_TYPE    NO_STDIO
        EXEC_STRING    /bin/sh -c 'dtaction Spell \
                       %Arg_1“File:“%; dtpad %Arg_1%'
    }

### Creazione di un'azione che venga eseguita con un nome utente diverso

Usare la seguente sintassi nella `EXEC_STRING`:

    EXEC_STRING dtaction -user nome_utente nome_azione [argomento]

Il nuovo utente (nome_utente) deve avere accesso di visualizzazione al sistema attraverso uno dei seguenti meccanismi:

- Autorizzazione di lettura per il file `.Xauthority` dell'utente specificato al login

- Oppure, autorizzazione xhost

Ad esempio, le due azioni seguenti offrono la possibilità di diventare superutente e di editare un file di impostazioni predefinite delle applicazioni.

    ACTION ImpPred
    {
          WINDOW_TYPE    NO_STDIO
          EXEC_STRING    /usr/dt/bin/dtaction -user root \
                         ModificaImpPred %Arg_1“File:“%
    }

    ACTION ModificaImpPred
    {
          WINDOW_TYPE    TERMINAL
          EXEC_STRING    /bin/sh -c 'chmod +w %Arg_1%; \
                         vi %Arg_1%; chmod -w %Arg_1%'
    }

## Creazione di azioni in lingue diverse

Il percorso di ricerca per i tipi di dati include directory dipendenti dalla lingua. Il desktop utilizza il valore di LANG per determinare le posizioni in cui cercare le definizioni dei tipi di dati.

### Posizione delle azioni localizzate

Le definizioni delle azioni localizzate devono trovarsi nelle directory corrette del percorso di ricerca delle azioni.

Il percorso di ricerca predefinito comprende le directory seguenti:

- Azioni personali: DirectoryIniziale`/.dt/types`

- Azioni di sistema: `/etc/dt/appconfig/types/`lingua

- Azioni predefinite: `/usr/dt/appconfig/types/`lingua

### Come tradurre un'azione esistente

1. Creare un file nella directory appropriata dipendente dalla lingua (ad esempio, in `/etc/dt/appconfig/types/it`).

2. Copiare la definizione dell'azione nel file di configurazione dipendente dalla lingua.

   Ad esempio, si potrà copiare la definizione di un'azione da

   `radice_app/dt/appconfig/types/C/file.dt`

   in

   `radice_app/dt/appconfig/types/it/nuovofile.dt`

3. Aggiungere un campo `LABEL` o modificare il campo `LABEL` esistente.

   `LABEL stringa`

   La Gestione di applicazioni e la Gestione di file useranno questa stringa per identificare l'icona dell'azione.

4. Adattare i campi seguenti nella definizione dell'azione:

   - Per le icone tradotte: `ICON`

   - Per i testi di aiuto tradotti: `DESCRIPTION`

   - Per le richieste tradotte: tutto il testo tra virgolette nella `EXEC_STRING`

## Creazione di azioni per le applicazioni ToolTalk

Le informazioni seguenti si riferiscono solo alle applicazioni che supportano i messaggi ToolTalk.

Creare un'azione di tipo `TT_MSG` che invii un messaggio ToolTalk.

    ACTION nome_azione
    {
        TYPE TT_MSG
        …
    }

### Campi addressing e disposition

- Il campo `addressing` di ToolTalk è sempre impostato su `TT_PROCEDURE`.

- Il campo `disposition` di ToolTalk viene impostato automaticamente sul valore specificato nello schema del messaggio statico.

#### Messaggi non supportati

Le azioni di tipo `TT_MSG` non supportano i messaggi seguenti:

- I messaggi di ToolTalk orientati agli oggetti

- L'uso di contesti come argomenti nei messaggi

#### Parole chiave per le azioni TT_MSG

Parola chiave | Uso
`TT_CLASS` | Definisce il valore del campo `class` dei messaggi di ToolTalk
`TT_SCOPE` | Definisce il valore del campo `scope` dei messaggi di ToolTalk
`TT_OPERATION` | Definisce il valore del campo `operation` dei messaggi di ToolTalk
`TT_FILE` | Definisce il valore del campo `file` dei messaggi di ToolTalk
`TT_ARGn_MODE` | Definisce il valore dell'attributo `mode` di ToolTalk per l'argomento n del messaggio
`TT_ARGn_VTYPE` | Definisce il valore dell'attributo `vtype` di ToolTalk per l'argomento n del messaggio
`TT_ARGn_VALUE` | Definisce il valore dell'argomento n del messaggio