1.22.0

Automatically generated by python-semantic-release

.gitlab-ci.yml

@@ -78,9 +78,9 @@ formatter:
   stage: Formatter
   needs: []
   script:
-    - pip install black isort
-    - isort --check --diff ./
-    - black --check --diff --color ./
+    - pip install bec_lib[dev]
+    - isort --check --diff --line-length=100 --profile=black --multi-line=3 --trailing-comma ./
+    - black --check --diff --color --line-length=100 --skip-magic-trailing-comma ./
   rules:
     - if: $CI_PROJECT_PATH == "bec/bec_widgets"
 
@@ -148,7 +148,7 @@ tests:
     - *clone-repos
     - *install-os-packages
     - *install-repos
-    - pip install -e .[dev,pyqt6]
+    - pip install -e .[dev,pyside6]
     - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --maxfail=2 --random-order --full-trace ./tests/unit_tests
     - coverage report
     - coverage xml
@@ -172,7 +172,6 @@ test-matrix:
           - "3.12"
         QT_PCKG:
           - "pyside6"
-          - "pyqt6"
 
   stage: AdditionalTests
   needs: []
@@ -211,7 +210,7 @@ end-2-end-conda:
     - cd ../
     - pip install -e ./ophyd_devices
 
-    - pip install -e .[dev,pyqt6]
+    - pip install -e .[dev,pyside6]
     - cd ./tests/end-2-end
     - pytest -v --start-servers --flush-redis --random-order
 

README.md

@@ -1,12 +1,17 @@
 # BEC Widgets
 
+**⚠️ Important Notice:**
+
+🚨 **PyQt6 is no longer supported** due to incompatibilities with Qt Designer. Please use **PySide6** instead. 🚨
+
 BEC Widgets is a GUI framework designed for interaction with [BEC (Beamline Experiment Control)](https://gitlab.psi.ch/bec/bec).
+
 ## Installation
 
 Use the package manager [pip](https://pip.pypa.io/en/stable/) to install BEC Widgets:
 
 ```bash
-pip install bec_widgets PyQt6
+pip install bec_widgets[pyside6]
 ```
 
 For development purposes, you can clone the repository and install the package locally in editable mode:
@@ -14,22 +19,12 @@ For development purposes, you can clone the repository and install the package l
 ```bash
 git clone https://gitlab.psi.ch/bec/bec-widgets
 cd bec_widgets
-pip install -e .[dev,pyqt6]
+pip install -e .[dev,pyside6]
 ```
 
-BEC Widgets currently supports both Pyside6 and PyQt6, however, no default distribution is specified. As a result, users must install one of the supported
-Python Qt distributions manually.
+BEC Widgets now **only supports PySide6**. Users must manually install PySide6 as no default Qt distribution is
+specified.
 
-To select a specific Python Qt distribution, install the package with an additional tag:
-
-```bash
-pip install bec_widgets[pyqt6]
-```
-or 
-
-```bash
-pip install bec_widgets[pyside6]
-```
 ## Documentation
 
 Documentation of BEC Widgets can be found [here](https://bec-widgets.readthedocs.io/en/latest/). The documentation of the BEC can be found [here](https://bec.readthedocs.io/en/latest/).
@@ -39,7 +34,7 @@ Documentation of BEC Widgets can be found [here](https://bec-widgets.readthedocs
 All commits should use the Angular commit scheme:
 
 > #### <a name="commit-header"></a>Angular Commit Message Header
-> 
+>
 > ```
 > <type>(<scope>): <short summary>
 >   │       │             │
@@ -53,13 +48,13 @@ All commits should use the Angular commit scheme:
 >   │
 >   └─⫸ Commit Type: build|ci|docs|feat|fix|perf|refactor|test
 > ```
-> 
+>
 > The `<type>` and `<summary>` fields are mandatory, the `(<scope>)` field is optional.
 
 > ##### Type
-> 
+>
 > Must be one of the following:
-> 
+>
 > * **build**: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
 > * **ci**: Changes to our CI configuration files and scripts (examples: CircleCi, SauceLabs)
 > * **docs**: Documentation only changes
@@ -71,4 +66,5 @@ All commits should use the Angular commit scheme:
 
 ## License
 
-[BSD-3-Clause](https://choosealicense.com/licenses/bsd-3-clause/)
+[BSD-3-Clause](https://choosealicense.com/licenses/bsd-3-clause/)
+

bec_widgets/cli/client.py

@@ -31,8 +31,11 @@ class Widgets(str, enum.Enum):
     DeviceComboBox = "DeviceComboBox"
     DeviceLineEdit = "DeviceLineEdit"
     LMFitDialog = "LMFitDialog"
+    LogPanel = "LogPanel"
+    Minesweeper = "Minesweeper"
     PositionIndicator = "PositionIndicator"
     PositionerBox = "PositionerBox"
+    PositionerBox2D = "PositionerBox2D"
     PositionerControlLine = "PositionerControlLine"
     ResetButton = "ResetButton"
     ResumeButton = "ResumeButton"
@@ -3181,6 +3184,29 @@ class LMFitDialog(RPCBase):
         """
 
 
+class LogPanel(RPCBase):
+    @rpc_call
+    def set_plain_text(self, text: str) -> None:
+        """
+        Set the plain text of the widget.
+
+        Args:
+            text (str): The text to set.
+        """
+
+    @rpc_call
+    def set_html_text(self, text: str) -> None:
+        """
+        Set the HTML text of the widget.
+
+        Args:
+            text (str): The text to set.
+        """
+
+
+class Minesweeper(RPCBase): ...
+
+
 class PositionIndicator(RPCBase):
     @rpc_call
     def set_value(self, position: float):
@@ -3231,6 +3257,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

@@ -34,6 +34,17 @@ else:
 logger = bec_logger.logger
 
 
+def _filter_output(output: str) -> str:
+    """
+    Filter out the output from the process.
+    """
+    if "IMKClient" in output:
+        # only relevant on macOS
+        # see https://discussions.apple.com/thread/255761734?sortBy=rank
+        return ""
+    return output
+
+
 def _get_output(process, logger) -> None:
     log_func = {process.stdout: logger.debug, process.stderr: logger.error}
     stream_buffer = {process.stdout: [], process.stderr: []}
@@ -47,6 +58,7 @@ def _get_output(process, logger) -> None:
                 if stream in readylist:
                     buf.append(stream.read(4096))
                 output, _, remaining = "".join(buf).rpartition("\n")
+                output = _filter_output(output)
                 if output:
                     log_func[stream](output)
                     buf.clear()
@@ -187,7 +199,7 @@ class BECGuiClient(RPCBase):
                     # if the module is not found, we skip it
                     if spec is None:
                         continue
-                    return ep.load()(gui=self)
+                    return ep.load()(gui=self._top_level["main"].widget)
                 except Exception as e:
                     logger.error(f"Error loading auto update script from plugin: {str(e)}")
         return None

bec_widgets/cli/generate_cli.py

@@ -43,14 +43,21 @@ from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
 
     def generate_client(self, class_container: BECClassContainer):
         """
-        Generate the client for the published classes.
+        Generate the client for the published classes, skipping any classes
+        that have `RPC = False`.
 
         Args:
             class_container: The class container with the classes to generate the client for.
         """
-        rpc_top_level_classes = class_container.rpc_top_level_classes
+        # Filter out classes that explicitly have RPC=False
+        rpc_top_level_classes = [
+            cls for cls in class_container.rpc_top_level_classes if getattr(cls, "RPC", True)
+        ]
         rpc_top_level_classes.sort(key=lambda x: x.__name__)
-        connector_classes = class_container.connector_classes
+
+        connector_classes = [
+            cls for cls in class_container.connector_classes if getattr(cls, "RPC", True)
+        ]
         connector_classes.sort(key=lambda x: x.__name__)
 
         self.write_client_enum(rpc_top_level_classes)
@@ -81,13 +88,13 @@ class Widgets(str, enum.Enum):
 
         class_name = cls.__name__
 
-        # Generate the content
-        if cls.__name__ == "BECDockArea":
+        if class_name == "BECDockArea":
             self.content += f"""
 class {class_name}(RPCBase):"""
         else:
             self.content += f"""
 class {class_name}(RPCBase):"""
+
         if not cls.USER_ACCESS:
             self.content += """...
     """
@@ -100,8 +107,10 @@ class {class_name}(RPCBase):"""
                 method = method.split(".setter")[0]
             if obj is None:
                 raise AttributeError(
-                    f"Method {method} not found in class {cls.__name__}. Please check the USER_ACCESS list."
+                    f"Method {method} not found in class {cls.__name__}. "
+                    f"Please check the USER_ACCESS list."
                 )
+
             if isinstance(obj, (property, QtProperty)):
                 # for the cli, we can map qt properties to regular properties
                 if is_property_setter:

bec_widgets/cli/server.py

@@ -218,15 +218,11 @@ def main():
 
     args = parser.parse_args()
 
+    bec_logger.level = bec_logger.LOGLEVEL.INFO
     if args.hide:
-        # if we start hidden, it means we are under control of the client
-        # -> set the log level to critical to not see all the messages
         # pylint: disable=protected-access
-        # bec_logger._stderr_log_level = bec_logger.LOGLEVEL.CRITICAL
-        bec_logger.level = bec_logger.LOGLEVEL.CRITICAL
-    else:
-        # verbose log
-        bec_logger.level = bec_logger.LOGLEVEL.DEBUG
+        bec_logger._stderr_log_level = bec_logger.LOGLEVEL.ERROR
+        bec_logger._update_sinks()
 
     if args.gui_class == "BECDockArea":
         gui_class = BECDockArea

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -20,6 +20,7 @@ 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
+from bec_widgets.widgets.plots_next_gen.plot_base import PlotBase
 
 
 class JupyterConsoleWindow(QWidget):  # pragma: no cover:
@@ -62,6 +63,8 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     "btn4": self.btn4,
                     "btn5": self.btn5,
                     "btn6": self.btn6,
+                    "pb": self.pb,
+                    "pi": self.pi,
                 }
             )
 
@@ -92,6 +95,15 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         third_tab_layout.addWidget(self.lm)
         tab_widget.addTab(third_tab, "Layout Manager Widget")
 
+        fourth_tab = QWidget()
+        fourth_tab_layout = QVBoxLayout(fourth_tab)
+        self.pb = PlotBase()
+        self.pi = self.pb.plot_item
+        fourth_tab_layout.addWidget(self.pb)
+        tab_widget.addTab(fourth_tab, "PltoBase")
+
+        tab_widget.setCurrentIndex(3)
+
         group_box = QGroupBox("Jupyter Console", splitter)
         group_box_layout = QVBoxLayout(group_box)
         self.console = BECJupyterConsole(inprocess=True)

bec_widgets/qt_utils/error_popups.py

@@ -2,42 +2,90 @@ import functools
 import sys
 import traceback
 
+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, **prop_kwargs):
+
+def SafeProperty(prop_type, *prop_args, popup_error: bool = False, default=None, **prop_kwargs):
     """
-    Decorator to create a Qt Property with a safe setter that won't crash Designer on errors.
-    Behaves similarly to SafeSlot, but for properties.
+    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, "QStringList", etc.)
-        popup_error (bool): If True, show popup on error, otherwise just handle it silently.
-        *prop_args, **prop_kwargs: Additional arguments and keyword arguments accepted by Property.
+        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(getter):
+    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):
-                self.getter_func = 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
                             )
-                        else:
-                            return
+                        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)
 
-        return PropertyWrapper(getter)
+            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
 
@@ -58,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
 

bec_widgets/qt_utils/round_frame.py

@@ -1,6 +1,6 @@
 import pyqtgraph as pg
 from qtpy.QtCore import Property
-from qtpy.QtWidgets import QApplication, QFrame, QVBoxLayout, QWidget
+from qtpy.QtWidgets import QApplication, QFrame, QHBoxLayout, QVBoxLayout, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
@@ -29,23 +29,22 @@ class RoundedFrame(BECWidget, QFrame):
         self._radius = radius
 
         # Apply rounded frame styling
+        self.setProperty("skip_settings", True)
         self.setObjectName("roundedFrame")
-        self.update_style()
 
         # Create a layout for the frame
-        layout = QVBoxLayout(self)
-        layout.setContentsMargins(5, 5, 5, 5)  # Set 5px margin
+        self.layout = QHBoxLayout(self)
+        self.layout.setContentsMargins(5, 5, 5, 5)  # Set 5px margin
 
         # Add the content widget to the layout
         if content_widget:
-            layout.addWidget(content_widget)
+            self.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()
+        # Automatically apply initial styles to the GraphicalLayoutWidget if applicable
+        self.apply_plot_widget_style()
 
         self._connect_to_theme_change()
 
@@ -64,10 +63,6 @@ class RoundedFrame(BECWidget, QFrame):
 
         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."""
@@ -91,6 +86,7 @@ class RoundedFrame(BECWidget, QFrame):
                 }}
             """
             )
+        self.apply_plot_widget_style()
 
     def apply_plot_widget_style(self, border: str = "none"):
         """
@@ -99,33 +95,16 @@ class RoundedFrame(BECWidget, QFrame):
         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))
-
+        if isinstance(self.content_widget, pg.GraphicsLayoutWidget):
             # Apply border style via stylesheet
             self.content_widget.setStyleSheet(
                 f"""
-                PlotWidget {{
+                GraphicsLayoutWidget {{
                     border: {border}; /* Explicitly set the border */
                 }}
             """
             )
+            self.content_widget.setBackground(self.background_color)
 
 
 class ExampleApp(QWidget):  # pragma: no cover
@@ -139,26 +118,27 @@ class ExampleApp(QWidget):  # pragma: no cover
         dark_button = DarkModeButton()
 
         # Create PlotWidgets
-        plot1 = pg.PlotWidget()
-        plot1.plot([1, 3, 2, 4, 6, 5], pen="r")
+        plot1 = pg.GraphicsLayoutWidget()
+        plot_item_1 = pg.PlotItem()
+        plot_item_1.plot([1, 3, 2, 4, 6, 5], pen="r")
+        plot1.plot_item = plot_item_1
 
-        plot2 = pg.PlotWidget()
-        plot2.plot([1, 2, 4, 8, 16, 32], pen="r")
+        plot2 = pg.GraphicsLayoutWidget()
+        plot_item_2 = pg.PlotItem()
+        plot_item_2.plot([1, 2, 4, 8, 16, 32], pen="r")
+        plot2.plot_item = plot_item_2
 
         # 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():

bec_widgets/qt_utils/side_panel.py

@@ -5,18 +5,18 @@ from qtpy.QtCore import Property, QEasingCurve, QPropertyAnimation
 from qtpy.QtGui import QAction
 from qtpy.QtWidgets import (
     QApplication,
+    QFrame,
     QHBoxLayout,
     QLabel,
     QMainWindow,
+    QScrollArea,
     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):
@@ -34,11 +34,13 @@ class SidePanel(QWidget):
     ):
         super().__init__(parent=parent)
 
+        self.setProperty("skip_settings", True)
+        self.setObjectName("SidePanel")
+
         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
@@ -68,6 +70,7 @@ class SidePanel(QWidget):
             self.stack_widget = QStackedWidget()
             self.stack_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
             self.stack_widget.setMinimumWidth(5)
+            self.stack_widget.setMaximumWidth(self._panel_max_width)
 
             if self._orientation == "left":
                 self.main_layout.addWidget(self.toolbar)
@@ -77,7 +80,10 @@ class SidePanel(QWidget):
                 self.main_layout.addWidget(self.toolbar)
 
             self.container.layout.addWidget(self.stack_widget)
-            self.stack_widget.setMaximumWidth(self._panel_max_width)
+
+            self.menu_anim = QPropertyAnimation(self, b"panel_width")
+            self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
+            self.panel_width = 0  # start hidden
 
         else:
             self.main_layout = QVBoxLayout(self)
@@ -94,6 +100,7 @@ class SidePanel(QWidget):
             self.stack_widget = QStackedWidget()
             self.stack_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
             self.stack_widget.setMinimumHeight(5)
+            self.stack_widget.setMaximumHeight(self._panel_max_width)
 
             if self._orientation == "top":
                 self.main_layout.addWidget(self.toolbar)
@@ -103,74 +110,46 @@ class SidePanel(QWidget):
                 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.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+            self.panel_height = 0  # start hidden
 
         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.
-        """
+        """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.
-        """
+        """Set the panel width."""
         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.
-        """
+        """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.
-        """
+        """Set the panel height."""
         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.
-        """
+        """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.
-        """
+        """Set 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)
@@ -179,45 +158,28 @@ class SidePanel(QWidget):
 
     @Property(int)
     def animation_duration(self):
-        """
-        Get the duration of the animation.
-        """
+        """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.
-        """
+        """Set 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.
-        """
+        """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.
-        """
+        """Set 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
@@ -265,9 +227,6 @@ class SidePanel(QWidget):
     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)
@@ -284,21 +243,35 @@ class SidePanel(QWidget):
             widget(QWidget): The widget to add to the panel.
             title(str): The title of the panel.
         """
+        # container_widget: top-level container for the stacked page
         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.setContentsMargins(0, 0, 0, 0)
         container_layout.setSpacing(5)
 
+        title_label = QLabel(f"<b>{title}</b>")
+        title_label.setStyleSheet("font-size: 16px;")
+        container_layout.addWidget(title_label)
+
+        # Create a QScrollArea for the actual widget to ensure scrolling if the widget inside is too large
+        scroll_area = QScrollArea()
+        scroll_area.setFrameShape(QFrame.NoFrame)
+        scroll_area.setWidgetResizable(True)
+        # Let the scroll area expand in both directions if there's room
+        scroll_area.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        scroll_area.setWidget(widget)
+
+        # Put the scroll area in the container layout
+        container_layout.addWidget(scroll_area)
+
+        # Optionally stretch the scroll area to fill vertical space
+        container_layout.setStretchFactor(scroll_area, 1)
+
+        # Add container_widget to the stacked widget
         index = self.stack_widget.count()
         self.stack_widget.addWidget(container_widget)
 
+        # Add an action to the toolbar
         action = MaterialIconAction(icon_name=icon_name, tooltip=tooltip, checkable=True)
         self.toolbar.add_action(action_id, action, target_widget=self)
 
@@ -326,6 +299,11 @@ class SidePanel(QWidget):
         action.action.toggled.connect(on_action_toggled)
 
 
+############################################
+# DEMO APPLICATION
+############################################
+
+
 class ExampleApp(QMainWindow):  # pragma: no cover
     def __init__(self):
         super().__init__()
@@ -333,20 +311,24 @@ class ExampleApp(QMainWindow):  # pragma: no cover
 
         central_widget = QWidget()
         self.setCentralWidget(central_widget)
-
-        self.side_panel = SidePanel(self, orientation="left")
-
         self.layout = QHBoxLayout(central_widget)
 
+        # Create side panel
+        self.side_panel = SidePanel(self, orientation="left", panel_max_width=250)
         self.layout.addWidget(self.side_panel)
+
+        from bec_widgets.widgets.plots.waveform.waveform_widget import BECWaveformWidget
+
         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"))
+        layout1 = QVBoxLayout(widget1)
+        for i in range(15):
+            layout1.addWidget(QLabel(f"Widget 1 label row {i}"))
         self.side_panel.add_menu(
             action_id="widget1",
             icon_name="counter_1",
@@ -356,8 +338,8 @@ class ExampleApp(QMainWindow):  # pragma: no cover
         )
 
         widget2 = QWidget()
-        widget2_layout = QVBoxLayout(widget2)
-        widget2_layout.addWidget(QLabel("This is Widget 2"))
+        layout2 = QVBoxLayout(widget2)
+        layout2.addWidget(QLabel("Short widget 2 content"))
         self.side_panel.add_menu(
             action_id="widget2",
             icon_name="counter_2",
@@ -367,8 +349,9 @@ class ExampleApp(QMainWindow):  # pragma: no cover
         )
 
         widget3 = QWidget()
-        widget3_layout = QVBoxLayout(widget3)
-        widget3_layout.addWidget(QLabel("This is Widget 3"))
+        layout3 = QVBoxLayout(widget3)
+        for i in range(10):
+            layout3.addWidget(QLabel(f"Line {i} for Widget 3"))
         self.side_panel.add_menu(
             action_id="widget3",
             icon_name="counter_3",
@@ -381,6 +364,6 @@ class ExampleApp(QMainWindow):  # pragma: no cover
 if __name__ == "__main__":  # pragma: no cover
     app = QApplication(sys.argv)
     window = ExampleApp()
-    window.resize(800, 600)
+    window.resize(1000, 700)
     window.show()
     sys.exit(app.exec())

bec_widgets/qt_utils/toolbar.py

@@ -2,28 +2,70 @@
 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.QtCore import QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QColor, QIcon
 from qtpy.QtWidgets import (
+    QApplication,
     QComboBox,
     QHBoxLayout,
     QLabel,
+    QMainWindow,
     QMenu,
     QSizePolicy,
+    QStyle,
     QToolBar,
     QToolButton,
+    QVBoxLayout,
     QWidget,
 )
 
 import bec_widgets
+from bec_widgets.utils.colors import set_theme
+from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
 MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
+# Ensure that icons are shown in menus (especially on macOS)
+QApplication.setAttribute(Qt.AA_DontShowIconsInMenus, False)
+
+
+class LongPressToolButton(QToolButton):
+    def __init__(self, *args, long_press_threshold=500, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.long_press_threshold = long_press_threshold
+        self._long_press_timer = QTimer(self)
+        self._long_press_timer.setSingleShot(True)
+        self._long_press_timer.timeout.connect(self.handleLongPress)
+        self._pressed = False
+        self._longPressed = False
+
+    def mousePressEvent(self, event):
+        self._pressed = True
+        self._longPressed = False
+        self._long_press_timer.start(self.long_press_threshold)
+        super().mousePressEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        self._pressed = False
+        if self._longPressed:
+            self._longPressed = False
+            self._long_press_timer.stop()
+            event.accept()  # Prevent normal click action after a long press
+            return
+        self._long_press_timer.stop()
+        super().mouseReleaseEvent(event)
+
+    def handleLongPress(self):
+        if self._pressed:
+            self._longPressed = True
+            self.showMenu()
+
 
 class ToolBarAction(ABC):
     """
@@ -31,7 +73,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 +123,33 @@ class IconAction(ToolBarAction):
         toolbar.addAction(self.action)
 
 
-class MaterialIconAction:
+class QtIconAction(ToolBarAction):
+    def __init__(self, standard_icon, tooltip=None, checkable=False, parent=None):
+        super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
+        self.standard_icon = standard_icon
+        self.icon = QApplication.style().standardIcon(standard_icon)
+        self.action = QAction(self.icon, self.tooltip, parent)
+        self.action.setCheckable(self.checkable)
+
+    def add_to_toolbar(self, toolbar, target):
+        toolbar.addAction(self.action)
+
+    def get_icon(self):
+        return self.icon
+
+
+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 +159,41 @@ 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 using the material_icon helper
+        self.icon = material_icon(
             self.icon_name,
             size=(20, 20),
             convert_to_pixmap=False,
             filled=self.filled,
             color=self.color,
         )
-        return icon
+        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,10 +203,9 @@ 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):
+    def __init__(self, label: str | None = None, device_combobox=None):
         super().__init__()
         self.label = label
         self.device_combobox = device_combobox
@@ -144,15 +214,99 @@ class DeviceSelectionAction(ToolBarAction):
     def add_to_toolbar(self, toolbar, target):
         widget = QWidget()
         layout = QHBoxLayout(widget)
-        label = QLabel(f"{self.label}")
-        layout.addWidget(label)
-        layout.addWidget(self.device_combobox)
-        toolbar.addWidget(widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        if self.label is not None:
+            label = QLabel(f"{self.label}")
+            layout.addWidget(label)
+        if self.device_combobox is not None:
+            layout.addWidget(self.device_combobox)
+            toolbar.addWidget(widget)
 
     def set_combobox_style(self, color: str):
         self.device_combobox.setStyleSheet(f"QComboBox {{ background-color: {color}; }}")
 
 
+class SwitchableToolBarAction(ToolBarAction):
+    """
+    A split toolbar action that combines a main action and a drop-down menu for additional actions.
+
+    The main button displays the currently selected action's icon and tooltip. Clicking on the main button
+    triggers that action. Clicking on the drop-down arrow displays a menu with alternative actions. When an
+    alternative action is selected, it becomes the new default and its callback is immediately executed.
+
+    This design mimics the behavior seen in Adobe Photoshop or Affinity Designer toolbars.
+
+    Args:
+        actions (dict): A dictionary mapping a unique key to a ToolBarAction instance.
+        initial_action (str, optional): The key of the initial default action. If not provided, the first action is used.
+        tooltip (str, optional): An optional tooltip for the split action; if provided, it overrides the default action's tooltip.
+        checkable (bool, optional): Whether the action is checkable. Defaults to True.
+        parent (QWidget, optional): Parent widget for the underlying QAction.
+    """
+
+    def __init__(
+        self,
+        actions: Dict[str, ToolBarAction],
+        initial_action: str = None,
+        tooltip: str = None,
+        checkable: bool = True,
+        parent=None,
+    ):
+        super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
+        self.actions = actions
+        self.current_key = initial_action if initial_action is not None else next(iter(actions))
+        self.parent = parent
+        self.checkable = checkable
+        self.main_button = None
+        self.menu_actions: Dict[str, QAction] = {}
+
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """
+        Adds the split action to the toolbar.
+
+        Args:
+            toolbar (QToolBar): The toolbar to add the action to.
+            target (QWidget): The target widget for the action.
+        """
+        self.main_button = LongPressToolButton(toolbar)
+        self.main_button.setPopupMode(QToolButton.MenuButtonPopup)
+        self.main_button.setCheckable(self.checkable)
+        default_action = self.actions[self.current_key]
+        self.main_button.setIcon(default_action.get_icon())
+        self.main_button.setToolTip(default_action.tooltip)
+        self.main_button.clicked.connect(self._trigger_current_action)
+        menu = QMenu(self.main_button)
+        self.menu_actions = {}
+        for key, action_obj in self.actions.items():
+            menu_action = QAction(action_obj.get_icon(), action_obj.tooltip, self.main_button)
+            menu_action.setIconVisibleInMenu(True)
+            menu_action.setCheckable(self.checkable)
+            menu_action.setChecked(key == self.current_key)
+            menu_action.triggered.connect(lambda checked, k=key: self._set_default_action(k))
+            menu.addAction(menu_action)
+            self.menu_actions[key] = menu_action
+        self.main_button.setMenu(menu)
+        toolbar.addWidget(self.main_button)
+
+    def _trigger_current_action(self):
+        action_obj = self.actions[self.current_key]
+        action_obj.action.trigger()
+
+    def _set_default_action(self, key: str):
+        self.current_key = key
+        new_action = self.actions[self.current_key]
+        self.main_button.setIcon(new_action.get_icon())
+        self.main_button.setToolTip(new_action.tooltip)
+        # Update check state of menu items
+        for k, menu_act in self.menu_actions.items():
+            menu_act.setChecked(k == key)
+        new_action.action.trigger()
+
+    def get_icon(self) -> QIcon:
+        return self.actions[self.current_key].get_icon()
+
+
 class WidgetAction(ToolBarAction):
     """
     Action for adding any widget to the toolbar.
@@ -160,19 +314,26 @@ 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):
-        super().__init__(parent)
+        super().__init__(icon_path=None, tooltip=label, checkable=False)
         self.label = label
         self.widget = widget
+        self.container = None
 
     def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
-        container = QWidget()
-        layout = QHBoxLayout(container)
+        """
+        Adds the widget to the toolbar.
+
+        Args:
+            toolbar (QToolBar): The toolbar to add the widget to.
+            target (QWidget): The target widget for the action.
+        """
+        self.container = QWidget()
+        layout = QHBoxLayout(self.container)
         layout.setContentsMargins(0, 0, 0, 0)
-        layout.setSpacing(5)
+        layout.setSpacing(0)
 
         if self.label is not None:
             label_widget = QLabel(f"{self.label}")
@@ -193,19 +354,12 @@ class WidgetAction(ToolBarAction):
 
         layout.addWidget(self.widget)
 
-        toolbar.addWidget(container)
+        toolbar.addWidget(self.container)
+        # Store the container as the action to allow toggling visibility.
+        self.action = self.container
 
     @staticmethod
     def calculate_minimum_width(combo_box: QComboBox) -> int:
-        """
-        Calculate the minimum width required to display the longest item in the combo box.
-
-        Args:
-            combo_box (QComboBox): The combo box to calculate the width for.
-
-        Returns:
-            int: The calculated minimum width in pixels.
-        """
         font_metrics = combo_box.fontMetrics()
         max_width = max(font_metrics.width(combo_box.itemText(i)) for i in range(combo_box.count()))
         return max_width + 60
@@ -219,7 +373,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):
@@ -246,12 +399,15 @@ class ExpandableMenuAction(ToolBarAction):
         menu = QMenu(button)
         for action_id, action in self.actions.items():
             sub_action = QAction(action.tooltip, target)
-            if hasattr(action, "icon_path"):
+            sub_action.setIconVisibleInMenu(True)
+            if action.icon_path:
                 icon = QIcon()
                 icon.addFile(action.icon_path, size=QSize(20, 20))
                 sub_action.setIcon(icon)
-            elif hasattr(action, "get_icon"):
-                sub_action.setIcon(action.get_icon())
+            elif hasattr(action, "get_icon") and callable(action.get_icon):
+                sub_icon = action.get_icon()
+                if sub_icon and not sub_icon.isNull():
+                    sub_action.setIcon(sub_icon)
             sub_action.setCheckable(action.checkable)
             menu.addAction(sub_action)
             self.widgets[action_id] = sub_action
@@ -259,6 +415,54 @@ class ExpandableMenuAction(ToolBarAction):
         toolbar.addWidget(button)
 
 
+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, 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 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.
 
@@ -267,7 +471,7 @@ class ModularToolBar(QToolBar):
         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.
+        background_color (str, optional): The background color of the toolbar. Defaults to "rgba(0, 0, 0, 0)".
     """
 
     def __init__(
@@ -287,10 +491,14 @@ class ModularToolBar(QToolBar):
         # 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:
@@ -298,16 +506,19 @@ class ModularToolBar(QToolBar):
             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, color: str = "rgba(0, 0, 0, 0)"):
         """
         Sets the background color and other appearance settings.
 
         Args:
-            color(str): The background color of the toolbar.
+            color (str): The background color of the toolbar.
         """
         self.setIconSize(QSize(20, 20))
         self.setMovable(False)
@@ -331,54 +542,414 @@ class ModularToolBar(QToolBar):
 
     def update_material_icon_colors(self, new_color: str | tuple | QColor):
         """
-        Updates the color of all MaterialIconAction icons in the toolbar.
+        Updates the color of all MaterialIconAction icons.
 
         Args:
-            new_color (str | tuple | QColor): The new color for the icons.
+            new_color (str | tuple | QColor): The new color.
         """
         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 action to the toolbar dynamically.
+        Adds a new standalone action 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.
+            action_id (str): Unique identifier.
+            action (ToolBarAction): The action to add.
+            target_widget (QWidget): The target widget.
         """
         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()
 
     def hide_action(self, action_id: str):
         """
-        Hides a specific action on the toolbar.
+        Hides a specific action.
 
         Args:
-            action_id (str): Unique identifier for the action to hide.
+            action_id (str): Unique identifier.
         """
         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):
+        if hasattr(action, "action") and action.action is not None:
             action.action.setVisible(False)
+            self.update_separators()
 
     def show_action(self, action_id: str):
         """
-        Shows a specific action on the toolbar.
+        Shows a specific action.
 
         Args:
-            action_id (str): Unique identifier for the action to show.
+            action_id (str): Unique identifier.
         """
         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):
+        if hasattr(action, "action") and action.action is not None:
             action.action.setVisible(True)
+            self.update_separators()
+
+    def add_bundle(self, bundle: ToolbarBundle, target_widget: QWidget):
+        """
+        Adds a bundle of actions, separated by a separator.
+
+        Args:
+            bundle (ToolbarBundle): The bundle.
+            target_widget (QWidget): The target widget.
+        """
+        if bundle.bundle_id in self.bundles:
+            raise ValueError(f"ToolbarBundle with ID '{bundle.bundle_id}' already exists.")
+
+        if self.toolbar_items:
+            sep = SeparatorAction()
+            sep.add_to_toolbar(self, target_widget)
+            self.toolbar_items.append(("separator", None))
+
+        for action_id, action_obj in bundle.actions.items():
+            action_obj.add_to_toolbar(self, target_widget)
+            self.widgets[action_id] = action_obj
+
+        self.bundles[bundle.bundle_id] = list(bundle.actions.keys())
+        self.toolbar_items.append(("bundle", bundle.bundle_id))
+        self.update_separators()
+
+    def add_action_to_bundle(self, bundle_id: str, action_id: str, action, target_widget: QWidget):
+        """
+        Dynamically adds an action to an existing bundle.
+
+        Args:
+            bundle_id (str): The bundle ID.
+            action_id (str): Unique identifier.
+            action (ToolBarAction): The action to add.
+            target_widget (QWidget): The target widget.
+        """
+        if bundle_id not in self.bundles:
+            raise ValueError(f"Bundle '{bundle_id}' does not exist.")
+        if action_id in self.widgets:
+            raise ValueError(f"Action with ID '{action_id}' already exists.")
+
+        action.add_to_toolbar(self, target_widget)
+        new_qaction = action.action
+        self.removeAction(new_qaction)
+
+        bundle_action_ids = self.bundles[bundle_id]
+        if bundle_action_ids:
+            last_bundle_action = self.widgets[bundle_action_ids[-1]].action
+            actions_list = self.actions()
+            try:
+                index = actions_list.index(last_bundle_action)
+            except ValueError:
+                self.addAction(new_qaction)
+            else:
+                if index + 1 < len(actions_list):
+                    before_action = actions_list[index + 1]
+                    self.insertAction(before_action, new_qaction)
+                else:
+                    self.addAction(new_qaction)
+        else:
+            self.addAction(new_qaction)
+
+        self.widgets[action_id] = action
+        self.bundles[bundle_id].append(action_id)
+        self.update_separators()
+
+    def contextMenuEvent(self, event):
+        """
+        Overrides the context menu event to show toolbar actions with checkboxes and icons.
+
+        Args:
+            event (QContextMenuEvent): The context menu event.
+        """
+        menu = QMenu(self)
+        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)
+        menu.triggered.connect(self.handle_menu_triggered)
+        menu.exec_(event.globalPos())
+
+    def handle_bundle_context_menu(self, menu: QMenu, bundle_id: str):
+        """
+        Adds bundle actions to the context menu.
+
+        Args:
+            menu (QMenu): The context menu.
+            bundle_id (str): The bundle identifier.
+        """
+        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 triggered signal from the context menu.
+
+        Args:
+            action: Action triggered.
+        """
+        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.
+
+        Args:
+            action_id (str): Unique identifier.
+            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 tool_action.action is not None:
+            tool_action.action.setVisible(visible)
+            self.update_separators()
+
+    def update_separators(self):
+        """
+        Hide separators that are adjacent to another separator or have no non-separator actions between them.
+        """
+        toolbar_actions = self.actions()
+        # First pass: set visibility based on surrounding non-separator actions.
+        for i, action in enumerate(toolbar_actions):
+            if not action.isSeparator():
+                continue
+            prev_visible = None
+            for j in range(i - 1, -1, -1):
+                if toolbar_actions[j].isVisible():
+                    prev_visible = toolbar_actions[j]
+                    break
+            next_visible = None
+            for j in range(i + 1, len(toolbar_actions)):
+                if toolbar_actions[j].isVisible():
+                    next_visible = toolbar_actions[j]
+                    break
+            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)
+        # Second pass: ensure no two visible separators are adjacent.
+        prev = None
+        for action in toolbar_actions:
+            if action.isVisible() and action.isSeparator():
+                if prev and prev.isSeparator():
+                    action.setVisible(False)
+                else:
+                    prev = action
+            else:
+                if action.isVisible():
+                    prev = action
+
+
+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)
+        self.test_label = QLabel(text="This is a test label.")
+        self.central_widget.layout = QVBoxLayout(self.central_widget)
+        self.central_widget.layout.addWidget(self.test_label)
+
+        self.toolbar = ModularToolBar(parent=self, target_widget=self)
+        self.addToolBar(self.toolbar)
+
+        self.add_switchable_button_checkable()
+        self.add_switchable_button_non_checkable()
+        self.add_widget_actions()
+        self.add_bundles()
+        self.add_menus()
+
+        # For theme testing
+
+        self.dark_button = DarkModeButton(toolbar=True)
+        dark_mode_action = WidgetAction(label=None, widget=self.dark_button)
+        self.toolbar.add_action("dark_mode", dark_mode_action, self)
+
+    def add_bundles(self):
+        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)
+
+        search_action = MaterialIconAction(
+            icon_name="search", tooltip="Search", checkable=False, parent=self
+        )
+        help_action = MaterialIconAction(
+            icon_name="help", tooltip="Help", checkable=False, 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)
+
+        new_action = MaterialIconAction(
+            icon_name="counter_1", tooltip="New Action", checkable=True, parent=self
+        )
+        self.toolbar.add_action_to_bundle(
+            "main_actions", "new_action", new_action, target_widget=self
+        )
+
+    def add_menus(self):
+        menu_material_actions = {
+            "mat1": MaterialIconAction(
+                icon_name="home", tooltip="Material Home", checkable=True, parent=self
+            ),
+            "mat2": MaterialIconAction(
+                icon_name="settings", tooltip="Material Settings", checkable=True, parent=self
+            ),
+            "mat3": MaterialIconAction(
+                icon_name="info", tooltip="Material Info", checkable=True, parent=self
+            ),
+        }
+        menu_qt_actions = {
+            "qt1": QtIconAction(
+                standard_icon=QStyle.SP_FileIcon, tooltip="Qt File", checkable=True, parent=self
+            ),
+            "qt2": QtIconAction(
+                standard_icon=QStyle.SP_DirIcon, tooltip="Qt Directory", checkable=True, parent=self
+            ),
+            "qt3": QtIconAction(
+                standard_icon=QStyle.SP_TrashIcon, tooltip="Qt Trash", checkable=True, parent=self
+            ),
+        }
+        expandable_menu_material = ExpandableMenuAction(
+            label="Material Menu", actions=menu_material_actions
+        )
+        expandable_menu_qt = ExpandableMenuAction(label="Qt Menu", actions=menu_qt_actions)
+
+        self.toolbar.add_action("material_menu", expandable_menu_material, self)
+        self.toolbar.add_action("qt_menu", expandable_menu_qt, self)
+
+    def add_switchable_button_checkable(self):
+        action1 = MaterialIconAction(
+            icon_name="counter_1", tooltip="Action 1", checkable=True, parent=self
+        )
+        action2 = MaterialIconAction(
+            icon_name="counter_2", tooltip="Action 2", checkable=True, parent=self
+        )
+
+        switchable_action = SwitchableToolBarAction(
+            actions={"action1": action1, "action2": action2},
+            initial_action="action1",
+            tooltip="Switchable Action",
+            checkable=True,
+            parent=self,
+        )
+        self.toolbar.add_action("switchable_action", switchable_action, self)
+
+        action1.action.toggled.connect(
+            lambda checked: self.test_label.setText(f"Action 1 triggered, checked = {checked}")
+        )
+        action2.action.toggled.connect(
+            lambda checked: self.test_label.setText(f"Action 2 triggered, checked = {checked}")
+        )
+
+    def add_switchable_button_non_checkable(self):
+        action1 = MaterialIconAction(
+            icon_name="counter_1", tooltip="Action 1", checkable=False, parent=self
+        )
+        action2 = MaterialIconAction(
+            icon_name="counter_2", tooltip="Action 2", checkable=False, parent=self
+        )
+
+        switchable_action = SwitchableToolBarAction(
+            actions={"action1": action1, "action2": action2},
+            initial_action="action1",
+            tooltip="Switchable Action",
+            checkable=False,
+            parent=self,
+        )
+        self.toolbar.add_action("switchable_action_no_toggle", switchable_action, self)
+
+        action1.action.triggered.connect(
+            lambda checked: self.test_label.setText(f"Action 1 triggered, checked = {checked}")
+        )
+        action2.action.triggered.connect(
+            lambda checked: self.test_label.setText(f"Action 2 triggered, checked = {checked}")
+        )
+
+    def add_widget_actions(self):
+        combo = QComboBox()
+        combo.addItems(["Option 1", "Option 2", "Option 3"])
+        self.toolbar.add_action("device_combo", WidgetAction(label="Device:", widget=combo), self)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication(sys.argv)
+    set_theme("light")
+    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

@@ -4,7 +4,7 @@ from __future__ import annotations
 import os
 import time
 import uuid
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import lazy_import_from
@@ -17,6 +17,9 @@ 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
 
+if TYPE_CHECKING:
+    from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
 logger = bec_logger.logger
 BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
 
@@ -108,7 +111,7 @@ class BECConnector:
 
         # register widget to rpc register
         # be careful: when registering, and the object is not a BECWidget,
-        # cleanup has to called manually since there is no 'closeEvent'
+        # cleanup has to be called manually since there is no 'closeEvent'
         self.rpc_register = RPCRegister()
         self.rpc_register.add_rpc(self)
 
@@ -116,6 +119,8 @@ class BECConnector:
         self.error_utility = ErrorPopupUtility()
 
         self._thread_pool = QThreadPool.globalInstance()
+        # Store references to running workers so they're not garbage collected prematurely.
+        self._workers = []
 
     def submit_task(self, fn, *args, on_complete: pyqtSlot = None, **kwargs) -> Worker:
         """
@@ -144,11 +149,14 @@ class BECConnector:
             >>> def on_complete():
             >>>     print("Task complete")
             >>> self.submit_task(my_function, 1, 2, on_complete=on_complete)
-
         """
         worker = Worker(fn, *args, **kwargs)
         if on_complete:
             worker.signals.completed.connect(on_complete)
+        # Keep a reference to the worker so it is not garbage collected.
+        self._workers.append(worker)
+        # When the worker is done, remove it from our list.
+        worker.signals.completed.connect(lambda: self._workers.remove(worker))
         self._thread_pool.start(worker)
         return worker
 
@@ -180,10 +188,10 @@ class BECConnector:
     @_config_dict.setter
     def _config_dict(self, config: BaseModel) -> None:
         """
-        Get the configuration of the widget.
+        Set the configuration of the widget.
 
-        Returns:
-            dict: The configuration of the widget.
+        Args:
+            config (BaseModel): The new configuration model.
         """
         self.config = config
 
@@ -192,8 +200,8 @@ class BECConnector:
         Apply the configuration to the widget.
 
         Args:
-            config(dict): Configuration settings.
-            generate_new_id(bool): If True, generate a new GUI ID for the widget.
+            config (dict): Configuration settings.
+            generate_new_id (bool): If True, generate a new GUI ID for the widget.
         """
         self.config = ConnectionConfig(**config)
         if generate_new_id is True:
@@ -209,8 +217,8 @@ class BECConnector:
         Load the configuration of the widget from YAML.
 
         Args:
-            path(str): Path to the configuration file for non-GUI dialog mode.
-            gui(bool): If True, use the GUI dialog to load the configuration file.
+            path (str | None): Path to the configuration file for non-GUI dialog mode.
+            gui (bool): If True, use the GUI dialog to load the configuration file.
         """
         if gui is True:
             config = load_yaml_gui(self)
@@ -229,8 +237,8 @@ class BECConnector:
         Save the configuration of the widget to YAML.
 
         Args:
-            path(str): Path to save the configuration file for non-GUI dialog mode.
-            gui(bool): If True, use the GUI dialog to save the configuration file.
+            path (str | None): Path to save the configuration file for non-GUI dialog mode.
+            gui (bool): If True, use the GUI dialog to save the configuration file.
         """
         if gui is True:
             save_yaml_gui(self, self._config_dict)
@@ -238,7 +246,6 @@ class BECConnector:
             if path is None:
                 path = os.getcwd()
             file_path = os.path.join(path, f"{self.__class__.__name__}_config.yaml")
-
             save_yaml(file_path, self._config_dict)
 
     @pyqtSlot(str)
@@ -247,7 +254,7 @@ class BECConnector:
         Set the GUI ID for the widget.
 
         Args:
-            gui_id(str): GUI ID
+            gui_id (str): GUI ID.
         """
         self.config.gui_id = gui_id
         self.gui_id = gui_id
@@ -268,7 +275,7 @@ class BECConnector:
         """Update the client and device manager from BEC and create object for BEC shortcuts.
 
         Args:
-            client: BEC client
+            client: BEC client.
         """
         self.client = client
         self.get_bec_shortcuts()
@@ -279,12 +286,10 @@ class BECConnector:
         Update the configuration for the widget.
 
         Args:
-            config(ConnectionConfig): Configuration settings.
+            config (ConnectionConfig | dict): Configuration settings.
         """
         if isinstance(config, dict):
             config = ConnectionConfig(**config)
-            # TODO add error handler
-
         self.config = config
 
     def get_config(self, dict_output: bool = True) -> dict | BaseModel:
@@ -292,12 +297,45 @@ class BECConnector:
         Get the configuration of the widget.
 
         Args:
-            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
+            dict_output (bool): If True, return the configuration as a dictionary.
+                                If False, return the configuration as a pydantic model.
 
         Returns:
-            dict: The configuration of the plot widget.
+            dict | BaseModel: The configuration of the widget.
         """
         if dict_output:
             return self.config.model_dump()
         else:
             return self.config
+
+
+# --- Example usage of BECConnector: running a simple task ---
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    # Create a QApplication instance (required for QThreadPool)
+    app = QApplication(sys.argv)
+
+    connector = BECConnector()
+
+    def print_numbers():
+        """
+        Task function that prints numbers 1 to 10 with a 0.5 second delay between each.
+        """
+        for i in range(1, 11):
+            print(i)
+            time.sleep(0.5)
+
+    def task_complete():
+        """
+        Called when the task is complete.
+        """
+        print("Task complete")
+        # Exit the application after the task completes.
+        app.quit()
+
+    # Submit the task using the connector's submit_task method.
+    connector.submit_task(print_numbers, on_complete=task_complete)
+
+    # Start the Qt event loop.
+    sys.exit(app.exec_())

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,30 @@ 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()
+
+    def cleanup(self):
+        """
+        Cleanup the proxy by stopping the timer and disconnecting the timeout signal.
+        """
+        self._timer.stop()
+        self._timer.timeout.disconnect(self._timeout_unblock)
+        self._timer.deleteLater()

bec_widgets/utils/bec_widget.py

@@ -66,7 +66,7 @@ class BECWidget(BECConnector):
         if hasattr(qapp, "theme_signal"):
             qapp.theme_signal.theme_updated.connect(self._update_theme)
 
-    def _update_theme(self, theme: str):
+    def _update_theme(self, theme: str | None = None):
         """Update the theme."""
         if theme is None:
             qapp = QApplication.instance()

bec_widgets/utils/colors.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import itertools
 import re
 from typing import TYPE_CHECKING, Literal
 
@@ -71,15 +70,64 @@ def apply_theme(theme: Literal["dark", "light"]):
     Apply the theme to all pyqtgraph widgets. Do not use this function directly. Use set_theme instead.
     """
     app = QApplication.instance()
-    # go through all pyqtgraph widgets and set background
-    children = itertools.chain.from_iterable(
-        top.findChildren(pg.GraphicsLayoutWidget) for top in app.topLevelWidgets()
-    )
-    pg.setConfigOptions(
-        foreground="d" if theme == "dark" else "k", background="k" if theme == "dark" else "w"
-    )
-    for pg_widget in children:
-        pg_widget.setBackground("k" if theme == "dark" else "w")
+    graphic_layouts = [
+        child
+        for top in app.topLevelWidgets()
+        for child in top.findChildren(pg.GraphicsLayoutWidget)
+    ]
+
+    plot_items = [
+        item
+        for gl in graphic_layouts
+        for item in gl.ci.items.keys()  # ci is internal pg.GraphicsLayout that hosts all items
+        if isinstance(item, pg.PlotItem)
+    ]
+
+    histograms = [
+        item
+        for gl in graphic_layouts
+        for item in gl.ci.items.keys()  # ci is internal pg.GraphicsLayout that hosts all items
+        if isinstance(item, pg.HistogramLUTItem)
+    ]
+
+    # Update background color based on the theme
+    if theme == "light":
+        background_color = "#e9ecef"  # Subtle contrast for light mode
+        foreground_color = "#141414"
+        label_color = "#000000"
+        axis_color = "#666666"
+    else:
+        background_color = "#141414"  # Dark mode
+        foreground_color = "#e9ecef"
+        label_color = "#FFFFFF"
+        axis_color = "#CCCCCC"
+
+    # update GraphicsLayoutWidget
+    pg.setConfigOptions(foreground=foreground_color, background=background_color)
+    for pg_widget in graphic_layouts:
+        pg_widget.setBackground(background_color)
+
+    # update PlotItems
+    for plot_item in plot_items:
+        for axis in ["left", "right", "top", "bottom"]:
+            plot_item.getAxis(axis).setPen(pg.mkPen(color=axis_color))
+            plot_item.getAxis(axis).setTextPen(pg.mkPen(color=label_color))
+
+        # Change title color
+        plot_item.titleLabel.setText(plot_item.titleLabel.text, color=label_color)
+
+        # Change legend color
+        if hasattr(plot_item, "legend") and plot_item.legend is not None:
+            plot_item.legend.setLabelTextColor(label_color)
+            # if legend is in plot item and theme is changed, has to be like that because of pg opt logic
+            for sample, label in plot_item.legend.items:
+                label_text = label.text
+                label.setText(label_text, color=label_color)
+
+    # update HistogramLUTItem
+    for histogram in histograms:
+        histogram.axis.setPen(pg.mkPen(color=axis_color))
+        histogram.axis.setTextPen(pg.mkPen(color=label_color))
 
     # now define stylesheet according to theme and apply it
     style = bec_qthemes.load_stylesheet(theme)

bec_widgets/utils/widget_io.py

@@ -15,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."""
@@ -125,6 +127,19 @@ class CheckBoxHandler(WidgetHandler):
         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."""
 
@@ -149,6 +164,7 @@ class WidgetIO:
         QDoubleSpinBox: SpinBoxHandler,
         QCheckBox: CheckBoxHandler,
         QLabel: LabelHandler,
+        ToggleSwitch: ToggleSwitchHandler,
     }
 
     @staticmethod

bec_widgets/utils/widget_state_manager.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from bec_lib import bec_logger
+from qtpy.QtCore import QSettings
+from qtpy.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QFileDialog,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
+)
+
+logger = bec_logger.logger
+
+
+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 an 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 an 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.
+        """
+        if widget.property("skip_settings") is True:
+            return
+
+        meta = widget.metaObject()
+        widget_name = self._get_full_widget_name(widget)
+        settings.beginGroup(widget_name)
+        for i in range(meta.propertyCount()):
+            prop = meta.property(i)
+            name = prop.name()
+            if (
+                name == "objectName"
+                or not prop.isReadable()
+                or not prop.isWritable()
+                or not prop.isStored()  # can be extended to fine filter
+            ):
+                continue
+            value = widget.property(name)
+            settings.setValue(name, value)
+        settings.endGroup()
+
+        # Recursively process children (only if they aren't skipped)
+        for child in widget.children():
+            if (
+                child.objectName()
+                and child.property("skip_settings") is not True
+                and not isinstance(child, QLabel)
+            ):
+                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.
+        """
+        if widget.property("skip_settings") is True:
+            return
+
+        meta = widget.metaObject()
+        widget_name = self._get_full_widget_name(widget)
+        settings.beginGroup(widget_name)
+        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 process children (only if they aren't skipped)
+        for child in widget.children():
+            if (
+                child.objectName()
+                and child.property("skip_settings") is not True
+                and not isinstance(child, QLabel)
+            ):
+                self._load_widget_state_qsettings(child, settings)
+
+    def _get_full_widget_name(self, widget: QWidget):
+        """
+        Get the full name of the widget including its parent names.
+
+        Args:
+            widget(QWidget): The widget to get the full name for.
+
+        Returns:
+            str: The full name of the widget.
+        """
+        name = widget.objectName()
+        parent = widget.parent()
+        while parent:
+            obj_name = parent.objectName() or parent.metaObject().className()
+            name = obj_name + "." + name
+            parent = parent.parent()
+        return name
+
+
+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)
+
+        # A checkbox that we want to skip
+        self.check_box_skip = QCheckBox("Enable feature - skip save?", self)
+        self.check_box_skip.setProperty("skip_state", True)
+        self.check_box_skip.setObjectName("MyCheckBoxSkip")
+        layout.addWidget(self.check_box_skip)
+
+        #  CREATE A "SIDE PANEL" with nested structure and skip all what is inside
+        self.side_panel = QWidget(self)
+        self.side_panel.setObjectName("SidePanel")
+        self.side_panel.setProperty("skip_settings", True)  # skip the ENTIRE panel
+        layout.addWidget(self.side_panel)
+
+        # Put some sub-widgets inside side_panel
+        panel_layout = QVBoxLayout(self.side_panel)
+        self.panel_label = QLabel("Label in side panel", self.side_panel)
+        self.panel_label.setObjectName("PanelLabel")
+        panel_layout.addWidget(self.panel_label)
+
+        self.panel_edit = QLineEdit(self.side_panel)
+        self.panel_edit.setObjectName("PanelLineEdit")
+        self.panel_edit.setPlaceholderText("I am inside side panel")
+        panel_layout.addWidget(self.panel_edit)
+
+        self.panel_checkbox = QCheckBox("Enable feature in side panel?", self.side_panel)
+        self.panel_checkbox.setObjectName("PanelCheckBox")
+        panel_layout.addWidget(self.panel_checkbox)
+
+        # Save/Load buttons
+        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/__init__.py

@@ -1 +0,0 @@
-

bec_widgets/widgets/containers/dock/dock_area.py

@@ -20,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
@@ -30,6 +30,7 @@ from bec_widgets.widgets.plots.waveform.waveform_widget import BECWaveformWidget
 from bec_widgets.widgets.progress.ring_progress_bar.ring_progress_bar import RingProgressBar
 from bec_widgets.widgets.services.bec_queue.bec_queue import BECQueue
 from bec_widgets.widgets.services.bec_status_box.bec_status_box import BECStatusBox
+from bec_widgets.widgets.utility.logpanel.logpanel import LogPanel
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
 
@@ -139,6 +140,9 @@ class BECDockArea(BECWidget, QWidget):
                             tooltip="Add Circular ProgressBar",
                             filled=True,
                         ),
+                        "log_panel": MaterialIconAction(
+                            icon_name=LogPanel.ICON_NAME, tooltip="Add LogPanel", filled=True
+                        ),
                     },
                 ),
                 "separator_2": SeparatorAction(),
@@ -200,6 +204,9 @@ class BECDockArea(BECWidget, QWidget):
         self.toolbar.widgets["menu_utils"].widgets["progress_bar"].triggered.connect(
             lambda: self.add_dock(widget="RingProgressBar", prefix="progress_bar")
         )
+        self.toolbar.widgets["menu_utils"].widgets["log_panel"].triggered.connect(
+            lambda: self.add_dock(widget="LogPanel", prefix="log_panel")
+        )
 
         # Icons
         self.toolbar.widgets["attach_all"].action.triggered.connect(self.attach_all)

bec_widgets/widgets/containers/layout_manager/layout_manager.py

@@ -34,6 +34,7 @@ class LayoutManagerWidget(QWidget):
 
     def __init__(self, parent=None, auto_reindex=True):
         super().__init__(parent)
+        self.setObjectName("LayoutManagerWidget")
         self.layout = QGridLayout(self)
         self.auto_reindex = auto_reindex
 

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/register_signal_combo_box.py

@@ -6,7 +6,7 @@ def main():  # pragma: no cover
         return
     from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
 
-    from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox_plugin import (
+    from bec_widgets.widgets.control.device_input.signal_combobox.signal_combo_box_plugin import (
         SignalComboBoxPlugin,
     )
 

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

@@ -8,7 +8,7 @@ from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox im
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='SignalComboBox' name='signal_combobox'>
+    <widget class='SignalComboBox' name='signal_combo_box'>
     </widget>
 </ui>
 """
@@ -33,7 +33,7 @@ class SignalComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return designer_material_icon(SignalComboBox.ICON_NAME)
 
     def includeFile(self):
-        return "signal_combobox"
+        return "signal_combo_box"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -48,7 +48,7 @@ class SignalComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "SignalComboBox"
 
     def toolTip(self):
-        return ""
+        return "Signal ComboBox Example for BEC Widgets with autocomplete."
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/control/device_input/signal_line_edit/signal_line_edit_plugin.py

@@ -50,7 +50,7 @@ class SignalLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "SignalLineEdit"
 
     def toolTip(self):
-        return ""
+        return "Signal LineEdit Example for BEC Widgets with autocomplete."
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/dap/lmfit_dialog/lmfit_dialog.py

@@ -1,9 +1,10 @@
 import os
 
 from bec_lib.logger import bec_logger
-from qtpy.QtCore import Property, Signal, Slot
+from qtpy.QtCore import Signal
 from qtpy.QtWidgets import QPushButton, QTreeWidgetItem, QVBoxLayout, QWidget
 
+from bec_widgets.qt_utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils import UILoader
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import get_accent_colors
@@ -43,6 +44,8 @@ class LMFitDialog(BECWidget, QWidget):
         """
         super().__init__(client=client, config=config, gui_id=gui_id)
         QWidget.__init__(self, parent=parent)
+        self.setProperty("skip_settings", True)
+        self.setObjectName("LMFitDialog")
         self._ui_file = ui_file
         self.target_widget = target_widget
 
@@ -65,7 +68,7 @@ class LMFitDialog(BECWidget, QWidget):
 
     @property
     def enable_actions(self) -> bool:
-        """Property to enable the move to buttons."""
+        """SafeProperty to enable the move to buttons."""
         return self._enable_actions
 
     @enable_actions.setter
@@ -74,37 +77,37 @@ class LMFitDialog(BECWidget, QWidget):
         for button in self.action_buttons.values():
             button.setEnabled(enable)
 
-    @Property(list)
+    @SafeProperty(list)
     def active_action_list(self) -> list[str]:
-        """Property to list the names of the fit parameters for which actions should be enabled."""
+        """SafeProperty to list the names of the fit parameters for which actions should be enabled."""
         return self._active_actions
 
     @active_action_list.setter
     def active_action_list(self, actions: list[str]):
         self._active_actions = actions
 
-    # This slot needed?
-    @Slot(bool)
+    # This SafeSlot needed?
+    @SafeSlot(bool)
     def set_actions_enabled(self, enable: bool) -> bool:
-        """Slot to enable the move to buttons.
+        """SafeSlot to enable the move to buttons.
 
         Args:
             enable (bool): Whether to enable the action buttons.
         """
         self.enable_actions = enable
 
-    @Property(bool)
+    @SafeProperty(bool)
     def always_show_latest(self):
-        """Property to indicate if always the latest DAP update is displayed."""
+        """SafeProperty to indicate if always the latest DAP update is displayed."""
         return self._always_show_latest
 
     @always_show_latest.setter
     def always_show_latest(self, show: bool):
         self._always_show_latest = show
 
-    @Property(bool)
+    @SafeProperty(bool)
     def hide_curve_selection(self):
-        """Property for showing the curve selection."""
+        """SafeProperty for showing the curve selection."""
         return not self.ui.group_curve_selection.isVisible()
 
     @hide_curve_selection.setter
@@ -116,9 +119,9 @@ class LMFitDialog(BECWidget, QWidget):
         """
         self.ui.group_curve_selection.setVisible(not show)
 
-    @Property(bool)
+    @SafeProperty(bool)
     def hide_summary(self) -> bool:
-        """Property for showing the summary."""
+        """SafeProperty for showing the summary."""
         return not self.ui.group_summary.isVisible()
 
     @hide_summary.setter
@@ -130,9 +133,9 @@ class LMFitDialog(BECWidget, QWidget):
         """
         self.ui.group_summary.setVisible(not show)
 
-    @Property(bool)
+    @SafeProperty(bool)
     def hide_parameters(self) -> bool:
-        """Property for showing the parameters."""
+        """SafeProperty for showing the parameters."""
         return not self.ui.group_parameters.isVisible()
 
     @hide_parameters.setter
@@ -146,7 +149,7 @@ class LMFitDialog(BECWidget, QWidget):
 
     @property
     def fit_curve_id(self) -> str:
-        """Property for the currently displayed fit curve_id."""
+        """SafeProperty for the currently displayed fit curve_id."""
         return self._fit_curve_id
 
     @fit_curve_id.setter
@@ -159,7 +162,7 @@ class LMFitDialog(BECWidget, QWidget):
         self._fit_curve_id = curve_id
         self.selected_fit.emit(curve_id)
 
-    @Slot(str)
+    @SafeSlot(str)
     def remove_dap_data(self, curve_id: str):
         """Remove the DAP data for the given curve_id.
 
@@ -169,7 +172,7 @@ class LMFitDialog(BECWidget, QWidget):
         self.summary_data.pop(curve_id, None)
         self.refresh_curve_list()
 
-    @Slot(str)
+    @SafeSlot(str)
     def select_curve(self, curve_id: str):
         """Select active curve_id in the curve list.
 
@@ -178,7 +181,7 @@ class LMFitDialog(BECWidget, QWidget):
         """
         self.fit_curve_id = curve_id
 
-    @Slot(dict, dict)
+    @SafeSlot(dict, dict)
     def update_summary_tree(self, data: dict, metadata: dict):
         """Update the summary tree with the given data.
 

bec_widgets/widgets/editors/scan_metadata/__init__.py

@@ -0,0 +1,7 @@
+from bec_widgets.widgets.editors.scan_metadata.additional_metadata_table import (
+    AdditionalMetadataTable,
+    AdditionalMetadataTableModel,
+)
+from bec_widgets.widgets.editors.scan_metadata.scan_metadata import ScanMetadata
+
+__all__ = ["ScanMetadata", "AdditionalMetadataTable", "AdditionalMetadataTableModel"]

bec_widgets/widgets/editors/scan_metadata/_metadata_widgets.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from decimal import Decimal
+from typing import TYPE_CHECKING, Callable, get_args
+
+from bec_lib.logger import bec_logger
+from bec_qthemes import material_icon
+from pydantic import BaseModel, Field
+from qtpy.QtCore import Signal  # type: ignore
+from qtpy.QtWidgets import (
+    QApplication,
+    QButtonGroup,
+    QCheckBox,
+    QDoubleSpinBox,
+    QGridLayout,
+    QHBoxLayout,
+    QLabel,
+    QLayout,
+    QLineEdit,
+    QRadioButton,
+    QSpinBox,
+    QToolButton,
+    QWidget,
+)
+
+from bec_widgets.widgets.editors.scan_metadata._util import (
+    clearable_required,
+    field_default,
+    field_limits,
+    field_maxlen,
+    field_minlen,
+    field_precision,
+)
+
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
+
+logger = bec_logger.logger
+
+
+class ClearableBoolEntry(QWidget):
+    stateChanged = Signal()
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._layout = QHBoxLayout()
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(self._layout)
+        self._layout.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
+        self._entry = QButtonGroup()
+        self._true = QRadioButton("true", parent=self)
+        self._false = QRadioButton("false", parent=self)
+        for button in [self._true, self._false]:
+            self._layout.addWidget(button)
+            self._entry.addButton(button)
+            button.toggled.connect(self.stateChanged)
+
+    def clear(self):
+        self._entry.setExclusive(False)
+        self._true.setChecked(False)
+        self._false.setChecked(False)
+        self._entry.setExclusive(True)
+
+    def isChecked(self) -> bool | None:
+        if not self._true.isChecked() and not self._false.isChecked():
+            return None
+        return self._true.isChecked()
+
+    def setChecked(self, value: bool | None):
+        if value is None:
+            self.clear()
+        elif value:
+            self._true.setChecked(True)
+            self._false.setChecked(False)
+        else:
+            self._true.setChecked(False)
+            self._false.setChecked(True)
+
+    def setToolTip(self, tooltip: str):
+        self._true.setToolTip(tooltip)
+        self._false.setToolTip(tooltip)
+
+
+class MetadataWidget(QWidget):
+
+    valueChanged = Signal()
+
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._info = info
+        self._layout = QHBoxLayout()
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._layout.setSizeConstraint(QLayout.SizeConstraint.SetMaximumSize)
+        self._default = field_default(self._info)
+        self._desc = self._info.description
+        self.setLayout(self._layout)
+        self._add_main_widget()
+        if clearable_required(info):
+            self._add_clear_button()
+
+    @abstractmethod
+    def getValue(self): ...
+
+    @abstractmethod
+    def setValue(self, value): ...
+
+    @abstractmethod
+    def _add_main_widget(self) -> None:
+        """Add the main data entry widget to self._main_widget and appply any
+        constraints from the field info"""
+
+    def _describe(self, pad=" "):
+        return pad + (self._desc if self._desc else "")
+
+    def _add_clear_button(self):
+        self._clear_button = QToolButton()
+        self._clear_button.setIcon(
+            material_icon(icon_name="close", size=(10, 10), convert_to_pixmap=False)
+        )
+        self._layout.addWidget(self._clear_button)
+        # the widget added in _add_main_widget must implement .clear() if value is not required
+        self._clear_button.setToolTip("Clear value or reset to default.")
+        self._clear_button.clicked.connect(self._main_widget.clear)  # type: ignore
+
+    def _value_changed(self, *_, **__):
+        self.valueChanged.emit()
+
+
+class StrMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
+        self._main_widget.textChanged.connect(self._value_changed)
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = QLineEdit()
+        self._layout.addWidget(self._main_widget)
+        min_length, max_length = field_minlen(self._info), field_maxlen(self._info)
+        if max_length:
+            self._main_widget.setMaxLength(max_length)
+        self._main_widget.setToolTip(
+            f"(length min: {min_length} max: {max_length}){self._describe()}"
+        )
+        if self._default:
+            self._main_widget.setText(self._default)
+            self._add_clear_button()
+
+    def getValue(self):
+        if self._main_widget.text() == "":
+            return self._default
+        return self._main_widget.text()
+
+    def setValue(self, value: str):
+        if value is None:
+            self._main_widget.setText("")
+        self._main_widget.setText(value)
+
+
+class IntMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
+        self._main_widget.textChanged.connect(self._value_changed)
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = QSpinBox()
+        self._layout.addWidget(self._main_widget)
+        min_, max_ = field_limits(self._info, int)
+        self._main_widget.setMinimum(min_)
+        self._main_widget.setMaximum(max_)
+        self._main_widget.setToolTip(f"(range {min_} to {max_}){self._describe()}")
+        if self._default is not None:
+            self._main_widget.setValue(self._default)
+            self._add_clear_button()
+        else:
+            self._main_widget.clear()
+
+    def getValue(self):
+        if self._main_widget.text() == "":
+            return self._default
+        return self._main_widget.value()
+
+    def setValue(self, value: int):
+        if value is None:
+            self._main_widget.clear()
+        self._main_widget.setValue(value)
+
+
+class FloatDecimalMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
+        self._main_widget.textChanged.connect(self._value_changed)
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = QDoubleSpinBox()
+        self._layout.addWidget(self._main_widget)
+        min_, max_ = field_limits(self._info, int)
+        self._main_widget.setMinimum(min_)
+        self._main_widget.setMaximum(max_)
+        precision = field_precision(self._info)
+        if precision:
+            self._main_widget.setDecimals(precision)
+        minstr = f"{float(min_):.3f}" if abs(min_) <= 1000 else f"{float(min_):.3e}"
+        maxstr = f"{float(max_):.3f}" if abs(max_) <= 1000 else f"{float(max_):.3e}"
+        self._main_widget.setToolTip(f"(range {minstr} to {maxstr}){self._describe()}")
+        if self._default is not None:
+            self._main_widget.setValue(self._default)
+            self._add_clear_button()
+        else:
+            self._main_widget.clear()
+
+    def getValue(self):
+        if self._main_widget.text() == "":
+            return self._default
+        return self._main_widget.value()
+
+    def setValue(self, value: float):
+        if value is None:
+            self._main_widget.clear()
+        self._main_widget.setValue(value)
+
+
+class BoolMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
+        self._main_widget.stateChanged.connect(self._value_changed)
+
+    def _add_main_widget(self) -> None:
+        if clearable_required(self._info):
+            self._main_widget = ClearableBoolEntry()
+        else:
+            self._main_widget = QCheckBox()
+        self._layout.addWidget(self._main_widget)
+        self._main_widget.setToolTip(self._describe(""))
+        self._main_widget.setChecked(self._default)  # type: ignore # if there is no default then it will be ClearableBoolEntry and can be set with None
+
+    def getValue(self):
+        return self._main_widget.isChecked()
+
+    def setValue(self, value):
+        self._main_widget.setChecked(value)
+
+
+def widget_from_type(annotation: type | None) -> Callable[[FieldInfo], MetadataWidget]:
+    if annotation in [str, str | None]:
+        return StrMetadataField
+    if annotation in [int, int | None]:
+        return IntMetadataField
+    if annotation in [float, float | None, Decimal, Decimal | None]:
+        return FloatDecimalMetadataField
+    if annotation in [bool, bool | None]:
+        return BoolMetadataField
+    else:
+        logger.warning(f"Type {annotation} is not (yet) supported in metadata form creation.")
+        return StrMetadataField
+
+
+if __name__ == "__main__":  # pragma: no cover
+
+    class TestModel(BaseModel):
+        value1: str | None = Field(None)
+        value2: bool | None = Field(None)
+        value3: bool = Field(True)
+        value4: int = Field(123)
+        value5: int | None = Field()
+
+    app = QApplication([])
+    w = QWidget()
+    layout = QGridLayout()
+    w.setLayout(layout)
+    for i, (field_name, info) in enumerate(TestModel.model_fields.items()):
+        layout.addWidget(QLabel(field_name), i, 0)
+        layout.addWidget(widget_from_type(info.annotation)(info), i, 1)
+
+    w.show()
+    app.exec()

bec_widgets/widgets/editors/scan_metadata/_util.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import sys
+from decimal import Decimal
+from math import inf, nextafter
+from typing import TYPE_CHECKING, TypeVar, get_args
+
+from annotated_types import Ge, Gt, Le, Lt
+from bec_lib.logger import bec_logger
+from pydantic_core import PydanticUndefined
+
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
+
+logger = bec_logger.logger
+
+
+_MININT = -2147483648
+_MAXINT = 2147483647
+_MINFLOAT = -sys.float_info.max
+_MAXFLOAT = sys.float_info.max
+
+T = TypeVar("T", int, float, Decimal)
+
+
+def field_limits(info: FieldInfo, type_: type[T]) -> tuple[T, T]:
+    _min = _MININT if type_ is int else _MINFLOAT
+    _max = _MAXINT if type_ is int else _MAXFLOAT
+    for md in info.metadata:
+        if isinstance(md, Ge):
+            _min = type_(md.ge)  # type: ignore
+        if isinstance(md, Gt):
+            _min = type_(md.gt) + 1 if type_ is int else nextafter(type_(md.gt), inf)  # type: ignore
+        if isinstance(md, Lt):
+            _max = type_(md.lt) - 1 if type_ is int else nextafter(type_(md.lt), -inf)  # type: ignore
+        if isinstance(md, Le):
+            _max = type_(md.le)  # type: ignore
+    return _min, _max  # type: ignore
+
+
+def _get_anno(info: FieldInfo, annotation: str, default):
+    for md in info.metadata:
+        if hasattr(md, annotation):
+            return getattr(md, annotation)
+    return default
+
+
+def field_precision(info: FieldInfo):
+    return _get_anno(info, "decimal_places", 307)
+
+
+def field_maxlen(info: FieldInfo):
+    return _get_anno(info, "max_length", None)
+
+
+def field_minlen(info: FieldInfo):
+    return _get_anno(info, "min_length", None)
+
+
+def field_default(info: FieldInfo):
+    if info.default is PydanticUndefined:
+        return
+    return info.default
+
+
+def clearable_required(info: FieldInfo):
+    return type(None) in get_args(info.annotation) or info.is_required()

bec_widgets/widgets/editors/scan_metadata/additional_metadata_table.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from typing import Any
+
+from qtpy.QtCore import QAbstractTableModel, QModelIndex, Qt, Signal  # type: ignore
+from qtpy.QtWidgets import (
+    QApplication,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QTableView,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.qt_utils.error_popups import SafeSlot
+
+
+class AdditionalMetadataTableModel(QAbstractTableModel):
+    def __init__(self, data):
+        super().__init__()
+        self._data: list[list[str]] = data
+        self._disallowed_keys: list[str] = []
+
+    def headerData(
+        self, section: int, orientation: Qt.Orientation, role: int = Qt.ItemDataRole()
+    ) -> Any:
+        if orientation == Qt.Orientation.Horizontal and role == Qt.ItemDataRole.DisplayRole:
+            return "Key" if section == 0 else "Value"
+        return super().headerData(section, orientation, role)
+
+    def rowCount(self, index: QModelIndex = QModelIndex()):
+        return 0 if index.isValid() else len(self._data)
+
+    def columnCount(self, index: QModelIndex = QModelIndex()):
+        return 0 if index.isValid() else 2
+
+    def data(self, index, role=Qt.ItemDataRole):
+        if index.isValid():
+            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
+                return str(self._data[index.row()][index.column()])
+
+    def setData(self, index, value, role):
+        if role == Qt.ItemDataRole.EditRole:
+            if value in self._disallowed_keys or value in self._other_keys(index.row()):
+                return False
+            self._data[index.row()][index.column()] = str(value)
+            return True
+        return False
+
+    def update_disallowed_keys(self, keys: list[str]):
+        self._disallowed_keys = keys
+        for i, item in enumerate(self._data):
+            if item[0] in self._disallowed_keys:
+                self._data[i][0] = ""
+                self.dataChanged.emit(self.index(i, 0), self.index(i, 0))
+
+    def _other_keys(self, row: int):
+        return [r[0] for r in self._data[:row] + self._data[row + 1 :]]
+
+    def flags(self, _):
+        return Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsEditable
+
+    def insertRows(self, row, number, index):
+        """We only support adding one at a time for now"""
+        if row != self.rowCount() or number != 1:
+            return False
+        self.beginInsertRows(QModelIndex(), 0, 0)
+        self._data.append(["", ""])
+        self.endInsertRows()
+        return True
+
+    def removeRows(self, row, number, index):
+        """This can only be consecutive, so instead of trying to be clever, only support removing one at a time"""
+        if number != 1:
+            return False
+        self.beginRemoveRows(QModelIndex(), row, row)
+        del self._data[row]
+        self.endRemoveRows()
+        return True
+
+    @SafeSlot()
+    def add_row(self):
+        self.insertRow(self.rowCount())
+
+    @SafeSlot(list)
+    def delete_rows(self, rows: list[int]):
+        # delete from the end so indices stay correct
+        for row in sorted(rows, reverse=True):
+            self.removeRows(row, 1, QModelIndex())
+
+    def dump_dict(self):
+        if self._data == [[]]:
+            return {}
+        return dict(self._data)
+
+
+class AdditionalMetadataTable(QWidget):
+
+    delete_rows = Signal(list)
+
+    def __init__(self, initial_data: list[list[str]]):
+        super().__init__()
+
+        self._layout = QHBoxLayout()
+        self.setLayout(self._layout)
+        self._table_model = AdditionalMetadataTableModel(initial_data)
+        self._table_view = QTableView()
+        self._table_view.setModel(self._table_model)
+        self._table_view.horizontalHeader().setStretchLastSection(True)
+        self._layout.addWidget(self._table_view)
+
+        self._buttons = QVBoxLayout()
+        self._layout.addLayout(self._buttons)
+        self._add_button = QPushButton("+")
+        self._add_button.setToolTip("add a new row")
+        self._remove_button = QPushButton("-")
+        self._remove_button.setToolTip("delete rows containing any selected cells")
+        self._buttons.addWidget(self._add_button)
+        self._buttons.addWidget(self._remove_button)
+        self._add_button.clicked.connect(self._table_model.add_row)
+        self._remove_button.clicked.connect(self.delete_selected_rows)
+        self.delete_rows.connect(self._table_model.delete_rows)
+
+    def delete_selected_rows(self):
+        cells: list[QModelIndex] = self._table_view.selectionModel().selectedIndexes()
+        row_indices = list({r.row() for r in cells})
+        if row_indices:
+            self.delete_rows.emit(row_indices)
+
+    def dump_dict(self):
+        return self._table_model.dump_dict()
+
+    def update_disallowed_keys(self, keys: list[str]):
+        self._table_model.update_disallowed_keys(keys)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from bec_widgets.utils.colors import set_theme
+
+    app = QApplication([])
+    set_theme("dark")
+
+    window = AdditionalMetadataTable([["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
+    window.show()
+    app.exec()

bec_widgets/widgets/editors/scan_metadata/scan_metadata.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import TYPE_CHECKING
+
+from bec_lib.logger import bec_logger
+from bec_lib.metadata_schema import get_metadata_schema_for_scan
+from bec_qthemes import material_icon
+from pydantic import Field, ValidationError
+from qtpy.QtWidgets import (
+    QApplication,
+    QComboBox,
+    QGridLayout,
+    QLabel,
+    QLayout,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.qt_utils.compact_popup import CompactPopupWidget
+from bec_widgets.qt_utils.error_popups import SafeSlot
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.widgets.editors.scan_metadata._metadata_widgets import widget_from_type
+from bec_widgets.widgets.editors.scan_metadata.additional_metadata_table import (
+    AdditionalMetadataTable,
+)
+
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
+
+logger = bec_logger.logger
+
+
+class ScanMetadata(BECWidget, QWidget):
+    """Dynamically generates a form for inclusion of metadata for a scan. Uses the
+    metadata schema registry supplied in the plugin repo to find pydantic models
+    associated with the scan type. Sets limits for numerical values if specified."""
+
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        scan_name: str | None = None,
+        initial_extras: list[list[str]] | None = None,
+    ):
+        super().__init__(client=client)
+        QWidget.__init__(self, parent=parent)
+
+        self.set_schema(scan_name)
+
+        self._layout = QVBoxLayout()
+        self._layout.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
+        self.setLayout(self._layout)
+        self._layout.addWidget(QLabel("<b>Required scan metadata:</b>"))
+        self._md_grid = QWidget()
+        self._layout.addWidget(self._md_grid)
+        self._grid_container = QVBoxLayout()
+        self._md_grid.setLayout(self._grid_container)
+        self._new_grid_layout()
+        self._grid_container.addLayout(self._md_grid_layout)
+        self._layout.addWidget(QLabel("<b>Additional metadata:</b>"))
+        self._additional_metadata = AdditionalMetadataTable(initial_extras or [])
+        self._layout.addWidget(self._additional_metadata)
+
+        self._validity = CompactPopupWidget()
+        self._validity.compact_view = True  # type: ignore
+        self._validity.label = "Validity"  # type: ignore
+        self._validity.compact_show_popup.setIcon(
+            material_icon(icon_name="info", size=(10, 10), convert_to_pixmap=False)
+        )
+        self._validity_message = QLabel("Not yet validated")
+        self._validity.addWidget(self._validity_message)
+        self._layout.addWidget(self._validity)
+
+        self.populate()
+
+    @SafeSlot(str)
+    def update_with_new_scan(self, scan_name: str):
+        self.set_schema(scan_name)
+        self.populate()
+        self.validate_form()
+
+    def validate_form(self, *_):
+        try:
+            self._md_schema.model_validate(self.get_full_model_dict())
+            self._validity.set_global_state("success")
+            self._validity_message.setText("No errors!")
+        except ValidationError as e:
+            self._validity.set_global_state("emergency")
+            self._validity_message.setText(str(e))
+
+    def get_full_model_dict(self):
+        """Get the entered metadata as a dict"""
+        return self._additional_metadata.dump_dict() | self._dict_from_grid()
+
+    def set_schema(self, scan_name: str | None = None):
+        self._scan_name = scan_name or ""
+        self._md_schema = get_metadata_schema_for_scan(self._scan_name)
+
+    def populate(self):
+        self._clear_grid()
+        self._populate()
+
+    def _populate(self):
+        self._additional_metadata.update_disallowed_keys(list(self._md_schema.model_fields.keys()))
+        for i, (field_name, info) in enumerate(self._md_schema.model_fields.items()):
+            self._add_griditem(field_name, info, i)
+
+    def _add_griditem(self, field_name: str, info: FieldInfo, row: int):
+        grid = self._md_grid_layout
+        label = QLabel(info.title or field_name)
+        label.setProperty("_model_field_name", field_name)
+        label.setToolTip(info.description or field_name)
+        grid.addWidget(label, row, 0)
+        widget = widget_from_type(info.annotation)(info)
+        widget.valueChanged.connect(self.validate_form)
+        grid.addWidget(widget, row, 1)
+
+    def _dict_from_grid(self) -> dict[str, str | int | float | Decimal | bool]:
+        grid = self._md_grid_layout
+        return {
+            grid.itemAtPosition(i, 0).widget().property("_model_field_name"): grid.itemAtPosition(i, 1).widget().getValue()  # type: ignore # we only add 'MetadataWidget's here
+            for i in range(grid.rowCount())
+        }
+
+    def _clear_grid(self):
+        while self._md_grid_layout.count():
+            item = self._md_grid_layout.takeAt(0)
+            widget = item.widget()
+            if widget is not None:
+                widget.deleteLater()
+        self._md_grid_layout.deleteLater()
+        self._new_grid_layout()
+        self._grid_container.addLayout(self._md_grid_layout)
+        self._md_grid.adjustSize()
+        self.adjustSize()
+
+    def _new_grid_layout(self):
+        self._md_grid_layout = QGridLayout()
+        self._md_grid_layout.setContentsMargins(0, 0, 0, 0)
+        self._md_grid_layout.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from unittest.mock import patch
+
+    from bec_lib.metadata_schema import BasicScanMetadata
+
+    from bec_widgets.utils.colors import set_theme
+
+    class ExampleSchema1(BasicScanMetadata):
+        abc: int = Field(gt=0, lt=2000, description="Heating temperature abc", title="A B C")
+        foo: str = Field(max_length=12, description="Sample database code", default="DEF123")
+        xyz: Decimal = Field(decimal_places=4)
+        baz: bool
+
+    class ExampleSchema2(BasicScanMetadata):
+        checkbox_up_top: bool
+        checkbox_again: bool = Field(
+            title="Checkbox Again", description="this one defaults to True", default=True
+        )
+        different_items: int | None = Field(
+            None, description="This is just one different item...", gt=-100, lt=0
+        )
+        length_limited_string: str = Field(max_length=32)
+        float_with_2dp: Decimal = Field(decimal_places=2)
+
+    class ExampleSchema3(BasicScanMetadata):
+        optional_with_regex: str | None = Field(None, pattern=r"^\d+-\d+$")
+
+    with patch(
+        "bec_lib.metadata_schema._get_metadata_schema_registry",
+        lambda: {"scan1": ExampleSchema1, "scan2": ExampleSchema2, "scan3": ExampleSchema3},
+    ):
+
+        app = QApplication([])
+        w = QWidget()
+        selection = QComboBox()
+        selection.addItems(["grid_scan", "scan1", "scan2", "scan3"])
+
+        layout = QVBoxLayout()
+        w.setLayout(layout)
+
+        scan_metadata = ScanMetadata(
+            scan_name="grid_scan",
+            initial_extras=[["key1", "value1"], ["key2", "value2"], ["key3", "value3"]],
+        )
+        selection.currentTextChanged.connect(scan_metadata.update_with_new_scan)
+
+        layout.addWidget(selection)
+        layout.addWidget(scan_metadata)
+
+        set_theme("dark")
+        window = w
+        window.show()
+        app.exec()

bec_widgets/widgets/editors/text_box/text_box.py

@@ -5,9 +5,9 @@ from html.parser import HTMLParser
 
 from bec_lib.logger import bec_logger
 from pydantic import Field
-from qtpy.QtCore import Property, Slot
 from qtpy.QtWidgets import QTextEdit, QVBoxLayout, QWidget
 
+from bec_widgets.qt_utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.bec_connector import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
 
@@ -66,7 +66,7 @@ class TextBox(BECWidget, QWidget):
         else:
             self.set_html_text(DEFAULT_TEXT)
 
-    @Slot(str)
+    @SafeSlot(str)
     def set_plain_text(self, text: str) -> None:
         """Set the plain text of the widget.
 
@@ -77,7 +77,7 @@ class TextBox(BECWidget, QWidget):
         self.config.text = text
         self.config.is_html = False
 
-    @Slot(str)
+    @SafeSlot(str)
     def set_html_text(self, text: str) -> None:
         """Set the HTML text of the widget.
 
@@ -88,7 +88,7 @@ class TextBox(BECWidget, QWidget):
         self.config.text = text
         self.config.is_html = True
 
-    @Property(str)
+    @SafeProperty(str)
     def plain_text(self) -> str:
         """Get the text of the widget.
 
@@ -106,7 +106,7 @@ class TextBox(BECWidget, QWidget):
         """
         self.set_plain_text(text)
 
-    @Property(str)
+    @SafeProperty(str)
     def html_text(self) -> str:
         """Get the HTML text of the widget.
 

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,416 @@
+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
+
+    def cleanup(self):
+        self._timer.stop()
+
+
+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

@@ -0,0 +1,54 @@
+# 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.games.minesweeper import Minesweeper
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='Minesweeper' name='minesweeper'>
+    </widget>
+</ui>
+"""
+
+
+class MinesweeperPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = Minesweeper(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Games"
+
+    def icon(self):
+        return designer_material_icon(Minesweeper.ICON_NAME)
+
+    def includeFile(self):
+        return "minesweeper"
+
+    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 "Minesweeper"
+
+    def toolTip(self):
+        return "Minesweeper"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/games/register_minesweeper.py

@@ -0,0 +1,15 @@
+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.games.minesweeper_plugin import MinesweeperPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(MinesweeperPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/plots_next_gen/plot_base.py

@@ -0,0 +1,606 @@
+from __future__ import annotations
+
+import pyqtgraph as pg
+from bec_lib import bec_logger
+from qtpy.QtCore import QPoint, QPointF, Qt, Signal
+from qtpy.QtWidgets import QLabel, QVBoxLayout, QWidget
+
+from bec_widgets.qt_utils.error_popups import SafeProperty, SafeSlot
+from bec_widgets.qt_utils.round_frame import RoundedFrame
+from bec_widgets.qt_utils.side_panel import SidePanel
+from bec_widgets.qt_utils.toolbar import MaterialIconAction, ModularToolBar, SeparatorAction
+from bec_widgets.utils import ConnectionConfig, Crosshair, EntryValidator
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.fps_counter import FPSCounter
+from bec_widgets.utils.widget_state_manager import WidgetStateManager
+from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
+from bec_widgets.widgets.plots_next_gen.setting_menus.axis_settings import AxisSettings
+from bec_widgets.widgets.plots_next_gen.toolbar_bundles.mouse_interactions import (
+    MouseInteractionToolbarBundle,
+)
+from bec_widgets.widgets.plots_next_gen.toolbar_bundles.plot_export import PlotExportBundle
+from bec_widgets.widgets.plots_next_gen.toolbar_bundles.roi_bundle import ROIBundle
+from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
+logger = bec_logger.logger
+
+
+class BECViewBox(pg.ViewBox):
+    sigPaint = Signal()
+
+    def paint(self, painter, opt, widget):
+        super().paint(painter, opt, widget)
+        self.sigPaint.emit()
+
+    def itemBoundsChanged(self, item):
+        self._itemBoundsCache.pop(item, None)
+        if (self.state["autoRange"][0] is not False) or (self.state["autoRange"][1] is not False):
+            # check if the call is coming from a mouse-move event
+            if hasattr(item, "skip_auto_range") and item.skip_auto_range:
+                return
+            self._autoRangeNeedsUpdate = True
+            self.update()
+
+
+class PlotBase(BECWidget, QWidget):
+    PLUGIN = False
+    RPC = False
+
+    # Custom Signals
+    property_changed = Signal(str, object)
+    crosshair_position_changed = Signal(tuple)
+    crosshair_position_clicked = Signal(tuple)
+    crosshair_coordinates_changed = Signal(tuple)
+    crosshair_coordinates_clicked = Signal(tuple)
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        config: ConnectionConfig | None = None,
+        client=None,
+        gui_id: str | None = None,
+    ) -> None:
+        if config is None:
+            config = ConnectionConfig(widget_class=self.__class__.__name__)
+        super().__init__(client=client, gui_id=gui_id, config=config)
+        QWidget.__init__(self, parent=parent)
+
+        # For PropertyManager identification
+        self.setObjectName("PlotBase")
+        self.get_bec_shortcuts()
+
+        # Layout Management
+        self.layout = QVBoxLayout(self)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.layout.setSpacing(0)
+        self.layout_manager = LayoutManagerWidget(parent=self)
+
+        # Property Manager
+        self.state_manager = WidgetStateManager(self)
+
+        # Entry Validator
+        self.entry_validator = EntryValidator(self.dev)
+
+        # Base widgets elements
+        self.plot_widget = pg.GraphicsLayoutWidget(parent=self)
+        self.plot_item = pg.PlotItem(viewBox=BECViewBox(enableMenu=True))
+        self.plot_widget.addItem(self.plot_item)
+        self.side_panel = SidePanel(self, orientation="left", panel_max_width=280)
+        self.toolbar = ModularToolBar(target_widget=self, orientation="horizontal")
+        self.init_toolbar()
+
+        # PlotItem Addons
+        self.plot_item.addLegend()
+        self.crosshair = None
+        self.fps_monitor = None
+        self.fps_label = QLabel(alignment=Qt.AlignmentFlag.AlignRight)
+        self._user_x_label = ""
+        self._x_label_suffix = ""
+
+        self._init_ui()
+
+        self._connect_to_theme_change()
+        self._update_theme()
+
+    def apply_theme(self, theme: str):
+        self.round_plot_widget.apply_theme(theme)
+
+    def _init_ui(self):
+        self.layout.addWidget(self.layout_manager)
+        self.round_plot_widget = RoundedFrame(content_widget=self.plot_widget, theme_update=True)
+
+        self.layout_manager.add_widget(self.round_plot_widget)
+        self.layout_manager.add_widget_relative(self.fps_label, self.round_plot_widget, "top")
+        self.fps_label.hide()
+        self.layout_manager.add_widget_relative(self.side_panel, self.round_plot_widget, "left")
+        self.layout_manager.add_widget_relative(self.toolbar, self.fps_label, "top")
+
+        self.add_side_menus()
+
+        # PlotItem ViewBox Signals
+        self.plot_item.vb.sigStateChanged.connect(self.viewbox_state_changed)
+
+    def init_toolbar(self):
+
+        self.plot_export_bundle = PlotExportBundle("plot_export", target_widget=self)
+        self.mouse_bundle = MouseInteractionToolbarBundle("mouse_interaction", target_widget=self)
+        # self.state_export_bundle = SaveStateBundle("state_export", target_widget=self) #TODO ATM disabled, cannot be used in DockArea, which is exposed to the user
+        self.roi_bundle = ROIBundle("roi", target_widget=self)
+
+        # Add elements to toolbar
+        self.toolbar.add_bundle(self.plot_export_bundle, target_widget=self)
+        # self.toolbar.add_bundle(self.state_export_bundle, target_widget=self) #TODO ATM disabled, cannot be used in DockArea, which is exposed to the user
+        self.toolbar.add_bundle(self.mouse_bundle, target_widget=self)
+        self.toolbar.add_bundle(self.roi_bundle, target_widget=self)
+
+        self.toolbar.add_action("separator_1", SeparatorAction(), target_widget=self)
+        self.toolbar.add_action(
+            "fps_monitor",
+            MaterialIconAction(icon_name="speed", tooltip="Show FPS Monitor", checkable=True),
+            target_widget=self,
+        )
+        self.toolbar.addWidget(DarkModeButton(toolbar=True))
+
+        self.toolbar.widgets["fps_monitor"].action.toggled.connect(
+            lambda checked: setattr(self, "enable_fps_monitor", checked)
+        )
+
+    def add_side_menus(self):
+        """Adds multiple menus to the side panel."""
+        # Setting Axis Widget
+        axis_setting = AxisSettings(target_widget=self)
+        self.side_panel.add_menu(
+            action_id="axis",
+            icon_name="settings",
+            tooltip="Show Axis Settings",
+            widget=axis_setting,
+            title="Axis Settings",
+        )
+
+    ################################################################################
+    # Toggle UI Elements
+    ################################################################################
+
+    @SafeProperty(bool, doc="Show Toolbar")
+    def enable_toolbar(self) -> bool:
+        return self.toolbar.isVisible()
+
+    @enable_toolbar.setter
+    def enable_toolbar(self, value: bool):
+        self.toolbar.setVisible(value)
+
+    @SafeProperty(bool, doc="Show Side Panel")
+    def enable_side_panel(self) -> bool:
+        return self.side_panel.isVisible()
+
+    @enable_side_panel.setter
+    def enable_side_panel(self, value: bool):
+        self.side_panel.setVisible(value)
+
+    @SafeProperty(bool, doc="Enable the FPS monitor.")
+    def enable_fps_monitor(self) -> bool:
+        return self.fps_label.isVisible()
+
+    @enable_fps_monitor.setter
+    def enable_fps_monitor(self, value: bool):
+        if value and self.fps_monitor is None:
+            self.hook_fps_monitor()
+        elif not value and self.fps_monitor is not None:
+            self.unhook_fps_monitor()
+
+    ################################################################################
+    # ViewBox State Signals
+    ################################################################################
+
+    def viewbox_state_changed(self):
+        """
+        Emit a signal when the state of the viewbox has changed.
+        Merges the default pyqtgraphs signal states and also CTRL menu toggles.
+        """
+
+        viewbox_state = self.plot_item.vb.getState()
+        # Range Limits
+        x_min, x_max = viewbox_state["targetRange"][0]
+        y_min, y_max = viewbox_state["targetRange"][1]
+        self.property_changed.emit("x_min", x_min)
+        self.property_changed.emit("x_max", x_max)
+        self.property_changed.emit("y_min", y_min)
+        self.property_changed.emit("y_max", y_max)
+
+        # Grid Toggles
+
+    ################################################################################
+    # Plot Properties
+    ################################################################################
+
+    def set(self, **kwargs):
+        """
+        Set the properties of the plot widget.
+
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+
+        Possible properties:
+
+        """
+        property_map = {
+            "title": self.title,
+            "x_label": self.x_label,
+            "y_label": self.y_label,
+            "x_limits": self.x_limits,
+            "y_limits": self.y_limits,
+            "x_grid": self.x_grid,
+            "y_grid": self.y_grid,
+            "inner_axes": self.inner_axes,
+            "outer_axes": self.outer_axes,
+            "lock_aspect_ratio": self.lock_aspect_ratio,
+            "auto_range_x": self.auto_range_x,
+            "auto_range_y": self.auto_range_y,
+            "x_log": self.x_log,
+            "y_log": self.y_log,
+            "legend_label_size": self.legend_label_size,
+        }
+
+        for key, value in kwargs.items():
+            if key in property_map:
+                setattr(self, key, value)
+            else:
+                logger.warning(f"Property {key} not found.")
+
+    @SafeProperty(str, doc="The title of the axes.")
+    def title(self) -> str:
+        return self.plot_item.titleLabel.text
+
+    @title.setter
+    def title(self, value: str):
+        self.plot_item.setTitle(value)
+        self.property_changed.emit("title", value)
+
+    @SafeProperty(str, doc="The text of the x label")
+    def x_label(self) -> str:
+        return self._user_x_label
+
+    @x_label.setter
+    def x_label(self, value: str):
+        self._user_x_label = value
+        self._apply_x_label()
+        self.property_changed.emit("x_label", self._user_x_label)
+
+    @property
+    def x_label_suffix(self) -> str:
+        """
+        A read-only (or internal) suffix automatically appended to the user label.
+        Not settable by the user directly from the UI.
+        """
+        return self._x_label_suffix
+
+    def set_x_label_suffix(self, suffix: str):
+        """
+        Public or protected method to update the suffix.
+        The user code or subclass (Waveform) can call this
+        when x_mode changes, but the AxisSettings won't show it.
+        """
+        self._x_label_suffix = suffix
+        self._apply_x_label()
+
+    @property
+    def x_label_combined(self) -> str:
+        """
+        The final label shown on the axis = user portion + suffix.
+        """
+        return self._user_x_label + self._x_label_suffix
+
+    def _apply_x_label(self):
+        """
+        Actually updates the pyqtgraph axis label text to
+        the combined label. Called whenever user label or suffix changes.
+        """
+        final_label = self.x_label_combined
+        self.plot_item.setLabel("bottom", text=final_label)
+
+    @SafeProperty(str, doc="The text of the y label")
+    def y_label(self) -> str:
+        return self.plot_item.getAxis("left").labelText
+
+    @y_label.setter
+    def y_label(self, value: str):
+        self.plot_item.setLabel("left", text=value)
+        self.property_changed.emit("y_label", value)
+
+    def _tuple_to_qpointf(self, tuple: tuple | list):
+        """
+        Helper function to convert a tuple to a QPointF.
+
+        Args:
+            tuple(tuple|list): Tuple or list of two numbers.
+
+        Returns:
+            QPointF: The tuple converted to a QPointF.
+        """
+        if len(tuple) != 2:
+            raise ValueError("Limits must be a tuple or list of two numbers.")
+        min_val, max_val = tuple
+        if not isinstance(min_val, (int, float)) or not isinstance(max_val, (int, float)):
+            raise TypeError("Limits must be numbers.")
+        if min_val > max_val:
+            raise ValueError("Minimum limit cannot be greater than maximum limit.")
+        return QPoint(*tuple)
+
+    ################################################################################
+    # X limits, has to be SaveProperty("QPointF") because of the tuple conversion for designer,
+    # the python properties are used for CLI and API for context dialog settings.
+
+    @SafeProperty("QPointF")
+    def x_limits(self) -> QPointF:
+        current_lim = self.plot_item.vb.viewRange()[0]
+        return QPointF(current_lim[0], current_lim[1])
+
+    @x_limits.setter
+    def x_limits(self, value):
+        if isinstance(value, (tuple, list)):
+            value = self._tuple_to_qpointf(value)
+        self.plot_item.vb.setXRange(value.x(), value.y(), padding=0)
+
+    @property
+    def x_lim(self) -> tuple:
+        return (self.x_limits.x(), self.x_limits.y())
+
+    @x_lim.setter
+    def x_lim(self, value):
+        self.x_limits = value
+
+    @property
+    def x_min(self) -> float:
+        return self.x_limits.x()
+
+    @x_min.setter
+    def x_min(self, value: float):
+        self.x_limits = (value, self.x_lim[1])
+
+    @property
+    def x_max(self) -> float:
+        return self.x_limits.y()
+
+    @x_max.setter
+    def x_max(self, value: float):
+        self.x_limits = (self.x_lim[0], value)
+
+    ################################################################################
+    # Y limits, has to be SaveProperty("QPointF") because of the tuple conversion for designer,
+    # the python properties are used for CLI and API for context dialog settings.
+
+    @SafeProperty("QPointF")
+    def y_limits(self) -> QPointF:
+        current_lim = self.plot_item.vb.viewRange()[1]
+        return QPointF(current_lim[0], current_lim[1])
+
+    @y_limits.setter
+    def y_limits(self, value):
+        if isinstance(value, (tuple, list)):
+            value = self._tuple_to_qpointf(value)
+        self.plot_item.vb.setYRange(value.x(), value.y(), padding=0)
+
+    @property
+    def y_lim(self) -> tuple:
+        return (self.y_limits.x(), self.y_limits.y())
+
+    @y_lim.setter
+    def y_lim(self, value):
+        self.y_limits = value
+
+    @property
+    def y_min(self) -> float:
+        return self.y_limits.x()
+
+    @y_min.setter
+    def y_min(self, value: float):
+        self.y_limits = (value, self.y_lim[1])
+
+    @property
+    def y_max(self) -> float:
+        return self.y_limits.y()
+
+    @y_max.setter
+    def y_max(self, value: float):
+        self.y_limits = (self.y_lim[0], value)
+
+    @SafeProperty(bool, doc="Show grid on the x-axis.")
+    def x_grid(self) -> bool:
+        return self.plot_item.ctrl.xGridCheck.isChecked()
+
+    @x_grid.setter
+    def x_grid(self, value: bool):
+        self.plot_item.showGrid(x=value)
+        self.property_changed.emit("x_grid", value)
+
+    @SafeProperty(bool, doc="Show grid on the y-axis.")
+    def y_grid(self) -> bool:
+        return self.plot_item.ctrl.yGridCheck.isChecked()
+
+    @y_grid.setter
+    def y_grid(self, value: bool):
+        self.plot_item.showGrid(y=value)
+        self.property_changed.emit("y_grid", value)
+
+    @SafeProperty(bool, doc="Set X-axis to log scale if True, linear if False.")
+    def x_log(self) -> bool:
+        return bool(self.plot_item.vb.state.get("logMode", [False, False])[0])
+
+    @x_log.setter
+    def x_log(self, value: bool):
+        self.plot_item.setLogMode(x=value)
+        self.property_changed.emit("x_log", value)
+
+    @SafeProperty(bool, doc="Set Y-axis to log scale if True, linear if False.")
+    def y_log(self) -> bool:
+        return bool(self.plot_item.vb.state.get("logMode", [False, False])[1])
+
+    @y_log.setter
+    def y_log(self, value: bool):
+        self.plot_item.setLogMode(y=value)
+        self.property_changed.emit("y_log", value)
+
+    @SafeProperty(bool, doc="Show the outer axes of the plot widget.")
+    def outer_axes(self) -> bool:
+        return self.plot_item.getAxis("top").isVisible()
+
+    @outer_axes.setter
+    def outer_axes(self, value: bool):
+        self.plot_item.showAxis("top", value)
+        self.plot_item.showAxis("right", value)
+        self.property_changed.emit("outer_axes", value)
+
+    @SafeProperty(bool, doc="Show inner axes of the plot widget.")
+    def inner_axes(self) -> bool:
+        return self.plot_item.getAxis("bottom").isVisible()
+
+    @inner_axes.setter
+    def inner_axes(self, value: bool):
+        self.plot_item.showAxis("bottom", value)
+        self.plot_item.showAxis("left", value)
+        self.property_changed.emit("inner_axes", value)
+
+    @SafeProperty(bool, doc="Lock aspect ratio of the plot widget.")
+    def lock_aspect_ratio(self) -> bool:
+        return bool(self.plot_item.vb.getState()["aspectLocked"])
+
+    @lock_aspect_ratio.setter
+    def lock_aspect_ratio(self, value: bool):
+        self.plot_item.setAspectLocked(value)
+
+    @SafeProperty(bool, doc="Set auto range for the x-axis.")
+    def auto_range_x(self) -> bool:
+        return bool(self.plot_item.vb.getState()["autoRange"][0])
+
+    @auto_range_x.setter
+    def auto_range_x(self, value: bool):
+        self.plot_item.enableAutoRange(x=value)
+
+    @SafeProperty(bool, doc="Set auto range for the y-axis.")
+    def auto_range_y(self) -> bool:
+        return bool(self.plot_item.vb.getState()["autoRange"][1])
+
+    @auto_range_y.setter
+    def auto_range_y(self, value: bool):
+        self.plot_item.enableAutoRange(y=value)
+
+    @SafeProperty(int, doc="The font size of the legend font.")
+    def legend_label_size(self) -> int:
+        if not self.plot_item.legend:
+            return
+        scale = self.plot_item.legend.scale() * 9
+        return scale
+
+    @legend_label_size.setter
+    def legend_label_size(self, value: int):
+        if not self.plot_item.legend:
+            return
+        scale = (
+            value / 9
+        )  # 9 is the default font size of the legend, so we always scale it against 9
+        self.plot_item.legend.setScale(scale)
+
+    ################################################################################
+    # FPS Counter
+    ################################################################################
+
+    def update_fps_label(self, fps: float) -> None:
+        """
+        Update the FPS label.
+
+        Args:
+            fps(float): The frames per second.
+        """
+        if self.fps_label:
+            self.fps_label.setText(f"FPS: {fps:.2f}")
+
+    def hook_fps_monitor(self):
+        """Hook the FPS monitor to the plot."""
+        if self.fps_monitor is None:
+            self.fps_monitor = FPSCounter(self.plot_item.vb)
+            self.fps_label.show()
+
+            self.fps_monitor.sigFpsUpdate.connect(self.update_fps_label)
+            self.update_fps_label(0)
+
+    def unhook_fps_monitor(self, delete_label=True):
+        """Unhook the FPS monitor from the plot."""
+        if self.fps_monitor is not None and delete_label:
+            # Remove Monitor
+            self.fps_monitor.cleanup()
+            self.fps_monitor.deleteLater()
+            self.fps_monitor = None
+        if self.fps_label is not None:
+            # Hide Label
+            self.fps_label.hide()
+
+    ################################################################################
+    # Crosshair
+    ################################################################################
+
+    def hook_crosshair(self) -> None:
+        """Hook the crosshair to all plots."""
+        if self.crosshair is None:
+            self.crosshair = Crosshair(self.plot_item, precision=3)
+            self.crosshair.crosshairChanged.connect(self.crosshair_position_changed)
+            self.crosshair.crosshairClicked.connect(self.crosshair_position_clicked)
+            self.crosshair.coordinatesChanged1D.connect(self.crosshair_coordinates_changed)
+            self.crosshair.coordinatesClicked1D.connect(self.crosshair_coordinates_clicked)
+            self.crosshair.coordinatesChanged2D.connect(self.crosshair_coordinates_changed)
+            self.crosshair.coordinatesClicked2D.connect(self.crosshair_coordinates_clicked)
+
+    def unhook_crosshair(self) -> None:
+        """Unhook the crosshair from all plots."""
+        if self.crosshair is not None:
+            self.crosshair.crosshairChanged.disconnect(self.crosshair_position_changed)
+            self.crosshair.crosshairClicked.disconnect(self.crosshair_position_clicked)
+            self.crosshair.coordinatesChanged1D.disconnect(self.crosshair_coordinates_changed)
+            self.crosshair.coordinatesClicked1D.disconnect(self.crosshair_coordinates_clicked)
+            self.crosshair.coordinatesChanged2D.disconnect(self.crosshair_coordinates_changed)
+            self.crosshair.coordinatesClicked2D.disconnect(self.crosshair_coordinates_clicked)
+            self.crosshair.cleanup()
+            self.crosshair.deleteLater()
+            self.crosshair = None
+
+    def toggle_crosshair(self) -> None:
+        """Toggle the crosshair on all plots."""
+        if self.crosshair is None:
+            return self.hook_crosshair()
+
+        self.unhook_crosshair()
+
+    @SafeSlot()
+    def reset(self) -> None:
+        """Reset the plot widget."""
+        if self.crosshair is not None:
+            self.crosshair.clear_markers()
+            self.crosshair.update_markers()
+
+    def cleanup(self):
+        self.unhook_crosshair()
+        self.unhook_fps_monitor(delete_label=True)
+        self.cleanup_pyqtgraph()
+        self.rpc_register.remove_rpc(self)
+
+    def cleanup_pyqtgraph(self):
+        """Cleanup pyqtgraph items."""
+        item = self.plot_item
+        item.vb.menu.close()
+        item.vb.menu.deleteLater()
+        item.ctrlMenu.close()
+        item.ctrlMenu.deleteLater()
+
+
+if __name__ == "__main__":  # pragma: no cover:
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = PlotBase()
+    widget.show()
+    # Just some example data and parameters to test
+    widget.y_grid = True
+    widget.plot_item.plot([1, 2, 3, 4, 5], [1, 2, 3, 4, 5])
+
+    sys.exit(app.exec_())

bec_widgets/widgets/plots_next_gen/setting_menus/axis_settings.py

@@ -0,0 +1,95 @@
+import os
+
+from qtpy.QtWidgets import QFrame, QScrollArea, QVBoxLayout, QWidget
+
+from bec_widgets.qt_utils.error_popups import SafeSlot
+from bec_widgets.qt_utils.settings_dialog import SettingWidget
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.widget_io import WidgetIO
+
+
+class AxisSettings(SettingWidget):
+    def __init__(self, parent=None, target_widget=None, *args, **kwargs):
+        super().__init__(parent=parent, *args, **kwargs)
+
+        # This is a settings widget that depends on the target widget
+        # and should mirror what is in the target widget.
+        # Saving settings for this widget could result in recursively setting the target widget.
+        self.setProperty("skip_settings", True)
+        self.setObjectName("AxisSettings")
+        current_path = os.path.dirname(__file__)
+        form = UILoader().load_ui(os.path.join(current_path, "axis_settings_vertical.ui"), self)
+
+        self.target_widget = target_widget
+
+        # # Scroll area
+        self.scroll_area = QScrollArea(self)
+        self.scroll_area.setWidgetResizable(True)
+        self.scroll_area.setFrameShape(QFrame.NoFrame)
+        self.scroll_area.setWidget(form)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.layout.addWidget(self.scroll_area)
+        # self.layout.addWidget(self.ui)
+        self.ui = form
+
+        self.connect_all_signals()
+        if self.target_widget is not None:
+            self.target_widget.property_changed.connect(self.update_property)
+
+    def connect_all_signals(self):
+        for widget in [
+            self.ui.title,
+            self.ui.inner_axes,
+            self.ui.outer_axes,
+            self.ui.x_label,
+            self.ui.x_min,
+            self.ui.x_max,
+            self.ui.x_log,
+            self.ui.x_grid,
+            self.ui.y_label,
+            self.ui.y_min,
+            self.ui.y_max,
+            self.ui.y_log,
+            self.ui.y_grid,
+        ]:
+            WidgetIO.connect_widget_change_signal(widget, self.set_property)
+
+    @SafeSlot()
+    def set_property(self, widget: QWidget, value):
+        """
+        Set property of the target widget based on the widget that emitted the signal.
+        The name of the property has to be the same as the objectName of the widget
+        and compatible with WidgetIO.
+
+        Args:
+            widget(QWidget): The widget that emitted the signal.
+            value(): The value to set the property to.
+        """
+
+        try:  # to avoid crashing when the widget is not found in Designer
+            property_name = widget.objectName()
+            setattr(self.target_widget, property_name, value)
+        except RuntimeError:
+            return
+
+    @SafeSlot()
+    def update_property(self, property_name: str, value):
+        """
+        Update the value of the widget based on the property name and value.
+        The name of the property has to be the same as the objectName of the widget
+        and compatible with WidgetIO.
+
+        Args:
+            property_name(str): The name of the property to update.
+            value: The value to set the property to.
+        """
+        try:  # to avoid crashing when the widget is not found in Designer
+            widget_to_set = self.ui.findChild(QWidget, property_name)
+        except RuntimeError:
+            return
+        # Block signals to avoid triggering set_property again
+        was_blocked = widget_to_set.blockSignals(True)
+        WidgetIO.set_value(widget_to_set, value)
+        widget_to_set.blockSignals(was_blocked)

bec_widgets/widgets/plots_next_gen/setting_menus/axis_settings_horizontal.ui

@@ -0,0 +1,256 @@
+<?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>427</width>
+                <height>270</height>
+            </rect>
+        </property>
+        <property name="minimumSize">
+            <size>
+                <width>0</width>
+                <height>250</height>
+            </size>
+        </property>
+        <property name="maximumSize">
+            <size>
+                <width>16777215</width>
+                <height>278</height>
+            </size>
+        </property>
+        <property name="windowTitle">
+            <string>Form</string>
+        </property>
+        <layout class="QGridLayout" name="gridLayout">
+            <item row="0" column="0" colspan="2">
+                <layout class="QHBoxLayout" name="horizontalLayout">
+                    <item>
+                        <widget class="QLabel" name="plot_title_label">
+                            <property name="text">
+                                <string>Plot Title</string>
+                            </property>
+                        </widget>
+                    </item>
+                    <item>
+                        <widget class="QLineEdit" name="plot_title"/>
+                    </item>
+                </layout>
+            </item>
+            <item row="1" column="0">
+                <widget class="QLabel" name="label_outer_axes">
+                    <property name="text">
+                        <string>Outer Axes</string>
+                    </property>
+                </widget>
+            </item>
+            <item row="2" column="1">
+                <widget class="QGroupBox" name="y_axis_box">
+                    <property name="title">
+                        <string>Y Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_5">
+                        <item row="3" column="2">
+                            <widget class="QComboBox" name="y_scale">
+                                <item>
+                                    <property name="text">
+                                        <string>linear</string>
+                                    </property>
+                                </item>
+                                <item>
+                                    <property name="text">
+                                        <string>log</string>
+                                    </property>
+                                </item>
+                            </widget>
+                        </item>
+                        <item row="2" column="2">
+                            <widget class="QDoubleSpinBox" name="y_max">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="y_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="QDoubleSpinBox" name="y_min">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="y_label"/>
+                        </item>
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="y_scale_label">
+                                <property name="text">
+                                    <string>Scale</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="y_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="y_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="2">
+                            <widget class="QCheckBox" name="y_grid">
+                                <property name="text">
+                                    <string/>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="y_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+            <item row="2" column="0">
+                <widget class="QGroupBox" name="x_axis_box">
+                    <property name="title">
+                        <string>X Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_4">
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="x_scale_label">
+                                <property name="text">
+                                    <string>Scale</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="QDoubleSpinBox" name="x_min">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="x_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="2">
+                            <widget class="QDoubleSpinBox" name="x_max">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="2">
+                            <widget class="QComboBox" name="x_scale">
+                                <item>
+                                    <property name="text">
+                                        <string>linear</string>
+                                    </property>
+                                </item>
+                                <item>
+                                    <property name="text">
+                                        <string>log</string>
+                                    </property>
+                                </item>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="x_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="x_label"/>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="x_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="2">
+                            <widget class="QCheckBox" name="x_grid">
+                                <property name="text">
+                                    <string/>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="x_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+            <item row="1" column="1">
+                <widget class="ToggleSwitch" name="switch_outer_axes">
+                    <property name="checked" stdset="0">
+                        <bool>false</bool>
+                    </property>
+                </widget>
+            </item>
+        </layout>
+    </widget>
+    <customwidgets>
+        <customwidget>
+            <class>ToggleSwitch</class>
+            <extends>QWidget</extends>
+            <header>toggle_switch</header>
+        </customwidget>
+    </customwidgets>
+    <resources/>
+    <connections/>
+</ui>

bec_widgets/widgets/plots_next_gen/setting_menus/axis_settings_vertical.ui

@@ -0,0 +1,240 @@
+<?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>241</width>
+                <height>526</height>
+            </rect>
+        </property>
+        <property name="windowTitle">
+            <string>Form</string>
+        </property>
+        <layout class="QGridLayout" name="gridLayout">
+            <item row="4" column="0" colspan="2">
+                <widget class="QGroupBox" name="x_axis_box">
+                    <property name="title">
+                        <string>X Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_4">
+                        <item row="2" column="2">
+                            <widget class="QDoubleSpinBox" name="x_max">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="x_scale_label">
+                                <property name="text">
+                                    <string>Log</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="x_label"/>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="x_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="2">
+                            <widget class="ToggleSwitch" name="x_log">
+                                <property name="checked" stdset="0">
+                                    <bool>false</bool>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="5" column="0">
+                            <widget class="QLabel" name="x_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="QDoubleSpinBox" name="x_min">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="x_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="x_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="5" column="2">
+                            <widget class="ToggleSwitch" name="x_grid">
+                                <property name="checked" stdset="0">
+                                    <bool>false</bool>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+            <item row="0" column="0" colspan="2">
+                <layout class="QHBoxLayout" name="horizontalLayout">
+                    <item>
+                        <widget class="QLabel" name="plot_title_label">
+                            <property name="text">
+                                <string>Plot Title</string>
+                            </property>
+                        </widget>
+                    </item>
+                    <item>
+                        <widget class="QLineEdit" name="title"/>
+                    </item>
+                </layout>
+            </item>
+            <item row="2" column="0">
+                <widget class="QLabel" name="label_outer_axes">
+                    <property name="text">
+                        <string>Outer Axes</string>
+                    </property>
+                </widget>
+            </item>
+            <item row="5" column="0" colspan="2">
+                <widget class="QGroupBox" name="y_axis_box">
+                    <property name="title">
+                        <string>Y Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_5">
+                        <item row="2" column="2">
+                            <widget class="QDoubleSpinBox" name="y_max">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="y_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="QDoubleSpinBox" name="y_min">
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="minimum">
+                                    <double>-9999.000000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                    <double>9999.000000000000000</double>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="y_label"/>
+                        </item>
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="y_scale_label">
+                                <property name="text">
+                                    <string>Log</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="y_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="y_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="y_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="2">
+                            <widget class="ToggleSwitch" name="y_log">
+                                <property name="checked" stdset="0">
+                                    <bool>false</bool>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="2">
+                            <widget class="ToggleSwitch" name="y_grid">
+                                <property name="checked" stdset="0">
+                                    <bool>false</bool>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+            <item row="2" column="1">
+                <widget class="ToggleSwitch" name="outer_axes">
+                    <property name="checked" stdset="0">
+                        <bool>false</bool>
+                    </property>
+                </widget>
+            </item>
+            <item row="1" column="0">
+                <widget class="QLabel" name="label">
+                    <property name="text">
+                        <string>Inner Axes</string>
+                    </property>
+                </widget>
+            </item>
+            <item row="1" column="1">
+                <widget class="ToggleSwitch" name="inner_axes"/>
+            </item>
+        </layout>
+    </widget>
+    <customwidgets>
+        <customwidget>
+            <class>ToggleSwitch</class>
+            <extends>QWidget</extends>
+            <header>toggle_switch</header>
+        </customwidget>
+    </customwidgets>
+    <resources/>
+    <connections/>
+</ui>

bec_widgets/widgets/plots_next_gen/toolbar_bundles/mouse_interactions.py

@@ -0,0 +1,109 @@
+import pyqtgraph as pg
+
+from bec_widgets.qt_utils.error_popups import SafeSlot
+from bec_widgets.qt_utils.toolbar import MaterialIconAction, ToolbarBundle
+
+
+class MouseInteractionToolbarBundle(ToolbarBundle):
+    """
+    A bundle of actions that are hooked in this constructor itself,
+    so that you can immediately connect the signals and toggle states.
+
+    This bundle is for a toolbar that controls mouse interactions on a plot.
+    """
+
+    def __init__(self, bundle_id="mouse_interaction", target_widget=None, **kwargs):
+        super().__init__(bundle_id=bundle_id, actions=[], **kwargs)
+        self.target_widget = target_widget
+
+        # Create each MaterialIconAction with a parent
+        # so the signals can fire even if the toolbar isn't added yet.
+        drag = MaterialIconAction(
+            icon_name="drag_pan",
+            tooltip="Drag Mouse Mode",
+            checkable=True,
+            parent=self.target_widget,  # or any valid parent
+        )
+        rect = MaterialIconAction(
+            icon_name="frame_inspect",
+            tooltip="Rectangle Zoom Mode",
+            checkable=True,
+            parent=self.target_widget,
+        )
+        auto = MaterialIconAction(
+            icon_name="open_in_full",
+            tooltip="Autorange Plot",
+            checkable=False,
+            parent=self.target_widget,
+        )
+        aspect_ratio = MaterialIconAction(
+            icon_name="aspect_ratio",
+            tooltip="Lock image aspect ratio",
+            checkable=True,
+            parent=self.target_widget,
+        )
+
+        # Add them to the bundle
+        self.add_action("drag_mode", drag)
+        self.add_action("rectangle_mode", rect)
+        self.add_action("auto_range", auto)
+        self.add_action("aspect_ratio", aspect_ratio)
+
+        # Immediately connect signals
+        drag.action.toggled.connect(self.enable_mouse_pan_mode)
+        rect.action.toggled.connect(self.enable_mouse_rectangle_mode)
+        auto.action.triggered.connect(self.autorange_plot)
+        aspect_ratio.action.toggled.connect(self.lock_aspect_ratio)
+
+        mode = self.get_viewbox_mode()
+        if mode == "PanMode":
+            drag.action.setChecked(True)
+        elif mode == "RectMode":
+            rect.action.setChecked(True)
+
+    def get_viewbox_mode(self) -> str:
+        """
+        Returns the current interaction mode of a PyQtGraph ViewBox.
+
+        Returns:
+            str: "PanMode" if pan is enabled, "RectMode" if zoom is enabled, "Unknown" otherwise.
+        """
+        if self.target_widget:
+            viewbox = self.target_widget.plot_item.getViewBox()
+            if viewbox.getState()["mouseMode"] == 3:
+                return "PanMode"
+            elif viewbox.getState()["mouseMode"] == 1:
+                return "RectMode"
+        return "Unknown"
+
+    @SafeSlot(bool)
+    def enable_mouse_rectangle_mode(self, checked: bool):
+        """
+        Enable the rectangle zoom mode on the plot widget.
+        """
+        self.actions["drag_mode"].action.setChecked(not checked)
+        if self.target_widget and checked:
+            self.target_widget.plot_item.getViewBox().setMouseMode(pg.ViewBox.RectMode)
+
+    @SafeSlot(bool)
+    def enable_mouse_pan_mode(self, checked: bool):
+        """
+        Enable the pan mode on the plot widget.
+        """
+        self.actions["rectangle_mode"].action.setChecked(not checked)
+        if self.target_widget and checked:
+            self.target_widget.plot_item.getViewBox().setMouseMode(pg.ViewBox.PanMode)
+
+    @SafeSlot()
+    def autorange_plot(self):
+        """
+        Enable autorange on the plot widget.
+        """
+        if self.target_widget:
+            self.target_widget.auto_range_x = True
+            self.target_widget.auto_range_y = True
+
+    @SafeSlot(bool)
+    def lock_aspect_ratio(self, checked: bool):
+        if self.target_widget:
+            self.target_widget.lock_aspect_ratio = checked

bec_widgets/widgets/plots_next_gen/toolbar_bundles/plot_export.py

@@ -0,0 +1,63 @@
+from pyqtgraph.exporters import MatplotlibExporter
+
+from bec_widgets.qt_utils.error_popups import SafeSlot, WarningPopupUtility
+from bec_widgets.qt_utils.toolbar import MaterialIconAction, ToolbarBundle
+
+
+class PlotExportBundle(ToolbarBundle):
+    """
+    A bundle of actions that are hooked in this constructor itself,
+    so that you can immediately connect the signals and toggle states.
+
+    This bundle is for a toolbar that controls exporting a plot.
+    """
+
+    def __init__(self, bundle_id="mouse_interaction", target_widget=None, **kwargs):
+        super().__init__(bundle_id=bundle_id, actions=[], **kwargs)
+        self.target_widget = target_widget
+
+        # Create each MaterialIconAction with a parent
+        # so the signals can fire even if the toolbar isn't added yet.
+        save = MaterialIconAction(
+            icon_name="save", tooltip="Open Export Dialog", parent=self.target_widget
+        )
+        matplotlib = MaterialIconAction(
+            icon_name="photo_library", tooltip="Open Matplotlib Dialog", parent=self.target_widget
+        )
+
+        # Add them to the bundle
+        self.add_action("save", save)
+        self.add_action("matplotlib", matplotlib)
+
+        # Immediately connect signals
+        save.action.triggered.connect(self.export_dialog)
+        matplotlib.action.triggered.connect(self.matplotlib_dialog)
+
+    @SafeSlot()
+    def export_dialog(self):
+        """
+        Open the export dialog for the plot widget.
+        """
+        if self.target_widget:
+            scene = self.target_widget.plot_item.scene()
+            scene.contextMenuItem = self.target_widget.plot_item
+            scene.showExportDialog()
+
+    @SafeSlot()
+    def matplotlib_dialog(self):
+        """
+        Export the plot widget to Matplotlib.
+        """
+        if self.target_widget:
+            try:
+                import matplotlib as mpl
+
+                MatplotlibExporter(self.target_widget.plot_item).export()
+            except:
+                warning_util = WarningPopupUtility()
+                warning_util.show_warning(
+                    title="Matplotlib not installed",
+                    message="Matplotlib is required for this feature.",
+                    detailed_text="Please install matplotlib in your Python environment by using 'pip install matplotlib'.",
+                )
+                return

bec_widgets/widgets/plots_next_gen/toolbar_bundles/roi_bundle.py

@@ -0,0 +1,26 @@
+from bec_widgets.qt_utils.toolbar import MaterialIconAction, ToolbarBundle
+
+
+class ROIBundle(ToolbarBundle):
+    """
+    A bundle of actions that are hooked in this constructor itself,
+    so that you can immediately connect the signals and toggle states.
+
+    This bundle is for a toolbar that controls crosshair and ROI interaction.
+    """
+
+    def __init__(self, bundle_id="roi", target_widget=None, **kwargs):
+        super().__init__(bundle_id=bundle_id, actions=[], **kwargs)
+        self.target_widget = target_widget
+
+        # Create each MaterialIconAction with a parent
+        # so the signals can fire even if the toolbar isn't added yet.
+        crosshair = MaterialIconAction(
+            icon_name="point_scan", tooltip="Show Crosshair", checkable=True
+        )
+
+        # Add them to the bundle
+        self.add_action("crosshair", crosshair)
+
+        # Immediately connect signals
+        crosshair.action.toggled.connect(self.target_widget.toggle_crosshair)

bec_widgets/widgets/plots_next_gen/toolbar_bundles/save_state.py

@@ -0,0 +1,48 @@
+from bec_widgets.qt_utils.error_popups import SafeSlot
+from bec_widgets.qt_utils.toolbar import MaterialIconAction, ToolbarBundle
+
+
+class SaveStateBundle(ToolbarBundle):
+    """
+    A bundle of actions that are hooked in this constructor itself,
+    so that you can immediately connect the signals and toggle states.
+
+    This bundle is for a toolbar that controls saving the state of the widget.
+    """
+
+    def __init__(self, bundle_id="mouse_interaction", target_widget=None, **kwargs):
+        super().__init__(bundle_id=bundle_id, actions=[], **kwargs)
+        self.target_widget = target_widget
+
+        # Create each MaterialIconAction with a parent
+        # so the signals can fire even if the toolbar isn't added yet.
+        save_state = MaterialIconAction(
+            icon_name="download", tooltip="Save Widget State", parent=self.target_widget
+        )
+        load_state = MaterialIconAction(
+            icon_name="upload", tooltip="Load Widget State", parent=self.target_widget
+        )
+
+        # Add them to the bundle
+        self.add_action("save", save_state)
+        self.add_action("matplotlib", load_state)
+
+        # Immediately connect signals
+        save_state.action.triggered.connect(self.save_state_dialog)
+        load_state.action.triggered.connect(self.load_state_dialog)
+
+    @SafeSlot()
+    def save_state_dialog(self):
+        """
+        Open the export dialog to save a state of the widget.
+        """
+        if self.target_widget:
+            self.target_widget.state_manager.save_state()
+
+    @SafeSlot()
+    def load_state_dialog(self):
+        """
+        Load a saved state of the widget.
+        """
+        if self.target_widget:
+            self.target_widget.state_manager.load_state()

bec_widgets/widgets/utility/logpanel/__init__.py

@@ -0,0 +1,3 @@
+from bec_widgets.widgets.utility.logpanel.logpanel import LogPanel
+
+__ALL__ = ["LogPanel"]

bec_widgets/widgets/utility/logpanel/_util.py

@@ -0,0 +1,58 @@
+""" Utilities for filtering and formatting in the LogPanel"""
+
+from __future__ import annotations
+
+import re
+from collections import deque
+from typing import Callable, Iterator
+
+from bec_lib.logger import LogLevel
+from bec_lib.messages import LogMessage
+from qtpy.QtCore import QDateTime
+
+LinesHtmlFormatter = Callable[[deque[LogMessage]], Iterator[str]]
+LineFormatter = Callable[[LogMessage], str]
+LineFilter = Callable[[LogMessage], bool] | None
+
+ANSI_ESCAPE_REGEX = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+
+def replace_escapes(s: str):
+    s = ANSI_ESCAPE_REGEX.sub("", s)
+    return s.replace(" ", "&nbsp;").replace("\n", "<br />").replace("\t", "    ")
+
+
+def level_filter(msg: LogMessage, thresh: int):
+    return LogLevel[msg.content["log_type"].upper()].value >= thresh
+
+
+def noop_format(line: LogMessage):
+    _textline = line.log_msg if isinstance(line.log_msg, str) else line.log_msg["text"]
+    return replace_escapes(_textline.strip()) + "<br />"
+
+
+def simple_color_format(line: LogMessage, colors: dict[LogLevel, str]):
+    color = colors.get(LogLevel[line.content["log_type"].upper()]) or colors[LogLevel.INFO]
+    return f'<font color="{color}">{noop_format(line)}</font>'
+
+
+def create_formatter(line_format: LineFormatter, line_filter: LineFilter) -> LinesHtmlFormatter:
+    def _formatter(data: deque[LogMessage]):
+        if line_filter is not None:
+            return (line_format(line) for line in data if line_filter(line))
+        else:
+            return (line_format(line) for line in data)
+
+    return _formatter
+
+
+def log_txt(line):
+    return line.log_msg if isinstance(line.log_msg, str) else line.log_msg["text"]
+
+
+def log_time(line):
+    return QDateTime.fromMSecsSinceEpoch(int(line.log_msg["record"]["time"]["timestamp"] * 1000))
+
+
+def log_svc(line):
+    return line.log_msg["service_name"]

bec_widgets/widgets/utility/logpanel/log_panel.pyproject

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

bec_widgets/widgets/utility/logpanel/log_panel_plugin.py

@@ -0,0 +1,54 @@
+# 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.utility.logpanel.logpanel import LogPanel
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='LogPanel' name='log_panel'>
+    </widget>
+</ui>
+"""
+
+
+class LogPanelPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = LogPanel(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Utils"
+
+    def icon(self):
+        return designer_material_icon(LogPanel.ICON_NAME)
+
+    def includeFile(self):
+        return "log_panel"
+
+    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 "LogPanel"
+
+    def toolTip(self):
+        return "Displays a log panel"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/utility/logpanel/logpanel.py

@@ -0,0 +1,529 @@
+""" Module for a LogPanel widget to display BEC log messages """
+
+from __future__ import annotations
+
+import operator
+import os
+import re
+from collections import deque
+from functools import partial, reduce
+from re import Pattern
+from typing import TYPE_CHECKING, Literal
+
+from bec_lib.client import BECClient
+from bec_lib.connector import ConnectorBase
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import LogLevel, bec_logger
+from bec_lib.messages import LogMessage, StatusMessage
+from qtpy.QtCore import QDateTime, Qt, Signal  # type: ignore
+from qtpy.QtGui import QFont
+from qtpy.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QComboBox,
+    QDateTimeEdit,
+    QDialog,
+    QGridLayout,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QScrollArea,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.qt_utils.error_popups import SafeSlot
+from bec_widgets.utils.colors import get_theme_palette, set_theme
+from bec_widgets.widgets.editors.text_box.text_box import TextBox
+from bec_widgets.widgets.services.bec_status_box.bec_status_box import BECServiceStatusMixin
+from bec_widgets.widgets.utility.logpanel._util import (
+    LineFilter,
+    LineFormatter,
+    LinesHtmlFormatter,
+    create_formatter,
+    level_filter,
+    log_svc,
+    log_time,
+    log_txt,
+    noop_format,
+    simple_color_format,
+)
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import SignalInstance
+
+logger = bec_logger.logger
+
+MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+
+# TODO: improve log color handling
+DEFAULT_LOG_COLORS = {
+    LogLevel.INFO: "#FFFFFF",
+    LogLevel.SUCCESS: "#00FF00",
+    LogLevel.WARNING: "#FFCC00",
+    LogLevel.ERROR: "#FF0000",
+    LogLevel.DEBUG: "#0000CC",
+}
+
+
+class BecLogsQueue:
+    """Manages getting logs from BEC Redis and formatting them for display"""
+
+    def __init__(
+        self,
+        conn: ConnectorBase,
+        new_message_signal: SignalInstance,
+        maxlen: int = 1000,
+        line_formatter: LineFormatter = noop_format,
+    ) -> None:
+        self._timestamp_start: QDateTime | None = None
+        self._timestamp_end: QDateTime | None = None
+        self._conn = conn
+        self._new_message_signal: SignalInstance | None = new_message_signal
+        self._max_length = maxlen
+        self._data: deque[LogMessage] = deque([], self._max_length)
+        self._display_queue: deque[str] = deque([], self._max_length)
+        self._log_level: str | None = None
+        self._search_query: Pattern | str | None = None
+        self._selected_services: set[str] | None = None
+        self._set_formatter_and_update_filter(line_formatter)
+        self._conn.register([MessageEndpoints.log()], None, self._process_incoming_log_msg)
+
+    def disconnect(self):
+        self._conn.unregister([MessageEndpoints.log()], None, self._process_incoming_log_msg)
+        self._new_message_signal.disconnect()
+
+    def _process_incoming_log_msg(self, msg: dict):
+        try:
+            _msg: LogMessage = msg["data"]
+            self._data.append(_msg)
+            if self.filter is None or self.filter(_msg):
+                self._display_queue.append(self._line_formatter(_msg))
+                if self._new_message_signal:
+                    self._new_message_signal.emit()
+        except Exception:
+            logger.warning("Error in LogPanel incoming message callback!")
+
+    def _set_formatter_and_update_filter(self, line_formatter: LineFormatter = noop_format):
+        self._line_formatter: LineFormatter = line_formatter
+        self._queue_formatter: LinesHtmlFormatter = create_formatter(
+            self._line_formatter, self.filter
+        )
+
+    def _combine_filters(self, *args: LineFilter):
+        return lambda msg: reduce(operator.and_, [filt(msg) for filt in args if filt is not None])
+
+    def _create_re_filter(self) -> LineFilter:
+        if self._search_query is None:
+            return None
+        elif isinstance(self._search_query, str):
+            return lambda line: self._search_query in log_txt(line)
+        return lambda line: self._search_query.match(log_txt(line)) is not None
+
+    def _create_service_filter(self):
+        return (
+            lambda line: self._selected_services is None or log_svc(line) in self._selected_services
+        )
+
+    def _create_timestamp_filter(self) -> LineFilter:
+        s, e = self._timestamp_start, self._timestamp_end
+        if s is e is None:
+            return lambda msg: True
+
+        def _time_filter(msg):
+            msg_time = log_time(msg)
+            if s is None:
+                return msg_time <= e
+            if e is None:
+                return s <= msg_time
+            return s <= msg_time <= e
+
+        return _time_filter
+
+    @property
+    def filter(self) -> LineFilter:
+        thresh = LogLevel[self._log_level].value if self._log_level is not None else 0
+        return self._combine_filters(
+            partial(level_filter, thresh=thresh),
+            self._create_re_filter(),
+            self._create_timestamp_filter(),
+            self._create_service_filter(),
+        )
+
+    def update_level_filter(self, level: str):
+        if level not in [l.name for l in LogLevel]:
+            logger.error(f"Logging level {level} unrecognized for filter!")
+            return
+        self._log_level = level
+        self._set_formatter_and_update_filter(self._line_formatter)
+
+    def update_search_filter(self, search_query: Pattern | str | None = None):
+        self._search_query = search_query
+        self._set_formatter_and_update_filter(self._line_formatter)
+
+    def update_time_filter(self, start: QDateTime | None, end: QDateTime | None):
+        self._timestamp_start = start
+        self._timestamp_end = end
+        self._set_formatter_and_update_filter(self._line_formatter)
+
+    def update_service_filter(self, services: set[str]):
+        self._selected_services = services
+        self._set_formatter_and_update_filter(self._line_formatter)
+
+    def update_line_formatter(self, line_formatter: LineFormatter):
+        self._set_formatter_and_update_filter(line_formatter)
+
+    def display_all(self) -> str:
+        return "\n".join(self._queue_formatter(self._data.copy()))
+
+    def format_new(self):
+        res = "\n".join(self._display_queue)
+        self._display_queue = deque([], self._max_length)
+        return res
+
+    def clear_logs(self):
+        self._data = deque([])
+        self._display_queue = deque([])
+
+    def fetch_history(self):
+        self._data = deque(
+            item["data"]
+            for item in self._conn.xread(
+                MessageEndpoints.log().endpoint, from_start=True, count=self._max_length
+            )
+        )
+
+    def unique_service_names_from_history(self) -> set[str]:
+        return set(msg.log_msg["service_name"] for msg in self._data)
+
+
+class LogPanelToolbar(QWidget):
+
+    services_selected: pyqtBoundSignal = Signal(set)
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+
+        # in unix time
+        self._timestamp_start: QDateTime | None = None
+        self._timestamp_end: QDateTime | None = None
+
+        self._unique_service_names: set[str] = set()
+        self._services_selected: set[str] | None = None
+
+        self.layout = QHBoxLayout(self)  # type: ignore
+
+        self.service_choice_button = QPushButton("Select services", self)
+        self.layout.addWidget(self.service_choice_button)
+        self.service_choice_button.clicked.connect(self._open_service_filter_dialog)
+
+        self.filter_level_dropdown = self._log_level_box()
+        self.layout.addWidget(self.filter_level_dropdown)
+
+        self.clear_button = QPushButton("Clear all", self)
+        self.layout.addWidget(self.clear_button)
+        self.fetch_button = QPushButton("Fetch history", self)
+        self.layout.addWidget(self.fetch_button)
+
+        self._string_search_box()
+
+        self.timerange_button = QPushButton("Set time range", self)
+        self.layout.addWidget(self.timerange_button)
+
+    @property
+    def time_start(self):
+        return self._timestamp_start
+
+    @property
+    def time_end(self):
+        return self._timestamp_end
+
+    def _string_search_box(self):
+        self.layout.addWidget(QLabel("Search: "))
+        self.search_textbox = QLineEdit()
+        self.layout.addWidget(self.search_textbox)
+        self.layout.addWidget(QLabel("Use regex: "))
+        self.regex_enabled = QCheckBox()
+        self.layout.addWidget(self.regex_enabled)
+        self.update_re_button = QPushButton("Update search", self)
+        self.layout.addWidget(self.update_re_button)
+
+    def _log_level_box(self):
+        box = QComboBox()
+        box.setToolTip("Display logs with equal or greater significance to the selected level.")
+        [box.addItem(l.name) for l in LogLevel]
+        return box
+
+    def _current_ts(self, selection_type: Literal["start", "end"]):
+        if selection_type == "start":
+            return self._timestamp_start
+        elif selection_type == "end":
+            return self._timestamp_end
+        else:
+            raise ValueError(f"timestamps can only be for the start or end, not {selection_type}")
+
+    def _open_datetime_dialog(self):
+        """Open dialog window for timestamp filter selection"""
+        self._dt_dialog = QDialog(self)
+        self._dt_dialog.setWindowTitle("Time range selection")
+        layout = QVBoxLayout()
+        self._dt_dialog.setLayout(layout)
+
+        label_start = QLabel(parent=self._dt_dialog)
+        label_end = QLabel(parent=self._dt_dialog)
+
+        def date_button_set(selection_type: Literal["start", "end"], label: QLabel):
+            dt = self._current_ts(selection_type)
+            _layout = QHBoxLayout()
+            layout.addLayout(_layout)
+            date_button = QPushButton(f"Time {selection_type}", parent=self._dt_dialog)
+            _layout.addWidget(date_button)
+            label.setText(dt.toString() if dt else "not selected")
+            _layout.addWidget(label)
+            date_button.clicked.connect(partial(self._open_cal_dialog, selection_type, label))
+            date_clear_button = QPushButton("clear", parent=self._dt_dialog)
+            date_clear_button.clicked.connect(
+                lambda: (
+                    partial(self._update_time, selection_type)(None),
+                    label.setText("not selected"),
+                )
+            )
+            _layout.addWidget(date_clear_button)
+
+        for v in [("start", label_start), ("end", label_end)]:
+            date_button_set(*v)
+
+        close_button = QPushButton("Close", parent=self._dt_dialog)
+        close_button.clicked.connect(self._dt_dialog.accept)
+        layout.addWidget(close_button)
+
+        self._dt_dialog.exec()
+        self._dt_dialog.deleteLater()
+
+    def _open_cal_dialog(self, selection_type: Literal["start", "end"], label: QLabel):
+        """Open dialog window for timestamp filter selection"""
+        dt = self._current_ts(selection_type) or QDateTime.currentDateTime()
+        label.setText(dt.toString() if dt else "not selected")
+        if selection_type == "start":
+            self._timestamp_start = dt
+        else:
+            self._timestamp_end = dt
+        self._cal_dialog = QDialog(self)
+        self._cal_dialog.setWindowTitle(f"Select time range {selection_type}")
+        layout = QVBoxLayout()
+        self._cal_dialog.setLayout(layout)
+        cal = QDateTimeEdit(parent=self._cal_dialog)
+        cal.setCalendarPopup(True)
+        cal.setDateTime(dt)
+        cal.setDisplayFormat("yyyy-MM-dd HH:mm:ss.zzz")
+        cal.dateTimeChanged.connect(partial(self._update_time, selection_type))
+        layout.addWidget(cal)
+        close_button = QPushButton("Close", parent=self._cal_dialog)
+        close_button.clicked.connect(self._cal_dialog.accept)
+        layout.addWidget(close_button)
+
+        self._cal_dialog.exec()
+        self._cal_dialog.deleteLater()
+
+    def _update_time(self, selection_type: Literal["start", "end"], dt: QDateTime | None):
+        if selection_type == "start":
+            self._timestamp_start = dt
+        else:
+            self._timestamp_end = dt
+
+    @SafeSlot(dict, set)
+    def service_list_update(
+        self, services_info: dict[str, StatusMessage], services_from_history: set[str], *_, **__
+    ):
+        self._unique_service_names = set([s.split("/")[0] for s in services_info.keys()])
+        self._unique_service_names |= services_from_history
+        if self._services_selected is None:
+            self._services_selected = self._unique_service_names
+
+    @SafeSlot()
+    def _open_service_filter_dialog(self):
+        if len(self._unique_service_names) == 0 or self._services_selected is None:
+            return
+        self._svc_dialog = QDialog(self)
+        self._svc_dialog.setWindowTitle(f"Select services to show logs from")
+        layout = QVBoxLayout()
+        self._svc_dialog.setLayout(layout)
+
+        service_cb_grid = QGridLayout(parent=self._svc_dialog)
+        layout.addLayout(service_cb_grid)
+
+        def check_box(name: str, checked: Qt.CheckState):
+            if checked == Qt.CheckState.Checked:
+                self._services_selected.add(name)
+            else:
+                if name in self._services_selected:
+                    self._services_selected.remove(name)
+            self.services_selected.emit(self._services_selected)
+
+        for i, svc in enumerate(self._unique_service_names):
+            service_cb_grid.addWidget(QLabel(svc, parent=self._svc_dialog), i, 0)
+            cb = QCheckBox(parent=self._svc_dialog)
+            cb.setChecked(svc in self._services_selected)
+            cb.checkStateChanged.connect(partial(check_box, svc))
+            service_cb_grid.addWidget(cb, i, 1)
+
+        close_button = QPushButton("Close", parent=self._svc_dialog)
+        close_button.clicked.connect(self._svc_dialog.accept)
+        layout.addWidget(close_button)
+
+        self._svc_dialog.exec()
+        self._svc_dialog.deleteLater()
+
+
+class LogPanel(TextBox):
+    """Displays a log panel"""
+
+    ICON_NAME = "terminal"
+    _new_messages = Signal()
+    service_list_update = Signal(dict, set)
+
+    def __init__(
+        self,
+        parent=None,
+        client: BECClient | None = None,
+        service_status: BECServiceStatusMixin | None = None,
+        **kwargs,
+    ):
+        """Initialize the LogPanel widget."""
+        super().__init__(parent=parent, client=client, **kwargs)
+        self._update_colors()
+        self._service_status = service_status or BECServiceStatusMixin(self, client=self.client)  # type: ignore
+        self._log_manager = BecLogsQueue(
+            self.client.connector,  # type: ignore
+            new_message_signal=self._new_messages,
+            line_formatter=partial(simple_color_format, colors=self._colors),
+        )
+
+        self.toolbar = LogPanelToolbar(parent=parent)
+        self.toolbar_area = QScrollArea()
+        self.toolbar_area.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.toolbar_area.setSizeAdjustPolicy(QScrollArea.SizeAdjustPolicy.AdjustToContents)
+        self.toolbar_area.setFixedHeight(int(self.toolbar.clear_button.height() * 2))
+        self.toolbar_area.setWidget(self.toolbar)
+
+        self.layout.addWidget(self.toolbar_area)
+        self.toolbar.clear_button.clicked.connect(self._on_clear)
+        self.toolbar.fetch_button.clicked.connect(self._on_fetch)
+        self.toolbar.update_re_button.clicked.connect(self._on_re_update)
+        self.toolbar.search_textbox.returnPressed.connect(self._on_re_update)
+        self.toolbar.regex_enabled.checkStateChanged.connect(self._on_re_update)
+        self.toolbar.filter_level_dropdown.currentTextChanged.connect(self._set_level_filter)
+        self._new_messages.connect(self._on_append)
+
+        self.toolbar.timerange_button.clicked.connect(self._choose_datetime)
+        self._service_status.services_update.connect(self._update_service_list)
+        self.service_list_update.connect(self.toolbar.service_list_update)
+        self.toolbar.services_selected.connect(self._update_service_filter)
+
+        self.text_box_text_edit.setFont(QFont("monospace", 12))
+        self.text_box_text_edit.setHtml("")
+        self.text_box_text_edit.setLineWrapMode(QTextEdit.LineWrapMode.NoWrap)
+
+        self._connect_to_theme_change()
+
+    @SafeSlot(set)
+    def _update_service_filter(self, services: set[str]):
+        self._log_manager.update_service_filter(services)
+        self._on_redraw()
+
+    @SafeSlot(dict, dict)
+    def _update_service_list(self, services_info: dict[str, StatusMessage], *_, **__):
+        self.service_list_update.emit(
+            services_info, self._log_manager.unique_service_names_from_history()
+        )
+
+    @SafeSlot()
+    def _choose_datetime(self):
+        self.toolbar._open_datetime_dialog()
+        self._set_time_filter()
+
+    def _connect_to_theme_change(self):
+        """Connect to the theme change signal."""
+        qapp = QApplication.instance()
+        if hasattr(qapp, "theme_signal"):
+            qapp.theme_signal.theme_updated.connect(self._on_redraw)  # type: ignore
+
+    def _update_colors(self):
+        self._colors = DEFAULT_LOG_COLORS.copy()
+        self._colors.update({LogLevel.INFO: get_theme_palette().text().color().name()})
+
+    def _cursor_to_end(self):
+        c = self.text_box_text_edit.textCursor()
+        c.movePosition(c.MoveOperation.End)
+        self.text_box_text_edit.setTextCursor(c)
+
+    @SafeSlot()
+    @SafeSlot(str)
+    def _on_redraw(self, *_):
+        self._update_colors()
+        self._log_manager.update_line_formatter(partial(simple_color_format, colors=self._colors))
+        self.set_html_text(self._log_manager.display_all())
+        self._cursor_to_end()
+
+    @SafeSlot()
+    def _on_append(self):
+        self._cursor_to_end()
+        self.text_box_text_edit.insertHtml(self._log_manager.format_new())
+
+    @SafeSlot()
+    def _on_clear(self):
+        self._log_manager.clear_logs()
+        self.set_html_text(self._log_manager.display_all())
+        self._cursor_to_end()
+
+    @SafeSlot()
+    @SafeSlot(Qt.CheckState)
+    def _on_re_update(self, *_):
+        if self.toolbar.regex_enabled.isChecked():
+            try:
+                search_query = re.compile(self.toolbar.search_textbox.text())
+            except Exception as e:
+                logger.warning(f"Failed to compile search regex with error {e}")
+                search_query = None
+            logger.info(f"Setting LogPanel search regex to {search_query}")
+        else:
+            search_query = self.toolbar.search_textbox.text()
+            logger.info(f'Setting LogPanel search string to "{search_query}"')
+        self._log_manager.update_search_filter(search_query)
+        self.set_html_text(self._log_manager.display_all())
+        self._cursor_to_end()
+
+    @SafeSlot()
+    def _on_fetch(self):
+        self._log_manager.fetch_history()
+        self.set_html_text(self._log_manager.display_all())
+        self._cursor_to_end()
+
+    @SafeSlot(str)
+    def _set_level_filter(self, level: str):
+        self._log_manager.update_level_filter(level)
+        self._on_redraw()
+
+    @SafeSlot()
+    def _set_time_filter(self):
+        self._log_manager.update_time_filter(self.toolbar.time_start, self.toolbar.time_end)
+        self._on_redraw()
+
+    def cleanup(self):
+        self._service_status.cleanup()
+        self._log_manager.disconnect()
+
+
+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 = LogPanel()
+
+    widget.show()
+    sys.exit(app.exec())

bec_widgets/widgets/utility/logpanel/register_log_panel.py

@@ -0,0 +1,15 @@
+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.utility.logpanel.log_panel_plugin import LogPanelPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(LogPanelPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

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/getting_started/installation.md

@@ -9,25 +9,24 @@ Before installing BEC Widgets, please ensure the following requirements are met:
 
 **Standard Installation**
 
-To install BEC Widgets using the pip package manager, execute the following command in your terminal for getting the default PyQT6 version into your python environment for BEC:
+To install BEC Widgets using the pip package manager, execute the following command in your terminal for getting the
+default PySide6 version into your python environment for BEC:
 
 
-```bash
-pip install 'bec_widgets[pyqt6]'
-```
-
-In case you want to use Pyside6, you can install it by using the following command:
-
 ```bash
 pip install 'bec_widgets[pyside6]'
 ```
 
 **Troubleshooting**
 
-If you encounter issues during installation, particularly with PyQt, try purging the pip cache:
+If you encounter issues during installation, particularly with Qt, try purging the pip cache:
 
 ```bash
 pip cache purge
 ```
 
 This can resolve conflicts or issues with package installations.
+
+```{warning}
+At the moment PyQt6 is no longer officially supported by BEC Widgets due to incompatibilities with Qt Designer. Please use PySide6 instead.
+```

docs/user/widgets/device_input/device_input.md

@@ -21,6 +21,10 @@ The `DeviceComboBox` widget offers a dropdown interface for device selection, pr
 - **Dropdown Selection (ComboBox)**: The `DeviceComboBox` widget displays devices in a dropdown list, making selection straightforward.
 - **QtDesigner Integration**: Both widgets can be added as custom widgets in `QtDesigner` or instantiated directly in code.
 
+## Screenshot
+```{figure} /assets/widget_screenshots/device_inputs.png
+```
+
 ````
 
 ````{tab} Examples

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/log_panel/log_panel.md

@@ -0,0 +1,39 @@
+(user.widgets.log_panel)=
+
+# LogPanel widget
+
+The LogPanel widget can be used to view logs:
+
+![LogPanel](./logpanel.png)
+
+It automatically subscribes to log updates. You can fetch the log history with the "Fetch history" button.
+
+## Filtering based on log level
+
+If you select a dropdown box, only logs of that priority level or higher will be displayed:
+
+![LogPanel](./logpanel_level.png)
+
+
+## Filtering based on a search string
+
+If you type in a search string into the box in the toolbar, and hit enter or press the update button, that filter will be applied:
+
+![LogPanel](./logpanel_text.png)
+
+This search uses the [Python regular expression syntax](https://docs.python.org/3/library/re.html) if the checkbox for this option is selected:
+
+![LogPanel](./logpanel_regex.png)
+
+
+## Filtering based on time range
+
+You may filter the logs to those occurring within a given time range.
+
+![LogPanel](./logpanel_timerange.png)
+
+## Filtering based on service
+
+You can select which services to show logs from.
+
+![LogPanel](./logpanel_services.png)

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/signal_input/signal_input.md

@@ -18,6 +18,11 @@ The `SignalComboBox` widget offers a dropdown interface for choosing a signal fr
 - **Dropdown Selection (SignalComboBox)**: The `SignalComboBox` widget displays the sorted signals of the device 
 - **QtDesigner Integration**: Both widgets can be added as custom widgets in `QtDesigner` or instantiated directly in code.
 
+## Screenshot
+
+```{figure} /assets/widget_screenshots/signal_inputs.png
+```
+
 ````
 
 ````{tab} Examples

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.12.0"
+version = "1.22.0"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -15,14 +15,15 @@ classifiers = [
 dependencies = [
     "bec_ipython_client>=2.21.4, <=4.0", # needed for jupyter console
     "bec_lib>=2.21.4, <=4.0",
+    "bec_qthemes~=0.7, >=0.7",
     "black~=24.0",                       # needed for bw-generate-cli
     "isort~=5.13, >=5.13.2",             # needed for bw-generate-cli
     "pydantic~=2.0",
     "pyqtgraph~=0.13",
-    "bec_qthemes~=0.7, >=0.7",
+    "PySide6>=6.8",
+    "pyte",                              # needed for vt100 console
     "qtconsole~=5.5, >=5.5.1",           # needed for jupyter console
     "qtpy~=2.4",
-    "pyte",                              # needed for vt100 console
 ]
 
 
@@ -37,8 +38,6 @@ dev = [
     "pytest-xvfb~=3.0",
     "pytest~=8.0",
 ]
-pyqt6 = ["PyQt6>=6.7", "PyQt6-WebEngine>=6.7"]
-pyside6 = ["PySide6==6.7.2"]
 
 [project.urls]
 "Bug Tracker" = "https://gitlab.psi.ch/bec/bec_widgets/issues"

tests/conftest.py

@@ -0,0 +1,46 @@
+import pytest
+import qtpy.QtCore
+from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
+from qtpy.QtCore import QTimer
+
+
+class TestableQTimer(QTimer):
+    _instances: list[tuple[QTimer, str]] = []
+    _current_test_name: str = ""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        TestableQTimer._instances.append((self, TestableQTimer._current_test_name))
+
+    @classmethod
+    def check_all_stopped(cls, qtbot):
+        def _is_done_or_deleted(t: QTimer):
+            try:
+                return not t.isActive()
+            except RuntimeError as e:
+                return "already deleted" in e.args[0]
+
+        try:
+            qtbot.waitUntil(lambda: all(_is_done_or_deleted(timer) for timer, _ in cls._instances))
+        except QtBotTimeoutError as exc:
+            active_timers = list(filter(lambda t: t[0].isActive(), cls._instances))
+            (t.stop() for t, _ in cls._instances)
+            raise TimeoutError(f"Failed to stop all timers: {active_timers}") from exc
+        cls._instances = []
+
+
+# To support 'from qtpy.QtCore import QTimer' syntax we just replace this completely for the test session
+# see: https://docs.python.org/3/library/unittest.mock.html#where-to-patch
+qtpy.QtCore.QTimer = TestableQTimer
+
+
+@pytest.fixture(autouse=True)
+def _capture_test_name_in_qtimer(request):
+    TestableQTimer._current_test_name = request.node.name
+    yield
+    TestableQTimer._current_test_name = ""
+
+
+@pytest.fixture
+def testable_qtimer_class():
+    return TestableQTimer

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -4,7 +4,8 @@ import numpy as np
 import pytest
 from bec_lib.endpoints import MessageEndpoints
 
-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,7 +13,7 @@ from bec_widgets.utils import Colors
 # pylint: disable=too-many-locals
 
 
-def test_rpc_add_dock_with_figure_e2e(bec_client_lib, connected_client_dock):
+def test_rpc_add_dock_with_figure_e2e(qtbot, bec_client_lib, connected_client_dock):
     # BEC client shortcuts
     dock = connected_client_dock
     client = bec_client_lib
@@ -88,14 +89,17 @@ def test_rpc_add_dock_with_figure_e2e(bec_client_lib, connected_client_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
@@ -255,11 +259,17 @@ def test_auto_update(bec_client_lib, connected_client_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"]
@@ -277,12 +287,18 @@ def test_auto_update(bec_client_lib, connected_client_dock_w_auto_updates, qtbot
 
     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"]
@@ -355,6 +371,7 @@ def test_rpc_call_with_exception_in_safeslot_error_popup(connected_client_gui_ob
     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,10 +1,10 @@
 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(connected_client_figure):
@@ -78,7 +78,7 @@ def test_rpc_plotting_shortcuts_init_configs(connected_client_figure, qtbot):
     }
 
 
-def test_rpc_waveform_scan(connected_client_figure, bec_client_lib):
+def test_rpc_waveform_scan(qtbot, connected_client_figure, bec_client_lib):
     fig = BECFigure(connected_client_figure)
 
     # add 3 different curves to track
@@ -97,6 +97,11 @@ def test_rpc_waveform_scan(connected_client_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()
 

tests/unit_tests/conftest.py

@@ -2,7 +2,6 @@ from unittest import mock
 
 import pytest
 from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
-from qtpy.QtCore import QTimer
 from qtpy.QtWidgets import QApplication
 
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
@@ -10,22 +9,6 @@ from bec_widgets.qt_utils import error_popups
 from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
 
 
-class TestableQTimer(QTimer):
-    _instances = []
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        TestableQTimer._instances.append(self)
-
-    @classmethod
-    def check_all_stopped(cls, qtbot):
-        try:
-            qtbot.waitUntil(lambda: all(not timer.isActive() for timer in cls._instances))
-        except QtBotTimeoutError as exc:
-            raise TimeoutError("Failed to stop all timers") from exc
-        cls._instances = []
-
-
 @pytest.hookimpl(tryfirst=True, hookwrapper=True)
 def pytest_runtest_makereport(item, call):
     # execute all other hooks to obtain the report object
@@ -36,17 +19,16 @@ def pytest_runtest_makereport(item, call):
 
 
 @pytest.fixture(autouse=True)
-def qapplication(qtbot, request):  # pylint: disable=unused-argument
-    with mock.patch("qtpy.QtCore.QTimer", new=TestableQTimer):
-        yield
+def qapplication(qtbot, request, testable_qtimer_class):  # pylint: disable=unused-argument
+    yield
 
-        # if the test failed, we don't want to check for open widgets as
-        # it simply pollutes the output
-        if request.node.stash._storage.get("failed"):
-            print("Test failed, skipping cleanup checks")
-            return
+    # if the test failed, we don't want to check for open widgets as
+    # it simply pollutes the output
+    if request.node.stash._storage.get("failed"):
+        print("Test failed, skipping cleanup checks")
+        return
 
-        TestableQTimer.check_all_stopped(qtbot)
+    testable_qtimer_class.check_all_stopped(qtbot)
 
     qapp = QApplication.instance()
     qapp.processEvents()

tests/unit_tests/test_axis_settings.py

@@ -0,0 +1,105 @@
+import pytest
+from qtpy.QtWidgets import QDoubleSpinBox, QLineEdit
+
+from bec_widgets.widgets.plots_next_gen.plot_base import PlotBase
+from bec_widgets.widgets.plots_next_gen.setting_menus.axis_settings import AxisSettings
+from tests.unit_tests.client_mocks import mocked_client
+from tests.unit_tests.conftest import create_widget
+
+
+@pytest.fixture
+def axis_settings_fixture(qtbot, mocked_client):
+    """
+    Creates an AxisSettings widget, targeting the real PlotBase widget.
+    """
+
+    plot_base = create_widget(qtbot, PlotBase, client=mocked_client)
+    axis_settings = create_widget(qtbot, AxisSettings, parent=None, target_widget=plot_base)
+    return axis_settings, plot_base
+
+
+def test_axis_settings_init(axis_settings_fixture):
+    """
+    Ensure AxisSettings constructs properly with a real PlotBase target.
+    """
+    axis_settings, plot_base = axis_settings_fixture
+    # Verify the UI was loaded and placed in a scroll area
+    assert axis_settings.ui is not None
+    assert axis_settings.scroll_area is not None
+    assert axis_settings.layout.count() == 1  # scroll area
+    # Check the target
+    assert axis_settings.target_widget == plot_base
+
+
+def test_change_ui_updates_plot_base(axis_settings_fixture, qtbot):
+    """
+    When user edits AxisSettings UI fields, verify that PlotBase's properties update.
+    """
+    axis_settings, plot_base = axis_settings_fixture
+
+    # 1) Set the 'title'
+    title_edit = axis_settings.ui.title
+    assert isinstance(title_edit, QLineEdit)
+    with qtbot.waitSignal(plot_base.property_changed, timeout=500) as signal:
+        title_edit.setText("New Plot Title")
+
+    assert signal.args == ["title", "New Plot Title"]
+    assert plot_base.title == "New Plot Title"
+
+    # 2) Set x_min spinbox
+    x_max_spin = axis_settings.ui.x_max
+    assert isinstance(x_max_spin, QDoubleSpinBox)
+    with qtbot.waitSignal(plot_base.property_changed, timeout=500) as signal2:
+        x_max_spin.setValue(123)
+    assert plot_base.x_max == 123
+
+    # # 3) Toggle grid
+    x_log_toggle = axis_settings.ui.x_log
+    x_log_toggle.checked = True
+    with qtbot.waitSignal(plot_base.property_changed, timeout=500) as signal3:
+        x_log_toggle.checked = True
+
+    assert plot_base.x_log is True
+
+
+def test_plot_base_updates_ui(axis_settings_fixture, qtbot):
+    """
+    When PlotBase properties change (on the Python side), AxisSettings UI should update.
+    We do this by simulating that PlotBase sets properties and emits property_changed.
+    (In real usage, PlotBase calls .property_changed.emit(...) in its setters.)
+    """
+    axis_settings, plot_base = axis_settings_fixture
+
+    # 1) Set plot_base.title
+    plot_base.title = "Plot Title from Code"
+    assert axis_settings.ui.title.text() == "Plot Title from Code"
+
+    # 2) Set x_max
+    plot_base.x_max = 100
+    qtbot.wait(50)
+    assert axis_settings.ui.x_max.value() == 100
+
+    # 3) Set x_log
+    plot_base.x_log = True
+    qtbot.wait(50)
+    assert axis_settings.ui.x_log.checked is True
+
+
+def test_no_crash_no_target(qtbot):
+    """
+    AxisSettings can be created with target_widget=None. It won't update anything,
+    but it shouldn't crash on UI changes.
+    """
+    axis_settings = create_widget(qtbot, AxisSettings, parent=None, target_widget=None)
+
+    axis_settings.ui.title.setText("No target")
+    assert axis_settings.ui.title.text() == "No target"
+
+
+def test_scroll_area_behavior(axis_settings_fixture, qtbot):
+    """
+    Optional: Check that the QScrollArea is set up in a resizable manner.
+    """
+    axis_settings, plot_base = axis_settings_fixture
+    scroll_area = axis_settings.scroll_area
+    assert scroll_area.widgetResizable() is True