Le bouton à bascule dérive du bouton simple et lui est donc très similaire. Il a cependant ceci de différent qu'il possède deux états et qu'un clic le fait basculer de l'un à l'autre. Lorsqu'il est enfoncé, un clic le fait remonter. Un autre clic et le voilà de nouveau enfoncé.
Les boutons à bascule sont la base des cases à cocher et des boutons radio, ces derniers héritent donc de beaucoup de leurs appels (nous le signalerons le cas échéant).
Création d'un bouton à bascule :
bouton_bascule = gtk.ToggleButton(label=None)
Comme vous pouvez l'imaginer, le fonctionnement de cet appel est identique à celui des boutons normaux. Si aucune étiquette n'est spécifiée, le bouton sera vierge. Dans le cas contraire, le texte donné sera inspecté à la recherche de caractères mnémoniques (préfixés par '_').
Pour récupérer l'état d'un bouton à bascule, ainsi que des boutons radio et des cases à cocher, on fait appel à une construction semblable à l'exemple ci-dessous. Elle teste l'état du bouton en invoquant la méthode get_active() de gtk.ToggleButton. Parmi les signaux émis par les boutons à bascule, celui qui nous intéresse est "toggled". Pour vérifier l'état d'un bouton à bascule, on définira alors un gestionnaire de signal qui se chargera de le capter, puis qui accèdera aux attributs de l'objet afin de déterminer son état. La fonction de rappel ressemblera à ceci :
def fct_rappel_bascule(widget, donnees):
if widget.get_active():
# si le contrôle arrive ici, le bouton à bascule est enfoncé
else:
# si le contrôle arrive ici, le bouton à bascule est relevé
Pour forcer l'état d'un bouton à bascule (et de ses descendants les cases à cocher et les boutons radio) on utilise la méthode :
bouton_bascule.set_active(is_active)
La méthode ci-dessus peut être utilisée pour imposer l'état d'un bouton à bascule, et de ses descendants les cases à cocher et les boutons radio. En donnant les valeurs TRUE ou FALSE à l'argument is_active, on indique que le bouton doit être respectivement enfoncé ou relevé. Lors de sa création, un bouton à bascule est en position relevée (FALSE) par défaut.
Notez que lorsqu'on utilise la méthode set_active() et que l'état est effectivement modifié, les signaux "clicked" et "toggled" sont automatiquement émis par le bouton.
bouton_bascule.get_active()
Cette méthode renvoie l'état actuel du bouton à bascule sous la forme d'une valeur booléenne TRUE/FALSE.
Le programme boutonsbascule.py donne un exemple courant d'utilisation des boutons à bascule. La figure 6.2 montre la fenêtre obtenue, dans laquelle le deuxième bouton est enfoncé :
Voici le code source du programme :
1 #!/usr/bin/env python
2
3 # exemple boutonsbascule.py
4
5 import pygtk
6 pygtk.require('2.0')
7 import gtk
8
9 class BoutonsBascule:
10 # Notre fonction de rappel. Le parametre "donnees"
11 # transmis a cette methode est affiche sur stdout
12 def fct_rappel(self, widget, donnees=None):
13 print "Le %s a ete %s." % (donnees, ("releve", "enfonce")[widget.get_active()])
14
15 # Cette fonction de rappel quitte le programme
16 def evnmt_delete(self, widget, evenement, donnees=None):
17 gtk.main_quit()
18 return gtk.FALSE
19
20 def __init__(self):
21 # Creation d'une nouvelle fenetre.
22 self.fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
23
24 # On definit le titre de la fenetre.
25 self.fenetre.set_title("Boutons a bascule")
26
27 # On definit un gestionnaire de signal pour "delete_event",
28 # qui quitte GTK immediatement.
29 self.fenetre.connect("delete_event", self.evnmt_delete)
30
31 # On fixe la largeur des bordures de la fenetre.
32 self.fenetre.set_border_width(20)
33
34 # Creation d'une boite verticale.
35 boite_v = gtk.VBox(True, 2)
36
37 # On place la VBox dans la fenetre principale.
38 self.fenetre.add(boite_v)
39
40 # Creation du premier bouton.
41 bouton = gtk.ToggleButton("bouton a bascule 1")
42
43 # Lorsque l'on change l'etat du bouton, la methode fct_rappel() est
44 # appelee, avec un pointeur sur "bouton a bascule 1" comme argument.
45 bouton.connect("toggled", self.fct_rappel, "bouton a bascule 1")
46
47
48 # Insertion du bouton 1 dans le quart superieur gauche du tableau.
49 boite_v.pack_start(bouton, True, True, 2)
50
51 bouton.show()
52
53 # Creation du deuxieme bouton.
54
55 bouton = gtk.ToggleButton("bouton a bascule 2")
56
57 # Lorsque l'on change l'etat du bouton, la methode fct_rappel() est
58 # appelee, avec un pointeur sur "bouton a bascule 2" comme argument.
59 bouton.connect("toggled", self.fct_rappel, "bouton a bascule 2")
60 # Insertion du bouton 2 dans le quart superieur droit du tableau.
61 boite_v.pack_start(bouton, True, True, 2)
62
63 bouton.show()
64
65 # Creation du bouton "Quitter".
66 bouton = gtk.Button("Quitter")
67
68 # Lorsque l'on clique sur le bouton, la fonction mainquit() est
69 # appelee et le programme se termine.
70 bouton.connect("clicked", lambda wid: gtk.main_quit())
71
72 # Insertion du bouton "Quitter" dans les deux quarts inferieurs du tableau.
73 boite_v.pack_start(bouton, True, True, 2)
74
75 bouton.show()
76 boite_v.show()
77 self.fenetre.show()
78
79 def main():
80 gtk.main()
81 return 0
82
83 if __name__ == "__main__":
84 BoutonsBascule()
85 main()
Les parties intéressantes sont les lignes 12-13, qui définissent la méthode fct_rappel() chargée d'afficher le nom et l'état du bouton à bascule quand celui-ci voit son état modifié, et les lignes 45 et 59, qui connectent le signal "toggled" des deux boutons à cette même méthode.