doc zenity
This commit is contained in:
gwen
parent
a67aab3002
commit
f22b59c29a
2 changed files with 338 additions and 0 deletions
195
doc/Zenity1.md
Normal file
195
doc/Zenity1.md
Normal file
|
|
@ -0,0 +1,195 @@
|
|||
je me souviens d'une librairie sous linux gnome (donc gtk je pense) qui à partir d'une commande terminal avec paramètres, affichait une widget. Une espèce de generative ui pilotée depuis le terminal. est-ce que tu pourrais m'en dire plus ?
|
||||
existe-t-il d'autres libs de ce type ? laquelle me conseilles tu ?
|
||||
|
||||
---
|
||||
|
||||
Ce que tu décris est très probablement **YAD** (*Yet Another Dialog*), ou éventuellement **Zenity**. Ce ne sont pas vraiment des bibliothèques, mais des programmes qui permettent de créer des fenêtres et des widgets GTK depuis une commande shell, avec les valeurs de retour et les événements transmis au terminal. YAD est le candidat le plus probable si tu te souviens d’une interface relativement riche ou « générative ». [packages.debian](https://packages.debian.org/experimental/utils/yad)
|
||||
|
||||
## Le candidat principal : YAD
|
||||
|
||||
YAD permet de construire des dialogues GTK depuis Bash :
|
||||
|
||||
```bash
|
||||
yad \
|
||||
--form \
|
||||
--title="Configuration" \
|
||||
--field="Nom" \
|
||||
--field="Actif":CHK \
|
||||
--field="Mode":CB \
|
||||
--button="Annuler":1 \
|
||||
--button="Valider":0
|
||||
```
|
||||
|
||||
La valeur saisie est généralement renvoyée sur la sortie standard, par exemple sous forme de champs séparés par `|`.
|
||||
|
||||
Quelques exemples :
|
||||
|
||||
```bash
|
||||
# Message
|
||||
yad --info --title="Terminé" --text="La génération est terminée."
|
||||
|
||||
# Question
|
||||
if yad --question --text="Continuer ?"; then
|
||||
echo "Oui"
|
||||
fi
|
||||
|
||||
# Formulaire
|
||||
result=$(yad --form \
|
||||
--field="Utilisateur" \
|
||||
--field="Mot de passe":H \
|
||||
--separator="|")
|
||||
|
||||
IFS='|' read -r user password <<< "$result"
|
||||
|
||||
# Liste
|
||||
yad --list \
|
||||
--title="Fichiers" \
|
||||
--column="Nom" \
|
||||
--column="Taille" \
|
||||
fichier1.txt 12K \
|
||||
fichier2.txt 25K
|
||||
```
|
||||
|
||||
YAD prend en charge beaucoup plus de types de dialogues que Zenity : formulaires, listes, arbres, texte, HTML selon la compilation, calendrier, sélection de fichiers, barres de progression, menus, onglets et interactions avec des pipes. Il dépend principalement de GTK et sa version actuelle demande GTK 3.22 ou supérieur. [github](https://github.com/v1cont/yad)
|
||||
|
||||
Sur Debian ou Ubuntu :
|
||||
|
||||
```bash
|
||||
sudo apt install yad
|
||||
```
|
||||
|
||||
La version du projet indique une release 14.2 publiée en novembre 2025, mais le rythme de maintenance reste relativement modéré. [github](https://github.com/v1cont/yad)
|
||||
|
||||
## Zenity : la version GNOME classique
|
||||
|
||||
**Zenity** est probablement le nom que tu as pu rencontrer dans des scripts GNOME. Il fournit des dialogues simples :
|
||||
|
||||
```bash
|
||||
zenity --info --text="Bonjour"
|
||||
|
||||
zenity --question --text="Supprimer le fichier ?"
|
||||
|
||||
zenity --entry \
|
||||
--title="Nom du projet" \
|
||||
--text="Saisir un nom :"
|
||||
|
||||
zenity --list \
|
||||
--checklist \
|
||||
--column="Sélectionné" \
|
||||
--column="Nom" \
|
||||
FALSE "Projet A" \
|
||||
TRUE "Projet B"
|
||||
```
|
||||
|
||||
Zenity est très pratique pour ajouter rapidement une petite interface graphique à un script Bash. En revanche, il est moins flexible que YAD pour créer une interface composée ou réagir dynamiquement à des actions utilisateur. Zenity est présenté comme une réécriture GTK de `gdialog`, l’ancien outil de dialogues graphiques GNOME. [ostechnix](https://ostechnix.com/zenity-create-gui-dialog-boxes-in-bash-scripts/)
|
||||
|
||||
Je le choisirais dans les cas suivants :
|
||||
|
||||
- une boîte d’information ou de confirmation ;
|
||||
- demander une valeur à l’utilisateur ;
|
||||
- sélectionner un fichier, une date ou une entrée dans une liste ;
|
||||
- éviter toute dépendance ou syntaxe trop spécifique à YAD.
|
||||
|
||||
## Les autres solutions intéressantes
|
||||
|
||||
| Outil | Technologie | Niveau de richesse | Cas d’usage |
|
||||
|---|---|---:|---|
|
||||
| `zenity` | GTK | Faible à moyen | Dialogues simples et scripts GNOME |
|
||||
| `yad` | GTK 3 | Moyen à élevé | Formulaires, listes, mini-applications Bash |
|
||||
| `gtkdialog` | GTK + XML | Élevé | Décrire une interface entière en XML depuis Bash |
|
||||
| `AdwDialog` | GTK 4 + libadwaita | Faible à moyen | Dialogues modernes cohérents avec GNOME |
|
||||
| `gtkdialog`/forks divers | GTK | Variable | Projets anciens ou spécialisés |
|
||||
| `pygobject` | GTK directement depuis Python | Très élevé | Application réelle et interface complètement dynamique |
|
||||
| `gtk4-rs` | GTK 4 depuis Rust | Très élevé | Application robuste et distribuable |
|
||||
| `QML`/Qt | Qt Quick | Très élevé | Interface déclarative et fortement dynamique |
|
||||
|
||||
### gtkdialog
|
||||
|
||||
**gtkdialog** est peut-être ce que tu as en tête si tu te souviens d’une interface décrite dans un fichier ou une chaîne XML. Il permet de définir des widgets GTK depuis Bash, par exemple avec des balises représentant des fenêtres, boutons, entrées, listes ou terminal embarqué. Il expose même un widget terminal basé sur `VteTerminal`. [fossies](https://fossies.org/linux/gtkdialog/doc/reference/terminal.html)
|
||||
|
||||
Son intérêt est sa capacité à décrire une interface plus complète qu’avec Zenity :
|
||||
|
||||
```xml
|
||||
<window title="Mon outil">
|
||||
<vbox>
|
||||
<text>
|
||||
<label>Paramètres</label>
|
||||
</text>
|
||||
<entry>
|
||||
<variable>NAME</variable>
|
||||
</entry>
|
||||
<button ok>
|
||||
<action>EXIT:0</action>
|
||||
</button>
|
||||
</vbox>
|
||||
</window>
|
||||
```
|
||||
|
||||
Mais je serais prudent : c’est un outil plus ancien, moins standard aujourd’hui, avec une maintenance et une disponibilité variables selon les distributions.
|
||||
|
||||
### AdwDialog
|
||||
|
||||
Pour GTK 4 et GNOME moderne, **AdwDialog** est une petite solution qui permet d’afficher des dialogues `libadwaita` depuis le terminal et des scripts. Sa syntaxe est volontairement limitée : titre, description, icône et type de dialogue. [github](https://github.com/Vanilla-OS/AdwDialog)
|
||||
|
||||
```bash
|
||||
adwdialog \
|
||||
--title "Mise à jour terminée" \
|
||||
--description "Le système est à jour." \
|
||||
--type info
|
||||
```
|
||||
|
||||
C’est intéressant pour l’intégration visuelle GNOME, mais ce n’est pas un équivalent complet de YAD : le projet est beaucoup plus petit et ne semble pas viser la génération de formulaires complexes. `libadwaita` fournit par ailleurs des widgets et des comportements adaptés aux recommandations GNOME et aux différentes tailles d’écran. [gtk-rs](https://gtk-rs.org/gtk4-rs/stable/latest/book/libadwaita.html)
|
||||
|
||||
## Ma recommandation
|
||||
|
||||
Pour ton profil de générateur de logiciels, je choisirais :
|
||||
|
||||
1. **YAD** pour prototyper rapidement une interface pilotée par Bash.
|
||||
2. **GTKDialog** si tu veux une interface XML plus structurée et que tu acceptes un outil plus ancien.
|
||||
3. **PyGObject + GTK 4/libadwaita** pour un véritable générateur d’interfaces dynamiques.
|
||||
4. **AdwDialog** uniquement pour quelques dialogues GNOME simples.
|
||||
|
||||
En pratique, YAD constitue le meilleur compromis :
|
||||
|
||||
```bash
|
||||
#!/usr/bin/env bash
|
||||
|
||||
while true; do
|
||||
choice=$(yad --list \
|
||||
--title="Outil de génération" \
|
||||
--text="Que souhaitez-vous faire ?" \
|
||||
--column="Action" \
|
||||
"Créer un projet" \
|
||||
"Configurer le projet" \
|
||||
"Quitter" \
|
||||
--height=250 \
|
||||
--width=400 \
|
||||
--print-column=1) || exit 0
|
||||
|
||||
case "$choice" in
|
||||
"Créer un projet")
|
||||
yad --form \
|
||||
--title="Nouveau projet" \
|
||||
--field="Nom du projet" \
|
||||
--field="Langage":CB "Python!Rust!Go" \
|
||||
--field="Créer un dépôt":CHK
|
||||
;;
|
||||
"Configurer le projet")
|
||||
yad --info --text="Configuration en cours..."
|
||||
;;
|
||||
"Quitter")
|
||||
exit 0
|
||||
;;
|
||||
esac
|
||||
done
|
||||
```
|
||||
|
||||
Le point important est la distinction suivante :
|
||||
|
||||
- **YAD/Zenity** génèrent des dialogues prêts à l’emploi ;
|
||||
- **GTKDialog** décrit une interface plus complète depuis XML ;
|
||||
- **PyGObject ou Rust/GTK** te donnent réellement accès à l’arbre de widgets, aux signaux, au binding de données et à la mise à jour dynamique.
|
||||
|
||||
Donc, si tu te souvenais d’une commande du genre `yad --form`, `yad --list` ou `yad --notebook`, c’était probablement **YAD**. Si tu te souvenais de balises XML comme `<window>`, `<vbox>`, `<button>` et `<entry>`, c’était plutôt **gtkdialog**.
|
||||
|
||||
|
||||
143
doc/Zenity2.md
Normal file
143
doc/Zenity2.md
Normal file
|
|
@ -0,0 +1,143 @@
|
|||
|
||||
je veux créer un script python avec Yad ou Zenity pour afficher des widgets dynamiques depuis une commande CLI
|
||||
|
||||
---
|
||||
|
||||
Créer un script Python qui utilise **Yad** ou **Zenity** pour afficher des widgets dynamiques depuis la ligne de commande est une excellente idée pour des interfaces graphiques simples et interactives. Voici comment procéder pour chaque outil, avec des exemples concrets et des explications.
|
||||
|
||||
---
|
||||
|
||||
## 1. **Zenity (plus simple, souvent préinstallé sur GNOME)**
|
||||
|
||||
Zenity permet de créer des boîtes de dialogue GTK depuis un script shell ou Python. Voici un exemple de base :
|
||||
|
||||
### Exemple : Boîte de dialogue avec entrée utilisateur
|
||||
```python
|
||||
import subprocess
|
||||
|
||||
def zenity_entry(title, text):
|
||||
cmd = ["zenity", "--entry", "--title", title, "--text", text]
|
||||
result = subprocess.run(cmd, capture_output=True, text=True)
|
||||
return result.stdout.strip()
|
||||
|
||||
def zenity_list(title, columns, data):
|
||||
cmd = ["zenity", "--list", "--title", title, "--column", columns[0], "--column", columns[1]]
|
||||
cmd.extend(data)
|
||||
result = subprocess.run(cmd, capture_output=True, text=True)
|
||||
return result.stdout.strip()
|
||||
|
||||
# Exemple d'utilisation
|
||||
if __name__ == "__main__":
|
||||
name = zenity_entry("Saisie", "Entrez votre nom :")
|
||||
if name:
|
||||
options = ["Option 1", "Val1", "Option 2", "Val2"]
|
||||
choice = zenity_list("Choix", ["Option", "Valeur"], options)
|
||||
print(f"Vous avez choisi : {choice}")
|
||||
```
|
||||
|
||||
### Autres widgets Zenity
|
||||
- `--info` : Boîte d'information
|
||||
- `--warning` : Boîte d'avertissement
|
||||
- `--error` : Boîte d'erreur
|
||||
- `--progress` : Barre de progression
|
||||
- `--file-selection` : Sélecteur de fichier
|
||||
- `--calendar` : Sélecteur de date
|
||||
|
||||
---
|
||||
|
||||
## 2. **Yad (plus puissant, plus de widgets)**
|
||||
|
||||
Yad est une alternative à Zenity avec plus de fonctionnalités (onglets, tableaux, HTML, etc.). Il n'est pas toujours préinstallé, mais très puissant.
|
||||
|
||||
### Installation (si nécessaire)
|
||||
```bash
|
||||
sudo apt install yad # Debian/Ubuntu
|
||||
sudo dnf install yad # Fedora
|
||||
```
|
||||
|
||||
### Exemple : Formulaire avec Yad
|
||||
```python
|
||||
import subprocess
|
||||
|
||||
def yad_form(title, fields):
|
||||
cmd = ["yad", "--form", "--title", title]
|
||||
for field in fields:
|
||||
cmd.extend(["--field", f"{field['label']}:{field['type']}"])
|
||||
result = subprocess.run(cmd, capture_output=True, text=True)
|
||||
return result.stdout.strip().split("|")
|
||||
|
||||
# Exemple d'utilisation
|
||||
if __name__ == "__main__":
|
||||
fields = [
|
||||
{"label": "Nom", "type": "txt"},
|
||||
{"label": "Âge", "type": "num"},
|
||||
{"label": "Date", "type": "date"},
|
||||
{"label": "Fichier", "type": "file"},
|
||||
]
|
||||
data = yad_form("Formulaire", fields)
|
||||
print("Données saisies :", data)
|
||||
```
|
||||
|
||||
### Autres widgets Yad
|
||||
- `--list` : Liste personnalisable
|
||||
- `--tree` : Arbre hiérarchique
|
||||
- `--notebook` : Onglets
|
||||
- `--html` : Affichage HTML
|
||||
- `--progress` : Barre de progression avancée
|
||||
- `--color` : Sélecteur de couleur
|
||||
|
||||
---
|
||||
|
||||
## 3. **Exemple complet : Menu interactif avec Yad**
|
||||
Voici un script Python qui affiche un menu interactif avec Yad, puis agit en fonction du choix de l'utilisateur :
|
||||
|
||||
```python
|
||||
import subprocess
|
||||
|
||||
def yad_menu(title, options):
|
||||
cmd = ["yad", "--list", "--title", title, "--column", "Choix", "--width=400", "--height=300"]
|
||||
cmd.extend(options)
|
||||
result = subprocess.run(cmd, capture_output=True, text=True)
|
||||
return result.stdout.strip().split("|")[0]
|
||||
|
||||
def yad_info(title, text):
|
||||
subprocess.run(["yad", "--info", "--title", title, "--text", text, "--width=300"])
|
||||
|
||||
if __name__ == "__main__":
|
||||
options = ["Ouvrir un fichier", "Enregistrer", "Quitter"]
|
||||
choice = yad_menu("Menu Principal", options)
|
||||
if choice == "Ouvrir un fichier":
|
||||
file = subprocess.run(["yad", "--file", "--title", "Sélectionnez un fichier"], capture_output=True, text=True).stdout.strip()
|
||||
yad_info("Fichier sélectionné", f"Vous avez choisi : {file}")
|
||||
elif choice == "Enregistrer":
|
||||
yad_info("Enregistrement", "Fonctionnalité à implémenter")
|
||||
elif choice == "Quitter":
|
||||
exit(0)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 4. **Gestion des erreurs et conseils**
|
||||
- **Vérifiez la présence de Yad/Zenity** :
|
||||
```python
|
||||
import shutil
|
||||
if not shutil.which("yad"):
|
||||
print("Yad n'est pas installé. Installez-le avec : sudo apt install yad")
|
||||
```
|
||||
- **Utilisez `subprocess.run`** avec `capture_output=True` et `text=True` pour récupérer la sortie.
|
||||
- **Testez toujours** vos commandes Yad/Zenity en ligne de commande avant de les intégrer en Python.
|
||||
|
||||
---
|
||||
|
||||
## 5. **Aller plus loin**
|
||||
- **Yad** : [Documentation officielle](https://sourceforge.net/p/yad-dialog/wiki/Home/)
|
||||
- **Zenity** : [Documentation GNOME](https://help.gnome.org/users/gnome-help/3.32/util-zenity.html)
|
||||
|
||||
---
|
||||
|
||||
### Quel outil choisir ?
|
||||
- **Zenity** : Simple, léger, idéal pour des boîtes de dialogue basiques.
|
||||
- **Yad** : Plus puissant, pour des interfaces complexes (formulaires, onglets, etc.).
|
||||
|
||||
---
|
||||
**Veux-tu un exemple plus spécifique (barre de progression, tableau, etc.) ou as-tu une idée précise de ce que tu veux afficher ?**
|
||||
Loading…
Reference in a new issue