Recherche de site Web

Comment créer des applications GUI sous Linux Desktop à l'aide de PyGObject - Partie 1


La création d'applications sous Linux peut être réalisée de différentes manières, mais il existe des manières limitées de le faire, donc en utilisant les langages de programmation et les bibliothèques les plus simples et les plus fonctionnels, c'est pourquoi nous allons jeter un coup d'œil rapide sur la création d'applications sous Linux. bureau en utilisant la bibliothèque GTK+ avec le langage de programmation Python appelé « PyGObject ».

PyGObject utilise l'introspection GObject pour créer une liaison pour les langages de programmation comme Python, PyGObject est la prochaine génération de PyGTK, vous pouvez dire que PyGObject=Python + GTK3.

Aujourd'hui, nous allons commencer une série sur la création d'applications GUI (Graphical User Interface) sous le bureau Linux à l'aide de la bibliothèque GTK+ et du langage PyGobject. La série couvrira les sujets suivants :

À propos de Python

Tout d’abord, vous devez avoir quelques connaissances de base en Python ; Python est un langage de programmation très moderne et facile à utiliser. C'est l'un des langages de programmation les plus connus au monde, en utilisant Python, vous pourrez créer de nombreuses applications et outils formidables. Vous pouvez suivre des cours gratuits comme ceux de codeacademy.com ou lire des livres sur Python sur :

À propos de GTK+

GTK+ est une boîte à outils multiplateforme open source permettant de créer des interfaces utilisateur graphiques pour les applications de bureau. Elle a été lancée pour la première fois en 1998 en tant que boîte à outils GUI pour GIMP, plus tard, elle a été utilisée dans de nombreuses autres applications et est rapidement devenue l'une des bibliothèques les plus connues pour créer des interfaces graphiques. GTK+ est publié sous licence LGPL.

Création d'applications GUI sous Linux

Il existe 2 manières de créer des applications à l'aide de GTK+ et Python :

  1. Ecrire l'interface graphique en utilisant uniquement du code.
  2. Concevoir l'interface graphique à l'aide du programme « Glade » ; qui est un outil RAD pour concevoir facilement des interfaces GTK+, Glade génère l'interface graphique sous forme de fichier XML qui peut être utilisé avec n'importe quel langage de programmation pour construire l'interface graphique, après avoir exporté le fichier XML de l'interface graphique, nous pourrons lier le fichier XML avec notre programme pour faire les emplois que nous voulons.

Nous expliquerons les deux manières en bref.

La méthode basée uniquement sur le code

Écrire l'interface graphique en utilisant uniquement du code peut être un peu difficile pour les programmeurs débutants et faire perdre beaucoup de temps, mais en l'utilisant, nous pouvons créer des interfaces graphiques très fonctionnelles pour nos programmes, plus que celles que nous créons à l'aide de certains outils comme Glade.

Prenons l'exemple suivant.

#!/usr/bin/python
-*- coding: utf-8 -*-

from gi.repository import Gtk

class ourwindow(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="My Hello World Program")
        Gtk.Window.set_default_size(self, 400,325)
        Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER)

        button1 = Gtk.Button("Hello, World!")
        button1.connect("clicked", self.whenbutton1_clicked)

        self.add(button1)
        
    def whenbutton1_clicked(self, button):
      print "Hello, World!"

window = ourwindow()        
window.connect("delete-event", Gtk.main_quit)
window.show_all()
Gtk.main()

Copiez le code ci-dessus, collez-le dans un fichier « test.py » et définissez l'autorisation 755 sur le fichier test.py et exécutez le fichier plus tard en utilisant « ./test.py », c'est ce que vous obtiendrez.

nano test.py
chmod 755 test.py
./test.py

En cliquant sur le bouton, vous voyez la phrase « Hello, World ! » imprimée dans le terminal :

Laissez-moi vous expliquer le code dans une explication détaillée.

  1. #!/usr/bin/python : chemin par défaut de l'interpréteur Python (version 2.7 dans la plupart des cas), cette ligne doit être la première ligne de chaque fichier Python.
  2. # -*- codage : utf-8 -*- : Ici, nous définissons le codage par défaut pour le fichier, UTF-8 est le meilleur si vous souhaitez prendre en charge les langues autres que l'anglais, laissez-le comme ça .
  3. from gi.repository import Gtk : Ici, nous importons la bibliothèque GTK 3 pour l'utiliser dans notre programme.
  4. Classe ourwindow (Gtk.Window) : Ici, nous créons une nouvelle classe, appelée « ourwindow », nous définissons également le type d'objet de classe sur « Gtk.Window ».
  5. def __init__(self) : Rien de nouveau, nous définissons ici les principaux composants de la fenêtre.
  6. Gtk.Window.__init__(self, title="My Hello World Program") : Nous utilisons cette ligne pour définir le titre "My Hello World Program" sur la fenêtre "ourwindow", vous pouvez modifier le titre si vous le souhaitez.
  7. Gtk.Window.set_default_size(self, 400,325) : je ne pense pas que cette ligne ait besoin d'explication, nous définissons ici la largeur et la hauteur par défaut de notre fenêtre.
  8. Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER) : En utilisant cette ligne, nous pourrons définir la position par défaut de la fenêtre, dans ce cas, nous la mettons au centre en utilisant le paramètre « Gtk.WindowPosition.CENTER », si vous le souhaitez, vous pouvez le changer en « Gtk.WindowPosition.MOUSE » pour ouvrir la fenêtre à la position du pointeur de la souris.
  9. button1=Gtk.Button("Hello, World!") : Nous avons créé un nouveau Gtk.Button, et nous l'avons appelé "button1", le texte par défaut du bouton est "Bonjour, World ! », vous pouvez créer n'importe quel widget Gtk si vous le souhaitez.
  10. button1.connect("clicked", self.whenbutton1_clicked) : Ici, nous lions le signal "clicked" à l'action "whenbutton1_clicked", de sorte que lorsque le bouton est cliqué, l'action "whenbutton1_clicked" est activé.
  11. self.add(button1) : Si nous voulons que nos widgets Gtk apparaissent, nous devons les ajouter à la fenêtre par défaut, cette simple ligne ajoute le widget « button1 » à la fenêtre, il est très nécessaire de fais ça.
  12. def whenbutton1_clicked(self, button) : Nous définissons maintenant l'action « whenbutton1_clicked » ici, nous définissons ce qui va se passer lorsque le widget « button1 » est cliqué, le « (self, bouton ) » est important afin de spécifier le type d'objet parent du signal.
  13. imprimer « Hello, World ! » : je n'ai pas besoin d'en expliquer davantage ici.
  14. window=ourwindow() : Nous devons créer une nouvelle variable globale et la définir sur la classe ourwindow() afin de pouvoir l'appeler plus tard en utilisant la bibliothèque GTK+.
  15. window.connect("delete-event", Gtk.main_quit) : Nous connectons maintenant le signal "delete-event" à l'action "Gtk.main_quit", c'est important pour supprimer tous les widgets après avoir fermé automatiquement la fenêtre de notre programme.
  16. window.show_all() : Affichage de la fenêtre.
  17. Gtk.main() : Exécution de la bibliothèque Gtk.

C'est tout, facile n'est-ce pas ? Et très fonctionnel si l’on veut créer des applications volumineuses. Pour plus d'informations sur la création d'interfaces GTK+ en utilisant uniquement le code, vous pouvez visiter le site Web de documentation officiel à l'adresse :

Tutoriels Python GTK3

La méthode Glade Designer

Comme je l'ai dit au début de l'article, Glade est un outil très simple pour créer les interfaces dont nous avons besoin pour nos programmes, il est très célèbre parmi les développeurs et de nombreuses interfaces d'applications géniales ont été créées en l'utilisant. Cette méthode est appelée « Développement rapide d'applications ».

Vous devez installer Glade pour pouvoir commencer à l'utiliser, sous Debian/Ubuntu/Mint :

sudo apt­-get install glade

Sur RedHat/Fedora/CentOS, exécutez :

yum install glade

Après avoir téléchargé et installé le programme, et après l'avoir exécuté, vous verrez les widgets Gtk disponibles sur la gauche, cliquez sur le widget « fenêtre » afin de créer une nouvelle fenêtre.

Vous remarquerez qu'une nouvelle fenêtre vide est créée.

Vous pouvez maintenant y ajouter quelques widgets, dans la barre d'outils de gauche, cliquez sur le widget « bouton », et cliquez sur la fenêtre vide afin d'ajouter le bouton à la fenêtre.

Vous remarquerez que l'ID du bouton est « bouton1 », reportez-vous maintenant à l'onglet Signaux dans la barre d'outils de droite, recherchez le signal « cliqué » et saisissez « button1_clicked » en dessous.

Maintenant que nous avons créé notre interface graphique, exportons-la. Cliquez sur le menu « Fichier » et choisissez « Enregistrer », enregistrez le fichier dans votre répertoire personnel sous le nom « monprogramme.glade » et sortie.

Maintenant, créez un nouveau fichier « test.py » et entrez le code suivant à l'intérieur.

#!/usr/bin/python
-*- coding: utf-8 -*-

from gi.repository import Gtk

class Handler:
    def button_1clicked(self, button):
      print "Hello, World!"

builder = Gtk.Builder()
builder.add_from_file("myprogram.glade")
builder.connect_signals(Handler())

ournewbutton = builder.get_object("button1")
ournewbutton.set_label("Hello, World!")

window = builder.get_object("window1")

window.connect("delete-event", Gtk.main_quit)
window.show_all()
Gtk.main()

Enregistrez le fichier, donnez-lui les autorisations 755 comme avant et exécutez-le en utilisant « ./test.py », et c'est ce que vous obtiendrez.

nano test.py
chmod 755 test.py
./test.py

Cliquez sur le bouton et vous remarquerez que la phrase « Hello, World ! » est imprimée dans le terminal.

Expliquons maintenant les nouveautés :

  1. class Handler : nous créons ici une classe appelée « Handler » qui inclura les définitions des actions et des signaux que nous créons pour l'interface graphique.
  2. builder=Gtk.Builder() : Nous avons créé une nouvelle variable globale appelée « builder » qui est un widget Gtk.Builder, ceci est important pour importer le fichier .glade.
  3. builder.add_from_file("myprogram.glade") : Ici, nous importons le fichier "myprogram.glade" pour l'utiliser comme interface graphique par défaut pour notre programme.
  4. builder.connect_signals(Handler()) : Cette ligne connecte le fichier .glade à la classe du gestionnaire, afin que les actions et les signaux que nous définissons sous la classe « Handler » fonctionnent correctement lorsque nous exécutons le programme. .
  5. ournewbutton=builder.get_object("button1") : Maintenant, nous importons l'objet « button1 » depuis le fichier .glade, nous le transmettons également à la variable globale « ournewbutton » pour l'utiliser plus tard dans notre programme.
  6. ournewbutton.set_label(« Hello, World ! ») : nous avons utilisé la méthode « set.label » pour définir le texte du bouton par défaut sur « Hello, World ! " phrase.
  7. window=builder.get_object("window1") : Ici nous avons appelé l'objet "window1" du fichier .glade afin de l'afficher plus tard dans le programme.

Et c'est tout! Vous avez créé avec succès votre premier programme sous Linux !

Bien sûr, il y a des choses beaucoup plus compliquées à faire pour créer une véritable application qui fait quelque chose, c'est pourquoi je vous recommande de jeter un œil à la documentation GTK+ et à l'API GObject à l'adresse :

  1. Manuel de référence GTK+
  2. Référence de l'API Python GObject
  3. Référence PyGObject

Avez-vous déjà développé une application sous le bureau Linux ? Quel langage de programmation et quels outils avez-vous utilisés pour le faire ? Que pensez-vous de la création d'applications avec Python et GTK 3 ?