gtk3
GTK + 3 con Python

Una simple ventana de GTK.

Simplemente presentar una ventana es fácil con GTK y Python. El siguiente ejemplo se basa en el Tutorial de Python GTK3 , que debe leer si es un principiante en la programación de GUI o GTK.

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()

Lo que resultará (en Windows 10) en:

Enlace simple al evento de pulsación de tecla de un widget

La forma más sencilla de obtener un controlador de eventos al presionar una tecla es conectar el controlador a la señal de key-press-event . En este ejemplo, nos registramos para el evento para toda la ventana, pero también puede registrarse para widgets individuales.

La parte más importante es la conexión del controlador al evento:

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

En el controlador de eventos, el widget y el evento de pulsación de tecla se pasan como parámetros. Los modificadores de pulsación de tecla, como la tecla Ctrl, están disponibles en event.state y la tecla presionada es event.keyval .

Los valores de las claves modificadoras se encuentran en Gdk.ModiferType e incluyen CONTROL_MASK , SHIFT_MASK y varios otros.

Los valores clave se encuentran en Gdk con los prefijos de KEY_ , por ejemplo, la clave h es Gdk.KEY_h ) Estos se pueden convertir en una cadena usando 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()

Se puede lograr un comportamiento más avanzado para los accesos directos de toda la aplicación con un grupo acelerador ( Gtk.AccelGroup ), pero a menudo todo lo que necesita para capturar los eventos de teclado que desea para un widget específico es un controlador de pulsación rápida de teclas.

Incrustar un video en una ventana de Gtk en Python3

A continuación se muestra un ejemplo de canalización de Gstreamer incrustada en una ventana gtk simple. Cuando se ejecuta, una pequeña ventana debe aparecer así:

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()