Créez votre première interface graphique en Python avec Glade et GTK+

par
Tweetez
Partagez
Enregistrer
Partagez
Partagez
0 Partages

Points clés à retenir

  • Les développeurs Python peuvent utiliser GTK+ et Glade pour créer des interfaces graphiques intuitives à l’aide d’une interface visuelle.
  • La configuration de l’environnement pour cet exemple implique l’installation de Python, GTK+, Glade et PyGObject.
  • L’utilisation de GTK+ et Glade pour le développement d’interfaces graphiques Python accélère le processus et sépare la conception de l’interface graphique du code.

Python est un langage accessible, parfait pour l’analyse de données et le développement Web. Mais c’est également un excellent choix pour le développement d’applications GUI. GTK+ et Glade simplifient le processus de création d’applications multiplateformes simples.

GTK+ et Glade Interface Designer pour les développeurs Python

GTK+ (GIMP Toolkit) et Glade Interface Designer sont une formidable combinaison pour les développeurs Python qui souhaitent créer des interfaces utilisateur graphiques intuitives et agréables.

GTK+ est une boîte à outils multiplateforme que vous pouvez utiliser pour le développement d’interfaces graphiques. Il est compatible avec une variété de systèmes d’exploitation, notamment Linux, Windows et macOS.

Glade Interface Designer, un outil compagnon de GTK+, vous permet de concevoir des interfaces graphiques sans avoir à écrire de code de mise en page. Vous pouvez l’utiliser pour créer une interface graphique dans un environnement WYSIWYG en quelques clics et de simples fonctions glisser-déposer.

Configuration de votre environnement Python pour le développement GTK+ et Glade

La configuration de votre environnement est une première étape essentielle pour garantir un flux de travail fluide et efficace.

1. Installez Python

Commencez par vous assurer que Python est installé sur votre système. Vous verrez du code Python 3 dans les exemples que vous lisez, car il offre une meilleure prise en charge et une meilleure intégration pour GTK+ et Glade. Pour Linux et macOS, Python est généralement préinstallé.

Les utilisateurs Windows peuvent télécharger Python depuis le site officiel de Python.

2. Installez GTK+

Vous pouvez installer GTK+ à l’aide d’un gestionnaire de packages.

Pour les systèmes Linux basés sur Ubuntu et Debian, utilisez :

 sudo apt-get install libgtk-3-dev

Pour Fedora et similaire :

 sudo dnf install gtk3-devel

Sur macOS, en utilisant Homebrew :

 brew install gtk+3

Les utilisateurs Windows peuvent télécharger GTK+ depuis Page de téléchargement officielle de GTK. Mais si MSYS2 est installé, vous pouvez ouvrir la ligne de commande MSYS2 et utiliser cette commande :

 pacman -S mingw-w64-x86_64-python-gobject

3. Installez Glade

Vous pouvez utiliser la ligne de commande pour installer Glade.

Pour les distributions Linux basées sur Ubuntu et Debian :

 sudo apt-get install glade

Sur Fedora :

 sudo dnf install glade

Les utilisateurs de macOS peuvent utiliser Homebrew :

 brew install glade

Les utilisateurs Windows peuvent utiliser la commande suivante avec MSYS2 :

 pacman -S mingw-w64-x86_64-glade

4. Liaisons Python pour GTK+

Installez PyGObject pour intégrer GTK+ à Python. La commande que vous utiliserez pour cela est :

 pip install PyGObject

S’il y a une erreur telle que « La roue de construction pour pycairo (pyproject.toml) n’a pas été exécutée » lors de l’installation de PyGObject, vous devrez également installer le package cairo.

Pour les distributions Linux basées sur Ubuntu et Debian :

 sudo apt-get install libcairo2-dev

Pour Fedora :

 sudo yum install cairo-devel

Sur macOS :

 brew install pygobject3

5. Configuration d’un environnement virtuel (facultatif)

C’est une bonne pratique d’utiliser un environnement virtuel pour vos projets Python. Cela isole les dépendances de votre projet. Créez et activez un environnement virtuel sous Linux avec ces commandes de terminal :

 python -m venv myenv
source myenv/bin/activate

Sous Windows, utilisez :

 python -m venv myenv
myenv\Scripts\activate

Sur macOS, pour garantir que l’environnement virtuel peut accéder aux packages qui installent Brew, utilisez :

 python -m venv --system-site-packages myenv
source myenv/bin/activate

6. Vérification de l’installation

Pour vérifier que GTK+ et Glade sont installés, créez un simple script Python qui importe GTK :

 import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
print("GTK+ version:", Gtk.get_major_version(), Gtk.get_minor_version())

Lorsque vous exécutez ce script, il affichera la version GTK+ installée. Si tout se passe bien, vous avez configuré votre environnement de développement.

Création d’une application GUI simple avec Glade Interface Designer et Python

Vous pouvez concevoir votre application GUI dans Glade Interface Designer et exporter la mise en page sous forme de fichier de projet. Vous pouvez ensuite accéder à ce fichier de projet à partir de votre code Python.

Concevoir votre interface graphique avec Glade

L’interface glisser-déposer de Glade permet de se concentrer facilement sur la conception sans s’enliser dans le code sous-jacent. Démarrez Glade à partir du menu d’application ou de la ligne de commande de votre système avec cette commande :

 glade

Vous devriez voir l’interface Glade où vous pouvez commencer à créer votre disposition GUI.

Le bouton Créer un nouveau projet en haut à gauche fournit une toile vierge pour la conception de votre interface graphique. Glade propose une grande variété de widgets dans sa barre supérieure, notamment des boutons, des entrées de texte et des étiquettes. Faites glisser ces widgets sur votre canevas pour commencer à styliser votre interface graphique. Vous pouvez redimensionner et positionner les widgets en fonction de vos besoins de conception.

Tout d’abord, sélectionnez le widget GtkWindow dans le menu Toplevels :

Sur la page Général dans la barre de droite de Glade, vous verrez une option d’identification. Cet identifiant est le nom unique du widget que vous avez ajouté. Pour cet exemple, attribuez l’ID myMainWindow au GtkWindow que vous avez ajouté.

Vous pouvez maintenant ajouter des widgets à la fenêtre principale que vous avez créée. Accédez à Conteneurs dans la barre supérieure, sélectionnez le widget GtkBox et faites-le glisser vers votre espace de travail. Donnez-lui ensuite un identifiant, myMainBox.

Après avoir ajouté le widget GtkBox, vous verrez diverses options à droite de votre espace de travail spécifiques à ce widget. Vous pouvez modifier l’intégralité de votre conception ici sans écrire de code.

Ensuite, ajoutez un widget de contrôle à votre conception. Pour ce faire, allez dans Control dans la barre supérieure, sélectionnez GtkButton comme exemple et faites-le glisser n’importe où dans la GtkBox. Donnez-lui un identifiant, myButton. Si vous le souhaitez, vous pouvez également modifier le texte du bouton à l’aide de l’onglet Général dans le panneau de droite.

GtkButton est un widget cliquable, vous pouvez donc définir un gestionnaire Python pour celui-ci et écrire le code approprié plus tard. Accédez à l’onglet Signaux dans le menu de droite et spécifiez un gestionnaire pour le signal cliqué. Pour cet exemple, appelez-le on_button_clicked.

Vous pouvez maintenant enregistrer votre conception GUI en tant que fichier de projet. Enregistrez le fichier sous myDesign.glade.

Utilisation du fichier de conception Glade à partir du code Python

Créez un fichier app.py dans le même répertoire que votre fichier myDesign.glade. Collez le code suivant dans ce fichier :

 import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from gi.repository import Gdk
class MyApp:
    def __init__(self):
        
        self.builder = Gtk.Builder()
        self.builder.add_from_file("myDesign.glade")
        
        self.window = self.builder.get_object("myMainWindow")
        self.window.connect("destroy", Gtk.main_quit)
        
        self.button = self.builder.get_object("myButton")
        self.button.connect("clicked", self.on_button_clicked)
        
        self.color_toggle = False
    def on_button_clicked(self, widget):
        
        color = "#FF0000" if self.color_toggle else "#00FF00"
        self.window.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(color))
        self.color_toggle = not self.color_toggle
    def run(self):
        self.window.show_all()
        Gtk.main()
if __name__ == "__main__":
    app = MyApp()
    app.run()

Ce code changera la couleur du fond à chaque fois que vous cliquerez sur le bouton. Notez les appels à self.builder.get_object() qui transmettent les ID des widgets que vous avez définis dans Glade.

Exécutez votre script Python à l’aide de cette commande pour voir le résultat :

 python3 app.py

Avantages de l’utilisation de GTK+ et Glade pour le développement d’interfaces graphiques Python

L’utilisation de GTK+ et Glade pour le développement d’interfaces graphiques Python offre des avantages évidents. Habituellement, la création d’une interface graphique demande beaucoup de temps et d’efforts. Mais avec Glade Interface Designer, vous pouvez accélérer le processus. Glade propose également une large gamme de widgets, chacun aussi simple à utiliser que le bouton de l’exemple.

Un avantage clé de Glade est sa capacité à séparer la conception de l’interface graphique du code. Cela simplifie la maintenance et la mise à jour de l’interface graphique. Cette approche conduit à un code plus propre et mieux organisé, conforme aux pratiques de programmation modernes.