Dans le même dossier que votre hello_world.glade, vous allez créer un hello_world.py. Pour le rendre exécutable, faites un clic droit -> propriétés et cochez la case "Autorisez l'exécution du fichier comme un programme" :
Maintenant, ouvrez ce hello_world.py avec votre éditeur de texte préféré. Nous allons y écrire notre script.
J'ai fait le choix de vous donner le script déjà tout fini pour pouvoir le commenter ligne par ligne tout en ayant une vision globale du produit fini :
Code : Python 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | #!/usr/bin/python
import pygtk
pygtk.require("2.0")
import gtk
class HelloWorld:
def __init__(self):
interface = gtk.Builder()
interface.add_from_file('hello_world.glade')
self.myLabel = interface.get_object("myLabel")
interface.connect_signals(self)
def on_mainWindow_destroy(self, widget):
gtk.main_quit()
def on_myButton_clicked(self, widget):
self.myLabel.set_text("World!")
if __name__ == "__main__":
HelloWorld()
gtk.main()
|
Le fichier commence donc par cette ligne :
Code : Python
Elle définit où trouver l'interpréteur Python qui lira et exécutera notre script. Tous les scripts Python commencent par une ligne du même genre. Ainsi, quand on exécutera notre fichier, le système saura quel programme devra le lire (dans notre cas, Python).
On a ensuite un bloc d'import :
Code : Python1
2
3 | import pygtk
pygtk.require("2.0")
import gtk
|
Ici, on importe simplement les modules dont on aura besoin pendant notre programme. Notez qu'on demande à PyGTK d'être au moins dans sa version 2.0.
Puis nous tombons sur ce gros bloc :
Code : Python 1
2
3
4
5
6
7
8
9
10
11
12
13 | class HelloWorld:
def __init__(self):
interface = gtk.Builder()
interface.add_from_file('hello_world.glade')
self.myLabel = interface.get_object("myLabel")
interface.connect_signals(self)
def on_mainWindow_destroy(self, widget):
gtk.main_quit()
def on_myButton_clicked(self, widget):
self.myLabel.set_text("World!")
|
Il s'agit d'une classe. La classe "HelloWorld". Si vous n'avez jamais touché à la POO (Programmation Orientée Objet) sachez juste qu'il s'agit d'un sac dans lequel on range des fonctions qui ont un thème commun. Vous n'avez pas besoin de connaître la POO pour suivre ce tuto, et ça n'en est pas non plus le thème principal, donc je n'en dirai pas plus pour le moment.
Nous allons plutôt nous intéresser aux fonctions que cette classe contient, et qui constituent le corps de notre programme.
Nous avons donc une fonction __init__, qui se lance automatiquement au démarrage du programme. Dans cette fonction, et comme son nom l'indique, on va faire toutes sortes de tâches d'initialisation.
Code : Python1
2
3
4
5
6 | def __init__(self):
interface = gtk.Builder()
interface.add_from_file('hello_world.glade')
self.myLabel = interface.get_object("myLabel")
interface.connect_signals(self)
|
Et comme notre programme ne fait pas grand chose, c'est cette fonction qui est la plus grosse. Dans des programmes plus fournis, ce ne sera pas le cas.
Code : Python1
2 | interface = gtk.Builder()
interface.add_from_file('hello_world.glade')
|
Avec ces lignes, nous stockons notre fichier Glade dans une variable. C'est à partir de cette variable nommée
interface que nous accéderons à nos widgets.
Code : Python1 | self.myLabel = interface.get_object("myLabel")
|
Ici, on stocke dans une variable
self.myLabel notre widget
myLabel pour pouvoir agir dessus plus tard. Par exemple en modifiant le texte qu'il contient.
Code : Python1 | interface.connect_signals(self)
|
Cette ligne de code très importante va relier les signaux aux fonctions. Ainsi, quand on fermera la fenêtre, la fonction
self.on_mainWindow_destroy sera exécutée. De même, quand on cliquera sur le bouton, la fonction
self.on_myButton_clicked sera exécutée. On appelle cela de la programmation événementielle : le programme tourne en boucle en attendant un événement. Puis un jour, quelqu'un clique sur le bouton. Le programme reçoit un signal, et agit en conséquence.
En fait, cette ligne connecte tous les signaux que l'on a précisés dans le concepteur Glade si les méthodes sont dans la même classe (les fonctions et méthodes à l'extérieur ne seront pas trouvés par cette méthode). Les méthodes créées doivent porter le même nom que l'on a mis dans Glade. Dans le concepteur, nous avions préciser le gestionnaire
on_mainWindow_destroy pour le signal
destroy de notre fenêtre. Grâce à Gtk.Builder, lorsque le signal destroy est émit, la fonction
on_mainWindow_destroy, ou la méthode
self.on_mainWindow_destroy selon les cas, sera appelée lors de l'émission du signal.
Et si la fonction se trouve à l'extérieur, ou si je n'utilise pas le POO, comment faire pour relier le gestionnaire à une fonction ?
Eh bien, il faudra écrire autre chose que self : un dictionnaire.
Exemple :
Code : Python1 | interface.connect_signals({'quitter' : quitter, 'changerTexte' : self.changerTexte})
|
Ici, la fonction quitter n'est pas dans la classe et la méthode self.changerTexte l'est.
Mais, cela a l'inconvénient d'avoir à écrire toutes les fonctions une à une.
Fin de la fonction __init__. Le programme est initialisé, plus rien ne se passe... Plus rien ? Sauf si on appuie sur le bouton, ou qu'on ferme la fenêtre !!!
Passons maintenant à la fonction
on_mainWindow_destroy, fonction qui est appelée quand on ferme la fenêtre :
Code : Python1
2 | def on_mainWindow_destroy(self, widget):
gtk.main_quit()
|
Elle contient juste gtk.main_quit() qui a pour effet d'arrêter le programme.
Mais le programme ne s'arrête pas automatiquement quand on ferme la fenêtre ?
Eh bien en apparence oui.
La fenêtre se ferme bien, mais en fait le programme continue de tourner tout seul,
dans l'invisible en arrière-plan !
On arrive maintenant à la fonction qui fait effet :
Code : Python1
2 | def on_myButton_clicked(self, widget):
self.myLabel.set_text("World!")
|
Alors d'après vous, que fait cette fonction ?
Elle change le texte de notre label bien sûr.
Voilà, nous avons fini d'étudier notre classe "HelloWorld".
Il ne nous reste que ce petit bout de code à voir :
Code : Python1
2
3 | if __name__ == "__main__":
HelloWorld()
gtk.main()
|
Il sert juste à lancer notre classe HelloWorld.
La dernière instruction gtk.main() est une boucle infinie qui empêche notre programme de se fermer dès son lancement.
Hello World
Quand j'ai compris pourquoi je m'en suis voulu.
SwimFan
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+