gtk3
GTK + 3 mit Python

Ein einfaches GTK-Fenster

Mit GTK und Python ist es einfach, ein Fenster zu präsentieren. Das folgende Beispiel basiert auf dem Python GTK3 Tutorial , das Sie lesen sollten, wenn Sie Anfänger in der GUI-Programmierung oder GTK sind.

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

# Set up the Gtk window    
win = Gtk.Window()

# Tell Gtk what to do when the window is closed (in this case quit the main loop)
win.connect("delete-event", Gtk.main_quit)

# Create a label saying Hello World!
label = Gtk.Label(label="Hello World!")

# Add the label to the window
win.add(label)

# Tell Gtk to show all widgets inside the window
win.show_all()

# Start the Gtk main loop, which returns when Gtk.main_quit is called
Gtk.main()

Was (unter Windows 10) zur Folge haben wird:

Einfache Anbindung an das Key-Press-Event eines Widgets

Der einfachste Weg, einen Event-Handler bei einem Tastendruck aufrufen zu lassen, besteht darin, den Handler mit dem key-press-event zu verbinden. In diesem Beispiel registrieren wir uns für das gesamte Fenster, aber Sie können sich auch für einzelne Widgets registrieren.

Der wichtigste Teil ist die Anbindung des Handlers an die Veranstaltung:

self.connect("key-press-event",self.on_key_press_event)

Im Event-Handler werden das Widget und das Tastendruckereignis als Parameter übergeben. Tastendruckmodifizierer wie die Strg- Taste stehen in event.state zur Verfügung und die gedrückte Taste ist event.keyval .

Werte für Zusatztasten finden Sie in Gdk.ModiferType gehören CONTROL_MASK , SHIFT_MASK und einige andere.

Schlüsselwerte werden in Gdk mit dem Präfix KEY_ . Der Schlüssel h ist beispielsweise Gdk.KEY_h ) Diese Gdk.KEY_h können mit Gdk.keyval_name() in einen String Gdk.keyval_name() .

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from gi.repository import Gdk

class MyWindow(Gtk.Window):

    key = Gdk.KEY_h

    def __init__(self):
        # init the base class (Gtk.Window)
        super().__init__()

        # state affected by shortcuts
        self.shortcut_hits = 0

        # Tell Gtk what to do when the window is closed (in this case quit the main loop)
        self.connect("delete-event", Gtk.main_quit)

        # connect the key-press event - this will call the keypress
        # handler when any key is pressed
        self.connect("key-press-event",self.on_key_press_event)

        # Window content goes in a vertical box
        box = Gtk.VBox()

        # mapping between Gdk.KEY_h and a string
        keyname = Gdk.keyval_name(self.key)

        # a helpful label
        instruct = Gtk.Label(label="Press Ctrl+%s" % keyname)
        box.add(instruct)

        # the label that will respond to the event
        self.label = Gtk.Label(label="")
        self.update_label_text()

        # Add the label to the window
        box.add(self.label)

        self.add(box)

    def on_key_press_event(self, widget, event):

        print("Key press on widget: ", widget)
        print("          Modifiers: ", event.state)
        print("      Key val, name: ", event.keyval, Gdk.keyval_name(event.keyval))

        # check the event modifiers (can also use SHIFTMASK, etc)
        ctrl = (event.state & Gdk.ModifierType.CONTROL_MASK)

        # see if we recognise a keypress
        if ctrl and event.keyval == Gdk.KEY_h:
            self.shortcut_hits += 1
            self.update_label_text()

    def update_label_text(self):
        # Update the label based on the state of the hit variable
        self.label.set_text("Shortcut pressed %d times" % self.shortcut_hits)

if __name__ == "__main__":
    win = MyWindow()
    win.show_all()

    # Start the Gtk main loop
    Gtk.main()

Ein erweitertes Verhalten für anwendungsweite Verknüpfungen kann mit einer Beschleunigergruppe ( Gtk.AccelGroup ) erreicht werden. Häufig reicht jedoch ein kurzer Tastendruck-Handler aus, um die gewünschten Tastaturereignisse für ein bestimmtes Widget zu erfassen.

Betten Sie ein Video in ein GTK-Fenster in Python3 ein

Im Folgenden finden Sie ein Beispiel für eine Gstreamer-Pipeline, die in einem einfachen GTK-Fenster eingebettet ist. Bei der Ausführung sollte ein kleines Fenster wie folgt aussehen:

import gi
gi.require_version('Gtk', '3.0')
gi.require_version('Gst', '1.0')

from gi.repository import Gtk, Gst
Gst.init(None)
Gst.init_check(None)


class GstWidget(Gtk.Box):
    def __init__(self, pipeline):
        super().__init__()
        # Only setup the widget after the window is shown.
        self.connect('realize', self._on_realize)

        # Parse a gstreamer pipeline and create it.
        self._bin = Gst.parse_bin_from_description(pipeline, True)

    def _on_realize(self, widget):
        pipeline = Gst.Pipeline()
        factory = pipeline.get_factory()
        gtksink = factory.make('gtksink')
        pipeline.add(self._bin)
        pipeline.add(gtksink)
        # Link the pipeline to the sink that will display the video.
        self._bin.link(gtksink)
        self.pack_start(gtksink.props.widget, True, True, 0)
        gtksink.props.widget.show()
        # Start the video
        pipeline.set_state(Gst.State.PLAYING)


window = Gtk.ApplicationWindow()

# Create a gstreamer pipeline with no sink. 
# A sink will be created inside the GstWidget.
widget = GstWidget('videotestsrc')
widget.set_size_request(200, 200)

window.add(widget)

window.show_all()


def on_destroy(win):
    Gtk.main_quit()

window.connect('destroy', on_destroy)

Gtk.main()