Bitte warten

GTK 4: Interaktions-Widgets

Gtk.Entry

► PyGObject Tutorial: Gtk.Entry
► GTK Dokumentation: Gtk.Entry Gtk.PasswordEntry Gtk.SearchEntry

Das Widget Gtk.Entry erzeugt ein Texteingabefeld. Mit set_text() kann ein Text vorgegeben werden. Mit get_text() kann ein eingegebener Text ausgelesen werden.

Wird der Text des Eingabefeldes geändert, so löst diese Aktion das Signal changed aus, das mit einer entsprechenden Funktion verknüpft werden kann.

Das Betätigen der Eingabe-Taste löst das Signal activate aus.

Code kopieren
        self.entry01 = Gtk.Entry()
        self.entry01.set_text("Hallo, Welt!")
        self.entry01.connect('changed', self.on_entry01_changed)
        self.entry01.connect('activate', self.on_entry01_activate)
        self.set_child(self.entry01)

    def on_entry01_changed(self, _widget):
        print("Text wurde geändert.")

    def on_entry01_activate(self, _widget):
        print(self.entry01.get_text())

Gtk.Button

► PyGObject Tutorial: Gtk.Button
► GTK Dokumentation: Gtk.Button

Das Widget Gtk.Button erzeugt eine Schaltfläche. Wird die Schaltfläche angeklickt, so löst diese Aktion das Signal clicked aus, das mit einer entsprechenden Funktion verknüpft werden kann. Die Eigenschaft label enthält den Text, mit dem der Button versehen ist.

Code kopieren
        self.button01 = Gtk.Button(label="Klick mich!")
        self.button01.connect('clicked', self.on_button01_clicked)
        self.set_child(self.button01)

    def on_button01_clicked(self, _widget):
        print("Button wurde geklickt.")

Gtk.CheckButton

► PyGObject Tutorial: Gtk.CheckButton
► GTK Dokumentation: Gtk.CheckButton

Das Widget Gtk.CheckButton erzeugt ein Kontrollkästchen. Beim Anklicken dieses Widgets wird das Signal toggled ausgelöst, das mit einer entsprechenden Funktion verknüpft werden kann. Die Eigenschaft label fügt dem Kontrollkästchen einen beschreibenden Text hinzu.

Der Status des Widgets lässt sich mit set_active() festlegen und mit get_active() abfragen.

Code kopieren
        self.checkbutton01 = Gtk.CheckButton(label="Ich bin ein Kontrollkästchen")
        self.checkbutton01.set_active(True)
        self.checkbutton01.connect('toggled', self.on_checkbutton01_toggled)
        self.set_child(self.checkbutton01)

    def on_checkbutton01_toggled(self, _widget):
        print("CheckButton wurde aktiviert." if self.checkbutton01.get_active() else "CheckButton wurde deaktiviert.")

Durch Gruppierung von Checkbuttons können Radiobuttons für die Auswahl von genau einer Option aus dieser Gruppe erzeugt werden. Die Zusammengehörigkeit einzelner Checkbuttons zu einer Gruppe wird über die Eigenschaft group definiert, die den Namen des ersten Checkbuttons der Gruppe enthält.

Wird eine Option ausgewählt (auch über die Methode set_active), so löst dies das Signal toggled aus, das mit einer entsprechenden Funktion verknüpft werden kann.

Code kopieren
        self.box01 = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.set_child(self.box01)

        self.radiobutton01_1 = Gtk.CheckButton(label="Ja")
        self.radiobutton01_2 = Gtk.CheckButton(label="Nein", group=self.radiobutton01_1)
        self.radiobutton01_3 = Gtk.CheckButton(label="Vielleicht", group=self.radiobutton01_1)
        self.radiobutton01_1.connect('toggled', self.on_radio01_toggled)
        self.radiobutton01_2.connect('toggled', self.on_radio01_toggled)
        self.radiobutton01_3.connect('toggled', self.on_radio01_toggled)
        self.box01.append(self.radiobutton01_1)
        self.box01.append(self.radiobutton01_2)
        self.box01.append(self.radiobutton01_3)
        self.radiobutton01_3.set_active(True)

    def on_radio01_toggled(self, _widget):
        print(_widget.get_label())

Gtk.Switch

► PyGObject Tutorial: Gtk.Switch
► GTK Dokumentation: Gtk.Switch

Das Widget Gtk.Switch erzeugt einen Schalter für eine An/Aus- bzw. Ja/Nein-Option.

Wird der Schalter betätigt, so löst dies das Signal notify::active aus, das mit einer entsprechenden Funktion verknüpft werden kann.

Der Status des Schalters kann mit set_active() eingestellt und mit get_active() abgefragt werden.

Code kopieren
        self.switch01 = Gtk.Switch()
        self.switch01.connect('notify::active', self.on_switch01_active)
        self.switch01.set_active(True)
        self.set_child(self.switch01)

    def on_switch01_active(self, _widget, _gparam):
        print(_widget.get_active())

Gtk.DropDown

► PyGObject Tutorial: Gtk.DropDown
► GTK Dokumentation: Gtk.DropDown

Das Widget Gtk.DropDown erzeugt eine einfache Combobox mit einer Dropdown-Liste zur Auswahl einer Option. Wird eine Option ausgewählt, so löst dies das Signal notify::selected-item aus, das mit einer entsprechenden Funktion verknüpft werden kann.

Code kopieren
        self.dropdown01 = Gtk.DropDown.new_from_strings(["Apfel", "Birne", "Kirsche", "Banane"])
        self.dropdown01.connect("notify::selected-item", self.on_string_selected)
        self.set_child(self.dropdown01)

    def on_string_selected(self, _widget, _pspec):
        if selected := _widget.get_selected_item():
            print(selected.get_string())

Gtk.SpinButton

► PyGObject Tutorial: Gtk.SpinButton
► GTK Dokumentation: Gtk.SpinButton

Das Widget Gtk.SpinButton erzeugt ein Steuerelement zur Auswahl eines numerischen Wertes, der schrittweise eingestellt werden kann. Der untere und obere Wert wird mit set_range() eingestellt, die Schrittweite mit set_increments().

Der Wert des Widgets kann mit set_value() eingestellt und mit get_value() abgefragt werden.

Wird der Wert geändert, so löst dies das Signal value-changed aus, das mit einer entsprechenden Funktion verknüpft werden kann.

Code kopieren
        self.spinbutton01 = Gtk.SpinButton()
        self.spinbutton01.set_range(0, 100)
        self.spinbutton01.set_increments(1, 10)
        self.spinbutton01.set_value(50)
        self.spinbutton01.connect('value-changed', self.on_spinbutton01_changed)
        self.set_child(self.spinbutton01)

    def on_spinbutton01_changed(self, _widget):
        print(_widget.get_value())

Gtk.Scale

► PyGObject Tutorial: Gtk.Scale
► GTK Dokumentation: Gtk.Scale

Das Widget Gtk.Scale erzeugt einen Schieberegler zur Auswahl eines numerischen Wertes, der schrittweise eingestellt werden kann. Mit new_with_range() können folgende Parameter als Argumente übergeben werden: Orientierung, unterer Wert, oberer Wert, Schrittweite.

Der Wert des Widgets kann mit set_value() eingestellt und mit get_value() abgefragt werden.

Wird der Wert geändert, so löst dies das Signal value-changed aus, das mit einer entsprechenden Funktion verknüpft werden kann.

Code kopieren
        self.scale01 = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL, 0, 10, 1)
        self.scale01.set_value(4)
        self.scale01.set_draw_value(True)  # Zeigt Werte neben dem Widget an
        self.scale01.connect('value-changed', self.on_scale01_changed)
        self.set_child(self.scale01)

    def on_scale01_changed(self, _widget):
        print(_widget.get_value())

Gtk.FileDialog

► GTK Dokumentation: Gtk.FileDialog

Das Widget Gtk.FileDialog erzeugt einen Dialog zur Auswahl einer Datei bzw. eines Ordners. Mit Filtern kann die Auswahl auf bestimmte Dateitypen beschränkt werden. Der Pfad des ausgewählten Objekts kann mit get_path() abgefragt werden.

Code kopieren
#!/usr/bin/python3
import gi
gi.require_version('Gtk', '4.0')
from gi.repository import Gtk, Gio

class MyWindow(Gtk.ApplicationWindow):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs, title="GTK 4 Beispiel")
        self.set_icon_name("python")
        self.set_default_size(200, 200)

        self.button01 = Gtk.Button(label="Select File")
        self.button01.connect("clicked", self.on_button01_clicked)
        self.set_child(self.button01)

    def on_file_selected(self, dialog, result, user_data):
        try:
            file = dialog.open_finish(result)
            if file:
                print(file.get_path())
        except Exception as e:
            print(f"Error: {e}")
    
    def on_button01_clicked(self, user_data):
        file_dialog = Gtk.FileDialog()
        file_dialog.set_title("Datei auswählen")
    
        filter_list = Gio.ListStore.new(Gtk.FileFilter)
        filter_text = Gtk.FileFilter()
        filter_text.set_name("Textdateien")
        filter_text.add_mime_type("text/plain")
        filter_list.append(filter_text)
        file_dialog.set_filters(filter_list)
    
        file_dialog.open(
            parent=None,
            cancellable=None,
            callback=self.on_file_selected,
            user_data=None
        )

def on_activate(app):
    win = MyWindow(application=app)
    win.connect("close-request", on_close_request)
    win.present()

def on_close_request(app):
    app.close()

app = Gtk.Application(application_id="com.example.MyApp")
app.connect("activate", on_activate)
app.run(None)

Gtk.ColorDialog

► GTK Dokumentation: Gtk.ColorDialog Gtk.ColorDialogButton
► GDK Dokumentation: RGBA Colors

Das Widget Gtk.ColorDialogButton erzeugt eine Schaltfläche zur Auswahl einer Farbe über ein Popup, das durch Gtk.ColorDialog getriggert wird.

Wird dort die Farbe geändert, so löst dies das Signal notify::rgba aus, das mit einer entsprechenden Funktion verknüpft werden kann.

Der Wert des Widgets kann mit set_rgba() eingestellt und mit get_rgba() abgefragt werden. Dazu wird die Komponente Gdk aus dem Modul gi.repository benötigt.

Code kopieren
#!/usr/bin/python3
import gi
gi.require_version('Gtk', '4.0')
gi.require_version('Gdk', '4.0')
from gi.repository import Gtk, Gdk

class MyWindow(Gtk.ApplicationWindow):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs, title="GTK 4 Beispiel")
        self.set_icon_name("python")
        self.set_default_size(200, 200)

        self.colordialog01 = Gtk.ColorDialog.new()
        self.colorbutton01 = Gtk.ColorDialogButton.new(self.colordialog01)
        rgba = Gdk.RGBA()
        rgba.parse("rgba(255,0,0,1)")  # Startfarbe Rot
        self.colorbutton01.set_rgba(rgba)
        self.colorbutton01.connect("notify::rgba", self.on_color_set)
        self.set_child(self.colorbutton01)

    def on_color_set(self, _widget, dialog):
        color = _widget.get_rgba()
        print(color.to_string())

def on_activate(app):
    win = MyWindow(application=app)
    win.connect("close-request", on_close_request)
    win.present()

def on_close_request(app):
    app.close()

app = Gtk.Application(application_id="com.example.MyApp")
app.connect("activate", on_activate)
app.run(None)