9. Widgets de botão
9.1. Button
O widget Button é outro widget comumente usado. Geralmente é usado para anexar uma função que é chamada quando o botão é pressionado.
O widget Gtk.Button pode conter qualquer widget filho válido. Isto é, ele pode conter praticamente qualquer outro padrão Gtk.Widget. Um filho mais comumente usado é a Gtk.Label.
Normalmente, você quer se conectar ao sinal “clicked” do botão que é emitido quando o botão foi pressionado e liberado.
9.1.1. Exemplo
1import gi
2
3gi.require_version("Gtk", "3.0")
4from gi.repository import Gtk
5
6
7class ButtonWindow(Gtk.Window):
8 def __init__(self):
9 super().__init__(title="Button Demo")
10 self.set_border_width(10)
11
12 hbox = Gtk.Box(spacing=6)
13 self.add(hbox)
14
15 button = Gtk.Button.new_with_label("Click Me")
16 button.connect("clicked", self.on_click_me_clicked)
17 hbox.pack_start(button, True, True, 0)
18
19 button = Gtk.Button.new_with_mnemonic("_Open")
20 button.connect("clicked", self.on_open_clicked)
21 hbox.pack_start(button, True, True, 0)
22
23 button = Gtk.Button.new_with_mnemonic("_Close")
24 button.connect("clicked", self.on_close_clicked)
25 hbox.pack_start(button, True, True, 0)
26
27 def on_click_me_clicked(self, button):
28 print('"Click me" button was clicked')
29
30 def on_open_clicked(self, button):
31 print('"Open" button was clicked')
32
33 def on_close_clicked(self, button):
34 print("Closing application")
35 Gtk.main_quit()
36
37
38win = ButtonWindow()
39win.connect("destroy", Gtk.main_quit)
40win.show_all()
41Gtk.main()
9.2. ToggleButton
A Gtk.ToggleButton (botão de alternância) é muito semelhante a um Gtk.Button normal, mas quando clicados eles permanecem ativados, ou pressionados, até serem clicados novamente. Quando o estado do botão é alterado, o sinal “toggled” é emitido.
Para recuperar o estado da Gtk.ToggleButton, você pode usar o método Gtk.ToggleButton.get_active(). Isso retorna True se o botão estiver “down” (inativo). Você também pode definir o estado do botão de alternância, com Gtk.ToggleButton.set_active(). Observe que, se você fizer isso e o estado realmente mudar, isso fará com que o sinal “toggled” seja emitido.
9.2.1. Exemplo
1import gi
2
3gi.require_version("Gtk", "3.0")
4from gi.repository import Gtk
5
6
7class ToggleButtonWindow(Gtk.Window):
8 def __init__(self):
9 super().__init__(title="ToggleButton Demo")
10 self.set_border_width(10)
11
12 hbox = Gtk.Box(spacing=6)
13 self.add(hbox)
14
15 button = Gtk.ToggleButton(label="Button 1")
16 button.connect("toggled", self.on_button_toggled, "1")
17 hbox.pack_start(button, True, True, 0)
18
19 button = Gtk.ToggleButton(label="B_utton 2", use_underline=True)
20 button.set_active(True)
21 button.connect("toggled", self.on_button_toggled, "2")
22 hbox.pack_start(button, True, True, 0)
23
24 def on_button_toggled(self, button, name):
25 if button.get_active():
26 state = "on"
27 else:
28 state = "off"
29 print("Button", name, "was turned", state)
30
31
32win = ToggleButtonWindow()
33win.connect("destroy", Gtk.main_quit)
34win.show_all()
35Gtk.main()
9.4. RadioButton
Assim como os botões de seleção, botões de opção também herdam de Gtk.ToggleButton, mas estes funcionam em grupos, e apenas um Gtk.RadioButton em um grupo pode ser selecionado de cada vez. Portanto, um Gtk.RadioButton é uma maneira de dar ao usuário uma escolha entre várias opções.
Botões de opção podem ser criados com um dos métodos estáticos Gtk.RadioButton.new_from_widget(), Gtk.RadioButton.new_with_label_from_widget() ou Gtk.RadioButton.new_with_mnemonic_from_widget(). O primeiro botão de opção de um grupo será criado passando o None como o argumento de group. Nas chamadas subsequentes, o grupo ao qual você deseja adicionar esse botão deve ser passado como um argumento.
Quando executado pela primeira vez, o primeiro botão de opção do grupo estará ativo. Isto pode ser alterado chamando Gtk.ToggleButton.set_active() com True como primeiro argumento.
Alterar o grupo de widgets Gtk.RadioButton após sua criação pode ser feito chamando Gtk.RadioButton.join_group().
9.4.1. Exemplo
1import gi
2
3gi.require_version("Gtk", "3.0")
4from gi.repository import Gtk
5
6
7class RadioButtonWindow(Gtk.Window):
8 def __init__(self):
9 super().__init__(title="RadioButton Demo")
10 self.set_border_width(10)
11
12 hbox = Gtk.Box(spacing=6)
13 self.add(hbox)
14
15 button1 = Gtk.RadioButton.new_with_label_from_widget(None, "Button 1")
16 button1.connect("toggled", self.on_button_toggled, "1")
17 hbox.pack_start(button1, False, False, 0)
18
19 button2 = Gtk.RadioButton.new_from_widget(button1)
20 button2.set_label("Button 2")
21 button2.connect("toggled", self.on_button_toggled, "2")
22 hbox.pack_start(button2, False, False, 0)
23
24 button3 = Gtk.RadioButton.new_with_mnemonic_from_widget(button1, "B_utton 3")
25 button3.connect("toggled", self.on_button_toggled, "3")
26 hbox.pack_start(button3, False, False, 0)
27
28 def on_button_toggled(self, button, name):
29 if button.get_active():
30 state = "on"
31 else:
32 state = "off"
33 print("Button", name, "was turned", state)
34
35
36win = RadioButtonWindow()
37win.connect("destroy", Gtk.main_quit)
38win.show_all()
39Gtk.main()
9.5. LinkButton
A Gtk.LinkButton é um Gtk.Button com um hiperlink, similar ao usado pelos navegadores web, que aciona uma ação quando clicado. É útil mostrar links rápidos para recursos.
A URI vinculada a um Gtk.LinkButton pode ser configurada especificamente usando Gtk.LinkButton.set_uri() e sendo obtida usando Gtk.LinkButton.get_uri().
9.5.1. Exemplo
1import gi
2
3gi.require_version("Gtk", "3.0")
4from gi.repository import Gtk
5
6
7class LinkButtonWindow(Gtk.Window):
8 def __init__(self):
9 super().__init__(title="LinkButton Demo")
10 self.set_border_width(10)
11
12 button = Gtk.LinkButton.new_with_label(
13 uri="https://www.gtk.org",
14 label="Visit GTK+ Homepage"
15 )
16 self.add(button)
17
18
19win = LinkButtonWindow()
20win.connect("destroy", Gtk.main_quit)
21win.show_all()
22Gtk.main()
9.6. SpinButton
A Gtk.SpinButton (botão de rotação) é uma maneira ideal de permitir que o usuário defina o valor de algum atributo. Em vez de digitar diretamente um número em Gtk.Entry, Gtk.SpinButton permite que o usuário clique em uma das duas setas para incrementar ou decrementar o valor exibido. Um valor ainda pode ser digitado, com o bônus que pode ser verificado para garantir que esteja em um determinado intervalo. As propriedades principais de um Gtk.SpinButton são definidas através de Gtk.Adjustment.
Para alterar o valor que Gtk.SpinButton está mostrando, use Gtk.SpinButton.set_value(). O valor digitado pode ser um número inteiro ou ponto flutuante, dependendo de seus requisitos, use Gtk.SpinButton.get_value_as_int() ou Gtk.SpinButton.get_value(), respectivamente.
Quando você permite a exibição de valores flutuantes no botão de rotação, você pode querer ajustar o número de espaços decimais exibidos chamando Gtk.SpinButton.set_digits().
Por padrão, Gtk.SpinButton aceita dados textuais. Se você deseja limitar isso apenas a valores numéricos, chame Gtk.SpinButton.set_numeric() com True como argumento.
Também podemos ajustar a política de atualização de Gtk.SpinButton. Existem duas opções aqui; por padrão, o botão de rotação atualiza o valor mesmo se os dados inseridos forem inválidos. Alternativamente, podemos definir a política para apenas atualizar quando o valor inserido é válido chamando Gtk.SpinButton.set_update_policy().
9.6.1. Exemplo
1import gi
2
3gi.require_version("Gtk", "3.0")
4from gi.repository import Gtk
5
6
7class SpinButtonWindow(Gtk.Window):
8 def __init__(self):
9 super().__init__(title="SpinButton Demo")
10 self.set_border_width(10)
11
12 hbox = Gtk.Box(spacing=6)
13 self.add(hbox)
14
15 adjustment = Gtk.Adjustment(upper=100, step_increment=1, page_increment=10)
16 self.spinbutton = Gtk.SpinButton()
17 self.spinbutton.set_adjustment(adjustment)
18 self.spinbutton.connect("value-changed", self.on_value_changed)
19 hbox.pack_start(self.spinbutton, False, False, 0)
20
21 check_numeric = Gtk.CheckButton(label="Numeric")
22 check_numeric.connect("toggled", self.on_numeric_toggled)
23 hbox.pack_start(check_numeric, False, False, 0)
24
25 check_ifvalid = Gtk.CheckButton(label="If Valid")
26 check_ifvalid.connect("toggled", self.on_ifvalid_toggled)
27 hbox.pack_start(check_ifvalid, False, False, 0)
28
29 def on_value_changed(self, scroll):
30 print(self.spinbutton.get_value_as_int())
31
32 def on_numeric_toggled(self, button):
33 self.spinbutton.set_numeric(button.get_active())
34
35 def on_ifvalid_toggled(self, button):
36 if button.get_active():
37 policy = Gtk.SpinButtonUpdatePolicy.IF_VALID
38 else:
39 policy = Gtk.SpinButtonUpdatePolicy.ALWAYS
40 self.spinbutton.set_update_policy(policy)
41
42
43win = SpinButtonWindow()
44win.connect("destroy", Gtk.main_quit)
45win.show_all()
46Gtk.main()
9.7. Switch
A Gtk.Switch (interruptor) é um widget que possui dois estados: ligado ou desligado. O usuário pode controlar qual estado deve estar ativo clicando na área vazia ou arrastando a alça.
Você não deve usar o sinal “activate” no Gtk.Switch que é um sinal de ação e emiti-lo faz com que o switch anime. Os aplicativos nunca devem se conectar a este sinal, mas use o sinal “notify::active”, veja o exemplo abaixo.
9.7.1. Exemplo
1import gi
2
3gi.require_version("Gtk", "3.0")
4from gi.repository import Gtk
5
6
7class SwitcherWindow(Gtk.Window):
8 def __init__(self):
9 super().__init__(title="Switch Demo")
10 self.set_border_width(10)
11
12 hbox = Gtk.Box(spacing=6)
13 self.add(hbox)
14
15 switch = Gtk.Switch()
16 switch.connect("notify::active", self.on_switch_activated)
17 switch.set_active(False)
18 hbox.pack_start(switch, True, True, 0)
19
20 switch = Gtk.Switch()
21 switch.connect("notify::active", self.on_switch_activated)
22 switch.set_active(True)
23 hbox.pack_start(switch, True, True, 0)
24
25 def on_switch_activated(self, switch, gparam):
26 if switch.get_active():
27 state = "on"
28 else:
29 state = "off"
30 print("Switch was turned", state)
31
32
33win = SwitcherWindow()
34win.connect("destroy", Gtk.main_quit)
35win.show_all()
36Gtk.main()