refactor: refactor device_manager_view

Note: The stylesheet is now set by qthemes, not the widget itself. As a result, the widget-specific stylesheet remains empty.

.github/workflows/pytest.yml

@@ -57,6 +57,14 @@ jobs:
         id: coverage
         run: pytest --random-order --cov=bec_widgets --cov-config=pyproject.toml --cov-branch --cov-report=xml --no-cov-on-fail tests/unit_tests/
 
+      - name: Upload test artifacts
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: image-references
+          path: bec_widgets/tests/reference_failures/
+          if-no-files-found: ignore
+
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v5
         with:

.github/workflows/stale-issues.yml

@@ -2,14 +2,10 @@ name: 'Close stale issues and PRs'
 on:
   schedule:
     - cron: '00 10 * * *'
-  workflow_dispatch:
 
 jobs:
   stale:
     runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
     steps:
       - uses: actions/stale@v9
         with:

CHANGELOG.md

@@ -1,46 +1,6 @@
 # CHANGELOG
 
 
-## v2.38.2 (2025-09-11)
-
-### Bug Fixes
-
-- **crosshair**: Ignore fetching data and markers from invisible items
-  ([`72b6f74`](https://github.com/bec-project/bec_widgets/commit/72b6f74252e1f36339945c549049b166cccf3561))
-
-- **plot_base**: Crosshair items are excluded from visible curves and from auto_range
-  ([`4dc4ede`](https://github.com/bec-project/bec_widgets/commit/4dc4ede1d251d081e5bcf3d37fcc784982c9258e))
-
-- **plot_base**: Visible items injected into plot item
-  ([`b703b37`](https://github.com/bec-project/bec_widgets/commit/b703b37bbdbf97182b58ac4c69c1384fa78d0c12))
-
-- **waveform**: Changing curve visibility refresh markers
-  ([`556832f`](https://github.com/bec-project/bec_widgets/commit/556832fd48bcb16b95df8cf91417d7045bbca2a3))
-
-### Continuous Integration
-
-- Fix stale issues job permissions; add workflow dispatch option
-  ([`fe67a4f`](https://github.com/bec-project/bec_widgets/commit/fe67a4f325cbd41f13102e5698d86ed9e90b048e))
-
-### Documentation
-
-- Move to autoapi
-  ([`18ef35f`](https://github.com/bec-project/bec_widgets/commit/18ef35f22a1b7496b13f833e63a4f3875e1497e3))
-
-### Testing
-
-- **crosshair**: Visibility test added with plotbase fixture
-  ([`3a2ec9f`](https://github.com/bec-project/bec_widgets/commit/3a2ec9f1b74c4bb5f239940b874576a877ce45c0))
-
-
-## v2.38.1 (2025-08-22)
-
-### Bug Fixes
-
-- Move thefuzz dependency to prod
-  ([`ad7cdc6`](https://github.com/bec-project/bec_widgets/commit/ad7cdc60dd6da6c5291f8b42932aacb12aa671a6))
-
-
 ## v2.38.0 (2025-08-19)
 
 ### Features

bec_widgets/__init__.py

@@ -1,4 +1,20 @@
+import os
+import sys
+
+import PySide6QtAds as QtAds
+
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 
+if sys.platform.startswith("linux"):
+    qt_platform = os.environ.get("QT_QPA_PLATFORM", "")
+    if qt_platform != "offscreen":
+        os.environ["QT_QPA_PLATFORM"] = "xcb"
+
+# Default QtAds configuration
+QtAds.CDockManager.setConfigFlag(QtAds.CDockManager.eConfigFlag.FocusHighlighting, True)
+QtAds.CDockManager.setConfigFlag(
+    QtAds.CDockManager.eConfigFlag.RetainTabSizeWhenCloseButtonHidden, True
+)
+
 __all__ = ["BECWidget", "SafeSlot", "SafeProperty"]

bec_widgets/cli/client.py

@@ -106,6 +106,99 @@ class AbortButton(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+
+class AdvancedDockArea(RPCBase):
+    @rpc_call
+    def new(
+        self,
+        widget: "BECWidget | str",
+        closable: "bool" = True,
+        floatable: "bool" = True,
+        movable: "bool" = True,
+        start_floating: "bool" = False,
+        where: "Literal['left', 'right', 'top', 'bottom'] | None" = None,
+    ) -> "BECWidget":
+        """
+        Create a new widget (or reuse an instance) and add it as a dock.
+
+        Args:
+            widget: Widget instance or a string widget type (factory-created).
+            closable: Whether the dock is closable.
+            floatable: Whether the dock is floatable.
+            movable: Whether the dock is movable.
+            start_floating: Start the dock in a floating state.
+            where: Preferred area to add the dock: "left" | "right" | "top" | "bottom".
+                   If None, uses the instance default passed at construction time.
+        Returns:
+            The widget instance.
+        """
+
+    @rpc_call
+    def widget_map(self) -> "dict[str, QWidget]":
+        """
+        Return a dictionary mapping widget names to their corresponding BECWidget instances.
+
+        Returns:
+            dict: A dictionary mapping widget names to BECWidget instances.
+        """
+
+    @rpc_call
+    def widget_list(self) -> "list[QWidget]":
+        """
+        Return a list of all BECWidget instances in the dock area.
+
+        Returns:
+            list: A list of all BECWidget instances in the dock area.
+        """
+
+    @property
+    @rpc_call
+    def lock_workspace(self) -> "bool":
+        """
+        Get or set the lock state of the workspace.
+
+        Returns:
+            bool: True if the workspace is locked, False otherwise.
+        """
+
+    @rpc_call
+    def attach_all(self):
+        """
+        Return all floating docks to the dock area, preserving tab groups within each floating container.
+        """
+
+    @rpc_call
+    def delete_all(self):
+        """
+        Delete all docks and widgets.
+        """
+
+    @property
+    @rpc_call
+    def mode(self) -> "str":
+        """
+        None
+        """
+
+    @mode.setter
+    @rpc_call
+    def mode(self) -> "str":
+        """
+        None
+        """
+
 
 class AutoUpdates(RPCBase):
     @property
@@ -442,6 +535,18 @@ class BECMainWindow(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
 
 class BECProgressBar(RPCBase):
     """A custom progress bar with smooth transitions. The displayed text can be customized using a template."""
@@ -525,6 +630,18 @@ class BECQueue(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
 
 class BECStatusBox(RPCBase):
     """An autonomous widget to display the status of BEC services."""
@@ -541,6 +658,25 @@ class BECStatusBox(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class BaseROI(RPCBase):
     """Base class for all Region of Interest (ROI) implementations."""
@@ -1002,6 +1138,18 @@ class DarkModeButton(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
 
 class DeviceBrowser(RPCBase):
     """DeviceBrowser is a widget that displays all available devices in the current BEC session."""
@@ -1012,6 +1160,18 @@ class DeviceBrowser(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
 
 class DeviceComboBox(RPCBase):
     """Combobox widget for device input with autocomplete for device names."""
@@ -1045,6 +1205,18 @@ class DeviceInputBase(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
 
 class DeviceLineEdit(RPCBase):
     """Line edit widget for device input with autocomplete for device names."""
@@ -1433,6 +1605,18 @@ class Heatmap(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
     @rpc_timeout(None)
     @rpc_call
     def screenshot(self, file_name: "str | None" = None):
@@ -1978,6 +2162,18 @@ class Image(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
     @rpc_timeout(None)
     @rpc_call
     def screenshot(self, file_name: "str | None" = None):
@@ -2590,6 +2786,25 @@ class MonacoWidget(RPCBase):
             str: The LSP header.
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class MotorMap(RPCBase):
     """Motor map widget for plotting motor positions in 2D including a trace of the last points."""
@@ -2865,6 +3080,18 @@ class MotorMap(RPCBase):
         The font size of the legend font.
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
     @rpc_timeout(None)
     @rpc_call
     def screenshot(self, file_name: "str | None" = None):
@@ -3277,6 +3504,18 @@ class MultiWaveform(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
     @rpc_timeout(None)
     @rpc_call
     def screenshot(self, file_name: "str | None" = None):
@@ -3498,6 +3737,18 @@ class PositionerBox(RPCBase):
             positioner (Positioner | str) : Positioner to set, accepts str or the device
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
     @rpc_timeout(None)
     @rpc_call
     def screenshot(self, file_name: "str | None" = None):
@@ -3527,6 +3778,18 @@ class PositionerBox2D(RPCBase):
             positioner (Positioner | str) : Positioner to set, accepts str or the device
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
     @rpc_timeout(None)
     @rpc_call
     def screenshot(self, file_name: "str | None" = None):
@@ -3547,6 +3810,18 @@ class PositionerControlLine(RPCBase):
             positioner (Positioner | str) : Positioner to set, accepts str or the device
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
     @rpc_timeout(None)
     @rpc_call
     def screenshot(self, file_name: "str | None" = None):
@@ -3566,6 +3841,25 @@ class PositionerGroup(RPCBase):
         Device names must be separated by space
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class RectangularROI(RPCBase):
     """Defines a rectangular Region of Interest (ROI) with additional functionality."""
@@ -3705,6 +3999,18 @@ class ResetButton(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
 
 class ResumeButton(RPCBase):
     """A button that continue scan queue."""
@@ -3715,6 +4021,18 @@ class ResumeButton(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
 
 class Ring(RPCBase):
     @rpc_call
@@ -3996,6 +4314,25 @@ class RingProgressBar(RPCBase):
             bool: True if scan segment updates are enabled.
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class SBBMonitor(RPCBase):
     """A widget to display the SBB monitor website."""
@@ -4007,9 +4344,15 @@ class ScanControl(RPCBase):
     """Widget to submit new scans to the queue."""
 
     @rpc_call
-    def remove(self):
+    def attach(self):
         """
-        Cleanup the BECConnector
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
         """
 
     @rpc_timeout(None)
@@ -4029,6 +4372,18 @@ class ScanProgressBar(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
 
 class ScatterCurve(RPCBase):
     """Scatter curve item for the scatter waveform widget."""
@@ -4327,6 +4682,18 @@ class ScatterWaveform(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
     @rpc_timeout(None)
     @rpc_call
     def screenshot(self, file_name: "str | None" = None):
@@ -4629,6 +4996,18 @@ class StopButton(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
 
 class TextBox(RPCBase):
     """A widget that displays text in plain and HTML format"""
@@ -4661,6 +5040,25 @@ class VSCodeEditor(RPCBase):
 class Waveform(RPCBase):
     """Widget for plotting waveforms."""
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def _config_dict(self) -> "dict":
@@ -4965,13 +5363,6 @@ class Waveform(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
-    @rpc_timeout(None)
-    @rpc_call
-    def screenshot(self, file_name: "str | None" = None):
-        """
-        Take a screenshot of the dock area and save it to a file.
-        """
-
     @property
     @rpc_call
     def curves(self) -> "list[Curve]":
@@ -5213,6 +5604,18 @@ class WebConsole(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
 
 class WebsiteWidget(RPCBase):
     """A simple widget to display a website"""
@@ -5252,3 +5655,22 @@ class WebsiteWidget(RPCBase):
         """
         Go forward in the history
         """
+
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """

bec_widgets/cli/server.py

@@ -7,8 +7,10 @@ import signal
 import sys
 from contextlib import redirect_stderr, redirect_stdout
 
+import darkdetect
 from bec_lib.logger import bec_logger
 from bec_lib.service_config import ServiceConfig
+from bec_qthemes import apply_theme
 from qtmonaco.pylsp_provider import pylsp_server
 from qtpy.QtCore import QSize, Qt
 from qtpy.QtGui import QIcon
@@ -92,6 +94,11 @@ class GUIServer:
         Run the GUI server.
         """
         self.app = QApplication(sys.argv)
+        if darkdetect.isDark():
+            apply_theme("dark")
+        else:
+            apply_theme("light")
+
         self.app.setApplicationName("BEC")
         self.app.gui_id = self.gui_id  # type: ignore
         self.setup_bec_icon()

bec_widgets/examples/bec_main_app/bec_main_app.py

@@ -0,0 +1,67 @@
+from qtpy import QtCore, QtWidgets
+
+from bec_widgets.examples.device_manager_view.device_manager_view import DeviceManagerView
+from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
+
+
+class BECMainApp(QtWidgets.QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        # Main layout
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        # Tab widget as central area
+        self.tabs = QtWidgets.QTabWidget(self)
+        self.tabs.setContentsMargins(0, 0, 0, 0)
+        self.tabs.setTabPosition(QtWidgets.QTabWidget.West)  # Tabs on the left side
+
+        layout.addWidget(self.tabs)
+        # Add DM
+        self._add_device_manager_view()
+
+        # Add Plot area
+        self._add_ad_dockarea()
+
+        # Adjust size of tab bar
+        # TODO not yet properly working, tabs a spread across the full length, to be checked!
+        tab_bar = self.tabs.tabBar()
+        tab_bar.setFixedWidth(tab_bar.sizeHint().width())
+
+    def _add_device_manager_view(self) -> None:
+        self.device_manager_view = DeviceManagerView(parent=self)
+        self.add_tab(self.device_manager_view, "Device Manager")
+
+    def _add_ad_dockarea(self) -> None:
+        self.advanced_dock_area = AdvancedDockArea(parent=self)
+        self.add_tab(self.advanced_dock_area, "Plot Area")
+
+    def add_tab(self, widget: QtWidgets.QWidget, title: str):
+        """Add a custom QWidget as a tab."""
+        tab_container = QtWidgets.QWidget()
+        tab_layout = QtWidgets.QVBoxLayout(tab_container)
+        tab_layout.setContentsMargins(0, 0, 0, 0)
+        tab_layout.setSpacing(0)
+
+        tab_layout.addWidget(widget)
+        self.tabs.addTab(tab_container, title)
+
+
+if __name__ == "__main__":
+    import sys
+
+    from bec_lib.bec_yaml_loader import yaml_load
+    from bec_qthemes import apply_theme
+
+    app = QtWidgets.QApplication(sys.argv)
+    apply_theme("light")
+    win = BECMainApp()
+    config_path = "/Users/appel_c/work_psi_awi/bec_workspace/csaxs_bec/csaxs_bec/device_configs/first_light.yaml"
+    cfg = yaml_load(config_path)
+    cfg.update({"device_will_fail": {"name": "device_will_fail", "some_param": 1}})
+    win.device_manager_view.device_table_view.set_device_config(cfg)
+    win.resize(1920, 1080)
+    win.show()
+    sys.exit(app.exec_())

bec_widgets/examples/device_manager_view/device_manager_view.py

@@ -0,0 +1,488 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, List
+
+import PySide6QtAds as QtAds
+import yaml
+from bec_lib.bec_yaml_loader import yaml_load
+from bec_lib.file_utils import DeviceConfigWriter
+from bec_lib.logger import bec_logger
+from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path
+from bec_qthemes import apply_theme
+from PySide6QtAds import CDockManager, CDockWidget
+from qtpy.QtCore import Qt, QTimer
+from qtpy.QtWidgets import QFileDialog, QMessageBox, QSplitter, QVBoxLayout, QWidget
+
+from bec_widgets import BECWidget
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.toolbars.actions import MaterialIconAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle
+from bec_widgets.utils.toolbars.toolbar import ModularToolBar
+from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
+from bec_widgets.widgets.control.device_manager.components import (
+    DeviceTableView,
+    DMConfigView,
+    DMOphydTest,
+    DocstringView,
+)
+
+if TYPE_CHECKING:
+    from bec_lib.client import BECClient
+
+logger = bec_logger.logger
+
+
+def set_splitter_weights(splitter: QSplitter, weights: List[float]) -> None:
+    """
+    Apply initial sizes to a splitter using weight ratios, e.g. [1,3,2,1].
+    Works for horizontal or vertical splitters and sets matching stretch factors.
+    """
+
+    def apply():
+        n = splitter.count()
+        if n == 0:
+            return
+        w = list(weights[:n]) + [1] * max(0, n - len(weights))
+        w = [max(0.0, float(x)) for x in w]
+        tot_w = sum(w)
+        if tot_w <= 0:
+            w = [1.0] * n
+            tot_w = float(n)
+        total_px = (
+            splitter.width() if splitter.orientation() == Qt.Horizontal else splitter.height()
+        )
+        if total_px < 2:
+            QTimer.singleShot(0, apply)
+            return
+        sizes = [max(1, int(total_px * (wi / tot_w))) for wi in w]
+        diff = total_px - sum(sizes)
+        if diff != 0:
+            idx = max(range(n), key=lambda i: w[i])
+            sizes[idx] = max(1, sizes[idx] + diff)
+        splitter.setSizes(sizes)
+        for i, wi in enumerate(w):
+            splitter.setStretchFactor(i, max(1, int(round(wi * 100))))
+
+    QTimer.singleShot(0, apply)
+
+
+class DeviceManagerView(BECWidget, QWidget):
+
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent=parent, client=None, *args, **kwargs)
+
+        # Top-level layout hosting a toolbar and the dock manager
+        self._root_layout = QVBoxLayout(self)
+        self._root_layout.setContentsMargins(0, 0, 0, 0)
+        self._root_layout.setSpacing(0)
+        self.dock_manager = CDockManager(self)
+        self._root_layout.addWidget(self.dock_manager)
+
+        # Available Resources Widget
+        self.available_devices = QWidget(self)
+        self.available_devices_dock = QtAds.CDockWidget("Available Devices", self)
+        self.available_devices_dock.setWidget(self.available_devices)
+
+        # Device Table View widget
+        self.device_table_view = DeviceTableView(self)
+        self.device_table_view_dock = QtAds.CDockWidget("Device Table", self)
+        self.device_table_view_dock.setWidget(self.device_table_view)
+
+        # Device Config View widget
+        self.dm_config_view = DMConfigView(self)
+        self.dm_config_view_dock = QtAds.CDockWidget("Device Config View", self)
+        self.dm_config_view_dock.setWidget(self.dm_config_view)
+
+        # Docstring View
+        self.dm_docs_view = DocstringView(self)
+        self.dm_docs_view_dock = QtAds.CDockWidget("Docstring View", self)
+        self.dm_docs_view_dock.setWidget(self.dm_docs_view)
+
+        # Ophyd Test view
+        self.ophyd_test_view = DMOphydTest(self)
+        self.ophyd_test_dock_view = QtAds.CDockWidget("Ophyd Test View", self)
+        self.ophyd_test_dock_view.setWidget(self.ophyd_test_view)
+
+        # Arrange widgets within the QtAds dock manager
+
+        # Central widget area
+        self.central_dock_area = self.dock_manager.setCentralWidget(self.device_table_view_dock)
+        self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.BottomDockWidgetArea,
+            self.dm_docs_view_dock,
+            self.central_dock_area,
+        )
+
+        # Left Area
+        self.left_dock_area = self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.LeftDockWidgetArea, self.available_devices_dock
+        )
+        self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.BottomDockWidgetArea, self.dm_config_view_dock, self.left_dock_area
+        )
+
+        # Right area
+        self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.RightDockWidgetArea, self.ophyd_test_dock_view
+        )
+
+        for dock in self.dock_manager.dockWidgets():
+            # dock.setFeature(CDockWidget.DockWidgetDeleteOnClose, True)#TODO implement according to MonacoDock or AdvancedDockArea
+            # dock.setFeature(CDockWidget.CustomCloseHandling, True) #TODO same
+            dock.setFeature(CDockWidget.DockWidgetClosable, False)
+            dock.setFeature(CDockWidget.DockWidgetFloatable, False)
+            dock.setFeature(CDockWidget.DockWidgetMovable, False)
+
+        # Fetch all dock areas of the dock widgets (on our case always one dock area)
+        for dock in self.dock_manager.dockWidgets():
+            area = dock.dockAreaWidget()
+            area.titleBar().setVisible(False)
+
+        # Apply stretch after the layout is done
+        self.set_default_view([2, 8, 2], [3, 1])
+        # self.set_default_view([2, 8, 2], [2, 2, 4])
+
+        # Connect slots
+        self.device_table_view.selected_device.connect(self.dm_config_view.on_select_config)
+        self.device_table_view.selected_device.connect(self.dm_docs_view.on_select_config)
+        self.ophyd_test_view.device_validated.connect(
+            self.device_table_view.update_device_validation
+        )
+        self.device_table_view.device_configs_added.connect(self.ophyd_test_view.add_device_configs)
+
+        self._add_toolbar()
+
+    def _add_toolbar(self):
+        self.toolbar = ModularToolBar(self)
+
+        # Add IO actions
+        self._add_io_actions()
+        self._add_table_actions()
+        self.toolbar.show_bundles(["IO", "Table"])
+        self._root_layout.insertWidget(0, self.toolbar)
+
+    def _add_io_actions(self):
+        # Create IO bundle
+        io_bundle = ToolbarBundle("IO", self.toolbar.components)
+
+        # Add load config from plugin dir
+        self.toolbar.add_bundle(io_bundle)
+
+        load = MaterialIconAction(
+            icon_name="file_open", parent=self, tooltip="Load configuration file from disk"
+        )
+        self.toolbar.components.add_safe("load", load)
+        load.action.triggered.connect(self._load_file_action)
+        io_bundle.add_action("load")
+
+        # Add safe to disk
+        safe_to_disk = MaterialIconAction(
+            icon_name="file_save", parent=self, tooltip="Save config to disk"
+        )
+        self.toolbar.components.add_safe("safe_to_disk", safe_to_disk)
+        safe_to_disk.action.triggered.connect(self._safe_to_disk_action)
+        io_bundle.add_action("safe_to_disk")
+
+        # Add load config from redis
+        load_redis = MaterialIconAction(
+            icon_name="cached", parent=self, tooltip="Load current config from Redis"
+        )
+        load_redis.action.triggered.connect(self._load_redis_action)
+        self.toolbar.components.add_safe("load_redis", load_redis)
+        io_bundle.add_action("load_redis")
+
+        # Update config action
+        update_config_redis = MaterialIconAction(
+            icon_name="cloud_upload", parent=self, tooltip="Update current config in Redis"
+        )
+        update_config_redis.action.triggered.connect(self._update_redis_action)
+        self.toolbar.components.add_safe("update_config_redis", update_config_redis)
+        io_bundle.add_action("update_config_redis")
+
+    # Table actions
+
+    def _add_table_actions(self) -> None:
+        table_bundle = ToolbarBundle("Table", self.toolbar.components)
+
+        # Add load config from plugin dir
+        self.toolbar.add_bundle(table_bundle)
+
+        # Reset composed view
+        reset_composed = MaterialIconAction(
+            icon_name="delete_sweep", parent=self, tooltip="Reset current composed config view"
+        )
+        reset_composed.action.triggered.connect(self._reset_composed_view)
+        self.toolbar.components.add_safe("reset_composed", reset_composed)
+        table_bundle.add_action("reset_composed")
+
+        # Add device
+        add_device = MaterialIconAction(icon_name="add", parent=self, tooltip="Add new device")
+        add_device.action.triggered.connect(self._add_device_action)
+        self.toolbar.components.add_safe("add_device", add_device)
+        table_bundle.add_action("add_device")
+
+        # Remove device
+        remove_device = MaterialIconAction(icon_name="remove", parent=self, tooltip="Remove device")
+        remove_device.action.triggered.connect(self._remove_device_action)
+        self.toolbar.components.add_safe("remove_device", remove_device)
+        table_bundle.add_action("remove_device")
+
+        # Rerun validation
+        rerun_validation = MaterialIconAction(
+            icon_name="checklist", parent=self, tooltip="Run device validation on selected devices"
+        )
+        rerun_validation.action.triggered.connect(self._rerun_validation_action)
+        self.toolbar.components.add_safe("rerun_validation", rerun_validation)
+        table_bundle.add_action("rerun_validation")
+
+        # Most likly, no actions on available devices
+        # Actions (vielleicht bundle fuer available devices )
+        # - reset composed view
+        # - add new device (EpicsMotor, EpicsMotorECMC, EpicsSignal, CustomDevice)
+        # - remove device
+        # - rerun validation (with/without connect)
+
+    # IO actions
+
+    @SafeSlot()
+    def _load_file_action(self):
+        """Action for the 'load' action to load a config from disk for the io_bundle of the toolbar."""
+        # Check if plugin repo is installed...
+        try:
+            plugin_path = plugin_repo_path()
+            plugin_name = plugin_package_name()
+            config_path = os.path.join(plugin_path, plugin_name, "device_configs")
+        except ValueError:
+            # Get the recovery config path as fallback
+            config_path = self._get_recovery_config_path()
+            logger.warning(
+                f"No plugin repository installed, fallback to recovery config path: {config_path}"
+            )
+
+        # Implement the file loading logic here
+        start_dir = os.path.abspath(config_path)
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, caption="Select Config File", dir=start_dir
+        )
+        if file_path:
+            try:
+                config = yaml_load(file_path)
+            except Exception as e:
+                logger.error(f"Failed to load config from file {file_path}. Error: {e}")
+                return
+            self.device_table_view.set_device_config(
+                config
+            )  # TODO ADD QDialog with 'replace', 'add' & 'cancel'
+
+    # TODO would we ever like to add the current config to an existing composition
+    @SafeSlot()
+    def _load_redis_action(self):
+        """Action for the 'load_redis' action to load the current config from Redis for the io_bundle of the toolbar."""
+        reply = QMessageBox.question(
+            self,
+            "Load currently active config",
+            "Do you really want to flush the current config and reload?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No,
+        )
+        if reply == QMessageBox.Yes:
+            cfg = {}
+            config_list = self.client.device_manager._get_redis_device_config()
+            for item in config_list:
+                k = item["name"]
+                item.pop("name")
+                cfg[k] = item
+            self.device_table_view.set_device_config(cfg)
+        else:
+            return
+
+    @SafeSlot()
+    def _safe_to_disk_action(self):
+        """Action for the 'safe_to_disk' action to save the current config to disk."""
+        # Check if plugin repo is installed...
+        try:
+            config_path = self._get_recovery_config_path()
+        except ValueError:
+            # Get the recovery config path as fallback
+            config_path = os.path.abspath(os.path.expanduser("~"))
+            logger.warning(f"Failed to find recovery config path, fallback to: {config_path}")
+
+        # Implement the file loading logic here
+        file_path, _ = QFileDialog.getSaveFileName(
+            self, caption="Save Config File", dir=config_path
+        )
+        if file_path:
+            config = self.device_table_view.get_device_config()
+            with open(file_path, "w") as file:
+                file.write(yaml.dump(config))
+
+    # TODO add here logic, should be asyncronous, but probably block UI, and show a loading spinner. If failed, it should report..
+    @SafeSlot()
+    def _update_redis_action(self):
+        """Action for the 'update_redis' action to update the current config in Redis."""
+        config = self.device_table_view.get_device_config()
+        reply = QMessageBox.question(
+            self,
+            "Not implemented yet",
+            "This feature has not been implemented yet, will be coming soon...!!",
+            QMessageBox.Cancel,
+            QMessageBox.Cancel,
+        )
+
+    # Table actions
+
+    @SafeSlot()
+    def _reset_composed_view(self):
+        """Action for the 'reset_composed_view' action to reset the composed view."""
+        reply = QMessageBox.question(
+            self,
+            "Clear View",
+            "You are about to clear the current composed config view, please confirm...",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No,
+        )
+        if reply == QMessageBox.Yes:
+            self.device_table_view.clear_device_configs()
+
+    # TODO Here we would like to implement a custom popup view, that allows to add new devices
+    # We want to have a combobox to choose from EpicsMotor, EpicsMotorECMC, EpicsSignal, EpicsSignalRO, and maybe EpicsSignalWithRBV and custom Device
+    # For all default Epics devices, we would like to preselect relevant fields, and prompt them with the proper deviceConfig args already, i.e. 'prefix', 'read_pv', 'write_pv' etc..
+    # For custom Device, they should receive all options. It might be cool to get a side panel with docstring view of the class upon inspecting it to make it easier in case deviceConfig entries are required..
+    @SafeSlot()
+    def _add_device_action(self):
+        """Action for the 'add_device' action to add a new device."""
+        # Implement the logic to add a new device
+        reply = QMessageBox.question(
+            self,
+            "Not implemented yet",
+            "This feature has not been implemented yet, will be coming soon...!!",
+            QMessageBox.Cancel,
+            QMessageBox.Cancel,
+        )
+
+    # TODO fix the device table remove actions. This is currently not working properly...
+    @SafeSlot()
+    def _remove_device_action(self):
+        """Action for the 'remove_device' action to remove a device."""
+        reply = QMessageBox.question(
+            self,
+            "Not implemented yet",
+            "This feature has not been implemented yet, will be coming soon...!!",
+            QMessageBox.Cancel,
+            QMessageBox.Cancel,
+        )
+
+    # TODO implement proper logic for validation. We should also carefully review how these jobs update the table, and how we can cancel pending validations
+    # in case they are no longer relevant. We might want to 'block' the interactivity on the items for which validation runs with 'connect'!
+    @SafeSlot()
+    def _rerun_validation_action(self):
+        """Action for the 'rerun_validation' action to rerun validation on selected devices."""
+        # Implement the logic to rerun validation on selected devices
+        reply = QMessageBox.question(
+            self,
+            "Not implemented yet",
+            "This feature has not been implemented yet, will be coming soon...!!",
+            QMessageBox.Cancel,
+            QMessageBox.Cancel,
+        )
+
+    ####### Default view has to be done with setting up splitters ########
+    def set_default_view(self, horizontal_weights: list, vertical_weights: list):
+        """Apply initial weights to every horizontal and vertical splitter.
+
+        Examples:
+            horizontal_weights = [1, 3, 2, 1]
+            vertical_weights   = [3, 7]  # top:bottom = 30:70
+        """
+        splitters_h = []
+        splitters_v = []
+        for splitter in self.findChildren(QSplitter):
+            if splitter.orientation() == Qt.Horizontal:
+                splitters_h.append(splitter)
+            elif splitter.orientation() == Qt.Vertical:
+                splitters_v.append(splitter)
+
+        def apply_all():
+            for s in splitters_h:
+                set_splitter_weights(s, horizontal_weights)
+            for s in splitters_v:
+                set_splitter_weights(s, vertical_weights)
+
+        QTimer.singleShot(0, apply_all)
+
+    def set_stretch(self, *, horizontal=None, vertical=None):
+        """Update splitter weights and re-apply to all splitters.
+
+        Accepts either a list/tuple of weights (e.g., [1,3,2,1]) or a role dict
+        for convenience: horizontal roles = {"left","center","right"},
+        vertical roles = {"top","bottom"}.
+        """
+
+        def _coerce_h(x):
+            if x is None:
+                return None
+            if isinstance(x, (list, tuple)):
+                return list(map(float, x))
+            if isinstance(x, dict):
+                return [
+                    float(x.get("left", 1)),
+                    float(x.get("center", x.get("middle", 1))),
+                    float(x.get("right", 1)),
+                ]
+            return None
+
+        def _coerce_v(x):
+            if x is None:
+                return None
+            if isinstance(x, (list, tuple)):
+                return list(map(float, x))
+            if isinstance(x, dict):
+                return [float(x.get("top", 1)), float(x.get("bottom", 1))]
+            return None
+
+        h = _coerce_h(horizontal)
+        v = _coerce_v(vertical)
+        if h is None:
+            h = [1, 1, 1]
+        if v is None:
+            v = [1, 1]
+        self.set_default_view(h, v)
+
+    def _get_recovery_config_path(self) -> str:
+        """Get the recovery config path from the log_writer config."""
+        # pylint: disable=protected-access
+        log_writer_config: BECClient = self.client._service_config.config.get("log_writer", {})
+        writer = DeviceConfigWriter(service_config=log_writer_config)
+        return os.path.abspath(os.path.expanduser(writer.get_recovery_directory()))
+
+
+if __name__ == "__main__":
+    import sys
+    from copy import deepcopy
+
+    from bec_lib.bec_yaml_loader import yaml_load
+    from qtpy.QtWidgets import QApplication
+
+    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
+    app = QApplication(sys.argv)
+    w = QWidget()
+    l = QVBoxLayout()
+    w.setLayout(l)
+    apply_theme("dark")
+    button = DarkModeButton()
+    l.addWidget(button)
+    device_manager_view = DeviceManagerView()
+    l.addWidget(device_manager_view)
+    # config_path = "/Users/appel_c/work_psi_awi/bec_workspace/csaxs_bec/csaxs_bec/device_configs/first_light.yaml"
+    # cfg = yaml_load(config_path)
+    # cfg.update({"device_will_fail": {"name": "device_will_fail", "some_param": 1}})
+
+    # # config = device_manager_view.client.device_manager._get_redis_device_config()
+    # device_manager_view.device_table_view.set_device_config(cfg)
+    w.show()
+    w.setWindowTitle("Device Manager View")
+    w.resize(1920, 1080)
+    # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime
+    sys.exit(app.exec_())

bec_widgets/examples/device_manager_view/device_manager_widget.py

@@ -0,0 +1,110 @@
+"""Top Level wrapper for device_manager widget"""
+
+from __future__ import annotations
+
+import os
+
+from bec_lib.bec_yaml_loader import yaml_load
+from bec_lib.logger import bec_logger
+from bec_qthemes import material_icon
+from qtpy import QtCore, QtWidgets
+
+from bec_widgets.examples.device_manager_view.device_manager_view import DeviceManagerView
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeSlot
+
+logger = bec_logger.logger
+
+
+class DeviceManagerWidget(BECWidget, QtWidgets.QWidget):
+
+    def __init__(self, parent=None, client=None):
+        super().__init__(client=client, parent=parent)
+        self.stacked_layout = QtWidgets.QStackedLayout()
+        self.stacked_layout.setContentsMargins(0, 0, 0, 0)
+        self.stacked_layout.setSpacing(0)
+        self.stacked_layout.setStackingMode(QtWidgets.QStackedLayout.StackAll)
+        self.setLayout(self.stacked_layout)
+
+        # Add device manager view
+        self.device_manager_view = DeviceManagerView()
+        self.stacked_layout.addWidget(self.device_manager_view)
+
+        # Add overlay widget
+        self._overlay_widget = QtWidgets.QWidget(self)
+        self._customize_overlay()
+        self.stacked_layout.addWidget(self._overlay_widget)
+        self.stacked_layout.setCurrentWidget(self._overlay_widget)
+
+    def _customize_overlay(self):
+        self._overlay_widget.setStyleSheet(
+            "background: qlineargradient(x1:0, y1:0, x2:0, y2:1,stop:0 #ffffff, stop:1 #e0e0e0);"
+        )
+        self._overlay_widget.setAutoFillBackground(True)
+        self._overlay_layout = QtWidgets.QVBoxLayout()
+        self._overlay_layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self._overlay_widget.setLayout(self._overlay_layout)
+        self._overlay_widget.setSizePolicy(
+            QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Expanding
+        )
+        # Load current config
+        self.button_load_current_config = QtWidgets.QPushButton("Load Current Config")
+        icon = material_icon(icon_name="database", size=(24, 24), convert_to_pixmap=False)
+        self.button_load_current_config.setIcon(icon)
+        self._overlay_layout.addWidget(self.button_load_current_config)
+        self.button_load_current_config.clicked.connect(self._load_config_clicked)
+        # Load config from disk
+        self.button_load_config_from_file = QtWidgets.QPushButton("Load Config From File")
+        icon = material_icon(icon_name="folder", size=(24, 24), convert_to_pixmap=False)
+        self.button_load_config_from_file.setIcon(icon)
+        self._overlay_layout.addWidget(self.button_load_config_from_file)
+        self.button_load_config_from_file.clicked.connect(self._load_config_from_file_clicked)
+        self._overlay_widget.setVisible(True)
+
+    def _load_config_from_file_clicked(self):
+        """Handle click on 'Load Config From File' button."""
+        start_dir = os.path.expanduser("~")
+        file_path, _ = QtWidgets.QFileDialog.getOpenFileName(
+            self, caption="Select Config File", dir=start_dir
+        )
+        if file_path:
+            self._load_config_from_file(file_path)
+
+    def _load_config_from_file(self, file_path: str):
+        try:
+            config = yaml_load(file_path)
+        except Exception as e:
+            logger.error(f"Failed to load config from file {file_path}. Error: {e}")
+            return
+        config_list = []
+        for name, cfg in config.items():
+            config_list.append(cfg)
+            config_list[-1]["name"] = name
+        self.device_manager_view.device_table_view.set_device_config(config_list)
+        # self.device_manager_view.ophyd_test.on_device_config_update(config)
+        self.stacked_layout.setCurrentWidget(self.device_manager_view)
+
+    @SafeSlot()
+    def _load_config_clicked(self):
+        """Handle click on 'Load Current Config' button."""
+        config = self.client.device_manager._get_redis_device_config()
+        config.append({"name": "wrong_device", "some_value": 1})
+        self.device_manager_view.device_table_view.set_device_config(config)
+        # self.device_manager_view.ophyd_test.on_device_config_update(config)
+        self.stacked_layout.setCurrentWidget(self.device_manager_view)
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    device_manager = DeviceManagerWidget()
+    # config = device_manager.client.device_manager._get_redis_device_config()
+    # device_manager.device_table_view.set_device_config(config)
+    device_manager.show()
+    device_manager.setWindowTitle("Device Manager View")
+    device_manager.resize(1600, 1200)
+    # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime
+    sys.exit(app.exec_())

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -15,7 +15,9 @@ from qtpy.QtWidgets import (
 )
 
 from bec_widgets.utils import BECDispatcher
+from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.widget_io import WidgetHierarchy as wh
+from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
 from bec_widgets.widgets.containers.dock import BECDockArea
 from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
 from bec_widgets.widgets.editors.jupyter_console.jupyter_console import BECJupyterConsole
@@ -44,6 +46,7 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     "wh": wh,
                     "dock": self.dock,
                     "im": self.im,
+                    "ads": self.ads,
                     # "mi": self.mi,
                     # "mm": self.mm,
                     # "lm": self.lm,
@@ -120,14 +123,12 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         tab_widget.addTab(sixth_tab, "Image Next Gen")
         tab_widget.setCurrentIndex(1)
         #
-        # seventh_tab = QWidget()
-        # seventh_tab_layout = QVBoxLayout(seventh_tab)
-        # self.scatter = ScatterWaveform()
-        # self.scatter_mi = self.scatter.main_curve
-        # self.scatter.plot("samx", "samy", "bpm4i")
-        # seventh_tab_layout.addWidget(self.scatter)
-        # tab_widget.addTab(seventh_tab, "Scatter Waveform")
-        # tab_widget.setCurrentIndex(6)
+        seventh_tab = QWidget()
+        seventh_tab_layout = QVBoxLayout(seventh_tab)
+        self.ads = AdvancedDockArea(gui_id="ads")
+        seventh_tab_layout.addWidget(self.ads)
+        tab_widget.addTab(seventh_tab, "ADS")
+        tab_widget.setCurrentIndex(2)
         #
         # eighth_tab = QWidget()
         # eighth_tab_layout = QVBoxLayout(eighth_tab)
@@ -169,6 +170,7 @@ if __name__ == "__main__":  # pragma: no cover
     module_path = os.path.dirname(bec_widgets.__file__)
 
     app = QApplication(sys.argv)
+    apply_theme("dark")
     app.setApplicationName("Jupyter Console")
     app.setApplicationDisplayName("Jupyter Console")
     icon = material_icon("terminal", color=(255, 255, 255, 255), filled=True)

bec_widgets/utils/bec_connector.py

@@ -77,6 +77,8 @@ class BECConnector:
 
     USER_ACCESS = ["_config_dict", "_get_all_rpc", "_rpc_id"]
     EXIT_HANDLERS = {}
+    widget_removed = Signal()
+    name_established = Signal(str)
 
     def __init__(
         self,
@@ -204,6 +206,10 @@ class BECConnector:
         self._enforce_unique_sibling_name()
         # 2) Register the object for RPC
         self.rpc_register.add_rpc(self)
+        try:
+            self.name_established.emit(self.object_name)
+        except RuntimeError:
+            return
 
     def _enforce_unique_sibling_name(self):
         """
@@ -450,6 +456,7 @@ class BECConnector:
         # i.e. Curve Item from Waveform
         else:
             self.rpc_register.remove_rpc(self)
+        self.widget_removed.emit()  # Emit the remove signal to notify listeners (eg docks in QtADS)
 
     def get_config(self, dict_output: bool = True) -> dict | BaseModel:
         """

bec_widgets/utils/bec_widget.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from datetime import datetime
 from typing import TYPE_CHECKING
 
-import darkdetect
+import PySide6QtAds as QtAds
 import shiboken6
 from bec_lib.logger import bec_logger
 from qtpy.QtCore import QObject
@@ -11,9 +11,9 @@ from qtpy.QtWidgets import QApplication, QFileDialog, QWidget
 
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
-from bec_widgets.utils.colors import set_theme
-from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.error_popups import SafeConnect, SafeSlot
 from bec_widgets.utils.rpc_decorator import rpc_timeout
+from bec_widgets.utils.widget_io import WidgetHierarchy
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_widgets.widgets.containers.dock import BECDock
@@ -27,7 +27,7 @@ class BECWidget(BECConnector):
     # The icon name is the name of the icon in the icon theme, typically a name taken
     # from fonts.google.com/icons. Override this in subclasses to set the icon name.
     ICON_NAME = "widgets"
-    USER_ACCESS = ["remove"]
+    USER_ACCESS = ["remove", "attach", "detach"]
 
     # pylint: disable=too-many-arguments
     def __init__(
@@ -45,8 +45,7 @@ class BECWidget(BECConnector):
 
         >>> class MyWidget(BECWidget, QWidget):
         >>>     def __init__(self, parent=None, client=None, config=None, gui_id=None):
-        >>>         super().__init__(client=client, config=config, gui_id=gui_id)
-        >>>         QWidget.__init__(self, parent=parent)
+        >>>         super().__init__(parent=parent, client=client, config=config, gui_id=gui_id)
 
 
         Args:
@@ -62,15 +61,6 @@ class BECWidget(BECConnector):
         )
         if not isinstance(self, QObject):
             raise RuntimeError(f"{repr(self)} is not a subclass of QWidget")
-        app = QApplication.instance()
-        if not hasattr(app, "theme"):
-            # DO NOT SET THE THEME TO AUTO! Otherwise, the qwebengineview will segfault
-            # Instead, we will set the theme to the system setting on startup
-            if darkdetect.isDark():
-                set_theme("dark")
-            else:
-                set_theme("light")
-
         if theme_update:
             logger.debug(f"Subscribing to theme updates for {self.__class__.__name__}")
             self._connect_to_theme_change()
@@ -78,9 +68,11 @@ class BECWidget(BECConnector):
     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._update_theme)
+        if hasattr(qapp, "theme"):
+            SafeConnect(self, qapp.theme.theme_changed, self._update_theme)
 
+    @SafeSlot(str)
+    @SafeSlot()
     def _update_theme(self, theme: str | None = None):
         """Update the theme."""
         if theme is None:
@@ -124,6 +116,26 @@ class BECWidget(BECConnector):
         screenshot.save(file_name)
         logger.info(f"Screenshot saved to {file_name}")
 
+    def attach(self):
+        dock = WidgetHierarchy.find_ancestor(self, QtAds.CDockWidget)
+        if dock is None:
+            return
+
+        if not dock.isFloating():
+            return
+        dock.dockManager().addDockWidget(QtAds.DockWidgetArea.RightDockWidgetArea, dock)
+
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+        dock = WidgetHierarchy.find_ancestor(self, QtAds.CDockWidget)
+        if dock is None:
+            return
+        if dock.isFloating():
+            return
+        dock.setFloating()
+
     def cleanup(self):
         """Cleanup the widget."""
         with RPCRegister.delayed_broadcast():

bec_widgets/utils/colors.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import re
 from typing import TYPE_CHECKING, Literal
 
-import bec_qthemes
 import numpy as np
 import pyqtgraph as pg
-from bec_qthemes._os_appearance.listener import OSThemeSwitchListener
+from bec_qthemes import apply_theme as apply_theme_global
 from pydantic_core import PydanticCustomError
+from qtpy.QtCore import QEvent, QEventLoop
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QApplication
 
@@ -23,7 +23,10 @@ def get_theme_name():
 
 
 def get_theme_palette():
-    return bec_qthemes.load_palette(get_theme_name())
+    # FIXME this is legacy code, should be removed in the future
+    app = QApplication.instance()
+    palette = app.palette()
+    return palette
 
 
 def get_accent_colors() -> AccentColors | None:
@@ -36,105 +39,18 @@ def get_accent_colors() -> AccentColors | None:
     return QApplication.instance().theme.accent_colors
 
 
-def _theme_update_callback():
-    """
-    Internal callback function to update the theme based on the system theme.
-    """
-    app = QApplication.instance()
-    # pylint: disable=protected-access
-    app.theme.theme = app.os_listener._theme.lower()
-    app.theme_signal.theme_updated.emit(app.theme.theme)
-    apply_theme(app.os_listener._theme.lower())
-
-
-def set_theme(theme: Literal["dark", "light", "auto"]):
-    """
-    Set the theme for the application.
-
-    Args:
-        theme (Literal["dark", "light", "auto"]): The theme to set. "auto" will automatically switch between dark and light themes based on the system theme.
-    """
-    app = QApplication.instance()
-    bec_qthemes.setup_theme(theme, install_event_filter=False)
-
-    app.theme_signal.theme_updated.emit(theme)
-    apply_theme(theme)
-
-    if theme != "auto":
-        return
-
-    if not hasattr(app, "os_listener") or app.os_listener is None:
-        app.os_listener = OSThemeSwitchListener(_theme_update_callback)
-        app.installEventFilter(app.os_listener)
+def process_all_deferred_deletes(qapp):
+    qapp.sendPostedEvents(None, QEvent.DeferredDelete)
+    qapp.processEvents(QEventLoop.AllEvents)
 
 
 def apply_theme(theme: Literal["dark", "light"]):
     """
-    Apply the theme to all pyqtgraph widgets. Do not use this function directly. Use set_theme instead.
+    Apply the theme via the global theming API. This updates QSS, QPalette, and pyqtgraph globally.
     """
-    app = QApplication.instance()
-    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)
-    app.setStyleSheet(style)
+    process_all_deferred_deletes(QApplication.instance())
+    apply_theme_global(theme)
+    process_all_deferred_deletes(QApplication.instance())
 
 
 class Colors:

bec_widgets/utils/compact_popup.py

@@ -11,6 +11,7 @@ from qtpy.QtWidgets import (
     QPushButton,
     QSizePolicy,
     QSpacerItem,
+    QToolButton,
     QVBoxLayout,
     QWidget,
 )
@@ -122,15 +123,14 @@ class CompactPopupWidget(QWidget):
         self.compact_view_widget = QWidget(self)
         self.compact_view_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
         QHBoxLayout(self.compact_view_widget)
-        self.compact_view_widget.layout().setSpacing(0)
+        self.compact_view_widget.layout().setSpacing(5)
         self.compact_view_widget.layout().setContentsMargins(0, 0, 0, 0)
         self.compact_view_widget.layout().addSpacerItem(
             QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Fixed)
         )
         self.compact_label = QLabel(self.compact_view_widget)
         self.compact_status = LedLabel(self.compact_view_widget)
-        self.compact_show_popup = QPushButton(self.compact_view_widget)
-        self.compact_show_popup.setFlat(True)
+        self.compact_show_popup = QToolButton(self.compact_view_widget)
         self.compact_show_popup.setIcon(
             material_icon(icon_name="expand_content", size=(10, 10), convert_to_pixmap=False)
         )

bec_widgets/utils/crosshair.py

@@ -209,11 +209,8 @@ class Crosshair(QObject):
         if self.highlighted_curve_index is not None and hasattr(self.plot_item, "visible_curves"):
             # Focus on the highlighted curve only
             self.items = [self.plot_item.visible_curves[self.highlighted_curve_index]]
-        elif hasattr(self.plot_item, "visible_items"):  # PlotBase general case
-            # Handle visible items in the plot item
-            self.items = self.plot_item.visible_items()
-        else:  # Non PlotBase case
-            # Handle all items
+        else:
+            # Handle all curves
             self.items = self.plot_item.items
 
         # Create or update markers

bec_widgets/utils/error_popups.py

@@ -2,7 +2,9 @@ import functools
 import sys
 import traceback
 
+import shiboken6
 from bec_lib.logger import bec_logger
+from louie.saferef import safe_ref
 from qtpy.QtCore import Property, QObject, Qt, Signal, Slot
 from qtpy.QtWidgets import QApplication, QMessageBox, QPushButton, QVBoxLayout, QWidget
 
@@ -90,6 +92,52 @@ def SafeProperty(prop_type, *prop_args, popup_error: bool = False, default=None,
     return decorator
 
 
+def _safe_connect_slot(weak_instance, weak_slot, *connect_args):
+    """Internal function used by SafeConnect to handle weak references to slots."""
+    instance = weak_instance()
+    slot_func = weak_slot()
+
+    # Check if the python object has already been garbage collected
+    if instance is None or slot_func is None:
+        return
+
+    # Check if the python object has already been marked for deletion
+    if getattr(instance, "_destroyed", False):
+        return
+
+    # Check if the C++ object is still valid
+    if not shiboken6.isValid(instance):
+        return
+
+    if connect_args:
+        slot_func(*connect_args)
+    slot_func()
+
+
+def SafeConnect(instance, signal, slot):  # pylint: disable=invalid-name
+    """
+    Method to safely handle Qt signal-slot connections. The python object is only forwarded
+    as a weak reference to avoid stale objects.
+
+    Args:
+        instance: The instance to connect.
+        signal: The signal to connect to.
+        slot: The slot to connect.
+
+    Example:
+        >>> SafeConnect(self, qapp.theme.theme_changed, self._update_theme)
+
+    """
+    weak_instance = safe_ref(instance)
+    weak_slot = safe_ref(slot)
+
+    # Create a partial function that will check weak references before calling the actual slot
+    safe_slot = functools.partial(_safe_connect_slot, weak_instance, weak_slot)
+
+    # Connect the signal to the safe connect slot wrapper
+    return signal.connect(safe_slot)
+
+
 def SafeSlot(*slot_args, **slot_kwargs):  # pylint: disable=invalid-name
     """Function with args, acting like a decorator, applying "error_managed" decorator + Qt Slot
     to the passed function, to display errors instead of potentially raising an exception

bec_widgets/utils/round_frame.py

@@ -1,11 +1,12 @@
 import pyqtgraph as pg
-from qtpy.QtCore import Property
+from qtpy.QtCore import Property, Qt
 from qtpy.QtWidgets import QApplication, QFrame, QHBoxLayout, QVBoxLayout, QWidget
 
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
 
 class RoundedFrame(QFrame):
+    # TODO this should be removed completely in favor of QSS styling, no time now
     """
     A custom QFrame with rounded corners and optional theme updates.
     The frame can contain any QWidget, however it is mainly designed to wrap PlotWidgets to provide a consistent look and feel with other BEC Widgets.
@@ -28,6 +29,9 @@ class RoundedFrame(QFrame):
         self.setProperty("skip_settings", True)
         self.setObjectName("roundedFrame")
 
+        # Ensure QSS can paint background/border on this widget
+        self.setAttribute(Qt.WA_StyledBackground, True)
+
         # Create a layout for the frame
         if orientation == "vertical":
             self.layout = QVBoxLayout(self)
@@ -45,22 +49,10 @@ class RoundedFrame(QFrame):
 
         # Automatically apply initial styles to the GraphicalLayoutWidget if applicable
         self.apply_plot_widget_style()
+        self.update_style()
 
     def apply_theme(self, theme: str):
-        """
-        Apply the theme to the frame and its content if theme updates are enabled.
-        """
-        if self.content_widget is not None and isinstance(
-            self.content_widget, pg.GraphicsLayoutWidget
-        ):
-            self.content_widget.setBackground(self.background_color)
-
-        # Update background color based on the theme
-        if theme == "light":
-            self.background_color = "#e9ecef"  # Subtle contrast for light mode
-        else:
-            self.background_color = "#141414"  # Dark mode
-
+        """Deprecated: RoundedFrame no longer handles theme; styling is QSS-driven."""
         self.update_style()
 
     @Property(int)
@@ -77,34 +69,21 @@ class RoundedFrame(QFrame):
         """
         Update the style of the frame based on the background color.
         """
-        if self.background_color:
-            self.setStyleSheet(
-                f"""
+        self.setStyleSheet(
+            f"""
                 QFrame#roundedFrame {{
-                    background-color: {self.background_color}; 
-                    border-radius: {self._radius}; /* Rounded corners */
+                    border-radius: {self._radius}px;
                 }}
             """
-            )
+        )
         self.apply_plot_widget_style()
 
     def apply_plot_widget_style(self, border: str = "none"):
         """
-        Automatically apply background, border, and axis styles to the PlotWidget.
-
-        Args:
-            border (str): Border style (e.g., 'none', '1px solid red').
+        Let QSS/pyqtgraph handle plot styling; avoid overriding here.
         """
         if isinstance(self.content_widget, pg.GraphicsLayoutWidget):
-            # Apply border style via stylesheet
-            self.content_widget.setStyleSheet(
-                f"""
-                GraphicsLayoutWidget {{
-                    border: {border}; /* Explicitly set the border */
-                }}
-            """
-            )
-            self.content_widget.setBackground(self.background_color)
+            self.content_widget.setStyleSheet("")
 
 
 class ExampleApp(QWidget):  # pragma: no cover
@@ -128,24 +107,14 @@ class ExampleApp(QWidget):  # pragma: no cover
         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(parent=self, content_widget=plot1)
-        rounded_plot2 = RoundedFrame(parent=self, content_widget=plot2)
-
-        # Add to layout
+        # Add to layout (no RoundedFrame wrapper; QSS styles plots)
         layout.addWidget(dark_button)
-        layout.addWidget(rounded_plot1)
-        layout.addWidget(rounded_plot2)
+        layout.addWidget(plot1)
+        layout.addWidget(plot2)
 
         self.setLayout(layout)
 
-        from qtpy.QtCore import QTimer
-
-        def change_theme():
-            rounded_plot1.apply_theme("light")
-            rounded_plot2.apply_theme("dark")
-
-        QTimer.singleShot(100, change_theme)
+        # Theme flip demo removed; global theming applies automatically
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/utils/serialization.py

@@ -1,3 +1,6 @@
+from typing import Type
+
+from bec_lib.codecs import BECCodec
 from bec_lib.serialization import msgpack
 from qtpy.QtCore import QPointF
 
@@ -6,39 +9,26 @@ def register_serializer_extension():
     """
     Register the serializer extension for the BECConnector.
     """
-    if not module_is_registered("bec_widgets.utils.serialization"):
-        msgpack.register_object_hook(encode_qpointf, decode_qpointf)
+    if not msgpack.is_registered(QPointF):
+        msgpack.register_codec(QPointFEncoder)
 
 
-def module_is_registered(module_name: str) -> bool:
-    """
-    Check if the module is registered in the encoder.
+class QPointFEncoder(BECCodec):
+    obj_type: Type = QPointF
 
-    Args:
-        module_name (str): The name of the module to check.
+    @staticmethod
+    def encode(obj: QPointF) -> str:
+        """
+        Encode a QPointF object to a list of floats. As this is mostly used for sending
+        data to the client, it is not necessary to convert it back to a QPointF object.
+        """
+        if isinstance(obj, QPointF):
+            return [obj.x(), obj.y()]
+        return obj
 
-    Returns:
-        bool: True if the module is registered, False otherwise.
-    """
-    # pylint: disable=protected-access
-    for enc in msgpack._encoder:
-        if enc[0].__module__ == module_name:
-            return True
-    return False
-
-
-def encode_qpointf(obj):
-    """
-    Encode a QPointF object to a list of floats. As this is mostly used for sending
-    data to the client, it is not necessary to convert it back to a QPointF object.
-    """
-    if isinstance(obj, QPointF):
-        return [obj.x(), obj.y()]
-    return obj
-
-
-def decode_qpointf(obj):
-    """
-    no-op function since QPointF is encoded as a list of floats.
-    """
-    return obj
+    @staticmethod
+    def decode(type_name: str, data: list[float]) -> list[float]:
+        """
+        no-op function since QPointF is encoded as a list of floats.
+        """
+        return data

bec_widgets/utils/toolbars/actions.py

@@ -446,6 +446,8 @@ class ExpandableMenuAction(ToolBarAction):
 
     def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
         button = QToolButton(toolbar)
+        button.setObjectName("toolbarMenuButton")
+        button.setAutoRaise(True)
         if self.icon_path:
             button.setIcon(QIcon(self.icon_path))
         button.setText(self.tooltip)

bec_widgets/utils/toolbars/toolbar.py

@@ -10,7 +10,7 @@ from qtpy.QtCore import QSize, Qt
 from qtpy.QtGui import QAction, QColor
 from qtpy.QtWidgets import QApplication, QLabel, QMainWindow, QMenu, QToolBar, QVBoxLayout, QWidget
 
-from bec_widgets.utils.colors import get_theme_name, set_theme
+from bec_widgets.utils.colors import apply_theme, get_theme_name
 from bec_widgets.utils.toolbars.actions import MaterialIconAction, ToolBarAction
 from bec_widgets.utils.toolbars.bundles import ToolbarBundle, ToolbarComponents
 from bec_widgets.utils.toolbars.connections import BundleConnection
@@ -507,7 +507,7 @@ if __name__ == "__main__":  # pragma: no cover
                 self.test_label.setText("FPS Monitor Disabled")
 
     app = QApplication(sys.argv)
-    set_theme("light")
+    apply_theme("light")
     main_window = MainWindow()
     main_window.show()
     sys.exit(app.exec_())

bec_widgets/utils/widget_io.py

@@ -465,13 +465,19 @@ class WidgetHierarchy:
         """
         from bec_widgets.utils import BECConnector
 
+        # Guard against deleted/invalid Qt wrappers
         if not shb.isValid(widget):
             return None
-        parent = widget.parent()
+
+        # Retrieve first parent
+        parent = widget.parent() if hasattr(widget, "parent") else None
+        # Walk up, validating each step
         while parent is not None:
+            if not shb.isValid(parent):
+                return None
             if isinstance(parent, BECConnector):
                 return parent
-            parent = parent.parent()
+            parent = parent.parent() if hasattr(parent, "parent") else None
         return None
 
     @staticmethod
@@ -553,6 +559,64 @@ class WidgetHierarchy:
                     WidgetIO.set_value(child, value)
                 WidgetHierarchy.import_config_from_dict(child, widget_config, set_values)
 
+    @staticmethod
+    def get_bec_connectors_from_parent(widget) -> list:
+        """
+        Return all BECConnector instances whose closest BECConnector ancestor is the given widget,
+        including the widget itself if it is a BECConnector.
+        """
+        from bec_widgets.utils import BECConnector
+
+        connectors: list[BECConnector] = []
+        if isinstance(widget, BECConnector):
+            connectors.append(widget)
+        for child in widget.findChildren(BECConnector):
+            if WidgetHierarchy._get_becwidget_ancestor(child) is widget:
+                connectors.append(child)
+        return connectors
+
+    @staticmethod
+    def find_ancestor(widget, ancestor_class) -> QWidget | None:
+        """
+        Traverse up the parent chain to find the nearest ancestor matching ancestor_class.
+        ancestor_class may be a class or a class-name string.
+        Returns the matching ancestor, or None if none is found.
+        """
+        # Guard against deleted/invalid Qt wrappers
+        if not shb.isValid(widget):
+            return None
+
+        # If searching for BECConnector specifically, reuse the dedicated helper
+        try:
+            from bec_widgets.utils import BECConnector  # local import to avoid cycles
+
+            if ancestor_class is BECConnector or (
+                isinstance(ancestor_class, str) and ancestor_class == "BECConnector"
+            ):
+                return WidgetHierarchy._get_becwidget_ancestor(widget)
+        except Exception:
+            # If import fails, fall back to generic traversal below
+            pass
+
+        # Generic traversal across QObject parent chain
+        parent = getattr(widget, "parent", None)
+        if callable(parent):
+            parent = parent()
+        while parent is not None:
+            if not shb.isValid(parent):
+                return None
+            try:
+                if isinstance(ancestor_class, str):
+                    if parent.__class__.__name__ == ancestor_class:
+                        return parent
+                else:
+                    if isinstance(parent, ancestor_class):
+                        return parent
+            except Exception:
+                pass
+            parent = parent.parent() if hasattr(parent, "parent") else None
+        return None
+
 
 # Example usage
 def hierarchy_example():  # pragma: no cover

bec_widgets/utils/widget_state_manager.py

@@ -15,6 +15,8 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
+from bec_widgets.utils.widget_io import WidgetHierarchy
+
 logger = bec_logger.logger
 
 
@@ -29,43 +31,58 @@ class WidgetStateManager:
     def __init__(self, widget):
         self.widget = widget
 
-    def save_state(self, filename: str = None):
+    def save_state(self, filename: str | None = None, settings: QSettings | None = None):
         """
         Save the state of the widget to an INI file.
 
         Args:
             filename(str): The filename to save the state to.
+            settings(QSettings): Optional QSettings object to save the state to.
         """
-        if not filename:
+        if not filename and not settings:
             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)
+        elif settings:
+            # If settings are provided, save the state to the provided QSettings object
+            self._save_widget_state_qsettings(self.widget, settings)
+        else:
+            logger.warning("No filename or settings provided for saving state.")
 
-    def load_state(self, filename: str = None):
+    def load_state(self, filename: str | None = None, settings: QSettings | None = None):
         """
         Load the state of the widget from an INI file.
 
         Args:
             filename(str): The filename to load the state from.
+            settings(QSettings): Optional QSettings object to load the state from.
         """
-        if not filename:
+        if not filename and not settings:
             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)
+        elif settings:
+            # If settings are provided, load the state from the provided QSettings object
+            self._load_widget_state_qsettings(self.widget, settings)
+        else:
+            logger.warning("No filename or settings provided for saving state.")
 
-    def _save_widget_state_qsettings(self, widget: QWidget, settings: QSettings):
+    def _save_widget_state_qsettings(
+        self, widget: QWidget, settings: QSettings, recursive: bool = True
+    ):
         """
         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.
+            recursive(bool): Whether to recursively save the state of child widgets.
         """
         if widget.property("skip_settings") is True:
             return
@@ -88,21 +105,32 @@ class WidgetStateManager:
         settings.endGroup()
 
         # Recursively process children (only if they aren't skipped)
-        for child in widget.children():
+        if not recursive:
+            return
+
+        direct_children = widget.children()
+        bec_connector_children = WidgetHierarchy.get_bec_connectors_from_parent(widget)
+        all_children = list(
+            set(direct_children) | set(bec_connector_children)
+        )  # to avoid duplicates
+        for child in all_children:
             if (
                 child.objectName()
                 and child.property("skip_settings") is not True
                 and not isinstance(child, QLabel)
             ):
-                self._save_widget_state_qsettings(child, settings)
+                self._save_widget_state_qsettings(child, settings, False)
 
-    def _load_widget_state_qsettings(self, widget: QWidget, settings: QSettings):
+    def _load_widget_state_qsettings(
+        self, widget: QWidget, settings: QSettings, recursive: bool = True
+    ):
         """
         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.
+            recursive(bool): Whether to recursively load the state of child widgets.
         """
         if widget.property("skip_settings") is True:
             return
@@ -118,14 +146,21 @@ class WidgetStateManager:
                 widget.setProperty(name, value)
         settings.endGroup()
 
+        if not recursive:
+            return
         # Recursively process children (only if they aren't skipped)
-        for child in widget.children():
+        direct_children = widget.children()
+        bec_connector_children = WidgetHierarchy.get_bec_connectors_from_parent(widget)
+        all_children = list(
+            set(direct_children) | set(bec_connector_children)
+        )  # to avoid duplicates
+        for child in all_children:
             if (
                 child.objectName()
                 and child.property("skip_settings") is not True
                 and not isinstance(child, QLabel)
             ):
-                self._load_widget_state_qsettings(child, settings)
+                self._load_widget_state_qsettings(child, settings, False)
 
     def _get_full_widget_name(self, widget: QWidget):
         """

bec_widgets/widgets/containers/advanced_dock_area/advanced_dock_area.py

@@ -0,0 +1,911 @@
+from __future__ import annotations
+
+import os
+from typing import Literal, cast
+
+import PySide6QtAds as QtAds
+from PySide6QtAds import CDockManager, CDockWidget
+from qtpy.QtCore import Signal
+from qtpy.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QDialog,
+    QHBoxLayout,
+    QInputDialog,
+    QLabel,
+    QLineEdit,
+    QMessageBox,
+    QPushButton,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+from shiboken6 import isValid
+
+from bec_widgets import BECWidget, SafeProperty, SafeSlot
+from bec_widgets.cli.rpc.rpc_widget_handler import widget_handler
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.utils.property_editor import PropertyEditor
+from bec_widgets.utils.toolbars.actions import (
+    ExpandableMenuAction,
+    MaterialIconAction,
+    WidgetAction,
+)
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle
+from bec_widgets.utils.toolbars.toolbar import ModularToolBar
+from bec_widgets.utils.widget_state_manager import WidgetStateManager
+from bec_widgets.widgets.containers.advanced_dock_area.profile_utils import (
+    SETTINGS_KEYS,
+    is_profile_readonly,
+    list_profiles,
+    open_settings,
+    profile_path,
+    read_manifest,
+    set_profile_readonly,
+    write_manifest,
+)
+from bec_widgets.widgets.containers.advanced_dock_area.toolbar_components.workspace_actions import (
+    WorkspaceConnection,
+    workspace_bundle,
+)
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindowNoRPC
+from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
+from bec_widgets.widgets.control.scan_control import ScanControl
+from bec_widgets.widgets.editors.vscode.vscode import VSCodeEditor
+from bec_widgets.widgets.plots.heatmap.heatmap import Heatmap
+from bec_widgets.widgets.plots.image.image import Image
+from bec_widgets.widgets.plots.motor_map.motor_map import MotorMap
+from bec_widgets.widgets.plots.multi_waveform.multi_waveform import MultiWaveform
+from bec_widgets.widgets.plots.scatter_waveform.scatter_waveform import ScatterWaveform
+from bec_widgets.widgets.plots.waveform.waveform import Waveform
+from bec_widgets.widgets.progress.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 import LogPanel
+from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
+
+class DockSettingsDialog(QDialog):
+
+    def __init__(self, parent: QWidget, target: QWidget):
+        super().__init__(parent)
+        self.setWindowTitle("Dock Settings")
+        self.setModal(True)
+        layout = QVBoxLayout(self)
+
+        # Property editor
+        self.prop_editor = PropertyEditor(target, self, show_only_bec=True)
+        layout.addWidget(self.prop_editor)
+
+
+class SaveProfileDialog(QDialog):
+    """Dialog for saving workspace profiles with read-only option."""
+
+    def __init__(self, parent: QWidget, current_name: str = ""):
+        super().__init__(parent)
+        self.setWindowTitle("Save Workspace Profile")
+        self.setModal(True)
+        self.resize(400, 150)
+        layout = QVBoxLayout(self)
+
+        # Name input
+        name_row = QHBoxLayout()
+        name_row.addWidget(QLabel("Profile Name:"))
+        self.name_edit = QLineEdit(current_name)
+        self.name_edit.setPlaceholderText("Enter profile name...")
+        name_row.addWidget(self.name_edit)
+        layout.addLayout(name_row)
+
+        # Read-only checkbox
+        self.readonly_checkbox = QCheckBox("Mark as read-only (cannot be overwritten or deleted)")
+        layout.addWidget(self.readonly_checkbox)
+
+        # Info label
+        info_label = QLabel("Read-only profiles are protected from modification and deletion.")
+        info_label.setStyleSheet("color: gray; font-size: 10px;")
+        layout.addWidget(info_label)
+
+        # Buttons
+        btn_row = QHBoxLayout()
+        btn_row.addStretch(1)
+        self.save_btn = QPushButton("Save")
+        self.save_btn.setDefault(True)
+        cancel_btn = QPushButton("Cancel")
+        self.save_btn.clicked.connect(self.accept)
+        cancel_btn.clicked.connect(self.reject)
+        btn_row.addWidget(self.save_btn)
+        btn_row.addWidget(cancel_btn)
+        layout.addLayout(btn_row)
+
+        # Enable/disable save button based on name input
+        self.name_edit.textChanged.connect(self._update_save_button)
+        self._update_save_button()
+
+    def _update_save_button(self):
+        """Enable save button only when name is not empty."""
+        self.save_btn.setEnabled(bool(self.name_edit.text().strip()))
+
+    def get_profile_name(self) -> str:
+        """Get the entered profile name."""
+        return self.name_edit.text().strip()
+
+    def is_readonly(self) -> bool:
+        """Check if the profile should be marked as read-only."""
+        return self.readonly_checkbox.isChecked()
+
+
+class AdvancedDockArea(BECWidget, QWidget):
+    RPC = True
+    PLUGIN = False
+    USER_ACCESS = [
+        "new",
+        "widget_map",
+        "widget_list",
+        "lock_workspace",
+        "attach_all",
+        "delete_all",
+        "mode",
+        "mode.setter",
+    ]
+
+    # Define a signal for mode changes
+    mode_changed = Signal(str)
+
+    def __init__(
+        self,
+        parent=None,
+        mode: str = "developer",
+        default_add_direction: Literal["left", "right", "top", "bottom"] = "right",
+        *args,
+        **kwargs,
+    ):
+        super().__init__(parent=parent, *args, **kwargs)
+
+        # Title (as a top-level QWidget it can have a window title)
+        self.setWindowTitle("Advanced Dock Area")
+
+        # Top-level layout hosting a toolbar and the dock manager
+        self._root_layout = QVBoxLayout(self)
+        self._root_layout.setContentsMargins(0, 0, 0, 0)
+        self._root_layout.setSpacing(0)
+
+        # Init Dock Manager
+        self.dock_manager = CDockManager(self)
+        self.dock_manager.setStyleSheet("")
+
+        # Dock manager helper variables
+        self._locked = False  # Lock state of the workspace
+
+        # Initialize mode property first (before toolbar setup)
+        self._mode = "developer"
+        self._default_add_direction = (
+            default_add_direction
+            if default_add_direction in ("left", "right", "top", "bottom")
+            else "right"
+        )
+
+        # Toolbar
+        self.dark_mode_button = DarkModeButton(parent=self, toolbar=True)
+        self._setup_toolbar()
+        self._hook_toolbar()
+
+        # Place toolbar and dock manager into layout
+        self._root_layout.addWidget(self.toolbar)
+        self._root_layout.addWidget(self.dock_manager, 1)
+
+        # Populate and hook the workspace combo
+        self._refresh_workspace_list()
+
+        # State manager
+        self.state_manager = WidgetStateManager(self)
+
+        # Developer mode state
+        self._editable = None
+        # Initialize default editable state based on current lock
+        self._set_editable(True)  # default to editable; will sync toolbar toggle below
+
+        # Sync Developer toggle icon state after initial setup
+        dev_action = self.toolbar.components.get_action("developer_mode").action
+        dev_action.setChecked(self._editable)
+
+        # Apply the requested mode after everything is set up
+        self.mode = mode
+
+    def _make_dock(
+        self,
+        widget: QWidget,
+        *,
+        closable: bool,
+        floatable: bool,
+        movable: bool = True,
+        area: QtAds.DockWidgetArea = QtAds.DockWidgetArea.RightDockWidgetArea,
+        start_floating: bool = False,
+    ) -> CDockWidget:
+        dock = CDockWidget(widget.objectName())
+        dock.setWidget(widget)
+        dock.setFeature(CDockWidget.DockWidgetDeleteOnClose, True)
+        dock.setFeature(CDockWidget.CustomCloseHandling, True)
+        dock.setFeature(CDockWidget.DockWidgetClosable, closable)
+        dock.setFeature(CDockWidget.DockWidgetFloatable, floatable)
+        dock.setFeature(CDockWidget.DockWidgetMovable, movable)
+
+        self._install_dock_settings_action(dock, widget)
+
+        def on_dock_close():
+            widget.close()
+            dock.closeDockWidget()
+            dock.deleteDockWidget()
+
+        def on_widget_destroyed():
+            if not isValid(dock):
+                return
+            dock.closeDockWidget()
+            dock.deleteDockWidget()
+
+        dock.closeRequested.connect(on_dock_close)
+        if hasattr(widget, "widget_removed"):
+            widget.widget_removed.connect(on_widget_destroyed)
+
+        dock.setMinimumSizeHintMode(CDockWidget.eMinimumSizeHintMode.MinimumSizeHintFromDockWidget)
+        self.dock_manager.addDockWidget(area, dock)
+        if start_floating:
+            dock.setFloating()
+        return dock
+
+    def _install_dock_settings_action(self, dock: CDockWidget, widget: QWidget) -> None:
+        action = MaterialIconAction(
+            icon_name="settings", tooltip="Dock settings", filled=True, parent=self
+        ).action
+        action.setToolTip("Dock settings")
+        action.setObjectName("dockSettingsAction")
+        action.triggered.connect(lambda: self._open_dock_settings_dialog(dock, widget))
+        dock.setTitleBarActions([action])
+        dock.setting_action = action
+
+    def _open_dock_settings_dialog(self, dock: CDockWidget, widget: QWidget) -> None:
+        dlg = DockSettingsDialog(self, widget)
+        dlg.resize(600, 600)
+        dlg.exec()
+
+    def _apply_dock_lock(self, locked: bool) -> None:
+        if locked:
+            self.dock_manager.lockDockWidgetFeaturesGlobally()
+        else:
+            self.dock_manager.lockDockWidgetFeaturesGlobally(QtAds.CDockWidget.NoDockWidgetFeatures)
+
+    def _delete_dock(self, dock: CDockWidget) -> None:
+        w = dock.widget()
+        if w and isValid(w):
+            w.close()
+            w.deleteLater()
+        if isValid(dock):
+            dock.closeDockWidget()
+            dock.deleteDockWidget()
+
+    def _area_from_where(self, where: str | None) -> QtAds.DockWidgetArea:
+        """Return ADS DockWidgetArea from a human-friendly direction string.
+        If *where* is None, fall back to instance default.
+        """
+        d = (where or getattr(self, "_default_add_direction", "right") or "right").lower()
+        mapping = {
+            "left": QtAds.DockWidgetArea.LeftDockWidgetArea,
+            "right": QtAds.DockWidgetArea.RightDockWidgetArea,
+            "top": QtAds.DockWidgetArea.TopDockWidgetArea,
+            "bottom": QtAds.DockWidgetArea.BottomDockWidgetArea,
+        }
+        return mapping.get(d, QtAds.DockWidgetArea.RightDockWidgetArea)
+
+    ################################################################################
+    # Toolbar Setup
+    ################################################################################
+
+    def _setup_toolbar(self):
+        self.toolbar = ModularToolBar(parent=self)
+
+        PLOT_ACTIONS = {
+            "waveform": (Waveform.ICON_NAME, "Add Waveform", "Waveform"),
+            "scatter_waveform": (
+                ScatterWaveform.ICON_NAME,
+                "Add Scatter Waveform",
+                "ScatterWaveform",
+            ),
+            "multi_waveform": (MultiWaveform.ICON_NAME, "Add Multi Waveform", "MultiWaveform"),
+            "image": (Image.ICON_NAME, "Add Image", "Image"),
+            "motor_map": (MotorMap.ICON_NAME, "Add Motor Map", "MotorMap"),
+            "heatmap": (Heatmap.ICON_NAME, "Add Heatmap", "Heatmap"),
+        }
+        DEVICE_ACTIONS = {
+            "scan_control": (ScanControl.ICON_NAME, "Add Scan Control", "ScanControl"),
+            "positioner_box": (PositionerBox.ICON_NAME, "Add Device Box", "PositionerBox"),
+        }
+        UTIL_ACTIONS = {
+            "queue": (BECQueue.ICON_NAME, "Add Scan Queue", "BECQueue"),
+            "vs_code": (VSCodeEditor.ICON_NAME, "Add VS Code", "VSCodeEditor"),
+            "status": (BECStatusBox.ICON_NAME, "Add BEC Status Box", "BECStatusBox"),
+            "progress_bar": (
+                RingProgressBar.ICON_NAME,
+                "Add Circular ProgressBar",
+                "RingProgressBar",
+            ),
+            "log_panel": (LogPanel.ICON_NAME, "Add LogPanel - Disabled", "LogPanel"),
+            "sbb_monitor": ("train", "Add SBB Monitor", "SBBMonitor"),
+        }
+
+        # Create expandable menu actions (original behavior)
+        def _build_menu(key: str, label: str, mapping: dict[str, tuple[str, str, str]]):
+            self.toolbar.components.add_safe(
+                key,
+                ExpandableMenuAction(
+                    label=label,
+                    actions={
+                        k: MaterialIconAction(
+                            icon_name=v[0], tooltip=v[1], filled=True, parent=self
+                        )
+                        for k, v in mapping.items()
+                    },
+                ),
+            )
+            b = ToolbarBundle(key, self.toolbar.components)
+            b.add_action(key)
+            self.toolbar.add_bundle(b)
+
+        _build_menu("menu_plots", "Add Plot ", PLOT_ACTIONS)
+        _build_menu("menu_devices", "Add Device Control ", DEVICE_ACTIONS)
+        _build_menu("menu_utils", "Add Utils ", UTIL_ACTIONS)
+
+        # Create flat toolbar bundles for each widget type
+        def _build_flat_bundles(category: str, mapping: dict[str, tuple[str, str, str]]):
+            bundle = ToolbarBundle(f"flat_{category}", self.toolbar.components)
+
+            for action_id, (icon_name, tooltip, widget_type) in mapping.items():
+                # Create individual action for each widget type
+                flat_action_id = f"flat_{action_id}"
+                self.toolbar.components.add_safe(
+                    flat_action_id,
+                    MaterialIconAction(
+                        icon_name=icon_name, tooltip=tooltip, filled=True, parent=self
+                    ),
+                )
+                bundle.add_action(flat_action_id)
+
+            self.toolbar.add_bundle(bundle)
+
+        _build_flat_bundles("plots", PLOT_ACTIONS)
+        _build_flat_bundles("devices", DEVICE_ACTIONS)
+        _build_flat_bundles("utils", UTIL_ACTIONS)
+
+        # Workspace
+        spacer_bundle = ToolbarBundle("spacer_bundle", self.toolbar.components)
+        spacer = QWidget(parent=self.toolbar.components.toolbar)
+        spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        self.toolbar.components.add_safe("spacer", WidgetAction(widget=spacer, adjust_size=False))
+        spacer_bundle.add_action("spacer")
+        self.toolbar.add_bundle(spacer_bundle)
+
+        self.toolbar.add_bundle(workspace_bundle(self.toolbar.components))
+        self.toolbar.connect_bundle(
+            "workspace", WorkspaceConnection(components=self.toolbar.components, target_widget=self)
+        )
+
+        # Dock actions
+        self.toolbar.components.add_safe(
+            "attach_all",
+            MaterialIconAction(
+                icon_name="zoom_in_map", tooltip="Attach all floating docks", parent=self
+            ),
+        )
+        self.toolbar.components.add_safe(
+            "screenshot",
+            MaterialIconAction(icon_name="photo_camera", tooltip="Take Screenshot", parent=self),
+        )
+        self.toolbar.components.add_safe(
+            "dark_mode", WidgetAction(widget=self.dark_mode_button, adjust_size=False, parent=self)
+        )
+        # Developer mode toggle (moved from menu into toolbar)
+        self.toolbar.components.add_safe(
+            "developer_mode",
+            MaterialIconAction(
+                icon_name="code", tooltip="Developer Mode", checkable=True, parent=self
+            ),
+        )
+        bda = ToolbarBundle("dock_actions", self.toolbar.components)
+        bda.add_action("attach_all")
+        bda.add_action("screenshot")
+        bda.add_action("dark_mode")
+        bda.add_action("developer_mode")
+        self.toolbar.add_bundle(bda)
+
+        # Default bundle configuration (show menus by default)
+        self.toolbar.show_bundles(
+            [
+                "menu_plots",
+                "menu_devices",
+                "menu_utils",
+                "spacer_bundle",
+                "workspace",
+                "dock_actions",
+            ]
+        )
+
+        # Store mappings on self for use in _hook_toolbar
+        self._ACTION_MAPPINGS = {
+            "menu_plots": PLOT_ACTIONS,
+            "menu_devices": DEVICE_ACTIONS,
+            "menu_utils": UTIL_ACTIONS,
+        }
+
+    def _hook_toolbar(self):
+
+        def _connect_menu(menu_key: str):
+            menu = self.toolbar.components.get_action(menu_key)
+            mapping = self._ACTION_MAPPINGS[menu_key]
+            for key, (_, _, widget_type) in mapping.items():
+                act = menu.actions[key].action
+                if widget_type == "LogPanel":
+                    act.setEnabled(False)  # keep disabled per issue #644
+                else:
+                    act.triggered.connect(lambda _, t=widget_type: self.new(widget=t))
+
+        _connect_menu("menu_plots")
+        _connect_menu("menu_devices")
+        _connect_menu("menu_utils")
+
+        # Connect flat toolbar actions
+        def _connect_flat_actions(category: str, mapping: dict[str, tuple[str, str, str]]):
+            for action_id, (_, _, widget_type) in mapping.items():
+                flat_action_id = f"flat_{action_id}"
+                flat_action = self.toolbar.components.get_action(flat_action_id).action
+                if widget_type == "LogPanel":
+                    flat_action.setEnabled(False)  # keep disabled per issue #644
+                else:
+                    flat_action.triggered.connect(lambda _, t=widget_type: self.new(widget=t))
+
+        _connect_flat_actions("plots", self._ACTION_MAPPINGS["menu_plots"])
+        _connect_flat_actions("devices", self._ACTION_MAPPINGS["menu_devices"])
+        _connect_flat_actions("utils", self._ACTION_MAPPINGS["menu_utils"])
+
+        self.toolbar.components.get_action("attach_all").action.triggered.connect(self.attach_all)
+        self.toolbar.components.get_action("screenshot").action.triggered.connect(self.screenshot)
+        # Developer mode toggle
+        self.toolbar.components.get_action("developer_mode").action.toggled.connect(
+            self._on_developer_mode_toggled
+        )
+
+    def _set_editable(self, editable: bool) -> None:
+        self.lock_workspace = not editable
+        self._editable = editable
+
+        # Sync the toolbar lock toggle with current mode
+        lock_action = self.toolbar.components.get_action("lock").action
+        lock_action.setChecked(not editable)
+        lock_action.setVisible(editable)
+
+        attach_all_action = self.toolbar.components.get_action("attach_all").action
+        attach_all_action.setVisible(editable)
+
+        # Show full creation menus only when editable; otherwise keep minimal set
+        if editable:
+            self.toolbar.show_bundles(
+                [
+                    "menu_plots",
+                    "menu_devices",
+                    "menu_utils",
+                    "spacer_bundle",
+                    "workspace",
+                    "dock_actions",
+                ]
+            )
+        else:
+            self.toolbar.show_bundles(["spacer_bundle", "workspace", "dock_actions"])
+
+        # Keep Developer mode UI in sync
+        self.toolbar.components.get_action("developer_mode").action.setChecked(editable)
+
+    def _on_developer_mode_toggled(self, checked: bool) -> None:
+        """Handle developer mode checkbox toggle."""
+        self._set_editable(checked)
+
+    ################################################################################
+    # Adding widgets
+    ################################################################################
+    @SafeSlot(popup_error=True)
+    def new(
+        self,
+        widget: BECWidget | str,
+        closable: bool = True,
+        floatable: bool = True,
+        movable: bool = True,
+        start_floating: bool = False,
+        where: Literal["left", "right", "top", "bottom"] | None = None,
+    ) -> BECWidget:
+        """
+        Create a new widget (or reuse an instance) and add it as a dock.
+
+        Args:
+            widget: Widget instance or a string widget type (factory-created).
+            closable: Whether the dock is closable.
+            floatable: Whether the dock is floatable.
+            movable: Whether the dock is movable.
+            start_floating: Start the dock in a floating state.
+            where: Preferred area to add the dock: "left" | "right" | "top" | "bottom".
+                   If None, uses the instance default passed at construction time.
+        Returns:
+            The widget instance.
+        """
+        target_area = self._area_from_where(where)
+
+        # 1) Instantiate or look up the widget
+        if isinstance(widget, str):
+            widget = cast(BECWidget, widget_handler.create_widget(widget_type=widget, parent=self))
+            widget.name_established.connect(
+                lambda: self._create_dock_with_name(
+                    widget=widget,
+                    closable=closable,
+                    floatable=floatable,
+                    movable=movable,
+                    start_floating=start_floating,
+                    area=target_area,
+                )
+            )
+            return widget
+
+        # If a widget instance is passed, dock it immediately
+        self._create_dock_with_name(
+            widget=widget,
+            closable=closable,
+            floatable=floatable,
+            movable=movable,
+            start_floating=start_floating,
+            area=target_area,
+        )
+        return widget
+
+    def _create_dock_with_name(
+        self,
+        widget: BECWidget,
+        closable: bool = True,
+        floatable: bool = False,
+        movable: bool = True,
+        start_floating: bool = False,
+        area: QtAds.DockWidgetArea | None = None,
+    ):
+        target_area = area or self._area_from_where(None)
+        self._make_dock(
+            widget,
+            closable=closable,
+            floatable=floatable,
+            movable=movable,
+            area=target_area,
+            start_floating=start_floating,
+        )
+        self.dock_manager.setFocus()
+
+    ################################################################################
+    # Dock Management
+    ################################################################################
+
+    def dock_map(self) -> dict[str, CDockWidget]:
+        """
+        Return the dock widgets map as dictionary with names as keys and dock widgets as values.
+
+        Returns:
+            dict: A dictionary mapping widget names to their corresponding dock widgets.
+        """
+        return self.dock_manager.dockWidgetsMap()
+
+    def dock_list(self) -> list[CDockWidget]:
+        """
+        Return the list of dock widgets.
+
+        Returns:
+            list: A list of all dock widgets in the dock area.
+        """
+        return self.dock_manager.dockWidgets()
+
+    def widget_map(self) -> dict[str, QWidget]:
+        """
+        Return a dictionary mapping widget names to their corresponding BECWidget instances.
+
+        Returns:
+            dict: A dictionary mapping widget names to BECWidget instances.
+        """
+        return {dock.objectName(): dock.widget() for dock in self.dock_list()}
+
+    def widget_list(self) -> list[QWidget]:
+        """
+        Return a list of all BECWidget instances in the dock area.
+
+        Returns:
+            list: A list of all BECWidget instances in the dock area.
+        """
+        return [dock.widget() for dock in self.dock_list() if isinstance(dock.widget(), QWidget)]
+
+    @SafeSlot()
+    def attach_all(self):
+        """
+        Return all floating docks to the dock area, preserving tab groups within each floating container.
+        """
+        for container in self.dock_manager.floatingWidgets():
+            docks = container.dockWidgets()
+            if not docks:
+                continue
+            target = docks[0]
+            self.dock_manager.addDockWidget(QtAds.DockWidgetArea.RightDockWidgetArea, target)
+            for d in docks[1:]:
+                self.dock_manager.addDockWidgetTab(
+                    QtAds.DockWidgetArea.RightDockWidgetArea, d, target
+                )
+
+    @SafeSlot()
+    def delete_all(self):
+        """Delete all docks and widgets."""
+        for dock in list(self.dock_manager.dockWidgets()):
+            self._delete_dock(dock)
+
+    ################################################################################
+    # Workspace Management
+    ################################################################################
+    @SafeProperty(bool)
+    def lock_workspace(self) -> bool:
+        """
+        Get or set the lock state of the workspace.
+
+        Returns:
+            bool: True if the workspace is locked, False otherwise.
+        """
+        return self._locked
+
+    @lock_workspace.setter
+    def lock_workspace(self, value: bool):
+        """
+        Set the lock state of the workspace. Docks remain resizable, but are not movable or closable.
+
+        Args:
+            value (bool): True to lock the workspace, False to unlock it.
+        """
+        self._locked = value
+        self._apply_dock_lock(value)
+        self.toolbar.components.get_action("save_workspace").action.setVisible(not value)
+        self.toolbar.components.get_action("delete_workspace").action.setVisible(not value)
+        for dock in self.dock_list():
+            dock.setting_action.setVisible(not value)
+
+    @SafeSlot(str)
+    def save_profile(self, name: str | None = None):
+        """
+        Save the current workspace profile.
+
+        Args:
+            name (str | None): The name of the profile. If None, a dialog will prompt for a name.
+        """
+        if not name:
+            # Use the new SaveProfileDialog instead of QInputDialog
+            dialog = SaveProfileDialog(self)
+            if dialog.exec() != QDialog.Accepted:
+                return
+            name = dialog.get_profile_name()
+            readonly = dialog.is_readonly()
+
+            # Check if profile already exists and is read-only
+            if os.path.exists(profile_path(name)) and is_profile_readonly(name):
+                suggested_name = f"{name}_custom"
+                reply = QMessageBox.warning(
+                    self,
+                    "Read-only Profile",
+                    f"The profile '{name}' is marked as read-only and cannot be overwritten.\n\n"
+                    f"Would you like to save it with a different name?\n"
+                    f"Suggested name: '{suggested_name}'",
+                    QMessageBox.Yes | QMessageBox.No,
+                    QMessageBox.Yes,
+                )
+                if reply == QMessageBox.Yes:
+                    # Show dialog again with suggested name pre-filled
+                    dialog = SaveProfileDialog(self, suggested_name)
+                    if dialog.exec() != QDialog.Accepted:
+                        return
+                    name = dialog.get_profile_name()
+                    readonly = dialog.is_readonly()
+
+                    # Check again if the new name is also read-only (recursive protection)
+                    if os.path.exists(profile_path(name)) and is_profile_readonly(name):
+                        return self.save_profile()
+                else:
+                    return
+        else:
+            # If name is provided directly, assume not read-only unless already exists
+            readonly = False
+            if os.path.exists(profile_path(name)) and is_profile_readonly(name):
+                QMessageBox.warning(
+                    self,
+                    "Read-only Profile",
+                    f"The profile '{name}' is marked as read-only and cannot be overwritten.",
+                    QMessageBox.Ok,
+                )
+                return
+
+        # Display saving placeholder
+        workspace_combo = self.toolbar.components.get_action("workspace_combo").widget
+        workspace_combo.blockSignals(True)
+        workspace_combo.insertItem(0, f"{name}-saving")
+        workspace_combo.setCurrentIndex(0)
+        workspace_combo.blockSignals(False)
+
+        # Save the profile
+        settings = open_settings(name)
+        settings.setValue(SETTINGS_KEYS["geom"], self.saveGeometry())
+        settings.setValue(
+            SETTINGS_KEYS["state"], b""
+        )  # No QMainWindow state; placeholder for backward compat
+        settings.setValue(SETTINGS_KEYS["ads_state"], self.dock_manager.saveState())
+        self.dock_manager.addPerspective(name)
+        self.dock_manager.savePerspectives(settings)
+        self.state_manager.save_state(settings=settings)
+        write_manifest(settings, self.dock_list())
+
+        # Set read-only status if specified
+        if readonly:
+            set_profile_readonly(name, readonly)
+
+        settings.sync()
+        self._refresh_workspace_list()
+        workspace_combo.setCurrentText(name)
+
+    def load_profile(self, name: str | None = None):
+        """
+        Load a workspace profile.
+
+        Args:
+            name (str | None): The name of the profile. If None, a dialog will prompt for a name.
+        """
+        # FIXME this has to be tweaked
+        if not name:
+            name, ok = QInputDialog.getText(
+                self, "Load Workspace", "Enter the name of the workspace profile to load:"
+            )
+            if not ok or not name:
+                return
+        settings = open_settings(name)
+
+        for item in read_manifest(settings):
+            obj_name = item["object_name"]
+            widget_class = item["widget_class"]
+            if obj_name not in self.widget_map():
+                w = widget_handler.create_widget(widget_type=widget_class, parent=self)
+                w.setObjectName(obj_name)
+                self._make_dock(
+                    w,
+                    closable=item["closable"],
+                    floatable=item["floatable"],
+                    movable=item["movable"],
+                    area=QtAds.DockWidgetArea.RightDockWidgetArea,
+                )
+
+        geom = settings.value(SETTINGS_KEYS["geom"])
+        if geom:
+            self.restoreGeometry(geom)
+        # No window state for QWidget-based host; keep for backwards compat read
+        # window_state = settings.value(SETTINGS_KEYS["state"])  # ignored
+        dock_state = settings.value(SETTINGS_KEYS["ads_state"])
+        if dock_state:
+            self.dock_manager.restoreState(dock_state)
+        self.dock_manager.loadPerspectives(settings)
+        self.state_manager.load_state(settings=settings)
+        self._set_editable(self._editable)
+
+    @SafeSlot()
+    def delete_profile(self):
+        """
+        Delete the currently selected workspace profile file and refresh the combo list.
+        """
+        combo = self.toolbar.components.get_action("workspace_combo").widget
+        name = combo.currentText()
+        if not name:
+            return
+
+        # Check if profile is read-only
+        if is_profile_readonly(name):
+            QMessageBox.warning(
+                self,
+                "Read-only Profile",
+                f"The profile '{name}' is marked as read-only and cannot be deleted.\n\n"
+                f"Read-only profiles are protected from modification and deletion.",
+                QMessageBox.Ok,
+            )
+            return
+
+        # Confirm deletion for regular profiles
+        reply = QMessageBox.question(
+            self,
+            "Delete Profile",
+            f"Are you sure you want to delete the profile '{name}'?\n\n"
+            f"This action cannot be undone.",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No,
+        )
+        if reply != QMessageBox.Yes:
+            return
+
+        file_path = profile_path(name)
+        try:
+            os.remove(file_path)
+        except FileNotFoundError:
+            return
+        self._refresh_workspace_list()
+
+    def _refresh_workspace_list(self):
+        """
+        Populate the workspace combo box with all saved profile names (without .ini).
+        """
+        combo = self.toolbar.components.get_action("workspace_combo").widget
+        if hasattr(combo, "refresh_profiles"):
+            combo.refresh_profiles()
+        else:
+            # Fallback for regular QComboBox
+            combo.blockSignals(True)
+            combo.clear()
+            combo.addItems(list_profiles())
+            combo.blockSignals(False)
+
+    ################################################################################
+    # Mode Switching
+    ################################################################################
+
+    @SafeProperty(str)
+    def mode(self) -> str:
+        return self._mode
+
+    @mode.setter
+    def mode(self, new_mode: str):
+        if new_mode not in ["plot", "device", "utils", "developer", "user"]:
+            raise ValueError(f"Invalid mode: {new_mode}")
+        self._mode = new_mode
+        self.mode_changed.emit(new_mode)
+
+        # Update toolbar visibility based on mode
+        if new_mode == "user":
+            # User mode: show only essential tools
+            self.toolbar.show_bundles(["spacer_bundle", "workspace", "dock_actions"])
+        elif new_mode == "developer":
+            # Developer mode: show all tools (use menu bundles)
+            self.toolbar.show_bundles(
+                [
+                    "menu_plots",
+                    "menu_devices",
+                    "menu_utils",
+                    "spacer_bundle",
+                    "workspace",
+                    "dock_actions",
+                ]
+            )
+        elif new_mode in ["plot", "device", "utils"]:
+            # Specific modes: show flat toolbar for that category
+            bundle_name = f"flat_{new_mode}s" if new_mode != "utils" else "flat_utils"
+            self.toolbar.show_bundles([bundle_name])
+            # self.toolbar.show_bundles([bundle_name, "spacer_bundle", "workspace", "dock_actions"])
+        else:
+            # Fallback to user mode
+            self.toolbar.show_bundles(["spacer_bundle", "workspace", "dock_actions"])
+
+    def cleanup(self):
+        """
+        Cleanup the dock area.
+        """
+        self.delete_all()
+        self.dark_mode_button.close()
+        self.dark_mode_button.deleteLater()
+        self.toolbar.cleanup()
+        super().cleanup()
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    dispatcher = BECDispatcher(gui_id="ads")
+    window = BECMainWindowNoRPC()
+    ads = AdvancedDockArea(mode="developer", root_widget=True)
+    window.setCentralWidget(ads)
+    window.show()
+    window.resize(800, 600)
+
+    sys.exit(app.exec())

bec_widgets/widgets/containers/advanced_dock_area/profile_utils.py

@@ -0,0 +1,79 @@
+import os
+
+from PySide6QtAds import CDockWidget
+from qtpy.QtCore import QSettings
+
+MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+_DEFAULT_PROFILES_DIR = os.path.join(os.path.dirname(__file__), "states", "default")
+_USER_PROFILES_DIR = os.path.join(os.path.dirname(__file__), "states", "user")
+
+
+def profiles_dir() -> str:
+    path = os.environ.get("BECWIDGETS_PROFILE_DIR", _USER_PROFILES_DIR)
+    os.makedirs(path, exist_ok=True)
+    return path
+
+
+def profile_path(name: str) -> str:
+    return os.path.join(profiles_dir(), f"{name}.ini")
+
+
+SETTINGS_KEYS = {
+    "geom": "mainWindow/Geometry",
+    "state": "mainWindow/State",
+    "ads_state": "mainWindow/DockingState",
+    "manifest": "manifest/widgets",
+    "readonly": "profile/readonly",
+}
+
+
+def list_profiles() -> list[str]:
+    return sorted(os.path.splitext(f)[0] for f in os.listdir(profiles_dir()) if f.endswith(".ini"))
+
+
+def is_profile_readonly(name: str) -> bool:
+    """Check if a profile is marked as read-only."""
+    settings = open_settings(name)
+    return settings.value(SETTINGS_KEYS["readonly"], False, type=bool)
+
+
+def set_profile_readonly(name: str, readonly: bool) -> None:
+    """Set the read-only status of a profile."""
+    settings = open_settings(name)
+    settings.setValue(SETTINGS_KEYS["readonly"], readonly)
+    settings.sync()
+
+
+def open_settings(name: str) -> QSettings:
+    return QSettings(profile_path(name), QSettings.IniFormat)
+
+
+def write_manifest(settings: QSettings, docks: list[CDockWidget]) -> None:
+    settings.beginWriteArray(SETTINGS_KEYS["manifest"], len(docks))
+    for i, dock in enumerate(docks):
+        settings.setArrayIndex(i)
+        w = dock.widget()
+        settings.setValue("object_name", w.objectName())
+        settings.setValue("widget_class", w.__class__.__name__)
+        settings.setValue("closable", getattr(dock, "_default_closable", True))
+        settings.setValue("floatable", getattr(dock, "_default_floatable", True))
+        settings.setValue("movable", getattr(dock, "_default_movable", True))
+    settings.endArray()
+
+
+def read_manifest(settings: QSettings) -> list[dict]:
+    items: list[dict] = []
+    count = settings.beginReadArray(SETTINGS_KEYS["manifest"])
+    for i in range(count):
+        settings.setArrayIndex(i)
+        items.append(
+            {
+                "object_name": settings.value("object_name"),
+                "widget_class": settings.value("widget_class"),
+                "closable": settings.value("closable", type=bool),
+                "floatable": settings.value("floatable", type=bool),
+                "movable": settings.value("movable", type=bool),
+            }
+        )
+    settings.endArray()
+    return items

bec_widgets/widgets/containers/advanced_dock_area/toolbar_components/workspace_actions.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from bec_qthemes import material_icon
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QComboBox, QSizePolicy, QWidget
+
+from bec_widgets import SafeSlot
+from bec_widgets.utils.toolbars.actions import MaterialIconAction, WidgetAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle, ToolbarComponents
+from bec_widgets.utils.toolbars.connections import BundleConnection
+from bec_widgets.widgets.containers.advanced_dock_area.profile_utils import (
+    is_profile_readonly,
+    list_profiles,
+)
+
+
+class ProfileComboBox(QComboBox):
+    """Custom combobox that displays icons for read-only profiles."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+
+    def refresh_profiles(self):
+        """Refresh the profile list with appropriate icons."""
+
+        current_text = self.currentText()
+        self.blockSignals(True)
+        self.clear()
+
+        lock_icon = material_icon("edit_off", size=(16, 16), convert_to_pixmap=False)
+
+        for profile in list_profiles():
+            if is_profile_readonly(profile):
+                self.addItem(lock_icon, f"{profile}")
+                # Set tooltip for read-only profiles
+                self.setItemData(self.count() - 1, "Read-only profile", Qt.ToolTipRole)
+            else:
+                self.addItem(profile)
+
+        # Restore selection if possible
+        index = self.findText(current_text)
+        if index >= 0:
+            self.setCurrentIndex(index)
+
+        self.blockSignals(False)
+
+
+def workspace_bundle(components: ToolbarComponents) -> ToolbarBundle:
+    """
+    Creates a workspace toolbar bundle for AdvancedDockArea.
+
+    Args:
+        components (ToolbarComponents): The components to be added to the bundle.
+
+    Returns:
+        ToolbarBundle: The workspace toolbar bundle.
+    """
+    # Lock icon action
+    components.add_safe(
+        "lock",
+        MaterialIconAction(
+            icon_name="lock_open_right",
+            tooltip="Lock Workspace",
+            checkable=True,
+            parent=components.toolbar,
+        ),
+    )
+
+    # Workspace combo
+    combo = ProfileComboBox(parent=components.toolbar)
+    components.add_safe("workspace_combo", WidgetAction(widget=combo, adjust_size=False))
+
+    # Save the current workspace icon
+    components.add_safe(
+        "save_workspace",
+        MaterialIconAction(
+            icon_name="save",
+            tooltip="Save Current Workspace",
+            checkable=False,
+            parent=components.toolbar,
+        ),
+    )
+    # Delete workspace icon
+    components.add_safe(
+        "refresh_workspace",
+        MaterialIconAction(
+            icon_name="refresh",
+            tooltip="Refresh Current Workspace",
+            checkable=False,
+            parent=components.toolbar,
+        ),
+    )
+    # Delete workspace icon
+    components.add_safe(
+        "delete_workspace",
+        MaterialIconAction(
+            icon_name="delete",
+            tooltip="Delete Current Workspace",
+            checkable=False,
+            parent=components.toolbar,
+        ),
+    )
+
+    bundle = ToolbarBundle("workspace", components)
+    bundle.add_action("lock")
+    bundle.add_action("workspace_combo")
+    bundle.add_action("save_workspace")
+    bundle.add_action("refresh_workspace")
+    bundle.add_action("delete_workspace")
+    return bundle
+
+
+class WorkspaceConnection(BundleConnection):
+    """
+    Connection class for workspace actions in AdvancedDockArea.
+    """
+
+    def __init__(self, components: ToolbarComponents, target_widget=None):
+        super().__init__(parent=components.toolbar)
+        self.bundle_name = "workspace"
+        self.components = components
+        self.target_widget = target_widget
+        if not hasattr(self.target_widget, "lock_workspace"):
+            raise AttributeError("Target widget must implement 'lock_workspace'.")
+        self._connected = False
+
+    def connect(self):
+        self._connected = True
+        # Connect the action to the target widget's method
+        self.components.get_action("lock").action.toggled.connect(self._lock_workspace)
+        self.components.get_action("save_workspace").action.triggered.connect(
+            self.target_widget.save_profile
+        )
+        self.components.get_action("workspace_combo").widget.currentTextChanged.connect(
+            self.target_widget.load_profile
+        )
+        self.components.get_action("refresh_workspace").action.triggered.connect(
+            self._refresh_workspace
+        )
+        self.components.get_action("delete_workspace").action.triggered.connect(
+            self.target_widget.delete_profile
+        )
+
+    def disconnect(self):
+        if not self._connected:
+            return
+        # Disconnect the action from the target widget's method
+        self.components.get_action("lock").action.toggled.disconnect(self._lock_workspace)
+        self.components.get_action("save_workspace").action.triggered.disconnect(
+            self.target_widget.save_profile
+        )
+        self.components.get_action("workspace_combo").widget.currentTextChanged.disconnect(
+            self.target_widget.load_profile
+        )
+        self.components.get_action("refresh_workspace").action.triggered.disconnect(
+            self._refresh_workspace
+        )
+        self.components.get_action("delete_workspace").action.triggered.disconnect(
+            self.target_widget.delete_profile
+        )
+        self._connected = False
+
+    @SafeSlot(bool)
+    def _lock_workspace(self, value: bool):
+        """
+        Switches the workspace lock state and change the icon accordingly.
+        """
+        setattr(self.target_widget, "lock_workspace", value)
+        self.components.get_action("lock").action.setChecked(value)
+        icon = material_icon(
+            "lock" if value else "lock_open_right", size=(20, 20), convert_to_pixmap=False
+        )
+        self.components.get_action("lock").action.setIcon(icon)
+
+    @SafeSlot()
+    def _refresh_workspace(self):
+        """
+        Refreshes the current workspace.
+        """
+        combo = self.components.get_action("workspace_combo").widget
+        current_workspace = combo.currentText()
+        self.target_widget.load_profile(current_workspace)

bec_widgets/widgets/containers/dock/dock_area.py

@@ -616,10 +616,10 @@ if __name__ == "__main__":  # pragma: no cover
 
     import sys
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication([])
-    set_theme("auto")
+    apply_theme("dark")
     dock_area = BECDockArea()
     dock_1 = dock_area.new(name="dock_0", widget="DarkModeButton")
     dock_1.new(widget="DarkModeButton")

bec_widgets/widgets/containers/main_window/main_window.py

@@ -19,7 +19,7 @@ from qtpy.QtWidgets import (
 import bec_widgets
 from bec_widgets.utils import UILoader
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import apply_theme, set_theme
+from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.widget_io import WidgetHierarchy
 from bec_widgets.widgets.containers.main_window.addons.hover_widget import HoverWidget
@@ -357,7 +357,7 @@ class BECMainWindow(BECWidget, QMainWindow):
 
         ########################################
         # Theme menu
-        theme_menu = menu_bar.addMenu("Theme")
+        theme_menu = menu_bar.addMenu("View")
 
         theme_group = QActionGroup(self)
         light_theme_action = QAction("Light Theme", self, checkable=True)
@@ -374,11 +374,12 @@ class BECMainWindow(BECWidget, QMainWindow):
         dark_theme_action.triggered.connect(lambda: self.change_theme("dark"))
 
         # Set the default theme
-        theme = self.app.theme.theme
-        if theme == "light":
-            light_theme_action.setChecked(True)
-        elif theme == "dark":
-            dark_theme_action.setChecked(True)
+        if hasattr(self.app, "theme") and self.app.theme:
+            theme_name = self.app.theme.theme.lower()
+            if "light" in theme_name:
+                light_theme_action.setChecked(True)
+            elif "dark" in theme_name:
+                dark_theme_action.setChecked(True)
 
         ########################################
         # Help menu
@@ -448,7 +449,7 @@ class BECMainWindow(BECWidget, QMainWindow):
         Args:
             theme(str): Either "light" or "dark".
         """
-        set_theme(theme)  # emits theme_updated and applies palette globally
+        apply_theme(theme)  # emits theme_updated and applies palette globally
 
     def event(self, event):
         if event.type() == QEvent.Type.StatusTip:

bec_widgets/widgets/control/buttons/button_abort/button_abort.py

@@ -38,9 +38,6 @@ class AbortButton(BECWidget, QWidget):
         else:
             self.button = QPushButton()
             self.button.setText("Abort")
-            self.button.setStyleSheet(
-                "background-color:  #666666; color: white; font-weight: bold; font-size: 12px;"
-            )
         self.button.clicked.connect(self.abort_scan)
 
         self.layout.addWidget(self.button)

bec_widgets/widgets/control/buttons/stop_button/stop_button.py

@@ -31,9 +31,7 @@ class StopButton(BECWidget, QWidget):
             self.button = QPushButton()
             self.button.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
             self.button.setText("Stop")
-            self.button.setStyleSheet(
-                f"background-color:  #cc181e; color: white; font-weight: bold; font-size: 12px;"
-            )
+            self.button.setProperty("variant", "danger")
         self.button.clicked.connect(self.stop_scan)
 
         self.layout.addWidget(self.button)

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

@@ -12,7 +12,7 @@ from qtpy.QtGui import QDoubleValidator
 from qtpy.QtWidgets import QDoubleSpinBox
 
 from bec_widgets.utils import UILoader
-from bec_widgets.utils.colors import get_accent_colors, set_theme
+from bec_widgets.utils.colors import apply_theme, get_accent_colors
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 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 (
@@ -33,7 +33,7 @@ class PositionerBox(PositionerBoxBase):
     PLUGIN = True
     RPC = True
 
-    USER_ACCESS = ["set_positioner", "screenshot"]
+    USER_ACCESS = ["set_positioner", "attach", "detach", "screenshot"]
     device_changed = Signal(str, str)
     # Signal emitted to inform listeners about a position update
     position_update = Signal(float)
@@ -259,7 +259,7 @@ if __name__ == "__main__":  # pragma: no cover
     from qtpy.QtWidgets import QApplication  # pylint: disable=ungrouped-imports
 
     app = QApplication(sys.argv)
-    set_theme("dark")
+    apply_theme("dark")
     widget = PositionerBox(device="bpm4i")
 
     widget.show()

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

@@ -13,7 +13,7 @@ from qtpy.QtGui import QDoubleValidator
 from qtpy.QtWidgets import QDoubleSpinBox
 
 from bec_widgets.utils import UILoader
-from bec_widgets.utils.colors import set_theme
+from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 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 (
@@ -34,7 +34,7 @@ class PositionerBox2D(PositionerBoxBase):
 
     PLUGIN = True
     RPC = True
-    USER_ACCESS = ["set_positioner_hor", "set_positioner_ver", "screenshot"]
+    USER_ACCESS = ["set_positioner_hor", "set_positioner_ver", "attach", "detach", "screenshot"]
 
     device_changed_hor = Signal(str, str)
     device_changed_ver = Signal(str, str)
@@ -478,7 +478,7 @@ if __name__ == "__main__":  # pragma: no cover
     from qtpy.QtWidgets import QApplication  # pylint: disable=ungrouped-imports
 
     app = QApplication(sys.argv)
-    set_theme("dark")
+    apply_theme("dark")
     widget = PositionerBox2D()
 
     widget.show()

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

@@ -62,7 +62,7 @@ class PositionerGroup(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "grid_view"
-    USER_ACCESS = ["set_positioners"]
+    USER_ACCESS = ["set_positioners", "attach", "detach", "screenshot"]
 
     # Signal emitted to inform listeners about a position update of the first positioner
     position_update = Signal(float)

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

@@ -147,24 +147,6 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
         dev_name = self.currentText()
         return self.get_device_object(dev_name)
 
-    def paintEvent(self, event: QPaintEvent) -> None:
-        """Extend the paint event to set the border color based on the validity of the input.
-
-        Args:
-            event (PySide6.QtGui.QPaintEvent) : Paint event.
-        """
-        # logger.info(f"Received paint event: {event} in {self.__class__}")
-        super().paintEvent(event)
-
-        if self._is_valid_input is False and self.isEnabled() is True:
-            painter = QPainter(self)
-            pen = QPen()
-            pen.setWidth(2)
-            pen.setColor(self._accent_colors.emergency)
-            painter.setPen(pen)
-            painter.drawRect(self.rect().adjusted(1, 1, -1, -1))
-            painter.end()
-
     @Slot(str)
     def check_validity(self, input_text: str) -> None:
         """
@@ -173,10 +155,12 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
         if self.validate_device(input_text) is True:
             self._is_valid_input = True
             self.device_selected.emit(input_text)
+            self.setStyleSheet("border: 1px solid transparent;")
         else:
             self._is_valid_input = False
             self.device_reset.emit()
-        self.update()
+            if self.isEnabled():
+                self.setStyleSheet("border: 1px solid red;")
 
     def validate_device(self, device: str) -> bool:  # type: ignore[override]
         """
@@ -202,10 +186,10 @@ if __name__ == "__main__":  # pragma: no cover
     # pylint: disable=import-outside-toplevel
     from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication([])
-    set_theme("dark")
+    apply_theme("dark")
     widget = QWidget()
     widget.setFixedSize(200, 200)
     layout = QVBoxLayout()

bec_widgets/widgets/control/device_input/device_line_edit/device_line_edit.py

@@ -175,13 +175,13 @@ if __name__ == "__main__":  # pragma: no cover
     # pylint: disable=import-outside-toplevel
     from qtpy.QtWidgets import QVBoxLayout, QWidget
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
     from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import (
         SignalComboBox,
     )
 
     app = QApplication([])
-    set_theme("dark")
+    apply_theme("dark")
     widget = QWidget()
     widget.setFixedSize(200, 200)
     layout = QVBoxLayout()

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

@@ -179,10 +179,10 @@ if __name__ == "__main__":  # pragma: no cover
     # pylint: disable=import-outside-toplevel
     from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication([])
-    set_theme("dark")
+    apply_theme("dark")
     widget = QWidget()
     widget.setFixedSize(200, 200)
     layout = QVBoxLayout()

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

@@ -147,13 +147,13 @@ if __name__ == "__main__":  # pragma: no cover
     # pylint: disable=import-outside-toplevel
     from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
     from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import (
         DeviceComboBox,
     )
 
     app = QApplication([])
-    set_theme("dark")
+    apply_theme("dark")
     widget = QWidget()
     widget.setFixedSize(200, 200)
     layout = QVBoxLayout()

bec_widgets/widgets/control/device_manager/components/__init__.py

@@ -0,0 +1,4 @@
+from .device_table_view import DeviceTableView
+from .dm_config_view import DMConfigView
+from .dm_docstring_view import DocstringView
+from .dm_ophyd_test import DMOphydTest

bec_widgets/widgets/control/device_manager/components/device_table_view.py

@@ -3,16 +3,18 @@
 from __future__ import annotations
 
 import copy
-import json
+import time
 
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from qtpy import QtCore, QtGui, QtWidgets
 from thefuzz import fuzz
 
+from bec_widgets.utils.bec_signal_proxy import BECSignalProxy
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import get_accent_colors
+from bec_widgets.utils.colors import get_accent_colors, get_theme_palette
 from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.control.device_manager.components.dm_ophyd_test import ValidationStatus
 
 logger = bec_logger.logger
 
@@ -23,34 +25,32 @@ FUZZY_SEARCH_THRESHOLD = 80
 class DictToolTipDelegate(QtWidgets.QStyledItemDelegate):
     """Delegate that shows all key-value pairs of a rows's data as a YAML-like tooltip."""
 
-    @staticmethod
-    def dict_to_str(d: dict) -> str:
-        """Convert a dictionary to a formatted string."""
-        return json.dumps(d, indent=4)
-
     def helpEvent(self, event, view, option, index):
         """Override to show tooltip when hovering."""
         if event.type() != QtCore.QEvent.ToolTip:
             return super().helpEvent(event, view, option, index)
         model: DeviceFilterProxyModel = index.model()
         model_index = model.mapToSource(index)
-        row_dict = model.sourceModel().row_data(model_index)
-        row_dict.pop("description", None)
-        QtWidgets.QToolTip.showText(event.globalPos(), self.dict_to_str(row_dict), view)
+        row_dict = model.sourceModel().get_row_data(model_index)
+        description = row_dict.get("description", "")
+        QtWidgets.QToolTip.showText(event.globalPos(), description, view)
         return True
 
 
 class CenterCheckBoxDelegate(DictToolTipDelegate):
     """Custom checkbox delegate to center checkboxes in table cells."""
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, colors=None):
         super().__init__(parent)
-        colors = get_accent_colors()
+        self._colors = colors if colors else get_accent_colors()
         self._icon_checked = material_icon(
-            "check_box", size=QtCore.QSize(16, 16), color=colors.default
+            "check_box", size=QtCore.QSize(16, 16), color=self._colors.default, filled=True
         )
         self._icon_unchecked = material_icon(
-            "check_box_outline_blank", size=QtCore.QSize(16, 16), color=colors.default
+            "check_box_outline_blank",
+            size=QtCore.QSize(16, 16),
+            color=self._colors.default,
+            filled=True,
         )
 
     def apply_theme(self, theme: str | None = None):
@@ -81,9 +81,51 @@ class CenterCheckBoxDelegate(DictToolTipDelegate):
         return model.setData(index, new_state, QtCore.Qt.CheckStateRole)
 
 
+class DeviceValidatedDelegate(DictToolTipDelegate):
+    """Custom delegate for displaying validated device configurations."""
+
+    def __init__(self, parent=None, colors=None):
+        super().__init__(parent)
+        self._colors = colors if colors else get_accent_colors()
+        self._icons = {
+            ValidationStatus.PENDING: material_icon(
+                icon_name="circle", size=(12, 12), color=self._colors.default, filled=True
+            ),
+            ValidationStatus.VALID: material_icon(
+                icon_name="circle", size=(12, 12), color=self._colors.success, filled=True
+            ),
+            ValidationStatus.FAILED: material_icon(
+                icon_name="circle", size=(12, 12), color=self._colors.emergency, filled=True
+            ),
+        }
+
+    def apply_theme(self, theme: str | None = None):
+        colors = get_accent_colors()
+        for status, icon in self._icons.items():
+            icon.setColor(colors[status])
+
+    def paint(self, painter, option, index):
+        status = index.model().data(index, QtCore.Qt.DisplayRole)
+        if status is None:
+            return super().paint(painter, option, index)
+
+        pixmap = self._icons.get(status)
+        if pixmap:
+            rect = option.rect
+            pix_rect = pixmap.rect()
+            pix_rect.moveCenter(rect.center())
+            painter.drawPixmap(pix_rect.topLeft(), pixmap)
+
+        super().paint(painter, option, index)
+
+
 class WrappingTextDelegate(DictToolTipDelegate):
     """Custom delegate for wrapping text in table cells."""
 
+    def __init__(self, table: BECTableView, parent=None):
+        super().__init__(parent)
+        self._table = table
+
     def paint(self, painter, option, index):
         text = index.model().data(index, QtCore.Qt.DisplayRole)
         if not text:
@@ -97,12 +139,14 @@ class WrappingTextDelegate(DictToolTipDelegate):
 
     def sizeHint(self, option, index):
         text = str(index.model().data(index, QtCore.Qt.DisplayRole) or "")
-        # if not text:
-        #     return super().sizeHint(option, index)
+        column_width = self._table.columnWidth(index.column()) - 8  # -4 & 4
 
-        # Use the actual column width
-        table = index.model().parent()  # or store reference to QTableView
-        column_width = table.columnWidth(index.column())  # - 8
+        # Avoid pathological heights for too-narrow columns
+        min_width = option.fontMetrics.averageCharWidth() * 4
+        if column_width < min_width:
+            fm = QtGui.QFontMetrics(option.font)
+            elided = fm.elidedText(text, QtCore.Qt.ElideRight, column_width)
+            return QtCore.QSize(column_width, fm.height() + 4)
 
         doc = QtGui.QTextDocument()
         doc.setDefaultFont(option.font)
@@ -110,8 +154,25 @@ class WrappingTextDelegate(DictToolTipDelegate):
         doc.setPlainText(text)
 
         layout_height = doc.documentLayout().documentSize().height()
-        height = int(layout_height) + 4  # Needs some extra padding, otherwise it gets cut off
-        return QtCore.QSize(column_width, height)
+        return QtCore.QSize(column_width, int(layout_height) + 4)
+
+    # def sizeHint(self, option, index):
+    #     text = str(index.model().data(index, QtCore.Qt.DisplayRole) or "")
+    #     # if not text:
+    #     #     return super().sizeHint(option, index)
+
+    #     # Use the actual column width
+    #     table = index.model().parent()  # or store reference to QTableView
+    #     column_width = table.columnWidth(index.column())  # - 8
+
+    #     doc = QtGui.QTextDocument()
+    #     doc.setDefaultFont(option.font)
+    #     doc.setTextWidth(column_width)
+    #     doc.setPlainText(text)
+
+    #     layout_height = doc.documentLayout().documentSize().height()
+    #     height = int(layout_height) + 4  # Needs some extra padding, otherwise it gets cut off
+    #     return QtCore.QSize(column_width, height)
 
 
 class DeviceTableModel(QtCore.QAbstractTableModel):
@@ -121,17 +182,22 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
     Sort logic is implemented directly on the data of the table view.
     """
 
-    def __init__(self, device_config: list[dict] | None = None, parent=None):
+    device_configs_added = QtCore.Signal(dict)  # Dict[str, dict] of configs that were added
+    devices_removed = QtCore.Signal(list)  # List of strings with device names that were removed
+
+    def __init__(self, parent=None):
         super().__init__(parent)
-        self._device_config = device_config or []
+        self._device_config: dict[str, dict] = {}
+        self._list_items: list[dict] = []
+        self._validation_status: dict[str, ValidationStatus] = {}
         self.headers = [
+            "",
             "name",
             "deviceClass",
             "readoutPriority",
+            "deviceTags",
             "enabled",
             "readOnly",
-            "deviceTags",
-            "description",
         ]
         self._checkable_columns_enabled = {"enabled": True, "readOnly": True}
 
@@ -140,7 +206,7 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
     ###############################################
 
     def rowCount(self, parent=QtCore.QModelIndex()) -> int:
-        return len(self._device_config)
+        return len(self._list_items)
 
     def columnCount(self, parent=QtCore.QModelIndex()) -> int:
         return len(self.headers)
@@ -150,25 +216,32 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
             return self.headers[section]
         return None
 
-    def row_data(self, index: QtCore.QModelIndex) -> dict:
+    def get_row_data(self, index: QtCore.QModelIndex) -> dict:
         """Return the row data for the given index."""
         if not index.isValid():
             return {}
-        return copy.deepcopy(self._device_config[index.row()])
+        return copy.deepcopy(self._list_items[index.row()])
 
     def data(self, index, role=QtCore.Qt.DisplayRole):
         """Return data for the given index and role."""
         if not index.isValid():
             return None
         row, col = index.row(), index.column()
+
+        if col == 0 and role == QtCore.Qt.DisplayRole:  # QtCore.Qt.DisplayRole:
+            dev_name = self._list_items[row].get("name", "")
+            return self._validation_status.get(dev_name, ValidationStatus.PENDING)
+
         key = self.headers[col]
-        value = self._device_config[row].get(key)
+        value = self._list_items[row].get(key)
 
         if role == QtCore.Qt.DisplayRole:
             if key in ("enabled", "readOnly"):
                 return bool(value)
             if key == "deviceTags":
                 return ", ".join(str(tag) for tag in value) if value else ""
+            if key == "deviceClass":
+                return str(value).split(".")[-1]
             return str(value) if value is not None else ""
         if role == QtCore.Qt.CheckStateRole and key in ("enabled", "readOnly"):
             return QtCore.Qt.Checked if value else QtCore.Qt.Unchecked
@@ -215,7 +288,7 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
         if key in ("enabled", "readOnly") and role == QtCore.Qt.CheckStateRole:
             if not self._checkable_columns_enabled.get(key, True):
                 return False  # ignore changes if column is disabled
-            self._device_config[row][key] = value == QtCore.Qt.Checked
+            self._list_items[row][key] = value == QtCore.Qt.Checked
             self.dataChanged.emit(index, index, [QtCore.Qt.CheckStateRole])
             return True
         return False
@@ -224,87 +297,115 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
     ############ Public methods ########
     ####################################
 
-    def get_device_config(self) -> list[dict]:
-        """Return the current device config (with checkbox updates applied)."""
+    def get_device_config(self) -> dict[str, dict]:
+        """Method to get the device configuration."""
         return self._device_config
 
-    def set_checkbox_enabled(self, column_name: str, enabled: bool):
+    def add_device_configs(self, device_configs: dict[str, dict]):
         """
-        Enable/Disable the checkbox column.
+        Add devices to the model.
 
         Args:
-            column_name (str): The name of the column to modify.
-            enabled (bool): Whether the checkbox should be enabled or disabled.
+            device_configs (dict[str, dict]): A dictionary of device configurations to add.
         """
-        if column_name in self._checkable_columns_enabled:
-            self._checkable_columns_enabled[column_name] = enabled
-            col = self.headers.index(column_name)
-            top_left = self.index(0, col)
-            bottom_right = self.index(self.rowCount() - 1, col)
-            self.dataChanged.emit(
-                top_left, bottom_right, [QtCore.Qt.CheckStateRole, QtCore.Qt.DisplayRole]
-            )
+        already_in_list = []
+        for k, cfg in device_configs.items():
+            if k in self._device_config:
+                logger.warning(f"Device {k} already exists in the model.")
+                already_in_list.append(k)
+                continue
+            self._device_config[k] = cfg
+            new_list_cfg = copy.deepcopy(cfg)
+            new_list_cfg["name"] = k
+            row = len(self._list_items)
+            self.beginInsertRows(QtCore.QModelIndex(), row, row)
+            self._list_items.append(new_list_cfg)
+            self.endInsertRows()
+        for k in already_in_list:
+            device_configs.pop(k)
+        self.device_configs_added.emit(device_configs)
 
-    def set_device_config(self, device_config: list[dict]):
+    def set_device_config(self, device_configs: dict[str, dict]):
         """
         Replace the device config.
 
         Args:
-            device_config (list[dict]): The new device config to set.
+            device_config (dict[str, dict]): The new device config to set.
         """
+        diff_names = set(device_configs.keys()) - set(self._device_config.keys())
         self.beginResetModel()
-        self._device_config = list(device_config)
+        self._device_config.clear()
+        self._list_items.clear()
+        for k, cfg in device_configs.items():
+            self._device_config[k] = cfg
+            new_list_cfg = copy.deepcopy(cfg)
+            new_list_cfg["name"] = k
+            self._list_items.append(new_list_cfg)
         self.endResetModel()
+        self.devices_removed.emit(diff_names)
+        self.device_configs_added.emit(device_configs)
 
-    @SafeSlot(dict)
-    def add_device(self, device: dict):
+    def remove_device_configs(self, device_configs: dict[str, dict]):
         """
-        Add an extra device to the device config at the bottom.
+        Remove devices from the model.
 
         Args:
-            device (dict): The device configuration to add.
+            device_configs (dict[str, dict]): A dictionary of device configurations to remove.
         """
-        row = len(self._device_config)
-        self.beginInsertRows(QtCore.QModelIndex(), row, row)
-        self._device_config.append(device)
-        self.endInsertRows()
-
-    @SafeSlot(int)
-    def remove_device_by_row(self, row: int):
-        """
-        Remove one device row by index. This maps to the row to the source of the data model
-
-        Args:
-            row (int): The index of the device row to remove.
-        """
-        if 0 <= row < len(self._device_config):
+        removed = []
+        for k in device_configs.keys():
+            if k not in self._device_config:
+                logger.warning(f"Device {k} does not exist in the model.")
+                continue
+            new_cfg = self._device_config.pop(k)
+            new_cfg["name"] = k
+            row = self._list_items.index(new_cfg)
             self.beginRemoveRows(QtCore.QModelIndex(), row, row)
-            self._device_config.pop(row)
+            self._list_items.pop(row)
             self.endRemoveRows()
+            removed.append(k)
+        self.devices_removed.emit(removed)
 
-    @SafeSlot(list)
-    def remove_devices_by_rows(self, rows: list[int]):
+    def clear_table(self):
         """
-        Remove multiple device rows by their indices.
+        Clear the table.
+        """
+        device_names = list(self._device_config.keys())
+        self.beginResetModel()
+        self._device_config.clear()
+        self._list_items.clear()
+        self.endResetModel()
+        self.devices_removed.emit(device_names)
+
+    def update_validation_status(self, device_name: str, status: int | ValidationStatus):
+        """
+        Handle device status changes.
 
         Args:
-            rows (list[int]): The indices of the device rows to remove.
+            device_name (str): The name of the device.
+            status (int): The new status of the device.
         """
-        for row in sorted(rows, reverse=True):
-            self.remove_device_by_row(row)
-
-    @SafeSlot(str)
-    def remove_device_by_name(self, name: str):
-        """
-        Remove one device row by name.
-
-        Args:
-            name (str): The name of the device to remove.
-        """
-        for row, device in enumerate(self._device_config):
-            if device.get("name") == name:
-                self.remove_device_by_row(row)
+        if isinstance(status, int):
+            status = ValidationStatus(status)
+        if device_name not in self._device_config:
+            logger.warning(
+                f"Device {device_name} not found in device_config dict {self._device_config}"
+            )
+            return
+        self._validation_status[device_name] = status
+        row = None
+        for ii, item in enumerate(self._list_items):
+            if item["name"] == device_name:
+                row = ii
                 break
+        if row is None:
+            logger.warning(
+                f"Device {device_name} not found in device_status dict {self._validation_status}"
+            )
+            return
+        # Emit dataChanged for column 0 (status column)
+        index = self.index(row, 0)
+        self.dataChanged.emit(index, index, [QtCore.Qt.DisplayRole])
 
 
 class BECTableView(QtWidgets.QTableView):
@@ -324,12 +425,7 @@ class BECTableView(QtWidgets.QTableView):
         if not proxy_indexes:
             return
 
-        # Get unique rows (proxy indices) in reverse order so removal indexes stay valid
-        proxy_rows = sorted({idx.row() for idx in proxy_indexes}, reverse=True)
-        # Map to source model rows
-        source_rows = [
-            self.model().mapToSource(self.model().index(row, 0)).row() for row in proxy_rows
-        ]
+        source_rows = self._get_source_rows(proxy_indexes)
 
         model: DeviceTableModel = self.model().sourceModel()  # access underlying model
         # Delegate confirmation and removal to helper
@@ -337,14 +433,28 @@ class BECTableView(QtWidgets.QTableView):
         if not removed:
             return
 
+    def _get_source_rows(self, proxy_indexes: list[QtWidgets.QModelIndex]) -> list[int]:
+        """
+        Map proxy model indices to source model row indices.
+
+        Args:
+            proxy_indexes (list[QModelIndex]): List of proxy model indices.
+
+        Returns:
+            list[int]: List of source model row indices.
+        """
+        proxy_rows = sorted({idx for idx in proxy_indexes}, reverse=True)
+        source_rows = [self.model().mapToSource(idx).row() for idx in proxy_rows]
+        return list(set(source_rows))
+
     def _confirm_and_remove_rows(self, model: DeviceTableModel, source_rows: list[int]) -> bool:
         """
         Prompt the user to confirm removal of rows and remove them from the model if accepted.
 
         Returns True if rows were removed, False otherwise.
         """
-        cfg = model.get_device_config()
-        names = [str(cfg[r].get("name", "<unknown>")) for r in sorted(source_rows)]
+        configs = [model._list_items[r] for r in sorted(source_rows)]
+        names = [cfg.get("name", "<unknown>") for cfg in configs]
 
         msg = QtWidgets.QMessageBox(self)
         msg.setIcon(QtWidgets.QMessageBox.Warning)
@@ -359,8 +469,8 @@ class BECTableView(QtWidgets.QTableView):
 
         res = msg.exec_()
         if res == QtWidgets.QMessageBox.Ok:
-            model.remove_devices_by_rows(source_rows)
-            # TODO add signal for removed devices
+            configs_to_be_removed = {model._device_config[name] for name in names}
+            model.remove_device_configs(configs_to_be_removed)
             return True
         return False
 
@@ -372,7 +482,7 @@ class DeviceFilterProxyModel(QtCore.QSortFilterProxyModel):
         self._hidden_rows = set()
         self._filter_text = ""
         self._enable_fuzzy = True
-        self._filter_columns = [0, 1]  # name and deviceClass for search
+        self._filter_columns = [1, 2]  # name and deviceClass for search
 
     def hide_rows(self, row_indices: list[int]):
         """
@@ -436,9 +546,12 @@ class DeviceFilterProxyModel(QtCore.QSortFilterProxyModel):
 class DeviceTableView(BECWidget, QtWidgets.QWidget):
     """Device Table View for the device manager."""
 
+    selected_device = QtCore.Signal(dict)  # Selected device configuration dict[str,dict]
+    device_configs_added = QtCore.Signal(dict)  # Dict[str, dict] of configs that were added
+    devices_removed = QtCore.Signal(list)  # List of strings with device names that were removed
+
     RPC = False
     PLUGIN = False
-    devices_removed = QtCore.Signal(list)
 
     def __init__(self, parent=None, client=None):
         super().__init__(client=client, parent=parent, theme_update=True)
@@ -455,6 +568,10 @@ class DeviceTableView(BECWidget, QtWidgets.QWidget):
         self.layout.addLayout(self.search_controls)
         self.layout.addWidget(self.table)
 
+        # Connect signals
+        self._model.devices_removed.connect(self.devices_removed.emit)
+        self._model.device_configs_added.connect(self.device_configs_added.emit)
+
     def _setup_search(self):
         """Create components related to the search functionality"""
 
@@ -495,137 +612,199 @@ class DeviceTableView(BECWidget, QtWidgets.QWidget):
         """Setup the table view."""
         # Model + Proxy
         self.table = BECTableView(self)
-        self.model = DeviceTableModel(parent=self.table)
+        self._model = DeviceTableModel(parent=self.table)
         self.proxy = DeviceFilterProxyModel(parent=self.table)
-        self.proxy.setSourceModel(self.model)
+        self.proxy.setSourceModel(self._model)
         self.table.setModel(self.proxy)
         self.table.setSortingEnabled(True)
 
         # Delegates
-        self.checkbox_delegate = CenterCheckBoxDelegate(self.table)
+        colors = get_accent_colors()
+        self.checkbox_delegate = CenterCheckBoxDelegate(self.table, colors=colors)
         self.wrap_delegate = WrappingTextDelegate(self.table)
         self.tool_tip_delegate = DictToolTipDelegate(self.table)
-        self.table.setItemDelegateForColumn(0, self.tool_tip_delegate)  # name
-        self.table.setItemDelegateForColumn(1, self.tool_tip_delegate)  # deviceClass
-        self.table.setItemDelegateForColumn(2, self.tool_tip_delegate)  # readoutPriority
-        self.table.setItemDelegateForColumn(3, self.checkbox_delegate)  # enabled
-        self.table.setItemDelegateForColumn(4, self.checkbox_delegate)  # readOnly
-        self.table.setItemDelegateForColumn(5, self.wrap_delegate)  # deviceTags
-        self.table.setItemDelegateForColumn(6, self.wrap_delegate)  # description
+        self.validated_delegate = DeviceValidatedDelegate(self.table, colors=colors)
+        self.table.setItemDelegateForColumn(0, self.validated_delegate)  # ValidationStatus
+        self.table.setItemDelegateForColumn(1, self.tool_tip_delegate)  # name
+        self.table.setItemDelegateForColumn(2, self.tool_tip_delegate)  # deviceClass
+        self.table.setItemDelegateForColumn(3, self.tool_tip_delegate)  # readoutPriority
+        self.table.setItemDelegateForColumn(4, self.wrap_delegate)  # deviceTags
+        self.table.setItemDelegateForColumn(5, self.checkbox_delegate)  # enabled
+        self.table.setItemDelegateForColumn(6, self.checkbox_delegate)  # readOnly
 
         # Column resize policies
-        # TODO maybe we need here a flexible header options as deviceClass
-        # may get quite long for beamlines plugin repos
         header = self.table.horizontalHeader()
-        header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)  # name
-        header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeToContents)  # deviceClass
-        header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeToContents)  # readoutPriority
-        header.setSectionResizeMode(3, QtWidgets.QHeaderView.Fixed)  # enabled
-        header.setSectionResizeMode(4, QtWidgets.QHeaderView.Fixed)  # readOnly
-        # TODO maybe better stretch...
-        header.setSectionResizeMode(5, QtWidgets.QHeaderView.ResizeToContents)  # deviceTags
-        header.setSectionResizeMode(6, QtWidgets.QHeaderView.Stretch)  # description
-        self.table.setColumnWidth(3, 82)
-        self.table.setColumnWidth(4, 82)
+        header.setSectionResizeMode(0, QtWidgets.QHeaderView.Fixed)  # ValidationStatus
+        header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeToContents)  # name
+        header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeToContents)  # deviceClass
+        header.setSectionResizeMode(3, QtWidgets.QHeaderView.ResizeToContents)  # readoutPriority
+        header.setSectionResizeMode(4, QtWidgets.QHeaderView.Stretch)  # deviceTags
+        header.setSectionResizeMode(5, QtWidgets.QHeaderView.Fixed)  # enabled
+        header.setSectionResizeMode(6, QtWidgets.QHeaderView.Fixed)  # readOnly
+
+        self.table.setColumnWidth(0, 25)
+        self.table.setColumnWidth(5, 70)
+        self.table.setColumnWidth(6, 70)
 
         # Ensure column widths stay fixed
-        header.setMinimumSectionSize(70)
+        header.setMinimumSectionSize(25)
         header.setDefaultSectionSize(90)
 
         # Enable resizing of column
-        header.sectionResized.connect(self.on_table_resized)
+        self._geometry_resize_proxy = BECSignalProxy(
+            header.geometriesChanged, rateLimit=10, slot=self._on_table_resized
+        )
 
         # Selection behavior
         self.table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
         self.table.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection)
+        # Connect to selection model to get selection changes
+        self.table.selectionModel().selectionChanged.connect(self._on_selection_changed)
         self.table.horizontalHeader().setHighlightSections(False)
 
         # QtCore.QTimer.singleShot(0, lambda: header.sectionResized.emit(0, 0, 0))
 
-    def device_config(self) -> list[dict]:
+    def get_device_config(self) -> dict[str, dict]:
         """Get the device config."""
-        return self.model.get_device_config()
+        return self._model.get_device_config()
 
     def apply_theme(self, theme: str | None = None):
         self.checkbox_delegate.apply_theme(theme)
+        self.validated_delegate.apply_theme(theme)
 
     ######################################
     ########### Slot API #################
     ######################################
 
-    @SafeSlot(int, int, int)
-    def on_table_resized(self, column, old_width, new_width):
+    @SafeSlot()
+    def _on_table_resized(self, *args):
         """Handle changes to the table column resizing."""
-        if column != len(self.model.headers) - 1:
+        option = QtWidgets.QStyleOptionViewItem()
+        model = self.table.model()
+        for row in range(model.rowCount()):
+            index = model.index(row, 4)
+            height = self.wrap_delegate.sizeHint(option, index).height()
+            self.table.setRowHeight(row, height)
+
+    @SafeSlot(QtCore.QItemSelection, QtCore.QItemSelection)
+    def _on_selection_changed(
+        self, selected: QtCore.QItemSelection, deselected: QtCore.QItemSelection
+    ) -> None:
+        """
+        Handle selection changes in the device table.
+
+        Args:
+            selected (QtCore.QItemSelection): The selected items.
+            deselected (QtCore.QItemSelection): The deselected items.
+        """
+        # TODO also hook up logic if a config update is propagated from somewhere!
+        # selected_indexes = selected.indexes()
+        selected_indexes = self.table.selectionModel().selectedIndexes()
+        if not selected_indexes:
             return
 
-        for row in range(self.table.model().rowCount()):
-            index = self.table.model().index(row, column)
-            delegate = self.table.itemDelegate(index)
-            option = QtWidgets.QStyleOptionViewItem()
-            height = delegate.sizeHint(option, index).height()
-            self.table.setRowHeight(row, height)
+        source_indexes = [self.proxy.mapToSource(idx) for idx in selected_indexes]
+        source_rows = {idx.row() for idx in source_indexes}
+        configs = [copy.deepcopy(self._model._list_items[r]) for r in sorted(source_rows)]
+        names = [cfg.pop("name") for cfg in configs]
+        selected_cfgs = {name: cfg for name, cfg in zip(names, configs)}
+        self.selected_device.emit(selected_cfgs)
 
     ######################################
     ##### Ext.  Slot API #################
     ######################################
 
-    @SafeSlot(list)
-    def set_device_config(self, config: list[dict]):
+    @SafeSlot(dict)
+    def set_device_config(self, device_configs: dict[str, dict]):
         """
         Set the device config.
 
         Args:
-            config (list[dict]): The device config to set.
+            config (dict[str,dict]): The device config to set.
         """
-        self.model.set_device_config(config)
+        self._model.set_device_config(device_configs)
 
     @SafeSlot()
-    def clear_device_config(self):
-        """
-        Clear the device config.
-        """
-        self.model.set_device_config([])
+    def clear_device_configs(self):
+        """Clear the device configs."""
+        self._model.clear_table()
 
     @SafeSlot(dict)
-    def add_device(self, device: dict):
+    def add_device_configs(self, device_configs: dict[str, dict]):
         """
-        Add a device to the config.
+        Add devices to the config.
 
         Args:
-            device (dict): The device to add.
+            device_configs (dict[str, dict]): The device configs to add.
         """
-        self.model.add_device(device)
+        self._model.add_device_configs(device_configs)
+
+    @SafeSlot(dict)
+    def remove_device_configs(self, device_configs: dict[str, dict]):
+        """
+        Remove devices from the config.
+
+        Args:
+            device_configs (dict[str, dict]): The device configs to remove.
+        """
+        self._model.remove_device_configs(device_configs)
 
-    @SafeSlot(int)
     @SafeSlot(str)
-    def remove_device(self, dev: int | str):
+    def remove_device(self, device_name: str):
         """
-        Remove the device from the config either by row id, or device name.
+        Remove a device from the config.
 
         Args:
-            dev (int | str): The device to remove, either by row id or device name.
+            device_name (str): The name of the device to remove.
         """
-        if isinstance(dev, int):
-            # TODO test this properly, check with proxy index and source index
-            # Use the proxy model to map to the correct row
-            model_source_index = self.table.model().mapToSource(self.table.model().index(dev, 0))
-            self.model.remove_device_by_row(model_source_index.row())
-            return
-        if isinstance(dev, str):
-            self.model.remove_device_by_name(dev)
+        cfg = self._model._device_config.get(device_name, None)
+        if cfg is None:
+            logger.warning(f"Device {device_name} not found in device_config dict")
             return
+        self._model.remove_device_configs({device_name: cfg})
+
+    @SafeSlot(str, int)
+    def update_device_validation(
+        self, device_name: str, validation_status: int | ValidationStatus
+    ) -> None:
+        """
+        Update the validation status of a device.
+
+        Args:
+            device_name (str): The name of the device.
+            validation_status (int | ValidationStatus): The new validation status.
+        """
+        self._model.update_validation_status(device_name, validation_status)
 
 
 if __name__ == "__main__":
     import sys
 
+    import numpy as np
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
+    widget = QtWidgets.QWidget()
+    layout = QtWidgets.QVBoxLayout(widget)
+    layout.setContentsMargins(0, 0, 0, 0)
     window = DeviceTableView()
+    layout.addWidget(window)
+    # QPushButton
+    button = QtWidgets.QPushButton("Test status_update")
+    layout.addWidget(button)
+
+    def _button_clicked():
+        names = list(window._model._device_config.keys())
+        for name in names:
+            window.update_device_validation(
+                name, ValidationStatus.VALID if np.random.rand() > 0.5 else ValidationStatus.FAILED
+            )
+
+    button.clicked.connect(_button_clicked)
     # pylint: disable=protected-access
     config = window.client.device_manager._get_redis_device_config()
-    window.set_device_config(config)
-    window.show()
+    names = [cfg.pop("name") for cfg in config]
+    config_dict = {name: cfg for name, cfg in zip(names, config)}
+    window.set_device_config(config_dict)
+    widget.show()
     sys.exit(app.exec_())

bec_widgets/widgets/control/device_manager/components/dm_config_view.py

@@ -0,0 +1,83 @@
+"""Module with a config view for the device manager."""
+
+from __future__ import annotations
+
+import traceback
+
+import yaml
+from bec_lib.logger import bec_logger
+from qtpy import QtCore, QtWidgets
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.colors import get_accent_colors, get_theme_palette
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.editors.monaco.monaco_widget import MonacoWidget
+
+logger = bec_logger.logger
+
+
+class DMConfigView(BECWidget, QtWidgets.QWidget):
+    def __init__(self, parent=None, client=None):
+        super().__init__(client=client, parent=parent, theme_update=True)
+        self.stacked_layout = QtWidgets.QStackedLayout()
+        self.stacked_layout.setContentsMargins(0, 0, 0, 0)
+        self.stacked_layout.setSpacing(0)
+        self.setLayout(self.stacked_layout)
+
+        # Monaco widget
+        self.monaco_editor = MonacoWidget()
+        self._customize_monaco()
+        self.stacked_layout.addWidget(self.monaco_editor)
+
+        self._overlay_widget = QtWidgets.QLabel(text="Select single device to show config")
+        self._customize_overlay()
+        self.stacked_layout.addWidget(self._overlay_widget)
+        self.stacked_layout.setCurrentWidget(self._overlay_widget)
+
+    def _customize_monaco(self):
+
+        self.monaco_editor.set_language("yaml")
+        self.monaco_editor.set_vim_mode_enabled(False)
+        self.monaco_editor.set_minimap_enabled(False)
+        # self.monaco_editor.setFixedHeight(600)
+        self.monaco_editor.set_readonly(True)
+        self.monaco_editor.editor.set_scroll_beyond_last_line_enabled(False)
+        self.monaco_editor.editor.set_line_numbers_mode("off")
+
+    def _customize_overlay(self):
+        self._overlay_widget.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self._overlay_widget.setAutoFillBackground(True)
+        self._overlay_widget.setSizePolicy(
+            QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Expanding
+        )
+
+    @SafeSlot(dict)
+    def on_select_config(self, device: dict):
+        """Handle selection of a device from the device table."""
+        if len(device) != 1:
+            text = ""
+            self.stacked_layout.setCurrentWidget(self._overlay_widget)
+        else:
+            try:
+                text = yaml.dump(device, default_flow_style=False)
+                self.stacked_layout.setCurrentWidget(self.monaco_editor)
+            except Exception:
+                content = traceback.format_exc()
+                logger.error(f"Error converting device to YAML:\n{content}")
+                text = ""
+                self.stacked_layout.setCurrentWidget(self._overlay_widget)
+        self.monaco_editor.set_readonly(False)  # Enable editing
+        text = text.rstrip()
+        self.monaco_editor.set_text(text)
+        self.monaco_editor.set_readonly(True)  # Disable editing again
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    config_view = DMConfigView()
+    config_view.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/control/device_manager/components/dm_docstring_view.py

@@ -0,0 +1,128 @@
+"""Module to visualize the docstring of a device class."""
+
+from __future__ import annotations
+
+import inspect
+import re
+import traceback
+
+from bec_lib.logger import bec_logger
+from bec_lib.plugin_helper import get_plugin_class, plugin_package_name
+from bec_lib.utils.rpc_utils import rgetattr
+from qtpy import QtCore, QtWidgets
+
+from bec_widgets.utils.error_popups import SafeSlot
+
+logger = bec_logger.logger
+
+try:
+    import ophyd
+    import ophyd_devices
+
+    READY_TO_VIEW = True
+except ImportError:
+    logger.warning(f"Optional dependencies not available: {ImportError}")
+    ophyd_devices = None
+    ophyd = None
+
+
+class DocstringView(QtWidgets.QTextEdit):
+    def __init__(self, parent: QtWidgets.QWidget | None = None):
+        super().__init__(parent)
+        self.setReadOnly(True)
+        self.setFocusPolicy(QtCore.Qt.NoFocus)
+        if not READY_TO_VIEW:
+            self._set_text("Ophyd or ophyd_devices not installed, cannot show docstrings.")
+            self.setEnabled(False)
+            return
+
+    def _format_docstring(self, doc: str | None) -> str:
+        if not doc:
+            return "<i>No docstring available.</i>"
+
+        # Escape HTML
+        doc = doc.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+        # Remove leading/trailing blank lines from the entire docstring
+        lines = [line.rstrip() for line in doc.splitlines()]
+        while lines and lines[0].strip() == "":
+            lines.pop(0)
+        while lines and lines[-1].strip() == "":
+            lines.pop()
+        doc = "\n".join(lines)
+
+        # Improved regex: match section header + all following indented lines
+        section_regex = re.compile(
+            r"(?m)^(Parameters|Args|Returns|Examples|Attributes|Raises)\b(?:\n([ \t]+.*))*",
+            re.MULTILINE,
+        )
+
+        def strip_section(match: re.Match) -> str:
+            # Capture all lines in the match
+            block = match.group(0)
+            lines = block.splitlines()
+            # Remove leading/trailing empty lines within the section
+            lines = [line for line in lines if line.strip() != ""]
+            return "\n".join(lines)
+
+        doc = section_regex.sub(strip_section, doc)
+
+        # Highlight section titles
+        doc = re.sub(
+            r"(?m)^(Parameters|Args|Returns|Examples|Attributes|Raises)\b", r"<b>\1</b>", doc
+        )
+
+        # Convert indented blocks to <pre> and strip leading/trailing newlines
+        def pre_block(match: re.Match) -> str:
+            text = match.group(0).strip("\n")
+            return f"<pre>{text}</pre>"
+
+        doc = re.sub(r"(?m)(?:\n[ \t]+.*)+", pre_block, doc)
+
+        # Replace remaining newlines with <br> and collapse multiple <br>
+        doc = doc.replace("\n", "<br>")
+        doc = re.sub(r"(<br>)+", r"<br>", doc)
+        doc = doc.strip("<br>")
+
+        return f"<div style='font-family: sans-serif; font-size: 12pt;'>{doc}</div>"
+
+    def _set_text(self, text: str):
+        self.setReadOnly(False)
+        self.setMarkdown(text)
+        # self.setHtml(self._format_docstring(text))
+        self.setReadOnly(True)
+
+    @SafeSlot(dict)
+    def on_select_config(self, device: dict):
+        if len(device) != 1:
+            self._set_text("")
+            return
+        k = next(iter(device))
+        device_class = device[k].get("deviceClass", "")
+        self.set_device_class(device_class)
+
+    @SafeSlot(str)
+    def set_device_class(self, device_class_str: str) -> None:
+        docstring = ""
+        if not READY_TO_VIEW:
+            return
+        try:
+            module_cls = get_plugin_class(device_class_str, [ophyd_devices, ophyd])
+            docstring = inspect.getdoc(module_cls)
+            self._set_text(docstring or "No docstring available.")
+        except Exception:
+            content = traceback.format_exc()
+            logger.error(f"Error retrieving docstring for {device_class_str}: {content}")
+            self._set_text(f"Error retrieving docstring for {device_class_str}")
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    config_view = DocstringView()
+    config_view.set_device_class("ophyd_devices.sim.sim_camera.SimCamera")
+    config_view.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/control/device_manager/components/dm_ophyd_test.py

@@ -0,0 +1,414 @@
+"""Module to run a static tests for devices from a yaml config."""
+
+from __future__ import annotations
+
+import enum
+import re
+import traceback
+from html import escape
+from typing import TYPE_CHECKING
+
+import bec_lib
+from bec_lib.logger import bec_logger
+from bec_qthemes import material_icon
+from ophyd import status
+from qtpy import QtCore, QtGui, QtWidgets
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.colors import get_accent_colors
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
+from bec_widgets.widgets.editors.web_console.web_console import WebConsole
+from bec_widgets.widgets.utility.spinner.spinner import SpinnerWidget
+
+READY_TO_TEST = False
+
+logger = bec_logger.logger
+
+try:
+    import bec_server
+    import ophyd_devices
+
+    READY_TO_TEST = True
+except ImportError:
+    logger.warning(f"Optional dependencies not available: {ImportError}")
+    ophyd_devices = None
+    bec_server = None
+
+if TYPE_CHECKING:  # pragma no cover
+    try:
+        from ophyd_devices.utils.static_device_test import StaticDeviceTest
+    except ImportError:
+        StaticDeviceTest = None
+
+
+class ValidationStatus(int, enum.Enum):
+    """Validation status for device configurations."""
+
+    PENDING = 0  # colors.default
+    VALID = 1  # colors.highlight
+    FAILED = 2  # colors.emergency
+
+
+class DeviceValidationResult(QtCore.QObject):
+    """Simple object to inject validation signals into QRunnable."""
+
+    # Device validation signal, device_name, ValidationStatus as int, error message or ''
+    device_validated = QtCore.Signal(str, bool, str)
+
+
+class DeviceValidationRunnable(QtCore.QRunnable):
+    """Runnable for validating a device configuration."""
+
+    def __init__(
+        self,
+        device_name: str,
+        config: dict,
+        static_device_test: StaticDeviceTest | None,
+        connect: bool = False,
+    ):
+        """
+        Initialize the device validation runnable.
+
+        Args:
+            device_name (str): The name of the device to validate.
+            config (dict): The configuration dictionary for the device.
+            static_device_test (StaticDeviceTest): The static device test instance.
+            connect (bool, optional): Whether to connect to the device. Defaults to False.
+        """
+        super().__init__()
+        self.device_name = device_name
+        self.config = config
+        self._connect = connect
+        self._static_device_test = static_device_test
+        self.signals = DeviceValidationResult()
+
+    def run(self):
+        """Run method for device validation."""
+        if self._static_device_test is None:
+            logger.error(
+                f"Ophyd devices or bec_server not available, cannot run validation for device {self.device_name}."
+            )
+            return
+        try:
+            self._static_device_test.config = {self.device_name: self.config}
+            results = self._static_device_test.run_with_list_output(connect=self._connect)
+            success = results[0].success
+            msg = results[0].message
+            self.signals.device_validated.emit(self.device_name, success, msg)
+        except Exception:
+            content = traceback.format_exc()
+            logger.error(f"Validation failed for device {self.device_name}. Exception: {content}")
+            self.signals.device_validated.emit(self.device_name, False, content)
+
+
+class ValidationListItem(QtWidgets.QWidget):
+    """Custom list item widget showing device name and validation status."""
+
+    def __init__(self, device_name: str, device_config: dict, parent=None):
+        """
+        Initialize the validation list item.
+
+        Args:
+            device_name (str): The name of the device.
+            device_config (dict): The configuration of the device.
+            validation_colors (dict[ValidationStatus, QtGui.QColor]): The colors for each validation status.
+            parent (QtWidgets.QWidget, optional): The parent widget.
+        """
+        super().__init__(parent)
+        self.main_layout = QtWidgets.QHBoxLayout(self)
+        self.main_layout.setContentsMargins(2, 2, 2, 2)
+        self.main_layout.setSpacing(4)
+        self.device_name = device_name
+        self.device_config = device_config
+        self.validation_msg = "Validation in progress..."
+        self._setup_ui()
+
+    def _setup_ui(self):
+        """Setup the UI for the list item."""
+        label = QtWidgets.QLabel(self.device_name)
+        self.main_layout.addWidget(label)
+        self.main_layout.addStretch()
+        self._spinner = SpinnerWidget(parent=self)
+        self._spinner.speed = 80
+        self._spinner.setFixedSize(24, 24)
+        self.main_layout.addWidget(self._spinner)
+        self._base_style = "font-weight: bold;"
+        self.setStyleSheet(self._base_style)
+        self._start_spinner()
+
+    def _start_spinner(self):
+        """Start the spinner animation."""
+        self._spinner.start()
+        QtWidgets.QApplication.processEvents()
+
+    def _stop_spinner(self):
+        """Stop the spinner animation."""
+        self._spinner.stop()
+        self._spinner.setVisible(False)
+
+    @SafeSlot()
+    def on_validation_restart(self):
+        """Handle validation restart."""
+        self.validation_msg = ""
+        self._start_spinner()
+        self.setStyleSheet("")  # Check if this works as expected
+
+    @SafeSlot(str)
+    def on_validation_failed(self, error_msg: str):
+        """Handle validation failure."""
+        self.validation_msg = error_msg
+        colors = get_accent_colors()
+        self._stop_spinner()
+        self.main_layout.removeWidget(self._spinner)
+        self._spinner.deleteLater()
+        label = QtWidgets.QLabel("")
+        icon = material_icon("error", color=colors.emergency, size=(24, 24))
+        label.setPixmap(icon)
+        self.main_layout.addWidget(label)
+
+
+class DMOphydTest(BECWidget, QtWidgets.QWidget):
+    """Widget to test device configurations using ophyd devices."""
+
+    # Signal to emit the validation status of a device
+    device_validated = QtCore.Signal(str, int)
+
+    def __init__(self, parent=None, client=None):
+        super().__init__(parent=parent, client=client)
+        if not READY_TO_TEST:
+            self.setDisabled(True)
+            self.static_device_test = None
+        else:
+            from ophyd_devices.utils.static_device_test import StaticDeviceTest
+
+            self.static_device_test = StaticDeviceTest(config_dict={})
+        self._device_list_items: dict[str, QtWidgets.QListWidgetItem] = {}
+        self._thread_pool = QtCore.QThreadPool.globalInstance()
+
+        self._main_layout = QtWidgets.QVBoxLayout(self)
+        self._main_layout.setContentsMargins(0, 0, 0, 0)
+        self._main_layout.setSpacing(4)
+
+        # We add a splitter between the list and the text box
+        self.splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Vertical)
+        self._main_layout.addWidget(self.splitter)
+
+        self._setup_list_ui()
+        self._setup_textbox_ui()
+
+    def _setup_list_ui(self):
+        """Setup the list UI."""
+        self._list_widget = QtWidgets.QListWidget(self)
+        self._list_widget.setSelectionMode(QtWidgets.QAbstractItemView.SingleSelection)
+        self.splitter.addWidget(self._list_widget)
+        # Connect signals
+        self._list_widget.currentItemChanged.connect(self._on_current_item_changed)
+
+    def _setup_textbox_ui(self):
+        """Setup the text box UI."""
+        self._text_box = QtWidgets.QTextEdit(self)
+        self._text_box.setReadOnly(True)
+        self._text_box.setFocusPolicy(QtCore.Qt.NoFocus)
+        self.splitter.addWidget(self._text_box)
+
+    @SafeSlot(dict)
+    def add_device_configs(self, device_configs: dict[str, dict]) -> None:
+        """Receive an update with device configs.
+
+        Args:
+            device_configs (dict[str, dict]): The updated device configurations.
+        """
+        for device_name, device_config in device_configs.items():
+            if device_name in self._device_list_items:
+                logger.error(f"Device {device_name} is already in the list.")
+                return
+            item = QtWidgets.QListWidgetItem(self._list_widget)
+            widget = ValidationListItem(device_name=device_name, device_config=device_config)
+
+            # wrap it in a QListWidgetItem
+            item.setSizeHint(widget.sizeHint())
+            self._list_widget.addItem(item)
+            self._list_widget.setItemWidget(item, widget)
+            self._device_list_items[device_name] = item
+            self._run_device_validation(widget)
+
+    @SafeSlot(dict)
+    def remove_device_configs(self, device_configs: dict[str, dict]) -> None:
+        """Remove device configs from the list.
+
+        Args:
+            device_name (str): The name of the device to remove.
+        """
+        for device_name in device_configs.keys():
+            if device_name not in self._device_list_items:
+                logger.warning(f"Device {device_name} not found in list.")
+                return
+            self._remove_list_item(device_name)
+
+    def _remove_list_item(self, device_name: str):
+        """Remove a device from the list."""
+        # Get the list item
+        item = self._device_list_items.pop(device_name)
+
+        # Retrieve the custom widget attached to the item
+        widget = self._list_widget.itemWidget(item)
+        if widget is not None:
+            widget.deleteLater()  # clean up custom widget
+
+        # Remove the item from the QListWidget
+        row = self._list_widget.row(item)
+        self._list_widget.takeItem(row)
+
+    def _run_device_validation(self, widget: ValidationListItem):
+        """
+        Run the device validation in a separate thread.
+
+        Args:
+            widget (ValidationListItem): The widget to validate.
+        """
+        if not READY_TO_TEST:
+            logger.error("Ophyd devices or bec_server not available, cannot run validation.")
+            return
+        if (
+            widget.device_name in self.client.device_manager.devices
+        ):  # TODO and config has to be exact the same..
+            self._on_device_validated(
+                widget.device_name,
+                ValidationStatus.VALID,
+                f"Device {widget.device_name} is already in active config",
+            )
+            return
+        runnable = DeviceValidationRunnable(
+            device_name=widget.device_name,
+            config=widget.device_config,
+            static_device_test=self.static_device_test,
+            connect=False,
+        )
+        runnable.signals.device_validated.connect(self._on_device_validated)
+        self._thread_pool.start(runnable)
+
+    @SafeSlot(str, bool, str)
+    def _on_device_validated(self, device_name: str, success: bool, message: str):
+        """Handle the device validation result.
+
+        Args:
+            device_name (str): The name of the device.
+            success (bool): Whether the validation was successful.
+            message (str): The validation message.
+        """
+        logger.info(f"Device {device_name} validation result: {success}, message: {message}")
+        item = self._device_list_items.get(device_name, None)
+        if not item:
+            logger.error(f"Device {device_name} not found in the list.")
+            return
+        if success:
+            self._remove_list_item(device_name=device_name)
+            self.device_validated.emit(device_name, ValidationStatus.VALID.value)
+        else:
+            widget: ValidationListItem = self._list_widget.itemWidget(item)
+            widget.on_validation_failed(message)
+            self.device_validated.emit(device_name, ValidationStatus.FAILED.value)
+
+    def _on_current_item_changed(
+        self, current: QtWidgets.QListWidgetItem, previous: QtWidgets.QListWidgetItem
+    ):
+        """Handle the current item change in the list widget.
+
+        Args:
+            current (QListWidgetItem): The currently selected item.
+            previous (QListWidgetItem): The previously selected item.
+        """
+        widget: ValidationListItem = self._list_widget.itemWidget(current)
+        if widget:
+            try:
+                formatted_html = self._format_validation_message(widget.validation_msg)
+                self._text_box.setHtml(formatted_html)
+            except Exception as e:
+                logger.error(f"Error formatting validation message: {e}")
+                self._text_box.setPlainText(widget.validation_msg)
+
+    def _format_validation_message(self, raw_msg: str) -> str:
+        """Simple HTML formatting for validation messages, wrapping text naturally."""
+        if not raw_msg.strip():
+            return "<i>Validation in progress...</i>"
+        if raw_msg == "Validation in progress...":
+            return "<i>Validation in progress...</i>"
+
+        raw_msg = escape(raw_msg)
+
+        # Split into lines
+        lines = raw_msg.splitlines()
+        summary = lines[0] if lines else "Validation Result"
+        rest = "\n".join(lines[1:]).strip()
+
+        # Split traceback / final ERROR
+        tb_match = re.search(r"(Traceback.*|ERROR:.*)$", rest, re.DOTALL | re.MULTILINE)
+        if tb_match:
+            main_text = rest[: tb_match.start()].strip()
+            error_detail = tb_match.group().strip()
+        else:
+            main_text = rest
+            error_detail = ""
+
+        # Highlight field names in orange (simple regex for word: Field)
+        main_text_html = re.sub(
+            r"(\b\w+\b)(?=: Field required)",
+            r'<span style="color:#FF8C00; font-weight:bold;">\1</span>',
+            main_text,
+        )
+        # Wrap in div for monospace, allowing wrapping
+        main_text_html = (
+            f'<div style="white-space: pre-wrap;">{main_text_html}</div>' if main_text_html else ""
+        )
+
+        # Traceback / error in red
+        error_html = (
+            f'<div style="white-space: pre-wrap; color:#A00000;">{error_detail}</div>'
+            if error_detail
+            else ""
+        )
+
+        # Summary at top, dark red
+        html = (
+            f'<div style="font-family: monospace; font-size:13px; white-space: pre-wrap;">'
+            f'<div style="font-weight:bold; color:#8B0000; margin-bottom:4px;">{summary}</div>'
+            f"{main_text_html}"
+            f"{error_html}"
+            f"</div>"
+        )
+        return html
+
+    @SafeSlot()
+    def clear_list(self):
+        """Clear the device list."""
+        self._thread_pool.clear()
+        if self._thread_pool.waitForDone(2000) is False:  # Wait for threads to finish
+            logger.error("Failed to wait for threads to finish. Removing items from the list.")
+        self._device_list_items.clear()
+        self._list_widget.clear()
+
+    def remove_device(self, device_name: str):
+        """Remove a device from the list."""
+        item = self._device_list_items.pop(device_name, None)
+        if item:
+            self._list_widget.removeItemWidget(item)
+
+
+if __name__ == "__main__":
+    import sys
+
+    from bec_lib.bec_yaml_loader import yaml_load
+
+    # pylint: disable=ungrouped-imports
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    device_manager_ophyd_test = DMOphydTest()
+    config_path = "/Users/appel_c/work_psi_awi/bec_workspace/csaxs_bec/csaxs_bec/device_configs/endstation.yaml"
+    cfg = yaml_load(config_path)
+    cfg.update({"device_will_fail": {"name": "device_will_fail", "some_param": 1}})
+    device_manager_ophyd_test.add_device_configs(cfg)
+    device_manager_ophyd_test.show()
+    device_manager_ophyd_test.setWindowTitle("Device Manager Ophyd Test")
+    device_manager_ophyd_test.resize(800, 600)
+    sys.exit(app.exec_())

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -20,7 +20,7 @@ from qtpy.QtWidgets import (
 
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import get_accent_colors
+from bec_widgets.utils.colors import apply_theme, get_accent_colors
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.widgets.control.buttons.stop_button.stop_button import StopButton
 from bec_widgets.widgets.control.scan_control.scan_group_box import ScanGroupBox
@@ -45,7 +45,7 @@ class ScanControl(BECWidget, QWidget):
     Widget to submit new scans to the queue.
     """
 
-    USER_ACCESS = ["remove", "screenshot"]
+    USER_ACCESS = ["attach", "detach", "screenshot"]
     PLUGIN = True
     ICON_NAME = "tune"
     ARG_BOX_POSITION: int = 2
@@ -136,13 +136,8 @@ class ScanControl(BECWidget, QWidget):
         self.scan_control_group.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
         self.button_layout = QHBoxLayout(self.scan_control_group)
         self.button_run_scan = QPushButton("Start", self.scan_control_group)
-        self.button_run_scan.setStyleSheet(
-            f"background-color: {palette.success.name()}; color: white"
-        )
+        self.button_run_scan.setProperty("variant", "success")
         self.button_stop_scan = StopButton(parent=self.scan_control_group)
-        self.button_stop_scan.setStyleSheet(
-            f"background-color: {palette.emergency.name()}; color: white"
-        )
         self.button_layout.addWidget(self.button_run_scan)
         self.button_layout.addWidget(self.button_stop_scan)
         self.layout.addWidget(self.scan_control_group)
@@ -547,12 +542,10 @@ class ScanControl(BECWidget, QWidget):
 
 # Application example
 if __name__ == "__main__":  # pragma: no cover
-    from bec_widgets.utils.colors import set_theme
-
     app = QApplication([])
     scan_control = ScanControl()
 
-    set_theme("auto")
+    apply_theme("dark")
     window = scan_control
     window.show()
     app.exec()

bec_widgets/widgets/dap/dap_combo_box/dap_combo_box.py

@@ -175,10 +175,10 @@ if __name__ == "__main__":  # pragma: no cover
     # pylint: disable=import-outside-toplevel
     from qtpy.QtWidgets import QApplication
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication([])
-    set_theme("dark")
+    apply_theme("dark")
     widget = QWidget()
     widget.setFixedSize(200, 200)
     layout = QVBoxLayout()

bec_widgets/widgets/editors/dict_backed_table.py

@@ -249,10 +249,10 @@ class DictBackedTable(QWidget):
 
 
 if __name__ == "__main__":  # pragma: no cover
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication([])
-    set_theme("dark")
+    apply_theme("dark")
 
     window = DictBackedTable(None, [["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
     window.show()

bec_widgets/widgets/editors/monaco/monaco_widget.py

@@ -32,6 +32,9 @@ class MonacoWidget(BECWidget, QWidget):
         "set_vim_mode_enabled",
         "set_lsp_header",
         "get_lsp_header",
+        "attach",
+        "detach",
+        "screenshot",
     ]
 
     def __init__(self, parent=None, config=None, client=None, gui_id=None, **kwargs):

bec_widgets/widgets/editors/scan_metadata/scan_metadata.py

@@ -97,7 +97,7 @@ if __name__ == "__main__":  # pragma: no cover
 
     from bec_lib.metadata_schema import BasicScanMetadata
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     class ExampleSchema1(BasicScanMetadata):
         abc: int = Field(gt=0, lt=2000, description="Heating temperature abc", title="A B C")
@@ -141,7 +141,7 @@ if __name__ == "__main__":  # pragma: no cover
         layout.addWidget(selection)
         layout.addWidget(scan_metadata)
 
-        set_theme("dark")
+        apply_theme("dark")
         window = w
         window.show()
         app.exec()

bec_widgets/widgets/editors/website/website.py

@@ -21,7 +21,16 @@ class WebsiteWidget(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "travel_explore"
-    USER_ACCESS = ["set_url", "get_url", "reload", "back", "forward"]
+    USER_ACCESS = [
+        "set_url",
+        "get_url",
+        "reload",
+        "back",
+        "forward",
+        "attach",
+        "detach",
+        "screenshot",
+    ]
 
     def __init__(
         self, parent=None, url: str = None, config=None, client=None, gui_id=None, **kwargs

bec_widgets/widgets/games/minesweeper.py

@@ -407,10 +407,10 @@ class Minesweeper(BECWidget, QWidget):
 
 
 if __name__ == "__main__":
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication([])
-    set_theme("light")
+    apply_theme("light")
     widget = Minesweeper()
     widget.show()
 

bec_widgets/widgets/plots/heatmap/heatmap.py

@@ -115,6 +115,8 @@ class Heatmap(ImageBase):
         "auto_range_y.setter",
         "minimal_crosshair_precision",
         "minimal_crosshair_precision.setter",
+        "attach",
+        "detach",
         "screenshot",
         # ImageView Specific Settings
         "color_map",

bec_widgets/widgets/plots/image/image.py

@@ -91,6 +91,8 @@ class Image(ImageBase):
         "auto_range_y.setter",
         "minimal_crosshair_precision",
         "minimal_crosshair_precision.setter",
+        "attach",
+        "detach",
         "screenshot",
         # ImageView Specific Settings
         "color_map",

bec_widgets/widgets/plots/motor_map/motor_map.py

@@ -11,7 +11,7 @@ from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QHBoxLayout, QMainWindow, QWidget
 
 from bec_widgets.utils import Colors, ConnectionConfig
-from bec_widgets.utils.colors import set_theme
+from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.settings_dialog import SettingsDialog
 from bec_widgets.utils.toolbars.toolbar import MaterialIconAction
@@ -128,6 +128,8 @@ class MotorMap(PlotBase):
         "y_log.setter",
         "legend_label_size",
         "legend_label_size.setter",
+        "attach",
+        "detach",
         "screenshot",
         # motor_map specific
         "color",
@@ -828,7 +830,7 @@ if __name__ == "__main__":  # pragma: no cover
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
-    set_theme("dark")
+    apply_theme("dark")
     widget = DemoApp()
     widget.show()
     widget.resize(1400, 600)

bec_widgets/widgets/plots/multi_waveform/multi_waveform.py

@@ -96,6 +96,8 @@ class MultiWaveform(PlotBase):
         "legend_label_size.setter",
         "minimal_crosshair_precision",
         "minimal_crosshair_precision.setter",
+        "attach",
+        "detach",
         "screenshot",
         # MultiWaveform Specific RPC Access
         "highlighted_index",

bec_widgets/widgets/plots/plot_base.py

@@ -109,7 +109,6 @@ class PlotBase(BECWidget, QWidget):
         self.plot_widget.ci.setContentsMargins(0, 0, 0, 0)
         self.plot_item = pg.PlotItem(viewBox=BECViewBox(enableMenu=True))
         self.plot_widget.addItem(self.plot_item)
-        self.plot_item.visible_items = lambda: self.visible_items
         self.side_panel = SidePanel(self, orientation="left", panel_max_width=280)
 
         # PlotItem Addons
@@ -135,7 +134,7 @@ class PlotBase(BECWidget, QWidget):
         self._init_ui()
 
         self._connect_to_theme_change()
-        self._update_theme()
+        self._update_theme(None)
 
     def apply_theme(self, theme: str):
         self.round_plot_widget.apply_theme(theme)
@@ -143,6 +142,8 @@ class PlotBase(BECWidget, QWidget):
     def _init_ui(self):
         self.layout.addWidget(self.layout_manager)
         self.round_plot_widget = RoundedFrame(parent=self, content_widget=self.plot_widget)
+        self.round_plot_widget.setProperty("variant", "plot_background")
+        self.round_plot_widget.setProperty("frameless", True)
 
         self.layout_manager.add_widget(self.round_plot_widget)
         self.layout_manager.add_widget_relative(self.fps_label, self.round_plot_widget, "top")
@@ -894,20 +895,15 @@ class PlotBase(BECWidget, QWidget):
             return
         self._apply_autorange_only_visible_curves()
 
-    @property
-    def visible_items(self):
-        crosshair_items = []
-        if self.crosshair:
-            crosshair_items = [
-                self.crosshair.v_line,
-                self.crosshair.h_line,
-                self.crosshair.coord_label,
-            ]
-        return [
-            item
-            for item in self.plot_item.items
-            if item.isVisible() and item not in crosshair_items
-        ]
+    def _fetch_visible_curves(self):
+        """
+        Fetch all visible curves from the plot item.
+        """
+        visible_curves = []
+        for curve in self.plot_item.curves:
+            if curve.isVisible():
+                visible_curves.append(curve)
+        return visible_curves
 
     def _apply_autorange_only_visible_curves(self):
         """
@@ -916,9 +912,8 @@ class PlotBase(BECWidget, QWidget):
         Args:
             curves (list): List of curves to apply autorange to.
         """
-        visible_items = self.visible_items
-
-        self.plot_item.autoRange(items=visible_items if visible_items else None)
+        visible_curves = self._fetch_visible_curves()
+        self.plot_item.autoRange(items=visible_curves if visible_curves else None)
 
     @SafeProperty(int, doc="The font size of the legend font.")
     def legend_label_size(self) -> int:

bec_widgets/widgets/plots/scatter_waveform/scatter_waveform.py

@@ -10,7 +10,6 @@ from qtpy.QtCore import QTimer, Signal
 from qtpy.QtWidgets import QHBoxLayout, QMainWindow, QWidget
 
 from bec_widgets.utils import Colors, ConnectionConfig
-from bec_widgets.utils.colors import set_theme
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.settings_dialog import SettingsDialog
 from bec_widgets.utils.toolbars.toolbar import MaterialIconAction
@@ -84,6 +83,8 @@ class ScatterWaveform(PlotBase):
         "legend_label_size.setter",
         "minimal_crosshair_precision",
         "minimal_crosshair_precision.setter",
+        "attach",
+        "detach",
         "screenshot",
         # Scatter Waveform Specific RPC Access
         "main_curve",
@@ -544,8 +545,10 @@ if __name__ == "__main__":  # pragma: no cover
 
     from qtpy.QtWidgets import QApplication
 
+    from bec_widgets.utils.colors import apply_theme
+
     app = QApplication(sys.argv)
-    set_theme("dark")
+    apply_theme("dark")
     widget = DemoApp()
     widget.show()
     widget.resize(1400, 600)

bec_widgets/widgets/plots/waveform/settings/curve_settings/curve_tree.py

@@ -7,6 +7,7 @@ from bec_lib.logger import bec_logger
 from bec_qthemes._icon.material_icons import material_icon
 from qtpy.QtCore import Qt
 from qtpy.QtWidgets import (
+    QApplication,
     QComboBox,
     QHBoxLayout,
     QHeaderView,
@@ -70,6 +71,7 @@ class CurveRow(QTreeWidgetItem):
             # A top-level device row.
             super().__init__(tree)
 
+        self.app = QApplication.instance()
         self.tree = tree
         self.parent_item = parent_item
         self.curve_tree = tree.parent()  # The CurveTree widget
@@ -115,7 +117,16 @@ class CurveRow(QTreeWidgetItem):
 
         # If device row, add "Add DAP" button
         if self.source == "device":
-            self.add_dap_button = QPushButton("DAP")
+            self.add_dap_button = QToolButton()
+            analysis_icon = material_icon(
+                "monitoring",
+                size=(20, 20),
+                convert_to_pixmap=False,
+                filled=False,
+                color=self.app.theme.colors["FG"].toTuple(),
+            )
+            self.add_dap_button.setIcon(analysis_icon)
+            self.add_dap_button.setToolTip("Add DAP")
             self.add_dap_button.clicked.connect(lambda: self.add_dap_row())
             actions_layout.addWidget(self.add_dap_button)
 

bec_widgets/widgets/plots/waveform/waveform.py

@@ -25,7 +25,7 @@ from qtpy.QtWidgets import (
 
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_signal_proxy import BECSignalProxy
-from bec_widgets.utils.colors import Colors, set_theme
+from bec_widgets.utils.colors import Colors, apply_theme
 from bec_widgets.utils.container_utils import WidgetContainerUtils
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.settings_dialog import SettingsDialog
@@ -63,6 +63,10 @@ class Waveform(PlotBase):
     RPC = True
     ICON_NAME = "show_chart"
     USER_ACCESS = [
+        # BECWidget Base Class
+        "attach",
+        "detach",
+        "screenshot",
         # General PlotBase Settings
         "_config_dict",
         "enable_toolbar",
@@ -105,7 +109,6 @@ class Waveform(PlotBase):
         "legend_label_size.setter",
         "minimal_crosshair_precision",
         "minimal_crosshair_precision.setter",
-        "screenshot",
         # Waveform Specific RPC Access
         "curves",
         "x_mode",
@@ -929,17 +932,8 @@ class Waveform(PlotBase):
         curve = Curve(config=config, name=name, parent_item=self)
         self.plot_item.addItem(curve)
         self._categorise_device_curves()
-        curve.visibleChanged.connect(self._refresh_crosshair_markers)
-        curve.visibleChanged.connect(self.auto_range)
         return curve
 
-    def _refresh_crosshair_markers(self):
-        """
-        Refresh the crosshair markers when a curve visibility changes.
-        """
-        if self.crosshair is not None:
-            self.crosshair.clear_markers()
-
     def _generate_color_from_palette(self) -> str:
         """
         Generate a color for the next new curve, based on the current number of curves.
@@ -1124,8 +1118,7 @@ class Waveform(PlotBase):
             self.reset()
             self.new_scan.emit()
             self.new_scan_id.emit(current_scan_id)
-            self.auto_range_x = True
-            self.auto_range_y = True
+            self.auto_range(True)
             self.old_scan_id = self.scan_id
             self.scan_id = current_scan_id
             self.scan_item = self.queue.scan_storage.find_scan_by_ID(self.scan_id)  # live scan
@@ -2066,7 +2059,7 @@ if __name__ == "__main__":  # pragma: no cover
     import sys
 
     app = QApplication(sys.argv)
-    set_theme("dark")
+    apply_theme("dark")
     widget = DemoApp()
     widget.show()
     widget.resize(1400, 600)

bec_widgets/widgets/progress/ring_progress_bar/ring_progress_bar.py

@@ -96,6 +96,9 @@ class RingProgressBar(BECWidget, QWidget):
         "set_diameter",
         "reset_diameter",
         "enable_auto_updates",
+        "attach",
+        "detach",
+        "screenshot",
     ]
 
     def __init__(

bec_widgets/widgets/services/bec_queue/bec_queue.py

@@ -242,8 +242,15 @@ class BECQueue(BECWidget, CompactPopupWidget):
         abort_button.button.setIcon(
             material_icon("cancel", color="#cc181e", filled=True, convert_to_pixmap=False)
         )
-        abort_button.button.setStyleSheet("background-color:  rgba(0,0,0,0) ")
-        abort_button.button.setFlat(True)
+        abort_button.setStyleSheet(
+            """
+            QPushButton {
+                background-color: transparent;
+                border: none;
+            }
+            """
+        )
+
         return abort_button
 
     def delete_selected_row(self):

bec_widgets/widgets/services/bec_status_box/bec_status_box.py

@@ -76,7 +76,7 @@ class BECStatusBox(BECWidget, CompactPopupWidget):
 
     PLUGIN = True
     CORE_SERVICES = ["DeviceServer", "ScanServer", "SciHub", "ScanBundler", "FileWriterManager"]
-    USER_ACCESS = ["get_server_state", "remove"]
+    USER_ACCESS = ["get_server_state", "remove", "attach", "detach", "screenshot"]
 
     service_update = Signal(BECServiceInfoContainer)
     bec_core_state = Signal(str)
@@ -315,10 +315,10 @@ if __name__ == "__main__":  # pragma: no cover
 
     from qtpy.QtWidgets import QApplication
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication(sys.argv)
-    set_theme("dark")
+    apply_theme("dark")
     main_window = BECStatusBox()
     main_window.show()
     sys.exit(app.exec())

bec_widgets/widgets/services/device_browser/device_browser.py

@@ -240,10 +240,10 @@ if __name__ == "__main__":  # pragma: no cover
 
     from qtpy.QtWidgets import QApplication
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication(sys.argv)
-    set_theme("light")
+    apply_theme("light")
     widget = DeviceBrowser()
     widget.show()
     sys.exit(app.exec_())

bec_widgets/widgets/services/device_browser/device_item/device_config_dialog.py

@@ -262,12 +262,12 @@ def main():  # pragma: no cover
 
     from qtpy.QtWidgets import QApplication, QLineEdit, QPushButton, QWidget
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     dialog = None
 
     app = QApplication(sys.argv)
-    set_theme("light")
+    apply_theme("light")
     widget = QWidget()
     widget.setLayout(QVBoxLayout())
 

bec_widgets/widgets/services/device_browser/device_item/device_signal_display.py

@@ -110,10 +110,10 @@ if __name__ == "__main__":  # pragma: no cover
 
     from qtpy.QtWidgets import QApplication
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication(sys.argv)
-    set_theme("light")
+    apply_theme("light")
     widget = SignalDisplay(device="samx")
     widget.show()
     sys.exit(app.exec_())

bec_widgets/widgets/utility/logpanel/logpanel.py

@@ -35,7 +35,7 @@ from qtpy.QtWidgets import (
 )
 
 from bec_widgets.utils.bec_connector import BECConnector
-from bec_widgets.utils.colors import get_theme_palette, set_theme
+from bec_widgets.utils.colors import apply_theme, get_theme_palette
 from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.widgets.editors.text_box.text_box import TextBox
 from bec_widgets.widgets.services.bec_status_box.bec_status_box import BECServiceStatusMixin
@@ -544,7 +544,7 @@ if __name__ == "__main__":  # pragma: no cover
     from qtpy.QtWidgets import QApplication  # pylint: disable=ungrouped-imports
 
     app = QApplication(sys.argv)
-    set_theme("dark")
+    apply_theme("dark")
     widget = LogPanel()
 
     widget.show()

bec_widgets/widgets/utility/spinner/spinner.py

@@ -49,7 +49,7 @@ class SpinnerWidget(QWidget):
 
     def paintEvent(self, event):
         painter = QPainter(self)
-        painter.setRenderHint(QPainter.Antialiasing)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
         size = min(self.width(), self.height())
         rect = QRect(0, 0, size, size)
 
@@ -63,14 +63,14 @@ class SpinnerWidget(QWidget):
         rect.adjust(line_width, line_width, -line_width, -line_width)
 
         # Background arc
-        painter.setPen(QPen(background_color, line_width, Qt.SolidLine))
+        painter.setPen(QPen(background_color, line_width, Qt.PenStyle.SolidLine))
         adjusted_rect = QRect(rect.left(), rect.top(), rect.width(), rect.height())
         painter.drawArc(adjusted_rect, 0, 360 * 16)
 
         if self._started:
             # Foreground arc
-            pen = QPen(color, line_width, Qt.SolidLine)
-            pen.setCapStyle(Qt.RoundCap)
+            pen = QPen(color, line_width, Qt.PenStyle.SolidLine)
+            pen.setCapStyle(Qt.PenCapStyle.RoundCap)
             painter.setPen(pen)
             proportion = 1 / 4
             angle_span = int(proportion * 360 * 16)

bec_widgets/widgets/utility/visual/dark_mode_button/dark_mode_button.py

@@ -5,7 +5,7 @@ from qtpy.QtCore import Property, Qt, Slot
 from qtpy.QtWidgets import QApplication, QHBoxLayout, QPushButton, QToolButton, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import set_theme
+from bec_widgets.utils.colors import apply_theme
 
 
 class DarkModeButton(BECWidget, QWidget):
@@ -85,7 +85,7 @@ class DarkModeButton(BECWidget, QWidget):
         """
         self.dark_mode_enabled = not self.dark_mode_enabled
         self.update_mode_button()
-        set_theme("dark" if self.dark_mode_enabled else "light")
+        apply_theme("dark" if self.dark_mode_enabled else "light")
 
     def update_mode_button(self):
         icon = material_icon(
@@ -100,7 +100,7 @@ class DarkModeButton(BECWidget, QWidget):
 if __name__ == "__main__":
 
     app = QApplication([])
-    set_theme("auto")
+    apply_theme("dark")
     w = DarkModeButton()
     w.show()
 

docs/api_reference/api_reference.md

@@ -1,11 +1,12 @@
 (api_reference)=
 # API Reference
 
-This page contains the auto-generated API documentation for all modules, classes, and functions in the BEC Widgets package.
+```{eval-rst}
+.. autosummary::
+   :toctree: _autosummary
+   :template: custom-module-template.rst
+   :recursive:
 
-```{toctree}
-:maxdepth: 2
-:caption: API Documentation
+   bec_widgets
 
-../autoapi/bec_widgets/index
 ```

docs/conf.py

@@ -32,15 +32,16 @@ def get_version():
 release = get_version()
 
 extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
     # "sphinx.ext.coverage",
+    "sphinx.ext.viewcode",
     "sphinx.ext.napoleon",
     "sphinx_toolbox.collapse",
     "sphinx_copybutton",
     "myst_parser",
     "sphinx_design",
     "sphinx_inline_tabs",
-    "autoapi.extension",
-    "sphinx.ext.viewcode",
 ]
 
 myst_enable_extensions = [
@@ -59,15 +60,7 @@ myst_enable_extensions = [
     "tasklist",
 ]
 
-# AutoAPI configuration
-autoapi_dirs = ["../bec_widgets"]
-autoapi_type = "python"
-autoapi_generate_api_docs = True
-autoapi_add_toctree_entry = False  # We'll control the toctree manually
-autoapi_keep_files = False
-autoapi_python_class_content = "both"  # Include both class docstring and __init__
-autoapi_member_order = "groupwise"
-
+autosummary_generate = True  # Turn on sphinx.ext.autosummary
 add_module_names = False  # Remove namespaces from class/method signatures
 autodoc_inherit_docstrings = True  # If no docstring, inherit from base class
 set_type_checking_flag = True  # Enable 'expensive' imports for sphinx_autodoc_typehints
@@ -87,30 +80,3 @@ html_theme = "pydata_sphinx_theme"
 html_static_path = ["_static"]
 html_css_files = ["custom.css"]
 html_logo = "../bec_widgets/assets/app_icons/bec_widgets_icon.png"
-
-
-def skip_submodules(app, what, name, obj, skip, options):
-    if what == "module":
-        if not name.startswith("bec_widgets"):
-            skip = True
-        # print(f"Checking module: {name}")
-        if "bec_widgets.widgets" in name:
-            widget = name.split(".")[-2]
-            submodule = name.split(".")[-1]
-            if submodule in [f"register_{widget}", f"{widget}_plugin"]:
-                # print(f"Skipping submodule: {name}")
-                skip = True
-    elif what in ["data", "attribute"]:
-        obj_name = name.split(".")[-1]
-        if obj_name.startswith("_") or obj_name in ["__all__", "logger", "bec_logger", "app"]:
-            skip = True
-
-    elif what == "class":
-        class_name = name.split(".")[-1]
-        if class_name.startswith("Demo"):
-            skip = True
-    return skip
-
-
-def setup(app):
-    app.connect("autoapi-skip-member", skip_submodules)

docs/developer/introduction/concepts.md

@@ -10,5 +10,5 @@ We offer up to three different options for composing larger GUIs from these modu
 ## Client-Server Architecture
 
 BEC Widgets is built on top of the [BEC](https://bec.readthedocs.io/en/latest/) package, which provides the backend for beamline experiment control. BEC Widgets is a client of BEC, meaning it can interact with the backend through a client-server architecture. To make full usage of the available features of BEC, we recommend to check the documentation about [data access](https://bec.readthedocs.io/en/latest/developer/data_access/data_access.html) in which the messaging and event system of BEC is described.
-In the context of BEC Widgets, the {py:class}`~bec_widgets.utils.bec_dispatcher.BECDispatcher` connects to this messaging and event system, allowing you to link your Qt [`Slots`](https://www.pythonguis.com/tutorials/pyside6-signals-slots-events/) to messages and event received from BEC.
+In the context of BEC Widgets, the [`BECDispatcher`](/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher) connects to this messaging and event system, allowing you to link your Qt [`Slots`](https://www.pythonguis.com/tutorials/pyside6-signals-slots-events/) to messages and event received from BEC.
 

docs/requirements.txt

@@ -7,5 +7,4 @@ sphinx-copybutton
 sphinx-inline-tabs
 myst-parser
 sphinx-design
-sphinx-autoapi
 tomli

docs/user/api_reference/api_reference.md

@@ -1,10 +1,11 @@
 (user.api_reference)=
 # User API Reference
 
-This section contains the API documentation for the main user-facing modules and classes.
+```{eval-rst}
+.. autosummary::
+   :toctree: _autosummary
+   :template: custom-module-template.rst
 
-```{toctree}
-:maxdepth: 2
+    bec_widgets.cli.client
 
-../../autoapi/bec_widgets/cli/index
 ```

docs/user/getting_started/quick_start.md

@@ -3,9 +3,9 @@
 In order to use BEC Widgets as a plotting tool for BEC, it needs to be [installed](#user.installation) in the same Python environment as the BEC IPython client (please refer to the [BEC documentation](https://bec.readthedocs.io/en/latest/user/command_line_interface.html#start-up) for more details). Upon startup, the client will automatically launch a GUI and store it as a `gui` object in the client. The GUI backend will also be automatically connect to the BEC server, giving access to all information on the server and allowing the user to visualize the data in real-time.
 
 ## BECGuiClient
-The `gui` object is the main entry point for interacting with the BEC Widgets framework. It is an instance of the {py:class}`~bec_widgets.cli.client_utils.BECGuiClient` class, which provides methods to create and manage GUI components. Upon BEC startup, a default {py:class}`~bec_widgets.cli.client.BECDockArea` instance named *bec* is automatically launched.
+The `gui` object is the main entry point for interacting with the BEC Widgets framework. It is an instance of the [`BECGuiClient`](/api_reference/_autosummary/bec_widgets.cli.client.BECGuiClient) class, which provides methods to create and manage GUI components. Upon BEC startup, a default [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) instance named *bec* is automatically launched.
 
-A launcher interface is available via the top menu bar under New → Open Launcher. This opens a window where users can launch a new {py:class}`~bec_widgets.cli.client.BECDockArea` instance, an [AutoUpdate](#user.auto_updates) instance, individual widgets or a custom *ui file* created with *BEC Designer*. Alternatively, users can launch a new {py:class}`~bec_widgets.cli.client.BECDockArea` from the command line:
+A launcher interface is available via the top menu bar under New → Open Launcher. This opens a window where users can launch a new [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) instance, an [AutoUpdate](#user.auto_updates) instance, individual widgets or a custom *ui file* created with *BEC Designer*. Alternatively, users can launch a new [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) from the command line:
 
 ```python
 dock_area = gui.new() # launches a new BECDockArea instance
@@ -19,7 +19,7 @@ If a name is provided, the new dock area will use that name. If the name already
 
 
 ## BECDockArea
-The {py:class}`~bec_widgets.cli.client.BECDockArea` is a versatile container for quickly building customized GUIs. It supports adding new widgets either through the CLI or directly via toolbar actions. Widgets must be added into {py:class}`~bec_widgets.cli.client.BECDockArea` instances, which serve as the individual containers. These docks can be arranged freely, detached from the main window, and used as floating panels.
+The [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) is a versatile container for quickly building customized GUIs. It supports adding new widgets either through the CLI or directly via toolbar actions. Widgets must be added into [`BECDock`](/api_reference/_autosummary/bec_widgets.cli.client.BECDock) instances, which serve as the individual containers. These docks can be arranged freely, detached from the main window, and used as floating panels.
 
 From the CLI, you can create new docks like this:
 
@@ -34,23 +34,23 @@ dock = gui.new().new()
 ![BECDockArea.png](BECDockArea.png) -->
 
 ## Widgets
-Widgets are the building blocks of the BEC Widgets framework. They are the visual components that allow users to interact with the data and control the behavior of the application. Each dock can contain multiple widgets, albeit we recommend for most use cases a single widget per dock. BEC Widgets provides a set of core widgets (cf. {ref}`user.widgets`). More widgets can be added by the users, and we invite you to explore the {ref}`developer.widgets` to learn how to create custom widgets.
+Widgets are the building blocks of the BEC Widgets framework. They are the visual components that allow users to interact with the data and control the behavior of the application. Each dock can contain multiple widgets, albeit we recommend for most use cases a single widget per dock. BEC Widgets provides a set of core widgets (cf. [widgets](#user.widgets)). More widgets can be added by the users, and we invite you to explore the [developer documentation](developer.widgets) to learn how to create custom widgets.
 For the introduction given here, we will focus on the plotting widgets of BECWidgets. 
 
 <!-- We also provide two methods [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.plot), [`image()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.image) and [`motor_map()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.motor_map) as shortcuts to add a plot, image or motor map to the BECFigure. -->
 
 **Waveform Plot** 
 
- The {py:class}`~bec_widgets.cli.client.Waveform` is a widget that can be used to visualize 1D waveform data, i.e. to plot data of a monitor against a motor position. The method {py:meth}`~bec_widgets.cli.client.Waveform.plot` returns the plot object. 
+ The [`WaveForm`](/api_reference/_autosummary/bec_widgets.cli.client.WaveForm) is a widget that can be used to visualize 1D waveform data, i.e. to plot data of a monitor against a motor position. The method [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.WaveForm.rst#bec_widgets.cli.client.WaveForm.plot) returns the plot object. 
 
 ```python
 plt = gui.new().new().new(gui.available_widgets.Waveform)
 plt.plot(x_name='samx', y_name='bpm4i')
 ```
-Here, we create a new plot with a subscription to the devices `samx` and `bpm4i` and assign the plot to the object `plt`. We can now use this object to further customize the plot, e.g. changing the title (`title`), axis labels (`x_label`) 
-<!-- or limits (`x_lim`).  -->
+Here, we create a new plot with a subscription to the devices `samx` and `bpm4i` and assign the plot to the object `plt`. We can now use this object to further customize the plot, e.g. changing the title ([`plt.title = 'my title' `](/api_reference/_autosummary/bec_widgets.cli.client.Waveform.rst#bec_widgets.cli.client.Waveform.title)), axis labels ([`plt.x_label = 'my x label'`](/api_reference/_autosummary/bec_widgets.cli.client.Waveform.rst#bec_widgets.cli.client.Waveform.x_label)) 
+<!-- or limits ([`set_x_lim()`](/api_reference/_autosummary/bec_widgets.cli.client.Waveform.rst#bec_widgets.cli.client.Waveform.x_lim)).  -->
 
-We invite you to explore the API of the WaveForm in the {ref}`user.widgets.waveform_1d` or directly in the command line.
+We invite you to explore the API of the WaveForm in the [documentation](user.widgets.waveform_1d) or directly in the command line.
 
 To plot custom data, i.e. data that is not directly available through a scan in BEC, we can use the same method, but provide the data directly to the plot. 
 
@@ -68,18 +68,18 @@ curve = plt.plot(x=[1,2,3,4], y=[1,4,9,16])
 
 **Scatter Plot**
 
-The {py:class}`~bec_widgets.cli.client.Waveform` widget can also be used to visualize 2D scatter plots. More details on setting up the scatter plot are available in the widget documentation of the {ref}`user.widgets.scatter_2d`.
+The [`WaveForm`](/api_reference/_autosummary/bec_widgets.cli.client.WaveForm) widget can also be used to visualize 2D scatter plots. More details on setting up the scatter plot are available in the widget documentation of the [scatter plot](user.widgets.scatter_2d).
 
 **Motor Map**
 
-The {py:class}`~bec_widgets.cli.client.MotorMap` widget can be used to visualize the position of motors. It's focused on tracking and visualizing the position of motors, crucial for precise alignment and movement tracking during scans. More details on setting up the motor map are available in the widget documentation of the {ref}`user.widgets.motor_map`.
+The [`MotorMap`](/api_reference/_autosummary/bec_widgets.cli.client.MotorMap) widget can be used to visualize the position of motors. It's focused on tracking and visualizing the position of motors, crucial for precise alignment and movement tracking during scans. More details on setting up the motor map are available in the widget documentation of the [motor map](user.widgets.motor_map).
 
 **Image Plot**
 
-The {py:class}`~bec_widgets.cli.client.Image` widget can be used to visualize 2D image data for example a camera. More details on setting up the image plot are available in the widget documentation of the {ref}`user.widgets.image`.
+The [`Image`](/api_reference/_autosummary/bec_widgets.cli.client.Image) widget can be used to visualize 2D image data for example a camera. More details on setting up the image plot are available in the widget documentation of the [image plot](user.widgets.image).
 
 ### Useful Commands
-We recommend users to explore the API of the widgets by themselves since we assume that the user interface is supposed to be intuitive and self-explanatory. We appreciate feedback from user in order to constantly improve the experience and allow easy access to the gui, widgets and their functionality. We recommend checking the {ref}`user.api_reference`, but also by using BEC Widgets, exploring the available functions and check their dockstrings.
+We recommend users to explore the API of the widgets by themselves since we assume that the user interface is supposed to be intuitive and self-explanatory. We appreciate feedback from user in order to constantly improve the experience and allow easy access to the gui, widgets and their functionality. We recommend checking the [API documentation](user.api_reference), but also by using BEC Widgets, exploring the available functions and check their dockstrings.
 ```python
 gui.new? # shows the dockstring of the new method
 ```

docs/user/widgets/bec_progressbar/bec_progressbar.md

@@ -3,7 +3,7 @@
 
 ```{tab} Overview
 
-The {py:class}`~bec_widgets.cli.client.BECProgressBar` widget is a general purpose progress bar that follows the BEC theme and style. It can be embedded in any application to display the progress of a task or operation.
+The [`BECProgressbar`](/api_reference/_autosummary/bec_widgets.cli.client.BECProgressBar) widget is a general purpose progress bar that follows the BEC theme and style. It can be embedded in any application to display the progress of a task or operation. 
 
 ## Key Features:
 - **Modern Design**: The BEC Progressbar widget is designed with a modern and sleek appearance, following the BEC theme.
@@ -35,8 +35,6 @@ pb.set_value(50)
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.BECProgressBar
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.BECProgressBar.rst
 ```
 ````

docs/user/widgets/bec_status_box/bec_status_box.md

@@ -3,7 +3,7 @@
 
 ````{tab} Overview
 
-The {py:class}`~bec_widgets.cli.client.BECStatusBox` widget is designed to monitor the status and health of all running BEC processes. This widget provides a real-time overview of the BEC core services, including DeviceServer, ScanServer, SciHub, ScanBundler, and FileWriter. The top-level display indicates the overall state of the BEC services, while the collapsed view allows users to delve into the status of each individual process. By double-clicking on a specific process, users can access a detailed popup window with live updates of the metrics for that process.
+The [`BEC Status Box`](/api_reference/_autosummary/bec_widgets.cli.client.BECStatusBox) widget is designed to monitor the status and health of all running BEC processes. This widget provides a real-time overview of the BEC core services, including DeviceServer, ScanServer, SciHub, ScanBundler, and FileWriter. The top-level display indicates the overall state of the BEC services, while the collapsed view allows users to delve into the status of each individual process. By double-clicking on a specific process, users can access a detailed popup window with live updates of the metrics for that process.
 
 ## Key Features:
 - **Comprehensive Service Monitoring**: Track the state of individual BEC services, including real-time updates on their health and status.
@@ -33,8 +33,6 @@ Once the `BECStatusBox` is added, users can interact with it to view the status
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.BECStatusBox
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.BECStatusBox.rst
 ```
 ````

docs/user/widgets/buttons_appearance/buttons_appearance.md

@@ -146,14 +146,8 @@ my_gui.show()
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.DarkModeButton
-   :members:
-   :show-inheritance:
-.. autoclass:: bec_widgets.cli.client.ColorButton
-   :members:
-   :show-inheritance:
-.. autoclass:: bec_widgets.cli.client.ColormapSelector
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.DarkModeButton.rst
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ColorButton.rst
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ColormapSelector.rst
 ```
 ````

docs/user/widgets/buttons_queue/button_queue.md

@@ -39,7 +39,7 @@ The `Reset Button` is used to reset the scan queue. It prompts the user for conf
 - **Toolbar and Button Options**: Can be configured as a toolbar button or a standard push button.
 ```
 
-````{tab} Examples
+`````{tab} Examples
 
 Integrating these buttons into a BEC GUI layout is straightforward. The following examples demonstrate how to embed these buttons within a custom GUI layout using `QtWidgets`.
 
@@ -66,21 +66,12 @@ app.exec_()
 ```
 
 `ResumeButton`, `ResetButton`, and `AbortButton` may be used in an exactly analogous way.
-````
 
 ````{tab} API
 ```{eval-rst}
-.. autoclass:: bec_widgets.cli.client.StopButton
-   :members:
-   :show-inheritance:
-.. autoclass:: bec_widgets.cli.client.ResumeButton
-   :members:
-   :show-inheritance:
-.. autoclass:: bec_widgets.cli.client.AbortButton
-   :members:
-   :show-inheritance:
-.. autoclass:: bec_widgets.cli.client.ResetButton
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.StopButton.rst
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ResumeButton.rst
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.AbortButton.rst
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ResetButton.rst
 ```
-````
+`````

docs/user/widgets/dap_combo_box/dap_combo_box.md

@@ -4,8 +4,8 @@
 
 ````{tab} Overview
 
-The {py:class}`~bec_widgets.widgets.dap_combo_box.dap_combo_box.DAPComboBox` is a widget that extends the functionality of a standard `QComboBox` to allow the user to select a DAP process from all available DAP models.
-One of its signals `new_dap_config` is designed to be connected to the {py:class}`~bec_widgets.widgets.plots.waveform.waveform.Waveform.add_dap_curve` slot from the Waveform widget to add a DAP process.
+The [`DAPComboBox`](/api_reference/_autosummary/bec_widgets.widgets.dap_combo_box.dap_combo_box.DAPComboBox) is a widget that extends the functionality of a standard `QComboBox` to allow the user to select a DAP process from all available DAP models.
+One of its signals `new_dap_config` is designed to be connected to the [`add_dap(str, str, str)`](/api_reference/_autosummary/bec_widgets.widgets.waveform.waveform_widget.BECWaveformWidget.rst#bec_widgets.widgets.waveform.waveform_widget.BECWaveformWidget.add_dap) slot from the BECWaveformWidget to add a DAP process.
 
 ## Key Features:
 - **Select DAP model**: Select one of the available DAP models.
@@ -30,6 +30,11 @@ The following slots are available for the `DAP ComboBox` widget:
 - `select_y_axis(str)` : Slot to select the current y axis, emits the `x_axis_updated` signal
 - `select_fit_model(str)` : Slot to select the current fit model, emits the `fit_model_updated` signal. If x and y axis are set, it will also emit the `new_dap_config` signal.
 ````
+````{tab} API
+```{eval-rst} 
+.. include:: /api_reference/_autosummary/bec_widgets.widgets.dap_combo_box.dap_combo_box.DAPCombobox.rst
+```
+````
 
 
 

docs/user/widgets/device_browser/device_browser.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The {py:class}`~bec_widgets.cli.client.DeviceBrowser` widget provides a user-friendly interface for browsing through all available devices in the current BEC session. As it supports drag functionality, users can easily drag and drop device into other widgets or applications. 
+The [`Device Browser`](/api_reference/_autosummary/bec_widgets.cli.client.DeviceBrowser) widget provides a user-friendly interface for browsing through all available devices in the current BEC session. As it supports drag functionality, users can easily drag and drop device into other widgets or applications. 
 
 ```{note}
 The `Device Browser` widget is currently under development. Other widgets may not support drag and drop functionality yet.
@@ -34,8 +34,6 @@ dock_area.device_browser.DeviceBrowser
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.DeviceBrowser
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.DeviceBrowser.rst
 ```
 ````

docs/user/widgets/device_input/device_input.md

@@ -114,16 +114,12 @@ The following Qt properties are also included:
 
 ````{tab} API - ComboBox
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.DeviceComboBox
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.DeviceComboBox.rst
 ```
 ````
 
 ````{tab} API - LineEdit
 ```{eval-rst}
-.. autoclass:: bec_widgets.cli.client.DeviceLineEdit
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.DeviceLineEdit.rst
 ```
 ````

docs/user/widgets/dock_area/bec_dock_area.md

@@ -4,12 +4,12 @@
 
 ````{tab} Overview
 
-`BECDockArea` is a powerful and flexible container designed to host various widgets and docks within a grid layout. It provides an environment for organizing and managing complex user interfaces, making it ideal for applications that require multiple tools and data visualizations to be displayed simultaneously. BECDockArea is particularly useful for embedding not only visualization tools but also other interactive components, allowing users to tailor their workspace to their specific needs.
+[`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) is a powerful and flexible container designed to host various widgets and docks within a grid layout. It provides an environment for organizing and managing complex user interfaces, making it ideal for applications that require multiple tools and data visualizations to be displayed simultaneously. BECDockArea is particularly useful for embedding not only visualization tools but also other interactive components, allowing users to tailor their workspace to their specific needs.
 
 - **Flexible Dock Management**: Easily add, remove, and rearrange docks within `BECDockArea`, providing a customized layout for different tasks.
 - **State Persistence**: Save and restore the state of the dock area, enabling consistent user experiences across sessions.
 - **Dock Customization**: Add docks with customizable positions, names, and behaviors, such as floating or closable docks.
-- **Integration with Widgets**: Integrate various widgets like [`WaveformWidget`](user.widgets.waveform_widget), [`ImageWidget`](user.widgets.image_widget), and [`MotorMapWidget`](user.widgets.motor_map) into `BECDockArea`, either as standalone tools or as part of a more complex interface.
+- **Integration with Widgets**: Integrate various widgets like [`WaveformWidget`](user.widgets.waveform_widget), [`ImageWidget`](user.widgets.image_widget), and [`MotorMapWidget`](user.widgets.motor_map) into [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea), either as standalone tools or as part of a more complex interface.
 
 **BEC Dock Area Components Schema**
 
@@ -114,9 +114,7 @@ When removing a dock, all widgets within the dock will be removed as well. This
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.BECDockArea
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.BECDockArea.rst
 ```
 ````
 

docs/user/widgets/heatmap/heatmap_widget.md

@@ -101,8 +101,6 @@ heatmap_widget.v_max = 1000
 
 ````{tab} API
 ```{eval-rst}  
-.. autoclass:: bec_widgets.widgets.plots.heatmap.heatmap.Heatmap
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.widgets.plots.heatmap.heatmap.Heatmap.rst
 ```
 ````

docs/user/widgets/image/image_widget.md

@@ -105,8 +105,6 @@ Since the Image Widget does not have prior information about the shape of incomi
 
 ````{tab} API
 ```{eval-rst}  
-.. autoclass:: bec_widgets.cli.client.Image
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.Image.rst
 ```
 ````

docs/user/widgets/lmfit_dialog/lmfit_dialog.md

@@ -4,8 +4,8 @@
 
 ````{tab} Overview
 
-The `LMFitDialog` is a widget that is developed to be used together with the `Waveform` widget. The `Waveform` widget allows user to submit a fit request to BEC's [DAP server](https://bec.readthedocs.io/en/latest/developer/getting_started/architecture.html) choosing from a selection of [LMFit models](https://lmfit.github.io/lmfit-py/builtin_models.html#) to fit monitored data sources. The `LMFit Dialog` provides an interface to monitor these fits, including statistics and fit parameters in real time. 
-Within the `Waveform` widget, the dialog is accessible via the toolbar and will be automatically linked to the current waveform widget. For a more customised use, we can embed the `LMFit Dialog` in a larger GUI using the *BEC Designer*. In this case, one has to connect the `update_summary_tree` slot of the LMFit Dialog to the `dap_summary_update` signal of the Waveform widget to ensure its functionality. 
+The [`LMFit Dialog`](/api_reference/_autosummary/bec_widgets.widgets.dap.lmfit_dialog.lmfit_dialog.LMFitDialog) is a widget that is developed to be used together with the [`Waveform`](/api_reference/_autosummary/bec_widgets.widgets.plots.waveform.waveform.Waveform) widget. The `Waveform` widget allows user to submit a fit request to BEC's [DAP server](https://bec.readthedocs.io/en/latest/developer/getting_started/architecture.html) choosing from a selection of [LMFit models](https://lmfit.github.io/lmfit-py/builtin_models.html#) to fit monitored data sources. The `LMFit Dialog` provides an interface to monitor these fits, including statistics and fit parameters in real time. 
+Within the `Waveform` widget, the dialog is accessible via the toolbar and will be automatically linked to the current waveform widget. For a more customised use, we can embed the `LMFit Dialog` in a larger GUI using the *BEC Designer*. In this case, one has to connect the [`update_summary_tree`](/api_reference/_autosummary/bec_widgets.widgets.dap.lmfit_dialog.lmfit_dialog.LMFitDialog.rst#bec_widgets.widgets.lmfit_dialog.lmfit_dialog.LMFitDialog.update_summary_tree) slot of the LMFit Dialog to the [`dap_summary_update`](/api_reference/_autosummary/bec_widgets.widgets.plots.waveform.waveform_widget.Waveform.rst#bec_widgets.widgets.plots.waveform.waveform.Waveform.dap_summary_update) signal of the Waveform widget to ensure its functionality. 
 
 
 ## Key Features:
@@ -34,7 +34,11 @@ waveform.dap_summary_update.connect(lmfit_dialog.update_summary_tree)
 
 ```
 ````
-
+````{tab} API
+```{eval-rst} 
+.. include:: /api_reference/_autosummary/bec_widgets.widgets.lmfit_dialog.lmfit_dialog.LMFitDialog.rst
+```
+````
 
 
 

docs/user/widgets/motor_map/motor_map.md

@@ -63,8 +63,6 @@ mm1.map(x_name='aptrx', y_name='aptry')
 
 ````{tab} API
 ```{eval-rst}  
-.. autoclass:: bec_widgets.cli.client.MotorMap
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.MotorMap.rst
 ```
 ````

docs/user/widgets/multi_waveform/multi_waveform.md

@@ -89,8 +89,6 @@ multi_waveform.export_to_matplotlib()
 
 ````{tab} API
 ```{eval-rst}  
-.. autoclass:: bec_widgets.cli.client.MultiWaveform
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.MultiWaveform.rst
 ```
 ````

docs/user/widgets/position_indicator/position_indicator.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The `PositionIndicator` widget is a simple yet effective tool for visually indicating the position of a motor within its set limits. This widget is particularly useful in applications where it is important to provide a visual clue of the motor's current position relative to its minimum and maximum values. The `PositionIndicator` can be easily integrated into your GUI application either through direct code instantiation or by using `BEC Designer`.
+The [`PositionIndicator`](/api_reference/_autosummary/bec_widgets.cli.client.PositionIndicator) widget is a simple yet effective tool for visually indicating the position of a motor within its set limits. This widget is particularly useful in applications where it is important to provide a visual clue of the motor's current position relative to its minimum and maximum values. The `PositionIndicator` can be easily integrated into your GUI application either through direct code instantiation or by using `BEC Designer`.
 
 ## Key Features:
 - **Position Visualization**: Displays the current position of a motor on a linear scale, showing its location relative to the defined limits.
@@ -36,7 +36,7 @@ Within the BEC Designer's [property editor](https://doc.qt.io/qt-6/designer-widg
 
 ````{tab} Examples
 
-The `PositionIndicator` widget can be embedded in a [`BECDockArea`](user.widgets.bec_dock_area) or used as an individual component in your application through `BEC Designer`. Below are examples demonstrating how to create and use the `PositionIndicator` from the CLI and also directly within Code.
+The `PositionIndicator` widget can be embedded in a [`BECDockArea`](#user.widgets.bec_dock_area) or used as an individual component in your application through `BEC Designer`. Below are examples demonstrating how to create and use the `PositionIndicator` from the CLI and also directly within Code.
 
 ## Example 1 - Creating a Position Indicator in Code
 
@@ -95,8 +95,6 @@ self.position_indicator.set_value(new_position_value)
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.PositionIndicator
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.PositionIndicator.rst
 ```
 ````

docs/user/widgets/positioner_box/positioner_box.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The `PositionerBox` widget provides a graphical user interface to control a positioner device within the BEC environment. This widget allows users to interact with a positioner by setting setpoints, tweaking the motor position, and stopping motion. The device selection can be done via a small button under the device label, through `BEC Designer`, or by using the command line interface (CLI). This flexibility makes the `PositionerBox` an essential tool for tasks involving precise position control.
+The [`PositionerBox`](/api_reference/_autosummary/bec_widgets.cli.client.PositionerBox) widget provides a graphical user interface to control a positioner device within the BEC environment. This widget allows users to interact with a positioner by setting setpoints, tweaking the motor position, and stopping motion. The device selection can be done via a small button under the device label, through `BEC Designer`, or by using the command line interface (CLI). This flexibility makes the `PositionerBox` an essential tool for tasks involving precise position control.
 
 ## Key Features:
 - **Device Selection**: Easily select a positioner device by clicking the button under the device label or by configuring the widget in `BEC Designer`.
@@ -58,8 +58,6 @@ self.positioner_box.set_positioner("motor2")
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.PositionerBox
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.PositionerBox.rst
 ```
 ````

docs/user/widgets/positioner_box/positioner_box_2d.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The `PositionerBox2D` widget is very similar to the `PositionerBox` 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`](/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.
 
@@ -55,8 +55,6 @@ self.positioner_box.set_positioner_verr("samy")
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.PositionerBox2D
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.PositionerBox2D.rst
 ```
 ````

docs/user/widgets/progress_bar/ring_progress_bar.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The `RingProgressBar` widget is a circular progress bar designed to visualize the progress of tasks in a clear and intuitive manner. This widget is particularly useful in applications where task progress needs to be represented as a percentage. The `Ring Progress Bar` can be controlled directly via its API or can be hooked up to track the progress of a device readback or scan, providing real-time visual feedback.
+The [`Ring Progress Bar`](/api_reference/_autosummary/bec_widgets.cli.client.RingProgressBar) widget is a circular progress bar designed to visualize the progress of tasks in a clear and intuitive manner. This widget is particularly useful in applications where task progress needs to be represented as a percentage. The `Ring Progress Bar` can be controlled directly via its API or can be hooked up to track the progress of a device readback or scan, providing real-time visual feedback.
 
 ## Key Features:
 - **Circular Progress Visualization**: Displays a circular progress bar to represent task completion.
@@ -98,9 +98,7 @@ progress.set_value([50, 75, 25])
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.RingProgressBar
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.RingProgressBar.rst
 ```
 ````
 

docs/user/widgets/queue/queue.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The `BECQueue` widget provides a real-time display and control of the BEC scan queue, allowing users to monitor, manage, and control the status of ongoing and pending scans. The widget automatically updates to reflect the current state of the scan queue, displaying critical information such as scan numbers, types, and statuses. Additionally, it provides control options to stop individual scans, stop the entire queue, resume, and reset the queue, making it a powerful tool for managing scan operations in the BEC environment.
+The [`BEC Queue`](/api_reference/_autosummary/bec_widgets.cli.client.BECQueue) widget provides a real-time display and control of the BEC scan queue, allowing users to monitor, manage, and control the status of ongoing and pending scans. The widget automatically updates to reflect the current state of the scan queue, displaying critical information such as scan numbers, types, and statuses. Additionally, it provides control options to stop individual scans, stop the entire queue, resume, and reset the queue, making it a powerful tool for managing scan operations in the BEC environment.
 
 ## Key Features:
 - **Real-Time Queue Monitoring**: Displays the current state of the BEC scan queue, with automatic updates as the queue changes.
@@ -39,8 +39,6 @@ Once the widget is added, it will automatically display the current scan queue
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.BECQueue
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.BECQueue.rst
 ```
 ````

docs/user/widgets/scan_control/scan_control.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The `ScanControl` widget provides a graphical user interface (GUI) to manage various scan operations in a BEC environment. It is designed to interact with the BEC server, enabling users to start and stop scans. The widget automatically creates the necessary input form based on the scan's signature and gui_config, making it highly adaptable to different scanning processes.
+The [`Scan Control`](/api_reference/_autosummary/bec_widgets.cli.client.ScanControl) widget provides a graphical user interface (GUI) to manage various scan operations in a BEC environment. It is designed to interact with the BEC server, enabling users to start and stop scans. The widget automatically creates the necessary input form based on the scan's signature and gui_config, making it highly adaptable to different scanning processes.
 
 ## Key Features:
 - **Automatic Interface Generation**: Automatically generates a control interface based on scan signatures and `gui_config`.
@@ -59,8 +59,6 @@ scan_control = dock_area.new().new(gui.available_widgets.ScanControl)
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.ScanControl
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ScanControl.rst
 ```
 ````

docs/user/widgets/scatter_waveform/scatter_waveform.md

@@ -34,8 +34,6 @@ The ScatterWaveform widget only plots the data points if both x and y axis motor
 
 ````{tab} API
 ```{eval-rst}  
-.. autoclass:: bec_widgets.cli.client.ScatterWaveform
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ScatterWaveform.rst
 ```
 ````

docs/user/widgets/signal_input/signal_input.md

@@ -104,6 +104,14 @@ The following Qt properties are also included:
 
 ````
 
+````{tab} API - ComboBox
+```{eval-rst} 
+.. include:: /api_reference/_autosummary/bec_widgets.control.device_input.signal_combobox.SignalComboBox.rst
+```
+````
 
-
-
+````{tab} API - LineEdit
+```{eval-rst}
+.. include:: /api_reference/_autosummary/bec_widgets.control.device_input.signal_line_edit.SignalLineEdit.rst
+```
+````

docs/user/widgets/signal_label/signal_label.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The `SignalLabel` displays the value of a signal from a device, with optional customization for labels, units, decimal formatting, and signal selection. It is designed for use in BEC (Beamline Experiment Control) GUIs to monitor values which beamline operators might want to keep an eye on, e.g. sample position, flux, hutch state...
+The [`SignalLabel`](/api_reference/_autosummary/bec_widgets.cli.client.SignalLabel) displays the value of a signal from a device, with optional customization for labels, units, decimal formatting, and signal selection. It is designed for use in BEC (Beamline Experiment Control) GUIs to monitor values which beamline operators might want to keep an eye on, e.g. sample position, flux, hutch state...
 
 ## Key Features:
 - Display: Shows the current value of a device signal.
@@ -88,9 +88,7 @@ The various properties can also be set when the SignalLabel widget is added to a
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.TextBox
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.TextBox.rst
 ```
 ````
 

docs/user/widgets/spinner/spinner.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The `SpinnerWidget` is a simple and versatile widget designed to indicate loading or movement within an application. It is commonly used to show that a device is in motion or that an operation is ongoing. The `SpinnerWidget` can be easily integrated into your GUI application either through direct code instantiation or by using `BEC Designer`.
+The [`SpinnerWidget`](/api_reference/_autosummary/bec_widgets.utility.spinner.spinner.SpinnerWidget) is a simple and versatile widget designed to indicate loading or movement within an application. It is commonly used to show that a device is in motion or that an operation is ongoing. The `SpinnerWidget` can be easily integrated into your GUI application either through direct code instantiation or by using `BEC Designer`.
 
 ## Key Features:
 - **Loading Indicator**: Provides a visual indication of ongoing operations or device movement.

docs/user/widgets/text_box/text_box.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The {py:class}`~bec_widgets.cli.client.TextBox` is a versatile widget that allows users to display text within the BEC GUI. It supports both plain text and HTML, making it useful for displaying simple messages or more complex formatted content. This widget is particularly suited for integrating textual content directly into the user interface, whether as a standalone message box or as part of a larger application interface.
+The [`Text Box Widget`](/api_reference/_autosummary/bec_widgets.cli.client.TextBox) is a versatile widget that allows users to display text within the BEC GUI. It supports both plain text and HTML, making it useful for displaying simple messages or more complex formatted content. This widget is particularly suited for integrating textual content directly into the user interface, whether as a standalone message box or as part of a larger application interface.
 
 ## Key Features:
 - **Text Display**: Display either plain text or HTML content, with automatic detection of the format.
@@ -45,9 +45,7 @@ text_box.set_html_text("<h1>Welcome to BEC Widgets</h1><p>This is an example of
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.TextBox
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.TextBox.rst
 ```
 ````