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 à 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 de Gtk.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éthode on_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 !

Articles connexes: