Les boutons

Gtk::Button

Nous avons déjà vu l’utilisation de base de ce widget, sous la forme d’un bouton contenant du texte. Cependant, un bouton peut contenir n’importe quel widget. On peut le créer en passant du texte à son constructeur, auquel cas un Label est créé, mais si on laisse le constructeur vide, on peut ensuite ajouter le widget de son choix (un Button hérite de Bin, un conteneur). La plupart du temps, cela est utilisé pour mettre une image au lieu d’un texte.

Nous avons vu le signal clicked, émis lorsque l’utilisateur clique sur le bouton (ou l’active avec le clavier). Il existe d’autres signaux :

Signal	Description
enter	Émis lorsque la souris arrive sur le bouton
leave	Émis lorsque la souris sort du bouton
pressed	Émis lorsque l’utilisateur appuie sur un bouton de la souris
released	Émis lorsque l’utilisateur relâche un bouton de la souris
activate	Émis lorsque le bouton est activé autrement qu’en cliquant dessus (touche espace ou entrée alors qu’il détient le focus, par exemple)

Vous pouvez également modifier l’apparence de relief de votre bouton. Cela est utile en particulier si vous faites une barre d’outils contenant de nombreux boutons, et que vous désirez supprimer les bords de ces boutons. Pour cela, vous pouvez utiliser la méthode set_relief ou relief= en lui passant une valeur parmi Gtk::RELIEF_NONE, Gtk::RELIEF_HALF et Gtk::RELIEF_NORMAL.

Enfin, il est possible de créer un bouton en utilisant des modèles prédéfinis. Depuis sa version 2, GTK est livré avec un stock de boutons prédéfinis, qui vous évitent d’avoir à recréer des boutons toujours identiques et à vous soucier des normes de nommage et de traduction. Nous reviendrons sur ce sujet ultérieurement, mais voyons un exemple :

window = Gtk::Window.new
window.set_title('Boutons predefinis')
window.signal_connect('destroy') { Gtk.main_quit }

hb = Gtk::HBox.new(false, 6)
b = Gtk::Button.new(Gtk::Stock::OK)
hb.pack_start(b)
b = Gtk::Button.new(Gtk::Stock::CANCEL)
hb.pack_start(b)

window.add(hb)
window.show_all

Gtk::ToggleButton

Un ToggleButton est un Button qui reste enfoncé lorsque l’on clique dessus. Cliquer une seconde fois le remet dans sa position initiale. Il s’agit, par exemple, des widgets utilises pour la barre d’outils de The Gimp. La création d’un ToggleButton se fait de la même façon que celle d’un bouton normal.

Vous pouvez obtenir ou changer l’état d’un ToggleButton à l’aide des méthodes active? et active=, comme nous allons le voir dans l’exemple ci-dessous. La valeur du champ ‘active’ est un booléen, vrai si le bouton est activé, faux sinon. Cependant, il existe un autre niveau intermédiaire, représentant le cas ‘inconsistant’. Par exemple, si vous avez un bouton représentant le fait qu’un texte soit souligné ou non, et que vous sélectionnez du texte dont une partie seulement est soulignée, alors vous ne pouvez mettre le bouton ni actif ni inactif.

hb = Gtk::HBox.new(false, 6)
b = Gtk::ToggleButton.new('Inactif')
hb.pack_start(b)
b = Gtk::ToggleButton.new('Actif')
b.active=true
hb.pack_start(b)
b = Gtk::ToggleButton.new('Inconsistant')
hb.pack_start(b)
b.inconsistent=true

window.add(hb)
window.show_all

Enfin, ces boutons disposent d’un signal nommé toggled, qui est envoyé lorsque l’état du bouton change (lorsqu’il devient activé ou désactivé). Pour l’utiliser, vous aurez probablement besoin de la valeur actuelle du bouton, et pas simplement de savoir qu’elle a changé. Ceci nous amène à voir les paramètres qui sont passés au bloc que nous associons à un signal. En règle général, ces paramètres sont le widget qui est à l’origine du signal, et des données utilisateur (nous verrons plus tard comment changer ces données). Voyons un exemple :

b = Gtk::ToggleButton.new('Inactif')
b.signal_connect('toggled') { |widget, data|
       print widget.active?.to_s + "n" 
}

Lorsque vous cliquerez sur le bouton, son état actuel s’affichera dans le terminal.

Gtk::CheckButton

Ces widgets sont connus en français sous le nom de “cases à cocher”. Ils héritent directement de Gtk::ToggleButton et se comportent de la même manière. La seule chose qui diffère est leur représentation graphique : ils sont constitués d’une cases à cocher suivie d’un autre widget, le plus souvent un label.

hb = Gtk::HBox.new(false, 6)
b = Gtk::CheckButton.new('Inactif')
hb.pack_start(b)
b = Gtk::CheckButton.new('Actif')
b.active=true
hb.pack_start(b)
b = Gtk::CheckButton.new('Inconsistant')
hb.pack_start(b)
b.inconsistent=true

Gtk::RadioButton

Ces boutons ressemblent beaucoup aux cases à cocher, mais sont un peu plus compliqués à utiliser. Il s’agit également de widgets possédant deux états (plus l’état inconsistant), mais il est possible de les réunir en groupes, et au sein d’un même groupe, seul un d’entre eux peut être actif à la fois (même s’il est possible qu’aucun ne soit actif). Cela signifie que lorsqu’on active un bouton radio, tous les autres boutons du même groupe deviennent inactifs.

En pratique, on commence par créer le premier bouton sans spécifier de groupe, puis on crée les suivants à partir du premier, en le leur passant comme premier paramètre. Il est aussi possible d’obtenir (ou de changer) le groupe d’un bouton avec les méthodes group et group=.

vb = Gtk::VBox.new(false, 6)
b = Gtk::RadioButton.new('Bonbon')
vb.pack_start(b)
b2 = Gtk::RadioButton.new(b, 'Caramel')
vb.pack_start(b2)
b2 = Gtk::RadioButton.new(b, 'Inconsistant')
vb.pack_start(b2)
b2.inconsistent = true