Let's tackle this Python GTK3 async issue step by step — I've run into similar problems with Gio.Task in PyGObject before, so I know exactly where you're stuck.

Problem Breakdown #

You're building a lunch-making app with four views, and your sync version blocks the GUI for 5 seconds when the user clicks "Make lunch" — the progress view never shows up, jumping straight to the result. When you tried to implement async with Gio.Task (following GNOME's C docs), you hit a ValueError: Pointer arguments are restricted to integers, capsules, and None error because the C-style pointer methods don't play nice with Python objects.

Why the Gio.Task Error Happens #

The set_source_tag() and set_task_data() methods you're trying to use are designed for C code, where you pass raw pointers. PyGObject restricts these methods to integer/capsule arguments because Python objects can't be safely converted to C pointers directly. This is a limitation in the PyGObject binding, not something you're doing wrong.

The Fix: Python-Friendly Gio.Task Implementation #

Instead of fighting with the C-style pointer methods, use PyGObject's more Pythonic Gio.Task APIs to handle async work without blocking the GUI. Here's a complete, working implementation:

Modified app.py (Async Version) #

import gi
gi.require_version('Gtk', '3.0')
gi.require_version('Gio', '2.0')
from gi.repository import Gtk, Gio, GLib
import time
import random

class LunchAppWindow(Gtk.ApplicationWindow):
    def __init__(self, app):
        super().__init__(application=app)
        self.set_default_size(300, 200)
        
        # Load UI from the .ui file
        builder = Gtk.Builder()
        builder.add_from_file("app-window.ui")
        
        # Reference all views from the UI
        self.views = {
            "a": builder.get_object("view_a"),
            "b": builder.get_object("view_b"),
            "c": builder.get_object("view_c"),
            "d": builder.get_object("view_d")
        }
        
        # Main container to switch views
        self.main_container = builder.get_object("main_box")
        self.main_container.add(self.views["a"])
        
        # Connect the button click handler
        builder.get_object("make_lunch_btn").connect("clicked", self.on_make_lunch_clicked)
        
        self.show_all()

    def on_make_lunch_clicked(self, _button):
        # Switch to progress view immediately (no blocking!)
        self._switch_view("b")
        
        # Create and start the async task
        task = Gio.Task.new(None, None, self._on_lunch_made, None)
        # Run the blocking work in a background thread
        task.run_in_thread(self._make_lunch_in_thread)

    def _make_lunch_in_thread(self, task, _source, _data, cancellable):
        # Simulate your blocking make_lunch operation
        time.sleep(5)
        # Randomly decide success/failure for demo
        lunch_ready = random.choice([True, False])
        
        # Check if the task was cancelled (optional but good practice)
        if task.return_error_if_cancelled():
            return
        
        # Pass the result back to the main thread using set_task_result
        task.set_task_result(lunch_ready)

    def _on_lunch_made(self, _source, result, _user_data):
        try:
            # Retrieve the result from the task (handles thread safety)
            lunch_ready = result.propagate_boolean()
        except GLib.Error as e:
            print(f"Lunch making failed: {e}")
            self._switch_view("a")
            return
        
        # Switch to the appropriate result view
        target_view = "c" if lunch_ready else "d"
        self._switch_view(target_view)

    def _switch_view(self, view_key):
        # Helper method to safely switch views in the main thread
        for view in self.views.values():
            if view.get_parent() == self.main_container:
                self.main_container.remove(view)
                break
        self.main_container.add(self.views[view_key])
        self.views[view_key].show_all()

class LunchApp(Gtk.Application):
    def __init__(self):
        super().__init__(application_id="org.example.LunchApp")

    def do_activate(self):
        window = LunchAppWindow(self)
        window.present()

if __name__ == "__main__":
    app = LunchApp()
    app.run(None)

Key Improvements & Explanations #

1. No More Pointer Errors: We avoid set_source_tag() and set_task_data() entirely. Instead, we use task.set_task_result() to pass Python objects between the background thread and the main thread, and result.propagate_boolean() to safely retrieve them.
2. GUI Remains Responsive: The blocking time.sleep(5) runs in a background thread via task.run_in_thread(), so the main thread (which handles the GUI) stays free to display the progress view.
3. Safe View Switching: The _switch_view() helper ensures we only modify the UI from the main thread (critical for GTK, which isn't thread-safe for UI operations).
4. Cancellation Support: We include a check for task cancellation with task.return_error_if_cancelled() — you can extend this to add a "Cancel" button if needed.

Why This Works #

PyGObject's Gio.Task binding provides Python-friendly methods to handle async work without dealing with low-level C pointers. By using set_task_result() and the propagate_*() family of methods, you can safely pass data between threads without hitting those pointer errors.

内容的提问来源于stack exchange，提问作者シツモンソ