PyGObject

https://pygobject.gnome.org
Admin
PyGObject is a Python package providing bindings for GObject-based libraries like GTK, GStreamer,...
Tokens:104,459
Snippets:1,096
Trust Score:10
Update:6 months ago
Show doc for...
Tokens:
Raw
### Example Usage of GTK Entry Widgets

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/controls/entries.rst.txt

This example demonstrates the various functionalities of GTK Entry widgets, including setting text, visibility, progress, icons, and placeholder text. It requires PyGObject and GTK to be installed.

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


class EntryWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Entry Demo")

        self.set_border_width(10)

        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        self.add(vbox)

        # Generic Entry
        entry = Gtk.Entry()
        entry.set_text("Hello World!")
        entry.connect("changed", self.on_changed, "generic")
        vbox.pack_start(entry, True, True, 0)

        # Password Entry
        password_entry = Gtk.PasswordEntry()
        password_entry.set_text("secret")
        password_entry.set_visibility(False)
        password_entry.connect("changed", self.on_changed, "password")
        vbox.pack_start(password_entry, True, True, 0)

        # Search Entry
        search_entry = Gtk.SearchEntry()
        search_entry.set_placeholder_text("Search...")
        search_entry.connect("search-changed", self.on_search_changed)
        vbox.pack_start(search_entry, True, True, 0)

        # Entry with Progress
        progress_entry = Gtk.Entry()
        progress_entry.set_progress_fraction(0.7)
        progress_entry.set_progress_pulse_step(0.5)
        progress_entry.grab_focus()
        progress_entry.progress_pulse()
        vbox.pack_start(progress_entry, True, True, 0)

        # Entry with Icons
        icon_entry = Gtk.Entry()
        icon_entry.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, "system-search-symbolic")
        icon_entry.set_icon_tooltip_text(Gtk.EntryIconPosition.PRIMARY, "Search Icon")
        icon_entry.set_icon_from_icon_name(Gtk.EntryIconPosition.SECONDARY, "pan-end-symbolic")
        icon_entry.set_icon_tooltip_text(Gtk.EntryIconPosition.SECONDARY, "Clear Text")
        vbox.pack_start(icon_entry, True, True, 0)

        # Entry with Placeholder Text
        placeholder_entry = Gtk.Entry()
        placeholder_entry.set_placeholder_text("Enter text here...")
        vbox.pack_start(placeholder_entry, True, True, 0)

    def on_changed(self, widget, entry_type):
        print("Type %s: text changed to %s" % (entry_type, widget.get_text()))

    def on_search_changed(self, widget):
        print("Search: text changed to %s" % widget.get_text())


win = EntryWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()

```

--------------------------------

### Implement Drag and Drop

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/drag-and-drop.rst.txt

A complete example demonstrating the setup of drag-and-drop operations between widgets.

```python
import sys
import gi

gi.require_version("Gtk", "4.0")
from gi.repository import Gtk, Gdk, GObject


def on_drag_begin(source, drag):
    print("Drag begin")


def on_drag_end(source, drag, success):
    print(f"Drag end: {success}")


def on_drop(target, value, x, y):
    print(f"Dropped value: {value}")
    return True


def on_activate(app):
    win = Gtk.ApplicationWindow(application=app)
    win.set_default_size(200, 200)

    box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
    win.set_child(box)

    label = Gtk.Label(label="Drag me!")
    box.append(label)

    # Drag Source
    source = Gtk.DragSource(actions=Gdk.DragAction.COPY)
    source.set_content(Gdk.ContentProvider.new_for_value("Hello World"))
    source.connect("drag-begin", on_drag_begin)
    source.connect("drag-end", on_drag_end)
    label.add_controller(source)

    # Drop Target
    target = Gtk.DropTarget(actions=Gdk.DragAction.COPY, gtypes=[str])
    target.connect("drop", on_drop)
    label2 = Gtk.Label(label="Drop here!")
    box.append(label2)
    label2.add_controller(target)

    win.present()


app = Gtk.Application(application_id="org.gtk.example")
app.connect("activate", on_activate)
app.run(sys.argv)
```

--------------------------------

### Set up Python Virtual Environment and Install Build Tools

Source: https://pygobject.gnome.org/devguide/dev_environ.html

Creates a Python virtual environment named '.venv', activates it, and installs Meson-Python, Meson, Ninja, Pycairo, pytest, and pre-commit. These are required for editable installs and development.

```bash
python3 -m venv .venv
source .venv/bin/activate
python3 -m pip install meson-python meson ninja pycairo pytest pre-commit

```

--------------------------------

### Class Docstring and Usage Example

Source: https://pygobject.gnome.org/_sources/devguide/style_guide.rst.txt

Standard format for class documentation including __init__ parameters and usage examples.

```python
      class Bacon(CookedFood):
            """Bacon is a breakfast food.

            :param CookingType cooking_type:
                Enum for the type of cooking to use.
            :param float cooking_time:
                Amount of time used to cook the Bacon in minutes.

            Use Bacon in combination with other breakfast foods for
            a complete breakfast. For example, combine Bacon with
            other items in a list to make a breakfast:

            .. code-block:: python

                breakfast = [Bacon(), Spam(), Spam(), Eggs()]

            """
            def __init__(self, cooking_type=CookingType.BAKE, cooking_time=15.0):
                super(Bacon, self).__init__(cooking_type, cooking_time)
```

--------------------------------

### Gtk.SpinButton Implementation Example

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/controls/spinbutton.rst.txt

A complete example demonstrating the creation and configuration of a Gtk.SpinButton widget.

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

class SpinButtonWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="SpinButton Example")
        self.set_border_width(10)

        hbox = Gtk.Box(spacing=6)
        self.add(hbox)

        adjustment = Gtk.Adjustment(value=0, lower=0, upper=100, step_increment=1, page_increment=10, page_size=0)
        self.spinbutton = Gtk.SpinButton(adjustment=adjustment)
        self.spinbutton.set_numeric(True)
        hbox.pack_start(self.spinbutton, False, False, 0)

        self.check_button = Gtk.CheckButton(label="Numeric")
        self.check_button.connect("toggled", self.on_numeric_toggled)
        hbox.pack_start(self.check_button, False, False, 0)

    def on_numeric_toggled(self, button):
        self.spinbutton.set_numeric(button.get_active())

win = SpinButtonWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()
```

--------------------------------

### Create and Configure a Gtk.CenterBox

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/layout-widgets.rst.txt

Illustrates the setup of a Gtk.CenterBox, which arranges three children (start, center, end) in a row or column. Use this for layouts where a central element needs to be prominent.

```python
centerbox = Gtk.CenterBox()
window.add(centerbox)
```

--------------------------------

### Example: Gtk.Grid Layout

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/layout-widgets.rst.txt

This example demonstrates the usage of Gtk.Grid for arranging widgets. It includes setting up the grid and attaching child widgets.

```python
import sys

import gi

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


class GridWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Grid Example")

        self.grid = Gtk.Grid()
        self.add(self.grid)

        button1 = Gtk.Button(label="Button 1")
        button2 = Gtk.Button(label="Button 2")
        button3 = Gtk.Button(label="Button 3")
        button4 = Gtk.Button(label="Button 4")
        button5 = Gtk.Button(label="Button 5")

        self.grid.attach(button1, 0, 0, 1, 1)
        self.grid.attach(button2, 1, 0, 2, 1)
        self.grid.attach(button3, 0, 1, 1, 2)
        self.grid.attach(button4, 1, 1, 1, 1)
        self.grid.attach(button5, 2, 1, 1, 2)


win = GridWindow()
win.connect('destroy', Gtk.main_quit)
win.show_all()
Gtk.main()

```

--------------------------------

### Build PyGObject with Meson

Source: https://pygobject.gnome.org/devguide/packagingguide.html

Use these commands to set up, compile, test, and install PyGObject using Meson. Ensure you have the necessary build dependencies installed.

```bash
meson setup --prefix /usr --buildtype=plain _build -Dc_args=... -Dc_link_args=...
meson compile -C _build
Meson test -C _build
DESTDIR=/path/to/staging/root meson install -C _build
```

--------------------------------

### Install PyGObject on openSUSE (PyPI)

Source: https://pygobject.gnome.org/getting_started.html

Installs PyGObject and GTK4 from PyPI using pip after installing build dependencies. This method is suitable for virtual environments.

```bash
sudo zypper install cairo-devel pkg-config python3-devel gcc gobject-introspection-devel
```

```bash
pip3 install pycairo
```

```bash
pip3 install PyGObject
```

--------------------------------

### Build Setup with jhbuild

Source: https://pygobject.gnome.org/devguide/profiling.html

General vpath build setup using jhbuild shell for x86_64 architecture. Ensure Python 3.3 is specified.

```bash
mkdir _build
cd _build
export PYTHON=`which python3.3`
jhbuild shell
../configure --prefix=$JHBUILD_PREFIX --libdir=$JHBUILD_LIBDIR --with-python=$PYTHON
make

```

--------------------------------

### Install openSUSE Dependencies

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Installs required development packages for PyGObject on openSUSE.

```console
sudo zypper install -y python3-wheel gobject-introspection-devel \
  python3-cairo-devel openssl zlib git
sudo zypper install --type pattern devel_basis
```

--------------------------------

### Example: Gtk.ListBox

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/layout-widgets.rst.txt

This example demonstrates how to create and populate a Gtk.ListBox with custom rows. It shows appending widgets and handling row activation.

```python
import sys

import gi

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


class ListBoxWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="ListBox Example")

        self.set_border_width(10)

        listbox = Gtk.ListBox()
        listbox.set_selection_mode(Gtk.SelectionMode.NONE)
        self.add(listbox)

        for i in range(5):
            label = Gtk.Label(label="Row %d" % (i + 1))
            listbox.add(label)

        listbox.connect("row-activated", self.on_row_activated)

    def on_row_activated(self, listbox, row):
        model = listbox.get_model()
        response_id = row.get_child().get_label()
        print("Activated: %s" % response_id)


win = ListBoxWindow()
win.connect('destroy', Gtk.main_quit)
win.show_all()
Gtk.main()

```

--------------------------------

### Example Text View Implementation

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/textview.rst.txt

This snippet is a complete example of a text view implementation, likely demonstrating various features including text formatting. It is loaded from an external file.

```python
from gi.repository import Gtk

class TextViewWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Text View Example")

        self.textbuffer = Gtk.TextBuffer()

        self.textview = Gtk.TextView()
        self.textview.set_buffer(self.textbuffer)
        self.add(self.textview)

        # Add some initial text
        self.textbuffer.insert_at_cursor("Hello, Gnome!")

        # Create and apply a tag for styling
        tag = self.textbuffer.create_tag('bold_tag', weight=Pango.Weight.BOLD)
        start_iter = self.textbuffer.get_iter_at_line(0)
        end_iter = self.textbuffer.get_iter_at_line(1)
        self.textbuffer.apply_tag(tag, start_iter, end_iter)

        tag_italic = self.textbuffer.create_tag('italic_tag', style=Pango.Style.ITALIC)
        start_iter_italic = self.textbuffer.get_iter_at_line(0)
        end_iter_italic = self.textbuffer.get_iter_at_line(1)
        self.textbuffer.apply_tag(tag_italic, start_iter_italic, end_iter_italic)

        tag_color = self.textbuffer.create_tag('red_fg', foreground='red')
        start_iter_color = self.textbuffer.get_iter_at_line(0)
        end_iter_color = self.textbuffer.get_iter_at_line(1)
        self.textbuffer.apply_tag(tag_color, start_iter_color, end_iter_color)

        tag_underline = self.textbuffer.create_tag('underline_tag', underline=Pango.Underline.SINGLE)
        start_iter_underline = self.textbuffer.get_iter_at_line(0)
        end_iter_underline = self.textbuffer.get_iter_at_line(1)
        self.textbuffer.apply_tag(tag_underline, start_iter_underline, end_iter_underline)

        tag_strikethrough = self.textbuffer.create_tag('strikethrough_tag', strikethrough=True)
        start_iter_strikethrough = self.textbuffer.get_iter_at_line(0)
        end_iter_strikethrough = self.textbuffer.get_iter_at_line(1)
        self.textbuffer.apply_tag(tag_strikethrough, start_iter_strikethrough, end_iter_strikethrough)

        tag_background = self.textbuffer.create_tag('background_tag', background='lightgray')
        start_iter_background = self.textbuffer.get_iter_at_line(0)
        end_iter_background = self.textbuffer.get_iter_at_line(1)
        self.textbuffer.apply_tag(tag_background, start_iter_background, end_iter_background)

        tag_size = self.textbuffer.create_tag('size_tag', size_points=18)
        start_iter_size = self.textbuffer.get_iter_at_line(0)
        end_iter_size = self.textbuffer.get_iter_at_line(1)
        self.textbuffer.apply_tag(tag_size, start_iter_size, end_iter_size)

        tag_wrap = self.textbuffer.create_tag('wrap_tag', wrap_mode=Gtk.WrapMode.WORD)
        start_iter_wrap = self.textbuffer.get_iter_at_line(0)
        end_iter_wrap = self.textbuffer.get_iter_at_line(1)
        self.textbuffer.apply_tag(tag_wrap, start_iter_wrap, end_iter_wrap)

        tag_justification = self.textbuffer.create_tag('justification_tag', justification=Gtk.Justification.RIGHT)
        start_iter_justification = self.textbuffer.get_iter_at_line(0)
        end_iter_justification = self.textbuffer.get_iter_at_line(1)
        self.textbuffer.apply_tag(tag_justification, start_iter_justification, end_iter_justification)


app = Gtk.Application(application_id='org.example.TextView')
app.connect('activate', lambda a: TextViewWindow())
app.run(None)

```

--------------------------------

### Install pyenv on Linux

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Installs pyenv and sets a global Python version on Linux.

```console
curl https://pyenv.run | bash
exec $SHELL
pyenv install 3.11
pyenv global 3.11
```

--------------------------------

### Example: Gtk.FlowBox

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/layout-widgets.rst.txt

This example demonstrates the use of Gtk.FlowBox to arrange widgets in a flow layout. It shows how to add children and configure the box.

```python
import sys

import gi

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


class FlowBoxWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="FlowBox Example")

        self.set_default_size(400, 200)
        self.set_border_width(10)

        scrolled_window = Gtk.ScrolledWindow()
        scrolled_window.set_hexpand(True)
        scrolled_window.set_vexpand(True)
        self.add(scrolled_window)

        flowbox = Gtk.FlowBox()
        flowbox.set_valign(Gtk.Align.START)
        flowbox.set_max_children_per_line(3)
        flowbox.set_selection_mode(Gtk.SelectionMode.NONE)
        scrolled_window.add(flowbox)

        for i in range(10):
            button = Gtk.Button(label="Button %d" % (i + 1))
            flowbox.insert_child_at(button, i)


win = FlowBoxWindow()
win.connect('destroy', Gtk.main_quit)
win.show_all()
Gtk.main()

```

--------------------------------

### Install GTK and PyGObject on Fedora (Pip)

Source: https://pygobject.gnome.org/_sources/getting_started.rst.txt

Installs build dependencies, GTK, PyCairo, and PyGObject using pip. Ensure you are in a virtual environment.

```bash
sudo dnf install gcc gobject-introspection-devel cairo-gobject-devel pkg-config python3-devel gtk4
```

```bash
pip3 install pycairo
```

```bash
pip3 install PyGObject
```

```bash
python3 hello.py
```

--------------------------------

### Install PyGObject with Meson

Source: https://pygobject.gnome.org/_sources/devguide/packagingguide.rst.txt

Command to install PyGObject to a staging directory using Meson. Ensure DESTDIR is set to the desired staging root path.

```bash
DESTDIR=/path/to/staging/root meson install -C _build
```

--------------------------------

### Creating a MessageDialog

Source: https://pygobject.gnome.org/devguide/introspection_porting.html

Example of instantiating a Gtk.MessageDialog directly in Python.

```python
$ python -c 'from gi.repository import Gtk; Gtk.MessageDialog(None, 0, Gtk.MessageType.INFO, Gtk.ButtonsType.CLOSE, "Hello World").run()'
```

--------------------------------

### Gtk.Label Example

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/display-widgets/label.rst.txt

This snippet demonstrates the usage of the Gtk.Label widget. It is part of a larger example file that showcases various label functionalities.

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


class LabelWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Label Example")

        self.set_border_width(10)

        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        self.add(vbox)

        # Basic label
        label = Gtk.Label(label="This is a basic Gtk.Label.")
        vbox.pack_start(label, True, True, 0)

        # Multi-line label
        multi_label = Gtk.Label(label="This is a multi-line label.\nWith a second line.")
        vbox.pack_start(multi_label, True, True, 0)

        # Selectable label
        selectable_label = Gtk.Label(label="You can select this text.")
        selectable_label.set_selectable(True)
        vbox.pack_start(selectable_label, True, True, 0)

        # Justified label
        justified_label = Gtk.Label(
            label="This is a justified label. It will be spaced to fill the entire line width."
        )
        justified_label.set_justify(Gtk.Justification.FILL)
        vbox.pack_start(justified_label, True, True, 0)

        # Wrapped label
        wrapped_label = Gtk.Label(
            label="This is a very long label that will be wrapped and will probably take up multiple lines."
        )
        wrapped_label.set_wrap(True)
        vbox.pack_start(wrapped_label, True, True, 0)

        # Label with Pango markup
        markup_label = Gtk.Label()
        markup_label.set_markup(
            "This label contains <a href=\"https://www.gtk.org\" title=\"Our website\">a link</a>, <b>bold text</b>, and <i>italic text</i>."
        )
        vbox.pack_start(markup_label, True, True, 0)

        # Label with mnemonic
        mnemonic_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
        vbox.pack_start(mnemonic_box, True, True, 0)

        button = Gtk.Button.new_with_mnemonic("_Click Me")
        button.connect("clicked", self.on_button_clicked)
        mnemonic_box.pack_start(button, True, True, 0)

        label_for_button = Gtk.Label("_Another Label:")
        label_for_button.set_mnemonic_widget(button)
        mnemonic_box.pack_start(label_for_button, True, True, 0)

        # Aligned label
        aligned_label = Gtk.Label(label="Aligned Label")
        aligned_label.set_xalign(0.0)  # Left alignment
        aligned_label.set_yalign(0.0)  # Top alignment
        vbox.pack_start(aligned_label, True, True, 0)

    def on_button_clicked(self, widget):
        print("Button clicked!")


win = LabelWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()

```

--------------------------------

### Install GTK and PyGObject on Ubuntu/Debian (Pip)

Source: https://pygobject.gnome.org/_sources/getting_started.rst.txt

Installs build dependencies, GTK, PyCairo, and PyGObject using pip. Ensure you are in a virtual environment.

```bash
sudo apt install libgirepository-2.0-dev gcc libcairo2-dev pkg-config python3-dev gir1.2-gtk-4.0
```

```bash
pip3 install pycairo
```

```bash
pip3 install PyGObject
```

```bash
python3 hello.py
```

--------------------------------

### Develop with PDM

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Installs dependencies and runs tests using PDM.

```console
pdm install
pdm run pytest
```

--------------------------------

### Create an extended Hello World application

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/introduction.rst.txt

A more complex example using a custom class that inherits from Gtk.ApplicationWindow.

```python
import gi
gi.require_version('Gtk', '4.0')
from gi.repository import Gtk

class MyWindow(Gtk.ApplicationWindow):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.set_title('Hello World')

        button = Gtk.Button(label='Click me')
        button.connect('clicked', self.on_button_clicked)
        self.set_child(button)

    def on_button_clicked(self, widget):
        print('Hello World')
        self.close()

def on_activate(app):
    win = MyWindow(application=app)
    win.present()

app = Gtk.Application(application_id='com.example.GtkApplication')
app.connect('activate', on_activate)
app.run(None)
```

--------------------------------

### Set up Meson build environment

Source: https://pygobject.gnome.org/_sources/devguide/packagingguide.rst.txt

Use this command to set up the build environment with specified prefix and build type. Adjust C arguments and link arguments as needed.

```bash
meson setup --prefix /usr --buildtype=plain _build -Dc_args=... -Dc_link_args=...
```

--------------------------------

### Implement a basic Gtk.Application

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/application.rst.txt

A complete example demonstrating the structure of a GTK application using Gtk.Application and Gtk.ApplicationWindow.

```python
import sys
import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Gio


class MyApplication(Gtk.Application):
    def __init__(self):
        super().__init__(application_id="com.example.MyApplication")

    def do_activate(self):
        window = Gtk.ApplicationWindow(application=self)
        window.set_default_size(400, 400)
        window.set_title("My Application")
        window.show_all()


app = MyApplication()
app.run(sys.argv)
```

--------------------------------

### Handle Editing Started Signal in Gtk.Window

Source: https://pygobject.gnome.org/devguide/analysis/object_ref_counting_for_vfuncs_and_closures.html

Connects to the 'editing-started' signal and prints the path. This example demonstrates a scenario where a floating reference might be leaked if not handled correctly.

```Python
class Window(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        renderer = Gtk.CellRendererText()
        renderer.connect('editing-started', self.on_view_label_cell_editing_started)

    def on_view_label_cell_editing_started(self, renderer, editable, path):
        print path

```

--------------------------------

### Create a basic GTK 4 window

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/introduction.rst.txt

A minimal example demonstrating how to initialize a GTK 4 application and display an empty window.

```python
import gi
gi.require_version('Gtk', '4.0')
from gi.repository import Gtk

def on_activate(app):
    win = Gtk.ApplicationWindow(application=app)
    win.set_default_size(200, 200)
    win.present()

app = Gtk.Application(application_id='com.example.GtkApplication')
app.connect('activate', on_activate)
app.run(None)
```

--------------------------------

### Gtk.Spinner with Timeout

Source: https://pygobject.gnome.org/tutorials/gtk4/display-widgets/spinner.html

An extended example showing how to use Gtk.Spinner with a timeout function for timed activity. The spinner starts and stops based on a countdown timer set by user input. Requires Gtk.ApplicationWindow, Gtk.Entry, Gtk.Button, and GLib.timeout_add.

```python
import gi

gi.require_version("Gtk", "4.0")
from gi.repository import Gtk, GLib


class SpinnerAnimation(Gtk.ApplicationWindow):
    def __init__(self, **kargs):
        super().__init__(**kargs, title="Spinner Demo")

        main_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        self.set_child(main_box)

        self.spinner = Gtk.Spinner()
        main_box.append(self.spinner)

        self.label = Gtk.Label()
        main_box.append(self.label)

        self.entry = Gtk.Entry(text="10")
        main_box.append(self.entry)

        self.button_start = Gtk.Button(label="Start timer")
        self.button_start.connect("clicked", self.on_button_start_clicked)
        main_box.append(self.button_start)

        self.button_stop = Gtk.Button(label="Stop timer", sensitive=False)
        self.button_stop.connect("clicked", self.on_button_stop_clicked)
        main_box.append(self.button_stop)

        self.timeout_id = None
        self.connect("unrealize", self.on_window_destroy)

    def on_button_start_clicked(self, _widget):
        """Handles 'clicked' event of button_start."""
        self.start_timer()

    def on_button_stop_clicked(self, _widget):
        """Handles 'clicked' event of button_stop."""
        self.stop_timer("Stopped from button")

    def on_window_destroy(self, _widget):
        """Handles unrealize event of main window."""
        # Ensure the timeout function is stopped
        if self.timeout_id:
            GLib.source_remove(self.timeout_id)
            self.timeout_id = None

    def on_timeout(self):
        """A timeout function.
        Return True to stop it.
        This is not a precise timer since next timeout
        is recalculated based on the current time.
        """
        self.counter -= 1
        if self.counter <= 0:
            self.stop_timer("Reached time out")
            return False
        self.label.props.label = f"Remaining: {int(self.counter / 4)!s}"
        return True

    def start_timer(self):
        """Start the timer."""
        self.button_start.props.sensitive = False
        self.button_stop.props.sensitive = True
        # time out will check every 250 milliseconds (1/4 of a second)
        self.counter = 4 * int(self.entry.props.text)
        self.label.props.label = f"Remaining: {int(self.counter / 4)!s}"
        self.spinner.start()
        self.timeout_id = GLib.timeout_add(250, self.on_timeout)

    def stop_timer(self, label_text):
        """Stop the timer."""
        if self.timeout_id:
            GLib.source_remove(self.timeout_id)
            self.timeout_id = None
        self.spinner.stop()
        self.button_start.props.sensitive = True
        self.button_stop.props.sensitive = False
        self.label.props.label = label_text


def on_activate(app):
    win = SpinnerAnimation(application=app)
    win.present()


app = Gtk.Application(application_id="com.example.App")
app.connect("activate", on_activate)

app.run(None)
```

--------------------------------

### Application Entry Point

Source: https://pygobject.gnome.org/tutorials/gtk4/textview.html

Initializes and runs the Gtk.Application instance.

```python
def on_activate(app):
    win = TextViewWindow(application=app)
    win.present()


app = Gtk.Application(application_id="com.example.App")
app.connect("activate", on_activate)

app.run(None)
```

--------------------------------

### Install PyGObject on macOS

Source: https://pygobject.gnome.org/getting_started.html

Installs PyGObject and GTK4 using Homebrew on macOS. Ensure Homebrew is installed first.

```bash
brew install pygobject3 gtk4
```

--------------------------------

### Initialize application and connect activate signal

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/introduction.rst.txt

Sets up the Gtk.Application instance and connects the activate signal to a callback function.

```python
app = Gtk.Application(application_id='com.example.GtkApplication')
app.connect('activate', on_activate)
```

--------------------------------

### Install PyGObject on openSUSE (System)

Source: https://pygobject.gnome.org/getting_started.html

Installs PyGObject and GTK4 using zypper on openSUSE. Ensure you have Python 3 installed.

```bash
sudo zypper install python3-gobject python3-gobject-Gdk typelib-1_0-Gtk-4_0 libgtk-4-1
```

--------------------------------

### Install PyGObject Project Dependencies with PDM

Source: https://pygobject.gnome.org/devguide/dev_environ.html

Installs all project dependencies using PDM, a modern Python package and dependency manager. Assumes PDM 2.13 or newer is installed.

```bash
pdm install

```

--------------------------------

### Create a GTK 'Hello World' Application

Source: https://pygobject.gnome.org/tutorials/gtk4/introduction.html

An extended example demonstrating a 'Hello World' application. It uses a custom `MyWindow` class subclassing `Gtk.ApplicationWindow` and includes a button that closes the window when clicked.

```python
import gi

gi.require_version("Gtk", "4.0")
from gi.repository import Gtk


class MyWindow(Gtk.ApplicationWindow):
    def __init__(self, **kargs):
        super().__init__(**kargs, title="Hello World")

        self.button = Gtk.Button(label="Click Here")
        self.button.connect("clicked", self.on_button_clicked)
        self.set_child(self.button)

    def on_button_clicked(self, _widget):
        self.close()


def on_activate(app):
    # Create window
    win = MyWindow(application=app)
    win.present()


app = Gtk.Application(application_id="com.example.App")
app.connect("activate", on_activate)

app.run(None)
```

--------------------------------

### Setup Meson Build Environment

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Initialize the Meson build system for PyGObject. This command is typically needed only once to set up the build directory.

```console
meson setup _build  # Needed only once
```

--------------------------------

### Install PyGObject with Development Dependencies

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Install PyGObject in your local environment with the --no-build-isolation flag to allow for dynamic rebuilds. This command installs development dependencies and enables tests.

```console
pip install --no-build-isolation --config-settings=setup-args="-Dtests=true" -e '.[dev]'
```

--------------------------------

### Setup PyGObject Build Directory with Meson

Source: https://pygobject.gnome.org/devguide/dev_environ.html

Initializes the Meson build system for PyGObject by setting up a build directory named '_build'. This command is typically needed only once.

```bash
meson setup _build  # Needed only once

```

--------------------------------

### Install pyenv and Set Python Version on macOS

Source: https://pygobject.gnome.org/devguide/dev_environ.html

Installs pyenv using Homebrew, then installs and sets Python 3.11 as the global version. This simplifies managing different Python environments.

```bash
brew install pyenv
pyenv install 3.11
pyenv global 3.11

```

--------------------------------

### Create Gtk.Button instances

Source: https://pygobject.gnome.org/tutorials/gtk4/controls/buttons.html

Demonstrates creating standard buttons with labels and mnemonics, and connecting them to clicked signals.

```python
 1import gi
 2
 3gi.require_version("Gtk", "4.0")
 4from gi.repository import Gtk
 5
 6
 7class ButtonWindow(Gtk.ApplicationWindow):
 8    def __init__(self, **kargs):
 9        super().__init__(**kargs, title="Button Demo")
10
11        hbox = Gtk.Box(spacing=6)
12        self.set_child(hbox)
13
14        button = Gtk.Button.new_with_label("Click Me")
15        button.connect("clicked", self.on_click_me_clicked)
16        hbox.append(button)
17
18        button = Gtk.Button.new_with_mnemonic("_Open")
19        button.connect("clicked", self.on_open_clicked)
20        hbox.append(button)
21
22        button = Gtk.Button.new_with_mnemonic("_Close")
23        button.connect("clicked", self.on_close_clicked)
24        hbox.append(button)
25
26    def on_click_me_clicked(self, _button):
27        print("[Click me] button was clicked")
28
29    def on_open_clicked(self, _button):
30        print("[Open] button was clicked")
31
32    def on_close_clicked(self, _button):
33        print("Closing application")
34        self.close()
35
36
37def on_activate(app):
38    win = ButtonWindow(application=app)
39    win.present()
40
41
42app = Gtk.Application(application_id="com.example.App")
43app.connect("activate", on_activate)
44
45app.run(None)
```

--------------------------------

### Install macOS PyGObject Dependencies with Homebrew

Source: https://pygobject.gnome.org/devguide/dev_environ.html

Updates Homebrew, installs Python 3, GObject introspection, and libffi. Sets the PKG_CONFIG_PATH for libffi, which may differ for older Homebrew installations.

```bash
brew update
brew install python3 gobject-introspection libffi
export PKG_CONFIG_PATH=$(brew --prefix libffi)/lib/pkgconfig  # use /usr/local/ for older Homebrew installs

```

--------------------------------

### Install and Run Pre-commit Hooks

Source: https://pygobject.gnome.org/_sources/devguide/style_guide.rst.txt

Commands to set up and execute pre-commit hooks for maintaining consistent code style.

```python
pre-commit install
```

```python
pre-commit run --all-files
```

--------------------------------

### Install Fedora Dependencies

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Installs required development packages for PyGObject on Fedora.

```console
sudo dnf install -y python3-wheel
sudo dnf install -y gcc zlib-devel bzip2 bzip2-devel readline-devel \
  sqlite sqlite-devel openssl-devel tk-devel git python3-cairo-devel \
  cairo-gobject-devel gobject-introspection-devel
```

--------------------------------

### Install pyenv on macOS

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Installs pyenv and sets a global Python version on macOS.

```console
brew install pyenv
pyenv install 3.11
pyenv global 3.11
```

--------------------------------

### Minimal example without GtkApplication

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/introduction.rst.txt

A manual main loop implementation for testing purposes; avoid using this for standard application development.

```python
import gi
gi.require_version('Gtk', '4.0')
from gi.repository import GLib, Gtk

win = Gtk.Window()
win.present()

while (len(Gtk.Window.get_toplevels()) > 0):
    GLib.MainContext.default().iteration(True)
```

--------------------------------

### Create Gtk.Label configurations

Source: https://pygobject.gnome.org/tutorials/gtk4/display-widgets/label.html

Demonstrates creating a Gtk.ApplicationWindow with multiple Gtk.Label instances showcasing different alignment, wrapping, markup, and mnemonic settings.

```python
  1import gi
  2
  3gi.require_version("Gtk", "4.0")
  4from gi.repository import Gtk
  5
  6
  7class LabelWindow(Gtk.ApplicationWindow):
  8    def __init__(self, **kargs):
  9        super().__init__(**kargs, title="Label Demo")
 10
 11        box = Gtk.Box(spacing=10)
 12        self.set_child(box)
 13
 14        box_left = Gtk.Box(
 15            orientation=Gtk.Orientation.VERTICAL,
 16            spacing=10,
 17            hexpand=True,
 18            homogeneous=True,
 19        )
 20        box_right = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
 21
 22        box.append(box_left)
 23        box.append(box_right)
 24
 25        label = Gtk.Label(label="This is a normal label")
 26        box_left.append(label)
 27
 28        label = Gtk.Label(
 29            label="This is a normal label with xalign set to 0",
 30            xalign=0,
 31        )
 32        box_left.append(label)
 33
 34        label = Gtk.Label(
 35            label="This is a left-justified label.\nWith multiple lines.",
 36            justify=Gtk.Justification.LEFT,
 37        )
 38        box_left.append(label)
 39
 40        label = Gtk.Label(
 41            label="This is a right-justified label.\nWith multiple lines.",
 42            justify=Gtk.Justification.RIGHT,
 43        )
 44        box_left.append(label)
 45
 46        label = Gtk.Label(
 47            label="This is an example of a line-wrapped label.  It "
 48            "should not be taking up the entire             "
 49            "width allocated to it, but automatically "
 50            "wraps the words to fit.\n"
 51            "     It supports multiple paragraphs correctly, "
 52            "and  correctly   adds "
 53            "many          extra  spaces. ",
 54            wrap=True,
 55            max_width_chars=32,
 56        )
 57        box_right.append(label)
 58
 59        label = Gtk.Label(
 60            label="This is an example of a line-wrapped, filled label. "
 61            "It should be taking "
 62            "up the entire              width allocated to it.  "
 63            "Here is a sentence to prove "
 64            "my point.  Here is another sentence. "
 65            "Here comes the sun, do de do de do.\n"
 66            "    This is a new paragraph.\n"
 67            "    This is another newer, longer, better "
 68            "paragraph.  It is coming to an end, "
 69            "unfortunately.",
 70            wrap=True,
 71            justify=Gtk.Justification.FILL,
 72            max_width_chars=32,
 73        )
 74        box_right.append(label)
 75
 76        label = Gtk.Label(wrap=True, max_width_chars=48)
 77        label.set_markup(
 78            "Text can be <small>small</small>, <big>big</big>, "
 79            "<b>bold</b>, <i>italic</i> and even point to "
 80            'somewhere in the <a href="https://www.gtk.org" '
 81            'title="Click to find out more">internets</a>.'
 82        )
 83        box_left.append(label)
 84
 85        button = Gtk.Button(label="Click at your own risk")
 86        label = Gtk.Label(
 87            label="_Press Alt + P to select button to the right",
 88            use_underline=True,
 89            selectable=True,
 90            mnemonic_widget=button,
 91        )
 92        box_left.append(label)
 93        box_right.append(button)
 94
 95
 96def on_activate(app):
 97    win = LabelWindow(application=app)
 98    win.present()
 99
100
101app = Gtk.Application(application_id="com.example.App")
102app.connect("activate", on_activate)
103
104app.run(None)
```

--------------------------------

### Install pyenv and Set Python Version on Linux

Source: https://pygobject.gnome.org/devguide/dev_environ.html

Installs pyenv using a curl script, reloads the shell, and then installs and sets Python 3.11 as the global version. Useful for managing multiple Python versions.

```bash
curl https://pyenv.run | bash
exec $SHELL
pyenv install 3.11
pyenv global 3.11

```

--------------------------------

### Install openSUSE PyGObject Dependencies

Source: https://pygobject.gnome.org/devguide/dev_environ.html

Installs Python wheel, GObject introspection development headers, cairo development headers, OpenSSL, zlib, and Git on openSUSE. It also installs the 'devel_basis' pattern for development tools.

```bash
sudo zypper install -y python3-wheel gobject-introspection-devel \
  python3-cairo-devel openssl zlib git
sudo zypper install --type pattern devel_basis

```

--------------------------------

### Install macOS Dependencies

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Installs required development packages for PyGObject on macOS using Homebrew.

```console
brew update
brew install python3 gobject-introspection libffi
export PKG_CONFIG_PATH=$(brew --prefix libffi)/lib/pkgconfig  # use /usr/local/ for older Homebrew installs
```

--------------------------------

### Install Windows Dependencies

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Installs required development packages for PyGObject on Windows using MSYS2.

```console
pacman -S --needed --noconfirm base-devel mingw-w64-ucrt-x86_64-toolchain git \
   mingw-w64-ucrt-x86_64-python mingw-w64-ucrt-x86_64-pycairo \
   mingw-w64-ucrt-x86_64-gobject-introspection mingw-w64-ucrt-x86_64-libffi
```

--------------------------------

### Implement Application Lifecycle and Command Line Handling

Source: https://pygobject.gnome.org/tutorials/gtk4/application.html

Handles window initialization, command line option parsing, and application actions like showing an about dialog or quitting.

```python
            # Windows are associated with the application
            # when the last one is closed the application shuts down
            self.window = AppWindow(application=self, title="Main Window")

        self.window.present()

    def do_command_line(self, command_line):
        options = command_line.get_options_dict()
        # convert GVariantDict -> GVariant -> dict
        options = options.end().unpack()

        if "test" in options:
            # This is printed on the main instance
            pass

        self.activate()
        return 0

    def on_about(self, _action, _param):
        about_dialog = Gtk.AboutDialog(transient_for=self.window, modal=True)
        about_dialog.present()

    def on_quit(self, _action, _param):
        self.quit()


if __name__ == "__main__":
    app = Application()
    app.run(sys.argv)
```

--------------------------------

### Gtk.ProgressBar Implementation Example

Source: https://pygobject.gnome.org/tutorials/gtk4/display-widgets/progressbar.html

Demonstrates a Gtk.ApplicationWindow containing a progress bar with toggles for text display, activity mode, and orientation inversion.

```python
 1import gi
 2
 3gi.require_version("Gtk", "4.0")
 4from gi.repository import Gtk, GLib
 5
 6
 7class ProgressBarWindow(Gtk.ApplicationWindow):
 8    def __init__(self, **kargs):
 9        super().__init__(**kargs, title="ProgressBar Demo")
10
11        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
12        self.set_child(vbox)
13
14        self.progressbar = Gtk.ProgressBar()
15        vbox.append(self.progressbar)
16
17        button = Gtk.CheckButton(label="Show text")
18        button.connect("toggled", self.on_show_text_toggled)
19        vbox.append(button)
20
21        button = Gtk.CheckButton(label="Activity mode")
22        button.connect("toggled", self.on_activity_mode_toggled)
23        vbox.append(button)
24
25        button = Gtk.CheckButton(label="Right to Left")
26        button.connect("toggled", self.on_right_to_left_toggled)
27        vbox.append(button)
28
29        self.timeout_id = GLib.timeout_add(50, self.on_timeout)
30        self.activity_mode = False
31
32    def on_show_text_toggled(self, button):
33        show_text = button.props.active
34        text = "some text" if show_text else None
35        self.progressbar.props.text = text
36        self.progressbar.props.show_text = show_text
37
38    def on_activity_mode_toggled(self, button):
39        self.activity_mode = button.props.active
40        if self.activity_mode:
41            self.progressbar.pulse()
42        else:
43            self.progressbar.props.fraction = 0.0
44
45    def on_right_to_left_toggled(self, button):
46        value = button.props.active
47        self.progressbar.props.inverted = value
48
49    def on_timeout(self):
50        """Update value on the progress bar."""
51        if self.activity_mode:
52            self.progressbar.pulse()
53        else:
54            new_value = self.progressbar.props.fraction + 0.01
55
56            if new_value > 1:
57                new_value = 0
58
59            self.progressbar.props.fraction = new_value
60
61        # As this is a timeout function, return True so that it
62        # continues to get called
63        return True
64
65
66def on_activate(app):
67    win = ProgressBarWindow(application=app)
68    win.present()
69
70
71app = Gtk.Application(application_id="com.example.App")
72app.connect("activate", on_activate)
73
74app.run(None)
```

--------------------------------

### Install Arch Linux Dependencies

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Installs required development packages for PyGObject on Arch Linux.

```console
sudo pacman -S --noconfirm python-wheel
sudo pacman -S --noconfirm base-devel openssl zlib git gobject-introspection
```

--------------------------------

### Install Ubuntu/Debian Dependencies

Source: https://pygobject.gnome.org/_sources/devguide/dev_environ.rst.txt

Installs necessary build tools and libraries for PyGObject on Ubuntu or Debian systems.

```console
sudo apt-get install -y python3-venv python3-wheel python3-dev
sudo apt-get install -y gobject-introspection libgirepository-2.0-dev \
  gir1.2-girepository-3.0 build-essential libbz2-dev libreadline-dev \
  libssl-dev zlib1g-dev libsqlite3-dev wget curl llvm libncurses-dev \
  xz-utils tk-dev libcairo2-dev
```

--------------------------------

### Create Gtk.CheckButton examples

Source: https://pygobject.gnome.org/_sources/tutorials/gtk4/controls/check-radio-buttons.rst.txt

Demonstrates the implementation of check and radio buttons using Gtk.CheckButton.

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

class CheckButtonWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="CheckButton Demo")
        self.set_border_width(10)

        hbox = Gtk.Box(spacing=6)
        self.add(hbox)

        button = Gtk.CheckButton(label="Button 1")
        button.connect("toggled", self.on_button_toggled)
        hbox.pack_start(button, True, True, 0)

        button = Gtk.CheckButton(label="Button 2")
        button.set_active(True)
        button.connect("toggled", self.on_button_toggled)
        hbox.pack_start(button, True, True, 0)

        button = Gtk.CheckButton(label="Button 3")
        button.set_inconsistent(True)
        button.connect("toggled", self.on_button_toggled)
        hbox.pack_start(button, True, True, 0)

    def on_button_toggled(self, widget):
        print("Button toggled")

win = CheckButtonWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()
```

--------------------------------

### Install PyGObject in Editable Mode with PDM

Source: https://pygobject.gnome.org/devguide/dev_environ.html

Installs PyGObject in editable mode using pip, with build isolation disabled. It includes development dependencies and enables tests. For Python 3.12+, 'setuptools' must also be installed separately.

```bash
pip install --no-build-isolation --config-settings=setup-args="-Dtests=true" -e '.[dev]'

```
Tokens:
Raw