Add pointer_enter and pointer_leave events (#80)

Author: almarklein

rendercanvas/_events.py

@@ -22,8 +22,10 @@ class EventType(BaseEnum):
     resize = None  #: The canvas has changed size. Has 'width' and 'height' in logical pixels, 'pixel_ratio'.
     close = None  #: The canvas is closed. No additional fields.
     pointer_down = None  #: The pointing device is pressed down. Has 'x', 'y', 'button', 'butons', 'modifiers', 'ntouches', 'touches'.
-    pointer_up = None  #: The pointing device is released. Same fields as pointer_down.
-    pointer_move = None  #: The  pointing device is moved. Same fields as pointer_down.
+    pointer_up = None  #: The pointing device is released. Same fields as pointer_down. Can occur outside of the canvas.
+    pointer_move = None  #: The pointing device is moved. Same fields as pointer_down. Can occur outside of the canvas if the pointer is currently down.
+    pointer_enter = None  #: The pointing device is moved into the canvas.
+    pointer_leave = None  #: The pointing device is moved outside of the canvas (regardless of a button currently being pressed).
     double_click = None  #: A double-click / long-tap. This event looks like a pointer event, but without the touches.
     wheel = None  #: The mouse-wheel is used (scrolling), or the touchpad/touchscreen is scrolled/pinched. Has 'dx', 'dy', 'x', 'y', 'modifiers'.
     key_down = None  #: A key is pressed down. Has 'key', 'modifiers'.

rendercanvas/glfw.py

@@ -231,9 +231,12 @@ def __init__(self, *args, present_method=None, **kwargs):
         self._key_modifiers = ()
         self._pointer_buttons = ()
         self._pointer_pos = 0, 0
+        self._pointer_inside = None
+        self._pointer_lock = False
         self._double_click_state = {"clicks": 0}
         glfw.set_mouse_button_callback(self._window, weakbind(self._on_mouse_button))
         glfw.set_cursor_pos_callback(self._window, weakbind(self._on_cursor_pos))
+        glfw.set_cursor_enter_callback(self._window, weakbind(self._on_cursor_enter))
         glfw.set_scroll_callback(self._window, weakbind(self._on_scroll))
         glfw.set_key_callback(self._window, weakbind(self._on_key))
         glfw.set_char_callback(self._window, weakbind(self._on_char))
@@ -441,6 +444,16 @@ def _on_mouse_button(self, window, but, action, mods):
         }
         button = button_map.get(but, 0)
 
+        # Handler pointer locking
+        if self._pointer_lock:
+            if action == glfw.RELEASE:
+                self._pointer_lock = False
+            return
+        elif not self._pointer_inside:
+            # This press is to select the window (regaining focus)
+            self._pointer_lock = True
+            return
+
         if action == glfw.PRESS:
             event_type = "pointer_down"
             buttons = set(self._pointer_buttons)
@@ -475,6 +488,9 @@ def _follow_double_click(self, action, button):
         # If a sequence of down-up-down-up is made in nearly the same
         # spot, and within a short time, we emit the double-click event.
 
+        if self._pointer_lock:
+            return
+
         x, y = self._pointer_pos[0], self._pointer_pos[1]
         state = self._double_click_state
 
@@ -521,6 +537,18 @@ def _follow_double_click(self, action, button):
             self.submit_event(ev)
 
     def _on_cursor_pos(self, window, x, y):
+        if self._pointer_lock:
+            return
+
+        # Maybe trigger initial enter
+        if self._pointer_inside is None:
+            if glfw.get_window_attrib(window, glfw.HOVERED):
+                self._on_cursor_enter(window, True)
+
+        # Only process move events if inside or if drag-tracking
+        if not (self._pointer_inside or self._pointer_buttons):
+            return
+
         # Store pointer position in logical coordinates
         if self._screen_size_is_logical:
             self._pointer_pos = x, y
@@ -540,6 +568,11 @@ def _on_cursor_pos(self, window, x, y):
 
         self.submit_event(ev)
 
+    def _on_cursor_enter(self, window, entered):
+        self._pointer_inside = bool(entered)
+        ev = {"event_type": "pointer_enter" if entered else "pointer_leave"}
+        self.submit_event(ev)
+
     def _on_scroll(self, window, dx, dy):
         # wheel is 1 or -1 in glfw, in jupyter_rfb this is ~100
         ev = {

rendercanvas/qt.py

@@ -542,6 +542,14 @@ def mouseMoveEvent(self, event):  # noqa: N802
     def mouseReleaseEvent(self, event):  # noqa: N802
         self._mouse_event("pointer_up", event)
 
+    def enterEvent(self, event):  # noqa: N802
+        ev = {"event_type": "pointer_enter"}
+        self.submit_event(ev)
+
+    def leaveEvent(self, event):  # noqa: N802
+        ev = {"event_type": "pointer_leave"}
+        self.submit_event(ev)
+
     def mouseDoubleClickEvent(self, event):  # noqa: N802
         super().mouseDoubleClickEvent(event)
         self._mouse_event("double_click", event, touches=False)

rendercanvas/wx.py

@@ -179,7 +179,7 @@ def _rc_add_task(self, async_func, name):
         return super()._rc_add_task(async_func, name)
 
     def _rc_call_later(self, delay, callback):
-        wx.CallLater(int(delay * 1000), callback)
+        wx.CallLater(max(int(delay * 1000), 1), callback)
 
     def process_wx_events(self):
         old_loop = wx.GUIEventLoop.GetActive()
@@ -223,6 +223,8 @@ def __init__(self, *args, present_method=None, **kwargs):
             raise ValueError(f"Invalid present_method {present_method}")
 
         self._is_closed = False
+        self._pointer_inside = None
+        self._is_pointer_inside_according_to_wx = False
 
         # We keep a timer to prevent draws during a resize. This prevents
         # issues with mismatching present sizes during resizing (on Linux).
@@ -238,6 +240,10 @@ def __init__(self, *args, present_method=None, **kwargs):
 
         self.Bind(wx.EVT_MOUSE_EVENTS, self._on_mouse_events)
         self.Bind(wx.EVT_MOTION, self._on_mouse_move)
+        self.Bind(wx.EVT_ENTER_WINDOW, self._on_window_enter)
+        self.Bind(wx.EVT_LEAVE_WINDOW, self._on_window_enter)
+        self.Bind(wx.EVT_SET_FOCUS, self._on_focus)
+        self.Bind(wx.EVT_KILL_FOCUS, self._on_focus)
 
         self.Show()
         self._final_canvas_init()
@@ -496,11 +502,7 @@ def _mouse_event(self, event_type: str, event: wx.MouseEvent, touches: bool = Tr
 
             ev.update({"dx": -dx, "dy": -dy})
 
-            self.submit_event(ev)
-        elif event_type == "pointer_move":
-            self.submit_event(ev)
-        else:
-            self.submit_event(ev)
+        self.submit_event(ev)
 
     def _on_mouse_events(self, event: wx.MouseEvent):
         event_type = event.GetEventType()
@@ -512,8 +514,38 @@ def _on_mouse_events(self, event: wx.MouseEvent):
         self._mouse_event(event_type_name, event)
 
     def _on_mouse_move(self, event: wx.MouseEvent):
+        # On MacOS this event does not happen unless a button is pressed (i.e. dragging)
         self._mouse_event("pointer_move", event)
 
+    def _on_window_enter(self, event: wx.MouseEvent):
+        if event.GetEventType() == wx.wxEVT_ENTER_WINDOW:
+            pointer_inside = True
+            ev = {"event_type": "pointer_enter"}
+        else:  # event.GetEventType() == wx.wxEVT_LEAVE_WINDOW
+            pointer_inside = False
+            ev = {"event_type": "pointer_leave"}
+
+        # Track the state of wx
+        self._is_pointer_inside_according_to_wx = pointer_inside
+
+        # Update our state only if we have focus
+        if self.HasFocus() and pointer_inside != self._pointer_inside:
+            self._pointer_inside = pointer_inside
+            self.submit_event(ev)
+
+    def _on_focus(self, event: wx.FocusEvent):
+        if event.GetEventType() == wx.wxEVT_SET_FOCUS:
+            if self._is_pointer_inside_according_to_wx:
+                if not self._pointer_inside:
+                    ev = {"event_type": "pointer_enter"}
+                    self._pointer_inside = True
+                    self.submit_event(ev)
+        else:  # event.GetEventType() == wx.wxEVT_KILL_FOCUS
+            if self._pointer_inside:
+                ev = {"event_type": "pointer_leave"}
+                self._pointer_inside = False
+                self.submit_event(ev)
+
 
 class WxRenderCanvas(WrapperRenderCanvas, wx.Frame):
     """A toplevel wx Frame providing a render canvas."""