YAD

Traduction de la description sur le site officiel de Yad. ¹⁾

Yad (« Yet Another Dialog », « encore une boîte de dialogue ») est un outil pour créer des boîtes de dialogue graphiques à partir de scripts shell.

Yad est un fork de Zenity. Ses avantages par rapport à Zenity sont l'intégration de plusieurs contrôles sur une même fenêtre (voir le paramètre --form)

Yad a été écrit par Victor Ananjevsky.

L'icone Yad a été créé par Bogdan Lisovich.

• Disposer des droits d'administration.
• Disposer d'une connexion à Internet configurée et activée.
• Avoir activé l'accès au Dépôts Universe de Canonical.

Pour installer ce logiciel, il suffit d'installer les paquets yad.

Pour installer une version récente de YAD, vous pouvez installer YAD avec le PPA de webupd8, en une ligne :

sudo add-apt-repository ppa:nilarimogard/webupd8 -y && sudo apt update && sudo apt install yad -y

< Pour les utilisateurs avancés > Yad évolue très vite, il peut être utile de compiler la dernière version.

Pour satisfaire les dépendances, installez Yad par APT puis si vous voulez la dernière version, compilez-la comme suit.

Vous devrez peut-être installer gcc, libwebkitgtk-dev

Pour avoir la dernière version, télécharger l'archive sur la page officielle de Yad Décompressez-la ou vous voulez. Ouvrez un terminal

cd /chemin/vers/le/dossier/décompressé
./configure
make
sudo make install

cd /chemin/vers/le/dossier/décompressé
./configure --enable-icon-browser --enable-html 
make
sudo make install

Yad permet d'afficher plusieurs types de fenêtre :

Pour plus d'infos, consulter les pages du manuel de Yad.

Les formulaires permettent de décliner les différentes options de yad dans la même fenêtre. Les types de champs de formulaire sont saisis sous la forme --field="LABEL"[:TYPE] Les types de champs sont les suivants : H, RO, NUM, CHK, CB, CBE, CE, FL, SFL, DIR, CDIR, FN, MFL, MDIR, DT, SCL, CLR, BTN, FBTN, LBL, TXT. ||

Avant de vous lancer dans la lecture, notez que vous trouverez de nombreux exemples, simples et complexes avec ces liens :

• Apprendre par l'exemple (copie en PDF)
• Applications simples

Dans cet exemple le calendrier s'ouvrira à la date du jour et la sortie sera de format sam./27/juil./2019/

--title="Titre de la fenêtre": Indique le titre de votre fenêtre.

--window-icon="yad": Affiche une icône dans la barre du titre (Selon votre thème.) et sur le bouton de la liste des fenêtres.

jour=$(date +%d)
mois=$(date +%m)
annee=$(date +%Y)
yad --calendar --day="$jour" --month="$mois" --year="$annee" --date-format=%a/%d/%b/%Y/ --title="Titre de la fenêtre" --window-icon="yad"

#!/bin/bash
yad --dnd \
--title="dnd dialog box" \
--window-icon="gtk-dnd-multiple" \
--width="200" --height="200" \
--center --on-top \
--undecorated \
--text="<span font_desc='Sans Bold Italic 13' foreground='#08fc00'>Glisser\nune\nimage.</span>" \
--text-align="center" --command="xdg-open"

Une boîte de recherche sur les pages en français de Google

#!/bin/bash
recherche=$(yad --entry --title='Recherche web' --text='Tapez votre recherche' --text-align="center" --no-escape --mouse --undecorated --skip-taskbar --on-top)
recherche=${recherche// /+}
xdg-open "https://www.google.fr/search?q=$recherche&site=webhp&source=lnt&tbs=lr:lang_1fr&lr=lang_fr"

C'est ici que Yad devient intéressant car il permet de cumuler plusieurs types de boîtes dans une seule fenêtre.

Deux exemples récapitulatifs :

retour=$(yad --form --field="BTN":BTN  --field="CB":CB  --field="CBE":CBE  --field="CDIR":CDIR  --field="CE":CE  --field="CHK":CHK  --field="CLR":CLR  --field="DIR":DIR  --field="DT":DT  --field="FBTN":FBTN  --field="FL":FL  --field="FN":FN  --field="H":H "gtk-cancel:1" "Valeur 1\!Valeur 2\!^Valeur 3\!Valeur 4" "Valeur 1\!Valeur 2\!Valeur 3\!Valeur 4" "/home/user/Documents/" "Texte libre." "TRUE" "#FA892F" "/home/user/Documents/" "12/11/2018" "Firefox" "/home/user/Documents/fichier.txt" "Sans Bold 12" "motdepasse")
echo "$retour"

et (un seul formulaire avec toutes les options risque de dépasser les dimensions de votre écran) :

retour=$(yad --form  --field="LBL":LBL  --field=:LBL  --field="MDIR":MDIR  --field="MFL":MFL  --field="NUM":NUM  --field="RO":RO  --field="SCL":SCL  --field="SFL":SFL  --field="TXT":TXT  --field="Champ dépourvu d'option : '" "Une étiquette" "" "/home/user/Documents/,/home/user/Musique" "/home/user/Documents/fichierun.txt,/home/user/Documents/fichierdeux.txt" "10.00\!0..1000\!0.05\!2" "Lecture seule" "27" "/home/user/NouveauFichier.txt" "Texte multiligne" "Valeur par défaut : texte simple")
echo "$retour"

Si l'on reprend l'exemple précédent vous pouvez entrer votre recherche et choisir le moteur le plus approprié :

#!/bin/bash
search=$(yad --title='Recherche web' --text='Tapez votre recherche' --text-align="center" --no-escape --mouse --undecorated --skip-taskbar --on-top \
--form \
--field="recherche:" '' \
--field="Moteur:CB" 'Forum ubuntu!^Google fr')
rech=$(echo "$search" | awk 'BEGIN {FS="|" } { print $1 }')
moteur=$(echo "$search" | awk 'BEGIN {FS="|" } { print $2 }')
if [ "$moteur" = "Forum ubuntu" ]
then
rech=$(echo "$rech" | sed 's/^/+/;s/ /+/g')
xdg-open https://www.google.fr/search?q=site:forum.ubuntu-fr.org"$rech"
elif  [ "$moteur" = "Google fr" ]
then
rech=$(echo "$rech" | sed 's/^/+/;s/ /+/g')
xdg-open https://www.google.fr/search?q="$rech"\&lr=lang_fr
fi

Affiche une icône dans la zone de notification du panel (le systray).

Un exemple concret tout simple, qui affiche une icône et quitte lorsqu'on clique gauche dessus :

yad --notification

On peux changer l’icône avec le paramètre --image

yad --notification --image="gtk-help"

yad --notification --image="system-software-update"

Exemple avec un script faisant les mises à jour et affichant avec une icône dans la zone de notification pour le signaler :

#!/bin/bash
MSG="Mise à jour du système en cours, n'éteignez pas l'ordinateur..."
notify-send "$MSG"
faireMaJ () { (sudo apt update ; sudo apt full-upgrade) > /dev/null; }
faireMaJ | yad --notification --no-middle --text="$MSG" --image="system-software-update" --command="zenity --info --text \"$MSG\"" --listen

La liste des noms d’icônes standard sont là : LIEN

Quelques exemples du site officiel : LIEN

Reprenons l'exemple d'avant et mettons-le dans une icône.

#!/bin/bash
#####Commande qui permet de montrer/cacher la fenêtre
function _commande ()
{
commande=$(ps -ef | grep "yad --title=Recherche web --text=Tapez votre recherche" | sed 's/^.*grep.*$//' | sed -n "1p" | awk 'BEGIN { FS=" " } { print $2 }')
if [ -n "$commande" ]
then
kill -9 "$commande"
else
_recherche
fi
}
export -f _commande
#####Recherche internet
function _recherche ()
{
search=$(yad --title='Recherche web' --text='Tapez votre recherche' --text-align="center" --no-escape --mouse --undecorated --skip-taskbar --on-top \
--form \
--field="recherche:" '' \
--field="Moteur:CB" 'Forum ubuntu!^Google fr')
rech=$(echo "$search" | awk 'BEGIN {FS="|" } { print $1 }')
moteur=$(echo "$search" | awk 'BEGIN {FS="|" } { print $2 }')
if [ "$moteur" = "Forum ubuntu" ]
then
rech=$(echo "$rech" | sed 's/^/+/;s/ /+/g')
xdg-open https://www.google.fr/search?q=site:forum.ubuntu-fr.org"$rech"
elif  [ "$moteur" = "Google fr" ]
then
rech=$(echo "$rech" | sed 's/^/+/;s/ /+/g')
xdg-open https://www.google.fr/search?q="$rech"\&lr=lang_fr
fi
}
export -f _recherche
#####lancement
yad --notification --no-middle --title="Recherche internet" --command="bash -c _commande" --text="Recherche internet" --image="search" --menu='Quitter!quit!exit'

Une boite à onglets.

#!/bin/bash
#####ID --KEY Création aléatoire de l'id 
id=$(($RANDOM % ($((10000 - 32000)) + 1) + 10000))
##########Onglet 1##########
#####Avec une colonne#######
yad --plug="$id" --tabnum=1 --form --columns="1" --item-separator='!' --focus-field="1" --dialog-sep --align="center" \
--field="Fichier d'entrée:FL" "$HOME" \
--field=":LBL" "" \
--field="Fichier de sortie:SFL" "" \
&> /tmp/data1 &
##########Onglet 2##########
#####Avec 3 colonnes########
yad --plug="$id" --tabnum=2 --form --columns="3" --item-separator='!' --focus-field="2" --dialog-sep --align="center" \
--field="<span weight='Bold' foreground='black'>Du texte.</span>:LBL" "" \
--field="motif:" "" \
--field="bouton avec relief:FBTN" '' \
--field="Bouton sans relief:BTN" '' \
--field="bouton avec relief:FBTN" '' \
--field="Bouton sans relief:BTN" '' \
&> /tmp/data2 &
yad --notebook --width="900" --height="700" --center --title="yad notebook" --window-icon="gnome-util" --key="$id" \
--tab="onglet 1" --tab="Onglet 2" \
--button="gtk-cancel:1" \
--button="gtk-ok:0"
fermernotebook=$?
if [ $fermernotebook -eq 252 ]
then
exit
elif [ $fermernotebook -eq 1 ]
then
exit
fi

Des cases à cocher. Choisir un item dans une liste :

#!/bin/bash
# Affichage du contenu du fichier sélectionné
function usage {
echo "Affichage du contenu du fichier sélectionné"
echo "Un unique fichier sélectionné"
echo "affichage par cat"
}
if [[ "$1" == "-h" ]] || [[ "$1" == "-help" ]] || [[ "$1" == "-aide" ]]; then 
  usage
else
  retour=$(yad --title="Fichier à afficher" --width 800 --height 200 --text-align="center" --list --radiolist --column="Sélectionné" --column="Fichier" --column="Mis à jour" --column="Utillisé" False "$HOME/Documents/FichierUn" "Non" "Non" False "$HOME/Documents/FichierDEux" "Oui" "Non" True "$HOME/Documents/FichierTrois" "Oui" "Non")
  cat "$(echo "$retour" | cut -d'|' -f2)"
fi

Et pour pourvoir sélectionner plusieurs lignes à la fois :

retour=$(yad --title="Fichier à afficher" --width 800 --height 200 --text-align="center" --list --checklist --column="Sélectionné" --column="Fichier" --column="Mis à jour" --column="Utillisé" False "/home/usr/Documents/FichierUn" "Non" "Non" False "/home/usr/Documents/FichierDEux" "Oui" "Non" True "/home/usr/Documents/FichierTrois" "Oui" "Non")
lesFichiers=$(echo "$retour" | cut -d'|' -f2)
for i in $lesFichiers; do 
  cat "$i"; 
done

Le langage de Markup Pango est un langage de mise en forme très simple qui est supporté par Yad. Il permet de mettre en forme le texte via des balises <span></span>.

Quelques balises inspirées du html existent aussi (sans balise <span>) : <b> pour gras, <u> pour souligné …

La liste des balises autorisées se trouvent ici : https://developer.gnome.org/pygtk/stable/pango-markup-language.html

Exemples :

font_desc : --text="une <span font_desc='Sans italic 10'>Maison</span> neuve" affiche le mot maison dans une police sans, en italique, avec une taille de 10.

font_desc : --text="une <span font_desc='Sans italic 10' strikethrough='true'>Maison</span> neuve" affiche le mot maison dans une police sans, en italique, avec une taille de 10 et barrée (strikethrough)

souligné : --text="une <u>Maison</u> neuve" affiche le mot maison en souligné.

Voilà le code (testable) renvoyé par yad quand on appuie sur certains boutons pour quitter une boite de dialogue :

0 : L'utilisateur a appuyé sur le bouton OK

1 : L'utilisateur a appuyé sur le bouton Annuler

70 : La boîte de dialogue a été fermée parce que le délai d'attente a été atteint. (Dans le cas d'un timeout)

252 : La boîte de dialogue a été fermée en appuyant sur la touche Echap ou en cliquant sur le bouton de fermeture de la barre du titre de la boîte de dialogue

Les codes de sortie pour les boutons créés par l'utilisateur doivent être spécifiés dans la ligne de commande. Le code de sortie spécifié sera imprimé comme résultat .

#!/bin/bash

yad  --title="Tests sur les boutons." --window-icon="yad" --width="200" --height="200" --center --text="<span font_desc='Ubuntu Mono Bold Italic 12' foreground='#14006c'>Cliquez sur le bouton\nValider.</span>" --text-align="center"
echo "$?"

yad  --title="Tests sur les boutons." --window-icon="yad" --width="200" --height="200" --center --text="<span font_desc='Ubuntu Mono Bold Italic 12' foreground='#14006c'>Cliquez sur le bouton\nAnnuler.</span>" --text-align="center"
echo "$?"

yad  --title="Tests sur les boutons." --window-icon="yad" --width="200" --height="200" --center --text="<span font_desc='Ubuntu Mono Bold Italic 12' foreground='#14006c'>Appuyez sur la touche\nEchap.</span>" --text-align="center"
echo "$?"

yad  --title="Tests sur les boutons." --window-icon="yad" --width="200" --height="200" --center --text="<span font_desc='Ubuntu Mono Bold Italic 12' foreground='#14006c'>Cliquer sur le bouton de\nfermeture de la barre du titre.</span>" --text-align="center"
echo "$?"

yad  --title="Tests sur les boutons." --window-icon="yad" --width="200" --height="200" --center --text="<span font_desc='Ubuntu Mono Bold Italic 12' foreground='#14006c'>Tests sur les\nboutons standard.</span><span font_desc='Ubuntu Mono Bold Italic 15' foreground='#000000'>\n\nTimeout\n\n</span>" --text-align="center" --timeout="5" --timeout-indicator=top --undecorated --no-buttons
echo "$?"

Comme vous le constatez la fenêtre se ferme mais le script continu.

Personnellement lorsque je clique sur le bouton de fermeture, le bouton Annuler ou la touche Echap je veux arrêter le script.

Pour ce faire nous allons utiliser la variable bash $? qui contient le code de retour de la dernière opération.

Je me sers de la structure case mais Il existe d'autres méthodes.

#!/bin/bash

yad  --title="Tests sur les boutons." --window-icon="yad" --width="200" --height="200" --center --text="<span font_desc='Ubuntu Mono Bold Italic 12' foreground='#14006c'>Cliquez sur le bouton\nValider.</span>" --text-align="center"
case $? in
    1)
    exit;;
    70)
    exit;;
    252)
    exit;;
esac

yad  --title="Tests sur les boutons." --window-icon="yad" --width="200" --height="200" --center --text="<span font_desc='Ubuntu Mono Bold Italic 12' foreground='#14006c'>Cliquez sur le bouton\nAnnuler.</span>" --text-align="center"
echo "$?"

Il y a deux types de comportements:

Si la sortie est numérique, la fenêtre se ferme.

Si la sortie est non numérique, la fenêtre reste ouverte.

yad --width="300" --height="300" --text='Boutons standards:\nla sortie sera 0, 1, 70 ou 252'
yad --width="300" --height="300" --text="Bouton personnalisé:\nLa fenêtre s'est fermée car la sortie est numérique.\n Le bouton ci-dessous ne fermera pas la fenêtre\ncar la sortie n'est pas numérique mais le bouton de fermeture de la fenêtre et la touche d'échappement fermeront la fenêtre car les sorties sont numériques." --button='add:echo "La fenêtre reste ouverte."'

Pour personnaliser les boutons vous pouvez:

Utiliser ceux prédéfinis gtk-stock (ex: gtk-close ou gtk-ok).

Définir vos propres options sous la forme LABEL[!ICON[!TOOLTIP]] où LABEL est le texte du bouton, ICON est l'icone du bouton et TOOLTIP est le texte qui s'affichera au survol du bouton (Le séparateur par défaut est "!".

yad --width="300" --height="300" --text="Bouton personnalisé avec gtk-add." --button='gtk-add:0"'
yad --width="300" --height="300" --text="Bouton personnalisé avec LABEL[!ICON[!TOOLTIP]]." --button='Mon bouton!search!Ceci est mon bouton personnalisé:0"'

L’icône peut être définie par son chemin complet ou par une icône système (Dans mon exemple "search".).

Il est possible d'affecter une action à un bouton yad.

yad --form --field "Bouton 1:btn" --field "Bouton 2:btn" --field "Bouton 3:btn" "echo 'bouton n°1 cliqué'" "echo 'bouton n°2 cliqué'" "echo 'bouton n°3 cliqué'"

Dans cet exemple simple, l'appui sur un bouton déclenche l'affichage d'un message simple. Il est possible d'aller un peu plus loin en activant une fonction personnalisée ou un script bash.

function bonjour () { echo "Bonjour ""$USER""."; PidYad=$(pgrep yad); echo "Le pid de Yad est ""$PidYad"; }
export -f bonjour
yad --form --field "bonjour:btn" "bash -c bonjour"

Dans cet autre exemple, on crée une fonction toute simple qui affiche le nom de l'utilisateur ainsi que le numéro d'identification du processus affecté à yad. Cette fonction est ensuite appelée par le bouton personnalisé yad.

Ce numéro pid (process identification digit) peut être utilisé pour fermer la fenêtre yad si le bouton appelle un script. En effet, comme indiqué ci-dessus, si la sortie du bouton n'est pas numérique, l'appui sur le bouton ne permet pas de fermer la fenêtre. Avec cette astuce, il est possible de combiner les deux actions. Exemple :

function ferme_yad () { bonjour ; PidYad=$(pgrep yad); kill -s SIGUSR1 "$PidYad";}
export -f ferme_yad
yad --form --field "bonjour:btn" "bash -c ferme_yad"

Dans les boîtes multiples la sortie standard sera de type champ1|champ2|champ3| où "|" est le séparateur par défaut. Pour récupérer les champs il est donc pratique d'utiliser awk et les variables.

#Envoi de la sortie dans une variable.
champs=$(yad --title="Mon titre" --text="Mon texte." --text-align="center" \
--form \
--field="champ 1:" '' \
--field="champ 2:" '' \
--field="champ 3:" '')
echo "$champs"
#Récupération des champs avec awk.
champ1=$(echo $champs | awk 'BEGIN {FS="|" } { print $1 }')
champ2=$(echo $champs | awk 'BEGIN {FS="|" } { print $2 }')
champ3=$(echo $champs | awk 'BEGIN {FS="|" } { print $3 }')
#Affichage des champs.
echo "$champ1"
echo "$champ2"
echo "$champ3"

Une autre méthode consiste à éclater l'ensemble des valeurs dans un tableau en modifiant temporairement la valeur de la variable interne bash $IFS qui détermine le séparateur par défaut (en général l'espace).

usr@pc:~$ ANC_IFS="$IFS"; IFS='|' read -ra LesParametres <<< "$retour" ; IFS="$ANC_IFS"
usr@pc:~$ echo "Champs 1 : ""${LesParametres[0]}"
usr@pc:~$ echo "Champs 2 : ""${LesParametres[1]}"
usr@pc:~$ echo "Champs 3 : ""${LesParametres[2]}"

Explications :

• ANC_IFS="$IFS" : stockage de la valeur initiale de $IFS dans une nouvelle variable $ANC_IFS
• IFS='|' : la valeur de $IFS est fixée à |, le caractère de séparation des champs à la sortie de yad
• read -ra LesParametres «< "$retour" : affecte l'ensemble des champs dans le tableau $LesParametres. La valeur du premier champ de $retour est insérée dans la case d'indice 0 de $LesParametres, celle du deuxième champ dans la case d'indice 1 et ainsi de suite
• IFS="$ANC_IFS" : la valeur initiale de $IFS est rétablie
• Pour accéder à la valeur de chaque champ, il suffit d'accéder à la case d'indice correspondant dans le tableau $LesParametres qui est affichée par ${LesParametres[i]} ou i est l'indice de la case.

L'utilisation de fenêtres gtk génère l'affichage d'un message d'erreur dans la console.

usr@pc:~/Rep$ Gtk-Message: GtkDialog mapped without a transient parent. This is discouraged.

Ce message est bien connu et ne correspond pas à une erreur grave. Pour s'en débarrasser, il est conseillé de rediriger les erreurs vers /dev/null.

usr@pc:~/Rep$  yad --title "Exemple simple"  2>/dev/null

Pour supprimer cette application, il suffit de supprimer son paquet. Selon la méthode choisie, la configuration globale de l'application est conservée ou supprimée. Les journaux du système, et les fichiers de préférence des utilisateurs dans leurs dossiers personnels sont toujours conservés.

• (en) Manuel des fonctions
• (en) Exemples simples de toutes les fonctions de base (Recommandé)
• (en) Site officiel avec exemples d'applications
• (en) Forum de discussion. L'auteur participe.
• (en) Exemples sur les boutons
• (en) Exemples sur les items multiples
• (en) Ajouter Yad à vos scripts Python (non testé)

Contributeurs principaux : sergeG75018, LukePerp., amiralgaby

Basé sur « les pages du manuel ».