fix(device_inputs): on_device_update additional _destroyed safeguard

CHANGELOG.md

@@ -1,63 +1,6 @@
 # CHANGELOG
 
 
-## v3.13.3 (2026-05-22)
-
-### Bug Fixes
-
-- **tests**: Rename description attribute to _description in FakeDevice
-  ([`668b1bd`](https://github.com/bec-project/bec_widgets/commit/668b1bd9cd158fc12cff2c340d7317f30a212121))
-
-
-## v3.13.2 (2026-05-22)
-
-### Bug Fixes
-
-- **tests**: Rename description attribute to _description in FakePositioner
-  ([`c346bd0`](https://github.com/bec-project/bec_widgets/commit/c346bd0f18ce873ff5ca6c59150c9581c9edca8d))
-
-
-## v3.13.1 (2026-05-21)
-
-### Bug Fixes
-
-- Use .show instead of .start
-  ([`b4beb27`](https://github.com/bec-project/bec_widgets/commit/b4beb274da745da618f9b37ec241cd0109c088f1))
-
-- **gui**: Replace window.show() with window.raise_window() and add hide() method
-  ([`f7a48b5`](https://github.com/bec-project/bec_widgets/commit/f7a48b5f6a51d391dca26ca42d03bad4f278ff22))
-
-
-## v3.13.0 (2026-05-21)
-
-### Features
-
-- **rpc-base**: Set default RPC timeout and allow customization
-  ([`f03a5d9`](https://github.com/bec-project/bec_widgets/commit/f03a5d9e853bd62b8ec1bad1c1e112fe01befe70))
-
-
-## v3.12.2 (2026-05-21)
-
-### Bug Fixes
-
-- **toggle**: Disable styling implemented
-  ([`9eb0541`](https://github.com/bec-project/bec_widgets/commit/9eb05416ab68dcb88732dca8974c665030d34e0b))
-
-
-## v3.12.1 (2026-05-21)
-
-### Bug Fixes
-
-- **device_input**: Correct cleanup unsubscribe
-  ([`56427a7`](https://github.com/bec-project/bec_widgets/commit/56427a7f0c3a89fe847d415c8b45212e663434c4))
-
-- **device_input**: Ensure callback is removed after cleanup
-  ([`d99db7d`](https://github.com/bec-project/bec_widgets/commit/d99db7d04208945b86a39d65022b211ba093caed))
-
-- **signal_combobox**: Signature matched for update_signals_from_filters
-  ([`a976837`](https://github.com/bec-project/bec_widgets/commit/a976837cff612349f2a3f17900903c203bc3d250))
-
-
 ## v3.12.0 (2026-05-20)
 
 ### Bug Fixes

bec_widgets/cli/client_utils.py

@@ -222,7 +222,6 @@ class BECGuiClient(RPCBase):
         self._ipython_registry: dict[str, RPCReference] = {}
         self.available_widgets = AvailableWidgetsNamespace()
         register_serializer_extension()
-        self._rpc_timeout = 5
 
     ####################
     #### Client API ####
@@ -233,16 +232,6 @@ class BECGuiClient(RPCBase):
         """The launcher object."""
         return RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self, object_name="launcher")
 
-    def set_rpc_timeout(self, timeout: float):
-        """Set the timeout for RPC calls to the GUI server.
-
-        Args:
-            timeout(float): The timeout in seconds.
-        """
-        if not isinstance(timeout, (int, float)) or timeout < 0:
-            raise ValueError("Timeout must be a non-negative number.")
-        self._rpc_timeout = timeout
-
     def _safe_register_stream(self, endpoint: EndpointInfo, cb: Callable, **kwargs):
         """Check if already registered for registration in idempotent functions."""
         if not self._client.connector.any_stream_is_registered(endpoint, cb=cb):
@@ -369,7 +358,7 @@ class BECGuiClient(RPCBase):
             )
 
         if not self._check_if_server_is_alive():
-            self.show(wait=True)
+            self.start(wait=True)
         if wait:
             with wait_for_server(self):
                 return self._new_impl(
@@ -561,7 +550,7 @@ class BECGuiClient(RPCBase):
         if self.launcher and len(self._top_level) == 0:
             self.launcher._run_rpc("show")  # pylint: disable=protected-access
         for window in self._top_level.values():
-            window.raise_window()
+            window.show()
 
     def _show_all(self):
         with wait_for_server(self):
@@ -580,7 +569,7 @@ class BECGuiClient(RPCBase):
         if self.launcher and len(self._top_level) == 0:
             self.launcher._run_rpc("raise")  # pylint: disable=protected-access
         for window in self._top_level.values():
-            window.raise_window()
+            window._run_rpc("raise")  # type: ignore[attr-defined]
 
     def _raise_all(self):
         with wait_for_server(self):

bec_widgets/cli/rpc/rpc_base.py

@@ -24,8 +24,6 @@ else:
 
 # pylint: disable=protected-access
 
-_DEFAULT_RPC_TIMEOUT = object()
-
 
 def _name_arg(arg):
     if isinstance(arg, DeviceBaseWithConfig):
@@ -156,7 +154,6 @@ class RPCReference:
 
 
 class RPCBase:
-
     def __init__(
         self,
         gui_id: str | None = None,
@@ -210,16 +207,12 @@ class RPCBase:
         # Use explicit call to ensure action name is 'raise' (not 'raise_')
         return self._run_rpc("raise")
 
-    def hide(self):
-        """Hide this widget (or its container)."""
-        return self._run_rpc("hide")
-
     def _run_rpc(
         self,
         method,
         *args,
-        wait_for_rpc_response: bool = True,
-        timeout: float | None | object = _DEFAULT_RPC_TIMEOUT,
+        wait_for_rpc_response=True,
+        timeout=5,
         gui_id: str | None = None,
         **kwargs,
     ) -> Any:
@@ -230,16 +223,13 @@ class RPCBase:
             method: The method to call.
             args: The arguments to pass to the method.
             wait_for_rpc_response: Whether to wait for the RPC response.
-            timeout: The timeout for the RPC response. If omitted, the client's default RPC
-                timeout is used. If explicitly set to None, wait indefinitely.
+            timeout: The timeout for the RPC response.
             gui_id: The GUI ID to use for the RPC call. If None, the default GUI ID is used.
             kwargs: The keyword arguments to pass to the method.
 
         Returns:
             The result of the RPC call.
         """
-        if timeout is _DEFAULT_RPC_TIMEOUT:
-            timeout = self._root._rpc_timeout
         if method in ["show", "hide", "raise"] and gui_id is None:
             obj = self._root._server_registry.get(self._gui_id)
             if obj is None:

bec_widgets/tests/utils.py

@@ -15,7 +15,7 @@ class FakeDevice(BECDevice):
         super().__init__(name=name)
         self._enabled = enabled
         self.signals = {self.name: {"value": 1.0}}
-        self._description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
         self._readout_priority = readout_priority
         self._config = {
             "readoutPriority": "baseline",
@@ -74,7 +74,7 @@ class FakeDevice(BECDevice):
         Returns:
             dict: Description of the device
         """
-        return self._description
+        return self.description
 
 
 class FakePositioner(BECPositioner):
@@ -96,7 +96,7 @@ class FakePositioner(BECPositioner):
         self._limits = limits
         self._readout_priority = readout_priority
         self.signals = {self.name: {"value": 1.0}}
-        self._description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
         self._config = {
             "readoutPriority": "baseline",
             "deviceClass": "ophyd_devices.SimPositioner",
@@ -176,7 +176,7 @@ class FakePositioner(BECPositioner):
         Returns:
             dict: Description of the device
         """
-        return self._description
+        return self.description
 
     @property
     def precision(self):

bec_widgets/utils/crosshair.py

@@ -429,10 +429,10 @@ class Crosshair(QObject):
             if event is None:
                 return  # nothing to do
             scene_pos = event[0]  # SignalProxy bundle
+            if not self.plot_item.vb.sceneBoundingRect().contains(scene_pos):
+                return
             view_pos = self.plot_item.vb.mapSceneToView(scene_pos)
             x, y = view_pos.x(), view_pos.y()
-        if not self._is_within_view_range(x, y):
-            return
 
         # Update cross‑hair visuals
         self.v_line.setPos(x)
@@ -493,12 +493,8 @@ class Crosshair(QObject):
         if event.button() != Qt.MouseButton.LeftButton:
             return
         self.update_markers()
-        scene_pos_getter = getattr(event, "scenePos", None)
-        if not callable(scene_pos_getter):
-            return
-        scene_pos = scene_pos_getter()
-        mouse_point = self.plot_item.vb.mapSceneToView(scene_pos)
-        if self._is_within_view_range(mouse_point.x(), mouse_point.y()):
+        if self.plot_item.vb.sceneBoundingRect().contains(event._scenePos):
+            mouse_point = self.plot_item.vb.mapSceneToView(event._scenePos)
             x, y = mouse_point.x(), mouse_point.y()
             scaled_x, scaled_y = self.scale_emitted_coordinates(mouse_point.x(), mouse_point.y())
             self.crosshairClicked.emit((scaled_x, scaled_y))
@@ -549,10 +545,6 @@ class Crosshair(QObject):
                 else:
                     continue
 
-    def _is_within_view_range(self, x: float, y: float) -> bool:
-        x_range, y_range = self.plot_item.vb.viewRange()
-        return min(x_range) <= x <= max(x_range) and min(y_range) <= y <= max(y_range)
-
     def _get_transformed_position(
         self, x: float, y: float, transform: QTransform
     ) -> tuple[QPointF, QPointF]:

bec_widgets/widgets/control/device_input/device_combobox/device_combobox.py

@@ -9,7 +9,7 @@ from bec_lib.device import ComputedSignal, Device, Positioner, ReadoutPriority
 from bec_lib.device import Signal as BECSignal
 from bec_lib.logger import bec_logger
 from pydantic import Field, field_validator
-from qtpy.QtCore import QSize, QStringListModel, Signal, Slot
+from qtpy.QtCore import QSize, QStringListModel, Qt, Signal, Slot
 from qtpy.QtWidgets import QComboBox, QCompleter, QSizePolicy
 
 from bec_widgets.utils.bec_connector import ConnectionConfig
@@ -191,6 +191,13 @@ class DeviceComboBox(BECWidget, QComboBox):
         if self.config.autocomplete:
             self.autocomplete = True
 
+        self._callback_id = self.bec_dispatcher.client.callbacks.register(
+            EventType.DEVICE_UPDATE, self.on_device_update
+        )
+        self.device_config_update.connect(
+            self.update_devices_from_filters, Qt.ConnectionType.QueuedConnection
+        )
+
         if available_devices is not None:
             self.set_available_devices(available_devices)
 
@@ -216,10 +223,6 @@ class DeviceComboBox(BECWidget, QComboBox):
         else:
             self.setCurrentText("")
 
-        self._callback_id = self.bec_dispatcher.client.callbacks.register(
-            EventType.DEVICE_UPDATE, self.on_device_update
-        )
-        self.device_config_update.connect(self.update_devices_from_filters)
         self.currentTextChanged.connect(self.check_validity)
         self.check_validity(self.currentText())
 
@@ -255,6 +258,9 @@ class DeviceComboBox(BECWidget, QComboBox):
     @SafeSlot()
     def update_devices_from_filters(self):
         """Refresh the available device list from current device/readout/signal filters."""
+        if self._callback_id is None or getattr(self, "_destroyed", False):
+            return
+
         self.config.device_filter = [entry.value for entry in self.device_filter]
         self.config.readout_filter = [entry.value for entry in self.readout_filter]
         self.config.signal_class_filter = self.signal_class_filter
@@ -497,9 +503,8 @@ class DeviceComboBox(BECWidget, QComboBox):
     def cleanup(self):
         """Cleanup the widget."""
         if self._callback_id is not None:
-            callback_id = self._callback_id
+            self.bec_dispatcher.client.callbacks.remove(self._callback_id)
             self._callback_id = None
-            self.bec_dispatcher.client.callbacks.remove(callback_id)
         super().cleanup()
 
     def get_current_device(self) -> object:

bec_widgets/widgets/control/device_input/signal_combobox/signal_combobox.py

@@ -77,6 +77,7 @@ class SignalComboBox(BECWidget, QComboBox):
 
     device_signal_changed = Signal(str)
     signal_reset = Signal()
+    device_config_update = Signal()
 
     def __init__(
         self,
@@ -138,7 +139,10 @@ class SignalComboBox(BECWidget, QComboBox):
             self.autocomplete = True
 
         self._device_update_register = self.bec_dispatcher.client.callbacks.register(
-            EventType.DEVICE_UPDATE, self.update_signals_from_filters
+            EventType.DEVICE_UPDATE, self.on_device_update
+        )
+        self.device_config_update.connect(
+            self.update_signals_from_filters, Qt.ConnectionType.QueuedConnection
         )
         self.currentTextChanged.connect(self.on_text_changed)
 
@@ -197,21 +201,19 @@ class SignalComboBox(BECWidget, QComboBox):
         self.update_signals_from_filters()
 
     @SafeSlot()
-    @SafeSlot(str, dict)
-    def update_signals_from_filters(self, action: str | None = None, content: dict | None = None):
+    @SafeSlot(dict, dict)
+    def update_signals_from_filters(
+        self, content: dict | None = None, metadata: dict | None = None
+    ):
         """Refresh available signals from the current device and filters.
 
         Args:
-            action: Optional BEC device update action. If provided, only device list changing
-                actions trigger a refresh.
             content: Optional callback payload from BEC device updates. Currently unused.
+            metadata: Optional callback metadata from BEC device updates. Currently unused.
         """
         if self._device_update_register is None or getattr(self, "_destroyed", False):
             return
 
-        if action is not None and action not in ["add", "remove", "reload"]:
-            return
-
         self.config.signal_filter = [kind.name for kind in self.signal_filter]
 
         if self._signal_class_filter:
@@ -252,6 +254,13 @@ class SignalComboBox(BECWidget, QComboBox):
             ),
         )
 
+    def on_device_update(self, action: str, content: dict) -> None:
+        """Refresh filters when BEC reports device configuration changes."""
+        if self._device_update_register is None or getattr(self, "_destroyed", False):
+            return
+        if action in ["add", "remove", "reload"]:
+            self.device_config_update.emit()
+
     @Property(str)
     def device(self) -> str:
         """Selected device."""
@@ -594,9 +603,8 @@ class SignalComboBox(BECWidget, QComboBox):
     def cleanup(self):
         """Cleanup the widget."""
         if self._device_update_register is not None:
-            callback_id = self._device_update_register
+            self.bec_dispatcher.client.callbacks.remove(self._device_update_register)
             self._device_update_register = None
-            self.bec_dispatcher.client.callbacks.remove(callback_id)
         super().cleanup()
 
     @staticmethod

bec_widgets/widgets/utility/toggle/toggle.py

@@ -1,6 +1,6 @@
 import sys
 
-from qtpy.QtCore import Property, QEasingCurve, QEvent, QPointF, QPropertyAnimation, Qt, Signal
+from qtpy.QtCore import Property, QEasingCurve, QPointF, QPropertyAnimation, Qt, Signal
 from qtpy.QtGui import QColor, QPainter
 from qtpy.QtWidgets import QApplication, QWidget
 
@@ -41,22 +41,10 @@ class ToggleSwitch(QWidget):
         theme = getattr(QApplication.instance(), "theme", None)
         colors = theme.colors if theme else {}
 
-        self._active_track_color = self._theme_color(colors, "PRIMARY", QColor(33, 150, 243))
-        self._active_thumb_color = self._theme_color(colors, "ON_PRIMARY", QColor(255, 255, 255))
-        self._inactive_track_color = self._theme_color(colors, "SEPARATOR", QColor(200, 200, 200))
-        self._inactive_thumb_color = self._theme_color(colors, "ON_PRIMARY", QColor(255, 255, 255))
-        self._disabled_track_color = self._theme_color(colors, "DISABLED_BG", QColor(220, 220, 220))
-        self._disabled_thumb_color = self._theme_color(colors, "DISABLED_FG", QColor(150, 150, 150))
-        self._disabled_border_color = self._theme_color(
-            colors, "DISABLED_BORDER", QColor(170, 170, 170)
-        )
-        if hasattr(self, "_checked"):
-            self.update_colors()
-
-    @staticmethod
-    def _theme_color(colors: dict, key: str, fallback: QColor) -> QColor:
-        color = colors.get(key, fallback)
-        return color if isinstance(color, QColor) else QColor(color)
+        self._active_track_color = colors.get("PRIMARY", QColor(33, 150, 243))
+        self._active_thumb_color = colors.get("ON_PRIMARY", QColor(255, 255, 255))
+        self._inactive_track_color = colors.get("SEPARATOR", QColor(200, 200, 200))
+        self._inactive_thumb_color = colors.get("ON_PRIMARY", QColor(255, 255, 255))
 
     @Property(bool)
     def checked(self):
@@ -131,40 +119,29 @@ class ToggleSwitch(QWidget):
 
     def paintEvent(self, event):
         painter = QPainter(self)
-        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.setRenderHint(QPainter.Antialiasing)
 
         # Draw track
         painter.setBrush(self._track_color)
-        painter.setPen(self._disabled_border_color if not self.isEnabled() else Qt.PenStyle.NoPen)
+        painter.setPen(Qt.NoPen)
         painter.drawRoundedRect(
             0, 0, self.width(), self.height(), self.height() / 2, self.height() / 2
         )
 
         # Draw thumb
         painter.setBrush(self._thumb_color)
-        painter.setPen(Qt.PenStyle.NoPen)
         diameter = int(self.height() * 0.8)
         painter.drawEllipse(int(self._thumb_pos.x()), int(self._thumb_pos.y()), diameter, diameter)
 
     def mousePressEvent(self, event):
-        if self.isEnabled() and event.button() == Qt.MouseButton.LeftButton:
+        if event.button() == Qt.LeftButton:
             self.checked = not self.checked
 
     def update_colors(self):
-        if not self.isEnabled():
-            self._thumb_color = self._disabled_thumb_color
-            self._track_color = self._disabled_track_color
-            return
 
         self._thumb_color = self.active_thumb_color if self._checked else self.inactive_thumb_color
         self._track_color = self.active_track_color if self._checked else self.inactive_track_color
 
-    def changeEvent(self, event):
-        if event.type() == QEvent.Type.EnabledChange:
-            self.update_colors()
-            self.update()
-        super().changeEvent(event)
-
     def get_thumb_pos(self, checked):
         return QPointF(self.width() - self.height() + 3, 2) if checked else QPointF(3, 2)
 
@@ -190,7 +167,7 @@ class ToggleSwitch(QWidget):
 
 
 if __name__ == "__main__":  # pragma: no cover
-    from qtpy.QtWidgets import QHBoxLayout, QWidget
+    from qtpy.QtWidgets import QHBoxLayout, QVBoxLayout, QWidget
 
     from bec_widgets.utils.colors import apply_theme
     from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
@@ -200,12 +177,9 @@ if __name__ == "__main__":  # pragma: no cover
     widget = QWidget()
     layout = QHBoxLayout(widget)
     toggle = ToggleSwitch()
-    toggle_disabled = ToggleSwitch()
     dark_mode_btn = DarkModeButton()
     layout.addWidget(toggle)
-    layout.addWidget(toggle_disabled)
     layout.addWidget(dark_mode_btn)
-    toggle_disabled.setEnabled(False)
     window = QWidget()
     window.setLayout(layout)
     window.show()

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bec_widgets"
-version = "3.13.3"
+version = "3.12.0"
 description = "BEC Widgets"
 requires-python = ">=3.11"
 classifiers = [
@@ -23,7 +23,7 @@ dependencies = [
   "ophyd_devices~=1.29, >=1.29.1",
   "pydantic~=2.0",
   "pylsp-bec~=1.2",
-  "pyqtgraph~=0.14.0",
+  "pyqtgraph==0.13.7",
   "qtconsole~=5.5, >=5.5.1",             # needed for jupyter console
   "qtmonaco~=0.8, >=0.8.1",
   "qtpy~=2.4",
@@ -65,12 +65,6 @@ qtermwidget = ["pyside6_qtermwidget"]
 
 
 
-
-
-
-
-
-
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

tests/end-2-end/conftest.py

@@ -45,7 +45,7 @@ def connected_client_gui_obj(qtbot, gui_id, bec_client_lib):
     """
     gui = BECGuiClient(gui_id=gui_id)
     try:
-        gui.show(wait=True)
+        gui.start(wait=True)
         qtbot.waitUntil(lambda: hasattr(gui, "bec"), timeout=5000)
         gui.bec.delete_all()  # ensure clean state
         qtbot.waitUntil(lambda: len(gui.bec.widget_list()) == 0, timeout=10000)

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -143,11 +143,11 @@ def test_rpc_gui_obj(connected_client_gui_obj: BECGuiClient, qtbot):
     qtbot.wait(500)
     gui.kill_server()
     assert not gui._gui_is_alive()
-    gui.show(wait=True)
+    gui.start(wait=True)
     assert gui._gui_is_alive()
-    # calling show multiple times should not change anything
-    gui.show(wait=True)
-    gui.show(wait=True)
+    # calling start multiple times should not change anything
+    gui.start(wait=True)
+    gui.start(wait=True)
 
     def wait_for_gui_started():
         return "bec" in gui.windows

tests/end-2-end/user_interaction/conftest.py

@@ -75,7 +75,7 @@ def connected_client_gui_obj(qtbot_scope_module, gui_id, bec_client_lib):
     """
     gui = BECGuiClient(gui_id=gui_id)
     try:
-        gui.show(wait=True)
+        gui.start(wait=True)
         qtbot_scope_module.waitUntil(lambda: hasattr(gui, "bec"), timeout=5000)
         gui.bec.delete_all()  # ensure clean state
         qtbot_scope_module.waitUntil(lambda: len(gui.bec.widget_list()) == 0, timeout=10000)

tests/unit_tests/test_client_utils.py

@@ -5,7 +5,6 @@ import pytest
 
 from bec_widgets.cli.client import BECDockArea
 from bec_widgets.cli.client_utils import BECGuiClient, _start_plot_process
-from bec_widgets.cli.rpc.rpc_base import RPCBase, RPCResponseTimeoutError, rpc_timeout
 
 
 @pytest.fixture
@@ -221,7 +220,7 @@ def test_client_utils_new_starts_server_when_not_alive():
         with mock.patch("bec_widgets.cli.client_utils.wait_for_server", _no_wait_for_server):
             with (
                 mock.patch.object(gui, "_check_if_server_is_alive", return_value=False),
-                mock.patch.object(gui, "show") as mock_start,
+                mock.patch.object(gui, "start") as mock_start,
             ):
                 gui.new(wait=False, startup_profile=None)
 
@@ -258,11 +257,3 @@ def test_client_utils_delete_falls_back_to_direct_close():
         gui.delete("dock")
 
     widget._run_rpc.assert_called_once_with("close")
-
-
-def test_client_utils_gui_client_set_rpc_timeout():
-    gui = BECGuiClient()
-    assert gui._rpc_timeout == 5
-
-    gui.set_rpc_timeout(10)
-    assert gui._rpc_timeout == 10

tests/unit_tests/test_crosshair.py

@@ -14,18 +14,6 @@ from .conftest import create_widget
 # pylint: disable = redefined-outer-name
 
 
-class _FakeMouseClickEvent:
-    def __init__(self, scene_pos: QPointF, button: Qt.MouseButton = Qt.MouseButton.LeftButton):
-        self._scene_pos = scene_pos
-        self._button = button
-
-    def button(self):
-        return self._button
-
-    def scenePos(self):
-        return self._scene_pos
-
-
 @pytest.fixture
 def plot_widget_with_crosshair(qtbot):
     widget = pg.PlotWidget()
@@ -34,7 +22,6 @@ def plot_widget_with_crosshair(qtbot):
 
     widget.plot(x=[1, 2, 3], y=[4, 5, 6], name="Curve 1")
     plot_item = widget.getPlotItem()
-    plot_item.vb.setRange(xRange=(0, 4), yRange=(0, 10), padding=0)
     crosshair = Crosshair(plot_item=plot_item, precision=3)
 
     yield crosshair, plot_item
@@ -51,17 +38,20 @@ def image_widget_with_crosshair(qtbot):
 
     widget.addItem(image_item)
     plot_item = widget.getPlotItem()
-    plot_item.vb.setRange(xRange=(0, 100), yRange=(0, 100), padding=0)
     crosshair = Crosshair(plot_item=plot_item, precision=3)
 
     yield crosshair, plot_item
 
 
 def test_mouse_moved_lines(plot_widget_with_crosshair):
-    crosshair, _ = plot_widget_with_crosshair
+    crosshair, plot_item = plot_widget_with_crosshair
+
+    pos_in_view = QPointF(2, 5)
+    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
 
     # Simulate mouse movement
-    crosshair.mouse_moved(manual_pos=(2, 5))
+    crosshair.mouse_moved(event_mock)
 
     # Check that the vertical line is indeed at x=2
     assert np.isclose(crosshair.v_line.pos().x(), 2)
@@ -69,7 +59,7 @@ def test_mouse_moved_lines(plot_widget_with_crosshair):
 
 
 def test_mouse_moved_signals(plot_widget_with_crosshair):
-    crosshair, _ = plot_widget_with_crosshair
+    crosshair, plot_item = plot_widget_with_crosshair
 
     emitted_values_1D = []
 
@@ -78,40 +68,43 @@ def test_mouse_moved_signals(plot_widget_with_crosshair):
 
     crosshair.coordinatesChanged1D.connect(slot)
 
-    crosshair.mouse_moved(manual_pos=(2, 5))
+    pos_in_view = QPointF(2, 5)
+    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
+
+    crosshair.mouse_moved(event_mock)
 
     # Assert the expected behavior
     assert emitted_values_1D == [("Curve 1", 2, 5)]
 
 
 def test_mouse_moved_signals_outside(plot_widget_with_crosshair):
-    crosshair, _ = plot_widget_with_crosshair
+    crosshair, plot_item = plot_widget_with_crosshair
 
     # Create a slot that will store the emitted values as tuples
     emitted_values_1D = []
-    emitted_positions = []
 
     def slot(coordinates):
         emitted_values_1D.append(coordinates)
 
     # Connect the signal to the custom slot
     crosshair.coordinatesChanged1D.connect(slot)
-    crosshair.crosshairChanged.connect(emitted_positions.append)
 
-    crosshair.mouse_moved(manual_pos=(2, 5))
-    emitted_positions.clear()
-    emitted_values_1D.clear()
-    crosshair.mouse_moved(manual_pos=(22, 55))
+    # Simulate a mouse moved event at a specific position
+    pos_in_view = QPointF(22, 55)
+    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
+
+    # Call the mouse_moved method
+    crosshair.mouse_moved(event_mock)
 
     # Assert the expected behavior
     assert emitted_values_1D == []
-    assert emitted_positions == []
-    assert np.isclose(crosshair.v_line.pos().x(), 2)
-    assert np.isclose(crosshair.h_line.pos().y(), 5)
 
 
 def test_mouse_moved_signals_2D(image_widget_with_crosshair):
-    crosshair, _ = image_widget_with_crosshair
+    crosshair, plot_item = image_widget_with_crosshair
+    image_item = plot_item.items[0]
 
     emitted_values_2D = []
 
@@ -120,16 +113,17 @@ def test_mouse_moved_signals_2D(image_widget_with_crosshair):
 
     crosshair.coordinatesChanged2D.connect(slot)
 
-    crosshair.mouse_moved(manual_pos=(21.0, 55.0))
+    pos_in_view = QPointF(21.0, 55.0)
+    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
+
+    crosshair.mouse_moved(event_mock)
 
     assert emitted_values_2D == [("ImageItem", 21, 55)]
 
 
-def test_mouse_moved_signals_2D_outside_image_bounds_clamps_inside_view_range(
-    image_widget_with_crosshair,
-):
+def test_mouse_moved_signals_2D_outside(image_widget_with_crosshair):
     crosshair, plot_item = image_widget_with_crosshair
-    plot_item.vb.setRange(xRange=(0, 300), yRange=(0, 600), padding=0)
 
     emitted_values_2D = []
 
@@ -138,34 +132,23 @@ def test_mouse_moved_signals_2D_outside_image_bounds_clamps_inside_view_range(
 
     crosshair.coordinatesChanged2D.connect(slot)
 
-    crosshair.mouse_moved(manual_pos=(220.0, 555.0))
+    pos_in_view = QPointF(220.0, 555.0)
+    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
 
-    assert emitted_values_2D == [("ImageItem", 99, 99)]
-
-
-def test_mouse_moved_signals_2D_outside_view_range_ignored(image_widget_with_crosshair):
-    crosshair, _ = image_widget_with_crosshair
-
-    emitted_values_2D = []
-    emitted_positions = []
-
-    crosshair.coordinatesChanged2D.connect(emitted_values_2D.append)
-    crosshair.crosshairChanged.connect(emitted_positions.append)
-
-    crosshair.mouse_moved(manual_pos=(21.0, 55.0))
-    emitted_positions.clear()
-    emitted_values_2D.clear()
-    crosshair.mouse_moved(manual_pos=(220.0, 555.0))
+    crosshair.mouse_moved(event_mock)
 
     assert emitted_values_2D == []
-    assert emitted_positions == []
-    assert np.isclose(crosshair.v_line.pos().x(), 21.0)
-    assert np.isclose(crosshair.h_line.pos().y(), 55.0)
 
 
 def test_marker_positions_after_mouse_move(plot_widget_with_crosshair):
-    crosshair, _ = plot_widget_with_crosshair
-    crosshair.mouse_moved(manual_pos=(2, 5))
+    crosshair, plot_item = plot_widget_with_crosshair
+
+    pos_in_view = QPointF(2, 5)
+    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
+
+    crosshair.mouse_moved(event_mock)
 
     marker = crosshair.marker_moved_1d["Curve 1"]
     marker_x, marker_y = marker.getData()
@@ -189,7 +172,7 @@ def test_scale_emitted_coordinates(plot_widget_with_crosshair):
 
 
 def test_crosshair_changed_signal(plot_widget_with_crosshair):
-    crosshair, _ = plot_widget_with_crosshair
+    crosshair, plot_item = plot_widget_with_crosshair
 
     emitted_positions = []
 
@@ -198,7 +181,11 @@ def test_crosshair_changed_signal(plot_widget_with_crosshair):
 
     crosshair.crosshairChanged.connect(slot)
 
-    crosshair.mouse_moved(manual_pos=(2, 5))
+    pos_in_view = QPointF(2, 5)
+    pos_in_scene = plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
+
+    crosshair.mouse_moved(event_mock)
 
     x, y = emitted_positions[0]
 
@@ -206,33 +193,33 @@ def test_crosshair_changed_signal(plot_widget_with_crosshair):
     assert np.isclose(y, 5)
 
 
-def test_crosshair_clicked_signal(plot_widget_with_crosshair):
+def test_crosshair_clicked_signal(qtbot, plot_widget_with_crosshair):
     crosshair, plot_item = plot_widget_with_crosshair
 
     emitted_positions = []
-    emitted_view_positions = []
 
     def slot(position):
         emitted_positions.append(position)
 
     crosshair.crosshairClicked.connect(slot)
-    crosshair.positionClicked.connect(emitted_view_positions.append)
 
-    crosshair.is_log_x = True
-    crosshair.is_log_y = True
-    plot_item.vb.setRange(xRange=(0, 1), yRange=(0, 1), padding=0)
+    x_data = 2
+    y_data = 5
 
-    known_view_point = QPointF(np.log10(2), np.log10(5))
-    pos_in_scene = plot_item.vb.mapViewToScene(known_view_point)
-    crosshair.mouse_clicked(_FakeMouseClickEvent(pos_in_scene))
+    # Map data coordinates to scene coordinates
+    pos_in_scene = plot_item.vb.mapViewToScene(QPointF(x_data, y_data))
+    # Map scene coordinates to widget coordinates
+    graphics_view = plot_item.vb.scene().views()[0]
+    qtbot.waitExposed(graphics_view)
+    pos_in_widget = graphics_view.mapFromScene(pos_in_scene)
+
+    # Simulate mouse click
+    qtbot.mouseClick(graphics_view.viewport(), Qt.LeftButton, pos=pos_in_widget)
 
     x, y = emitted_positions[0]
-    view_x, view_y = emitted_view_positions[0]
 
-    assert np.isclose(x, 2)
-    assert np.isclose(y, 5)
-    assert np.isclose(view_x, known_view_point.x())
-    assert np.isclose(view_y, known_view_point.y())
+    assert np.isclose(round(x, 1), 2)
+    assert np.isclose(round(y, 1), 5)
 
 
 def test_update_coord_label_1D(plot_widget_with_crosshair):
@@ -372,17 +359,20 @@ def test_ignore_invisible_curves_on_move(qtbot, mocked_client):
     c0 = wf.plot(x=[1, 2, 3], y=[1, 4, 9], name="Curve_0")
     c1 = wf.plot(x=[1, 2, 3], y=[2, 5, 10], name="Curve_1")
     wf.hook_crosshair()
-    wf.crosshair.plot_item.vb.setRange(xRange=(0, 4), yRange=(0, 10), padding=0)
 
     # # Simulate a mouse move at (2,5)
+    pos_in_view = QPointF(2, 5)
+    pos_in_scene = wf.plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
+
     # 1) Both curves visible: expect markers for both
     wf.crosshair.clear_markers()
-    wf.crosshair.mouse_moved(manual_pos=(2, 5))
+    wf.crosshair.mouse_moved(event_mock)
     assert set(wf.crosshair.marker_moved_1d.keys()) == {"Curve_0", "Curve_1"}
 
     # 2) Hide Curve B and repeat: only Curve_0 should remain
     c1.setVisible(False)
     wf.crosshair.clear_markers()
-    wf.crosshair.mouse_moved(manual_pos=(2, 5))
+    wf.crosshair.mouse_moved(event_mock)
     qtbot.wait(200)
     assert set(wf.crosshair.marker_moved_1d.keys()) == {"Curve_0"}

tests/unit_tests/test_device_input_widgets.py

@@ -139,23 +139,6 @@ def test_device_input_combobox_cleanup_unregisters_callback(qtbot, mocked_client
         assert widget._callback_id is None
 
 
-def test_device_input_combobox_cleanup_clears_callback_before_unregister(qtbot, mocked_client):
-    widget = DeviceComboBox(client=mocked_client)
-    qtbot.addWidget(widget)
-    callback_id = widget._callback_id
-
-    def assert_callback_cleared(removed_callback_id):
-        assert removed_callback_id == callback_id
-        assert widget._callback_id is None
-
-    with mock.patch.object(
-        mocked_client.callbacks, "remove", side_effect=assert_callback_cleared
-    ) as remove_mock:
-        widget.cleanup()
-
-    remove_mock.assert_called_once_with(callback_id)
-
-
 def test_get_device_from_input_combobox_init(device_input_combobox):
     device_input_combobox.setCurrentIndex(0)
     device_text = device_input_combobox.currentText()

tests/unit_tests/test_device_signal_input.py

@@ -196,50 +196,6 @@ def test_device_signal_input_base_cleanup(qtbot, mocked_client):
         assert widget._device_update_register is None
 
 
-def test_signal_combobox_cleanup_clears_callback_before_unregister(qtbot, mocked_client):
-    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
-    callback_id = widget._device_update_register
-
-    def assert_callback_cleared(removed_callback_id):
-        assert removed_callback_id == callback_id
-        assert widget._device_update_register is None
-
-    with mock.patch.object(
-        mocked_client.callbacks, "remove", side_effect=assert_callback_cleared
-    ) as remove_mock:
-        widget.cleanup()
-
-    remove_mock.assert_called_once_with(callback_id)
-
-
-def test_signal_combobox_cleanup_blocks_in_flight_device_update(qtbot, mocked_client):
-    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
-    callback_id = widget._device_update_register
-
-    def trigger_in_flight_update(_):
-        widget.update_signals_from_filters("reload", {})
-
-    with (
-        mock.patch.object(
-            mocked_client.callbacks, "remove", side_effect=trigger_in_flight_update
-        ) as remove_mock,
-        mock.patch.object(widget, "_set_signal_groups") as set_signal_groups,
-    ):
-        widget.cleanup()
-
-    remove_mock.assert_called_once_with(callback_id)
-    set_signal_groups.assert_not_called()
-
-
-def test_signal_combobox_device_update_ignores_update_action(qtbot, mocked_client):
-    widget = create_widget(qtbot=qtbot, widget=SignalComboBox, client=mocked_client)
-
-    with mock.patch.object(widget, "_set_signal_groups") as set_signal_groups:
-        widget.update_signals_from_filters("update", {})
-
-    set_signal_groups.assert_not_called()
-
-
 def test_signal_combobox_get_signal_name_with_item_data(qtbot, device_signal_combobox):
     """Test get_signal_name returns obj_name from item data when available."""
     device_signal_combobox.include_normal_signals = True

tests/unit_tests/test_toggle.py

@@ -36,26 +36,3 @@ def test_toggle_click(qtbot, toggle):
     qtbot.mouseClick(toggle, Qt.LeftButton)
     toggle.paintEvent(None)
     assert toggle.checked is not init_state
-
-
-def test_toggle_disabled_state_blocks_clicks_and_restores_colors(qtbot, toggle):
-    toggle.checked = True
-    assert toggle._track_color == toggle.active_track_color
-    assert toggle._thumb_color == toggle.active_thumb_color
-
-    toggle.setEnabled(False)
-
-    assert toggle._track_color == toggle._disabled_track_color
-    assert toggle._thumb_color == toggle._disabled_thumb_color
-
-    qtbot.mouseClick(toggle, Qt.LeftButton)
-
-    assert toggle.checked is True
-    assert toggle._track_color == toggle._disabled_track_color
-    assert toggle._thumb_color == toggle._disabled_thumb_color
-
-    toggle.setEnabled(True)
-
-    assert toggle.checked is True
-    assert toggle._track_color == toggle.active_track_color
-    assert toggle._thumb_color == toggle.active_thumb_color