Work with all gui frontends

Author: gselzer

src/ndv/_types.py

@@ -5,6 +5,7 @@
 from collections.abc import Hashable, Sequence
 from contextlib import suppress
 from enum import Enum, IntFlag, auto
+from functools import lru_cache
 from typing import TYPE_CHECKING, Annotated, Any, NamedTuple, cast
 
 from pydantic import PlainSerializer, PlainValidator
@@ -13,6 +14,7 @@
 if TYPE_CHECKING:
     from qtpy.QtCore import Qt
     from qtpy.QtWidgets import QWidget
+    from wx import Cursor
 
     from ndv.views.bases import Viewable
 
@@ -123,3 +125,27 @@ def to_jupyter(self) -> str:
             CursorType.BDIAG_ARROW: "nesw-resize",
             CursorType.FDIAG_ARROW: "nwse-resize",
         }[self]
+
+    @lru_cache
+    def to_wx(self) -> Cursor:
+        """Converts CursorType to jupyter cursor strings."""
+        from wx import (
+            CURSOR_ARROW,
+            CURSOR_CROSS,
+            CURSOR_SIZENESW,
+            CURSOR_SIZENS,
+            CURSOR_SIZENWSE,
+            CURSOR_SIZEWE,
+            CURSOR_SIZING,
+            Cursor,
+        )
+
+        return {
+            CursorType.DEFAULT: Cursor(CURSOR_ARROW),
+            CursorType.CROSS: Cursor(CURSOR_CROSS),
+            CursorType.V_ARROW: Cursor(CURSOR_SIZENS),
+            CursorType.H_ARROW: Cursor(CURSOR_SIZEWE),
+            CursorType.ALL_ARROW: Cursor(CURSOR_SIZING),
+            CursorType.BDIAG_ARROW: Cursor(CURSOR_SIZENESW),
+            CursorType.FDIAG_ARROW: Cursor(CURSOR_SIZENWSE),
+        }[self]

src/ndv/views/_jupyter/_app.py

@@ -6,7 +6,12 @@
 
 from jupyter_rfb import RemoteFrameBuffer
 
-from ndv._types import MouseMoveEvent, MousePressEvent, MouseReleaseEvent
+from ndv._types import (
+    MouseButton,
+    MouseMoveEvent,
+    MousePressEvent,
+    MouseReleaseEvent,
+)
 from ndv.views.bases._app import NDVApp
 
 if TYPE_CHECKING:
@@ -41,6 +46,19 @@ def array_view_class(self) -> type[ArrayView]:
 
         return JupyterArrayView
 
+    @staticmethod
+    def mouse_btn(btn: Any) -> MouseButton:
+        if btn == 0:
+            return MouseButton.NONE
+        if btn == 1:
+            return MouseButton.LEFT
+        if btn == 2:
+            return MouseButton.RIGHT
+        if btn == 3:
+            return MouseButton.MIDDLE
+
+        raise Exception(f"Jupyter mouse button {btn} is unknown")
+
     def filter_mouse_events(
         self, canvas: Any, receiver: Mouseable
     ) -> Callable[[], None]:
@@ -52,19 +70,29 @@ def filter_mouse_events(
         # patch the handle_event from _jupyter_rfb.CanvasBackend
         # to intercept various mouse events.
         super_handle_event = canvas.handle_event
+        active_btn: MouseButton = MouseButton.NONE
 
         def handle_event(self: RemoteFrameBuffer, ev: dict) -> None:
+            nonlocal active_btn
+            nonlocal canvas
+
             etype = ev["event_type"]
+            if "button" in ev:
+                btn = JupyterAppWrap.mouse_btn(ev["button"])
             if etype == "pointer_move":
-                mme = MouseMoveEvent(x=ev["x"], y=ev["y"])
+                mme = MouseMoveEvent(x=ev["x"], y=ev["y"], btn=active_btn)
                 receiver.on_mouse_move(mme)
+                if cursor := receiver.get_cursor(mme):
+                    canvas.cursor = cursor.to_jupyter()
                 receiver.mouseMoved.emit(mme)
             elif etype == "pointer_down":
-                mpe = MousePressEvent(x=ev["x"], y=ev["y"])
+                active_btn = btn
+                mpe = MousePressEvent(x=ev["x"], y=ev["y"], btn=active_btn)
                 receiver.on_mouse_press(mpe)
                 receiver.mousePressed.emit(mpe)
             elif etype == "pointer_up":
-                mre = MouseReleaseEvent(x=ev["x"], y=ev["y"])
+                mre = MouseReleaseEvent(x=ev["x"], y=ev["y"], btn=active_btn)
+                active_btn = MouseButton.NONE
                 receiver.on_mouse_release(mre)
                 receiver.mouseReleased.emit(mre)
             super_handle_event(ev)

src/ndv/views/_pygfx/_array_canvas.py

@@ -10,11 +10,17 @@
 import pygfx
 import pylinalg as la
 
-from ndv._types import CursorType, MouseButton, MouseMoveEvent, MousePressEvent, MouseReleaseEvent
+from ndv._types import (
+    CursorType,
+    MouseButton,
+    MouseMoveEvent,
+    MousePressEvent,
+    MouseReleaseEvent,
+)
 from ndv.models._viewer_model import ArrayViewerModel, InteractionMode
 from ndv.views._app import filter_mouse_events
 from ndv.views.bases import ArrayCanvas, CanvasElement, ImageHandle
-from ndv.views.bases._graphics._canvas_elements import ROIMoveMode, RectangularROI
+from ndv.views.bases._graphics._canvas_elements import RectangularROI, ROIMoveMode
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -100,7 +106,7 @@ def remove(self) -> None:
         if (par := self._image.parent) is not None:
             par.remove(self._image)
 
-    def get_cursor(self, pos: tuple[float, float]) -> CursorType | None:
+    def get_cursor(self, mme: MouseMoveEvent) -> CursorType | None:
         return None
 
 
@@ -317,9 +323,9 @@ def _handle_under(self, pos: Sequence[float]) -> int | None:
                 return i
         return None
 
-    def get_cursor(self, pos: tuple[float, float]) -> CursorType | None:
+    def get_cursor(self, mme: MouseMoveEvent) -> CursorType | None:
         # Convert event pos (on canvas) to world pos
-        world_pos = self._canvas_to_world(pos)
+        world_pos = self._canvas_to_world((mme.x, mme.y))
         # Step 1: Handles
         # Preferred over the rectangle
         # Can only be moved if ROI is selected
@@ -648,11 +654,10 @@ def on_mouse_release(self, event: MouseReleaseEvent) -> bool:
             self._selection.on_mouse_release(event)
         return False
 
-    def get_cursor(self, pos: tuple[float, float]) -> CursorType:
+    def get_cursor(self, event: MouseMoveEvent) -> CursorType:
         if self._viewer.interaction_mode == InteractionMode.CREATE_ROI:
             return CursorType.CROSS
-        for vis in self.elements_at(pos):
-            self.canvas_to_world(pos)[:2]
-            if cursor := vis.get_cursor(pos):
+        for vis in self.elements_at((event.x, event.y)):
+            if cursor := vis.get_cursor(event):
                 return cursor
         return CursorType.DEFAULT

src/ndv/views/_qt/_app.py

@@ -5,9 +5,15 @@
 
 from qtpy.QtCore import QEvent, QObject
 from qtpy.QtGui import QMouseEvent
-from qtpy.QtWidgets import QApplication
-
-from ndv._types import MouseButton, MouseMoveEvent, MousePressEvent, MouseReleaseEvent
+from qtpy.QtWidgets import QApplication, QWidget
+
+from ndv._types import (
+    CursorType,
+    MouseButton,
+    MouseMoveEvent,
+    MousePressEvent,
+    MouseReleaseEvent,
+)
 from ndv.views.bases._app import NDVApp
 
 if TYPE_CHECKING:
@@ -67,22 +73,22 @@ def array_view_class(self) -> type[ArrayView]:
     def filter_mouse_events(
         self, canvas: Any, receiver: Mouseable
     ) -> Callable[[], None]:
-        if not isinstance(canvas, QObject):
-            raise TypeError(f"Expected canvas to be QObject, got {type(canvas)}")
+        if not isinstance(canvas, QWidget):
+            raise TypeError(f"Expected canvas to be QWidget, got {type(canvas)}")
 
         f = MouseEventFilter(canvas, receiver)
         canvas.installEventFilter(f)
         return lambda: canvas.removeEventFilter(f)
 
 
 class MouseEventFilter(QObject):
-    def __init__(self, canvas: QObject, receiver: Mouseable):
+    def __init__(self, canvas: QWidget, receiver: Mouseable):
         super().__init__()
         self.canvas = canvas
         self.receiver = receiver
         self.active_button = MouseButton.NONE
 
-    def mouse_btn(self, btn : Any) -> MouseButton:
+    def mouse_btn(self, btn: Any) -> MouseButton:
         from qtpy.QtCore import Qt
 
         if btn == Qt.MouseButton.LeftButton:
@@ -94,6 +100,9 @@ def mouse_btn(self, btn : Any) -> MouseButton:
 
         raise Exception(f"Qt mouse button {btn} is unknown")
 
+    def set_cursor(self, type: CursorType) -> None:
+        self.canvas.setCursor(type.to_qt())
+
     def eventFilter(self, obj: QObject | None, qevent: QEvent | None) -> bool:
         """Event filter installed on the canvas to handle mouse events.
 
@@ -121,14 +130,18 @@ def eventFilter(self, obj: QObject | None, qevent: QEvent | None) -> bool:
                 if etype == QEvent.Type.MouseMove:
                     mme = MouseMoveEvent(x=pos.x(), y=pos.y(), btn=self.active_button)
                     intercept |= receiver.on_mouse_move(mme)
+                    if cursor := receiver.get_cursor(mme):
+                        self.set_cursor(cursor)
                     receiver.mouseMoved.emit(mme)
                 elif etype == QEvent.Type.MouseButtonPress:
                     self.active_button = btn
                     mpe = MousePressEvent(x=pos.x(), y=pos.y(), btn=self.active_button)
                     intercept |= receiver.on_mouse_press(mpe)
                     receiver.mousePressed.emit(mpe)
                 elif etype == QEvent.Type.MouseButtonRelease:
-                    mre = MouseReleaseEvent(x=pos.x(), y=pos.y(), btn=self.active_button)
+                    mre = MouseReleaseEvent(
+                        x=pos.x(), y=pos.y(), btn=self.active_button
+                    )
                     self.active_button = MouseButton.NONE
                     intercept |= receiver.on_mouse_release(mre)
                     receiver.mouseReleased.emit(mre)

src/ndv/views/_vispy/_array_canvas.py

@@ -15,7 +15,13 @@
 from vispy import scene
 from vispy.util.quaternion import Quaternion
 
-from ndv._types import CursorType, MouseButton, MouseMoveEvent, MousePressEvent, MouseReleaseEvent
+from ndv._types import (
+    CursorType,
+    MouseButton,
+    MouseMoveEvent,
+    MousePressEvent,
+    MouseReleaseEvent,
+)
 from ndv.models._viewer_model import ArrayViewerModel, InteractionMode
 from ndv.views._app import filter_mouse_events
 from ndv.views.bases import ArrayCanvas
@@ -106,7 +112,7 @@ def move(self, pos: Sequence[float]) -> None:
     def remove(self) -> None:
         self._visual.parent = None
 
-    def get_cursor(self, pos: tuple[float, float]) -> CursorType | None:
+    def get_cursor(self, mme: MouseMoveEvent) -> CursorType | None:
         return None
 
 
@@ -239,7 +245,8 @@ def on_mouse_press(self, event: MousePressEvent) -> bool:
     def on_mouse_release(self, event: MouseReleaseEvent) -> bool:
         return False
 
-    def get_cursor(self, canvas_pos: tuple[float, float]) -> CursorType | None:
+    def get_cursor(self, mme: MouseMoveEvent) -> CursorType | None:
+        canvas_pos = (mme.x, mme.y)
         pos = self._tform.map(canvas_pos)[:2]
         if self._handle_under(pos) is not None:
             center = self._rect.center
@@ -415,7 +422,7 @@ def set_range(
                 _y[1] = max(_y[1], shape[1])
                 if len(shape) > 2:
                     _z[1] = max(_z[1], shape[2])
-            elif isinstance(handle, VispyRoiHandle):
+            elif isinstance(handle, VispyBoundingBox):
                 for v in handle.vertices:
                     _x[0] = min(_x[0], v[0])
                     _x[1] = max(_x[1], v[0])
@@ -503,11 +510,11 @@ def on_mouse_release(self, event: MouseReleaseEvent) -> bool:
         self._camera.interactive = True
         return False
 
-    def get_cursor(self, canvas_pos: tuple[float, float]) -> CursorType:
+    def get_cursor(self, mme: MouseMoveEvent) -> CursorType:
         if self._viewer.interaction_mode == InteractionMode.CREATE_ROI:
             return CursorType.CROSS
-        for vis in self.elements_at(canvas_pos):
-            if cursor := vis.get_cursor(canvas_pos):
+        for vis in self.elements_at((mme.x, mme.y)):
+            if cursor := vis.get_cursor(mme):
                 return cursor
         return CursorType.DEFAULT
 

src/ndv/views/_vispy/_histogram.py

@@ -272,7 +272,8 @@ def _update_lut_lines(self, npoints: int = 256) -> None:
             v._bounds_changed()
         self._gamma_handle._bounds_changed()
 
-    def get_cursor(self, pos: tuple[float, float]) -> CursorType:
+    def get_cursor(self, event: MouseMoveEvent) -> CursorType:
+        pos = (event.x, event.y)
         nearby = self._find_nearby_node(pos)
 
         if nearby in [Grabbable.LEFT_CLIM, Grabbable.RIGHT_CLIM]:
@@ -332,7 +333,7 @@ def on_mouse_move(self, event: MouseMoveEvent) -> bool:
             self.gammaChanged.emit(-np.log2(y / y1))
             return False
 
-        self.get_cursor(pos).apply_to(self)
+        self.get_cursor(event).apply_to(self)
         return False
 
     def _find_nearby_node(

src/ndv/views/_wx/_app.py

@@ -5,7 +5,7 @@
 import wx
 from wx import EVT_LEFT_DOWN, EVT_LEFT_UP, EVT_MOTION, EvtHandler, MouseEvent
 
-from ndv._types import MouseMoveEvent, MousePressEvent, MouseReleaseEvent
+from ndv._types import MouseButton, MouseMoveEvent, MousePressEvent, MouseReleaseEvent
 from ndv.views.bases._app import NDVApp
 
 from ._main_thread import call_in_main_thread
@@ -61,20 +61,31 @@ def filter_mouse_events(
 
         # TIP: event.Skip() allows the event to propagate to other handlers.
 
+        active_button = MouseButton.NONE
+
         def on_mouse_move(event: MouseEvent) -> None:
-            mme = MouseMoveEvent(x=event.GetX(), y=event.GetY())
+            nonlocal active_button
+            mme = MouseMoveEvent(x=event.GetX(), y=event.GetY(), btn=active_button)
             if not receiver.on_mouse_move(mme):
                 receiver.mouseMoved.emit(mme)
                 event.Skip()
+            # FIXME: get_cursor is VERY slow, unsure why.
+            if cursor := receiver.get_cursor(mme):
+                canvas.SetCursor(cursor.to_wx())
 
         def on_mouse_press(event: MouseEvent) -> None:
-            mpe = MousePressEvent(x=event.GetX(), y=event.GetY())
+            nonlocal active_button
+            # NB This function is bound to the left mouse button press
+            active_button = MouseButton.LEFT
+            mpe = MousePressEvent(x=event.GetX(), y=event.GetY(), btn=active_button)
             if not receiver.on_mouse_press(mpe):
                 receiver.mousePressed.emit(mpe)
                 event.Skip()
 
         def on_mouse_release(event: MouseEvent) -> None:
-            mre = MouseReleaseEvent(x=event.GetX(), y=event.GetY())
+            nonlocal active_button
+            mre = MouseReleaseEvent(x=event.GetX(), y=event.GetY(), btn=active_button)
+            active_button = MouseButton.NONE
             if not receiver.on_mouse_release(mre):
                 receiver.mouseReleased.emit(mre)
                 event.Skip()