Zoeken…


Een eenvoudig GTK-venster

Een venster eenvoudig presenteren is eenvoudig met GTK en Python. Het onderstaande voorbeeld is gebaseerd op de Python GTK3-zelfstudie , die u moet lezen als u een beginner bent in GUI-programmering of 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()

Wat (op Windows 10) zal resulteren in:

Het resultaat van het bovenstaande voorbeeld

Eenvoudig binden aan de toetsaanslag van een widget

De eenvoudigste manier om een gebeurtenishandler een toetsaanslag te laten krijgen, is door de handler aan te sluiten op het key-press-event . In dit voorbeeld registreren we ons voor het hele venster, maar u kunt zich ook registreren voor afzonderlijke widgets.

Het belangrijkste onderdeel is de verbinding van de handler met het evenement:

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

In de gebeurtenishandler worden de widget en de toetsdrukgebeurtenis doorgegeven als parameters. event.state zoals de Ctrl- toets zijn beschikbaar in event.state en de ingedrukte toets is event.keyval .

Waarden voor modificatiesleutels zijn te vinden in Gdk.ModiferType en omvatten CONTROL_MASK , SHIFT_MASK en verschillende andere.

Sleutelwaarden worden gevonden in Gdk met voorvoegsels van KEY_ , de sleutel h is bijvoorbeeld Gdk.KEY_h ) Deze kunnen worden omgezet in een string met behulp van 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()

Meer geavanceerd gedrag voor sneltoetsen voor de hele applicatie kan worden bereikt met een versnellergroep ( Gtk.AccelGroup ), maar vaak is een sneltoets-handler alles wat u nodig hebt om de toetsenbordgebeurtenissen vast te leggen die u voor een specifieke widget wilt.

Een video insluiten in een Gtk-venster in Python3

Hieronder is een voorbeeld van een Gstreamer-pijplijn ingebed in een eenvoudig GTK-venster. Wanneer het wordt uitgevoerd, zou er een klein venster als volgt moeten verschijnen:

Het voorbeeld wanneer uitgevoerd

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


Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow