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

import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk


class ButtonWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="Button Demo")
        self.set_border_width(10)

        hbox = Gtk.Box(spacing=6)
        self.add(hbox)

        button = Gtk.Button.new_with_label("Click Me")
        button.connect("clicked", self.on_click_me_clicked)
        hbox.pack_start(button, True, True, 0)

        button = Gtk.Button.new_with_mnemonic("_Open")
        button.connect("clicked", self.on_open_clicked)
        hbox.pack_start(button, True, True, 0)

        button = Gtk.Button.new_with_mnemonic("_Close")
        button.connect("clicked", self.on_close_clicked)
        hbox.pack_start(button, True, True, 0)

    def on_click_me_clicked(self, button):
        print('"Click me" button was clicked')

    def on_open_clicked(self, button):
        print('"Open" button was clicked')

    def on_close_clicked(self, button):
        print("Closing application")
        Gtk.main_quit()


win = ButtonWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.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

import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk


class ToggleButtonWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="ToggleButton Demo")
        self.set_border_width(10)

        hbox = Gtk.Box(spacing=6)
        self.add(hbox)

        button = Gtk.ToggleButton(label="Button 1")
        button.connect("toggled", self.on_button_toggled, "1")
        hbox.pack_start(button, True, True, 0)

        button = Gtk.ToggleButton(label="B_utton 2", use_underline=True)
        button.set_active(True)
        button.connect("toggled", self.on_button_toggled, "2")
        hbox.pack_start(button, True, True, 0)

    def on_button_toggled(self, button, name):
        if button.get_active():
            state = "on"
        else:
            state = "off"
        print("Button", name, "was turned", state)


win = ToggleButtonWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()

9.3. CheckButton

Gtk.CheckButton (botão de seleção) herda de Gtk.ToggleButton. A única diferença real entre os dois é como Gtk.CheckButton é apresentado. A Gtk.CheckButton coloca um discreto Gtk.ToggleButton ao lado de um widget, (geralmente um Gtk.Label). O sinal “toggled”, Gtk.ToggleButton.set_active() e Gtk.ToggleButton.get_active() são herdados.

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

import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk


class RadioButtonWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="RadioButton Demo")
        self.set_border_width(10)

        hbox = Gtk.Box(spacing=6)
        self.add(hbox)

        button1 = Gtk.RadioButton.new_with_label_from_widget(None, "Button 1")
        button1.connect("toggled", self.on_button_toggled, "1")
        hbox.pack_start(button1, False, False, 0)

        button2 = Gtk.RadioButton.new_from_widget(button1)
        button2.set_label("Button 2")
        button2.connect("toggled", self.on_button_toggled, "2")
        hbox.pack_start(button2, False, False, 0)

        button3 = Gtk.RadioButton.new_with_mnemonic_from_widget(button1, "B_utton 3")
        button3.connect("toggled", self.on_button_toggled, "3")
        hbox.pack_start(button3, False, False, 0)

    def on_button_toggled(self, button, name):
        if button.get_active():
            state = "on"
        else:
            state = "off"
        print("Button", name, "was turned", state)


win = RadioButtonWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.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

import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk


class LinkButtonWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="LinkButton Demo")
        self.set_border_width(10)

        button = Gtk.LinkButton.new_with_label(
            uri="https://www.gtk.org",
            label="Visit GTK+ Homepage"
        )
        self.add(button)


win = LinkButtonWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.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.

To change the value that Gtk.SpinButton is showing, use Gtk.SpinButton.set_value(). The value entered can either be an integer or float, depending on your requirements, use Gtk.SpinButton.get_value_as_int() or Gtk.SpinButton.get_value(), respectively.

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

import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk


class SpinButtonWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="SpinButton Demo")
        self.set_border_width(10)

        hbox = Gtk.Box(spacing=6)
        self.add(hbox)

        adjustment = Gtk.Adjustment(upper=100, step_increment=1, page_increment=10)
        self.spinbutton = Gtk.SpinButton()
        self.spinbutton.set_adjustment(adjustment)
        self.spinbutton.connect("value-changed", self.on_value_changed)
        hbox.pack_start(self.spinbutton, False, False, 0)

        check_numeric = Gtk.CheckButton(label="Numeric")
        check_numeric.connect("toggled", self.on_numeric_toggled)
        hbox.pack_start(check_numeric, False, False, 0)

        check_ifvalid = Gtk.CheckButton(label="If Valid")
        check_ifvalid.connect("toggled", self.on_ifvalid_toggled)
        hbox.pack_start(check_ifvalid, False, False, 0)

    def on_value_changed(self, scroll):
        print(self.spinbutton.get_value_as_int())

    def on_numeric_toggled(self, button):
        self.spinbutton.set_numeric(button.get_active())

    def on_ifvalid_toggled(self, button):
        if button.get_active():
            policy = Gtk.SpinButtonUpdatePolicy.IF_VALID
        else:
            policy = Gtk.SpinButtonUpdatePolicy.ALWAYS
        self.spinbutton.set_update_policy(policy)


win = SpinButtonWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.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

import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk


class SwitcherWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="Switch Demo")
        self.set_border_width(10)

        hbox = Gtk.Box(spacing=6)
        self.add(hbox)

        switch = Gtk.Switch()
        switch.connect("notify::active", self.on_switch_activated)
        switch.set_active(False)
        hbox.pack_start(switch, True, True, 0)

        switch = Gtk.Switch()
        switch.connect("notify::active", self.on_switch_activated)
        switch.set_active(True)
        hbox.pack_start(switch, True, True, 0)

    def on_switch_activated(self, switch, gparam):
        if switch.get_active():
            state = "on"
        else:
            state = "off"
        print("Switch was turned", state)


win = SwitcherWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()