Comment créer des applications GUI sous Linux à l'aide de PyGObject
La création d'applications d'interface utilisateur graphique (GUI) est un moyen fantastique de donner vie à vos idées et de rendre vos programmes plus conviviaux.
PyGObject est une bibliothèque Python qui permet aux développeurs de créer des applications GUI sur des bureaux Linux à l'aide du framework GTK (GIMP Toolkit). GTK est largement utilisé dans les environnements Linux, alimentant de nombreuses applications de bureau populaires telles que Gedit, le terminal GNOME, et bien plus encore.
Dans cet article, nous explorerons comment créer des applications GUI dans un environnement de bureau Linux à l'aide de PyGObject. Nous commencerons par comprendre ce qu'est PyGObject, comment l'installer, puis passerons à la création d'une application GUI simple.
Étape 1 : Installation de Python et GTK sous Linux
Pour travailler avec PyGObject, vous devez avoir Python installé et la plupart des distributions Linux actuelles sont livrées avec Python préinstallé, mais vous pouvez confirmer en exécutant :
python3 --version
Python 3.12.3
Si Python n'est pas installé, vous pouvez l'installer à l'aide de la commande suivante appropriée pour votre distribution Linux spécifique.
sudo apt install python3 [On Debian, Ubuntu and Mint]
sudo dnf install python3 [On RHEL/CentOS/Fedora and Rocky/AlmaLinux]
sudo apk add python3 [On Alpine Linux]
sudo pacman -S python [On Arch Linux]
sudo zypper install python3 [On OpenSUSE]
Vous devez maintenant installer les liaisons PyGObject pour Python, ainsi que les bibliothèques de développement GTK.
sudo apt install python3-gi gir1.2-gtk-3.0 [On Debian, Ubuntu and Mint]
sudo dnf install python3-gobject gtk3 [On RHEL/CentOS/Fedora and Rocky/AlmaLinux]
sudo apk add py3-gobject gtk+3 [On Alpine Linux]
sudo pacman -S python-gobject gtk3 [On Arch Linux]
sudo zypper install python3-gobject gtk3 [On OpenSUSE]
Étape 2 : Installation de PyGObject sous Linux
Une fois les bibliothèques de développement Python et GTK installées, vous pouvez maintenant installer PyGObject à l'aide de la commande suivante appropriée pour votre distribution Linux spécifique.
sudo apt install python3-gi [On Debian, Ubuntu and Mint]
sudo dnf install pygobject3 [On RHEL/CentOS/Fedora and Rocky/AlmaLinux]
sudo apk add py3-gobject [On Alpine Linux]
sudo pacman -S python-gobject [On Arch Linux]
sudo zypper install python3-gobject [On OpenSUSE]
Après l'installation, vous êtes prêt à commencer à développer des applications GUI à l'aide de PyGObject et GTK.
Création de la première application GUI PyGObject sous Linux
Maintenant, créons une application PyGObject simple qui affiche une fenêtre avec un bouton. Lorsque vous cliquez sur le bouton, un message indiquant « Hello, World ! » s'affiche.
Créez un fichier Python appelé app.py
et commençons à écrire la structure de base de notre application PyGObject.
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
class MyApp(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="Hello World App")
self.set_size_request(300, 100)
# Creating a button and adding it to the window
button = Gtk.Button(label="Click Me")
button.connect("clicked", self.on_button_clicked)
self.add(button)
def on_button_clicked(self, widget):
print("Hello, World!")
Initialize the application
app = MyApp()
app.connect("destroy", Gtk.main_quit) # Close the app when window is closed
app.show_all()
Gtk.main()
Explication du Code :
- Les deux premières lignes importent les modules PyGObject nécessaires. Nous spécifions la version GTK que nous souhaitons utiliser (
3.0
dans ce cas). - La classe
MyApp
hérite deGtk.Window
, qui représente la fenêtre principale de l'application. - Nous créons un bouton en utilisant
Gtk.Button
, et l'étiquette du bouton est définie sur « Cliquez sur moi ». Nous connectons également le signal « cliqué » du bouton à la méthodeon_button_clicked
, qui affiche « Hello, World ! » lorsque vous cliquez dessus. - La boucle principale de l'application est démarrée en appelant
Gtk.main()
. Cette boucle attend des événements (comme des clics) et met à jour l'application en conséquence.
Pour exécuter l'application, accédez au répertoire dans lequel vous avez enregistré le fichier app.py
et exécutez la commande suivante :
python3 app.py
Une fenêtre apparaîtra avec un bouton intitulé « Cliquez sur moi ». Lorsque vous cliquez sur le bouton, « Hello, World ! » sera imprimé dans le terminal.
Ajout de plus de fonctionnalités à votre application PyGObject
Développons maintenant notre application en ajoutant plus de widgets et d'interactivité.
1. Ajout d'une étiquette
Nous pouvons améliorer notre application en ajoutant un Gtk.Label
pour afficher les messages dans la fenêtre plutôt que de les imprimer dans le terminal.
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
class MyApp(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="Enhanced GUI App")
self.set_size_request(400, 200)
# Create a vertical box layout
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
self.add(vbox)
# Create a label
self.label = Gtk.Label(label="Press the button to see a message")
vbox.pack_start(self.label, True, True, 0)
# Create a button
button = Gtk.Button(label="Click Me")
button.connect("clicked", self.on_button_clicked)
vbox.pack_start(button, True, True, 0)
def on_button_clicked(self, widget):
self.label.set_text("Hello, World!")
Initialize the application
app = MyApp()
app.connect("destroy", Gtk.main_quit)
app.show_all()
Gtk.main()
Explication des changements :
- Nous avons utilisé
Gtk.Box
pour organiser les widgets verticalement, ce qui nous aide à organiser l'étiquette et le bouton l'un après l'autre. - Le widget
Gtk.Label
est ajouté pour afficher un message à l'intérieur de la fenêtre. - Au lieu d'imprimer sur le terminal, la fonction
on_button_clicked
met désormais à jour le texte de l'étiquette.
2. Ajout de champs de saisie pour la saisie utilisateur
Ensuite, ajoutons les widgets Gtk.Entry
pour permettre la saisie de l'utilisateur, ce qui nous permettra de créer une application simple dans laquelle les utilisateurs pourront saisir leur nom et cliquer sur un bouton pour afficher un message d'accueil personnalisé.
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
class MyApp(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="User Input App")
self.set_size_request(400, 200)
# Create a vertical box layout
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
self.add(vbox)
# Create an Entry widget for user input
self.entry = Gtk.Entry()
self.entry.set_placeholder_text("Enter your name")
vbox.pack_start(self.entry, True, True, 0)
# Create a button
button = Gtk.Button(label="Submit")
button.connect("clicked", self.on_button_clicked)
vbox.pack_start(button, True, True, 0)
# Create a label to display the greeting
self.label = Gtk.Label(label="")
vbox.pack_start(self.label, True, True, 0)
def on_button_clicked(self, widget):
name = self.entry.get_text()
if name:
self.label.set_text(f"Hello, {name}!")
else:
self.label.set_text("Please enter your name.")
Initialize the application
app = MyApp()
app.connect("destroy", Gtk.main_quit)
app.show_all()
Gtk.main()
Explication du Code :
- Le
Gtk.Entry
est un champ de saisie dans lequel les utilisateurs peuvent saisir leur nom. - La méthode
set_placeholder_text
affiche un indice à l'intérieur de la zone de saisie jusqu'à ce que l'utilisateur tape quelque chose. - Après avoir cliqué sur le bouton, le nom saisi est récupéré à l'aide de
get_text()
et affiché dans l'étiquette sous forme de message d'accueil personnalisé.
3. Styliser votre application avec CSS
PyGObject vous permet d'appliquer des styles personnalisés aux widgets de votre application à l'aide d'un fichier CSS appelé style.css
.
window {
background-color: #f0f0f0;
}
button {
background-color: #4CAF50;
color: white;
border-radius: 5px;
padding: 10px;
}
label {
font-size: 16px;
color: #333;
}
Maintenant, modifiez le code Python pour charger et appliquer ce fichier CSS :
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Gdk
class MyApp(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="Styled GUI App")
self.set_size_request(400, 200)
# Load CSS
css_provider = Gtk.CssProvider()
css_provider.load_from_path("style.css")
screen = Gdk.Screen.get_default()
style_context = Gtk.StyleContext()
style_context.add_provider_for_screen(screen, css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
# Create a vertical box layout
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
self.add(vbox)
# Create an Entry widget for user input
self.entry = Gtk.Entry()
self.entry.set_placeholder_text("Enter your name")
vbox.pack_start(self.entry, True, True, 0)
# Create a button
button = Gtk.Button(label="Submit")
button.connect("clicked", self.on_button_clicked)
vbox.pack_start(button, True, True, 0)
# Create a label to display the greeting
self.label = Gtk.Label(label="")
vbox.pack_start(self.label, True, True, 0)
def on_button_clicked(self, widget):
name = self.entry.get_text()
if name:
self.label.set_text(f"Hello, {name}!")
else:
self.label.set_text("Please enter your name.")
Initialize the application
app = MyApp()
app.connect("destroy", Gtk.main_quit)
app.show_all()
Gtk.main()
Explication des modifications CSS :
- Le bouton a un arrière-plan vert et les étiquettes ont une taille de police et une couleur personnalisées.
- Les bordures du bouton sont arrondies pour un look moderne.
Conclusion
PyGObject est un outil puissant permettant de créer des applications GUI sur le bureau Linux à l'aide de Python. En tirant parti de la flexibilité et de la simplicité de Python ainsi que des riches fonctionnalités de GTK, les développeurs peuvent créer des applications riches en fonctionnalités et visuellement attrayantes.
Dans ce guide, nous avons couvert les bases de la configuration de PyGObject, de la création d'une fenêtre simple, de la gestion des clics sur les boutons, de l'ajout des entrées utilisateur et même de l'application de styles CSS personnalisés.
Vous pouvez étendre ces exemples pour créer des applications plus complexes, telles que des gestionnaires de fichiers, des lecteurs multimédias ou même des logiciels de qualité professionnelle. Avec PyGObject et GTK, les possibilités de création d'applications de bureau sont presque illimitées !