9. Knappkomponenter

9.1. Button

Komponenten Button är en annan ofta använd komponent. Den används vanligen för att ansluta en funktion som anropas när knappen trycks ned.

Komponenten Gtk.Button kan innehålla alla giltiga barnkomponenter. Det vill säga att den kan innehålla de flesta andra vanliga Gtk.Widget. Det oftast använda barnet är Gtk.Label.

Vanligen vill du ansluta till knappens ”clicked”-signal som sänds ut när knappen har tryckts ned och släppts.

9.1.1. Exempel

_images/button_example.png
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
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

En Gtk.ToggleButton är väldigt lik en vanlig Gtk.Button, men när de klickats så förbli de aktiverade, eller nedtryckta, tills de klickas på igen. När tillståndet för knappen ändras sänder den ut signalen ”toggled”.

För att erhålla tillståndet för Gtk.ToggleButton kan du använda metoden Gtk.ToggleButton.get_active(). Denna returnerar True om knappen är ”nere”. Du kan också ställa in växlingsknappens tillstånd med Gtk.ToggleButton.set_active(). Observera att om du gör detta och tillståndet faktiskt ändras så får det signalen ”toggled” att sändas ut.

9.2.1. Exempel

_images/togglebutton_example.png
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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 ärver från Gtk.ToggleButton. Den enda reella skillnaden mellan dem är utseendet för Gtk.CheckButton. En Gtk.CheckButton placerar en diskret Gtk.ToggleButton intill en komponent (vanligen en Gtk.Label). Signalen ”toggled”, Gtk.ToggleButton.set_active() och Gtk.ToggleButton.get_active() ärvs.

9.4. RadioButton

Liksom kryssrutor så ärver även radioknappar från Gtk.ToggleButton, men dessa fungerar i grupp, och endast en Gtk.RadioButton i en grupp kan väljas vid varje givet tillfälle. Därigenom är en Gtk.RadioButton ett sätt att ge användaren ett val bland många alternativ.

Radioknappar kan skapas med en av de statiska metoderna Gtk.RadioButton.new_from_widget(), Gtk.RadioButton.new_with_label_from_widget() eller Gtk.RadioButton.new_with_mnemonic_from_widget(). Den första radioknappen i en grupp kommer skicka None som group-argument då den skapas. I följande anrop ska gruppen som du vill lägga till denna knapp till skickas med som ett argument.

Då den först körs kommer den första radioknappen vara aktiv. Detta kan ändras genom att anropa Gtk.ToggleButton.set_active() med True som första argument.

Att ändra komponentgrupp för en Gtk.RadioButton efter att den skapats kan göras genom att anropa Gtk.RadioButton.join_group().

9.4.1. Exempel

_images/radiobutton_example.png
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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

En Gtk.LinkButton är en Gtk.Button med en hyperlänk, liknande den som används av webbläsare, vilken utlöser en åtgärd då den klickas på. Den är användbar för att visa snabblänkar till resurser.

Den URI som är bunden till en Gtk.LinkButton kan specifikt ställas in med Gtk.LinkButton.set_uri(), och erhållas med Gtk.LinkButton.get_uri().

9.5.1. Exempel

_images/linkbutton_example.png
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
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

En Gtk.SpinButton är ett idealiskt sätt att låta användaren ställa in värdet för något attribut. Snarare än att direkt behöva skriva in ett tal i ett Gtk.Entry, så låter Gtk.SpinButton användaren klicka på en av två pilar för att öka eller minska det visade värdet. Ett värde kan fortfarande skrivas in, med bonusen att det kan kontrolleras för att säkerställa att det är i ett givet intervall. Huvudegenskaperna för en Gtk.SpinButton ställs in genom Gtk.Adjustment.

För att ändra värdet som Gtk.SpinButton visar, använd Gtk.SpinButton.set_value(). Värdet som matas in kan antingen vara ett hel- eller flyttal, beroende på dina krav. Använd Gtk.SpinButton.get_value_as_int() respektive Gtk.SpinButton.get_value().

När du tillåter visning av flyttalsvärden i stegningsrutan kan du vilja justera antalet decimaler som visas genom att anropa Gtk.SpinButton.set_digits().

Som standard accepterar Gtk.SpinButton textdata. Om du vill begränsa detta till endast numeriska värden anropar du Gtk.SpinButton.set_numeric() med True som argument.

Vi kan även justera uppdateringspolicyn för Gtk.SpinButton. Det finns två alternativ här; som standard uppdaterar stegningsrutan värdet även om de data som matas in är ogiltiga. Alternativt kan vi ställa in policyn så att det bara uppdateras när det inmatade värdet är giltigt genom att anropa Gtk.SpinButton.set_update_policy().

9.6.1. Exempel

_images/spinbutton_example.png
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
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

En Gtk.Switch är en komponent som har två tillstånd: på eller av. Användaren kan styra vilket tillstånd som ska vara aktivt genom att klicka på den tomma ytan, eller genom att dra handtaget.

Du bör inte använda ”activate”-signalen vilken är en åtgärdssignal på Gtk.Switch, att sända ut den får brytaren att animeras. Program ska aldrig ansluta till denna signal, utan använda signalen ”notify::active”, se exemplet nedan.

9.7.1. Exempel

_images/switch_example.png
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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()