1.17.1

Automatically generated by python-semantic-release

.gitlab-ci.yml

@@ -61,6 +61,7 @@ stages:
   - pip install -e ./ophyd_devices
   - pip install -e ./bec/bec_lib[dev]
   - pip install -e ./bec/bec_ipython_client
+  - pip install -e ./bec/pytest_bec_e2e
 
 .install-os-packages: &install-os-packages
   - apt-get update

bec_widgets/cli/auto_updates.py

@@ -27,25 +27,17 @@ class AutoUpdates:
 
     def __init__(self, gui: BECDockArea):
         self.gui = gui
-        self.msg_queue = Queue()
-        self.auto_update_thread = None
-        self._shutdown_sentinel = object()
-        self.start()
-
-    def start(self):
-        """
-        Start the auto update thread.
-        """
-        self.auto_update_thread = threading.Thread(target=self.process_queue)
-        self.auto_update_thread.start()
+        self._default_dock = None
+        self._default_fig = None
 
     def start_default_dock(self):
         """
         Create a default dock for the auto updates.
         """
-        dock = self.gui.add_dock("default_figure")
-        dock.add_widget("BECFigure")
         self.dock_name = "default_figure"
+        self._default_dock = self.gui.add_dock(self.dock_name)
+        self._default_dock.add_widget("BECFigure")
+        self._default_fig = self._default_dock.widget_list[0]
 
     @staticmethod
     def get_scan_info(msg) -> ScanInfo:
@@ -73,15 +65,9 @@ class AutoUpdates:
         """
         Get the default figure from the GUI.
         """
-        dock = self.gui.panels.get(self.dock_name, [])
-        if not dock:
-            return None
-        widgets = dock.widget_list
-        if not widgets:
-            return None
-        return widgets[0]
+        return self._default_fig
 
-    def run(self, msg):
+    def do_update(self, msg):
         """
         Run the update function if enabled.
         """
@@ -90,20 +76,9 @@ class AutoUpdates:
         if msg.status != "open":
             return
         info = self.get_scan_info(msg)
-        self.handler(info)
+        return self.handler(info)
 
-    def process_queue(self):
-        """
-        Process the message queue.
-        """
-        while True:
-            msg = self.msg_queue.get()
-            if msg is self._shutdown_sentinel:
-                break
-            self.run(msg)
-
-    @staticmethod
-    def get_selected_device(monitored_devices, selected_device):
+    def get_selected_device(self, monitored_devices, selected_device):
         """
         Get the selected device for the plot. If no device is selected, the first
         device in the monitored devices list is selected.
@@ -120,14 +95,11 @@ class AutoUpdates:
         Default update function.
         """
         if info.scan_name == "line_scan" and info.scan_report_devices:
-            self.simple_line_scan(info)
-            return
+            return self.simple_line_scan(info)
         if info.scan_name == "grid_scan" and info.scan_report_devices:
-            self.simple_grid_scan(info)
-            return
+            return self.simple_grid_scan(info)
         if info.scan_report_devices:
-            self.best_effort(info)
-            return
+            return self.best_effort(info)
 
     def simple_line_scan(self, info: ScanInfo) -> None:
         """
@@ -137,12 +109,19 @@ class AutoUpdates:
         if not fig:
             return
         dev_x = info.scan_report_devices[0]
-        dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
+        selected_device = yield self.gui.selected_device
+        dev_y = self.get_selected_device(info.monitored_devices, selected_device)
         if not dev_y:
             return
-        fig.clear_all()
-        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
-        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
+        yield fig.clear_all()
+        yield fig.plot(
+            x_name=dev_x,
+            y_name=dev_y,
+            label=f"Scan {info.scan_number} - {dev_y}",
+            title=f"Scan {info.scan_number}",
+            x_label=dev_x,
+            y_label=dev_y,
+        )
 
     def simple_grid_scan(self, info: ScanInfo) -> None:
         """
@@ -153,12 +132,18 @@ class AutoUpdates:
             return
         dev_x = info.scan_report_devices[0]
         dev_y = info.scan_report_devices[1]
-        dev_z = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
-        fig.clear_all()
-        plt = fig.plot(
-            x_name=dev_x, y_name=dev_y, z_name=dev_z, label=f"Scan {info.scan_number} - {dev_z}"
+        selected_device = yield self.gui.selected_device
+        dev_z = self.get_selected_device(info.monitored_devices, selected_device)
+        yield fig.clear_all()
+        yield fig.plot(
+            x_name=dev_x,
+            y_name=dev_y,
+            z_name=dev_z,
+            label=f"Scan {info.scan_number} - {dev_z}",
+            title=f"Scan {info.scan_number}",
+            x_label=dev_x,
+            y_label=dev_y,
         )
-        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
 
     def best_effort(self, info: ScanInfo) -> None:
         """
@@ -168,17 +153,16 @@ class AutoUpdates:
         if not fig:
             return
         dev_x = info.scan_report_devices[0]
-        dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
+        selected_device = yield self.gui.selected_device
+        dev_y = self.get_selected_device(info.monitored_devices, selected_device)
         if not dev_y:
             return
-        fig.clear_all()
-        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
-        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
-
-    def shutdown(self):
-        """
-        Shutdown the auto update thread.
-        """
-        self.msg_queue.put(self._shutdown_sentinel)
-        if self.auto_update_thread:
-            self.auto_update_thread.join()
+        yield fig.clear_all()
+        yield fig.plot(
+            x_name=dev_x,
+            y_name=dev_y,
+            label=f"Scan {info.scan_number} - {dev_y}",
+            title=f"Scan {info.scan_number}",
+            x_label=dev_x,
+            y_label=dev_y,
+        )

bec_widgets/cli/client.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import enum
 from typing import Literal, Optional, overload
 
-from bec_widgets.cli.client_utils import BECGuiClientMixin, RPCBase, rpc_call
+from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
 
 # pylint: skip-file
 
@@ -19,7 +19,6 @@ class Widgets(str, enum.Enum):
     BECColorMapWidget = "BECColorMapWidget"
     BECDockArea = "BECDockArea"
     BECImageWidget = "BECImageWidget"
-    BECMainWindow = "BECMainWindow"
     BECMotorMapWidget = "BECMotorMapWidget"
     BECMultiWaveformWidget = "BECMultiWaveformWidget"
     BECProgressBar = "BECProgressBar"
@@ -32,8 +31,10 @@ class Widgets(str, enum.Enum):
     DeviceComboBox = "DeviceComboBox"
     DeviceLineEdit = "DeviceLineEdit"
     LMFitDialog = "LMFitDialog"
+    Minesweeper = "Minesweeper"
     PositionIndicator = "PositionIndicator"
     PositionerBox = "PositionerBox"
+    PositionerBox2D = "PositionerBox2D"
     PositionerControlLine = "PositionerControlLine"
     ResetButton = "ResetButton"
     ResumeButton = "ResumeButton"
@@ -64,6 +65,13 @@ class AbortButton(RPCBase):
         Get all registered RPC objects.
         """
 
+    @property
+    @rpc_call
+    def _rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
+
 
 class BECColorMapWidget(RPCBase):
     @property
@@ -336,7 +344,7 @@ class BECDock(RPCBase):
         """
 
 
-class BECDockArea(RPCBase, BECGuiClientMixin):
+class BECDockArea(RPCBase):
     @property
     @rpc_call
     def _config_dict(self) -> "dict":
@@ -347,6 +355,13 @@ class BECDockArea(RPCBase, BECGuiClientMixin):
             dict: The configuration of the widget.
         """
 
+    @property
+    @rpc_call
+    def selected_device(self) -> "str":
+        """
+        None
+        """
+
     @property
     @rpc_call
     def panels(self) -> "dict[str, BECDock]":
@@ -474,6 +489,12 @@ class BECDockArea(RPCBase, BECGuiClientMixin):
         Hide all windows including floating docks.
         """
 
+    @rpc_call
+    def delete(self):
+        """
+        None
+        """
+
 
 class BECFigure(RPCBase):
     @property
@@ -3162,6 +3183,9 @@ class LMFitDialog(RPCBase):
         """
 
 
+class Minesweeper(RPCBase): ...
+
+
 class PositionIndicator(RPCBase):
     @rpc_call
     def set_value(self, position: float):
@@ -3212,6 +3236,51 @@ class PositionerBox(RPCBase):
         """
 
 
+class PositionerBox2D(RPCBase):
+    @rpc_call
+    def set_positioner_hor(self, positioner: "str | Positioner"):
+        """
+        Set the device
+
+        Args:
+            positioner (Positioner | str) : Positioner to set, accepts str or the device
+        """
+
+    @rpc_call
+    def set_positioner_ver(self, positioner: "str | Positioner"):
+        """
+        Set the device
+
+        Args:
+            positioner (Positioner | str) : Positioner to set, accepts str or the device
+        """
+
+
+class PositionerBoxBase(RPCBase):
+    @property
+    @rpc_call
+    def _config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    def _get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
+    @property
+    @rpc_call
+    def _rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
+
+
 class PositionerControlLine(RPCBase):
     @rpc_call
     def set_positioner(self, positioner: "str | Positioner"):

bec_widgets/cli/client_utils.py

@@ -7,61 +7,33 @@ import os
 import select
 import subprocess
 import threading
-import time
-import uuid
-from functools import wraps
+from contextlib import contextmanager
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from bec_lib.client import BECClient
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import isinstance_based_on_class_name, lazy_import, lazy_import_from
 
 import bec_widgets.cli.client as client
 from bec_widgets.cli.auto_updates import AutoUpdates
+from bec_widgets.cli.rpc.rpc_base import RPCBase
 
 if TYPE_CHECKING:
+    from bec_lib import messages
+    from bec_lib.connector import MessageObject
     from bec_lib.device import DeviceBase
 
-messages = lazy_import("bec_lib.messages")
-# from bec_lib.connector import MessageObject
-MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
-BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
+    from bec_widgets.utils.bec_dispatcher import BECDispatcher
+else:
+    messages = lazy_import("bec_lib.messages")
+    # from bec_lib.connector import MessageObject
+    MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
+    BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
 
 logger = bec_logger.logger
 
 
-def rpc_call(func):
-    """
-    A decorator for calling a function on the server.
-
-    Args:
-        func: The function to call.
-
-    Returns:
-        The result of the function call.
-    """
-
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        # we could rely on a strict type check here, but this is more flexible
-        # moreover, it would anyway crash for objects...
-        out = []
-        for arg in args:
-            if hasattr(arg, "name"):
-                arg = arg.name
-            out.append(arg)
-        args = tuple(out)
-        for key, val in kwargs.items():
-            if hasattr(val, "name"):
-                kwargs[key] = val.name
-        if not self.gui_is_alive():
-            raise RuntimeError("GUI is not alive")
-        return self._run_rpc(func.__name__, *args, **kwargs)
-
-    return wrapper
-
-
 def _get_output(process, logger) -> None:
     log_func = {process.stdout: logger.debug, process.stderr: logger.error}
     stream_buffer = {process.stdout: [], process.stderr: []}
@@ -132,29 +104,79 @@ class RepeatTimer(threading.Timer):
             self.function(*self.args, **self.kwargs)
 
 
-class BECGuiClientMixin:
+@contextmanager
+def wait_for_server(client):
+    timeout = client._startup_timeout
+    if not timeout:
+        if client.gui_is_alive():
+            # there is hope, let's wait a bit
+            timeout = 1
+        else:
+            raise RuntimeError("GUI is not alive")
+    try:
+        if client._gui_started_event.wait(timeout=timeout):
+            client._gui_started_timer.cancel()
+            client._gui_started_timer.join()
+        else:
+            raise TimeoutError("Could not connect to GUI server")
+    finally:
+        # after initial waiting period, do not wait so much any more
+        # (only relevant if GUI didn't start)
+        client._startup_timeout = 0
+    yield
+
+
+### ----------------------------
+### NOTE
+### it is far easier to extend the 'delete' method on the client side,
+### to know when the client is deleted, rather than listening to server
+### to get notified. However, 'generate_cli.py' cannot add extra stuff
+### in the generated client module. So, here a class with the same name
+### is created, and client module is patched.
+class BECDockArea(client.BECDockArea):
+    def delete(self):
+        if self is BECGuiClient._top_level["main"].widget:
+            raise RuntimeError("Cannot delete main window")
+        super().delete()
+        try:
+            del BECGuiClient._top_level[self._gui_id]
+        except KeyError:
+            # if a dock area is not at top level
+            pass
+
+
+client.BECDockArea = BECDockArea
+### ----------------------------
+
+
+@dataclass
+class WidgetDesc:
+    title: str
+    widget: BECDockArea
+
+
+class BECGuiClient(RPCBase):
+    _top_level = {}
+
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._auto_updates_enabled = True
         self._auto_updates = None
+        self._startup_timeout = 0
         self._gui_started_timer = None
         self._gui_started_event = threading.Event()
         self._process = None
         self._process_output_processing_thread = None
-        self._target_endpoint = MessageEndpoints.scan_status()
-        self._selected_device = None
+
+    @property
+    def windows(self):
+        return self._top_level
 
     @property
     def auto_updates(self):
         if self._auto_updates_enabled:
-            self._gui_started_event.wait()
-        return self._auto_updates
-
-    def shutdown_auto_updates(self):
-        if self._auto_updates_enabled:
-            if self._auto_updates is not None:
-                self._auto_updates.shutdown()
-                self._auto_updates = None
+            with wait_for_server(self):
+                return self._auto_updates
 
     def _get_update_script(self) -> AutoUpdates | None:
         eps = imd.entry_points(group="bec.widgets.auto_updates")
@@ -175,49 +197,59 @@ class BECGuiClientMixin:
         """
         Selected device for the plot.
         """
-        return self._selected_device
+        auto_update_config_ep = MessageEndpoints.gui_auto_update_config(self._gui_id)
+        auto_update_config = self._client.connector.get(auto_update_config_ep)
+        if auto_update_config:
+            return auto_update_config.selected_device
+        return None
 
     @selected_device.setter
     def selected_device(self, device: str | DeviceBase):
         if isinstance_based_on_class_name(device, "bec_lib.device.DeviceBase"):
-            self._selected_device = device.name
+            self._client.connector.set_and_publish(
+                MessageEndpoints.gui_auto_update_config(self._gui_id),
+                messages.GUIAutoUpdateConfigMessage(selected_device=device.name),
+            )
         elif isinstance(device, str):
-            self._selected_device = device
+            self._client.connector.set_and_publish(
+                MessageEndpoints.gui_auto_update_config(self._gui_id),
+                messages.GUIAutoUpdateConfigMessage(selected_device=device),
+            )
         else:
             raise ValueError("Device must be a string or a device object")
 
     def _start_update_script(self) -> None:
-        self._client.connector.register(
-            self._target_endpoint, cb=self._handle_msg_update, parent=self
-        )
+        self._client.connector.register(MessageEndpoints.scan_status(), cb=self._handle_msg_update)
 
-    @staticmethod
-    def _handle_msg_update(msg: MessageObject, parent: BECGuiClientMixin) -> None:
-        if parent.auto_updates is not None:
+    def _handle_msg_update(self, msg: MessageObject) -> None:
+        if self.auto_updates is not None:
             # pylint: disable=protected-access
-            parent._update_script_msg_parser(msg.value)
+            return self._update_script_msg_parser(msg.value)
 
     def _update_script_msg_parser(self, msg: messages.BECMessage) -> None:
         if isinstance(msg, messages.ScanStatusMessage):
             if not self.gui_is_alive():
                 return
             if self._auto_updates_enabled:
-                self.auto_updates.msg_queue.put(msg)
+                return self.auto_updates.do_update(msg)
 
     def _gui_post_startup(self):
+        self._top_level["main"] = WidgetDesc(
+            title="BEC Widgets", widget=BECDockArea(gui_id=self._gui_id)
+        )
         if self._auto_updates_enabled:
             if self._auto_updates is None:
                 auto_updates = self._get_update_script()
                 if auto_updates is None:
                     AutoUpdates.create_default_dock = True
                     AutoUpdates.enabled = True
-                    auto_updates = AutoUpdates(gui=self)
+                    auto_updates = AutoUpdates(self._top_level["main"].widget)
                 if auto_updates.create_default_dock:
                     auto_updates.start_default_dock()
-                    # fig = auto_updates.get_default_figure()
+                self._start_update_script()
                 self._auto_updates = auto_updates
+        self._do_show_all()
         self._gui_started_event.set()
-        self.show_all()
 
     def start_server(self, wait=False) -> None:
         """
@@ -225,8 +257,8 @@ class BECGuiClientMixin:
         """
         if self._process is None or self._process.poll() is not None:
             logger.success("GUI starting...")
+            self._startup_timeout = 5
             self._gui_started_event.clear()
-            self._start_update_script()
             self._process, self._process_output_processing_thread = _start_plot_process(
                 self._gui_id, self.__class__, self._client._service_config.config, logger=logger
             )
@@ -239,27 +271,66 @@ class BECGuiClientMixin:
                     threading.current_thread().cancel()
 
             self._gui_started_timer = RepeatTimer(
-                1, lambda: self.gui_is_alive() and gui_started_callback(self._gui_post_startup)
+                0.5, lambda: self.gui_is_alive() and gui_started_callback(self._gui_post_startup)
             )
             self._gui_started_timer.start()
 
         if wait:
             self._gui_started_event.wait()
 
-    def show_all(self):
-        self._gui_started_event.wait()
+    def _dump(self):
+        rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
+        return rpc_client._run_rpc("_dump")
+
+    def start(self):
+        return self.start_server()
+
+    def _do_show_all(self):
         rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
         rpc_client._run_rpc("show")
+        for window in self._top_level.values():
+            window.widget.show()
+
+    def show_all(self):
+        with wait_for_server(self):
+            return self._do_show_all()
 
     def hide_all(self):
-        self._gui_started_event.wait()
-        rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
-        rpc_client._run_rpc("hide")
+        with wait_for_server(self):
+            rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
+            rpc_client._run_rpc("hide")
+            for window in self._top_level.values():
+                window.widget.hide()
+
+    def show(self):
+        if self._process is not None:
+            return self.show_all()
+        # backward compatibility: show() was also starting server
+        return self.start_server(wait=True)
+
+    def hide(self):
+        return self.hide_all()
+
+    @property
+    def main(self):
+        """Return client to main dock area (in main window)"""
+        with wait_for_server(self):
+            return self._top_level["main"].widget
+
+    def new(self, title):
+        """Ask main window to create a new top-level dock area"""
+        with wait_for_server(self):
+            rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
+            widget = rpc_client._run_rpc("new_dock_area", title)
+            self._top_level[widget._gui_id] = WidgetDesc(title=title, widget=widget)
+            return widget
 
     def close(self) -> None:
         """
         Close the gui window.
         """
+        self._top_level.clear()
+
         if self._gui_started_timer is not None:
             self._gui_started_timer.cancel()
             self._gui_started_timer.join()
@@ -274,130 +345,3 @@ class BECGuiClientMixin:
                 self._process_output_processing_thread.join()
             self._process.wait()
             self._process = None
-        self.shutdown_auto_updates()
-
-
-class RPCResponseTimeoutError(Exception):
-    """Exception raised when an RPC response is not received within the expected time."""
-
-    def __init__(self, request_id, timeout):
-        super().__init__(
-            f"RPC response not received within {timeout} seconds for request ID {request_id}"
-        )
-
-
-class RPCBase:
-    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
-        self._client = BECClient()  # BECClient is a singleton; here, we simply get the instance
-        self._config = config if config is not None else {}
-        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())[:5]
-        self._parent = parent
-        self._msg_wait_event = threading.Event()
-        self._rpc_response = None
-        super().__init__()
-        # print(f"RPCBase: {self._gui_id}")
-
-    def __repr__(self):
-        type_ = type(self)
-        qualname = type_.__qualname__
-        return f"<{qualname} object at {hex(id(self))}>"
-
-    @property
-    def _root(self):
-        """
-        Get the root widget. This is the BECFigure widget that holds
-        the anchor gui_id.
-        """
-        parent = self
-        # pylint: disable=protected-access
-        while parent._parent is not None:
-            parent = parent._parent
-        return parent
-
-    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=3, **kwargs):
-        """
-        Run the RPC call.
-
-        Args:
-            method: The method to call.
-            args: The arguments to pass to the method.
-            wait_for_rpc_response: Whether to wait for the RPC response.
-            kwargs: The keyword arguments to pass to the method.
-
-        Returns:
-            The result of the RPC call.
-        """
-        request_id = str(uuid.uuid4())
-        rpc_msg = messages.GUIInstructionMessage(
-            action=method,
-            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
-            metadata={"request_id": request_id},
-        )
-
-        # pylint: disable=protected-access
-        receiver = self._root._gui_id
-        if wait_for_rpc_response:
-            self._rpc_response = None
-            self._msg_wait_event.clear()
-            self._client.connector.register(
-                MessageEndpoints.gui_instruction_response(request_id),
-                cb=self._on_rpc_response,
-                parent=self,
-            )
-
-        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
-
-        if wait_for_rpc_response:
-            try:
-                finished = self._msg_wait_event.wait(10)
-                if not finished:
-                    raise RPCResponseTimeoutError(request_id, timeout)
-            finally:
-                self._msg_wait_event.clear()
-                self._client.connector.unregister(
-                    MessageEndpoints.gui_instruction_response(request_id), cb=self._on_rpc_response
-                )
-            # get class name
-            if not self._rpc_response.accepted:
-                raise ValueError(self._rpc_response.message["error"])
-            msg_result = self._rpc_response.message.get("result")
-            self._rpc_response = None
-            return self._create_widget_from_msg_result(msg_result)
-
-    @staticmethod
-    def _on_rpc_response(msg: MessageObject, parent: RPCBase) -> None:
-        msg = msg.value
-        parent._msg_wait_event.set()
-        parent._rpc_response = msg
-
-    def _create_widget_from_msg_result(self, msg_result):
-        if msg_result is None:
-            return None
-        if isinstance(msg_result, list):
-            return [self._create_widget_from_msg_result(res) for res in msg_result]
-        if isinstance(msg_result, dict):
-            if "__rpc__" not in msg_result:
-                return {
-                    key: self._create_widget_from_msg_result(val) for key, val in msg_result.items()
-                }
-            cls = msg_result.pop("widget_class", None)
-            msg_result.pop("__rpc__", None)
-
-            if not cls:
-                return msg_result
-
-            cls = getattr(client, cls)
-            # print(msg_result)
-            return cls(parent=self, **msg_result)
-        return msg_result
-
-    def gui_is_alive(self):
-        """
-        Check if the GUI is alive.
-        """
-        heart = self._client.connector.get(MessageEndpoints.gui_heartbeat(self._root._gui_id))
-        if heart is None:
-            return False
-        if heart.status == messages.BECStatus.RUNNING:
-            return True
-        return False

bec_widgets/cli/generate_cli.py

@@ -35,7 +35,7 @@ from __future__ import annotations
 import enum
 from typing import Literal, Optional, overload
 
-from bec_widgets.cli.client_utils import RPCBase, rpc_call, BECGuiClientMixin
+from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
 
 # pylint: skip-file"""
 
@@ -84,7 +84,7 @@ class Widgets(str, enum.Enum):
         # Generate the content
         if cls.__name__ == "BECDockArea":
             self.content += f"""
-class {class_name}(RPCBase, BECGuiClientMixin):"""
+class {class_name}(RPCBase):"""
         else:
             self.content += f"""
 class {class_name}(RPCBase):"""

bec_widgets/cli/rpc/rpc_base.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import threading
+import uuid
+from functools import wraps
+from typing import TYPE_CHECKING
+
+from bec_lib.client import BECClient
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.utils.import_utils import lazy_import, lazy_import_from
+
+import bec_widgets.cli.client as client
+
+if TYPE_CHECKING:
+    from bec_lib import messages
+    from bec_lib.connector import MessageObject
+else:
+    messages = lazy_import("bec_lib.messages")
+    # from bec_lib.connector import MessageObject
+    MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
+
+
+def rpc_call(func):
+    """
+    A decorator for calling a function on the server.
+
+    Args:
+        func: The function to call.
+
+    Returns:
+        The result of the function call.
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # we could rely on a strict type check here, but this is more flexible
+        # moreover, it would anyway crash for objects...
+        out = []
+        for arg in args:
+            if hasattr(arg, "name"):
+                arg = arg.name
+            out.append(arg)
+        args = tuple(out)
+        for key, val in kwargs.items():
+            if hasattr(val, "name"):
+                kwargs[key] = val.name
+        if not self.gui_is_alive():
+            raise RuntimeError("GUI is not alive")
+        return self._run_rpc(func.__name__, *args, **kwargs)
+
+    return wrapper
+
+
+class RPCResponseTimeoutError(Exception):
+    """Exception raised when an RPC response is not received within the expected time."""
+
+    def __init__(self, request_id, timeout):
+        super().__init__(
+            f"RPC response not received within {timeout} seconds for request ID {request_id}"
+        )
+
+
+class RPCBase:
+    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
+        self._client = BECClient()  # BECClient is a singleton; here, we simply get the instance
+        self._config = config if config is not None else {}
+        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())[:5]
+        self._parent = parent
+        self._msg_wait_event = threading.Event()
+        self._rpc_response = None
+        super().__init__()
+        # print(f"RPCBase: {self._gui_id}")
+
+    def __repr__(self):
+        type_ = type(self)
+        qualname = type_.__qualname__
+        return f"<{qualname} object at {hex(id(self))}>"
+
+    @property
+    def _root(self):
+        """
+        Get the root widget. This is the BECFigure widget that holds
+        the anchor gui_id.
+        """
+        parent = self
+        # pylint: disable=protected-access
+        while parent._parent is not None:
+            parent = parent._parent
+        return parent
+
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=3, **kwargs):
+        """
+        Run the RPC call.
+
+        Args:
+            method: The method to call.
+            args: The arguments to pass to the method.
+            wait_for_rpc_response: Whether to wait for the RPC response.
+            kwargs: The keyword arguments to pass to the method.
+
+        Returns:
+            The result of the RPC call.
+        """
+        request_id = str(uuid.uuid4())
+        rpc_msg = messages.GUIInstructionMessage(
+            action=method,
+            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
+            metadata={"request_id": request_id},
+        )
+
+        # pylint: disable=protected-access
+        receiver = self._root._gui_id
+        if wait_for_rpc_response:
+            self._rpc_response = None
+            self._msg_wait_event.clear()
+            self._client.connector.register(
+                MessageEndpoints.gui_instruction_response(request_id),
+                cb=self._on_rpc_response,
+                parent=self,
+            )
+
+        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
+
+        if wait_for_rpc_response:
+            try:
+                finished = self._msg_wait_event.wait(timeout)
+                if not finished:
+                    raise RPCResponseTimeoutError(request_id, timeout)
+            finally:
+                self._msg_wait_event.clear()
+                self._client.connector.unregister(
+                    MessageEndpoints.gui_instruction_response(request_id), cb=self._on_rpc_response
+                )
+            # get class name
+            if not self._rpc_response.accepted:
+                raise ValueError(self._rpc_response.message["error"])
+            msg_result = self._rpc_response.message.get("result")
+            self._rpc_response = None
+            return self._create_widget_from_msg_result(msg_result)
+
+    @staticmethod
+    def _on_rpc_response(msg: MessageObject, parent: RPCBase) -> None:
+        msg = msg.value
+        parent._msg_wait_event.set()
+        parent._rpc_response = msg
+
+    def _create_widget_from_msg_result(self, msg_result):
+        if msg_result is None:
+            return None
+        if isinstance(msg_result, list):
+            return [self._create_widget_from_msg_result(res) for res in msg_result]
+        if isinstance(msg_result, dict):
+            if "__rpc__" not in msg_result:
+                return {
+                    key: self._create_widget_from_msg_result(val) for key, val in msg_result.items()
+                }
+            cls = msg_result.pop("widget_class", None)
+            msg_result.pop("__rpc__", None)
+
+            if not cls:
+                return msg_result
+
+            cls = getattr(client, cls)
+            # print(msg_result)
+            return cls(parent=self, **msg_result)
+        return msg_result
+
+    def gui_is_alive(self):
+        """
+        Check if the GUI is alive.
+        """
+        heart = self._client.connector.get(MessageEndpoints.gui_heartbeat(self._root._gui_id))
+        if heart is None:
+            return False
+        if heart.status == messages.BECStatus.RUNNING:
+            return True
+        return False

bec_widgets/cli/server.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import functools
 import json
 import signal
 import sys
-from contextlib import redirect_stderr, redirect_stdout
+import types
+from contextlib import contextmanager, redirect_stderr, redirect_stdout
 from typing import Union
 
 from bec_lib.endpoints import MessageEndpoints
@@ -12,7 +14,8 @@ from bec_lib.service_config import ServiceConfig
 from bec_lib.utils.import_utils import lazy_import
 from qtpy.QtCore import Qt, QTimer
 
-from bec_widgets.cli.rpc_register import RPCRegister
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.qt_utils.error_popups import ErrorPopupUtility
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.widgets.containers.dock import BECDockArea
@@ -23,6 +26,27 @@ messages = lazy_import("bec_lib.messages")
 logger = bec_logger.logger
 
 
+@contextmanager
+def rpc_exception_hook(err_func):
+    """This context replaces the popup message box for error display with a specific hook"""
+    # get error popup utility singleton
+    popup = ErrorPopupUtility()
+    # save current setting
+    old_exception_hook = popup.custom_exception_hook
+
+    # install err_func, if it is a callable
+    def custom_exception_hook(self, exc_type, value, tb, **kwargs):
+        err_func({"error": popup.get_error_message(exc_type, value, tb)})
+
+    popup.custom_exception_hook = types.MethodType(custom_exception_hook, popup)
+
+    try:
+        yield popup
+    finally:
+        # restore state of error popup utility singleton
+        popup.custom_exception_hook = old_exception_hook
+
+
 class BECWidgetsCLIServer:
 
     def __init__(
@@ -57,18 +81,19 @@ class BECWidgetsCLIServer:
     def on_rpc_update(self, msg: dict, metadata: dict):
         request_id = metadata.get("request_id")
         logger.debug(f"Received RPC instruction: {msg}, metadata: {metadata}")
-        try:
-            obj = self.get_object_from_config(msg["parameter"])
-            method = msg["action"]
-            args = msg["parameter"].get("args", [])
-            kwargs = msg["parameter"].get("kwargs", {})
-            res = self.run_rpc(obj, method, args, kwargs)
-        except Exception as e:
-            logger.error(f"Error while executing RPC instruction: {e}")
-            self.send_response(request_id, False, {"error": str(e)})
-        else:
-            logger.debug(f"RPC instruction executed successfully: {res}")
-            self.send_response(request_id, True, {"result": res})
+        with rpc_exception_hook(functools.partial(self.send_response, request_id, False)):
+            try:
+                obj = self.get_object_from_config(msg["parameter"])
+                method = msg["action"]
+                args = msg["parameter"].get("args", [])
+                kwargs = msg["parameter"].get("kwargs", {})
+                res = self.run_rpc(obj, method, args, kwargs)
+            except Exception as e:
+                logger.error(f"Error while executing RPC instruction: {e}")
+                self.send_response(request_id, False, {"error": str(e)})
+            else:
+                logger.debug(f"RPC instruction executed successfully: {res}")
+                self.send_response(request_id, True, {"result": res})
 
     def send_response(self, request_id: str, accepted: bool, msg: dict):
         self.client.connector.set_and_publish(
@@ -181,14 +206,8 @@ def main():
 
     import bec_widgets
 
-    bec_logger.level = bec_logger.LOGLEVEL.DEBUG
-    if __name__ != "__main__":
-        # if not running as main, set the log level to critical
-        # pylint: disable=protected-access
-        bec_logger._stderr_log_level = bec_logger.LOGLEVEL.CRITICAL
-
     parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
-    parser.add_argument("--id", type=str, help="The id of the server")
+    parser.add_argument("--id", type=str, default="test", help="The id of the server")
     parser.add_argument(
         "--gui_class",
         type=str,
@@ -199,10 +218,16 @@ def main():
 
     args = parser.parse_args()
 
-    if args.gui_class == "BECFigure":
-        gui_class = BECFigure
-    elif args.gui_class == "BECDockArea":
+    bec_logger.level = bec_logger.LOGLEVEL.INFO
+    if args.hide:
+        # pylint: disable=protected-access
+        bec_logger._stderr_log_level = bec_logger.LOGLEVEL.ERROR
+        bec_logger._update_sinks()
+
+    if args.gui_class == "BECDockArea":
         gui_class = BECDockArea
+    elif args.gui_class == "BECFigure":
+        gui_class = BECFigure
     else:
         print(
             "Please specify a valid gui_class to run. Use -h for help."
@@ -213,8 +238,10 @@ def main():
     with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.info)):
         with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):
             app = QApplication(sys.argv)
-            app.setQuitOnLastWindowClosed(False)
-            app.setApplicationName("BEC Figure")
+            # set close on last window, only if not under control of client ;
+            # indeed, Qt considers a hidden window a closed window, so if all windows
+            # are hidden by default it exits
+            app.setQuitOnLastWindowClosed(not args.hide)
             module_path = os.path.dirname(bec_widgets.__file__)
             icon = QIcon()
             icon.addFile(
@@ -222,6 +249,8 @@ def main():
                 size=QSize(48, 48),
             )
             app.setWindowIcon(icon)
+            # store gui id within QApplication object, to make it available to all widgets
+            app.gui_id = args.id
 
             server = _start_server(args.id, gui_class, args.config)
 
@@ -233,7 +262,6 @@ def main():
 
             gui = server.gui
             win.setCentralWidget(gui)
-            win.resize(800, 600)
             if not args.hide:
                 win.show()
 
@@ -242,6 +270,12 @@ def main():
             def sigint_handler(*args):
                 # display message, for people to let it terminate gracefully
                 print("Caught SIGINT, exiting")
+                # first hide all top level windows
+                # this is to discriminate the cases between "user clicks on [X]"
+                # (which should be filtered, to not close -see BECDockArea-)
+                # or "app is asked to close"
+                for window in app.topLevelWidgets():
+                    window.hide()  # so, we know we can exit because it is hidden
                 app.quit()
 
             signal.signal(signal.SIGINT, sigint_handler)
@@ -250,6 +284,5 @@ def main():
             sys.exit(app.exec())
 
 
-if __name__ == "__main__":  # pragma: no cover
-    sys.argv = ["bec_widgets.cli.server", "--id", "e2860", "--gui_class", "BECDockArea"]
+if __name__ == "__main__":
     main()

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -7,6 +7,7 @@ from qtpy.QtWidgets import (
     QApplication,
     QGroupBox,
     QHBoxLayout,
+    QPushButton,
     QSplitter,
     QTabWidget,
     QVBoxLayout,
@@ -17,6 +18,7 @@ from bec_widgets.utils import BECDispatcher
 from bec_widgets.utils.colors import apply_theme
 from bec_widgets.widgets.containers.dock import BECDockArea
 from bec_widgets.widgets.containers.figure import BECFigure
+from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
 from bec_widgets.widgets.editors.jupyter_console.jupyter_console import BECJupyterConsole
 
 
@@ -50,11 +52,16 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     "d1": self.d1,
                     "d2": self.d2,
                     "wave": self.wf,
-                    # "bar": self.bar,
-                    # "cm": self.colormap,
                     "im": self.im,
                     "mm": self.mm,
                     "mw": self.mw,
+                    "lm": self.lm,
+                    "btn1": self.btn1,
+                    "btn2": self.btn2,
+                    "btn3": self.btn3,
+                    "btn4": self.btn4,
+                    "btn5": self.btn5,
+                    "btn6": self.btn6,
                 }
             )
 
@@ -79,11 +86,25 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         second_tab_layout.addWidget(self.figure)
         tab_widget.addTab(second_tab, "BEC Figure")
 
+        third_tab = QWidget()
+        third_tab_layout = QVBoxLayout(third_tab)
+        self.lm = LayoutManagerWidget()
+        third_tab_layout.addWidget(self.lm)
+        tab_widget.addTab(third_tab, "Layout Manager Widget")
+
         group_box = QGroupBox("Jupyter Console", splitter)
         group_box_layout = QVBoxLayout(group_box)
         self.console = BECJupyterConsole(inprocess=True)
         group_box_layout.addWidget(self.console)
 
+        # Some buttons for layout testing
+        self.btn1 = QPushButton("Button 1")
+        self.btn2 = QPushButton("Button 2")
+        self.btn3 = QPushButton("Button 3")
+        self.btn4 = QPushButton("Button 4")
+        self.btn5 = QPushButton("Button 5")
+        self.btn6 = QPushButton("Button 6")
+
         # add stuff to figure
         self._init_figure()
 
@@ -93,15 +114,7 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.setWindowTitle("Jupyter Console Window")
 
     def _init_figure(self):
-        self.w1 = self.figure.plot(
-            x_name="samx",
-            y_name="bpm4i",
-            # title="Standard Plot with sync device, custom labels - w1",
-            # x_label="Motor Position",
-            # y_label="Intensity (A.U.)",
-            row=0,
-            col=0,
-        )
+        self.w1 = self.figure.plot(x_name="samx", y_name="bpm4i", row=0, col=0)
         self.w1.set(
             title="Standard Plot with sync device, custom labels - w1",
             x_label="Motor Position",
@@ -169,14 +182,6 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.wf = self.d2.add_widget("BECFigure", row=0, col=0)
 
         self.mw = self.wf.multi_waveform(monitor="waveform")  # , config=config)
-        # self.wf.plot(x_name="samx", y_name="bpm3a")
-        # self.wf.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
-        # self.bar = self.d2.add_widget("RingProgressBar", row=0, col=1)
-        # self.bar.set_diameter(200)
-
-        # self.d3 = self.dock.add_dock(name="dock_3", position="bottom")
-        # self.colormap = pg.GradientWidget()
-        # self.d3.add_widget(self.colormap, row=0, col=0)
 
         self.dock.save_state()
 

bec_widgets/qt_utils/collapsible_panel_manager.py

@@ -0,0 +1,380 @@
+from __future__ import annotations
+
+import sys
+from typing import Literal
+
+import pyqtgraph as pg
+from qtpy.QtCore import Property, QEasingCurve, QObject, QPropertyAnimation
+from qtpy.QtWidgets import (
+    QApplication,
+    QHBoxLayout,
+    QMainWindow,
+    QPushButton,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+from typeguard import typechecked
+
+from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
+
+
+class DimensionAnimator(QObject):
+    """
+    Helper class to animate the size of a panel widget.
+    """
+
+    def __init__(self, panel_widget: QWidget, direction: str):
+        super().__init__()
+        self.panel_widget = panel_widget
+        self.direction = direction
+        self._size = 0
+
+    @Property(int)
+    def panel_width(self):
+        """
+        Returns the current width of the panel widget.
+        """
+        return self._size
+
+    @panel_width.setter
+    def panel_width(self, val: int):
+        """
+        Set the width of the panel widget.
+
+        Args:
+            val(int): The width to set.
+        """
+        self._size = val
+        self.panel_widget.setFixedWidth(val)
+
+    @Property(int)
+    def panel_height(self):
+        """
+        Returns the current height of the panel widget.
+        """
+        return self._size
+
+    @panel_height.setter
+    def panel_height(self, val: int):
+        """
+        Set the height of the panel widget.
+
+        Args:
+            val(int): The height to set.
+        """
+        self._size = val
+        self.panel_widget.setFixedHeight(val)
+
+
+class CollapsiblePanelManager(QObject):
+    """
+    Manager class to handle collapsible panels from a main widget using LayoutManagerWidget.
+    """
+
+    def __init__(self, layout_manager: LayoutManagerWidget, reference_widget: QWidget, parent=None):
+        super().__init__(parent)
+        self.layout_manager = layout_manager
+        self.reference_widget = reference_widget
+        self.animations = {}
+        self.panels = {}
+        self.direction_settings = {
+            "left": {"property": b"maximumWidth", "default_size": 200},
+            "right": {"property": b"maximumWidth", "default_size": 200},
+            "top": {"property": b"maximumHeight", "default_size": 150},
+            "bottom": {"property": b"maximumHeight", "default_size": 150},
+        }
+
+    def add_panel(
+        self,
+        direction: Literal["left", "right", "top", "bottom"],
+        panel_widget: QWidget,
+        target_size: int | None = None,
+        duration: int = 300,
+    ):
+        """
+        Add a panel widget to the layout manager.
+
+        Args:
+            direction(Literal["left", "right", "top", "bottom"]): Direction of the panel.
+            panel_widget(QWidget): The panel widget to add.
+            target_size(int, optional): The target size of the panel. Defaults to None.
+            duration(int): The duration of the animation in milliseconds. Defaults to 300.
+        """
+        if direction not in self.direction_settings:
+            raise ValueError("Direction must be one of 'left', 'right', 'top', 'bottom'.")
+
+        if target_size is None:
+            target_size = self.direction_settings[direction]["default_size"]
+
+        self.layout_manager.add_widget_relative(
+            widget=panel_widget, reference_widget=self.reference_widget, position=direction
+        )
+        panel_widget.setVisible(False)
+
+        # Set initial constraints as flexible
+        if direction in ["left", "right"]:
+            panel_widget.setMaximumWidth(0)
+            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        else:
+            panel_widget.setMaximumHeight(0)
+            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+
+        self.panels[direction] = {
+            "widget": panel_widget,
+            "direction": direction,
+            "target_size": target_size,
+            "duration": duration,
+            "animator": None,
+        }
+
+    def toggle_panel(
+        self,
+        direction: Literal["left", "right", "top", "bottom"],
+        target_size: int | None = None,
+        duration: int | None = None,
+        easing_curve: QEasingCurve = QEasingCurve.InOutQuad,
+        ensure_max: bool = False,
+        scale: float | None = None,
+        animation: bool = True,
+    ):
+        """
+        Toggle the specified panel.
+
+        Parameters:
+            direction (Literal["left", "right", "top", "bottom"]): Direction of the panel to toggle.
+            target_size (int, optional): Override target size for this toggle.
+            duration (int, optional): Override the animation duration.
+            easing_curve (QEasingCurve): Animation easing curve.
+            ensure_max (bool): If True, animate as a fixed-size panel.
+            scale (float, optional): If provided, calculate target_size from main widget size.
+            animation (bool): If False, no animation is performed; panel instantly toggles.
+        """
+        if direction not in self.panels:
+            raise ValueError(f"No panel found in direction '{direction}'.")
+
+        panel_info = self.panels[direction]
+        panel_widget = panel_info["widget"]
+        dir_settings = self.direction_settings[direction]
+
+        # Determine final target size
+        if scale is not None:
+            main_rect = self.reference_widget.geometry()
+            if direction in ["left", "right"]:
+                computed_target = int(main_rect.width() * scale)
+            else:
+                computed_target = int(main_rect.height() * scale)
+            final_target_size = computed_target
+        else:
+            if target_size is None:
+                final_target_size = panel_info["target_size"]
+            else:
+                final_target_size = target_size
+
+        if duration is None:
+            duration = panel_info["duration"]
+
+        expanding_property = dir_settings["property"]
+        currently_visible = panel_widget.isVisible()
+
+        if ensure_max:
+            if panel_info["animator"] is None:
+                panel_info["animator"] = DimensionAnimator(panel_widget, direction)
+            animator = panel_info["animator"]
+
+            if direction in ["left", "right"]:
+                prop_name = b"panel_width"
+            else:
+                prop_name = b"panel_height"
+        else:
+            animator = None
+            prop_name = expanding_property
+
+        if currently_visible:
+            # Hide the panel
+            if ensure_max:
+                start_value = final_target_size
+                end_value = 0
+                finish_callback = lambda w=panel_widget, d=direction: self._after_hide_reset(w, d)
+            else:
+                start_value = (
+                    panel_widget.width()
+                    if direction in ["left", "right"]
+                    else panel_widget.height()
+                )
+                end_value = 0
+                finish_callback = lambda w=panel_widget: w.setVisible(False)
+        else:
+            # Show the panel
+            start_value = 0
+            end_value = final_target_size
+            finish_callback = None
+            if ensure_max:
+                # Fix panel exactly
+                if direction in ["left", "right"]:
+                    panel_widget.setMinimumWidth(0)
+                    panel_widget.setMaximumWidth(final_target_size)
+                    panel_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
+                else:
+                    panel_widget.setMinimumHeight(0)
+                    panel_widget.setMaximumHeight(final_target_size)
+                    panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+            else:
+                # Flexible mode
+                if direction in ["left", "right"]:
+                    panel_widget.setMinimumWidth(0)
+                    panel_widget.setMaximumWidth(final_target_size)
+                    panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+                else:
+                    panel_widget.setMinimumHeight(0)
+                    panel_widget.setMaximumHeight(final_target_size)
+                    panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+
+            panel_widget.setVisible(True)
+
+        if not animation:
+            # No animation: instantly set final state
+            if end_value == 0:
+                # Hiding
+                if ensure_max:
+                    # Reset after hide
+                    self._after_hide_reset(panel_widget, direction)
+                else:
+                    panel_widget.setVisible(False)
+            else:
+                # Showing
+                if ensure_max:
+                    # Already set fixed size
+                    if direction in ["left", "right"]:
+                        panel_widget.setFixedWidth(end_value)
+                    else:
+                        panel_widget.setFixedHeight(end_value)
+                else:
+                    # Just set maximum dimension
+                    if direction in ["left", "right"]:
+                        panel_widget.setMaximumWidth(end_value)
+                    else:
+                        panel_widget.setMaximumHeight(end_value)
+            return
+
+        # With animation
+        animation = QPropertyAnimation(animator if ensure_max else panel_widget, prop_name)
+        animation.setDuration(duration)
+        animation.setStartValue(start_value)
+        animation.setEndValue(end_value)
+        animation.setEasingCurve(easing_curve)
+
+        if end_value == 0 and finish_callback:
+            animation.finished.connect(finish_callback)
+        elif end_value == 0 and not finish_callback:
+            animation.finished.connect(lambda w=panel_widget: w.setVisible(False))
+
+        animation.start()
+        self.animations[panel_widget] = animation
+
+    @typechecked
+    def _after_hide_reset(
+        self, panel_widget: QWidget, direction: Literal["left", "right", "top", "bottom"]
+    ):
+        """
+        Reset the panel widget after hiding it in ensure_max mode.
+
+        Args:
+            panel_widget(QWidget): The panel widget to reset.
+            direction(Literal["left", "right", "top", "bottom"]): The direction of the panel.
+        """
+        # Called after hiding a panel in ensure_max mode
+        panel_widget.setVisible(False)
+        if direction in ["left", "right"]:
+            panel_widget.setMinimumWidth(0)
+            panel_widget.setMaximumWidth(0)
+            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        else:
+            panel_widget.setMinimumHeight(0)
+            panel_widget.setMaximumHeight(16777215)
+            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+
+
+####################################################################################################
+# The following code is for the GUI control panel to interact with the CollapsiblePanelManager.
+# It is not covered by any tests as it serves only as an example for the CollapsiblePanelManager class.
+####################################################################################################
+
+
+class MainWindow(QMainWindow):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Panels with ensure_max, scale, and animation toggle")
+        self.resize(800, 600)
+
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        main_layout = QVBoxLayout(central_widget)
+        main_layout.setContentsMargins(10, 10, 10, 10)
+        main_layout.setSpacing(10)
+
+        # Buttons
+        buttons_layout = QHBoxLayout()
+        self.btn_left = QPushButton("Toggle Left (ensure_max=True)")
+        self.btn_top = QPushButton("Toggle Top (scale=0.5, no animation)")
+        self.btn_right = QPushButton("Toggle Right (ensure_max=True, scale=0.3)")
+        self.btn_bottom = QPushButton("Toggle Bottom (no animation)")
+
+        buttons_layout.addWidget(self.btn_left)
+        buttons_layout.addWidget(self.btn_top)
+        buttons_layout.addWidget(self.btn_right)
+        buttons_layout.addWidget(self.btn_bottom)
+
+        main_layout.addLayout(buttons_layout)
+
+        self.layout_manager = LayoutManagerWidget()
+        main_layout.addWidget(self.layout_manager)
+
+        # Main widget
+        self.main_plot = pg.PlotWidget()
+        self.main_plot.plot([1, 2, 3, 4], [4, 3, 2, 1])
+        self.layout_manager.add_widget(self.main_plot, 0, 0)
+
+        self.panel_manager = CollapsiblePanelManager(self.layout_manager, self.main_plot)
+
+        # Panels
+        self.left_panel = pg.PlotWidget()
+        self.left_panel.plot([1, 2, 3], [3, 2, 1])
+        self.panel_manager.add_panel("left", self.left_panel, target_size=200)
+
+        self.right_panel = pg.PlotWidget()
+        self.right_panel.plot([10, 20, 30], [1, 10, 1])
+        self.panel_manager.add_panel("right", self.right_panel, target_size=200)
+
+        self.top_panel = pg.PlotWidget()
+        self.top_panel.plot([1, 2, 3], [1, 2, 3])
+        self.panel_manager.add_panel("top", self.top_panel, target_size=150)
+
+        self.bottom_panel = pg.PlotWidget()
+        self.bottom_panel.plot([2, 4, 6], [10, 5, 10])
+        self.panel_manager.add_panel("bottom", self.bottom_panel, target_size=150)
+
+        # Connect buttons
+        # Left with ensure_max
+        self.btn_left.clicked.connect(
+            lambda: self.panel_manager.toggle_panel("left", ensure_max=True)
+        )
+        # Top with scale=0.5 and no animation
+        self.btn_top.clicked.connect(
+            lambda: self.panel_manager.toggle_panel("top", scale=0.5, animation=False)
+        )
+        # Right with ensure_max, scale=0.3
+        self.btn_right.clicked.connect(
+            lambda: self.panel_manager.toggle_panel("right", ensure_max=True, scale=0.3)
+        )
+        # Bottom no animation
+        self.btn_bottom.clicked.connect(
+            lambda: self.panel_manager.toggle_panel("bottom", target_size=100, animation=False)
+        )
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication(sys.argv)
+    w = MainWindow()
+    w.show()
+    sys.exit(app.exec())

bec_widgets/qt_utils/error_popups.py

@@ -2,9 +2,93 @@ import functools
 import sys
 import traceback
 
-from qtpy.QtCore import QObject, Qt, Signal, Slot
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import Property, QObject, Qt, Signal, Slot
 from qtpy.QtWidgets import QApplication, QMessageBox, QPushButton, QVBoxLayout, QWidget
 
+logger = bec_logger.logger
+
+
+def SafeProperty(prop_type, *prop_args, popup_error: bool = False, default=None, **prop_kwargs):
+    """
+    Decorator to create a Qt Property with safe getter and setter so that
+    Qt Designer won't crash if an exception occurs in either method.
+
+    Args:
+        prop_type: The property type (e.g., str, bool, int, custom classes, etc.)
+        popup_error (bool): If True, show a popup for any error; otherwise, ignore or log silently.
+        default: Any default/fallback value to return if the getter raises an exception.
+        *prop_args, **prop_kwargs: Passed along to the underlying Qt Property constructor.
+
+    Usage:
+        @SafeProperty(int, default=-1)
+        def some_value(self) -> int:
+            # your getter logic
+            return ...   # if an exception is raised, returns -1
+
+        @some_value.setter
+        def some_value(self, val: int):
+            # your setter logic
+            ...
+    """
+
+    def decorator(py_getter):
+        """Decorator for the user's property getter function."""
+
+        @functools.wraps(py_getter)
+        def safe_getter(self_):
+            try:
+                return py_getter(self_)
+            except Exception:
+                # Identify which property function triggered error
+                prop_name = f"{py_getter.__module__}.{py_getter.__qualname__}"
+                error_msg = traceback.format_exc()
+
+                if popup_error:
+                    ErrorPopupUtility().custom_exception_hook(*sys.exc_info(), popup_error=True)
+                logger.error(f"SafeProperty error in GETTER of '{prop_name}':\n{error_msg}")
+                return default
+
+        class PropertyWrapper:
+            """
+            Intermediate wrapper used so that the user can optionally chain .setter(...).
+            """
+
+            def __init__(self, getter_func):
+                # We store only our safe_getter in the wrapper
+                self.getter_func = safe_getter
+
+            def setter(self, setter_func):
+                """Wraps the user-defined setter to handle errors safely."""
+
+                @functools.wraps(setter_func)
+                def safe_setter(self_, value):
+                    try:
+                        return setter_func(self_, value)
+                    except Exception:
+                        prop_name = f"{setter_func.__module__}.{setter_func.__qualname__}"
+                        error_msg = traceback.format_exc()
+
+                        if popup_error:
+                            ErrorPopupUtility().custom_exception_hook(
+                                *sys.exc_info(), popup_error=True
+                            )
+                        logger.error(f"SafeProperty error in SETTER of '{prop_name}':\n{error_msg}")
+                        return
+
+                # Return the full read/write Property
+                return Property(prop_type, self.getter_func, safe_setter, *prop_args, **prop_kwargs)
+
+            def __call__(self):
+                """
+                If user never calls `.setter(...)`, produce a read-only property.
+                """
+                return Property(prop_type, self.getter_func, None, *prop_args, **prop_kwargs)
+
+        return PropertyWrapper(py_getter)
+
+    return decorator
+
 
 def SafeSlot(*slot_args, **slot_kwargs):  # pylint: disable=invalid-name
     """Function with args, acting like a decorator, applying "error_managed" decorator + Qt Slot
@@ -22,7 +106,13 @@ def SafeSlot(*slot_args, **slot_kwargs):  # pylint: disable=invalid-name
             try:
                 return method(*args, **kwargs)
             except Exception:
-                ErrorPopupUtility().custom_exception_hook(*sys.exc_info(), popup_error=popup_error)
+                slot_name = f"{method.__module__}.{method.__qualname__}"
+                error_msg = traceback.format_exc()
+                if popup_error:
+                    ErrorPopupUtility().custom_exception_hook(
+                        *sys.exc_info(), popup_error=popup_error
+                    )
+                logger.error(f"SafeSlot error in slot '{slot_name}':\n{error_msg}")
 
         return wrapper
 
@@ -91,6 +181,12 @@ class _ErrorPopupUtility(QObject):
         msg.setMinimumHeight(400)
         msg.exec_()
 
+    def show_property_error(self, title, message, widget):
+        """
+        Show a property-specific error message.
+        """
+        self.error_occurred.emit(title, message, widget)
+
     def format_traceback(self, traceback_message: str) -> str:
         """
         Format the traceback message to be displayed in the error popup by adding indentation to each line.
@@ -127,12 +223,14 @@ class _ErrorPopupUtility(QObject):
             error_message = " ".join(captured_message)
         return error_message
 
+    def get_error_message(self, exctype, value, tb):
+        return "".join(traceback.format_exception(exctype, value, tb))
+
     def custom_exception_hook(self, exctype, value, tb, popup_error=False):
         if popup_error or self.enable_error_popup:
-            error_message = traceback.format_exception(exctype, value, tb)
             self.error_occurred.emit(
                 "Method error" if popup_error else "Application Error",
-                "".join(error_message),
+                self.get_error_message(exctype, value, tb),
                 self.parent(),
             )
         else:

bec_widgets/qt_utils/round_frame.py

@@ -0,0 +1,177 @@
+import pyqtgraph as pg
+from qtpy.QtCore import Property
+from qtpy.QtWidgets import QApplication, QFrame, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
+
+class RoundedFrame(BECWidget, QFrame):
+    """
+    A custom QFrame with rounded corners and optional theme updates.
+    The frame can contain any QWidget, however it is mainly designed to wrap PlotWidgets to provide a consistent look and feel with other BEC Widgets.
+    """
+
+    def __init__(
+        self,
+        parent=None,
+        content_widget: QWidget = None,
+        background_color: str = None,
+        theme_update: bool = True,
+        radius: int = 10,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        QFrame.__init__(self, parent)
+
+        self.background_color = background_color
+        self.theme_update = theme_update if background_color is None else False
+        self._radius = radius
+
+        # Apply rounded frame styling
+        self.setObjectName("roundedFrame")
+        self.update_style()
+
+        # Create a layout for the frame
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(5, 5, 5, 5)  # Set 5px margin
+
+        # Add the content widget to the layout
+        if content_widget:
+            layout.addWidget(content_widget)
+
+        # Store reference to the content widget
+        self.content_widget = content_widget
+
+        # Automatically apply initial styles to the PlotWidget if applicable
+        if isinstance(content_widget, pg.PlotWidget):
+            self.apply_plot_widget_style()
+
+        self._connect_to_theme_change()
+
+    def apply_theme(self, theme: str):
+        """
+        Apply the theme to the frame and its content if theme updates are enabled.
+        """
+        if not self.theme_update:
+            return
+
+        # Update background color based on the theme
+        if theme == "light":
+            self.background_color = "#e9ecef"  # Subtle contrast for light mode
+        else:
+            self.background_color = "#141414"  # Dark mode
+
+        self.update_style()
+
+        # Update PlotWidget's background color and axis styles if applicable
+        if isinstance(self.content_widget, pg.PlotWidget):
+            self.apply_plot_widget_style()
+
+    @Property(int)
+    def radius(self):
+        """Radius of the rounded corners."""
+        return self._radius
+
+    @radius.setter
+    def radius(self, value: int):
+        self._radius = value
+        self.update_style()
+
+    def update_style(self):
+        """
+        Update the style of the frame based on the background color.
+        """
+        if self.background_color:
+            self.setStyleSheet(
+                f"""
+                QFrame#roundedFrame {{
+                    background-color: {self.background_color}; 
+                    border-radius: {self._radius}; /* Rounded corners */
+                }}
+            """
+            )
+
+    def apply_plot_widget_style(self, border: str = "none"):
+        """
+        Automatically apply background, border, and axis styles to the PlotWidget.
+
+        Args:
+            border (str): Border style (e.g., 'none', '1px solid red').
+        """
+        if isinstance(self.content_widget, pg.PlotWidget):
+            # Sync PlotWidget's background color with the RoundedFrame's background color
+            self.content_widget.setBackground(self.background_color)
+
+            # Calculate contrast-optimized axis and label colors
+            if self.background_color == "#e9ecef":  # Light mode
+                label_color = "#000000"
+                axis_color = "#666666"
+            else:  # Dark mode
+                label_color = "#FFFFFF"
+                axis_color = "#CCCCCC"
+
+            # Apply axis label and tick colors
+            plot_item = self.content_widget.getPlotItem()
+            plot_item.getAxis("left").setPen(pg.mkPen(color=axis_color))
+            plot_item.getAxis("bottom").setPen(pg.mkPen(color=axis_color))
+            plot_item.getAxis("left").setTextPen(pg.mkPen(color=label_color))
+            plot_item.getAxis("bottom").setTextPen(pg.mkPen(color=label_color))
+
+            # Apply border style via stylesheet
+            self.content_widget.setStyleSheet(
+                f"""
+                PlotWidget {{
+                    border: {border}; /* Explicitly set the border */
+                }}
+            """
+            )
+
+
+class ExampleApp(QWidget):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Rounded Plots Example")
+
+        # Main layout
+        layout = QVBoxLayout(self)
+
+        dark_button = DarkModeButton()
+
+        # Create PlotWidgets
+        plot1 = pg.PlotWidget()
+        plot1.plot([1, 3, 2, 4, 6, 5], pen="r")
+
+        plot2 = pg.PlotWidget()
+        plot2.plot([1, 2, 4, 8, 16, 32], pen="r")
+
+        # Wrap PlotWidgets in RoundedFrame
+        rounded_plot1 = RoundedFrame(content_widget=plot1, theme_update=True)
+        rounded_plot2 = RoundedFrame(content_widget=plot2, theme_update=True)
+        round = RoundedFrame()
+
+        # Add to layout
+        layout.addWidget(dark_button)
+        layout.addWidget(rounded_plot1)
+        layout.addWidget(rounded_plot2)
+        layout.addWidget(round)
+
+        self.setLayout(layout)
+
+        # Simulate theme change after 2 seconds
+        from qtpy.QtCore import QTimer
+
+        def change_theme():
+            rounded_plot1.apply_theme("light")
+            rounded_plot2.apply_theme("dark")
+
+        QTimer.singleShot(100, change_theme)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication([])
+
+    window = ExampleApp()
+    window.show()
+
+    app.exec()

bec_widgets/qt_utils/side_panel.py

@@ -0,0 +1,386 @@
+import sys
+from typing import Literal, Optional
+
+from qtpy.QtCore import Property, QEasingCurve, QPropertyAnimation
+from qtpy.QtGui import QAction
+from qtpy.QtWidgets import (
+    QApplication,
+    QHBoxLayout,
+    QLabel,
+    QMainWindow,
+    QSizePolicy,
+    QSpacerItem,
+    QStackedWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.qt_utils.toolbar import MaterialIconAction, ModularToolBar
+from bec_widgets.widgets.plots.waveform.waveform_widget import BECWaveformWidget
+
+
+class SidePanel(QWidget):
+    """
+    Side panel widget that can be placed on the left, right, top, or bottom of the main widget.
+    """
+
+    def __init__(
+        self,
+        parent=None,
+        orientation: Literal["left", "right", "top", "bottom"] = "left",
+        panel_max_width: int = 200,
+        animation_duration: int = 200,
+        animations_enabled: bool = True,
+    ):
+        super().__init__(parent=parent)
+
+        self._orientation = orientation
+        self._panel_max_width = panel_max_width
+        self._animation_duration = animation_duration
+        self._animations_enabled = animations_enabled
+        self._orientation = orientation
+
+        self._panel_width = 0
+        self._panel_height = 0
+        self.panel_visible = False
+        self.current_action: Optional[QAction] = None
+        self.current_index: Optional[int] = None
+        self.switching_actions = False
+
+        self._init_ui()
+
+    def _init_ui(self):
+        """
+        Initialize the UI elements.
+        """
+        if self._orientation in ("left", "right"):
+            self.main_layout = QHBoxLayout(self)
+            self.main_layout.setContentsMargins(0, 0, 0, 0)
+            self.main_layout.setSpacing(0)
+
+            self.toolbar = ModularToolBar(target_widget=self, orientation="vertical")
+
+            self.container = QWidget()
+            self.container.layout = QVBoxLayout(self.container)
+            self.container.layout.setContentsMargins(0, 0, 0, 0)
+            self.container.layout.setSpacing(0)
+
+            self.stack_widget = QStackedWidget()
+            self.stack_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
+            self.stack_widget.setMinimumWidth(5)
+
+            if self._orientation == "left":
+                self.main_layout.addWidget(self.toolbar)
+                self.main_layout.addWidget(self.container)
+            else:
+                self.main_layout.addWidget(self.container)
+                self.main_layout.addWidget(self.toolbar)
+
+            self.container.layout.addWidget(self.stack_widget)
+            self.stack_widget.setMaximumWidth(self._panel_max_width)
+
+        else:
+            self.main_layout = QVBoxLayout(self)
+            self.main_layout.setContentsMargins(0, 0, 0, 0)
+            self.main_layout.setSpacing(0)
+
+            self.toolbar = ModularToolBar(target_widget=self, orientation="horizontal")
+
+            self.container = QWidget()
+            self.container.layout = QVBoxLayout(self.container)
+            self.container.layout.setContentsMargins(0, 0, 0, 0)
+            self.container.layout.setSpacing(0)
+
+            self.stack_widget = QStackedWidget()
+            self.stack_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+            self.stack_widget.setMinimumHeight(5)
+
+            if self._orientation == "top":
+                self.main_layout.addWidget(self.toolbar)
+                self.main_layout.addWidget(self.container)
+            else:
+                self.main_layout.addWidget(self.container)
+                self.main_layout.addWidget(self.toolbar)
+
+            self.container.layout.addWidget(self.stack_widget)
+            self.stack_widget.setMaximumHeight(self._panel_max_width)
+
+        if self._orientation in ("left", "right"):
+            self.menu_anim = QPropertyAnimation(self, b"panel_width")
+        else:
+            self.menu_anim = QPropertyAnimation(self, b"panel_height")
+
+        self.menu_anim.setDuration(self._animation_duration)
+        self.menu_anim.setEasingCurve(QEasingCurve.InOutQuad)
+
+        if self._orientation in ("left", "right"):
+            self.panel_width = 0
+        else:
+            self.panel_height = 0
+
+    @Property(int)
+    def panel_width(self):
+        """
+        Get the panel width.
+        """
+        return self._panel_width
+
+    @panel_width.setter
+    def panel_width(self, width: int):
+        """
+        Set the panel width.
+
+        Args:
+            width(int): The width of the panel.
+        """
+        self._panel_width = width
+        if self._orientation in ("left", "right"):
+            self.stack_widget.setFixedWidth(width)
+
+    @Property(int)
+    def panel_height(self):
+        """
+        Get the panel height.
+        """
+        return self._panel_height
+
+    @panel_height.setter
+    def panel_height(self, height: int):
+        """
+        Set the panel height.
+
+        Args:
+            height(int): The height of the panel.
+        """
+        self._panel_height = height
+        if self._orientation in ("top", "bottom"):
+            self.stack_widget.setFixedHeight(height)
+
+    @Property(int)
+    def panel_max_width(self):
+        """
+        Get the maximum width of the panel.
+        """
+        return self._panel_max_width
+
+    @panel_max_width.setter
+    def panel_max_width(self, size: int):
+        """
+        Set the maximum width of the panel.
+
+        Args:
+            size(int): The maximum width of the panel.
+        """
+        self._panel_max_width = size
+        if self._orientation in ("left", "right"):
+            self.stack_widget.setMaximumWidth(self._panel_max_width)
+        else:
+            self.stack_widget.setMaximumHeight(self._panel_max_width)
+
+    @Property(int)
+    def animation_duration(self):
+        """
+        Get the duration of the animation.
+        """
+        return self._animation_duration
+
+    @animation_duration.setter
+    def animation_duration(self, duration: int):
+        """
+        Set the duration of the animation.
+
+        Args:
+            duration(int): The duration of the animation.
+        """
+        self._animation_duration = duration
+        self.menu_anim.setDuration(duration)
+
+    @Property(bool)
+    def animations_enabled(self):
+        """
+        Get the status of the animations.
+        """
+        return self._animations_enabled
+
+    @animations_enabled.setter
+    def animations_enabled(self, enabled: bool):
+        """
+        Set the status of the animations.
+
+        Args:
+            enabled(bool): The status of the animations.
+        """
+        self._animations_enabled = enabled
+
+    def show_panel(self, idx: int):
+        """
+        Show the side panel with animation and switch to idx.
+
+        Args:
+            idx(int): The index of the panel to show.
+        """
+        self.stack_widget.setCurrentIndex(idx)
+        self.panel_visible = True
+        self.current_index = idx
+
+        if self._orientation in ("left", "right"):
+            start_val, end_val = 0, self._panel_max_width
+        else:
+            start_val, end_val = 0, self._panel_max_width
+
+        if self._animations_enabled:
+            self.menu_anim.stop()
+            self.menu_anim.setStartValue(start_val)
+            self.menu_anim.setEndValue(end_val)
+            self.menu_anim.start()
+        else:
+            if self._orientation in ("left", "right"):
+                self.panel_width = end_val
+            else:
+                self.panel_height = end_val
+
+    def hide_panel(self):
+        """
+        Hide the side panel with animation.
+        """
+        self.panel_visible = False
+        self.current_index = None
+
+        if self._orientation in ("left", "right"):
+            start_val, end_val = self._panel_max_width, 0
+        else:
+            start_val, end_val = self._panel_max_width, 0
+
+        if self._animations_enabled:
+            self.menu_anim.stop()
+            self.menu_anim.setStartValue(start_val)
+            self.menu_anim.setEndValue(end_val)
+            self.menu_anim.start()
+        else:
+            if self._orientation in ("left", "right"):
+                self.panel_width = end_val
+            else:
+                self.panel_height = end_val
+
+    def switch_to(self, idx: int):
+        """
+        Switch to the specified index without animation.
+
+        Args:
+            idx(int): The index of the panel to switch to.
+        """
+        if self.current_index != idx:
+            self.stack_widget.setCurrentIndex(idx)
+            self.current_index = idx
+
+    def add_menu(self, action_id: str, icon_name: str, tooltip: str, widget: QWidget, title: str):
+        """
+        Add a menu to the side panel.
+
+        Args:
+            action_id(str): The ID of the action.
+            icon_name(str): The name of the icon.
+            tooltip(str): The tooltip for the action.
+            widget(QWidget): The widget to add to the panel.
+            title(str): The title of the panel.
+        """
+        container_widget = QWidget()
+        container_layout = QVBoxLayout(container_widget)
+        container_widget.setStyleSheet("background-color: rgba(0,0,0,0);")
+        title_label = QLabel(f"<b>{title}</b>")
+        title_label.setStyleSheet("font-size: 16px;")
+        spacer = QSpacerItem(0, 0, QSizePolicy.Minimum, QSizePolicy.Expanding)
+        container_layout.addWidget(title_label)
+        container_layout.addWidget(widget)
+        container_layout.addItem(spacer)
+        container_layout.setContentsMargins(5, 5, 5, 5)
+        container_layout.setSpacing(5)
+
+        index = self.stack_widget.count()
+        self.stack_widget.addWidget(container_widget)
+
+        action = MaterialIconAction(icon_name=icon_name, tooltip=tooltip, checkable=True)
+        self.toolbar.add_action(action_id, action, target_widget=self)
+
+        def on_action_toggled(checked: bool):
+            if self.switching_actions:
+                return
+
+            if checked:
+                if self.current_action and self.current_action != action.action:
+                    self.switching_actions = True
+                    self.current_action.setChecked(False)
+                    self.switching_actions = False
+
+                self.current_action = action.action
+
+                if not self.panel_visible:
+                    self.show_panel(index)
+                else:
+                    self.switch_to(index)
+            else:
+                if self.current_action == action.action:
+                    self.current_action = None
+                    self.hide_panel()
+
+        action.action.toggled.connect(on_action_toggled)
+
+
+class ExampleApp(QMainWindow):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Side Panel Example")
+
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+
+        self.side_panel = SidePanel(self, orientation="left")
+
+        self.layout = QHBoxLayout(central_widget)
+
+        self.layout.addWidget(self.side_panel)
+        self.plot = BECWaveformWidget()
+        self.layout.addWidget(self.plot)
+        self.add_side_menus()
+
+    def add_side_menus(self):
+        widget1 = QWidget()
+        widget1_layout = QVBoxLayout(widget1)
+        widget1_layout.addWidget(QLabel("This is Widget 1"))
+        self.side_panel.add_menu(
+            action_id="widget1",
+            icon_name="counter_1",
+            tooltip="Show Widget 1",
+            widget=widget1,
+            title="Widget 1 Panel",
+        )
+
+        widget2 = QWidget()
+        widget2_layout = QVBoxLayout(widget2)
+        widget2_layout.addWidget(QLabel("This is Widget 2"))
+        self.side_panel.add_menu(
+            action_id="widget2",
+            icon_name="counter_2",
+            tooltip="Show Widget 2",
+            widget=widget2,
+            title="Widget 2 Panel",
+        )
+
+        widget3 = QWidget()
+        widget3_layout = QVBoxLayout(widget3)
+        widget3_layout.addWidget(QLabel("This is Widget 3"))
+        self.side_panel.add_menu(
+            action_id="widget3",
+            icon_name="counter_3",
+            tooltip="Show Widget 3",
+            widget=widget3,
+            title="Widget 3 Panel",
+        )
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication(sys.argv)
+    window = ExampleApp()
+    window.resize(800, 600)
+    window.show()
+    sys.exit(app.exec())

bec_widgets/qt_utils/toolbar.py

@@ -2,17 +2,20 @@
 from __future__ import annotations
 
 import os
+import sys
 from abc import ABC, abstractmethod
 from collections import defaultdict
-from typing import Literal
+from typing import Dict, List, Literal, Tuple
 
 from bec_qthemes._icon.material_icons import material_icon
 from qtpy.QtCore import QSize, Qt
 from qtpy.QtGui import QAction, QColor, QIcon
 from qtpy.QtWidgets import (
+    QApplication,
     QComboBox,
     QHBoxLayout,
     QLabel,
+    QMainWindow,
     QMenu,
     QSizePolicy,
     QToolBar,
@@ -31,7 +34,7 @@ class ToolBarAction(ABC):
 
     Args:
         icon_path (str, optional): The name of the icon file from `assets/toolbar_icons`. Defaults to None.
-        tooltip (bool, optional): The tooltip for the action. Defaults to None.
+        tooltip (str, optional): The tooltip for the action. Defaults to None.
         checkable (bool, optional): Whether the action is checkable. Defaults to False.
     """
 
@@ -81,15 +84,18 @@ class IconAction(ToolBarAction):
         toolbar.addAction(self.action)
 
 
-class MaterialIconAction:
+class MaterialIconAction(ToolBarAction):
     """
     Action with a Material icon for the toolbar.
 
     Args:
-        icon_path (str, optional): The name of the Material icon. Defaults to None.
-        tooltip (bool, optional): The tooltip for the action. Defaults to None.
+        icon_name (str, optional): The name of the Material icon. Defaults to None.
+        tooltip (str, optional): The tooltip for the action. Defaults to None.
         checkable (bool, optional): Whether the action is checkable. Defaults to False.
         filled (bool, optional): Whether the icon is filled. Defaults to False.
+        color (str | tuple | QColor | dict[Literal["dark", "light"], str] | None, optional): The color of the icon.
+            Defaults to None.
+        parent (QWidget or None, optional): Parent widget for the underlying QAction.
     """
 
     def __init__(
@@ -99,30 +105,42 @@ class MaterialIconAction:
         checkable: bool = False,
         filled: bool = False,
         color: str | tuple | QColor | dict[Literal["dark", "light"], str] | None = None,
+        parent=None,
     ):
+        super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
         self.icon_name = icon_name
-        self.tooltip = tooltip
-        self.checkable = checkable
-        self.action = None
         self.filled = filled
         self.color = color
-
-    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
-        icon = self.get_icon()
-        self.action = QAction(icon, self.tooltip, target)
-        self.action.setCheckable(self.checkable)
-        toolbar.addAction(self.action)
-
-    def get_icon(self):
-
-        icon = material_icon(
+        # Generate the icon
+        self.icon = material_icon(
             self.icon_name,
             size=(20, 20),
             convert_to_pixmap=False,
             filled=self.filled,
             color=self.color,
         )
-        return icon
+        # Immediately create an QAction with the given parent
+        self.action = QAction(self.icon, self.tooltip, parent=parent)
+        self.action.setCheckable(self.checkable)
+
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """
+        Adds the action to the toolbar.
+
+        Args:
+            toolbar(QToolBar): The toolbar to add the action to.
+            target(QWidget): The target widget for the action.
+        """
+        toolbar.addAction(self.action)
+
+    def get_icon(self):
+        """
+        Returns the icon for the action.
+
+        Returns:
+            QIcon: The icon for the action.
+        """
+        return self.icon
 
 
 class DeviceSelectionAction(ToolBarAction):
@@ -132,7 +150,6 @@ class DeviceSelectionAction(ToolBarAction):
     Args:
         label (str): The label for the combobox.
         device_combobox (DeviceComboBox): The combobox for selecting the device.
-
     """
 
     def __init__(self, label: str, device_combobox):
@@ -160,7 +177,6 @@ class WidgetAction(ToolBarAction):
     Args:
         label (str|None): The label for the widget.
         widget (QWidget): The widget to be added to the toolbar.
-
     """
 
     def __init__(self, label: str | None = None, widget: QWidget = None, parent=None):
@@ -219,7 +235,6 @@ class ExpandableMenuAction(ToolBarAction):
         label (str): The label for the menu.
         actions (dict): A dictionary of actions to populate the menu.
         icon_path (str, optional): The path to the icon file. Defaults to None.
-
     """
 
     def __init__(self, label: str, actions: dict, icon_path: str = None):
@@ -259,38 +274,399 @@ class ExpandableMenuAction(ToolBarAction):
         toolbar.addWidget(button)
 
 
-class ModularToolBar(QToolBar):
-    """Modular toolbar with optional automatic initialization.
-    Args:
-        parent (QWidget, optional): The parent widget of the toolbar. Defaults to None.
-        actions (list[ToolBarAction], optional): A list of action creators to populate the toolbar. Defaults to None.
-        target_widget (QWidget, optional): The widget that the actions will target. Defaults to None.
+class ToolbarBundle:
+    """
+    Represents a bundle of toolbar actions, keyed by action_id.
+    Allows direct dictionary-like access: self.actions["some_id"] -> ToolBarAction object.
     """
 
-    def __init__(self, parent=None, actions: dict | None = None, target_widget=None):
+    def __init__(self, bundle_id: str = None, actions=None):
+        """
+        Args:
+            bundle_id (str): Unique identifier for the bundle.
+            actions: Either None or a list of (action_id, ToolBarAction) tuples.
+        """
+        self.bundle_id = bundle_id
+        self._actions: dict[str, ToolBarAction] = {}
+
+        # If you passed in a list of tuples, load them into the dictionary
+        if actions is not None:
+            for action_id, action in actions:
+                self._actions[action_id] = action
+
+    def add_action(self, action_id: str, action: ToolBarAction):
+        """
+        Adds or replaces an action in the bundle.
+
+        Args:
+            action_id (str): Unique identifier for the action.
+            action (ToolBarAction): The action to add.
+        """
+        self._actions[action_id] = action
+
+    def remove_action(self, action_id: str):
+        """
+        Removes an action from the bundle by ID.
+        Ignores if not present.
+
+        Args:
+            action_id (str): Unique identifier for the action to remove.
+        """
+        self._actions.pop(action_id, None)
+
+    @property
+    def actions(self) -> dict[str, ToolBarAction]:
+        """
+        Return the internal dictionary of actions so that you can do
+        bundle.actions["drag_mode"] -> ToolBarAction instance.
+        """
+        return self._actions
+
+
+class ModularToolBar(QToolBar):
+    """Modular toolbar with optional automatic initialization.
+
+    Args:
+        parent (QWidget, optional): The parent widget of the toolbar. Defaults to None.
+        actions (dict, optional): A dictionary of action creators to populate the toolbar. Defaults to None.
+        target_widget (QWidget, optional): The widget that the actions will target. Defaults to None.
+        orientation (Literal["horizontal", "vertical"], optional): The initial orientation of the toolbar. Defaults to "horizontal".
+        background_color (str, optional): The background color of the toolbar. Defaults to "rgba(0, 0, 0, 0)" - transparent background.
+    """
+
+    def __init__(
+        self,
+        parent=None,
+        actions: dict | None = None,
+        target_widget=None,
+        orientation: Literal["horizontal", "vertical"] = "horizontal",
+        background_color: str = "rgba(0, 0, 0, 0)",
+    ):
         super().__init__(parent)
 
         self.widgets = defaultdict(dict)
-        self.set_background_color()
+        self.background_color = background_color
+        self.set_background_color(self.background_color)
+
+        # Set the initial orientation
+        self.set_orientation(orientation)
+
+        # Initialize bundles
+        self.bundles = {}
+        self.toolbar_items = []
 
         if actions is not None and target_widget is not None:
             self.populate_toolbar(actions, target_widget)
 
-    def populate_toolbar(self, actions: dict, target_widget):
+    def populate_toolbar(self, actions: dict, target_widget: QWidget):
         """Populates the toolbar with a set of actions.
 
         Args:
-            actions (list[ToolBarAction]): A list of action creators to populate the toolbar.
+            actions (dict): A dictionary of action creators to populate the toolbar.
             target_widget (QWidget): The widget that the actions will target.
         """
         self.clear()
+        self.toolbar_items.clear()  # Reset the order tracking
         for action_id, action in actions.items():
             action.add_to_toolbar(self, target_widget)
             self.widgets[action_id] = action
+            self.toolbar_items.append(("action", action_id))
+        self.update_separators()  # Ensure separators are updated after populating
 
-    def set_background_color(self):
+    def set_background_color(self, color: str = "rgba(0, 0, 0, 0)"):
+        """
+        Sets the background color and other appearance settings.
+
+        Args:
+            color(str): The background color of the toolbar.
+        """
         self.setIconSize(QSize(20, 20))
         self.setMovable(False)
         self.setFloatable(False)
         self.setContentsMargins(0, 0, 0, 0)
-        self.setStyleSheet("QToolBar { background-color: rgba(0, 0, 0, 0); border: none; }")
+        self.background_color = color
+        self.setStyleSheet(f"QToolBar {{ background-color: {color}; border: none; }}")
+
+    def set_orientation(self, orientation: Literal["horizontal", "vertical"]):
+        """Sets the orientation of the toolbar.
+
+        Args:
+            orientation (Literal["horizontal", "vertical"]): The desired orientation of the toolbar.
+        """
+        if orientation == "horizontal":
+            self.setOrientation(Qt.Horizontal)
+        elif orientation == "vertical":
+            self.setOrientation(Qt.Vertical)
+        else:
+            raise ValueError("Orientation must be 'horizontal' or 'vertical'.")
+
+    def update_material_icon_colors(self, new_color: str | tuple | QColor):
+        """
+        Updates the color of all MaterialIconAction icons in the toolbar.
+
+        Args:
+            new_color (str | tuple | QColor): The new color for the icons.
+        """
+        for action in self.widgets.values():
+            if isinstance(action, MaterialIconAction):
+                action.color = new_color
+                # Refresh the icon
+                updated_icon = action.get_icon()
+                action.action.setIcon(updated_icon)
+
+    def add_action(self, action_id: str, action: ToolBarAction, target_widget: QWidget):
+        """
+        Adds a new standalone action to the toolbar dynamically.
+
+        Args:
+            action_id (str): Unique identifier for the action.
+            action (ToolBarAction): The action to add to the toolbar.
+            target_widget (QWidget): The target widget for the action.
+        """
+        if action_id in self.widgets:
+            raise ValueError(f"Action with ID '{action_id}' already exists.")
+        action.add_to_toolbar(self, target_widget)
+        self.widgets[action_id] = action
+        self.toolbar_items.append(("action", action_id))
+        self.update_separators()  # Update separators after adding the action
+
+    def hide_action(self, action_id: str):
+        """
+        Hides a specific action on the toolbar.
+
+        Args:
+            action_id (str): Unique identifier for the action to hide.
+        """
+        if action_id not in self.widgets:
+            raise ValueError(f"Action with ID '{action_id}' does not exist.")
+        action = self.widgets[action_id]
+        if hasattr(action, "action") and isinstance(action.action, QAction):
+            action.action.setVisible(False)
+            self.update_separators()  # Update separators after hiding the action
+
+    def show_action(self, action_id: str):
+        """
+        Shows a specific action on the toolbar.
+
+        Args:
+            action_id (str): Unique identifier for the action to show.
+        """
+        if action_id not in self.widgets:
+            raise ValueError(f"Action with ID '{action_id}' does not exist.")
+        action = self.widgets[action_id]
+        if hasattr(action, "action") and isinstance(action.action, QAction):
+            action.action.setVisible(True)
+            self.update_separators()  # Update separators after showing the action
+
+    def add_bundle(self, bundle: ToolbarBundle, target_widget: QWidget):
+        """
+        Adds a bundle of actions to the toolbar, separated by a separator.
+
+        Args:
+            bundle (ToolbarBundle): The bundle to add.
+            target_widget (QWidget): The target widget for the actions.
+        """
+        if bundle.bundle_id in self.bundles:
+            raise ValueError(f"ToolbarBundle with ID '{bundle.bundle_id}' already exists.")
+
+        # Add a separator before the bundle (but not to first one)
+        if self.toolbar_items:
+            sep = SeparatorAction()
+            sep.add_to_toolbar(self, target_widget)
+            self.toolbar_items.append(("separator", None))
+
+        # Add each action in the bundle
+        for action_id, action_obj in bundle.actions.items():
+            action_obj.add_to_toolbar(self, target_widget)
+            self.widgets[action_id] = action_obj
+
+        # Register the bundle
+        self.bundles[bundle.bundle_id] = list(bundle.actions.keys())
+        self.toolbar_items.append(("bundle", bundle.bundle_id))
+
+        self.update_separators()  # Update separators after adding the bundle
+
+    def contextMenuEvent(self, event):
+        """
+        Overrides the context menu event to show a list of toolbar actions with checkboxes and icons, including separators.
+
+        Args:
+            event(QContextMenuEvent): The context menu event.
+        """
+        menu = QMenu(self)
+
+        # Iterate through the toolbar items in order
+        for item_type, identifier in self.toolbar_items:
+            if item_type == "separator":
+                menu.addSeparator()
+            elif item_type == "bundle":
+                self.handle_bundle_context_menu(menu, identifier)
+            elif item_type == "action":
+                self.handle_action_context_menu(menu, identifier)
+
+        # Connect the triggered signal after all actions are added
+        menu.triggered.connect(self.handle_menu_triggered)
+        menu.exec_(event.globalPos())
+
+    def handle_bundle_context_menu(self, menu: QMenu, bundle_id: str):
+        """
+        Adds a set of bundle actions to the context menu.
+
+        Args:
+            menu (QMenu): The context menu to which the actions are added.
+            bundle_id (str): The identifier for the bundle.
+        """
+        action_ids = self.bundles.get(bundle_id, [])
+        for act_id in action_ids:
+            toolbar_action = self.widgets.get(act_id)
+            if not isinstance(toolbar_action, ToolBarAction) or not hasattr(
+                toolbar_action, "action"
+            ):
+                continue
+            qaction = toolbar_action.action
+            if not isinstance(qaction, QAction):
+                continue
+            display_name = qaction.text() or toolbar_action.tooltip or act_id
+            menu_action = QAction(display_name, self)
+            menu_action.setCheckable(True)
+            menu_action.setChecked(qaction.isVisible())
+            menu_action.setData(act_id)  # Store the action_id
+
+            # Set the icon if available
+            if qaction.icon() and not qaction.icon().isNull():
+                menu_action.setIcon(qaction.icon())
+
+            menu.addAction(menu_action)
+
+    def handle_action_context_menu(self, menu: QMenu, action_id: str):
+        """
+        Adds a single toolbar action to the context menu.
+
+        Args:
+            menu (QMenu): The context menu to which the action is added.
+            action_id (str): Unique identifier for the action.
+        """
+        toolbar_action = self.widgets.get(action_id)
+        if not isinstance(toolbar_action, ToolBarAction) or not hasattr(toolbar_action, "action"):
+            return
+        qaction = toolbar_action.action
+        if not isinstance(qaction, QAction):
+            return
+        display_name = qaction.text() or toolbar_action.tooltip or action_id
+        menu_action = QAction(display_name, self)
+        menu_action.setCheckable(True)
+        menu_action.setChecked(qaction.isVisible())
+        menu_action.setData(action_id)  # Store the action_id
+
+        # Set the icon if available
+        if qaction.icon() and not qaction.icon().isNull():
+            menu_action.setIcon(qaction.icon())
+
+        menu.addAction(menu_action)
+
+    def handle_menu_triggered(self, action):
+        """Handles the toggling of toolbar actions from the context menu."""
+        action_id = action.data()
+        if action_id:
+            self.toggle_action_visibility(action_id, action.isChecked())
+
+    def toggle_action_visibility(self, action_id: str, visible: bool):
+        """
+        Toggles the visibility of a specific action on the toolbar.
+
+        Args:
+            action_id(str): Unique identifier for the action to toggle.
+            visible(bool): Whether the action should be visible.
+        """
+        if action_id not in self.widgets:
+            return
+
+        tool_action = self.widgets[action_id]
+        if hasattr(tool_action, "action") and isinstance(tool_action.action, QAction):
+            tool_action.action.setVisible(visible)
+            self.update_separators()
+
+    def update_separators(self):
+        """
+        Hide separators that are adjacent to another separator or have no actions next to them.
+        """
+        toolbar_actions = self.actions()
+
+        for i, action in enumerate(toolbar_actions):
+            if not action.isSeparator():
+                continue
+            # Find the previous visible action
+            prev_visible = None
+            for j in range(i - 1, -1, -1):
+                if toolbar_actions[j].isVisible():
+                    prev_visible = toolbar_actions[j]
+                    break
+
+            # Find the next visible action
+            next_visible = None
+            for j in range(i + 1, len(toolbar_actions)):
+                if toolbar_actions[j].isVisible():
+                    next_visible = toolbar_actions[j]
+                    break
+
+            # Determine if the separator should be hidden
+            # Hide if both previous and next visible actions are separators or non-existent
+            if (prev_visible is None or prev_visible.isSeparator()) and (
+                next_visible is None or next_visible.isSeparator()
+            ):
+                action.setVisible(False)
+            else:
+                action.setVisible(True)
+
+
+class MainWindow(QMainWindow):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Toolbar / ToolbarBundle Demo")
+
+        self.central_widget = QWidget()
+        self.setCentralWidget(self.central_widget)
+
+        # Create a modular toolbar
+        self.toolbar = ModularToolBar(parent=self, target_widget=self)
+        self.addToolBar(self.toolbar)
+
+        # Example: Add a single bundle
+        home_action = MaterialIconAction(
+            icon_name="home", tooltip="Home", checkable=True, parent=self
+        )
+        settings_action = MaterialIconAction(
+            icon_name="settings", tooltip="Settings", checkable=True, parent=self
+        )
+        profile_action = MaterialIconAction(
+            icon_name="person", tooltip="Profile", checkable=True, parent=self
+        )
+        main_actions_bundle = ToolbarBundle(
+            bundle_id="main_actions",
+            actions=[
+                ("home_action", home_action),
+                ("settings_action", settings_action),
+                ("profile_action", profile_action),
+            ],
+        )
+        self.toolbar.add_bundle(main_actions_bundle, target_widget=self)
+
+        # Another bundle
+        search_action = MaterialIconAction(
+            icon_name="search", tooltip="Search", checkable=True, parent=self
+        )
+        help_action = MaterialIconAction(
+            icon_name="help", tooltip="Help", checkable=True, parent=self
+        )
+        second_bundle = ToolbarBundle(
+            bundle_id="secondary_actions",
+            actions=[("search_action", search_action), ("help_action", help_action)],
+        )
+        self.toolbar.add_bundle(second_bundle, target_widget=self)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication(sys.argv)
+    main_window = MainWindow()
+    main_window.show()
+    sys.exit(app.exec_())

bec_widgets/tests/utils.py

@@ -224,3 +224,11 @@ DEVICES = [
     Positioner("test", limits=[-10, 10], read_value=2.0),
     Device("test_device"),
 ]
+
+
+def check_remote_data_size(widget, plot_name, num_elements):
+    """
+    Check if the remote data has the correct number of elements.
+    Used in the qtbot.waitUntil function.
+    """
+    return len(widget.get_all_data()[plot_name]["x"]) == num_elements

bec_widgets/utils/bec_connector.py

@@ -12,7 +12,7 @@ from pydantic import BaseModel, Field, field_validator
 from qtpy.QtCore import QObject, QRunnable, QThreadPool, Signal
 from qtpy.QtWidgets import QApplication
 
-from bec_widgets.cli.rpc_register import RPCRegister
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.qt_utils.error_popups import ErrorPopupUtility
 from bec_widgets.qt_utils.error_popups import SafeSlot as pyqtSlot
 from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui

bec_widgets/utils/bec_designer.py

@@ -93,17 +93,24 @@ def patch_designer():  # pragma: no cover
             _extend_path_var("PATH", os.fspath(Path(sys._base_executable).parent), True)
     else:
         if sys.platform == "linux":
-            suffix = f"{sys.abiflags}.so"
             env_var = "LD_PRELOAD"
+            current_pid = os.getpid()
+            with open(f"/proc/{current_pid}/maps", "rt") as f:
+                for line in f:
+                    if "libpython" in line:
+                        lib_path = line.split()[-1]
+                        os.environ[env_var] = lib_path
+                        break
+
         elif sys.platform == "darwin":
             suffix = ".dylib"
             env_var = "DYLD_INSERT_LIBRARIES"
+            version = f"{major_version}.{minor_version}"
+            library_name = f"libpython{version}{suffix}"
+            lib_path = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
+            os.environ[env_var] = lib_path
         else:
             raise RuntimeError(f"Unsupported platform: {sys.platform}")
-        version = f"{major_version}.{minor_version}"
-        library_name = f"libpython{version}{suffix}"
-        lib_path = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
-        os.environ[env_var] = lib_path
 
         if is_pyenv_python() or is_virtual_env():
             # append all editable packages to the PYTHONPATH

bec_widgets/utils/bec_signal_proxy.py

@@ -5,28 +5,43 @@ analyse data. Requesting a new fit may lead to request piling up and an overall
 will allow you to decide by yourself when to unblock and execute the callback again."""
 
 from pyqtgraph import SignalProxy
-from qtpy.QtCore import Signal, Slot
+from qtpy.QtCore import QTimer, Signal
+
+from bec_widgets.qt_utils.error_popups import SafeSlot
 
 
 class BECSignalProxy(SignalProxy):
-    """Thin wrapper around the SignalProxy class to allow signal calls to be blocked, but args still being stored
+    """
+    Thin wrapper around the SignalProxy class to allow signal calls to be blocked,
+    but arguments still being stored.
 
     Args:
-        *args: Arguments to pass to the SignalProxy class
-        rateLimit (int): The rateLimit of the proxy
-        **kwargs: Keyword arguments to pass to the SignalProxy class
+        *args: Arguments to pass to the SignalProxy class.
+        rateLimit (int): The rateLimit of the proxy.
+        timeout (float): The number of seconds after which the proxy automatically
+                         unblocks if still blocked. Default is 10.0 seconds.
+        **kwargs: Keyword arguments to pass to the SignalProxy class.
 
     Example:
-    >>> proxy = BECSignalProxy(signal, rate_limit=25, slot=callback)"""
+        >>> proxy = BECSignalProxy(signal, rate_limit=25, slot=callback)
+    """
 
     is_blocked = Signal(bool)
 
-    def __init__(self, *args, rateLimit=25, **kwargs):
+    def __init__(self, *args, rateLimit=25, timeout=10.0, **kwargs):
         super().__init__(*args, rateLimit=rateLimit, **kwargs)
         self._blocking = False
         self.old_args = None
         self.new_args = None
 
+        # Store timeout value (in seconds)
+        self._timeout = timeout
+
+        # Create a single-shot timer for auto-unblocking
+        self._timer = QTimer()
+        self._timer.setSingleShot(True)
+        self._timer.timeout.connect(self._timeout_unblock)
+
     @property
     def blocked(self):
         """Returns if the proxy is blocked"""
@@ -46,9 +61,22 @@ class BECSignalProxy(SignalProxy):
         self.old_args = args
         super().signalReceived(*args)
 
-    @Slot()
+        self._timer.start(int(self._timeout * 1000))
+
+    @SafeSlot()
     def unblock_proxy(self):
         """Unblock the proxy, and call the signalReceived method in case there was an update of the args."""
-        self.blocked = False
-        if self.new_args != self.old_args:
-            self.signalReceived(*self.new_args)
+        if self.blocked:
+            self._timer.stop()
+            self.blocked = False
+            if self.new_args != self.old_args:
+                self.signalReceived(*self.new_args)
+
+    @SafeSlot()
+    def _timeout_unblock(self):
+        """
+        Internal method called by the QTimer upon timeout. Unblocks the proxy
+        automatically if it is still blocked.
+        """
+        if self.blocked:
+            self.unblock_proxy()

bec_widgets/utils/widget_io.py

@@ -1,6 +1,5 @@
 # pylint: disable=no-name-in-module
 from abc import ABC, abstractmethod
-from typing import Literal
 
 from qtpy.QtWidgets import (
     QApplication,
@@ -16,6 +15,8 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
+from bec_widgets.widgets.utility.toggle.toggle import ToggleSwitch
+
 
 class WidgetHandler(ABC):
     """Abstract base class for all widget handlers."""
@@ -28,6 +29,15 @@ class WidgetHandler(ABC):
     def set_value(self, widget: QWidget, value):
         """Set a value on the widget instance."""
 
+    def connect_change_signal(self, widget: QWidget, slot):
+        """
+        Connect a change signal from this widget to the given slot.
+        If the widget type doesn't have a known "value changed" signal, do nothing.
+
+        slot: a function accepting two arguments (widget, value)
+        """
+        pass
+
 
 class LineEditHandler(WidgetHandler):
     """Handler for QLineEdit widgets."""
@@ -38,6 +48,9 @@ class LineEditHandler(WidgetHandler):
     def set_value(self, widget: QLineEdit, value: str) -> None:
         widget.setText(value)
 
+    def connect_change_signal(self, widget: QLineEdit, slot):
+        widget.textChanged.connect(lambda text, w=widget: slot(w, text))
+
 
 class ComboBoxHandler(WidgetHandler):
     """Handler for QComboBox widgets."""
@@ -53,6 +66,11 @@ class ComboBoxHandler(WidgetHandler):
         if isinstance(value, int):
             widget.setCurrentIndex(value)
 
+    def connect_change_signal(self, widget: QComboBox, slot):
+        # currentIndexChanged(int) or currentIndexChanged(str) both possible.
+        # We use currentIndexChanged(int) for a consistent behavior.
+        widget.currentIndexChanged.connect(lambda idx, w=widget: slot(w, self.get_value(w)))
+
 
 class TableWidgetHandler(WidgetHandler):
     """Handler for QTableWidget widgets."""
@@ -72,6 +90,16 @@ class TableWidgetHandler(WidgetHandler):
                 item = QTableWidgetItem(str(cell_value))
                 widget.setItem(row, col, item)
 
+    def connect_change_signal(self, widget: QTableWidget, slot):
+        # If desired, we could connect cellChanged(row, col) and then fetch all data.
+        # This might be noisy if table is large.
+        # For demonstration, connect cellChanged to update entire table value.
+        def on_cell_changed(row, col, w=widget):
+            val = self.get_value(w)
+            slot(w, val)
+
+        widget.cellChanged.connect(on_cell_changed)
+
 
 class SpinBoxHandler(WidgetHandler):
     """Handler for QSpinBox and QDoubleSpinBox widgets."""
@@ -82,6 +110,9 @@ class SpinBoxHandler(WidgetHandler):
     def set_value(self, widget, value):
         widget.setValue(value)
 
+    def connect_change_signal(self, widget: QSpinBox | QDoubleSpinBox, slot):
+        widget.valueChanged.connect(lambda val, w=widget: slot(w, val))
+
 
 class CheckBoxHandler(WidgetHandler):
     """Handler for QCheckBox widgets."""
@@ -92,6 +123,22 @@ class CheckBoxHandler(WidgetHandler):
     def set_value(self, widget, value):
         widget.setChecked(value)
 
+    def connect_change_signal(self, widget: QCheckBox, slot):
+        widget.toggled.connect(lambda val, w=widget: slot(w, val))
+
+
+class ToggleSwitchHandler(WidgetHandler):
+    """Handler for ToggleSwitch widgets."""
+
+    def get_value(self, widget, **kwargs):
+        return widget.checked
+
+    def set_value(self, widget, value):
+        widget.checked = value
+
+    def connect_change_signal(self, widget: ToggleSwitch, slot):
+        widget.enabled.connect(lambda val, w=widget: slot(w, val))
+
 
 class LabelHandler(WidgetHandler):
     """Handler for QLabel widgets."""
@@ -99,12 +146,15 @@ class LabelHandler(WidgetHandler):
     def get_value(self, widget, **kwargs):
         return widget.text()
 
-    def set_value(self, widget, value):
+    def set_value(self, widget: QLabel, value):
         widget.setText(value)
 
+    # QLabel typically doesn't have user-editable changes. No signal to connect.
+    # If needed, this can remain empty.
+
 
 class WidgetIO:
-    """Public interface for getting and setting values using handler mapping"""
+    """Public interface for getting, setting values and connecting signals using handler mapping"""
 
     _handlers = {
         QLineEdit: LineEditHandler,
@@ -114,6 +164,7 @@ class WidgetIO:
         QDoubleSpinBox: SpinBoxHandler,
         QCheckBox: CheckBoxHandler,
         QLabel: LabelHandler,
+        ToggleSwitch: ToggleSwitchHandler,
     }
 
     @staticmethod
@@ -148,6 +199,17 @@ class WidgetIO:
         elif not ignore_errors:
             raise ValueError(f"No handler for widget type: {type(widget)}")
 
+    @staticmethod
+    def connect_widget_change_signal(widget, slot):
+        """
+        Connect the widget's value-changed signal to a generic slot function (widget, value).
+        This now delegates the logic to the widget's handler.
+        """
+        handler_class = WidgetIO._find_handler(widget)
+        if handler_class:
+            handler = handler_class()
+            handler.connect_change_signal(widget, slot)
+
     @staticmethod
     def check_and_adjust_limits(spin_box: QDoubleSpinBox, number: float):
         """
@@ -309,8 +371,8 @@ class WidgetHierarchy:
                 WidgetHierarchy.import_config_from_dict(child, widget_config, set_values)
 
 
-# Example application to demonstrate the usage of the functions
-if __name__ == "__main__":  # pragma: no cover
+# Example usage
+def hierarchy_example():  # pragma: no cover
     app = QApplication([])
 
     # Create instance of WidgetHierarchy
@@ -365,3 +427,37 @@ if __name__ == "__main__":  # pragma: no cover
     print(f"Config dict new REDUCED: {config_dict_new_reduced}")
 
     app.exec()
+
+
+def widget_io_signal_example():  # pragma: no cover
+    app = QApplication([])
+
+    main_widget = QWidget()
+    layout = QVBoxLayout(main_widget)
+    line_edit = QLineEdit(main_widget)
+    combo_box = QComboBox(main_widget)
+    spin_box = QSpinBox(main_widget)
+    combo_box.addItems(["Option 1", "Option 2", "Option 3"])
+
+    layout.addWidget(line_edit)
+    layout.addWidget(combo_box)
+    layout.addWidget(spin_box)
+
+    main_widget.show()
+
+    def universal_slot(w, val):
+        print(f"Widget {w.objectName() or w} changed, new value: {val}")
+
+    # Connect all supported widgets through their handlers
+    WidgetIO.connect_widget_change_signal(line_edit, universal_slot)
+    WidgetIO.connect_widget_change_signal(combo_box, universal_slot)
+    WidgetIO.connect_widget_change_signal(spin_box, universal_slot)
+
+    app.exec_()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # Change example function to test different scenarios
+
+    # hierarchy_example()
+    widget_io_signal_example()

bec_widgets/utils/widget_state_manager.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from qtpy.QtCore import QSettings
+from qtpy.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QFileDialog,
+    QHBoxLayout,
+    QLineEdit,
+    QPushButton,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class WidgetStateManager:
+    """
+    A class to manage the state of a widget by saving and loading the state to and from a INI file.
+
+    Args:
+        widget(QWidget): The widget to manage the state for.
+    """
+
+    def __init__(self, widget):
+        self.widget = widget
+
+    def save_state(self, filename: str = None):
+        """
+        Save the state of the widget to a INI file.
+
+        Args:
+            filename(str): The filename to save the state to.
+        """
+        if not filename:
+            filename, _ = QFileDialog.getSaveFileName(
+                self.widget, "Save Settings", "", "INI Files (*.ini)"
+            )
+        if filename:
+            settings = QSettings(filename, QSettings.IniFormat)
+            self._save_widget_state_qsettings(self.widget, settings)
+
+    def load_state(self, filename: str = None):
+        """
+        Load the state of the widget from a INI file.
+
+        Args:
+            filename(str): The filename to load the state from.
+        """
+        if not filename:
+            filename, _ = QFileDialog.getOpenFileName(
+                self.widget, "Load Settings", "", "INI Files (*.ini)"
+            )
+        if filename:
+            settings = QSettings(filename, QSettings.IniFormat)
+            self._load_widget_state_qsettings(self.widget, settings)
+
+    def _save_widget_state_qsettings(self, widget: QWidget, settings: QSettings):
+        """
+        Save the state of the widget to QSettings.
+
+        Args:
+            widget(QWidget): The widget to save the state for.
+            settings(QSettings): The QSettings object to save the state to.
+        """
+        meta = widget.metaObject()
+        settings.beginGroup(widget.objectName())
+        for i in range(meta.propertyCount()):
+            prop = meta.property(i)
+            name = prop.name()
+            value = widget.property(name)
+            settings.setValue(name, value)
+        settings.endGroup()
+
+        # Recursively save child widgets
+        for child in widget.findChildren(QWidget):
+            if child.objectName():
+                self._save_widget_state_qsettings(child, settings)
+
+    def _load_widget_state_qsettings(self, widget: QWidget, settings: QSettings):
+        """
+        Load the state of the widget from QSettings.
+
+        Args:
+            widget(QWidget): The widget to load the state for.
+            settings(QSettings): The QSettings object to load the state from.
+        """
+        meta = widget.metaObject()
+        settings.beginGroup(widget.objectName())
+        for i in range(meta.propertyCount()):
+            prop = meta.property(i)
+            name = prop.name()
+            if settings.contains(name):
+                value = settings.value(name)
+                widget.setProperty(name, value)
+        settings.endGroup()
+
+        # Recursively load child widgets
+        for child in widget.findChildren(QWidget):
+            if child.objectName():
+                self._load_widget_state_qsettings(child, settings)
+
+
+class ExampleApp(QWidget):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self.setObjectName("MainWindow")
+        self.setWindowTitle("State Manager Example")
+
+        layout = QVBoxLayout(self)
+
+        # A line edit to store some user text
+        self.line_edit = QLineEdit(self)
+        self.line_edit.setObjectName("MyLineEdit")
+        self.line_edit.setPlaceholderText("Enter some text here...")
+        layout.addWidget(self.line_edit)
+
+        # A spin box to hold a numeric value
+        self.spin_box = QSpinBox(self)
+        self.spin_box.setObjectName("MySpinBox")
+        self.spin_box.setRange(0, 100)
+        layout.addWidget(self.spin_box)
+
+        # A checkbox to hold a boolean value
+        self.check_box = QCheckBox("Enable feature?", self)
+        self.check_box.setObjectName("MyCheckBox")
+        layout.addWidget(self.check_box)
+
+        # Buttons to save and load state
+        button_layout = QHBoxLayout()
+        self.save_button = QPushButton("Save State", self)
+        self.load_button = QPushButton("Load State", self)
+        button_layout.addWidget(self.save_button)
+        button_layout.addWidget(self.load_button)
+        layout.addLayout(button_layout)
+
+        # Create the state manager
+        self.state_manager = WidgetStateManager(self)
+
+        # Connect buttons
+        self.save_button.clicked.connect(lambda: self.state_manager.save_state())
+        self.load_button.clicked.connect(lambda: self.state_manager.load_state())
+
+
+if __name__ == "__main__":  # pragma: no cover:
+    import sys
+
+    app = QApplication(sys.argv)
+    w = ExampleApp()
+    w.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/containers/dock/dock.py

@@ -6,7 +6,7 @@ from pydantic import Field
 from pyqtgraph.dockarea import Dock, DockLabel
 from qtpy import QtCore, QtGui
 
-from bec_widgets.cli.rpc_wigdet_handler import widget_handler
+from bec_widgets.cli.rpc.rpc_widget_handler import widget_handler
 from bec_widgets.utils import ConnectionConfig, GridLayoutManager
 from bec_widgets.utils.bec_widget import BECWidget
 

bec_widgets/widgets/containers/dock/dock_area.py

@@ -3,11 +3,12 @@ from __future__ import annotations
 from typing import Literal, Optional
 from weakref import WeakValueDictionary
 
+from bec_lib.endpoints import MessageEndpoints
 from pydantic import Field
 from pyqtgraph.dockarea.DockArea import DockArea
-from qtpy.QtCore import Qt
+from qtpy.QtCore import QSize, Qt
 from qtpy.QtGui import QPainter, QPaintEvent
-from qtpy.QtWidgets import QSizePolicy, QVBoxLayout, QWidget
+from qtpy.QtWidgets import QApplication, QSizePolicy, QVBoxLayout, QWidget
 
 from bec_widgets.qt_utils.error_popups import SafeSlot
 from bec_widgets.qt_utils.toolbar import (
@@ -19,7 +20,7 @@ from bec_widgets.qt_utils.toolbar import (
 from bec_widgets.utils import ConnectionConfig, WidgetContainerUtils
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.widgets.containers.dock.dock import BECDock, DockConfig
-from bec_widgets.widgets.control.device_control.positioner_box.positioner_box import PositionerBox
+from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
 from bec_widgets.widgets.control.scan_control.scan_control import ScanControl
 from bec_widgets.widgets.editors.vscode.vscode import VSCodeEditor
 from bec_widgets.widgets.plots.image.image_widget import BECImageWidget
@@ -43,6 +44,7 @@ class BECDockArea(BECWidget, QWidget):
     PLUGIN = True
     USER_ACCESS = [
         "_config_dict",
+        "selected_device",
         "panels",
         "save_state",
         "remove_dock",
@@ -55,6 +57,7 @@ class BECDockArea(BECWidget, QWidget):
         "temp_areas",
         "show",
         "hide",
+        "delete",
     ]
 
     def __init__(
@@ -158,6 +161,9 @@ class BECDockArea(BECWidget, QWidget):
         self.toolbar.addWidget(DarkModeButton(toolbar=True))
         self._hook_toolbar()
 
+    def minimumSizeHint(self):
+        return QSize(800, 600)
+
     def _hook_toolbar(self):
         # Menu Plot
         self.toolbar.widgets["menu_plots"].widgets["waveform"].triggered.connect(
@@ -210,6 +216,17 @@ class BECDockArea(BECWidget, QWidget):
                 "Add docks using 'add_dock' method from CLI\n or \n Add widget docks using the toolbar",
             )
 
+    @property
+    def selected_device(self) -> str:
+        gui_id = QApplication.instance().gui_id
+        auto_update_config = self.client.connector.get(
+            MessageEndpoints.gui_auto_update_config(gui_id)
+        )
+        try:
+            return auto_update_config.selected_device
+        except AttributeError:
+            return None
+
     @property
     def panels(self) -> dict[str, BECDock]:
         """
@@ -406,6 +423,17 @@ class BECDockArea(BECWidget, QWidget):
         self.dock_area.deleteLater()
         super().cleanup()
 
+    def closeEvent(self, event):
+        if self.parent() is None:
+            # we are at top-level (independent window)
+            if self.isVisible():
+                # we are visible => user clicked on [X]
+                # (when closeEvent is called from shutdown procedure,
+                # everything is hidden first)
+                # so, let's ignore "close", and do hide instead
+                event.ignore()
+                self.setVisible(False)
+
     def close(self):
         """
         Close the dock area and cleanup.
@@ -418,14 +446,24 @@ class BECDockArea(BECWidget, QWidget):
         """Show all windows including floating docks."""
         super().show()
         for docks in self.panels.values():
+            if docks.window() is self:
+                # avoid recursion
+                continue
             docks.window().show()
 
     def hide(self):
         """Hide all windows including floating docks."""
         super().hide()
         for docks in self.panels.values():
+            if docks.window() is self:
+                # avoid recursion
+                continue
             docks.window().hide()
 
+    def delete(self):
+        self.hide()
+        self.deleteLater()
+
 
 if __name__ == "__main__":
     from qtpy.QtWidgets import QApplication

bec_widgets/widgets/containers/layout_manager/layout_manager.py

@@ -0,0 +1,881 @@
+import math
+import sys
+from typing import Dict, Literal, Optional, Set, Tuple, Union
+
+from qtpy.QtWidgets import (
+    QApplication,
+    QComboBox,
+    QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QMainWindow,
+    QMessageBox,
+    QPushButton,
+    QSpinBox,
+    QSplitter,
+    QVBoxLayout,
+    QWidget,
+)
+from typeguard import typechecked
+
+from bec_widgets.cli.rpc.rpc_widget_handler import widget_handler
+
+
+class LayoutManagerWidget(QWidget):
+    """
+    A robust layout manager that extends QGridLayout functionality, allowing
+    users to add/remove widgets, access widgets by coordinates, shift widgets,
+    and change the layout dynamically with automatic reindexing to keep the grid compact.
+
+    Supports adding widgets via QWidget instances or string identifiers referencing the widget handler.
+    """
+
+    def __init__(self, parent=None, auto_reindex=True):
+        super().__init__(parent)
+        self.layout = QGridLayout(self)
+        self.auto_reindex = auto_reindex
+
+        # Mapping from widget to its position (row, col, rowspan, colspan)
+        self.widget_positions: Dict[QWidget, Tuple[int, int, int, int]] = {}
+
+        # Mapping from (row, col) to widget
+        self.position_widgets: Dict[Tuple[int, int], QWidget] = {}
+
+        # Keep track of the current position for automatic placement
+        self.current_row = 0
+        self.current_col = 0
+
+    def add_widget(
+        self,
+        widget: QWidget | str,
+        row: int | None = None,
+        col: Optional[int] = None,
+        rowspan: int = 1,
+        colspan: int = 1,
+        shift_existing: bool = True,
+        shift_direction: Literal["down", "up", "left", "right"] = "right",
+    ) -> QWidget:
+        """
+        Add a widget to the grid with enhanced shifting capabilities.
+
+        Args:
+            widget (QWidget | str): The widget to add. If str, it is used to create a widget via widget_handler.
+            row (int, optional): The row to add the widget to. If None, the next available row is used.
+            col (int, optional): The column to add the widget to. If None, the next available column is used.
+            rowspan (int): Number of rows the widget spans. Default is 1.
+            colspan (int): Number of columns the widget spans. Default is 1.
+            shift_existing (bool): Whether to shift existing widgets if the target position is occupied. Default is True.
+            shift_direction (Literal["down", "up", "left", "right"]): Direction to shift existing widgets. Default is "right".
+
+        Returns:
+            QWidget: The widget that was added.
+        """
+        # Handle widget creation if a BECWidget string identifier is provided
+        if isinstance(widget, str):
+            widget = widget_handler.create_widget(widget)
+
+        if row is None:
+            row = self.current_row
+        if col is None:
+            col = self.current_col
+
+        if (row, col) in self.position_widgets:
+            if shift_existing:
+                # Attempt to shift the existing widget in the specified direction
+                self.shift_widgets(direction=shift_direction, start_row=row, start_col=col)
+            else:
+                raise ValueError(f"Position ({row}, {col}) is already occupied.")
+
+            # Add the widget to the layout
+        self.layout.addWidget(widget, row, col, rowspan, colspan)
+        self.widget_positions[widget] = (row, col, rowspan, colspan)
+        self.position_widgets[(row, col)] = widget
+
+        # Update current position for automatic placement
+        self.current_col = col + colspan
+        self.current_row = max(self.current_row, row)
+
+        if self.auto_reindex:
+            self.reindex_grid()
+
+        return widget
+
+    def add_widget_relative(
+        self,
+        widget: QWidget | str,
+        reference_widget: QWidget,
+        position: Literal["left", "right", "top", "bottom"],
+        rowspan: int = 1,
+        colspan: int = 1,
+        shift_existing: bool = True,
+        shift_direction: Literal["down", "up", "left", "right"] = "right",
+    ) -> QWidget:
+        """
+        Add a widget relative to an existing widget.
+
+        Args:
+            widget (QWidget | str): The widget to add. If str, it is used to create a widget via widget_handler.
+            reference_widget (QWidget): The widget relative to which the new widget will be placed.
+            position (Literal["left", "right", "top", "bottom"]): Position relative to the reference widget.
+            rowspan (int): Number of rows the widget spans. Default is 1.
+            colspan (int): Number of columns the widget spans. Default is 1.
+            shift_existing (bool): Whether to shift existing widgets if the target position is occupied.
+            shift_direction (Literal["down", "up", "left", "right"]): Direction to shift existing widgets.
+
+        Returns:
+            QWidget: The widget that was added.
+
+        Raises:
+            ValueError: If the reference widget is not found.
+        """
+        if reference_widget not in self.widget_positions:
+            raise ValueError("Reference widget not found in layout.")
+
+        ref_row, ref_col, ref_rowspan, ref_colspan = self.widget_positions[reference_widget]
+
+        # Determine new widget position based on the specified relative position
+        if position == "left":
+            new_row = ref_row
+            new_col = ref_col - 1
+        elif position == "right":
+            new_row = ref_row
+            new_col = ref_col + ref_colspan
+        elif position == "top":
+            new_row = ref_row - 1
+            new_col = ref_col
+        elif position == "bottom":
+            new_row = ref_row + ref_rowspan
+            new_col = ref_col
+        else:
+            raise ValueError("Invalid position. Choose from 'left', 'right', 'top', 'bottom'.")
+
+        # Add the widget at the calculated position
+        return self.add_widget(
+            widget=widget,
+            row=new_row,
+            col=new_col,
+            rowspan=rowspan,
+            colspan=colspan,
+            shift_existing=shift_existing,
+            shift_direction=shift_direction,
+        )
+
+    def move_widget_by_coords(
+        self,
+        current_row: int,
+        current_col: int,
+        new_row: int,
+        new_col: int,
+        shift: bool = True,
+        shift_direction: Literal["down", "up", "left", "right"] = "right",
+    ) -> None:
+        """
+        Move a widget from (current_row, current_col) to (new_row, new_col).
+
+        Args:
+            current_row (int): Current row of the widget.
+            current_col (int): Current column of the widget.
+            new_row (int): Target row.
+            new_col (int): Target column.
+            shift (bool): Whether to shift existing widgets if the target position is occupied.
+            shift_direction (Literal["down", "up", "left", "right"]): Direction to shift existing widgets.
+
+        Raises:
+            ValueError: If the widget is not found or target position is invalid.
+        """
+        self.move_widget(
+            old_row=current_row,
+            old_col=current_col,
+            new_row=new_row,
+            new_col=new_col,
+            shift=shift,
+            shift_direction=shift_direction,
+        )
+
+    @typechecked
+    def move_widget_by_object(
+        self,
+        widget: QWidget,
+        new_row: int,
+        new_col: int,
+        shift: bool = True,
+        shift_direction: Literal["down", "up", "left", "right"] = "right",
+    ) -> None:
+        """
+        Move a widget to a new position using the widget object.
+
+        Args:
+            widget (QWidget): The widget to move.
+            new_row (int): Target row.
+            new_col (int): Target column.
+            shift (bool): Whether to shift existing widgets if the target position is occupied.
+            shift_direction (Literal["down", "up", "left", "right"]): Direction to shift existing widgets.
+
+        Raises:
+            ValueError: If the widget is not found or target position is invalid.
+        """
+        if widget not in self.widget_positions:
+            raise ValueError("Widget not found in layout.")
+
+        old_position = self.widget_positions[widget]
+        old_row, old_col = old_position[0], old_position[1]
+
+        self.move_widget(
+            old_row=old_row,
+            old_col=old_col,
+            new_row=new_row,
+            new_col=new_col,
+            shift=shift,
+            shift_direction=shift_direction,
+        )
+
+    @typechecked
+    def move_widget(
+        self,
+        old_row: int | None = None,
+        old_col: int | None = None,
+        new_row: int | None = None,
+        new_col: int | None = None,
+        shift: bool = True,
+        shift_direction: Literal["down", "up", "left", "right"] = "right",
+    ) -> None:
+        """
+        Move a widget to a new position. If the new position is occupied and shift is True,
+        shift the existing widget to the specified direction.
+
+        Args:
+            old_row (int, optional): The current row of the widget.
+            old_col (int, optional): The current column of the widget.
+            new_row (int, optional): The target row to move the widget to.
+            new_col (int, optional): The target column to move the widget to.
+            shift (bool): Whether to shift existing widgets if the target position is occupied.
+            shift_direction (Literal["down", "up", "left", "right"]): Direction to shift existing widgets.
+
+        Raises:
+            ValueError: If the widget is not found or target position is invalid.
+        """
+        if new_row is None or new_col is None:
+            raise ValueError("Must provide both new_row and new_col to move a widget.")
+
+        if old_row is None and old_col is None:
+            raise ValueError(f"No widget found at position ({old_row}, {old_col}).")
+        widget = self.get_widget(old_row, old_col)
+
+        if (new_row, new_col) in self.position_widgets:
+            if not shift:
+                raise ValueError(f"Position ({new_row}, {new_col}) is already occupied.")
+            # Shift the existing widget to make space
+            self.shift_widgets(
+                direction=shift_direction,
+                start_row=new_row if shift_direction in ["down", "up"] else 0,
+                start_col=new_col if shift_direction in ["left", "right"] else 0,
+            )
+
+        # Proceed to move the widget
+        self.layout.removeWidget(widget)
+        old_position = self.widget_positions.pop(widget)
+        self.position_widgets.pop((old_position[0], old_position[1]))
+
+        self.layout.addWidget(widget, new_row, new_col, old_position[2], old_position[3])
+        self.widget_positions[widget] = (new_row, new_col, old_position[2], old_position[3])
+        self.position_widgets[(new_row, new_col)] = widget
+
+        # Update current_row and current_col for automatic placement if needed
+        self.current_row = max(self.current_row, new_row)
+        self.current_col = max(self.current_col, new_col + old_position[3])
+
+        if self.auto_reindex:
+            self.reindex_grid()
+
+    @typechecked
+    def shift_widgets(
+        self,
+        direction: Literal["down", "up", "left", "right"],
+        start_row: int = 0,
+        start_col: int = 0,
+    ) -> None:
+        """
+        Shift widgets in the grid in the specified direction starting from the given position.
+
+        Args:
+            direction (Literal["down", "up", "left", "right"]): Direction to shift widgets.
+            start_row (int): Starting row index.
+            start_col (int): Starting column index.
+
+        Raises:
+            ValueError: If shifting causes widgets to go out of grid boundaries.
+        """
+        shifts = []
+        positions_to_shift = [(start_row, start_col)]
+        visited_positions = set()
+
+        while positions_to_shift:
+            row, col = positions_to_shift.pop(0)
+            if (row, col) in visited_positions:
+                continue
+            visited_positions.add((row, col))
+
+            widget = self.position_widgets.get((row, col))
+            if widget is None:
+                continue  # No widget at this position
+
+            # Compute new position based on the direction
+            if direction == "down":
+                new_row = row + 1
+                new_col = col
+            elif direction == "up":
+                new_row = row - 1
+                new_col = col
+            elif direction == "right":
+                new_row = row
+                new_col = col + 1
+            elif direction == "left":
+                new_row = row
+                new_col = col - 1
+
+            # Check for negative indices
+            if new_row < 0 or new_col < 0:
+                raise ValueError("Shifting widgets out of grid boundaries.")
+
+            # If the new position is occupied, add it to the positions to shift
+            if (new_row, new_col) in self.position_widgets:
+                positions_to_shift.append((new_row, new_col))
+
+            shifts.append(
+                (widget, (row, col), (new_row, new_col), self.widget_positions[widget][2:])
+            )
+
+        # Remove all widgets from their old positions
+        for widget, (old_row, old_col), _, _ in shifts:
+            self.layout.removeWidget(widget)
+            self.position_widgets.pop((old_row, old_col))
+
+        # Add widgets to their new positions
+        for widget, _, (new_row, new_col), (rowspan, colspan) in shifts:
+            self.layout.addWidget(widget, new_row, new_col, rowspan, colspan)
+            self.widget_positions[widget] = (new_row, new_col, rowspan, colspan)
+            self.position_widgets[(new_row, new_col)] = widget
+
+            # Update current_row and current_col if needed
+            self.current_row = max(self.current_row, new_row)
+            self.current_col = max(self.current_col, new_col + colspan)
+
+    def shift_all_widgets(self, direction: Literal["down", "up", "left", "right"]) -> None:
+        """
+        Shift all widgets in the grid in the specified direction to make room and prevent negative indices.
+
+        Args:
+            direction (Literal["down", "up", "left", "right"]): Direction to shift all widgets.
+        """
+        # First, collect all the shifts to perform
+        shifts = []
+        for widget, (row, col, rowspan, colspan) in self.widget_positions.items():
+
+            if direction == "down":
+                new_row = row + 1
+                new_col = col
+            elif direction == "up":
+                new_row = row - 1
+                new_col = col
+            elif direction == "right":
+                new_row = row
+                new_col = col + 1
+            elif direction == "left":
+                new_row = row
+                new_col = col - 1
+
+            # Check for negative indices
+            if new_row < 0 or new_col < 0:
+                raise ValueError("Shifting widgets out of grid boundaries.")
+
+            shifts.append((widget, (row, col), (new_row, new_col), (rowspan, colspan)))
+
+        # Now perform the shifts
+        for widget, (old_row, old_col), (new_row, new_col), (rowspan, colspan) in shifts:
+            self.layout.removeWidget(widget)
+            self.position_widgets.pop((old_row, old_col))
+
+        for widget, (old_row, old_col), (new_row, new_col), (rowspan, colspan) in shifts:
+            self.layout.addWidget(widget, new_row, new_col, rowspan, colspan)
+            self.widget_positions[widget] = (new_row, new_col, rowspan, colspan)
+            self.position_widgets[(new_row, new_col)] = widget
+
+        # Update current_row and current_col based on new widget positions
+        self.current_row = max((pos[0] for pos in self.position_widgets.keys()), default=0)
+        self.current_col = max((pos[1] for pos in self.position_widgets.keys()), default=0)
+
+    def remove(
+        self,
+        row: int | None = None,
+        col: int | None = None,
+        coordinates: Tuple[int, int] | None = None,
+    ) -> None:
+        """
+        Remove a widget from the layout. Can be removed by widget ID or by coordinates.
+
+        Args:
+            row (int, optional): The row coordinate of the widget to remove.
+            col (int, optional): The column coordinate of the widget to remove.
+            coordinates (tuple[int, int], optional): The (row, col) coordinates of the widget to remove.
+
+        Raises:
+            ValueError: If the widget to remove is not found.
+        """
+        if coordinates:
+            row, col = coordinates
+            widget = self.get_widget(row, col)
+            if widget is None:
+                raise ValueError(f"No widget found at coordinates {coordinates}.")
+        elif row is not None and col is not None:
+            widget = self.get_widget(row, col)
+            if widget is None:
+                raise ValueError(f"No widget found at position ({row}, {col}).")
+        else:
+            raise ValueError(
+                "Must provide either widget_id, coordinates, or both row and col for removal."
+            )
+
+        self.remove_widget(widget)
+
+    def remove_widget(self, widget: QWidget) -> None:
+        """
+        Remove a widget from the grid and reindex the grid to keep it compact.
+
+        Args:
+            widget (QWidget): The widget to remove.
+
+        Raises:
+            ValueError: If the widget is not found in the layout.
+        """
+        if widget not in self.widget_positions:
+            raise ValueError("Widget not found in layout.")
+
+        position = self.widget_positions.pop(widget)
+        self.position_widgets.pop((position[0], position[1]))
+        self.layout.removeWidget(widget)
+        widget.setParent(None)  # Remove widget from the parent
+        widget.deleteLater()
+
+        # Reindex the grid to maintain compactness
+        if self.auto_reindex:
+            self.reindex_grid()
+
+    def get_widget(self, row: int, col: int) -> QWidget | None:
+        """
+        Get the widget at the specified position.
+
+        Args:
+            row (int): The row coordinate.
+            col (int): The column coordinate.
+
+        Returns:
+            QWidget | None: The widget at the specified position, or None if empty.
+        """
+        return self.position_widgets.get((row, col))
+
+    def get_widget_position(self, widget: QWidget) -> Tuple[int, int, int, int] | None:
+        """
+        Get the position of the specified widget.
+
+        Args:
+            widget (QWidget): The widget to query.
+
+        Returns:
+            Tuple[int, int, int, int] | None: The (row, col, rowspan, colspan) tuple, or None if not found.
+        """
+        return self.widget_positions.get(widget)
+
+    def change_layout(self, num_rows: int | None = None, num_cols: int | None = None) -> None:
+        """
+        Change the layout to have a certain number of rows and/or columns,
+        rearranging the widgets accordingly.
+
+        If only one of num_rows or num_cols is provided, the other is calculated automatically
+        based on the number of widgets and the provided constraint.
+
+        If both are provided, num_rows is calculated based on num_cols.
+
+        Args:
+            num_rows (int | None): The new maximum number of rows.
+            num_cols (int | None): The new maximum number of columns.
+        """
+        if num_rows is None and num_cols is None:
+            return  # Nothing to change
+
+        total_widgets = len(self.widget_positions)
+
+        if num_cols is not None:
+            # Calculate num_rows based on num_cols
+            num_rows = math.ceil(total_widgets / num_cols)
+        elif num_rows is not None:
+            # Calculate num_cols based on num_rows
+            num_cols = math.ceil(total_widgets / num_rows)
+
+        # Sort widgets by current position (row-major order)
+        widgets_sorted = sorted(
+            self.widget_positions.items(),
+            key=lambda item: (item[1][0], item[1][1]),  # Sort by row, then column
+        )
+
+        # Clear the layout without deleting widgets
+        for widget, _ in widgets_sorted:
+            self.layout.removeWidget(widget)
+
+        # Reset position mappings
+        self.widget_positions.clear()
+        self.position_widgets.clear()
+
+        # Re-add widgets based on new layout constraints
+        current_row, current_col = 0, 0
+        for widget, _ in widgets_sorted:
+            if current_col >= num_cols:
+                current_col = 0
+                current_row += 1
+            self.layout.addWidget(widget, current_row, current_col, 1, 1)
+            self.widget_positions[widget] = (current_row, current_col, 1, 1)
+            self.position_widgets[(current_row, current_col)] = widget
+            current_col += 1
+
+        # Update current_row and current_col for automatic placement
+        self.current_row = current_row
+        self.current_col = current_col
+
+        # Reindex the grid to ensure compactness
+        self.reindex_grid()
+
+    def clear_layout(self) -> None:
+        """
+        Remove all widgets from the layout without deleting them.
+        """
+        for widget in list(self.widget_positions):
+            self.layout.removeWidget(widget)
+            self.position_widgets.pop(
+                (self.widget_positions[widget][0], self.widget_positions[widget][1])
+            )
+            self.widget_positions.pop(widget)
+            widget.setParent(None)  # Optionally hide/remove the widget
+
+        self.current_row = 0
+        self.current_col = 0
+
+    def reindex_grid(self) -> None:
+        """
+        Reindex the grid to remove empty rows and columns, ensuring that
+        widget coordinates are contiguous and start from (0, 0).
+        """
+        # Step 1: Collect all occupied positions
+        occupied_positions = sorted(self.position_widgets.keys())
+
+        if not occupied_positions:
+            # No widgets to reindex
+            self.clear_layout()
+            return
+
+        # Step 2: Determine the new mapping by eliminating empty columns and rows
+        # Find unique rows and columns
+        unique_rows = sorted(set(pos[0] for pos in occupied_positions))
+        unique_cols = sorted(set(pos[1] for pos in occupied_positions))
+
+        # Create mappings from old to new indices
+        row_mapping = {old_row: new_row for new_row, old_row in enumerate(unique_rows)}
+        col_mapping = {old_col: new_col for new_col, old_col in enumerate(unique_cols)}
+
+        # Step 3: Collect widgets with their new positions
+        widgets_with_new_positions = []
+        for widget, (row, col, rowspan, colspan) in self.widget_positions.items():
+            new_row = row_mapping[row]
+            new_col = col_mapping[col]
+            widgets_with_new_positions.append((widget, new_row, new_col, rowspan, colspan))
+
+        # Step 4: Clear the layout and reset mappings
+        self.clear_layout()
+
+        # Reset current_row and current_col
+        self.current_row = 0
+        self.current_col = 0
+
+        # Step 5: Re-add widgets with new positions
+        for widget, new_row, new_col, rowspan, colspan in widgets_with_new_positions:
+            self.layout.addWidget(widget, new_row, new_col, rowspan, colspan)
+            self.widget_positions[widget] = (new_row, new_col, rowspan, colspan)
+            self.position_widgets[(new_row, new_col)] = widget
+
+            # Update current position for automatic placement
+            self.current_col = max(self.current_col, new_col + colspan)
+            self.current_row = max(self.current_row, new_row)
+
+    def get_widgets_positions(self) -> Dict[QWidget, Tuple[int, int, int, int]]:
+        """
+        Get the positions of all widgets in the layout.
+
+        Returns:
+            Dict[QWidget, Tuple[int, int, int, int]]: Mapping of widgets to their (row, col, rowspan, colspan).
+        """
+        return self.widget_positions.copy()
+
+    def print_all_button_text(self):
+        """Debug function to print the text of all QPushButton widgets."""
+        print("Coordinates - Button Text")
+        for coord, widget in self.position_widgets.items():
+            if isinstance(widget, QPushButton):
+                print(f"{coord} - {widget.text()}")
+
+
+####################################################################################################
+# The following code is for the GUI control panel to interact with the LayoutManagerWidget.
+# It is not covered by any tests as it serves only as an example for the LayoutManagerWidget class.
+####################################################################################################
+
+
+class ControlPanel(QWidget):  # pragma: no cover
+    def __init__(self, layout_manager: LayoutManagerWidget):
+        super().__init__()
+        self.layout_manager = layout_manager
+        self.init_ui()
+
+    def init_ui(self):
+        main_layout = QVBoxLayout()
+
+        # Add Widget by Coordinates
+        add_coord_group = QGroupBox("Add Widget by Coordinates")
+        add_coord_layout = QGridLayout()
+
+        add_coord_layout.addWidget(QLabel("Text:"), 0, 0)
+        self.text_input = QLineEdit()
+        add_coord_layout.addWidget(self.text_input, 0, 1)
+
+        add_coord_layout.addWidget(QLabel("Row:"), 1, 0)
+        self.row_input = QSpinBox()
+        self.row_input.setMinimum(0)
+        add_coord_layout.addWidget(self.row_input, 1, 1)
+
+        add_coord_layout.addWidget(QLabel("Column:"), 2, 0)
+        self.col_input = QSpinBox()
+        self.col_input.setMinimum(0)
+        add_coord_layout.addWidget(self.col_input, 2, 1)
+
+        self.add_button = QPushButton("Add at Coordinates")
+        self.add_button.clicked.connect(self.add_at_coordinates)
+        add_coord_layout.addWidget(self.add_button, 3, 0, 1, 2)
+
+        add_coord_group.setLayout(add_coord_layout)
+        main_layout.addWidget(add_coord_group)
+
+        # Add Widget Relative
+        add_rel_group = QGroupBox("Add Widget Relative to Existing")
+        add_rel_layout = QGridLayout()
+
+        add_rel_layout.addWidget(QLabel("Text:"), 0, 0)
+        self.rel_text_input = QLineEdit()
+        add_rel_layout.addWidget(self.rel_text_input, 0, 1)
+
+        add_rel_layout.addWidget(QLabel("Reference Widget:"), 1, 0)
+        self.ref_widget_combo = QComboBox()
+        add_rel_layout.addWidget(self.ref_widget_combo, 1, 1)
+
+        add_rel_layout.addWidget(QLabel("Position:"), 2, 0)
+        self.position_combo = QComboBox()
+        self.position_combo.addItems(["left", "right", "top", "bottom"])
+        add_rel_layout.addWidget(self.position_combo, 2, 1)
+
+        self.add_rel_button = QPushButton("Add Relative")
+        self.add_rel_button.clicked.connect(self.add_relative)
+        add_rel_layout.addWidget(self.add_rel_button, 3, 0, 1, 2)
+
+        add_rel_group.setLayout(add_rel_layout)
+        main_layout.addWidget(add_rel_group)
+
+        # Remove Widget
+        remove_group = QGroupBox("Remove Widget")
+        remove_layout = QGridLayout()
+
+        remove_layout.addWidget(QLabel("Row:"), 0, 0)
+        self.remove_row_input = QSpinBox()
+        self.remove_row_input.setMinimum(0)
+        remove_layout.addWidget(self.remove_row_input, 0, 1)
+
+        remove_layout.addWidget(QLabel("Column:"), 1, 0)
+        self.remove_col_input = QSpinBox()
+        self.remove_col_input.setMinimum(0)
+        remove_layout.addWidget(self.remove_col_input, 1, 1)
+
+        self.remove_button = QPushButton("Remove at Coordinates")
+        self.remove_button.clicked.connect(self.remove_widget)
+        remove_layout.addWidget(self.remove_button, 2, 0, 1, 2)
+
+        remove_group.setLayout(remove_layout)
+        main_layout.addWidget(remove_group)
+
+        # Change Layout
+        change_layout_group = QGroupBox("Change Layout")
+        change_layout_layout = QGridLayout()
+
+        change_layout_layout.addWidget(QLabel("Number of Rows:"), 0, 0)
+        self.change_rows_input = QSpinBox()
+        self.change_rows_input.setMinimum(1)
+        self.change_rows_input.setValue(1)  # Default value
+        change_layout_layout.addWidget(self.change_rows_input, 0, 1)
+
+        change_layout_layout.addWidget(QLabel("Number of Columns:"), 1, 0)
+        self.change_cols_input = QSpinBox()
+        self.change_cols_input.setMinimum(1)
+        self.change_cols_input.setValue(1)  # Default value
+        change_layout_layout.addWidget(self.change_cols_input, 1, 1)
+
+        self.change_layout_button = QPushButton("Apply Layout Change")
+        self.change_layout_button.clicked.connect(self.change_layout)
+        change_layout_layout.addWidget(self.change_layout_button, 2, 0, 1, 2)
+
+        change_layout_group.setLayout(change_layout_layout)
+        main_layout.addWidget(change_layout_group)
+
+        # Remove All Widgets
+        self.clear_all_button = QPushButton("Clear All Widgets")
+        self.clear_all_button.clicked.connect(self.clear_all_widgets)
+        main_layout.addWidget(self.clear_all_button)
+
+        # Refresh Reference Widgets and Print Button
+        self.refresh_button = QPushButton("Refresh Reference Widgets")
+        self.refresh_button.clicked.connect(self.refresh_references)
+        self.print_button = QPushButton("Print All Button Text")
+        self.print_button.clicked.connect(self.layout_manager.print_all_button_text)
+        main_layout.addWidget(self.refresh_button)
+        main_layout.addWidget(self.print_button)
+
+        main_layout.addStretch()
+        self.setLayout(main_layout)
+        self.refresh_references()
+
+    def refresh_references(self):
+        self.ref_widget_combo.clear()
+        widgets = self.layout_manager.get_widgets_positions()
+        for widget in widgets:
+            if isinstance(widget, QPushButton):
+                self.ref_widget_combo.addItem(widget.text(), widget)
+
+    def add_at_coordinates(self):
+        text = self.text_input.text()
+        row = self.row_input.value()
+        col = self.col_input.value()
+
+        if not text:
+            QMessageBox.warning(self, "Input Error", "Please enter text for the button.")
+            return
+
+        button = QPushButton(text)
+        try:
+            self.layout_manager.add_widget(widget=button, row=row, col=col)
+            self.refresh_references()
+        except Exception as e:
+            QMessageBox.critical(self, "Error", str(e))
+
+    def add_relative(self):
+        text = self.rel_text_input.text()
+        ref_index = self.ref_widget_combo.currentIndex()
+        ref_widget = self.ref_widget_combo.itemData(ref_index)
+        position = self.position_combo.currentText()
+
+        if not text:
+            QMessageBox.warning(self, "Input Error", "Please enter text for the button.")
+            return
+
+        if ref_widget is None:
+            QMessageBox.warning(self, "Input Error", "Please select a reference widget.")
+            return
+
+        button = QPushButton(text)
+        try:
+            self.layout_manager.add_widget_relative(
+                widget=button, reference_widget=ref_widget, position=position
+            )
+            self.refresh_references()
+        except Exception as e:
+            QMessageBox.critical(self, "Error", str(e))
+
+    def remove_widget(self):
+        row = self.remove_row_input.value()
+        col = self.remove_col_input.value()
+
+        try:
+            widget = self.layout_manager.get_widget(row, col)
+            if widget is None:
+                QMessageBox.warning(self, "Not Found", f"No widget found at ({row}, {col}).")
+                return
+            self.layout_manager.remove_widget(widget)
+            self.refresh_references()
+        except Exception as e:
+            QMessageBox.critical(self, "Error", str(e))
+
+    def change_layout(self):
+        num_rows = self.change_rows_input.value()
+        num_cols = self.change_cols_input.value()
+
+        try:
+            self.layout_manager.change_layout(num_rows=num_rows, num_cols=num_cols)
+            self.refresh_references()
+        except Exception as e:
+            QMessageBox.critical(self, "Error", str(e))
+
+    def clear_all_widgets(self):
+        reply = QMessageBox.question(
+            self,
+            "Confirm Clear",
+            "Are you sure you want to remove all widgets?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No,
+        )
+
+        if reply == QMessageBox.Yes:
+            try:
+                self.layout_manager.clear_layout()
+                self.refresh_references()
+            except Exception as e:
+                QMessageBox.critical(self, "Error", str(e))
+
+
+class MainWindow(QMainWindow):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Layout Manager Demo")
+        self.resize(800, 600)
+        self.init_ui()
+
+    def init_ui(self):
+        central_widget = QWidget()
+        main_layout = QHBoxLayout()
+
+        # Layout Area GroupBox
+        layout_group = QGroupBox("Layout Area")
+        layout_group.setMinimumSize(400, 400)
+        layout_layout = QVBoxLayout()
+
+        self.layout_manager = LayoutManagerWidget()
+        layout_layout.addWidget(self.layout_manager)
+
+        layout_group.setLayout(layout_layout)
+
+        # Splitter
+        splitter = QSplitter()
+        splitter.addWidget(layout_group)
+
+        # Control Panel
+        control_panel = ControlPanel(self.layout_manager)
+        control_group = QGroupBox("Control Panel")
+        control_layout = QVBoxLayout()
+        control_layout.addWidget(control_panel)
+        control_layout.addStretch()
+        control_group.setLayout(control_layout)
+        splitter.addWidget(control_group)
+
+        main_layout.addWidget(splitter)
+        central_widget.setLayout(main_layout)
+        self.setCentralWidget(central_widget)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication(sys.argv)
+    window = MainWindow()
+    window.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/containers/main_window/main_window.py

@@ -1,9 +1,41 @@
-from qtpy.QtWidgets import QMainWindow
+from qtpy.QtWidgets import QApplication, QMainWindow
 
 from bec_widgets.utils import BECConnector
+from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
 
 
 class BECMainWindow(QMainWindow, BECConnector):
     def __init__(self, *args, **kwargs):
         BECConnector.__init__(self, **kwargs)
         QMainWindow.__init__(self, *args, **kwargs)
+
+    def _dump(self):
+        """Return a dictionary with informations about the application state, for use in tests"""
+        # TODO: ModularToolBar and something else leak top-level widgets (3 or 4 QMenu + 2 QWidget);
+        # so, a filtering based on title is applied here, but the solution is to not have those widgets
+        # as top-level (so for now, a window with no title does not appear in _dump() result)
+
+        # NOTE: the main window itself is excluded, since we want to dump dock areas
+        info = {
+            tlw.gui_id: {
+                "title": tlw.windowTitle(),
+                "visible": tlw.isVisible(),
+                "class": str(type(tlw)),
+            }
+            for tlw in QApplication.instance().topLevelWidgets()
+            if tlw is not self and tlw.windowTitle()
+        }
+        # Add the main window dock area
+        info[self.centralWidget().gui_id] = {
+            "title": self.windowTitle(),
+            "visible": self.isVisible(),
+            "class": str(type(self.centralWidget())),
+        }
+        return info
+
+    def new_dock_area(self, name):
+        dock_area = BECDockArea()
+        dock_area.resize(dock_area.minimumSizeHint())
+        dock_area.window().setWindowTitle(name)
+        dock_area.show()
+        return dock_area

bec_widgets/widgets/control/device_control/positioner_box/__init__.py

@@ -0,0 +1,11 @@
+from bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box import (
+    PositionerBox,
+)
+from bec_widgets.widgets.control.device_control.positioner_box.positioner_box_2d.positioner_box_2d import (
+    PositionerBox2D,
+)
+from bec_widgets.widgets.control.device_control.positioner_box.positioner_control_line.positioner_control_line import (
+    PositionerControlLine,
+)
+
+__ALL__ = ["PositionerBox", "PositionerControlLine", "PositionerBox2D"]

bec_widgets/widgets/control/device_control/positioner_box/_base/__init__.py

@@ -0,0 +1,3 @@
+from .positioner_box_base import PositionerBoxBase
+
+__ALL__ = ["PositionerBoxBase"]

bec_widgets/widgets/control/device_control/positioner_box/_base/positioner_box_base.py

@@ -0,0 +1,243 @@
+import uuid
+from abc import abstractmethod
+from ast import Tuple
+from typing import Callable, TypedDict
+
+from bec_lib.device import Positioner
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from bec_lib.messages import ScanQueueMessage
+from qtpy.QtWidgets import (
+    QDialog,
+    QDoubleSpinBox,
+    QGroupBox,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QVBoxLayout,
+)
+
+from bec_widgets.qt_utils.compact_popup import CompactPopupWidget
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.widgets.control.device_control.position_indicator.position_indicator import (
+    PositionIndicator,
+)
+from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
+from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
+    DeviceLineEdit,
+)
+from bec_widgets.widgets.utility.spinner.spinner import SpinnerWidget
+
+logger = bec_logger.logger
+
+
+class DeviceUpdateUIComponents(TypedDict):
+    spinner: SpinnerWidget
+    setpoint: QLineEdit
+    readback: QLabel
+    position_indicator: PositionIndicator
+    step_size: QDoubleSpinBox
+    device_box: QGroupBox
+    stop: QPushButton
+    tweak_increase: QPushButton
+    tweak_decrease: QPushButton
+
+
+class PositionerBoxBase(BECWidget, CompactPopupWidget):
+    """Contains some core logic for positioner box widgets"""
+
+    current_path = ""
+    ICON_NAME = "switch_right"
+
+    def __init__(self, parent=None, **kwargs):
+        """Initialize the PositionerBox widget.
+
+        Args:
+            parent: The parent widget.
+            device (Positioner): The device to control.
+        """
+        super().__init__(**kwargs)
+        CompactPopupWidget.__init__(self, parent=parent, layout=QVBoxLayout)
+        self._dialog = None
+        self.get_bec_shortcuts()
+
+    def _check_device_is_valid(self, device: str):
+        """Check if the device is a positioner
+
+        Args:
+            device (str): The device name
+        """
+        if device not in self.dev:
+            logger.info(f"Device {device} not found in the device list")
+            return False
+        if not isinstance(self.dev[device], Positioner):
+            logger.info(f"Device {device} is not a positioner")
+            return False
+        return True
+
+    @abstractmethod
+    def _device_ui_components(self, device: str) -> DeviceUpdateUIComponents: ...
+
+    def _init_device(
+        self,
+        device: str,
+        position_emit: Callable[[float], None],
+        limit_update: Callable[[tuple[float, float]], None],
+    ):
+        """Init the device view and readback"""
+        if self._check_device_is_valid(device):
+            data = self.dev[device].read()
+            self._on_device_readback(
+                device,
+                self._device_ui_components(device),
+                {"signals": data},
+                {},
+                position_emit,
+                limit_update,
+            )
+
+    def _stop_device(self, device: str):
+        """Stop call"""
+        request_id = str(uuid.uuid4())
+        params = {"device": device, "rpc_id": request_id, "func": "stop", "args": [], "kwargs": {}}
+        msg = ScanQueueMessage(
+            scan_type="device_rpc",
+            parameter=params,
+            queue="emergency",
+            metadata={"RID": request_id, "response": False},
+        )
+        self.client.connector.send(MessageEndpoints.scan_queue_request(), msg)
+
+    # pylint: disable=unused-argument
+    def _on_device_readback(
+        self,
+        device: str,
+        ui_components: DeviceUpdateUIComponents,
+        msg_content: dict,
+        metadata: dict,
+        position_emit: Callable[[float], None],
+        limit_update: Callable[[tuple[float, float]], None],
+    ):
+        signals = msg_content.get("signals", {})
+        # pylint: disable=protected-access
+        hinted_signals = self.dev[device]._hints
+        precision = self.dev[device].precision
+
+        spinner = ui_components["spinner"]
+        position_indicator = ui_components["position_indicator"]
+        readback = ui_components["readback"]
+        setpoint = ui_components["setpoint"]
+
+        readback_val = None
+        setpoint_val = None
+
+        if len(hinted_signals) == 1:
+            signal = hinted_signals[0]
+            readback_val = signals.get(signal, {}).get("value")
+
+        for setpoint_signal in ["setpoint", "user_setpoint"]:
+            setpoint_val = signals.get(f"{device}_{setpoint_signal}", {}).get("value")
+            if setpoint_val is not None:
+                break
+
+        for moving_signal in ["motor_done_move", "motor_is_moving"]:
+            is_moving = signals.get(f"{device}_{moving_signal}", {}).get("value")
+            if is_moving is not None:
+                break
+
+        if is_moving is not None:
+            spinner.setVisible(True)
+            if is_moving:
+                spinner.start()
+                spinner.setToolTip("Device is moving")
+                self.set_global_state("warning")
+            else:
+                spinner.stop()
+                spinner.setToolTip("Device is idle")
+                self.set_global_state("success")
+        else:
+            spinner.setVisible(False)
+
+        if readback_val is not None:
+            readback.setText(f"{readback_val:.{precision}f}")
+            position_emit(readback_val)
+
+        if setpoint_val is not None:
+            setpoint.setText(f"{setpoint_val:.{precision}f}")
+
+        limits = self.dev[device].limits
+        limit_update(limits)
+        if limits is not None and readback_val is not None and limits[0] != limits[1]:
+            pos = (readback_val - limits[0]) / (limits[1] - limits[0])
+            position_indicator.set_value(pos)
+
+    def _update_limits_ui(
+        self, limits: tuple[float, float], position_indicator, setpoint_validator
+    ):
+        if limits is not None and limits[0] != limits[1]:
+            position_indicator.setToolTip(f"Min: {limits[0]}, Max: {limits[1]}")
+            setpoint_validator.setRange(limits[0], limits[1])
+        else:
+            position_indicator.setToolTip("No limits set")
+            setpoint_validator.setRange(float("-inf"), float("inf"))
+
+    def _update_device_ui(self, device: str, ui: DeviceUpdateUIComponents):
+        ui["device_box"].setTitle(device)
+        ui["readback"].setToolTip(f"{device} readback")
+        ui["setpoint"].setToolTip(f"{device} setpoint")
+        ui["step_size"].setToolTip(f"Step size for {device}")
+        precision = self.dev[device].precision
+        if precision is not None:
+            ui["step_size"].setDecimals(precision)
+            ui["step_size"].setValue(10**-precision * 10)
+
+    def _swap_readback_signal_connection(self, slot, old_device, new_device):
+        self.bec_dispatcher.disconnect_slot(slot, MessageEndpoints.device_readback(old_device))
+        self.bec_dispatcher.connect_slot(slot, MessageEndpoints.device_readback(new_device))
+
+    def _toggle_enable_buttons(self, ui: DeviceUpdateUIComponents, enable: bool) -> None:
+        """Toogle enable/disable on available buttons
+
+        Args:
+            enable (bool): Enable buttons
+        """
+        ui["tweak_increase"].setEnabled(enable)
+        ui["tweak_decrease"].setEnabled(enable)
+        ui["stop"].setEnabled(enable)
+        ui["setpoint"].setEnabled(enable)
+        ui["step_size"].setEnabled(enable)
+
+    def _on_device_change(
+        self,
+        old_device: str,
+        new_device: str,
+        position_emit: Callable[[float], None],
+        limit_update: Callable[[tuple[float, float]], None],
+        on_device_readback: Callable,
+        ui: DeviceUpdateUIComponents,
+    ):
+        logger.info(f"Device changed from {old_device} to {new_device}")
+        self._toggle_enable_buttons(ui, True)
+        self._init_device(new_device, position_emit, limit_update)
+        self._swap_readback_signal_connection(on_device_readback, old_device, new_device)
+        self._update_device_ui(new_device, ui)
+
+    def _open_dialog_selection(self, set_positioner: Callable):
+        def _ods():
+            """Open dialog window for positioner selection"""
+            self._dialog = QDialog(self)
+            self._dialog.setWindowTitle("Positioner Selection")
+            layout = QVBoxLayout()
+            line_edit = DeviceLineEdit(
+                self, client=self.client, device_filter=[BECDeviceFilter.POSITIONER]
+            )
+            line_edit.textChanged.connect(set_positioner)
+            layout.addWidget(line_edit)
+            close_button = QPushButton("Close")
+            close_button.clicked.connect(self._dialog.accept)
+            layout.addWidget(close_button)
+            self._dialog.setLayout(layout)
+            self._dialog.exec()
+            self._dialog = None
+
+        return _ods

bec_widgets/widgets/control/device_control/positioner_box/positioner_box.py

@@ -1,352 +0,0 @@
-""" Module for a PositionerBox widget to control a positioner device."""
-
-from __future__ import annotations
-
-import os
-import uuid
-
-from bec_lib.device import Positioner
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.logger import bec_logger
-from bec_lib.messages import ScanQueueMessage
-from bec_qthemes import material_icon
-from qtpy.QtCore import Property, Signal, Slot
-from qtpy.QtGui import QDoubleValidator
-from qtpy.QtWidgets import QDialog, QDoubleSpinBox, QPushButton, QVBoxLayout
-
-from bec_widgets.qt_utils.compact_popup import CompactPopupWidget
-from bec_widgets.utils import UILoader
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import get_accent_colors, set_theme
-from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
-from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
-    DeviceLineEdit,
-)
-
-logger = bec_logger.logger
-
-MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-
-
-class PositionerBox(BECWidget, CompactPopupWidget):
-    """Simple Widget to control a positioner in box form"""
-
-    ui_file = "positioner_box.ui"
-    dimensions = (234, 224)
-
-    PLUGIN = True
-    ICON_NAME = "switch_right"
-    USER_ACCESS = ["set_positioner"]
-    device_changed = Signal(str, str)
-    # Signal emitted to inform listeners about a position update
-    position_update = Signal(float)
-
-    def __init__(self, parent=None, device: Positioner = None, **kwargs):
-        """Initialize the PositionerBox widget.
-
-        Args:
-            parent: The parent widget.
-            device (Positioner): The device to control.
-        """
-        super().__init__(**kwargs)
-        CompactPopupWidget.__init__(self, parent=parent, layout=QVBoxLayout)
-        self.get_bec_shortcuts()
-        self._device = ""
-        self._limits = None
-        self._dialog = None
-
-        self.init_ui()
-
-        if device is not None:
-            self.device = device
-            self.init_device()
-
-    def init_ui(self):
-        """Init the ui"""
-        self.device_changed.connect(self.on_device_change)
-
-        current_path = os.path.dirname(__file__)
-        self.ui = UILoader(self).loader(os.path.join(current_path, self.ui_file))
-
-        self.addWidget(self.ui)
-        self.layout.setSpacing(0)
-        self.layout.setContentsMargins(0, 0, 0, 0)
-
-        # fix the size of the device box
-        db = self.ui.device_box
-        db.setFixedHeight(self.dimensions[0])
-        db.setFixedWidth(self.dimensions[1])
-
-        self.ui.step_size.setStepType(QDoubleSpinBox.AdaptiveDecimalStepType)
-        self.ui.stop.clicked.connect(self.on_stop)
-        self.ui.stop.setToolTip("Stop")
-        self.ui.stop.setStyleSheet(
-            f"QPushButton {{background-color: {get_accent_colors().emergency.name()}; color: white;}}"
-        )
-        self.ui.tweak_right.clicked.connect(self.on_tweak_right)
-        self.ui.tweak_right.setToolTip("Tweak right")
-        self.ui.tweak_left.clicked.connect(self.on_tweak_left)
-        self.ui.tweak_left.setToolTip("Tweak left")
-        self.ui.setpoint.returnPressed.connect(self.on_setpoint_change)
-
-        self.setpoint_validator = QDoubleValidator()
-        self.ui.setpoint.setValidator(self.setpoint_validator)
-        self.ui.spinner_widget.start()
-        self.ui.tool_button.clicked.connect(self._open_dialog_selection)
-        icon = material_icon(icon_name="edit_note", size=(16, 16), convert_to_pixmap=False)
-        self.ui.tool_button.setIcon(icon)
-
-    def _open_dialog_selection(self):
-        """Open dialog window for positioner selection"""
-        self._dialog = QDialog(self)
-        self._dialog.setWindowTitle("Positioner Selection")
-        layout = QVBoxLayout()
-        line_edit = DeviceLineEdit(
-            self, client=self.client, device_filter=[BECDeviceFilter.POSITIONER]
-        )
-        line_edit.textChanged.connect(self.set_positioner)
-        layout.addWidget(line_edit)
-        close_button = QPushButton("Close")
-        close_button.clicked.connect(self._dialog.accept)
-        layout.addWidget(close_button)
-        self._dialog.setLayout(layout)
-        self._dialog.exec()
-        self._dialog = None
-
-    def init_device(self):
-        """Init the device view and readback"""
-        if self._check_device_is_valid(self.device):
-            data = self.dev[self.device].read()
-            self.on_device_readback({"signals": data}, {})
-
-    def _toogle_enable_buttons(self, enable: bool) -> None:
-        """Toogle enable/disable on available buttons
-
-        Args:
-            enable (bool): Enable buttons
-        """
-        self.ui.tweak_left.setEnabled(enable)
-        self.ui.tweak_right.setEnabled(enable)
-        self.ui.stop.setEnabled(enable)
-        self.ui.setpoint.setEnabled(enable)
-        self.ui.step_size.setEnabled(enable)
-
-    @Property(str)
-    def device(self):
-        """Property to set the device"""
-        return self._device
-
-    @device.setter
-    def device(self, value: str):
-        """Setter, checks if device is a string"""
-        if not value or not isinstance(value, str):
-            return
-        if not self._check_device_is_valid(value):
-            return
-        old_device = self._device
-        self._device = value
-        if not self.label:
-            self.label = value
-        self.device_changed.emit(old_device, value)
-
-    @Property(bool)
-    def hide_device_selection(self):
-        """Hide the device selection"""
-        return not self.ui.tool_button.isVisible()
-
-    @hide_device_selection.setter
-    def hide_device_selection(self, value: bool):
-        """Set the device selection visibility"""
-        self.ui.tool_button.setVisible(not value)
-
-    @Slot(bool)
-    def show_device_selection(self, value: bool):
-        """Show the device selection
-
-        Args:
-            value (bool): Show the device selection
-        """
-        self.hide_device_selection = not value
-
-    @Slot(str)
-    def set_positioner(self, positioner: str | Positioner):
-        """Set the device
-
-        Args:
-            positioner (Positioner | str) : Positioner to set, accepts str or the device
-        """
-        if isinstance(positioner, Positioner):
-            positioner = positioner.name
-        self.device = positioner
-
-    def _check_device_is_valid(self, device: str):
-        """Check if the device is a positioner
-
-        Args:
-            device (str): The device name
-        """
-        if device not in self.dev:
-            logger.info(f"Device {device} not found in the device list")
-            return False
-        if not isinstance(self.dev[device], Positioner):
-            logger.info(f"Device {device} is not a positioner")
-            return False
-        return True
-
-    @Slot(str, str)
-    def on_device_change(self, old_device: str, new_device: str):
-        """Upon changing the device, a check will be performed if the device is a Positioner.
-
-        Args:
-            old_device (str): The old device name.
-            new_device (str): The new device name.
-        """
-        if not self._check_device_is_valid(new_device):
-            return
-        logger.info(f"Device changed from {old_device} to {new_device}")
-        self._toogle_enable_buttons(True)
-        self.init_device()
-        self.bec_dispatcher.disconnect_slot(
-            self.on_device_readback, MessageEndpoints.device_readback(old_device)
-        )
-        self.bec_dispatcher.connect_slot(
-            self.on_device_readback, MessageEndpoints.device_readback(new_device)
-        )
-        self.ui.device_box.setTitle(new_device)
-        self.ui.readback.setToolTip(f"{self.device} readback")
-        self.ui.setpoint.setToolTip(f"{self.device} setpoint")
-        self.ui.step_size.setToolTip(f"Step size for {new_device}")
-
-        precision = self.dev[new_device].precision
-        if precision is not None:
-            self.ui.step_size.setDecimals(precision)
-            self.ui.step_size.setValue(10**-precision * 10)
-
-    # pylint: disable=unused-argument
-    @Slot(dict, dict)
-    def on_device_readback(self, msg_content: dict, metadata: dict):
-        """Callback for device readback.
-
-        Args:
-            msg_content (dict): The message content.
-            metadata (dict): The message metadata.
-        """
-        signals = msg_content.get("signals", {})
-        # pylint: disable=protected-access
-        hinted_signals = self.dev[self.device]._hints
-        precision = self.dev[self.device].precision
-
-        readback_val = None
-        setpoint_val = None
-
-        if len(hinted_signals) == 1:
-            signal = hinted_signals[0]
-            readback_val = signals.get(signal, {}).get("value")
-
-        for setpoint_signal in ["setpoint", "user_setpoint"]:
-            setpoint_val = signals.get(f"{self.device}_{setpoint_signal}", {}).get("value")
-            if setpoint_val is not None:
-                break
-
-        for moving_signal in ["motor_done_move", "motor_is_moving"]:
-            is_moving = signals.get(f"{self.device}_{moving_signal}", {}).get("value")
-            if is_moving is not None:
-                break
-
-        if is_moving is not None:
-            self.ui.spinner_widget.setVisible(True)
-            if is_moving:
-                self.ui.spinner_widget.start()
-                self.ui.spinner_widget.setToolTip("Device is moving")
-                self.set_global_state("warning")
-            else:
-                self.ui.spinner_widget.stop()
-                self.ui.spinner_widget.setToolTip("Device is idle")
-                self.set_global_state("success")
-        else:
-            self.ui.spinner_widget.setVisible(False)
-
-        if readback_val is not None:
-            self.ui.readback.setText(f"{readback_val:.{precision}f}")
-            self.position_update.emit(readback_val)
-
-        if setpoint_val is not None:
-            self.ui.setpoint.setText(f"{setpoint_val:.{precision}f}")
-
-        limits = self.dev[self.device].limits
-        self.update_limits(limits)
-        if limits is not None and readback_val is not None and limits[0] != limits[1]:
-            pos = (readback_val - limits[0]) / (limits[1] - limits[0])
-            self.ui.position_indicator.set_value(pos)
-
-    def update_limits(self, limits: tuple):
-        """Update limits
-
-        Args:
-            limits (tuple): Limits of the positioner
-        """
-        if limits == self._limits:
-            return
-        self._limits = limits
-        if limits is not None and limits[0] != limits[1]:
-            self.ui.position_indicator.setToolTip(f"Min: {limits[0]}, Max: {limits[1]}")
-            self.setpoint_validator.setRange(limits[0], limits[1])
-        else:
-            self.ui.position_indicator.setToolTip("No limits set")
-            self.setpoint_validator.setRange(float("-inf"), float("inf"))
-
-    @Slot()
-    def on_stop(self):
-        """Stop call"""
-        request_id = str(uuid.uuid4())
-        params = {
-            "device": self.device,
-            "rpc_id": request_id,
-            "func": "stop",
-            "args": [],
-            "kwargs": {},
-        }
-        msg = ScanQueueMessage(
-            scan_type="device_rpc",
-            parameter=params,
-            queue="emergency",
-            metadata={"RID": request_id, "response": False},
-        )
-        self.client.connector.send(MessageEndpoints.scan_queue_request(), msg)
-
-    @property
-    def step_size(self):
-        """Step size for tweak"""
-        return self.ui.step_size.value()
-
-    @Slot()
-    def on_tweak_right(self):
-        """Tweak motor right"""
-        self.dev[self.device].move(self.step_size, relative=True)
-
-    @Slot()
-    def on_tweak_left(self):
-        """Tweak motor left"""
-        self.dev[self.device].move(-self.step_size, relative=True)
-
-    @Slot()
-    def on_setpoint_change(self):
-        """Change the setpoint for the motor"""
-        self.ui.setpoint.clearFocus()
-        setpoint = self.ui.setpoint.text()
-        self.dev[self.device].move(float(setpoint), relative=False)
-        self.ui.tweak_left.setToolTip(f"Tweak left by {self.step_size}")
-        self.ui.tweak_right.setToolTip(f"Tweak right by {self.step_size}")
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication  # pylint: disable=ungrouped-imports
-
-    app = QApplication(sys.argv)
-    set_theme("dark")
-    widget = PositionerBox(device="bpm4i")
-
-    widget.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/control/device_control/positioner_box/positioner_box/positioner_box.py

@@ -0,0 +1,242 @@
+""" Module for a PositionerBox widget to control a positioner device."""
+
+from __future__ import annotations
+
+import os
+
+from bec_lib.device import Positioner
+from bec_lib.logger import bec_logger
+from bec_qthemes import material_icon
+from qtpy.QtCore import Signal
+from qtpy.QtGui import QDoubleValidator
+from qtpy.QtWidgets import QDoubleSpinBox
+
+from bec_widgets.qt_utils.error_popups import SafeProperty, SafeSlot
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.colors import get_accent_colors, set_theme
+from bec_widgets.widgets.control.device_control.positioner_box._base import PositionerBoxBase
+from bec_widgets.widgets.control.device_control.positioner_box._base.positioner_box_base import (
+    DeviceUpdateUIComponents,
+)
+
+logger = bec_logger.logger
+
+MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+
+
+class PositionerBox(PositionerBoxBase):
+    """Simple Widget to control a positioner in box form"""
+
+    ui_file = "positioner_box.ui"
+    dimensions = (234, 224)
+
+    PLUGIN = True
+
+    USER_ACCESS = ["set_positioner"]
+    device_changed = Signal(str, str)
+    # Signal emitted to inform listeners about a position update
+    position_update = Signal(float)
+
+    def __init__(self, parent=None, device: Positioner | str | None = None, **kwargs):
+        """Initialize the PositionerBox widget.
+
+        Args:
+            parent: The parent widget.
+            device (Positioner): The device to control.
+        """
+        super().__init__(parent=parent, **kwargs)
+
+        self._device = ""
+        self._limits = None
+        if self.current_path == "":
+            self.current_path = os.path.dirname(__file__)
+
+        self.init_ui()
+        self.device = device
+        self._init_device(self.device, self.position_update.emit, self.update_limits)
+
+    def init_ui(self):
+        """Init the ui"""
+        self.device_changed.connect(self.on_device_change)
+
+        self.ui = UILoader(self).loader(os.path.join(self.current_path, self.ui_file))
+
+        self.addWidget(self.ui)
+        self.layout.setSpacing(0)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+
+        # fix the size of the device box
+        db = self.ui.device_box
+        db.setFixedHeight(self.dimensions[0])
+        db.setFixedWidth(self.dimensions[1])
+
+        self.ui.step_size.setStepType(QDoubleSpinBox.AdaptiveDecimalStepType)
+        self.ui.stop.clicked.connect(self.on_stop)
+        self.ui.stop.setToolTip("Stop")
+        self.ui.stop.setStyleSheet(
+            f"QPushButton {{background-color: {get_accent_colors().emergency.name()}; color: white;}}"
+        )
+        self.ui.tweak_right.clicked.connect(self.on_tweak_right)
+        self.ui.tweak_right.setToolTip("Tweak right")
+        self.ui.tweak_left.clicked.connect(self.on_tweak_left)
+        self.ui.tweak_left.setToolTip("Tweak left")
+        self.ui.setpoint.returnPressed.connect(self.on_setpoint_change)
+
+        self.setpoint_validator = QDoubleValidator()
+        self.ui.setpoint.setValidator(self.setpoint_validator)
+        self.ui.spinner_widget.start()
+        self.ui.tool_button.clicked.connect(self._open_dialog_selection(self.set_positioner))
+        icon = material_icon(icon_name="edit_note", size=(16, 16), convert_to_pixmap=False)
+        self.ui.tool_button.setIcon(icon)
+
+    def force_update_readback(self):
+        self._init_device(self.device, self.position_update.emit, self.update_limits)
+
+    @SafeProperty(str)
+    def device(self):
+        """Property to set the device"""
+        return self._device
+
+    @device.setter
+    def device(self, value: str):
+        """Setter, checks if device is a string"""
+        if not value or not isinstance(value, str):
+            return
+        if not self._check_device_is_valid(value):
+            return
+        old_device = self._device
+        self._device = value
+        if not self.label:
+            self.label = value
+        self.device_changed.emit(old_device, value)
+
+    @SafeProperty(bool)
+    def hide_device_selection(self):
+        """Hide the device selection"""
+        return not self.ui.tool_button.isVisible()
+
+    @hide_device_selection.setter
+    def hide_device_selection(self, value: bool):
+        """Set the device selection visibility"""
+        self.ui.tool_button.setVisible(not value)
+
+    @SafeSlot(bool)
+    def show_device_selection(self, value: bool):
+        """Show the device selection
+
+        Args:
+            value (bool): Show the device selection
+        """
+        self.hide_device_selection = not value
+
+    @SafeSlot(str)
+    def set_positioner(self, positioner: str | Positioner):
+        """Set the device
+
+        Args:
+            positioner (Positioner | str) : Positioner to set, accepts str or the device
+        """
+        if isinstance(positioner, Positioner):
+            positioner = positioner.name
+        self.device = positioner
+
+    @SafeSlot(str, str)
+    def on_device_change(self, old_device: str, new_device: str):
+        """Upon changing the device, a check will be performed if the device is a Positioner.
+
+        Args:
+            old_device (str): The old device name.
+            new_device (str): The new device name.
+        """
+        if not self._check_device_is_valid(new_device):
+            return
+        self._on_device_change(
+            old_device,
+            new_device,
+            self.position_update.emit,
+            self.update_limits,
+            self.on_device_readback,
+            self._device_ui_components(new_device),
+        )
+
+    def _device_ui_components(self, device: str) -> DeviceUpdateUIComponents:
+        return {
+            "spinner": self.ui.spinner_widget,
+            "position_indicator": self.ui.position_indicator,
+            "readback": self.ui.readback,
+            "setpoint": self.ui.setpoint,
+            "step_size": self.ui.step_size,
+            "device_box": self.ui.device_box,
+            "stop": self.ui.stop,
+            "tweak_increase": self.ui.tweak_right,
+            "tweak_decrease": self.ui.tweak_left,
+        }
+
+    @SafeSlot(dict, dict)
+    def on_device_readback(self, msg_content: dict, metadata: dict):
+        """Callback for device readback.
+
+        Args:
+            msg_content (dict): The message content.
+            metadata (dict): The message metadata.
+        """
+        self._on_device_readback(
+            self.device,
+            self._device_ui_components(self.device),
+            msg_content,
+            metadata,
+            self.position_update.emit,
+            self.update_limits,
+        )
+
+    def update_limits(self, limits: tuple):
+        """Update limits
+
+        Args:
+            limits (tuple): Limits of the positioner
+        """
+        if limits == self._limits:
+            return
+        self._limits = limits
+        self._update_limits_ui(limits, self.ui.position_indicator, self.setpoint_validator)
+
+    @SafeSlot()
+    def on_stop(self):
+        self._stop_device(self.device)
+
+    @property
+    def step_size(self):
+        """Step size for tweak"""
+        return self.ui.step_size.value()
+
+    @SafeSlot()
+    def on_tweak_right(self):
+        """Tweak motor right"""
+        self.dev[self.device].move(self.step_size, relative=True)
+
+    @SafeSlot()
+    def on_tweak_left(self):
+        """Tweak motor left"""
+        self.dev[self.device].move(-self.step_size, relative=True)
+
+    @SafeSlot()
+    def on_setpoint_change(self):
+        """Change the setpoint for the motor"""
+        self.ui.setpoint.clearFocus()
+        setpoint = self.ui.setpoint.text()
+        self.dev[self.device].move(float(setpoint), relative=False)
+        self.ui.tweak_left.setToolTip(f"Tweak left by {self.step_size}")
+        self.ui.tweak_right.setToolTip(f"Tweak right by {self.step_size}")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication  # pylint: disable=ungrouped-imports
+
+    app = QApplication(sys.argv)
+    set_theme("dark")
+    widget = PositionerBox(device="bpm4i")
+
+    widget.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/control/device_control/positioner_box/positioner_box/positioner_box_plugin.py

@@ -6,7 +6,7 @@ import os
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
 
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.control.device_control.positioner_box.positioner_box import PositionerBox
+from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
 
 DOM_XML = """
 <ui language='c++'>

bec_widgets/widgets/control/device_control/positioner_box/positioner_box/register_positioner_box.py

@@ -6,7 +6,7 @@ def main():  # pragma: no cover
         return
     from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
 
-    from bec_widgets.widgets.control.device_control.positioner_box.positioner_box_plugin import (
+    from bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box_plugin import (
         PositionerBoxPlugin,
     )
 

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_2d/positioner_box2_d.pyproject

@@ -0,0 +1 @@
+{'files': ['positioner_box_2d.py']}

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_2d/positioner_box2_d_plugin.py

@@ -0,0 +1,56 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.control.device_control.positioner_box.positioner_box_2d.positioner_box_2d import (
+    PositionerBox2D,
+)
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='PositionerBox2D' name='positioner_box2_d'>
+    </widget>
+</ui>
+"""
+
+
+class PositionerBox2DPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = PositionerBox2D(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "Device Control"
+
+    def icon(self):
+        return designer_material_icon(PositionerBox2D.ICON_NAME)
+
+    def includeFile(self):
+        return "positioner_box2_d"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "PositionerBox2D"
+
+    def toolTip(self):
+        return "Simple Widget to control two positioners in box form"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_2d/positioner_box_2d.py

@@ -0,0 +1,482 @@
+""" Module for a PositionerBox2D widget to control two positioner devices."""
+
+from __future__ import annotations
+
+import os
+from typing import Literal
+
+from bec_lib.device import Positioner
+from bec_lib.logger import bec_logger
+from bec_qthemes import material_icon
+from qtpy.QtCore import Signal
+from qtpy.QtGui import QDoubleValidator
+from qtpy.QtWidgets import QDoubleSpinBox
+
+from bec_widgets.qt_utils.error_popups import SafeProperty, SafeSlot
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.colors import set_theme
+from bec_widgets.widgets.control.device_control.positioner_box._base import PositionerBoxBase
+from bec_widgets.widgets.control.device_control.positioner_box._base.positioner_box_base import (
+    DeviceUpdateUIComponents,
+)
+
+logger = bec_logger.logger
+
+MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+
+DeviceId = Literal["horizontal", "vertical"]
+
+
+class PositionerBox2D(PositionerBoxBase):
+    """Simple Widget to control two positioners in box form"""
+
+    ui_file = "positioner_box_2d.ui"
+
+    PLUGIN = True
+    USER_ACCESS = ["set_positioner_hor", "set_positioner_ver"]
+
+    device_changed_hor = Signal(str, str)
+    device_changed_ver = Signal(str, str)
+    # Signals emitted to inform listeners about a position update
+    position_update_hor = Signal(float)
+    position_update_ver = Signal(float)
+
+    def __init__(
+        self,
+        parent=None,
+        device_hor: Positioner | str | None = None,
+        device_ver: Positioner | str | None = None,
+        **kwargs,
+    ):
+        """Initialize the PositionerBox widget.
+
+        Args:
+            parent: The parent widget.
+            device_hor (Positioner | str): The first device to control - assigned the horizontal axis.
+            device_ver (Positioner | str): The second device to control - assigned the vertical axis.
+        """
+        super().__init__(parent=parent, **kwargs)
+
+        self._device_hor = ""
+        self._device_ver = ""
+        self._limits_hor = None
+        self._limits_ver = None
+        self._dialog = None
+        if self.current_path == "":
+            self.current_path = os.path.dirname(__file__)
+        self.init_ui()
+        self.device_hor = device_hor
+        self.device_ver = device_ver
+
+        self.connect_ui()
+
+    def init_ui(self):
+        """Init the ui"""
+        self.device_changed_hor.connect(self.on_device_change_hor)
+        self.device_changed_ver.connect(self.on_device_change_ver)
+
+        self.ui = UILoader(self).loader(os.path.join(self.current_path, self.ui_file))
+        self.setpoint_validator_hor = QDoubleValidator()
+        self.setpoint_validator_ver = QDoubleValidator()
+
+    def connect_ui(self):
+        """Connect the UI components to signals, data, or routines"""
+        self.addWidget(self.ui)
+        self.layout.setSpacing(0)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+
+        def _init_ui(val: QDoubleValidator, device_id: DeviceId):
+            ui = self._device_ui_components_hv(device_id)
+            tweak_inc = (
+                self.on_tweak_inc_hor if device_id == "horizontal" else self.on_tweak_inc_ver
+            )
+            tweak_dec = (
+                self.on_tweak_dec_hor if device_id == "horizontal" else self.on_tweak_dec_ver
+            )
+            ui["setpoint"].setValidator(val)
+            ui["setpoint"].returnPressed.connect(
+                self.on_setpoint_change_hor
+                if device_id == "horizontal"
+                else self.on_setpoint_change_ver
+            )
+            ui["stop"].setToolTip("Stop")
+            ui["step_size"].setStepType(QDoubleSpinBox.StepType.AdaptiveDecimalStepType)
+            ui["tweak_increase"].clicked.connect(tweak_inc)
+            ui["tweak_decrease"].clicked.connect(tweak_dec)
+
+        _init_ui(self.setpoint_validator_hor, "horizontal")
+        _init_ui(self.setpoint_validator_ver, "vertical")
+
+        self.ui.stop_button.button.clicked.connect(self.on_stop)
+
+        self.ui.step_decrease_hor.clicked.connect(self.on_step_dec_hor)
+        self.ui.step_decrease_ver.clicked.connect(self.on_step_dec_ver)
+        self.ui.step_increase_hor.clicked.connect(self.on_step_inc_hor)
+        self.ui.step_increase_ver.clicked.connect(self.on_step_inc_ver)
+
+        self.ui.tool_button_hor.clicked.connect(
+            self._open_dialog_selection(self.set_positioner_hor)
+        )
+        self.ui.tool_button_ver.clicked.connect(
+            self._open_dialog_selection(self.set_positioner_ver)
+        )
+        icon = material_icon(icon_name="edit_note", size=(16, 16), convert_to_pixmap=False)
+        self.ui.tool_button_hor.setIcon(icon)
+        self.ui.tool_button_ver.setIcon(icon)
+
+        step_tooltip = "Step by the step size"
+        tweak_tooltip = "Tweak by 1/10th the step size"
+
+        for b in [
+            self.ui.step_increase_hor,
+            self.ui.step_increase_ver,
+            self.ui.step_decrease_hor,
+            self.ui.step_decrease_ver,
+        ]:
+            b.setToolTip(step_tooltip)
+
+        for b in [
+            self.ui.tweak_increase_hor,
+            self.ui.tweak_increase_ver,
+            self.ui.tweak_decrease_hor,
+            self.ui.tweak_decrease_ver,
+        ]:
+            b.setToolTip(tweak_tooltip)
+
+        icon_options = {"size": (16, 16), "convert_to_pixmap": False}
+        self.ui.tweak_increase_hor.setIcon(
+            material_icon(icon_name="keyboard_arrow_right", **icon_options)
+        )
+        self.ui.step_increase_hor.setIcon(
+            material_icon(icon_name="keyboard_double_arrow_right", **icon_options)
+        )
+        self.ui.tweak_decrease_hor.setIcon(
+            material_icon(icon_name="keyboard_arrow_left", **icon_options)
+        )
+        self.ui.step_decrease_hor.setIcon(
+            material_icon(icon_name="keyboard_double_arrow_left", **icon_options)
+        )
+        self.ui.tweak_increase_ver.setIcon(
+            material_icon(icon_name="keyboard_arrow_up", **icon_options)
+        )
+        self.ui.step_increase_ver.setIcon(
+            material_icon(icon_name="keyboard_double_arrow_up", **icon_options)
+        )
+        self.ui.tweak_decrease_ver.setIcon(
+            material_icon(icon_name="keyboard_arrow_down", **icon_options)
+        )
+        self.ui.step_decrease_ver.setIcon(
+            material_icon(icon_name="keyboard_double_arrow_down", **icon_options)
+        )
+
+    @SafeProperty(str)
+    def device_hor(self):
+        """SafeProperty to set the device"""
+        return self._device_hor
+
+    @device_hor.setter
+    def device_hor(self, value: str):
+        """Setter, checks if device is a string"""
+        if not value or not isinstance(value, str):
+            return
+        if not self._check_device_is_valid(value):
+            return
+        if value == self.device_ver:
+            return
+        old_device = self._device_hor
+        self._device_hor = value
+        self.label = f"{self._device_hor}, {self._device_ver}"
+        self.device_changed_hor.emit(old_device, value)
+        self._init_device(self.device_hor, self.position_update_hor.emit, self.update_limits_hor)
+
+    @SafeProperty(str)
+    def device_ver(self):
+        """SafeProperty to set the device"""
+        return self._device_ver
+
+    @device_ver.setter
+    def device_ver(self, value: str):
+        """Setter, checks if device is a string"""
+        if not value or not isinstance(value, str):
+            return
+        if not self._check_device_is_valid(value):
+            return
+        if value == self.device_hor:
+            return
+        old_device = self._device_ver
+        self._device_ver = value
+        self.label = f"{self._device_hor}, {self._device_ver}"
+        self.device_changed_ver.emit(old_device, value)
+        self._init_device(self.device_ver, self.position_update_ver.emit, self.update_limits_ver)
+
+    @SafeProperty(bool)
+    def hide_device_selection(self):
+        """Hide the device selection"""
+        return not self.ui.tool_button_hor.isVisible()
+
+    @hide_device_selection.setter
+    def hide_device_selection(self, value: bool):
+        """Set the device selection visibility"""
+        self.ui.tool_button_hor.setVisible(not value)
+        self.ui.tool_button_ver.setVisible(not value)
+
+    @SafeProperty(bool)
+    def hide_device_boxes(self):
+        """Hide the device selection"""
+        return not self.ui.device_box_hor.isVisible()
+
+    @hide_device_boxes.setter
+    def hide_device_boxes(self, value: bool):
+        """Set the device selection visibility"""
+        self.ui.device_box_hor.setVisible(not value)
+        self.ui.device_box_ver.setVisible(not value)
+
+    @SafeSlot(bool)
+    def show_device_selection(self, value: bool):
+        """Show the device selection
+
+        Args:
+            value (bool): Show the device selection
+        """
+        self.hide_device_selection = not value
+
+    @SafeSlot(str)
+    def set_positioner_hor(self, positioner: str | Positioner):
+        """Set the device
+
+        Args:
+            positioner (Positioner | str) : Positioner to set, accepts str or the device
+        """
+        if isinstance(positioner, Positioner):
+            positioner = positioner.name
+        self.device_hor = positioner
+
+    @SafeSlot(str)
+    def set_positioner_ver(self, positioner: str | Positioner):
+        """Set the device
+
+        Args:
+            positioner (Positioner | str) : Positioner to set, accepts str or the device
+        """
+        if isinstance(positioner, Positioner):
+            positioner = positioner.name
+        self.device_ver = positioner
+
+    @SafeSlot(str, str)
+    def on_device_change_hor(self, old_device: str, new_device: str):
+        """Upon changing the device, a check will be performed if the device is a Positioner.
+
+        Args:
+            old_device (str): The old device name.
+            new_device (str): The new device name.
+        """
+        if not self._check_device_is_valid(new_device):
+            return
+        self._on_device_change(
+            old_device,
+            new_device,
+            self.position_update_hor.emit,
+            self.update_limits_hor,
+            self.on_device_readback_hor,
+            self._device_ui_components_hv("horizontal"),
+        )
+
+    @SafeSlot(str, str)
+    def on_device_change_ver(self, old_device: str, new_device: str):
+        """Upon changing the device, a check will be performed if the device is a Positioner.
+
+        Args:
+            old_device (str): The old device name.
+            new_device (str): The new device name.
+        """
+        if not self._check_device_is_valid(new_device):
+            return
+        self._on_device_change(
+            old_device,
+            new_device,
+            self.position_update_ver.emit,
+            self.update_limits_ver,
+            self.on_device_readback_ver,
+            self._device_ui_components_hv("vertical"),
+        )
+
+    def _device_ui_components_hv(self, device: DeviceId) -> DeviceUpdateUIComponents:
+        if device == "horizontal":
+            return {
+                "spinner": self.ui.spinner_widget_hor,
+                "position_indicator": self.ui.position_indicator_hor,
+                "readback": self.ui.readback_hor,
+                "setpoint": self.ui.setpoint_hor,
+                "step_size": self.ui.step_size_hor,
+                "device_box": self.ui.device_box_hor,
+                "stop": self.ui.stop_button,
+                "tweak_increase": self.ui.tweak_increase_hor,
+                "tweak_decrease": self.ui.tweak_decrease_hor,
+            }
+        elif device == "vertical":
+            return {
+                "spinner": self.ui.spinner_widget_ver,
+                "position_indicator": self.ui.position_indicator_ver,
+                "readback": self.ui.readback_ver,
+                "setpoint": self.ui.setpoint_ver,
+                "step_size": self.ui.step_size_ver,
+                "device_box": self.ui.device_box_ver,
+                "stop": self.ui.stop_button,
+                "tweak_increase": self.ui.tweak_increase_ver,
+                "tweak_decrease": self.ui.tweak_decrease_ver,
+            }
+        else:
+            raise ValueError(f"Device {device} is not represented by this UI")
+
+    def _device_ui_components(self, device: str):
+        if device == self.device_hor:
+            return self._device_ui_components_hv("horizontal")
+        if device == self.device_ver:
+            return self._device_ui_components_hv("vertical")
+
+    @SafeSlot(dict, dict)
+    def on_device_readback_hor(self, msg_content: dict, metadata: dict):
+        """Callback for device readback.
+
+        Args:
+            msg_content (dict): The message content.
+            metadata (dict): The message metadata.
+        """
+        self._on_device_readback(
+            self.device_hor,
+            self._device_ui_components_hv("horizontal"),
+            msg_content,
+            metadata,
+            self.position_update_hor.emit,
+            self.update_limits_hor,
+        )
+
+    @SafeSlot(dict, dict)
+    def on_device_readback_ver(self, msg_content: dict, metadata: dict):
+        """Callback for device readback.
+
+        Args:
+            msg_content (dict): The message content.
+            metadata (dict): The message metadata.
+        """
+        self._on_device_readback(
+            self.device_ver,
+            self._device_ui_components_hv("vertical"),
+            msg_content,
+            metadata,
+            self.position_update_ver.emit,
+            self.update_limits_ver,
+        )
+
+    def update_limits_hor(self, limits: tuple):
+        """Update limits
+
+        Args:
+            limits (tuple): Limits of the positioner
+        """
+        if limits == self._limits_hor:
+            return
+        self._limits_hor = limits
+        self._update_limits_ui(limits, self.ui.position_indicator_hor, self.setpoint_validator_hor)
+
+    def update_limits_ver(self, limits: tuple):
+        """Update limits
+
+        Args:
+            limits (tuple): Limits of the positioner
+        """
+        if limits == self._limits_ver:
+            return
+        self._limits_ver = limits
+        self._update_limits_ui(limits, self.ui.position_indicator_ver, self.setpoint_validator_ver)
+
+    @SafeSlot()
+    def on_stop(self):
+        self._stop_device(f"{self.device_hor} or {self.device_ver}")
+
+    @SafeProperty(float)
+    def step_size_hor(self):
+        """Step size for tweak"""
+        return self.ui.step_size_hor.value()
+
+    @step_size_hor.setter
+    def step_size_hor(self, val: float):
+        """Step size for tweak"""
+        self.ui.step_size_hor.setValue(val)
+
+    @SafeProperty(float)
+    def step_size_ver(self):
+        """Step size for tweak"""
+        return self.ui.step_size_ver.value()
+
+    @step_size_ver.setter
+    def step_size_ver(self, val: float):
+        """Step size for tweak"""
+        self.ui.step_size_ver.setValue(val)
+
+    @SafeSlot()
+    def on_tweak_inc_hor(self):
+        """Tweak device a up"""
+        self.dev[self.device_hor].move(self.step_size_hor / 10, relative=True)
+
+    @SafeSlot()
+    def on_tweak_dec_hor(self):
+        """Tweak device a down"""
+        self.dev[self.device_hor].move(-self.step_size_hor / 10, relative=True)
+
+    @SafeSlot()
+    def on_step_inc_hor(self):
+        """Tweak device a up"""
+        self.dev[self.device_hor].move(self.step_size_hor, relative=True)
+
+    @SafeSlot()
+    def on_step_dec_hor(self):
+        """Tweak device a down"""
+        self.dev[self.device_hor].move(-self.step_size_hor, relative=True)
+
+    @SafeSlot()
+    def on_tweak_inc_ver(self):
+        """Tweak device a up"""
+        self.dev[self.device_ver].move(self.step_size_ver / 10, relative=True)
+
+    @SafeSlot()
+    def on_tweak_dec_ver(self):
+        """Tweak device b down"""
+        self.dev[self.device_ver].move(-self.step_size_ver / 10, relative=True)
+
+    @SafeSlot()
+    def on_step_inc_ver(self):
+        """Tweak device b up"""
+        self.dev[self.device_ver].move(self.step_size_ver, relative=True)
+
+    @SafeSlot()
+    def on_step_dec_ver(self):
+        """Tweak device a down"""
+        self.dev[self.device_ver].move(-self.step_size_ver, relative=True)
+
+    @SafeSlot()
+    def on_setpoint_change_hor(self):
+        """Change the setpoint for device a"""
+        self.ui.setpoint_hor.clearFocus()
+        setpoint = self.ui.setpoint_hor.text()
+        self.dev[self.device_hor].move(float(setpoint), relative=False)
+
+    @SafeSlot()
+    def on_setpoint_change_ver(self):
+        """Change the setpoint for device b"""
+        self.ui.setpoint_ver.clearFocus()
+        setpoint = self.ui.setpoint_ver.text()
+        self.dev[self.device_ver].move(float(setpoint), relative=False)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication  # pylint: disable=ungrouped-imports
+
+    app = QApplication(sys.argv)
+    set_theme("dark")
+    widget = PositionerBox2D()
+
+    widget.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_2d/positioner_box_2d.ui

@@ -0,0 +1,562 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>326</width>
+    <height>323</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="1">
+    <layout class="QGridLayout" name="gridLayout_4">
+     <item row="0" column="1">
+      <layout class="QGridLayout" name="gridLayout_2">
+       <item row="0" column="2">
+        <widget class="QGroupBox" name="device_box_ver">
+         <property name="title">
+          <string>No positioner selected</string>
+         </property>
+         <layout class="QGridLayout" name="gridLayout_6" rowstretch="0,0,0,0,0,0">
+          <property name="topMargin">
+           <number>0</number>
+          </property>
+          <item row="1" column="0">
+           <layout class="QHBoxLayout" name="horizontalLayout_5">
+            <item>
+             <widget class="QToolButton" name="tool_button_ver">
+              <property name="focusPolicy">
+               <enum>Qt::FocusPolicy::NoFocus</enum>
+              </property>
+              <property name="text">
+               <string>...</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QLabel" name="readback_ver">
+              <property name="text">
+               <string>Position</string>
+              </property>
+              <property name="alignment">
+               <set>Qt::AlignmentFlag::AlignCenter</set>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="SpinnerWidget" name="spinner_widget_ver">
+              <property name="minimumSize">
+               <size>
+                <width>25</width>
+                <height>25</height>
+               </size>
+              </property>
+              <property name="maximumSize">
+               <size>
+                <width>25</width>
+                <height>25</height>
+               </size>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+          <item row="2" column="0">
+           <widget class="QLineEdit" name="setpoint_ver">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="focusPolicy">
+             <enum>Qt::FocusPolicy::StrongFocus</enum>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignmentFlag::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="5" column="0">
+           <layout class="QHBoxLayout" name="horizontalLayout_6">
+            <item>
+             <widget class="QDoubleSpinBox" name="step_size_ver">
+              <property name="enabled">
+               <bool>false</bool>
+              </property>
+              <property name="focusPolicy">
+               <enum>Qt::FocusPolicy::StrongFocus</enum>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item row="0" column="1">
+        <widget class="QGroupBox" name="device_box_hor">
+         <property name="title">
+          <string>No positioner selected</string>
+         </property>
+         <layout class="QGridLayout" name="gridLayout_5" rowstretch="0,0,0,0,0,0,0,0,0,0,0">
+          <property name="topMargin">
+           <number>0</number>
+          </property>
+          <item row="9" column="0">
+           <widget class="QLineEdit" name="setpoint_hor">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="focusPolicy">
+             <enum>Qt::FocusPolicy::StrongFocus</enum>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignmentFlag::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0">
+           <layout class="QHBoxLayout" name="horizontalLayout_4">
+            <item>
+             <widget class="QToolButton" name="tool_button_hor">
+              <property name="focusPolicy">
+               <enum>Qt::FocusPolicy::NoFocus</enum>
+              </property>
+              <property name="text">
+               <string>...</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QLabel" name="readback_hor">
+              <property name="text">
+               <string>Position</string>
+              </property>
+              <property name="alignment">
+               <set>Qt::AlignmentFlag::AlignCenter</set>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="SpinnerWidget" name="spinner_widget_hor">
+              <property name="minimumSize">
+               <size>
+                <width>25</width>
+                <height>25</height>
+               </size>
+              </property>
+              <property name="maximumSize">
+               <size>
+                <width>25</width>
+                <height>25</height>
+               </size>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+          <item row="10" column="0">
+           <layout class="QHBoxLayout" name="horizontalLayout_7">
+            <item>
+             <widget class="QDoubleSpinBox" name="step_size_hor">
+              <property name="enabled">
+               <bool>false</bool>
+              </property>
+              <property name="focusPolicy">
+               <enum>Qt::FocusPolicy::StrongFocus</enum>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </item>
+     <item row="4" column="0">
+      <widget class="PositionIndicator" name="position_indicator_ver">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="maximum" stdset="0">
+        <double>1.000000000000000</double>
+       </property>
+       <property name="vertical" stdset="0">
+        <bool>true</bool>
+       </property>
+       <property name="value" stdset="0">
+        <double>0.500000000000000</double>
+       </property>
+       <property name="indicator_width" stdset="0">
+        <number>4</number>
+       </property>
+       <property name="rounded_corners" stdset="0">
+        <number>4</number>
+       </property>
+      </widget>
+     </item>
+     <item row="4" column="1">
+      <layout class="QGridLayout" name="gridLayout_3">
+       <item row="0" column="3">
+        <widget class="QPushButton" name="step_increase_ver">
+         <property name="focusPolicy">
+          <enum>Qt::FocusPolicy::NoFocus</enum>
+         </property>
+         <property name="text">
+          <string/>
+         </property>
+        </widget>
+       </item>
+       <item row="2" column="5">
+        <spacer name="horizontalSpacer_3">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="6" column="3">
+        <widget class="QPushButton" name="step_decrease_ver">
+         <property name="focusPolicy">
+          <enum>Qt::FocusPolicy::NoFocus</enum>
+         </property>
+         <property name="text">
+          <string/>
+         </property>
+        </widget>
+       </item>
+       <item row="4" column="5">
+        <spacer name="horizontalSpacer_2">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="6" column="2">
+        <spacer name="horizontalSpacer_16">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>10</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="2" column="1">
+        <spacer name="horizontalSpacer">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="0" column="2">
+        <spacer name="horizontalSpacer_14">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>10</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="4" column="1">
+        <spacer name="horizontalSpacer_17">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="2" column="2">
+        <spacer name="horizontalSpacer_7">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>10</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="6" column="1">
+        <spacer name="horizontalSpacer_4">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="3" column="3">
+        <spacer name="horizontalSpacer_6">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="3" column="5">
+        <widget class="QPushButton" name="step_increase_hor">
+         <property name="focusPolicy">
+          <enum>Qt::FocusPolicy::NoFocus</enum>
+         </property>
+         <property name="text">
+          <string/>
+         </property>
+        </widget>
+       </item>
+       <item row="6" column="4">
+        <spacer name="horizontalSpacer_10">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="3" column="2">
+        <widget class="QPushButton" name="tweak_decrease_hor">
+         <property name="focusPolicy">
+          <enum>Qt::FocusPolicy::NoFocus</enum>
+         </property>
+         <property name="text">
+          <string/>
+         </property>
+        </widget>
+       </item>
+       <item row="4" column="2">
+        <spacer name="horizontalSpacer_15">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>10</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="0" column="1">
+        <spacer name="horizontalSpacer_35">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="4" column="3">
+        <widget class="QPushButton" name="tweak_decrease_ver">
+         <property name="focusPolicy">
+          <enum>Qt::FocusPolicy::NoFocus</enum>
+         </property>
+         <property name="text">
+          <string/>
+         </property>
+        </widget>
+       </item>
+       <item row="3" column="1">
+        <widget class="QPushButton" name="step_decrease_hor">
+         <property name="focusPolicy">
+          <enum>Qt::FocusPolicy::NoFocus</enum>
+         </property>
+         <property name="text">
+          <string/>
+         </property>
+        </widget>
+       </item>
+       <item row="3" column="4">
+        <widget class="QPushButton" name="tweak_increase_hor">
+         <property name="focusPolicy">
+          <enum>Qt::FocusPolicy::NoFocus</enum>
+         </property>
+         <property name="text">
+          <string/>
+         </property>
+        </widget>
+       </item>
+       <item row="2" column="3">
+        <widget class="QPushButton" name="tweak_increase_ver">
+         <property name="focusPolicy">
+          <enum>Qt::FocusPolicy::NoFocus</enum>
+         </property>
+         <property name="text">
+          <string/>
+         </property>
+        </widget>
+       </item>
+       <item row="2" column="4">
+        <spacer name="horizontalSpacer_12">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="0" column="4">
+        <spacer name="horizontalSpacer_8">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="4" column="4">
+        <spacer name="horizontalSpacer_11">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="0" column="5">
+        <spacer name="horizontalSpacer_5">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="6" column="5">
+        <widget class="StopButton" name="stop_button"/>
+       </item>
+      </layout>
+     </item>
+     <item row="2" column="1">
+      <widget class="PositionIndicator" name="position_indicator_hor">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="maximum" stdset="0">
+        <double>1.000000000000000</double>
+       </property>
+       <property name="value" stdset="0">
+        <double>0.500000000000000</double>
+       </property>
+       <property name="indicator_width" stdset="0">
+        <number>4</number>
+       </property>
+       <property name="rounded_corners" stdset="0">
+        <number>4</number>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>StopButton</class>
+   <extends>QWidget</extends>
+   <header>stop_button</header>
+  </customwidget>
+  <customwidget>
+   <class>PositionIndicator</class>
+   <extends>QWidget</extends>
+   <header>position_indicator</header>
+  </customwidget>
+  <customwidget>
+   <class>SpinnerWidget</class>
+   <extends>QWidget</extends>
+   <header>spinner_widget</header>
+  </customwidget>
+ </customwidgets>
+ <tabstops>
+  <tabstop>tool_button_hor</tabstop>
+  <tabstop>tool_button_ver</tabstop>
+  <tabstop>setpoint_hor</tabstop>
+  <tabstop>setpoint_ver</tabstop>
+  <tabstop>step_size_hor</tabstop>
+  <tabstop>step_size_ver</tabstop>
+  <tabstop>tweak_decrease_hor</tabstop>
+  <tabstop>tweak_increase_ver</tabstop>
+  <tabstop>tweak_increase_hor</tabstop>
+  <tabstop>tweak_decrease_ver</tabstop>
+  <tabstop>step_decrease_hor</tabstop>
+  <tabstop>step_increase_ver</tabstop>
+  <tabstop>step_increase_hor</tabstop>
+  <tabstop>step_decrease_ver</tabstop>
+ </tabstops>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_2d/register_positioner_box2_d.py

@@ -0,0 +1,17 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.control.device_control.positioner_box.positioner_box_2d.positioner_box2_d_plugin import (
+        PositionerBox2DPlugin,
+    )
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(PositionerBox2DPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/control/device_control/positioner_box/positioner_control_line/positioner_control_line.py

@@ -1,6 +1,8 @@
+import os
+
 from bec_lib.device import Positioner
 
-from bec_widgets.widgets.control.device_control.positioner_box.positioner_box import PositionerBox
+from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
 
 
 class PositionerControlLine(PositionerBox):
@@ -12,13 +14,14 @@ class PositionerControlLine(PositionerBox):
     PLUGIN = True
     ICON_NAME = "switch_left"
 
-    def __init__(self, parent=None, device: Positioner = None, *args, **kwargs):
+    def __init__(self, parent=None, device: Positioner | str | None = None, *args, **kwargs):
         """Initialize the DeviceControlLine.
 
         Args:
             parent: The parent widget.
             device (Positioner): The device to control.
         """
+        self.current_path = os.path.dirname(__file__)
         super().__init__(parent=parent, device=device, *args, **kwargs)
 
 

bec_widgets/widgets/control/device_control/positioner_box/positioner_control_line/positioner_control_line_plugin.py

@@ -6,9 +6,7 @@ import os
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
 
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.control.device_control.positioner_box.positioner_control_line import (
-    PositionerControlLine,
-)
+from bec_widgets.widgets.control.device_control.positioner_box import PositionerControlLine
 
 DOM_XML = """
 <ui language='c++'>

bec_widgets/widgets/control/device_control/positioner_box/positioner_control_line/register_positioner_control_line.py

@@ -6,7 +6,7 @@ def main():  # pragma: no cover
         return
     from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
 
-    from bec_widgets.widgets.control.device_control.positioner_box.positioner_control_line_plugin import (
+    from bec_widgets.widgets.control.device_control.positioner_box.positioner_control_line.positioner_control_line_plugin import (
         PositionerControlLinePlugin,
     )
 

bec_widgets/widgets/control/device_control/positioner_group/positioner_group.py

@@ -4,11 +4,12 @@ from __future__ import annotations
 
 from bec_lib.device import Positioner
 from bec_lib.logger import bec_logger
-from qtpy.QtCore import Property, QSize, Signal, Slot
+from qtpy.QtCore import QSize, Signal
 from qtpy.QtWidgets import QGridLayout, QGroupBox, QVBoxLayout, QWidget
 
+from bec_widgets.qt_utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.widgets.control.device_control.positioner_box.positioner_box import PositionerBox
+from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
 
 logger = bec_logger.logger
 
@@ -32,7 +33,7 @@ class PositionerGroupBox(QGroupBox):
         self.widget.position_update.connect(self._on_position_update)
         self.widget.expand.connect(self._on_expand)
         self.setTitle(self.device_name)
-        self.widget.init_device()  # force readback
+        self.widget.force_update_readback()
 
     def _on_expand(self, expand):
         if expand:
@@ -82,7 +83,7 @@ class PositionerGroup(BECWidget, QWidget):
     def minimumSizeHint(self):
         return QSize(300, 30)
 
-    @Slot(str)
+    @SafeSlot(str)
     def set_positioners(self, device_names: str):
         """Redraw grid with positioners from device_names string
 
@@ -130,7 +131,7 @@ class PositionerGroup(BECWidget, QWidget):
         widget = self.sender()
         self.device_position_update.emit(widget.title(), pos)
 
-    @Property(str)
+    @SafeProperty(str)
     def devices_list(self):
         """Device names string separated by space"""
         return " ".join(self._device_widgets)
@@ -144,7 +145,7 @@ class PositionerGroup(BECWidget, QWidget):
                 return
         self.set_positioners(device_names)
 
-    @Property(int)
+    @SafeProperty(int)
     def grid_max_cols(self):
         """Max number of columns for widgets grid"""
         return self._grid_ncols

bec_widgets/widgets/control/device_input/signal_combobox/signal_combobox.pyproject

@@ -1 +0,0 @@
-{'files': ['signal_combobox.py']}

bec_widgets/widgets/games/__init__.py

@@ -0,0 +1,3 @@
+from bec_widgets.widgets.games.minesweeper import Minesweeper
+
+__ALL__ = ["Minesweeper"]

bec_widgets/widgets/games/minesweeper.py

@@ -0,0 +1,413 @@
+import enum
+import random
+import time
+
+from bec_qthemes import material_icon
+from qtpy.QtCore import QSize, Qt, QTimer, Signal, Slot
+from qtpy.QtGui import QBrush, QColor, QPainter, QPen
+from qtpy.QtWidgets import (
+    QApplication,
+    QComboBox,
+    QGridLayout,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.utils.bec_widget import BECWidget
+
+NUM_COLORS = {
+    1: QColor("#f44336"),
+    2: QColor("#9C27B0"),
+    3: QColor("#3F51B5"),
+    4: QColor("#03A9F4"),
+    5: QColor("#00BCD4"),
+    6: QColor("#4CAF50"),
+    7: QColor("#E91E63"),
+    8: QColor("#FF9800"),
+}
+
+LEVELS: dict[str, tuple[int, int]] = {"1": (8, 10), "2": (16, 40), "3": (24, 99)}
+
+
+class GameStatus(enum.Enum):
+    READY = 0
+    PLAYING = 1
+    FAILED = 2
+    SUCCESS = 3
+
+
+class Pos(QWidget):
+    expandable = Signal(int, int)
+    clicked = Signal()
+    ohno = Signal()
+
+    def __init__(self, x, y, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.setFixedSize(QSize(20, 20))
+
+        self.x = x
+        self.y = y
+        self.is_start = False
+        self.is_mine = False
+        self.adjacent_n = 0
+        self.is_revealed = False
+        self.is_flagged = False
+
+    def reset(self):
+        """Restore the tile to its original state before mine status is assigned"""
+        self.is_start = False
+        self.is_mine = False
+        self.adjacent_n = 0
+
+        self.is_revealed = False
+        self.is_flagged = False
+
+        self.update()
+
+    def paintEvent(self, event):
+        p = QPainter(self)
+
+        r = event.rect()
+
+        if self.is_revealed:
+            color = self.palette().base().color()
+            outer, inner = color, color
+        else:
+            outer, inner = (self.palette().highlightedText().color(), self.palette().text().color())
+
+        p.fillRect(r, QBrush(inner))
+        pen = QPen(outer)
+        pen.setWidth(1)
+        p.setPen(pen)
+        p.drawRect(r)
+
+        if self.is_revealed:
+            if self.is_mine:
+                p.drawPixmap(r, material_icon("experiment", convert_to_pixmap=True, filled=True))
+
+            elif self.adjacent_n > 0:
+                pen = QPen(NUM_COLORS[self.adjacent_n])
+                p.setPen(pen)
+                f = p.font()
+                f.setBold(True)
+                p.setFont(f)
+                p.drawText(r, Qt.AlignHCenter | Qt.AlignVCenter, str(self.adjacent_n))
+
+        elif self.is_flagged:
+            p.drawPixmap(
+                r,
+                material_icon(
+                    "flag",
+                    size=(50, 50),
+                    convert_to_pixmap=True,
+                    filled=True,
+                    color=self.palette().base().color(),
+                ),
+            )
+        p.end()
+
+    def flag(self):
+        self.is_flagged = not self.is_flagged
+        self.update()
+
+        self.clicked.emit()
+
+    def reveal(self):
+        self.is_revealed = True
+        self.update()
+
+    def click(self):
+        if not self.is_revealed:
+            self.reveal()
+            if self.adjacent_n == 0:
+                self.expandable.emit(self.x, self.y)
+
+        self.clicked.emit()
+
+    def mouseReleaseEvent(self, event):
+        if event.button() == Qt.MouseButton.RightButton and not self.is_revealed:
+            self.flag()
+            return
+
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.click()
+            if self.is_mine:
+                self.ohno.emit()
+
+
+class Minesweeper(BECWidget, QWidget):
+
+    PLUGIN = True
+    ICON_NAME = "videogame_asset"
+    USER_ACCESS = []
+
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        QWidget.__init__(self, parent=parent)
+
+        self._ui_initialised = False
+        self._timer_start_num_seconds = 0
+        self._set_level_params(LEVELS["1"])
+
+        self._init_ui()
+        self._init_map()
+
+        self.update_status(GameStatus.READY)
+        self.reset_map()
+        self.update_status(GameStatus.READY)
+
+    def _init_ui(self):
+        if self._ui_initialised:
+            return
+        self._ui_initialised = True
+
+        status_hb = QHBoxLayout()
+        self.mines = QLabel()
+        self.mines.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
+        f = self.mines.font()
+        f.setPointSize(24)
+        self.mines.setFont(f)
+
+        self.reset_button = QPushButton()
+        self.reset_button.setFixedSize(QSize(32, 32))
+        self.reset_button.setIconSize(QSize(32, 32))
+        self.reset_button.setFlat(True)
+        self.reset_button.pressed.connect(self.reset_button_pressed)
+
+        self.clock = QLabel()
+        self.clock.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
+        self.clock.setFont(f)
+        self._timer = QTimer()
+        self._timer.timeout.connect(self.update_timer)
+        self._timer.start(1000)  # 1 second timer
+        self.mines.setText(f"{self.num_mines:03d}")
+        self.clock.setText("000")
+
+        status_hb.addWidget(self.mines)
+        status_hb.addWidget(self.reset_button)
+        status_hb.addWidget(self.clock)
+
+        level_hb = QHBoxLayout()
+        self.level_selector = QComboBox()
+        self.level_selector.addItems(list(LEVELS.keys()))
+        level_hb.addWidget(QLabel("Level: "))
+        level_hb.addWidget(self.level_selector)
+        self.level_selector.currentTextChanged.connect(self.change_level)
+
+        vb = QVBoxLayout()
+        vb.addLayout(level_hb)
+        vb.addLayout(status_hb)
+
+        self.grid = QGridLayout()
+        self.grid.setSpacing(5)
+
+        vb.addLayout(self.grid)
+        self.setLayout(vb)
+
+    def _init_map(self):
+        """Redraw the grid of mines"""
+
+        # Remove any previous grid items and reset the grid
+        for i in reversed(range(self.grid.count())):
+            w: Pos = self.grid.itemAt(i).widget()
+            w.clicked.disconnect(self.on_click)
+            w.expandable.disconnect(self.expand_reveal)
+            w.ohno.disconnect(self.game_over)
+            w.setParent(None)
+            w.deleteLater()
+
+        # Add positions to the map
+        for x in range(0, self.b_size):
+            for y in range(0, self.b_size):
+                w = Pos(x, y)
+                self.grid.addWidget(w, y, x)
+                # Connect signal to handle expansion.
+                w.clicked.connect(self.on_click)
+                w.expandable.connect(self.expand_reveal)
+                w.ohno.connect(self.game_over)
+
+    def reset_map(self):
+        """
+        Reset the map and add new mines.
+        """
+        # Clear all mine positions
+        for x in range(0, self.b_size):
+            for y in range(0, self.b_size):
+                w = self.grid.itemAtPosition(y, x).widget()
+                w.reset()
+
+        # Add mines to the positions
+        positions = []
+        while len(positions) < self.num_mines:
+            x, y = (random.randint(0, self.b_size - 1), random.randint(0, self.b_size - 1))
+            if (x, y) not in positions:
+                w = self.grid.itemAtPosition(y, x).widget()
+                w.is_mine = True
+                positions.append((x, y))
+
+        def get_adjacency_n(x, y):
+            positions = self.get_surrounding(x, y)
+            num_mines = sum(1 if w.is_mine else 0 for w in positions)
+
+            return num_mines
+
+        # Add adjacencies to the positions
+        for x in range(0, self.b_size):
+            for y in range(0, self.b_size):
+                w = self.grid.itemAtPosition(y, x).widget()
+                w.adjacent_n = get_adjacency_n(x, y)
+
+        # Place starting marker
+        while True:
+            x, y = (random.randint(0, self.b_size - 1), random.randint(0, self.b_size - 1))
+            w = self.grid.itemAtPosition(y, x).widget()
+            # We don't want to start on a mine.
+            if (x, y) not in positions:
+                w = self.grid.itemAtPosition(y, x).widget()
+                w.is_start = True
+
+                # Reveal all positions around this, if they are not mines either.
+                for w in self.get_surrounding(x, y):
+                    if not w.is_mine:
+                        w.click()
+                break
+
+    def get_surrounding(self, x, y):
+        positions = []
+        for xi in range(max(0, x - 1), min(x + 2, self.b_size)):
+            for yi in range(max(0, y - 1), min(y + 2, self.b_size)):
+                positions.append(self.grid.itemAtPosition(yi, xi).widget())
+        return positions
+
+    def get_num_hidden(self) -> int:
+        """
+        Get the number of hidden positions.
+        """
+        return sum(
+            1
+            for x in range(0, self.b_size)
+            for y in range(0, self.b_size)
+            if not self.grid.itemAtPosition(y, x).widget().is_revealed
+        )
+
+    def get_num_remaining_flags(self) -> int:
+        """
+        Get the number of remaining flags.
+        """
+        return self.num_mines - sum(
+            1
+            for x in range(0, self.b_size)
+            for y in range(0, self.b_size)
+            if self.grid.itemAtPosition(y, x).widget().is_flagged
+        )
+
+    def reset_button_pressed(self):
+        match self.status:
+            case GameStatus.PLAYING:
+                self.game_over()
+            case GameStatus.FAILED | GameStatus.SUCCESS:
+                self.reset_map()
+
+    def reveal_map(self):
+        for x in range(0, self.b_size):
+            for y in range(0, self.b_size):
+                w = self.grid.itemAtPosition(y, x).widget()
+                w.reveal()
+
+    @Slot(str)
+    def change_level(self, level: str):
+        self._set_level_params(LEVELS[level])
+        self._init_map()
+        self.reset_map()
+
+    @Slot(int, int)
+    def expand_reveal(self, x, y):
+        """
+        Expand the reveal to the surrounding
+
+        Args:
+            x (int): The x position.
+            y (int): The y position.
+        """
+        for xi in range(max(0, x - 1), min(x + 2, self.b_size)):
+            for yi in range(max(0, y - 1), min(y + 2, self.b_size)):
+                w = self.grid.itemAtPosition(yi, xi).widget()
+                if not w.is_mine:
+                    w.click()
+
+    @Slot()
+    def on_click(self):
+        """
+        Handle the click event. If the game is not started, start the game.
+        """
+        self.update_available_flags()
+        if self.status != GameStatus.PLAYING:
+            # First click.
+            self.update_status(GameStatus.PLAYING)
+            # Start timer.
+            self._timer_start_num_seconds = int(time.time())
+            return
+        self.check_win()
+
+    def update_available_flags(self):
+        """
+        Update the number of available flags.
+        """
+        self.mines.setText(f"{self.get_num_remaining_flags():03d}")
+
+    def check_win(self):
+        """
+        Check if the game is won.
+        """
+        if self.get_num_hidden() == self.num_mines:
+            self.update_status(GameStatus.SUCCESS)
+
+    def update_status(self, status: GameStatus):
+        """
+        Update the status of the game.
+
+        Args:
+            status (GameStatus): The status of the game.
+        """
+        self.status = status
+        match status:
+            case GameStatus.READY:
+                icon = material_icon(icon_name="add", convert_to_pixmap=False)
+            case GameStatus.PLAYING:
+                icon = material_icon(icon_name="smart_toy", convert_to_pixmap=False)
+            case GameStatus.FAILED:
+                icon = material_icon(icon_name="error", convert_to_pixmap=False)
+            case GameStatus.SUCCESS:
+                icon = material_icon(icon_name="celebration", convert_to_pixmap=False)
+        self.reset_button.setIcon(icon)
+
+    def update_timer(self):
+        """
+        Update the timer.
+        """
+        if self.status == GameStatus.PLAYING:
+            num_seconds = int(time.time()) - self._timer_start_num_seconds
+            self.clock.setText(f"{num_seconds:03d}")
+
+    def game_over(self):
+        """Cause the game to end early"""
+        self.reveal_map()
+        self.update_status(GameStatus.FAILED)
+
+    def _set_level_params(self, level: tuple[int, int]):
+        self.b_size, self.num_mines = level
+
+
+if __name__ == "__main__":
+    from bec_widgets.utils.colors import set_theme
+
+    app = QApplication([])
+    set_theme("light")
+    widget = Minesweeper()
+    widget.show()
+
+    app.exec_()

bec_widgets/widgets/games/minesweeper.pyproject

@@ -0,0 +1 @@
+{'files': ['minesweeper.py']}

bec_widgets/widgets/games/minesweeper_plugin.py

@@ -4,36 +4,36 @@
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
 
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
+from bec_widgets.widgets.games.minesweeper import Minesweeper
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='SignalComboBox' name='signal_combobox'>
+    <widget class='Minesweeper' name='minesweeper'>
     </widget>
 </ui>
 """
 
 
-class SignalComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+class MinesweeperPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
         super().__init__()
         self._form_editor = None
 
     def createWidget(self, parent):
-        t = SignalComboBox(parent)
+        t = Minesweeper(parent)
         return t
 
     def domXml(self):
         return DOM_XML
 
     def group(self):
-        return "BEC Input Widgets"
+        return "BEC Games"
 
     def icon(self):
-        return designer_material_icon(SignalComboBox.ICON_NAME)
+        return designer_material_icon(Minesweeper.ICON_NAME)
 
     def includeFile(self):
-        return "signal_combobox"
+        return "minesweeper"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -45,10 +45,10 @@ class SignalComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return self._form_editor is not None
 
     def name(self):
-        return "SignalComboBox"
+        return "Minesweeper"
 
     def toolTip(self):
-        return ""
+        return "Minesweeper"
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/games/register_minesweeper.py

@@ -6,11 +6,9 @@ def main():  # pragma: no cover
         return
     from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
 
-    from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox_plugin import (
-        SignalComboBoxPlugin,
-    )
+    from bec_widgets.widgets.games.minesweeper_plugin import MinesweeperPlugin
 
-    QPyDesignerCustomWidgetCollection.addCustomWidget(SignalComboBoxPlugin())
+    QPyDesignerCustomWidgetCollection.addCustomWidget(MinesweeperPlugin())
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/widgets/utility/spinner/spinner.py

@@ -75,7 +75,7 @@ class SpinnerWidget(QWidget):
             proportion = 1 / 4
             angle_span = int(proportion * 360 * 16)
             angle_span += angle_span * ease_in_out_sine(self.time / self.duration)
-            painter.drawArc(adjusted_rect, self.angle * 16, int(angle_span))
+            painter.drawArc(adjusted_rect, int(self.angle * 16), int(angle_span))
         painter.end()
 
     def closeEvent(self, event):

docs/user/widgets/games/games.md

@@ -0,0 +1,11 @@
+(user.widgets.games)=
+
+# Game widgets
+
+To provide some entertainment during long nights at the beamline, there are game widgets available. Well, only one, so far.
+
+## Minesweeper
+
+![Minesweeper](./minesweeper.png)
+
+The classic game Minesweeper. You may select from three different levels. The game can be ended or reset by clicking on the icon in the top-centre (the robot in the screenshot).

docs/user/widgets/positioner_box/positioner_box_2d.md

@@ -0,0 +1,60 @@
+(user.widgets.positioner_box_2d)=
+
+# Positioner Box Widget
+
+````{tab} Overview
+
+The [`PositionerBox2D`](/api_reference/_autosummary/bec_widgets.cli.client.PositionerBox2D) widget is very similar to the ['PositionerBox'](/user/widgets/positioner_box/positioner_box) but allows controlling two positioners at the same time, in a horizontal and vertical orientation respectively. It is intended primarily for controlling axes which have a perpendicular relationship like that. In other cases, it may be better to use a `PositionerGroup` instead. 
+
+The `PositionerBox2D` has the same features as the standard `PositionerBox`, but additionally, step buttons which move the positioner by the selected step size, and tweak buttons which move by a tenth of the selected step size.
+
+````
+
+````{tab} Examples
+
+The `PositionerBox2D` widget can be integrated within a GUI application either through direct code instantiation or by using `QtDesigner`. Below are examples demonstrating how to create and use the `PositionerBox2D` widget.
+
+## Example 1 - Creating a PositionerBox in Code
+
+In this example, we demonstrate how to create a `PositionerBox2D` widget in code and configure it for a specific device.
+
+```python
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+from bec_widgets.widgets.positioner_box import PositionerBox2D
+
+class MyGui(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setLayout(QVBoxLayout(self))  # Initialize the layout for the widget
+
+        # Create and add the PositionerBox to the layout
+        self.positioner_box_2d = PositionerBox(device_hor="horizontal_motor", device_ver="vertical_motor")
+        self.layout().addWidget(self.positioner_box_2d)
+
+# Example of how this custom GUI might be used:
+app = QApplication([])
+my_gui = MyGui()
+my_gui.show()
+app.exec_()
+```
+
+## Example 2 - Selecting a Device via GUI
+
+Users can select the positioner device by clicking the button under the device label, which opens a dialog for device selection.
+
+## Example 3 - Customizing PositionerBox in QtDesigner
+
+The `PositionerBox2D` widget can be added to a GUI through `QtDesigner`. Once integrated, you can configure the default device and customize the widget’s appearance and behavior directly within the designer.
+
+```python
+# After adding the widget to a form in QtDesigner, you can configure the device:
+self.positioner_box.set_positioner_hor("samx")
+self.positioner_box.set_positioner_verr("samy")
+```
+````
+
+````{tab} API
+```{eval-rst} 
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.PositionerBox2D.rst
+```
+````

docs/user/widgets/widgets.md

@@ -102,6 +102,14 @@ Find and drag devices.
 Control individual device.
 ```
 
+```{grid-item-card}  Positioner Box 2D
+:link: user.widgets.positioner_box_2d
+:link-type: ref
+:img-top: /assets/widget_screenshots/positioner_box_2d.png
+
+Control two individual devices on perpendicular axes.
+```
+
 ```{grid-item-card} Ring Progress Bar 
 :link: user.widgets.ring_progress_bar
 :link-type: ref
@@ -260,6 +268,7 @@ buttons_appearance/buttons_appearance.md
 buttons_queue/button_queue.md
 device_browser/device_browser.md
 positioner_box/positioner_box.md
+positioner_box/positioner_box_2d.md
 text_box/text_box.md
 website/website.md
 toggle/toggle.md
@@ -270,5 +279,6 @@ signal_input/signal_input.md
 position_indicator/position_indicator.md
 lmfit_dialog/lmfit_dialog.md
 dap_combo_box/dap_combo_box.md
+games/games.md
 
 ```

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "1.7.0"
+version = "1.17.1"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -30,7 +30,7 @@ dependencies = [
 dev = [
     "coverage~=7.0",
     "fakeredis~=2.23, >=2.23.2",
-    "pytest-bec-e2e~=2.16",
+    "pytest-bec-e2e>=2.21.4, <=4.0",
     "pytest-qt~=4.4",
     "pytest-random-order~=1.1",
     "pytest-timeout~=2.2",

tests/end-2-end/conftest.py

@@ -5,8 +5,7 @@ from contextlib import contextmanager
 import pytest
 from bec_lib.endpoints import MessageEndpoints
 
-from bec_widgets.cli.client import BECDockArea
-from bec_widgets.cli.client_utils import _start_plot_process
+from bec_widgets.cli.client_utils import BECGuiClient, _start_plot_process
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.widgets.containers.figure import BECFigure
 
@@ -41,27 +40,37 @@ def plot_server(gui_id, klass, client_lib):
 
 
 @pytest.fixture
-def rpc_server_figure(gui_id, bec_client_lib):
+def connected_client_figure(gui_id, bec_client_lib):
     with plot_server(gui_id, BECFigure, bec_client_lib) as server:
         yield server
 
 
 @pytest.fixture
-def rpc_server_dock(gui_id, bec_client_lib):
-    dock_area = BECDockArea(gui_id=gui_id)
-    dock_area._auto_updates_enabled = False
+def connected_client_gui_obj(gui_id, bec_client_lib):
+    gui = BECGuiClient(gui_id=gui_id)
     try:
-        dock_area.start_server(wait=True)
-        yield dock_area
+        gui.start_server(wait=True)
+        yield gui
     finally:
-        dock_area.close()
+        gui.close()
 
 
 @pytest.fixture
-def rpc_server_dock_w_auto_updates(gui_id, bec_client_lib):
-    dock_area = BECDockArea(gui_id=gui_id)
+def connected_client_dock(gui_id, bec_client_lib):
+    gui = BECGuiClient(gui_id=gui_id)
+    gui._auto_updates_enabled = False
     try:
-        dock_area.start_server(wait=True)
-        yield dock_area
+        gui.start_server(wait=True)
+        yield gui.main
     finally:
-        dock_area.close()
+        gui.close()
+
+
+@pytest.fixture
+def connected_client_dock_w_auto_updates(gui_id, bec_client_lib):
+    gui = BECGuiClient(gui_id=gui_id)
+    try:
+        gui.start_server(wait=True)
+        yield gui, gui.main
+    finally:
+        gui.close()

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -1,10 +1,11 @@
 import time
 
 import numpy as np
+import pytest
 from bec_lib.endpoints import MessageEndpoints
 
-from bec_widgets.cli.auto_updates import AutoUpdates
-from bec_widgets.cli.client import BECDockArea, BECFigure, BECImageShow, BECMotorMap, BECWaveform
+from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
+from bec_widgets.tests.utils import check_remote_data_size
 from bec_widgets.utils import Colors
 
 # pylint: disable=unused-argument
@@ -12,9 +13,9 @@ from bec_widgets.utils import Colors
 # pylint: disable=too-many-locals
 
 
-def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
+def test_rpc_add_dock_with_figure_e2e(qtbot, bec_client_lib, connected_client_dock):
     # BEC client shortcuts
-    dock = rpc_server_dock
+    dock = connected_client_dock
     client = bec_client_lib
     dev = client.device_manager.devices
     scans = client.scans
@@ -88,14 +89,17 @@ def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
 
     # Try to make a scan
     status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
-
-    # wait for scan to finish
-    while not status.status == "COMPLETED":
-        time.sleep(0.2)
+    status.wait()
 
     # plot
     item = queue.scan_storage.storage[-1]
     plt_last_scan_data = item.live_data if hasattr(item, "live_data") else item.data
+    num_elements = 10
+
+    plot_name = "bpm4i-bpm4i"
+
+    qtbot.waitUntil(lambda: check_remote_data_size(plt, plot_name, num_elements))
+
     plt_data = plt.get_all_data()
     assert plt_data["bpm4i-bpm4i"]["x"] == plt_last_scan_data["samx"]["samx"].val
     assert plt_data["bpm4i-bpm4i"]["y"] == plt_last_scan_data["bpm4i"]["bpm4i"].val
@@ -123,8 +127,8 @@ def test_rpc_add_dock_with_figure_e2e(bec_client_lib, rpc_server_dock):
     )
 
 
-def test_dock_manipulations_e2e(rpc_server_dock):
-    dock = rpc_server_dock
+def test_dock_manipulations_e2e(connected_client_dock):
+    dock = connected_client_dock
 
     d0 = dock.add_dock("dock_0")
     d1 = dock.add_dock("dock_1")
@@ -155,8 +159,8 @@ def test_dock_manipulations_e2e(rpc_server_dock):
     assert len(dock.temp_areas) == 0
 
 
-def test_ring_bar(rpc_server_dock):
-    dock = rpc_server_dock
+def test_ring_bar(connected_client_dock):
+    dock = connected_client_dock
 
     d0 = dock.add_dock(name="dock_0")
 
@@ -182,8 +186,8 @@ def test_ring_bar(rpc_server_dock):
     assert bar_colors == expected_colors_light or bar_colors == expected_colors_dark
 
 
-def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
-    dock = rpc_server_dock
+def test_ring_bar_scan_update(bec_client_lib, connected_client_dock):
+    dock = connected_client_dock
 
     d0 = dock.add_dock("dock_0")
 
@@ -234,19 +238,20 @@ def test_ring_bar_scan_update(bec_client_lib, rpc_server_dock):
     assert bar_config["rings"][1]["max_value"] == final_samy
 
 
-def test_auto_update(bec_client_lib, rpc_server_dock_w_auto_updates, qtbot):
+def test_auto_update(bec_client_lib, connected_client_dock_w_auto_updates, qtbot):
     client = bec_client_lib
     dev = client.device_manager.devices
     scans = client.scans
     queue = client.queue
-    dock = rpc_server_dock_w_auto_updates
+    gui, dock = connected_client_dock_w_auto_updates
+    auto_updates = gui.auto_updates
 
     def get_default_figure():
-        return dock.auto_updates.get_default_figure()
+        return auto_updates.get_default_figure()
 
     plt = get_default_figure()
 
-    dock.selected_device = "bpm4i"
+    gui.selected_device = "bpm4i"
 
     status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
     status.wait()
@@ -254,11 +259,17 @@ def test_auto_update(bec_client_lib, rpc_server_dock_w_auto_updates, qtbot):
     # get data from curves
     widgets = plt.widget_list
     qtbot.waitUntil(lambda: len(plt.widget_list) > 0, timeout=5000)
-    plt_data = widgets[0].get_all_data()
 
     item = queue.scan_storage.storage[-1]
     last_scan_data = item.live_data if hasattr(item, "live_data") else item.data
 
+    num_elements = 10
+
+    plot_name = f"Scan {status.scan.scan_number} - {dock.selected_device}"
+
+    qtbot.waitUntil(lambda: check_remote_data_size(widgets[0], plot_name, num_elements))
+    plt_data = widgets[0].get_all_data()
+
     # check plotted data
     assert (
         plt_data[f"Scan {status.scan.scan_number} - bpm4i"]["x"]
@@ -274,14 +285,20 @@ def test_auto_update(bec_client_lib, rpc_server_dock_w_auto_updates, qtbot):
     )
     status.wait()
 
-    plt = dock.auto_updates.get_default_figure()
+    plt = auto_updates.get_default_figure()
     widgets = plt.widget_list
+
     qtbot.waitUntil(lambda: len(plt.widget_list) > 0, timeout=5000)
-    plt_data = widgets[0].get_all_data()
 
     item = queue.scan_storage.storage[-1]
     last_scan_data = item.live_data if hasattr(item, "live_data") else item.data
 
+    plot_name = f"Scan {status.scan.scan_number} - bpm4i"
+
+    num_elements_bec = 25
+    qtbot.waitUntil(lambda: check_remote_data_size(widgets[0], plot_name, num_elements_bec))
+    plt_data = widgets[0].get_all_data()
+
     # check plotted data
     assert (
         plt_data[f"Scan {status.scan.scan_number} - {dock.selected_device}"]["x"]
@@ -291,3 +308,70 @@ def test_auto_update(bec_client_lib, rpc_server_dock_w_auto_updates, qtbot):
         plt_data[f"Scan {status.scan.scan_number} - {dock.selected_device}"]["y"]
         == last_scan_data["samy"]["samy"].val
     )
+
+
+def test_rpc_gui_obj(connected_client_gui_obj, qtbot):
+    gui = connected_client_gui_obj
+
+    assert gui.selected_device is None
+    assert len(gui.windows) == 1
+    assert gui.windows["main"].widget is gui.main
+    assert gui.windows["main"].title == "BEC Widgets"
+    mw = gui.main
+    assert mw.__class__.__name__ == "BECDockArea"
+
+    xw = gui.new("X")
+    assert xw.__class__.__name__ == "BECDockArea"
+    assert len(gui.windows) == 2
+
+    gui_info = gui._dump()
+    mw_info = gui_info[mw._gui_id]
+    assert mw_info["title"] == "BEC Widgets"
+    assert mw_info["visible"]
+    xw_info = gui_info[xw._gui_id]
+    assert xw_info["title"] == "X"
+    assert xw_info["visible"]
+
+    gui.hide()
+    gui_info = gui._dump()
+    assert not any(windows["visible"] for windows in gui_info.values())
+
+    gui.show()
+    gui_info = gui._dump()
+    assert all(windows["visible"] for windows in gui_info.values())
+
+    assert gui.gui_is_alive()
+    gui.close()
+    assert not gui.gui_is_alive()
+    gui.start_server(wait=True)
+    assert gui.gui_is_alive()
+    # calling start multiple times should not change anything
+    gui.start_server(wait=True)
+    gui.start()
+    # gui.windows should have main, and main dock area should have same gui_id as before
+    assert len(gui.windows) == 1
+    assert gui.windows["main"].widget._gui_id == mw._gui_id
+    # communication should work, main dock area should have same id and be visible
+    gui_info = gui._dump()
+    assert gui_info[mw._gui_id]["visible"]
+
+    with pytest.raises(RuntimeError):
+        gui.main.delete()
+
+    yw = gui.new("Y")
+    assert len(gui.windows) == 2
+    yw.delete()
+    assert len(gui.windows) == 1
+    # check it is really deleted on server
+    gui_info = gui._dump()
+    assert yw._gui_id not in gui_info
+
+
+def test_rpc_call_with_exception_in_safeslot_error_popup(connected_client_gui_obj, qtbot):
+    gui = connected_client_gui_obj
+
+    gui.main.add_dock("test")
+    qtbot.waitUntil(lambda: len(gui.main.panels) == 2)  # default_figure + test
+    with pytest.raises(ValueError):
+        gui.main.add_dock("test")
+        # time.sleep(0.1)

tests/end-2-end/test_bec_figure_rpc_e2e.py

@@ -1,14 +1,14 @@
 import time
 
 import numpy as np
-import pytest
 from bec_lib.endpoints import MessageEndpoints
 
 from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
+from bec_widgets.tests.utils import check_remote_data_size
 
 
-def test_rpc_waveform1d_custom_curve(rpc_server_figure):
-    fig = BECFigure(rpc_server_figure)
+def test_rpc_waveform1d_custom_curve(connected_client_figure):
+    fig = BECFigure(connected_client_figure)
 
     ax = fig.plot()
     curve = ax.plot(x=[1, 2, 3], y=[1, 2, 3])
@@ -20,8 +20,8 @@ def test_rpc_waveform1d_custom_curve(rpc_server_figure):
     assert len(fig.widgets[ax._rpc_id].curves) == 1
 
 
-def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
-    fig = BECFigure(rpc_server_figure)
+def test_rpc_plotting_shortcuts_init_configs(connected_client_figure, qtbot):
+    fig = BECFigure(connected_client_figure)
 
     plt = fig.plot(x_name="samx", y_name="bpm4i")
     im = fig.image("eiger")
@@ -78,8 +78,8 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
     }
 
 
-def test_rpc_waveform_scan(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
+def test_rpc_waveform_scan(qtbot, connected_client_figure, bec_client_lib):
+    fig = BECFigure(connected_client_figure)
 
     # add 3 different curves to track
     plt = fig.plot(x_name="samx", y_name="bpm4i")
@@ -97,6 +97,11 @@ def test_rpc_waveform_scan(rpc_server_figure, bec_client_lib):
     item = queue.scan_storage.storage[-1]
     last_scan_data = item.live_data if hasattr(item, "live_data") else item.data
 
+    num_elements = 10
+
+    for plot_name in ["bpm4i-bpm4i", "bpm3a-bpm3a", "bpm4d-bpm4d"]:
+        qtbot.waitUntil(lambda: check_remote_data_size(plt, plot_name, num_elements))
+
     # get data from curves
     plt_data = plt.get_all_data()
 
@@ -109,8 +114,8 @@ def test_rpc_waveform_scan(rpc_server_figure, bec_client_lib):
     assert plt_data["bpm4d-bpm4d"]["y"] == last_scan_data["bpm4d"]["bpm4d"].val
 
 
-def test_rpc_image(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
+def test_rpc_image(connected_client_figure, bec_client_lib):
+    fig = BECFigure(connected_client_figure)
 
     im = fig.image("eiger")
 
@@ -130,8 +135,8 @@ def test_rpc_image(rpc_server_figure, bec_client_lib):
     np.testing.assert_equal(last_image_device, last_image_plot)
 
 
-def test_rpc_motor_map(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
+def test_rpc_motor_map(connected_client_figure, bec_client_lib):
+    fig = BECFigure(connected_client_figure)
 
     motor_map = fig.motor_map("samx", "samy")
 
@@ -159,9 +164,9 @@ def test_rpc_motor_map(rpc_server_figure, bec_client_lib):
     )
 
 
-def test_dap_rpc(rpc_server_figure, bec_client_lib, qtbot):
+def test_dap_rpc(connected_client_figure, bec_client_lib, qtbot):
 
-    fig = BECFigure(rpc_server_figure)
+    fig = BECFigure(connected_client_figure)
     plt = fig.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
 
     client = bec_client_lib
@@ -199,8 +204,8 @@ def test_dap_rpc(rpc_server_figure, bec_client_lib, qtbot):
     qtbot.waitUntil(wait_for_fit, timeout=10000)
 
 
-def test_removing_subplots(rpc_server_figure, bec_client_lib):
-    fig = BECFigure(rpc_server_figure)
+def test_removing_subplots(connected_client_figure, bec_client_lib):
+    fig = BECFigure(connected_client_figure)
     plt = fig.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
     im = fig.image(monitor="eiger")
     mm = fig.motor_map(motor_x="samx", motor_y="samy")

tests/end-2-end/test_rpc_register_e2e.py

@@ -3,8 +3,8 @@ import pytest
 from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
 
 
-def test_rpc_register_list_connections(rpc_server_figure):
-    fig = BECFigure(rpc_server_figure)
+def test_rpc_register_list_connections(connected_client_figure):
+    fig = BECFigure(connected_client_figure)
 
     plt = fig.plot(x_name="samx", y_name="bpm4i")
     im = fig.image("eiger")

tests/unit_tests/conftest.py

@@ -5,7 +5,7 @@ from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
 from qtpy.QtCore import QTimer
 from qtpy.QtWidgets import QApplication
 
-from bec_widgets.cli.rpc_register import RPCRegister
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.qt_utils import error_popups
 from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
 

tests/unit_tests/test_client_utils.py

@@ -4,7 +4,7 @@ from unittest import mock
 import pytest
 
 from bec_widgets.cli.client import BECFigure
-from bec_widgets.cli.client_utils import BECGuiClientMixin, _start_plot_process
+from bec_widgets.cli.client_utils import BECGuiClient, _start_plot_process
 from bec_widgets.tests.utils import FakeDevice
 
 
@@ -63,15 +63,14 @@ def test_client_utils_passes_client_config_to_server(bec_dispatcher):
 
     @contextmanager
     def bec_client_mixin():
-        mixin = BECGuiClientMixin()
+        mixin = BECGuiClient()
         mixin._client = bec_dispatcher.client
         mixin._gui_id = "gui_id"
         mixin.gui_is_alive = mock.MagicMock()
         mixin.gui_is_alive.side_effect = [True]
 
         try:
-            with mock.patch.object(mixin, "_start_update_script"):
-                yield mixin
+            yield mixin
         finally:
             mixin.close()
 
@@ -82,6 +81,5 @@ def test_client_utils_passes_client_config_to_server(bec_dispatcher):
                 wait=False
             )  # the started event will not be set, wait=True would block forever
             mock_start_plot.assert_called_once_with(
-                "gui_id", BECGuiClientMixin, mixin._client._service_config.config, logger=mock.ANY
+                "gui_id", BECGuiClient, mixin._client._service_config.config, logger=mock.ANY
             )
-            mixin._start_update_script.assert_called_once()

tests/unit_tests/test_collapsible_panel_manager.py

@@ -0,0 +1,308 @@
+import pytest
+from qtpy.QtCore import QEasingCurve
+from qtpy.QtWidgets import QPushButton, QVBoxLayout, QWidget
+
+from bec_widgets.qt_utils.collapsible_panel_manager import (
+    CollapsiblePanelManager,
+    DimensionAnimator,
+)
+from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
+
+
+@pytest.fixture
+def reference_widget(qtbot):
+    widget = QWidget()
+    layout = QVBoxLayout(widget)
+    btn = QPushButton("Reference")
+    layout.addWidget(btn)
+    qtbot.addWidget(widget)
+    widget.setVisible(True)
+    qtbot.waitExposed(widget)
+    return widget
+
+
+@pytest.fixture
+def layout_manager(qtbot, reference_widget):
+    manager = LayoutManagerWidget()
+    qtbot.addWidget(manager)
+    manager.add_widget(reference_widget, row=0, col=0)
+    manager.setVisible(True)
+    qtbot.waitExposed(manager)
+    return manager
+
+
+@pytest.fixture
+def panel_manager(layout_manager, reference_widget):
+    manager = CollapsiblePanelManager(layout_manager, reference_widget)
+    return manager
+
+
+@pytest.fixture
+def test_panel_widget(qtbot):
+    widget = QWidget()
+    qtbot.addWidget(widget)
+    return widget
+
+
+def test_dimension_animator_width_setting(qtbot, test_panel_widget):
+    animator = DimensionAnimator(test_panel_widget, "left")
+    animator.panel_width = 100
+    assert animator.panel_width == 100
+    assert test_panel_widget.width() == 100
+
+
+def test_dimension_animator_height_setting(qtbot, test_panel_widget):
+    animator = DimensionAnimator(test_panel_widget, "top")
+    animator.panel_height = 150
+    assert animator.panel_height == 150
+    assert test_panel_widget.height() == 150
+
+
+def test_add_panel(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=200)
+    assert panel_manager.panels["left"]["widget"] == test_panel_widget
+    # Initially hidden
+    assert not test_panel_widget.isVisible()
+    assert test_panel_widget.maximumWidth() == 0
+
+
+def test_add_panel_no_target_size(panel_manager, test_panel_widget):
+    panel_manager.add_panel("top", test_panel_widget)
+    assert panel_manager.panels["top"]["target_size"] == 150
+    assert not test_panel_widget.isVisible()
+
+
+def test_add_panel_invalid_direction(panel_manager, test_panel_widget):
+    with pytest.raises(ValueError) as exc_info:
+        panel_manager.add_panel("invalid", test_panel_widget)
+    assert "Direction must be one of 'left', 'right', 'top', 'bottom'." in str(exc_info.value)
+
+
+def test_toggle_panel_show(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=200)
+    assert not test_panel_widget.isVisible()
+
+    panel_manager.toggle_panel("left", animation=False)
+    assert test_panel_widget.isVisible()
+
+
+def test_toggle_panel_hide(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=200)
+    panel_manager.toggle_panel("left", animation=False)
+    assert test_panel_widget.isVisible()
+
+    panel_manager.toggle_panel("left", animation=False)
+    assert not test_panel_widget.isVisible()
+
+
+def test_toggle_panel_scale(panel_manager, test_panel_widget, reference_widget):
+    reference_widget.resize(800, 600)
+    panel_manager.add_panel("right", test_panel_widget)
+    panel_manager.toggle_panel("right", scale=0.25, animation=False)
+    assert test_panel_widget.isVisible()
+    assert test_panel_widget.maximumWidth() == 200
+
+
+def test_toggle_panel_ensure_max(panel_manager, test_panel_widget):
+    panel_manager.add_panel("bottom", test_panel_widget, target_size=150)
+    panel_manager.toggle_panel("bottom", ensure_max=True, animation=False)
+    assert test_panel_widget.isVisible()
+    assert test_panel_widget.maximumHeight() == 150
+    panel_manager.toggle_panel("bottom", ensure_max=True, animation=False)
+    assert not test_panel_widget.isVisible()
+    assert test_panel_widget.maximumHeight() == 16777215
+
+
+def test_toggle_panel_easing_curve(panel_manager, test_panel_widget):
+    panel_manager.add_panel("top", test_panel_widget, target_size=100, duration=500)
+    panel_manager.toggle_panel("top", easing_curve=QEasingCurve.OutBounce, animation=True)
+    assert panel_manager.animations.get(test_panel_widget) is not None
+
+
+def test_toggle_nonexistent_panel(panel_manager):
+    with pytest.raises(ValueError) as exc_info:
+        panel_manager.toggle_panel("invalid")
+    assert "No panel found in direction 'invalid'." in str(exc_info.value)
+
+
+def test_toggle_panel_without_animation(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=200)
+    panel_manager.toggle_panel("left", animation=False)
+    assert test_panel_widget.isVisible()
+    assert test_panel_widget.maximumWidth() == 200
+    panel_manager.toggle_panel("left", animation=False)
+    assert not test_panel_widget.isVisible()
+
+
+def test_after_hide_reset(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=200)
+    panel_manager.toggle_panel("left", ensure_max=True, animation=False)
+    assert test_panel_widget.isVisible()
+    panel_manager.toggle_panel("left", ensure_max=True, animation=False)
+    assert not test_panel_widget.isVisible()
+    assert test_panel_widget.minimumWidth() == 0
+    assert test_panel_widget.maximumWidth() == 0
+
+
+def test_toggle_panel_repeated(panel_manager, test_panel_widget):
+    panel_manager.add_panel("right", test_panel_widget, target_size=200)
+    panel_manager.toggle_panel("right", animation=False)
+    assert test_panel_widget.isVisible()
+    panel_manager.toggle_panel("right", animation=False)
+    assert not test_panel_widget.isVisible()
+    panel_manager.toggle_panel("right", animation=False)
+    assert test_panel_widget.isVisible()
+
+
+def test_toggle_panel_with_custom_duration(panel_manager, test_panel_widget):
+    panel_manager.add_panel("bottom", test_panel_widget, target_size=150, duration=1000)
+    panel_manager.toggle_panel("bottom", duration=2000, animation=True)
+    animation = panel_manager.animations.get(test_panel_widget)
+    assert animation is not None
+    assert animation.duration() == 2000
+
+
+def test_toggle_panel_ensure_max_scale(panel_manager, test_panel_widget, reference_widget):
+    reference_widget.resize(1000, 800)
+    panel_manager.add_panel("top", test_panel_widget)
+    panel_manager.toggle_panel("top", ensure_max=True, scale=0.5, animation=False)
+    assert test_panel_widget.isVisible()
+    assert test_panel_widget.maximumHeight() == 400
+
+
+def test_no_animation_mode(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=200)
+    panel_manager.toggle_panel("left", animation=False)
+    assert test_panel_widget.isVisible()
+    panel_manager.toggle_panel("left", animation=False)
+    assert not test_panel_widget.isVisible()
+
+
+def test_toggle_panel_nondefault_easing(panel_manager, test_panel_widget):
+    panel_manager.add_panel("right", test_panel_widget, target_size=200)
+    panel_manager.toggle_panel("right", easing_curve=QEasingCurve.InCurve, animation=True)
+    animation = panel_manager.animations.get(test_panel_widget)
+    assert animation is not None
+    assert animation.easingCurve() == QEasingCurve.InCurve
+
+
+def test_toggle_panel_ensure_max_no_animation(panel_manager, test_panel_widget):
+    panel_manager.add_panel("bottom", test_panel_widget, target_size=150)
+    panel_manager.toggle_panel("bottom", ensure_max=True, animation=False)
+    assert test_panel_widget.isVisible()
+    assert test_panel_widget.maximumHeight() == 150
+    panel_manager.toggle_panel("bottom", ensure_max=True, animation=False)
+    assert not test_panel_widget.isVisible()
+    assert test_panel_widget.maximumHeight() == 16777215
+
+
+def test_toggle_panel_new_target_size(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=200)
+    panel_manager.toggle_panel("left", target_size=300, animation=False)
+    assert test_panel_widget.isVisible()
+    assert test_panel_widget.maximumWidth() == 300
+    panel_manager.toggle_panel("left", animation=False)
+    assert not test_panel_widget.isVisible()
+
+
+def test_toggle_panel_new_duration(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=200, duration=300)
+    panel_manager.toggle_panel("left", duration=1000, animation=True)
+    animation = panel_manager.animations.get(test_panel_widget)
+    assert animation.duration() == 1000
+
+
+def test_toggle_panel_wrong_direction(panel_manager):
+    with pytest.raises(ValueError) as exc:
+        panel_manager.toggle_panel("unknown_direction")
+    assert "No panel found in direction 'unknown_direction'." in str(exc.value)
+
+
+def test_toggle_panel_no_panels(panel_manager):
+    with pytest.raises(ValueError) as exc:
+        panel_manager.toggle_panel("top")
+    assert "No panel found in direction 'top'." in str(exc.value)
+
+
+def test_multiple_panels_interaction(panel_manager):
+    widget_left = QWidget()
+    widget_right = QWidget()
+    panel_manager.add_panel("left", widget_left, target_size=200)
+    panel_manager.add_panel("right", widget_right, target_size=300)
+
+    panel_manager.toggle_panel("left", animation=False)
+    assert widget_left.isVisible()
+
+    panel_manager.toggle_panel("right", animation=False)
+    assert widget_right.isVisible()
+
+    panel_manager.toggle_panel("left", animation=False)
+    assert not widget_left.isVisible()
+    assert widget_right.isVisible()
+
+    panel_manager.toggle_panel("right", animation=False)
+    assert not widget_right.isVisible()
+
+
+def test_panel_manager_custom_easing(panel_manager, test_panel_widget):
+    panel_manager.add_panel("top", test_panel_widget, target_size=150)
+    panel_manager.toggle_panel("top", easing_curve=QEasingCurve.InQuad, animation=True)
+    animation = panel_manager.animations.get(test_panel_widget)
+    assert animation is not None
+    assert animation.easingCurve() == QEasingCurve.InQuad
+
+
+def test_toggle_panel_scale_no_animation(panel_manager, test_panel_widget, reference_widget):
+    reference_widget.resize(400, 300)
+    panel_manager.add_panel("bottom", test_panel_widget)
+    panel_manager.toggle_panel("bottom", scale=0.5, animation=False)
+    assert test_panel_widget.isVisible()
+    assert test_panel_widget.maximumHeight() == 150
+    panel_manager.toggle_panel("bottom", animation=False)
+    assert not test_panel_widget.isVisible()
+
+
+def test_after_hide_reset_properties(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=200)
+    panel_manager.toggle_panel("left", ensure_max=True, animation=False)
+    panel_manager.toggle_panel("left", ensure_max=True, animation=False)
+    assert not test_panel_widget.isVisible()
+    assert test_panel_widget.minimumWidth() == 0
+    assert test_panel_widget.maximumWidth() == 0
+
+
+def test_toggle_panel_no_animation_show_only(panel_manager, test_panel_widget):
+    panel_manager.add_panel("right", test_panel_widget, target_size=100)
+    panel_manager.toggle_panel("right", animation=False)
+    assert test_panel_widget.isVisible()
+    assert test_panel_widget.maximumWidth() == 100
+
+
+def test_toggle_panel_no_animation_hide_only(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=100)
+    panel_manager.toggle_panel("left", animation=False)
+    assert test_panel_widget.isVisible()
+    panel_manager.toggle_panel("left", animation=False)
+    assert not test_panel_widget.isVisible()
+
+
+def test_toggle_panel_easing_inout(panel_manager, test_panel_widget):
+    panel_manager.add_panel("top", test_panel_widget, target_size=120)
+    panel_manager.toggle_panel("top", easing_curve=QEasingCurve.InOutQuad, animation=True)
+    animation = panel_manager.animations.get(test_panel_widget)
+    assert animation is not None
+    assert animation.easingCurve() == QEasingCurve.InOutQuad
+
+
+def test_toggle_panel_ensure_max_width(panel_manager, test_panel_widget):
+    panel_manager.add_panel("right", test_panel_widget, target_size=200)
+    panel_manager.toggle_panel("right", ensure_max=True, animation=False)
+    assert test_panel_widget.isVisible()
+    assert test_panel_widget.maximumWidth() == 200
+
+
+def test_toggle_panel_invalid_direction_twice(panel_manager, test_panel_widget):
+    panel_manager.add_panel("left", test_panel_widget, target_size=200)
+    with pytest.raises(ValueError) as exc_info:
+        panel_manager.toggle_panel("invalid_direction")
+    assert "No panel found in direction 'invalid_direction'." in str(exc_info.value)

tests/unit_tests/test_error_utils.py

@@ -1,10 +1,33 @@
+import sys
 from unittest.mock import patch
 
 import pytest
 import pytestqt
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QObject
 from qtpy.QtWidgets import QMessageBox
 
-from bec_widgets.qt_utils.error_popups import ErrorPopupUtility, ExampleWidget
+from bec_widgets.qt_utils.error_popups import ErrorPopupUtility, ExampleWidget, SafeProperty
+
+
+class TestSafePropertyClass(QObject):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._my_value = 10  # internal store
+
+    @SafeProperty(int, default=-1)
+    def my_value(self) -> int:
+        # artificially raise if it's 999 for testing
+        if self._my_value == 999:
+            raise ValueError("Invalid internal state in getter!")
+        return self._my_value
+
+    @my_value.setter
+    def my_value(self, val: int):
+        # artificially raise if user sets -999 for testing
+        if val == -999:
+            raise ValueError("Invalid user input in setter!")
+        self._my_value = val
 
 
 @pytest.fixture
@@ -18,46 +41,109 @@ def widget(qtbot):
 
 @patch.object(QMessageBox, "exec_", return_value=QMessageBox.Ok)
 def test_show_error_message_global(mock_exec, widget, qtbot):
+    """
+    Test that an error popup is shown if global error popups are enabled
+    and the error_occurred signal is emitted manually.
+    """
     error_utility = ErrorPopupUtility()
     error_utility.enable_global_error_popups(True)
 
     with qtbot.waitSignal(error_utility.error_occurred, timeout=1000) as blocker:
         error_utility.error_occurred.emit("Test Error", "This is a test error message.", widget)
 
-    assert mock_exec.called
     assert blocker.signal_triggered
+    assert mock_exec.called
 
 
 @pytest.mark.parametrize("global_pop", [False, True])
 @patch.object(QMessageBox, "exec_", return_value=QMessageBox.Ok)
 def test_slot_with_popup_on_error(mock_exec, widget, qtbot, global_pop):
+    """
+    If the slot is decorated with @SafeSlot(popup_error=True),
+    we always expect a popup on error (and a signal) even if global popups are off.
+    """
     error_utility = ErrorPopupUtility()
     error_utility.enable_global_error_popups(global_pop)
 
-    with qtbot.waitSignal(error_utility.error_occurred, timeout=200) as blocker:
+    with qtbot.waitSignal(error_utility.error_occurred, timeout=500) as blocker:
         widget.method_with_error_handling()
 
     assert blocker.signal_triggered
-    assert mock_exec.called
+    assert mock_exec.called  # Because popup_error=True forces popup
 
 
 @pytest.mark.parametrize("global_pop", [False, True])
+@patch.object(bec_logger.logger, "error")
 @patch.object(QMessageBox, "exec_", return_value=QMessageBox.Ok)
-def test_slot_no_popup_by_default_on_error(mock_exec, widget, qtbot, capsys, global_pop):
+def test_slot_no_popup_by_default_on_error(mock_exec, mock_log_error, widget, qtbot, global_pop):
+    """
+    If the slot is decorated with @SafeSlot() (no popup_error=True),
+    we never show a popup, even if global popups are on,
+    because the code does not check 'enable_error_popup' for normal slots.
+    """
     error_utility = ErrorPopupUtility()
     error_utility.enable_global_error_popups(global_pop)
 
-    try:
-        with qtbot.waitSignal(error_utility.error_occurred, timeout=200) as blocker:
-            widget.method_without_error_handling()
-    except pytestqt.exceptions.TimeoutError:
-        assert not global_pop
+    # We do NOT expect a popup or signal in either case, since code only logs
+    with qtbot.assertNotEmitted(error_utility.error_occurred):
+        widget.method_without_error_handling()
 
-    if global_pop:
-        assert blocker.signal_triggered
-        assert mock_exec.called
-    else:
-        assert not blocker.signal_triggered
-        assert not mock_exec.called
-        stdout, stderr = capsys.readouterr()
-        assert "ValueError" in stderr
+    assert not mock_exec.called
+
+    # Confirm logger.error(...) was called
+    mock_log_error.assert_called_once()
+    logged_msg = mock_log_error.call_args[0][0]
+    assert "ValueError" in logged_msg
+    assert "SafeSlot error in slot" in logged_msg
+
+
+@pytest.mark.parametrize("global_pop", [False, True])
+@patch.object(bec_logger.logger, "error")
+@patch.object(QMessageBox, "exec_", return_value=QMessageBox.Ok)
+def test_safe_property_getter_error(mock_exec, mock_log_error, qtbot, global_pop):
+    """
+    If a property getter raises an error, we log it by default.
+    (No popup is shown unless code specifically calls it.)
+    """
+    error_utility = ErrorPopupUtility()
+    error_utility.enable_global_error_popups(global_pop)
+
+    test_obj = TestSafePropertyClass()
+    test_obj._my_value = 999  # triggers ValueError in getter => logs => returns default (-1)
+
+    val = test_obj.my_value
+    assert val == -1
+
+    # No popup => mock_exec not called
+    assert not mock_exec.called
+
+    # logger.error(...) is called once
+    mock_log_error.assert_called_once()
+    logged_msg = mock_log_error.call_args[0][0]
+    assert "SafeProperty error in GETTER" in logged_msg
+    assert "ValueError" in logged_msg
+
+
+@pytest.mark.parametrize("global_pop", [False, True])
+@patch.object(bec_logger.logger, "error")
+@patch.object(QMessageBox, "exec_", return_value=QMessageBox.Ok)
+def test_safe_property_setter_error(mock_exec, mock_log_error, qtbot, global_pop):
+    """
+    If a property setter raises an error, we log it by default.
+    (No popup is shown unless code specifically calls it.)
+    """
+    error_utility = ErrorPopupUtility()
+    error_utility.enable_global_error_popups(global_pop)
+
+    test_obj = TestSafePropertyClass()
+    # Setting to -999 triggers setter error => logs => property returns None
+    test_obj.my_value = -999
+
+    # No popup => mock_exec not called
+    assert not mock_exec.called
+
+    # logger.error(...) is called once
+    mock_log_error.assert_called_once()
+    logged_msg = mock_log_error.call_args[0][0]
+    assert "SafeProperty error in SETTER" in logged_msg
+    assert "ValueError" in logged_msg

tests/unit_tests/test_generate_cli_client.py

@@ -70,7 +70,7 @@ def test_client_generator_with_black_formatting():
         import enum
         from typing import Literal, Optional, overload
 
-        from bec_widgets.cli.client_utils import BECGuiClientMixin, RPCBase, rpc_call
+        from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
 
         # pylint: skip-file
 

tests/unit_tests/test_layout_manager.py

@@ -0,0 +1,368 @@
+from typing import Optional
+from unittest.mock import patch
+
+import pytest
+from qtpy.QtWidgets import QLabel, QPushButton, QWidget
+
+from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
+
+
+class MockWidgetHandler:
+    def create_widget(self, widget_type: str) -> Optional[QWidget]:
+        if widget_type == "ButtonWidget":
+            return QPushButton()
+        elif widget_type == "LabelWidget":
+            return QLabel()
+        else:
+            return None
+
+
+@pytest.fixture
+def mock_widget_handler():
+    handler = MockWidgetHandler()
+    with patch(
+        "bec_widgets.widgets.containers.layout_manager.layout_manager.widget_handler", handler
+    ):
+        yield handler
+
+
+@pytest.fixture
+def layout_manager(qtbot, mock_widget_handler):
+    widget = LayoutManagerWidget()
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_add_widget_empty_position(layout_manager):
+    """Test adding a widget to an empty position without shifting."""
+    btn1 = QPushButton("Button 1")
+    layout_manager.add_widget(btn1, row=0, col=0)
+
+    assert layout_manager.get_widget(0, 0) == btn1
+    assert layout_manager.widget_positions[btn1] == (0, 0, 1, 1)
+    assert layout_manager.position_widgets[(0, 0)] == btn1
+
+
+def test_add_widget_occupied_position(layout_manager):
+    """Test adding a widget to an occupied position with shifting (default direction right)."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+    layout_manager.add_widget(btn1, row=0, col=0)
+    layout_manager.add_widget(btn2, row=0, col=0)  # This should shift btn1 to the right
+
+    assert layout_manager.get_widget(0, 0) == btn2
+    assert layout_manager.get_widget(0, 1) == btn1
+    assert layout_manager.widget_positions[btn2] == (0, 0, 1, 1)
+    assert layout_manager.widget_positions[btn1] == (0, 1, 1, 1)
+
+
+def test_add_widget_directional_shift_down(layout_manager):
+    """Test adding a widget to an occupied position but shifting down instead of right."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+    btn3 = QPushButton("Button 3")
+    layout_manager.add_widget(btn1, row=0, col=0)
+    layout_manager.add_widget(btn2, row=0, col=0)  # Shifts btn1 to the right by default
+
+    # Now add btn3 at (0,1) but shift direction is down, so it should push btn1 down.
+    layout_manager.add_widget(btn3, row=0, col=1, shift_direction="down")
+
+    assert layout_manager.get_widget(0, 0) == btn2
+    assert layout_manager.get_widget(0, 1) == btn3
+    assert layout_manager.get_widget(1, 1) == btn1
+
+
+def test_remove_widget_by_position(layout_manager):
+    """Test removing a widget by specifying its row and column."""
+    btn1 = QPushButton("Button 1")
+    layout_manager.add_widget(btn1, row=0, col=0)
+
+    layout_manager.remove(row=0, col=0)
+
+    assert layout_manager.get_widget(0, 0) is None
+    assert btn1 not in layout_manager.widget_positions
+
+
+def test_move_widget_with_shift(layout_manager):
+    """Test moving a widget to an occupied position, triggering a shift."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+    btn3 = QPushButton("Button 3")
+
+    layout_manager.add_widget(btn1, row=0, col=0)
+    layout_manager.add_widget(btn2, row=0, col=1)
+    layout_manager.add_widget(btn3, row=1, col=0)
+
+    layout_manager.move_widget(old_row=0, old_col=0, new_row=0, new_col=1, shift_direction="right")
+
+    assert layout_manager.get_widget(0, 1) == btn1
+    assert layout_manager.get_widget(0, 2) == btn2
+    assert layout_manager.get_widget(1, 0) == btn3
+
+
+def test_move_widget_without_shift(layout_manager):
+    """Test moving a widget to an occupied position without shifting."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+
+    layout_manager.add_widget(btn1, row=0, col=0)
+    layout_manager.add_widget(btn2, row=0, col=1)
+
+    with pytest.raises(ValueError) as exc_info:
+        layout_manager.move_widget(old_row=0, old_col=0, new_row=0, new_col=1, shift=False)
+
+    assert "Position (0, 1) is already occupied." in str(exc_info.value)
+
+
+def test_change_layout_num_cols(layout_manager):
+    """Test changing the layout by specifying only the number of columns."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+    btn3 = QPushButton("Button 3")
+    btn4 = QPushButton("Button 4")
+
+    layout_manager.add_widget(btn1)
+    layout_manager.add_widget(btn2)
+    layout_manager.add_widget(btn3)
+    layout_manager.add_widget(btn4)
+
+    layout_manager.change_layout(num_cols=2)
+
+    assert layout_manager.get_widget(0, 0) == btn1
+    assert layout_manager.get_widget(0, 1) == btn2
+    assert layout_manager.get_widget(1, 0) == btn3
+    assert layout_manager.get_widget(1, 1) == btn4
+
+
+def test_change_layout_num_rows(layout_manager):
+    """Test changing the layout by specifying only the number of rows."""
+    btn_list = [QPushButton(f"Button {i}") for i in range(1, 7)]
+    for btn in btn_list:
+        layout_manager.add_widget(btn)
+
+    layout_manager.change_layout(num_rows=3)
+
+    assert layout_manager.get_widget(0, 0) == btn_list[0]
+    assert layout_manager.get_widget(0, 1) == btn_list[1]
+    assert layout_manager.get_widget(1, 0) == btn_list[2]
+    assert layout_manager.get_widget(1, 1) == btn_list[3]
+    assert layout_manager.get_widget(2, 0) == btn_list[4]
+    assert layout_manager.get_widget(2, 1) == btn_list[5]
+
+
+def test_shift_all_widgets(layout_manager):
+    """Test shifting all widgets down and then up."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+
+    layout_manager.add_widget(btn1, row=0, col=0)
+    layout_manager.add_widget(btn2, row=0, col=1)
+
+    # Shift all down
+    layout_manager.shift_all_widgets(direction="down")
+
+    assert layout_manager.get_widget(1, 0) == btn1
+    assert layout_manager.get_widget(1, 1) == btn2
+
+    # Shift all up
+    layout_manager.shift_all_widgets(direction="up")
+
+    assert layout_manager.get_widget(0, 0) == btn1
+    assert layout_manager.get_widget(0, 1) == btn2
+
+
+def test_add_widget_auto_position(layout_manager):
+    """Test adding widgets without specifying row and column."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+
+    layout_manager.add_widget(btn1)
+    layout_manager.add_widget(btn2)
+
+    assert layout_manager.get_widget(0, 0) == btn1
+    assert layout_manager.get_widget(0, 1) == btn2
+
+
+def test_clear_layout(layout_manager):
+    """Test clearing the entire layout."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+    layout_manager.add_widget(btn1)
+    layout_manager.add_widget(btn2)
+
+    layout_manager.clear_layout()
+
+    assert layout_manager.get_widget(0, 0) is None
+    assert layout_manager.get_widget(0, 1) is None
+    assert len(layout_manager.widget_positions) == 0
+
+
+def test_add_widget_with_span(layout_manager):
+    """Test adding a widget with rowspan and colspan."""
+    btn1 = QPushButton("Button 1")
+    layout_manager.add_widget(btn1, row=0, col=0, rowspan=2, colspan=2)
+
+    assert layout_manager.widget_positions[btn1] == (0, 0, 2, 2)
+
+
+def test_add_widget_overlap_with_span(layout_manager):
+    """
+    Test adding a widget that overlaps with an existing widget's span.
+    The code will attempt to shift widgets accordingly.
+    """
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+
+    layout_manager.add_widget(btn1, row=0, col=0, rowspan=2, colspan=1)
+
+    layout_manager.add_widget(btn2, row=1, col=1, shift_direction="right")
+
+    assert layout_manager.get_widget(0, 0) == btn1
+    assert layout_manager.widget_positions[btn1] == (0, 0, 2, 1)
+    assert layout_manager.get_widget(1, 1) == btn2
+    assert layout_manager.widget_positions[btn2] == (1, 1, 1, 1)
+
+
+@pytest.mark.parametrize(
+    "position, btn3_coords",
+    [("left", (1, 0)), ("right", (1, 2)), ("top", (0, 1)), ("bottom", (2, 1))],
+)
+def test_add_widget_relative(layout_manager, position, btn3_coords):
+    """Test adding a widget relative to an existing widget using parameterized data."""
+    expected_row, expected_col = btn3_coords
+
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+    btn3 = QPushButton("Button 3")
+
+    layout_manager.add_widget(btn1, row=0, col=0)
+    layout_manager.add_widget(btn2, row=1, col=1)
+
+    layout_manager.add_widget_relative(btn3, reference_widget=btn2, position=position)
+
+    assert layout_manager.get_widget(0, 0) == btn1
+    assert layout_manager.get_widget(1, 1) == btn2
+    assert layout_manager.get_widget(expected_row, expected_col) == btn3
+
+
+def test_add_widget_relative_invalid_position(layout_manager):
+    """Test adding a widget relative to an existing widget with an invalid position."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+
+    layout_manager.add_widget(btn1, row=1, col=1)
+    with pytest.raises(ValueError) as exc_info:
+        layout_manager.add_widget_relative(btn2, reference_widget=btn1, position="invalid_position")
+
+    assert "Invalid position. Choose from 'left', 'right', 'top', 'bottom'." in str(exc_info.value)
+    btn2.deleteLater()
+
+
+def test_add_widget_relative_to_nonexistent_widget(layout_manager):
+    """Test adding a widget relative to a widget that does not exist in the layout."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+
+    with pytest.raises(ValueError) as exc_info:
+        layout_manager.add_widget_relative(btn2, reference_widget=btn1, position="left")
+
+    assert "Reference widget not found in layout." in str(exc_info.value)
+    btn1.deleteLater()
+    btn2.deleteLater()
+
+
+def test_add_widget_relative_with_shift(layout_manager):
+    """Test adding a widget relative to an existing widget with shifting."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+    btn3 = QPushButton("Button 3")
+
+    layout_manager.add_widget(btn1, row=1, col=1)
+    layout_manager.add_widget(btn2, row=1, col=0)
+
+    layout_manager.add_widget_relative(
+        btn3, reference_widget=btn1, position="left", shift_direction="right"
+    )
+
+    assert layout_manager.get_widget(0, 0) == btn3
+    assert layout_manager.get_widget(1, 1) == btn2
+    assert layout_manager.get_widget(0, 1) == btn1
+
+
+def test_move_widget_by_object(layout_manager):
+    """Test moving a widget using the widget object."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+
+    layout_manager.add_widget(btn1)
+    layout_manager.add_widget(btn2, row=0, col=1)
+
+    layout_manager.move_widget_by_object(btn1, new_row=1, new_col=1)
+
+    # the grid is reindex after each move, so the new positions are (0,0) and (1,0), because visually there is only one column
+    assert layout_manager.get_widget(1, 0) == btn1
+    assert layout_manager.get_widget(0, 0) == btn2
+
+
+def test_move_widget_by_coords(layout_manager):
+    """Test moving a widget using its current coordinates."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+
+    layout_manager.add_widget(btn1)
+    layout_manager.add_widget(btn2, row=0, col=1)
+
+    layout_manager.move_widget_by_coords(0, 0, 1, 0, shift_direction="down")
+
+    assert layout_manager.get_widget(1, 0) == btn1
+    assert layout_manager.get_widget(0, 1) == btn2
+
+
+def test_change_layout_no_arguments(layout_manager):
+    """Test changing the layout with no arguments (should do nothing)."""
+    btn1 = QPushButton("Button 1")
+    layout_manager.add_widget(btn1, row=0, col=0)
+
+    layout_manager.change_layout()
+
+    assert layout_manager.get_widget(0, 0) == btn1
+    assert len(layout_manager.widget_positions) == 1
+
+
+def test_remove_nonexistent_widget(layout_manager):
+    """Test removing a widget that doesn't exist in the layout."""
+    with pytest.raises(ValueError) as exc_info:
+        layout_manager.remove(row=0, col=0)
+
+    assert "No widget found at position (0, 0)." in str(exc_info.value)
+
+
+def test_reindex_grid_after_removal(layout_manager):
+    """Test reindexing the grid after removing a widget."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+    layout_manager.add_widget(btn1)
+    layout_manager.add_widget(btn2, row=0, col=1)
+
+    layout_manager.remove_widget(btn1)
+    layout_manager.reindex_grid()
+
+    # After removal and reindex, btn2 should shift to (0,0)
+    assert layout_manager.get_widget(0, 0) == btn2
+    assert layout_manager.widget_positions[btn2] == (0, 0, 1, 1)
+
+
+def test_shift_all_widgets_up_at_top_row(layout_manager):
+    """Test shifting all widgets up when they are already at the top row."""
+    btn1 = QPushButton("Button 1")
+    btn2 = QPushButton("Button 2")
+
+    layout_manager.add_widget(btn1, row=0, col=0)
+    layout_manager.add_widget(btn2, row=0, col=1)
+
+    # Shifting up should cause an error since widgets can't move above row 0
+    with pytest.raises(ValueError) as exc_info:
+        layout_manager.shift_all_widgets(direction="up")
+
+    assert "Shifting widgets out of grid boundaries." in str(exc_info.value)

tests/unit_tests/test_minesweeper.py

@@ -0,0 +1,50 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
+
+import pytest
+from qtpy.QtCore import Qt
+
+from bec_widgets.widgets.games import Minesweeper
+from bec_widgets.widgets.games.minesweeper import LEVELS, GameStatus, Pos
+
+
+@pytest.fixture
+def minesweeper(qtbot):
+    widget = Minesweeper()
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_minesweeper_init(minesweeper: Minesweeper):
+    assert minesweeper.status == GameStatus.READY
+
+
+def test_changing_level_updates_size_and_removes_old_grid_items(minesweeper: Minesweeper):
+    assert minesweeper.b_size == LEVELS["1"][0]
+    grid_items = [minesweeper.grid.itemAt(i).widget() for i in range(minesweeper.grid.count())]
+    for w in grid_items:
+        assert w.parent() is not None
+    minesweeper.change_level("2")
+    assert minesweeper.b_size == LEVELS["2"][0]
+    for w in grid_items:
+        assert w.parent() is None
+
+
+def test_game_state_changes_to_failed_on_loss(qtbot, minesweeper: Minesweeper):
+    assert minesweeper.status == GameStatus.READY
+    grid_items: list[Pos] = [
+        minesweeper.grid.itemAt(i).widget() for i in range(minesweeper.grid.count())
+    ]
+    mine = [p for p in grid_items if p.is_mine][0]
+
+    with qtbot.waitSignal(mine.ohno, timeout=1000):
+        qtbot.mouseRelease(mine, Qt.MouseButton.LeftButton)
+    assert minesweeper.status == GameStatus.FAILED
+
+
+def test_game_resets_on_reset_click(minesweeper: Minesweeper):
+    assert minesweeper.status == GameStatus.READY
+    minesweeper.grid.itemAt(1).widget().ohno.emit()
+    assert minesweeper.status == GameStatus.FAILED
+    minesweeper.reset_button_pressed()
+    assert minesweeper.status == GameStatus.PLAYING

tests/unit_tests/test_modular_toolbar.py

@@ -0,0 +1,396 @@
+from typing import Literal
+
+import pytest
+from qtpy.QtCore import QPoint, Qt
+from qtpy.QtGui import QContextMenuEvent
+from qtpy.QtWidgets import QComboBox, QLabel, QMenu, QToolButton, QWidget
+
+from bec_widgets.qt_utils.toolbar import (
+    DeviceSelectionAction,
+    ExpandableMenuAction,
+    IconAction,
+    MaterialIconAction,
+    ModularToolBar,
+    SeparatorAction,
+    ToolbarBundle,
+    WidgetAction,
+)
+from tests.unit_tests.conftest import create_widget
+
+
+@pytest.fixture
+def dummy_widget(qtbot):
+    """Fixture to create a simple widget to be used as target widget."""
+    widget = QWidget()
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    return widget
+
+
+@pytest.fixture(params=["horizontal", "vertical"])
+def toolbar_fixture(qtbot, request, dummy_widget):
+    """Parametrized fixture to create a ModularToolBar with different orientations."""
+    orientation: Literal["horizontal", "vertical"] = request.param
+    toolbar = ModularToolBar(
+        target_widget=dummy_widget,
+        orientation=orientation,
+        background_color="rgba(255, 255, 255, 255)",  # White background for testing
+    )
+    qtbot.addWidget(toolbar)
+    qtbot.waitExposed(toolbar)
+    yield toolbar
+    toolbar.close()
+
+
+@pytest.fixture
+def separator_action():
+    """Fixture to create a SeparatorAction."""
+    return SeparatorAction()
+
+
+@pytest.fixture
+def icon_action():
+    """Fixture to create an IconAction."""
+    return IconAction(icon_path="assets/BEC-Icon.png", tooltip="Test Icon Action", checkable=True)
+
+
+@pytest.fixture
+def material_icon_action():
+    """Fixture to create a MaterialIconAction."""
+    return MaterialIconAction(
+        icon_name="home", tooltip="Test Material Icon Action", checkable=False
+    )
+
+
+@pytest.fixture
+def device_selection_action():
+    """Fixture to create a DeviceSelectionAction."""
+    device_combobox = QComboBox()
+    device_combobox.addItems(["Device 1", "Device 2", "Device 3"])
+    device_combobox.setCurrentIndex(0)
+    return DeviceSelectionAction(label="Select Device:", device_combobox=device_combobox)
+
+
+@pytest.fixture
+def widget_action():
+    """Fixture to create a WidgetAction."""
+    sample_widget = QLabel("Sample Widget")
+    return WidgetAction(label="Sample Label:", widget=sample_widget)
+
+
+@pytest.fixture
+def expandable_menu_action():
+    """Fixture to create an ExpandableMenuAction."""
+    action1 = MaterialIconAction(icon_name="counter_1", tooltip="Menu Action 1", checkable=False)
+    action2 = MaterialIconAction(icon_name="counter_2", tooltip="Menu Action 2", checkable=True)
+    actions = {"action1": action1, "action2": action2}
+    return ExpandableMenuAction(
+        label="Expandable Menu", actions=actions, icon_path="assets/BEC-Icon.png"
+    )
+
+
+def test_initialization(toolbar_fixture):
+    """Test that ModularToolBar initializes correctly with different orientations."""
+    toolbar = toolbar_fixture
+    if toolbar.orientation() == Qt.Horizontal:
+        assert toolbar.orientation() == Qt.Horizontal
+    elif toolbar.orientation() == Qt.Vertical:
+        assert toolbar.orientation() == Qt.Vertical
+    else:
+        pytest.fail("Toolbar orientation is neither horizontal nor vertical.")
+    assert toolbar.background_color == "rgba(255, 255, 255, 255)"
+    assert toolbar.widgets == {}
+    assert not toolbar.isMovable()
+    assert not toolbar.isFloatable()
+
+
+def test_set_background_color(toolbar_fixture):
+    """Test setting the background color of the toolbar."""
+    toolbar = toolbar_fixture
+    new_color = "rgba(0, 0, 0, 255)"  # Black
+    toolbar.set_background_color(new_color)
+    assert toolbar.background_color == new_color
+    # Verify stylesheet
+    expected_style = f"QToolBar {{ background-color: {new_color}; border: none; }}"
+    assert toolbar.styleSheet() == expected_style
+
+
+def test_set_orientation(toolbar_fixture, qtbot, dummy_widget):
+    """Test changing the orientation of the toolbar."""
+    toolbar = toolbar_fixture
+    if toolbar.orientation() == Qt.Horizontal:
+        new_orientation = "vertical"
+    else:
+        new_orientation = "horizontal"
+    toolbar.set_orientation(new_orientation)
+    qtbot.wait(100)
+    if new_orientation == "horizontal":
+        assert toolbar.orientation() == Qt.Horizontal
+    else:
+        assert toolbar.orientation() == Qt.Vertical
+
+
+def test_add_action(
+    toolbar_fixture, icon_action, separator_action, material_icon_action, dummy_widget
+):
+    """Test adding different types of actions to the toolbar."""
+    toolbar = toolbar_fixture
+
+    # Add IconAction
+    toolbar.add_action("icon_action", icon_action, dummy_widget)
+    assert "icon_action" in toolbar.widgets
+    assert toolbar.widgets["icon_action"] == icon_action
+    assert icon_action.action in toolbar.actions()
+
+    # Add SeparatorAction
+    toolbar.add_action("separator_action", separator_action, dummy_widget)
+    assert "separator_action" in toolbar.widgets
+    assert toolbar.widgets["separator_action"] == separator_action
+
+    # Add MaterialIconAction
+    toolbar.add_action("material_icon_action", material_icon_action, dummy_widget)
+    assert "material_icon_action" in toolbar.widgets
+    assert toolbar.widgets["material_icon_action"] == material_icon_action
+    assert material_icon_action.action in toolbar.actions()
+
+
+def test_hide_show_action(toolbar_fixture, icon_action, qtbot, dummy_widget):
+    """Test hiding and showing actions on the toolbar."""
+    toolbar = toolbar_fixture
+
+    # Add an action
+    toolbar.add_action("icon_action", icon_action, dummy_widget)
+    assert icon_action.action.isVisible()
+
+    # Hide the action
+    toolbar.hide_action("icon_action")
+    qtbot.wait(100)
+    assert not icon_action.action.isVisible()
+
+    # Show the action
+    toolbar.show_action("icon_action")
+    qtbot.wait(100)
+    assert icon_action.action.isVisible()
+
+
+def test_add_duplicate_action(toolbar_fixture, icon_action, dummy_widget):
+    """Test that adding an action with a duplicate action_id raises a ValueError."""
+    toolbar = toolbar_fixture
+
+    # Add an action
+    toolbar.add_action("icon_action", icon_action, dummy_widget)
+    assert "icon_action" in toolbar.widgets
+
+    # Attempt to add another action with the same ID
+    with pytest.raises(ValueError) as excinfo:
+        toolbar.add_action("icon_action", icon_action, dummy_widget)
+    assert "Action with ID 'icon_action' already exists." in str(excinfo.value)
+
+
+def test_update_material_icon_colors(toolbar_fixture, material_icon_action, dummy_widget):
+    """Test updating the color of MaterialIconAction icons."""
+    toolbar = toolbar_fixture
+
+    # Add MaterialIconAction
+    toolbar.add_action("material_icon_action", material_icon_action, dummy_widget)
+    assert material_icon_action.action is not None
+
+    # Initial icon
+    initial_icon = material_icon_action.action.icon()
+
+    # Update color
+    new_color = "#ff0000"  # Red
+    toolbar.update_material_icon_colors(new_color)
+
+    # Updated icon
+    updated_icon = material_icon_action.action.icon()
+
+    # Assuming that the icon changes when color is updated
+    assert initial_icon != updated_icon
+
+
+def test_device_selection_action(toolbar_fixture, device_selection_action, dummy_widget):
+    """Test adding a DeviceSelectionAction to the toolbar."""
+    toolbar = toolbar_fixture
+    toolbar.add_action("device_selection", device_selection_action, dummy_widget)
+    assert "device_selection" in toolbar.widgets
+    # DeviceSelectionAction adds a QWidget, so it should be present in the toolbar's widgets
+    # Check if the widget is added
+    widget = device_selection_action.device_combobox.parentWidget()
+    assert widget in toolbar.findChildren(QWidget)
+    # Verify that the label is correct
+    label = widget.findChild(QLabel)
+    assert label.text() == "Select Device:"
+
+
+def test_widget_action(toolbar_fixture, widget_action, dummy_widget):
+    """Test adding a WidgetAction to the toolbar."""
+    toolbar = toolbar_fixture
+    toolbar.add_action("widget_action", widget_action, dummy_widget)
+    assert "widget_action" in toolbar.widgets
+    # WidgetAction adds a QWidget to the toolbar
+    container = widget_action.widget.parentWidget()
+    assert container in toolbar.findChildren(QWidget)
+    # Verify the label if present
+    label = container.findChild(QLabel)
+    assert label.text() == "Sample Label:"
+
+
+def test_expandable_menu_action(toolbar_fixture, expandable_menu_action, dummy_widget):
+    """Test adding an ExpandableMenuAction to the toolbar."""
+    toolbar = toolbar_fixture
+    toolbar.add_action("expandable_menu", expandable_menu_action, dummy_widget)
+    assert "expandable_menu" in toolbar.widgets
+    # ExpandableMenuAction adds a QToolButton with a QMenu
+    # Find the QToolButton
+    tool_buttons = toolbar.findChildren(QToolButton)
+    assert len(tool_buttons) > 0
+    button = tool_buttons[-1]  # Assuming it's the last one added
+    menu = button.menu()
+    assert menu is not None
+    # Check that menu has the correct actions
+    for action_id, sub_action in expandable_menu_action.actions.items():
+        # Check if a sub-action with the correct tooltip exists
+        matched = False
+        for menu_action in menu.actions():
+            if menu_action.toolTip() == sub_action.tooltip:
+                matched = True
+                break
+        assert matched, f"Sub-action with tooltip '{sub_action.tooltip}' not found in menu."
+
+
+def test_update_material_icon_colors_no_material_actions(toolbar_fixture, dummy_widget):
+    """Test updating material icon colors when there are no MaterialIconActions."""
+    toolbar = toolbar_fixture
+    # Ensure there are no MaterialIconActions
+    toolbar.update_material_icon_colors("#00ff00")
+
+
+def test_hide_action_nonexistent(toolbar_fixture):
+    """Test hiding an action that does not exist raises a ValueError."""
+    toolbar = toolbar_fixture
+    with pytest.raises(ValueError) as excinfo:
+        toolbar.hide_action("nonexistent_action")
+    assert "Action with ID 'nonexistent_action' does not exist." in str(excinfo.value)
+
+
+def test_show_action_nonexistent(toolbar_fixture):
+    """Test showing an action that does not exist raises a ValueError."""
+    toolbar = toolbar_fixture
+    with pytest.raises(ValueError) as excinfo:
+        toolbar.show_action("nonexistent_action")
+    assert "Action with ID 'nonexistent_action' does not exist." in str(excinfo.value)
+
+
+def test_add_bundle(toolbar_fixture, dummy_widget, icon_action, material_icon_action):
+    """Test adding a bundle of actions to the toolbar."""
+    toolbar = toolbar_fixture
+    bundle = ToolbarBundle(
+        bundle_id="test_bundle",
+        actions=[
+            ("icon_action_in_bundle", icon_action),
+            ("material_icon_in_bundle", material_icon_action),
+        ],
+    )
+    toolbar.add_bundle(bundle, dummy_widget)
+    assert "test_bundle" in toolbar.bundles
+    assert "icon_action_in_bundle" in toolbar.widgets
+    assert "material_icon_in_bundle" in toolbar.widgets
+    assert icon_action.action in toolbar.actions()
+    assert material_icon_action.action in toolbar.actions()
+
+
+def test_invalid_orientation(dummy_widget):
+    """Test that an invalid orientation raises a ValueError."""
+    toolbar = ModularToolBar(target_widget=dummy_widget, orientation="horizontal")
+    with pytest.raises(ValueError):
+        toolbar.set_orientation("diagonal")
+
+
+def test_widget_action_calculate_minimum_width(qtbot):
+    """Test calculate_minimum_width with various combo box items."""
+    combo = QComboBox()
+    combo.addItems(["Short", "Longer Item", "The Longest Item In Combo"])
+    widget_action = WidgetAction(label="Test", widget=combo)
+    width = widget_action.calculate_minimum_width(combo)
+    assert width > 0
+    # Width should be large enough to accommodate the longest item plus additional space
+    assert width > 100
+
+
+# FIXME test is stucking CI, works locally
+# def test_context_menu_contains_added_actions(
+#     qtbot, icon_action, material_icon_action, dummy_widget
+# ):
+#     """
+#     Test that the toolbar's context menu lists all added toolbar actions.
+#     """
+#     toolbar = create_widget(
+#         qtbot, widget=ModularToolBar, target_widget=dummy_widget, orientation="horizontal"
+#     )
+#
+#     # Add two different actions
+#     toolbar.add_action("icon_action", icon_action, dummy_widget)
+#     toolbar.add_action("material_icon_action", material_icon_action, dummy_widget)
+#
+#     # Manually trigger the context menu event
+#     event = QContextMenuEvent(QContextMenuEvent.Mouse, QPoint(10, 10))
+#     toolbar.contextMenuEvent(event)
+#
+#     # The QMenu is executed in contextMenuEvent, so we can fetch all possible actions
+#     # from the displayed menu by searching for QMenu in the immediate children of the toolbar.
+#     menus = toolbar.findChildren(QMenu)
+#     assert len(menus) > 0
+#     menu = menus[-1]  # The most recently created menu
+#
+#     menu_action_texts = [action.text() for action in menu.actions()]
+#     # Check if the menu contains entries for both added actions
+#     assert any(icon_action.tooltip in text or "icon_action" in text for text in menu_action_texts)
+#     assert any(
+#         material_icon_action.tooltip in text or "material_icon_action" in text
+#         for text in menu_action_texts
+#     )
+#     menu.actions()[0].trigger()  # Trigger the first action to close the menu
+#     toolbar.close()
+
+
+# FIXME test is stucking CI, works locally
+# def test_context_menu_toggle_action_visibility(qtbot, icon_action, dummy_widget):
+#     """
+#     Test that toggling action visibility works correctly through the toolbar's context menu.
+#     """
+#     toolbar = create_widget(
+#         qtbot, widget=ModularToolBar, target_widget=dummy_widget, orientation="horizontal"
+#     )
+#     # Add an action
+#     toolbar.add_action("icon_action", icon_action, dummy_widget)
+#     assert icon_action.action.isVisible()
+#
+#     # Manually trigger the context menu event
+#     event = QContextMenuEvent(QContextMenuEvent.Mouse, QPoint(10, 10))
+#     toolbar.contextMenuEvent(event)
+#
+#     # Grab the menu that was created
+#     menus = toolbar.findChildren(QMenu)
+#     assert len(menus) > 0
+#     menu = menus[-1]
+#
+#     # Locate the QAction in the menu
+#     matching_actions = [m for m in menu.actions() if m.text() == icon_action.tooltip]
+#     assert len(matching_actions) == 1
+#     action_in_menu = matching_actions[0]
+#
+#     # Toggle it off (uncheck)
+#     action_in_menu.setChecked(False)
+#     menu.triggered.emit(action_in_menu)
+#     # The action on the toolbar should now be hidden
+#     assert not icon_action.action.isVisible()
+#
+#     # Toggle it on (check)
+#     action_in_menu.setChecked(True)
+#     menu.triggered.emit(action_in_menu)
+#     # The action on the toolbar should be visible again
+#     assert icon_action.action.isVisible()
+#
+#     menu.actions()[0].trigger()  # Trigger the first action to close the menu
+#     toolbar.close()

tests/unit_tests/test_positioner_box.py

@@ -7,8 +7,8 @@ from qtpy.QtCore import Qt, QTimer
 from qtpy.QtGui import QValidator
 from qtpy.QtWidgets import QPushButton
 
-from bec_widgets.widgets.control.device_control.positioner_box.positioner_box import PositionerBox
-from bec_widgets.widgets.control.device_control.positioner_box.positioner_control_line import (
+from bec_widgets.widgets.control.device_control.positioner_box import (
+    PositionerBox,
     PositionerControlLine,
 )
 from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
@@ -23,11 +23,11 @@ from .conftest import create_widget
 def positioner_box(qtbot, mocked_client):
     """Fixture for PositionerBox widget"""
     with mock.patch(
-        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.uuid.uuid4"
+        "bec_widgets.widgets.control.device_control.positioner_box._base.positioner_box_base.uuid.uuid4"
     ) as mock_uuid:
         mock_uuid.return_value = "fake_uuid"
         with mock.patch(
-            "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.PositionerBox._check_device_is_valid",
+            "bec_widgets.widgets.control.device_control.positioner_box._base.positioner_box_base.PositionerBoxBase._check_device_is_valid",
             return_value=True,
         ):
             db = create_widget(qtbot, PositionerBox, device="samx", client=mocked_client)
@@ -126,11 +126,11 @@ def test_positioner_control_line(qtbot, mocked_client):
     Inherits from PositionerBox, but the layout is changed. Check dimensions only
     """
     with mock.patch(
-        "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.uuid.uuid4"
+        "bec_widgets.widgets.control.device_control.positioner_box._base.positioner_box_base.uuid.uuid4"
     ) as mock_uuid:
         mock_uuid.return_value = "fake_uuid"
         with mock.patch(
-            "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.PositionerBox._check_device_is_valid",
+            "bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box.PositionerBox._check_device_is_valid",
             return_value=True,
         ):
             db = PositionerControlLine(device="samx", client=mocked_client)
@@ -158,3 +158,10 @@ def test_positioner_box_open_dialog_selection(qtbot, positioner_box):
     QTimer.singleShot(100, close_dialog)
     qtbot.mouseClick(positioner_box.ui.tool_button, Qt.LeftButton)
     assert positioner_box.device == "samy"
+
+
+def test_device_validity_check_rejects_non_positioner():
+    # isinstance checks for PositionerBox are mocked out in the mock client
+    positioner_box = mock.MagicMock(spec=PositionerBox)
+    positioner_box.dev = {"test": 5.123}
+    assert not PositionerBox._check_device_is_valid(positioner_box, "test")

tests/unit_tests/test_positioner_box_2d.py

@@ -0,0 +1,82 @@
+from unittest import mock
+
+import pytest
+
+from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox2D
+
+from .client_mocks import mocked_client
+from .conftest import create_widget
+
+
+@pytest.fixture
+def positioner_box_2d(qtbot, mocked_client):
+    """Fixture for PositionerBox widget"""
+    with mock.patch(
+        "bec_widgets.widgets.control.device_control.positioner_box._base.positioner_box_base.uuid.uuid4"
+    ) as mock_uuid:
+        mock_uuid.return_value = "fake_uuid"
+        with mock.patch(
+            "bec_widgets.widgets.control.device_control.positioner_box._base.positioner_box_base.PositionerBoxBase._check_device_is_valid",
+            return_value=True,
+        ):
+            db = create_widget(
+                qtbot, PositionerBox2D, device_hor="samx", device_ver="samy", client=mocked_client
+            )
+            yield db
+
+
+def test_positioner_box_2d(positioner_box_2d):
+    """Test init of 2D positioner box"""
+    assert positioner_box_2d.device_hor == "samx"
+    assert positioner_box_2d.device_ver == "samy"
+    data_hor = positioner_box_2d.dev["samx"].read()
+    data_ver = positioner_box_2d.dev["samy"].read()
+    # Avoid check for Positioner class from BEC in _init_device
+
+    setpoint_hor_text = positioner_box_2d.ui.setpoint_hor.text()
+    setpoint_ver_text = positioner_box_2d.ui.setpoint_ver.text()
+    # check that the setpoint is taken correctly after init
+    assert float(setpoint_hor_text) == data_hor["samx_setpoint"]["value"]
+    assert float(setpoint_ver_text) == data_ver["samy_setpoint"]["value"]
+
+    # check that the precision is taken correctly after init
+    precision_hor = positioner_box_2d.dev["samx"].precision
+    precision_ver = positioner_box_2d.dev["samy"].precision
+    assert setpoint_hor_text == f"{data_hor['samx_setpoint']['value']:.{precision_hor}f}"
+    assert setpoint_ver_text == f"{data_ver['samy_setpoint']['value']:.{precision_ver}f}"
+
+    # check that the step size is set according to the device precision
+    assert positioner_box_2d.ui.step_size_hor.value() == 10**-precision_hor * 10
+    assert positioner_box_2d.ui.step_size_ver.value() == 10**-precision_ver * 10
+
+
+def test_positioner_box_move_hor_does_not_affect_ver(positioner_box_2d):
+    """Test that moving one positioner doesn't affect the other"""
+    with (
+        mock.patch.object(positioner_box_2d.dev["samx"], "move") as mock_move_hor,
+        mock.patch.object(positioner_box_2d.dev["samy"], "move") as mock_move_ver,
+    ):
+        positioner_box_2d.ui.step_size_hor.setValue(0.1)
+        positioner_box_2d.on_tweak_inc_hor()
+        mock_move_hor.assert_called_once_with(0.01, relative=True)
+        mock_move_ver.assert_not_called()
+    with (
+        mock.patch.object(positioner_box_2d.dev["samx"], "move") as mock_move_hor,
+        mock.patch.object(positioner_box_2d.dev["samy"], "move") as mock_move_ver,
+    ):
+        positioner_box_2d.ui.step_size_ver.setValue(0.1)
+        positioner_box_2d.on_step_dec_ver()
+        mock_move_ver.assert_called_once_with(-0.1, relative=True)
+        mock_move_hor.assert_not_called()
+
+
+def test_positioner_box_setpoint_changes(positioner_box_2d: PositionerBox2D):
+    """Test positioner box setpoint change"""
+    with mock.patch.object(positioner_box_2d.dev["samx"], "move") as mock_move:
+        positioner_box_2d.ui.setpoint_hor.setText("100")
+        positioner_box_2d.on_setpoint_change_hor()
+        mock_move.assert_called_once_with(100, relative=False)
+    with mock.patch.object(positioner_box_2d.dev["samy"], "move") as mock_move:
+        positioner_box_2d.ui.setpoint_ver.setText("100")
+        positioner_box_2d.on_setpoint_change_ver()
+        mock_move.assert_called_once_with(100, relative=False)

tests/unit_tests/test_round_frame.py

@@ -0,0 +1,64 @@
+import pyqtgraph as pg
+import pytest
+
+from bec_widgets.qt_utils.round_frame import RoundedFrame
+
+
+def cleanup_pyqtgraph(plot_widget):
+    item = plot_widget.getPlotItem()
+    item.vb.menu.close()
+    item.vb.menu.deleteLater()
+    item.ctrlMenu.close()
+    item.ctrlMenu.deleteLater()
+
+
+@pytest.fixture
+def basic_rounded_frame(qtbot):
+    frame = RoundedFrame()
+    qtbot.addWidget(frame)
+    qtbot.waitExposed(frame)
+    yield frame
+
+
+@pytest.fixture
+def plot_rounded_frame(qtbot):
+    plot_widget = pg.PlotWidget()
+    plot_widget.plot([0, 1, 2], [2, 1, 0])
+    frame = RoundedFrame(content_widget=plot_widget, theme_update=True)
+    qtbot.addWidget(frame)
+    qtbot.waitExposed(frame)
+    yield frame
+    cleanup_pyqtgraph(plot_widget)
+
+
+def test_basic_rounded_frame_initialization(basic_rounded_frame):
+    assert basic_rounded_frame.radius == 10
+    assert basic_rounded_frame.content_widget is None
+    assert basic_rounded_frame.background_color is None
+    assert basic_rounded_frame.theme_update is True
+
+
+def test_set_radius(basic_rounded_frame):
+    basic_rounded_frame.radius = 20
+    assert basic_rounded_frame.radius == 20
+
+
+def test_apply_theme_light(plot_rounded_frame):
+    plot_rounded_frame.apply_theme("light")
+
+    assert plot_rounded_frame.background_color == "#e9ecef"
+
+
+def test_apply_theme_dark(plot_rounded_frame):
+    plot_rounded_frame.apply_theme("dark")
+
+    assert plot_rounded_frame.background_color == "#141414"
+
+
+def test_apply_plot_widget_style(plot_rounded_frame):
+    # Verify that a PlotWidget can have its style applied
+    plot_rounded_frame.apply_plot_widget_style(border="1px solid red")
+
+    # Ensure style application did not break anything
+    assert plot_rounded_frame.content_widget is not None
+    assert isinstance(plot_rounded_frame.content_widget, pg.PlotWidget)

tests/unit_tests/test_rpc_register.py

@@ -1,4 +1,4 @@
-from bec_widgets.cli.rpc_register import RPCRegister
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
 
 
 class FakeObject:

tests/unit_tests/test_rpc_widget_handler.py

@@ -1,4 +1,4 @@
-from bec_widgets.cli.rpc_wigdet_handler import RPCWidgetHandler
+from bec_widgets.cli.rpc.rpc_widget_handler import RPCWidgetHandler
 
 
 def test_rpc_widget_handler():

tests/unit_tests/test_side_menu.py

@@ -0,0 +1,366 @@
+from typing import Literal
+
+import pytest
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QHBoxLayout, QLabel, QVBoxLayout, QWidget
+
+from bec_widgets.qt_utils.side_panel import SidePanel
+
+
+@pytest.fixture(params=["left", "right", "top", "bottom"])
+def side_panel_fixture(qtbot, request):
+    """
+    Parametrized fixture to create SidePanel with different orientations.
+
+    Yields:
+        tuple: (SidePanel instance, orientation string)
+    """
+    orientation: Literal["left", "right", "top", "bottom"] = request.param
+    panel = SidePanel(orientation=orientation)
+    qtbot.addWidget(panel)
+    qtbot.waitExposed(panel)
+    yield panel, orientation
+
+
+@pytest.fixture
+def menu_widget(qtbot):
+    """Fixture to create a simple widget to add to the SidePanel."""
+    widget = QWidget()
+    layout = QVBoxLayout(widget)
+    label = QLabel("Test Widget")
+    layout.addWidget(label)
+    widget.setLayout(layout)
+    return widget
+
+
+def test_initialization(side_panel_fixture):
+    """Test that SidePanel initializes correctly with different orientations."""
+    panel, orientation = side_panel_fixture
+
+    assert panel._orientation == orientation
+    assert panel.panel_max_width == 200
+    assert panel.animation_duration == 200
+    assert panel.animations_enabled is True
+    assert panel.panel_visible is False
+    assert panel.current_action is None
+    assert panel.current_index is None
+    assert panel.switching_actions is False
+
+    if orientation in ("left", "right"):
+        assert panel.toolbar.orientation() == Qt.Vertical
+        assert isinstance(panel.main_layout, QHBoxLayout)
+    else:
+        assert panel.toolbar.orientation() == Qt.Horizontal
+        assert isinstance(panel.main_layout, QVBoxLayout)
+
+
+def test_set_panel_max_width(side_panel_fixture, qtbot):
+    """Test setting the panel_max_width property."""
+    panel, orientation = side_panel_fixture
+    new_max_width = 300
+    panel.panel_max_width = new_max_width
+    qtbot.wait(100)
+
+    assert panel.panel_max_width == new_max_width
+    if orientation in ("left", "right"):
+        assert panel.stack_widget.maximumWidth() == new_max_width
+    else:
+        assert panel.stack_widget.maximumHeight() == new_max_width
+
+
+def test_set_animation_duration(side_panel_fixture, qtbot):
+    """Test setting the animationDuration property."""
+    panel, _ = side_panel_fixture
+    new_duration = 500
+    panel.animation_duration = new_duration
+    qtbot.wait(100)
+
+    assert panel.animation_duration == new_duration
+    assert panel.menu_anim.duration() == new_duration
+
+
+def test_set_animations_enabled(side_panel_fixture, qtbot):
+    """Test setting the animationsEnabled property."""
+    panel, _ = side_panel_fixture
+    panel.animationsEnabled = False
+    qtbot.wait(100)
+
+    assert panel.animationsEnabled is False
+
+    panel.animationsEnabled = True
+    qtbot.wait(100)
+
+    assert panel.animationsEnabled is True
+
+
+def test_show_hide_panel_with_animation(side_panel_fixture, qtbot):
+    """Test showing and hiding the panel with animations enabled."""
+    panel, orientation = side_panel_fixture
+    panel.animationsEnabled = True
+
+    # Show panel
+    panel.show_panel(0)
+    qtbot.wait(panel.animation_duration + 100)  # Wait for animation to complete
+
+    final_size = panel.panel_max_width
+    if orientation in ("left", "right"):
+        assert panel.panel_width == final_size
+    else:
+        assert panel.panel_height == final_size
+    assert panel.panel_visible is True
+
+    # Hide panel
+    panel.hide_panel()
+    qtbot.wait(panel.animation_duration + 100)  # Wait for animation to complete
+
+    if orientation in ("left", "right"):
+        assert panel.panel_width == 0
+    else:
+        assert panel.panel_height == 0
+    assert panel.panel_visible is False
+
+
+def test_add_menu(side_panel_fixture, menu_widget, qtbot):
+    """Test adding a menu to the SidePanel."""
+    panel, _ = side_panel_fixture
+    initial_count = panel.stack_widget.count()
+
+    panel.add_menu(
+        action_id="test_action",
+        icon_name="counter_1",
+        tooltip="Test Tooltip",
+        widget=menu_widget,
+        title="Test Panel",
+    )
+    qtbot.wait(100)
+
+    assert panel.stack_widget.count() == initial_count + 1
+    # Verify the action is added to the toolbar
+    action = panel.toolbar.widgets.get("test_action")
+    assert action is not None
+    assert action.tooltip == "Test Tooltip"
+    assert action.action in panel.toolbar.actions()
+
+
+def test_toggle_action_show_panel(side_panel_fixture, menu_widget, qtbot):
+    """Test that toggling an action shows the corresponding panel."""
+    panel, _ = side_panel_fixture
+
+    panel.add_menu(
+        action_id="toggle_action",
+        icon_name="counter_1",
+        tooltip="Toggle Tooltip",
+        widget=menu_widget,
+        title="Toggle Panel",
+    )
+    qtbot.wait(100)
+
+    action = panel.toolbar.widgets.get("toggle_action")
+    assert action is not None
+
+    # Initially, panel should be hidden
+    assert panel.panel_visible is False
+
+    # Toggle the action to show the panel
+    action.action.trigger()
+    qtbot.wait(panel.animation_duration + 100)
+
+    assert panel.panel_visible is True
+    assert panel.current_action == action.action
+    assert panel.current_index == panel.stack_widget.count() - 1
+
+    # Toggle the action again to hide the panel
+    action.action.trigger()
+    qtbot.wait(panel.animation_duration + 100)
+
+    assert panel.panel_visible is False
+    assert panel.current_action is None
+    assert panel.current_index is None
+
+
+def test_switch_actions(side_panel_fixture, menu_widget, qtbot):
+    """Test switching between multiple actions and panels."""
+    panel, _ = side_panel_fixture
+
+    # Add two menus
+    panel.add_menu(
+        action_id="action1",
+        icon_name="counter_1",
+        tooltip="Tooltip1",
+        widget=menu_widget,
+        title="Panel 1",
+    )
+    panel.add_menu(
+        action_id="action2",
+        icon_name="counter_2",
+        tooltip="Tooltip2",
+        widget=menu_widget,
+        title="Panel 2",
+    )
+    qtbot.wait(100)
+
+    action1 = panel.toolbar.widgets.get("action1")
+    action2 = panel.toolbar.widgets.get("action2")
+    assert action1 is not None
+    assert action2 is not None
+
+    # Activate first action
+    action1.action.trigger()
+    qtbot.wait(panel.animation_duration + 100)
+    assert panel.panel_visible is True
+    assert panel.current_action == action1.action
+    assert panel.current_index == 0
+
+    # Activate second action
+    action2.action.trigger()
+    qtbot.wait(panel.animation_duration + 100)
+    assert panel.panel_visible is True
+    assert panel.current_action == action2.action
+    assert panel.current_index == 1
+
+    # Deactivate second action
+    action2.action.trigger()
+    qtbot.wait(panel.animation_duration + 100)
+    assert panel.panel_visible is False
+    assert panel.current_action is None
+    assert panel.current_index is None
+
+
+def test_multiple_add_menu(side_panel_fixture, menu_widget, qtbot):
+    """Test adding multiple menus and ensure they are all added correctly."""
+    panel, _ = side_panel_fixture
+    initial_count = panel.stack_widget.count()
+
+    for i in range(3):
+        panel.add_menu(
+            action_id=f"action{i}",
+            icon_name=f"counter_{i}",
+            tooltip=f"Tooltip{i}",
+            widget=menu_widget,
+            title=f"Panel {i}",
+        )
+        qtbot.wait(100)
+        assert panel.stack_widget.count() == initial_count + i + 1
+        action = panel.toolbar.widgets.get(f"action{i}")
+        assert action is not None
+        assert action.tooltip == f"Tooltip{i}"
+        assert action.action in panel.toolbar.actions()
+
+
+def test_switch_to_method(side_panel_fixture, menu_widget, qtbot):
+    """Test the switch_to method to change panels without animation."""
+    panel, _ = side_panel_fixture
+
+    # Add two menus
+    panel.add_menu(
+        action_id="action1",
+        icon_name="counter_1",
+        tooltip="Tooltip1",
+        widget=menu_widget,
+        title="Panel 1",
+    )
+    panel.add_menu(
+        action_id="action2",
+        icon_name="counter_2",
+        tooltip="Tooltip2",
+        widget=menu_widget,
+        title="Panel 2",
+    )
+    qtbot.wait(100)
+
+    # Show first panel
+    panel.show_panel(0)
+    qtbot.wait(panel.animation_duration + 100)
+    assert panel.current_index == 0
+
+    # Switch to second panel
+    panel.switch_to(1)
+    qtbot.wait(100)
+    assert panel.current_index == 1
+
+
+def test_animation_enabled_parametrization(qtbot):
+    """Test SidePanel with animations enabled and disabled."""
+    for animations_enabled in [True, False]:
+        panel = SidePanel(animations_enabled=animations_enabled)
+        qtbot.addWidget(panel)
+        qtbot.waitExposed(panel)
+
+        assert panel.animations_enabled == animations_enabled
+
+        panel.close()
+
+
+def test_orientation_layouts(qtbot):
+    """Test that the layouts are correctly set based on orientation."""
+    orientations = {
+        "left": ("horizontal", Qt.Vertical),
+        "right": ("horizontal", Qt.Vertical),
+        "top": ("vertical", Qt.Horizontal),
+        "bottom": ("vertical", Qt.Horizontal),
+    }
+
+    for orientation, (main_layout_dir, toolbar_orientation) in orientations.items():
+        panel = SidePanel(orientation=orientation)
+        qtbot.addWidget(panel)
+        qtbot.waitExposed(panel)
+
+        # Verify main layout direction
+        if main_layout_dir == "horizontal":
+            assert isinstance(panel.main_layout, QHBoxLayout)
+        else:
+            assert isinstance(panel.main_layout, QVBoxLayout)
+
+        # Verify toolbar orientation
+        bar_orientation = panel.toolbar.orientation()
+        assert bar_orientation == toolbar_orientation
+
+        panel.close()
+
+
+def test_panel_width_height_properties(side_panel_fixture, qtbot):
+    """Test that setting panel_width and panel_height works correctly."""
+    panel, orientation = side_panel_fixture
+
+    if orientation in ("left", "right"):
+        panel.panel_width = 150
+        qtbot.wait(100)
+        assert panel.panel_width == 150
+        assert panel.stack_widget.width() == 150
+    else:
+        panel.panel_height = 150
+        qtbot.wait(100)
+        assert panel.panel_height == 150
+        assert panel.stack_widget.height() == 150
+
+
+def test_no_panel_initially(side_panel_fixture, qtbot):
+    """Test that the panel is initially hidden."""
+    panel, orientation = side_panel_fixture
+
+    if orientation in ("left", "right"):
+        assert panel.panel_width == 0
+    else:
+        assert panel.panel_height == 0
+    assert panel.panel_visible is False
+
+
+def test_add_multiple_menus(side_panel_fixture, menu_widget, qtbot):
+    """Test adding multiple menus and ensure they are all added correctly."""
+    panel, _ = side_panel_fixture
+    initial_count = panel.stack_widget.count()
+
+    for i in range(3):
+        panel.add_menu(
+            action_id=f"action{i}",
+            icon_name=f"counter_{i}",
+            tooltip=f"Tooltip{i}",
+            widget=menu_widget,
+            title=f"Panel {i}",
+        )
+        qtbot.wait(100)
+        assert panel.stack_widget.count() == initial_count + i + 1
+        action = panel.toolbar.widgets.get(f"action{i}")
+        assert action is not None
+        assert action.tooltip == f"Tooltip{i}"
+        assert action.action in panel.toolbar.actions()

tests/unit_tests/test_spinner.py

@@ -19,6 +19,12 @@ def test_spinner_widget_paint_event(spinner_widget, qtbot):
     spinner_widget.paintEvent(None)
 
 
+def test_spinnner_with_float_angle(spinner_widget, qtbot):
+    spinner_widget.start()
+    spinner_widget.angle = 0.123453453453453
+    spinner_widget.paintEvent(None)
+
+
 def test_spinner_widget_rendered(spinner_widget, qtbot, tmpdir):
     spinner_widget.update()
     qtbot.wait(200)

tests/unit_tests/test_utils_bec_signal_proxy.py

@@ -73,3 +73,52 @@ def test_bec_signal_proxy(qtbot, dap_combo_box):
     qtbot.wait(100)
     assert proxy.blocked is False
     assert proxy_container == [(("samx",),), (("samz",),)]
+
+
+def test_bec_signal_proxy_timeout(qtbot, dap_combo_box):
+    """
+    Test that BECSignalProxy auto-unblocks after the specified timeout if no manual unblock
+    occurs in the interim.
+    """
+    proxy_container = []
+
+    def proxy_callback(*args):
+        proxy_container.append(args)
+
+    # Create the proxy with a short 1-second timeout
+    proxy = BECSignalProxy(
+        dap_combo_box.x_axis_updated, rateLimit=25, slot=proxy_callback, timeout=1.0
+    )
+
+    # Initially, ensure it's not blocked
+    assert proxy.blocked is False
+
+    # Trigger the signal once (samx) -> the proxy should block
+    dap_combo_box.x_axis = "samx"
+    qtbot.waitSignal(dap_combo_box.x_axis_updated, timeout=1000)
+    qtbot.wait(100)
+    assert proxy.blocked is True
+    # The first signal should be passed immediately to the callback
+    assert proxy_container == [(("samx",),)]
+
+    # While still blocked, set another value (samz)
+    dap_combo_box.x_axis = "samz"
+    qtbot.waitSignal(dap_combo_box.x_axis_updated, timeout=1000)
+    qtbot.wait(100)
+    # Proxy is still blocked, so the callback shouldn't see "samz" yet
+    assert len(proxy_container) == 1
+
+    # Wait just under 1 second -> should still be blocked
+    qtbot.wait(700)
+    assert proxy.blocked is True
+
+    # Wait a bit more than 1 s
+    qtbot.wait(2000)
+
+    # Wait to catch the is_blocked signal that indicates it has unblocked
+    qtbot.waitSignal(proxy.is_blocked, timeout=2000)
+    # Now it should be unblocked
+    assert proxy.blocked is False
+
+    # The second value "samz" should have been forwarded after auto-unblocking
+    assert proxy_container == [(("samx",),), (("samz",),)]

tests/unit_tests/test_widget_io.py

@@ -1,8 +1,18 @@
 # pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import pytest
-from qtpy.QtWidgets import QComboBox, QLineEdit, QSpinBox, QTableWidget, QVBoxLayout, QWidget
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import (
+    QComboBox,
+    QLineEdit,
+    QSpinBox,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
 
-from bec_widgets.utils.widget_io import WidgetHierarchy
+from bec_widgets.utils.widget_io import WidgetHierarchy, WidgetIO
+from bec_widgets.widgets.utility.toggle.toggle import ToggleSwitch
 
 
 @pytest.fixture(scope="function")
@@ -14,14 +24,23 @@ def example_widget(qtbot):
     combo_box = QComboBox(main_widget)
     table_widget = QTableWidget(2, 2, main_widget)
     spin_box = QSpinBox(main_widget)
+    toggle = ToggleSwitch(main_widget)
+
     layout.addWidget(line_edit)
     layout.addWidget(combo_box)
     layout.addWidget(table_widget)
     layout.addWidget(spin_box)
+    layout.addWidget(toggle)
 
     # Add text items to the combo box
     combo_box.addItems(["Option 1", "Option 2", "Option 3"])
 
+    # Populate the table widget
+    table_widget.setItem(0, 0, QTableWidgetItem("Initial A"))
+    table_widget.setItem(0, 1, QTableWidgetItem("Initial B"))
+    table_widget.setItem(1, 0, QTableWidgetItem("Initial C"))
+    table_widget.setItem(1, 1, QTableWidgetItem("Initial D"))
+
     qtbot.addWidget(main_widget)
     qtbot.waitExposed(main_widget)
     yield main_widget
@@ -45,46 +64,129 @@ def test_export_import_config(example_widget):
 
     expected_full = {
         "QWidget ()": {
-            "QVBoxLayout ()": {},
-            "QLineEdit ()": {"value": "New Text", "QObject ()": {}},
-            "QComboBox ()": {"value": 1, "QStandardItemModel ()": {}},
+            "QComboBox ()": {"QStandardItemModel ()": {}, "value": 1},
+            "QLineEdit ()": {"QObject ()": {}, "value": "New Text"},
+            "QSpinBox ()": {
+                "QLineEdit (qt_spinbox_lineedit)": {"QObject ()": {}, "value": "10"},
+                "QValidator (qt_spinboxvalidator)": {},
+                "value": 10,
+            },
             "QTableWidget ()": {
-                "value": [["a", "b"], ["c", "d"]],
-                "QWidget (qt_scrollarea_viewport)": {},
-                "QStyledItemDelegate ()": {},
-                "QHeaderView ()": {
-                    "QWidget (qt_scrollarea_viewport)": {},
-                    "QWidget (qt_scrollarea_hcontainer)": {
-                        "QScrollBar ()": {},
-                        "QBoxLayout ()": {},
-                    },
-                    "QWidget (qt_scrollarea_vcontainer)": {
-                        "QScrollBar ()": {},
-                        "QBoxLayout ()": {},
-                    },
-                    "QItemSelectionModel ()": {},
-                },
                 "QAbstractButton ()": {},
                 "QAbstractTableModel ()": {},
+                "QHeaderView ()": {
+                    "QItemSelectionModel ()": {},
+                    "QWidget (qt_scrollarea_hcontainer)": {
+                        "QBoxLayout ()": {},
+                        "QScrollBar ()": {},
+                    },
+                    "QWidget (qt_scrollarea_vcontainer)": {
+                        "QBoxLayout ()": {},
+                        "QScrollBar ()": {},
+                    },
+                    "QWidget (qt_scrollarea_viewport)": {},
+                },
                 "QItemSelectionModel ()": {},
-                "QWidget (qt_scrollarea_hcontainer)": {"QScrollBar ()": {}, "QBoxLayout ()": {}},
-                "QWidget (qt_scrollarea_vcontainer)": {"QScrollBar ()": {}, "QBoxLayout ()": {}},
-            },
-            "QSpinBox ()": {
-                "value": 10,
-                "QLineEdit (qt_spinbox_lineedit)": {"value": "10", "QObject ()": {}},
-                "QValidator (qt_spinboxvalidator)": {},
+                "QStyledItemDelegate ()": {},
+                "QWidget (qt_scrollarea_hcontainer)": {"QBoxLayout ()": {}, "QScrollBar ()": {}},
+                "QWidget (qt_scrollarea_vcontainer)": {"QBoxLayout ()": {}, "QScrollBar ()": {}},
+                "QWidget (qt_scrollarea_viewport)": {},
+                "value": [["a", "b"], ["c", "d"]],
             },
+            "QVBoxLayout ()": {},
+            "ToggleSwitch ()": {"value": True},
         }
     }
     expected_reduced = {
         "QWidget ()": {
-            "QLineEdit ()": {"value": "New Text"},
             "QComboBox ()": {"value": 1},
+            "QLineEdit ()": {"value": "New Text"},
+            "QSpinBox ()": {"QLineEdit (qt_spinbox_lineedit)": {"value": "10"}, "value": 10},
             "QTableWidget ()": {"value": [["a", "b"], ["c", "d"]]},
-            "QSpinBox ()": {"value": 10, "QLineEdit (qt_spinbox_lineedit)": {"value": "10"}},
+            "ToggleSwitch ()": {"value": True},
         }
     }
 
     assert exported_config_full == expected_full
     assert exported_config_reduced == expected_reduced
+
+
+def test_widget_io_get_set_value(example_widget):
+    # Extract widgets
+    line_edit = example_widget.findChild(QLineEdit)
+    combo_box = example_widget.findChild(QComboBox)
+    table_widget = example_widget.findChild(QTableWidget)
+    spin_box = example_widget.findChild(QSpinBox)
+    toggle = example_widget.findChild(ToggleSwitch)
+
+    # Check initial values
+    assert WidgetIO.get_value(line_edit) == ""
+    assert WidgetIO.get_value(combo_box) == 0  # first index
+    assert WidgetIO.get_value(table_widget) == [
+        ["Initial A", "Initial B"],
+        ["Initial C", "Initial D"],
+    ]
+    assert WidgetIO.get_value(spin_box) == 0
+    assert WidgetIO.get_value(toggle) == True
+
+    # Set new values
+    WidgetIO.set_value(line_edit, "Hello")
+    WidgetIO.set_value(combo_box, "Option 2")
+    WidgetIO.set_value(table_widget, [["X", "Y"], ["Z", "W"]])
+    WidgetIO.set_value(spin_box, 5)
+    WidgetIO.set_value(toggle, False)
+
+    # Check updated values
+    assert WidgetIO.get_value(line_edit) == "Hello"
+    assert WidgetIO.get_value(combo_box, as_string=True) == "Option 2"
+    assert WidgetIO.get_value(table_widget) == [["X", "Y"], ["Z", "W"]]
+    assert WidgetIO.get_value(spin_box) == 5
+    assert WidgetIO.get_value(toggle) == False
+
+
+def test_widget_io_signal(qtbot, example_widget):
+    # Extract widgets
+    line_edit = example_widget.findChild(QLineEdit)
+    combo_box = example_widget.findChild(QComboBox)
+    spin_box = example_widget.findChild(QSpinBox)
+    table_widget = example_widget.findChild(QTableWidget)
+    toggle = example_widget.findChild(ToggleSwitch)
+
+    # We'll store changes in a list to verify the slot is called
+    changes = []
+
+    def universal_slot(w, val):
+        changes.append((w, val))
+
+    # Connect signals
+    WidgetIO.connect_widget_change_signal(line_edit, universal_slot)
+    WidgetIO.connect_widget_change_signal(combo_box, universal_slot)
+    WidgetIO.connect_widget_change_signal(spin_box, universal_slot)
+    WidgetIO.connect_widget_change_signal(table_widget, universal_slot)
+    WidgetIO.connect_widget_change_signal(toggle, universal_slot)
+
+    # Trigger changes
+    line_edit.setText("NewText")
+    qtbot.waitUntil(lambda: len(changes) > 0)
+    assert changes[-1][1] == "NewText"
+
+    combo_box.setCurrentIndex(2)
+    qtbot.waitUntil(lambda: len(changes) > 1)
+    # combo_box change should give the current index or value
+    # We set "Option 3" is index 2
+    assert changes[-1][1] == 2 or changes[-1][1] == "Option 3"
+
+    spin_box.setValue(42)
+    qtbot.waitUntil(lambda: len(changes) > 2)
+    assert changes[-1][1] == 42
+
+    # For the table widget, changing a cell triggers cellChanged
+    table_widget.setItem(0, 0, QTableWidgetItem("ChangedCell"))
+    qtbot.waitUntil(lambda: len(changes) > 3)
+    # The entire table value should be retrieved
+    assert changes[-1][1][0][0] == "ChangedCell"
+
+    # Test the toggle switch
+    toggle.checked = False
+    qtbot.waitUntil(lambda: len(changes) > 4)
+    assert changes[-1][1] == False

tests/unit_tests/test_widget_state_manager.py

@@ -0,0 +1,135 @@
+import os
+import tempfile
+
+import pytest
+from qtpy.QtCore import Property
+from qtpy.QtWidgets import QLineEdit, QVBoxLayout, QWidget
+
+from bec_widgets.utils.widget_state_manager import WidgetStateManager
+
+
+class MyLineEdit(QLineEdit):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        # Internal attribute to hold the color string
+        self._customColor = ""
+
+    @Property(str)
+    def customColor(self):
+        return self._customColor
+
+    @customColor.setter
+    def customColor(self, color):
+        self._customColor = color
+
+
+@pytest.fixture
+def test_widget(qtbot):
+    w = QWidget()
+    w.setObjectName("MainWidget")
+    layout = QVBoxLayout(w)
+
+    child1 = MyLineEdit(w)
+    child1.setObjectName("ChildLineEdit1")
+    child1.setText("Hello")
+    child1.customColor = "red"
+
+    child2 = MyLineEdit(w)
+    child2.setObjectName("ChildLineEdit2")
+    child2.setText("World")
+    child2.customColor = "blue"
+
+    layout.addWidget(child1)
+    layout.addWidget(child2)
+
+    qtbot.addWidget(w)
+    qtbot.waitExposed(w)
+    return w
+
+
+def test_save_load_widget_state(test_widget):
+    """
+    Test saving and loading the state
+    """
+
+    manager = WidgetStateManager(test_widget)
+
+    # Before saving, confirm initial properties
+    child1 = test_widget.findChild(MyLineEdit, "ChildLineEdit1")
+    child2 = test_widget.findChild(MyLineEdit, "ChildLineEdit2")
+    assert child1.text() == "Hello"
+    assert child1.customColor == "red"
+    assert child2.text() == "World"
+    assert child2.customColor == "blue"
+
+    # Create a temporary file to save settings
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".ini") as tmp_file:
+        tmp_filename = tmp_file.name
+
+    # Save the current state
+    manager.save_state(tmp_filename)
+
+    # Modify the widget properties
+    child1.setText("Changed1")
+    child1.customColor = "green"
+    child2.setText("Changed2")
+    child2.customColor = "yellow"
+
+    assert child1.text() == "Changed1"
+    assert child1.customColor == "green"
+    assert child2.text() == "Changed2"
+    assert child2.customColor == "yellow"
+
+    # Load the previous state
+    manager.load_state(tmp_filename)
+
+    # Confirm that the state has been restored
+    assert child1.text() == "Hello"
+    assert child1.customColor == "red"
+    assert child2.text() == "World"
+    assert child2.customColor == "blue"
+
+    # Clean up temporary file
+    os.remove(tmp_filename)
+
+
+def test_save_load_without_filename(test_widget, monkeypatch, qtbot):
+    """
+    Test that the dialog would open if filename is not provided.
+    """
+
+    manager = WidgetStateManager(test_widget)
+
+    # Mock QFileDialog.getSaveFileName to return a temporary filename
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".ini") as tmp_file:
+        tmp_filename = tmp_file.name
+
+    def mock_getSaveFileName(*args, **kwargs):
+        return tmp_filename, "INI Files (*.ini)"
+
+    def mock_getOpenFileName(*args, **kwargs):
+        return tmp_filename, "INI Files (*.ini)"
+
+    from qtpy.QtWidgets import QFileDialog
+
+    monkeypatch.setattr(QFileDialog, "getSaveFileName", mock_getSaveFileName)
+    monkeypatch.setattr(QFileDialog, "getOpenFileName", mock_getOpenFileName)
+
+    # Initial values
+    child1 = test_widget.findChild(MyLineEdit, "ChildLineEdit1")
+    assert child1.text() == "Hello"
+
+    # Save state without providing filename -> uses dialog mock
+    manager.save_state()
+
+    # Change property
+    child1.setText("Modified")
+
+    # Load state using dialog mock
+    manager.load_state()
+
+    # State should be restored
+    assert child1.text() == "Hello"
+
+    # Clean up
+    os.remove(tmp_filename)