Recherche de site Web

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 en utilisant le 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, etc.

Dans cet article, nous allons explorer 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 nous passerons à la création d’une application graphique 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 appropriée suivante 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]

Maintenant, vous devez 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 en utilisant la commande appropriée suivante 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, construisons une application PyGObject simple qui affiche une fenêtre avec un bouton. Lorsque vous cliquez sur le bouton, il affichera un message disant : « Bonjour, tout le monde !“.

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 de GTK que nous voulons utiliser (3.0 dans ce cas).
  • La classe MyApp hérite de Gtk.Window, qui représente la fenêtre principale de l’application.
  • Nous créons un bouton à l’aide de Gtk.Button, et l’étiquette du bouton est définie sur « Click Me ». Nous connectons également le signal « cliqué » du bouton à la méthode on_button_clicked, qui affiche « Hello, World !" lorsqu’on clique dessus.
  • La boucle principale de l’application est démarrée en appelant Gtk.main(). Cette boucle attend les événements (tels que les 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 « Bonjour tout le monde !" sera imprimé dans le terminal.

Ajouter 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 par l’utilisateur

Ensuite, ajoutons des widgets Gtk.Entry pour permettre la saisie par l’utilisateur, ce qui nous permettra de créer une application simple où les utilisateurs peuvent 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 où les utilisateurs peuvent taper leur nom.
  • La méthode set_placeholder_text affiche un indicateur à 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 en tant que message d’accueil personnalisé.

3. Styliser votre application avec CSS

PyGObject vous permet d’appliquer des styles personnalisés à vos widgets d’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 de CSS :

  • Le bouton a un arrière-plan vert et les étiquettes ont une taille et une couleur de police personnalisées.
  • Les bordures du bouton sont arrondies pour un look moderne.

Conclusion

PyGObject est un outil puissant pour 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 abordé 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 d’une entrée utilisateur et même de l’application de styles CSS personnalisés.

Vous pouvez étendre ces exemples à la création d’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 !

Articles connexes: