Solaris CDE - Guide avancé de l'utilisateur et de l'administrateur système

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

Les deux zones requises pour une action de type COMMAND sontACTION 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%

%(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. (Voir "Interprétation d'un argument (fichier) en tant que chaîne" pour en savoir plus sur l'utilisation de la syntaxe %(String)Arg_n% .

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 -load.
```
	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 's -l %Arg_1% | grep rw-'
 	        ...
 	}
```

Création d'une action invitant à indiquerun argument de 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 :

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

Création d'une action prenant en charge les fichiers posés ou invitant à les indiquer

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

%Arg_n"invite"%

ou la

%(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 deux fois 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 suivante :

%"invite"%

ou la

%(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 -tbanniè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 prend en charge 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 de trois manières, décrites ci-dessous.

L'action peut être exécutée à plusieurs reprises, 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 arguments 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 prenne en charge 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 prenant en charge 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 fichier 2
```
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 plus une invite lorsque l'utilisateur clique deux fois dessus (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 prenne en charge plusieurs arguments et exécute une commande du type :

commande fichier 1 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%
```