Fix qt 6.3 keyboard events (#284)

* Fix keyboard events not coming in by setting focus policy

* Simplify Qt lib import logic

* fix handle_event

Co-authored-by: Almar Klein <[email protected]>

Author: berendkleinhaneveld

examples/triangle_qt.py

@@ -9,7 +9,7 @@
 # For the sake of making this example Just Work, we try multiple QT libs
 for lib in ("PySide6", "PyQt6", "PySide2", "PyQt5"):
     try:
-        QtWidgets = importlib.import_module(f"{lib}.QtWidgets")
+        QtWidgets = importlib.import_module(".QtWidgets", lib)
         break
     except ModuleNotFoundError:
         pass

examples/triangle_qt_embed.py

@@ -9,7 +9,7 @@
 # For the sake of making this example Just Work, we try multiple QT libs
 for lib in ("PySide6", "PyQt6", "PySide2", "PyQt5"):
     try:
-        QtWidgets = importlib.import_module(f"{lib}.QtWidgets")
+        QtWidgets = importlib.import_module(".QtWidgets", lib)
         break
     except ModuleNotFoundError:
         pass

wgpu/gui/base.py

@@ -216,41 +216,36 @@ def _handle_event_rate_limited(self, ev, call_later_func, match_keys, accum_keys
         pending event, the old event is dispatched now. The `accum_keys` keys of
         the current and new event are added together (e.g. to accumulate wheel delta).
 
-        This method is called in the following cases:
+        The (accumulated) event is handled in the following cases:
         * When the timer runs out.
         * When a non-rate-limited event is dispatched.
         * When a rate-limited event of the same type is scheduled
           that has different match_keys (e.g. modifiers changes).
+
+        Subclasses that use this method must use ``_handle_event_and_flush()``
+        where they would otherwise call ``handle_event()``, to preserve event order.
         """
         event_type = ev["event_type"]
         # We may need to emit the old event. Otherwise, we need to update the new one.
         old = self._pending_events.get(event_type, None)
         if old:
             if any(ev[key] != old[key] for key in match_keys):
-                self._dispatch_event(old)
+                self.handle_event(old)
             else:
                 for key in accum_keys:
                     ev[key] = old[key] + ev[key]
         # Make sure that we have scheduled a moment to handle events
         if not self._pending_events:
-            call_later_func(self._get_event_wait_time(), self._dispatch_pending_events)
+            call_later_func(self._get_event_wait_time(), self._handle_pending_events)
         # Store the event object
         self._pending_events[event_type] = ev
 
-    def handle_event(self, event):
-        """Handle an incoming event.
+    def _handle_event_and_flush(self, event):
+        """Call handle_event after flushing any pending (rate-limited) events."""
+        self._handle_pending_events()
+        self.handle_event(event)
 
-        Subclasses can overload this method. Events include widget
-        resize, mouse/touch interaction, key events, and more. An event
-        is a dict with at least the key event_type. For details, see
-        https://jupyter-rfb.readthedocs.io/en/latest/events.html
-        """
-        # On any not-rate-limited event, we dispatch any pending events.
-        # This is to make sure that the original order of events is preserved.
-        self._dispatch_pending_events()
-        self._dispatch_event(event)
-
-    def _dispatch_pending_events(self):
+    def _handle_pending_events(self):
         """Handle any pending rate-limited events."""
         if self._pending_events:
             events = self._pending_events.values()
@@ -259,10 +254,22 @@ def _dispatch_pending_events(self):
             for ev in events:
                 self.handle_event(ev)
 
-    def _dispatch_event(self, event):
-        """Dispatch event to the event handlers."""
+    def handle_event(self, event):
+        """Handle an incoming event.
+
+        Subclasses can overload this method. Events include widget
+        resize, mouse/touch interaction, key events, and more. An event
+        is a dict with at least the key event_type. For details, see
+        https://jupyter-rfb.readthedocs.io/en/latest/events.html
+
+        The default implementation dispatches the event to the
+        registered event handlers.
+        """
+        # Collect callbacks
         event_type = event.get("event_type")
-        for callback in self._event_handlers[event_type].copy():
+        callbacks = self._event_handlers[event_type] | self._event_handlers["*"]
+        # Dispatch
+        for callback in callbacks:
             with log_exception(f"Error during handling {event['event_type']} event"):
                 callback(event)
 
@@ -295,11 +302,24 @@ def my_handler(event):
             @canvas.add_event_handler("pointer_up", "pointer_down")
             def my_handler(event):
                 print(event)
+
+        Catch 'm all:
+
+        .. code-block:: py
+
+            canvas.add_event_handler(my_handler, "*")
+
         """
         decorating = not callable(args[0])
         callback = None if decorating else args[0]
         types = args if decorating else args[1:]
 
+        if not types:
+            raise TypeError("No event types are given to add_event_handler.")
+        for type in types:
+            if not isinstance(type, str):
+                raise TypeError(f"Event types must be str, but got {type}")
+
         def decorator(_callback):
             for type in types:
                 self._event_handlers[type].add(_callback)

wgpu/gui/glfw.py

@@ -201,7 +201,7 @@ def _on_size_change(self, *args):
     def _on_close(self, *args):
         all_glfw_canvases.discard(self)
         glfw.hide_window(self._window)
-        self.handle_event({"event_type": "close"})
+        self._handle_event_and_flush({"event_type": "close"})
 
     def _on_window_dirty(self, *args):
         self._request_draw()
@@ -234,7 +234,7 @@ def _determine_size(self):
             "height": self._logical_size[1],
             "pixel_ratio": self._pixel_ratio,
         }
-        self.handle_event(ev)
+        self._handle_event_and_flush(ev)
 
     def _set_logical_size(self, new_logical_size):
         # There is unclarity about the window size in "screen pixels".
@@ -358,7 +358,7 @@ def _on_mouse_button(self, window, but, action, mods):
         }
 
         # Emit the current event
-        self.handle_event(ev)
+        self._handle_event_and_flush(ev)
 
         # Maybe emit a double-click event
         self._follow_double_click(action, button)
@@ -410,7 +410,7 @@ def _follow_double_click(self, action, button):
                 "ntouches": 0,  # glfw dows not have touch support
                 "touches": {},
             }
-            self.handle_event(ev)
+            self._handle_event_and_flush(ev)
 
     def _on_cursor_pos(self, window, x, y):
         # Store pointer position in logical coordinates
@@ -483,7 +483,7 @@ def _on_key(self, window, key, scancode, action, mods):
             "key": keyname,
             "modifiers": list(self._key_modifiers),
         }
-        self.handle_event(ev)
+        self._handle_event_and_flush(ev)
 
 
 # Make available under a name that is the same for all gui backends

wgpu/gui/qt.py

@@ -13,18 +13,19 @@
 # Select GUI toolkit
 for libname in ("PySide6", "PyQt6", "PySide2", "PyQt5"):
     if libname in sys.modules:
-        QtCore = importlib.import_module(libname + ".QtCore")
-        widgets_modname = "QtGui" if QtCore.qVersion()[0] == "4" else "QtWidgets"
-        QtWidgets = importlib.import_module(libname + "." + widgets_modname)
+        QtCore = importlib.import_module(".QtCore", libname)
+        QtWidgets = importlib.import_module(".QtWidgets", libname)
         try:
             WA_PaintOnScreen = QtCore.Qt.WidgetAttribute.WA_PaintOnScreen
             PreciseTimer = QtCore.Qt.TimerType.PreciseTimer
             KeyboardModifiers = QtCore.Qt.KeyboardModifier
+            FocusPolicy = QtCore.Qt.FocusPolicy
             Keys = QtCore.Qt.Key
         except AttributeError:
             WA_PaintOnScreen = QtCore.Qt.WA_PaintOnScreen
             PreciseTimer = QtCore.Qt.PreciseTimer
             KeyboardModifiers = QtCore.Qt
+            FocusPolicy = QtCore.Qt
             Keys = QtCore.Qt
         break
 else:
@@ -126,6 +127,7 @@ def __init__(self, *args, **kwargs):
         self.setAttribute(WA_PaintOnScreen, True)
         self.setAutoFillBackground(False)
         self.setMouseTracking(True)
+        self.setFocusPolicy(FocusPolicy.StrongFocus)
 
         # A timer for limiting fps
         self._request_draw_timer = QtCore.QTimer()
@@ -209,7 +211,7 @@ def _key_event(self, event_type, event):
             "key": KEY_MAP.get(event.key(), event.text()),
             "modifiers": modifiers,
         }
-        self.handle_event(ev)
+        self._handle_event_and_flush(ev)
 
     def keyPressEvent(self, event):  # noqa: N802
         self._key_event("key_down", event)
@@ -253,7 +255,7 @@ def _mouse_event(self, event_type, event, touches=True):
             accum_keys = {}
             self._handle_event_rate_limited(ev, call_later, match_keys, accum_keys)
         else:
-            self.handle_event(ev)
+            self._handle_event_and_flush(ev)
 
     def mousePressEvent(self, event):  # noqa: N802
         self._mouse_event("pointer_down", event)
@@ -295,10 +297,10 @@ def resizeEvent(self, event):  # noqa: N802
             "height": float(event.size().height()),
             "pixel_ratio": self.get_pixel_ratio(),
         }
-        self.handle_event(ev)
+        self._handle_event_and_flush(ev)
 
     def closeEvent(self, event):  # noqa: N802
-        self.handle_event({"event_type": "close"})
+        self._handle_event_and_flush({"event_type": "close"})
 
 
 class QWgpuCanvas(WgpuAutoGui, WgpuCanvasBase, QtWidgets.QWidget):
@@ -321,6 +323,7 @@ def __init__(self, *, size=None, title=None, max_fps=30, **kwargs):
         self.setMouseTracking(True)
 
         self._subwidget = QWgpuWidget(self, max_fps=max_fps)
+        self._subwidget.add_event_handler(self.handle_event, "*")
 
         layout = QtWidgets.QHBoxLayout(self)
         layout.setContentsMargins(0, 0, 0, 0)
@@ -374,12 +377,6 @@ def get_context(self, *args, **kwargs):
     def request_draw(self, *args, **kwargs):
         return self._subwidget.request_draw(*args, **kwargs)
 
-    def add_event_handler(self, *args, **kwargs):
-        return self._subwidget.add_event_handler(*args, **kwargs)
-
-    def remove_event_handler(self, *args, **kwargs):
-        return self._subwidget.remove_event_handler(*args, **kwargs)
-
 
 # Make available under a name that is the same for all gui backends
 WgpuWidget = QWgpuWidget

wgpu/gui/wx.py

@@ -120,6 +120,7 @@ def __init__(self, *, parent=None, size=None, title=None, max_fps=30, **kwargs):
         self.SetTitle(title or "wx wgpu canvas")
 
         self._subwidget = WxWgpuWindow(parent=self, max_fps=max_fps)
+        self._subwidget.add_event_handler(self.handle_event, "*")
         self.Bind(wx.EVT_CLOSE, lambda e: self.Destroy())
 
         self.Show()