refactor: refactor device_manager_view

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

.github/workflows/pytest-matrix.yml

@@ -27,7 +27,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.11", "3.12", "3.13"]
+        python-version: ["3.10", "3.11", "3.12"]
 
     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,14 +2,10 @@ name: 'Close stale issues and PRs'
 on:
   schedule:
     - cron: '00 10 * * *'
-  workflow_dispatch:
 
 jobs:
   stale:
     runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
     steps:
       - uses: actions/stale@v9
         with:

.gitlab-ci.yml

@@ -0,0 +1,289 @@
+# 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.11
+py-version=3.10
 
 # When enabled, pylint would attempt to guess common misconfiguration and emit
 # user-friendly hints instead of false-positive error messages.

CHANGELOG.md

@@ -1,70 +1,6 @@
 # CHANGELOG
 
 
-## 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
-
-- Move thefuzz dependency to prod
-  ([`ad7cdc6`](https://github.com/bec-project/bec_widgets/commit/ad7cdc60dd6da6c5291f8b42932aacb12aa671a6))
-
-
 ## v2.38.0 (2025-08-19)
 
 ### Features

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.11%20%7C%203.12%20%7C%203.13-blue?logo=python&logoColor=white)](https://www.python.org)
+[![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)
 [![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/cli/client.py

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

bec_widgets/cli/server.py

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

bec_widgets/examples/bec_main_app/bec_main_app.py

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

bec_widgets/examples/device_manager_view/device_manager_view.py

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

bec_widgets/examples/device_manager_view/device_manager_widget.py

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

bec_widgets/examples/jupyter_console/jupyter_console_window.py

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

bec_widgets/utils/bec_connector.py

@@ -77,6 +77,8 @@ class BECConnector:
 
     USER_ACCESS = ["_config_dict", "_get_all_rpc", "_rpc_id"]
     EXIT_HANDLERS = {}
+    widget_removed = Signal()
+    name_established = Signal(str)
 
     def __init__(
         self,
@@ -204,6 +206,10 @@ class BECConnector:
         self._enforce_unique_sibling_name()
         # 2) Register the object for RPC
         self.rpc_register.add_rpc(self)
+        try:
+            self.name_established.emit(self.object_name)
+        except RuntimeError:
+            return
 
     def _enforce_unique_sibling_name(self):
         """
@@ -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.sendPostedEvents()
+        QApplication.processEvents()
         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__(
@@ -45,8 +45,7 @@ class BECWidget(BECConnector):
 
         >>> class MyWidget(BECWidget, QWidget):
         >>>     def __init__(self, parent=None, client=None, config=None, gui_id=None):
-        >>>         super().__init__(client=client, config=config, gui_id=gui_id)
-        >>>         QWidget.__init__(self, parent=parent)
+        >>>         super().__init__(parent=parent, client=client, config=config, gui_id=gui_id)
 
 
         Args:
@@ -62,15 +61,6 @@ class BECWidget(BECConnector):
         )
         if not isinstance(self, QObject):
             raise RuntimeError(f"{repr(self)} is not a subclass of QWidget")
-        app = QApplication.instance()
-        if not hasattr(app, "theme"):
-            # DO NOT SET THE THEME TO AUTO! Otherwise, the qwebengineview will segfault
-            # Instead, we will set the theme to the system setting on startup
-            if darkdetect.isDark():
-                set_theme("dark")
-            else:
-                set_theme("light")
-
         if theme_update:
             logger.debug(f"Subscribing to theme updates for {self.__class__.__name__}")
             self._connect_to_theme_change()
@@ -78,9 +68,11 @@ class BECWidget(BECConnector):
     def _connect_to_theme_change(self):
         """Connect to the theme change signal."""
         qapp = QApplication.instance()
-        if hasattr(qapp, "theme_signal"):
-            qapp.theme_signal.theme_updated.connect(self._update_theme)
+        if hasattr(qapp, "theme"):
+            SafeConnect(self, qapp.theme.theme_changed, self._update_theme)
 
+    @SafeSlot(str)
+    @SafeSlot()
     def _update_theme(self, theme: str | None = None):
         """Update the theme."""
         if theme is None:
@@ -124,6 +116,26 @@ class BECWidget(BECConnector):
         screenshot.save(file_name)
         logger.info(f"Screenshot saved to {file_name}")
 
+    def attach(self):
+        dock = WidgetHierarchy.find_ancestor(self, QtAds.CDockWidget)
+        if dock is None:
+            return
+
+        if not dock.isFloating():
+            return
+        dock.dockManager().addDockWidget(QtAds.DockWidgetArea.RightDockWidgetArea, dock)
+
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+        dock = WidgetHierarchy.find_ancestor(self, QtAds.CDockWidget)
+        if dock is None:
+            return
+        if dock.isFloating():
+            return
+        dock.setFloating()
+
     def cleanup(self):
         """Cleanup the widget."""
         with RPCRegister.delayed_broadcast():

bec_widgets/utils/colors.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import re
 from typing import TYPE_CHECKING, Literal
 
-import bec_qthemes
 import numpy as np
 import pyqtgraph as pg
-from bec_qthemes._os_appearance.listener import OSThemeSwitchListener
+from bec_qthemes import apply_theme as apply_theme_global
 from pydantic_core import PydanticCustomError
+from qtpy.QtCore import QEvent, QEventLoop
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QApplication
 
@@ -23,7 +23,10 @@ def get_theme_name():
 
 
 def get_theme_palette():
-    return bec_qthemes.load_palette(get_theme_name())
+    # FIXME this is legacy code, should be removed in the future
+    app = QApplication.instance()
+    palette = app.palette()
+    return palette
 
 
 def get_accent_colors() -> AccentColors | None:
@@ -36,105 +39,18 @@ def get_accent_colors() -> AccentColors | None:
     return QApplication.instance().theme.accent_colors
 
 
-def _theme_update_callback():
-    """
-    Internal callback function to update the theme based on the system theme.
-    """
-    app = QApplication.instance()
-    # pylint: disable=protected-access
-    app.theme.theme = app.os_listener._theme.lower()
-    app.theme_signal.theme_updated.emit(app.theme.theme)
-    apply_theme(app.os_listener._theme.lower())
-
-
-def set_theme(theme: Literal["dark", "light", "auto"]):
-    """
-    Set the theme for the application.
-
-    Args:
-        theme (Literal["dark", "light", "auto"]): The theme to set. "auto" will automatically switch between dark and light themes based on the system theme.
-    """
-    app = QApplication.instance()
-    bec_qthemes.setup_theme(theme, install_event_filter=False)
-
-    app.theme_signal.theme_updated.emit(theme)
-    apply_theme(theme)
-
-    if theme != "auto":
-        return
-
-    if not hasattr(app, "os_listener") or app.os_listener is None:
-        app.os_listener = OSThemeSwitchListener(_theme_update_callback)
-        app.installEventFilter(app.os_listener)
+def process_all_deferred_deletes(qapp):
+    qapp.sendPostedEvents(None, QEvent.DeferredDelete)
+    qapp.processEvents(QEventLoop.AllEvents)
 
 
 def apply_theme(theme: Literal["dark", "light"]):
     """
-    Apply the theme to all pyqtgraph widgets. Do not use this function directly. Use set_theme instead.
+    Apply the theme via the global theming API. This updates QSS, QPalette, and pyqtgraph globally.
     """
-    app = QApplication.instance()
-    graphic_layouts = [
-        child
-        for top in app.topLevelWidgets()
-        for child in top.findChildren(pg.GraphicsLayoutWidget)
-    ]
-
-    plot_items = [
-        item
-        for gl in graphic_layouts
-        for item in gl.ci.items.keys()  # ci is internal pg.GraphicsLayout that hosts all items
-        if isinstance(item, pg.PlotItem)
-    ]
-
-    histograms = [
-        item
-        for gl in graphic_layouts
-        for item in gl.ci.items.keys()  # ci is internal pg.GraphicsLayout that hosts all items
-        if isinstance(item, pg.HistogramLUTItem)
-    ]
-
-    # Update background color based on the theme
-    if theme == "light":
-        background_color = "#e9ecef"  # Subtle contrast for light mode
-        foreground_color = "#141414"
-        label_color = "#000000"
-        axis_color = "#666666"
-    else:
-        background_color = "#141414"  # Dark mode
-        foreground_color = "#e9ecef"
-        label_color = "#FFFFFF"
-        axis_color = "#CCCCCC"
-
-    # update GraphicsLayoutWidget
-    pg.setConfigOptions(foreground=foreground_color, background=background_color)
-    for pg_widget in graphic_layouts:
-        pg_widget.setBackground(background_color)
-
-    # update PlotItems
-    for plot_item in plot_items:
-        for axis in ["left", "right", "top", "bottom"]:
-            plot_item.getAxis(axis).setPen(pg.mkPen(color=axis_color))
-            plot_item.getAxis(axis).setTextPen(pg.mkPen(color=label_color))
-
-        # Change title color
-        plot_item.titleLabel.setText(plot_item.titleLabel.text, color=label_color)
-
-        # Change legend color
-        if hasattr(plot_item, "legend") and plot_item.legend is not None:
-            plot_item.legend.setLabelTextColor(label_color)
-            # if legend is in plot item and theme is changed, has to be like that because of pg opt logic
-            for sample, label in plot_item.legend.items:
-                label_text = label.text
-                label.setText(label_text, color=label_color)
-
-    # update HistogramLUTItem
-    for histogram in histograms:
-        histogram.axis.setPen(pg.mkPen(color=axis_color))
-        histogram.axis.setTextPen(pg.mkPen(color=label_color))
-
-    # now define stylesheet according to theme and apply it
-    style = bec_qthemes.load_stylesheet(theme)
-    app.setStyleSheet(style)
+    process_all_deferred_deletes(QApplication.instance())
+    apply_theme_global(theme)
+    process_all_deferred_deletes(QApplication.instance())
 
 
 class Colors:

bec_widgets/utils/compact_popup.py

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

bec_widgets/utils/crosshair.py

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

bec_widgets/utils/error_popups.py

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

bec_widgets/utils/forms_from_types/items.py

@@ -4,17 +4,7 @@ import typing
 from abc import abstractmethod
 from decimal import Decimal
 from types import GenericAlias, UnionType
-from typing import (
-    Callable,
-    Final,
-    Generic,
-    Iterable,
-    Literal,
-    NamedTuple,
-    OrderedDict,
-    TypeVar,
-    get_args,
-)
+from typing import Callable, Final, Iterable, Literal, NamedTuple, OrderedDict, get_args
 
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
@@ -360,13 +350,11 @@ class DictFormItem(DynamicFormItem):
         self._main_widget.replace_data(value)
 
 
-_IW = TypeVar("_IW", bound=int | float | str)
-
-
-class _ItemAndWidgetType(NamedTuple, Generic[_IW]):
-    item: type[_IW]
+class _ItemAndWidgetType(NamedTuple):
+    # TODO: this should be generic but not supported in 3.10
+    item: type[int | float | str]
     widget: type[QWidget]
-    default: _IW
+    default: int | float | str
 
 
 class ListFormItem(DynamicFormItem):

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,7 +1,6 @@
 from __future__ import annotations
 
 import functools
-import time
 import traceback
 import types
 from contextlib import contextmanager
@@ -230,8 +229,6 @@ 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

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

bec_widgets/utils/toolbars/toolbar.py

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

bec_widgets/utils/widget_io.py

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

bec_widgets/utils/widget_state_manager.py

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

bec_widgets/widgets/containers/advanced_dock_area/advanced_dock_area.py

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

bec_widgets/widgets/containers/advanced_dock_area/profile_utils.py

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

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

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

bec_widgets/widgets/containers/dock/dock_area.py

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

bec_widgets/widgets/containers/main_window/main_window.py

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bec_widgets/widgets/control/device_manager/components/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_resources.py

@@ -0,0 +1,87 @@
+from random import randint
+from typing import Any, Callable, Generator, Iterable, TypeVar
+
+from qtpy.QtCore import QSize
+from qtpy.QtWidgets import QListWidgetItem, 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.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.available_device_resources.device_tag_group import (
+    DeviceTagGroup,
+)
+
+_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
+
+
+class AvailableDeviceResources(BECWidget, QWidget, Ui_availableDeviceResources):
+    def __init__(self, parent=None, **kwargs):
+        super().__init__(parent=parent, **kwargs)
+        self.setupUi(self)
+        self._backend = get_backend()
+        self._items: dict[str, tuple[QListWidgetItem, DeviceTagGroup]] = {}
+        self.refresh_full_list()
+
+    def refresh_full_list(self):
+        self.tag_groups_list.clear()
+        self._items = {}
+        for tag_group, devices in self._backend.tag_groups.items():
+            self._add_tag_group(tag_group, devices)
+        self._add_tag_group("Untagged devices", self._backend.untagged_devices)
+
+    def _add_tag_group(self, tag_group: str, devices: set[HashableDevice]):
+        item = QListWidgetItem(self.tag_groups_list)
+        tag_group_widget = DeviceTagGroup(self.tag_groups_list, tag_group, devices)
+        self.tag_groups_list.setItemWidget(item, tag_group_widget)
+        self.tag_groups_list.addItem(item)
+        self._items[tag_group] = (item, tag_group_widget)
+        item.setSizeHint(QSize(tag_group_widget.width(), tag_group_widget.height()))
+
+    def _reset_devices_state(self):
+        for _, tag_group in self._items.values():
+            tag_group.reset_devices_state()
+
+    def set_devices_state(self, devices: Iterable[HashableDevice], included: bool):
+        for device in devices:
+            for _, tag_group in self._items.values():
+                tag_group.set_item_state(hash(device), included)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        for list_item, tag_group_widget in self._items.values():
+            list_item.setSizeHint(tag_group_widget.sizeHint())
+
+    @SafeSlot(list)
+    def update_devices_state(self, config_list: list[dict[str, Any]]):
+        self.set_devices_state(
+            _yield_only_passing(HashableDevice.model_validate, config_list), True
+        )
+
+
+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,27 @@
+from qtpy.QtCore import QMetaObject, Qt
+from qtpy.QtWidgets import QAbstractItemView, QListView, QListWidget, QVBoxLayout
+
+
+class Ui_availableDeviceResources(object):
+    def setupUi(self, availableDeviceResources):
+        if not availableDeviceResources.objectName():
+            availableDeviceResources.setObjectName("availableDeviceResources")
+        self.verticalLayout = QVBoxLayout(availableDeviceResources)
+        self.verticalLayout.setObjectName("verticalLayout")
+        self.tag_groups_list = QListWidget(availableDeviceResources)
+        self.tag_groups_list.setObjectName("tag_groups_list")
+        self.tag_groups_list.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
+        self.tag_groups_list.setVerticalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
+        self.tag_groups_list.setHorizontalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
+        self.tag_groups_list.setMovement(QListView.Movement.Static)
+        self.tag_groups_list.setSpacing(2)
+        self.tag_groups_list.setDragDropMode(QListWidget.DragDropMode.DragOnly)
+        self.tag_groups_list.setDragEnabled(True)
+        self.tag_groups_list.setAcceptDrops(False)
+        self.tag_groups_list.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        availableDeviceResources.setMinimumWidth(250)
+        availableDeviceResources.resize(250, availableDeviceResources.height())
+
+        self.verticalLayout.addWidget(self.tag_groups_list)
+
+        QMetaObject.connectSlotsByName(availableDeviceResources)

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

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import operator
+from functools import reduce
+from glob import glob
+from pathlib import Path
+from textwrap import dedent
+from typing import AbstractSet, Protocol
+
+from bec_lib.atlas_models import Device
+from bec_lib.bec_yaml_loader import yaml_load
+from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path
+from pydantic import model_validator
+
+
+class HashableDevice(Device):
+    source_files: set[str] = set()
+    names: set[str] = set()
+
+    @model_validator(mode="after")
+    def add_name(self) -> HashableDevice:
+        self.names.add(self.name)
+        return self
+
+    def as_normal_device(self):
+        return Device.model_validate(self)
+
+    def __hash__(self) -> int:
+        config_values = sorted(
+            (str(kv) for kv in self.deviceConfig.items()) if self.deviceConfig else []
+        )
+        return (reduce(operator.add, (self.name, self.deviceClass, *config_values))).__hash__()
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, self.__class__):
+            return False
+        if hash(self) == hash(value):
+            return True
+        return False
+
+    def rich_text(self) -> str:
+        return dedent(
+            f"""
+        <b><u><h2> {self.name}: </h2></u></b>
+        <table>
+        <tr><td> description: </td><td><i> {self.description}  </i></td></tr>
+        <tr><td> config:      </td><td><i> {self.deviceConfig} </i></td></tr>
+        <tr><td> enabled:     </td><td><i> {self.enabled}      </i></td></tr>
+        <tr><td> read only:   </td><td><i> {self.readOnly}     </i></td></tr>
+        </table>
+        """
+        )
+
+    def add_sources(self, other: HashableDevice):
+        self.source_files.update(other.source_files)
+
+    def add_tags(self, other: HashableDevice):
+        self.deviceTags.update(other.deviceTags)
+
+    def add_names(self, other: HashableDevice):
+        self.names.update(other.names)
+
+
+class _HashableDeviceSet(set):
+    def __or__(self, value: AbstractSet) -> _HashableDeviceSet:
+        for item in self:
+            if item in value:
+                for other_item in value:
+                    if other_item == item:
+                        item.add_sources(other_item)
+                        item.add_tags(other_item)
+                        item.add_names(other_item)
+        for other_item in value:
+            if other_item not in self:
+                self.add(other_item)
+        return self
+
+
+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."""
+        ...
+
+    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 _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_file() or self._get_configs_from_plugin_files(
+            Path(plugin_repo_path()) / plugin_package_name() / "device_configs/"
+        )
+        self._tag_groups = self._get_tag_groups()
+
+    def _get_config_from_backup_file(self):
+        return None
+        # return _devices_from_file(
+        #     "/home/perl_d/Development/bec/bec/logs/device_configs/recovery_configs/recovery_config_2025-08-22_14-02-29.yaml"
+        # )
+
+    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)))
+
+    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._tag_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()}
+
+    def tags(self) -> set[str]:
+        return reduce(operator.or_, (dev.deviceTags for dev in self._raw_device_set))
+
+    def tag_group(self, tag: str) -> set[HashableDevice]:
+        return self.tag_groups[tag]
+
+
+def get_backend() -> DeviceResourceBackend:
+    return _ConfigFileBackend()

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

@@ -0,0 +1,189 @@
+from typing import NamedTuple
+
+from bec_qthemes import material_icon
+from qtpy.QtCore import QSize
+from qtpy.QtWidgets import QFrame, QHBoxLayout, QLabel, QListWidgetItem, QVBoxLayout, QWidget
+
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.device_resource_backend import (
+    HashableDevice,
+)
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.device_tag_group_item_ui import (
+    Ui_DeviceTagGroup,
+)
+
+DEVICE_HASH_ROLE = 101
+
+
+def _warning_string(spec: HashableDevice):
+
+    names_str = "\n  ".join(spec.names)
+    msg = (
+        f"Device defined with multiple names! Please check:\n  {names_str}\n"
+        if len(spec.names) > 1
+        else ""
+    )
+
+    source_str = "\n  ".join(spec.source_files)
+    source_warning = (
+        f"Device found in multiple source files! Please check:\n  {source_str}"
+        if len(spec.source_files) > 1
+        else ""
+    )
+    return f"{msg}{source_warning}"
+
+
+class _DeviceEntryWidget(QFrame):
+    _grid_size = QSize(120, 80)
+
+    def __init__(self, device_spec: HashableDevice, parent=None, **kwargs):
+        super().__init__(parent, **kwargs)
+        self._device_spec = device_spec
+        self.included: bool = False
+
+        self.setFrameShape(QFrame.Shape.StyledPanel)
+        self.setFrameShadow(QFrame.Shadow.Raised)
+
+        self._layout = QVBoxLayout()
+        self._layout.setContentsMargins(5, 5, 5, 5)
+        self.setLayout(self._layout)
+        self.setMinimumSize(self._grid_size)
+
+        self.setup_title_layout(device_spec)
+        self.check_and_display_warning()
+
+        self.setToolTip(device_spec.rich_text())
+
+        self.details = QLabel(f"Tags:\n{', '.join(device_spec.deviceTags)}")
+        self.details.setStyleSheet("QLabel { font-size: 8pt; }")
+        self.details.setWordWrap(True)
+        self._layout.addWidget(self.details)
+
+    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._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 DeviceTagGroup(QWidget, Ui_DeviceTagGroup):
+    def __init__(
+        self, parent=None, name: str = "TagGroupTitle", data: set[HashableDevice] = set(), **kwargs
+    ):
+        super().__init__(parent=parent, **kwargs)
+        self.setupUi(self)
+        self.device_list.setGridSize(_DeviceEntryWidget._grid_size)
+        self.title.setText(name)
+        self._devices: dict[str, _DeviceEntry] = {}
+        for device in data:
+            self._add_item(device)
+        self.device_list.sortItems()
+        self._update_num_included()
+
+        self.add_to_composition_button.clicked.connect(self.test)
+
+    def _add_item(self, device: HashableDevice):
+        item = QListWidgetItem(self.device_list)
+        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 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 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 test(self, *args):
+        print(self.get_selection())
+
+    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 = DeviceTagGroup(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/device_tag_group_item_ui.py

@@ -0,0 +1,135 @@
+import math
+from functools import partial
+
+from bec_qthemes import material_icon
+from qtpy.QtCore import QMetaObject, QSize, Qt
+from qtpy.QtWidgets import (
+    QAbstractItemView,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QListView,
+    QListWidget,
+    QSizePolicy,
+    QSpacerItem,
+    QToolButton,
+    QVBoxLayout,
+)
+
+
+class AutoHeightListWidget(QListWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setViewMode(QListView.ViewMode.IconMode)
+        self.setResizeMode(QListView.ResizeMode.Adjust)
+        self.setWrapping(True)
+        self.setUniformItemSizes(True)
+        self.setMovement(QListView.Movement.Static)
+        self.setAcceptDrops(False)
+        self.setDragEnabled(True)
+        self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+        self.setSpacing(5)
+
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        self.setMinimumHeight(self._calcSize().height())
+        self.setMaximumHeight(self._calcSize().height())
+
+    def sizeHint(self):
+        return self._calcSize()
+
+    def minimumSizeHint(self):
+        return self._calcSize()
+
+    def _calcSize(self):
+        if self.count() == 0:
+            return super().sizeHint()
+
+        grid = self.gridSize()
+        if not grid.isValid():
+            grid = QSize(100, 100)  # fallback
+
+        items_per_row = max(1, self.viewport().width() // grid.width())
+        rows = math.ceil(self.count() / items_per_row)
+
+        height = rows * grid.height() + 2 * self.frameWidth()
+        return QSize(self.viewport().width(), height)
+
+
+class Ui_DeviceTagGroup(object):
+    def setupUi(self, DeviceTagGroup):
+        if not DeviceTagGroup.objectName():
+            DeviceTagGroup.setObjectName("DeviceTagGroup")
+        DeviceTagGroup.setMinimumWidth(150)
+        self.verticalLayout = QVBoxLayout(DeviceTagGroup)
+        self.verticalLayout.setObjectName("verticalLayout")
+        self.frame = QFrame(DeviceTagGroup)
+        self.frame.setObjectName("frame")
+        self.frame.setFrameShape(QFrame.Shape.StyledPanel)
+        self.frame.setFrameShadow(QFrame.Shadow.Raised)
+        self.verticalLayout_2 = QVBoxLayout(self.frame)
+        self.verticalLayout_2.setObjectName("verticalLayout_2")
+        self.horizontalLayout = QHBoxLayout()
+        self.horizontalLayout.setObjectName("horizontalLayout")
+
+        self.title = QLabel(self.frame)
+        self.title.setObjectName("title")
+        self.horizontalLayout.addWidget(self.title)
+
+        self.n_included = QLabel(self.frame, text="...")
+        self.n_included.setObjectName("n_included")
+        self.horizontalLayout.addWidget(self.n_included)
+
+        self.horizontalSpacer = QSpacerItem(
+            40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum
+        )
+        self.horizontalLayout.addItem(self.horizontalSpacer)
+
+        self.delete_tag_button = QToolButton(self.frame)
+        self.delete_tag_button.setObjectName("delete_tag_button")
+        self.horizontalLayout.addWidget(self.delete_tag_button)
+
+        self.remove_from_composition_button = QToolButton(self.frame)
+        self.remove_from_composition_button.setObjectName("remove_from_composition_button")
+        self.horizontalLayout.addWidget(self.remove_from_composition_button)
+
+        self.add_to_composition_button = QToolButton(self.frame)
+        self.add_to_composition_button.setObjectName("add_to_composition_button")
+        self.horizontalLayout.addWidget(self.add_to_composition_button)
+
+        self.remove_all_button = QToolButton(self.frame)
+        self.remove_all_button.setObjectName("remove_all_from_composition_button")
+        self.horizontalLayout.addWidget(self.remove_all_button)
+
+        self.add_all_button = QToolButton(self.frame)
+        self.add_all_button.setObjectName("add_all_to_composition_button")
+        self.horizontalLayout.addWidget(self.add_all_button)
+
+        self.verticalLayout_2.addLayout(self.horizontalLayout)
+
+        self.device_list = AutoHeightListWidget(self.frame)
+        self.device_list.setObjectName("device_list")
+
+        self.verticalLayout_2.addWidget(self.device_list)
+
+        self.verticalLayout.addWidget(self.frame)
+
+        self.set_icons()
+
+        QMetaObject.connectSlotsByName(DeviceTagGroup)
+
+    def set_icons(self):
+        icon = partial(material_icon, size=(15, 15), convert_to_pixmap=False)
+        self.delete_tag_button.setIcon(icon("delete"))
+        self.delete_tag_button.setToolTip("Delete tag group")
+        self.remove_from_composition_button.setIcon(icon("remove"))
+        self.remove_from_composition_button.setToolTip("Remove selected from composition")
+        self.add_to_composition_button.setIcon(icon("add"))
+        self.add_to_composition_button.setToolTip("Add selected to composition")
+        self.remove_all_button.setIcon(icon("chips"))
+        self.remove_all_button.setToolTip("Remove all with this tag from composition")
+        self.add_all_button.setIcon(icon("add_box"))
+        self.add_all_button.setToolTip("Add all with this tag to composition")

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

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

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

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

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

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

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

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

bec_widgets/widgets/control/scan_control/scan_control.py

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

bec_widgets/widgets/dap/dap_combo_box/dap_combo_box.py

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

bec_widgets/widgets/editors/dict_backed_table.py

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

bec_widgets/widgets/editors/monaco/monaco_widget.py

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

bec_widgets/widgets/editors/scan_metadata/scan_metadata.py

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

bec_widgets/widgets/editors/website/website.py

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

bec_widgets/widgets/games/minesweeper.py

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

bec_widgets/widgets/plots/heatmap/heatmap.py

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

bec_widgets/widgets/plots/image/image.py

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

bec_widgets/widgets/plots/motor_map/motor_map.py

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

bec_widgets/widgets/plots/multi_waveform/multi_waveform.py

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

bec_widgets/widgets/plots/plot_base.py

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

bec_widgets/widgets/plots/scatter_waveform/scatter_waveform.py

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

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

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

bec_widgets/widgets/plots/waveform/waveform.py

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

bec_widgets/widgets/progress/ring_progress_bar/ring.py

@@ -12,8 +12,8 @@ from bec_widgets.utils import BECConnector, ConnectionConfig
 
 
 class ProgressbarConnections(BaseModel):
-    slot: Literal["on_scan_progress", "on_device_readback", None] = None
-    endpoint: EndpointInfo | str | None = None
+    slot: Literal["on_scan_progress", "on_device_readback"] = None
+    endpoint: EndpointInfo | str = None
     model_config: dict = {"validate_assignment": True}
 
     @field_validator("endpoint")
@@ -222,10 +222,9 @@ class Ring(BECConnector, QObject):
             device(str): Device name for the device readback mode, only used when mode is "device"
         """
         if mode == "manual":
-            if self.config.connections.slot is not None:
-                self.bec_dispatcher.disconnect_slot(
-                    getattr(self, self.config.connections.slot), self.config.connections.endpoint
-                )
+            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,9 +22,13 @@ class RingProgressBarConfig(ConnectionConfig):
     color_map: Optional[str] = Field(
         "plasma", description="Color scheme for the progress bars.", validate_default=True
     )
-    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.")
+    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.")
     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."
@@ -92,6 +96,9 @@ class RingProgressBar(BECWidget, QWidget):
         "set_diameter",
         "reset_diameter",
         "enable_auto_updates",
+        "attach",
+        "detach",
+        "screenshot",
     ]
 
     def __init__(
@@ -238,7 +245,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 = None):
+    def set_precision(self, precision: int, bar_index: int = None):
         """
         Set the precision for the progress bars. If bar_index is not provide, the precision will be set for all progress bars.
 
@@ -267,9 +274,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, float)):
+        if isinstance(min_values, int) or isinstance(min_values, float):
             min_values = [min_values]
-        if isinstance(max_values, (int, float)):
+        if isinstance(max_values, int) or isinstance(max_values, float):
             max_values = [max_values]
         min_values = self._adjust_list_to_bars(min_values)
         max_values = self._adjust_list_to_bars(max_values)
@@ -437,10 +444,14 @@ class RingProgressBar(BECWidget, QWidget):
         Returns:
             Ring: Ring object.
         """
+        found_ring = None
         for ring in self._rings:
             if ring.config.index == index:
-                return ring
-        raise ValueError(f"Ring with index {index} not found.")
+                found_ring = ring
+                break
+        if found_ring is None:
+            raise ValueError(f"Ring with index {index} not found.")
+        return found_ring
 
     def enable_auto_updates(self, enable: bool = True):
         """
@@ -477,30 +488,29 @@ class RingProgressBar(BECWidget, QWidget):
         primary_queue = msg.get("queue").get("primary")
         info = primary_queue.get("info", None)
 
-        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
+        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.")
 
-        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.")
+                    # elif instruction_type == "device_progress":
+                    #     print("hook device_progress")
 
-    def _hook_scan_progress(self, ring_index: int | None = None):
+    def _hook_scan_progress(self, ring_index: int = None):
         """
         Hook the scan progress to the progress bars.
 
@@ -514,7 +524,8 @@ class RingProgressBar(BECWidget, QWidget):
 
         if ring.config.connections.slot == "on_scan_progress":
             return
-        ring.set_connections("on_scan_progress", MessageEndpoints.scan_progress())
+        else:
+            ring.set_connections("on_scan_progress", MessageEndpoints.scan_progress())
 
     def _hook_readback(self, bar_index: int, device: str, min: float | int, max: float | int):
         """
@@ -568,8 +579,6 @@ 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())
@@ -622,8 +631,9 @@ 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 = max(total_width * 2, 50)
-
+        diameter = total_width * 2
+        if diameter < 50:
+            diameter = 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

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

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

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

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

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

bec_widgets/widgets/utility/logpanel/logpanel.py

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

bec_widgets/widgets/utility/spinner/spinner.py

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

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

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

docs/api_reference/api_reference.md

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

docs/conf.py

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

docs/developer/introduction/concepts.md

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

docs/developer/introduction/contributing.md

@@ -8,7 +8,7 @@ Therefore, we recommend that you install BEC first following the [developer inst
 If you already have a BEC environment set up, you can install BEC Widgets in editable mode into your BEC Python environment.
 
 **Prerequisites**
-1. **Python Version:** BEC Widgets requires Python version 3.11 or higher. Verify your Python version to ensure compatibility.
+1. **Python Version:** BEC Widgets requires Python version 3.10 or higher. Verify your Python version to ensure compatibility.
 2. **BEC Installation:** BEC Widgets works in conjunction with BEC. While BEC is a dependency and will be installed automatically, you can find more information about BEC and its installation process in the [BEC documentation](https://beamline-experiment-control.readthedocs.io/en/latest/).
 3. **Qt Distributions:** BEC Widgets supports [PySide6](https://doc.qt.io/qtforpython-6/quickstart.html) and [PyQt6](https://www.riverbankcomputing.com/static/Docs/PyQt6/introduction.html). We use [qtpy](https://pypi.org/project/QtPy/) to abstract the underlying QT distribution.
 

docs/requirements.txt

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

docs/user/api_reference/api_reference.md

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

docs/user/getting_started/installation.md

@@ -4,7 +4,7 @@
 
 Before installing BEC Widgets, please ensure the following requirements are met:
 
-1. **Python Version:** BEC Widgets requires Python version 3.11 or higher. Verify your Python version to ensure compatibility.
+1. **Python Version:** BEC Widgets requires Python version 3.10 or higher. Verify your Python version to ensure compatibility.
 2. **BEC Installation:** BEC Widgets works in conjunction with BEC. While BEC is a dependency and will be installed automatically, you can find more information about BEC and its installation process in the [BEC documentation](https://beamline-experiment-control.readthedocs.io/en/latest/).
 
 **Standard Installation**

docs/user/getting_started/quick_start.md

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

docs/user/widgets/bec_progressbar/bec_progressbar.md

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

docs/user/widgets/bec_status_box/bec_status_box.md

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

docs/user/widgets/buttons_appearance/buttons_appearance.md

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

docs/user/widgets/buttons_queue/button_queue.md

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

docs/user/widgets/dap_combo_box/dap_combo_box.md

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

docs/user/widgets/device_browser/device_browser.md

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

docs/user/widgets/device_input/device_input.md

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

docs/user/widgets/dock_area/bec_dock_area.md

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

docs/user/widgets/heatmap/heatmap_widget.md

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