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/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,91 +1,6 @@
 # CHANGELOG
 
 
-## v2.39.0 (2025-09-24)
-
-### Bug Fixes
-
-- **rpc**: Fix hide/show
-  ([`975404f`](https://github.com/bec-project/bec_widgets/commit/975404f483ddae041d9f4d819f39c53cec191439))
-
-### Features
-
-- **rpc_base**: Windows can be raised to front from CLI
-  ([`565c0bd`](https://github.com/bec-project/bec_widgets/commit/565c0bd1e7f4684d8401b6a2827c35422b1125c4))
-
-
-## v2.38.4 (2025-09-23)
-
-### Bug Fixes
-
-- **image**: Add support for specifying preview signals through cli
-  ([`108ddae`](https://github.com/bec-project/bec_widgets/commit/108ddae6ca3501a57b499c7080a36cf41a653074))
-
-
-## v2.38.3 (2025-09-23)
-
-### Bug Fixes
-
-- **connector**: Only flush pending events
-  ([`475ca9f`](https://github.com/bec-project/bec_widgets/commit/475ca9f2d81bcc2bb0c7b104c0712b13d6616c08))
-
-- **ringprogressbar**: Fix client signature
-  ([`65bc5f5`](https://github.com/bec-project/bec_widgets/commit/65bc5f5421077da70ef5068d51e36119e1055955))
-
-- **ringprogressbar**: Various fixes and improvements
-  ([`bbb5fc6`](https://github.com/bec-project/bec_widgets/commit/bbb5fc6ce17248a948c6fd4a7652d17d64a79d2a))
-
-### Chores
-
-- Deprecate 3.10, add 3.13
-  ([`3e33934`](https://github.com/bec-project/bec_widgets/commit/3e339348dd3d0a3b12522312132fca139dc22835))
-
-### Testing
-
-- **ringprogressbar**: Extend e2e test
-  ([`b1b6c5e`](https://github.com/bec-project/bec_widgets/commit/b1b6c5e6a5dd81965baa5c742e9bdae8cdb4f09b))
-
-
-## v2.38.2 (2025-09-11)
-
-### Bug Fixes
-
-- **crosshair**: Ignore fetching data and markers from invisible items
-  ([`72b6f74`](https://github.com/bec-project/bec_widgets/commit/72b6f74252e1f36339945c549049b166cccf3561))
-
-- **plot_base**: Crosshair items are excluded from visible curves and from auto_range
-  ([`4dc4ede`](https://github.com/bec-project/bec_widgets/commit/4dc4ede1d251d081e5bcf3d37fcc784982c9258e))
-
-- **plot_base**: Visible items injected into plot item
-  ([`b703b37`](https://github.com/bec-project/bec_widgets/commit/b703b37bbdbf97182b58ac4c69c1384fa78d0c12))
-
-- **waveform**: Changing curve visibility refresh markers
-  ([`556832f`](https://github.com/bec-project/bec_widgets/commit/556832fd48bcb16b95df8cf91417d7045bbca2a3))
-
-### Continuous Integration
-
-- Fix stale issues job permissions; add workflow dispatch option
-  ([`fe67a4f`](https://github.com/bec-project/bec_widgets/commit/fe67a4f325cbd41f13102e5698d86ed9e90b048e))
-
-### Documentation
-
-- Move to autoapi
-  ([`18ef35f`](https://github.com/bec-project/bec_widgets/commit/18ef35f22a1b7496b13f833e63a4f3875e1497e3))
-
-### Testing
-
-- **crosshair**: Visibility test added with plotbase fixture
-  ([`3a2ec9f`](https://github.com/bec-project/bec_widgets/commit/3a2ec9f1b74c4bb5f239940b874576a877ce45c0))
-
-
-## v2.38.1 (2025-08-22)
-
-### Bug Fixes
-
-- 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/applications/main_app.py

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

bec_widgets/applications/navigation_centre/reveal_animator.py

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

bec_widgets/applications/navigation_centre/side_bar.py

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

bec_widgets/applications/navigation_centre/side_bar_components.py

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

bec_widgets/applications/views/view.py

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

bec_widgets/cli/client.py

@@ -27,6 +27,7 @@ class _WidgetsEnumType(str, enum.Enum):
 
 
 _Widgets = {
+    "AbortButton": "AbortButton",
     "BECDockArea": "BECDockArea",
     "BECMainWindow": "BECMainWindow",
     "BECProgressBar": "BECProgressBar",
@@ -49,6 +50,7 @@ _Widgets = {
     "PositionerBox2D": "PositionerBox2D",
     "PositionerControlLine": "PositionerControlLine",
     "PositionerGroup": "PositionerGroup",
+    "ResetButton": "ResetButton",
     "ResumeButton": "ResumeButton",
     "RingProgressBar": "RingProgressBar",
     "SBBMonitor": "SBBMonitor",
@@ -58,6 +60,7 @@ _Widgets = {
     "SignalComboBox": "SignalComboBox",
     "SignalLabel": "SignalLabel",
     "SignalLineEdit": "SignalLineEdit",
+    "StopButton": "StopButton",
     "TextBox": "TextBox",
     "VSCodeEditor": "VSCodeEditor",
     "Waveform": "Waveform",
@@ -94,6 +97,28 @@ except ImportError as e:
     logger.error(f"Failed loading plugins: \n{reduce(add, traceback.format_exception(e))}")
 
 
+class AbortButton(RPCBase):
+    """A button that abort the scan."""
+
+    @rpc_call
+    def remove(self):
+        """
+        Cleanup the BECConnector
+        """
+
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+
 class AdvancedDockArea(RPCBase):
     @rpc_call
     def new(
@@ -211,26 +236,6 @@ class AutoUpdates(RPCBase):
         """
 
 
-class AvailableDeviceResources(RPCBase):
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-    @rpc_call
-    def attach(self):
-        """
-        None
-        """
-
-    @rpc_call
-    def detach(self):
-        """
-        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
-        """
-
-
 class BECDock(RPCBase):
     @property
     @rpc_call
@@ -1095,48 +1100,6 @@ class Curve(RPCBase):
         """
 
 
-class DMConfigView(RPCBase):
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-    @rpc_call
-    def attach(self):
-        """
-        None
-        """
-
-    @rpc_call
-    def detach(self):
-        """
-        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
-        """
-
-
-class DMOphydTest(RPCBase):
-    """Widget to test device configurations using ophyd devices."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-    @rpc_call
-    def attach(self):
-        """
-        None
-        """
-
-    @rpc_call
-    def detach(self):
-        """
-        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
-        """
-
-
 class DapComboBox(RPCBase):
     """The DAPComboBox widget is an extension to the QComboBox with all avaialble DAP model from BEC."""
 
@@ -2451,7 +2414,7 @@ class Image(RPCBase):
         Set the image source and update the image.
 
         Args:
-            monitor(str|tuple|None): The name of the monitor to use for the image, or a tuple of (device, signal) for preview signals. If None or empty string, the current monitor will be disconnected.
+            monitor(str): The name of the monitor to use for the image.
             monitor_type(str): The type of monitor to use. Options are "1d", "2d", or "auto".
             color_map(str): The color map to use for the image.
             color_bar(str): The type of color bar to use. Options are "simple" or "full".
@@ -4027,6 +3990,28 @@ class RectangularROI(RPCBase):
         """
 
 
+class ResetButton(RPCBase):
+    """A button that resets the scan queue."""
+
+    @rpc_call
+    def remove(self):
+        """
+        Cleanup the BECConnector
+        """
+
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+
 class ResumeButton(RPCBase):
     """A button that continue scan queue."""
 
@@ -4213,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.
 
@@ -5002,6 +4987,28 @@ class SignalLineEdit(RPCBase):
         """
 
 
+class StopButton(RPCBase):
+    """A button that stops the current scan."""
+
+    @rpc_call
+    def remove(self):
+        """
+        Cleanup the BECConnector
+        """
+
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+
 class TextBox(RPCBase):
     """A widget that displays text in plain and HTML format"""
 

bec_widgets/cli/client_utils.py

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

bec_widgets/cli/rpc/rpc_base.py

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

bec_widgets/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

@@ -1,19 +1,17 @@
 from __future__ import annotations
 
 import os
-from functools import partial
-from typing import List
+from typing import TYPE_CHECKING, List
 
 import PySide6QtAds as QtAds
 import yaml
-from bec_lib import config_helper
 from bec_lib.bec_yaml_loader import yaml_load
 from bec_lib.file_utils import DeviceConfigWriter
 from bec_lib.logger import bec_logger
 from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path
 from bec_qthemes import apply_theme
 from PySide6QtAds import CDockManager, CDockWidget
-from qtpy.QtCore import Qt, QThreadPool, QTimer
+from qtpy.QtCore import Qt, QTimer
 from qtpy.QtWidgets import QFileDialog, QMessageBox, QSplitter, QVBoxLayout, QWidget
 
 from bec_widgets import BECWidget
@@ -21,31 +19,22 @@ 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._util import SharedSelectionSignal
 from bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_resources import (
     AvailableDeviceResources,
 )
-from bec_widgets.widgets.services.device_browser.device_item.config_communicator import (
-    CommunicateConfigAction,
-)
-from bec_widgets.widgets.services.device_browser.device_item.device_config_dialog import (
-    PresetClassDeviceConfigDialog,
-)
+
+if TYPE_CHECKING:
+    from bec_lib.client import BECClient
 
 logger = bec_logger.logger
 
-_yes_no_question = partial(
-    QMessageBox.question,
-    buttons=QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
-    defaultButton=QMessageBox.StandardButton.No,
-)
-
 
 def set_splitter_weights(splitter: QSplitter, weights: List[float]) -> None:
     """
@@ -64,9 +53,7 @@ def set_splitter_weights(splitter: QSplitter, weights: List[float]) -> None:
             w = [1.0] * n
             tot_w = float(n)
         total_px = (
-            splitter.width()
-            if splitter.orientation() == Qt.Orientation.Horizontal
-            else splitter.height()
+            splitter.width() if splitter.orientation() == Qt.Horizontal else splitter.height()
         )
         if total_px < 2:
             QTimer.singleShot(0, apply)
@@ -88,46 +75,36 @@ class DeviceManagerView(BECWidget, QWidget):
     def __init__(self, parent=None, *args, **kwargs):
         super().__init__(parent=parent, client=None, *args, **kwargs)
 
-        self._config_helper = config_helper.ConfigHelper(self.client.connector)
-        self._shared_selection = SharedSelectionSignal()
-
         # Top-level layout hosting a toolbar and the dock manager
         self._root_layout = QVBoxLayout(self)
         self._root_layout.setContentsMargins(0, 0, 0, 0)
         self._root_layout.setSpacing(0)
         self.dock_manager = CDockManager(self)
-        self.dock_manager.setStyleSheet("")
         self._root_layout.addWidget(self.dock_manager)
 
         # Available Resources Widget
-        self.available_devices = AvailableDeviceResources(
-            self, shared_selection_signal=self._shared_selection
-        )
-        self.available_devices_dock = QtAds.CDockWidget(
-            self.dock_manager, "Available Devices", self
-        )
+        self.available_devices = 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, shared_selection_signal=self._shared_selection
-        )
-        self.device_table_view_dock = QtAds.CDockWidget(self.dock_manager, "Device Table", self)
+        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(self.dock_manager, "Device Config View", 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(self.dock_manager, "Docstring View", 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(self.dock_manager, "Ophyd Test View", 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
@@ -170,37 +147,12 @@ class DeviceManagerView(BECWidget, QWidget):
         # self.set_default_view([2, 8, 2], [2, 2, 4])
 
         # Connect slots
-        for signal, slots in [
-            (
-                self.device_table_view.selected_devices,
-                (self.dm_config_view.on_select_config, self.dm_docs_view.on_select_config),
-            ),
-            (
-                self.available_devices.selected_devices,
-                (self.dm_config_view.on_select_config, self.dm_docs_view.on_select_config),
-            ),
-            (
-                self.ophyd_test_view.device_validated,
-                (self.device_table_view.update_device_validation,),
-            ),
-            (
-                self.device_table_view.device_configs_changed,
-                (
-                    self.ophyd_test_view.change_device_configs,
-                    self.available_devices.mark_devices_used,
-                ),
-            ),
-            (
-                self.available_devices.add_selected_devices,
-                (self.device_table_view.add_device_configs,),
-            ),
-            (
-                self.available_devices.del_selected_devices,
-                (self.device_table_view.remove_device_configs,),
-            ),
-        ]:
-            for slot in slots:
-                signal.connect(slot)
+        self.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()
 
@@ -217,11 +169,11 @@ class DeviceManagerView(BECWidget, QWidget):
         # 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",
-            label_text="Load Config",
+            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)
@@ -229,21 +181,15 @@ class DeviceManagerView(BECWidget, QWidget):
 
         # Add safe to disk
         safe_to_disk = MaterialIconAction(
-            icon_name="file_save",
-            parent=self,
-            tooltip="Save config to disk",
-            label_text="Save Config",
+            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._save_to_disk_action)
+        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",
-            label_text="Reload Config",
+            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)
@@ -251,64 +197,48 @@ class DeviceManagerView(BECWidget, QWidget):
 
         # Update config action
         update_config_redis = MaterialIconAction(
-            icon_name="cloud_upload",
-            parent=self,
-            tooltip="Update current config in Redis",
-            label_text="Update Config",
+            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")
 
-        # Add load config from plugin dir
-        self.toolbar.add_bundle(io_bundle)
-
     # Table actions
 
     def _add_table_actions(self) -> None:
         table_bundle = ToolbarBundle("Table", self.toolbar.components)
 
+        # 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",
-            label_text="Reset Config",
+            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", label_text="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", label_text="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 with 'connect' on selected devices",
-            label_text="Rerun Validation",
+            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")
 
-        # Add load config from plugin dir
-        self.toolbar.add_bundle(table_bundle)
-
         # Most likly, no actions on available devices
         # Actions (vielleicht bundle fuer available devices )
         # - reset composed view
@@ -317,14 +247,6 @@ class DeviceManagerView(BECWidget, QWidget):
         # - rerun validation (with/without connect)
 
     # IO actions
-    def _coming_soon(self):
-        return QMessageBox.question(
-            self,
-            "Not implemented yet",
-            "This feature has not been implemented yet, will be coming soon...!!",
-            QMessageBox.StandardButton.Cancel,
-            QMessageBox.StandardButton.Cancel,
-        )
 
     @SafeSlot()
     def _load_file_action(self):
@@ -348,7 +270,7 @@ class DeviceManagerView(BECWidget, QWidget):
         )
         if file_path:
             try:
-                config = [{"name": k, **v} for k, v in yaml_load(file_path).items()]
+                config = yaml_load(file_path)
             except Exception as e:
                 logger.error(f"Failed to load config from file {file_path}. Error: {e}")
                 return
@@ -360,46 +282,26 @@ class DeviceManagerView(BECWidget, QWidget):
     @SafeSlot()
     def _load_redis_action(self):
         """Action for the 'load_redis' action to load the current config from Redis for the io_bundle of the toolbar."""
-        reply = _yes_no_question(
+        reply = QMessageBox.question(
             self,
             "Load currently active config",
-            "Do you really want to discard the current config and reload?",
+            "Do you really want to flush the current config and reload?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No,
         )
-        if reply == QMessageBox.StandardButton.Yes and self.client.device_manager is not None:
-            self.device_table_view.set_device_config(
-                self.client.device_manager._get_redis_device_config()
-            )
+        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 _update_redis_action(self):
-        """Action to push the current composition to Redis"""
-        reply = _yes_no_question(
-            self,
-            "Push composition to Redis",
-            "Do you really want to replace the active configuration in the BEC server with the current composition? ",
-        )
-        if reply != QMessageBox.StandardButton.Yes:
-            return
-        if self.device_table_view.table.contains_invalid_devices():
-            return QMessageBox.warning(
-                self, "Validation has errors!", "Please resolve before proceeding."
-            )
-        if self.ophyd_test_view.validation_running():
-            return QMessageBox.warning(
-                self, "Validation has not completed.", "Please wait for the validation to finish."
-            )
-        self._push_compositiion_to_redis()
-
-    def _push_compositiion_to_redis(self):
-        config = {cfg.pop("name"): cfg for cfg in self.device_table_view.table.all_configs()}
-        threadpool = QThreadPool.globalInstance()
-        comm = CommunicateConfigAction(self._config_helper, None, config, "set")
-        threadpool.start(comm)
-
-    @SafeSlot()
-    def _save_to_disk_action(self):
+    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:
@@ -414,55 +316,82 @@ class DeviceManagerView(BECWidget, QWidget):
             self, caption="Save Config File", dir=config_path
         )
         if file_path:
-            config = {cfg.pop("name"): cfg for cfg in self.device_table_view.get_device_config()}
+            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 = _yes_no_question(
+        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.StandardButton.Yes:
+        if reply == QMessageBox.Yes:
             self.device_table_view.clear_device_configs()
 
-    # TODO We want to have a combobox to choose from EpicsMotor, EpicsMotorECMC, EpicsSignal, EpicsSignalRO, and maybe EpicsSignalWithRBV and custom Device
+    # 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
-        dialog = PresetClassDeviceConfigDialog(parent=self)
-        dialog.accepted_data.connect(self._add_to_table_from_dialog)
-        dialog.open()
-
-    @SafeSlot(dict)
-    def _add_to_table_from_dialog(self, data):
-        self.device_table_view.add_device_configs([data])
+        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."""
-        self.device_table_view.remove_selected_rows()
+        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."""
-        configs = self.device_table_view.table.selected_configs()
-        self.ophyd_test_view.change_device_configs(configs, True, True)
+        # 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
-    ):  # TODO separate logic for all ads based widgets
+    def set_default_view(self, horizontal_weights: list, vertical_weights: list):
         """Apply initial weights to every horizontal and vertical splitter.
 
         Examples:
@@ -472,9 +401,9 @@ class DeviceManagerView(BECWidget, QWidget):
         splitters_h = []
         splitters_v = []
         for splitter in self.findChildren(QSplitter):
-            if splitter.orientation() == Qt.Orientation.Horizontal:
+            if splitter.orientation() == Qt.Horizontal:
                 splitters_h.append(splitter)
-            elif splitter.orientation() == Qt.Orientation.Vertical:
+            elif splitter.orientation() == Qt.Vertical:
                 splitters_v.append(splitter)
 
         def apply_all():
@@ -485,9 +414,7 @@ class DeviceManagerView(BECWidget, QWidget):
 
         QTimer.singleShot(0, apply_all)
 
-    def set_stretch(
-        self, *, horizontal=None, vertical=None
-    ):  # TODO separate logic for all ads based widgets
+    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
@@ -528,7 +455,7 @@ class DeviceManagerView(BECWidget, QWidget):
     def _get_recovery_config_path(self) -> str:
         """Get the recovery config path from the log_writer config."""
         # pylint: disable=protected-access
-        log_writer_config = self.client._service_config.config.get("log_writer", {})
+        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()))
 
@@ -551,12 +478,12 @@ if __name__ == "__main__":
     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_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)
+    # 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)

bec_widgets/examples/device_manager_view/device_manager_widget.py

@@ -9,7 +9,7 @@ from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from qtpy import QtCore, QtWidgets
 
-from bec_widgets.applications.views.device_manager_view.device_manager_view import DeviceManagerView
+from bec_widgets.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
 
@@ -37,6 +37,9 @@ class DeviceManagerWidget(BECWidget, QtWidgets.QWidget):
         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)
@@ -85,34 +88,22 @@ class DeviceManagerWidget(BECWidget, QtWidgets.QWidget):
     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__":  # pragma: no cover
+if __name__ == "__main__":
     import sys
 
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
-    from bec_widgets.utils.colors import apply_theme
-
-    apply_theme("light")
-
-    widget = QtWidgets.QWidget()
-    layout = QtWidgets.QVBoxLayout(widget)
-    widget.setLayout(layout)
-    layout.setContentsMargins(0, 0, 0, 0)
-    layout.setSpacing(0)
     device_manager = DeviceManagerWidget()
     # config = device_manager.client.device_manager._get_redis_device_config()
     # device_manager.device_table_view.set_device_config(config)
-    layout.addWidget(device_manager)
-    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
-
-    dark_mode_button = DarkModeButton()
-    layout.addWidget(dark_mode_button)
-    widget.show()
+    device_manager.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

bec_widgets/utils/bec_connector.py

@@ -219,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:

bec_widgets/utils/bec_widget.py

@@ -36,8 +36,6 @@ class BECWidget(BECConnector):
         config: ConnectionConfig = None,
         gui_id: str | None = None,
         theme_update: bool = False,
-        start_busy: bool = False,
-        busy_text: str = "Loading…",
         parent_dock: BECDock | None = None,  # TODO should go away -> issue created #473
         **kwargs,
     ):
@@ -67,20 +65,6 @@ class BECWidget(BECConnector):
             logger.debug(f"Subscribing to theme updates for {self.__class__.__name__}")
             self._connect_to_theme_change()
 
-        # Initialize optional busy loader overlay utility (lazy by default)
-        self._busy_overlay = None
-        self._loading = False
-        if start_busy and isinstance(self, QWidget):
-            try:
-                overlay = self._ensure_busy_overlay(busy_text=busy_text)
-                if overlay is not None:
-                    overlay.setGeometry(self.rect())
-                    overlay.raise_()
-                    overlay.show()
-                    self._loading = True
-            except Exception as exc:
-                logger.debug(f"Busy loader init skipped: {exc}")
-
     def _connect_to_theme_change(self):
         """Connect to the theme change signal."""
         qapp = QApplication.instance()
@@ -97,77 +81,8 @@ class BECWidget(BECConnector):
                 theme = qapp.theme.theme
             else:
                 theme = "dark"
-        self._update_overlay_theme(theme)
         self.apply_theme(theme)
 
-    def _ensure_busy_overlay(self, *, busy_text: str = "Loading…"):
-        """Create the busy overlay on demand and cache it in _busy_overlay.
-        Returns the overlay instance or None if not a QWidget.
-        """
-        if not isinstance(self, QWidget):
-            return None
-        overlay = getattr(self, "_busy_overlay", None)
-        if overlay is None:
-            from bec_widgets.utils.busy_loader import install_busy_loader
-
-            overlay = install_busy_loader(self, text=busy_text, start_loading=False)
-            self._busy_overlay = overlay
-        return overlay
-
-    def _init_busy_loader(self, *, start_busy: bool = False, busy_text: str = "Loading…") -> None:
-        """Create and attach the loading overlay to this widget if QWidget is present."""
-        if not isinstance(self, QWidget):
-            return
-        self._ensure_busy_overlay(busy_text=busy_text)
-        if start_busy and self._busy_overlay is not None:
-            self._busy_overlay.setGeometry(self.rect())
-            self._busy_overlay.raise_()
-            self._busy_overlay.show()
-
-    def set_busy(self, enabled: bool, text: str | None = None) -> None:
-        """
-        Enable/disable the loading overlay. Optionally update the text.
-
-        Args:
-            enabled(bool): Whether to enable the loading overlay.
-            text(str, optional): The text to display on the overlay. If None, the text is not changed.
-        """
-        if not isinstance(self, QWidget):
-            return
-        if getattr(self, "_busy_overlay", None) is None:
-            self._ensure_busy_overlay(busy_text=text or "Loading…")
-        if text is not None:
-            self.set_busy_text(text)
-        if enabled:
-            self._busy_overlay.setGeometry(self.rect())
-            self._busy_overlay.raise_()
-            self._busy_overlay.show()
-        else:
-            self._busy_overlay.hide()
-        self._loading = bool(enabled)
-
-    def is_busy(self) -> bool:
-        """
-        Check if the loading overlay is enabled.
-
-        Returns:
-            bool: True if the loading overlay is enabled, False otherwise.
-        """
-        return bool(getattr(self, "_loading", False))
-
-    def set_busy_text(self, text: str) -> None:
-        """
-        Update the text on the loading overlay.
-
-        Args:
-            text(str): The text to display on the overlay.
-        """
-        overlay = getattr(self, "_busy_overlay", None)
-        if overlay is None:
-            overlay = self._ensure_busy_overlay(busy_text=text)
-        if overlay is not None:
-            overlay.set_text(text)
-
     @SafeSlot(str)
     def apply_theme(self, theme: str):
         """
@@ -177,22 +92,6 @@ class BECWidget(BECConnector):
             theme(str, optional): The theme to be applied.
         """
 
-    def _update_overlay_theme(self, theme: str):
-        try:
-            overlay = getattr(self, "_busy_overlay", None)
-            if overlay is not None and hasattr(overlay, "update_palette"):
-                overlay.update_palette()
-        except Exception:
-            logger.warning(f"Failed to apply theme {theme} to {self}")
-
-    def get_help_md(self) -> str:
-        """
-        Method to override in subclasses to provide help text in markdown format.
-
-        Returns:
-            str: The help text in markdown format.
-        """
-
     @SafeSlot()
     @SafeSlot(str)
     @rpc_timeout(None)
@@ -251,22 +150,6 @@ class BECWidget(BECConnector):
             child.close()
             child.deleteLater()
 
-        # Tear down busy overlay explicitly to stop spinner and remove filters
-        overlay = getattr(self, "_busy_overlay", None)
-        if overlay is not None and shiboken6.isValid(overlay):
-            try:
-                overlay.hide()
-                filt = getattr(overlay, "_filter", None)
-                if filt is not None and shiboken6.isValid(filt):
-                    try:
-                        self.removeEventFilter(filt)
-                    except Exception as exc:
-                        logger.warning(f"Failed to remove event filter from busy overlay: {exc}")
-                overlay.deleteLater()
-            except Exception as exc:
-                logger.warning(f"Failed to delete busy overlay: {exc}")
-        self._busy_overlay = None
-
     def closeEvent(self, event):
         """Wrap the close even to ensure the rpc_register is cleaned up."""
         try:

bec_widgets/utils/busy_loader.py

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

bec_widgets/utils/colors.py

@@ -1,17 +1,19 @@
 from __future__ import annotations
 
 import re
-from typing import Literal
+from typing import TYPE_CHECKING, Literal
 
 import numpy as np
 import pyqtgraph as pg
 from bec_qthemes import apply_theme as apply_theme_global
-from bec_qthemes._theme import AccentColors
 from pydantic_core import PydanticCustomError
 from qtpy.QtCore import QEvent, QEventLoop
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QApplication
 
+if TYPE_CHECKING:  # pragma: no cover
+    from bec_qthemes._main import AccentColors
+
 
 def get_theme_name():
     if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
@@ -27,14 +29,13 @@ def get_theme_palette():
     return palette
 
 
-def get_accent_colors() -> AccentColors:
+def get_accent_colors() -> AccentColors | None:
     """
     Get the accent colors for the current theme. These colors are extensions of the color palette
     and are used to highlight specific elements in the UI.
     """
     if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
-        accent_colors = AccentColors()
-        return accent_colors
+        return None
     return QApplication.instance().theme.accent_colors
 
 

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

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

bec_widgets/utils/forms_from_types/forms.py

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

bec_widgets/utils/forms_from_types/items.py

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

bec_widgets/utils/help_inspector/help_inspector.py

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

bec_widgets/utils/list_of_expandable_frames.py

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

bec_widgets/utils/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/toolbars/actions.py

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

bec_widgets/widgets/containers/advanced_dock_area/advanced_dock_area.py

@@ -25,7 +25,6 @@ from shiboken6 import isValid
 from bec_widgets import BECWidget, SafeProperty, SafeSlot
 from bec_widgets.cli.rpc.rpc_widget_handler import widget_handler
 from bec_widgets.utils import BECDispatcher
-from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.property_editor import PropertyEditor
 from bec_widgets.utils.toolbars.actions import (
     ExpandableMenuAction,
@@ -902,7 +901,6 @@ if __name__ == "__main__":
     import sys
 
     app = QApplication(sys.argv)
-    apply_theme("dark")
     dispatcher = BECDispatcher(gui_id="ads")
     window = BECMainWindowNoRPC()
     ads = AdvancedDockArea(mode="developer", root_widget=True)

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

@@ -11,7 +11,7 @@ class AbortButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "cancel"
-    RPC = False
+    RPC = True
 
     def __init__(
         self,

bec_widgets/widgets/control/buttons/button_reset/button_reset.py

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,34 +1,79 @@
 from __future__ import annotations
 
 import operator
-import os
-from enum import Enum, auto
-from functools import partial, reduce
+from functools import reduce
 from glob import glob
 from pathlib import Path
-from typing import Protocol
+from textwrap import dedent
+from typing import AbstractSet, Protocol
 
-import bec_lib
-from bec_lib.atlas_models import HashableDevice, HashableDeviceSet
+from bec_lib.atlas_models import Device
 from bec_lib.bec_yaml_loader import yaml_load
-from bec_lib.logger import bec_logger
-from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path, plugins_installed
-
-logger = bec_logger.logger
-
-# use the last n recovery files
-_N_RECOVERY_FILES = 3
-_BASE_REPO_PATH = Path(os.path.dirname(bec_lib.__file__)) / "../.."
+from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path
+from pydantic import model_validator
 
 
-def get_backend() -> DeviceResourceBackend:
-    return _ConfigFileBackend()
+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 HashModel(str, Enum):
-    DEFAULT = auto()
-    DEFAULT_DEVICECONFIG = auto()
-    DEFAULT_EPICS = auto()
+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):
@@ -48,11 +93,6 @@ class DeviceResourceBackend(Protocol):
         """A set of all untagged devices. The same device may not appear more than once."""
         ...
 
-    @property
-    def allowed_sort_keys(self) -> set[str]:
-        """A set of all fields which you may group devices by"""
-        ...
-
     def tags(self) -> set[str]:
         """Returns a set of all the tags in all available devices."""
         ...
@@ -61,15 +101,10 @@ class DeviceResourceBackend(Protocol):
         """Returns a set of the devices in the tag group with the given key."""
         ...
 
-    def group_by_key(self, key: str) -> dict[str, set[HashableDevice]]:
-        """Return a dict of all devices, organised by the specified key, which must be one of
-        the string keys in the Device model."""
-        ...
-
 
 def _devices_from_file(file: str, include_source: bool = True):
     data = yaml_load(file, process_includes=False)
-    return HashableDeviceSet(
+    return _HashableDeviceSet(
         HashableDevice.model_validate(
             dev | {"name": name, "source_files": {file} if include_source else set()}
         )
@@ -79,31 +114,22 @@ def _devices_from_file(file: str, include_source: bool = True):
 
 class _ConfigFileBackend(DeviceResourceBackend):
     def __init__(self) -> None:
-        self._raw_device_set: set[HashableDevice] = self._get_config_from_backup_files()
-        if plugins_installed() == 1:
-            self._raw_device_set.update(
-                self._get_configs_from_plugin_files(
-                    Path(plugin_repo_path()) / plugin_package_name() / "device_configs/"
-                )
-            )
-        self._device_groups = self._get_tag_groups()
-
-    def _get_config_from_backup_files(self):
-        dir = _BASE_REPO_PATH / "logs/device_configs/recovery_configs"
-        files = sorted(glob("*.yaml", root_dir=dir))
-        last_n_files = files[-_N_RECOVERY_FILES:]
-        return reduce(
-            operator.or_,
-            map(
-                partial(_devices_from_file, include_source=False),
-                (str(dir / f) for f in last_n_files),
-            ),
-            set(),
+        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)), set())
+        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 {
@@ -113,7 +139,7 @@ class _ConfigFileBackend(DeviceResourceBackend):
 
     @property
     def tag_groups(self):
-        return self._device_groups
+        return self._tag_groups
 
     @property
     def all_devices(self):
@@ -123,18 +149,12 @@ class _ConfigFileBackend(DeviceResourceBackend):
     def untagged_devices(self):
         return {d for d in self._raw_device_set if d.deviceTags == set()}
 
-    @property
-    def allowed_sort_keys(self) -> set[str]:
-        return {n for n, info in HashableDevice.model_fields.items() if info.annotation is str}
-
     def tags(self) -> set[str]:
-        return reduce(operator.or_, (dev.deviceTags for dev in self._raw_device_set), set())
+        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 group_by_key(self, key: str) -> dict[str, set[HashableDevice]]:
-        if key not in self.allowed_sort_keys:
-            raise ValueError(f"Cannot group available devices by model key {key}")
-        group_names: set[str] = {getattr(item, key) for item in self._raw_device_set}
-        return {g: {d for d in self._raw_device_set if getattr(d, key) == g} for g in group_names}
+
+def get_backend() -> DeviceResourceBackend:
+    return _ConfigFileBackend()

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

@@ -1,67 +1,62 @@
-from textwrap import dedent
 from typing import NamedTuple
-from uuid import uuid4
 
 from bec_qthemes import material_icon
-from qtpy.QtCore import QItemSelection, QSize, Signal
+from qtpy.QtCore import QSize
 from qtpy.QtWidgets import QFrame, QHBoxLayout, QLabel, QListWidgetItem, QVBoxLayout, QWidget
 
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.expandable_frame import ExpandableGroupFrame
-from bec_widgets.widgets.control.device_manager.components._util import SharedSelectionSignal
-from bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_group_ui import (
-    Ui_AvailableDeviceGroup,
-)
 from bec_widgets.widgets.control.device_manager.components.available_device_resources.device_resource_backend import (
     HashableDevice,
 )
-from bec_widgets.widgets.control.device_manager.components.constants import CONFIG_DATA_ROLE
+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):
-    name_warning = (
-        "Device defined with multiple names! Please check:\n  " + "\n  ".join(spec.names)
+
+    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 = (
-        "Device found in multiple source files! Please check:\n  " + "\n  ".join(spec._source_files)
-        if len(spec._source_files) > 1
+        f"Device found in multiple source files! Please check:\n  {source_str}"
+        if len(spec.source_files) > 1
         else ""
     )
-    return f"{name_warning}{source_warning}"
+    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.setFrameStyle(0)
+        self.setFrameShape(QFrame.Shape.StyledPanel)
+        self.setFrameShadow(QFrame.Shadow.Raised)
 
         self._layout = QVBoxLayout()
-        self._layout.setContentsMargins(2, 2, 2, 2)
+        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(self._rich_text())
+        self.setToolTip(device_spec.rich_text())
 
-    def _rich_text(self):
-        return dedent(
-            f"""
-        <b><u><h2> {self._device_spec.name}: </h2></u></b>
-        <table>
-        <tr><td> description: </td><td><i> {self._device_spec.description}  </i></td></tr>
-        <tr><td> config:      </td><td><i> {self._device_spec.deviceConfig} </i></td></tr>
-        <tr><td> enabled:     </td><td><i> {self._device_spec.enabled}      </i></td></tr>
-        <tr><td> read only:   </td><td><i> {self._device_spec.readOnly}     </i></td></tr>
-        </table>
-        """
-        )
+        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()
@@ -77,11 +72,10 @@ class _DeviceEntryWidget(QFrame):
         self.title.setStyleSheet(self.title_style("#FF0000"))
         self._title_layout.addWidget(self.title)
 
-        self._title_layout.addStretch(1)
         self._layout.addWidget(self._title_container)
 
     def check_and_display_warning(self):
-        if len(self._device_spec.names) == 1 and len(self._device_spec._source_files) == 1:
+        if len(self._device_spec.names) == 1 and len(self._device_spec.source_files) == 1:
             self._warning_label.setText("")
             self._warning_label.setToolTip("")
         else:
@@ -108,49 +102,30 @@ class _DeviceEntry(NamedTuple):
     widget: _DeviceEntryWidget
 
 
-class AvailableDeviceGroup(ExpandableGroupFrame, Ui_AvailableDeviceGroup):
-
-    selected_devices = Signal(list)
-
+class DeviceTagGroup(QWidget, Ui_DeviceTagGroup):
     def __init__(
-        self,
-        parent=None,
-        name: str = "TagGroupTitle",
-        data: set[HashableDevice] = set(),
-        shared_selection_signal=SharedSelectionSignal(),
-        **kwargs,
+        self, parent=None, name: str = "TagGroupTitle", data: set[HashableDevice] = set(), **kwargs
     ):
         super().__init__(parent=parent, **kwargs)
         self.setupUi(self)
-
-        self._shared_selection_signal = shared_selection_signal
-        self._shared_selection_uuid = str(uuid4())
-        self._shared_selection_signal.proc.connect(self._handle_shared_selection_signal)
-        self.device_list.selectionModel().selectionChanged.connect(self._on_selection_changed)
-
-        self.title_text = name  # type: ignore
-        self._mime_data = []
+        self.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.setMinimumSize(self.device_list.sizeHint())
         self._update_num_included()
 
+        self.add_to_composition_button.clicked.connect(self.test)
+
     def _add_item(self, device: HashableDevice):
         item = QListWidgetItem(self.device_list)
-        device_dump = device.model_dump(exclude_defaults=True)
-        item.setData(CONFIG_DATA_ROLE, device_dump)
-        self._mime_data.append(device_dump)
         widget = _DeviceEntryWidget(device, self)
         item.setSizeHint(QSize(widget.width(), widget.height()))
         self.device_list.setItemWidget(item, widget)
         self.device_list.addItem(item)
         self._devices[device.name] = _DeviceEntry(item, widget)
 
-    def create_mime_data(self):
-        return self._mime_data
-
     def reset_devices_state(self):
         for dev in self._devices.values():
             dev.widget.set_included(False)
@@ -173,25 +148,6 @@ class AvailableDeviceGroup(ExpandableGroupFrame, Ui_AvailableDeviceGroup):
         self.n_included.setText(f"{n_included} / {len(self._devices)}")
         self.n_included.setStyleSheet(f"QLabel {{ color: {color}; }}")
 
-    def sizeHint(self) -> QSize:
-        if not getattr(self, "device_list", None) or not self.expanded:
-            return super().sizeHint()
-        return QSize(
-            max(150, self.device_list.viewport().width()),
-            self.device_list.sizeHintForRow(0) * self.device_list.count() + 50,
-        )
-
-    @SafeSlot(QItemSelection, QItemSelection)
-    def _on_selection_changed(self, selected: QItemSelection, deselected: QItemSelection) -> None:
-        self._shared_selection_signal.proc.emit(self._shared_selection_uuid)
-        config = [dev.as_normal_device().model_dump() for dev in self.get_selection()]
-        self.selected_devices.emit(config)
-
-    @SafeSlot(str)
-    def _handle_shared_selection_signal(self, uuid: str):
-        if uuid != self._shared_selection_uuid:
-            self.device_list.clearSelection()
-
     def resizeEvent(self, event):
         super().resizeEvent(event)
         self.setMinimumHeight(self.sizeHint().height())
@@ -202,8 +158,11 @@ class AvailableDeviceGroup(ExpandableGroupFrame, Ui_AvailableDeviceGroup):
         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}"
+        return f"{self.__class__.__name__}: {self.title.text()}"
 
 
 if __name__ == "__main__":
@@ -212,7 +171,7 @@ if __name__ == "__main__":
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
-    widget = AvailableDeviceGroup(name="Tag group 1")
+    widget = DeviceTagGroup(name="Tag group 1")
     for item in [
         HashableDevice(
             **{

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

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

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

@@ -3,47 +3,31 @@
 from __future__ import annotations
 
 import copy
-import json
-from contextlib import contextmanager
-from functools import partial
-from typing import TYPE_CHECKING, Any, Iterable, List
-from uuid import uuid4
+import time
 
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from qtpy import QtCore, QtGui, QtWidgets
-from qtpy.QtCore import QModelIndex, QPersistentModelIndex, Qt, QTimer
-from qtpy.QtWidgets import QAbstractItemView, QHeaderView, QMessageBox
 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._util import SharedSelectionSignal
-from bec_widgets.widgets.control.device_manager.components.constants import MIME_DEVICE_CONFIG
 from bec_widgets.widgets.control.device_manager.components.dm_ophyd_test import ValidationStatus
 
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_qthemes._theme import AccentColors
-
 logger = bec_logger.logger
 
-_DeviceCfgIter = Iterable[dict[str, Any]]
-
 # Threshold for fuzzy matching, careful with adjusting this. 80 seems good
 FUZZY_SEARCH_THRESHOLD = 80
 
-#
-USER_CHECK_DATA_ROLE = 101
-
 
 class DictToolTipDelegate(QtWidgets.QStyledItemDelegate):
     """Delegate that shows all key-value pairs of a rows's data as a YAML-like tooltip."""
 
     def helpEvent(self, event, view, option, index):
         """Override to show tooltip when hovering."""
-        if event.type() != QtCore.QEvent.Type.ToolTip:
+        if event.type() != QtCore.QEvent.ToolTip:
             return super().helpEvent(event, view, option, index)
         model: DeviceFilterProxyModel = index.model()
         model_index = model.mapToSource(index)
@@ -53,72 +37,66 @@ class DictToolTipDelegate(QtWidgets.QStyledItemDelegate):
         return True
 
 
-class CustomDisplayDelegate(DictToolTipDelegate):
-    _paint_test_role = Qt.ItemDataRole.DisplayRole
-
-    def displayText(self, value: Any, locale: QtCore.QLocale | QtCore.QLocale.Language) -> str:
-        return ""
-
-    def _test_custom_paint(self, painter, option, index):
-        v = index.model().data(index, self._paint_test_role)
-        return (v is not None), v
-
-    def _do_custom_paint(self, painter, option, index, value): ...
-
-    def paint(self, painter, option, index) -> None:
-        (check, value) = self._test_custom_paint(painter, option, index)
-        if not check:
-            return super().paint(painter, option, index)
-        super().paint(painter, option, index)
-        painter.save()
-        self._do_custom_paint(painter, option, index, value)
-        painter.restore()
-
-
-class CenterCheckBoxDelegate(CustomDisplayDelegate):
+class CenterCheckBoxDelegate(DictToolTipDelegate):
     """Custom checkbox delegate to center checkboxes in table cells."""
 
-    _paint_test_role = USER_CHECK_DATA_ROLE
-
     def __init__(self, parent=None, colors=None):
         super().__init__(parent)
-        colors: AccentColors = colors if colors else get_accent_colors()  # type: ignore
-        _icon = partial(material_icon, size=(16, 16), color=colors.default, filled=True)
-        self._icon_checked = _icon("check_box")
-        self._icon_unchecked = _icon("check_box_outline_blank")
+        self._colors = colors if colors else get_accent_colors()
+        self._icon_checked = material_icon(
+            "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=self._colors.default,
+            filled=True,
+        )
 
     def apply_theme(self, theme: str | None = None):
         colors = get_accent_colors()
         self._icon_checked.setColor(colors.default)
         self._icon_unchecked.setColor(colors.default)
 
-    def _do_custom_paint(self, painter, option, index, value):
-        pixmap = self._icon_checked if value == Qt.CheckState.Checked else self._icon_unchecked
+    def paint(self, painter, option, index):
+        value = index.model().data(index, QtCore.Qt.CheckStateRole)
+        if value is None:
+            super().paint(painter, option, index)
+            return
+
+        # Choose icon based on state
+        pixmap = self._icon_checked if value == QtCore.Qt.Checked else self._icon_unchecked
+
+        # Draw icon centered
+        rect = option.rect
         pix_rect = pixmap.rect()
-        pix_rect.moveCenter(option.rect.center())
+        pix_rect.moveCenter(rect.center())
         painter.drawPixmap(pix_rect.topLeft(), pixmap)
 
     def editorEvent(self, event, model, option, index):
-        if event.type() != QtCore.QEvent.Type.MouseButtonRelease:
+        if event.type() != QtCore.QEvent.MouseButtonRelease:
             return False
-        current = model.data(index, USER_CHECK_DATA_ROLE)
-        new_state = (
-            Qt.CheckState.Unchecked if current == Qt.CheckState.Checked else Qt.CheckState.Checked
-        )
-        return model.setData(index, new_state, USER_CHECK_DATA_ROLE)
+        current = model.data(index, QtCore.Qt.CheckStateRole)
+        new_state = QtCore.Qt.Unchecked if current == QtCore.Qt.Checked else QtCore.Qt.Checked
+        return model.setData(index, new_state, QtCore.Qt.CheckStateRole)
 
 
-class DeviceValidatedDelegate(CustomDisplayDelegate):
+class DeviceValidatedDelegate(DictToolTipDelegate):
     """Custom delegate for displaying validated device configurations."""
 
     def __init__(self, parent=None, colors=None):
         super().__init__(parent)
-        colors = colors if colors else get_accent_colors()
-        _icon = partial(material_icon, icon_name="circle", size=(12, 12), filled=True)
+        self._colors = colors if colors else get_accent_colors()
         self._icons = {
-            ValidationStatus.PENDING: _icon(color=colors.default),
-            ValidationStatus.VALID: _icon(color=colors.success),
-            ValidationStatus.FAILED: _icon(color=colors.emergency),
+            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):
@@ -126,12 +104,76 @@ class DeviceValidatedDelegate(CustomDisplayDelegate):
         for status, icon in self._icons.items():
             icon.setColor(colors[status])
 
-    def _do_custom_paint(self, painter, option, index, value):
-        if pixmap := self._icons.get(value):
+    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(option.rect.center())
+            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:
+            return super().paint(painter, option, index)
+
+        painter.save()
+        painter.setClipRect(option.rect)
+        text_option = QtCore.Qt.TextWordWrap | QtCore.Qt.AlignLeft | QtCore.Qt.AlignTop
+        painter.drawText(option.rect.adjusted(4, 2, -4, -2), text_option, text)
+        painter.restore()
+
+    def sizeHint(self, option, index):
+        text = str(index.model().data(index, QtCore.Qt.DisplayRole) or "")
+        column_width = self._table.columnWidth(index.column()) - 8  # -4 & 4
+
+        # 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)
+        doc.setTextWidth(column_width)
+        doc.setPlainText(text)
+
+        layout_height = doc.documentLayout().documentSize().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):
     """
@@ -140,12 +182,13 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
     Sort logic is implemented directly on the data of the table view.
     """
 
-    # tuple of list[dict[str, Any]] of configs which were added and bool True if added or False if removed
-    configs_changed = QtCore.Signal(list, bool)
+    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: list[dict[str, Any]] = []
+        self._device_config: dict[str, dict] = {}
+        self._list_items: list[dict] = []
         self._validation_status: dict[str, ValidationStatus] = {}
         self.headers = [
             "",
@@ -159,19 +202,17 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
         self._checkable_columns_enabled = {"enabled": True, "readOnly": True}
 
     ###############################################
-    ########## Override custom Qt methods #########
+    ########## Overwrite custom Qt methods ########
     ###############################################
 
-    def rowCount(self, parent: QModelIndex | QPersistentModelIndex = QtCore.QModelIndex()) -> int:
-        return len(self._device_config)
+    def rowCount(self, parent=QtCore.QModelIndex()) -> int:
+        return len(self._list_items)
 
-    def columnCount(
-        self, parent: QModelIndex | QPersistentModelIndex = QtCore.QModelIndex()
-    ) -> int:
+    def columnCount(self, parent=QtCore.QModelIndex()) -> int:
         return len(self.headers)
 
-    def headerData(self, section, orientation, role=int(Qt.ItemDataRole.DisplayRole)):
-        if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
+    def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):
+        if role == QtCore.Qt.DisplayRole and orientation == QtCore.Qt.Horizontal:
             return self.headers[section]
         return None
 
@@ -179,22 +220,22 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
         """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=int(Qt.ItemDataRole.DisplayRole)):
+    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 == Qt.ItemDataRole.DisplayRole:
-            dev_name = self._device_config[row].get("name", "")
+        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 == Qt.ItemDataRole.DisplayRole:
+        if role == QtCore.Qt.DisplayRole:
             if key in ("enabled", "readOnly"):
                 return bool(value)
             if key == "deviceTags":
@@ -202,13 +243,13 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
             if key == "deviceClass":
                 return str(value).split(".")[-1]
             return str(value) if value is not None else ""
-        if role == USER_CHECK_DATA_ROLE and key in ("enabled", "readOnly"):
-            return Qt.CheckState.Checked if value else Qt.CheckState.Unchecked
-        if role == Qt.ItemDataRole.TextAlignmentRole:
+        if role == QtCore.Qt.CheckStateRole and key in ("enabled", "readOnly"):
+            return QtCore.Qt.Checked if value else QtCore.Qt.Unchecked
+        if role == QtCore.Qt.TextAlignmentRole:
             if key in ("enabled", "readOnly"):
-                return Qt.AlignmentFlag.AlignCenter
-            return Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter
-        if role == Qt.ItemDataRole.FontRole:
+                return QtCore.Qt.AlignCenter
+            return QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter
+        if role == QtCore.Qt.FontRole:
             font = QtGui.QFont()
             return font
         return None
@@ -216,21 +257,18 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
     def flags(self, index):
         """Flags for the table model."""
         if not index.isValid():
-            return Qt.ItemFlag.NoItemFlags
+            return QtCore.Qt.NoItemFlags
         key = self.headers[index.column()]
 
-        base_flags = super().flags(index) | (
-            Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsDropEnabled
-        )
-
         if key in ("enabled", "readOnly"):
+            base_flags = QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable
             if self._checkable_columns_enabled.get(key, True):
-                return base_flags | Qt.ItemFlag.ItemIsUserCheckable
+                return base_flags | QtCore.Qt.ItemIsUserCheckable
             else:
                 return base_flags  # disable editing but still visible
-        return base_flags
+        return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable
 
-    def setData(self, index, value, role=int(Qt.ItemDataRole.EditRole)) -> bool:
+    def setData(self, index, value, role=QtCore.Qt.EditRole) -> bool:
         """
         Method to set the data of the table.
 
@@ -245,128 +283,99 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
         if not index.isValid():
             return False
         key = self.headers[index.column()]
-        if key in ("enabled", "readOnly") and role == USER_CHECK_DATA_ROLE:
+        row = index.row()
+
+        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[index.row()][key] = value == Qt.CheckState.Checked
-            self.dataChanged.emit(index, index, [Qt.ItemDataRole.DisplayRole, USER_CHECK_DATA_ROLE])
+            self._list_items[row][key] = value == QtCore.Qt.Checked
+            self.dataChanged.emit(index, index, [QtCore.Qt.CheckStateRole])
             return True
         return False
 
-    ####################################
-    ############ Drag and Drop #########
-    ####################################
-
-    def mimeTypes(self) -> List[str]:
-        return [*super().mimeTypes(), MIME_DEVICE_CONFIG]
-
-    def supportedDropActions(self):
-        return Qt.DropAction.CopyAction | Qt.DropAction.MoveAction
-
-    def dropMimeData(self, data, action, row, column, parent):
-        if action not in [Qt.DropAction.CopyAction, Qt.DropAction.MoveAction]:
-            return False
-        if (raw_data := data.data(MIME_DEVICE_CONFIG)) is None:
-            return False
-        self.add_device_configs(json.loads(raw_data.toStdString()))
-        return True
-
     ####################################
     ############ Public methods ########
     ####################################
 
-    def get_device_config(self) -> list[dict[str, Any]]:
+    def get_device_config(self) -> dict[str, dict]:
         """Method to get the device configuration."""
-        return copy.deepcopy(self._device_config)
+        return self._device_config
 
-    def device_names(self, configs: _DeviceCfgIter | None = None) -> set[str]:
-        _configs = self._device_config if configs is None else configs
-        return set(cfg.get("name") for cfg in _configs if cfg.get("name") is not None)  # type: ignore
-
-    def _name_exists_in_config(self, name: str, exists: bool):
-        if (name in self.device_names()) == exists:
-            return True
-        return not exists
-
-    def add_device_configs(self, device_configs: _DeviceCfgIter):
+    def add_device_configs(self, device_configs: dict[str, dict]):
         """
         Add devices to the model.
 
         Args:
-            device_configs (_DeviceCfgList): An iterable of device configurations to add.
+            device_configs (dict[str, dict]): A dictionary of device configurations to add.
         """
         already_in_list = []
-        added_configs = []
-        for cfg in device_configs:
-            if self._name_exists_in_config(name := cfg.get("name", "<not found>"), True):
-                logger.warning(f"Device {name} already exists in the model.")
-                already_in_list.append(name)
+        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
-            row = len(self._device_config)
+            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._device_config.append(copy.deepcopy(cfg))
-            added_configs.append(cfg)
+            self._list_items.append(new_list_cfg)
             self.endInsertRows()
-        self.configs_changed.emit(device_configs, True)
+        for k in already_in_list:
+            device_configs.pop(k)
+        self.device_configs_added.emit(device_configs)
 
-    def remove_device_configs(self, device_configs: _DeviceCfgIter):
-        """
-        Remove devices from the model.
-
-        Args:
-            device_configs (_DeviceCfgList): An iterable of device configurations to remove.
-        """
-        removed = []
-        for cfg in device_configs:
-            if cfg not in self._device_config:
-                logger.warning(f"Device {cfg.get('name')} does not exist in the model.")
-                continue
-            with self._remove_row(self._device_config.index(cfg)) as row:
-                removed.append(self._device_config.pop(row))
-        self.configs_changed.emit(removed, False)
-
-    def remove_configs_by_name(self, names: Iterable[str]):
-        configs = filter(lambda cfg: cfg is not None, (self.get_by_name(name) for name in names))
-        self.remove_device_configs(configs)  # type: ignore # Nones are filtered
-
-    def get_by_name(self, name: str) -> dict[str, Any] | None:
-        for cfg in self._device_config:
-            if cfg.get("name") == name:
-                return cfg
-        logger.warning(f"Device {name} does not exist in the model.")
-        return None
-
-    @contextmanager
-    def _remove_row(self, row: int):
-        self.beginRemoveRows(QtCore.QModelIndex(), row, row)
-        try:
-            yield row
-        finally:
-            self.endRemoveRows()
-
-    def set_device_config(self, device_configs: _DeviceCfgIter):
+    def set_device_config(self, device_configs: dict[str, dict]):
         """
         Replace the device config.
 
         Args:
-            device_config (Iterable[dict[str,Any]]): An iterable of device configurations to set.
+            device_config (dict[str, dict]): The new device config to set.
         """
-        diff_names = self.device_names(device_configs) - self.device_names()
-        diff = [cfg for cfg in self._device_config if cfg.get("name") in diff_names]
+        diff_names = set(device_configs.keys()) - set(self._device_config.keys())
         self.beginResetModel()
-        self._device_config = copy.deepcopy(list(device_configs))
+        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.configs_changed.emit(diff, False)
-        self.configs_changed.emit(device_configs, True)
+        self.devices_removed.emit(diff_names)
+        self.device_configs_added.emit(device_configs)
+
+    def remove_device_configs(self, device_configs: dict[str, dict]):
+        """
+        Remove devices from the model.
+
+        Args:
+            device_configs (dict[str, dict]): A dictionary of device configurations to remove.
+        """
+        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._list_items.pop(row)
+            self.endRemoveRows()
+            removed.append(k)
+        self.devices_removed.emit(removed)
 
     def clear_table(self):
         """
         Clear the table.
         """
+        device_names = list(self._device_config.keys())
         self.beginResetModel()
         self._device_config.clear()
+        self._list_items.clear()
         self.endResetModel()
-        self.configs_changed.emit(self._device_config, False)
+        self.devices_removed.emit(device_names)
 
     def update_validation_status(self, device_name: str, status: int | ValidationStatus):
         """
@@ -378,12 +387,14 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
         """
         if isinstance(status, int):
             status = ValidationStatus(status)
-        if device_name not in self.device_names():
-            logger.warning(f"Device {device_name} not found in table")
+        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._device_config):
+        for ii, item in enumerate(self._list_items):
             if item["name"] == device_name:
                 row = ii
                 break
@@ -394,24 +405,12 @@ class DeviceTableModel(QtCore.QAbstractTableModel):
             return
         # Emit dataChanged for column 0 (status column)
         index = self.index(row, 0)
-        self.dataChanged.emit(index, index, [Qt.ItemDataRole.DisplayRole])
-
-    def validation_statuses(self):
-        return copy.deepcopy(self._validation_status)
+        self.dataChanged.emit(index, index, [QtCore.Qt.DisplayRole])
 
 
 class BECTableView(QtWidgets.QTableView):
     """Table View with custom keyPressEvent to delete rows with backspace or delete key"""
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.setAcceptDrops(True)
-        self.setDropIndicatorShown(True)
-        self.setDragDropMode(QtWidgets.QTableView.DragDropMode.DropOnly)
-
-    def model(self) -> DeviceFilterProxyModel:
-        return super().model()  # type: ignore
-
     def keyPressEvent(self, event) -> None:
         """
         Delete selected rows with backspace or delete key
@@ -419,27 +418,22 @@ class BECTableView(QtWidgets.QTableView):
         Args:
             event: keyPressEvent
         """
-        if event.key() in (Qt.Key.Key_Backspace, Qt.Key.Key_Delete):
-            return self.delete_selected()
-        return super().keyPressEvent(event)
+        if event.key() not in (QtCore.Qt.Key_Backspace, QtCore.Qt.Key_Delete):
+            return super().keyPressEvent(event)
 
-    def contains_invalid_devices(self):
-        return ValidationStatus.FAILED in self.model().sourceModel().validation_statuses().values()
-
-    def all_configs(self):
-        return self.model().sourceModel().get_device_config()
-
-    def selected_configs(self):
-        return self.model().get_row_data(self.selectionModel().selectedRows())
-
-    def delete_selected(self):
-        proxy_indexes = self.selectionModel().selectedRows()
+        proxy_indexes = self.selectedIndexes()
         if not proxy_indexes:
             return
-        model: DeviceTableModel = self.model().sourceModel()  # access underlying model
-        self._confirm_and_remove_rows(model, self._get_source_rows(proxy_indexes))
 
-    def _get_source_rows(self, proxy_indexes: list[QModelIndex]) -> list[QModelIndex]:
+        source_rows = self._get_source_rows(proxy_indexes)
+
+        model: DeviceTableModel = self.model().sourceModel()  # access underlying model
+        # Delegate confirmation and removal to helper
+        removed = self._confirm_and_remove_rows(model, source_rows)
+        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.
 
@@ -450,33 +444,33 @@ class BECTableView(QtWidgets.QTableView):
             list[int]: List of source model row indices.
         """
         proxy_rows = sorted({idx for idx in proxy_indexes}, reverse=True)
-        return list(set(self.model().mapToSource(idx) for idx in proxy_rows))
+        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[QModelIndex]
-    ) -> bool:
+    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.
         """
-        configs = [model.get_row_data(r) for r in sorted(source_rows, key=lambda r: r.row())]
+        configs = [model._list_items[r] for r in sorted(source_rows)]
         names = [cfg.get("name", "<unknown>") for cfg in configs]
 
-        msg = QMessageBox(self)
-        msg.setIcon(QMessageBox.Icon.Warning)
-        msg.setWindowTitle("Confirm device removal")
-        msg.setText(
-            f"Remove device '{names[0]}'?" if len(names) == 1 else f"Remove {len(names)} devices?"
-        )
-        separator = "\n" if len(names) < 12 else ", "
-        msg.setInformativeText("Selected devices: \n" + separator.join(names))
-        msg.setStandardButtons(QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Cancel)
-        msg.setDefaultButton(QMessageBox.StandardButton.Cancel)
+        msg = QtWidgets.QMessageBox(self)
+        msg.setIcon(QtWidgets.QMessageBox.Warning)
+        msg.setWindowTitle("Confirm remove devices")
+        if len(names) == 1:
+            msg.setText(f"Remove device '{names[0]}'?")
+        else:
+            msg.setText(f"Remove {len(names)} devices?")
+        msg.setInformativeText("\n".join(names))
+        msg.setStandardButtons(QtWidgets.QMessageBox.Ok | QtWidgets.QMessageBox.Cancel)
+        msg.setDefaultButton(QtWidgets.QMessageBox.Cancel)
 
         res = msg.exec_()
-        if res == QMessageBox.StandardButton.Ok:
-            model.remove_device_configs(configs)
+        if res == QtWidgets.QMessageBox.Ok:
+            configs_to_be_removed = {model._device_config[name] for name in names}
+            model.remove_device_configs(configs_to_be_removed)
             return True
         return False
 
@@ -490,12 +484,6 @@ class DeviceFilterProxyModel(QtCore.QSortFilterProxyModel):
         self._enable_fuzzy = True
         self._filter_columns = [1, 2]  # name and deviceClass for search
 
-    def get_row_data(self, rows: Iterable[QModelIndex]) -> Iterable[dict[str, Any]]:
-        return (self.sourceModel().get_row_data(self.mapToSource(idx)) for idx in rows)
-
-    def sourceModel(self) -> DeviceTableModel:
-        return super().sourceModel()  # type: ignore
-
     def hide_rows(self, row_indices: list[int]):
         """
         Hide specific rows in the model.
@@ -544,7 +532,7 @@ class DeviceFilterProxyModel(QtCore.QSortFilterProxyModel):
         text = self._filter_text.lower()
         for column in self._filter_columns:
             index = model.index(source_row, column, source_parent)
-            data = str(model.data(index, Qt.ItemDataRole.DisplayRole) or "")
+            data = str(model.data(index, QtCore.Qt.DisplayRole) or "")
             if self._enable_fuzzy is True:
                 match_ratio = fuzz.partial_ratio(self._filter_text.lower(), data.lower())
                 if match_ratio >= FUZZY_SEARCH_THRESHOLD:
@@ -554,53 +542,35 @@ class DeviceFilterProxyModel(QtCore.QSortFilterProxyModel):
                     return True
         return False
 
-    def flags(self, index):
-        return super().flags(index) | Qt.ItemFlag.ItemIsDropEnabled
-
-    def supportedDropActions(self):
-        return self.sourceModel().supportedDropActions()
-
-    def mimeTypes(self):
-        return self.sourceModel().mimeTypes()
-
-    def dropMimeData(self, data, action, row, column, parent):
-        sp = self.mapToSource(parent) if parent.isValid() else QtCore.QModelIndex()
-        return self.sourceModel().dropMimeData(data, action, row, column, sp)
-
 
 class DeviceTableView(BECWidget, QtWidgets.QWidget):
     """Device Table View for the device manager."""
 
-    # Selected device configuration list[dict[str, Any]]
-    selected_devices = QtCore.Signal(list)  # type: ignore
-    # tuple of list[dict[str, Any]] of configs which were added and bool True if added or False if removed
-    device_configs_changed = QtCore.Signal(list, bool)  # type: ignore
+    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
 
-    def __init__(self, parent=None, client=None, shared_selection_signal=SharedSelectionSignal()):
+    def __init__(self, parent=None, client=None):
         super().__init__(client=client, parent=parent, theme_update=True)
 
-        self._shared_selection_signal = shared_selection_signal
-        self._shared_selection_uuid = str(uuid4())
-        self._shared_selection_signal.proc.connect(self._handle_shared_selection_signal)
-
-        self._layout = QtWidgets.QVBoxLayout(self)
-        self._layout.setContentsMargins(0, 0, 0, 0)
-        self._layout.setSpacing(4)
-        self.setLayout(self._layout)
+        self.layout = QtWidgets.QVBoxLayout(self)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.layout.setSpacing(4)
 
         # Setup table view
         self._setup_table_view()
         # Setup search view, needs table proxy to be iniditate
         self._setup_search()
         # Add widgets to main layout
-        self._layout.addLayout(self.search_controls)
-        self._layout.addWidget(self.table)
+        self.layout.addLayout(self.search_controls)
+        self.layout.addWidget(self.table)
 
         # Connect signals
-        self._model.configs_changed.connect(self.device_configs_changed.emit)
+        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"""
@@ -636,7 +606,7 @@ class DeviceTableView(BECWidget, QtWidgets.QWidget):
         self.search_controls.addLayout(self.search_layout)
         self.search_controls.addSpacing(20)  # Add some space between the search box and toggle
         self.search_controls.addLayout(self.fuzzy_layout)
-        QTimer.singleShot(0, lambda: self.fuzzy_is_disabled.stateChanged.emit(0))
+        QtCore.QTimer.singleShot(0, lambda: self.fuzzy_is_disabled.stateChanged.emit(0))
 
     def _setup_table_view(self) -> None:
         """Setup the table view."""
@@ -651,33 +621,26 @@ class DeviceTableView(BECWidget, QtWidgets.QWidget):
         # Delegates
         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.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.tool_tip_delegate
-        )  # deviceTags (was wrap_delegate)
+        self.table.setItemDelegateForColumn(4, self.wrap_delegate)  # deviceTags
         self.table.setItemDelegateForColumn(5, self.checkbox_delegate)  # enabled
         self.table.setItemDelegateForColumn(6, self.checkbox_delegate)  # readOnly
 
-        # Disable wrapping, use eliding, and smooth scrolling
-        self.table.setWordWrap(False)
-        self.table.setTextElideMode(QtCore.Qt.TextElideMode.ElideRight)
-        self.table.setVerticalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)
-        self.table.setHorizontalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)
-
         # Column resize policies
         header = self.table.horizontalHeader()
-        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Fixed)  # ValidationStatus
-        header.setSectionResizeMode(1, QHeaderView.ResizeMode.Interactive)  # name
-        header.setSectionResizeMode(2, QHeaderView.ResizeMode.Interactive)  # deviceClass
-        header.setSectionResizeMode(3, QHeaderView.ResizeMode.Interactive)  # readoutPriority
-        header.setSectionResizeMode(4, QHeaderView.ResizeMode.Stretch)  # deviceTags: expand to fill
-        header.setSectionResizeMode(5, QHeaderView.ResizeMode.Fixed)  # enabled
-        header.setSectionResizeMode(6, QHeaderView.ResizeMode.Fixed)  # readOnly
+        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)
@@ -686,24 +649,22 @@ class DeviceTableView(BECWidget, QtWidgets.QWidget):
         # Ensure column widths stay fixed
         header.setMinimumSectionSize(25)
         header.setDefaultSectionSize(90)
-        header.setStretchLastSection(False)
+
+        # Enable resizing of column
+        self._geometry_resize_proxy = BECSignalProxy(
+            header.geometriesChanged, rateLimit=10, slot=self._on_table_resized
+        )
 
         # Selection behavior
-        self.table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
-        self.table.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+        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)
 
-        # Connect model signals to autosize request
-        self._model.rowsInserted.connect(self._request_autosize_columns)
-        self._model.modelReset.connect(self._request_autosize_columns)
-        self._model.dataChanged.connect(self._request_autosize_columns)
+        # QtCore.QTimer.singleShot(0, lambda: header.sectionResized.emit(0, 0, 0))
 
-    def remove_selected_rows(self):
-        self.table.delete_selected()
-
-    def get_device_config(self) -> list[dict[str, Any]]:
+    def get_device_config(self) -> dict[str, dict]:
         """Get the device config."""
         return self._model.get_device_config()
 
@@ -715,24 +676,15 @@ class DeviceTableView(BECWidget, QtWidgets.QWidget):
     ########### Slot API #################
     ######################################
 
-    def _request_autosize_columns(self, *args):
-        if not hasattr(self, "_autosize_timer"):
-            self._autosize_timer = QtCore.QTimer(self)
-            self._autosize_timer.setSingleShot(True)
-            self._autosize_timer.timeout.connect(self._autosize_columns)
-        self._autosize_timer.start(0)
-
     @SafeSlot()
-    def _autosize_columns(self):
-        if self._model.rowCount() == 0:
-            return
-        for col in (1, 2, 3):
-            self.table.resizeColumnToContents(col)
-
-    @SafeSlot(str)
-    def _handle_shared_selection_signal(self, uuid: str):
-        if uuid != self._shared_selection_uuid:
-            self.table.clearSelection()
+    def _on_table_resized(self, *args):
+        """Handle changes to the table column resizing."""
+        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(
@@ -745,22 +697,30 @@ class DeviceTableView(BECWidget, QtWidgets.QWidget):
             selected (QtCore.QItemSelection): The selected items.
             deselected (QtCore.QItemSelection): The deselected items.
         """
-        self._shared_selection_signal.proc.emit(self._shared_selection_uuid)
-        if not (selected_configs := list(self.table.selected_configs())):
+        # 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
-        self.selected_devices.emit(selected_configs)
+
+        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, device_configs: _DeviceCfgIter):
+    @SafeSlot(dict)
+    def set_device_config(self, device_configs: dict[str, dict]):
         """
         Set the device config.
 
         Args:
-            config (Iterable[str,dict]): The device config to set.
+            config (dict[str,dict]): The device config to set.
         """
         self._model.set_device_config(device_configs)
 
@@ -769,8 +729,8 @@ class DeviceTableView(BECWidget, QtWidgets.QWidget):
         """Clear the device configs."""
         self._model.clear_table()
 
-    @SafeSlot(list)
-    def add_device_configs(self, device_configs: _DeviceCfgIter):
+    @SafeSlot(dict)
+    def add_device_configs(self, device_configs: dict[str, dict]):
         """
         Add devices to the config.
 
@@ -779,8 +739,8 @@ class DeviceTableView(BECWidget, QtWidgets.QWidget):
         """
         self._model.add_device_configs(device_configs)
 
-    @SafeSlot(list)
-    def remove_device_configs(self, device_configs: _DeviceCfgIter):
+    @SafeSlot(dict)
+    def remove_device_configs(self, device_configs: dict[str, dict]):
         """
         Remove devices from the config.
 
@@ -797,7 +757,11 @@ class DeviceTableView(BECWidget, QtWidgets.QWidget):
         Args:
             device_name (str): The name of the device to remove.
         """
-        self._model.remove_configs_by_name([device_name])
+        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(
@@ -830,7 +794,7 @@ if __name__ == "__main__":
     layout.addWidget(button)
 
     def _button_clicked():
-        names = list(window._model.device_names())
+        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
@@ -839,8 +803,8 @@ if __name__ == "__main__":
     button.clicked.connect(_button_clicked)
     # pylint: disable=protected-access
     config = window.client.device_manager._get_redis_device_config()
-    # names = [cfg.pop("name") for cfg in config]
-    # config_dict = {name: cfg for name, cfg in zip(names, config)}
-    window.set_device_config(config)
+    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

@@ -9,6 +9,7 @@ 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
 
@@ -51,14 +52,14 @@ class DMConfigView(BECWidget, QtWidgets.QWidget):
         )
 
     @SafeSlot(dict)
-    def on_select_config(self, device: list[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[0], default_flow_style=False)
+                text = yaml.dump(device, default_flow_style=False)
                 self.stacked_layout.setCurrentWidget(self.monaco_editor)
             except Exception:
                 content = traceback.format_exc()
@@ -77,24 +78,6 @@ if __name__ == "__main__":
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
-    widget = QtWidgets.QWidget()
-    layout = QtWidgets.QVBoxLayout(widget)
-    widget.setLayout(layout)
-    layout.setContentsMargins(0, 0, 0, 0)
-    layout.setSpacing(0)
     config_view = DMConfigView()
-    layout.addWidget(config_view)
-    combo_box = QtWidgets.QComboBox()
-    config = config_view.client.device_manager._get_redis_device_config()
-    combo_box.addItems([""] + [str(v) for v, item in enumerate(config)])
-
-    def on_select(text):
-        if text == "":
-            config_view.on_select_config([])
-        else:
-            config_view.on_select_config([config[int(text)]])
-
-    combo_box.currentTextChanged.connect(on_select)
-    layout.addWidget(combo_box)
-    widget.show()
+    config_view.show()
     sys.exit(app.exec_())

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

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

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

@@ -4,19 +4,20 @@ from __future__ import annotations
 
 import enum
 import re
-from collections import deque
-from concurrent.futures import CancelledError, Future, ThreadPoolExecutor
+import traceback
 from html import escape
-from threading import Event, RLock
-from typing import Any, Iterable
+from typing import TYPE_CHECKING
 
+import bec_lib
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
-from qtpy import QtCore, QtWidgets
+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 SafeSlot
+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
@@ -33,10 +34,11 @@ except ImportError:
     ophyd_devices = None
     bec_server = None
 
-try:
-    from ophyd_devices.utils.static_device_test import StaticDeviceTest
-except ImportError:
-    StaticDeviceTest = 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):
@@ -54,76 +56,49 @@ class DeviceValidationResult(QtCore.QObject):
     device_validated = QtCore.Signal(str, bool, str)
 
 
-class DeviceTester(QtCore.QRunnable):
-    def __init__(self, config: dict) -> None:
+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()
-        self.shutdown_event = Event()
-
-        self._config = config
-
-        self._max_threads = 4
-        self._pending_event = Event()
-        self._lock = RLock()
-        self._test_executor = ThreadPoolExecutor(self._max_threads, "device_manager_tester")
-
-        self._pending_queue: deque[tuple[str, dict]] = deque([])
-        self._active: set[str] = set()
-
-        QtWidgets.QApplication.instance().aboutToQuit.connect(lambda: self.shutdown_event.set())
 
     def run(self):
-        if StaticDeviceTest is None:
-            logger.error("Ophyd devices or bec_server not available, cannot run validation.")
+        """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
-        while not self.shutdown_event.is_set():
-            self._pending_event.wait(timeout=0.5)  # check if shutting down every 0.5s
-            if len(self._active) >= self._max_threads:
-                self._pending_event.clear()  # it will be set again on removing something from active
-                continue
-            with self._lock:
-                if len(self._pending_queue) > 0:
-                    item, cfg, connect = self._pending_queue.pop()
-                    self._active.add(item)
-                    fut = self._test_executor.submit(self._run_test, item, {item: cfg}, connect)
-                    fut.__dict__["__device_name"] = item
-                    fut.add_done_callback(self._done_cb)
-            self._safe_check_and_clear()
-        self._cleanup()
-
-    def submit(self, devices: Iterable[tuple[str, dict, bool]]):
-        with self._lock:
-            self._pending_queue.extend(devices)
-            self._pending_event.set()
-
-    @staticmethod
-    def _run_test(name: str, config: dict, connect: bool) -> tuple[str, bool, str]:
-        tester = StaticDeviceTest(config_dict=config)  # type: ignore # we exit early if it is None
-        results = tester.run_with_list_output(connect=connect)
-        return name, results[0].success, results[0].message
-
-    def _safe_check_and_clear(self):
-        with self._lock:
-            if len(self._pending_queue) == 0:
-                self._pending_event.clear()
-
-    def _safe_remove_from_active(self, name: str):
-        with self._lock:
-            self._active.remove(name)
-            self._pending_event.set()  # check again once a completed task is removed
-
-    def _done_cb(self, future: Future):
         try:
-            name, success, message = future.result()
-        except CancelledError:
-            return
-        except Exception as e:
-            name, success, message = future.__dict__["__device_name"], False, str(e)
-        finally:
-            self._safe_remove_from_active(future.__dict__["__device_name"])
-        self.signals.device_validated.emit(name, success, message)
-
-    def _cleanup(self): ...
+            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):
@@ -164,6 +139,7 @@ class ValidationListItem(QtWidgets.QWidget):
     def _start_spinner(self):
         """Start the spinner animation."""
         self._spinner.start()
+        QtWidgets.QApplication.processEvents()
 
     def _stop_spinner(self):
         """Stop the spinner animation."""
@@ -196,31 +172,29 @@ class DMOphydTest(BECWidget, QtWidgets.QWidget):
 
     # Signal to emit the validation status of a device
     device_validated = QtCore.Signal(str, int)
-    # validation_msg in markdown format
-    validation_msg_md = QtCore.Signal(str)
 
     def __init__(self, parent=None, client=None):
         super().__init__(parent=parent, client=client)
         if not READY_TO_TEST:
             self.setDisabled(True)
-            self.tester = None
+            self.static_device_test = None
         else:
-            self.tester = DeviceTester({})
-            self.tester.signals.device_validated.connect(self._on_device_validated)
-            QtCore.QThreadPool.globalInstance().start(self.tester)
+            from ophyd_devices.utils.static_device_test import StaticDeviceTest
+
+            self.static_device_test = StaticDeviceTest(config_dict={})
         self._device_list_items: dict[str, QtWidgets.QListWidgetItem] = {}
-        # TODO Consider using the thread pool from BECConnector instead of fetching the global instance!
         self._thread_pool = QtCore.QThreadPool.globalInstance()
 
         self._main_layout = QtWidgets.QVBoxLayout(self)
         self._main_layout.setContentsMargins(0, 0, 0, 0)
-        self._main_layout.setSpacing(0)
+        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."""
@@ -230,38 +204,46 @@ class DMOphydTest(BECWidget, QtWidgets.QWidget):
         # Connect signals
         self._list_widget.currentItemChanged.connect(self._on_current_item_changed)
 
-    @SafeSlot(list, bool)
-    @SafeSlot(list, bool, bool)
-    def change_device_configs(
-        self, device_configs: list[dict[str, Any]], added: bool, connect: bool = False
-    ) -> None:
+    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 (list[dict[str, Any]]): The updated device configurations.
+            device_configs (dict[str, dict]): The updated device configurations.
         """
-        for cfg in device_configs:
-            name = cfg.get("name", "<not found>")
-            if added:
-                if name in self._device_list_items:
-                    continue
-                if self.tester:
-                    self._add_device(name, cfg)
-                    self.tester.submit([(name, cfg, connect)])
-                continue
-            if name not in self._device_list_items:
-                continue
-            self._remove_list_item(name)
+        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)
 
-    def _add_device(self, name, cfg):
-        item = QtWidgets.QListWidgetItem(self._list_widget)
-        widget = ValidationListItem(device_name=name, device_config=cfg)
+            # wrap it in a QListWidgetItem
+            item.setSizeHint(widget.sizeHint())
+            self._list_widget.addItem(item)
+            self._list_widget.setItemWidget(item, widget)
+            self._device_list_items[device_name] = item
+            self._run_device_validation(widget)
 
-        # wrap it in a QListWidgetItem
-        item.setSizeHint(widget.sizeHint())
-        self._list_widget.addItem(item)
-        self._list_widget.setItemWidget(item, widget)
-        self._device_list_items[name] = item
+    @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."""
@@ -277,6 +259,34 @@ class DMOphydTest(BECWidget, QtWidgets.QWidget):
         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.
@@ -311,42 +321,62 @@ class DMOphydTest(BECWidget, QtWidgets.QWidget):
         widget: ValidationListItem = self._list_widget.itemWidget(current)
         if widget:
             try:
-                formatted_md = self._format_markdown_text(widget.device_name, widget.validation_msg)
-                self.validation_msg_md.emit(formatted_md)
+                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 for device {widget.device_name}:\n{e}"
-                )
-                self.validation_msg_md.emit(widget.validation_msg)
-        else:
-            self.validation_msg_md.emit("")
+                logger.error(f"Error formatting validation message: {e}")
+                self._text_box.setPlainText(widget.validation_msg)
 
-    def _format_markdown_text(self, device_name: str, raw_msg: str) -> str:
+    def _format_validation_message(self, raw_msg: str) -> str:
         """Simple HTML formatting for validation messages, wrapping text naturally."""
         if not raw_msg.strip():
-            return f"### Validation in progress for {device_name}... \n\n"
+            return "<i>Validation in progress...</i>"
         if raw_msg == "Validation in progress...":
-            return f"### Validation in progress for {device_name}... \n\n"
+            return "<i>Validation in progress...</i>"
 
-        m = re.search(r"ERROR:\s*([^\s]+)\s+is not valid:\s*(.+?errors?)", raw_msg)
-        device, summary = m.group(1), m.group(2)
-        lines = [f"## Error for '{device}'", f"'{device}' is not valid: {summary}"]
+        raw_msg = escape(raw_msg)
 
-        # Find each field block:  \n<field>\n  Field required ...
-        field_pat = re.compile(
-            r"\n(?P<field>\w+)\n\s+(?P<rest>Field required.*?(?=\n\w+\n|$))", re.DOTALL
+        # 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 ""
         )
 
-        for m in field_pat.finditer(raw_msg):
-            field = m.group("field")
-            rest = m.group("rest").rstrip()
-            lines.append(f"### {field}")
-            lines.append(rest)
+        # Traceback / error in red
+        error_html = (
+            f'<div style="white-space: pre-wrap; color:#A00000;">{error_detail}</div>'
+            if error_detail
+            else ""
+        )
 
-        return "\n".join(lines)
-
-    def validation_running(self):
-        return self._device_list_items != {}
+        # 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):
@@ -356,7 +386,6 @@ class DMOphydTest(BECWidget, QtWidgets.QWidget):
             logger.error("Failed to wait for threads to finish. Removing items from the list.")
         self._device_list_items.clear()
         self._list_widget.clear()
-        self.validation_msg_md.emit("")
 
     def remove_device(self, device_name: str):
         """Remove a device from the list."""
@@ -364,11 +393,6 @@ class DMOphydTest(BECWidget, QtWidgets.QWidget):
         if item:
             self._list_widget.removeItemWidget(item)
 
-    def cleanup(self):
-        if self.tester:
-            self.tester.shutdown_event.set()
-        return super().cleanup()
-
 
 if __name__ == "__main__":
     import sys
@@ -379,32 +403,12 @@ if __name__ == "__main__":
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
-    wid = QtWidgets.QWidget()
-    layout = QtWidgets.QVBoxLayout(wid)
-    wid.setLayout(layout)
-    layout.setContentsMargins(0, 0, 0, 0)
-    layout.setSpacing(0)
     device_manager_ophyd_test = DMOphydTest()
-    try:
-        config_path = "/Users/appel_c/work_psi_awi/bec_workspace/csaxs_bec/csaxs_bec/device_configs/endstation.yaml"
-        config = [{"name": k, **v} for k, v in yaml_load(config_path).items()]
-    except Exception as e:
-        logger.error(f"Error loading config: {e}")
-        import os
-
-        import bec_lib
-
-        config_path = os.path.join(os.path.dirname(bec_lib.__file__), "configs", "demo_config.yaml")
-        config = [{"name": k, **v} for k, v in yaml_load(config_path).items()]
-
-    config.append({"name": "non_existing_device", "type": "NonExistingDevice"})
-    device_manager_ophyd_test.change_device_configs(config, True, True)
-    layout.addWidget(device_manager_ophyd_test)
+    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)
-    text_box = QtWidgets.QTextEdit()
-    text_box.setReadOnly(True)
-    layout.addWidget(text_box)
-    device_manager_ophyd_test.validation_msg_md.connect(text_box.setMarkdown)
-    wid.show()
     sys.exit(app.exec_())

bec_widgets/widgets/plots/image/image.py

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

bec_widgets/widgets/plots/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
@@ -896,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):
         """
@@ -918,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/waveform/waveform.py

@@ -932,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.
@@ -1127,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

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."
@@ -241,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.
 
@@ -270,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)
@@ -440,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):
         """
@@ -480,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.
 
@@ -517,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):
         """
@@ -571,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())
@@ -625,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/device_browser/device_browser.py

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

bec_widgets/widgets/services/device_browser/device_browser.ui

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

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

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

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

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

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

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

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

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

bec_widgets/widgets/utility/signal_label/signal_label.py

@@ -8,6 +8,7 @@ import numpy as np
 from bec_lib.device import Device, Signal
 from bec_lib.endpoints import MessageEndpoints
 from bec_qthemes import material_icon
+from qtpy.QtCore import Qt
 from qtpy.QtCore import Signal as QSignal
 from qtpy.QtWidgets import (
     QApplication,
@@ -480,11 +481,6 @@ class SignalLabel(BECWidget, QWidget):
             self._custom_label if self._custom_label else f"{self._default_label}:"
         )
 
-    def cleanup(self):
-        self.disconnect_device()
-        self._device_obj = None
-        super().cleanup()
-
 
 if __name__ == "__main__":
     app = QApplication(sys.argv)

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
 ```
 ````

docs/user/widgets/image/image_widget.md

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

docs/user/widgets/lmfit_dialog/lmfit_dialog.md

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

docs/user/widgets/motor_map/motor_map.md

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

docs/user/widgets/multi_waveform/multi_waveform.md

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

docs/user/widgets/position_indicator/position_indicator.md

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

docs/user/widgets/positioner_box/positioner_box.md

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

docs/user/widgets/positioner_box/positioner_box_2d.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The `PositionerBox2D` widget is very similar to the `PositionerBox` but allows controlling two positioners at the same time, in a horizontal and vertical orientation respectively. It is intended primarily for controlling axes which have a perpendicular relationship like that. In other cases, it may be better to use a `PositionerGroup` instead. 
+The [`PositionerBox2D`](/api_reference/_autosummary/bec_widgets.cli.client.PositionerBox2D) widget is very similar to the [`PositionerBox`](/user/widgets/positioner_box/positioner_box) but allows controlling two positioners at the same time, in a horizontal and vertical orientation respectively. It is intended primarily for controlling axes which have a perpendicular relationship like that. In other cases, it may be better to use a `PositionerGroup` instead. 
 
 The `PositionerBox2D` has the same features as the standard `PositionerBox`, but additionally, step buttons which move the positioner by the selected step size, and tweak buttons which move by a tenth of the selected step size.
 
@@ -55,8 +55,6 @@ self.positioner_box.set_positioner_verr("samy")
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.PositionerBox2D
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.PositionerBox2D.rst
 ```
 ````

docs/user/widgets/progress_bar/ring_progress_bar.md

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

docs/user/widgets/queue/queue.md

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

docs/user/widgets/scan_control/scan_control.md

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

docs/user/widgets/scatter_waveform/scatter_waveform.md

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

docs/user/widgets/signal_input/signal_input.md

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

docs/user/widgets/signal_label/signal_label.md

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

docs/user/widgets/spinner/spinner.md

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

docs/user/widgets/text_box/text_box.md

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

docs/user/widgets/toggle/toggle.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The {py:class}`~bec_widgets.cli.client.ToggleSwitch` widget provides a simple, customizable toggle switch that can be used to represent binary states (e.g., on/off, true/false) within a GUI. This widget is designed to be used directly in code or added through `BEC Designer`, making it versatile for various applications where a user-friendly switch is needed.
+The [`Toggle Switch`](/api_reference/_autosummary/bec_widgets.cli.client.ToggleSwitch) widget provides a simple, customizable toggle switch that can be used to represent binary states (e.g., on/off, true/false) within a GUI. This widget is designed to be used directly in code or added through `BEC Designer`, making it versatile for various applications where a user-friendly switch is needed.
 
 ## Key Features:
 - **Binary State Representation**: Represents a simple on/off state with a smooth toggle animation.

docs/user/widgets/waveform/waveform_widget.md

@@ -101,8 +101,6 @@ print(dap_bpm3a.dap_params)
 
 ````{tab} API
 ```{eval-rst}  
-.. autoclass:: bec_widgets.cli.client.Waveform
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.Waveform.rst
 ```
 ````

docs/user/widgets/website/website.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The {py:class}`~bec_widgets.cli.client.WebsiteWidget` is a versatile tool that allows users to display websites directly within the BEC GUI. This widget is useful for embedding documentation, dashboards, or any web-based tools within the application interface. It is designed to be integrated within a [`BECDockArea`](user.widgets.bec_dock_area) or used as an individual component in your application through `BEC Designer`.
+The [`Website Widget`](/api_reference/_autosummary/bec_widgets.cli.client.WebsiteWidget) is a versatile tool that allows users to display websites directly within the BEC GUI. This widget is useful for embedding documentation, dashboards, or any web-based tools within the application interface. It is designed to be integrated within a [`BECDockArea`](user.widgets.bec_dock_area) or used as an individual component in your application through `BEC Designer`.
 
 ## Key Features:
 - **URL Display**: Set and display any website URL within the widget.
@@ -66,8 +66,6 @@ print(f"The current URL is: {current_url}")
 
 ````{tab} API
 ```{eval-rst} 
-.. autoclass:: bec_widgets.cli.client.WebsiteWidget
-   :members:
-   :show-inheritance:
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.WebsiteWidget.rst
 ```
 ````

pyproject.toml

@@ -4,9 +4,9 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "2.39.0"
+version = "2.38.0"
 description = "BEC Widgets"
-requires-python = ">=3.11"
+requires-python = ">=3.10"
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Programming Language :: Python :: 3",
@@ -23,8 +23,7 @@ dependencies = [
     "PySide6==6.9.0",
     "qtconsole~=5.5, >=5.5.1",   # needed for jupyter console
     "qtpy~=2.4",
-    "thefuzz~=0.22",
-    "qtmonaco~=0.7",
+    "qtmonaco~=0.5",
     "darkdetect~=0.8",
     "PySide6-QtAds==4.4.0",
 ]
@@ -44,7 +43,7 @@ dev = [
     "pytest-cov~=6.1.1",
     "watchdog~=6.0",
     "pre_commit~=4.2",
-
+    "thefuzz~=0.22",
 ]
 
 [project.urls]

tests/end-2-end/user_interaction/test_user_interaction_e2e.py

@@ -139,6 +139,25 @@ def maybe_remove_dock_area(qtbot, gui: BECGuiClient, random_int_gen: random.Rand
         )
 
 
+@pytest.mark.timeout(PYTEST_TIMEOUT)
+def test_widgets_e2e_abort_button(qtbot, connected_client_gui_obj, random_generator_from_seed):
+    """Test the AbortButton widget."""
+    gui: BECGuiClient = connected_client_gui_obj
+    bec = gui._client
+    # Create dock_area, dock, widget
+    dock, widget = create_widget(qtbot, gui, gui.available_widgets.AbortButton)
+    dock: client.BECDock
+    widget: client.AbortButton
+
+    # No rpc calls to check so far
+
+    # Try detaching the dock
+    dock.detach()
+
+    # Test removing the widget, or leaving it open for the next test
+    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
 @pytest.mark.timeout(PYTEST_TIMEOUT)
 def test_widgets_e2e_bec_progress_bar(qtbot, connected_client_gui_obj, random_generator_from_seed):
     """Test the BECProgressBar widget."""
@@ -352,13 +371,6 @@ def test_widgets_e2e_image(qtbot, connected_client_gui_obj, random_generator_fro
     )  # Get last image from Redis monitor 2D endpoint
     assert np.allclose(img.get_data(), last_img)
 
-    # Now add a device with a preview signal
-    img = widget.image(["eiger", "preview"])
-    s = scans.line_scan(dev.samx, -3, 3, steps=50, exp_time=0.01, relative=False)
-    s.wait()
-
-    qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
-
     # Test removing the widget, or leaving it open for the next test
     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
@@ -565,13 +577,6 @@ def test_widgets_e2e_ring_progress_bar(qtbot, connected_client_gui_obj, random_g
     dock: client.BECDock
     widget: client.RingProgressBar
 
-    widget.set_number_of_bars(3)
-    widget.rings[0].set_update("manual")
-    widget.rings[0].set_value(30)
-    widget.rings[0].set_min_max_values(0, 100)
-    widget.rings[1].set_update("scan")
-    widget.rings[2].set_update("device", device="samx")
-
     # Test rpc calls
     dev = bec.device_manager.devices
     scans = bec.scans
@@ -618,6 +623,53 @@ def test_widgets_e2e_scatter_waveform(qtbot, connected_client_gui_obj, random_ge
     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
 
+@pytest.mark.timeout(PYTEST_TIMEOUT)
+def test_widgets_e2e_stop_button(qtbot, connected_client_gui_obj, random_generator_from_seed):
+    """Test the StopButton widget"""
+    gui = connected_client_gui_obj
+    bec = gui._client
+    # Create dock_area, dock, widget
+    dock, widget = create_widget(qtbot, gui, gui.available_widgets.StopButton)
+    dock: client.BECDock
+    widget: client.StopButton
+
+    # No rpc calls to check so far
+
+    # Test removing the widget, or leaving it open for the next test
+    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
+@pytest.mark.timeout(PYTEST_TIMEOUT)
+def test_widgets_e2e_resume_button(qtbot, connected_client_gui_obj, random_generator_from_seed):
+    """Test the StopButton widget"""
+    gui = connected_client_gui_obj
+    bec = gui._client
+    # Create dock_area, dock, widget
+    dock, widget = create_widget(qtbot, gui, gui.available_widgets.ResumeButton)
+    dock: client.BECDock
+    widget: client.ResumeButton
+
+    # No rpc calls to check so far
+
+    # Test removing the widget, or leaving it open for the next test
+    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
+@pytest.mark.timeout(PYTEST_TIMEOUT)
+def test_widgets_e2e_reset_button(qtbot, connected_client_gui_obj, random_generator_from_seed):
+    """Test the StopButton widget"""
+    gui = connected_client_gui_obj
+    bec = gui._client
+    # Create dock_area, dock, widget
+    dock, widget = create_widget(qtbot, gui, gui.available_widgets.ResetButton)
+    dock: client.BECDock
+    widget: client.ResetButton
+    # No rpc calls to check so far
+
+    # Test removing the widget, or leaving it open for the next test
+    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
+
+
 @pytest.mark.timeout(PYTEST_TIMEOUT)
 def test_widgets_e2e_text_box(qtbot, connected_client_gui_obj, random_generator_from_seed):
     """Test the TextBox widget"""

tests/unit_tests/test_app_side_bar.py

@@ -1,189 +0,0 @@
-import pytest
-from qtpy.QtCore import QParallelAnimationGroup, QSize
-
-from bec_widgets.applications.navigation_centre.side_bar import SideBar
-from bec_widgets.applications.navigation_centre.side_bar_components import (
-    NavigationItem,
-    SectionHeader,
-)
-
-ANIM_TEST_DURATION = 60  # ms
-
-
-def _run(group: QParallelAnimationGroup, qtbot, duration=ANIM_TEST_DURATION):
-    group.start()
-    qtbot.wait(duration + 100)
-
-
-@pytest.fixture
-def header(qtbot):
-    w = SectionHeader(text="Group", anim_duration=ANIM_TEST_DURATION)
-    qtbot.addWidget(w)
-    qtbot.waitExposed(w)
-    return w
-
-
-def test_section_header_initial_state_collapsed(header):
-    # RevealAnimator is initially collapsed for the label
-    assert header.lbl.maximumWidth() == 0
-    assert header.lbl.maximumHeight() == 0
-
-
-def test_section_header_animates_reveal_and_hide(header, qtbot):
-    group = QParallelAnimationGroup()
-    for anim in header.build_animations():
-        group.addAnimation(anim)
-
-    # Expand
-    header.setup_animations(True)
-    _run(group, qtbot)
-    sh = header.lbl.sizeHint()
-    assert header.lbl.maximumWidth() >= sh.width()
-    assert header.lbl.maximumHeight() >= sh.height()
-
-    # Collapse
-    header.setup_animations(False)
-    _run(group, qtbot)
-    assert header.lbl.maximumWidth() == 0
-    assert header.lbl.maximumHeight() == 0
-
-
-@pytest.fixture
-def nav(qtbot):
-    w = NavigationItem(
-        title="Counter", icon_name="widgets", mini_text="cnt", anim_duration=ANIM_TEST_DURATION
-    )
-    qtbot.addWidget(w)
-    qtbot.waitExposed(w)
-    return w
-
-
-def test_build_animations_contains(nav):
-    lst = nav.build_animations()
-    assert len(lst) == 5
-
-
-def test_setup_animations_changes_targets(nav, qtbot):
-    group = QParallelAnimationGroup()
-    for a in nav.build_animations():
-        group.addAnimation(a)
-
-    # collapsed -> expanded
-    nav.setup_animations(True)
-    _run(group, qtbot)
-
-    sh_title = nav.title_lbl.sizeHint()
-    assert nav.title_lbl.maximumWidth() >= sh_title.width()
-    assert nav.mini_lbl.maximumHeight() == 0
-    assert nav.icon_btn.iconSize() == QSize(26, 26)
-
-    # expanded -> collapsed
-    nav.setup_animations(False)
-    _run(group, qtbot)
-    assert nav.title_lbl.maximumWidth() == 0
-    sh_mini = nav.mini_lbl.sizeHint()
-    assert nav.mini_lbl.maximumHeight() >= sh_mini.height()
-    assert nav.icon_btn.iconSize() == QSize(20, 20)
-
-
-def test_activation_signal_emits(nav, qtbot):
-    with qtbot.waitSignal(nav.activated, timeout=1000):
-        nav.icon_btn.click()
-
-
-@pytest.fixture
-def sidebar(qtbot):
-    sb = SideBar(title="Controls", anim_duration=ANIM_TEST_DURATION)
-    qtbot.addWidget(sb)
-    qtbot.waitExposed(sb)
-    return sb
-
-
-def test_add_section_and_separator(sidebar):
-    sec = sidebar.add_section("Group A", id="group_a")
-    assert sec is not None
-    sep = sidebar.add_separator()
-    assert sep is not None
-    assert sidebar.content_layout.indexOf(sep) != -1
-
-
-def test_add_item_top_and_bottom_positions(sidebar):
-    top_item = sidebar.add_item(icon="widgets", title="Top", id="top")
-    bottom_item = sidebar.add_item(icon="widgets", title="Bottom", id="bottom", from_top=False)
-
-    i_spacer = sidebar.content_layout.indexOf(sidebar._bottom_spacer)
-    i_top = sidebar.content_layout.indexOf(top_item)
-    i_bottom = sidebar.content_layout.indexOf(bottom_item)
-
-    assert i_top != -1 and i_bottom != -1
-    assert i_bottom > i_spacer  # bottom items go after the spacer
-
-
-def test_selection_exclusive_and_nonexclusive(sidebar, qtbot):
-    a = sidebar.add_item(icon="widgets", title="A", id="a", exclusive=True)
-    b = sidebar.add_item(icon="widgets", title="B", id="b", exclusive=True)
-    c = sidebar.add_item(icon="widgets", title="C", id="c", exclusive=False)
-
-    c._emit_activated()
-    qtbot.wait(10)
-    assert c.is_active() is True
-
-    a._emit_activated()
-    qtbot.wait(10)
-    assert a.is_active() is True
-    assert b.is_active() is False
-    assert c.is_active() is True
-
-    b._emit_activated()
-    qtbot.wait(200)
-    assert a.is_active() is False
-    assert b.is_active() is True
-    assert c.is_active() is True
-
-
-def test_on_expand_configures_targets_and_shows_title(sidebar, qtbot):
-    # Start collapsed
-    assert sidebar._is_expanded is False
-    start_w = sidebar.width()
-
-    sidebar.on_expand()
-
-    assert sidebar.width_anim.startValue() == start_w
-    assert sidebar.width_anim.endValue() == sidebar._expanded_width
-    assert sidebar.title_anim.endValue() == 1.0
-
-
-def test__on_anim_finished_hides_on_collapse_and_resets_alignment(sidebar, qtbot):
-    # Add one item so set_visible is called on components too
-    item = sidebar.add_item(icon="widgets", title="Item", id="item")
-
-    # Expand first
-    sidebar.on_expand()
-    qtbot.wait(ANIM_TEST_DURATION + 150)
-    assert sidebar._is_expanded is True
-
-    # Now collapse
-    sidebar.on_expand()
-    # Wait for animation group to finish and _on_anim_finished to run
-    with qtbot.waitSignal(sidebar.group.finished, timeout=2000):
-        pass
-
-    # Collapsed state
-    assert sidebar._is_expanded is False
-
-
-def test_dark_mode_item_is_action(sidebar, qtbot, monkeypatch):
-    dm = sidebar.add_dark_mode_item()
-
-    called = {"toggled": False}
-
-    def fake_apply(theme):
-        called["toggled"] = True
-
-    monkeypatch.setattr("bec_widgets.utils.colors.apply_theme", fake_apply, raising=False)
-
-    before = dm.is_active()
-    dm._emit_activated()
-    qtbot.wait(200)
-    assert called["toggled"] is True
-    assert dm.is_active() == before

tests/unit_tests/test_available_device_resources.py

@@ -0,0 +1,78 @@
+from copy import copy
+
+import pytest
+
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.device_resource_backend import (
+    HashableDevice,
+    _HashableDeviceSet,
+)
+
+TEST_DEVICE_DICT = {
+    "name": "test_device",
+    "deviceClass": "TestDeviceClass",
+    "readoutPriority": "baseline",
+    "enabled": True,
+}
+
+
+def _test_device_dict(**kwargs):
+    new = copy(TEST_DEVICE_DICT)
+    new.update(kwargs)
+    return new
+
+
+@pytest.mark.parametrize(
+    "kwargs_1, kwargs_2, kwargs_3, kwargs_4, n",
+    [
+        ({}, {}, {}, {}, 1),
+        ({}, {}, {}, {"deviceConfig": {"a": 1}}, 1),
+        ({}, {}, {}, {"name": "test_device_2"}, 2),
+        ({}, {}, {"name": "test_device_2"}, {"deviceClass": "OtherDeviceClass"}, 3),
+    ],
+)
+def test_hashable_device_set_merges_equal(kwargs_1, kwargs_2, kwargs_3, kwargs_4, n):
+    item_1 = HashableDevice(**_test_device_dict(**kwargs_1))
+    item_2 = HashableDevice(**_test_device_dict(**kwargs_2))
+    item_3 = HashableDevice(**_test_device_dict(**kwargs_3))
+    item_4 = HashableDevice(**_test_device_dict(**kwargs_4))
+
+    test_set = _HashableDeviceSet((item_1, item_2, item_3, item_4))
+    assert len(test_set) == n
+
+
+def test_hashable_device_set_or_adds_sources():
+    item_1 = HashableDevice(**_test_device_dict(), source_files={"a", "b"})
+    item_2 = HashableDevice(**_test_device_dict(), source_files={"c", "d"})
+
+    set_1 = _HashableDeviceSet((item_1,))
+    set_2 = _HashableDeviceSet((item_2,))
+
+    combined = set_1 | set_2
+    assert len(combined) == 1
+    assert combined.pop().source_files == {"a", "b", "c", "d"}
+
+
+def test_hashable_device_set_or_adds_tags():
+    item_1 = HashableDevice(
+        **_test_device_dict(deviceTags={"tag1"}, deviceConfig={"param": "value"}),
+        source_files={"a", "b"},
+    )
+    item_2 = HashableDevice(
+        **_test_device_dict(deviceTags={"tag2"}, deviceConfig={"param": "value"}),
+        source_files={"c", "d"},
+    )
+    item_3 = HashableDevice(
+        **_test_device_dict(deviceTags={"tag3"}, deviceConfig={"param": "other_value"}),
+        source_files={"q"},
+    )
+
+    set_1 = _HashableDeviceSet((item_1,))
+    set_2 = _HashableDeviceSet((item_2,))
+    set_3 = _HashableDeviceSet((item_3,))
+
+    combined = sorted(set_1 | set_2 | set_3, key=lambda hd: hd.deviceConfig["param"])
+    assert len(combined) == 2
+    assert combined[0].source_files == {"q"}
+    assert combined[0].deviceTags == {"tag3"}
+    assert combined[1].source_files == {"a", "b", "c", "d"}
+    assert combined[1].deviceTags == {"tag1", "tag2"}