feat(help-inspector): add help inspector widget

refactor: use list of configs for general interfaces

.github/workflows/pytest-matrix.yml

@@ -27,7 +27,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.11", "3.12", "3.13"]
 
     env:
       BEC_WIDGETS_BRANCH: main  # Set the branch you want for bec_widgets

.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,10 +2,14 @@ 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:

.gitlab-ci.yml

@@ -1,289 +0,0 @@
-# This file is a template, and might need editing before it works on your project.
-# Official language image. Look for the different tagged releases at:
-# https://hub.docker.com/r/library/python/tags/
-image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
-#commands to run in the Docker container before starting each job.
-variables:
-  DOCKER_TLS_CERTDIR: ""
-  BEC_CORE_BRANCH:
-    description: bec branch
-    value: main
-  OPHYD_DEVICES_BRANCH:
-    description: ophyd_devices branch
-    value: main
-  CHILD_PIPELINE_BRANCH: $CI_DEFAULT_BRANCH
-  CHECK_PKG_VERSIONS:
-    description: Whether to run additional tests against min/max/random selection of dependencies. Set to 1 for running.
-    value: 0
-
-workflow:
-  rules:
-    - if: $CI_PIPELINE_SOURCE == "schedule"
-    - if: $CI_PIPELINE_SOURCE == "web"
-    - if: $CI_PIPELINE_SOURCE == "pipeline"
-    - if: $CI_PIPELINE_SOURCE == "parent_pipeline"
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-    - if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
-      when: never
-    - if: $CI_COMMIT_BRANCH
-
-include:
-  - template: Security/Secret-Detection.gitlab-ci.yml
-  - project: "bec/awi_utils"
-    file: "/templates/check-packages-job.yml"
-    inputs:
-      stage: test
-      path: "."
-      pytest_args: "-v,--random-order,tests/unit_tests"
-      pip_args: ".[dev]"
-
-# different stages in the pipeline
-stages:
-  - Formatter
-  - test
-  - AdditionalTests
-  - End2End
-  - Deploy
-
-.install-qt-webengine-deps: &install-qt-webengine-deps
-  - apt-get -y install libnss3 libxdamage1 libasound2 libatomic1 libxcursor1
-  - export QTWEBENGINE_DISABLE_SANDBOX=1
-
-.clone-repos: &clone-repos
-  - echo -e "\033[35;1m Using branch $BEC_CORE_BRANCH of BEC CORE \033[0;m";
-  - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-  - echo -e "\033[35;1m Using branch $OPHYD_DEVICES_BRANCH of OPHYD_DEVICES \033[0;m";
-  - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-  - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-
-.install-repos: &install-repos
-  - pip install -e ./ophyd_devices
-  - pip install -e ./bec/bec_lib[dev]
-  - pip install -e ./bec/bec_ipython_client
-  - pip install -e ./bec/pytest_bec_e2e
-
-.install-os-packages: &install-os-packages
-  - apt-get update
-  - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3 xvfb
-  - *install-qt-webengine-deps
-
-before_script:
-  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then
-    echo -e "\033[35;1m Using branch $CHILD_PIPELINE_BRANCH of BEC Widgets \033[0;m";
-    test -d bec_widgets || git clone --branch $CHILD_PIPELINE_BRANCH https://gitlab.psi.ch/bec/bec_widgets.git; cd bec_widgets;
-    fi
-
-formatter:
-  stage: Formatter
-  needs: []
-  script:
-    - pip install -e ./[dev]
-    - isort --check --diff --line-length=100 --profile=black --multi-line=3 --trailing-comma ./
-    - black --check --diff --color --line-length=100 --skip-magic-trailing-comma ./
-  rules:
-    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
-
-pylint:
-  stage: Formatter
-  needs: []
-  before_script:
-    - pip install pylint pylint-exit anybadge
-    - pip install -e .[dev]
-  script:
-    - mkdir ./pylint
-    - pylint ./bec_widgets --output-format=text --output=./pylint/pylint.log | tee ./pylint/pylint.log || pylint-exit $?
-    - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint.log)
-    - anybadge --label=Pylint --file=pylint/pylint.svg --value=$PYLINT_SCORE 2=red 4=orange 8=yellow 10=green
-    - echo "Pylint score is $PYLINT_SCORE"
-  artifacts:
-    paths:
-      - ./pylint/
-    expire_in: 1 week
-  rules:
-    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
-
-pylint-check:
-  stage: Formatter
-  needs: []
-  allow_failure: true
-  before_script:
-    - pip install pylint pylint-exit anybadge
-    - apt-get update
-    - apt-get install -y bc
-  script:
-    - git fetch origin $CI_MERGE_REQUEST_TARGET_BRANCH_NAME
-    # Identify changed Python files
-    - if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then
-      TARGET_BRANCH_COMMIT_SHA=$(git rev-parse origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME);
-      CHANGED_FILES=$(git diff --name-only $TARGET_BRANCH_COMMIT_SHA HEAD | grep '\.py$' || true);
-      else
-      CHANGED_FILES=$(git diff --name-only $CI_COMMIT_BEFORE_SHA $CI_COMMIT_SHA | grep '\.py$' || true);
-      fi
-    - if [ -z "$CHANGED_FILES" ]; then echo "No Python files changed."; exit 0; fi
-
-    - echo "Changed Python files:"
-      - $CHANGED_FILES
-    # Run pylint only on changed files
-    - mkdir ./pylint
-    - pylint $CHANGED_FILES --output-format=text | tee ./pylint/pylint_changed_files.log || pylint-exit $?
-    - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint_changed_files.log)
-    - echo "Pylint score is $PYLINT_SCORE"
-
-    # Fail the job if the pylint score is below 9
-    - if [ "$(echo "$PYLINT_SCORE < 9" | bc)" -eq 1 ]; then echo "Your pylint score is below the acceptable threshold (9)."; exit 1; fi
-  artifacts:
-    paths:
-      - ./pylint/
-    expire_in: 1 week
-  rules:
-    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
-
-tests:
-  stage: test
-  needs: []
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-  script:
-    - *clone-repos
-    - *install-os-packages
-    - *install-repos
-    - pip install -e .[dev,pyside6]
-    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --maxfail=2 --random-order --full-trace ./tests/unit_tests
-    - coverage report
-    - coverage xml
-  coverage: '/(?i)total.*? (100(?:\.0+)?\%|[1-9]?\d(?:\.\d+)?\%)$/'
-  artifacts:
-    reports:
-      junit: report.xml
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage.xml
-    paths:
-      - tests/reference_failures/
-    when: always
-
-generate-client-check:
-  stage: test
-  needs: []
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-  script:
-    - *clone-repos
-    - *install-os-packages
-    - *install-repos
-    - pip install -e .[dev,pyside6]
-    - bw-generate-cli --target bec_widgets
-    # if there are changes in the generated files, fail the job
-    - git diff --exit-code
-
-test-matrix:
-  parallel:
-    matrix:
-      - PYTHON_VERSION:
-          - "3.10"
-          - "3.11"
-          - "3.12"
-        QT_PCKG:
-          - "pyside6"
-
-  stage: AdditionalTests
-  needs: []
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-    PYTHON_VERSION: ""
-    QT_PCKG: ""
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:$PYTHON_VERSION
-  script:
-    - *clone-repos
-    - *install-os-packages
-    - *install-repos
-    - pip install -e .[dev,$QT_PCKG]
-    - pytest -v --maxfail=2 --junitxml=report.xml --random-order ./tests/unit_tests
-
-end-2-end-conda:
-  stage: End2End
-  needs: []
-  image: continuumio/miniconda3:25.1.1-2
-  allow_failure: false
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-  script:
-    - *clone-repos
-    - *install-os-packages
-    - conda config --show-sources
-    - conda config --add channels conda-forge
-    - conda config --system --remove channels https://repo.anaconda.com/pkgs/main
-    - conda config --system --remove channels https://repo.anaconda.com/pkgs/r
-    - conda config --remove channels https://repo.anaconda.com/pkgs/main
-    - conda config --remove channels https://repo.anaconda.com/pkgs/r
-    - conda config --show-sources
-    - conda config --set channel_priority strict
-    - conda config --set always_yes yes --set changeps1 no
-    - conda create -q -n test-environment python=3.11
-    - conda init bash
-    - source ~/.bashrc
-    - conda activate test-environment
-
-    - cd ./bec
-    - source ./bin/install_bec_dev.sh -t
-    - cd ../
-    - pip install -e ./ophyd_devices
-
-    - pip install -e .[dev,pyside6]
-    - pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end
-
-  artifacts:
-    when: on_failure
-    paths:
-      - ./logs/*.log
-    expire_in: 1 week
-
-  rules:
-    - if: '$CI_PIPELINE_SOURCE == "schedule"'
-    - if: '$CI_PIPELINE_SOURCE == "web"'
-    - if: '$CI_PIPELINE_SOURCE == "pipeline"'
-    - if: '$CI_PIPELINE_SOURCE == "parent_pipeline"'
-    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"'
-    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
-    - if: "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME =~ /^pre_release.*$/"
-
-semver:
-  stage: Deploy
-  needs: ["tests"]
-  script:
-    - git config --global user.name "ci_update_bot"
-    - git config --global user.email "ci_update_bot@bec.ch"
-    - git checkout "$CI_COMMIT_REF_NAME"
-    - git reset --hard origin/"$CI_COMMIT_REF_NAME"
-
-    # delete all local tags
-    - git tag -l | xargs git tag -d
-    - git fetch --tags
-    - git tag
-
-    # build and publish package
-    - pip install python-semantic-release==9.* wheel build twine
-    - export GL_TOKEN=$CI_UPDATES
-    - semantic-release -vv version
-
-    # check if any artifacts were created
-    - if [ ! -d dist ]; then echo No release will be made; exit 0; fi
-    - twine upload dist/* -u __token__ -p $CI_PYPI_TOKEN --skip-existing
-    - semantic-release publish
-
-  allow_failure: false
-  rules:
-    - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
-
-pages:
-  stage: Deploy
-  needs: ["semver"]
-  variables:
-    TARGET_BRANCH: $CI_COMMIT_REF_NAME
-  rules:
-    - if: "$CI_COMMIT_TAG != null"
-      variables:
-        TARGET_BRANCH: $CI_COMMIT_TAG
-    - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
-  script:
-    - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/bec-widgets/253243/

.pylintrc

@@ -52,7 +52,7 @@ persistent=yes
 
 # Minimum Python version to use for version dependent checks. Will default to
 # the version used to run pylint.
-py-version=3.10
+py-version=3.11
 
 # When enabled, pylint would attempt to guess common misconfiguration and emit
 # user-friendly hints instead of false-positive error messages.

CHANGELOG.md

@@ -1,6 +1,83 @@
 # CHANGELOG
 
 
+## v2.39.0 (2025-09-24)
+
+### Bug Fixes
+
+- **rpc**: Fix hide/show
+  ([`975404f`](https://github.com/bec-project/bec_widgets/commit/975404f483ddae041d9f4d819f39c53cec191439))
+
+### Features
+
+- **rpc_base**: Windows can be raised to front from CLI
+  ([`565c0bd`](https://github.com/bec-project/bec_widgets/commit/565c0bd1e7f4684d8401b6a2827c35422b1125c4))
+
+
+## v2.38.4 (2025-09-23)
+
+### Bug Fixes
+
+- **image**: Add support for specifying preview signals through cli
+  ([`108ddae`](https://github.com/bec-project/bec_widgets/commit/108ddae6ca3501a57b499c7080a36cf41a653074))
+
+
+## v2.38.3 (2025-09-23)
+
+### Bug Fixes
+
+- **connector**: Only flush pending events
+  ([`475ca9f`](https://github.com/bec-project/bec_widgets/commit/475ca9f2d81bcc2bb0c7b104c0712b13d6616c08))
+
+- **ringprogressbar**: Fix client signature
+  ([`65bc5f5`](https://github.com/bec-project/bec_widgets/commit/65bc5f5421077da70ef5068d51e36119e1055955))
+
+- **ringprogressbar**: Various fixes and improvements
+  ([`bbb5fc6`](https://github.com/bec-project/bec_widgets/commit/bbb5fc6ce17248a948c6fd4a7652d17d64a79d2a))
+
+### Chores
+
+- Deprecate 3.10, add 3.13
+  ([`3e33934`](https://github.com/bec-project/bec_widgets/commit/3e339348dd3d0a3b12522312132fca139dc22835))
+
+### Testing
+
+- **ringprogressbar**: Extend e2e test
+  ([`b1b6c5e`](https://github.com/bec-project/bec_widgets/commit/b1b6c5e6a5dd81965baa5c742e9bdae8cdb4f09b))
+
+
+## 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

README.md

@@ -5,7 +5,7 @@
 [![badge](https://img.shields.io/pypi/v/bec-widgets)](https://pypi.org/project/bec-widgets/)
 [![License](https://img.shields.io/github/license/bec-project/bec_widgets)](./LICENSE)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-[![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue?logo=python&logoColor=white)](https://www.python.org)
+[![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue?logo=python&logoColor=white)](https://www.python.org)
 [![PySide6](https://img.shields.io/badge/PySide6-blue?logo=qt&logoColor=white)](https://doc.qt.io/qtforpython/)
 [![Conventional Commits](https://img.shields.io/badge/conventional%20commits-1.0.0-yellow?logo=conventionalcommits&logoColor=white)](https://conventionalcommits.org)
 [![codecov](https://codecov.io/gh/bec-project/bec_widgets/graph/badge.svg?token=0Z9IQRJKMY)](https://codecov.io/gh/bec-project/bec_widgets)

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/applications/main_app.py

@@ -0,0 +1,200 @@
+from qtpy.QtWidgets import QApplication, QHBoxLayout, QStackedWidget, QWidget
+
+from bec_widgets.applications.navigation_centre.reveal_animator import ANIMATION_DURATION
+from bec_widgets.applications.navigation_centre.side_bar import SideBar
+from bec_widgets.applications.navigation_centre.side_bar_components import NavigationItem
+from bec_widgets.applications.views.device_manager_view.device_manager_widget import (
+    DeviceManagerWidget,
+)
+from bec_widgets.applications.views.view import ViewBase, WaveformViewInline, WaveformViewPopup
+from bec_widgets.utils.colors import apply_theme
+from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
+
+
+class BECMainApp(BECMainWindow):
+
+    def __init__(
+        self,
+        parent=None,
+        *args,
+        anim_duration: int = ANIMATION_DURATION,
+        show_examples: bool = False,
+        **kwargs,
+    ):
+        super().__init__(parent=parent, *args, **kwargs)
+        self._show_examples = bool(show_examples)
+
+        # --- Compose central UI (sidebar + stack)
+        self.sidebar = SideBar(parent=self, anim_duration=anim_duration)
+        self.stack = QStackedWidget(self)
+
+        container = QWidget(self)
+        layout = QHBoxLayout(container)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        layout.addWidget(self.sidebar, 0)
+        layout.addWidget(self.stack, 1)
+        self.setCentralWidget(container)
+
+        # Mapping for view switching
+        self._view_index: dict[str, int] = {}
+        self._current_view_id: str | None = None
+        self.sidebar.view_selected.connect(self._on_view_selected)
+
+        self._add_views()
+
+    def _add_views(self):
+        self.add_section("BEC Applications", "bec_apps")
+        self.ads = AdvancedDockArea(self)
+        self.device_manager = DeviceManagerWidget(self)
+
+        self.add_view(
+            icon="widgets", title="Dock Area", id="dock_area", widget=self.ads, mini_text="Docks"
+        )
+        self.add_view(
+            icon="display_settings",
+            title="Device Manager",
+            id="device_manager",
+            widget=self.device_manager,
+            mini_text="DM",
+        )
+
+        if self._show_examples:
+            self.add_section("Examples", "examples")
+            waveform_view_popup = WaveformViewPopup(
+                parent=self, id="waveform_view_popup", title="Waveform Plot"
+            )
+            waveform_view_stack = WaveformViewInline(
+                parent=self, id="waveform_view_stack", title="Waveform Plot"
+            )
+
+            self.add_view(
+                icon="show_chart",
+                title="Waveform With Popup",
+                id="waveform_popup",
+                widget=waveform_view_popup,
+                mini_text="Popup",
+            )
+            self.add_view(
+                icon="show_chart",
+                title="Waveform InLine Stack",
+                id="waveform_stack",
+                widget=waveform_view_stack,
+                mini_text="Stack",
+            )
+
+        self.set_current("dock_area")
+        self.sidebar.add_dark_mode_item()
+
+    # --- Public API ------------------------------------------------------
+    def add_section(self, title: str, id: str, position: int | None = None):
+        return self.sidebar.add_section(title, id, position)
+
+    def add_separator(self):
+        return self.sidebar.add_separator()
+
+    def add_dark_mode_item(self, id: str = "dark_mode", position: int | None = None):
+        return self.sidebar.add_dark_mode_item(id=id, position=position)
+
+    def add_view(
+        self,
+        *,
+        icon: str,
+        title: str,
+        id: str,
+        widget: QWidget,
+        mini_text: str | None = None,
+        position: int | None = None,
+        from_top: bool = True,
+        toggleable: bool = True,
+        exclusive: bool = True,
+    ) -> NavigationItem:
+        """
+        Register a view in the stack and create a matching nav item in the sidebar.
+
+        Args:
+            icon(str): Icon name for the nav item.
+            title(str): Title for the nav item.
+            id(str): Unique ID for the view/item.
+            widget(QWidget): The widget to add to the stack.
+            mini_text(str, optional): Short text for the nav item when sidebar is collapsed.
+            position(int, optional): Position to insert the nav item.
+            from_top(bool, optional): Whether to count position from the top or bottom.
+            toggleable(bool, optional): Whether the nav item is toggleable.
+            exclusive(bool, optional): Whether the nav item is exclusive.
+
+        Returns:
+            NavigationItem: The created navigation item.
+
+
+        """
+        item = self.sidebar.add_item(
+            icon=icon,
+            title=title,
+            id=id,
+            mini_text=mini_text,
+            position=position,
+            from_top=from_top,
+            toggleable=toggleable,
+            exclusive=exclusive,
+        )
+        # Wrap plain widgets into a ViewBase so enter/exit hooks are available
+        if isinstance(widget, ViewBase):
+            view_widget = widget
+        else:
+            view_widget = ViewBase(content=widget, parent=self, id=id, title=title)
+
+        idx = self.stack.addWidget(view_widget)
+        self._view_index[id] = idx
+        return item
+
+    def set_current(self, id: str) -> None:
+        if id in self._view_index:
+            self.sidebar.activate_item(id)
+
+    # Internal: route sidebar selection to the stack
+    def _on_view_selected(self, vid: str) -> None:
+        # Determine current view
+        current_index = self.stack.currentIndex()
+        current_view = (
+            self.stack.widget(current_index) if 0 <= current_index < self.stack.count() else None
+        )
+
+        # Ask current view whether we may leave
+        if current_view is not None and hasattr(current_view, "on_exit"):
+            may_leave = current_view.on_exit()
+            if may_leave is False:
+                # Veto: restore previous highlight without re-emitting selection
+                if self._current_view_id is not None:
+                    self.sidebar.activate_item(self._current_view_id, emit_signal=False)
+                return
+
+        # Proceed with switch
+        idx = self._view_index.get(vid)
+        if idx is None or not (0 <= idx < self.stack.count()):
+            return
+        self.stack.setCurrentIndex(idx)
+        new_view = self.stack.widget(idx)
+        self._current_view_id = vid
+        if hasattr(new_view, "on_enter"):
+            new_view.on_enter()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="BEC Main Application")
+    parser.add_argument(
+        "--examples", action="store_true", help="Show the Examples section with waveform demo views"
+    )
+    # Let Qt consume the remaining args
+    args, qt_args = parser.parse_known_args(sys.argv[1:])
+
+    app = QApplication([sys.argv[0], *qt_args])
+    apply_theme("dark")
+    w = BECMainApp(show_examples=args.examples)
+    w.show()
+
+    sys.exit(app.exec())

bec_widgets/applications/navigation_centre/reveal_animator.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from qtpy.QtCore import QEasingCurve, QParallelAnimationGroup, QPropertyAnimation
+from qtpy.QtWidgets import QGraphicsOpacityEffect, QWidget
+
+ANIMATION_DURATION = 500  # ms
+
+
+class RevealAnimator:
+    """Animate reveal/hide for a single widget using opacity + max W/H.
+
+    This keeps the widget always visible to avoid jitter from setVisible().
+    Collapsed state: opacity=0, maxW=0, maxH=0.
+    Expanded state: opacity=1, maxW=sizeHint.width(), maxH=sizeHint.height().
+    """
+
+    def __init__(
+        self,
+        widget: QWidget,
+        duration: int = ANIMATION_DURATION,
+        easing: QEasingCurve.Type = QEasingCurve.InOutCubic,
+        initially_revealed: bool = False,
+        *,
+        animate_opacity: bool = True,
+        animate_width: bool = True,
+        animate_height: bool = True,
+    ):
+        self.widget = widget
+        self.animate_opacity = animate_opacity
+        self.animate_width = animate_width
+        self.animate_height = animate_height
+        # Opacity effect
+        self.fx = QGraphicsOpacityEffect(widget)
+        widget.setGraphicsEffect(self.fx)
+        # Animations
+        self.opacity_anim = (
+            QPropertyAnimation(self.fx, b"opacity") if self.animate_opacity else None
+        )
+        self.width_anim = (
+            QPropertyAnimation(widget, b"maximumWidth") if self.animate_width else None
+        )
+        self.height_anim = (
+            QPropertyAnimation(widget, b"maximumHeight") if self.animate_height else None
+        )
+        for anim in (self.opacity_anim, self.width_anim, self.height_anim):
+            if anim is not None:
+                anim.setDuration(duration)
+                anim.setEasingCurve(easing)
+        # Initialize to requested state
+        self.set_immediate(initially_revealed)
+
+    def _natural_sizes(self) -> tuple[int, int]:
+        sh = self.widget.sizeHint()
+        w = max(sh.width(), 1)
+        h = max(sh.height(), 1)
+        return w, h
+
+    def set_immediate(self, revealed: bool):
+        """
+        Immediately set the widget to the target revealed/collapsed state.
+
+        Args:
+            revealed(bool): True to reveal, False to collapse.
+        """
+        w, h = self._natural_sizes()
+        if self.animate_opacity:
+            self.fx.setOpacity(1.0 if revealed else 0.0)
+        if self.animate_width:
+            self.widget.setMaximumWidth(w if revealed else 0)
+        if self.animate_height:
+            self.widget.setMaximumHeight(h if revealed else 0)
+
+    def setup(self, reveal: bool):
+        """
+        Prepare animations to transition to the target revealed/collapsed state.
+
+        Args:
+            reveal(bool): True to reveal, False to collapse.
+        """
+        # Prepare animations from current state to target
+        target_w, target_h = self._natural_sizes()
+        if self.opacity_anim is not None:
+            self.opacity_anim.setStartValue(self.fx.opacity())
+            self.opacity_anim.setEndValue(1.0 if reveal else 0.0)
+        if self.width_anim is not None:
+            self.width_anim.setStartValue(self.widget.maximumWidth())
+            self.width_anim.setEndValue(target_w if reveal else 0)
+        if self.height_anim is not None:
+            self.height_anim.setStartValue(self.widget.maximumHeight())
+            self.height_anim.setEndValue(target_h if reveal else 0)
+
+    def add_to_group(self, group: QParallelAnimationGroup):
+        """
+        Add the prepared animations to the given animation group.
+
+        Args:
+            group(QParallelAnimationGroup): The animation group to add to.
+        """
+        if self.opacity_anim is not None:
+            group.addAnimation(self.opacity_anim)
+        if self.width_anim is not None:
+            group.addAnimation(self.width_anim)
+        if self.height_anim is not None:
+            group.addAnimation(self.height_anim)
+
+    def animations(self):
+        """
+        Get a list of all animations (non-None) for adding to a group.
+        """
+        return [
+            anim
+            for anim in (self.opacity_anim, self.height_anim, self.width_anim)
+            if anim is not None
+        ]

bec_widgets/applications/navigation_centre/side_bar.py

@@ -0,0 +1,357 @@
+from __future__ import annotations
+
+from bec_qthemes import material_icon
+from qtpy import QtWidgets
+from qtpy.QtCore import QEasingCurve, QParallelAnimationGroup, QPropertyAnimation, Qt, Signal
+from qtpy.QtWidgets import (
+    QGraphicsOpacityEffect,
+    QHBoxLayout,
+    QLabel,
+    QScrollArea,
+    QToolButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets import SafeProperty, SafeSlot
+from bec_widgets.applications.navigation_centre.reveal_animator import ANIMATION_DURATION
+from bec_widgets.applications.navigation_centre.side_bar_components import (
+    DarkModeNavItem,
+    NavigationItem,
+    SectionHeader,
+    SideBarSeparator,
+)
+
+
+class SideBar(QScrollArea):
+    view_selected = Signal(str)
+    toggled = Signal(bool)
+
+    def __init__(
+        self,
+        parent=None,
+        title: str = "Control Panel",
+        collapsed_width: int = 56,
+        expanded_width: int = 250,
+        anim_duration: int = ANIMATION_DURATION,
+    ):
+        super().__init__(parent=parent)
+        self.setObjectName("SideBar")
+
+        # private attributes
+        self._is_expanded = False
+        self._collapsed_width = collapsed_width
+        self._expanded_width = expanded_width
+        self._anim_duration = anim_duration
+
+        # containers
+        self.components = {}
+        self._item_opts: dict[str, dict] = {}
+
+        # Scroll area properties
+        self.setWidgetResizable(True)
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.setFrameShape(QtWidgets.QFrame.NoFrame)
+        self.setFixedWidth(self._collapsed_width)
+
+        # Content widget holding buttons for switching views
+        self.content = QWidget(self)
+        self.content_layout = QVBoxLayout(self.content)
+        self.content_layout.setContentsMargins(0, 0, 0, 0)
+        self.content_layout.setSpacing(4)
+        self.setWidget(self.content)
+
+        # Track active navigation item
+        self._active_id = None
+
+        # Top row with title and toggle button
+        self.toggle_row = QWidget(self)
+        self.toggle_row_layout = QHBoxLayout(self.toggle_row)
+
+        self.title_label = QLabel(title, self)
+        self.title_label.setObjectName("TopTitle")
+        self.title_label.setStyleSheet("font-weight: 600;")
+        self.title_fx = QGraphicsOpacityEffect(self.title_label)
+        self.title_label.setGraphicsEffect(self.title_fx)
+        self.title_fx.setOpacity(0.0)
+        self.title_label.setVisible(False)  # TODO dirty trick to avoid layout shift
+
+        self.toggle = QToolButton(self)
+        self.toggle.setCheckable(False)
+        self.toggle.setIcon(material_icon("keyboard_arrow_right", convert_to_pixmap=False))
+        self.toggle.clicked.connect(self.on_expand)
+
+        self.toggle_row_layout.addWidget(self.title_label, 1, Qt.AlignLeft | Qt.AlignVCenter)
+        self.toggle_row_layout.addWidget(self.toggle, 1, Qt.AlignHCenter | Qt.AlignVCenter)
+
+        # To push the content up always
+        self._bottom_spacer = QtWidgets.QSpacerItem(
+            0, 0, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding
+        )
+
+        # Add core widgets to layout
+        self.content_layout.addWidget(self.toggle_row)
+        self.content_layout.addItem(self._bottom_spacer)
+
+        # Animations
+        self.width_anim = QPropertyAnimation(self, b"bar_width")
+        self.width_anim.setDuration(self._anim_duration)
+        self.width_anim.setEasingCurve(QEasingCurve.InOutCubic)
+
+        self.title_anim = QPropertyAnimation(self.title_fx, b"opacity")
+        self.title_anim.setDuration(self._anim_duration)
+        self.title_anim.setEasingCurve(QEasingCurve.InOutCubic)
+
+        self.group = QParallelAnimationGroup(self)
+        self.group.addAnimation(self.width_anim)
+        self.group.addAnimation(self.title_anim)
+        self.group.finished.connect(self._on_anim_finished)
+
+        app = QtWidgets.QApplication.instance()
+        if app is not None and hasattr(app, "theme") and hasattr(app.theme, "theme_changed"):
+            app.theme.theme_changed.connect(self._on_theme_changed)
+
+    @SafeProperty(int)
+    def bar_width(self) -> int:
+        """
+        Get the current width of the side bar.
+
+        Returns:
+            int: The current width of the side bar.
+        """
+        return self.width()
+
+    @bar_width.setter
+    def bar_width(self, width: int):
+        """
+        Set the width of the side bar.
+
+        Args:
+            width(int): The new width of the side bar.
+        """
+        self.setFixedWidth(width)
+
+    @SafeProperty(bool)
+    def is_expanded(self) -> bool:
+        """
+        Check if the side bar is expanded.
+
+        Returns:
+            bool: True if the side bar is expanded, False otherwise.
+        """
+        return self._is_expanded
+
+    @SafeSlot()
+    @SafeSlot(bool)
+    def on_expand(self):
+        """
+        Toggle the expansion state of the side bar.
+        """
+        self._is_expanded = not self._is_expanded
+        self.toggle.setIcon(
+            material_icon(
+                "keyboard_arrow_left" if self._is_expanded else "keyboard_arrow_right",
+                convert_to_pixmap=False,
+            )
+        )
+
+        if self._is_expanded:
+            self.toggle_row_layout.setAlignment(self.toggle, Qt.AlignRight | Qt.AlignVCenter)
+
+        self.group.stop()
+        # Setting limits for animations of the side bar
+        self.width_anim.setStartValue(self.width())
+        self.width_anim.setEndValue(
+            self._expanded_width if self._is_expanded else self._collapsed_width
+        )
+        self.title_anim.setStartValue(self.title_fx.opacity())
+        self.title_anim.setEndValue(1.0 if self._is_expanded else 0.0)
+
+        # Setting limits for animations of the components
+        for comp in self.components.values():
+            if hasattr(comp, "setup_animations"):
+                comp.setup_animations(self._is_expanded)
+
+        self.group.start()
+        if self._is_expanded:
+            # TODO do not like this trick, but it is what it is for now
+            self.title_label.setVisible(self._is_expanded)
+            for comp in self.components.values():
+                if hasattr(comp, "set_visible"):
+                    comp.set_visible(self._is_expanded)
+        self.toggled.emit(self._is_expanded)
+
+    @SafeSlot()
+    def _on_anim_finished(self):
+        if not self._is_expanded:
+            self.toggle_row_layout.setAlignment(self.toggle, Qt.AlignHCenter | Qt.AlignVCenter)
+            # TODO do not like this trick, but it is what it is for now
+            self.title_label.setVisible(self._is_expanded)
+            for comp in self.components.values():
+                if hasattr(comp, "set_visible"):
+                    comp.set_visible(self._is_expanded)
+
+    @SafeSlot(str)
+    def _on_theme_changed(self, theme_name: str):
+        # Refresh toggle arrow icon so it picks up the new theme
+        self.toggle.setIcon(
+            material_icon(
+                "keyboard_arrow_left" if self._is_expanded else "keyboard_arrow_right",
+                convert_to_pixmap=False,
+            )
+        )
+        # Refresh each component that supports it
+        for comp in self.components.values():
+            if hasattr(comp, "refresh_theme"):
+                comp.refresh_theme()
+            else:
+                comp.style().unpolish(comp)
+                comp.style().polish(comp)
+                comp.update()
+        self.style().unpolish(self)
+        self.style().polish(self)
+        self.update()
+
+    def add_section(self, title: str, id: str, position: int | None = None) -> SectionHeader:
+        """
+        Add a section header to the side bar.
+
+        Args:
+            title(str): The title of the section.
+            id(str): Unique ID for the section.
+            position(int, optional): Position to insert the section header.
+
+        Returns:
+            SectionHeader: The created section header.
+
+        """
+        header = SectionHeader(self, title, anim_duration=self._anim_duration)
+        position = position if position is not None else self.content_layout.count() - 1
+        self.content_layout.insertWidget(position, header)
+        for anim in header.animations:
+            self.group.addAnimation(anim)
+        self.components[id] = header
+        return header
+
+    def add_separator(
+        self, *, from_top: bool = True, position: int | None = None
+    ) -> SideBarSeparator:
+        """
+        Add a separator line to the side bar. Separators are treated like regular
+        items; you can place multiple separators anywhere using `from_top` and `position`.
+        """
+        line = SideBarSeparator(self)
+        line.setStyleSheet("margin:12px;")
+        self._insert_nav_item(line, from_top=from_top, position=position)
+        return line
+
+    def add_item(
+        self,
+        icon: str,
+        title: str,
+        id: str,
+        mini_text: str | None = None,
+        position: int | None = None,
+        *,
+        from_top: bool = True,
+        toggleable: bool = True,
+        exclusive: bool = True,
+    ) -> NavigationItem:
+        """
+        Add a navigation item to the side bar.
+
+        Args:
+            icon(str): Icon name for the nav item.
+            title(str): Title for the nav item.
+            id(str): Unique ID for the nav item.
+            mini_text(str, optional): Short text for the nav item when sidebar is collapsed.
+            position(int, optional): Position to insert the nav item.
+            from_top(bool, optional): Whether to count position from the top or bottom.
+            toggleable(bool, optional): Whether the nav item is toggleable.
+            exclusive(bool, optional): Whether the nav item is exclusive.
+
+        Returns:
+            NavigationItem: The created navigation item.
+        """
+        item = NavigationItem(
+            parent=self,
+            title=title,
+            icon_name=icon,
+            mini_text=mini_text,
+            toggleable=toggleable,
+            exclusive=exclusive,
+            anim_duration=self._anim_duration,
+        )
+        self._insert_nav_item(item, from_top=from_top, position=position)
+        for anim in item.build_animations():
+            self.group.addAnimation(anim)
+        self.components[id] = item
+        # Connect activation to activation logic, passing id unchanged
+        item.activated.connect(lambda id=id: self.activate_item(id))
+        return item
+
+    def activate_item(self, target_id: str, *, emit_signal: bool = True):
+        target = self.components.get(target_id)
+        if target is None:
+            return
+        # Non-toggleable acts like an action: do not change any toggled states
+        if hasattr(target, "toggleable") and not target.toggleable:
+            self._active_id = target_id
+            if emit_signal:
+                self.view_selected.emit(target_id)
+            return
+
+        is_exclusive = getattr(target, "exclusive", True)
+        if is_exclusive:
+            # Radio-like behavior among exclusive items only
+            for comp_id, comp in self.components.items():
+                if not isinstance(comp, NavigationItem):
+                    continue
+                if comp is target:
+                    comp.set_active(True)
+                else:
+                    # Only untoggle other items that are also exclusive
+                    if getattr(comp, "exclusive", True):
+                        comp.set_active(False)
+                    # Leave non-exclusive items as they are
+        else:
+            # Non-exclusive toggles independently
+            target.set_active(not target.is_active())
+
+        self._active_id = target_id
+        if emit_signal:
+            self.view_selected.emit(target_id)
+
+    def add_dark_mode_item(
+        self, id: str = "dark_mode", position: int | None = None
+    ) -> DarkModeNavItem:
+        """
+        Add a dark mode toggle item to the side bar.
+
+        Args:
+            id(str): Unique ID for the dark mode item.
+            position(int, optional): Position to insert the dark mode item.
+
+        Returns:
+            DarkModeNavItem: The created dark mode navigation item.
+        """
+        item = DarkModeNavItem(parent=self, id=id, anim_duration=self._anim_duration)
+        # compute bottom insertion point (same semantics as from_top=False)
+        self._insert_nav_item(item, from_top=False, position=position)
+        for anim in item.build_animations():
+            self.group.addAnimation(anim)
+        self.components[id] = item
+        item.activated.connect(lambda id=id: self.activate_item(id))
+        return item
+
+    def _insert_nav_item(
+        self, item: QWidget, *, from_top: bool = True, position: int | None = None
+    ):
+        if from_top:
+            base_index = self.content_layout.indexOf(self._bottom_spacer)
+            pos = base_index if position is None else min(base_index, position)
+        else:
+            base = self.content_layout.indexOf(self._bottom_spacer) + 1
+            pos = base if position is None else base + max(0, position)
+        self.content_layout.insertWidget(pos, item)

bec_widgets/applications/navigation_centre/side_bar_components.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+
+from bec_qthemes import material_icon
+from qtpy import QtCore
+from qtpy.QtCore import QEasingCurve, QPropertyAnimation, Qt
+from qtpy.QtWidgets import (
+    QApplication,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QSizePolicy,
+    QToolButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets import SafeProperty
+from bec_widgets.applications.navigation_centre.reveal_animator import (
+    ANIMATION_DURATION,
+    RevealAnimator,
+)
+
+
+def get_on_primary():
+    app = QApplication.instance()
+    if app is not None and hasattr(app, "theme"):
+        return app.theme.color("ON_PRIMARY")
+    return "#FFFFFF"
+
+
+def get_fg():
+    app = QApplication.instance()
+    if app is not None and hasattr(app, "theme"):
+        return app.theme.color("FG")
+    return "#FFFFFF"
+
+
+class SideBarSeparator(QFrame):
+    """A horizontal line separator for use in SideBar."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setObjectName("SideBarSeparator")
+        self.setFrameShape(QFrame.NoFrame)
+        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        self.setFixedHeight(2)
+        self.setProperty("variant", "separator")
+
+
+class SectionHeader(QWidget):
+    """A section header with a label and a horizontal line below."""
+
+    def __init__(self, parent=None, text: str = None, anim_duration: int = ANIMATION_DURATION):
+        super().__init__(parent)
+        self.setObjectName("SectionHeader")
+
+        self.lbl = QLabel(text, self)
+        self.lbl.setObjectName("SectionHeaderLabel")
+        self.lbl.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
+        self._reveal = RevealAnimator(self.lbl, duration=anim_duration, initially_revealed=False)
+
+        self.line = SideBarSeparator(self)
+
+        lay = QVBoxLayout(self)
+        # keep your margins/spacing preferences here if needed
+        lay.setContentsMargins(12, 0, 12, 0)
+        lay.setSpacing(6)
+        lay.addWidget(self.lbl)
+        lay.addWidget(self.line)
+
+        self.animations = self.build_animations()
+
+    def build_animations(self) -> list[QPropertyAnimation]:
+        """
+        Build and return animations for expanding/collapsing the sidebar.
+
+        Returns:
+            list[QPropertyAnimation]: List of animations.
+        """
+        return self._reveal.animations()
+
+    def setup_animations(self, expanded: bool):
+        """
+        Setup animations for expanding/collapsing the sidebar.
+
+        Args:
+            expanded(bool): True if the sidebar is expanded, False if collapsed.
+        """
+        self._reveal.setup(expanded)
+
+
+class NavigationItem(QWidget):
+    """A nav tile with an icon + labels and an optional expandable body.
+    Provides animations for collapsed/expanded sidebar states via
+    build_animations()/setup_animations(), similar to SectionHeader.
+    """
+
+    activated = QtCore.Signal()
+
+    def __init__(
+        self,
+        parent=None,
+        *,
+        title: str,
+        icon_name: str,
+        mini_text: str | None = None,
+        toggleable: bool = True,
+        exclusive: bool = True,
+        anim_duration: int = ANIMATION_DURATION,
+    ):
+        super().__init__(parent=parent)
+        self.setObjectName("NavigationItem")
+
+        # Private attributes
+        self._title = title
+        self._icon_name = icon_name
+        self._mini_text = mini_text or title
+        self._toggleable = toggleable
+        self._toggled = False
+        self._exclusive = exclusive
+
+        # Main Icon
+        self.icon_btn = QToolButton(self)
+        self.icon_btn.setIcon(material_icon(self._icon_name, filled=False, convert_to_pixmap=False))
+        self.icon_btn.setAutoRaise(True)
+        self._icon_size_collapsed = QtCore.QSize(20, 20)
+        self._icon_size_expanded = QtCore.QSize(26, 26)
+        self.icon_btn.setIconSize(self._icon_size_collapsed)
+        # Remove QToolButton hover/pressed background/outline
+        self.icon_btn.setStyleSheet(
+            """
+            QToolButton:hover { background: transparent; border: none; }
+            QToolButton:pressed { background: transparent; border: none; }
+            """
+        )
+
+        # Mini label below icon
+        self.mini_lbl = QLabel(self._mini_text, self)
+        self.mini_lbl.setObjectName("NavMiniLabel")
+        self.mini_lbl.setAlignment(Qt.AlignCenter)
+        self.mini_lbl.setStyleSheet("font-size: 10px;")
+        self.reveal_mini_lbl = RevealAnimator(
+            widget=self.mini_lbl,
+            initially_revealed=True,
+            animate_width=False,
+            duration=anim_duration,
+        )
+
+        # Container for icon + mini label
+        self.mini_icon = QWidget(self)
+        mini_lay = QVBoxLayout(self.mini_icon)
+        mini_lay.setContentsMargins(0, 2, 0, 2)
+        mini_lay.setSpacing(2)
+        mini_lay.addWidget(self.icon_btn, 0, Qt.AlignCenter)
+        mini_lay.addWidget(self.mini_lbl, 0, Qt.AlignCenter)
+
+        # Title label
+        self.title_lbl = QLabel(self._title, self)
+        self.title_lbl.setObjectName("NavTitleLabel")
+        self.title_lbl.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
+        self.title_lbl.setStyleSheet("font-size: 13px;")
+        self.reveal_title_lbl = RevealAnimator(
+            widget=self.title_lbl,
+            initially_revealed=False,
+            animate_height=False,
+            duration=anim_duration,
+        )
+        self.title_lbl.setVisible(False)  # TODO dirty trick to avoid layout shift
+
+        lay = QHBoxLayout(self)
+        lay.setContentsMargins(12, 2, 12, 2)
+        lay.setSpacing(6)
+        lay.addWidget(self.mini_icon, 0, Qt.AlignHCenter | Qt.AlignTop)
+        lay.addWidget(self.title_lbl, 1, Qt.AlignLeft | Qt.AlignVCenter)
+
+        self.icon_size_anim = QPropertyAnimation(self.icon_btn, b"iconSize")
+        self.icon_size_anim.setDuration(anim_duration)
+        self.icon_size_anim.setEasingCurve(QEasingCurve.InOutCubic)
+
+        # Connect icon button to emit activation
+        self.icon_btn.clicked.connect(self._emit_activated)
+        self.setMouseTracking(True)
+        self.setAttribute(Qt.WA_StyledBackground, True)
+
+    def is_active(self) -> bool:
+        """Return whether the item is currently active/selected."""
+        return self.property("toggled") is True
+
+    def build_animations(self) -> list[QPropertyAnimation]:
+        """
+        Build and return animations for expanding/collapsing the sidebar.
+
+        Returns:
+            list[QPropertyAnimation]: List of animations.
+        """
+        return (
+            self.reveal_title_lbl.animations()
+            + self.reveal_mini_lbl.animations()
+            + [self.icon_size_anim]
+        )
+
+    def setup_animations(self, expanded: bool):
+        """
+        Setup animations for expanding/collapsing the sidebar.
+
+        Args:
+            expanded(bool): True if the sidebar is expanded, False if collapsed.
+        """
+        self.reveal_mini_lbl.setup(not expanded)
+        self.reveal_title_lbl.setup(expanded)
+        self.icon_size_anim.setStartValue(self.icon_btn.iconSize())
+        self.icon_size_anim.setEndValue(
+            self._icon_size_expanded if expanded else self._icon_size_collapsed
+        )
+
+    def set_visible(self, visible: bool):
+        """Set visibility of the title label."""
+        self.title_lbl.setVisible(visible)
+
+    def _emit_activated(self):
+        self.activated.emit()
+
+    def set_active(self, active: bool):
+        """
+        Set the active/selected state of the item.
+
+        Args:
+            active(bool): True to set active, False to deactivate.
+        """
+        self.setProperty("toggled", active)
+        self.toggled = active
+        # ensure style refresh
+        self.style().unpolish(self)
+        self.style().polish(self)
+        self.update()
+
+    def mousePressEvent(self, event):
+        self.activated.emit()
+        super().mousePressEvent(event)
+
+    @SafeProperty(bool)
+    def toggleable(self) -> bool:
+        """
+        Whether the item is toggleable (like a button) or not (like an action).
+
+        Returns:
+            bool: True if toggleable, False otherwise.
+        """
+        return self._toggleable
+
+    @toggleable.setter
+    def toggleable(self, value: bool):
+        """
+        Set whether the item is toggleable (like a button) or not (like an action).
+        Args:
+            value(bool): True to make toggleable, False otherwise.
+        """
+        self._toggleable = bool(value)
+
+    @SafeProperty(bool)
+    def toggled(self) -> bool:
+        """
+        Whether the item is currently toggled/selected.
+
+        Returns:
+            bool: True if toggled, False otherwise.
+        """
+        return self._toggled
+
+    @toggled.setter
+    def toggled(self, value: bool):
+        """
+        Set whether the item is currently toggled/selected.
+
+        Args:
+            value(bool): True to set toggled, False to untoggle.
+        """
+        self._toggled = value
+        if value:
+            new_icon = material_icon(
+                self._icon_name, filled=True, color=get_on_primary(), convert_to_pixmap=False
+            )
+        else:
+            new_icon = material_icon(
+                self._icon_name, filled=False, color=get_fg(), convert_to_pixmap=False
+            )
+        self.icon_btn.setIcon(new_icon)
+        # Re-polish so QSS applies correct colors to icon/labels
+        for w in (self, self.icon_btn, self.title_lbl, self.mini_lbl):
+            w.style().unpolish(w)
+            w.style().polish(w)
+            w.update()
+
+    @SafeProperty(bool)
+    def exclusive(self) -> bool:
+        """
+        Whether the item is exclusive in its toggle group.
+
+        Returns:
+            bool: True if exclusive, False otherwise.
+        """
+        return self._exclusive
+
+    @exclusive.setter
+    def exclusive(self, value: bool):
+        """
+        Set whether the item is exclusive in its toggle group.
+
+        Args:
+            value(bool): True to make exclusive, False otherwise.
+        """
+        self._exclusive = bool(value)
+
+    def refresh_theme(self):
+        # Recompute icon/label colors according to current theme and state
+        # Trigger the toggled setter to rebuild the icon with the correct color
+        self.toggled = self._toggled
+        # Ensure QSS-driven text/icon colors refresh
+        for w in (self, self.icon_btn, self.title_lbl, self.mini_lbl):
+            w.style().unpolish(w)
+            w.style().polish(w)
+            w.update()
+
+
+class DarkModeNavItem(NavigationItem):
+    """Bottom action item that toggles app theme and updates its icon/text."""
+
+    def __init__(
+        self, parent=None, *, id: str = "dark_mode", anim_duration: int = ANIMATION_DURATION
+    ):
+        super().__init__(
+            parent=parent,
+            title="Dark mode",
+            icon_name="dark_mode",
+            mini_text="Dark",
+            toggleable=False,  # action-like, no selection highlight changes
+            exclusive=False,
+            anim_duration=anim_duration,
+        )
+        self._id = id
+        self._sync_from_qapp_theme()
+        self.activated.connect(self.toggle_theme)
+
+    def _qapp_dark_enabled(self) -> bool:
+        qapp = QApplication.instance()
+        return bool(getattr(getattr(qapp, "theme", None), "theme", None) == "dark")
+
+    def _sync_from_qapp_theme(self):
+        is_dark = self._qapp_dark_enabled()
+        # Update labels
+        self.title_lbl.setText("Light mode" if is_dark else "Dark mode")
+        self.mini_lbl.setText("Light" if is_dark else "Dark")
+        # Update icon
+        self.icon_btn.setIcon(
+            material_icon("light_mode" if is_dark else "dark_mode", convert_to_pixmap=False)
+        )
+
+    def refresh_theme(self):
+        self._sync_from_qapp_theme()
+        for w in (self, self.icon_btn, self.title_lbl, self.mini_lbl):
+            w.style().unpolish(w)
+            w.style().polish(w)
+            w.update()
+
+    def toggle_theme(self):
+        """Toggle application theme and update icon/text."""
+        from bec_widgets.utils.colors import apply_theme
+
+        is_dark = self._qapp_dark_enabled()
+
+        apply_theme("light" if is_dark else "dark")
+        self._sync_from_qapp_theme()

bec_widgets/applications/views/device_manager_view/device_manager_view.py

@@ -0,0 +1,564 @@
+from __future__ import annotations
+
+import os
+from functools import partial
+from typing import List
+
+import PySide6QtAds as QtAds
+import yaml
+from bec_lib import config_helper
+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, QThreadPool, 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.control.device_manager.components import (
+    DeviceTableView,
+    DMConfigView,
+    DMOphydTest,
+    DocstringView,
+)
+from bec_widgets.widgets.control.device_manager.components._util import SharedSelectionSignal
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_resources import (
+    AvailableDeviceResources,
+)
+from bec_widgets.widgets.services.device_browser.device_item.config_communicator import (
+    CommunicateConfigAction,
+)
+from bec_widgets.widgets.services.device_browser.device_item.device_config_dialog import (
+    PresetClassDeviceConfigDialog,
+)
+
+logger = bec_logger.logger
+
+_yes_no_question = partial(
+    QMessageBox.question,
+    buttons=QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+    defaultButton=QMessageBox.StandardButton.No,
+)
+
+
+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.Orientation.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)
+
+        self._config_helper = config_helper.ConfigHelper(self.client.connector)
+        self._shared_selection = SharedSelectionSignal()
+
+        # 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.dock_manager.setStyleSheet("")
+        self._root_layout.addWidget(self.dock_manager)
+
+        # Available Resources Widget
+        self.available_devices = AvailableDeviceResources(
+            self, shared_selection_signal=self._shared_selection
+        )
+        self.available_devices_dock = QtAds.CDockWidget(
+            self.dock_manager, "Available Devices", self
+        )
+        self.available_devices_dock.setWidget(self.available_devices)
+
+        # Device Table View widget
+        self.device_table_view = DeviceTableView(
+            self, shared_selection_signal=self._shared_selection
+        )
+        self.device_table_view_dock = QtAds.CDockWidget(self.dock_manager, "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(self.dock_manager, "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(self.dock_manager, "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(self.dock_manager, "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
+        for signal, slots in [
+            (
+                self.device_table_view.selected_devices,
+                (self.dm_config_view.on_select_config, self.dm_docs_view.on_select_config),
+            ),
+            (
+                self.available_devices.selected_devices,
+                (self.dm_config_view.on_select_config, self.dm_docs_view.on_select_config),
+            ),
+            (
+                self.ophyd_test_view.device_validated,
+                (self.device_table_view.update_device_validation,),
+            ),
+            (
+                self.device_table_view.device_configs_changed,
+                (
+                    self.ophyd_test_view.change_device_configs,
+                    self.available_devices.mark_devices_used,
+                ),
+            ),
+            (
+                self.available_devices.add_selected_devices,
+                (self.device_table_view.add_device_configs,),
+            ),
+            (
+                self.available_devices.del_selected_devices,
+                (self.device_table_view.remove_device_configs,),
+            ),
+        ]:
+            for slot in slots:
+                signal.connect(slot)
+
+        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)
+
+        load = MaterialIconAction(
+            icon_name="file_open",
+            parent=self,
+            tooltip="Load configuration file from disk",
+            label_text="Load Config",
+        )
+        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",
+            label_text="Save Config",
+        )
+        self.toolbar.components.add_safe("safe_to_disk", safe_to_disk)
+        safe_to_disk.action.triggered.connect(self._save_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",
+            label_text="Reload Config",
+        )
+        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",
+            label_text="Update Config",
+        )
+        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")
+
+        # Add load config from plugin dir
+        self.toolbar.add_bundle(io_bundle)
+
+    # Table actions
+
+    def _add_table_actions(self) -> None:
+        table_bundle = ToolbarBundle("Table", self.toolbar.components)
+
+        # Reset composed view
+        reset_composed = MaterialIconAction(
+            icon_name="delete_sweep",
+            parent=self,
+            tooltip="Reset current composed config view",
+            label_text="Reset Config",
+        )
+        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", label_text="Add 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", label_text="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 with 'connect' on selected devices",
+            label_text="Rerun Validation",
+        )
+        rerun_validation.action.triggered.connect(self._rerun_validation_action)
+        self.toolbar.components.add_safe("rerun_validation", rerun_validation)
+        table_bundle.add_action("rerun_validation")
+
+        # Add load config from plugin dir
+        self.toolbar.add_bundle(table_bundle)
+
+        # 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
+    def _coming_soon(self):
+        return QMessageBox.question(
+            self,
+            "Not implemented yet",
+            "This feature has not been implemented yet, will be coming soon...!!",
+            QMessageBox.StandardButton.Cancel,
+            QMessageBox.StandardButton.Cancel,
+        )
+
+    @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 = [{"name": k, **v} for k, v in yaml_load(file_path).items()]
+            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 = _yes_no_question(
+            self,
+            "Load currently active config",
+            "Do you really want to discard the current config and reload?",
+        )
+        if reply == QMessageBox.StandardButton.Yes and self.client.device_manager is not None:
+            self.device_table_view.set_device_config(
+                self.client.device_manager._get_redis_device_config()
+            )
+        else:
+            return
+
+    @SafeSlot()
+    def _update_redis_action(self):
+        """Action to push the current composition to Redis"""
+        reply = _yes_no_question(
+            self,
+            "Push composition to Redis",
+            "Do you really want to replace the active configuration in the BEC server with the current composition? ",
+        )
+        if reply != QMessageBox.StandardButton.Yes:
+            return
+        if self.device_table_view.table.contains_invalid_devices():
+            return QMessageBox.warning(
+                self, "Validation has errors!", "Please resolve before proceeding."
+            )
+        if self.ophyd_test_view.validation_running():
+            return QMessageBox.warning(
+                self, "Validation has not completed.", "Please wait for the validation to finish."
+            )
+        self._push_compositiion_to_redis()
+
+    def _push_compositiion_to_redis(self):
+        config = {cfg.pop("name"): cfg for cfg in self.device_table_view.table.all_configs()}
+        threadpool = QThreadPool.globalInstance()
+        comm = CommunicateConfigAction(self._config_helper, None, config, "set")
+        threadpool.start(comm)
+
+    @SafeSlot()
+    def _save_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 = {cfg.pop("name"): cfg for cfg in self.device_table_view.get_device_config()}
+            with open(file_path, "w") as file:
+                file.write(yaml.dump(config))
+
+    # Table actions
+
+    @SafeSlot()
+    def _reset_composed_view(self):
+        """Action for the 'reset_composed_view' action to reset the composed view."""
+        reply = _yes_no_question(
+            self,
+            "Clear View",
+            "You are about to clear the current composed config view, please confirm...",
+        )
+        if reply == QMessageBox.StandardButton.Yes:
+            self.device_table_view.clear_device_configs()
+
+    # TODO 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
+        dialog = PresetClassDeviceConfigDialog(parent=self)
+        dialog.accepted_data.connect(self._add_to_table_from_dialog)
+        dialog.open()
+
+    @SafeSlot(dict)
+    def _add_to_table_from_dialog(self, data):
+        self.device_table_view.add_device_configs([data])
+
+    @SafeSlot()
+    def _remove_device_action(self):
+        """Action for the 'remove_device' action to remove a device."""
+        self.device_table_view.remove_selected_rows()
+
+    # 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."""
+        configs = self.device_table_view.table.selected_configs()
+        self.ophyd_test_view.change_device_configs(configs, True, True)
+
+    ####### Default view has to be done with setting up splitters ########
+    def set_default_view(
+        self, horizontal_weights: list, vertical_weights: list
+    ):  # TODO separate logic for all ads based widgets
+        """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.Orientation.Horizontal:
+                splitters_h.append(splitter)
+            elif splitter.orientation() == Qt.Orientation.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
+    ):  # TODO separate logic for all ads based widgets
+        """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 = 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/applications/views/device_manager_view/device_manager_widget.py

@@ -0,0 +1,119 @@
+"""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.applications.views.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.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()
+        self.device_manager_view.device_table_view.set_device_config(config)
+        self.stacked_layout.setCurrentWidget(self.device_manager_view)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    from bec_widgets.utils.colors import apply_theme
+
+    apply_theme("light")
+
+    widget = QtWidgets.QWidget()
+    layout = QtWidgets.QVBoxLayout(widget)
+    widget.setLayout(layout)
+    layout.setContentsMargins(0, 0, 0, 0)
+    layout.setSpacing(0)
+    device_manager = DeviceManagerWidget()
+    # config = device_manager.client.device_manager._get_redis_device_config()
+    # device_manager.device_table_view.set_device_config(config)
+    layout.addWidget(device_manager)
+    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
+    dark_mode_button = DarkModeButton()
+    layout.addWidget(dark_mode_button)
+    widget.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/applications/views/view.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+from qtpy.QtCore import QEventLoop
+from qtpy.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFormLayout,
+    QHBoxLayout,
+    QLabel,
+    QMessageBox,
+    QPushButton,
+    QStackedLayout,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
+from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
+from bec_widgets.widgets.plots.waveform.waveform import Waveform
+
+
+class ViewBase(QWidget):
+    """Wrapper for a content widget used inside the main app's stacked view.
+
+    Subclasses can implement `on_enter` and `on_exit` to run custom logic when the view becomes visible or is about to be hidden.
+
+    Args:
+        content (QWidget): The actual view widget to display.
+        parent (QWidget | None): Parent widget.
+        id (str | None): Optional view id, useful for debugging or introspection.
+        title (str | None): Optional human-readable title.
+    """
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        content: QWidget | None = None,
+        *,
+        id: str | None = None,
+        title: str | None = None,
+    ):
+        super().__init__(parent=parent)
+        self.content: QWidget | None = None
+        self.view_id = id
+        self.view_title = title
+
+        lay = QVBoxLayout(self)
+        lay.setContentsMargins(0, 0, 0, 0)
+        lay.setSpacing(0)
+
+        if content is not None:
+            self.set_content(content)
+
+    def set_content(self, content: QWidget) -> None:
+        """Replace the current content widget with a new one."""
+        if self.content is not None:
+            self.content.setParent(None)
+        self.content = content
+        self.layout().addWidget(content)
+
+    @SafeSlot()
+    def on_enter(self) -> None:
+        """Called after the view becomes current/visible.
+
+        Default implementation does nothing. Override in subclasses.
+        """
+        pass
+
+    @SafeSlot()
+    def on_exit(self) -> bool:
+        """Called before the view is switched away/hidden.
+
+        Return True to allow switching, or False to veto.
+        Default implementation allows switching.
+        """
+        return True
+
+
+####################################################################################################
+# Example views for demonstration/testing purposes
+####################################################################################################
+
+
+# --- Popup UI version ---
+class WaveformViewPopup(ViewBase):  # pragma: no cover
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent=parent, *args, **kwargs)
+
+        self.waveform = Waveform(parent=self)
+        self.set_content(self.waveform)
+
+    @SafeSlot()
+    def on_enter(self) -> None:
+        dialog = QDialog(self)
+        dialog.setWindowTitle("Configure Waveform View")
+
+        label = QLabel("Select device and signal for the waveform plot:", parent=dialog)
+
+        # same as in the CurveRow used in waveform
+        self.device_edit = DeviceComboBox(parent=self)
+        self.device_edit.insertItem(0, "")
+        self.device_edit.setEditable(True)
+        self.device_edit.setCurrentIndex(0)
+        self.entry_edit = SignalComboBox(parent=self)
+        self.entry_edit.include_config_signals = False
+        self.entry_edit.insertItem(0, "")
+        self.entry_edit.setEditable(True)
+        self.device_edit.currentTextChanged.connect(self.entry_edit.set_device)
+        self.device_edit.device_reset.connect(self.entry_edit.reset_selection)
+
+        form = QFormLayout()
+        form.addRow(label)
+        form.addRow("Device", self.device_edit)
+        form.addRow("Signal", self.entry_edit)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, parent=dialog)
+        buttons.accepted.connect(dialog.accept)
+        buttons.rejected.connect(dialog.reject)
+
+        v = QVBoxLayout(dialog)
+        v.addLayout(form)
+        v.addWidget(buttons)
+
+        if dialog.exec_() == QDialog.Accepted:
+            self.waveform.plot(
+                y_name=self.device_edit.currentText(), y_entry=self.entry_edit.currentText()
+            )
+
+    @SafeSlot()
+    def on_exit(self) -> bool:
+        ans = QMessageBox.question(
+            self,
+            "Switch and clear?",
+            "Do you want to switch views and clear the plot?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No,
+        )
+        if ans == QMessageBox.Yes:
+            self.waveform.clear_all()
+            return True
+        return False
+
+
+# --- Inline stacked UI version ---
+class WaveformViewInline(ViewBase):  # pragma: no cover
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent=parent, *args, **kwargs)
+
+        # Root layout for this view uses a stacked layout
+        self.stack = QStackedLayout()
+        container = QWidget(self)
+        container.setLayout(self.stack)
+        self.set_content(container)
+
+        # --- Page 0: Settings page (inline form)
+        self.settings_page = QWidget()
+        sp_layout = QVBoxLayout(self.settings_page)
+        sp_layout.setContentsMargins(16, 16, 16, 16)
+        sp_layout.setSpacing(12)
+
+        title = QLabel("Select device and signal for the waveform plot:", parent=self.settings_page)
+        self.device_edit = DeviceComboBox(parent=self.settings_page)
+        self.device_edit.insertItem(0, "")
+        self.device_edit.setEditable(True)
+        self.device_edit.setCurrentIndex(0)
+
+        self.entry_edit = SignalComboBox(parent=self.settings_page)
+        self.entry_edit.include_config_signals = False
+        self.entry_edit.insertItem(0, "")
+        self.entry_edit.setEditable(True)
+        self.device_edit.currentTextChanged.connect(self.entry_edit.set_device)
+        self.device_edit.device_reset.connect(self.entry_edit.reset_selection)
+
+        form = QFormLayout()
+        form.addRow(title)
+        form.addRow("Device", self.device_edit)
+        form.addRow("Signal", self.entry_edit)
+
+        btn_row = QHBoxLayout()
+        ok_btn = QPushButton("OK", parent=self.settings_page)
+        cancel_btn = QPushButton("Cancel", parent=self.settings_page)
+        btn_row.addStretch(1)
+        btn_row.addWidget(cancel_btn)
+        btn_row.addWidget(ok_btn)
+
+        sp_layout.addLayout(form)
+        sp_layout.addLayout(btn_row)
+
+        # --- Page 1: Waveform page
+        self.waveform_page = QWidget()
+        wf_layout = QVBoxLayout(self.waveform_page)
+        wf_layout.setContentsMargins(0, 0, 0, 0)
+        self.waveform = Waveform(parent=self.waveform_page)
+        wf_layout.addWidget(self.waveform)
+
+        # --- Page 2: Exit confirmation page (inline)
+        self.confirm_page = QWidget()
+        cp_layout = QVBoxLayout(self.confirm_page)
+        cp_layout.setContentsMargins(16, 16, 16, 16)
+        cp_layout.setSpacing(12)
+        qlabel = QLabel("Do you want to switch views and clear the plot?", parent=self.confirm_page)
+        cp_buttons = QHBoxLayout()
+        no_btn = QPushButton("No", parent=self.confirm_page)
+        yes_btn = QPushButton("Yes", parent=self.confirm_page)
+        cp_buttons.addStretch(1)
+        cp_buttons.addWidget(no_btn)
+        cp_buttons.addWidget(yes_btn)
+        cp_layout.addWidget(qlabel)
+        cp_layout.addLayout(cp_buttons)
+
+        # Add pages to the stack
+        self.stack.addWidget(self.settings_page)  # index 0
+        self.stack.addWidget(self.waveform_page)  # index 1
+        self.stack.addWidget(self.confirm_page)  # index 2
+
+        # Wire settings buttons
+        ok_btn.clicked.connect(self._apply_settings_and_show_waveform)
+        cancel_btn.clicked.connect(self._show_waveform_without_changes)
+
+        # Prepare result holder for the inline confirmation
+        self._exit_choice_yes = None
+        yes_btn.clicked.connect(lambda: self._exit_reply(True))
+        no_btn.clicked.connect(lambda: self._exit_reply(False))
+
+    @SafeSlot()
+    def on_enter(self) -> None:
+        # Always start on the settings page when entering
+        self.stack.setCurrentIndex(0)
+
+    @SafeSlot()
+    def on_exit(self) -> bool:
+        # Show inline confirmation page and synchronously wait for a choice
+        # -> trick to make the choice blocking, however popup would be cleaner solution
+        self._exit_choice_yes = None
+        self.stack.setCurrentIndex(2)
+        loop = QEventLoop()
+        self._exit_loop = loop
+        loop.exec_()
+
+        if self._exit_choice_yes:
+            self.waveform.clear_all()
+            return True
+        # Revert to waveform view if user cancelled switching
+        self.stack.setCurrentIndex(1)
+        return False
+
+    def _apply_settings_and_show_waveform(self):
+        dev = self.device_edit.currentText()
+        sig = self.entry_edit.currentText()
+        if dev and sig:
+            self.waveform.plot(y_name=dev, y_entry=sig)
+        self.stack.setCurrentIndex(1)
+
+    def _show_waveform_without_changes(self):
+        # Just show waveform page without plotting
+        self.stack.setCurrentIndex(1)
+
+    def _exit_reply(self, yes: bool):
+        self._exit_choice_yes = bool(yes)
+        if hasattr(self, "_exit_loop") and self._exit_loop.isRunning():
+            self._exit_loop.quit()

bec_widgets/cli/client.py

@@ -27,7 +27,6 @@ class _WidgetsEnumType(str, enum.Enum):
 
 
 _Widgets = {
-    "AbortButton": "AbortButton",
     "BECDockArea": "BECDockArea",
     "BECMainWindow": "BECMainWindow",
     "BECProgressBar": "BECProgressBar",
@@ -50,7 +49,6 @@ _Widgets = {
     "PositionerBox2D": "PositionerBox2D",
     "PositionerControlLine": "PositionerControlLine",
     "PositionerGroup": "PositionerGroup",
-    "ResetButton": "ResetButton",
     "ResumeButton": "ResumeButton",
     "RingProgressBar": "RingProgressBar",
     "SBBMonitor": "SBBMonitor",
@@ -60,7 +58,6 @@ _Widgets = {
     "SignalComboBox": "SignalComboBox",
     "SignalLabel": "SignalLabel",
     "SignalLineEdit": "SignalLineEdit",
-    "StopButton": "StopButton",
     "TextBox": "TextBox",
     "VSCodeEditor": "VSCodeEditor",
     "Waveform": "Waveform",
@@ -97,13 +94,84 @@ except ImportError as e:
     logger.error(f"Failed loading plugins: \n{reduce(add, traceback.format_exception(e))}")
 
 
-class AbortButton(RPCBase):
-    """A button that abort the scan."""
+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 remove(self):
+    def widget_map(self) -> "dict[str, QWidget]":
         """
-        Cleanup the BECConnector
+        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
         """
 
 
@@ -143,6 +211,26 @@ class AutoUpdates(RPCBase):
         """
 
 
+class AvailableDeviceResources(RPCBase):
+    @rpc_call
+    def remove(self):
+        """
+        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 BECDock(RPCBase):
     @property
     @rpc_call
@@ -442,6 +530,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 +625,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 +653,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."""
@@ -964,6 +1095,48 @@ class Curve(RPCBase):
         """
 
 
+class DMConfigView(RPCBase):
+    @rpc_call
+    def remove(self):
+        """
+        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 DMOphydTest(RPCBase):
+    """Widget to test device configurations using ophyd devices."""
+
+    @rpc_call
+    def remove(self):
+        """
+        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 DapComboBox(RPCBase):
     """The DAPComboBox widget is an extension to the QComboBox with all avaialble DAP model from BEC."""
 
@@ -1002,6 +1175,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 +1197,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 +1242,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 +1642,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 +2199,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):
@@ -2218,7 +2451,7 @@ class Image(RPCBase):
         Set the image source and update the image.
 
         Args:
-            monitor(str): The name of the monitor to use for the image.
+            monitor(str|tuple|None): The name of the monitor to use for the image, or a tuple of (device, signal) for preview signals. If None or empty string, the current monitor will be disconnected.
             monitor_type(str): The type of monitor to use. Options are "1d", "2d", or "auto".
             color_map(str): The color map to use for the image.
             color_bar(str): The type of color bar to use. Options are "simple" or "full".
@@ -2590,6 +2823,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 +3117,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 +3541,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 +3774,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 +3815,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 +3847,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 +3878,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."""
@@ -3696,16 +4027,6 @@ class RectangularROI(RPCBase):
         """
 
 
-class ResetButton(RPCBase):
-    """A button that resets the scan queue."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class ResumeButton(RPCBase):
     """A button that continue scan queue."""
 
@@ -3715,6 +4036,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
@@ -3880,7 +4213,7 @@ class RingProgressBar(RPCBase):
         """
 
     @rpc_call
-    def set_precision(self, precision: "int", bar_index: "int" = None):
+    def set_precision(self, precision: "int", bar_index: "int | None" = None):
         """
         Set the precision for the progress bars. If bar_index is not provide, the precision will be set for all progress bars.
 
@@ -3996,6 +4329,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 +4359,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 +4387,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 +4697,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):
@@ -4620,16 +5002,6 @@ class SignalLineEdit(RPCBase):
         """
 
 
-class StopButton(RPCBase):
-    """A button that stops the current scan."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class TextBox(RPCBase):
     """A widget that displays text in plain and HTML format"""
 
@@ -4661,6 +5033,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 +5356,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 +5597,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 +5648,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/client_utils.py

@@ -285,6 +285,18 @@ class BECGuiClient(RPCBase):
         """Hide the GUI window."""
         return self._hide_all()
 
+    def raise_window(self, wait: bool = True) -> None:
+        """
+        Bring GUI windows to the front.
+        If the GUI server is not running, it will be started.
+
+        Args:
+            wait(bool): Whether to wait for the server to start. Defaults to True.
+        """
+        if self._check_if_server_is_alive():
+            return self._raise_all()
+        return self._start(wait=wait)
+
     def new(
         self,
         name: str | None = None,
@@ -443,8 +455,8 @@ class BECGuiClient(RPCBase):
         self._update_dynamic_namespace(self._server_registry)
 
     def _do_show_all(self):
-        rpc_client = RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self)
-        rpc_client._run_rpc("show")  # pylint: disable=protected-access
+        if self.launcher and len(self._top_level) == 0:
+            self.launcher._run_rpc("show")  # pylint: disable=protected-access
         for window in self._top_level.values():
             window.show()
 
@@ -454,11 +466,24 @@ class BECGuiClient(RPCBase):
 
     def _hide_all(self):
         with wait_for_server(self):
-            rpc_client = RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self)
-            rpc_client._run_rpc("hide")  # pylint: disable=protected-access
-            if not self._killed:
-                for window in self._top_level.values():
-                    window.hide()
+            if self._killed:
+                return
+            self.launcher._run_rpc("hide")
+            for window in self._top_level.values():
+                window.hide()
+
+    def _do_raise_all(self):
+        """Bring GUI windows to the front."""
+        if self.launcher and len(self._top_level) == 0:
+            self.launcher._run_rpc("raise")  # pylint: disable=protected-access
+        for window in self._top_level.values():
+            window._run_rpc("raise")  # type: ignore[attr-defined]
+
+    def _raise_all(self):
+        with wait_for_server(self):
+            if self._killed:
+                return
+            return self._do_raise_all()
 
     def _update_dynamic_namespace(self, server_registry: dict):
         """

bec_widgets/cli/rpc/rpc_base.py

@@ -202,6 +202,11 @@ class RPCBase:
             parent = parent._parent
         return parent  # type: ignore
 
+    def raise_window(self):
+        """Bring this widget (or its container) to the front."""
+        # Use explicit call to ensure action name is 'raise' (not 'raise_')
+        return self._run_rpc("raise")
+
     def _run_rpc(
         self,
         method,
@@ -225,6 +230,12 @@ class RPCBase:
         Returns:
             The result of the RPC call.
         """
+        if method in ["show", "hide", "raise"] and gui_id is None:
+            obj = self._root._server_registry.get(self._gui_id)
+            if obj is None:
+                raise ValueError(f"Widget {self._gui_id} not found.")
+            gui_id = obj.get("container_proxy")  # type: ignore
+
         request_id = str(uuid.uuid4())
         rpc_msg = messages.GUIInstructionMessage(
             action=method,

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/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):
         """
@@ -213,7 +219,7 @@ class BECConnector:
           - If there's a nearest BECConnector parent, only compare with children of that parent.
           - If parent is None (i.e., top-level object), compare with all other top-level BECConnectors.
         """
-        QApplication.processEvents()
+        QApplication.sendPostedEvents()
         parent_bec = WidgetHierarchy._get_becwidget_ancestor(self)
 
         if parent_bec:
@@ -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__(
@@ -36,6 +36,8 @@ class BECWidget(BECConnector):
         config: ConnectionConfig = None,
         gui_id: str | None = None,
         theme_update: bool = False,
+        start_busy: bool = False,
+        busy_text: str = "Loading…",
         parent_dock: BECDock | None = None,  # TODO should go away -> issue created #473
         **kwargs,
     ):
@@ -45,8 +47,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,25 +63,32 @@ 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()
 
+        # Initialize optional busy loader overlay utility (lazy by default)
+        self._busy_overlay = None
+        self._loading = False
+        if start_busy and isinstance(self, QWidget):
+            try:
+                overlay = self._ensure_busy_overlay(busy_text=busy_text)
+                if overlay is not None:
+                    overlay.setGeometry(self.rect())
+                    overlay.raise_()
+                    overlay.show()
+                    self._loading = True
+            except Exception as exc:
+                logger.debug(f"Busy loader init skipped: {exc}")
+
     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:
@@ -89,8 +97,77 @@ class BECWidget(BECConnector):
                 theme = qapp.theme.theme
             else:
                 theme = "dark"
+        self._update_overlay_theme(theme)
         self.apply_theme(theme)
 
+    def _ensure_busy_overlay(self, *, busy_text: str = "Loading…"):
+        """Create the busy overlay on demand and cache it in _busy_overlay.
+        Returns the overlay instance or None if not a QWidget.
+        """
+        if not isinstance(self, QWidget):
+            return None
+        overlay = getattr(self, "_busy_overlay", None)
+        if overlay is None:
+            from bec_widgets.utils.busy_loader import install_busy_loader
+
+            overlay = install_busy_loader(self, text=busy_text, start_loading=False)
+            self._busy_overlay = overlay
+        return overlay
+
+    def _init_busy_loader(self, *, start_busy: bool = False, busy_text: str = "Loading…") -> None:
+        """Create and attach the loading overlay to this widget if QWidget is present."""
+        if not isinstance(self, QWidget):
+            return
+        self._ensure_busy_overlay(busy_text=busy_text)
+        if start_busy and self._busy_overlay is not None:
+            self._busy_overlay.setGeometry(self.rect())
+            self._busy_overlay.raise_()
+            self._busy_overlay.show()
+
+    def set_busy(self, enabled: bool, text: str | None = None) -> None:
+        """
+        Enable/disable the loading overlay. Optionally update the text.
+
+        Args:
+            enabled(bool): Whether to enable the loading overlay.
+            text(str, optional): The text to display on the overlay. If None, the text is not changed.
+        """
+        if not isinstance(self, QWidget):
+            return
+        if getattr(self, "_busy_overlay", None) is None:
+            self._ensure_busy_overlay(busy_text=text or "Loading…")
+        if text is not None:
+            self.set_busy_text(text)
+        if enabled:
+            self._busy_overlay.setGeometry(self.rect())
+            self._busy_overlay.raise_()
+            self._busy_overlay.show()
+        else:
+            self._busy_overlay.hide()
+        self._loading = bool(enabled)
+
+    def is_busy(self) -> bool:
+        """
+        Check if the loading overlay is enabled.
+
+        Returns:
+            bool: True if the loading overlay is enabled, False otherwise.
+        """
+        return bool(getattr(self, "_loading", False))
+
+    def set_busy_text(self, text: str) -> None:
+        """
+        Update the text on the loading overlay.
+
+        Args:
+            text(str): The text to display on the overlay.
+        """
+        overlay = getattr(self, "_busy_overlay", None)
+        if overlay is None:
+            overlay = self._ensure_busy_overlay(busy_text=text)
+        if overlay is not None:
+            overlay.set_text(text)
+
     @SafeSlot(str)
     def apply_theme(self, theme: str):
         """
@@ -100,6 +177,22 @@ class BECWidget(BECConnector):
             theme(str, optional): The theme to be applied.
         """
 
+    def _update_overlay_theme(self, theme: str):
+        try:
+            overlay = getattr(self, "_busy_overlay", None)
+            if overlay is not None and hasattr(overlay, "update_palette"):
+                overlay.update_palette()
+        except Exception:
+            logger.warning(f"Failed to apply theme {theme} to {self}")
+
+    def get_help_md(self) -> str:
+        """
+        Method to override in subclasses to provide help text in markdown format.
+
+        Returns:
+            str: The help text in markdown format.
+        """
+
     @SafeSlot()
     @SafeSlot(str)
     @rpc_timeout(None)
@@ -124,6 +217,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():
@@ -138,6 +251,22 @@ class BECWidget(BECConnector):
             child.close()
             child.deleteLater()
 
+        # Tear down busy overlay explicitly to stop spinner and remove filters
+        overlay = getattr(self, "_busy_overlay", None)
+        if overlay is not None and shiboken6.isValid(overlay):
+            try:
+                overlay.hide()
+                filt = getattr(overlay, "_filter", None)
+                if filt is not None and shiboken6.isValid(filt):
+                    try:
+                        self.removeEventFilter(filt)
+                    except Exception as exc:
+                        logger.warning(f"Failed to remove event filter from busy overlay: {exc}")
+                overlay.deleteLater()
+            except Exception as exc:
+                logger.warning(f"Failed to delete busy overlay: {exc}")
+        self._busy_overlay = None
+
     def closeEvent(self, event):
         """Wrap the close even to ensure the rpc_register is cleaned up."""
         try:

bec_widgets/utils/busy_loader.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+from qtpy.QtCore import QEvent, QObject, Qt, QTimer
+from qtpy.QtGui import QColor, QFont
+from qtpy.QtWidgets import (
+    QApplication,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QMainWindow,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets import BECWidget
+from bec_widgets.utils.colors import apply_theme
+from bec_widgets.widgets.plots.waveform.waveform import Waveform
+from bec_widgets.widgets.utility.spinner.spinner import SpinnerWidget
+
+
+class _OverlayEventFilter(QObject):
+    """Keeps the overlay sized and stacked over its target widget."""
+
+    def __init__(self, target: QWidget, overlay: QWidget):
+        super().__init__(target)
+        self._target = target
+        self._overlay = overlay
+
+    def eventFilter(self, obj, event):
+        if obj is self._target and event.type() in (
+            QEvent.Resize,
+            QEvent.Show,
+            QEvent.LayoutRequest,
+            QEvent.Move,
+        ):
+            self._overlay.setGeometry(self._target.rect())
+            self._overlay.raise_()
+        return False
+
+
+class BusyLoaderOverlay(QWidget):
+    """
+    A semi-transparent scrim with centered text and an animated spinner.
+    Call show()/hide() directly, or use via `install_busy_loader(...)`.
+
+    Args:
+        parent(QWidget): The parent widget to overlay.
+        text(str): Initial text to display.
+        opacity(float): Overlay opacity (0..1).
+
+    Returns:
+        BusyLoaderOverlay: The overlay instance.
+    """
+
+    def __init__(self, parent: QWidget, text: str = "Loading…", opacity: float = 0.85, **kwargs):
+        super().__init__(parent=parent, **kwargs)
+        self.setAttribute(Qt.WA_StyledBackground, True)
+        self.setAutoFillBackground(False)
+        self.setAttribute(Qt.WA_TranslucentBackground, True)
+        self._opacity = opacity
+
+        self._label = QLabel(text, self)
+        self._label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
+        f = QFont(self._label.font())
+        f.setBold(True)
+        f.setPointSize(f.pointSize() + 1)
+        self._label.setFont(f)
+
+        self._spinner = SpinnerWidget(self)
+        self._spinner.setFixedSize(42, 42)
+
+        lay = QVBoxLayout(self)
+        lay.setContentsMargins(24, 24, 24, 24)
+        lay.setSpacing(10)
+        lay.addStretch(1)
+        lay.addWidget(self._spinner, 0, Qt.AlignHCenter)
+        lay.addWidget(self._label, 0, Qt.AlignHCenter)
+        lay.addStretch(1)
+
+        self._frame = QFrame(self)
+        self._frame.setObjectName("busyFrame")
+        self._frame.setAttribute(Qt.WA_TransparentForMouseEvents, True)
+        self._frame.lower()
+
+        # Defaults
+        self._scrim_color = QColor(0, 0, 0, 110)
+        self._label_color = QColor(240, 240, 240)
+        self.update_palette()
+
+        # Start hidden; interactions beneath are blocked while visible
+        self.hide()
+
+    # --- API ---
+    def set_text(self, text: str):
+        """
+        Update the overlay text.
+
+        Args:
+            text(str): The text to display on the overlay.
+        """
+        self._label.setText(text)
+
+    def set_opacity(self, opacity: float):
+        """
+        Set overlay opacity (0..1).
+
+        Args:
+            opacity(float): The opacity value between 0.0 (fully transparent) and 1.0 (fully opaque).
+        """
+        self._opacity = max(0.0, min(1.0, float(opacity)))
+        # Re-apply alpha using the current theme color
+        if isinstance(self._scrim_color, QColor):
+            base = QColor(self._scrim_color)
+            base.setAlpha(int(255 * self._opacity))
+            self._scrim_color = base
+        self.update()
+
+    def update_palette(self):
+        """
+        Update colors from the current application theme.
+        """
+        app = QApplication.instance()
+        if hasattr(app, "theme"):
+            theme = app.theme  # type: ignore[attr-defined]
+            self._bg = theme.color("BORDER")
+            self._fg = theme.color("FG")
+            self._primary = theme.color("PRIMARY")
+        else:
+            # Fallback neutrals
+            self._bg = QColor(30, 30, 30)
+            self._fg = QColor(230, 230, 230)
+        # Semi-transparent scrim derived from bg
+        self._scrim_color = QColor(self._bg)
+        self._scrim_color.setAlpha(int(255 * max(0.0, min(1.0, getattr(self, "_opacity", 0.35)))))
+        self._spinner.update()
+        fg_hex = self._fg.name() if isinstance(self._fg, QColor) else str(self._fg)
+        self._label.setStyleSheet(f"color: {fg_hex};")
+        self._frame.setStyleSheet(
+            f"#busyFrame {{ border: 2px dashed {fg_hex}; border-radius: 9px; background-color: rgba(128, 128, 128, 110); }}"
+        )
+        self.update()
+
+    # --- QWidget overrides ---
+    def showEvent(self, e):
+        self._spinner.start()
+        super().showEvent(e)
+
+    def hideEvent(self, e):
+        self._spinner.stop()
+        super().hideEvent(e)
+
+    def resizeEvent(self, e):
+        super().resizeEvent(e)
+        r = self.rect().adjusted(10, 10, -10, -10)
+        self._frame.setGeometry(r)
+
+    def paintEvent(self, e):
+        super().paintEvent(e)
+
+
+def install_busy_loader(
+    target: QWidget, text: str = "Loading…", start_loading: bool = False, opacity: float = 0.35
+) -> BusyLoaderOverlay:
+    """
+    Attach a BusyLoaderOverlay to `target` and keep it sized and stacked.
+
+    Args:
+        target(QWidget): The widget to overlay.
+        text(str): Initial text to display.
+        start_loading(bool): If True, show the overlay immediately.
+        opacity(float): Overlay opacity (0..1).
+
+    Returns:
+        BusyLoaderOverlay: The overlay instance.
+    """
+    overlay = BusyLoaderOverlay(target, text=text, opacity=opacity)
+    overlay.setGeometry(target.rect())
+    filt = _OverlayEventFilter(target, overlay)
+    overlay._filter = filt  # type: ignore[attr-defined]
+    target.installEventFilter(filt)
+    if start_loading:
+        overlay.show()
+    return overlay
+
+
+# --------------------------
+# Launchable demo
+# --------------------------
+class DemoWidget(BECWidget, QWidget):  # pragma: no cover
+    def __init__(self, parent=None):
+        super().__init__(
+            parent=parent, theme_update=True, start_busy=True, busy_text="Demo: Initializing…"
+        )
+
+        self._title = QLabel("Demo Content", self)
+        self._title.setAlignment(Qt.AlignCenter)
+        self._title.setFrameStyle(QFrame.Panel | QFrame.Sunken)
+        lay = QVBoxLayout(self)
+        lay.addWidget(self._title)
+        waveform = Waveform(self)
+        waveform.plot([1, 2, 3, 4, 5])
+        lay.addWidget(waveform, 1)
+
+        QTimer.singleShot(5000, self._ready)
+
+    def _ready(self):
+        self._title.setText("Ready ✓")
+        self.set_busy(False)
+
+
+class DemoWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Busy Loader — BECWidget demo")
+
+        left = DemoWidget()
+        right = DemoWidget()
+
+        btn_on = QPushButton("Right → Loading")
+        btn_off = QPushButton("Right → Ready")
+        btn_text = QPushButton("Set custom text")
+        btn_on.clicked.connect(lambda: right.set_busy(True, "Fetching data…"))
+        btn_off.clicked.connect(lambda: right.set_busy(False))
+        btn_text.clicked.connect(lambda: right.set_busy_text("Almost there…"))
+
+        panel = QWidget()
+        prow = QVBoxLayout(panel)
+        prow.addWidget(btn_on)
+        prow.addWidget(btn_off)
+        prow.addWidget(btn_text)
+        prow.addStretch(1)
+
+        central = QWidget()
+        row = QHBoxLayout(central)
+        row.setContentsMargins(12, 12, 12, 12)
+        row.setSpacing(12)
+        row.addWidget(left, 1)
+        row.addWidget(right, 1)
+        row.addWidget(panel, 0)
+
+        self.setCentralWidget(central)
+        self.resize(900, 420)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    app = QApplication(sys.argv)
+    apply_theme("light")
+    w = DemoWindow()
+    w.show()
+    sys.exit(app.exec())

bec_widgets/utils/colors.py

@@ -1,19 +1,17 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING, Literal
+from typing import 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 bec_qthemes._theme import AccentColors
 from pydantic_core import PydanticCustomError
+from qtpy.QtCore import QEvent, QEventLoop
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QApplication
 
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_qthemes._main import AccentColors
-
 
 def get_theme_name():
     if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
@@ -23,118 +21,35 @@ 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:
+def get_accent_colors() -> AccentColors:
     """
     Get the accent colors for the current theme. These colors are extensions of the color palette
     and are used to highlight specific elements in the UI.
     """
     if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
-        return None
+        accent_colors = AccentColors()
+        return accent_colors
     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,8 +209,11 @@ 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]]
-        else:
-            # Handle all curves
+        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
             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/expandable_frame.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from bec_qthemes import material_icon
-from qtpy.QtCore import Signal
+from qtpy.QtCore import QSize, Signal
 from qtpy.QtWidgets import (
     QApplication,
     QFrame,
@@ -19,7 +19,8 @@ from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 
 
 class ExpandableGroupFrame(QFrame):
-
+    broadcast_size_hint = Signal(QSize)
+    imminent_deletion = Signal()
     expansion_state_changed = Signal()
 
     EXPANDED_ICON_NAME: str = "collapse_all"
@@ -31,10 +32,11 @@ class ExpandableGroupFrame(QFrame):
         super().__init__(parent=parent)
         self._expanded = expanded
 
-        self.setFrameStyle(QFrame.Shape.StyledPanel | QFrame.Shadow.Plain)
+        self._title_text = f"<b>{title}</b>"
+        self.setFrameStyle(QFrame.Shape.StyledPanel | QFrame.Shadow.Raised)
         self.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
         self._layout = QVBoxLayout()
-        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._layout.setContentsMargins(5, 0, 0, 0)
         self.setLayout(self._layout)
 
         self._create_title_layout(title, icon)
@@ -49,21 +51,27 @@ class ExpandableGroupFrame(QFrame):
     def _create_title_layout(self, title: str, icon: str):
         self._title_layout = QHBoxLayout()
         self._layout.addLayout(self._title_layout)
+        self._internal_title_layout = QHBoxLayout()
+        self._title_layout.addLayout(self._internal_title_layout)
 
-        self._title = ClickableLabel(f"<b>{title}</b>")
+        self._title = ClickableLabel()
+        self._set_title_text(self._title_text)
         self._title_icon = ClickableLabel()
-        self._title_layout.addWidget(self._title_icon)
-        self._title_layout.addWidget(self._title)
+        self._internal_title_layout.addWidget(self._title_icon)
+        self._internal_title_layout.addWidget(self._title)
         self.icon_name = icon
         self._title.clicked.connect(self.switch_expanded_state)
         self._title_icon.clicked.connect(self.switch_expanded_state)
 
-        self._title_layout.addStretch(1)
+        self._internal_title_layout.addStretch(1)
 
         self._expansion_button = QToolButton()
         self._update_expansion_icon()
         self._title_layout.addWidget(self._expansion_button, stretch=1)
 
+    def get_title_layout(self) -> QHBoxLayout:
+        return self._internal_title_layout
+
     def set_layout(self, layout: QLayout) -> None:
         self._contents.setLayout(layout)
         self._contents.layout().setContentsMargins(0, 0, 0, 0)  # type: ignore
@@ -112,6 +120,18 @@ class ExpandableGroupFrame(QFrame):
         else:
             self._title_icon.setVisible(False)
 
+    @SafeProperty(str)
+    def title_text(self):  # type: ignore
+        return self._title_text
+
+    @title_text.setter
+    def title_text(self, title_text: str):
+        self._title_text = title_text
+        self._set_title_text(self._title_text)
+
+    def _set_title_text(self, title_text: str):
+        self._title.setText(title_text)
+
 
 # Application example
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/utils/forms_from_types/forms.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from types import NoneType
+from types import GenericAlias, NoneType, UnionType
 from typing import NamedTuple
 
 from bec_lib.logger import bec_logger
@@ -11,7 +11,7 @@ from qtpy.QtWidgets import QApplication, QGridLayout, QLabel, QSizePolicy, QVBox
 
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.compact_popup import CompactPopupWidget
-from bec_widgets.utils.error_popups import SafeProperty
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.forms_from_types import styles
 from bec_widgets.utils.forms_from_types.items import (
     DynamicFormItem,
@@ -216,6 +216,9 @@ class PydanticModelForm(TypedForm):
 
         self._connect_to_theme_change()
 
+    @SafeSlot()
+    def clear(self): ...
+
     def set_pretty_display_theme(self, theme: str = "dark"):
         if self._pretty_display:
             self.setStyleSheet(styles.pretty_display_theme(theme))
@@ -280,3 +283,24 @@ class PydanticModelForm(TypedForm):
             self.form_data_cleared.emit(None)
             self.validity_proc.emit(False)
             return False
+
+
+class PydanticModelFormItem(DynamicFormItem):
+    def __init__(
+        self, parent: QWidget | None = None, *, spec: FormItemSpec, model: type[BaseModel]
+    ) -> None:
+        self._data_model = model
+
+        super().__init__(parent=parent, spec=spec)
+        self._main_widget.form_data_updated.connect(self._value_changed)
+
+    def _add_main_widget(self) -> None:
+
+        self._main_widget = PydanticModelForm(data_model=self._data_model)
+        self._layout.addWidget(self._main_widget)
+
+    def getValue(self):
+        return self._main_widget.get_form_data()
+
+    def setValue(self, value: dict):
+        self._main_widget.set_data(self._data_model.model_validate(value))

bec_widgets/utils/forms_from_types/items.py

@@ -1,10 +1,23 @@
 from __future__ import annotations
 
+import inspect
 import typing
 from abc import abstractmethod
 from decimal import Decimal
 from types import GenericAlias, UnionType
-from typing import Callable, Final, Iterable, Literal, NamedTuple, OrderedDict, get_args
+from typing import (
+    Callable,
+    Final,
+    Generic,
+    Iterable,
+    Literal,
+    NamedTuple,
+    OrderedDict,
+    Protocol,
+    TypeVar,
+    get_args,
+    runtime_checkable,
+)
 
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
@@ -158,9 +171,10 @@ class DynamicFormItem(QWidget):
         self._desc = self._spec.info.description
         self.setLayout(self._layout)
         self._add_main_widget()
+        # Sadly, QWidget and ABC are not compatible
         assert isinstance(self._main_widget, QWidget), "Please set a widget in _add_main_widget()"  # type: ignore
-        self._main_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
-        self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
+        self._main_widget.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
+        self.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
         if not spec.pretty_display:
             if clearable_required(spec.info):
                 self._add_clear_button()
@@ -175,6 +189,7 @@ class DynamicFormItem(QWidget):
 
     @abstractmethod
     def _add_main_widget(self) -> None:
+        self._main_widget: QWidget
         """Add the main data entry widget to self._main_widget and appply any
         constraints from the field info"""
 
@@ -350,11 +365,13 @@ class DictFormItem(DynamicFormItem):
         self._main_widget.replace_data(value)
 
 
-class _ItemAndWidgetType(NamedTuple):
-    # TODO: this should be generic but not supported in 3.10
-    item: type[int | float | str]
+_IW = TypeVar("_IW", bound=int | float | str)
+
+
+class _ItemAndWidgetType(NamedTuple, Generic[_IW]):
+    item: type[_IW]
     widget: type[QWidget]
-    default: int | float | str
+    default: _IW
 
 
 class ListFormItem(DynamicFormItem):
@@ -380,7 +397,7 @@ class ListFormItem(DynamicFormItem):
 
     def sizeHint(self):
         default = super().sizeHint()
-        return QSize(default.width(), QFontMetrics(self.font()).height() * 6)
+        return QSize(default.width(), QFontMetrics(self.font()).height() * 4)
 
     def _add_main_widget(self) -> None:
         self._main_widget = QListWidget()
@@ -430,10 +447,17 @@ class ListFormItem(DynamicFormItem):
         self._add_list_item(val)
         self._repop(self._data)
 
+    def _item_height(self):
+        return int(QFontMetrics(self.font()).height() * 1.5)
+
     def _add_list_item(self, val):
         item = QListWidgetItem(self._main_widget)
         item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsEditable)
         item_widget = self._types.widget(parent=self)
+        item_widget.setMinimumHeight(self._item_height())
+        self._main_widget.setGridSize(QSize(0, self._item_height()))
+        if (layout := item_widget.layout()) is not None:
+            layout.setContentsMargins(0, 0, 0, 0)
         WidgetIO.set_value(item_widget, val)
         self._main_widget.setItemWidget(item, item_widget)
         self._main_widget.addItem(item)
@@ -470,14 +494,11 @@ class ListFormItem(DynamicFormItem):
         self._data = list(value)
         self._repop(self._data)
 
-    def _line_height(self):
-        return QFontMetrics(self._main_widget.font()).height()
-
     def set_max_height_in_lines(self, lines: int):
         outer_inc = 1 if self._spec.pretty_display else 3
-        self._main_widget.setFixedHeight(self._line_height() * max(lines, self._min_lines))
-        self._button_holder.setFixedHeight(self._line_height() * (max(lines, self._min_lines) + 1))
-        self.setFixedHeight(self._line_height() * (max(lines, self._min_lines) + outer_inc))
+        self._main_widget.setFixedHeight(self._item_height() * max(lines, self._min_lines))
+        self._button_holder.setFixedHeight(self._item_height() * (max(lines, self._min_lines) + 1))
+        self.setFixedHeight(self._item_height() * (max(lines, self._min_lines) + outer_inc))
 
     def scale_to_data(self, *_):
         self.set_max_height_in_lines(self._main_widget.count() + 1)
@@ -545,7 +566,14 @@ class StrLiteralFormItem(DynamicFormItem):
         self._main_widget.setCurrentIndex(-1)
 
 
-WidgetTypeRegistry = OrderedDict[str, tuple[Callable[[FormItemSpec], bool], type[DynamicFormItem]]]
+@runtime_checkable
+class _ItemTypeFn(Protocol):
+    def __call__(self, spec: FormItemSpec) -> type[DynamicFormItem]: ...
+
+
+WidgetTypeRegistry = OrderedDict[
+    str, tuple[Callable[[FormItemSpec], bool], type[DynamicFormItem] | _ItemTypeFn]
+]
 
 DEFAULT_WIDGET_TYPES: Final[WidgetTypeRegistry] = OrderedDict() | {
     # dict literals are ordered already but TypedForm subclasses may modify coppies of this dict
@@ -586,7 +614,10 @@ def widget_from_type(
     widget_types = widget_types or DEFAULT_WIDGET_TYPES
     for predicate, widget_type in widget_types.values():
         if predicate(spec):
-            return widget_type
+            if inspect.isclass(widget_type) and issubclass(widget_type, DynamicFormItem):
+                return widget_type
+            return widget_type(spec)
+
     logger.warning(
         f"Type {spec.item_type=} / {spec.info.annotation=} is not (yet) supported in dynamic form creation."
     )

bec_widgets/utils/help_inspector/help_inspector.py

@@ -0,0 +1,238 @@
+"""Module providing a simple help inspector tool for QtWidgets."""
+
+from functools import partial
+from typing import Callable
+from uuid import uuid4
+
+from bec_lib.logger import bec_logger
+from bec_qthemes import material_icon
+from qtpy import QtCore, QtWidgets
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.colors import AccentColors, get_accent_colors
+from bec_widgets.utils.error_popups import SafeSlot
+
+logger = bec_logger.logger
+
+
+class HelpInspector(BECWidget, QtWidgets.QWidget):
+    """
+    A help inspector widget that allows to inspect other widgets in the application.
+    Per default, it emits signals with the docstring, tooltip and bec help text of the inspected widget.
+    The method "get_help_md" is called on the widget which is added to the BECWidget base class.
+    It should return a string with a help text, ideally in proper format to be displayed (i.e. markdown).
+    The inspector also allows to register custom callback that are called with the inspected widget
+    as argument. This may be useful in the future to hook up more callbacks with custom signals.
+
+    Args:
+        parent (QWidget | None): The parent widget of the help inspector.
+        client: Optional client for BECWidget functionality.
+        size (tuple[int, int]): Optional size of the icon for the help inspector.
+    """
+
+    widget_docstring = QtCore.Signal(str)  # Emits docstring from QWidget
+    widget_tooltip = QtCore.Signal(str)  # Emits tooltip string from QWidget
+    bec_widget_help = QtCore.Signal(str)  # Emits md formatted help string from BECWidget class
+
+    def __init__(self, parent=None, client=None):
+        super().__init__(client=client, parent=parent, theme_update=True)
+        self._app = QtWidgets.QApplication.instance()
+        layout = QtWidgets.QHBoxLayout(self)  # type: ignore
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        self._active = False
+        self._init_ui()
+        self._callbacks = {}
+        # Register the default callbacks
+        self._register_default_callbacks()
+        # Connect the button toggle signal
+        self._button.toggled.connect(self._toggle_mode)
+
+    def _init_ui(self):
+        """Init the UI components."""
+        colors: AccentColors = get_accent_colors()
+        self._button = QtWidgets.QToolButton(self.parent())
+        self._button.setCheckable(True)
+
+        self._icon_checked = partial(
+            material_icon, "help", size=(32, 32), color=colors.highlight, filled=True
+        )
+        self._icon_unchecked = partial(
+            material_icon, "help", size=(32, 32), color=colors.highlight, filled=False
+        )
+        self._button.setText("Help Inspect Tool")
+        self._button.setIcon(self._icon_unchecked())
+        self._button.setToolTip("Click to enter Help Mode")
+        self.layout().addWidget(self._button)
+
+    def apply_theme(self, theme: str) -> None:
+        colors = get_accent_colors()
+        self._icon_checked = partial(
+            material_icon, "help", size=(32, 32), color=colors.highlight, filled=True
+        )
+        self._icon_unchecked = partial(
+            material_icon, "help", size=(32, 32), color=colors.highlight, filled=False
+        )
+        if self._active:
+            self._button.setIcon(self._icon_checked())
+        else:
+            self._button.setIcon(self._icon_unchecked())
+
+    @SafeSlot(bool)
+    def _toggle_mode(self, enabled: bool):
+        """
+        Toggle the help inspection mode.
+
+        Args:
+            enabled (bool): Whether to enable or disable the help inspection mode.
+        """
+        if self._app is None:
+            self._app = QtWidgets.QApplication.instance()
+        self._active = enabled
+        if enabled:
+            self._app.installEventFilter(self)
+            self._button.setIcon(self._icon_checked())
+            QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.CursorShape.WhatsThisCursor)
+        else:
+            self._app.removeEventFilter(self)
+            self._button.setIcon(self._icon_unchecked())
+            self._button.setChecked(False)
+            QtWidgets.QApplication.restoreOverrideCursor()
+
+    def eventFilter(self, obj, event):
+        """
+        Filter events to capture Key_Escape event, and mouse clicks
+        if event filter is active. Any click event on a widget is suppressed, if
+        the Inspector is active, and the registered callbacks are called with
+        the clicked widget as argument.
+
+        Args:
+            obj (QObject): The object that received the event.
+            event (QEvent): The event to filter.
+        """
+        if (
+            event.type() == QtCore.QEvent.KeyPress
+            and event.key() == QtCore.Qt.Key_Escape
+            and self._active
+        ):
+            self._toggle_mode(False)
+            return super().eventFilter(obj, event)
+        if self._active and event.type() == QtCore.QEvent.MouseButtonPress:
+            if event.button() == QtCore.Qt.LeftButton:
+                widget = self._app.widgetAt(event.globalPos())
+                if widget:
+                    if widget is self or self.isAncestorOf(widget):
+                        self._toggle_mode(False)
+                        return True
+                    for cb in self._callbacks.values():
+                        try:
+                            cb(widget)
+                        except Exception as e:
+                            print(f"Error occurred in callback {cb}: {e}")
+                    return True
+        return super().eventFilter(obj, event)
+
+    def register_callback(self, callback: Callable[[QtWidgets.QWidget], None]) -> str:
+        """
+        Register a callback to be called when a widget is inspected.
+        The callback should be callable with the following signature:
+            callback(widget: QWidget) -> None
+
+        Args:
+            callback (Callable[[QWidget], None]): The callback function to register.
+        Returns:
+            str: A unique ID for the registered callback.
+        """
+        cb_id = str(uuid4())
+        self._callbacks[cb_id] = callback
+        return cb_id
+
+    def unregister_callback(self, cb_id: str):
+        """Unregister a previously registered callback."""
+        self._callbacks.pop(cb_id, None)
+
+    def _register_default_callbacks(self):
+        """Default behavior: publish tooltip, docstring, bec_help"""
+
+        def cb_doc(widget: QtWidgets.QWidget):
+            docstring = widget.__doc__ or "No documentation available."
+            self.widget_docstring.emit(docstring)
+
+        def cb_help(widget: QtWidgets.QWidget):
+            tooltip = widget.toolTip() or "No tooltip available."
+            self.widget_tooltip.emit(tooltip)
+
+        def cb_bec_help(widget: QtWidgets.QWidget):
+            help_text = None
+            if hasattr(widget, "get_help_md") and callable(widget.get_help_md):
+                try:
+                    help_text = widget.get_help_md()
+                except Exception as e:
+                    logger.debug(f"Error retrieving help text from {widget}: {e}")
+            if help_text is None:
+                help_text = widget.toolTip() or "No help available."
+            if not isinstance(help_text, str):
+                logger.error(
+                    f"Help text from {widget.__class__} is not a string: {type(help_text)}"
+                )
+                help_text = str(help_text)
+            self.bec_widget_help.emit(help_text)
+
+        self.register_callback(cb_doc)
+        self.register_callback(cb_help)
+        self.register_callback(cb_bec_help)
+
+
+if __name__ == "__main__":
+    import sys
+
+    from bec_qthemes import apply_theme
+
+    from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
+    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
+    app = QtWidgets.QApplication(sys.argv)
+
+    main_window = QtWidgets.QMainWindow()
+    apply_theme("dark")
+    main_window.setWindowTitle("Help Inspector Test")
+
+    central_widget = QtWidgets.QWidget()
+    main_layout = QtWidgets.QVBoxLayout(central_widget)
+    dark_mode_button = DarkModeButton(parent=main_window)
+    main_layout.addWidget(dark_mode_button)
+
+    help_inspector = HelpInspector()
+    main_layout.addWidget(help_inspector)
+
+    test_button = QtWidgets.QPushButton("Test Button")
+    test_button.setToolTip("This is a test button.")
+    test_line_edit = QtWidgets.QLineEdit()
+    test_line_edit.setToolTip("This is a test line edit.")
+    test_label = QtWidgets.QLabel("Test Label")
+    test_label.setToolTip("")
+    box = PositionerBox()
+
+    layout_1 = QtWidgets.QHBoxLayout()
+    layout_1.addWidget(test_button)
+    layout_1.addWidget(test_line_edit)
+    layout_1.addWidget(test_label)
+    layout_1.addWidget(box)
+    main_layout.addLayout(layout_1)
+
+    doc_label = QtWidgets.QLabel("Docstring will appear here.")
+    tool_tip_label = QtWidgets.QLabel("Tooltip will appear here.")
+    bec_help_label = QtWidgets.QLabel("BEC Help text will appear here.")
+    main_layout.addWidget(doc_label)
+    main_layout.addWidget(tool_tip_label)
+    main_layout.addWidget(bec_help_label)
+
+    help_inspector.widget_tooltip.connect(tool_tip_label.setText)
+    help_inspector.widget_docstring.connect(doc_label.setText)
+    help_inspector.bec_widget_help.connect(bec_help_label.setText)
+
+    main_window.setCentralWidget(central_widget)
+    main_window.resize(400, 200)
+    main_window.show()
+    sys.exit(app.exec())

bec_widgets/utils/list_of_expandable_frames.py

@@ -0,0 +1,133 @@
+import re
+from functools import partial
+from re import Pattern
+from typing import Generic, Iterable, NamedTuple, TypeVar
+
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QSize, Qt
+from qtpy.QtWidgets import QListWidget, QListWidgetItem, QWidget
+
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.expandable_frame import ExpandableGroupFrame
+from bec_widgets.widgets.control.device_manager.components._util import (
+    SORT_KEY_ROLE,
+    SortableQListWidgetItem,
+)
+
+logger = bec_logger.logger
+
+
+_EF = TypeVar("_EF", bound=ExpandableGroupFrame)
+
+
+class ListOfExpandableFrames(QListWidget, Generic[_EF]):
+    def __init__(
+        self, /, parent: QWidget | None = None, item_class: type[_EF] = ExpandableGroupFrame
+    ) -> None:
+        super().__init__(parent)
+        _Items = NamedTuple("_Items", (("item", QListWidgetItem), ("widget", _EF)))
+        self.item_tuple = _Items
+        self._item_class = item_class
+        self._item_dict: dict[str, _Items] = {}
+
+    def __contains__(self, id: str):
+        return id in self._item_dict
+
+    def clear(self) -> None:
+        self._item_dict = {}
+        return super().clear()
+
+    def add_item(self, id: str, *args, **kwargs) -> tuple[QListWidgetItem, _EF]:
+        """Adds the specified type of widget as an item. args and kwargs are passed to the constructor.
+
+        Args:
+            id (str): the key under which to store the list item in the internal dict
+
+        Returns:
+            The widget created in the addition process
+        """
+
+        def _remove_item(item: QListWidgetItem):
+            self.takeItem(self.row(item))
+            del self._item_dict[id]
+            self.sortItems()
+
+        def _updatesize(item: QListWidgetItem, item_widget: _EF):
+            item_widget.adjustSize()
+            item.setSizeHint(QSize(item_widget.width(), item_widget.height()))
+
+        item = SortableQListWidgetItem(self)
+        item.setData(SORT_KEY_ROLE, id)  # used for sorting
+
+        item_widget = self._item_class(*args, **kwargs)
+        item_widget.expansion_state_changed.connect(partial(_updatesize, item, item_widget))
+        item_widget.imminent_deletion.connect(partial(_remove_item, item))
+        item_widget.broadcast_size_hint.connect(item.setSizeHint)
+
+        self.addItem(item)
+        self.setItemWidget(item, item_widget)
+        self._item_dict[id] = self.item_tuple(item, item_widget)
+
+        item.setSizeHint(item_widget.sizeHint())
+        return (item, item_widget)
+
+    def sort_by_key(self, role=SORT_KEY_ROLE, order=Qt.SortOrder.AscendingOrder):
+        items = [self.takeItem(0) for i in range(self.count())]
+        items.sort(key=lambda it: it.data(role), reverse=(order == Qt.SortOrder.DescendingOrder))
+
+        for it in items:
+            self.addItem(it)
+            # reattach its custom widget
+            widget = self.itemWidget(it)
+            if widget:
+                self.setItemWidget(it, widget)
+
+    def item_widget_pairs(self):
+        return self._item_dict.values()
+
+    def widgets(self):
+        return (i.widget for i in self._item_dict.values())
+
+    def get_item_widget(self, id: str):
+        if (item := self._item_dict.get(id)) is None:
+            return None
+        return item
+
+    def set_hidden_pattern(self, pattern: Pattern):
+        self.hide_all()
+        self._set_hidden(filter(pattern.search, self._item_dict.keys()), False)
+
+    def set_hidden(self, ids: Iterable[str]):
+        self._set_hidden(ids, True)
+
+    def _set_hidden(self, ids: Iterable[str], hidden: bool):
+        for id in ids:
+            if (_item := self._item_dict.get(id)) is not None:
+                _item.item.setHidden(hidden)
+                _item.widget.setHidden(hidden)
+            else:
+                logger.warning(
+                    f"List {self.__qualname__} does not have an item with ID {id} to hide!"
+                )
+        self.sortItems()
+
+    def hide_all(self):
+        self.set_hidden_state_on_all(True)
+
+    def unhide_all(self):
+        self.set_hidden_state_on_all(False)
+
+    def set_hidden_state_on_all(self, hidden: bool):
+        for _item in self._item_dict.values():
+            _item.item.setHidden(hidden)
+            _item.widget.setHidden(hidden)
+        self.sortItems()
+
+    @SafeSlot(str)
+    def update_filter(self, value: str):
+        if value == "":
+            return self.unhide_all()
+        try:
+            self.set_hidden_pattern(re.compile(value, re.IGNORECASE))
+        except Exception:
+            self.unhide_all()

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

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import functools
+import time
 import traceback
 import types
 from contextlib import contextmanager
@@ -229,6 +230,8 @@ class RPCServer:
         if wait:
             while not self.rpc_register.object_is_registered(connector):
                 QApplication.processEvents()
+                logger.info(f"Waiting for {connector} to be registered...")
+                time.sleep(0.1)
 
         widget_class = getattr(connector, "rpc_widget_class", None)
         if not widget_class:

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

@@ -33,6 +33,26 @@ logger = bec_logger.logger
 MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
 
+def create_action_with_text(toolbar_action, toolbar: QToolBar):
+    """
+    Helper function to create a toolbar button with text beside or under the icon.
+
+    Args:
+        toolbar_action(ToolBarAction): The toolbar action to create the button for.
+        toolbar(ModularToolBar): The toolbar to add the button to.
+    """
+
+    btn = QToolButton(parent=toolbar)
+    btn.setDefaultAction(toolbar_action.action)
+    btn.setAutoRaise(True)
+    if toolbar_action.text_position == "under":
+        btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
+    else:
+        btn.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
+    btn.setText(toolbar_action.label_text)
+    toolbar.addWidget(btn)
+
+
 class NoCheckDelegate(QStyledItemDelegate):
     """To reduce space in combo boxes by removing the checkmark."""
 
@@ -114,15 +134,39 @@ class SeparatorAction(ToolBarAction):
 
 
 class QtIconAction(ToolBarAction):
-    def __init__(self, standard_icon, tooltip=None, checkable=False, parent=None):
+    def __init__(
+        self,
+        standard_icon,
+        tooltip=None,
+        checkable=False,
+        label_text: str | None = None,
+        text_position: Literal["beside", "under"] | None = None,
+        parent=None,
+    ):
+        """
+        Action with a standard Qt icon for the toolbar.
+
+        Args:
+            standard_icon: The standard icon from QStyle.
+            tooltip(str, optional): The tooltip for the action. Defaults to None.
+            checkable(bool, optional): Whether the action is checkable. Defaults to False.
+            label_text(str | None, optional): Optional label text to display beside or under the icon.
+            text_position(Literal["beside", "under"] | None, optional): Position of text relative to icon.
+            parent(QWidget or None, optional): Parent widget for the underlying QAction.
+        """
         super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
         self.standard_icon = standard_icon
         self.icon = QApplication.style().standardIcon(standard_icon)
         self.action = QAction(icon=self.icon, text=self.tooltip, parent=parent)
         self.action.setCheckable(self.checkable)
+        self.label_text = label_text
+        self.text_position = text_position
 
     def add_to_toolbar(self, toolbar, target):
-        toolbar.addAction(self.action)
+        if self.label_text is not None:
+            create_action_with_text(toolbar_action=self, toolbar=toolbar)
+        else:
+            toolbar.addAction(self.action)
 
     def get_icon(self):
         return self.icon
@@ -139,6 +183,8 @@ class MaterialIconAction(ToolBarAction):
         filled (bool, optional): Whether the icon is filled. Defaults to False.
         color (str | tuple | QColor | dict[Literal["dark", "light"], str] | None, optional): The color of the icon.
             Defaults to None.
+        label_text (str | None, optional): Optional label text to display beside or under the icon.
+        text_position (Literal["beside", "under"] | None, optional): Position of text relative to icon.
         parent (QWidget or None, optional): Parent widget for the underlying QAction.
     """
 
@@ -149,12 +195,20 @@ class MaterialIconAction(ToolBarAction):
         checkable: bool = False,
         filled: bool = False,
         color: str | tuple | QColor | dict[Literal["dark", "light"], str] | None = None,
+        label_text: str | None = None,
+        text_position: Literal["beside", "under"] | None = None,
         parent=None,
     ):
+        """
+        MaterialIconAction for toolbar: if label_text and text_position are provided, show text beside or under icon.
+        This enables per-action icon text without breaking the existing API.
+        """
         super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
         self.icon_name = icon_name
         self.filled = filled
         self.color = color
+        self.label_text = label_text
+        self.text_position = text_position
         # Generate the icon using the material_icon helper
         self.icon = material_icon(
             self.icon_name,
@@ -178,7 +232,10 @@ class MaterialIconAction(ToolBarAction):
             toolbar(QToolBar): The toolbar to add the action to.
             target(QWidget): The target widget for the action.
         """
-        toolbar.addAction(self.action)
+        if self.label_text is not None:
+            create_action_with_text(toolbar_action=self, toolbar=toolbar)
+        else:
+            toolbar.addAction(self.action)
 
     def get_icon(self):
         """
@@ -446,6 +503,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,913 @@
+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.colors import apply_theme
+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)
+    apply_theme("dark")
+    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

@@ -11,7 +11,7 @@ class AbortButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "cancel"
-    RPC = True
+    RPC = False
 
     def __init__(
         self,
@@ -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/button_reset/button_reset.py

@@ -11,7 +11,7 @@ class ResetButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "restart_alt"
-    RPC = True
+    RPC = False
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)

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

@@ -11,7 +11,7 @@ class StopButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "dangerous"
-    RPC = True
+    RPC = False
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
@@ -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/_util.py

@@ -0,0 +1,53 @@
+import json
+from typing import Any, Callable, Generator, Iterable, TypeVar
+
+from bec_lib.utils.json import ExtendedEncoder
+from qtpy.QtCore import QByteArray, QMimeData, QObject, Signal  # type: ignore
+from qtpy.QtWidgets import QListWidgetItem
+
+from bec_widgets.widgets.control.device_manager.components.constants import (
+    MIME_DEVICE_CONFIG,
+    SORT_KEY_ROLE,
+)
+
+_T = TypeVar("_T")
+_RT = TypeVar("_RT")
+
+
+def yield_only_passing(fn: Callable[[_T], _RT], vals: Iterable[_T]) -> Generator[_RT, Any, None]:
+    for v in vals:
+        try:
+            yield fn(v)
+        except BaseException:
+            pass
+
+
+def mimedata_from_configs(configs: Iterable[dict]) -> QMimeData:
+    """Takes an iterable of device configs, gives a QMimeData with the configs json-encoded under the type MIME_DEVICE_CONFIG"""
+    mime_obj = QMimeData()
+    byte_array = QByteArray(json.dumps(list(configs), cls=ExtendedEncoder).encode("utf-8"))
+    mime_obj.setData(MIME_DEVICE_CONFIG, byte_array)
+    return mime_obj
+
+
+class SortableQListWidgetItem(QListWidgetItem):
+    """Store a sorting string key with .setData(SORT_KEY_ROLE, key) to be able to sort a list with
+    custom widgets and this item."""
+
+    def __gt__(self, other):
+        if (self_key := self.data(SORT_KEY_ROLE)) is None or (
+            other_key := other.data(SORT_KEY_ROLE)
+        ) is None:
+            return False
+        return self_key.lower() > other_key.lower()
+
+    def __lt__(self, other):
+        if (self_key := self.data(SORT_KEY_ROLE)) is None or (
+            other_key := other.data(SORT_KEY_ROLE)
+        ) is None:
+            return False
+        return self_key.lower() < other_key.lower()
+
+
+class SharedSelectionSignal(QObject):
+    proc = Signal(str)

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

@@ -0,0 +1,3 @@
+from .available_device_resources import AvailableDeviceResources
+
+__all__ = ["AvailableDeviceResources"]

bec_widgets/widgets/control/device_manager/components/available_device_resources/available_device_group.py

@@ -0,0 +1,230 @@
+from textwrap import dedent
+from typing import NamedTuple
+from uuid import uuid4
+
+from bec_qthemes import material_icon
+from qtpy.QtCore import QItemSelection, QSize, Signal
+from qtpy.QtWidgets import QFrame, QHBoxLayout, QLabel, QListWidgetItem, QVBoxLayout, QWidget
+
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.expandable_frame import ExpandableGroupFrame
+from bec_widgets.widgets.control.device_manager.components._util import SharedSelectionSignal
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_group_ui import (
+    Ui_AvailableDeviceGroup,
+)
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.device_resource_backend import (
+    HashableDevice,
+)
+from bec_widgets.widgets.control.device_manager.components.constants import CONFIG_DATA_ROLE
+
+
+def _warning_string(spec: HashableDevice):
+    name_warning = (
+        "Device defined with multiple names! Please check:\n  " + "\n  ".join(spec.names)
+        if len(spec.names) > 1
+        else ""
+    )
+    source_warning = (
+        "Device found in multiple source files! Please check:\n  " + "\n  ".join(spec._source_files)
+        if len(spec._source_files) > 1
+        else ""
+    )
+    return f"{name_warning}{source_warning}"
+
+
+class _DeviceEntryWidget(QFrame):
+
+    def __init__(self, device_spec: HashableDevice, parent=None, **kwargs):
+        super().__init__(parent, **kwargs)
+        self._device_spec = device_spec
+        self.included: bool = False
+
+        self.setFrameStyle(0)
+
+        self._layout = QVBoxLayout()
+        self._layout.setContentsMargins(2, 2, 2, 2)
+        self.setLayout(self._layout)
+
+        self.setup_title_layout(device_spec)
+        self.check_and_display_warning()
+
+        self.setToolTip(self._rich_text())
+
+    def _rich_text(self):
+        return dedent(
+            f"""
+        <b><u><h2> {self._device_spec.name}: </h2></u></b>
+        <table>
+        <tr><td> description: </td><td><i> {self._device_spec.description}  </i></td></tr>
+        <tr><td> config:      </td><td><i> {self._device_spec.deviceConfig} </i></td></tr>
+        <tr><td> enabled:     </td><td><i> {self._device_spec.enabled}      </i></td></tr>
+        <tr><td> read only:   </td><td><i> {self._device_spec.readOnly}     </i></td></tr>
+        </table>
+        """
+        )
+
+    def setup_title_layout(self, device_spec: HashableDevice):
+        self._title_layout = QHBoxLayout()
+        self._title_layout.setContentsMargins(0, 0, 0, 0)
+        self._title_container = QWidget(parent=self)
+        self._title_container.setLayout(self._title_layout)
+
+        self._warning_label = QLabel()
+        self._title_layout.addWidget(self._warning_label)
+
+        self.title = QLabel(device_spec.name)
+        self.title.setToolTip(device_spec.name)
+        self.title.setStyleSheet(self.title_style("#FF0000"))
+        self._title_layout.addWidget(self.title)
+
+        self._title_layout.addStretch(1)
+        self._layout.addWidget(self._title_container)
+
+    def check_and_display_warning(self):
+        if len(self._device_spec.names) == 1 and len(self._device_spec._source_files) == 1:
+            self._warning_label.setText("")
+            self._warning_label.setToolTip("")
+        else:
+            self._warning_label.setPixmap(material_icon("warning", size=(12, 12), color="#FFAA00"))
+            self._warning_label.setToolTip(_warning_string(self._device_spec))
+
+    @property
+    def device_hash(self):
+        return hash(self._device_spec)
+
+    def title_style(self, color: str) -> str:
+        return f"QLabel {{ color: {color}; font-weight: bold; font-size: 10pt; }}"
+
+    def setTitle(self, text: str):
+        self.title.setText(text)
+
+    def set_included(self, included: bool):
+        self.included = included
+        self.title.setStyleSheet(self.title_style("#00FF00" if included else "#FF0000"))
+
+
+class _DeviceEntry(NamedTuple):
+    list_item: QListWidgetItem
+    widget: _DeviceEntryWidget
+
+
+class AvailableDeviceGroup(ExpandableGroupFrame, Ui_AvailableDeviceGroup):
+
+    selected_devices = Signal(list)
+
+    def __init__(
+        self,
+        parent=None,
+        name: str = "TagGroupTitle",
+        data: set[HashableDevice] = set(),
+        shared_selection_signal=SharedSelectionSignal(),
+        **kwargs,
+    ):
+        super().__init__(parent=parent, **kwargs)
+        self.setupUi(self)
+
+        self._shared_selection_signal = shared_selection_signal
+        self._shared_selection_uuid = str(uuid4())
+        self._shared_selection_signal.proc.connect(self._handle_shared_selection_signal)
+        self.device_list.selectionModel().selectionChanged.connect(self._on_selection_changed)
+
+        self.title_text = name  # type: ignore
+        self._mime_data = []
+        self._devices: dict[str, _DeviceEntry] = {}
+        for device in data:
+            self._add_item(device)
+        self.device_list.sortItems()
+        self.setMinimumSize(self.device_list.sizeHint())
+        self._update_num_included()
+
+    def _add_item(self, device: HashableDevice):
+        item = QListWidgetItem(self.device_list)
+        device_dump = device.model_dump(exclude_defaults=True)
+        item.setData(CONFIG_DATA_ROLE, device_dump)
+        self._mime_data.append(device_dump)
+        widget = _DeviceEntryWidget(device, self)
+        item.setSizeHint(QSize(widget.width(), widget.height()))
+        self.device_list.setItemWidget(item, widget)
+        self.device_list.addItem(item)
+        self._devices[device.name] = _DeviceEntry(item, widget)
+
+    def create_mime_data(self):
+        return self._mime_data
+
+    def reset_devices_state(self):
+        for dev in self._devices.values():
+            dev.widget.set_included(False)
+        self._update_num_included()
+
+    def set_item_state(self, /, device_hash: int, included: bool):
+        for dev in self._devices.values():
+            if dev.widget.device_hash == device_hash:
+                dev.widget.set_included(included)
+        self._update_num_included()
+
+    def _update_num_included(self):
+        n_included = sum(int(dev.widget.included) for dev in self._devices.values())
+        if n_included == 0:
+            color = "#FF0000"
+        elif n_included == len(self._devices):
+            color = "#00FF00"
+        else:
+            color = "#FFAA00"
+        self.n_included.setText(f"{n_included} / {len(self._devices)}")
+        self.n_included.setStyleSheet(f"QLabel {{ color: {color}; }}")
+
+    def sizeHint(self) -> QSize:
+        if not getattr(self, "device_list", None) or not self.expanded:
+            return super().sizeHint()
+        return QSize(
+            max(150, self.device_list.viewport().width()),
+            self.device_list.sizeHintForRow(0) * self.device_list.count() + 50,
+        )
+
+    @SafeSlot(QItemSelection, QItemSelection)
+    def _on_selection_changed(self, selected: QItemSelection, deselected: QItemSelection) -> None:
+        self._shared_selection_signal.proc.emit(self._shared_selection_uuid)
+        config = [dev.as_normal_device().model_dump() for dev in self.get_selection()]
+        self.selected_devices.emit(config)
+
+    @SafeSlot(str)
+    def _handle_shared_selection_signal(self, uuid: str):
+        if uuid != self._shared_selection_uuid:
+            self.device_list.clearSelection()
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        self.setMinimumHeight(self.sizeHint().height())
+        self.setMaximumHeight(self.sizeHint().height())
+
+    def get_selection(self) -> set[HashableDevice]:
+        selection = self.device_list.selectedItems()
+        widgets = (w.widget for _, w in self._devices.items() if w.list_item in selection)
+        return set(w._device_spec for w in widgets)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}: {self.title_text}"
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = AvailableDeviceGroup(name="Tag group 1")
+    for item in [
+        HashableDevice(
+            **{
+                "name": f"test_device_{i}",
+                "deviceClass": "TestDeviceClass",
+                "readoutPriority": "baseline",
+                "enabled": True,
+            }
+        )
+        for i in range(5)
+    ]:
+        widget._add_item(item)
+    widget._update_num_included()
+    widget.show()
+    sys.exit(app.exec())

bec_widgets/widgets/control/device_manager/components/available_device_resources/available_device_group_ui.py

@@ -0,0 +1,56 @@
+from typing import TYPE_CHECKING
+
+from qtpy.QtCore import QMetaObject, Qt
+from qtpy.QtWidgets import QFrame, QLabel, QListWidget, QVBoxLayout
+
+from bec_widgets.widgets.control.device_manager.components._util import mimedata_from_configs
+from bec_widgets.widgets.control.device_manager.components.constants import (
+    CONFIG_DATA_ROLE,
+    MIME_DEVICE_CONFIG,
+)
+
+if TYPE_CHECKING:
+    from .available_device_group import AvailableDeviceGroup
+
+
+class _DeviceListWiget(QListWidget):
+
+    def _item_iter(self):
+        return (self.item(i) for i in range(self.count()))
+
+    def all_configs(self):
+        return [item.data(CONFIG_DATA_ROLE) for item in self._item_iter()]
+
+    def mimeTypes(self):
+        return [MIME_DEVICE_CONFIG]
+
+    def mimeData(self, items):
+        return mimedata_from_configs(item.data(CONFIG_DATA_ROLE) for item in items)
+
+
+class Ui_AvailableDeviceGroup(object):
+    def setupUi(self, AvailableDeviceGroup: "AvailableDeviceGroup"):
+        if not AvailableDeviceGroup.objectName():
+            AvailableDeviceGroup.setObjectName("AvailableDeviceGroup")
+        AvailableDeviceGroup.setMinimumWidth(150)
+
+        self.verticalLayout = QVBoxLayout()
+        self.verticalLayout.setObjectName("verticalLayout")
+        AvailableDeviceGroup.set_layout(self.verticalLayout)
+
+        title_layout = AvailableDeviceGroup.get_title_layout()
+
+        self.n_included = QLabel(AvailableDeviceGroup, text="...")
+        self.n_included.setObjectName("n_included")
+        title_layout.addWidget(self.n_included)
+
+        self.device_list = _DeviceListWiget(AvailableDeviceGroup)
+        self.device_list.setSelectionMode(QListWidget.SelectionMode.ExtendedSelection)
+        self.device_list.setObjectName("device_list")
+        self.device_list.setFrameStyle(0)
+        self.device_list.setDragEnabled(True)
+        self.device_list.setAcceptDrops(False)
+        self.device_list.setDefaultDropAction(Qt.DropAction.CopyAction)
+        self.verticalLayout.addWidget(self.device_list)
+        AvailableDeviceGroup.setFrameStyle(QFrame.Shadow.Plain | QFrame.Shape.Box)
+        QMetaObject.connectSlotsByName(AvailableDeviceGroup)

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

@@ -0,0 +1,128 @@
+from random import randint
+from typing import Any, Iterable
+from uuid import uuid4
+
+from qtpy.QtCore import QItemSelection, Signal  # type: ignore
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.control.device_manager.components._util import (
+    SharedSelectionSignal,
+    yield_only_passing,
+)
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_resources_ui import (
+    Ui_availableDeviceResources,
+)
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.device_resource_backend import (
+    HashableDevice,
+    get_backend,
+)
+from bec_widgets.widgets.control.device_manager.components.constants import CONFIG_DATA_ROLE
+
+
+class AvailableDeviceResources(BECWidget, QWidget, Ui_availableDeviceResources):
+
+    selected_devices = Signal(list)  # list[dict[str,Any]] of device configs currently selected
+    add_selected_devices = Signal(list)
+    del_selected_devices = Signal(list)
+
+    def __init__(self, parent=None, shared_selection_signal=SharedSelectionSignal(), **kwargs):
+        super().__init__(parent=parent, **kwargs)
+        self.setupUi(self)
+        self._backend = get_backend()
+        self._shared_selection_signal = shared_selection_signal
+        self._shared_selection_uuid = str(uuid4())
+        self._shared_selection_signal.proc.connect(self._handle_shared_selection_signal)
+        self.device_groups_list.selectionModel().selectionChanged.connect(
+            self._on_selection_changed
+        )
+        self.grouping_selector.addItem("deviceTags")
+        self.grouping_selector.addItems(self._backend.allowed_sort_keys)
+        self._grouping_selection_changed("deviceTags")
+        self.grouping_selector.currentTextChanged.connect(self._grouping_selection_changed)
+        self.search_box.textChanged.connect(self.device_groups_list.update_filter)
+
+        self.tb_add_selected.action.triggered.connect(self._add_selected_action)
+        self.tb_del_selected.action.triggered.connect(self._del_selected_action)
+
+    def refresh_full_list(self, device_groups: dict[str, set[HashableDevice]]):
+        self.device_groups_list.clear()
+        for device_group, devices in device_groups.items():
+            self._add_device_group(device_group, devices)
+        if self.grouping_selector.currentText == "deviceTags":
+            self._add_device_group("Untagged devices", self._backend.untagged_devices)
+        self.device_groups_list.sortItems()
+
+    def _add_device_group(self, device_group: str, devices: set[HashableDevice]):
+        item, widget = self.device_groups_list.add_item(
+            device_group,
+            self.device_groups_list,
+            device_group,
+            devices,
+            shared_selection_signal=self._shared_selection_signal,
+            expanded=False,
+        )
+        item.setData(CONFIG_DATA_ROLE, widget.create_mime_data())
+        # Re-emit the selected items from a subgroup - all other selections should be disabled anyway
+        widget.selected_devices.connect(self.selected_devices)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        for list_item, device_group_widget in self.device_groups_list.item_widget_pairs():
+            list_item.setSizeHint(device_group_widget.sizeHint())
+
+    @SafeSlot()
+    def _add_selected_action(self):
+        self.add_selected_devices.emit(self.device_groups_list.any_selected_devices())
+
+    @SafeSlot()
+    def _del_selected_action(self):
+        self.del_selected_devices.emit(self.device_groups_list.any_selected_devices())
+
+    @SafeSlot(QItemSelection, QItemSelection)
+    def _on_selection_changed(self, selected: QItemSelection, deselected: QItemSelection) -> None:
+        self.selected_devices.emit(self.device_groups_list.selected_devices_from_groups())
+        self._shared_selection_signal.proc.emit(self._shared_selection_uuid)
+
+    @SafeSlot(str)
+    def _handle_shared_selection_signal(self, uuid: str):
+        if uuid != self._shared_selection_uuid:
+            self.device_groups_list.clearSelection()
+
+    def _set_devices_state(self, devices: Iterable[HashableDevice], included: bool):
+        for device in devices:
+            for device_group in self.device_groups_list.widgets():
+                device_group.set_item_state(hash(device), included)
+
+    @SafeSlot(list)
+    def mark_devices_used(self, config_list: list[dict[str, Any]], used: bool):
+        """Set the display color of individual devices and update the group display of numbers
+        included. Accepts a list of dicts with the complete config as used in
+        bec_lib.atlas_models.Device."""
+        self._set_devices_state(
+            yield_only_passing(HashableDevice.model_validate, config_list), used
+        )
+
+    @SafeSlot(str)
+    def _grouping_selection_changed(self, sort_key: str):
+        self.search_box.setText("")
+        if sort_key == "deviceTags":
+            device_groups = self._backend.tag_groups
+        else:
+            device_groups = self._backend.group_by_key(sort_key)
+        self.refresh_full_list(device_groups)
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = AvailableDeviceResources()
+    widget._set_devices_state(
+        list(filter(lambda _: randint(0, 1) == 1, widget._backend.all_devices)), True
+    )
+    widget.show()
+    sys.exit(app.exec())

bec_widgets/widgets/control/device_manager/components/available_device_resources/available_device_resources_ui.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import itertools
+
+from qtpy.QtCore import QMetaObject, Qt
+from qtpy.QtWidgets import (
+    QAbstractItemView,
+    QComboBox,
+    QGridLayout,
+    QLabel,
+    QLineEdit,
+    QListView,
+    QListWidget,
+    QListWidgetItem,
+    QSizePolicy,
+    QVBoxLayout,
+)
+
+from bec_widgets.utils.list_of_expandable_frames import ListOfExpandableFrames
+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.control.device_manager.components._util import mimedata_from_configs
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_group import (
+    AvailableDeviceGroup,
+)
+from bec_widgets.widgets.control.device_manager.components.constants import (
+    CONFIG_DATA_ROLE,
+    MIME_DEVICE_CONFIG,
+)
+
+
+class _ListOfDeviceGroups(ListOfExpandableFrames[AvailableDeviceGroup]):
+
+    def itemWidget(self, item: QListWidgetItem) -> AvailableDeviceGroup:
+        return super().itemWidget(item)  # type: ignore
+
+    def any_selected_devices(self):
+        return self.selected_individual_devices() or self.selected_devices_from_groups()
+
+    def selected_individual_devices(self):
+        for widget in (self.itemWidget(self.item(i)) for i in range(self.count())):
+            if (selected := widget.get_selection()) != set():
+                return [dev.as_normal_device().model_dump() for dev in selected]
+        return []
+
+    def selected_devices_from_groups(self):
+        selected_items = (self.item(r.row()) for r in self.selectionModel().selectedRows())
+        widgets = (self.itemWidget(item) for item in selected_items)
+        return list(itertools.chain.from_iterable(w.device_list.all_configs() for w in widgets))
+
+    def mimeTypes(self):
+        return [MIME_DEVICE_CONFIG]
+
+    def mimeData(self, items):
+        return mimedata_from_configs(
+            itertools.chain.from_iterable(item.data(CONFIG_DATA_ROLE) for item in items)
+        )
+
+
+class Ui_availableDeviceResources(object):
+    def setupUi(self, availableDeviceResources):
+        if not availableDeviceResources.objectName():
+            availableDeviceResources.setObjectName("availableDeviceResources")
+        self.verticalLayout = QVBoxLayout(availableDeviceResources)
+        self.verticalLayout.setObjectName("verticalLayout")
+
+        self._add_toolbar()
+
+        # Main area with search and filter using a grid layout
+        self.search_layout = QVBoxLayout()
+        self.grid_layout = QGridLayout()
+
+        self.grouping_selector = QComboBox()
+        self.grouping_selector.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        lbl_group = QLabel("Group by:")
+        lbl_group.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        self.grid_layout.addWidget(lbl_group, 0, 0)
+        self.grid_layout.addWidget(self.grouping_selector, 0, 1)
+
+        self.search_box = QLineEdit()
+        self.search_box.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        lbl_filter = QLabel("Filter:")
+        lbl_filter.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        self.grid_layout.addWidget(lbl_filter, 1, 0)
+        self.grid_layout.addWidget(self.search_box, 1, 1)
+
+        self.grid_layout.setColumnStretch(0, 0)
+        self.grid_layout.setColumnStretch(1, 1)
+
+        self.search_layout.addLayout(self.grid_layout)
+        self.verticalLayout.addLayout(self.search_layout)
+
+        self.device_groups_list = _ListOfDeviceGroups(
+            availableDeviceResources, AvailableDeviceGroup
+        )
+        self.device_groups_list.setObjectName("device_groups_list")
+        self.device_groups_list.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
+        self.device_groups_list.setVerticalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
+        self.device_groups_list.setHorizontalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
+        self.device_groups_list.setMovement(QListView.Movement.Static)
+        self.device_groups_list.setSpacing(4)
+        self.device_groups_list.setDragDropMode(QListWidget.DragDropMode.DragOnly)
+        self.device_groups_list.setSelectionBehavior(QListWidget.SelectionBehavior.SelectItems)
+        self.device_groups_list.setSelectionMode(QListWidget.SelectionMode.ExtendedSelection)
+        self.device_groups_list.setDragEnabled(True)
+        self.device_groups_list.setAcceptDrops(False)
+        self.device_groups_list.setDefaultDropAction(Qt.DropAction.CopyAction)
+        self.device_groups_list.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        availableDeviceResources.setMinimumWidth(250)
+        availableDeviceResources.resize(250, availableDeviceResources.height())
+
+        self.verticalLayout.addWidget(self.device_groups_list)
+
+        QMetaObject.connectSlotsByName(availableDeviceResources)
+
+    def _add_toolbar(self):
+        self.toolbar = ModularToolBar(self)
+        io_bundle = ToolbarBundle("IO", self.toolbar.components)
+
+        self.tb_add_selected = MaterialIconAction(
+            icon_name="add_box", parent=self, tooltip="Add selected devices to composition"
+        )
+        self.toolbar.components.add_safe("add_selected", self.tb_add_selected)
+        io_bundle.add_action("add_selected")
+
+        self.tb_del_selected = MaterialIconAction(
+            icon_name="chips", parent=self, tooltip="Remove selected devices from composition"
+        )
+        self.toolbar.components.add_safe("del_selected", self.tb_del_selected)
+        io_bundle.add_action("del_selected")
+
+        self.verticalLayout.addWidget(self.toolbar)
+        self.toolbar.add_bundle(io_bundle)
+        self.toolbar.show_bundles(["IO"])

bec_widgets/widgets/control/device_manager/components/available_device_resources/device_resource_backend.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import operator
+import os
+from enum import Enum, auto
+from functools import partial, reduce
+from glob import glob
+from pathlib import Path
+from typing import Protocol
+
+import bec_lib
+from bec_lib.atlas_models import HashableDevice, HashableDeviceSet
+from bec_lib.bec_yaml_loader import yaml_load
+from bec_lib.logger import bec_logger
+from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path, plugins_installed
+
+logger = bec_logger.logger
+
+# use the last n recovery files
+_N_RECOVERY_FILES = 3
+_BASE_REPO_PATH = Path(os.path.dirname(bec_lib.__file__)) / "../.."
+
+
+def get_backend() -> DeviceResourceBackend:
+    return _ConfigFileBackend()
+
+
+class HashModel(str, Enum):
+    DEFAULT = auto()
+    DEFAULT_DEVICECONFIG = auto()
+    DEFAULT_EPICS = auto()
+
+
+class DeviceResourceBackend(Protocol):
+    @property
+    def tag_groups(self) -> dict[str, set[HashableDevice]]:
+        """A dictionary of all availble devices separated by tag groups. The same device may
+        appear more than once (in different groups)."""
+        ...
+
+    @property
+    def all_devices(self) -> set[HashableDevice]:
+        """A set of all availble devices. The same device may not appear more than once."""
+        ...
+
+    @property
+    def untagged_devices(self) -> set[HashableDevice]:
+        """A set of all untagged devices. The same device may not appear more than once."""
+        ...
+
+    @property
+    def allowed_sort_keys(self) -> set[str]:
+        """A set of all fields which you may group devices by"""
+        ...
+
+    def tags(self) -> set[str]:
+        """Returns a set of all the tags in all available devices."""
+        ...
+
+    def tag_group(self, tag: str) -> set[HashableDevice]:
+        """Returns a set of the devices in the tag group with the given key."""
+        ...
+
+    def group_by_key(self, key: str) -> dict[str, set[HashableDevice]]:
+        """Return a dict of all devices, organised by the specified key, which must be one of
+        the string keys in the Device model."""
+        ...
+
+
+def _devices_from_file(file: str, include_source: bool = True):
+    data = yaml_load(file, process_includes=False)
+    return HashableDeviceSet(
+        HashableDevice.model_validate(
+            dev | {"name": name, "source_files": {file} if include_source else set()}
+        )
+        for name, dev in data.items()
+    )
+
+
+class _ConfigFileBackend(DeviceResourceBackend):
+    def __init__(self) -> None:
+        self._raw_device_set: set[HashableDevice] = self._get_config_from_backup_files()
+        if plugins_installed() == 1:
+            self._raw_device_set.update(
+                self._get_configs_from_plugin_files(
+                    Path(plugin_repo_path()) / plugin_package_name() / "device_configs/"
+                )
+            )
+        self._device_groups = self._get_tag_groups()
+
+    def _get_config_from_backup_files(self):
+        dir = _BASE_REPO_PATH / "logs/device_configs/recovery_configs"
+        files = sorted(glob("*.yaml", root_dir=dir))
+        last_n_files = files[-_N_RECOVERY_FILES:]
+        return reduce(
+            operator.or_,
+            map(
+                partial(_devices_from_file, include_source=False),
+                (str(dir / f) for f in last_n_files),
+            ),
+            set(),
+        )
+
+    def _get_configs_from_plugin_files(self, dir: Path):
+        files = glob("*.yaml", root_dir=dir, recursive=True)
+        return reduce(operator.or_, map(_devices_from_file, (str(dir / f) for f in files)), set())
+
+    def _get_tag_groups(self) -> dict[str, set[HashableDevice]]:
+        return {
+            tag: set(filter(lambda dev: tag in dev.deviceTags, self._raw_device_set))
+            for tag in self.tags()
+        }
+
+    @property
+    def tag_groups(self):
+        return self._device_groups
+
+    @property
+    def all_devices(self):
+        return self._raw_device_set
+
+    @property
+    def untagged_devices(self):
+        return {d for d in self._raw_device_set if d.deviceTags == set()}
+
+    @property
+    def allowed_sort_keys(self) -> set[str]:
+        return {n for n, info in HashableDevice.model_fields.items() if info.annotation is str}
+
+    def tags(self) -> set[str]:
+        return reduce(operator.or_, (dev.deviceTags for dev in self._raw_device_set), set())
+
+    def tag_group(self, tag: str) -> set[HashableDevice]:
+        return self.tag_groups[tag]
+
+    def group_by_key(self, key: str) -> dict[str, set[HashableDevice]]:
+        if key not in self.allowed_sort_keys:
+            raise ValueError(f"Cannot group available devices by model key {key}")
+        group_names: set[str] = {getattr(item, key) for item in self._raw_device_set}
+        return {g: {d for d in self._raw_device_set if getattr(d, key) == g} for g in group_names}

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

@@ -0,0 +1,8 @@
+from typing import Final
+
+# Denotes a MIME type for JSON-encoded list of device config dictionaries
+MIME_DEVICE_CONFIG: Final[str] = "application/x-bec_device_config"
+
+# Custom user roles
+SORT_KEY_ROLE: Final[int] = 117
+CONFIG_DATA_ROLE: Final[int] = 118

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

@@ -0,0 +1,100 @@
+"""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.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: list[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[0], 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)
+    widget = QtWidgets.QWidget()
+    layout = QtWidgets.QVBoxLayout(widget)
+    widget.setLayout(layout)
+    layout.setContentsMargins(0, 0, 0, 0)
+    layout.setSpacing(0)
+    config_view = DMConfigView()
+    layout.addWidget(config_view)
+    combo_box = QtWidgets.QComboBox()
+    config = config_view.client.device_manager._get_redis_device_config()
+    combo_box.addItems([""] + [str(v) for v, item in enumerate(config)])
+
+    def on_select(text):
+        if text == "":
+            config_view.on_select_config([])
+        else:
+            config_view.on_select_config([config[int(text)]])
+
+    combo_box.currentTextChanged.connect(on_select)
+    layout.addWidget(combo_box)
+    widget.show()
+    sys.exit(app.exec_())

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

@@ -0,0 +1,133 @@
+"""Module to visualize the docstring of a device class."""
+
+from __future__ import annotations
+
+import inspect
+import re
+import textwrap
+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
+
+
+def docstring_to_markdown(obj) -> str:
+    """
+    Convert a Python docstring to Markdown suitable for QTextEdit.setMarkdown.
+    """
+    raw = inspect.getdoc(obj) or "*No docstring available.*"
+
+    # Dedent and normalize newlines
+    text = textwrap.dedent(raw).strip()
+
+    md = ""
+    if hasattr(obj, "__name__"):
+        md += f"# {obj.__name__}\n\n"
+
+    # Highlight section headers for Markdown
+    headers = ["Parameters", "Args", "Returns", "Raises", "Attributes", "Examples", "Notes"]
+    for h in headers:
+        doc = re.sub(rf"(?m)^({h})\s*:?\s*$", rf"### \1", text)
+
+    # Preserve code blocks (4+ space indented lines)
+    def fence_code(match: re.Match) -> str:
+        block = re.sub(r"^ {4}", "", match.group(0), flags=re.M)
+        return f"```\n{block}\n```"
+
+    doc = re.sub(r"(?m)(^ {4,}.*(\n {4,}.*)*)", fence_code, text)
+
+    # Preserve normal line breaks for Markdown
+    lines = doc.splitlines()
+    processed_lines = []
+    for line in lines:
+        if line.strip() == "":
+            processed_lines.append("")
+        else:
+            processed_lines.append(line + "  ")
+    doc = "\n".join(processed_lines)
+
+    md += doc
+    return md
+
+
+class DocstringView(QtWidgets.QTextEdit):
+    def __init__(self, parent: QtWidgets.QWidget | None = None):
+        super().__init__(parent)
+        self.setReadOnly(True)
+        self.setFocusPolicy(QtCore.Qt.FocusPolicy.NoFocus)
+        if not READY_TO_VIEW:
+            self._set_text("Ophyd or ophyd_devices not installed, cannot show docstrings.")
+            self.setEnabled(False)
+            return
+
+    def _set_text(self, text: str):
+        self.setReadOnly(False)
+        self.setMarkdown(text)
+        self.setReadOnly(True)
+
+    @SafeSlot(list)
+    def on_select_config(self, device: list[dict]):
+        if len(device) != 1:
+            self._set_text("")
+            return
+        device_class = device[0].get("deviceClass", "")
+        self.set_device_class(device_class)
+
+    @SafeSlot(str)
+    def set_device_class(self, device_class_str: str) -> None:
+        if not READY_TO_VIEW:
+            return
+        try:
+            module_cls = get_plugin_class(device_class_str, [ophyd_devices, ophyd])
+            markdown = docstring_to_markdown(module_cls)
+            self._set_text(markdown)
+        except Exception:
+            logger.exception("Error retrieving docstring")
+            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)
+    widget = QtWidgets.QWidget()
+    layout = QtWidgets.QVBoxLayout(widget)
+    widget.setLayout(layout)
+    layout.setContentsMargins(0, 0, 0, 0)
+    layout.setSpacing(0)
+
+    config_view = DocstringView()
+    config_view.set_device_class("ophyd_devices.sim.sim_camera.SimCamera")
+    layout.addWidget(config_view)
+    combo = QtWidgets.QComboBox()
+    combo.addItems(
+        [
+            "",
+            "ophyd_devices.sim.sim_camera.SimCamera",
+            "ophyd.EpicsSignalWithRBV",
+            "ophyd.EpicsMotor",
+            "csaxs_bec.devices.epics.mcs_card.mcs_card_csaxs.MCSCardCSAXS",
+        ]
+    )
+    combo.currentTextChanged.connect(config_view.set_device_class)
+    layout.addWidget(combo)
+    widget.show()
+    sys.exit(app.exec_())

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

@@ -0,0 +1,410 @@
+"""Module to run a static tests for devices from a yaml config."""
+
+from __future__ import annotations
+
+import enum
+import re
+from collections import deque
+from concurrent.futures import CancelledError, Future, ThreadPoolExecutor
+from html import escape
+from threading import Event, RLock
+from typing import Any, Iterable
+
+from bec_lib.logger import bec_logger
+from bec_qthemes import material_icon
+from qtpy import QtCore, 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 SafeSlot
+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
+
+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 DeviceTester(QtCore.QRunnable):
+    def __init__(self, config: dict) -> None:
+        super().__init__()
+        self.signals = DeviceValidationResult()
+        self.shutdown_event = Event()
+
+        self._config = config
+
+        self._max_threads = 4
+        self._pending_event = Event()
+        self._lock = RLock()
+        self._test_executor = ThreadPoolExecutor(self._max_threads, "device_manager_tester")
+
+        self._pending_queue: deque[tuple[str, dict]] = deque([])
+        self._active: set[str] = set()
+
+        QtWidgets.QApplication.instance().aboutToQuit.connect(lambda: self.shutdown_event.set())
+
+    def run(self):
+        if StaticDeviceTest is None:
+            logger.error("Ophyd devices or bec_server not available, cannot run validation.")
+            return
+        while not self.shutdown_event.is_set():
+            self._pending_event.wait(timeout=0.5)  # check if shutting down every 0.5s
+            if len(self._active) >= self._max_threads:
+                self._pending_event.clear()  # it will be set again on removing something from active
+                continue
+            with self._lock:
+                if len(self._pending_queue) > 0:
+                    item, cfg, connect = self._pending_queue.pop()
+                    self._active.add(item)
+                    fut = self._test_executor.submit(self._run_test, item, {item: cfg}, connect)
+                    fut.__dict__["__device_name"] = item
+                    fut.add_done_callback(self._done_cb)
+            self._safe_check_and_clear()
+        self._cleanup()
+
+    def submit(self, devices: Iterable[tuple[str, dict, bool]]):
+        with self._lock:
+            self._pending_queue.extend(devices)
+            self._pending_event.set()
+
+    @staticmethod
+    def _run_test(name: str, config: dict, connect: bool) -> tuple[str, bool, str]:
+        tester = StaticDeviceTest(config_dict=config)  # type: ignore # we exit early if it is None
+        results = tester.run_with_list_output(connect=connect)
+        return name, results[0].success, results[0].message
+
+    def _safe_check_and_clear(self):
+        with self._lock:
+            if len(self._pending_queue) == 0:
+                self._pending_event.clear()
+
+    def _safe_remove_from_active(self, name: str):
+        with self._lock:
+            self._active.remove(name)
+            self._pending_event.set()  # check again once a completed task is removed
+
+    def _done_cb(self, future: Future):
+        try:
+            name, success, message = future.result()
+        except CancelledError:
+            return
+        except Exception as e:
+            name, success, message = future.__dict__["__device_name"], False, str(e)
+        finally:
+            self._safe_remove_from_active(future.__dict__["__device_name"])
+        self.signals.device_validated.emit(name, success, message)
+
+    def _cleanup(self): ...
+
+
+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()
+
+    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)
+    # validation_msg in markdown format
+    validation_msg_md = QtCore.Signal(str)
+
+    def __init__(self, parent=None, client=None):
+        super().__init__(parent=parent, client=client)
+        if not READY_TO_TEST:
+            self.setDisabled(True)
+            self.tester = None
+        else:
+            self.tester = DeviceTester({})
+            self.tester.signals.device_validated.connect(self._on_device_validated)
+            QtCore.QThreadPool.globalInstance().start(self.tester)
+        self._device_list_items: dict[str, QtWidgets.QListWidgetItem] = {}
+        # TODO Consider using the thread pool from BECConnector instead of fetching the global instance!
+        self._thread_pool = QtCore.QThreadPool.globalInstance()
+
+        self._main_layout = QtWidgets.QVBoxLayout(self)
+        self._main_layout.setContentsMargins(0, 0, 0, 0)
+        self._main_layout.setSpacing(0)
+
+        # 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()
+
+    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)
+
+    @SafeSlot(list, bool)
+    @SafeSlot(list, bool, bool)
+    def change_device_configs(
+        self, device_configs: list[dict[str, Any]], added: bool, connect: bool = False
+    ) -> None:
+        """Receive an update with device configs.
+
+        Args:
+            device_configs (list[dict[str, Any]]): The updated device configurations.
+        """
+        for cfg in device_configs:
+            name = cfg.get("name", "<not found>")
+            if added:
+                if name in self._device_list_items:
+                    continue
+                if self.tester:
+                    self._add_device(name, cfg)
+                    self.tester.submit([(name, cfg, connect)])
+                continue
+            if name not in self._device_list_items:
+                continue
+            self._remove_list_item(name)
+
+    def _add_device(self, name, cfg):
+        item = QtWidgets.QListWidgetItem(self._list_widget)
+        widget = ValidationListItem(device_name=name, device_config=cfg)
+
+        # wrap it in a QListWidgetItem
+        item.setSizeHint(widget.sizeHint())
+        self._list_widget.addItem(item)
+        self._list_widget.setItemWidget(item, widget)
+        self._device_list_items[name] = item
+
+    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)
+
+    @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_md = self._format_markdown_text(widget.device_name, widget.validation_msg)
+                self.validation_msg_md.emit(formatted_md)
+            except Exception as e:
+                logger.error(
+                    f"##Error formatting validation message for device {widget.device_name}:\n{e}"
+                )
+                self.validation_msg_md.emit(widget.validation_msg)
+        else:
+            self.validation_msg_md.emit("")
+
+    def _format_markdown_text(self, device_name: str, raw_msg: str) -> str:
+        """Simple HTML formatting for validation messages, wrapping text naturally."""
+        if not raw_msg.strip():
+            return f"### Validation in progress for {device_name}... \n\n"
+        if raw_msg == "Validation in progress...":
+            return f"### Validation in progress for {device_name}... \n\n"
+
+        m = re.search(r"ERROR:\s*([^\s]+)\s+is not valid:\s*(.+?errors?)", raw_msg)
+        device, summary = m.group(1), m.group(2)
+        lines = [f"## Error for '{device}'", f"'{device}' is not valid: {summary}"]
+
+        # Find each field block:  \n<field>\n  Field required ...
+        field_pat = re.compile(
+            r"\n(?P<field>\w+)\n\s+(?P<rest>Field required.*?(?=\n\w+\n|$))", re.DOTALL
+        )
+
+        for m in field_pat.finditer(raw_msg):
+            field = m.group("field")
+            rest = m.group("rest").rstrip()
+            lines.append(f"### {field}")
+            lines.append(rest)
+
+        return "\n".join(lines)
+
+    def validation_running(self):
+        return self._device_list_items != {}
+
+    @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()
+        self.validation_msg_md.emit("")
+
+    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)
+
+    def cleanup(self):
+        if self.tester:
+            self.tester.shutdown_event.set()
+        return super().cleanup()
+
+
+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)
+    wid = QtWidgets.QWidget()
+    layout = QtWidgets.QVBoxLayout(wid)
+    wid.setLayout(layout)
+    layout.setContentsMargins(0, 0, 0, 0)
+    layout.setSpacing(0)
+    device_manager_ophyd_test = DMOphydTest()
+    try:
+        config_path = "/Users/appel_c/work_psi_awi/bec_workspace/csaxs_bec/csaxs_bec/device_configs/endstation.yaml"
+        config = [{"name": k, **v} for k, v in yaml_load(config_path).items()]
+    except Exception as e:
+        logger.error(f"Error loading config: {e}")
+        import os
+
+        import bec_lib
+
+        config_path = os.path.join(os.path.dirname(bec_lib.__file__), "configs", "demo_config.yaml")
+        config = [{"name": k, **v} for k, v in yaml_load(config_path).items()]
+
+    config.append({"name": "non_existing_device", "type": "NonExistingDevice"})
+    device_manager_ophyd_test.change_device_configs(config, True, True)
+    layout.addWidget(device_manager_ophyd_test)
+    device_manager_ophyd_test.setWindowTitle("Device Manager Ophyd Test")
+    device_manager_ophyd_test.resize(800, 600)
+    text_box = QtWidgets.QTextEdit()
+    text_box.setReadOnly(True)
+    layout.addWidget(text_box)
+    device_manager_ophyd_test.validation_msg_md.connect(text_box.setMarkdown)
+    wid.show()
+    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

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Literal
+from typing import Literal, Sequence
 
 import numpy as np
 from bec_lib import bec_logger
@@ -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",
@@ -307,7 +309,7 @@ class Image(ImageBase):
         Set the image source and update the image.
 
         Args:
-            monitor(str): The name of the monitor to use for the image.
+            monitor(str|tuple|None): The name of the monitor to use for the image, or a tuple of (device, signal) for preview signals. If None or empty string, the current monitor will be disconnected.
             monitor_type(str): The type of monitor to use. Options are "1d", "2d", or "auto".
             color_map(str): The color map to use for the image.
             color_bar(str): The type of color bar to use. Options are "simple" or "full".
@@ -322,10 +324,13 @@ class Image(ImageBase):
         if monitor is None or monitor == "":
             logger.warning(f"No monitor specified, cannot set image, old monitor is unsubscribed")
             return None
-        if isinstance(monitor, tuple):
+
+        if isinstance(monitor, str):
+            self.entry_validator.validate_monitor(monitor)
+        elif isinstance(monitor, Sequence):
             self.entry_validator.validate_monitor(monitor[0])
         else:
-            self.entry_validator.validate_monitor(monitor)
+            raise ValueError(f"Invalid monitor type: {type(monitor)}")
 
         self.set_image_update(monitor=monitor, type=monitor_type)
         if color_map is not None:
@@ -347,7 +352,7 @@ class Image(ImageBase):
         if config.monitor is not None:
             for combo in (self.device_combo_box, self.dim_combo_box):
                 combo.blockSignals(True)
-            if isinstance(config.monitor, tuple):
+            if isinstance(config.monitor, (list, tuple)):
                 self.device_combo_box.setCurrentText(f"{config.monitor[0]}_{config.monitor[1]}")
             else:
                 self.device_combo_box.setCurrentText(config.monitor)
@@ -452,7 +457,7 @@ class Image(ImageBase):
         """
 
         # TODO consider moving connecting and disconnecting logic to Image itself if multiple images
-        if isinstance(monitor, tuple):
+        if isinstance(monitor, (list, tuple)):
             device = self.dev[monitor[0]]
             signal = monitor[1]
             if len(monitor) == 3:
@@ -520,7 +525,7 @@ class Image(ImageBase):
         Args:
             monitor(str|tuple): The name of the monitor to disconnect, or a tuple of (device, signal) for preview signals.
         """
-        if isinstance(monitor, tuple):
+        if isinstance(monitor, (list, tuple)):
             if self.subscriptions["main"].source == "device_monitor_1d":
                 self.bec_dispatcher.disconnect_slot(
                     self.on_image_update_1d, MessageEndpoints.device_preview(monitor[0], monitor[1])

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,6 +109,7 @@ 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
@@ -134,7 +135,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)
@@ -142,6 +143,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")
@@ -893,15 +896,20 @@ class PlotBase(BECWidget, QWidget):
             return
         self._apply_autorange_only_visible_curves()
 
-    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
+    @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 _apply_autorange_only_visible_curves(self):
         """
@@ -910,8 +918,9 @@ class PlotBase(BECWidget, QWidget):
         Args:
             curves (list): List of curves to apply autorange to.
         """
-        visible_curves = self._fetch_visible_curves()
-        self.plot_item.autoRange(items=visible_curves if visible_curves else None)
+        visible_items = self.visible_items
+
+        self.plot_item.autoRange(items=visible_items if visible_items 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,8 +932,17 @@ 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.
@@ -1115,7 +1127,8 @@ class Waveform(PlotBase):
             self.reset()
             self.new_scan.emit()
             self.new_scan_id.emit(current_scan_id)
-            self.auto_range(True)
+            self.auto_range_x = True
+            self.auto_range_y = 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
@@ -2056,7 +2069,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.py

@@ -12,8 +12,8 @@ from bec_widgets.utils import BECConnector, ConnectionConfig
 
 
 class ProgressbarConnections(BaseModel):
-    slot: Literal["on_scan_progress", "on_device_readback"] = None
-    endpoint: EndpointInfo | str = None
+    slot: Literal["on_scan_progress", "on_device_readback", None] = None
+    endpoint: EndpointInfo | str | None = None
     model_config: dict = {"validate_assignment": True}
 
     @field_validator("endpoint")
@@ -222,9 +222,10 @@ class Ring(BECConnector, QObject):
             device(str): Device name for the device readback mode, only used when mode is "device"
         """
         if mode == "manual":
-            self.bec_dispatcher.disconnect_slot(
-                getattr(self, self.config.connections.slot), self.config.connections.endpoint
-            )
+            if self.config.connections.slot is not None:
+                self.bec_dispatcher.disconnect_slot(
+                    getattr(self, self.config.connections.slot), self.config.connections.endpoint
+                )
             self.config.connections.slot = None
             self.config.connections.endpoint = None
         elif mode == "scan":

bec_widgets/widgets/progress/ring_progress_bar/ring_progress_bar.py

@@ -22,13 +22,9 @@ class RingProgressBarConfig(ConnectionConfig):
     color_map: Optional[str] = Field(
         "plasma", description="Color scheme for the progress bars.", validate_default=True
     )
-    min_number_of_bars: int | None = Field(
-        1, description="Minimum number of progress bars to display."
-    )
-    max_number_of_bars: int | None = Field(
-        10, description="Maximum number of progress bars to display."
-    )
-    num_bars: int | None = Field(1, description="Number of progress bars to display.")
+    min_number_of_bars: int = Field(1, description="Minimum number of progress bars to display.")
+    max_number_of_bars: int = Field(10, description="Maximum number of progress bars to display.")
+    num_bars: int = Field(1, description="Number of progress bars to display.")
     gap: int | None = Field(20, description="Gap between progress bars.")
     auto_updates: bool | None = Field(
         True, description="Enable or disable updates based on scan queue status."
@@ -96,6 +92,9 @@ class RingProgressBar(BECWidget, QWidget):
         "set_diameter",
         "reset_diameter",
         "enable_auto_updates",
+        "attach",
+        "detach",
+        "screenshot",
     ]
 
     def __init__(
@@ -242,7 +241,7 @@ class RingProgressBar(BECWidget, QWidget):
         for i, ring in enumerate(self._rings):
             ring.config.index = i
 
-    def set_precision(self, precision: int, bar_index: int = None):
+    def set_precision(self, precision: int, bar_index: int | None = None):
         """
         Set the precision for the progress bars. If bar_index is not provide, the precision will be set for all progress bars.
 
@@ -271,9 +270,9 @@ class RingProgressBar(BECWidget, QWidget):
             min_values(int|float | list[float]): Minimum value(s) for the progress bars. If multiple progress bars are displayed, provide a list of minimum values for each progress bar.
             max_values(int|float | list[float]): Maximum value(s) for the progress bars. If multiple progress bars are displayed, provide a list of maximum values for each progress bar.
         """
-        if isinstance(min_values, int) or isinstance(min_values, float):
+        if isinstance(min_values, (int, float)):
             min_values = [min_values]
-        if isinstance(max_values, int) or isinstance(max_values, float):
+        if isinstance(max_values, (int, float)):
             max_values = [max_values]
         min_values = self._adjust_list_to_bars(min_values)
         max_values = self._adjust_list_to_bars(max_values)
@@ -441,14 +440,10 @@ class RingProgressBar(BECWidget, QWidget):
         Returns:
             Ring: Ring object.
         """
-        found_ring = None
         for ring in self._rings:
             if ring.config.index == index:
-                found_ring = ring
-                break
-        if found_ring is None:
-            raise ValueError(f"Ring with index {index} not found.")
-        return found_ring
+                return ring
+        raise ValueError(f"Ring with index {index} not found.")
 
     def enable_auto_updates(self, enable: bool = True):
         """
@@ -485,29 +480,30 @@ class RingProgressBar(BECWidget, QWidget):
         primary_queue = msg.get("queue").get("primary")
         info = primary_queue.get("info", None)
 
-        if info:
-            active_request_block = info[0].get("active_request_block", None)
-            if active_request_block:
-                report_instructions = active_request_block.get("report_instructions", None)
-                if report_instructions:
-                    instruction_type = list(report_instructions[0].keys())[0]
-                    if instruction_type == "scan_progress":
-                        self._hook_scan_progress(ring_index=0)
-                    elif instruction_type == "readback":
-                        devices = report_instructions[0].get("readback").get("devices")
-                        start = report_instructions[0].get("readback").get("start")
-                        end = report_instructions[0].get("readback").get("end")
-                        if self.config.num_bars != len(devices):
-                            self.set_number_of_bars(len(devices))
-                        for index, device in enumerate(devices):
-                            self._hook_readback(index, device, start[index], end[index])
-                    else:
-                        logger.error(f"{instruction_type} not supported yet.")
+        if not info:
+            return
+        active_request_block = info[0].get("active_request_block", None)
+        if not active_request_block:
+            return
+        report_instructions = active_request_block.get("report_instructions", None)
+        if not report_instructions:
+            return
 
-                    # elif instruction_type == "device_progress":
-                    #     print("hook device_progress")
+        instruction_type = list(report_instructions[0].keys())[0]
+        if instruction_type == "scan_progress":
+            self._hook_scan_progress(ring_index=0)
+        elif instruction_type == "readback":
+            devices = report_instructions[0].get("readback").get("devices")
+            start = report_instructions[0].get("readback").get("start")
+            end = report_instructions[0].get("readback").get("end")
+            if self.config.num_bars != len(devices):
+                self.set_number_of_bars(len(devices))
+            for index, device in enumerate(devices):
+                self._hook_readback(index, device, start[index], end[index])
+        else:
+            logger.error(f"{instruction_type} not supported yet.")
 
-    def _hook_scan_progress(self, ring_index: int = None):
+    def _hook_scan_progress(self, ring_index: int | None = None):
         """
         Hook the scan progress to the progress bars.
 
@@ -521,8 +517,7 @@ class RingProgressBar(BECWidget, QWidget):
 
         if ring.config.connections.slot == "on_scan_progress":
             return
-        else:
-            ring.set_connections("on_scan_progress", MessageEndpoints.scan_progress())
+        ring.set_connections("on_scan_progress", MessageEndpoints.scan_progress())
 
     def _hook_readback(self, bar_index: int, device: str, min: float | int, max: float | int):
         """
@@ -576,6 +571,8 @@ class RingProgressBar(BECWidget, QWidget):
         return bar_index
 
     def paintEvent(self, event):
+        if not self._rings:
+            return
         painter = QtGui.QPainter(self)
         painter.setRenderHint(QtGui.QPainter.Antialiasing)
         size = min(self.width(), self.height())
@@ -628,9 +625,8 @@ class RingProgressBar(BECWidget, QWidget):
             return QSize(10, 10)
         ring_widths = [self.config.rings[i].line_width for i in range(self.config.num_bars)]
         total_width = sum(ring_widths) + self.config.gap * (self.config.num_bars - 1)
-        diameter = total_width * 2
-        if diameter < 50:
-            diameter = 50
+        diameter = max(total_width * 2, 50)
+
         return QSize(diameter, diameter)
 
     def sizeHint(self):

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

@@ -1,6 +1,4 @@
 import os
-import re
-from functools import partial
 from typing import Callable
 
 import bec_lib
@@ -11,23 +9,17 @@ from bec_lib.logger import bec_logger
 from bec_lib.messages import ConfigAction, ScanStatusMessage
 from bec_qthemes import material_icon
 from pyqtgraph import SignalProxy
-from qtpy.QtCore import QSize, QThreadPool, Signal
-from qtpy.QtWidgets import (
-    QFileDialog,
-    QListWidget,
-    QListWidgetItem,
-    QToolButton,
-    QVBoxLayout,
-    QWidget,
-)
+from qtpy.QtCore import QThreadPool, Signal
+from qtpy.QtWidgets import QFileDialog, QListWidget, QToolButton, QVBoxLayout, QWidget
 
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.list_of_expandable_frames import ListOfExpandableFrames
 from bec_widgets.utils.ui_loader import UILoader
 from bec_widgets.widgets.services.device_browser.device_item import DeviceItem
 from bec_widgets.widgets.services.device_browser.device_item.device_config_dialog import (
-    DeviceConfigDialog,
+    DirectUpdateDeviceConfigDialog,
 )
 from bec_widgets.widgets.services.device_browser.util import map_device_type_to_icon
 
@@ -59,7 +51,8 @@ class DeviceBrowser(BECWidget, QWidget):
         self._q_threadpool = QThreadPool()
         self.ui = None
         self.init_ui()
-        self.dev_list: QListWidget = self.ui.device_list
+        self.dev_list = ListOfExpandableFrames(self, DeviceItem)
+        self.ui.verticalLayout.addWidget(self.dev_list)
         self.dev_list.setVerticalScrollMode(QListWidget.ScrollMode.ScrollPerPixel)
         self.proxy_device_update = SignalProxy(
             self.ui.filter_input.textChanged, rateLimit=500, slot=self.update_device_list
@@ -114,7 +107,7 @@ class DeviceBrowser(BECWidget, QWidget):
         )
 
     def _create_add_dialog(self):
-        dialog = DeviceConfigDialog(parent=self, device=None, action="add")
+        dialog = DirectUpdateDeviceConfigDialog(parent=self, device=None, action="add")
         dialog.open()
 
     def on_device_update(self, action: ConfigAction, content: dict) -> None:
@@ -132,25 +125,15 @@ class DeviceBrowser(BECWidget, QWidget):
 
     def init_device_list(self):
         self.dev_list.clear()
-        self._device_items: dict[str, QListWidgetItem] = {}
 
         with RPCRegister.delayed_broadcast():
             for device, device_obj in self.dev.items():
                 self._add_item_to_list(device, device_obj)
 
     def _add_item_to_list(self, device: str, device_obj):
-        def _updatesize(item: QListWidgetItem, device_item: DeviceItem):
-            device_item.adjustSize()
-            item.setSizeHint(QSize(device_item.width(), device_item.height()))
-            logger.debug(f"Adjusting {item} size to {device_item.width(), device_item.height()}")
 
-        def _remove_item(item: QListWidgetItem):
-            self.dev_list.takeItem(self.dev_list.row(item))
-            del self._device_items[device]
-            self.dev_list.sortItems()
-
-        item = QListWidgetItem(self.dev_list)
-        device_item = DeviceItem(
+        _, device_item = self.dev_list.add_item(
+            id=device,
             parent=self,
             device=device,
             devices=self.dev,
@@ -158,18 +141,11 @@ class DeviceBrowser(BECWidget, QWidget):
             config_helper=self._config_helper,
             q_threadpool=self._q_threadpool,
         )
-        device_item.expansion_state_changed.connect(partial(_updatesize, item, device_item))
-        device_item.imminent_deletion.connect(partial(_remove_item, item))
+
         self.editing_enabled.connect(device_item.set_editable)
         self.device_update.connect(device_item.config_update)
         tooltip = self.dev[device]._config.get("description", "")
         device_item.setToolTip(tooltip)
-        device_item.broadcast_size_hint.connect(item.setSizeHint)
-        item.setSizeHint(device_item.sizeHint())
-
-        self.dev_list.setItemWidget(item, device_item)
-        self.dev_list.addItem(item)
-        self._device_items[device] = item
 
     @SafeSlot(dict, dict)
     def scan_status_changed(self, scan_info: dict, _: dict):
@@ -198,20 +174,11 @@ class DeviceBrowser(BECWidget, QWidget):
 
         Either way, the function will filter the devices based on the filter input text and update the device list.
         """
-        filter_text = self.ui.filter_input.text()
         for device in self.dev:
-            if device not in self._device_items:
+            if device not in self.dev_list:
                 # it is possible the device has just been added to the config
                 self._add_item_to_list(device, self.dev[device])
-        try:
-            self.regex = re.compile(filter_text, re.IGNORECASE)
-        except re.error:
-            self.regex = None  # Invalid regex, disable filtering
-            for device in self.dev:
-                self._device_items[device].setHidden(False)
-            return
-        for device in self.dev:
-            self._device_items[device].setHidden(not self.regex.search(device))
+        self.dev_list.update_filter(self.ui.filter_input.text())
 
     @SafeSlot()
     def _load_from_file(self):
@@ -240,10 +207,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_browser.ui

@@ -1,93 +1,90 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>Form</class>
- <widget class="QWidget" name="Form">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>406</width>
-    <height>500</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <widget class="QGroupBox" name="browser_group_box">
-     <property name="title">
-      <string>Device Browser</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_2">
-      <item>
-       <layout class="QHBoxLayout" name="filter_layout">
-        <item>
-         <widget class="QLineEdit" name="filter_input">
-          <property name="placeholderText">
-           <string>Filter</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QGroupBox" name="button_box">
-          <layout class="QHBoxLayout" name="horizontalLayout">
-           <property name="leftMargin">
-            <number>0</number>
-           </property>
-           <property name="topMargin">
-            <number>0</number>
-           </property>
-           <property name="rightMargin">
-            <number>0</number>
-           </property>
-           <property name="bottomMargin">
-            <number>0</number>
-           </property>
-           <item>
-            <widget class="QToolButton" name="add_button">
-             <property name="text">
-              <string>...</string>
-             </property>
-            </widget>
-           </item>
-           <item>
-            <widget class="QToolButton" name="save_button">
-             <property name="text">
-              <string>...</string>
-             </property>
-            </widget>
-           </item>
-           <item>
-            <widget class="QToolButton" name="import_button">
-             <property name="text">
-              <string>...</string>
-             </property>
-            </widget>
-           </item>
-          </layout>
-         </widget>
-        </item>
-       </layout>
-      </item>
-      <item>
-       <widget class="QLabel" name="scan_running_warning">
-        <property name="styleSheet">
-         <string notr="true"/>
+    <class>Form</class>
+    <widget class="QWidget" name="Form">
+        <property name="geometry">
+            <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>406</width>
+                <height>500</height>
+            </rect>
         </property>
-        <property name="text">
-         <string>warning</string>
+        <property name="windowTitle">
+            <string>Form</string>
         </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QListWidget" name="device_list"/>
-      </item>
-     </layout>
+        <layout class="QVBoxLayout" name="verticalLayout">
+            <item>
+                <widget class="QGroupBox" name="browser_group_box">
+                    <property name="title">
+                        <string>Device Browser</string>
+                    </property>
+                    <layout class="QVBoxLayout" name="verticalLayout_2">
+                        <item>
+                            <layout class="QHBoxLayout" name="filter_layout">
+                                <item>
+                                    <widget class="QLineEdit" name="filter_input">
+                                        <property name="placeholderText">
+                                            <string>Filter</string>
+                                        </property>
+                                    </widget>
+                                </item>
+                                <item>
+                                    <widget class="QGroupBox" name="button_box">
+                                        <layout class="QHBoxLayout" name="horizontalLayout">
+                                            <property name="leftMargin">
+                                                <number>0</number>
+                                            </property>
+                                            <property name="topMargin">
+                                                <number>0</number>
+                                            </property>
+                                            <property name="rightMargin">
+                                                <number>0</number>
+                                            </property>
+                                            <property name="bottomMargin">
+                                                <number>0</number>
+                                            </property>
+                                            <item>
+                                                <widget class="QToolButton" name="add_button">
+                                                    <property name="text">
+                                                        <string>...</string>
+                                                    </property>
+                                                </widget>
+                                            </item>
+                                            <item>
+                                                <widget class="QToolButton" name="save_button">
+                                                    <property name="text">
+                                                        <string>...</string>
+                                                    </property>
+                                                </widget>
+                                            </item>
+                                            <item>
+                                                <widget class="QToolButton" name="import_button">
+                                                    <property name="text">
+                                                        <string>...</string>
+                                                    </property>
+                                                </widget>
+                                            </item>
+                                        </layout>
+                                    </widget>
+                                </item>
+                            </layout>
+                        </item>
+                        <item>
+                            <widget class="QLabel" name="scan_running_warning">
+                                <property name="styleSheet">
+                                    <string notr="true" />
+                                </property>
+                                <property name="text">
+                                    <string>warning</string>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+        </layout>
     </widget>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections/>
-</ui>
+    <resources />
+    <connections />
+</ui>

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

@@ -34,7 +34,11 @@ class CommunicateConfigAction(QRunnable):
     @SafeSlot()
     def run(self):
         try:
-            if self.action in ["add", "update", "remove"]:
+            if self.action == "set":
+                self._process(
+                    {"action": self.action, "config": self.config, "wait_for_response": False}
+                )
+            elif self.action in ["add", "update", "remove"]:
                 if (dev_name := self.device or self.config.get("name")) is None:
                     raise ValueError(
                         "Must be updating a device or be supplied a name for a new device"
@@ -57,6 +61,9 @@ class CommunicateConfigAction(QRunnable):
             "config": {dev_name: self.config},
             "wait_for_response": False,
         }
+        self._process(req_args)
+
+    def _process(self, req_args: dict):
         timeout = (
             self.config_helper.suggested_timeout_s(self.config) if self.config is not None else 20
         )

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

@@ -5,12 +5,14 @@ from bec_lib.atlas_models import Device as DeviceConfigModel
 from bec_lib.config_helper import CONF as DEVICE_CONF_KEYS
 from bec_lib.config_helper import ConfigHelper
 from bec_lib.logger import bec_logger
-from pydantic import ValidationError, field_validator
-from qtpy.QtCore import QSize, Qt, QThreadPool, Signal
+from pydantic import BaseModel, field_validator
+from qtpy.QtCore import QSize, Qt, QThreadPool, Signal  # type: ignore
 from qtpy.QtWidgets import (
     QApplication,
+    QComboBox,
     QDialog,
     QDialogButtonBox,
+    QHBoxLayout,
     QLabel,
     QStackedLayout,
     QVBoxLayout,
@@ -19,6 +21,7 @@ from qtpy.QtWidgets import (
 
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.forms_from_types.items import DynamicFormItem, DynamicFormItemType
 from bec_widgets.widgets.services.device_browser.device_item.config_communicator import (
     CommunicateConfigAction,
 )
@@ -29,6 +32,8 @@ from bec_widgets.widgets.utility.spinner.spinner import SpinnerWidget
 
 logger = bec_logger.logger
 
+_StdBtn = QDialogButtonBox.StandardButton
+
 
 def _try_literal_eval(value: str):
     if value == "":
@@ -39,79 +44,36 @@ def _try_literal_eval(value: str):
         raise ValueError(f"Entered config value {value} is not a valid python value!") from e
 
 
-class DeviceConfigDialog(BECWidget, QDialog):
+class DeviceConfigDialog(QDialog):
     RPC = False
     applied = Signal()
+    accepted_data = Signal(dict)
 
     def __init__(
-        self,
-        *,
-        parent=None,
-        device: str | None = None,
-        config_helper: ConfigHelper | None = None,
-        action: Literal["update", "add"] = "update",
-        threadpool: QThreadPool | None = None,
-        **kwargs,
+        self, *, parent=None, class_deviceconfig_item: type[DynamicFormItem] | None = None, **kwargs
     ):
-        """A dialog to edit the configuration of a device in BEC. Generated from the pydantic model
-        for device specification in bec_lib.atlas_models.
 
-        Args:
-            parent (QObject): the parent QObject
-            device (str | None): the name of the device. used with the "update" action to prefill the dialog and validate entries.
-            config_helper (ConfigHelper | None): a ConfigHelper object for communication with Redis, will be created if necessary.
-            action (Literal["update", "add"]): the action which the form should perform on application or acceptance.
-        """
         self._initial_config = {}
+        self._class_deviceconfig_item = class_deviceconfig_item
         super().__init__(parent=parent, **kwargs)
-        self._config_helper = config_helper or ConfigHelper(
-            self.client.connector, self.client._service_name
-        )
-        self._device = device
-        self._action: Literal["update", "add"] = action
-        self._q_threadpool = threadpool or QThreadPool()
-        self.setWindowTitle(f"Edit config for: {device}")
+
         self._container = QStackedLayout()
-        self._container.setStackingMode(QStackedLayout.StackAll)
+        self._container.setStackingMode(QStackedLayout.StackingMode.StackAll)
 
         self._layout = QVBoxLayout()
-        user_warning = QLabel(
-            "Warning: edit items here at your own risk - minimal validation is applied to the entered values.\n"
-            "Items in the deviceConfig dictionary should correspond to python literals, e.g. numbers, lists, strings (including quotes), etc."
-        )
-        user_warning.setWordWrap(True)
-        user_warning.setStyleSheet("QLabel { color: red; }")
-        self._layout.addWidget(user_warning)
-        self.get_bec_shortcuts()
+        self._data = {}
         self._add_form()
-        if self._action == "update":
-            self._form._validity.setVisible(False)
-        else:
-            self._set_schema_to_check_devices()
-            # TODO: replace when https://github.com/bec-project/bec/issues/528 https://github.com/bec-project/bec/issues/547 are resolved
-            # self._form._validity.setVisible(True)
-            self._form.validity_proc.connect(self.enable_buttons_for_validity)
         self._add_overlay()
         self._add_buttons()
-
+        self.setWindowTitle("Add new device")
         self.setLayout(self._container)
-        self._form.validate_form()
         self._overlay_widget.setVisible(False)
+        self._form._validity.setVisible(True)
+        self._connect_form()
 
-    def _set_schema_to_check_devices(self):
-        class _NameValidatedConfigModel(DeviceConfigModel):
-            @field_validator("name")
-            @staticmethod
-            def _validate_name(value: str, *_):
-                if not value.isidentifier():
-                    raise ValueError(
-                        f"Invalid device name: {value}. Device names must be valid Python identifiers."
-                    )
-                if value in self.dev:
-                    raise ValueError(f"A device with name {value} already exists!")
-                return value
-
-        self._form.set_schema(_NameValidatedConfigModel)
+    def _connect_form(self):
+        self._form.validity_proc.connect(self.enable_buttons_for_validity)
+        self._form.validate_form()
 
     def _add_form(self):
         self._form_widget = QWidget()
@@ -119,16 +81,6 @@ class DeviceConfigDialog(BECWidget, QDialog):
         self._form = DeviceConfigForm()
         self._layout.addWidget(self._form)
 
-        for row in self._form.enumerate_form_widgets():
-            if (
-                row.label.property("_model_field_name") in DEVICE_CONF_KEYS.NON_UPDATABLE
-                and self._action == "update"
-            ):
-                row.widget._set_pretty_display()
-
-        if self._action == "update" and self._device in self.dev:
-            self._fetch_config()
-            self._fill_form()
         self._container.addWidget(self._form_widget)
 
     def _add_overlay(self):
@@ -145,21 +97,12 @@ class DeviceConfigDialog(BECWidget, QDialog):
         self._container.addWidget(self._overlay_widget)
 
     def _add_buttons(self):
-        self.button_box = QDialogButtonBox(
-            QDialogButtonBox.Apply | QDialogButtonBox.Ok | QDialogButtonBox.Cancel
-        )
-        self.button_box.button(QDialogButtonBox.Apply).clicked.connect(self.apply)
+        self.button_box = QDialogButtonBox(_StdBtn.Apply | _StdBtn.Ok | _StdBtn.Cancel)
+        self.button_box.button(_StdBtn.Apply).clicked.connect(self.apply)
         self.button_box.accepted.connect(self.accept)
         self.button_box.rejected.connect(self.reject)
         self._layout.addWidget(self.button_box)
 
-    def _fetch_config(self):
-        if (
-            self.client.device_manager is not None
-            and self._device in self.client.device_manager.devices
-        ):
-            self._initial_config = self.client.device_manager.devices.get(self._device)._config
-
     def _fill_form(self):
         self._form.set_data(DeviceConfigModel.model_validate(self._initial_config))
 
@@ -190,12 +133,16 @@ class DeviceConfigDialog(BECWidget, QDialog):
     @SafeSlot(bool)
     def enable_buttons_for_validity(self, valid: bool):
         # TODO: replace when https://github.com/bec-project/bec/issues/528 https://github.com/bec-project/bec/issues/547 are resolved
-        for button in [
-            self.button_box.button(b) for b in [QDialogButtonBox.Apply, QDialogButtonBox.Ok]
-        ]:
+        for button in [self.button_box.button(b) for b in [_StdBtn.Apply, _StdBtn.Ok]]:
             button.setEnabled(valid)
             button.setToolTip(self._form._validity_message.text())
 
+    def _process_action(self):
+        self.accepted_data.emit(self._form.get_form_data())
+
+    def get_data(self):
+        return self._data
+
     @SafeSlot(popup_error=True)
     def apply(self):
         self._process_action()
@@ -206,10 +153,138 @@ class DeviceConfigDialog(BECWidget, QDialog):
         self._process_action()
         return super().accept()
 
+
+class EpicsMotorConfig(BaseModel):
+    prefix: str
+
+
+class EpicsSignalROConfig(BaseModel):
+    read_pv: str
+
+
+class EpicsSignalConfig(BaseModel):
+    read_pv: str
+    write_pv: str | None = None
+
+
+class PresetClassDeviceConfigDialog(DeviceConfigDialog):
+    def __init__(self, *, parent=None, **kwargs):
+        super().__init__(parent=parent, **kwargs)
+        self._device_models = {
+            "EpicsMotor": (EpicsMotorConfig, {"deviceClass": ("ophyd.EpicsMotor", False)}),
+            "EpicsSignalRO": (EpicsSignalROConfig, {"deviceClass": ("ophyd.EpicsSignalRO", False)}),
+            "EpicsSignal": (EpicsSignalConfig, {"deviceClass": ("ophyd.EpicsSignal", False)}),
+            "Custom": (None, {}),
+        }
+        self._create_selection_box()
+        self._selection_box.currentTextChanged.connect(self._replace_form)
+
+    def _apply_constraints(self, constraints: dict[str, tuple[DynamicFormItemType, bool]]):
+        for field_name, (value, editable) in constraints.items():
+            if (widget := self._form.widget_dict.get(field_name)) is not None:
+                widget.setValue(value)
+                if not editable:
+                    widget._set_pretty_display()
+
+    def _replace_form(self, deviceconfig_cls_key):
+        self._form.deleteLater()
+        if (devmodel_params := self._device_models.get(deviceconfig_cls_key)) is not None:
+            devmodel, params = devmodel_params
+        else:
+            devmodel, params = None, {}
+        self._form = DeviceConfigForm(class_deviceconfig_item=devmodel)
+        self._apply_constraints(params)
+        self._layout.insertWidget(1, self._form)
+        self._connect_form()
+
+    def _create_selection_box(self):
+        layout = QHBoxLayout()
+        self._selection_box = QComboBox()
+        self._selection_box.addItems(list(self._device_models.keys()))
+        layout.addWidget(QLabel("Choose a device class: "))
+        layout.addWidget(self._selection_box)
+        self._layout.insertLayout(0, layout)
+
+
+class DirectUpdateDeviceConfigDialog(BECWidget, DeviceConfigDialog):
+    def __init__(
+        self,
+        *,
+        parent=None,
+        device: str | None = None,
+        config_helper: ConfigHelper | None = None,
+        action: Literal["update"] | Literal["add"] = "update",
+        threadpool: QThreadPool | None = None,
+        **kwargs,
+    ):
+        """A dialog to edit the configuration of a device in BEC. Generated from the pydantic model
+        for device specification in bec_lib.atlas_models.
+
+        Args:
+            parent (QObject): the parent QObject
+            device (str | None): the name of the device. used with the "update" action to prefill the dialog and validate entries.
+            config_helper (ConfigHelper | None): a ConfigHelper object for communication with Redis, will be created if necessary.
+            action (Literal["update", "add"]): the action which the form should perform on application or acceptance.
+        """
+        self._device = device
+        self._q_threadpool = threadpool or QThreadPool()
+        self._config_helper = config_helper or ConfigHelper(
+            self.client.connector, self.client._service_name
+        )
+        super().__init__(parent=parent, **kwargs)
+        self.get_bec_shortcuts()
+        self._action: Literal["update", "add"] = action
+        user_warning = QLabel(
+            "Warning: edit items here at your own risk - minimal validation is applied to the entered values.\n"
+            "Items in the deviceConfig dictionary should correspond to python literals, e.g. numbers, lists, strings (including quotes), etc."
+        )
+        user_warning.setWordWrap(True)
+        user_warning.setStyleSheet("QLabel { color: red; }")
+        self._layout.insertWidget(0, user_warning)
+        self.setWindowTitle(
+            f"Edit config for: {device}" if action == "update" else "Add new device"
+        )
+
+        if self._action == "update":
+            self._modify_for_update()
+            self._form.validity_proc.disconnect(self.enable_buttons_for_validity)
+        else:
+            self._set_schema_to_check_devices()
+            # TODO: replace when https://github.com/bec-project/bec/issues/528 https://github.com/bec-project/bec/issues/547 are resolved
+            # self._form._validity.setVisible(True)
+
+    def _modify_for_update(self):
+        for row in self._form.enumerate_form_widgets():
+            if row.label.property("_model_field_name") in DEVICE_CONF_KEYS.NON_UPDATABLE:
+                row.widget._set_pretty_display()
+        if self._device in self.dev:
+            self._fetch_config()
+            self._fill_form()
+        self._form._validity.setVisible(False)
+
+    def _set_schema_to_check_devices(self):
+        class _NameValidatedConfigModel(DeviceConfigModel):
+            @field_validator("name")
+            @staticmethod
+            def _validate_name(value: str, *_):
+                if not value.isidentifier():
+                    raise ValueError(
+                        f"Invalid device name: {value}. Device names must be valid Python identifiers."
+                    )
+                if value in self.dev:
+                    raise ValueError(f"A device with name {value} already exists!")
+                return value
+
+        self._form.set_schema(_NameValidatedConfigModel)
+
+    def _fetch_config(self):
+        if self.dev is not None and (device := self.dev.get(self._device)) is not None:  # type: ignore
+            self._initial_config = device._config
+
     def _process_action(self):
         updated_config = self.updated_config()
         if self._action == "add":
-            if (name := updated_config.get("name")) in self.dev:
+            if self.dev is not None and (name := updated_config.get("name")) in self.dev:
                 raise ValueError(
                     f"Can't create a new device with the same name as already existing device {name}!"
                 )
@@ -249,12 +324,12 @@ class DeviceConfigDialog(BECWidget, QDialog):
     def _start_waiting_display(self):
         self._overlay_widget.setVisible(True)
         self._spinner.start()
-        QApplication.processEvents()
+        QApplication.processEvents()  # TODO check if this kills performance and scheduling!
 
     def _stop_waiting_display(self):
         self._overlay_widget.setVisible(False)
         self._spinner.stop()
-        QApplication.processEvents()
+        QApplication.processEvents()  # TODO check if this kills performance and scheduling!
 
 
 def main():  # pragma: no cover
@@ -262,17 +337,17 @@ 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())
+    widget.setLayout(layout := QVBoxLayout())
 
     device = QLineEdit()
-    widget.layout().addWidget(device)
+    layout.addWidget(device)
 
     def _destroy_dialog(*_):
         nonlocal dialog
@@ -285,14 +360,14 @@ def main():  # pragma: no cover
     def _show_dialog(*_):
         nonlocal dialog
         if dialog is None:
-            kwargs = {"device": dev} if (dev := device.text()) else {"action": "add"}
-            dialog = DeviceConfigDialog(**kwargs)
+            kwargs = {}  # kwargs = {"device": dev} if (dev := device.text()) else {"action": "add"}
+            dialog = PresetClassDeviceConfigDialog(**kwargs)  # type: ignore
             dialog.accepted.connect(accept)
             dialog.rejected.connect(_destroy_dialog)
             dialog.open()
 
     button = QPushButton("Show device dialog")
-    widget.layout().addWidget(button)
+    layout.addWidget(button)
     button.clicked.connect(_show_dialog)
     widget.show()
     sys.exit(app.exec_())

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

@@ -1,16 +1,20 @@
 from __future__ import annotations
 
+from functools import partial
+
 from bec_lib.atlas_models import Device as DeviceConfigModel
 from pydantic import BaseModel
 from qtpy.QtWidgets import QApplication
 
 from bec_widgets.utils.colors import get_theme_name
 from bec_widgets.utils.forms_from_types import styles
-from bec_widgets.utils.forms_from_types.forms import PydanticModelForm
+from bec_widgets.utils.forms_from_types.forms import PydanticModelForm, PydanticModelFormItem
 from bec_widgets.utils.forms_from_types.items import (
     DEFAULT_WIDGET_TYPES,
     BoolFormItem,
     BoolToggleFormItem,
+    DictFormItem,
+    FormItemSpec,
 )
 
 
@@ -18,7 +22,14 @@ class DeviceConfigForm(PydanticModelForm):
     RPC = False
     PLUGIN = False
 
-    def __init__(self, parent=None, client=None, pretty_display=False, **kwargs):
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        pretty_display=False,
+        class_deviceconfig_item: type[BaseModel] | None = None,
+        **kwargs,
+    ):
         super().__init__(
             parent=parent,
             data_model=DeviceConfigModel,
@@ -26,18 +37,28 @@ class DeviceConfigForm(PydanticModelForm):
             client=client,
             **kwargs,
         )
+        self._class_deviceconfig_item: type[BaseModel] | None = class_deviceconfig_item
         self._widget_types = DEFAULT_WIDGET_TYPES.copy()
         self._widget_types["bool"] = (lambda spec: spec.item_type is bool, BoolToggleFormItem)
         self._widget_types["optional_bool"] = (
             lambda spec: spec.item_type == bool | None,
             BoolFormItem,
         )
-        self._validity.setVisible(False)
+        pred, _ = self._widget_types["dict"]
+        self._widget_types["dict"] = pred, self._custom_device_config_item
+        self._validity.setVisible(True)
         self._connect_to_theme_change()
         self.populate()
 
     def _post_init(self): ...
 
+    def _custom_device_config_item(self, spec: FormItemSpec):
+        if spec.name != "deviceConfig":
+            return DictFormItem
+        if self._class_deviceconfig_item is not None:
+            return partial(PydanticModelFormItem, model=self._class_deviceconfig_item)
+        return DictFormItem
+
     def set_pretty_display_theme(self, theme: str | None = None):
         if theme is None:
             theme = get_theme_name()

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

@@ -18,7 +18,7 @@ from bec_widgets.widgets.services.device_browser.device_item.config_communicator
     CommunicateConfigAction,
 )
 from bec_widgets.widgets.services.device_browser.device_item.device_config_dialog import (
-    DeviceConfigDialog,
+    DirectUpdateDeviceConfigDialog,
 )
 from bec_widgets.widgets.services.device_browser.device_item.device_config_form import (
     DeviceConfigForm,
@@ -35,9 +35,6 @@ logger = bec_logger.logger
 
 
 class DeviceItem(ExpandableGroupFrame):
-    broadcast_size_hint = Signal(QSize)
-    imminent_deletion = Signal()
-
     RPC = False
 
     def __init__(
@@ -94,7 +91,7 @@ class DeviceItem(ExpandableGroupFrame):
 
     @SafeSlot()
     def _create_edit_dialog(self):
-        dialog = DeviceConfigDialog(
+        dialog = DirectUpdateDeviceConfigDialog(
             parent=self,
             device=self.device,
             config_helper=self._config_helper,

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_())