# Actionscréation manuelle Création manuelle d'actions

Une action peut être définie de deux façons:

- à l'aide de l'utilitaire “Créer action”

- en créant manuellement une définition d'action

Pour créer une action manuellement, vous devez éditer un fichier de base de données; le présent chapitre explique comment effectuer cette opération.

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

## Voir aussi

- Pour plus de détails sur les actions, reportez-vous au SAG.IntAc.mkr.1.

- Pour savoir comment utiliser “Créer action”, reportez-vous au .

- Pour plus de détails sur les définitions d'actions, consultez la page de manuel `dtactionfile(4)`.

## Pourquoi créer manuellement une action

Il existe trois principaux types d'action:

- `COMMAND`

- `MAP`

- `TT_MSG`

L'utilitaire “Créer action” permet uniquement de créer certains types d'actions `COMMAND` et `MAP`. Toutes les actions `TT_MSG` doivent être créées manuellement.

Pour plus de détails, reportez-vous à la section SAG.dtCrA.mkr.3.

###
Actions de type COMMAND

Ces actions permettent d'exécuter une commande de lancement d'application ou d'utilitaire, de lancer un script shell ou d'exécuter une commande du système d'exploitation. La définition de l'action indique la commande à exécuter (zone `EXEC_STRING`).

“Créer action” s'applique aux types les plus courants d'actions de commande. Cependant, certaines d'entre elles doivent être créées manuellement, par exemple dans les cas suivants:

- lorsque l'action comporte plusieurs arguments de fichier, et qu'une invite différente est utilisée pour chacun d'eux

- lorsque l'action en appelle une autre

- lorsqu'elle définit des comportements distincts pour différents arguments de fichiers

- lorsqu'elle doit s'exécuter sur un système éloigné, différent de celui sur lequel elle est définie

- lorsqu'elle doit pouvoir être exécutée par un utilisateur différent (elle peut par exemple inviter l'entrée du mot de passe de root à un moment spécifique de l'exécution, puis continuer de s'exécuter en tant que root)

###
Actions de type MAP

Ces actions n'indiquent pas directement de commande ou de message ToolTalk ; elles sont mises en correspondance avec d'autres actions.

Cette méthode permet de spécifier plusieurs noms pour une même action. Par exemple, l'action de commande intégrée Editeur d'icônes permet de lancer le programme correspondant. La base de données contient également une action “Ouvrir”, ne s'appliquant qu'aux fichiers bitmaps et pixmaps (caractéristique indiquée dans la zone `ARG_TYPE` de la définition de l'action), mise en correspondance avec l'action “Editeur d'icônes”. Ainsi, l'utilisateur peut lancer l'Editeur d'icônes en sélectionnant un fichier bitmap ou pixmap dans le Gestionnaire de fichiers, et en choisissant “Ouvrir” sur le menu “Sélectionné(s)”.

A l'aide de “Créer action”, seules les actions “Ouvrir” et “Imprimer” peuvent être mises en correspondance; toutes les autres actions doivent l'être manuellement.

###
Actions de type TT_MSG (message ToolTalk)

Ces actions permettent d'envoyer des messages ToolTalk; elle doivent être créées manuellement.

## Création manuelle d'une action: étapes principales

La présente section explique comment créer un fichier de configuration pour une définition d'action.

### Fichiers de configuration d'action

Les fichiers de configuration contenant des définitions d'actions doivent respecter les règles suivantes.

- Leur nom doit adopter le format nom`.dt`.

- Les fichiers doivent se trouver dans le chemin de recherche de la base de données des actions et des types de données. Les chemins de recherche par défaut sont les suivants:

  Actions personnelles | Rép_personnel`/.dt/types`
  Actions système | `/etc/dt/appconfig/types/`langue
  Actions intégrées | `/usr/dt/appconfig/types/`langue. Il est préférable de ne pas utiliser ce répertoire.

Pour plus de détails sur la modification du chemin de recherche des actions et des types de données, reportez-vous à la section SAG.Datab.mkr.6.

### Procédure

1. Ouvrez un fichier de base de données existant ou créez-en un nouveau. Reportez-vous à la section précédente, SAG.CrAct.mkr.5.

2. Créez la définition de l'action en utilisant la syntaxe:

       ACTION nom_action
       {
          TYPE   type_action zone_action
          …
       }

   où:

   nom_action | Nom utilisé pour appeler l'action.
   type_action | `COMMAND` (défaut), `MAP` ou `TT_MSG.`
   zone_action | Une ou plusieurs des zones requises ou facultatives pour ce type d'action. Elles se composent d'un mot clé et d'une valeur. La plupart des zones d'action sont décrites dans ce chapitre. Pour plus de détails, consultez la page de manuel dtactionfile(4).

3. Enregistrez le fichier.

4. Pour associer des icônes particulières à l'action, créez-les. Par défaut, les icônes se trouvent dans les répertoires suivants:

   - icônes personnelles: Rép_Personnel`/.dt/icons`

   - icônes système: `/etc/dt/appconfig/icons/`langue (la langue par défaut est C).

     Pour plus de détails, reportez-vous à la section SAG.FrPC.mkr.12.

5. Cliquez deux fois sur “Recharger actions” dans le groupe d'applications Outils_Bureau.

6. Créez un fichier d'action, pour qu'une icône représentant l'action soit ajoutée dans le Gestionnaire de fichiers ou d'applications. Si l'action est destinée à lancer une application, l'icône est appelée
   icône d'application.

   Pour créer le fichier d'action, créez un fichier exécutable portant le même nom que l'action, dans n'importe quel répertoire auquel vous avez accès en écriture. Vous pouvez créer autant de fichiers d'action que nécessaire.

### Exemple d'action COMMAND

Les étapes suivantes créent une action personnelle permettant de lancer une application de télécopie sur un système éloigné appelé Serveur_AppA. La commande de lancement de cette application est la suivante:

    /usr/fax/bin/faxcompose [nom_fichier]

1. Créez le fichier Rép_personnel`/.dt/types/Télécopie.dt`.

2. Entrez la définition d'action suivante dans le fichier :

       ACTION Compo_télécopie
       {
          TYPE         COMMAND
          ICON         fax
          WINDOW_TYPE  NO_STDIO
          EXEC_STRING  /usr/fax/bin/faxcompose -c %Arg_1%
          EXEC_HOST    Serveur_AppA
          DESCRIPTION  Lance le programme de composition des télécopies.
       )

   Les zones `WINDOW_TYPE` et `EXEC_STRING` décrivent le comportement de l'action.

   `WINDOW_TYPE` | Le mot clé `NO_STDIO` indique que l'action ne doit pas nécessairement être exécutée dans une fenêtre d'émulation de terminal. Pour plus de détails, reportez-vous à la section sag.cract.mkr.25.
   `EXEC_STRING` | La syntaxe `%Arg_1%` indique qu'un fichier peut être posé sur l'action. Lorsque l'utilisateur clique deux fois sur l'icône d'action, une fenêtre de composition de télécopie vide s'affiche. Pour plus de détails, reportez-vous à la section sag.cract.mkr.13.

3. Sauvegardez le fichier.

4. À l'aide de l'Editeur d'icônes, créez les icônes suivantes dans le répertoire auquel Rép_personnel`/.dt/icons`:

   - `Télecopie.m.pm` (32 x 32 pixels)

   - `Télecopie.t.pm` (16 x 16 pixels)

5. Cliquez deux fois sur Recharger actions dans le groupe d'applications Outils_Bureau.

6. Créez un fichier exécutable appelé `Compo_télécopie` dans un répertoire auquel vous avez accès en écriture (votre répertoire personnel, par exemple).

### Exemple d'action MAP

Supposons que vous créez la plupart des fichiers que vous télécopiez à l'aide de l'Editeur de texte et qu'ils ont le type de données TEXTFILE (leur extension est `.txt`).

La procédure ci-après permet d'ajouter une option Télécopier au menu Sélectionné(s) associé à ce type de données.

1. Ouvrez le fichier Rép_personnel`/.dt/types/Télécopie.dt` que vous avez créé précédemment.

2. Ajoutez-y la définition d'action `MAP` suivante:

       ACTION Télécopier
       {
          ARG_TYPE    TEXTFILE
          TYPE        MAP
          MAP_ACTION  Compo_télécopie
       }

3. Sauvegardez le fichier.

4. Copiez la définition des attributs du type de données TEXTFILE de`/usr/dt/appconfig/types/`langue`/dtpad.dt` dans un nouveau fichier, Rép_personnel`/.dt/types/fich_texte.dt`. Ajoutez l'action Télécopier à la zone `ACTIONS`.

       DATA_ATTRIBUTES TEXTFILE
       {
          ACTIONS   Ouvrir,Imprimer,Télécopier
          ICON      Dtpenpd
          …
       }

5. Enregistrez le fichier.

6. Ouvrez le Gestionnaire d'applications et cliquez deux fois sur Recharger applications, dans le groupe d'applications Outils_Bureau.

### Rechargement de la base de données des actions et des types de données

Pour que les nouvelles définitions d'action ou les actions modifiées entrent en vigueur, le Bureau doit relire la base de données.

- Ouvrez le groupe d'applications Outils_Bureau et cliquez deux fois sur Recharger actions.

- Ou lancez la commande:

  `dtaction ReloadActions`

ReloadActions est le nom de l'action correspondant à l'icône Recharger actions.

La base de données est également relue lorsque l'utilisateur :

- se connecte

- relance le Gestionnaire de l'espace de travail

- enregistre une action dans la fenêtre Créer action à l'aide de l'option Sauvegarder du menu Fichier

###
Création d'un fichier (icône) d'action

Un
fichier d'action permet de créer une représentation visuelle d'une action dans le Gestionnaire de fichiers ou d'applications.

#### Fichiers d'action (ou icônes d'action ou encore icônes d'application) dans le Gestionnaire d'applications

Les icônes de fichiers d'action représentant des actions, elles sont parfois appelées
icônes d'action. Si les actions associées permettent de lancer une application, ces icônes sont appelées icônes d'application.

Lorsque vous cliquez deux fois sur une icône d'action, l'action correspondante est lancée. Une icône d'action peut également être une zone de pose.

#### Procédure

- Créez un fichier exécutable portant le même nom que
  l'action; son contenu n'a pas d'importance.

Par exemple, dans le cas d'une action définie comme suit:

    ACTION Mon_application
    {
       EXEC_STRING  Ma -file %Arg_1%
       DESCRIPTION  Lance Mon_application.
       ICON         Mapp
    }

Le fichier d'action est un fichier exécutable appelé `Mon_application`. Dans les Gestionnaires de fichiers et d'applications, ce fichier utilise l'icône `Mapp.`taille`.`type. Lorsque vous cliquez deux fois sur cette icône, la chaîne d'exécution de l'action est lancée. Lorsque vous demandez l'aide sur l'élément de l'action,
le contenu de la zone `DESCRIPTION` s'affiche.

####
Libellés d'actions

Si la zone `LABEL` figure dans une définition d'action, sa valeur sera utilisée comme libellé du fichier d'action dans les Gestionnaires de fichiers et d'applications, à la place du nom du fichier (nom_action). Par exemple, si la définition d'action comporte les zones suivantes:

    ACTION Mon_application
    {
       LABEL   Mon application
       …
    }

Le libellé de l'icône d'action sera “Mon application”.

### Définition d'une icône d'action

Pour indiquer l'image à utiliser pour les icônes d'une action dans les Gestionnaires de fichiers et d'applications, complétez la zone `ICON`.

Si vous ne spécifiez pas d'icône, le système utilise
les fichiers d'icônes d'action par défaut situés dans le répertoire `/usr/dt/appconfig/icons/`langue`/Dtactn.*`.

#### Icône d'action par défaut

Pour modifier l'icône d'action, utilisez la ressource suivante :

    *actionIcon: nom_fichier_icône

où nom_fichier_icône peut être un nom de base ou un chemin d'accès absolu.

La zone `ICON` peut prendre l'une des valeurs ci-dessous.

- Un nom de base de fichier.

  Il
  s'agit du nom du fichier contenant l'image, sans les extensions indiquant la taille de cette dernière (`m` et `t`) et son type (`bm` et `pm`). Par exemple, le nom de base des fichiers `IcôneJeu.m.pm` et `IcôneJeu.t.pm` est `IcôneJeu`.

  Si vous indiquez un nom de base, les fichiers d'icône doivent se trouver dans un répertoire du chemin de recherche des icônes :

  - icônes personnelles: Rép_Personnel`/.dt/icons`

  - icônes système: `/etc/dt/appconfig/icons/`langue

- Un chemin d'accès absolu, comprenant le nom complet du fichier.

  Utilisez le chemin absolu uniquement si le fichier d'icône ne figure pas dans le chemin de recherche des icônes. Par exemple, dans le cas du fichier `IcôneJeu.m.pm`, situé dans le répertoire `/doc/projets` (ne se trouvant pas dans le chemin de recherche des icônes), la valeur de la zone `ICON` doit être `/doc/projets/IcôneJeu.m.pm`.

Le SAG.CrAct.mkr.11 indique les différentes tailles d'icônes et les noms de fichiers correspondants.

### Nom et taille des icônes d'action

`Taille en pixels` | `Nom du bitmap` | `Nom du pixmap`
48 x 48 | nom`.l.bm` | nom`.l.pm`
32 x 32 | nom`.m.bm` | nom`.m.pm`
16 x 16 | nom`.t.bm` | nom`.t.pm`

### Modification d'une définition d'action existante

Toutes les actions installées sur le système peuvent être modifiées, y compris les actions intégrées.

Toute modification de la base de données des actions intégrées doit être effectuée avec prudence, en veillant à ne pas compromettre la compatibilité des actions intégrées avec les applications du Bureau.

1. Localisez la définition de l'action à modifier.

   Les emplacements par défaut des définitions d'action sont les suivants:

   - actions intégrées: `/usr/dt/appconfig/types/`langue

   - actions système: `/etc/dt/appconfig/types/`langue

   - actions personnelles: Rép_personnel`/.dt/types`

     Il est possible que des emplacements supplémentaires soient disponibles sur votre système. Pour en afficher la liste, entrez la commande suivante:

     `
     dtsearchpath -v`

     Votre système utilise les répertoires indiqués par
     la variable `DTDATABASESEARCHPATH`.

2. S'il y a lieu, copiez la définition d'action dans un fichier (nouveau ou existant) de l'un des répertoires suivants:

   - actions système: `/etc/dt/appconfig/types/`langue

   - actions personnelles: Rép_personnel`/.dt/types`

     Les fichiers situés dans `/usr/dt/appconfig/types/`langue ne pouvant pas être modifiés, vous devez copier les actions intégrées.

3. Effectuez les modifications voulues. Une fois cette opération terminée, enregistrez le fichier.

4. Cliquez deux fois sur Recharger actions dans le groupe d'applications Outils_Bureau.

### Priorité des définitions d'action

Lorsque l'utilisateur lance une action, le système recherche une entrée correspondante dans la base de données. Lorsqu'il existe plusieurs occurrences, des règles de priorité sont appliquées pour sélectionner l'action à utiliser.

- La priorité est déterminée par l'emplacement de la définition d'action, si aucune autre règle n'est définie. La liste suivante indique les répertoires d'actions, dans un ordre de priorité décroissant:

  - actions personnelles (Rép_personnel`/.dt/types`)

  - actions système locales (`/etc/dt/appconfig/types/`langue)

  - actions système éloignées ( nom_hôte:`/etc/dt/appconfig/types/`langue). Les systèmes hôtes éloignés recherchés sont ceux définis dans le chemin de recherche des applications

  - actions intégrées (`/usr/dt/appconfig/types/`langue.

- A l'intérieur d'un répertoire, les fichiers `*.dt` sont lus dans l'ordre alphabétique.

- Les actions faisant l'objet d'une restriction `(ARG_CLASS`, `
  ARG_TYPE`, `
  ARG_MODE` ou `
  ARG_COUNT)` sont prioritaires par rapport aux autres. La valeur par défaut de ces zones est `*`.

  Lorsque plusieurs restrictions s'appliquent, l'ordre (décroissant) de priorité est le suivant:

  - `ARG_CLASS`

  - `ARG_TYPE`

  - `ARG_MODE`

  - `ARG_COUNT`

    Si plusieurs restrictions `ARG_COUNT` existent, l'ordre (décroissant) de priorité est le suivant:

  - Valeur entière n

  - <n

  - >n

  - *

Par exemple, dans le cas de la définition d'action (partielle) suivante:

    ACTION Editer_graphiques
    # Editer_graphiques-1
    {
       ARG_TYPE   XWD
       …
    }

    ACTION Editer_graphiques
    # Editer_graphiques-2
    {
       ARG_COUNT  0
       …
    }

    ACTION Editer_graphiques
    # Editer_graphiques-3
    {
       ARG_TYPE  *
       …
    }

Lorsque vous cliquez deux fois sur l'icône d'action Editer_graphiques, l'action Editer_graphiques-2 est lancée. En effet, aucun argument n'ayant été indiqué, `ARG_COUNT 0` est prioritaire. Lorsqu'un argument (fichier de type XWD) est spécifié, Editer_graphiques-1 est lancée car la zone `ARG_TYPE` est définie (sa valeur est XWD). Editer_graphiques-3 est utilisée pour tous les autres arguments (fichiers).

## Création de la chaîne d'exécution d'une action COMMAND

Les deux zones requises pour une action de type `
COMMAND` sont `ACTION` et `EXEC_STRING`.

    ACTION nom_action
    {
       EXEC_STRING  chaîne_exécution
    }

La chaîne d'exécution est la partie essentielle d'une définition d'action `COMMAND`; sa syntaxe est identique à celle de la ligne de commande entrée dans une fenêtre d'émulation de terminal. Elle contient cependant des éléments supplémentaires destinés au traitement des arguments (chaînes et fichiers).

###
Fonctions générales des chaînes d'exécution

Une chaîne d'exécution peut contenir:

- des arguments (fichiers ou autres)

- une syntaxe de shell

- des chemins d'accès absolus ou des noms de fichiers exécutables

#### Arguments d'action

Un argument est une donnée nécessaire à l'exécution d'une application ou d'une commande. Par exemple, la ligne de commande ci-après permet d'ouvrir un fichier dans une fenêtre de l'Editeur de texte.

`dtpad` nom_fichier

Dans cette commande, nom_fichier est un fichier indiqué comme argument de la commande `dtpad`.

Tout comme les applications et les commandes, les actions peuvent être associées à des arguments. Les deux types d'arguments disponibles pour les actions `COMMAND` sont les suivants:

- fichiers

- chaînes

#### Utilisation des shells dans les chaînes d'exécution

Bien que la chaîne s'exécute directement, sans passer par un shell, vous pouvez en indiquer un dans sa syntaxe.

Par exemple:

    EXEC_STRING     \
            /bin/sh -c \
            'tar -tvf %(File)Arg_1% 2>&1 | \${PAGER:-more};\
            echo "\\n*** Sélectionnez Fermer pour sortir ***”'

#### Nom ou chemin d'accès absolu du fichier exécutable

Si votre application est installée dans un répertoire figurant dans la variable
PATH, vous pouvez indiquer uniquement le nom du fichier exécutable. Sinon, vous devez utiliser
son chemin d'accès absolu.

### Création d'une action sans arguments

Dans la zone `EXEC_STRING`, utilisez la syntaxe permettant de lancer l'application à partir de la ligne de commande.

#### Exemples

- La chaîne d'exécution suivante fait partie d'une action permettant de lancer le client X `xcutsel`:

      EXEC_STRING xcutsel

- La chaîne suivante permet de lancer le client `xclock` en indiquant une horloge numérique; la ligne de commande comporte une option mais aucun argument n'est requis:

      EXEC_STRING xclock -digital

### Création d'une action prenant en charge la pose de fichiers

Pour indiquer l'argument (fichier), utilisez la syntaxe suivante:

    %Arg_n%

ou

    %(File)Arg_n%

`(File)` est facultatif, étant donné que les arguments indiqués pour `Arg_n sont` considérés par défaut comme des fichiers. Pour plus de détails sur l'utilisation de la syntaxe `%(String)Arg_n%`, reportez-vous à la section SAG.CrAct.mkr.19.

Cette syntaxe permet à l'utilisateur de poser un fichier de données sur une icône d'action afin de l'utiliser comme argument pour cette dernière. Il remplace le nième argument de la ligne de commande. Il peut s'agir d'un fichier local ou éloigné.

#### Exemples

- La chaîne d'exécution suivante lance `wc -w` en utilisant un fichier posé comme argument pour le paramètre.

      EXEC_STRING wc -w %Arg_1%

- L'exemple ci-dessous représente la définition partielle d'une action qui n'accepte que des répertoires en tant qu'arguments. Lorsqu'un répertoire est posé sur l'icône de cette action, celle-ci affiche la liste des fichiers du répertoire accessibles en lecture-écriture.

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

### Création d'une action invitant à indiquer un argument (fichier)

Pour indiquer l'argument (fichier), utilisez la syntaxe suivante:

    %(File)"invite"%

Lorsque l'utilisateur clique deux fois sur l'icône correspondant à cette action, un message l'invitant à indiquer un nom de fichier s'affiche.

Par exemple, la chaîne d'exécution suivante affiche une boîte de dialogue dans laquelle l'argument de la commande `wc -w` doit être indiqué:

    EXEC_STRING wc -w %(File)"Fichier à compter :"%

### Création d'une action supportant les fichiers posés ou invitant à les indiquer

Pour indiquer l'argument (fichier), utilisez la syntaxe suivante:

    %Arg_n"invite"%

ou

    %(File)Arg_n"invite"%

L'action créée par cette syntaxe:

- accepte les fichiers posés en tant qu'arguments

- affiche, lorsque l'utilisateur clique sur l'icône correspondante, une boîte de dialogue l'invitant à entrer un nom de fichier

Par exemple, la chaîne d'exécution ci-dessous lance la commande `lp -oraw` sur un fichier posé. Si l'utilisateur a cliqué deux fois sur l'icône de l'action pour la lancer, il est invité à indiquer un nom de fichier.

    EXEC_STRING lp -oraw %Arg_1"Fichier à imprimer:"%

### Création d'une action invitant à indiquer un argument autre qu'un fichier

Pour indiquer l'argument, utilisez la syntaxe suivant:

    %"invite"%

ou

    %(String)"invite"%

`(String)` est facultatif; en effet, le texte indiqué entre guillemets est considéré par défaut comme une chaîne. Cette syntaxe affiche une boîte de dialogue qui invite l'utilisateur à entrer des données; ne l'utilisez pas lorsqu'un nom de fichier doit être indiqué.

Par exemple, la chaîne d'exécution suivante lance la commande `xwd` et invite l'utilisateur à indiquer une valeur à ajouter à chaque pixel:

    EXEC_STRING xwd -add %"Valeur à ajouter :"% -out %Arg_1"Nom du
    fichier :"%

### Interprétation d'un argument (fichier) en tant que chaîne

Pour indiquer l'argument, utilisez la syntaxe suivante:

    %(String)Arg_n%

Par exemple, la chaîne d'exécution suivante permet d'imprimer un fichier accompagné d'une page bannière indiquant son nom, à l'aide de la commande `lp -t` bannière nom_fichier.

    EXEC_STRING lp -t%(String)Arg_1% %(File)Arg_1"Fichier à imprimer :"%

### Fonctions shell

Indiquez le shell dans la chaîne d'exécution:

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

#### Exemples

- La chaîne d'exécution suivante correspond à une action qui utilise les fonctions de tube du shell:

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

- La chaîne suivante est plus complexe; elle requiert un traitement par le shell et supporte un argument (fichier):

    EXEC_STRING /bin/sh -c 'tbl %Arg_1"Page de manuel :"% | troff -man'

- Pour la chaîne ci-après, l'argument doit être un fichier compressé; l'action le décompresse et l'imprime à l'aide de la commande `lp -oraw`.

    EXEC_STRING /bin/sh -c 'cat %Arg_1 "Fichier à imprimer :"% |  uncompress | lp -oraw'

- La chaîne suivante permet de lancer un script shell :

    EXEC_STRING /usr/local/bin/LancerClientGnu

### Création d'actions COMMAND pour plusieurs arguments (fichiers)

Les actions peuvent gérer les arguments multiples des trois manières suivantes.

- L'action peut être exécutée à plusieurs reprises, à raison d'une par argument. Lorsqu'une zone `EXEC_STRING` définit un seul argument et que plusieurs fichiers sont posés sur l'icône de l'action, celle-ci est exécutée pour chaque fichier.

  Par exemple, si plusieurs fichiers sont indiqués pour la définition d'action suivante:

      ACTION Affich_image_écran
      {
         EXEC_STRING xwud -in %Arg_1%
          …
      }

  Dans ce cas, l'action Affich_image_écran est exécutée à plusieurs reprises.

- L'action peut utiliser deux (ou plus) fichiers non interchangeables. Par exemple:

      xsetroot -cursor fich_curseur fich_masque

  Cette action requiert deux fichiers, indiqués dans un ordre donné.

- Une action peut également exécuter la même commande de façon séquentielle sur chaque fichier. Par exemple :

      pr fichier [fichier …]

  Cette action regroupe un ou plusieurs fichiers dans un même travail d'impression.

#### Création d'une action avec des arguments non interchangeables

Utilisez l'une des syntaxes décrites ci-dessous.

- Pour que l'action invite à indiquer les noms de fichier, utilisez la syntaxe suivante pour chaque argument:

      %(File)”invite”%

  Utilisez une chaîne invite différente pour chaque argument.

  Par exemple, la chaîne suivante invite à spécifier deux fichiers:

      EXEC_STRING  xsetroot -cursor %(File)”Bitmap curseur :”% \
                   %(File)”Bitmap masque :”%

- Pour que l'action supporte les fichiers posés, utilisez la syntaxe suivante pour chaque argument:

       %Arg_n%

  Attribuez une valeur différente à n pour chaque argument. Par exemple:

      EXEC_STRING diff %Arg_1% %Arg_2%

#### Création d'une action avec des arguments interchangeables

Utilisez l'une des syntaxes décrites ci-dessous.

- Pour créer une action supportant les fichiers posés, chargée d'exécuter une commande du type `commande` fichier 1 fichier 2 …, utilisez la syntaxe suivante pour les arguments:

      %Args%

- Pour créer une action qui prenne en charge plusieurs fichiers posés, ou qui affiche un message invitant à indiquer un fichier lorsque l'utilisateur clique deux fois dessus, utilisez la syntaxe suivante pour les arguments:

      %Arg_1”invite”% %Args%

  La commande sera lancée sous la forme `commande` fichier 1 fichier 2 ….

##### Exemples

- La chaîne suivante crée une action qui exécute la commande:

    pr fichier
    1 fichier2

Cette action prend en charge plusieurs arguments (fichiers).

    EXEC_STRING pr %Args%

- La chaîne suivante crée une action semblable à la précédente, qui affiche en outre une invite lors de l'exécution d'un double déclic par l'utilisateur (pas d'arguments):

    EXEC_STRING pr %Arg_1"Fichier(s) à imprimer :"% %Args%

#### Création d'une action pour plusieurs fichiers posés

Pour créer une action qui supporte plusieurs arguments et exécute une commande du type:

    commande fichier1 fichier
    2 …

Utilisez la syntaxe:

    %Args%

##### Exemples

- La chaîne suivante lance le script Vérification sur plusieurs fichiers:

    EXEC_STRING   /usr/local/bin/Vérification \
                  %Arg_1"Fichier à vérifier ?"% %Args%

- La chaîne suivante exécute la commande `lp -oraw` sur plusieurs fichiers:

    EXEC_STRING lp -oraw %Arg_1"Fichier à imprimer :"% %Args%

## Support de fenêtrage et émulateurs de terminal pour les actions COMMAND

Les actions `COMMAND` supportent les fenêtres du Bureau des manières décrites ci-dessous.

- Si l'application dispose de sa propre fenêtre, l'action peut être conçue de sorte qu'aucune fenêtre supplémentaire ne soit ouverte. Cette option est également utilisée pour les actions qui lancent des commandes ne requérant aucune entrée utilisateur et ne générant aucune sortie.

- Si l'application doit s'exécuter dans une fenêtre d'émulation de terminal, l'action peut ouvrir cette fenêtre avant de lancer l'application. Il existe plusieurs options de terminal.

### Définition du support de fenêtrage

Pour indiquer le type de support de fenêtrage utilisé par l'action, utilisez la zone `WINDOW_TYPE`.

WINDOW_TYPE | Type de support de fenêtrage
`NO_STDIO` | Aucun. Utilisez cette valeur si l'application dispose de sa propre fenêtre, ou si la commande ne génère aucune sortie visible.
`PERM_TERMINAL` | Fenêtre d'émulation de terminal permanente. L'action ouvre une fenêtre de terminal qui reste ouverte jusqu'à ce que l'utilisateur demande explicitement sa fermeture; des données peuvent être entrées dans cette fenêtre. Cette valeur doit être utilisée avec les commandes qui exigent des entrées et génèrent une sortie avant de prendre fin (par exemple, `ls` répertoire ).
`TERMINAL` | Fenêtre d'émulation de terminal provisoire. L'action ouvre une fenêtre de terminal qui se ferme dès la fin de l'exécution de la commande. Utilisez cette valeur dans le cas des commandes plein écran (par exemple, `vi`).

### Définition d'options de ligne de commande pour l'émulateur de terminal

Pour définir ces options, utilisez la zone `TERM_OPTS` de la définition de l'action.

Par exemple, l'action suivante invite à indiquer l'hôte d'exécution:

    ACTION Ouvrir_term_sur_système_indiqué
    {
       WINDOW_TYPE   PERM_TERMINAL
       EXEC_HOST     %(String)"Terminal éloigné sur :"%
       TERM_OPTS     -title %(String)"Titre de la fenêtre :"%
       EXEC_STRING   $SHELL
    }

### Définition d'un émulateur de terminal par défaut différent

Par défaut, les actions utilisent l'émulateur de terminal `dtterm`; vous pouvez cependant en indiquer un autre. L'émulateur par défaut est pris en compte lorsque l'action n'identifie pas explicitement l'émulateur à utiliser.

L'émulateur utilisé par les actions doit être associé aux options de ligne de commande suivantes:

- `-title` titre_fenêtre

- `-e` commande

Les ressources ci-dessous définissent l'émulateur utilisé par les actions.

- La ressource `localTerminal` indique l'émulateur associé aux applications locales.

      *localTerminal: terminal

  Par exemple:

      *localTerminal: xterm

- La ressource `remoteTerminal` indique l'émulateur associé aux applications éloignées.

    *remoteTerminal: hôte:terminal [,hôte:terminal…]

Par exemple:

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

##
Restriction des actions à certains arguments

Pour préciser l'action, vous avez la possibilité de l'associer à certains arguments uniquement. Par exemple, il est préférable de faire en sorte que l'action permettant d'afficher les fichiers PostScript n'accepte que ce type de fichier comme argument. Si un fichier incorrect est indiqué, l'action affiche un message d'erreur.

Les restrictions s'appliquent en fonction:

- du type de données du fichier indiqué comme argument

- du nombre d'arguments (par exemple, aucun argument ou un ou plusieurs arguments), ce qui permet d'indiquer différents comportements pour la pose et le double clic sur l'icône de l'action

- le mode de lecture-écriture de l'argument

### Restriction des actions à certains types de données

Utilisez la zone `ARG_TYPE` pour définir les types de données auxquels l'action s'applique (indiquez les noms d'attributs de données).

Vous pouvez indiquer plusieurs types de données, à condition de les séparer par des virgules.

Dans l'exemple de définition d'action suivante, on considère que le type de données Gif a été créé.

    ACTION Ouvrir_Gif
    {
       TYPE         COMMAND
       LABEL        "Afficher fichier GIF"
       WINDOW_TYPE  NO_STDIO
       ARG_TYPE     Gif
       ICON         xgif
       DESCRIPTION  Permet d'afficher les fichiers GIF.
       EXEC_STRING  xgif
    }

### Restriction d'une action en fonction du nombre d'arguments

Pour indiquer le nombre d'arguments supportés par l'action, utilisez la zone `ARG_COUNT`. Les valeurs possibles sont les suivantes :

* | (défaut) Nombre d'arguments illimité. Les autres valeurs sont prioritaires par rapport à *.
n | Toute valeur entière, y compris 0.
>n | Plus de n arguments.
<n | Moins de n arguments.

La zone `ARG_COUNT` permet d'indiquer différents comportements pour l'icône d'action, selon que l'utilisateur clique deux fois dessus ou y pose un fichier. Pour plus de détails, reportez-vous à la section suivante SAG.CrAct.mkr.31.

### Définition de comportements différents pour la pose et le double clic

La procédure suivante permet de créer une action prenant en charge les fichiers posés, mais n'invitant pas à indiquer un fichier lors d'un double clic utilisateu:

1. Créez une définition d'action pour la fonction double clic.

   Indiquez la valeur 0 dans la zone `ARG_COUNT`. Dans la zone `EXEC_STRING`, spécifiez une syntaxe ne supportant pas les arguments posés.

2. Créez une définition d'action pour la fonction pose.

   Indiquez la valeur >0 dans la zone `ARG_COUNT`. Dans la zone `EXEC_STRING`, spécifiez une syntaxe supportant les arguments posés.

Dans les exemples ci-dessous, les commandes suivantes permettent de lancer l'éditeur `vedit`.

- Pour lancer l'éditeur sans argument:

      vedit

- Pour lancer l'éditeur et ouvrir un fichier en lecture seule:

      vedit -R nom_fichier

Les deux actions ci-dessous permettent de créer les fonctions pose et double clic pour l'action Vedit. La première action est prioritaire lors de la recherche dans la base de données; en effet, la définition `ARG_COUNT 0` est plus précise que (`ARG_COUNT *` ).

    # Fonction double clic
    ACTION Vedit
    {
       TYPE          COMMAND
       ARG_COUNT     0
       WINDOW_TYPE   PERM_TERMINAL
       EXEC_STRING   vedit
    }

    # Fonction pose
    ACTION Vedit
    {
       TYPE         COMMAND
       WINDOW_TYPE  PERM_TERMINAL
       EXEC_STRING  vedit -R %Arg_1%
    }

### Restriction d'une action en fonction du mode de l'argument

Pour indiquer le mode de lecture-écriture de l'argument, utilisez la zone `ARG_MODE`. Les valeurs possibles sont les suivantes:

* | (défaut) Mode quelconque.
!w | Non accessible en écriture.
w | Accessible en écriture.

## Création d'actions exécutant des applications sur des systèmes éloignés

Vous devez connaître la signification des termes suivants:

Hôte de base de données | Système contenant la définition de l'action.
Hôte d'exécution | Système sur lequel le programme s'exécute.

Dans la plupart des cas, les actions et les applications associées sont installées sur le même système; étant donné que l'hôte d'exécution par défaut d'une action est l'hôte de base de données, aucune syntaxe particulière n'est requise.

Cependant, lorsque l'hôte d'exécution est différent de l'hôte de base de données, le système sur lequel la chaîne d'exécution sera lancée doit être indiqué dans la définition de l'action.

La fonction de recherche des actions et des applications sur différents systèmes fait partie de l'architecture client/serveur du Bureau. Pour plus de détails sur les applications en réseau, reportez-vous à la section SAG.ClSrv.mkr.15.

### Création d'une action exécutant une application éloignée

Pour définir l'emplacement de l'application, utilisez la zone `EXEC_HOST` de la définition de l'action.

Vous pouvez indiquer les valeurs suivantes:

`%DatabaseHost%` | Système hôte sur lequel l'action est définie.
`%LocalHost%` | Système hôte sur lequel l'action est lancée (serveur de session).
`%DisplayHost%` | Système hôte sur lequel le serveur X s'exécute (non autorisé dans le cas des terminaux X).
`%SessionHost%` | Système hôte sur lequel le Gestionnaire de connexion en cours s'exécute.
nom_hôte | Utilisez cette valeur pour les environnements dans lesquels l'action doit toujours être exécutée sur un système hôte donné.
%"invite"% | Invite l'utilisateur à indiquer le nom hôte lors de chaque exécution de l'action.

La valeur par défaut est `%DatabaseHost%`, `%LocalHost%`.
Ainsi, lorsque la zone `EXEC_HOST` n'est pas précisée, une tentative d'exécution de la commande est effectuée sur le système hôte contenant la définition de l'action. En cas d'échec, le serveur de sessions est utilisé.

#### Exemples

- La zone suivante désigne le système hôte `ddsyd`:

    EXEC_HOST ddsyd

- La zone suivante invite à indiquer un système hôte:

    EXEC_HOST %"Hôte contenant l'application :"%

- La zone suivante indique que l'action tente de lancer l'application sur le système hôte qui contient sa définition. En cas d'échec, elle tente de la lancer sur le système hôte `ddsyd`.

    EXEC_HOST %DatabaseHost%, ddsyd

## Utilisation de variables dans les définitions d'actions et de types de données

Vous pouvez indiquer des variables d'environnement et des variables chaînes de caractères dans les fichiers de définition d'actions et de types de données.

### Variables chaînes de caractères (actions)

Ce type de variable entre en vigueur lorsqu'elle est définie et le reste jusqu'à la fin du fichier. Il n'existe aucune variable globale pour la base de données.

Si une variable d'environnement et une variable chaîne de caractères portent le même nom, cette dernière est prioritaire.

#### Définition d'une variable chaîne de caractères

- Utilisez la syntaxe:

      set nom_variable=valeur

Les noms de variables peuvent contenir des caractères alphanumériques et le caractère de soulignement “__”. Chaque définition de variable doit figurer sur une ligne distincte.

Par exemple:

    set Remote_Application_Server=sysapp
    set Remote_File_Server=sysdata

#### Référence à une variable chaîne de caractères :

- Utilisez la syntaxe:

  $[{]nom_variable[}]

Par exemple:

    EXEC-HOST   $Remote_Application_Server
    CWD /net/   ${Remote_File_Server}/doc/projet

### Variables d'environnement (actions et types de données)

- Utilisez la syntaxe suivante pour faire référence à une variable d'environnement:

  `$[{]`variable[`}]`.

La variable est remplacée par sa valeur lors du chargement de la base de données. Si une variable d'environnement et une variable chaîne de caractères portent le même nom, cette dernière est prioritaire.

Par exemple, la chaîne d'exécution suivante permet d'imprimer un fichier avec une bannière indiquant le nom de connexion:

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

## Exécution d'actions à partir de la ligne de commande

Pour effectuer cette opération, utilisez la commande du Bureau `dtaction`. Les actions peuvent être exécutées à partir:

- de scripts

- d'autres actions

- de la ligne de commande d'une fenêtre d'émulation de terminal.

### Commande dtaction

`dtaction [-user` nom_utilisateur`] [-execHost` nom_hôte`]` nom_action `[`argument `[`argument`]…]`

`-user` nom_utilisateur | Permet à un autre utilisateur d'exécuter l'action. Si `dtaction` est lancée par un utilisateur différent de nom_utilisateur, il est invité à indiquer un mot de passe.
-`execHost` nom_hôte | Actions de type `COMMAND` uniquement; indique le système hôte d'exécution de la commande.
argument | Arguments associés à l'action; il s'agit généralement de fichiers.

Le client `dtaction` dispose d'options de ligne de commande supplémentaires. Pour plus de détails, consultez la page de manuel `dtaction(1)`.

### Création d'une action exécutant une autre action

Indiquez `dtaction` dans la zone `EXEC_STRING` de l'action.

Par exemple, l'action ci-dessous utilise l'action intégrée Spell, dont le libellé est Vérifier orthographe dans le Gestionnaire d'applications. La nouvelle action lance l'Editeur de texte et Spell, puis affiche les erreurs d'orthographe dans une fenêtre d'émulation de terminal distincte.

    ACTION Editer_et_vérifier
    {
       WINDOW_TYPE   NO_STDIO
       EXEC_STRING   /bin/sh -c 'dtaction Spell \
                     %Arg_1"Fichier :"%; dtpad %Arg_1%'
    }

### Création d'une action exécutée par un autre utilisateur

Utilisez la syntaxe suivante dans la zone `EXEC_STRING` :

    EXEC_STRING dtaction -user nom_utilisateur nom_action [argument_fichier]

Pour avoir accès au système, le nouvel utilisateur (nom_utilisateur) doit disposer d'une des autorisations suivantes:

- autorisation de lecture sur le fichier `.Xauthority` de l'utilisateur de connexion

- ou autorisation `xhost`

Par exemple, les actions suivantes permettent de devenir utilisateur root et d'éditer un fichier app-defaults.

    ACTION AppDefaults
    {
       WINDOW_TYPE  NO_STDIO
       EXEC_STRING  /usr/dt/bin/dtaction -user root \
                    EditerAppDefaults %Arg_1"Fichier :"%
    }

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

## Création d'actions internationalisées

Le chemin de recherche de types de données comporte des emplacements liés à la langue utilisée. Le Bureau utilise la valeur de `LANG` pour identifier les répertoires dans lesquels rechercher les définitions de types de données.

### Emplacements des actions internationalisées

Les définitions des actions adaptées au pays doivent être situées dans les répertoires associés à la langue utilisée, dans le chemin de recherche des actions.

Les chemins de recherche par défaut sont les suivants:

- actions personnelles: Rép_personnel`/.dt/types`

- actions système: `/etc/dt/appconfig/types/`langue

- actions intégrées: `/usr/dt/appconfig/types/`langue.

### Internationalisation d'une action existante

1. Créez un fichier dans le répertoire correspondant à la langue (par exemple, `/etc/dt/appconfig/types/fr_FR`).

2. Copiez la définition de l'action dans le fichier de configuration lié à la langue.

   Par exemple, vous pouvez copier une définition d'action de

   `racine_app/dt/appconfig/types/C/fichier.dt`

   vers

   `racine_app/dt/appconfig/types/fr_FR/nouveau_fichier.dt`

3. Ajoutez une zone `LABEL` ou modifiez celle qui existe.

   `LABEL` chaîne

   Les Gestionnaires d'applications et de fichiers utilisent cette chaîne pour identifier l'icône d'action.

4. Localisez un ou plusieurs des éléments suivants :

   - icônes: zone `ICON`

   - aide sur l'élément: zone `DESCRIPTION`

   - invites localisées: texte entre guillemets dans la zone `EXEC_STRING`

## Création d'actions pour les applications ToolTalk

Les informations suivantes ne s'appliquent qu'aux programmes qui supportent la messagerie ToolTalk.

Les actions permettant d'envoyer des messages ToolTalk, sont du type `TT_MSG`.

    ACTION nom_action
    {
       TYPE   TT_MSG
       …
    }

### Zones addressing et disposition

- La valeur de la zone ToolTalk `addressing` est toujours `TT_PROCEDURE`.

- Par défaut, la valeur de la zone `disposition` est la spécification de forme de message statique.

#### Messages non pris en charge

Les messages suivants ne sont pas pris en charge par les actions de type `TT_MSG`:

- messages ToolTalk orientés objet

- arguments contextuels des messages

#### Mots clés des actions TT_MSG

Mot clé | Utilisation
`TT_CLASS` | Définit la valeur de la zone ToolTalk `class`.
`TT_SCOPE` | Définit la valeur de la zone ToolTalk `scope`.
`TT_OPERATION` | Définit la valeur de la zone ToolTalk `operation`.
`TT_FILE` | Définit la valeur de la zone ToolTalk `file`.
`TT_ARGn_MODE` | Définit la valeur de l'attribut ToolTalk `mode` pour le nième message.
`TT_ARGn_VTYPE` | Définit la valeur de l'attribut ToolTalk `vtype` pour le nième message.
`TT_ARGn_VALUE` | Définit la valeur du nième message.