wip

refactor: use list of configs for general interfaces

.github/actions/bw_install/action.yml

@@ -53,6 +53,7 @@ runs:
         sudo apt-get update
         sudo apt-get install -y libgl1 libegl1 x11-utils libxkbcommon-x11-0 libdbus-1-3 xvfb
         sudo apt-get -y install libnss3 libxdamage1 libasound2t64 libatomic1 libxcursor1
+        sudo apt-get -y install ttyd
 
     - name: Install Python dependencies
       shell: bash

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/pytest-matrix.yml

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

.github/workflows/stale-issues.yml

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

.gitlab-ci.yml

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

.pylintrc

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

CHANGELOG.md

@@ -1,6 +1,210 @@
 # CHANGELOG
 
 
+## v2.41.1 (2025-10-15)
+
+### Bug Fixes
+
+- **dependencies**: Bec lib versions fixed
+  ([`3941050`](https://github.com/bec-project/bec_widgets/commit/3941050883a791f800ab7178af2435ac14f837b6))
+
+
+## v2.41.0 (2025-10-15)
+
+### Bug Fixes
+
+- **image_roi**: Delete button added to compact version
+  ([`ef27de4`](https://github.com/bec-project/bec_widgets/commit/ef27de40ceee8375d95a0f3a8e451b7d05d0ae2c))
+
+- **image_roi**: Rois can be removed with right click context menu
+  ([`37df95e`](https://github.com/bec-project/bec_widgets/commit/37df95ead8d6a07a6c5794a97a486d9f380004cc))
+
+### Build System
+
+- **bec_lib**: Version bump to 3.69.3
+  ([`28ac9c5`](https://github.com/bec-project/bec_widgets/commit/28ac9c5cc369bdfa712c70c45591243631c65066))
+
+### Features
+
+- **image_roi_tree**: Compact mode added
+  ([`c87a6cf`](https://github.com/bec-project/bec_widgets/commit/c87a6cfce9c36588b32f5279e63072bc2646c36f))
+
+### Refactoring
+
+- **serializer**: Upgrade to new serializer interface
+  ([`3d807ea`](https://github.com/bec-project/bec_widgets/commit/3d807eaa63980fd2bb11661696c4d8548fffde8c))
+
+### Testing
+
+- **deviceconfig-form-update**: Add onFailure default to test
+  ([`1dd20d5`](https://github.com/bec-project/bec_widgets/commit/1dd20d5986485f3bfe7ee02596ca23027ec4b756))
+
+
+## v2.40.0 (2025-10-08)
+
+### Bug Fixes
+
+- **curve_tree**: Fetching scan numbers directly from the bec client
+  ([`8111a4a`](https://github.com/bec-project/bec_widgets/commit/8111a4a21b7c1bd75316e9a1f1166b88ea52326d))
+
+- **curve_tree**: Safeguard fetching scan numbers from BEC client
+  ([`df8065e`](https://github.com/bec-project/bec_widgets/commit/df8065ea4000b24235520756515aa18f812bb390))
+
+- **curve_tree**: Scans are always fetched by scan ids
+  ([`20a59af`](https://github.com/bec-project/bec_widgets/commit/20a59af648a9808057df2226a3a3c12893cc5059))
+
+- **waveform**: Cleanup of scan_history dialog if not closed manually before widget
+  ([`d681ba5`](https://github.com/bec-project/bec_widgets/commit/d681ba538be9ccec45a1ebd412cbc33c8c7c0ae2))
+
+- **waveform**: Fetching scan number is not done from list but from .get_by_scan_number
+  ([`962ab77`](https://github.com/bec-project/bec_widgets/commit/962ab774e6afc73a321a5680e2862d9e41812888))
+
+- **waveform**: If scan id and scan number is provided, the scan is fetched from the scan id
+  ([`e59f27a`](https://github.com/bec-project/bec_widgets/commit/e59f27a22de490768c814c80642a7a91bebfef5b))
+
+- **waveform**: Safeguard added to the fetching history data
+  ([`540cfc3`](https://github.com/bec-project/bec_widgets/commit/540cfc37be65afcf721773564adc85de681a9d07))
+
+- **waveform**: Safeguard for _scan_history_closed
+  ([`2bf4896`](https://github.com/bec-project/bec_widgets/commit/2bf489600e96bb5b47d89bed261614f62c970ca9))
+
+- **waveform**: Safeguard for if scan_item is a list
+  ([`7e88a00`](https://github.com/bec-project/bec_widgets/commit/7e88a002b6ca40fc85fde993282b8706f140d9aa))
+
+- **waveform**: Update x suffix label with x property change, do not wait for next update cycle
+  ([`d19001c`](https://github.com/bec-project/bec_widgets/commit/d19001c94e652c0c3e18f8d7903fd1ccff1111cd))
+
+- **waveform**: X_data checked with is scalar instead of len()
+  ([`db7dd4f`](https://github.com/bec-project/bec_widgets/commit/db7dd4f8d4b1210e65c852f6193fc8cf0f4809a5))
+
+### Build System
+
+- **bec_lib**: Bec_lib dependency raised to 3.68
+  ([`2f3dc2c`](https://github.com/bec-project/bec_widgets/commit/2f3dc2ce6b7133fc5582bd6996a674590cf1002d))
+
+### Chores
+
+- Add dependabot config
+  ([`f25f865`](https://github.com/bec-project/bec_widgets/commit/f25f86522f0a2e9dd24ca862ea8de89873951f83))
+
+### Features
+
+- **waveform**: New type of curve - history curve
+  ([`f083dff`](https://github.com/bec-project/bec_widgets/commit/f083dff6128c6256443b49f54ab12b54f1b90d66))
+
+### Refactoring
+
+- **test_waveform**: Test waveform renamed
+  ([`2f798be`](https://github.com/bec-project/bec_widgets/commit/2f798be7b0d43d304ccbd0e992a9d62f1aa1dd5f))
+
+- **waveform**: Separate method to fetch scan item from history
+  ([`4be7058`](https://github.com/bec-project/bec_widgets/commit/4be70580a60293204b135c6ea77978f1dcf8aa5f))
+
+### Testing
+
+- **conftest**: Suppress_message_box for error popups fixture autouse True
+  ([`0844a9e`](https://github.com/bec-project/bec_widgets/commit/0844a9e11975a34780b1dc413f5145517d1a1a22))
+
+- **plotting_framework_e2e**: Fetching history curve
+  ([`a006f95`](https://github.com/bec-project/bec_widgets/commit/a006f95f211ad115019967e365a6627d9678a1e3))
+
+- **waveform,curve_tree**: Test extended to cover history curve behaviour
+  ([`5a5d323`](https://github.com/bec-project/bec_widgets/commit/5a5d32312b08e1edeb69243daddfaaa9bac22273))
+
+
+## v2.39.1 (2025-10-07)
+
+### Bug Fixes
+
+- Explicitly pass the cached readout flag
+  ([`50696bc`](https://github.com/bec-project/bec_widgets/commit/50696bce4ce14c61b4bdda8c6fb40967972e6b23))
+
+
+## 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.10%20%7C%203.11%20%7C%203.12-blue?logo=python&logoColor=white)](https://www.python.org)
+[![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue?logo=python&logoColor=white)](https://www.python.org)
 [![PySide6](https://img.shields.io/badge/PySide6-blue?logo=qt&logoColor=white)](https://doc.qt.io/qtforpython/)
 [![Conventional Commits](https://img.shields.io/badge/conventional%20commits-1.0.0-yellow?logo=conventionalcommits&logoColor=white)](https://conventionalcommits.org)
 [![codecov](https://codecov.io/gh/bec-project/bec_widgets/graph/badge.svg?token=0Z9IQRJKMY)](https://codecov.io/gh/bec-project/bec_widgets)

bec_widgets/applications/main_app.py

@@ -0,0 +1,226 @@
+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.developer_view.developer_view import DeveloperView
+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.developer_view = DeveloperView(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",
+        )
+        self.add_view(
+            icon="code_blocks",
+            title="IDE",
+            widget=self.developer_view,
+            id="developer_view",
+            exclusive=True,
+        )
+
+        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
+            view_widget.view_id = id
+            view_widget.view_title = title
+        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)
+
+    screen = app.primaryScreen()
+    screen_geometry = screen.availableGeometry()
+    screen_width = screen_geometry.width()
+    screen_height = screen_geometry.height()
+    # 70% of screen height, keep 16:9 ratio
+    height = int(screen_height * 0.9)
+    width = int(height * (16 / 9))
+
+    # If width exceeds screen width, scale down
+    if width > screen_width * 0.9:
+        width = int(screen_width * 0.9)
+        height = int(width / (16 / 9))
+
+    w.resize(width, height)
+    w.show()
+
+    sys.exit(app.exec())

bec_widgets/applications/navigation_centre/reveal_animator.py

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

bec_widgets/applications/navigation_centre/side_bar.py

@@ -0,0 +1,358 @@
+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.QtGui import QIcon
+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", icon_type=QIcon))
+        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",
+                icon_type=QIcon,
+            )
+        )
+
+        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",
+                icon_type=QIcon,
+            )
+        )
+        # Refresh each component that supports it
+        for comp in self.components.values():
+            if hasattr(comp, "refresh_theme"):
+                comp.refresh_theme()
+            else:
+                comp.style().unpolish(comp)
+                comp.style().polish(comp)
+                comp.update()
+        self.style().unpolish(self)
+        self.style().polish(self)
+        self.update()
+
+    def add_section(self, title: str, id: str, position: int | None = None) -> SectionHeader:
+        """
+        Add a section header to the side bar.
+
+        Args:
+            title(str): The title of the section.
+            id(str): Unique ID for the section.
+            position(int, optional): Position to insert the section header.
+
+        Returns:
+            SectionHeader: The created section header.
+
+        """
+        header = SectionHeader(self, title, anim_duration=self._anim_duration)
+        position = position if position is not None else self.content_layout.count() - 1
+        self.content_layout.insertWidget(position, header)
+        for anim in header.animations:
+            self.group.addAnimation(anim)
+        self.components[id] = header
+        return header
+
+    def add_separator(
+        self, *, from_top: bool = True, position: int | None = None
+    ) -> SideBarSeparator:
+        """
+        Add a separator line to the side bar. Separators are treated like regular
+        items; you can place multiple separators anywhere using `from_top` and `position`.
+        """
+        line = SideBarSeparator(self)
+        line.setStyleSheet("margin:12px;")
+        self._insert_nav_item(line, from_top=from_top, position=position)
+        return line
+
+    def add_item(
+        self,
+        icon: str,
+        title: str,
+        id: str,
+        mini_text: str | None = None,
+        position: int | None = None,
+        *,
+        from_top: bool = True,
+        toggleable: bool = True,
+        exclusive: bool = True,
+    ) -> NavigationItem:
+        """
+        Add a navigation item to the side bar.
+
+        Args:
+            icon(str): Icon name for the nav item.
+            title(str): Title for the nav item.
+            id(str): Unique ID for the nav item.
+            mini_text(str, optional): Short text for the nav item when sidebar is collapsed.
+            position(int, optional): Position to insert the nav item.
+            from_top(bool, optional): Whether to count position from the top or bottom.
+            toggleable(bool, optional): Whether the nav item is toggleable.
+            exclusive(bool, optional): Whether the nav item is exclusive.
+
+        Returns:
+            NavigationItem: The created navigation item.
+        """
+        item = NavigationItem(
+            parent=self,
+            title=title,
+            icon_name=icon,
+            mini_text=mini_text,
+            toggleable=toggleable,
+            exclusive=exclusive,
+            anim_duration=self._anim_duration,
+        )
+        self._insert_nav_item(item, from_top=from_top, position=position)
+        for anim in item.build_animations():
+            self.group.addAnimation(anim)
+        self.components[id] = item
+        # Connect activation to activation logic, passing id unchanged
+        item.activated.connect(lambda id=id: self.activate_item(id))
+        return item
+
+    def activate_item(self, target_id: str, *, emit_signal: bool = True):
+        target = self.components.get(target_id)
+        if target is None:
+            return
+        # Non-toggleable acts like an action: do not change any toggled states
+        if hasattr(target, "toggleable") and not target.toggleable:
+            self._active_id = target_id
+            if emit_signal:
+                self.view_selected.emit(target_id)
+            return
+
+        is_exclusive = getattr(target, "exclusive", True)
+        if is_exclusive:
+            # Radio-like behavior among exclusive items only
+            for comp_id, comp in self.components.items():
+                if not isinstance(comp, NavigationItem):
+                    continue
+                if comp is target:
+                    comp.set_active(True)
+                else:
+                    # Only untoggle other items that are also exclusive
+                    if getattr(comp, "exclusive", True):
+                        comp.set_active(False)
+                    # Leave non-exclusive items as they are
+        else:
+            # Non-exclusive toggles independently
+            target.set_active(not target.is_active())
+
+        self._active_id = target_id
+        if emit_signal:
+            self.view_selected.emit(target_id)
+
+    def add_dark_mode_item(
+        self, id: str = "dark_mode", position: int | None = None
+    ) -> DarkModeNavItem:
+        """
+        Add a dark mode toggle item to the side bar.
+
+        Args:
+            id(str): Unique ID for the dark mode item.
+            position(int, optional): Position to insert the dark mode item.
+
+        Returns:
+            DarkModeNavItem: The created dark mode navigation item.
+        """
+        item = DarkModeNavItem(parent=self, id=id, anim_duration=self._anim_duration)
+        # compute bottom insertion point (same semantics as from_top=False)
+        self._insert_nav_item(item, from_top=False, position=position)
+        for anim in item.build_animations():
+            self.group.addAnimation(anim)
+        self.components[id] = item
+        item.activated.connect(lambda id=id: self.activate_item(id))
+        return item
+
+    def _insert_nav_item(
+        self, item: QWidget, *, from_top: bool = True, position: int | None = None
+    ):
+        if from_top:
+            base_index = self.content_layout.indexOf(self._bottom_spacer)
+            pos = base_index if position is None else min(base_index, position)
+        else:
+            base = self.content_layout.indexOf(self._bottom_spacer) + 1
+            pos = base if position is None else base + max(0, position)
+        self.content_layout.insertWidget(pos, item)

bec_widgets/applications/navigation_centre/side_bar_components.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+
+from qtpy.QtGui import QIcon
+
+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, icon_type=QIcon))
+        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(), icon_type=QIcon
+            )
+        else:
+            new_icon = material_icon(self._icon_name, filled=False, color=get_fg(), icon_type=QIcon)
+        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", icon_type=QIcon)
+        )
+
+    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/developer_view/developer_view.py

@@ -0,0 +1,63 @@
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.applications.views.developer_view.developer_widget import DeveloperWidget
+from bec_widgets.applications.views.view import ViewBase
+
+
+class DeveloperView(ViewBase):
+    """
+    A view for users to write scripts and macros and execute them within the application.
+    """
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        content: QWidget | None = None,
+        *,
+        id: str | None = None,
+        title: str | None = None,
+    ):
+        super().__init__(parent=parent, content=content, id=id, title=title)
+        self.developer_widget = DeveloperWidget(parent=self)
+        self.set_content(self.developer_widget)
+
+        # Apply stretch after the layout is done
+        self.set_default_view([2, 5, 3], [7, 3])
+
+
+if __name__ == "__main__":
+    import sys
+
+    from bec_qthemes import apply_theme
+    from qtpy.QtWidgets import QApplication
+
+    from bec_widgets.applications.main_app import BECMainApp
+
+    app = QApplication(sys.argv)
+    apply_theme("dark")
+
+    _app = BECMainApp()
+    screen = app.primaryScreen()
+    screen_geometry = screen.availableGeometry()
+    screen_width = screen_geometry.width()
+    screen_height = screen_geometry.height()
+    # 70% of screen height, keep 16:9 ratio
+    height = int(screen_height * 0.9)
+    width = int(height * (16 / 9))
+
+    # If width exceeds screen width, scale down
+    if width > screen_width * 0.9:
+        width = int(screen_width * 0.9)
+        height = int(width / (16 / 9))
+
+    _app.resize(width, height)
+    developer_view = DeveloperView()
+    _app.add_view(
+        icon="code_blocks", title="IDE", widget=developer_view, id="developer_view", exclusive=True
+    )
+    _app.show()
+    # developer_view.show()
+    # developer_view.setWindowTitle("Developer View")
+    # developer_view.resize(1920, 1080)
+    # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime
+    sys.exit(app.exec_())

bec_widgets/applications/views/developer_view/developer_widget.py

@@ -0,0 +1,347 @@
+import re
+
+import markdown
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.script_executor import upload_script
+from bec_qthemes import material_icon
+from qtpy.QtGui import QKeySequence, QShortcut
+from qtpy.QtWidgets import QTextEdit, QVBoxLayout, QWidget
+from shiboken6 import isValid
+
+import bec_widgets.widgets.containers.ads as QtAds
+from bec_widgets import BECWidget
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.toolbars.actions import MaterialIconAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle
+from bec_widgets.utils.toolbars.toolbar import ModularToolBar
+from bec_widgets.widgets.containers.ads import CDockManager, CDockWidget
+from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
+from bec_widgets.widgets.editors.monaco.monaco_dock import MonacoDock
+from bec_widgets.widgets.editors.web_console.web_console import WebConsole
+from bec_widgets.widgets.utility.ide_explorer.ide_explorer import IDEExplorer
+
+
+def markdown_to_html(md_text: str) -> str:
+    """Convert Markdown with syntax highlighting to HTML (Qt-compatible)."""
+
+    # Preprocess: convert consecutive >>> lines to Python code blocks
+    def replace_python_examples(match):
+        indent = match.group(1)
+        examples = match.group(2)
+        # Remove >>> prefix and clean up the code
+        lines = []
+        for line in examples.strip().split("\n"):
+            line = line.strip()
+            if line.startswith(">>> "):
+                lines.append(line[4:])  # Remove '>>> '
+            elif line.startswith(">>>"):
+                lines.append(line[3:])  # Remove '>>>'
+        code = "\n".join(lines)
+
+        return f"{indent}```python\n{indent}{code}\n{indent}```"
+
+    # Match one or more consecutive >>> lines (with same indentation)
+    pattern = r"^(\s*)((?:>>> .+(?:\n|$))+)"
+    md_text = re.sub(pattern, replace_python_examples, md_text, flags=re.MULTILINE)
+
+    extensions = ["fenced_code", "codehilite", "tables", "sane_lists"]
+    html = markdown.markdown(
+        md_text,
+        extensions=extensions,
+        extension_configs={
+            "codehilite": {"linenums": False, "guess_lang": False, "noclasses": True}
+        },
+        output_format="html",
+    )
+
+    # Remove hardcoded background colors that conflict with themes
+    html = re.sub(r'style="background: #[^"]*"', 'style="background: transparent"', html)
+    html = re.sub(r"background: #[^;]*;", "", html)
+
+    # Add CSS to force code blocks to wrap
+    css = """
+    <style>
+    pre, code {
+        white-space: pre-wrap !important;
+        word-wrap: break-word !important;
+        overflow-wrap: break-word !important;
+    }
+    .codehilite pre {
+        white-space: pre-wrap !important;
+        word-wrap: break-word !important;
+        overflow-wrap: break-word !important;
+    }
+    </style>
+    """
+
+    return css + html
+
+
+class DeveloperWidget(BECWidget, QWidget):
+
+    def __init__(self, parent=None, **kwargs):
+        super().__init__(parent=parent, **kwargs)
+
+        # Top-level layout hosting a toolbar and the dock manager
+        self._root_layout = QVBoxLayout(self)
+        self._root_layout.setContentsMargins(0, 0, 0, 0)
+        self._root_layout.setSpacing(0)
+        self.toolbar = ModularToolBar(self)
+        self.init_developer_toolbar()
+        self._root_layout.addWidget(self.toolbar)
+
+        self.dock_manager = CDockManager(self)
+        self.dock_manager.setStyleSheet("")
+        self._root_layout.addWidget(self.dock_manager)
+
+        # Initialize the widgets
+        self.explorer = IDEExplorer(self)
+        self.console = WebConsole(self)
+        self.terminal = WebConsole(self, startup_cmd="")
+        self.monaco = MonacoDock(self)
+        self.monaco.save_enabled.connect(self._on_save_enabled_update)
+        self.plotting_ads = AdvancedDockArea(self, mode="plot", default_add_direction="bottom")
+        self.signature_help = QTextEdit(self)
+        self.signature_help.setAcceptRichText(True)
+        self.signature_help.setReadOnly(True)
+        self.signature_help.setLineWrapMode(QTextEdit.LineWrapMode.WidgetWidth)
+        opt = self.signature_help.document().defaultTextOption()
+        opt.setWrapMode(opt.WrapMode.WrapAnywhere)
+        self.signature_help.document().setDefaultTextOption(opt)
+        self.monaco.signature_help.connect(
+            lambda text: self.signature_help.setHtml(markdown_to_html(text))
+        )
+        self._current_script_id: str | None = None
+
+        # Create the dock widgets
+        self.explorer_dock = QtAds.CDockWidget("Explorer", self)
+        self.explorer_dock.setWidget(self.explorer)
+
+        self.console_dock = QtAds.CDockWidget("Console", self)
+        self.console_dock.setWidget(self.console)
+
+        self.monaco_dock = QtAds.CDockWidget("Monaco Editor", self)
+        self.monaco_dock.setWidget(self.monaco)
+
+        self.terminal_dock = QtAds.CDockWidget("Terminal", self)
+        self.terminal_dock.setWidget(self.terminal)
+
+        # Monaco will be central widget
+        self.dock_manager.setCentralWidget(self.monaco_dock)
+
+        # Add the dock widgets to the dock manager
+        area_bottom = self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.BottomDockWidgetArea, self.console_dock
+        )
+        self.dock_manager.addDockWidgetTabToArea(self.terminal_dock, area_bottom)
+
+        area_left = self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.LeftDockWidgetArea, self.explorer_dock
+        )
+        area_left.titleBar().setVisible(False)
+
+        for dock in self.dock_manager.dockWidgets():
+            # dock.setFeature(CDockWidget.DockWidgetDeleteOnClose, True)#TODO implement according to MonacoDock or AdvancedDockArea
+            # dock.setFeature(CDockWidget.CustomCloseHandling, True) #TODO same
+            dock.setFeature(CDockWidget.DockWidgetFeature.DockWidgetClosable, False)
+            dock.setFeature(CDockWidget.DockWidgetFeature.DockWidgetFloatable, False)
+            dock.setFeature(CDockWidget.DockWidgetFeature.DockWidgetMovable, False)
+
+        self.plotting_ads_dock = QtAds.CDockWidget("Plotting Area", self)
+        self.plotting_ads_dock.setWidget(self.plotting_ads)
+
+        self.signature_dock = QtAds.CDockWidget("Signature Help", self)
+        self.signature_dock.setWidget(self.signature_help)
+
+        area_right = self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.RightDockWidgetArea, self.plotting_ads_dock
+        )
+        self.dock_manager.addDockWidgetTabToArea(self.signature_dock, area_right)
+
+        # Connect editor signals
+        self.explorer.file_open_requested.connect(self._open_new_file)
+        self.monaco.macro_file_updated.connect(self.explorer.refresh_macro_file)
+
+        self.toolbar.show_bundles(["save", "execution", "settings"])
+
+    def init_developer_toolbar(self):
+        """Initialize the developer toolbar with necessary actions and widgets."""
+        save_button = MaterialIconAction(
+            icon_name="save", tooltip="Save", label_text="Save", filled=True, parent=self
+        )
+        save_button.action.triggered.connect(self.on_save)
+        self.toolbar.components.add_safe("save", save_button)
+
+        save_as_button = MaterialIconAction(
+            icon_name="save_as", tooltip="Save As", label_text="Save As", parent=self
+        )
+        self.toolbar.components.add_safe("save_as", save_as_button)
+        save_as_button.action.triggered.connect(self.on_save_as)
+
+        save_bundle = ToolbarBundle("save", self.toolbar.components)
+        save_bundle.add_action("save")
+        save_bundle.add_action("save_as")
+        self.toolbar.add_bundle(save_bundle)
+
+        run_action = MaterialIconAction(
+            icon_name="play_arrow",
+            tooltip="Run current file",
+            label_text="Run",
+            filled=True,
+            parent=self,
+        )
+        run_action.action.triggered.connect(self.on_execute)
+        self.toolbar.components.add_safe("run", run_action)
+
+        stop_action = MaterialIconAction(
+            icon_name="stop",
+            tooltip="Stop current execution",
+            label_text="Stop",
+            filled=True,
+            parent=self,
+        )
+        stop_action.action.triggered.connect(self.on_stop)
+        self.toolbar.components.add_safe("stop", stop_action)
+
+        execution_bundle = ToolbarBundle("execution", self.toolbar.components)
+        execution_bundle.add_action("run")
+        execution_bundle.add_action("stop")
+        self.toolbar.add_bundle(execution_bundle)
+
+        vim_action = MaterialIconAction(
+            icon_name="vim",
+            tooltip="Toggle Vim Mode",
+            label_text="Vim",
+            filled=True,
+            parent=self,
+            checkable=True,
+        )
+        self.toolbar.components.add_safe("vim", vim_action)
+        vim_action.action.triggered.connect(self.on_vim_triggered)
+
+        settings_bundle = ToolbarBundle("settings", self.toolbar.components)
+        settings_bundle.add_action("vim")
+        self.toolbar.add_bundle(settings_bundle)
+
+        save_shortcut = QShortcut(QKeySequence("Ctrl+S"), self)
+        save_shortcut.activated.connect(self.on_save)
+        save_as_shortcut = QShortcut(QKeySequence("Ctrl+Shift+S"), self)
+        save_as_shortcut.activated.connect(self.on_save_as)
+
+    def _open_new_file(self, file_name: str, scope: str):
+        self.monaco.open_file(file_name, scope)
+
+        # Set read-only mode for shared files
+        if "shared" in scope:
+            self.monaco.set_file_readonly(file_name, True)
+
+        # Add appropriate icon based on file type
+        if "script" in scope:
+            # Use script icon for script files
+            icon = material_icon("script", size=(24, 24))
+            self.monaco.set_file_icon(file_name, icon)
+        elif "macro" in scope:
+            # Use function icon for macro files
+            icon = material_icon("function", size=(24, 24))
+            self.monaco.set_file_icon(file_name, icon)
+
+    @SafeSlot()
+    def on_save(self):
+        self.monaco.save_file()
+
+    @SafeSlot()
+    def on_save_as(self):
+        self.monaco.save_file(force_save_as=True)
+
+    @SafeSlot()
+    def on_vim_triggered(self):
+        self.monaco.set_vim_mode(self.toolbar.components.get_action("vim").action.isChecked())
+
+    @SafeSlot(bool)
+    def _on_save_enabled_update(self, enabled: bool):
+        self.toolbar.components.get_action("save").action.setEnabled(enabled)
+        self.toolbar.components.get_action("save_as").action.setEnabled(enabled)
+
+    @SafeSlot()
+    def on_execute(self):
+        self.script_editor_tab = self.monaco.last_focused_editor
+        if not self.script_editor_tab:
+            return
+        self.current_script_id = upload_script(
+            self.client.connector, self.script_editor_tab.widget().get_text()
+        )
+        self.console.write(f'bec._run_script("{self.current_script_id}")')
+        print(f"Uploaded script with ID: {self.current_script_id}")
+
+    @SafeSlot()
+    def on_stop(self):
+        if not self.current_script_id:
+            return
+        self.console.send_ctrl_c()
+
+    @property
+    def current_script_id(self):
+        return self._current_script_id
+
+    @current_script_id.setter
+    def current_script_id(self, value: str | None):
+        if value is not None and not isinstance(value, str):
+            raise ValueError("Script ID must be a string.")
+        old_script_id = self._current_script_id
+        self._current_script_id = value
+        self._update_subscription(value, old_script_id)
+
+    def _update_subscription(self, new_script_id: str | None, old_script_id: str | None):
+        if old_script_id is not None:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_script_execution_info, MessageEndpoints.script_execution_info(old_script_id)
+            )
+        if new_script_id is not None:
+            self.bec_dispatcher.connect_slot(
+                self.on_script_execution_info, MessageEndpoints.script_execution_info(new_script_id)
+            )
+
+    @SafeSlot(dict, dict)
+    def on_script_execution_info(self, content: dict, metadata: dict):
+        print(f"Script execution info: {content}")
+        current_lines = content.get("current_lines")
+        if not current_lines:
+            self.script_editor_tab.widget().clear_highlighted_lines()
+            return
+        line_number = current_lines[0]
+        self.script_editor_tab.widget().clear_highlighted_lines()
+        self.script_editor_tab.widget().set_highlighted_lines(line_number, line_number)
+
+    def cleanup(self):
+        for dock in self.dock_manager.dockWidgets():
+            self._delete_dock(dock)
+        return super().cleanup()
+
+    def _delete_dock(self, dock: CDockWidget) -> None:
+        w = dock.widget()
+        if w and isValid(w):
+            w.close()
+            w.deleteLater()
+        if isValid(dock):
+            dock.closeDockWidget()
+            dock.deleteDockWidget()
+
+
+if __name__ == "__main__":
+    import sys
+
+    from bec_qthemes import apply_theme
+    from qtpy.QtWidgets import QApplication
+
+    from bec_widgets.applications.main_app import BECMainApp
+
+    app = QApplication(sys.argv)
+    apply_theme("dark")
+
+    _app = BECMainApp()
+    _app.show()
+    # developer_view.show()
+    # developer_view.setWindowTitle("Developer View")
+    # developer_view.resize(1920, 1080)
+    # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime
+    sys.exit(app.exec_())

bec_widgets/applications/views/device_manager_view/device_manager_view.py

@@ -0,0 +1,687 @@
+from __future__ import annotations
+
+import os
+from functools import partial
+from typing import List, Literal
+
+import PySide6QtAds as QtAds
+import yaml
+from bec_lib import config_helper
+from bec_lib.bec_yaml_loader import yaml_load
+from bec_lib.file_utils import DeviceConfigWriter
+from bec_lib.logger import bec_logger
+from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path
+from bec_qthemes import apply_theme
+from PySide6QtAds import CDockManager, CDockWidget
+from qtpy.QtCore import Qt, QThreadPool, QTimer
+from qtpy.QtWidgets import (
+    QDialog,
+    QFileDialog,
+    QHBoxLayout,
+    QLabel,
+    QMessageBox,
+    QPushButton,
+    QSizePolicy,
+    QSplitter,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets import BECWidget
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.help_inspector.help_inspector import HelpInspector
+from bec_widgets.utils.toolbars.actions import MaterialIconAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle
+from bec_widgets.utils.toolbars.toolbar import ModularToolBar
+from bec_widgets.widgets.control.device_manager.components import (
+    DeviceTableView,
+    DMConfigView,
+    DMOphydTest,
+    DocstringView,
+)
+from bec_widgets.widgets.control.device_manager.components._util import SharedSelectionSignal
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_resources import (
+    AvailableDeviceResources,
+)
+from bec_widgets.widgets.services.device_browser.device_item.config_communicator import (
+    CommunicateConfigAction,
+)
+from bec_widgets.widgets.services.device_browser.device_item.device_config_dialog import (
+    PresetClassDeviceConfigDialog,
+)
+
+logger = bec_logger.logger
+
+_yes_no_question = partial(
+    QMessageBox.question,
+    buttons=QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+    defaultButton=QMessageBox.StandardButton.No,
+)
+
+
+def set_splitter_weights(splitter: QSplitter, weights: List[float]) -> None:
+    """
+    Apply initial sizes to a splitter using weight ratios, e.g. [1,3,2,1].
+    Works for horizontal or vertical splitters and sets matching stretch factors.
+    """
+
+    def apply():
+        n = splitter.count()
+        if n == 0:
+            return
+        w = list(weights[:n]) + [1] * max(0, n - len(weights))
+        w = [max(0.0, float(x)) for x in w]
+        tot_w = sum(w)
+        if tot_w <= 0:
+            w = [1.0] * n
+            tot_w = float(n)
+        total_px = (
+            splitter.width()
+            if splitter.orientation() == Qt.Orientation.Horizontal
+            else splitter.height()
+        )
+        if total_px < 2:
+            QTimer.singleShot(0, apply)
+            return
+        sizes = [max(1, int(total_px * (wi / tot_w))) for wi in w]
+        diff = total_px - sum(sizes)
+        if diff != 0:
+            idx = max(range(n), key=lambda i: w[i])
+            sizes[idx] = max(1, sizes[idx] + diff)
+        splitter.setSizes(sizes)
+        for i, wi in enumerate(w):
+            splitter.setStretchFactor(i, max(1, int(round(wi * 100))))
+
+    QTimer.singleShot(0, apply)
+
+
+class ConfigChoiceDialog(QDialog):
+    REPLACE = 1
+    ADD = 2
+    CANCEL = 0
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Load Config")
+        layout = QVBoxLayout(self)
+
+        label = QLabel("Do you want to replace the current config or add to it?")
+        label.setWordWrap(True)
+        layout.addWidget(label)
+
+        # Buttons: equal size, stacked vertically
+        self.replace_btn = QPushButton("Replace")
+        self.add_btn = QPushButton("Add")
+        self.cancel_btn = QPushButton("Cancel")
+        btn_layout = QHBoxLayout()
+        for btn in (self.replace_btn, self.add_btn, self.cancel_btn):
+            btn.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+            btn_layout.addWidget(btn)
+        layout.addLayout(btn_layout)
+
+        # Connect signals to explicit slots
+        self.replace_btn.clicked.connect(self.accept_replace)
+        self.add_btn.clicked.connect(self.accept_add)
+        self.cancel_btn.clicked.connect(self.reject_cancel)
+
+        self._result = self.CANCEL
+
+    def accept_replace(self):
+        self._result = self.REPLACE
+        self.accept()
+
+    def accept_add(self):
+        self._result = self.ADD
+        self.accept()
+
+    def reject_cancel(self):
+        self._result = self.CANCEL
+        self.reject()
+
+    def result(self):
+        return self._result
+
+
+AVAILABLE_RESOURCE_IS_READY = False
+
+
+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)
+
+        # Device Table View widget
+        self.device_table_view = DeviceTableView(
+            self, shared_selection_signal=self._shared_selection
+        )
+        self.device_table_view_dock = QtAds.CDockWidget(self.dock_manager, "Device Table", self)
+        self.device_table_view_dock.setWidget(self.device_table_view)
+
+        # Device Config View widget
+        self.dm_config_view = DMConfigView(self)
+        self.dm_config_view_dock = QtAds.CDockWidget(self.dock_manager, "Device Config View", self)
+        self.dm_config_view_dock.setWidget(self.dm_config_view)
+
+        # Docstring View
+        self.dm_docs_view = DocstringView(self)
+        self.dm_docs_view_dock = QtAds.CDockWidget(self.dock_manager, "Docstring View", self)
+        self.dm_docs_view_dock.setWidget(self.dm_docs_view)
+
+        # Ophyd Test view
+        self.ophyd_test_view = DMOphydTest(self)
+        self.ophyd_test_dock_view = QtAds.CDockWidget(self.dock_manager, "Ophyd Test View", self)
+        self.ophyd_test_dock_view.setWidget(self.ophyd_test_view)
+
+        # Help Inspector
+        widget = QWidget(self)
+        layout = QVBoxLayout(widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        self.help_inspector = HelpInspector(self)
+        layout.addWidget(self.help_inspector)
+        text_box = QTextEdit(self)
+        text_box.setReadOnly(False)
+        text_box.setPlaceholderText("Help text will appear here...")
+        layout.addWidget(text_box)
+        self.help_inspector_dock = QtAds.CDockWidget(self.dock_manager, "Help Inspector", self)
+        self.help_inspector_dock.setWidget(widget)
+
+        # Register callback
+        self.help_inspector.bec_widget_help.connect(text_box.setMarkdown)
+
+        # Error Logs View
+        self.error_logs_view = QTextEdit(self)
+        self.error_logs_view.setReadOnly(True)
+        self.error_logs_view.setPlaceholderText("Error logs will appear here...")
+        self.error_logs_dock = QtAds.CDockWidget(self.dock_manager, "Error Logs", self)
+        self.error_logs_dock.setWidget(self.error_logs_view)
+        self.ophyd_test_view.validation_msg_md.connect(self.error_logs_view.setMarkdown)
+
+        # Arrange widgets within the QtAds dock manager
+        # Central widget area
+        self.central_dock_area = self.dock_manager.setCentralWidget(self.device_table_view_dock)
+        # Right area - should be pushed into view if something is active
+        self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.RightDockWidgetArea,
+            self.ophyd_test_dock_view,
+            self.central_dock_area,
+        )
+        # create bottom area (2-arg -> area)
+        self.bottom_dock_area = self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.BottomDockWidgetArea, self.dm_docs_view_dock
+        )
+
+        # YAML view left of docstrings (docks relative to bottom area)
+        self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.LeftDockWidgetArea, self.dm_config_view_dock, self.bottom_dock_area
+        )
+
+        # Error/help area right of docstrings (dock relative to bottom area)
+        area = self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.RightDockWidgetArea,
+            self.help_inspector_dock,
+            self.bottom_dock_area,
+        )
+        self.dock_manager.addDockWidgetTabToArea(self.error_logs_dock, area)
+
+        for dock in self.dock_manager.dockWidgets():
+            dock.setFeature(CDockWidget.DockWidgetClosable, False)
+            dock.setFeature(CDockWidget.DockWidgetFloatable, False)
+            dock.setFeature(CDockWidget.DockWidgetMovable, False)
+
+        # Apply stretch after the layout is done
+        self.set_default_view([2, 8, 2], [7, 3])
+
+        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.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,),
+            ),
+        ]:
+            for slot in slots:
+                signal.connect(slot)
+
+        # Once available resource is ready, add it to the view again
+        if AVAILABLE_RESOURCE_IS_READY:
+            # Available Resources Widget
+            self.available_devices = AvailableDeviceResources(
+                self, shared_selection_signal=self._shared_selection
+            )
+            self.available_devices_dock = QtAds.CDockWidget(
+                self.dock_manager, "Available Devices", self
+            )
+            self.available_devices_dock.setWidget(self.available_devices)
+            # Connect slots for available reosource
+            for signal, slots in [
+                (
+                    self.available_devices.selected_devices,
+                    (self.dm_config_view.on_select_config, self.dm_docs_view.on_select_config),
+                ),
+                (
+                    self.device_table_view.device_configs_changed,
+                    (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)
+
+        # Add toolbar
+        self._add_toolbar()
+
+    def _add_toolbar(self):
+        self.toolbar = ModularToolBar(self)
+
+        # Add IO actions
+        self._add_io_actions()
+        self._add_table_actions()
+        self.toolbar.show_bundles(["IO", "Table"])
+        self._root_layout.insertWidget(0, self.toolbar)
+
+    def _add_io_actions(self):
+        # Create IO bundle
+        io_bundle = ToolbarBundle("IO", self.toolbar.components)
+
+        # Load from disk
+        load = MaterialIconAction(
+            text_position="under",
+            icon_name="file_open",
+            parent=self,
+            tooltip="Load configuration file from disk",
+            label_text="Load Config",
+        )
+        self.toolbar.components.add_safe("load", load)
+        load.action.triggered.connect(self._load_file_action)
+        io_bundle.add_action("load")
+
+        # Add safe to disk
+        save_to_disk = MaterialIconAction(
+            text_position="under",
+            icon_name="file_save",
+            parent=self,
+            tooltip="Save config to disk",
+            label_text="Save Config",
+        )
+        self.toolbar.components.add_safe("save_to_disk", save_to_disk)
+        save_to_disk.action.triggered.connect(self._save_to_disk_action)
+        io_bundle.add_action("save_to_disk")
+
+        # Add load config from redis
+        load_redis = MaterialIconAction(
+            text_position="under",
+            icon_name="cached",
+            parent=self,
+            tooltip="Load current config from Redis",
+            label_text="Get Current Config",
+        )
+        load_redis.action.triggered.connect(self._load_redis_action)
+        self.toolbar.components.add_safe("load_redis", load_redis)
+        io_bundle.add_action("load_redis")
+
+        # Update config action
+        update_config_redis = MaterialIconAction(
+            text_position="under",
+            icon_name="cloud_upload",
+            parent=self,
+            tooltip="Update current config in Redis",
+            label_text="Update Config",
+        )
+        update_config_redis.action.setEnabled(False)
+        update_config_redis.action.triggered.connect(self._update_redis_action)
+        self.toolbar.components.add_safe("update_config_redis", update_config_redis)
+        io_bundle.add_action("update_config_redis")
+
+        # Add load config from plugin dir
+        self.toolbar.add_bundle(io_bundle)
+
+    # Table actions
+
+    def _add_table_actions(self) -> None:
+        table_bundle = ToolbarBundle("Table", self.toolbar.components)
+
+        # Reset composed view
+        reset_composed = MaterialIconAction(
+            text_position="under",
+            icon_name="delete_sweep",
+            parent=self,
+            tooltip="Reset current composed config view",
+            label_text="Reset Config",
+        )
+        reset_composed.action.triggered.connect(self._reset_composed_view)
+        self.toolbar.components.add_safe("reset_composed", reset_composed)
+        table_bundle.add_action("reset_composed")
+
+        # Add device
+        add_device = MaterialIconAction(
+            text_position="under",
+            icon_name="add",
+            parent=self,
+            tooltip="Add new device",
+            label_text="Add Device",
+        )
+        add_device.action.triggered.connect(self._add_device_action)
+        self.toolbar.components.add_safe("add_device", add_device)
+        table_bundle.add_action("add_device")
+
+        # Remove device
+        remove_device = MaterialIconAction(
+            text_position="under",
+            icon_name="remove",
+            parent=self,
+            tooltip="Remove device",
+            label_text="Remove Device",
+        )
+        remove_device.action.triggered.connect(self._remove_device_action)
+        self.toolbar.components.add_safe("remove_device", remove_device)
+        table_bundle.add_action("remove_device")
+
+        # Rerun validation
+        rerun_validation = MaterialIconAction(
+            text_position="under",
+            icon_name="checklist",
+            parent=self,
+            tooltip="Run device validation with 'connect' on selected devices",
+            label_text="Validate Connection",
+        )
+        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)
+
+    # IO actions
+    def _coming_soon(self):
+        return QMessageBox.question(
+            self,
+            "Not implemented yet",
+            "This feature has not been implemented yet, will be coming soon...!!",
+            QMessageBox.StandardButton.Cancel,
+            QMessageBox.StandardButton.Cancel,
+        )
+
+    @SafeSlot()
+    def _load_file_action(self):
+        """Action for the 'load' action to load a config from disk for the io_bundle of the toolbar."""
+        try:
+            plugin_path = plugin_repo_path()
+            plugin_name = plugin_package_name()
+            config_path = os.path.join(plugin_path, plugin_name, "device_configs")
+        except ValueError:
+            # Get the recovery config path as fallback
+            config_path = self._get_recovery_config_path()
+            logger.warning(
+                f"No plugin repository installed, fallback to recovery config path: {config_path}"
+            )
+
+        # Implement the file loading logic here
+        start_dir = os.path.abspath(config_path)
+        file_path = self._get_file_path(start_dir, "open_file")
+        if file_path:
+            self._load_config_from_file(file_path)
+
+    def _get_file_path(self, start_dir: str, mode: Literal["open_file", "save_file"]) -> str:
+        if mode == "open_file":
+            file_path, _ = QFileDialog.getOpenFileName(
+                self, caption="Select Config File", dir=start_dir
+            )
+        else:
+            file_path, _ = QFileDialog.getSaveFileName(
+                self, caption="Save Config File", dir=start_dir
+            )
+        return file_path
+
+    def _load_config_from_file(self, file_path: str):
+        """
+        Load device config from a given file path and update the device table view.
+
+        Args:
+            file_path (str): Path to the configuration file.
+        """
+        try:
+            config = [{"name": k, **v} for k, v in yaml_load(file_path).items()]
+        except Exception as e:
+            logger.error(f"Failed to load config from file {file_path}. Error: {e}")
+            return
+        self._open_config_choice_dialog(config)
+
+    def _open_config_choice_dialog(self, config: List[dict]):
+        """
+        Open a dialog to choose whether to replace or add the loaded config.
+
+        Args:
+            config (List[dict]): List of device configurations loaded from the file.
+        """
+        dialog = ConfigChoiceDialog(self)
+        if dialog.exec():
+            if dialog.result() == ConfigChoiceDialog.REPLACE:
+                self.device_table_view.set_device_config(config)
+            elif dialog.result() == ConfigChoiceDialog.ADD:
+                self.device_table_view.add_device_configs(config)
+
+    # TODO would we ever like to add the current config to an existing composition
+    @SafeSlot()
+    def _load_redis_action(self):
+        """Action for the 'load_redis' action to load the current config from Redis for the io_bundle of the toolbar."""
+        reply = _yes_no_question(
+            self,
+            "Load currently active config",
+            "Do you really want to discard the current config and reload?",
+        )
+        if reply == QMessageBox.StandardButton.Yes and self.client.device_manager is not None:
+            self.device_table_view.set_device_config(
+                self.client.device_manager._get_redis_device_config()
+            )
+        else:
+            return
+
+    @SafeSlot()
+    def _update_redis_action(self) -> None | QMessageBox.StandardButton:
+        """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_composition_to_redis()
+
+    def _push_composition_to_redis(self):
+        config = {cfg.pop("name"): cfg for cfg in self.device_table_view.table.all_configs()}
+        threadpool = QThreadPool.globalInstance()
+        comm = CommunicateConfigAction(self._config_helper, None, config, "set")
+        threadpool.start(comm)
+
+    @SafeSlot()
+    def _save_to_disk_action(self):
+        """Action for the 'save_to_disk' action to save the current config to disk."""
+        # Check if plugin repo is installed...
+        try:
+            config_path = self._get_recovery_config_path()
+        except ValueError:
+            # Get the recovery config path as fallback
+            config_path = os.path.abspath(os.path.expanduser("~"))
+            logger.warning(f"Failed to find recovery config path, fallback to: {config_path}")
+
+        # Implement the file loading logic here
+        file_path = self._get_file_path(config_path, "save_file")
+        if file_path:
+            config = {cfg.pop("name"): cfg for cfg in self.device_table_view.get_device_config()}
+            with open(file_path, "w") as file:
+                file.write(yaml.dump(config))
+
+    # Table actions
+    @SafeSlot()
+    def _reset_composed_view(self):
+        """Action for the 'reset_composed_view' action to reset the composed view."""
+        reply = _yes_no_question(
+            self,
+            "Clear View",
+            "You are about to clear the current composed config view, please confirm...",
+        )
+        if reply == QMessageBox.StandardButton.Yes:
+            self.device_table_view.clear_device_configs()
+
+    # TODO Bespoke Form to add a new device
+    @SafeSlot()
+    def _add_device_action(self):
+        """Action for the 'add_device' action to add a new device."""
+        dialog = PresetClassDeviceConfigDialog(parent=self)
+        dialog.accepted_data.connect(self._add_to_table_from_dialog)
+        dialog.open()
+
+    @SafeSlot(dict)
+    def _add_to_table_from_dialog(self, data):
+        self.device_table_view.add_device_configs([data])
+
+    @SafeSlot()
+    def _remove_device_action(self):
+        """Action for the 'remove_device' action to remove a device."""
+        self.device_table_view.remove_selected_rows()
+
+    @SafeSlot()
+    @SafeSlot(bool)
+    def _rerun_validation_action(self, connect: bool = True):
+        """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, connect)
+
+    ####### Default view has to be done with setting up splitters ########
+    def set_default_view(
+        self, horizontal_weights: list, vertical_weights: list
+    ):  # TODO separate logic for all ads based widgets
+        """Apply initial weights to every horizontal and vertical splitter.
+
+        Examples:
+            horizontal_weights = [1, 3, 2, 1]
+            vertical_weights   = [3, 7]  # top:bottom = 30:70
+        """
+        splitters_h = []
+        splitters_v = []
+        for splitter in self.findChildren(QSplitter):
+            if splitter.orientation() == Qt.Orientation.Horizontal:
+                splitters_h.append(splitter)
+            elif splitter.orientation() == Qt.Orientation.Vertical:
+                splitters_v.append(splitter)
+
+        def apply_all():
+            for s in splitters_h:
+                set_splitter_weights(s, horizontal_weights)
+            for s in splitters_v:
+                set_splitter_weights(s, vertical_weights)
+
+        QTimer.singleShot(0, apply_all)
+
+    def set_stretch(
+        self, *, horizontal=None, vertical=None
+    ):  # TODO separate logic for all ads based widgets
+        """Update splitter weights and re-apply to all splitters.
+
+        Accepts either a list/tuple of weights (e.g., [1,3,2,1]) or a role dict
+        for convenience: horizontal roles = {"left","center","right"},
+        vertical roles = {"top","bottom"}.
+        """
+
+        def _coerce_h(x):
+            if x is None:
+                return None
+            if isinstance(x, (list, tuple)):
+                return list(map(float, x))
+            if isinstance(x, dict):
+                return [
+                    float(x.get("left", 1)),
+                    float(x.get("center", x.get("middle", 1))),
+                    float(x.get("right", 1)),
+                ]
+            return None
+
+        def _coerce_v(x):
+            if x is None:
+                return None
+            if isinstance(x, (list, tuple)):
+                return list(map(float, x))
+            if isinstance(x, dict):
+                return [float(x.get("top", 1)), float(x.get("bottom", 1))]
+            return None
+
+        h = _coerce_h(horizontal)
+        v = _coerce_v(vertical)
+        if h is None:
+            h = [1, 1, 1]
+        if v is None:
+            v = [1, 1]
+        self.set_default_view(h, v)
+
+    def _get_recovery_config_path(self) -> str:
+        """Get the recovery config path from the log_writer config."""
+        # pylint: disable=protected-access
+        log_writer_config = self.client._service_config.config.get("log_writer", {})
+        writer = DeviceConfigWriter(service_config=log_writer_config)
+        return os.path.abspath(os.path.expanduser(writer.get_recovery_directory()))
+
+
+if __name__ == "__main__":
+    import sys
+    from copy import deepcopy
+
+    from bec_lib.bec_yaml_loader import yaml_load
+    from qtpy.QtWidgets import QApplication
+
+    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
+    app = QApplication(sys.argv)
+    w = QWidget()
+    l = QVBoxLayout()
+    w.setLayout(l)
+    apply_theme("dark")
+    button = DarkModeButton()
+    l.addWidget(button)
+    device_manager_view = DeviceManagerView()
+    l.addWidget(device_manager_view)
+    # config_path = "/Users/appel_c/work_psi_awi/bec_workspace/csaxs_bec/csaxs_bec/device_configs/first_light.yaml"
+    # cfg = yaml_load(config_path)
+    # cfg.update({"device_will_fail": {"name": "device_will_fail", "some_param": 1}})
+
+    # # config = device_manager_view.client.device_manager._get_redis_device_config()
+    # device_manager_view.device_table_view.set_device_config(cfg)
+    w.show()
+    w.setWindowTitle("Device Manager View")
+    w.resize(1920, 1080)
+    # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime
+    sys.exit(app.exec_())

bec_widgets/applications/views/device_manager_view/device_manager_widget.py

@@ -8,8 +8,9 @@ from bec_lib.bec_yaml_loader import yaml_load
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from qtpy import QtCore, QtWidgets
+from qtpy.QtGui import QIcon
 
-from bec_widgets.examples.device_manager_view.device_manager_view import DeviceManagerView
+from bec_widgets.applications.views.device_manager_view.device_manager_view import DeviceManagerView
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeSlot
 
@@ -37,9 +38,6 @@ 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)
@@ -49,13 +47,13 @@ class DeviceManagerWidget(BECWidget, QtWidgets.QWidget):
         )
         # Load current config
         self.button_load_current_config = QtWidgets.QPushButton("Load Current Config")
-        icon = material_icon(icon_name="database", size=(24, 24), convert_to_pixmap=False)
+        icon = material_icon(icon_name="database", size=(24, 24), icon_type=QIcon)
         self.button_load_current_config.setIcon(icon)
         self._overlay_layout.addWidget(self.button_load_current_config)
         self.button_load_current_config.clicked.connect(self._load_config_clicked)
         # Load config from disk
         self.button_load_config_from_file = QtWidgets.QPushButton("Load Config From File")
-        icon = material_icon(icon_name="folder", size=(24, 24), convert_to_pixmap=False)
+        icon = material_icon(icon_name="folder", size=(24, 24), icon_type=QIcon)
         self.button_load_config_from_file.setIcon(icon)
         self._overlay_layout.addWidget(self.button_load_config_from_file)
         self.button_load_config_from_file.clicked.connect(self._load_config_from_file_clicked)
@@ -88,22 +86,34 @@ 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__":
+if __name__ == "__main__":  # pragma: no cover
     import sys
 
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
+    from bec_widgets.utils.colors import apply_theme
+
+    apply_theme("light")
+
+    widget = QtWidgets.QWidget()
+    layout = QtWidgets.QVBoxLayout(widget)
+    widget.setLayout(layout)
+    layout.setContentsMargins(0, 0, 0, 0)
+    layout.setSpacing(0)
     device_manager = DeviceManagerWidget()
     # config = device_manager.client.device_manager._get_redis_device_config()
     # device_manager.device_table_view.set_device_config(config)
-    device_manager.show()
+    layout.addWidget(device_manager)
+    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
+    dark_mode_button = DarkModeButton()
+    layout.addWidget(dark_mode_button)
+    widget.show()
     device_manager.setWindowTitle("Device Manager View")
     device_manager.resize(1600, 1200)
     # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime

bec_widgets/applications/views/view.py

@@ -0,0 +1,363 @@
+from __future__ import annotations
+
+from typing import List
+
+from qtpy.QtCore import QEventLoop, Qt, QTimer
+from qtpy.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFormLayout,
+    QHBoxLayout,
+    QLabel,
+    QMessageBox,
+    QPushButton,
+    QSplitter,
+    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
+
+
+def set_splitter_weights(splitter: QSplitter, weights: List[float]) -> None:
+    """
+    Apply initial sizes to a splitter using weight ratios, e.g. [1,3,2,1].
+    Works for horizontal or vertical splitters and sets matching stretch factors.
+    """
+
+    def apply():
+        n = splitter.count()
+        if n == 0:
+            return
+        w = list(weights[:n]) + [1] * max(0, n - len(weights))
+        w = [max(0.0, float(x)) for x in w]
+        tot_w = sum(w)
+        if tot_w <= 0:
+            w = [1.0] * n
+            tot_w = float(n)
+        total_px = (
+            splitter.width()
+            if splitter.orientation() == Qt.Orientation.Horizontal
+            else splitter.height()
+        )
+        if total_px < 2:
+            QTimer.singleShot(0, apply)
+            return
+        sizes = [max(1, int(total_px * (wi / tot_w))) for wi in w]
+        diff = total_px - sum(sizes)
+        if diff != 0:
+            idx = max(range(n), key=lambda i: w[i])
+            sizes[idx] = max(1, sizes[idx] + diff)
+        splitter.setSizes(sizes)
+        for i, wi in enumerate(w):
+            splitter.setStretchFactor(i, max(1, int(round(wi * 100))))
+
+    QTimer.singleShot(0, apply)
+
+
+class 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
+
+    ####### Default view has to be done with setting up splitters ########
+    def set_default_view(self, horizontal_weights: list, vertical_weights: list):
+        """Apply initial weights to every horizontal and vertical splitter.
+
+        Examples:
+            horizontal_weights = [1, 3, 2, 1]
+            vertical_weights   = [3, 7]  # top:bottom = 30:70
+        """
+        splitters_h = []
+        splitters_v = []
+        for splitter in self.findChildren(QSplitter):
+            if splitter.orientation() == Qt.Orientation.Horizontal:
+                splitters_h.append(splitter)
+            elif splitter.orientation() == Qt.Orientation.Vertical:
+                splitters_v.append(splitter)
+
+        def apply_all():
+            for s in splitters_h:
+                set_splitter_weights(s, horizontal_weights)
+            for s in splitters_v:
+                set_splitter_weights(s, vertical_weights)
+
+        QTimer.singleShot(0, apply_all)
+
+    def set_stretch(self, *, horizontal=None, vertical=None):
+        """Update splitter weights and re-apply to all splitters.
+
+        Accepts either a list/tuple of weights (e.g., [1,3,2,1]) or a role dict
+        for convenience: horizontal roles = {"left","center","right"},
+        vertical roles = {"top","bottom"}.
+        """
+
+        def _coerce_h(x):
+            if x is None:
+                return None
+            if isinstance(x, (list, tuple)):
+                return list(map(float, x))
+            if isinstance(x, dict):
+                return [
+                    float(x.get("left", 1)),
+                    float(x.get("center", x.get("middle", 1))),
+                    float(x.get("right", 1)),
+                ]
+            return None
+
+        def _coerce_v(x):
+            if x is None:
+                return None
+            if isinstance(x, (list, tuple)):
+                return list(map(float, x))
+            if isinstance(x, dict):
+                return [float(x.get("top", 1)), float(x.get("bottom", 1))]
+            return None
+
+        h = _coerce_h(horizontal)
+        v = _coerce_v(vertical)
+        if h is None:
+            h = [1, 1, 1]
+        if v is None:
+            v = [1, 1]
+        self.set_default_view(h, v)
+
+
+####################################################################################################
+# Example views for demonstration/testing purposes
+####################################################################################################
+
+
+# --- Popup UI version ---
+class WaveformViewPopup(ViewBase):  # pragma: no cover
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent=parent, *args, **kwargs)
+
+        self.waveform = Waveform(parent=self)
+        self.set_content(self.waveform)
+
+    @SafeSlot()
+    def on_enter(self) -> None:
+        dialog = QDialog(self)
+        dialog.setWindowTitle("Configure Waveform View")
+
+        label = QLabel("Select device and signal for the waveform plot:", parent=dialog)
+
+        # same as in the CurveRow used in waveform
+        self.device_edit = DeviceComboBox(parent=self)
+        self.device_edit.insertItem(0, "")
+        self.device_edit.setEditable(True)
+        self.device_edit.setCurrentIndex(0)
+        self.entry_edit = SignalComboBox(parent=self)
+        self.entry_edit.include_config_signals = False
+        self.entry_edit.insertItem(0, "")
+        self.entry_edit.setEditable(True)
+        self.device_edit.currentTextChanged.connect(self.entry_edit.set_device)
+        self.device_edit.device_reset.connect(self.entry_edit.reset_selection)
+
+        form = QFormLayout()
+        form.addRow(label)
+        form.addRow("Device", self.device_edit)
+        form.addRow("Signal", self.entry_edit)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, parent=dialog)
+        buttons.accepted.connect(dialog.accept)
+        buttons.rejected.connect(dialog.reject)
+
+        v = QVBoxLayout(dialog)
+        v.addLayout(form)
+        v.addWidget(buttons)
+
+        if dialog.exec_() == QDialog.Accepted:
+            self.waveform.plot(
+                y_name=self.device_edit.currentText(), y_entry=self.entry_edit.currentText()
+            )
+
+    @SafeSlot()
+    def on_exit(self) -> bool:
+        ans = QMessageBox.question(
+            self,
+            "Switch and clear?",
+            "Do you want to switch views and clear the plot?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No,
+        )
+        if ans == QMessageBox.Yes:
+            self.waveform.clear_all()
+            return True
+        return False
+
+
+# --- Inline stacked UI version ---
+class WaveformViewInline(ViewBase):  # pragma: no cover
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent=parent, *args, **kwargs)
+
+        # Root layout for this view uses a stacked layout
+        self.stack = QStackedLayout()
+        container = QWidget(self)
+        container.setLayout(self.stack)
+        self.set_content(container)
+
+        # --- Page 0: Settings page (inline form)
+        self.settings_page = QWidget()
+        sp_layout = QVBoxLayout(self.settings_page)
+        sp_layout.setContentsMargins(16, 16, 16, 16)
+        sp_layout.setSpacing(12)
+
+        title = QLabel("Select device and signal for the waveform plot:", parent=self.settings_page)
+        self.device_edit = DeviceComboBox(parent=self.settings_page)
+        self.device_edit.insertItem(0, "")
+        self.device_edit.setEditable(True)
+        self.device_edit.setCurrentIndex(0)
+
+        self.entry_edit = SignalComboBox(parent=self.settings_page)
+        self.entry_edit.include_config_signals = False
+        self.entry_edit.insertItem(0, "")
+        self.entry_edit.setEditable(True)
+        self.device_edit.currentTextChanged.connect(self.entry_edit.set_device)
+        self.device_edit.device_reset.connect(self.entry_edit.reset_selection)
+
+        form = QFormLayout()
+        form.addRow(title)
+        form.addRow("Device", self.device_edit)
+        form.addRow("Signal", self.entry_edit)
+
+        btn_row = QHBoxLayout()
+        ok_btn = QPushButton("OK", parent=self.settings_page)
+        cancel_btn = QPushButton("Cancel", parent=self.settings_page)
+        btn_row.addStretch(1)
+        btn_row.addWidget(cancel_btn)
+        btn_row.addWidget(ok_btn)
+
+        sp_layout.addLayout(form)
+        sp_layout.addLayout(btn_row)
+
+        # --- Page 1: Waveform page
+        self.waveform_page = QWidget()
+        wf_layout = QVBoxLayout(self.waveform_page)
+        wf_layout.setContentsMargins(0, 0, 0, 0)
+        self.waveform = Waveform(parent=self.waveform_page)
+        wf_layout.addWidget(self.waveform)
+
+        # --- Page 2: Exit confirmation page (inline)
+        self.confirm_page = QWidget()
+        cp_layout = QVBoxLayout(self.confirm_page)
+        cp_layout.setContentsMargins(16, 16, 16, 16)
+        cp_layout.setSpacing(12)
+        qlabel = QLabel("Do you want to switch views and clear the plot?", parent=self.confirm_page)
+        cp_buttons = QHBoxLayout()
+        no_btn = QPushButton("No", parent=self.confirm_page)
+        yes_btn = QPushButton("Yes", parent=self.confirm_page)
+        cp_buttons.addStretch(1)
+        cp_buttons.addWidget(no_btn)
+        cp_buttons.addWidget(yes_btn)
+        cp_layout.addWidget(qlabel)
+        cp_layout.addLayout(cp_buttons)
+
+        # Add pages to the stack
+        self.stack.addWidget(self.settings_page)  # index 0
+        self.stack.addWidget(self.waveform_page)  # index 1
+        self.stack.addWidget(self.confirm_page)  # index 2
+
+        # Wire settings buttons
+        ok_btn.clicked.connect(self._apply_settings_and_show_waveform)
+        cancel_btn.clicked.connect(self._show_waveform_without_changes)
+
+        # Prepare result holder for the inline confirmation
+        self._exit_choice_yes = None
+        yes_btn.clicked.connect(lambda: self._exit_reply(True))
+        no_btn.clicked.connect(lambda: self._exit_reply(False))
+
+    @SafeSlot()
+    def on_enter(self) -> None:
+        # Always start on the settings page when entering
+        self.stack.setCurrentIndex(0)
+
+    @SafeSlot()
+    def on_exit(self) -> bool:
+        # Show inline confirmation page and synchronously wait for a choice
+        # -> trick to make the choice blocking, however popup would be cleaner solution
+        self._exit_choice_yes = None
+        self.stack.setCurrentIndex(2)
+        loop = QEventLoop()
+        self._exit_loop = loop
+        loop.exec_()
+
+        if self._exit_choice_yes:
+            self.waveform.clear_all()
+            return True
+        # Revert to waveform view if user cancelled switching
+        self.stack.setCurrentIndex(1)
+        return False
+
+    def _apply_settings_and_show_waveform(self):
+        dev = self.device_edit.currentText()
+        sig = self.entry_edit.currentText()
+        if dev and sig:
+            self.waveform.plot(y_name=dev, y_entry=sig)
+        self.stack.setCurrentIndex(1)
+
+    def _show_waveform_without_changes(self):
+        # Just show waveform page without plotting
+        self.stack.setCurrentIndex(1)
+
+    def _exit_reply(self, yes: bool):
+        self._exit_choice_yes = bool(yes)
+        if hasattr(self, "_exit_loop") and self._exit_loop.isRunning():
+            self._exit_loop.quit()

bec_widgets/cli/client.py

@@ -27,7 +27,6 @@ class _WidgetsEnumType(str, enum.Enum):
 
 
 _Widgets = {
-    "AbortButton": "AbortButton",
     "BECDockArea": "BECDockArea",
     "BECMainWindow": "BECMainWindow",
     "BECProgressBar": "BECProgressBar",
@@ -50,7 +49,6 @@ _Widgets = {
     "PositionerBox2D": "PositionerBox2D",
     "PositionerControlLine": "PositionerControlLine",
     "PositionerGroup": "PositionerGroup",
-    "ResetButton": "ResetButton",
     "ResumeButton": "ResumeButton",
     "RingProgressBar": "RingProgressBar",
     "SBBMonitor": "SBBMonitor",
@@ -60,7 +58,6 @@ _Widgets = {
     "SignalComboBox": "SignalComboBox",
     "SignalLabel": "SignalLabel",
     "SignalLineEdit": "SignalLineEdit",
-    "StopButton": "StopButton",
     "TextBox": "TextBox",
     "VSCodeEditor": "VSCodeEditor",
     "Waveform": "Waveform",
@@ -97,28 +94,6 @@ 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(
@@ -129,6 +104,7 @@ class AdvancedDockArea(RPCBase):
         movable: "bool" = True,
         start_floating: "bool" = False,
         where: "Literal['left', 'right', 'top', 'bottom'] | None" = None,
+        **kwargs,
     ) -> "BECWidget":
         """
         Create a new widget (or reuse an instance) and add it as a dock.
@@ -141,6 +117,7 @@ class AdvancedDockArea(RPCBase):
             start_floating: Start the dock in a floating state.
             where: Preferred area to add the dock: "left" | "right" | "top" | "bottom".
                    If None, uses the instance default passed at construction time.
+            **kwargs: The keyword arguments for the widget.
         Returns:
             The widget instance.
         """
@@ -236,6 +213,26 @@ class AutoUpdates(RPCBase):
         """
 
 
+class AvailableDeviceResources(RPCBase):
+    @rpc_call
+    def remove(self):
+        """
+        Cleanup the BECConnector
+        """
+
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+
 class BECDock(RPCBase):
     @property
     @rpc_call
@@ -1100,6 +1097,48 @@ class Curve(RPCBase):
         """
 
 
+class DMConfigView(RPCBase):
+    @rpc_call
+    def remove(self):
+        """
+        Cleanup the BECConnector
+        """
+
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+
+class DMOphydTest(RPCBase):
+    """Widget to test device configurations using ophyd devices."""
+
+    @rpc_call
+    def remove(self):
+        """
+        Cleanup the BECConnector
+        """
+
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+
 class DapComboBox(RPCBase):
     """The DAPComboBox widget is an extension to the QComboBox with all avaialble DAP model from BEC."""
 
@@ -2414,7 +2453,7 @@ class Image(RPCBase):
         Set the image source and update the image.
 
         Args:
-            monitor(str): The name of the monitor to use for the image.
+            monitor(str|tuple|None): The name of the monitor to use for the image, or a tuple of (device, signal) for preview signals. If None or empty string, the current monitor will be disconnected.
             monitor_type(str): The type of monitor to use. Options are "1d", "2d", or "auto".
             color_map(str): The color map to use for the image.
             color_bar(str): The type of color bar to use. Options are "simple" or "full".
@@ -2647,26 +2686,54 @@ class LogPanel(RPCBase):
 class Minesweeper(RPCBase): ...
 
 
+class MonacoDock(RPCBase):
+    """MonacoDock is a dock widget that contains Monaco editor instances."""
+
+    @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 MonacoWidget(RPCBase):
     """A simple Monaco editor widget"""
 
     @rpc_call
-    def set_text(self, text: str) -> None:
+    def set_text(
+        self, text: "str", file_name: "str | None" = None, reset: "bool" = False
+    ) -> "None":
         """
         Set the text in the Monaco editor.
 
         Args:
             text (str): The text to set in the editor.
+            file_name (str): Set the file name
+            reset (bool): If True, reset the original content to the new text.
         """
 
     @rpc_call
-    def get_text(self) -> str:
+    def get_text(self) -> "str":
         """
         Get the current text from the Monaco editor.
         """
 
     @rpc_call
-    def insert_text(self, text: str, line: int | None = None, column: int | None = None) -> None:
+    def insert_text(
+        self, text: "str", line: "int | None" = None, column: "int | None" = None
+    ) -> "None":
         """
         Insert text at the current cursor position or at a specified line and column.
 
@@ -2677,7 +2744,7 @@ class MonacoWidget(RPCBase):
         """
 
     @rpc_call
-    def delete_line(self, line: int | None = None) -> None:
+    def delete_line(self, line: "int | None" = None) -> "None":
         """
         Delete a line in the Monaco editor.
 
@@ -2686,7 +2753,16 @@ class MonacoWidget(RPCBase):
         """
 
     @rpc_call
-    def set_language(self, language: str) -> None:
+    def open_file(self, file_name: "str") -> "None":
+        """
+        Open a file in the editor.
+
+        Args:
+            file_name (str): The path + file name of the file that needs to be displayed.
+        """
+
+    @rpc_call
+    def set_language(self, language: "str") -> "None":
         """
         Set the programming language for syntax highlighting in the Monaco editor.
 
@@ -2695,13 +2771,13 @@ class MonacoWidget(RPCBase):
         """
 
     @rpc_call
-    def get_language(self) -> str:
+    def get_language(self) -> "str":
         """
         Get the current programming language set in the Monaco editor.
         """
 
     @rpc_call
-    def set_theme(self, theme: str) -> None:
+    def set_theme(self, theme: "str") -> "None":
         """
         Set the theme for the Monaco editor.
 
@@ -2710,13 +2786,13 @@ class MonacoWidget(RPCBase):
         """
 
     @rpc_call
-    def get_theme(self) -> str:
+    def get_theme(self) -> "str":
         """
         Get the current theme of the Monaco editor.
         """
 
     @rpc_call
-    def set_readonly(self, read_only: bool) -> None:
+    def set_readonly(self, read_only: "bool") -> "None":
         """
         Set the Monaco editor to read-only mode.
 
@@ -2727,10 +2803,10 @@ class MonacoWidget(RPCBase):
     @rpc_call
     def set_cursor(
         self,
-        line: int,
-        column: int = 1,
-        move_to_position: Literal[None, "center", "top", "position"] = None,
-    ) -> None:
+        line: "int",
+        column: "int" = 1,
+        move_to_position: "Literal[None, 'center', 'top', 'position']" = None,
+    ) -> "None":
         """
         Set the cursor position in the Monaco editor.
 
@@ -2741,7 +2817,7 @@ class MonacoWidget(RPCBase):
         """
 
     @rpc_call
-    def current_cursor(self) -> dict[str, int]:
+    def current_cursor(self) -> "dict[str, int]":
         """
         Get the current cursor position in the Monaco editor.
 
@@ -2750,7 +2826,7 @@ class MonacoWidget(RPCBase):
         """
 
     @rpc_call
-    def set_minimap_enabled(self, enabled: bool) -> None:
+    def set_minimap_enabled(self, enabled: "bool") -> "None":
         """
         Enable or disable the minimap in the Monaco editor.
 
@@ -2759,7 +2835,7 @@ class MonacoWidget(RPCBase):
         """
 
     @rpc_call
-    def set_vim_mode_enabled(self, enabled: bool) -> None:
+    def set_vim_mode_enabled(self, enabled: "bool") -> "None":
         """
         Enable or disable Vim mode in the Monaco editor.
 
@@ -2768,7 +2844,7 @@ class MonacoWidget(RPCBase):
         """
 
     @rpc_call
-    def set_lsp_header(self, header: str) -> None:
+    def set_lsp_header(self, header: "str") -> "None":
         """
         Set the LSP (Language Server Protocol) header for the Monaco editor.
         The header is used to provide context for language servers but is not displayed in the editor.
@@ -2778,7 +2854,7 @@ class MonacoWidget(RPCBase):
         """
 
     @rpc_call
-    def get_lsp_header(self) -> str:
+    def get_lsp_header(self) -> "str":
         """
         Get the current LSP header set in the Monaco editor.
 
@@ -3990,28 +4066,6 @@ 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."""
 
@@ -4198,7 +4252,7 @@ class RingProgressBar(RPCBase):
         """
 
     @rpc_call
-    def set_precision(self, precision: "int", bar_index: "int" = None):
+    def set_precision(self, precision: "int", bar_index: "int | None" = None):
         """
         Set the precision for the progress bars. If bar_index is not provide, the precision will be set for all progress bars.
 
@@ -4987,28 +5041,6 @@ 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"""
 
@@ -5470,6 +5502,8 @@ class Waveform(RPCBase):
         color: "str | None" = None,
         label: "str | None" = None,
         dap: "str | None" = None,
+        scan_id: "str | None" = None,
+        scan_number: "int | None" = None,
         **kwargs,
     ) -> "Curve":
         """
@@ -5492,6 +5526,10 @@ class Waveform(RPCBase):
             dap(str): The dap model to use for the curve, only available for sync devices.
             If not specified, none will be added.
             Use the same string as is the name of the LMFit model.
+            scan_id(str):  Optional scan ID. When provided, the curve is treated as a **history** curve and
+                the y‑data (and optional x‑data) are fetched from that historical scan. Such curves are
+                never cleared by live‑scan resets.
+            scan_number(int): Optional scan index. When provided, the curve is treated as a **history** curve and
 
         Returns:
             Curve: The curve object.
@@ -5534,11 +5572,11 @@ class Waveform(RPCBase):
     def update_with_scan_history(self, scan_index: "int" = None, scan_id: "str" = None):
         """
         Update the scan curves with the data from the scan storage.
-        Provide only one of scan_id or scan_index.
+        If both arguments are provided, scan_id takes precedence and scan_index is ignored.
 
         Args:
             scan_id(str, optional): ScanID of the scan to be updated. Defaults to None.
-            scan_index(int, optional): Index of the scan to be updated. Defaults to None.
+            scan_index(int, optional): Index (scan number) of the scan to be updated. Defaults to None.
         """
 
     @rpc_call

bec_widgets/cli/client_utils.py

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

bec_widgets/cli/rpc/rpc_base.py

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

bec_widgets/examples/bec_main_app/bec_main_app.py

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

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -1,12 +1,23 @@
+from __future__ import annotations
+
+import ast
+import importlib
 import os
+from typing import Any, Dict
 
 import numpy as np
 import pyqtgraph as pg
 from bec_qthemes import material_icon
+from qtpy.QtCore import Qt
 from qtpy.QtWidgets import (
     QApplication,
+    QComboBox,
+    QFrame,
+    QGridLayout,
     QGroupBox,
     QHBoxLayout,
+    QLabel,
+    QLineEdit,
     QPushButton,
     QSplitter,
     QTabWidget,
@@ -14,149 +25,359 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
-from bec_widgets.utils import BECDispatcher
+from bec_widgets import BECWidget
+from bec_widgets.cli.rpc.rpc_widget_handler import widget_handler
 from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.widget_io import WidgetHierarchy as wh
-from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
 from bec_widgets.widgets.containers.dock import BECDockArea
-from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
 from bec_widgets.widgets.editors.jupyter_console.jupyter_console import BECJupyterConsole
-from bec_widgets.widgets.plots.image.image import Image
-from bec_widgets.widgets.plots.motor_map.motor_map import MotorMap
-from bec_widgets.widgets.plots.multi_waveform.multi_waveform import MultiWaveform
-from bec_widgets.widgets.plots.plot_base import PlotBase
-from bec_widgets.widgets.plots.scatter_waveform.scatter_waveform import ScatterWaveform
-from bec_widgets.widgets.plots.waveform.waveform import Waveform
 
 
 class JupyterConsoleWindow(QWidget):  # pragma: no cover:
-    """A widget that contains a Jupyter console linked to BEC Widgets with full API access (contains Qt and pyqtgraph API)."""
+    """A widget that contains a Jupyter console linked to BEC Widgets with full API access.
 
-    def __init__(self, parent=None):
-        super().__init__(parent)
+    Features:
+    - Add widgets dynamically from the UI (top-right panel) or from the console via `jc.add_widget(...)`.
+    - Add BEC widgets by registered type via a combo box or `jc.add_widget_by_type(...)`.
+    - Each added widget appears as a new tab in the left tab widget and is exposed in the console under the chosen shortcut.
+    - Hardcoded example tabs removed; two examples are added programmatically at startup in the __main__ block.
+    """
 
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+
+        self._widgets_by_name: Dict[str, QWidget] = {}
         self._init_ui()
 
-        # console push
+        # expose helper API and basics in the inprocess console
         if self.console.inprocess is True:
-            self.console.kernel_manager.kernel.shell.push(
-                {
-                    "np": np,
-                    "pg": pg,
-                    "wh": wh,
-                    "dock": self.dock,
-                    "im": self.im,
-                    "ads": self.ads,
-                    # "mi": self.mi,
-                    # "mm": self.mm,
-                    # "lm": self.lm,
-                    # "btn1": self.btn1,
-                    # "btn2": self.btn2,
-                    # "btn3": self.btn3,
-                    # "btn4": self.btn4,
-                    # "btn5": self.btn5,
-                    # "btn6": self.btn6,
-                    # "pb": self.pb,
-                    # "pi": self.pi,
-                    # "wf": self.wf,
-                    # "scatter": self.scatter,
-                    # "scatter_mi": self.scatter,
-                    # "mwf": self.mwf,
-                }
-            )
+            # A thin API wrapper so users have a stable, minimal surface in the console
+            class _ConsoleAPI:
+                def __init__(self, win: "JupyterConsoleWindow"):
+                    self._win = win
+
+                def add_widget(self, widget: QWidget, shortcut: str, title: str | None = None):
+                    """Add an existing QWidget as a new tab and expose it in the console under `shortcut`."""
+                    return self._win.add_widget(widget, shortcut, title=title)
+
+                def add_widget_by_class_path(
+                    self,
+                    class_path: str,
+                    shortcut: str,
+                    kwargs: dict | None = None,
+                    title: str | None = None,
+                ):
+                    """Import a QWidget class from `class_path`, instantiate it, and add it."""
+                    return self._win.add_widget_by_class_path(
+                        class_path, shortcut, kwargs=kwargs, title=title
+                    )
+
+                def add_widget_by_type(
+                    self,
+                    widget_type: str,
+                    shortcut: str,
+                    kwargs: dict | None = None,
+                    title: str | None = None,
+                ):
+                    """Instantiate a registered BEC widget by type string and add it."""
+                    return self._win.add_widget_by_type(
+                        widget_type, shortcut, kwargs=kwargs, title=title
+                    )
+
+                def list_widgets(self):
+                    return list(self._win._widgets_by_name.keys())
+
+                def get_widget(self, shortcut: str) -> QWidget | None:
+                    return self._win._widgets_by_name.get(shortcut)
+
+                def available_widgets(self):
+                    return list(widget_handler.widget_classes.keys())
+
+            self.jc = _ConsoleAPI(self)
+            self._push_to_console({"jc": self.jc, "np": np, "pg": pg, "wh": wh})
 
     def _init_ui(self):
         self.layout = QHBoxLayout(self)
 
-        # Horizontal splitter
+        # Horizontal splitter: left = widgets tabs, right = console + add-widget panel
         splitter = QSplitter(self)
         self.layout.addWidget(splitter)
 
-        tab_widget = QTabWidget(splitter)
+        # Left: tabs that will host dynamically added widgets
+        self.tab_widget = QTabWidget(splitter)
 
-        first_tab = QWidget()
-        first_tab_layout = QVBoxLayout(first_tab)
-        self.dock = BECDockArea(gui_id="dock")
-        first_tab_layout.addWidget(self.dock)
-        tab_widget.addTab(first_tab, "Dock Area")
+        # Right: console area with an add-widget mini panel on top
+        right_panel = QGroupBox("Jupyter Console", splitter)
+        right_layout = QVBoxLayout(right_panel)
+        right_layout.setContentsMargins(6, 12, 6, 6)
 
-        # third_tab = QWidget()
-        # third_tab_layout = QVBoxLayout(third_tab)
-        # self.lm = LayoutManagerWidget()
-        # third_tab_layout.addWidget(self.lm)
-        # tab_widget.addTab(third_tab, "Layout Manager Widget")
-        #
-        # fourth_tab = QWidget()
-        # fourth_tab_layout = QVBoxLayout(fourth_tab)
-        # self.pb = PlotBase()
-        # self.pi = self.pb.plot_item
-        # fourth_tab_layout.addWidget(self.pb)
-        # tab_widget.addTab(fourth_tab, "PlotBase")
-        #
-        # tab_widget.setCurrentIndex(3)
-        #
-        group_box = QGroupBox("Jupyter Console", splitter)
-        group_box_layout = QVBoxLayout(group_box)
+        # Add-widget mini panel
+        add_panel = QFrame(right_panel)
+        shape = QFrame.Shape.StyledPanel  # PySide6 style enums
+        add_panel.setFrameShape(shape)
+        add_grid = QGridLayout(add_panel)
+        add_grid.setContentsMargins(8, 8, 8, 8)
+        add_grid.setHorizontalSpacing(8)
+        add_grid.setVerticalSpacing(6)
+
+        instr = QLabel(
+            "Add a widget by class path or choose a registered BEC widget type,"
+            " and expose it in the console under a shortcut.\n"
+            "Example class path: bec_widgets.widgets.plots.waveform.waveform.Waveform"
+        )
+        instr.setWordWrap(True)
+        add_grid.addWidget(instr, 0, 0, 1, 2)
+
+        # Registered widget selector
+        reg_label = QLabel("Registered")
+        reg_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        self.registry_combo = QComboBox(add_panel)
+        self.registry_combo.setEditable(False)
+        self.refresh_btn = QPushButton("Refresh")
+        reg_row = QHBoxLayout()
+        reg_row.addWidget(self.registry_combo)
+        reg_row.addWidget(self.refresh_btn)
+        add_grid.addWidget(reg_label, 1, 0)
+        add_grid.addLayout(reg_row, 1, 1)
+
+        # Class path entry
+        class_label = QLabel("Class")
+        class_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        self.class_path_edit = QLineEdit(add_panel)
+        self.class_path_edit.setPlaceholderText("Fully-qualified class path (e.g. pkg.mod.Class)")
+        add_grid.addWidget(class_label, 2, 0)
+        add_grid.addWidget(self.class_path_edit, 2, 1)
+
+        # Shortcut
+        shortcut_label = QLabel("Shortcut")
+        shortcut_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        self.shortcut_edit = QLineEdit(add_panel)
+        self.shortcut_edit.setPlaceholderText("Shortcut in console (variable name)")
+        add_grid.addWidget(shortcut_label, 3, 0)
+        add_grid.addWidget(self.shortcut_edit, 3, 1)
+
+        # Kwargs
+        kwargs_label = QLabel("Kwargs")
+        kwargs_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        self.kwargs_edit = QLineEdit(add_panel)
+        self.kwargs_edit.setPlaceholderText(
+            'Optional kwargs as dict literal, e.g. {"popups": True}'
+        )
+        add_grid.addWidget(kwargs_label, 4, 0)
+        add_grid.addWidget(self.kwargs_edit, 4, 1)
+
+        # Title
+        title_label = QLabel("Title")
+        title_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        self.title_edit = QLineEdit(add_panel)
+        self.title_edit.setPlaceholderText("Optional tab title (defaults to Shortcut or Class)")
+        add_grid.addWidget(title_label, 5, 0)
+        add_grid.addWidget(self.title_edit, 5, 1)
+
+        # Buttons
+        btn_row = QHBoxLayout()
+        self.add_btn = QPushButton("Add by class path")
+        self.add_btn.clicked.connect(self._on_add_widget_clicked)
+        self.add_reg_btn = QPushButton("Add registered")
+        self.add_reg_btn.clicked.connect(self._on_add_registered_clicked)
+        btn_row.addStretch(1)
+        btn_row.addWidget(self.add_reg_btn)
+        btn_row.addWidget(self.add_btn)
+        add_grid.addLayout(btn_row, 6, 0, 1, 2)
+
+        # Make the second column expand
+        add_grid.setColumnStretch(0, 0)
+        add_grid.setColumnStretch(1, 1)
+
+        # Console widget
         self.console = BECJupyterConsole(inprocess=True)
-        group_box_layout.addWidget(self.console)
-        #
-        # # Some buttons for layout testing
-        # self.btn1 = QPushButton("Button 1")
-        # self.btn2 = QPushButton("Button 2")
-        # self.btn3 = QPushButton("Button 3")
-        # self.btn4 = QPushButton("Button 4")
-        # self.btn5 = QPushButton("Button 5")
-        # self.btn6 = QPushButton("Button 6")
-        #
-        # fifth_tab = QWidget()
-        # fifth_tab_layout = QVBoxLayout(fifth_tab)
-        # self.wf = Waveform()
-        # fifth_tab_layout.addWidget(self.wf)
-        # tab_widget.addTab(fifth_tab, "Waveform Next Gen")
-        # tab_widget.setCurrentIndex(4)
-        #
-        sixth_tab = QWidget()
-        sixth_tab_layout = QVBoxLayout(sixth_tab)
-        self.im = Image(popups=True)
-        self.mi = self.im.main_image
-        sixth_tab_layout.addWidget(self.im)
-        tab_widget.addTab(sixth_tab, "Image Next Gen")
-        tab_widget.setCurrentIndex(1)
-        #
-        seventh_tab = QWidget()
-        seventh_tab_layout = QVBoxLayout(seventh_tab)
-        self.ads = AdvancedDockArea(gui_id="ads")
-        seventh_tab_layout.addWidget(self.ads)
-        tab_widget.addTab(seventh_tab, "ADS")
-        tab_widget.setCurrentIndex(2)
-        #
-        # eighth_tab = QWidget()
-        # eighth_tab_layout = QVBoxLayout(eighth_tab)
-        # self.mm = MotorMap()
-        # eighth_tab_layout.addWidget(self.mm)
-        # tab_widget.addTab(eighth_tab, "Motor Map")
-        # tab_widget.setCurrentIndex(7)
-        #
-        # ninth_tab = QWidget()
-        # ninth_tab_layout = QVBoxLayout(ninth_tab)
-        # self.mwf = MultiWaveform()
-        # ninth_tab_layout.addWidget(self.mwf)
-        # tab_widget.addTab(ninth_tab, "MultiWaveform")
-        # tab_widget.setCurrentIndex(8)
-        #
-        # # add stuff to the new Waveform widget
-        # self._init_waveform()
-        #
-        # self.setWindowTitle("Jupyter Console Window")
 
-    def _init_waveform(self):
-        self.wf.plot(y_name="bpm4i", y_entry="bpm4i", dap="GaussianModel")
-        self.wf.plot(y_name="bpm3a", y_entry="bpm3a", dap="GaussianModel")
+        # Vertical splitter between add panel and console
+        right_splitter = QSplitter(Qt.Vertical, right_panel)
+        right_splitter.addWidget(add_panel)
+        right_splitter.addWidget(self.console)
+        right_splitter.setStretchFactor(0, 0)
+        right_splitter.setStretchFactor(1, 1)
+        right_splitter.setSizes([300, 600])
+
+        # Put splitter into the right group box
+        right_layout.addWidget(right_splitter)
+
+        # Populate registry on startup
+        self._populate_registry_widgets()
+
+    def _populate_registry_widgets(self):
+        try:
+            widget_handler.update_available_widgets()
+            items = sorted(widget_handler.widget_classes.keys())
+        except Exception as exc:
+            print(f"Failed to load registered widgets: {exc}")
+            items = []
+        self.registry_combo.clear()
+        self.registry_combo.addItems(items)
+
+    def _on_add_widget_clicked(self):
+        class_path = self.class_path_edit.text().strip()
+        shortcut = self.shortcut_edit.text().strip()
+        kwargs_text = self.kwargs_edit.text().strip()
+        title = self.title_edit.text().strip() or None
+
+        if not class_path or not shortcut:
+            print("Please provide both class path and shortcut.")
+            return
+
+        kwargs: dict | None = None
+        if kwargs_text:
+            try:
+                parsed = ast.literal_eval(kwargs_text)
+                if isinstance(parsed, dict):
+                    kwargs = parsed
+                else:
+                    print("Kwargs must be a Python dict literal, ignoring input.")
+            except Exception as exc:
+                print(f"Failed to parse kwargs: {exc}")
+
+        try:
+            widget = self._instantiate_from_class_path(class_path, kwargs=kwargs)
+        except Exception as exc:
+            print(f"Failed to instantiate {class_path}: {exc}")
+            return
+
+        try:
+            self.add_widget(widget, shortcut, title=title)
+        except Exception as exc:
+            print(f"Failed to add widget: {exc}")
+            return
+
+        # focus the newly added tab
+        idx = self.tab_widget.count() - 1
+        if idx >= 0:
+            self.tab_widget.setCurrentIndex(idx)
+
+    def _on_add_registered_clicked(self):
+        widget_type = self.registry_combo.currentText().strip()
+        shortcut = self.shortcut_edit.text().strip()
+        kwargs_text = self.kwargs_edit.text().strip()
+        title = self.title_edit.text().strip() or None
+
+        if not widget_type or not shortcut:
+            print("Please select a registered widget and provide a shortcut.")
+            return
+
+        kwargs: dict | None = None
+        if kwargs_text:
+            try:
+                parsed = ast.literal_eval(kwargs_text)
+                if isinstance(parsed, dict):
+                    kwargs = parsed
+                else:
+                    print("Kwargs must be a Python dict literal, ignoring input.")
+            except Exception as exc:
+                print(f"Failed to parse kwargs: {exc}")
+
+        try:
+            self.add_widget_by_type(widget_type, shortcut, kwargs=kwargs, title=title)
+        except Exception as exc:
+            print(f"Failed to add registered widget: {exc}")
+            return
+
+        # focus the newly added tab
+        idx = self.tab_widget.count() - 1
+        if idx >= 0:
+            self.tab_widget.setCurrentIndex(idx)
+
+    def _instantiate_from_class_path(self, class_path: str, kwargs: dict | None = None) -> QWidget:
+        module_path, _, class_name = class_path.rpartition(".")
+        if not module_path or not class_name:
+            raise ValueError("class_path must be of the form 'package.module.Class'")
+        module = importlib.import_module(module_path)
+        cls = getattr(module, class_name)
+        if kwargs is None:
+            obj = cls()
+        else:
+            obj = cls(**kwargs)
+        if not isinstance(obj, QWidget):
+            raise TypeError(f"Instantiated object from {class_path} is not a QWidget: {type(obj)}")
+        return obj
+
+    def add_widget(self, widget: QWidget, shortcut: str, title: str | None = None) -> QWidget:
+        """Add a QWidget as a new tab and expose it in the Jupyter console.
+
+        - widget: a QWidget instance to host in a new tab
+        - shortcut: variable name used in the console to access it
+        - title: optional tab title (defaults to shortcut or class name)
+        """
+        if not isinstance(widget, QWidget):
+            raise TypeError("widget must be a QWidget instance")
+        if not shortcut or not shortcut.isidentifier():
+            raise ValueError("shortcut must be a valid Python identifier")
+        if shortcut in self._widgets_by_name:
+            raise ValueError(f"A widget with shortcut '{shortcut}' already exists")
+        if self.console.inprocess is not True:
+            raise RuntimeError("Adding widgets and exposing them requires inprocess console")
+
+        tab_title = title or shortcut or widget.__class__.__name__
+        self.tab_widget.addTab(widget, tab_title)
+        self._widgets_by_name[shortcut] = widget
+
+        # Expose in console under the given shortcut
+        self._push_to_console({shortcut: widget})
+        return widget
+
+    def add_widget_by_class_path(
+        self, class_path: str, shortcut: str, kwargs: dict | None = None, title: str | None = None
+    ) -> QWidget:
+        widget = self._instantiate_from_class_path(class_path, kwargs=kwargs)
+        return self.add_widget(widget, shortcut, title=title)
+
+    def add_widget_by_type(
+        self, widget_type: str, shortcut: str, kwargs: dict | None = None, title: str | None = None
+    ) -> QWidget:
+        """Instantiate a registered BEC widget by its type string and add it as a tab.
+
+        If kwargs does not contain `object_name`, it will default to the provided shortcut.
+        """
+        # Ensure registry is loaded
+        widget_handler.update_available_widgets()
+        cls = widget_handler.widget_classes.get(widget_type)
+        if cls is None:
+            raise ValueError(f"Unknown registered widget type: {widget_type}")
+
+        if kwargs is None:
+            kwargs = {"object_name": shortcut}
+        else:
+            kwargs = dict(kwargs)
+            kwargs.setdefault("object_name", shortcut)
+
+        # Instantiate and add
+        widget = cls(**kwargs)
+        if not isinstance(widget, QWidget):
+            raise TypeError(
+                f"Instantiated object for type '{widget_type}' is not a QWidget: {type(widget)}"
+            )
+        return self.add_widget(widget, shortcut, title=title)
+
+    def _push_to_console(self, mapping: Dict[str, Any]):
+        """Push Python objects into the inprocess kernel user namespace."""
+        if self.console.inprocess is True:
+            self.console.kernel_manager.kernel.shell.push(mapping)
+        else:
+            raise RuntimeError("Can only push variables when using inprocess kernel")
 
     def closeEvent(self, event):
         """Override to handle things when main window is closed."""
-        self.dock.cleanup()
-        self.dock.close()
+        # clean up any widgets that might have custom cleanup
+        try:
+            # call cleanup on known containers if present
+            dock = self._widgets_by_name.get("dock")
+            if isinstance(dock, BECDockArea):
+                dock.cleanup()
+                dock.close()
+        except Exception:
+            pass
+
+        # Ensure the embedded kernel and BEC client are shut down before window teardown
+        self.console.shutdown_kernel()
         self.console.close()
 
         super().closeEvent(event)
@@ -176,13 +397,20 @@ if __name__ == "__main__":  # pragma: no cover
     icon = material_icon("terminal", color=(255, 255, 255, 255), filled=True)
     app.setWindowIcon(icon)
 
-    bec_dispatcher = BECDispatcher(gui_id="jupyter_console")
-    client = bec_dispatcher.client
-    client.start()
-
     win = JupyterConsoleWindow()
+
+    # Examples: add two widgets programmatically to demonstrate usage
+    try:
+        win.add_widget_by_type("Waveform", shortcut="wf")
+    except Exception as exc:
+        print(f"Example add failed (Waveform by type): {exc}")
+
+    try:
+        win.add_widget_by_type("Image", shortcut="im", kwargs={"popups": True})
+    except Exception as exc:
+        print(f"Example add failed (Image by type): {exc}")
+
     win.show()
     win.resize(1500, 800)
 
-    app.aboutToQuit.connect(win.close)
     sys.exit(app.exec_())

bec_widgets/tests/utils.py

@@ -173,7 +173,7 @@ class FakePositioner(BECPositioner):
     def set_read_value(self, value):
         self.read_value = value
 
-    def read(self):
+    def read(self, cached=False):
         return self.signals
 
     def set_limits(self, limits):

bec_widgets/utils/bec_connector.py

@@ -129,6 +129,17 @@ class BECConnector:
             def terminate(client=self.client, dispatcher=self.bec_dispatcher):
                 logger.info("Disconnecting", repr(dispatcher))
                 dispatcher.disconnect_all()
+
+                try:  # shutdown ophyd threads if any
+                    from ophyd._pyepics_shim import _dispatcher
+
+                    _dispatcher.stop()
+                    logger.info("Ophyd dispatcher shut down successfully.")
+                except Exception as e:
+                    logger.warning(
+                        f"Error shutting down ophyd dispatcher: {e}\n{traceback.format_exc()}"
+                    )
+
                 logger.info("Shutting down BEC Client", repr(client))
                 client.shutdown()
 
@@ -219,7 +230,7 @@ class BECConnector:
           - If there's a nearest BECConnector parent, only compare with children of that parent.
           - If parent is None (i.e., top-level object), compare with all other top-level BECConnectors.
         """
-        QApplication.processEvents()
+        QApplication.sendPostedEvents()
         parent_bec = WidgetHierarchy._get_becwidget_ancestor(self)
 
         if parent_bec:

bec_widgets/utils/bec_designer.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 from bec_qthemes import material_icon
 from qtpy import PYSIDE6
-from qtpy.QtGui import QIcon
+from qtpy.QtGui import QIcon, QPixmap
 
 from bec_widgets.utils.bec_plugin_helper import user_widget_plugin
 
@@ -35,7 +35,7 @@ def designer_material_icon(icon_name: str) -> QIcon:
     Returns:
         QIcon: The QIcon for the material icon.
     """
-    return QIcon(material_icon(icon_name, filled=True, convert_to_pixmap=True))
+    return QIcon(material_icon(icon_name, filled=True, icon_type=QPixmap))
 
 
 def list_editable_packages() -> set[str]:

bec_widgets/utils/bec_widget.py

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

bec_widgets/utils/busy_loader.py

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

bec_widgets/utils/colors.py

@@ -1,19 +1,17 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING, Literal
+from typing import Literal
 
 import 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"):
@@ -29,13 +27,14 @@ def get_theme_palette():
     return palette
 
 
-def get_accent_colors() -> AccentColors | None:
+def get_accent_colors() -> AccentColors:
     """
     Get the accent colors for the current theme. These colors are extensions of the color palette
     and are used to highlight specific elements in the UI.
     """
     if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
-        return None
+        accent_colors = AccentColors()
+        return accent_colors
     return QApplication.instance().theme.accent_colors
 
 

bec_widgets/utils/compact_popup.py

@@ -3,7 +3,7 @@ from types import SimpleNamespace
 
 from bec_qthemes import material_icon
 from qtpy.QtCore import Property, Qt, Signal
-from qtpy.QtGui import QColor
+from qtpy.QtGui import QColor, QIcon
 from qtpy.QtWidgets import (
     QDialog,
     QHBoxLayout,
@@ -132,7 +132,7 @@ class CompactPopupWidget(QWidget):
         self.compact_status = LedLabel(self.compact_view_widget)
         self.compact_show_popup = QToolButton(self.compact_view_widget)
         self.compact_show_popup.setIcon(
-            material_icon(icon_name="expand_content", size=(10, 10), convert_to_pixmap=False)
+            material_icon(icon_name="expand_content", size=(10, 10), icon_type=QIcon)
         )
         self.compact_view_widget.layout().addWidget(self.compact_label)
         self.compact_view_widget.layout().addWidget(self.compact_status)
@@ -171,9 +171,7 @@ class CompactPopupWidget(QWidget):
                 self.compact_label.setVisible(False)
                 self.compact_status.setVisible(False)
                 self.compact_show_popup.setIcon(
-                    material_icon(
-                        icon_name="collapse_content", size=(10, 10), convert_to_pixmap=False
-                    )
+                    material_icon(icon_name="collapse_content", size=(10, 10), icon_type=QIcon)
                 )
                 self.expand.emit(True)
             else:
@@ -181,9 +179,7 @@ class CompactPopupWidget(QWidget):
                 self.compact_label.setVisible(True)
                 self.compact_status.setVisible(True)
                 self.compact_show_popup.setIcon(
-                    material_icon(
-                        icon_name="expand_content", size=(10, 10), convert_to_pixmap=False
-                    )
+                    material_icon(icon_name="expand_content", size=(10, 10), icon_type=QIcon)
                 )
                 self.compact_view = True
                 self.expand.emit(False)

bec_widgets/utils/crosshair.py

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

bec_widgets/utils/expandable_frame.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from bec_qthemes import material_icon
-from qtpy.QtCore import Signal
+from qtpy.QtCore import QSize, Signal
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import (
     QApplication,
     QFrame,
@@ -19,7 +20,8 @@ from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 
 
 class ExpandableGroupFrame(QFrame):
-
+    broadcast_size_hint = Signal(QSize)
+    imminent_deletion = Signal()
     expansion_state_changed = Signal()
 
     EXPANDED_ICON_NAME: str = "collapse_all"
@@ -31,10 +33,11 @@ class ExpandableGroupFrame(QFrame):
         super().__init__(parent=parent)
         self._expanded = expanded
 
-        self.setFrameStyle(QFrame.Shape.StyledPanel | QFrame.Shadow.Plain)
+        self._title_text = f"<b>{title}</b>"
+        self.setFrameStyle(QFrame.Shape.StyledPanel | QFrame.Shadow.Raised)
         self.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
         self._layout = QVBoxLayout()
-        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._layout.setContentsMargins(5, 0, 0, 0)
         self.setLayout(self._layout)
 
         self._create_title_layout(title, icon)
@@ -49,21 +52,27 @@ class ExpandableGroupFrame(QFrame):
     def _create_title_layout(self, title: str, icon: str):
         self._title_layout = QHBoxLayout()
         self._layout.addLayout(self._title_layout)
+        self._internal_title_layout = QHBoxLayout()
+        self._title_layout.addLayout(self._internal_title_layout)
 
-        self._title = ClickableLabel(f"<b>{title}</b>")
+        self._title = ClickableLabel()
+        self._set_title_text(self._title_text)
         self._title_icon = ClickableLabel()
-        self._title_layout.addWidget(self._title_icon)
-        self._title_layout.addWidget(self._title)
+        self._internal_title_layout.addWidget(self._title_icon)
+        self._internal_title_layout.addWidget(self._title)
         self.icon_name = icon
         self._title.clicked.connect(self.switch_expanded_state)
         self._title_icon.clicked.connect(self.switch_expanded_state)
 
-        self._title_layout.addStretch(1)
+        self._internal_title_layout.addStretch(1)
 
         self._expansion_button = QToolButton()
         self._update_expansion_icon()
         self._title_layout.addWidget(self._expansion_button, stretch=1)
 
+    def get_title_layout(self) -> QHBoxLayout:
+        return self._internal_title_layout
+
     def set_layout(self, layout: QLayout) -> None:
         self._contents.setLayout(layout)
         self._contents.layout().setContentsMargins(0, 0, 0, 0)  # type: ignore
@@ -87,11 +96,9 @@ class ExpandableGroupFrame(QFrame):
 
     def _update_expansion_icon(self):
         self._expansion_button.setIcon(
-            material_icon(icon_name=self.EXPANDED_ICON_NAME, size=(10, 10), convert_to_pixmap=False)
+            material_icon(icon_name=self.EXPANDED_ICON_NAME, size=(10, 10), icon_type=QIcon)
             if self.expanded
-            else material_icon(
-                icon_name=self.COLLAPSED_ICON_NAME, size=(10, 10), convert_to_pixmap=False
-            )
+            else material_icon(icon_name=self.COLLAPSED_ICON_NAME, size=(10, 10), icon_type=QIcon)
         )
 
     @SafeProperty(str)
@@ -107,11 +114,23 @@ class ExpandableGroupFrame(QFrame):
         if icon_name:
             self._title_icon.setVisible(True)
             self._title_icon.setPixmap(
-                material_icon(icon_name=icon_name, size=(20, 20), convert_to_pixmap=True)
+                material_icon(icon_name=icon_name, size=(20, 20), icon_type=QPixmap)
             )
         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,17 +1,18 @@
 from __future__ import annotations
 
-from types import NoneType
+from types import GenericAlias, NoneType, UnionType
 from typing import NamedTuple
 
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from pydantic import BaseModel, ValidationError
 from qtpy.QtCore import Signal  # type: ignore
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QApplication, QGridLayout, QLabel, QSizePolicy, QVBoxLayout, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.compact_popup import CompactPopupWidget
-from bec_widgets.utils.error_popups import SafeProperty
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.forms_from_types import styles
 from bec_widgets.utils.forms_from_types.items import (
     DynamicFormItem,
@@ -207,7 +208,7 @@ class PydanticModelForm(TypedForm):
         self._validity.compact_view = True  # type: ignore
         self._validity.label = "Validity"  # type: ignore
         self._validity.compact_show_popup.setIcon(
-            material_icon(icon_name="info", size=(10, 10), convert_to_pixmap=False)
+            material_icon(icon_name="info", size=(10, 10), icon_type=QIcon)
         )
         self._validity_message = QLabel("Not yet validated")
         self._validity.addWidget(self._validity_message)
@@ -216,6 +217,9 @@ class PydanticModelForm(TypedForm):
 
         self._connect_to_theme_change()
 
+    @SafeSlot()
+    def clear(self): ...
+
     def set_pretty_display_theme(self, theme: str = "dark"):
         if self._pretty_display:
             self.setStyleSheet(styles.pretty_display_theme(theme))
@@ -280,3 +284,24 @@ class PydanticModelForm(TypedForm):
             self.form_data_cleared.emit(None)
             self.validity_proc.emit(False)
             return False
+
+
+class PydanticModelFormItem(DynamicFormItem):
+    def __init__(
+        self, parent: QWidget | None = None, *, spec: FormItemSpec, model: type[BaseModel]
+    ) -> None:
+        self._data_model = model
+
+        super().__init__(parent=parent, spec=spec)
+        self._main_widget.form_data_updated.connect(self._value_changed)
+
+    def _add_main_widget(self) -> None:
+
+        self._main_widget = PydanticModelForm(data_model=self._data_model)
+        self._layout.addWidget(self._main_widget)
+
+    def getValue(self):
+        return self._main_widget.get_form_data()
+
+    def setValue(self, value: dict):
+        self._main_widget.set_data(self._data_model.model_validate(value))

bec_widgets/utils/forms_from_types/items.py

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

bec_widgets/utils/guided_tour.py

@@ -0,0 +1,735 @@
+"""Module providing a guided help system for creating interactive GUI tours."""
+
+from __future__ import annotations
+
+import sys
+import weakref
+from typing import Callable, Dict, List, TypedDict
+from uuid import uuid4
+
+import louie
+from bec_lib.logger import bec_logger
+from bec_qthemes import material_icon
+from louie import saferef
+from qtpy.QtCore import QEvent, QObject, QRect, Qt, Signal
+from qtpy.QtGui import QAction, QColor, QPainter, QPen
+from qtpy.QtWidgets import (
+    QApplication,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QMainWindow,
+    QMenuBar,
+    QPushButton,
+    QToolBar,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.toolbars.actions import ExpandableMenuAction, MaterialIconAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle
+from bec_widgets.utils.toolbars.toolbar import ModularToolBar
+
+logger = bec_logger.logger
+
+
+class TourStep(TypedDict):
+    """Type definition for a tour step."""
+
+    widget_ref: (
+        louie.saferef.BoundMethodWeakref
+        | weakref.ReferenceType[
+            QWidget | QAction | Callable[[], tuple[QWidget | QAction, str | None]]
+        ]
+        | Callable[[], tuple[QWidget | QAction, str | None]]
+        | None
+    )
+    text: str
+    title: str
+
+
+class TutorialOverlay(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        # Keep mouse events enabled for the overlay but we'll handle them manually
+        self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, False)
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.setWindowFlags(Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint)
+        self.current_rect = QRect()
+        self.message_box = self._create_message_box()
+        self.message_box.hide()
+
+    def _create_message_box(self):
+        box = QFrame(self)
+        app = QApplication.instance()
+        bg_color = app.palette().window().color()
+        box.setStyleSheet(
+            f"""
+            QFrame {{
+                background-color: {bg_color.name()};
+                border-radius: 8px;
+                padding: 8px;
+            }}
+        """
+        )
+        layout = QVBoxLayout(box)
+
+        # Top layout with close button (left) and step indicator (right)
+        top_layout = QHBoxLayout()
+
+        # Close button on the left with material icon
+        self.close_btn = QPushButton()
+        self.close_btn.setIcon(material_icon("close"))
+        self.close_btn.setToolTip("Close")
+        self.close_btn.setMaximumSize(32, 32)
+
+        # Step indicator on the right
+        self.step_label = QLabel()
+        self.step_label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+        self.step_label.setStyleSheet("color: #666; font-size: 12px; font-weight: bold;")
+
+        top_layout.addWidget(self.close_btn)
+        top_layout.addStretch()
+        top_layout.addWidget(self.step_label)
+
+        # Main content label
+        self.label = QLabel()
+        self.label.setWordWrap(True)
+
+        # Bottom navigation buttons
+        btn_layout = QHBoxLayout()
+
+        # Back button with material icon
+        self.back_btn = QPushButton("Back")
+        self.back_btn.setIcon(material_icon("arrow_back"))
+
+        # Next button with material icon
+        self.next_btn = QPushButton("Next")
+        self.next_btn.setIcon(material_icon("arrow_forward"))
+
+        btn_layout.addStretch()
+        btn_layout.addWidget(self.back_btn)
+        btn_layout.addWidget(self.next_btn)
+
+        layout.addLayout(top_layout)
+        layout.addWidget(self.label)
+        layout.addLayout(btn_layout)
+        return box
+
+    def paintEvent(self, event):  # pylint: disable=unused-argument
+        if not self.current_rect.isValid():
+            return
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        # Create semi-transparent overlay color
+        overlay_color = QColor(0, 0, 0, 160)
+        # Use exclusive coordinates to avoid 1px gaps caused by QRect.bottom()/right() being inclusive.
+        r = self.current_rect
+        rect_x, rect_y, rect_w, rect_h = r.x(), r.y(), r.width(), r.height()
+
+        # Paint overlay in 4 regions around the highlighted widget using exclusive bounds
+        # Top region (everything above the highlight)
+        if rect_y > 0:
+            top_rect = QRect(0, 0, self.width(), rect_y)
+            painter.fillRect(top_rect, overlay_color)
+
+        # Bottom region (everything below the highlight)
+        bottom_y = rect_y + rect_h
+        if bottom_y < self.height():
+            bottom_rect = QRect(0, bottom_y, self.width(), self.height() - bottom_y)
+            painter.fillRect(bottom_rect, overlay_color)
+
+        # Left region (to the left of the highlight)
+        if rect_x > 0:
+            left_rect = QRect(0, rect_y, rect_x, rect_h)
+            painter.fillRect(left_rect, overlay_color)
+
+        # Right region (to the right of the highlight)
+        right_x = rect_x + rect_w
+        if right_x < self.width():
+            right_rect = QRect(right_x, rect_y, self.width() - right_x, rect_h)
+            painter.fillRect(right_rect, overlay_color)
+
+        # Draw highlight border around the clear area. Expand slightly so border doesn't leave a hairline gap.
+        border_rect = QRect(rect_x - 2, rect_y - 2, rect_w + 4, rect_h + 4)
+        painter.setPen(QPen(QColor(76, 175, 80), 3))  # Green border
+        painter.setBrush(Qt.BrushStyle.NoBrush)
+        painter.drawRoundedRect(border_rect, 8, 8)
+        painter.end()
+
+    def show_step(
+        self, rect: QRect, title: str, text: str, current_step: int = 1, total_steps: int = 1
+    ):
+        """
+        rect must already be in the overlay's coordinate space (i.e. mapped).
+        This method positions the message box so it does not overlap the rect.
+
+        Args:
+            rect(QRect): rectangle to highlight
+            title(str): Title text for the step
+            text(str): Main content text for the step
+            current_step(int):  Current step number
+            total_steps(int): Total number of steps in the tour
+        """
+        self.current_rect = rect
+
+        # Update step indicator in top right
+        self.step_label.setText(f"Step {current_step} of {total_steps}")
+
+        # Update main content text (without step number since it's now in top right)
+        content_text = f"<b>{title}</b><br>{text}" if title else text
+        self.label.setText(content_text)
+        self.message_box.adjustSize()  # ensure layout applied
+        message_size = self.message_box.size()  # actual widget size (width, height)
+
+        spacing = 15
+
+        # Preferred placement: to the right, vertically centered
+        pos_x = rect.right() + spacing
+        pos_y = rect.center().y() - (message_size.height() // 2)
+
+        # If it would go off the right edge, try left of the widget
+        if pos_x + message_size.width() > self.width():
+            pos_x = rect.left() - message_size.width() - spacing
+            # vertical center is still good, but if that overlaps top/bottom we'll clamp below
+
+        # If it goes off the left edge (no space either side), place below, centered horizontally
+        if pos_x < spacing:
+            pos_x = rect.center().x() - (message_size.width() // 2)
+            pos_y = rect.bottom() + spacing
+
+        # If it goes off the bottom, try moving it above the widget
+        if pos_y + message_size.height() > self.height() - spacing:
+            # if there's room above the rect, put it there
+            candidate_y = rect.top() - message_size.height() - spacing
+            if candidate_y >= spacing:
+                pos_y = candidate_y
+            else:
+                # otherwise clamp to bottom with spacing
+                pos_y = max(spacing, self.height() - message_size.height() - spacing)
+
+        # If it goes off the top, clamp down
+        pos_y = max(spacing, pos_y)
+
+        # Make sure we don't poke the left edge
+        pos_x = max(spacing, min(pos_x, self.width() - message_size.width() - spacing))
+
+        # Apply geometry and show
+        self.message_box.setGeometry(
+            int(pos_x), int(pos_y), message_size.width(), message_size.height()
+        )
+        self.message_box.show()
+        self.update()
+
+    def eventFilter(self, obj, event):
+        if event.type() == QEvent.Type.Resize:
+            self.setGeometry(obj.rect())
+        return False
+
+
+class GuidedTour(QObject):
+    """
+    A guided help system for creating interactive GUI tours.
+
+    Allows developers to register widgets with help text and create guided tours.
+    """
+
+    tour_started = Signal()
+    tour_finished = Signal()
+    step_changed = Signal(int, int)  # current_step, total_steps
+
+    def __init__(self, main_window: QWidget, *, enforce_visibility: bool = True):
+        super().__init__()
+        self._visible_check: bool = enforce_visibility
+        self.main_window_ref = saferef.safe_ref(main_window)
+        self.overlay = None
+        self._registered_widgets: Dict[str, TourStep] = {}
+        self._tour_steps: List[TourStep] = []
+        self._current_index = 0
+        self._active = False
+
+    @property
+    def main_window(self) -> QWidget | None:
+        """Get the main window from weak reference."""
+        if self.main_window_ref and callable(self.main_window_ref):
+            widget = self.main_window_ref()
+            if isinstance(widget, QWidget):
+                return widget
+        return None
+
+    def register_widget(
+        self,
+        *,
+        widget: QWidget | QAction | Callable[[], tuple[QWidget | QAction, str | None]],
+        text: str = "",
+        title: str = "",
+    ) -> str:
+        """
+        Register a widget with help text for tours.
+
+        Args:
+            widget (QWidget | QAction | Callable[[], tuple[QWidget | QAction, str | None]]): The target widget or a callable that returns the widget and its help text.
+            text (str): The help text for the widget. This will be shown during the tour.
+            title (str, optional): A title for the widget (defaults to its class name or action text).
+
+        Returns:
+            str: The unique ID for the registered widget.
+        """
+        step_id = str(uuid4())
+        # If it's a plain callable
+        if callable(widget) and not hasattr(widget, "__self__"):
+            widget_ref = widget
+            default_title = "Widget"
+        elif isinstance(widget, QAction):
+            widget_ref = weakref.ref(widget)
+            default_title = widget.text() or "Action"
+        elif hasattr(widget, "get_toolbar_button") and callable(widget.get_toolbar_button):
+
+            def _resolve_toolbar_button(toolbar_action=widget):
+                button = toolbar_action.get_toolbar_button()
+                return (button, None)
+
+            widget_ref = _resolve_toolbar_button
+            default_title = getattr(widget, "tooltip", "Toolbar Menu")
+        else:
+            widget_ref = saferef.safe_ref(widget)
+            default_title = widget.__class__.__name__ if hasattr(widget, "__class__") else "Widget"
+
+        self._registered_widgets[step_id] = {
+            "widget_ref": widget_ref,
+            "text": text,
+            "title": title or default_title,
+        }
+        logger.debug(f"Registered widget {title or default_title} with ID {step_id}")
+        return step_id
+
+    def _action_highlight_rect(self, action: QAction) -> QRect | None:
+        """
+        Try to find the QRect in main_window coordinates that should be highlighted for the given QAction.
+        Returns None if not found (e.g. not visible).
+        """
+        mw = self.main_window
+        if mw is None:
+            return None
+        # Try toolbars first
+        for tb in mw.findChildren(QToolBar):
+            btn = tb.widgetForAction(action)
+            if btn and btn.isVisible():
+                rect = btn.rect()
+                top_left = btn.mapTo(mw, rect.topLeft())
+                return QRect(top_left, rect.size())
+        # Try menu bars
+        menubars = []
+        if hasattr(mw, "menuBar") and callable(getattr(mw, "menuBar", None)):
+            mb = mw.menuBar()
+            if mb and mb not in menubars:
+                menubars.append(mb)
+        menubars += [mb for mb in mw.findChildren(QMenuBar) if mb not in menubars]
+        for mb in menubars:
+            if action in mb.actions():
+                ar = mb.actionGeometry(action)
+                top_left = mb.mapTo(mw, ar.topLeft())
+                return QRect(top_left, ar.size())
+        return None
+
+    def unregister_widget(self, step_id: str) -> bool:
+        """
+        Unregister a previously registered widget.
+
+        Args:
+            step_id (str): The unique ID of the registered widget.
+
+        Returns:
+            bool: True if the widget was unregistered, False if not found.
+        """
+        if self._active:
+            raise RuntimeError("Cannot unregister widget while tour is active")
+        if step_id in self._registered_widgets:
+            if self._registered_widgets[step_id] in self._tour_steps:
+                self._tour_steps.remove(self._registered_widgets[step_id])
+            del self._registered_widgets[step_id]
+            return True
+        return False
+
+    def create_tour(self, step_ids: List[str] | None = None) -> bool:
+        """
+        Create a tour from registered widget IDs.
+
+        Args:
+            step_ids (List[str], optional): List of registered widget IDs to include in the tour. If None, all registered widgets will be included.
+
+        Returns:
+            bool: True if the tour was created successfully, False if any step IDs were not found
+        """
+        if step_ids is None:
+            step_ids = list(self._registered_widgets.keys())
+
+        tour_steps = []
+        for step_id in step_ids:
+            if step_id not in self._registered_widgets:
+                logger.error(f"Step ID {step_id} not found")
+                return False
+            tour_steps.append(self._registered_widgets[step_id])
+
+        self._tour_steps = tour_steps
+        logger.info(f"Created tour with {len(tour_steps)} steps")
+        return True
+
+    @SafeSlot()
+    def start_tour(self):
+        """Start the guided tour."""
+        if not self._tour_steps:
+            self.create_tour()
+
+        if self._active:
+            logger.warning("Tour already active")
+            return
+
+        main_window = self.main_window
+        if main_window is None:
+            logger.error("Main window no longer exists (weak reference is dead)")
+            return
+
+        self._active = True
+        self._current_index = 0
+
+        # Create overlay
+        self.overlay = TutorialOverlay(main_window)
+        self.overlay.setGeometry(main_window.rect())
+        self.overlay.show()
+        main_window.installEventFilter(self.overlay)
+
+        # Connect signals
+        self.overlay.next_btn.clicked.connect(self.next_step)
+        self.overlay.back_btn.clicked.connect(self.prev_step)
+        self.overlay.close_btn.clicked.connect(self.stop_tour)
+
+        main_window.installEventFilter(self)
+        self._show_current_step()
+        self.tour_started.emit()
+        logger.info("Started guided tour")
+
+    @SafeSlot()
+    def stop_tour(self):
+        """Stop the current tour."""
+        if not self._active:
+            return
+
+        self._active = False
+
+        main_window = self.main_window
+        if self.overlay and main_window:
+            main_window.removeEventFilter(self.overlay)
+            self.overlay.hide()
+            self.overlay.deleteLater()
+            self.overlay = None
+
+        if main_window:
+            main_window.removeEventFilter(self)
+        self.tour_finished.emit()
+        logger.info("Stopped guided tour")
+
+    @SafeSlot()
+    def next_step(self):
+        """Move to next step or finish tour if on last step."""
+        if not self._active:
+            return
+
+        if self._current_index < len(self._tour_steps) - 1:
+            self._current_index += 1
+            self._show_current_step()
+        else:
+            # On last step, finish the tour
+            self.stop_tour()
+
+    @SafeSlot()
+    def prev_step(self):
+        """Move to previous step."""
+        if not self._active:
+            return
+
+        if self._current_index > 0:
+            self._current_index -= 1
+            self._show_current_step()
+
+    def _show_current_step(self):
+        """Display the current step."""
+        if not self._active or not self.overlay:
+            return
+
+        step = self._tour_steps[self._current_index]
+        step_title = step["title"]
+
+        target, step_text = self._resolve_step_target(step)
+        if target is None:
+            self._advance_past_invalid_step(step_title, reason="Step target no longer exists.")
+            return
+
+        main_window = self.main_window
+        if main_window is None:
+            logger.error("Main window no longer exists (weak reference is dead)")
+            self.stop_tour()
+            return
+
+        highlight_rect = self._get_highlight_rect(main_window, target, step_title)
+        if highlight_rect is None:
+            return
+
+        # Calculate step numbers
+        current_step = self._current_index + 1
+        total_steps = len(self._tour_steps)
+
+        self.overlay.show_step(highlight_rect, step_title, step_text, current_step, total_steps)
+
+        # Update button states
+        self.overlay.back_btn.setEnabled(self._current_index > 0)
+
+        # Update next button text and state
+        is_last_step = self._current_index >= len(self._tour_steps) - 1
+        if is_last_step:
+            self.overlay.next_btn.setText("Finish")
+            self.overlay.next_btn.setIcon(material_icon("check"))
+            self.overlay.next_btn.setEnabled(True)
+        else:
+            self.overlay.next_btn.setText("Next")
+            self.overlay.next_btn.setIcon(material_icon("arrow_forward"))
+            self.overlay.next_btn.setEnabled(True)
+
+        self.step_changed.emit(self._current_index + 1, len(self._tour_steps))
+
+    def _resolve_step_target(self, step: TourStep) -> tuple[QWidget | QAction | None, str]:
+        """
+        Resolve the target widget/action for the given step.
+
+        Args:
+            step(TourStep): The tour step to resolve.
+
+        Returns:
+            tuple[QWidget | QAction | None, str]: The resolved target and the step text.
+        """
+        widget_ref = step.get("widget_ref")
+        step_text = step.get("text", "")
+
+        if isinstance(widget_ref, (louie.saferef.BoundMethodWeakref, weakref.ReferenceType)):
+            target = widget_ref()
+        else:
+            target = widget_ref
+
+        if target is None:
+            return None, step_text
+
+        if callable(target) and not isinstance(target, (QWidget, QAction)):
+            result = target()
+            if isinstance(result, tuple):
+                target, alt_text = result
+                if alt_text:
+                    step_text = alt_text
+            else:
+                target = result
+
+        return target, step_text
+
+    def _get_highlight_rect(
+        self, main_window: QWidget, target: QWidget | QAction, step_title: str
+    ) -> QRect | None:
+        """
+        Get the QRect in main_window coordinates to highlight for the given target.
+
+        Args:
+            main_window(QWidget): The main window containing the target.
+            target(QWidget | QAction): The target widget or action to highlight.
+            step_title(str): The title of the current step (for logging purposes).
+
+        Returns:
+            QRect | None: The rectangle to highlight, or None if not found/visible.
+        """
+        if isinstance(target, QAction):
+            rect = self._action_highlight_rect(target)
+            if rect is None:
+                self._advance_past_invalid_step(
+                    step_title,
+                    reason=f"Could not find visible widget or menu for QAction {target.text()!r}.",
+                )
+                return None
+            return rect
+
+        if isinstance(target, QWidget):
+            if self._visible_check:
+                if not target.isVisible():
+                    self._advance_past_invalid_step(
+                        step_title, reason=f"Widget {target!r} is not visible."
+                    )
+                    return None
+            rect = target.rect()
+            top_left = target.mapTo(main_window, rect.topLeft())
+            return QRect(top_left, rect.size())
+
+        self._advance_past_invalid_step(
+            step_title, reason=f"Unsupported step target type: {type(target)}"
+        )
+        return None
+
+    def _advance_past_invalid_step(self, step_title: str, *, reason: str):
+        """
+        Skip the current step (or stop the tour) when the target cannot be visualised.
+        """
+        logger.warning("%s Skipping step %r.", reason, step_title)
+        if self._current_index < len(self._tour_steps) - 1:
+            self._current_index += 1
+            self._show_current_step()
+        else:
+            self.stop_tour()
+
+    def get_registered_widgets(self) -> Dict[str, TourStep]:
+        """Get all registered widgets."""
+        return self._registered_widgets.copy()
+
+    def clear_registrations(self):
+        """Clear all registered widgets."""
+        if self._active:
+            self.stop_tour()
+        self._registered_widgets.clear()
+        self._tour_steps.clear()
+        logger.info("Cleared all registrations")
+
+    def set_visibility_enforcement(self, enabled: bool):
+        """Enable or disable visibility checks when highlighting widgets."""
+        self._visible_check = enabled
+
+    def eventFilter(self, obj, event):
+        """Handle window resize/move events to update step positioning."""
+        if event.type() in (QEvent.Type.Move, QEvent.Type.Resize):
+            if self._active:
+                self._show_current_step()
+        return super().eventFilter(obj, event)
+
+
+################################################################################
+############ # Example usage of GuidedTour system ##############################
+################################################################################
+
+
+class MainWindow(QMainWindow):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Guided Tour Demo")
+        central = QWidget()
+        layout = QVBoxLayout(central)
+        layout.setSpacing(12)
+
+        layout.addWidget(QLabel("Welcome to the guided tour demo with toolbar support."))
+        self.btn1 = QPushButton("Primary Button")
+        self.btn2 = QPushButton("Secondary Button")
+        self.status_label = QLabel("Use the controls below or the toolbar to interact.")
+        self.start_tour_btn = QPushButton("Start Guided Tour")
+
+        layout.addWidget(self.btn1)
+        layout.addWidget(self.btn2)
+        layout.addWidget(self.status_label)
+        layout.addStretch()
+        layout.addWidget(self.start_tour_btn)
+        self.setCentralWidget(central)
+
+        # Guided tour system
+        self.guided_help = GuidedTour(self)
+
+        # Menus for demonstrating QAction support in menu bars
+        self._init_menu_bar()
+
+        # Modular toolbar showcasing QAction targets
+        self._init_toolbar()
+
+        # Register widgets and actions with help text
+        primary_step = self.guided_help.register_widget(
+            widget=self.btn1,
+            text="The primary button updates the status text when clicked.",
+            title="Primary Button",
+        )
+        secondary_step = self.guided_help.register_widget(
+            widget=self.btn2,
+            text="The secondary button complements the demo layout.",
+            title="Secondary Button",
+        )
+        toolbar_action_step = self.guided_help.register_widget(
+            widget=self.toolbar_tour_action.action,
+            text="Toolbar actions are supported in the guided tour. This one also starts the tour.",
+            title="Toolbar Tour Action",
+        )
+        tools_menu_step = self.guided_help.register_widget(
+            widget=self.toolbar.components.get_action("menu_tools"),
+            text="Expandable toolbar menus group related actions. This button opens the tools menu.",
+            title="Tools Menu",
+        )
+
+        # Create tour from registered widgets
+        self.tour_step_ids = [primary_step, secondary_step, toolbar_action_step, tools_menu_step]
+        widget_ids = self.tour_step_ids
+        self.guided_help.create_tour(widget_ids)
+
+        # Connect start button
+        self.start_tour_btn.clicked.connect(self.guided_help.start_tour)
+
+    def _init_menu_bar(self):
+        menu_bar = self.menuBar()
+        info_menu = menu_bar.addMenu("Info")
+        info_menu.setObjectName("info-menu")
+        self.info_menu = info_menu
+        self.info_menu_action = info_menu.menuAction()
+        self.about_action = info_menu.addAction("About This Demo")
+
+    def _init_toolbar(self):
+        self.toolbar = ModularToolBar(parent=self)
+        self.addToolBar(self.toolbar)
+
+        self.toolbar_tour_action = MaterialIconAction(
+            "play_circle", tooltip="Start the guided tour", parent=self
+        )
+        self.toolbar.components.add_safe("tour-start", self.toolbar_tour_action)
+
+        self.toolbar_highlight_action = MaterialIconAction(
+            "visibility", tooltip="Highlight the primary button", parent=self
+        )
+        self.toolbar.components.add_safe("inspect-primary", self.toolbar_highlight_action)
+
+        demo_bundle = self.toolbar.new_bundle("demo")
+        demo_bundle.add_action("tour-start")
+        demo_bundle.add_action("inspect-primary")
+
+        self._setup_tools_menu()
+        self.toolbar.show_bundles(["demo", "menu_tools"])
+        self.toolbar.refresh()
+
+        self.toolbar_tour_action.action.triggered.connect(self.guided_help.start_tour)
+
+    def _setup_tools_menu(self):
+        self.tools_menu_actions: dict[str, MaterialIconAction] = {
+            "notes": MaterialIconAction(
+                icon_name="note_add", tooltip="Add a note", filled=True, parent=self
+            ),
+            "bookmark": MaterialIconAction(
+                icon_name="bookmark_add", tooltip="Bookmark current view", filled=True, parent=self
+            ),
+            "settings": MaterialIconAction(
+                icon_name="tune", tooltip="Adjust settings", filled=True, parent=self
+            ),
+        }
+        self.tools_menu_action = ExpandableMenuAction(
+            label="Tools ", actions=self.tools_menu_actions
+        )
+        self.toolbar.components.add_safe("menu_tools", self.tools_menu_action)
+        bundle = ToolbarBundle("menu_tools", self.toolbar.components)
+        bundle.add_action("menu_tools")
+        self.toolbar.add_bundle(bundle)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication(sys.argv)
+    from bec_qthemes import apply_theme
+
+    apply_theme("dark")
+    w = MainWindow()
+    w.resize(400, 300)
+    w.show()
+    sys.exit(app.exec())

bec_widgets/utils/help_inspector/help_inspector.py

@@ -0,0 +1,247 @@
+"""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
+from bec_widgets.utils.widget_io import WidgetHierarchy
+
+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: QtWidgets.QWidget, event: QtCore.QEvent) -> bool:
+        """
+        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 not active, return immediately
+        if not self._active:
+            return super().eventFilter(obj, event)
+        # If active, handle escape key
+        if event.type() == QtCore.QEvent.KeyPress and event.key() == QtCore.Qt.Key_Escape:
+            self._toggle_mode(False)
+            return super().eventFilter(obj, event)
+        # If active, and left mouse button pressed, handle click
+        if event.type() == QtCore.QEvent.MouseButtonPress:
+            if event.button() == QtCore.Qt.LeftButton:
+                widget = self._app.widgetAt(event.globalPos())
+                if widget is None:
+                    return super().eventFilter(obj, event)
+                # Get BECWidget ancestor
+                # TODO check what happens if the HELP Inspector itself is embedded in another BECWidget
+                # I suppose we would like to get the first ancestor that is a BECWidget, not the topmost one
+                if not isinstance(widget, BECWidget):
+                    widget = WidgetHierarchy._get_becwidget_ancestor(widget)
+                if widget:
+                    if widget is self:
+                        self._toggle_mode(False)
+                        return True
+                    for cb in self._callbacks.values():
+                        try:
+                            cb(widget)
+                        except Exception as e:
+                            logger.error(f"Error occurred in callback {cb}: {e}")
+                    return True
+        return super().eventFilter(obj, event)
+
+    def register_callback(self, callback: Callable[[QtWidgets.QWidget], None]) -> str:
+        """
+        Register a callback to be called when a widget is inspected.
+        The callback should be callable with the following signature:
+            callback(widget: QWidget) -> None
+
+        Args:
+            callback (Callable[[QWidget], None]): The callback function to register.
+        Returns:
+            str: A unique ID for the registered callback.
+        """
+        cb_id = str(uuid4())
+        self._callbacks[cb_id] = callback
+        return cb_id
+
+    def unregister_callback(self, cb_id: str):
+        """Unregister a previously registered callback."""
+        self._callbacks.pop(cb_id, None)
+
+    def _register_default_callbacks(self):
+        """Default behavior: publish tooltip, docstring, bec_help"""
+
+        def cb_doc(widget: QtWidgets.QWidget):
+            docstring = widget.__doc__ or "No documentation available."
+            self.widget_docstring.emit(docstring)
+
+        def cb_help(widget: QtWidgets.QWidget):
+            tooltip = widget.toolTip() or "No tooltip available."
+            self.widget_tooltip.emit(tooltip)
+
+        def cb_bec_help(widget: QtWidgets.QWidget):
+            help_text = None
+            if hasattr(widget, "get_help_md") and callable(widget.get_help_md):
+                try:
+                    help_text = widget.get_help_md()
+                except Exception as e:
+                    logger.debug(f"Error retrieving help text from {widget}: {e}")
+            if help_text is None:
+                help_text = widget.toolTip() or "No help available."
+            if not isinstance(help_text, str):
+                logger.error(
+                    f"Help text from {widget.__class__} is not a string: {type(help_text)}"
+                )
+                help_text = str(help_text)
+            self.bec_widget_help.emit(help_text)
+
+        self.register_callback(cb_doc)
+        self.register_callback(cb_help)
+        self.register_callback(cb_bec_help)
+
+
+if __name__ == "__main__":
+    import sys
+
+    from bec_qthemes import apply_theme
+
+    from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
+    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
+    app = QtWidgets.QApplication(sys.argv)
+
+    main_window = QtWidgets.QMainWindow()
+    apply_theme("dark")
+    main_window.setWindowTitle("Help Inspector Test")
+
+    central_widget = QtWidgets.QWidget()
+    main_layout = QtWidgets.QVBoxLayout(central_widget)
+    dark_mode_button = DarkModeButton(parent=main_window)
+    main_layout.addWidget(dark_mode_button)
+
+    help_inspector = HelpInspector()
+    main_layout.addWidget(help_inspector)
+
+    test_button = QtWidgets.QPushButton("Test Button")
+    test_button.setToolTip("This is a test button.")
+    test_line_edit = QtWidgets.QLineEdit()
+    test_line_edit.setToolTip("This is a test line edit.")
+    test_label = QtWidgets.QLabel("Test Label")
+    test_label.setToolTip("")
+    box = PositionerBox()
+
+    layout_1 = QtWidgets.QHBoxLayout()
+    layout_1.addWidget(test_button)
+    layout_1.addWidget(test_line_edit)
+    layout_1.addWidget(test_label)
+    layout_1.addWidget(box)
+    main_layout.addLayout(layout_1)
+
+    doc_label = QtWidgets.QLabel("Docstring will appear here.")
+    tool_tip_label = QtWidgets.QLabel("Tooltip will appear here.")
+    bec_help_label = QtWidgets.QLabel("BEC Help text will appear here.")
+    main_layout.addWidget(doc_label)
+    main_layout.addWidget(tool_tip_label)
+    main_layout.addWidget(bec_help_label)
+
+    help_inspector.widget_tooltip.connect(tool_tip_label.setText)
+    help_inspector.widget_docstring.connect(doc_label.setText)
+    help_inspector.bec_widget_help.connect(bec_help_label.setText)
+
+    main_window.setCentralWidget(central_widget)
+    main_window.resize(400, 200)
+    main_window.show()
+    sys.exit(app.exec())

bec_widgets/utils/list_of_expandable_frames.py

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

bec_widgets/utils/rpc_server.py

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

bec_widgets/utils/serialization.py

@@ -1,34 +1,25 @@
-from typing import Type
-
 from bec_lib.codecs import BECCodec
 from bec_lib.serialization import msgpack
 from qtpy.QtCore import QPointF
 
 
+class QPointFEncoder(BECCodec):
+    obj_type = QPointF
+
+    @staticmethod
+    def encode(obj: QPointF) -> list[float]:
+        """Encode a QPointF object to a list of floats."""
+        return [obj.x(), obj.y()]
+
+    @staticmethod
+    def decode(type_name: str, data: list[float]) -> list[float]:
+        """No-op function since QPointF is encoded as a list of floats."""
+        return data
+
+
 def register_serializer_extension():
     """
     Register the serializer extension for the BECConnector.
     """
     if not msgpack.is_registered(QPointF):
-        msgpack.register_codec(QPointFEncoder)
-
-
-class QPointFEncoder(BECCodec):
-    obj_type: Type = QPointF
-
-    @staticmethod
-    def encode(obj: QPointF) -> str:
-        """
-        Encode a QPointF object to a list of floats. As this is mostly used for sending
-        data to the client, it is not necessary to convert it back to a QPointF object.
-        """
-        if isinstance(obj, QPointF):
-            return [obj.x(), obj.y()]
-        return obj
-
-    @staticmethod
-    def decode(type_name: str, data: list[float]) -> list[float]:
-        """
-        no-op function since QPointF is encoded as a list of floats.
-        """
-        return data
+        msgpack.register(QPointF, QPointFEncoder.encode, QPointFEncoder.decode)

bec_widgets/utils/toolbars/actions.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import os
+import weakref
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
 from typing import Dict, Literal
@@ -33,6 +34,32 @@ 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)
+    if getattr(toolbar_action, "label_text", None):
+        toolbar_action.action.setText(toolbar_action.label_text)
+    if getattr(toolbar_action, "tooltip", None):
+        toolbar_action.action.setToolTip(toolbar_action.tooltip)
+        btn.setToolTip(toolbar_action.tooltip)
+
+    btn.setDefaultAction(toolbar_action.action)
+    btn.setAutoRaise(True)
+    if toolbar_action.text_position == "beside":
+        btn.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
+    else:
+        btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
+    btn.setText(toolbar_action.label_text)
+    toolbar.addWidget(btn)
+
+
 class NoCheckDelegate(QStyledItemDelegate):
     """To reduce space in combo boxes by removing the checkmark."""
 
@@ -114,15 +141,39 @@ class SeparatorAction(ToolBarAction):
 
 
 class QtIconAction(ToolBarAction):
-    def __init__(self, standard_icon, tooltip=None, checkable=False, parent=None):
+    def __init__(
+        self,
+        standard_icon,
+        tooltip=None,
+        checkable=False,
+        label_text: str | None = None,
+        text_position: Literal["beside", "under"] | None = None,
+        parent=None,
+    ):
+        """
+        Action with a standard Qt icon for the toolbar.
+
+        Args:
+            standard_icon: The standard icon from QStyle.
+            tooltip(str, optional): The tooltip for the action. Defaults to None.
+            checkable(bool, optional): Whether the action is checkable. Defaults to False.
+            label_text(str | None, optional): Optional label text to display beside or under the icon.
+            text_position(Literal["beside", "under"] | None, optional): Position of text relative to icon.
+            parent(QWidget or None, optional): Parent widget for the underlying QAction.
+        """
         super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
         self.standard_icon = standard_icon
         self.icon = QApplication.style().standardIcon(standard_icon)
         self.action = QAction(icon=self.icon, text=self.tooltip, parent=parent)
         self.action.setCheckable(self.checkable)
+        self.label_text = label_text
+        self.text_position = text_position
 
     def add_to_toolbar(self, toolbar, target):
-        toolbar.addAction(self.action)
+        if self.label_text is not None:
+            create_action_with_text(toolbar_action=self, toolbar=toolbar)
+        else:
+            toolbar.addAction(self.action)
 
     def get_icon(self):
         return self.icon
@@ -139,6 +190,8 @@ class MaterialIconAction(ToolBarAction):
         filled (bool, optional): Whether the icon is filled. Defaults to False.
         color (str | tuple | QColor | dict[Literal["dark", "light"], str] | None, optional): The color of the icon.
             Defaults to None.
+        label_text (str | None, optional): Optional label text to display beside or under the icon.
+        text_position (Literal["beside", "under"] | None, optional): Position of text relative to icon.
         parent (QWidget or None, optional): Parent widget for the underlying QAction.
     """
 
@@ -149,19 +202,23 @@ 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,
-            size=(20, 20),
-            convert_to_pixmap=False,
-            filled=self.filled,
-            color=self.color,
+            self.icon_name, size=(20, 20), icon_type=QIcon, filled=self.filled, color=self.color
         )
         if parent is None:
             logger.warning(
@@ -178,7 +235,10 @@ class MaterialIconAction(ToolBarAction):
             toolbar(QToolBar): The toolbar to add the action to.
             target(QWidget): The target widget for the action.
         """
-        toolbar.addAction(self.action)
+        if self.label_text is not None:
+            create_action_with_text(toolbar_action=self, toolbar=toolbar)
+        else:
+            toolbar.addAction(self.action)
 
     def get_icon(self):
         """
@@ -443,6 +503,8 @@ class ExpandableMenuAction(ToolBarAction):
     def __init__(self, label: str, actions: dict, icon_path: str = None):
         super().__init__(icon_path, label)
         self.actions = actions
+        self._button_ref: weakref.ReferenceType[QToolButton] | None = None
+        self._menu_ref: weakref.ReferenceType[QMenu] | None = None
 
     def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
         button = QToolButton(toolbar)
@@ -478,6 +540,14 @@ class ExpandableMenuAction(ToolBarAction):
             menu.addAction(action)
         button.setMenu(menu)
         toolbar.addWidget(button)
+        self._button_ref = weakref.ref(button)
+        self._menu_ref = weakref.ref(menu)
+
+    def get_toolbar_button(self) -> QToolButton | None:
+        return self._button_ref() if self._button_ref else None
+
+    def get_menu(self) -> QMenu | None:
+        return self._menu_ref() if self._menu_ref else None
 
 
 class DeviceComboBoxAction(WidgetAction):
@@ -524,3 +594,76 @@ class DeviceComboBoxAction(WidgetAction):
             self.combobox.close()
             self.combobox.deleteLater()
         return super().cleanup()
+
+
+class TutorialAction(MaterialIconAction):
+    """
+    Action for starting a guided tutorial/help tour.
+
+    This action automatically initializes a GuidedTour instance and provides
+    methods to register widgets and start tours.
+
+    Args:
+        main_window (QWidget): The main window widget for the guided tour overlay.
+        tooltip (str, optional): The tooltip for the action. Defaults to "Start Guided Tutorial".
+        parent (QWidget or None, optional): Parent widget for the underlying QAction.
+    """
+
+    def __init__(self, main_window: QWidget, tooltip: str = "Start Guided Tutorial", parent=None):
+        super().__init__(
+            icon_name="help",
+            tooltip=tooltip,
+            checkable=False,
+            filled=False,
+            color=None,
+            parent=parent,
+        )
+
+        from bec_widgets.utils.guided_tour import GuidedTour
+
+        self.guided_help = GuidedTour(main_window)
+        self.main_window = main_window
+
+        # Connect the action to start the tour
+        self.action.triggered.connect(self.start_tour)
+
+    def register_widget(self, widget: QWidget, text: str, widget_name: str = "") -> str:
+        """
+        Register a widget for the guided tour.
+
+        Args:
+            widget (QWidget): The widget to highlight during the tour.
+            text (str): The help text to display.
+            widget_name (str, optional): Optional name for the widget.
+
+        Returns:
+            str: Unique ID for the registered widget.
+        """
+        return self.guided_help.register_widget(widget, text, widget_name)
+
+    def start_tour(self):
+        """Start the guided tour with all registered widgets."""
+        registered_widgets = self.guided_help.get_registered_widgets()
+        if registered_widgets:
+            # Create tour from all registered widgets
+            step_ids = list(registered_widgets.keys())
+            if self.guided_help.create_tour(step_ids):
+                self.guided_help.start_tour()
+            else:
+                logger.warning("Failed to create guided tour")
+        else:
+            logger.warning("No widgets registered for guided tour")
+
+    def has_registered_widgets(self) -> bool:
+        """Check if any widgets have been registered for the tour."""
+        return len(self.guided_help.get_registered_widgets()) > 0
+
+    def clear_registered_widgets(self):
+        """Clear all registered widgets."""
+        self.guided_help.clear_registrations()
+
+    def cleanup(self):
+        """Clean up the guided help instance."""
+        if hasattr(self, "guided_help"):
+            self.guided_help.stop_tour()
+        super().cleanup()

bec_widgets/utils/toolbars/toolbar.py

@@ -6,7 +6,7 @@ from collections import defaultdict
 from typing import DefaultDict, Literal
 
 from bec_lib.logger import bec_logger
-from qtpy.QtCore import QSize, Qt
+from qtpy.QtCore import QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QColor
 from qtpy.QtWidgets import QApplication, QLabel, QMainWindow, QMenu, QToolBar, QVBoxLayout, QWidget
 
@@ -492,10 +492,33 @@ if __name__ == "__main__":  # pragma: no cover
             self.toolbar.connect_bundle(
                 "base", PerformanceConnection(self.toolbar.components, self)
             )
+            self.toolbar.components.add_safe(
+                "text",
+                MaterialIconAction(
+                    "text_fields",
+                    tooltip="Test Text Action",
+                    checkable=True,
+                    label_text="text",
+                    text_position="under",
+                ),
+            )
             self.toolbar.show_bundles(["performance", "plot_export"])
             self.toolbar.get_bundle("performance").add_action("save")
+            self.toolbar.get_bundle("performance").add_action("text")
             self.toolbar.refresh()
 
+            # Timer to disable and enable text button each 2s
+            self.timer = QTimer()
+            self.timer.timeout.connect(self.toggle_text_action)
+            self.timer.start(2000)
+
+        def toggle_text_action(self):
+            text_action = self.toolbar.components.get_action("text")
+            if text_action.action.isEnabled():
+                text_action.action.setEnabled(False)
+            else:
+                text_action.action.setEnabled(True)
+
         def enable_fps_monitor(self, enabled: bool):
             """
             Example method to enable or disable FPS monitoring.

bec_widgets/widgets/containers/ads/__init__.py

@@ -0,0 +1 @@
+from PySide6QtAds import *

bec_widgets/widgets/containers/advanced_dock_area/advanced_dock_area.py

@@ -25,6 +25,7 @@ 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,
@@ -49,9 +50,9 @@ from bec_widgets.widgets.containers.advanced_dock_area.toolbar_components.worksp
     workspace_bundle,
 )
 from bec_widgets.widgets.containers.main_window.main_window import BECMainWindowNoRPC
-from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
+from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox, PositionerBox2D
 from bec_widgets.widgets.control.scan_control import ScanControl
-from bec_widgets.widgets.editors.vscode.vscode import VSCodeEditor
+from bec_widgets.widgets.editors.web_console.web_console import WebConsole
 from bec_widgets.widgets.plots.heatmap.heatmap import Heatmap
 from bec_widgets.widgets.plots.image.image import Image
 from bec_widgets.widgets.plots.motor_map.motor_map import MotorMap
@@ -317,16 +318,22 @@ class AdvancedDockArea(BECWidget, QWidget):
         DEVICE_ACTIONS = {
             "scan_control": (ScanControl.ICON_NAME, "Add Scan Control", "ScanControl"),
             "positioner_box": (PositionerBox.ICON_NAME, "Add Device Box", "PositionerBox"),
+            "positioner_box_2D": (
+                PositionerBox2D.ICON_NAME,
+                "Add Device 2D Box",
+                "PositionerBox2D",
+            ),
         }
         UTIL_ACTIONS = {
             "queue": (BECQueue.ICON_NAME, "Add Scan Queue", "BECQueue"),
-            "vs_code": (VSCodeEditor.ICON_NAME, "Add VS Code", "VSCodeEditor"),
             "status": (BECStatusBox.ICON_NAME, "Add BEC Status Box", "BECStatusBox"),
             "progress_bar": (
                 RingProgressBar.ICON_NAME,
                 "Add Circular ProgressBar",
                 "RingProgressBar",
             ),
+            "terminal": (WebConsole.ICON_NAME, "Add Terminal", "WebConsole"),
+            "bec_shell": (WebConsole.ICON_NAME, "Add BEC Shell", "WebConsole"),
             "log_panel": (LogPanel.ICON_NAME, "Add LogPanel - Disabled", "LogPanel"),
             "sbb_monitor": ("train", "Add SBB Monitor", "SBBMonitor"),
         }
@@ -443,6 +450,18 @@ class AdvancedDockArea(BECWidget, QWidget):
                 act = menu.actions[key].action
                 if widget_type == "LogPanel":
                     act.setEnabled(False)  # keep disabled per issue #644
+                elif key == "terminal":
+                    act.triggered.connect(
+                        lambda _, t=widget_type: self.new(widget=t, closable=True, startup_cmd=None)
+                    )
+                elif key == "bec_shell":
+                    act.triggered.connect(
+                        lambda _, t=widget_type: self.new(
+                            widget=t,
+                            closable=True,
+                            startup_cmd=f"bec --gui-id {self.bec_dispatcher.cli_server.gui_id}",
+                        )
+                    )
                 else:
                     act.triggered.connect(lambda _, t=widget_type: self.new(widget=t))
 
@@ -517,6 +536,7 @@ class AdvancedDockArea(BECWidget, QWidget):
         movable: bool = True,
         start_floating: bool = False,
         where: Literal["left", "right", "top", "bottom"] | None = None,
+        **kwargs,
     ) -> BECWidget:
         """
         Create a new widget (or reuse an instance) and add it as a dock.
@@ -529,6 +549,7 @@ class AdvancedDockArea(BECWidget, QWidget):
             start_floating: Start the dock in a floating state.
             where: Preferred area to add the dock: "left" | "right" | "top" | "bottom".
                    If None, uses the instance default passed at construction time.
+            **kwargs: The keyword arguments for the widget.
         Returns:
             The widget instance.
         """
@@ -536,7 +557,9 @@ class AdvancedDockArea(BECWidget, QWidget):
 
         # 1) Instantiate or look up the widget
         if isinstance(widget, str):
-            widget = cast(BECWidget, widget_handler.create_widget(widget_type=widget, parent=self))
+            widget = cast(
+                BECWidget, widget_handler.create_widget(widget_type=widget, parent=self, **kwargs)
+            )
             widget.name_established.connect(
                 lambda: self._create_dock_with_name(
                     widget=widget,
@@ -901,6 +924,7 @@ 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/containers/advanced_dock_area/toolbar_components/workspace_actions.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from bec_qthemes import material_icon
 from qtpy.QtCore import Qt
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QComboBox, QSizePolicy, QWidget
 
 from bec_widgets import SafeSlot
@@ -28,7 +29,7 @@ class ProfileComboBox(QComboBox):
         self.blockSignals(True)
         self.clear()
 
-        lock_icon = material_icon("edit_off", size=(16, 16), convert_to_pixmap=False)
+        lock_icon = material_icon("edit_off", size=(16, 16), icon_type=QIcon)
 
         for profile in list_profiles():
             if is_profile_readonly(profile):
@@ -168,9 +169,7 @@ class WorkspaceConnection(BundleConnection):
         """
         setattr(self.target_widget, "lock_workspace", value)
         self.components.get_action("lock").action.setChecked(value)
-        icon = material_icon(
-            "lock" if value else "lock_open_right", size=(20, 20), convert_to_pixmap=False
-        )
+        icon = material_icon("lock" if value else "lock_open_right", size=(20, 20), icon_type=QIcon)
         self.components.get_action("lock").action.setIcon(icon)
 
     @SafeSlot()

bec_widgets/widgets/containers/explorer/collapsible_tree_section.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from bec_qthemes import material_icon
 from qtpy.QtCore import QMimeData, Qt, Signal
-from qtpy.QtGui import QDrag
-from qtpy.QtWidgets import QHBoxLayout, QPushButton, QSizePolicy, QVBoxLayout, QWidget
+from qtpy.QtGui import QDrag, QIcon
+from qtpy.QtWidgets import QHBoxLayout, QPushButton, QSizePolicy, QToolButton, QVBoxLayout, QWidget
 
 from bec_widgets.utils.colors import get_theme_palette
 from bec_widgets.utils.error_popups import SafeProperty
@@ -24,7 +24,14 @@ class CollapsibleSection(QWidget):
 
     section_reorder_requested = Signal(str, str)  # (source_title, target_title)
 
-    def __init__(self, parent=None, title="", indentation=10, show_add_button=False):
+    def __init__(
+        self,
+        parent=None,
+        title="",
+        indentation=10,
+        show_add_button=False,
+        tooltip: str | None = None,
+    ):
         super().__init__(parent=parent)
         self.title = title
         self.content_widget = None
@@ -50,6 +57,8 @@ class CollapsibleSection(QWidget):
         self.header_button.mouseMoveEvent = self._header_mouse_move_event
         self.header_button.dragEnterEvent = self._header_drag_enter_event
         self.header_button.dropEvent = self._header_drop_event
+        if tooltip:
+            self.header_button.setToolTip(tooltip)
 
         self.drag_start_position = None
 
@@ -57,13 +66,16 @@ class CollapsibleSection(QWidget):
         header_layout.addWidget(self.header_button)
         header_layout.addStretch()
 
-        self.header_add_button = QPushButton()
+        # Add button in header (icon-only)
+        self.header_add_button = QToolButton()
         self.header_add_button.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
-        self.header_add_button.setFixedSize(20, 20)
+        self.header_add_button.setFixedSize(28, 28)
         self.header_add_button.setToolTip("Add item")
         self.header_add_button.setVisible(show_add_button)
+        self.header_add_button.setToolButtonStyle(Qt.ToolButtonIconOnly)
+        self.header_add_button.setAutoRaise(True)
 
-        self.header_add_button.setIcon(material_icon("add", size=(20, 20)))
+        self.header_add_button.setIcon(material_icon("add", size=(28, 28)))
         header_layout.addWidget(self.header_add_button)
 
         self.main_layout.addLayout(header_layout)
@@ -88,7 +100,7 @@ class CollapsibleSection(QWidget):
         """Update the header button appearance based on expanded state"""
         # Use material icons with consistent sizing to match tree items
         icon_name = "keyboard_arrow_down" if self.expanded else "keyboard_arrow_right"
-        icon = material_icon(icon_name=icon_name, size=(20, 20), convert_to_pixmap=False)
+        icon = material_icon(icon_name=icon_name, size=(20, 20), icon_type=QIcon)
 
         self.header_button.setIcon(icon)
         self.header_button.setText(self.title)

bec_widgets/widgets/containers/explorer/explorer.py

@@ -18,8 +18,8 @@ class Explorer(BECWidget, QWidget):
     RPC = False
     PLUGIN = False
 
-    def __init__(self, parent=None):
-        super().__init__(parent)
+    def __init__(self, parent=None, **kwargs):
+        super().__init__(parent=parent, **kwargs)
 
         # Main layout
         self.main_layout = QVBoxLayout(self)

bec_widgets/widgets/containers/explorer/explorer_delegate.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from typing import Any
+
+from qtpy.QtCore import QModelIndex, QRect, QSortFilterProxyModel, Qt
+from qtpy.QtGui import QPainter
+from qtpy.QtWidgets import QAction, QStyledItemDelegate, QTreeView
+
+from bec_widgets.utils.colors import get_theme_palette
+
+
+class ExplorerDelegate(QStyledItemDelegate):
+    """Custom delegate to show action buttons on hover for the explorer"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.hovered_index = QModelIndex()
+        self.button_rects: list[QRect] = []
+        self.current_macro_info = {}
+        self.target_model = QSortFilterProxyModel
+
+    def paint(self, painter, option, index):
+        """Paint the item with action buttons on hover"""
+        # Paint the default item
+        super().paint(painter, option, index)
+
+        # Early return if not hovering over this item
+        if index != self.hovered_index:
+            return
+
+        tree_view = self.parent()
+        if not isinstance(tree_view, QTreeView):
+            return
+
+        proxy_model = tree_view.model()
+        if not isinstance(proxy_model, self.target_model):
+            return
+
+        actions = self.get_actions_for_current_item(proxy_model, index)
+        if actions:
+            self._draw_action_buttons(painter, option, actions)
+
+    def _draw_action_buttons(self, painter, option, actions: list[Any]):
+        """Draw action buttons on the right side"""
+        button_size = 18
+        margin = 4
+        spacing = 2
+
+        # Calculate total width needed for all buttons
+        total_width = len(actions) * button_size + (len(actions) - 1) * spacing
+
+        # Clear previous button rects and create new ones
+        self.button_rects.clear()
+
+        # Calculate starting position (right side of the item)
+        start_x = option.rect.right() - total_width - margin
+        current_x = start_x
+
+        painter.save()
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        # Get theme colors for better integration
+        palette = get_theme_palette()
+        button_bg = palette.button().color()
+        button_bg.setAlpha(150)  # Semi-transparent
+
+        for action in actions:
+            if not action.isVisible():
+                continue
+
+            # Calculate button position
+            button_rect = QRect(
+                current_x,
+                option.rect.top() + (option.rect.height() - button_size) // 2,
+                button_size,
+                button_size,
+            )
+            self.button_rects.append(button_rect)
+
+            # Draw button background
+            painter.setBrush(button_bg)
+            painter.setPen(palette.mid().color())
+            painter.drawRoundedRect(button_rect, 3, 3)
+
+            # Draw action icon
+            icon = action.icon()
+            if not icon.isNull():
+                icon_rect = button_rect.adjusted(2, 2, -2, -2)
+                icon.paint(painter, icon_rect)
+
+            # Move to next button position
+            current_x += button_size + spacing
+
+        painter.restore()
+
+    def get_actions_for_current_item(self, model, index) -> list[QAction] | None:
+        """Get actions for the current item based on its type"""
+        return None
+
+    def editorEvent(self, event, model, option, index):
+        """Handle mouse events for action buttons"""
+        # Early return if not a left click
+        if not (
+            event.type() == event.Type.MouseButtonPress
+            and event.button() == Qt.MouseButton.LeftButton
+        ):
+            return super().editorEvent(event, model, option, index)
+
+        actions = self.get_actions_for_current_item(model, index)
+        if not actions:
+            return super().editorEvent(event, model, option, index)
+
+        # Check which button was clicked
+        visible_actions = [action for action in actions if action.isVisible()]
+        for i, button_rect in enumerate(self.button_rects):
+            if button_rect.contains(event.pos()) and i < len(visible_actions):
+                # Trigger the action
+                visible_actions[i].trigger()
+                return True
+
+        return super().editorEvent(event, model, option, index)
+
+    def set_hovered_index(self, index):
+        """Set the currently hovered index"""
+        self.hovered_index = index

bec_widgets/widgets/containers/explorer/macro_tree_widget.py

@@ -0,0 +1,382 @@
+import ast
+import os
+from pathlib import Path
+from typing import Any
+
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QModelIndex, QRect, Qt, Signal
+from qtpy.QtGui import QStandardItem, QStandardItemModel
+from qtpy.QtWidgets import QAction, QTreeView, QVBoxLayout, QWidget
+
+from bec_widgets.utils.colors import get_theme_palette
+from bec_widgets.utils.toolbars.actions import MaterialIconAction
+from bec_widgets.widgets.containers.explorer.explorer_delegate import ExplorerDelegate
+
+logger = bec_logger.logger
+
+
+class MacroItemDelegate(ExplorerDelegate):
+    """Custom delegate to show action buttons on hover for macro functions"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.macro_actions: list[Any] = []
+        self.button_rects: list[QRect] = []
+        self.current_macro_info = {}
+        self.target_model = QStandardItemModel
+
+    def add_macro_action(self, action: Any) -> None:
+        """Add an action for macro functions"""
+        self.macro_actions.append(action)
+
+    def clear_actions(self) -> None:
+        """Remove all actions"""
+        self.macro_actions.clear()
+
+    def get_actions_for_current_item(self, model, index) -> list[QAction] | None:
+        # Only show actions for macro functions (not directories)
+        item = index.model().itemFromIndex(index)
+        if not item or not item.data(Qt.ItemDataRole.UserRole):
+            return
+
+        macro_info = item.data(Qt.ItemDataRole.UserRole)
+        if not isinstance(macro_info, dict) or "function_name" not in macro_info:
+            return
+
+        self.current_macro_info = macro_info
+        return self.macro_actions
+
+
+class MacroTreeWidget(QWidget):
+    """A tree widget that displays macro functions from Python files"""
+
+    macro_selected = Signal(str, str)  # Function name, file path
+    macro_open_requested = Signal(str, str)  # Function name, file path
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        # Create layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        # Create tree view
+        self.tree = QTreeView()
+        self.tree.setHeaderHidden(True)
+        self.tree.setRootIsDecorated(True)
+
+        # Disable editing to prevent renaming on double-click
+        self.tree.setEditTriggers(QTreeView.EditTrigger.NoEditTriggers)
+
+        # Enable mouse tracking for hover effects
+        self.tree.setMouseTracking(True)
+
+        # Create model for macro functions
+        self.model = QStandardItemModel()
+        self.tree.setModel(self.model)
+
+        # Create and set custom delegate
+        self.delegate = MacroItemDelegate(self.tree)
+        self.tree.setItemDelegate(self.delegate)
+
+        # Add default open button for macros
+        action = MaterialIconAction(icon_name="file_open", tooltip="Open macro file", parent=self)
+        action.action.triggered.connect(self._on_macro_open_requested)
+        self.delegate.add_macro_action(action.action)
+
+        # Apply BEC styling
+        self._apply_styling()
+
+        # Macro specific properties
+        self.directory = None
+
+        # Connect signals
+        self.tree.clicked.connect(self._on_item_clicked)
+        self.tree.doubleClicked.connect(self._on_item_double_clicked)
+
+        # Install event filter for hover tracking
+        self.tree.viewport().installEventFilter(self)
+
+        # Add to layout
+        layout.addWidget(self.tree)
+
+    def _apply_styling(self):
+        """Apply styling to the tree widget"""
+        # Get theme colors for subtle tree lines
+        palette = get_theme_palette()
+        subtle_line_color = palette.mid().color()
+        subtle_line_color.setAlpha(80)
+
+        # Standard editable styling
+        opacity_modifier = ""
+        cursor_style = ""
+
+        # pylint: disable=f-string-without-interpolation
+        tree_style = f""" 
+            QTreeView {{ 
+                border: none;
+                outline: 0;
+                show-decoration-selected: 0;
+                {opacity_modifier}
+                {cursor_style}
+            }}
+            QTreeView::branch {{
+                border-image: none;
+                background: transparent;
+            }}
+
+            QTreeView::item {{
+                border: none;
+                padding: 0px;
+                margin: 0px;
+            }}
+            QTreeView::item:hover {{
+                background: palette(midlight);
+                border: none;
+                padding: 0px;
+                margin: 0px;
+                text-decoration: none;
+            }}
+            QTreeView::item:selected {{
+                background: palette(highlight);
+                color: palette(highlighted-text);
+            }}
+            QTreeView::item:selected:hover {{
+                background: palette(highlight);
+            }}
+        """
+
+        self.tree.setStyleSheet(tree_style)
+
+    def eventFilter(self, obj, event):
+        """Handle mouse move events for hover tracking"""
+        # Early return if not the tree viewport
+        if obj != self.tree.viewport():
+            return super().eventFilter(obj, event)
+
+        if event.type() == event.Type.MouseMove:
+            index = self.tree.indexAt(event.pos())
+            if index.isValid():
+                self.delegate.set_hovered_index(index)
+            else:
+                self.delegate.set_hovered_index(QModelIndex())
+            self.tree.viewport().update()
+            return super().eventFilter(obj, event)
+
+        if event.type() == event.Type.Leave:
+            self.delegate.set_hovered_index(QModelIndex())
+            self.tree.viewport().update()
+            return super().eventFilter(obj, event)
+
+        return super().eventFilter(obj, event)
+
+    def set_directory(self, directory):
+        """Set the macros directory and scan for macro functions"""
+        self.directory = directory
+
+        # Early return if directory doesn't exist
+        if not directory or not os.path.exists(directory):
+            return
+
+        self._scan_macro_functions()
+
+    def _create_file_item(self, py_file: Path) -> QStandardItem | None:
+        """Create a file item with its functions
+
+        Args:
+            py_file: Path to the Python file
+
+        Returns:
+            QStandardItem representing the file, or None if no functions found
+        """
+        # Skip files starting with underscore
+        if py_file.name.startswith("_"):
+            return None
+
+        try:
+            functions = self._extract_functions_from_file(py_file)
+            if not functions:
+                return None
+
+            # Create a file node
+            file_item = QStandardItem(py_file.stem)
+            file_item.setData({"file_path": str(py_file), "type": "file"}, Qt.ItemDataRole.UserRole)
+
+            # Add function nodes
+            for func_name, func_info in functions.items():
+                func_item = QStandardItem(func_name)
+                func_data = {
+                    "function_name": func_name,
+                    "file_path": str(py_file),
+                    "line_number": func_info.get("line_number", 1),
+                    "type": "function",
+                }
+                func_item.setData(func_data, Qt.ItemDataRole.UserRole)
+                file_item.appendRow(func_item)
+
+            return file_item
+        except Exception as e:
+            logger.warning(f"Failed to parse {py_file}: {e}")
+            return None
+
+    def _scan_macro_functions(self):
+        """Scan the directory for Python files and extract macro functions"""
+        self.model.clear()
+        self.model.setHorizontalHeaderLabels(["Macros"])
+
+        if not self.directory or not os.path.exists(self.directory):
+            return
+
+        # Get all Python files in the directory
+        python_files = list(Path(self.directory).glob("*.py"))
+
+        for py_file in python_files:
+            file_item = self._create_file_item(py_file)
+            if file_item:
+                self.model.appendRow(file_item)
+
+        self.tree.expandAll()
+
+    def _extract_functions_from_file(self, file_path: Path) -> dict:
+        """Extract function definitions from a Python file"""
+        functions = {}
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Parse the AST
+            tree = ast.parse(content)
+
+            # Only get top-level function definitions
+            for node in tree.body:
+                if isinstance(node, ast.FunctionDef):
+                    functions[node.name] = {
+                        "line_number": node.lineno,
+                        "docstring": ast.get_docstring(node) or "",
+                    }
+
+        except Exception as e:
+            logger.warning(f"Failed to parse {file_path}: {e}")
+
+        return functions
+
+    def _on_item_clicked(self, index: QModelIndex):
+        """Handle item clicks"""
+        item = self.model.itemFromIndex(index)
+        if not item:
+            return
+
+        data = item.data(Qt.ItemDataRole.UserRole)
+        if not data:
+            return
+
+        if data.get("type") == "function":
+            function_name = data.get("function_name")
+            file_path = data.get("file_path")
+            if function_name and file_path:
+                logger.info(f"Macro function selected: {function_name} in {file_path}")
+                self.macro_selected.emit(function_name, file_path)
+
+    def _on_item_double_clicked(self, index: QModelIndex):
+        """Handle item double-clicks"""
+        item = self.model.itemFromIndex(index)
+        if not item:
+            return
+
+        data = item.data(Qt.ItemDataRole.UserRole)
+        if not data:
+            return
+
+        if data.get("type") == "function":
+            function_name = data.get("function_name")
+            file_path = data.get("file_path")
+            if function_name and file_path:
+                logger.info(
+                    f"Macro open requested via double-click: {function_name} in {file_path}"
+                )
+                self.macro_open_requested.emit(function_name, file_path)
+
+    def _on_macro_open_requested(self):
+        """Handle macro open action triggered"""
+        logger.info("Macro open requested")
+        # Early return if no hovered item
+        if not self.delegate.hovered_index.isValid():
+            return
+
+        macro_info = self.delegate.current_macro_info
+        if not macro_info or macro_info.get("type") != "function":
+            return
+
+        function_name = macro_info.get("function_name")
+        file_path = macro_info.get("file_path")
+        if function_name and file_path:
+            self.macro_open_requested.emit(function_name, file_path)
+
+    def add_macro_action(self, action: Any) -> None:
+        """Add an action for macro items"""
+        self.delegate.add_macro_action(action)
+
+    def clear_actions(self) -> None:
+        """Remove all actions from items"""
+        self.delegate.clear_actions()
+
+    def refresh(self):
+        """Refresh the tree view"""
+        if self.directory is None:
+            return
+        self._scan_macro_functions()
+
+    def refresh_file_item(self, file_path: str):
+        """Refresh a single file item by re-scanning its functions
+
+        Args:
+            file_path: Path to the Python file to refresh
+        """
+        if not file_path or not os.path.exists(file_path):
+            logger.warning(f"Cannot refresh file item: {file_path} does not exist")
+            return
+
+        py_file = Path(file_path)
+
+        # Find existing file item in the model
+        existing_item = None
+        existing_row = -1
+        for row in range(self.model.rowCount()):
+            item = self.model.item(row)
+            if not item or not item.data(Qt.ItemDataRole.UserRole):
+                continue
+            item_data = item.data(Qt.ItemDataRole.UserRole)
+            if item_data.get("type") == "file" and item_data.get("file_path") == str(py_file):
+                existing_item = item
+                existing_row = row
+                break
+
+        # Store expansion state if item exists
+        was_expanded = existing_item and self.tree.isExpanded(existing_item.index())
+
+        # Remove existing item if found
+        if existing_item and existing_row >= 0:
+            self.model.removeRow(existing_row)
+
+        # Create new item using the helper method
+        new_item = self._create_file_item(py_file)
+        if new_item:
+            # Insert at the same position or append if it was a new file
+            insert_row = existing_row if existing_row >= 0 else self.model.rowCount()
+            self.model.insertRow(insert_row, new_item)
+
+            # Restore expansion state
+            if was_expanded:
+                self.tree.expand(new_item.index())
+            else:
+                self.tree.expand(new_item.index())
+
+    def expand_all(self):
+        """Expand all items in the tree"""
+        self.tree.expandAll()
+
+    def collapse_all(self):
+        """Collapse all items in the tree"""
+        self.tree.collapseAll()

bec_widgets/widgets/containers/explorer/script_tree_widget.py

@@ -2,32 +2,29 @@ import os
 from pathlib import Path
 
 from bec_lib.logger import bec_logger
-from qtpy.QtCore import QModelIndex, QRect, QRegularExpression, QSortFilterProxyModel, Qt, Signal
-from qtpy.QtGui import QAction, QPainter
-from qtpy.QtWidgets import QFileSystemModel, QStyledItemDelegate, QTreeView, QVBoxLayout, QWidget
+from qtpy.QtCore import QModelIndex, QRegularExpression, QSortFilterProxyModel, Signal
+from qtpy.QtWidgets import QFileSystemModel, QTreeView, QVBoxLayout, QWidget
 
 from bec_widgets.utils.colors import get_theme_palette
 from bec_widgets.utils.toolbars.actions import MaterialIconAction
+from bec_widgets.widgets.containers.explorer.explorer_delegate import ExplorerDelegate
 
 logger = bec_logger.logger
 
 
-class FileItemDelegate(QStyledItemDelegate):
+class FileItemDelegate(ExplorerDelegate):
     """Custom delegate to show action buttons on hover"""
 
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.hovered_index = QModelIndex()
-        self.file_actions: list[QAction] = []
-        self.dir_actions: list[QAction] = []
-        self.button_rects: list[QRect] = []
-        self.current_file_path = ""
+    def __init__(self, tree_widget):
+        super().__init__(tree_widget)
+        self.file_actions = []
+        self.dir_actions = []
 
-    def add_file_action(self, action: QAction) -> None:
+    def add_file_action(self, action) -> None:
         """Add an action for files"""
         self.file_actions.append(action)
 
-    def add_dir_action(self, action: QAction) -> None:
+    def add_dir_action(self, action) -> None:
         """Add an action for directories"""
         self.dir_actions.append(action)
 
@@ -36,126 +33,18 @@ class FileItemDelegate(QStyledItemDelegate):
         self.file_actions.clear()
         self.dir_actions.clear()
 
-    def paint(self, painter, option, index):
-        """Paint the item with action buttons on hover"""
-        # Paint the default item
-        super().paint(painter, option, index)
-
-        # Early return if not hovering over this item
-        if index != self.hovered_index:
-            return
-
-        tree_view = self.parent()
-        if not isinstance(tree_view, QTreeView):
-            return
-
-        proxy_model = tree_view.model()
-        if not isinstance(proxy_model, QSortFilterProxyModel):
-            return
-
-        source_index = proxy_model.mapToSource(index)
-        source_model = proxy_model.sourceModel()
-        if not isinstance(source_model, QFileSystemModel):
-            return
-
-        is_dir = source_model.isDir(source_index)
-        file_path = source_model.filePath(source_index)
-        self.current_file_path = file_path
-
-        # Choose appropriate actions based on item type
-        actions = self.dir_actions if is_dir else self.file_actions
-        if actions:
-            self._draw_action_buttons(painter, option, actions)
-
-    def _draw_action_buttons(self, painter, option, actions: list[QAction]):
-        """Draw action buttons on the right side"""
-        button_size = 18
-        margin = 4
-        spacing = 2
-
-        # Calculate total width needed for all buttons
-        total_width = len(actions) * button_size + (len(actions) - 1) * spacing
-
-        # Clear previous button rects and create new ones
-        self.button_rects.clear()
-
-        # Calculate starting position (right side of the item)
-        start_x = option.rect.right() - total_width - margin
-        current_x = start_x
-
-        painter.save()
-        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
-
-        # Get theme colors for better integration
-        palette = get_theme_palette()
-        button_bg = palette.button().color()
-        button_bg.setAlpha(150)  # Semi-transparent
-
-        for action in actions:
-            if not action.isVisible():
-                continue
-
-            # Calculate button position
-            button_rect = QRect(
-                current_x,
-                option.rect.top() + (option.rect.height() - button_size) // 2,
-                button_size,
-                button_size,
-            )
-            self.button_rects.append(button_rect)
-
-            # Draw button background
-            painter.setBrush(button_bg)
-            painter.setPen(palette.mid().color())
-            painter.drawRoundedRect(button_rect, 3, 3)
-
-            # Draw action icon
-            icon = action.icon()
-            if not icon.isNull():
-                icon_rect = button_rect.adjusted(2, 2, -2, -2)
-                icon.paint(painter, icon_rect)
-
-            # Move to next button position
-            current_x += button_size + spacing
-
-        painter.restore()
-
-    def editorEvent(self, event, model, option, index):
-        """Handle mouse events for action buttons"""
-        # Early return if not a left click
-        if not (
-            event.type() == event.Type.MouseButtonPress
-            and event.button() == Qt.MouseButton.LeftButton
-        ):
-            return super().editorEvent(event, model, option, index)
-
-        # Early return if not a proxy model
+    def get_actions_for_current_item(self, model, index) -> list[MaterialIconAction] | None:
+        """Get actions for the current item based on its type"""
         if not isinstance(model, QSortFilterProxyModel):
-            return super().editorEvent(event, model, option, index)
+            return None
 
         source_index = model.mapToSource(index)
         source_model = model.sourceModel()
-
-        # Early return if not a file system model
         if not isinstance(source_model, QFileSystemModel):
-            return super().editorEvent(event, model, option, index)
+            return None
 
         is_dir = source_model.isDir(source_index)
-        actions = self.dir_actions if is_dir else self.file_actions
-
-        # Check which button was clicked
-        visible_actions = [action for action in actions if action.isVisible()]
-        for i, button_rect in enumerate(self.button_rects):
-            if button_rect.contains(event.pos()) and i < len(visible_actions):
-                # Trigger the action
-                visible_actions[i].trigger()
-                return True
-
-        return super().editorEvent(event, model, option, index)
-
-    def set_hovered_index(self, index):
-        """Set the currently hovered index"""
-        self.hovered_index = index
+        return self.dir_actions if is_dir else self.file_actions
 
 
 class ScriptTreeWidget(QWidget):
@@ -229,12 +118,18 @@ class ScriptTreeWidget(QWidget):
         subtle_line_color = palette.mid().color()
         subtle_line_color.setAlpha(80)
 
+        # Standard editable styling
+        opacity_modifier = ""
+        cursor_style = ""
+
         # pylint: disable=f-string-without-interpolation
         tree_style = f""" 
             QTreeView {{ 
                 border: none;
                 outline: 0;
                 show-decoration-selected: 0;
+                {opacity_modifier}
+                {cursor_style}
             }}
             QTreeView::branch {{
                 border-image: none;
@@ -286,14 +181,14 @@ class ScriptTreeWidget(QWidget):
 
         return super().eventFilter(obj, event)
 
-    def set_directory(self, directory):
+    def set_directory(self, directory: str) -> None:
         """Set the scripts directory"""
-        self.directory = directory
-
         # Early return if directory doesn't exist
-        if not directory or not os.path.exists(directory):
+        if not directory or not isinstance(directory, str) or not os.path.exists(directory):
             return
 
+        self.directory = directory
+
         root_index = self.model.setRootPath(directory)
         # Map the source model index to proxy model index
         proxy_root_index = self.proxy_model.mapFromSource(root_index)
@@ -357,11 +252,11 @@ class ScriptTreeWidget(QWidget):
 
         self.file_open_requested.emit(file_path)
 
-    def add_file_action(self, action: QAction) -> None:
+    def add_file_action(self, action) -> None:
         """Add an action for file items"""
         self.delegate.add_file_action(action)
 
-    def add_dir_action(self, action: QAction) -> None:
+    def add_dir_action(self, action) -> None:
         """Add an action for directory items"""
         self.delegate.add_dir_action(action)
 

bec_widgets/widgets/containers/main_window/addons/notification_center/notification_banner.py

@@ -119,7 +119,7 @@ class NotificationToast(QFrame):
                 color=SEVERITY[self._kind.value]["color"],
                 filled=True,
                 size=(24, 24),
-                convert_to_pixmap=False,
+                icon_type=QtGui.QIcon,
             )
         )
         icon_btn.setIconSize(QtCore.QSize(24, 24))
@@ -901,7 +901,7 @@ class NotificationIndicator(QWidget):
                 color=SEVERITY[sev.value]["color"],
                 filled=True,
                 size=(20, 20),
-                convert_to_pixmap=False,
+                icon_type=QIcon,
             )
             b.setIcon(icon)
             b.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)

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

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

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

@@ -1,5 +1,6 @@
 from bec_qthemes import material_icon
 from qtpy.QtCore import Qt
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QHBoxLayout, QMessageBox, QPushButton, QToolButton, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
@@ -11,7 +12,7 @@ class ResetButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "restart_alt"
-    RPC = True
+    RPC = False
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
@@ -23,9 +24,7 @@ class ResetButton(BECWidget, QWidget):
         self.layout.setAlignment(Qt.AlignmentFlag.AlignVCenter)
 
         if toolbar:
-            icon = material_icon(
-                "restart_alt", color="#F19E39", filled=True, convert_to_pixmap=False
-            )
+            icon = material_icon("restart_alt", color="#F19E39", filled=True, icon_type=QIcon)
             self.button = QToolButton(icon=icon)
             self.button.setToolTip("Reset the scan queue")
         else:

bec_widgets/widgets/control/buttons/button_resume/button_resume.py

@@ -1,5 +1,6 @@
 from bec_qthemes import material_icon
 from qtpy.QtCore import Qt
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QHBoxLayout, QPushButton, QToolButton, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
@@ -24,7 +25,7 @@ class ResumeButton(BECWidget, QWidget):
         self.layout.setAlignment(Qt.AlignmentFlag.AlignVCenter)
 
         if toolbar:
-            icon = material_icon("resume", color="#2793e8", filled=True, convert_to_pixmap=False)
+            icon = material_icon("resume", color="#2793e8", filled=True, icon_type=QIcon)
             self.button = QToolButton(icon=icon)
             self.button.setToolTip("Resume the scan queue")
         else:

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

@@ -1,5 +1,6 @@
 from bec_qthemes import material_icon
 from qtpy.QtCore import Qt
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QHBoxLayout, QPushButton, QSizePolicy, QToolButton, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
@@ -11,7 +12,7 @@ class StopButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "dangerous"
-    RPC = True
+    RPC = False
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
@@ -24,7 +25,7 @@ class StopButton(BECWidget, QWidget):
         self.layout.setAlignment(Qt.AlignmentFlag.AlignVCenter)
 
         if toolbar:
-            icon = material_icon("stop", color="#cc181e", filled=True, convert_to_pixmap=False)
+            icon = material_icon("stop", color="#cc181e", filled=True, icon_type=QIcon)
             self.button = QToolButton(icon=icon)
             self.button.setToolTip("Stop the scan queue")
         else:

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

@@ -88,7 +88,7 @@ class PositionerBoxBase(BECWidget, CompactPopupWidget):
         if not self._check_device_is_valid(device):
             return
 
-        data = self.dev[device].read()
+        data = self.dev[device].read(cached=True)
         self._on_device_readback(
             device,
             self._device_ui_components(device),

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

@@ -8,7 +8,7 @@ from bec_lib.device import Positioner
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from qtpy.QtCore import Signal
-from qtpy.QtGui import QDoubleValidator
+from qtpy.QtGui import QDoubleValidator, QIcon
 from qtpy.QtWidgets import QDoubleSpinBox
 
 from bec_widgets.utils import UILoader
@@ -87,7 +87,7 @@ class PositionerBox(PositionerBoxBase):
         self.ui.setpoint.setValidator(self.setpoint_validator)
         self.ui.spinner_widget.start()
         self.ui.tool_button.clicked.connect(self._open_dialog_selection(self.set_positioner))
-        icon = material_icon(icon_name="edit_note", size=(16, 16), convert_to_pixmap=False)
+        icon = material_icon(icon_name="edit_note", size=(16, 16), icon_type=QIcon)
         self.ui.tool_button.setIcon(icon)
 
     def force_update_readback(self):

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

@@ -9,7 +9,7 @@ from bec_lib.device import Positioner
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from qtpy.QtCore import Signal
-from qtpy.QtGui import QDoubleValidator
+from qtpy.QtGui import QDoubleValidator, QIcon
 from qtpy.QtWidgets import QDoubleSpinBox
 
 from bec_widgets.utils import UILoader
@@ -121,7 +121,7 @@ class PositionerBox2D(PositionerBoxBase):
         self.ui.tool_button_ver.clicked.connect(
             self._open_dialog_selection(self.set_positioner_ver)
         )
-        icon = material_icon(icon_name="edit_note", size=(16, 16), convert_to_pixmap=False)
+        icon = material_icon(icon_name="edit_note", size=(16, 16), icon_type=QIcon)
         self.ui.tool_button_hor.setIcon(icon)
         self.ui.tool_button_ver.setIcon(icon)
 

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

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

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

@@ -1,62 +1,67 @@
+from textwrap import dedent
 from typing import NamedTuple
+from uuid import uuid4
 
 from bec_qthemes import material_icon
-from qtpy.QtCore import QSize
+from qtpy.QtCore import QItemSelection, QSize, Signal
 from qtpy.QtWidgets import QFrame, QHBoxLayout, QLabel, QListWidgetItem, QVBoxLayout, QWidget
 
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.expandable_frame import ExpandableGroupFrame
+from bec_widgets.widgets.control.device_manager.components._util import SharedSelectionSignal
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_group_ui import (
+    Ui_AvailableDeviceGroup,
+)
 from bec_widgets.widgets.control.device_manager.components.available_device_resources.device_resource_backend import (
     HashableDevice,
 )
-from bec_widgets.widgets.control.device_manager.components.available_device_resources.device_tag_group_item_ui import (
-    Ui_DeviceTagGroup,
-)
-
-DEVICE_HASH_ROLE = 101
+from bec_widgets.widgets.control.device_manager.components.constants import CONFIG_DATA_ROLE
 
 
 def _warning_string(spec: HashableDevice):
-
-    names_str = "\n  ".join(spec.names)
-    msg = (
-        f"Device defined with multiple names! Please check:\n  {names_str}\n"
+    name_warning = (
+        "Device defined with multiple names! Please check:\n  " + "\n  ".join(spec.names)
         if len(spec.names) > 1
         else ""
     )
-
-    source_str = "\n  ".join(spec.source_files)
     source_warning = (
-        f"Device found in multiple source files! Please check:\n  {source_str}"
-        if len(spec.source_files) > 1
+        "Device found in multiple source files! Please check:\n  " + "\n  ".join(spec._source_files)
+        if len(spec._source_files) > 1
         else ""
     )
-    return f"{msg}{source_warning}"
+    return f"{name_warning}{source_warning}"
 
 
 class _DeviceEntryWidget(QFrame):
-    _grid_size = QSize(120, 80)
 
     def __init__(self, device_spec: HashableDevice, parent=None, **kwargs):
         super().__init__(parent, **kwargs)
         self._device_spec = device_spec
         self.included: bool = False
 
-        self.setFrameShape(QFrame.Shape.StyledPanel)
-        self.setFrameShadow(QFrame.Shadow.Raised)
+        self.setFrameStyle(0)
 
         self._layout = QVBoxLayout()
-        self._layout.setContentsMargins(5, 5, 5, 5)
+        self._layout.setContentsMargins(2, 2, 2, 2)
         self.setLayout(self._layout)
-        self.setMinimumSize(self._grid_size)
 
         self.setup_title_layout(device_spec)
         self.check_and_display_warning()
 
-        self.setToolTip(device_spec.rich_text())
+        self.setToolTip(self._rich_text())
 
-        self.details = QLabel(f"Tags:\n{', '.join(device_spec.deviceTags)}")
-        self.details.setStyleSheet("QLabel { font-size: 8pt; }")
-        self.details.setWordWrap(True)
-        self._layout.addWidget(self.details)
+    def _rich_text(self):
+        return dedent(
+            f"""
+        <b><u><h2> {self._device_spec.name}: </h2></u></b>
+        <table>
+        <tr><td> description: </td><td><i> {self._device_spec.description}  </i></td></tr>
+        <tr><td> config:      </td><td><i> {self._device_spec.deviceConfig} </i></td></tr>
+        <tr><td> enabled:     </td><td><i> {self._device_spec.enabled}      </i></td></tr>
+        <tr><td> read only:   </td><td><i> {self._device_spec.readOnly}     </i></td></tr>
+        </table>
+        """
+        )
 
     def setup_title_layout(self, device_spec: HashableDevice):
         self._title_layout = QHBoxLayout()
@@ -72,10 +77,11 @@ 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:
@@ -102,30 +108,49 @@ class _DeviceEntry(NamedTuple):
     widget: _DeviceEntryWidget
 
 
-class DeviceTagGroup(QWidget, Ui_DeviceTagGroup):
+class AvailableDeviceGroup(ExpandableGroupFrame, Ui_AvailableDeviceGroup):
+
+    selected_devices = Signal(list)
+
     def __init__(
-        self, parent=None, name: str = "TagGroupTitle", data: set[HashableDevice] = set(), **kwargs
+        self,
+        parent=None,
+        name: str = "TagGroupTitle",
+        data: set[HashableDevice] = set(),
+        shared_selection_signal=SharedSelectionSignal(),
+        **kwargs,
     ):
         super().__init__(parent=parent, **kwargs)
         self.setupUi(self)
-        self.device_list.setGridSize(_DeviceEntryWidget._grid_size)
-        self.title.setText(name)
+
+        self._shared_selection_signal = shared_selection_signal
+        self._shared_selection_uuid = str(uuid4())
+        self._shared_selection_signal.proc.connect(self._handle_shared_selection_signal)
+        self.device_list.selectionModel().selectionChanged.connect(self._on_selection_changed)
+
+        self.title_text = name  # type: ignore
+        self._mime_data = []
         self._devices: dict[str, _DeviceEntry] = {}
         for device in data:
             self._add_item(device)
         self.device_list.sortItems()
+        self.setMinimumSize(self.device_list.sizeHint())
         self._update_num_included()
 
-        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)
@@ -148,6 +173,25 @@ class DeviceTagGroup(QWidget, Ui_DeviceTagGroup):
         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())
@@ -158,11 +202,8 @@ class DeviceTagGroup(QWidget, Ui_DeviceTagGroup):
         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__":
@@ -171,7 +212,7 @@ if __name__ == "__main__":
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
-    widget = DeviceTagGroup(name="Tag group 1")
+    widget = AvailableDeviceGroup(name="Tag group 1")
     for item in [
         HashableDevice(
             **{

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

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

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

@@ -1,11 +1,16 @@
 from random import randint
-from typing import Any, Callable, Generator, Iterable, TypeVar
+from typing import Any, Iterable
+from uuid import uuid4
 
-from qtpy.QtCore import QSize
-from qtpy.QtWidgets import QListWidgetItem, QWidget
+from qtpy.QtCore import QItemSelection, Signal  # type: ignore
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.control.device_manager.components._util import (
+    SharedSelectionSignal,
+    yield_only_passing,
+)
 from bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_resources_ui import (
     Ui_availableDeviceResources,
 )
@@ -13,65 +18,101 @@ from bec_widgets.widgets.control.device_manager.components.available_device_reso
     HashableDevice,
     get_backend,
 )
-from bec_widgets.widgets.control.device_manager.components.available_device_resources.device_tag_group import (
-    DeviceTagGroup,
-)
-
-_T = TypeVar("_T")
-_RT = TypeVar("_RT")
-
-
-def _yield_only_passing(fn: Callable[[_T], _RT], vals: Iterable[_T]) -> Generator[_RT, Any, None]:
-    for v in vals:
-        try:
-            yield fn(v)
-        except BaseException:
-            pass
+from bec_widgets.widgets.control.device_manager.components.constants import CONFIG_DATA_ROLE
 
 
 class AvailableDeviceResources(BECWidget, QWidget, Ui_availableDeviceResources):
-    def __init__(self, parent=None, **kwargs):
+
+    selected_devices = Signal(list)  # list[dict[str,Any]] of device configs currently selected
+    add_selected_devices = Signal(list)
+    del_selected_devices = Signal(list)
+
+    def __init__(self, parent=None, shared_selection_signal=SharedSelectionSignal(), **kwargs):
         super().__init__(parent=parent, **kwargs)
         self.setupUi(self)
         self._backend = get_backend()
-        self._items: dict[str, tuple[QListWidgetItem, DeviceTagGroup]] = {}
-        self.refresh_full_list()
+        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)
 
-    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)
+        self.tb_add_selected.action.triggered.connect(self._add_selected_action)
+        self.tb_del_selected.action.triggered.connect(self._del_selected_action)
 
-    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 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 _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 _add_device_group(self, device_group: str, devices: set[HashableDevice]):
+        item, widget = self.device_groups_list.add_item(
+            device_group,
+            self.device_groups_list,
+            device_group,
+            devices,
+            shared_selection_signal=self._shared_selection_signal,
+            expanded=False,
+        )
+        item.setData(CONFIG_DATA_ROLE, widget.create_mime_data())
+        # Re-emit the selected items from a subgroup - all other selections should be disabled anyway
+        widget.selected_devices.connect(self.selected_devices)
 
     def resizeEvent(self, event):
         super().resizeEvent(event)
-        for list_item, tag_group_widget in self._items.values():
-            list_item.setSizeHint(tag_group_widget.sizeHint())
+        for list_item, device_group_widget in self.device_groups_list.item_widget_pairs():
+            list_item.setSizeHint(device_group_widget.sizeHint())
+
+    @SafeSlot()
+    def _add_selected_action(self):
+        self.add_selected_devices.emit(self.device_groups_list.any_selected_devices())
+
+    @SafeSlot()
+    def _del_selected_action(self):
+        self.del_selected_devices.emit(self.device_groups_list.any_selected_devices())
+
+    @SafeSlot(QItemSelection, QItemSelection)
+    def _on_selection_changed(self, selected: QItemSelection, deselected: QItemSelection) -> None:
+        self.selected_devices.emit(self.device_groups_list.selected_devices_from_groups())
+        self._shared_selection_signal.proc.emit(self._shared_selection_uuid)
+
+    @SafeSlot(str)
+    def _handle_shared_selection_signal(self, uuid: str):
+        if uuid != self._shared_selection_uuid:
+            self.device_groups_list.clearSelection()
+
+    def _set_devices_state(self, devices: Iterable[HashableDevice], included: bool):
+        for device in devices:
+            for device_group in self.device_groups_list.widgets():
+                device_group.set_item_state(hash(device), included)
 
     @SafeSlot(list)
-    def update_devices_state(self, config_list: list[dict[str, Any]]):
-        self.set_devices_state(
-            _yield_only_passing(HashableDevice.model_validate, config_list), True
+    def mark_devices_used(self, config_list: list[dict[str, Any]], used: bool):
+        """Set the display color of individual devices and update the group display of numbers
+        included. Accepts a list of dicts with the complete config as used in
+        bec_lib.atlas_models.Device."""
+        self._set_devices_state(
+            yield_only_passing(HashableDevice.model_validate, config_list), used
         )
 
+    @SafeSlot(str)
+    def _grouping_selection_changed(self, sort_key: str):
+        self.search_box.setText("")
+        if sort_key == "deviceTags":
+            device_groups = self._backend.tag_groups
+        else:
+            device_groups = self._backend.group_by_key(sort_key)
+        self.refresh_full_list(device_groups)
+
 
 if __name__ == "__main__":
     import sys
@@ -80,7 +121,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,5 +1,61 @@
+from __future__ import annotations
+
+import itertools
+
 from qtpy.QtCore import QMetaObject, Qt
-from qtpy.QtWidgets import QAbstractItemView, QListView, QListWidget, QVBoxLayout
+from qtpy.QtWidgets import (
+    QAbstractItemView,
+    QComboBox,
+    QGridLayout,
+    QLabel,
+    QLineEdit,
+    QListView,
+    QListWidget,
+    QListWidgetItem,
+    QSizePolicy,
+    QVBoxLayout,
+)
+
+from bec_widgets.utils.list_of_expandable_frames import ListOfExpandableFrames
+from bec_widgets.utils.toolbars.actions import MaterialIconAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle
+from bec_widgets.utils.toolbars.toolbar import ModularToolBar
+from bec_widgets.widgets.control.device_manager.components._util import mimedata_from_configs
+from bec_widgets.widgets.control.device_manager.components.available_device_resources.available_device_group import (
+    AvailableDeviceGroup,
+)
+from bec_widgets.widgets.control.device_manager.components.constants import (
+    CONFIG_DATA_ROLE,
+    MIME_DEVICE_CONFIG,
+)
+
+
+class _ListOfDeviceGroups(ListOfExpandableFrames[AvailableDeviceGroup]):
+
+    def itemWidget(self, item: QListWidgetItem) -> AvailableDeviceGroup:
+        return super().itemWidget(item)  # type: ignore
+
+    def any_selected_devices(self):
+        return self.selected_individual_devices() or self.selected_devices_from_groups()
+
+    def selected_individual_devices(self):
+        for widget in (self.itemWidget(self.item(i)) for i in range(self.count())):
+            if (selected := widget.get_selection()) != set():
+                return [dev.as_normal_device().model_dump() for dev in selected]
+        return []
+
+    def selected_devices_from_groups(self):
+        selected_items = (self.item(r.row()) for r in self.selectionModel().selectedRows())
+        widgets = (self.itemWidget(item) for item in selected_items)
+        return list(itertools.chain.from_iterable(w.device_list.all_configs() for w in widgets))
+
+    def mimeTypes(self):
+        return [MIME_DEVICE_CONFIG]
+
+    def mimeData(self, items):
+        return mimedata_from_configs(
+            itertools.chain.from_iterable(item.data(CONFIG_DATA_ROLE) for item in items)
+        )
 
 
 class Ui_availableDeviceResources(object):
@@ -8,20 +64,72 @@ class Ui_availableDeviceResources(object):
             availableDeviceResources.setObjectName("availableDeviceResources")
         self.verticalLayout = QVBoxLayout(availableDeviceResources)
         self.verticalLayout.setObjectName("verticalLayout")
-        self.tag_groups_list = QListWidget(availableDeviceResources)
-        self.tag_groups_list.setObjectName("tag_groups_list")
-        self.tag_groups_list.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
-        self.tag_groups_list.setVerticalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
-        self.tag_groups_list.setHorizontalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
-        self.tag_groups_list.setMovement(QListView.Movement.Static)
-        self.tag_groups_list.setSpacing(2)
-        self.tag_groups_list.setDragDropMode(QListWidget.DragDropMode.DragOnly)
-        self.tag_groups_list.setDragEnabled(True)
-        self.tag_groups_list.setAcceptDrops(False)
-        self.tag_groups_list.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+
+        self._add_toolbar()
+
+        # Main area with search and filter using a grid layout
+        self.search_layout = QVBoxLayout()
+        self.grid_layout = QGridLayout()
+
+        self.grouping_selector = QComboBox()
+        self.grouping_selector.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        lbl_group = QLabel("Group by:")
+        lbl_group.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        self.grid_layout.addWidget(lbl_group, 0, 0)
+        self.grid_layout.addWidget(self.grouping_selector, 0, 1)
+
+        self.search_box = QLineEdit()
+        self.search_box.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        lbl_filter = QLabel("Filter:")
+        lbl_filter.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        self.grid_layout.addWidget(lbl_filter, 1, 0)
+        self.grid_layout.addWidget(self.search_box, 1, 1)
+
+        self.grid_layout.setColumnStretch(0, 0)
+        self.grid_layout.setColumnStretch(1, 1)
+
+        self.search_layout.addLayout(self.grid_layout)
+        self.verticalLayout.addLayout(self.search_layout)
+
+        self.device_groups_list = _ListOfDeviceGroups(
+            availableDeviceResources, AvailableDeviceGroup
+        )
+        self.device_groups_list.setObjectName("device_groups_list")
+        self.device_groups_list.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
+        self.device_groups_list.setVerticalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
+        self.device_groups_list.setHorizontalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
+        self.device_groups_list.setMovement(QListView.Movement.Static)
+        self.device_groups_list.setSpacing(4)
+        self.device_groups_list.setDragDropMode(QListWidget.DragDropMode.DragOnly)
+        self.device_groups_list.setSelectionBehavior(QListWidget.SelectionBehavior.SelectItems)
+        self.device_groups_list.setSelectionMode(QListWidget.SelectionMode.ExtendedSelection)
+        self.device_groups_list.setDragEnabled(True)
+        self.device_groups_list.setAcceptDrops(False)
+        self.device_groups_list.setDefaultDropAction(Qt.DropAction.CopyAction)
+        self.device_groups_list.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         availableDeviceResources.setMinimumWidth(250)
         availableDeviceResources.resize(250, availableDeviceResources.height())
 
-        self.verticalLayout.addWidget(self.tag_groups_list)
+        self.verticalLayout.addWidget(self.device_groups_list)
 
         QMetaObject.connectSlotsByName(availableDeviceResources)
+
+    def _add_toolbar(self):
+        self.toolbar = ModularToolBar(self)
+        io_bundle = ToolbarBundle("IO", self.toolbar.components)
+
+        self.tb_add_selected = MaterialIconAction(
+            icon_name="add_box", parent=self, tooltip="Add selected devices to composition"
+        )
+        self.toolbar.components.add_safe("add_selected", self.tb_add_selected)
+        io_bundle.add_action("add_selected")
+
+        self.tb_del_selected = MaterialIconAction(
+            icon_name="chips", parent=self, tooltip="Remove selected devices from composition"
+        )
+        self.toolbar.components.add_safe("del_selected", self.tb_del_selected)
+        io_bundle.add_action("del_selected")
+
+        self.verticalLayout.addWidget(self.toolbar)
+        self.toolbar.add_bundle(io_bundle)
+        self.toolbar.show_bundles(["IO"])

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

@@ -1,79 +1,34 @@
 from __future__ import annotations
 
 import operator
-from functools import reduce
+import os
+from enum import Enum, auto
+from functools import partial, reduce
 from glob import glob
 from pathlib import Path
-from textwrap import dedent
-from typing import AbstractSet, Protocol
+from typing import Protocol
 
-from bec_lib.atlas_models import Device
+import bec_lib
+from bec_lib.atlas_models import HashableDevice, HashableDeviceSet
 from bec_lib.bec_yaml_loader import yaml_load
-from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path
-from pydantic import model_validator
+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__)) / "../.."
 
 
-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)
+def get_backend() -> DeviceResourceBackend:
+    return _ConfigFileBackend()
 
 
-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 HashModel(str, Enum):
+    DEFAULT = auto()
+    DEFAULT_DEVICECONFIG = auto()
+    DEFAULT_EPICS = auto()
 
 
 class DeviceResourceBackend(Protocol):
@@ -93,6 +48,11 @@ 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."""
         ...
@@ -101,10 +61,15 @@ 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()}
         )
@@ -114,22 +79,31 @@ 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_file() or self._get_configs_from_plugin_files(
-            Path(plugin_repo_path()) / plugin_package_name() / "device_configs/"
-        )
-        self._tag_groups = self._get_tag_groups()
+        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_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_config_from_backup_files(self):
+        dir = _BASE_REPO_PATH / "logs/device_configs/recovery_configs"
+        files = sorted(glob("*.yaml", root_dir=dir))
+        last_n_files = files[-_N_RECOVERY_FILES:]
+        return reduce(
+            operator.or_,
+            map(
+                partial(_devices_from_file, include_source=False),
+                (str(dir / f) for f in last_n_files),
+            ),
+            set(),
+        )
 
     def _get_configs_from_plugin_files(self, dir: Path):
         files = glob("*.yaml", root_dir=dir, recursive=True)
-        return reduce(operator.or_, map(_devices_from_file, (str(dir / f) for f in files)))
+        return reduce(operator.or_, map(_devices_from_file, (str(dir / f) for f in files)), set())
 
     def _get_tag_groups(self) -> dict[str, set[HashableDevice]]:
         return {
@@ -139,7 +113,7 @@ class _ConfigFileBackend(DeviceResourceBackend):
 
     @property
     def tag_groups(self):
-        return self._tag_groups
+        return self._device_groups
 
     @property
     def all_devices(self):
@@ -149,12 +123,18 @@ 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))
+        return reduce(operator.or_, (dev.deviceTags for dev in self._raw_device_set), set())
 
     def tag_group(self, tag: str) -> set[HashableDevice]:
         return self.tag_groups[tag]
 
-
-def get_backend() -> DeviceResourceBackend:
-    return _ConfigFileBackend()
+    def group_by_key(self, key: str) -> dict[str, set[HashableDevice]]:
+        if key not in self.allowed_sort_keys:
+            raise ValueError(f"Cannot group available devices by model key {key}")
+        group_names: set[str] = {getattr(item, key) for item in self._raw_device_set}
+        return {g: {d for d in self._raw_device_set if getattr(d, key) == g} for g in group_names}

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

@@ -1,135 +0,0 @@
-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

@@ -0,0 +1,72 @@
+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
+
+# TODO 882 keep in sync with headers in device_table_view.py
+HEADERS_HELP_MD: dict[str, str] = {
+    "status": "\n".join(
+        [
+            "## Status",
+            "The current status of the device. Can be one of the following values: ",
+            "### **LOADED** \n The device with the specified configuration is loaded in the current config.",
+            "### **CONNECT_READY** \n The device config is valid and the connection has been validated. It has not yet been loaded to the current config.",
+            "### **CONNECT_FAILED** \n The device config is valid, but the connection could not be established.",
+            "### **VALID** \n The device config is valid, but the connection has not yet been validated.",
+            "### **INVALID** \n The device config is invalid and can not be loaded to the current config.",
+        ]
+    ),
+    "name": "\n".join(["## Name ", "The name of the device."]),
+    "deviceClass": "\n".join(
+        [
+            "## Device Class",
+            "The device class specifies the type of the device. It will be used to create the instance.",
+        ]
+    ),
+    "readoutPriority": "\n".join(
+        [
+            "## Readout Priority",
+            "The readout priority of the device. Can be one of the following values: ",
+            "### **monitored** \n The monitored priority is used for devices that are read out during the scan (i.e. at every step) and whose value may change during the scan.",
+            "### **baseline** \n The baseline priority is used for devices that are read out at the beginning of the scan and whose value does not change during the scan.",
+            "### **async** \n The async priority is used for devices that are asynchronous to the monitored devices, and send their data independently.",
+            "### **continuous** \n The continuous priority is used for devices that are read out continuously during the scan.",
+            "### **on_request** \n The on_request priority is used for devices that should not be read out during the scan, yet are configured to be read out manually.",
+        ]
+    ),
+    "deviceTags": "\n".join(
+        [
+            "## Device Tags",
+            "A list of tags associated with the device. Tags can be used to group devices and filter them in the device manager.",
+        ]
+    ),
+    "enabled": "\n".join(
+        [
+            "## Enabled",
+            "Indicator whether the device is enabled or disabled. Disabled devices can not be used.",
+        ]
+    ),
+    "readOnly": "\n".join(
+        ["## Read Only", "Indicator that a device is read-only or can be modified."]
+    ),
+    "onFailure": "\n".join(
+        [
+            "## On Failure",
+            "Specifies the behavior of the device in case of a failure. Can be one of the following values: ",
+            "### **buffer** \n The device readback will fall back to the last known value.",
+            "### **retry** \n The device readback will be retried once, and raises an error if it fails again.",
+            "### **raise** \n The device readback will raise immediately.",
+        ]
+    ),
+    "softwareTrigger": "\n".join(
+        [
+            "## Software Trigger",
+            "Indicator whether the device receives a software trigger from BEC during a scan.",
+        ]
+    ),
+    "description": "\n".join(["## Description", "A short description of the device."]),
+}

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

@@ -9,7 +9,6 @@ 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
 
@@ -52,14 +51,14 @@ class DMConfigView(BECWidget, QtWidgets.QWidget):
         )
 
     @SafeSlot(dict)
-    def on_select_config(self, device: dict):
+    def on_select_config(self, device: list[dict]):
         """Handle selection of a device from the device table."""
         if len(device) != 1:
             text = ""
             self.stacked_layout.setCurrentWidget(self._overlay_widget)
         else:
             try:
-                text = yaml.dump(device, default_flow_style=False)
+                text = yaml.dump(device[0], default_flow_style=False)
                 self.stacked_layout.setCurrentWidget(self.monaco_editor)
             except Exception:
                 content = traceback.format_exc()
@@ -78,6 +77,24 @@ 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()
-    config_view.show()
+    layout.addWidget(config_view)
+    combo_box = QtWidgets.QComboBox()
+    config = config_view.client.device_manager._get_redis_device_config()
+    combo_box.addItems([""] + [str(v) for v, item in enumerate(config)])
+
+    def on_select(text):
+        if text == "":
+            config_view.on_select_config([])
+        else:
+            config_view.on_select_config([config[int(text)]])
+
+    combo_box.currentTextChanged.connect(on_select)
+    layout.addWidget(combo_box)
+    widget.show()
     sys.exit(app.exec_())

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

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import inspect
 import re
+import textwrap
 import traceback
 
 from bec_lib.logger import bec_logger
@@ -26,94 +27,79 @@ 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:
+        text = 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.NoFocus)
+        self.setFocusPolicy(QtCore.Qt.FocusPolicy.NoFocus)
         if not READY_TO_VIEW:
             self._set_text("Ophyd or ophyd_devices not installed, cannot show docstrings.")
             self.setEnabled(False)
             return
 
-    def _format_docstring(self, doc: str | None) -> str:
-        if not doc:
-            return "<i>No docstring available.</i>"
-
-        # Escape HTML
-        doc = doc.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-
-        # Remove leading/trailing blank lines from the entire docstring
-        lines = [line.rstrip() for line in doc.splitlines()]
-        while lines and lines[0].strip() == "":
-            lines.pop(0)
-        while lines and lines[-1].strip() == "":
-            lines.pop()
-        doc = "\n".join(lines)
-
-        # Improved regex: match section header + all following indented lines
-        section_regex = re.compile(
-            r"(?m)^(Parameters|Args|Returns|Examples|Attributes|Raises)\b(?:\n([ \t]+.*))*",
-            re.MULTILINE,
-        )
-
-        def strip_section(match: re.Match) -> str:
-            # Capture all lines in the match
-            block = match.group(0)
-            lines = block.splitlines()
-            # Remove leading/trailing empty lines within the section
-            lines = [line for line in lines if line.strip() != ""]
-            return "\n".join(lines)
-
-        doc = section_regex.sub(strip_section, doc)
-
-        # Highlight section titles
-        doc = re.sub(
-            r"(?m)^(Parameters|Args|Returns|Examples|Attributes|Raises)\b", r"<b>\1</b>", doc
-        )
-
-        # Convert indented blocks to <pre> and strip leading/trailing newlines
-        def pre_block(match: re.Match) -> str:
-            text = match.group(0).strip("\n")
-            return f"<pre>{text}</pre>"
-
-        doc = re.sub(r"(?m)(?:\n[ \t]+.*)+", pre_block, doc)
-
-        # Replace remaining newlines with <br> and collapse multiple <br>
-        doc = doc.replace("\n", "<br>")
-        doc = re.sub(r"(<br>)+", r"<br>", doc)
-        doc = doc.strip("<br>")
-
-        return f"<div style='font-family: sans-serif; font-size: 12pt;'>{doc}</div>"
-
     def _set_text(self, text: str):
         self.setReadOnly(False)
         self.setMarkdown(text)
-        # self.setHtml(self._format_docstring(text))
         self.setReadOnly(True)
 
-    @SafeSlot(dict)
-    def on_select_config(self, device: dict):
+    @SafeSlot(list)
+    def on_select_config(self, device: list[dict]):
         if len(device) != 1:
             self._set_text("")
             return
-        k = next(iter(device))
-        device_class = device[k].get("deviceClass", "")
+        device_class = device[0].get("deviceClass", "")
         self.set_device_class(device_class)
 
     @SafeSlot(str)
     def set_device_class(self, device_class_str: str) -> None:
-        docstring = ""
         if not READY_TO_VIEW:
             return
         try:
             module_cls = get_plugin_class(device_class_str, [ophyd_devices, ophyd])
-            docstring = inspect.getdoc(module_cls)
-            self._set_text(docstring or "No docstring available.")
+            markdown = docstring_to_markdown(module_cls)
+            self._set_text(markdown)
         except Exception:
-            content = traceback.format_exc()
-            logger.error(f"Error retrieving docstring for {device_class_str}: {content}")
-            self._set_text(f"Error retrieving docstring for {device_class_str}")
+            logger.exception("Error retrieving docstring")
+            self._set_text(f"*Error retrieving docstring for `{device_class_str}`*")
 
 
 if __name__ == "__main__":
@@ -122,7 +108,26 @@ 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")
-    config_view.show()
+    layout.addWidget(config_view)
+    combo = QtWidgets.QComboBox()
+    combo.addItems(
+        [
+            "",
+            "ophyd_devices.sim.sim_camera.SimCamera",
+            "ophyd.EpicsSignalWithRBV",
+            "ophyd.EpicsMotor",
+            "csaxs_bec.devices.epics.mcs_card.mcs_card_csaxs.MCSCardCSAXS",
+        ]
+    )
+    combo.currentTextChanged.connect(config_view.set_device_class)
+    layout.addWidget(combo)
+    widget.show()
     sys.exit(app.exec_())

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

@@ -4,20 +4,19 @@ from __future__ import annotations
 
 import enum
 import re
-import traceback
+from collections import deque
+from concurrent.futures import CancelledError, Future, ThreadPoolExecutor
 from html import escape
-from typing import TYPE_CHECKING
+from threading import Event, RLock
+from typing import Any, Iterable
 
-import bec_lib
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
-from ophyd import status
-from qtpy import QtCore, QtGui, QtWidgets
+from qtpy import QtCore, QtWidgets
 
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import get_accent_colors
-from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
-from bec_widgets.widgets.editors.web_console.web_console import WebConsole
+from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.widgets.utility.spinner.spinner import SpinnerWidget
 
 READY_TO_TEST = False
@@ -34,11 +33,10 @@ except ImportError:
     ophyd_devices = None
     bec_server = None
 
-if TYPE_CHECKING:  # pragma no cover
-    try:
-        from ophyd_devices.utils.static_device_test import StaticDeviceTest
-    except ImportError:
-        StaticDeviceTest = None
+try:
+    from ophyd_devices.utils.static_device_test import StaticDeviceTest
+except ImportError:
+    StaticDeviceTest = None
 
 
 class ValidationStatus(int, enum.Enum):
@@ -56,49 +54,76 @@ class DeviceValidationResult(QtCore.QObject):
     device_validated = QtCore.Signal(str, bool, str)
 
 
-class DeviceValidationRunnable(QtCore.QRunnable):
-    """Runnable for validating a device configuration."""
-
-    def __init__(
-        self,
-        device_name: str,
-        config: dict,
-        static_device_test: StaticDeviceTest | None,
-        connect: bool = False,
-    ):
-        """
-        Initialize the device validation runnable.
-
-        Args:
-            device_name (str): The name of the device to validate.
-            config (dict): The configuration dictionary for the device.
-            static_device_test (StaticDeviceTest): The static device test instance.
-            connect (bool, optional): Whether to connect to the device. Defaults to False.
-        """
+class DeviceTester(QtCore.QRunnable):
+    def __init__(self, config: dict) -> None:
         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):
-        """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}."
-            )
+        if StaticDeviceTest is None:
+            logger.error("Ophyd devices or bec_server not available, cannot run validation.")
             return
+        while not self.shutdown_event.is_set():
+            self._pending_event.wait(timeout=0.5)  # check if shutting down every 0.5s
+            if len(self._active) >= self._max_threads:
+                self._pending_event.clear()  # it will be set again on removing something from active
+                continue
+            with self._lock:
+                if len(self._pending_queue) > 0:
+                    item, cfg, connect = self._pending_queue.pop()
+                    self._active.add(item)
+                    fut = self._test_executor.submit(self._run_test, item, {item: cfg}, connect)
+                    fut.__dict__["__device_name"] = item
+                    fut.add_done_callback(self._done_cb)
+            self._safe_check_and_clear()
+        self._cleanup()
+
+    def submit(self, devices: Iterable[tuple[str, dict, bool]]):
+        with self._lock:
+            self._pending_queue.extend(devices)
+            self._pending_event.set()
+
+    @staticmethod
+    def _run_test(name: str, config: dict, connect: bool) -> tuple[str, bool, str]:
+        tester = StaticDeviceTest(config_dict=config)  # type: ignore # we exit early if it is None
+        results = tester.run_with_list_output(connect=connect)
+        return name, results[0].success, results[0].message
+
+    def _safe_check_and_clear(self):
+        with self._lock:
+            if len(self._pending_queue) == 0:
+                self._pending_event.clear()
+
+    def _safe_remove_from_active(self, name: str):
+        with self._lock:
+            self._active.remove(name)
+            self._pending_event.set()  # check again once a completed task is removed
+
+    def _done_cb(self, future: Future):
         try:
-            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)
+            name, success, message = future.result()
+        except CancelledError:
+            return
+        except Exception as e:
+            name, success, message = future.__dict__["__device_name"], False, str(e)
+        finally:
+            self._safe_remove_from_active(future.__dict__["__device_name"])
+        self.signals.device_validated.emit(name, success, message)
+
+    def _cleanup(self): ...
 
 
 class ValidationListItem(QtWidgets.QWidget):
@@ -139,7 +164,6 @@ 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."""
@@ -172,29 +196,31 @@ 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.static_device_test = None
+            self.tester = None
         else:
-            from ophyd_devices.utils.static_device_test import StaticDeviceTest
-
-            self.static_device_test = StaticDeviceTest(config_dict={})
+            self.tester = DeviceTester({})
+            self.tester.signals.device_validated.connect(self._on_device_validated)
+            QtCore.QThreadPool.globalInstance().start(self.tester)
         self._device_list_items: dict[str, QtWidgets.QListWidgetItem] = {}
+        # TODO Consider using the thread pool from BECConnector instead of fetching the global instance!
         self._thread_pool = QtCore.QThreadPool.globalInstance()
 
         self._main_layout = QtWidgets.QVBoxLayout(self)
         self._main_layout.setContentsMargins(0, 0, 0, 0)
-        self._main_layout.setSpacing(4)
+        self._main_layout.setSpacing(0)
 
         # We add a splitter between the list and the text box
         self.splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Vertical)
         self._main_layout.addWidget(self.splitter)
 
         self._setup_list_ui()
-        self._setup_textbox_ui()
 
     def _setup_list_ui(self):
         """Setup the list UI."""
@@ -204,46 +230,38 @@ class DMOphydTest(BECWidget, QtWidgets.QWidget):
         # Connect signals
         self._list_widget.currentItemChanged.connect(self._on_current_item_changed)
 
-    def _setup_textbox_ui(self):
-        """Setup the text box UI."""
-        self._text_box = QtWidgets.QTextEdit(self)
-        self._text_box.setReadOnly(True)
-        self._text_box.setFocusPolicy(QtCore.Qt.NoFocus)
-        self.splitter.addWidget(self._text_box)
-
-    @SafeSlot(dict)
-    def add_device_configs(self, device_configs: dict[str, dict]) -> None:
+    @SafeSlot(list, bool)
+    @SafeSlot(list, bool, bool)
+    def change_device_configs(
+        self, device_configs: list[dict[str, Any]], added: bool, connect: bool = False
+    ) -> None:
         """Receive an update with device configs.
 
         Args:
-            device_configs (dict[str, dict]): The updated device configurations.
+            device_configs (list[dict[str, Any]]): The updated device configurations.
         """
-        for device_name, device_config in device_configs.items():
-            if device_name in self._device_list_items:
-                logger.error(f"Device {device_name} is already in the list.")
-                return
-            item = QtWidgets.QListWidgetItem(self._list_widget)
-            widget = ValidationListItem(device_name=device_name, device_config=device_config)
+        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)
 
-            # 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)
+    def _add_device(self, name, cfg):
+        item = QtWidgets.QListWidgetItem(self._list_widget)
+        widget = ValidationListItem(device_name=name, device_config=cfg)
 
-    @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)
+        # wrap it in a QListWidgetItem
+        item.setSizeHint(widget.sizeHint())
+        self._list_widget.addItem(item)
+        self._list_widget.setItemWidget(item, widget)
+        self._device_list_items[name] = item
 
     def _remove_list_item(self, device_name: str):
         """Remove a device from the list."""
@@ -259,34 +277,6 @@ 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.
@@ -321,62 +311,50 @@ class DMOphydTest(BECWidget, QtWidgets.QWidget):
         widget: ValidationListItem = self._list_widget.itemWidget(current)
         if widget:
             try:
-                formatted_html = self._format_validation_message(widget.validation_msg)
-                self._text_box.setHtml(formatted_html)
+                formatted_md = self._format_markdown_text(widget.device_name, widget.validation_msg)
+                self.validation_msg_md.emit(formatted_md)
             except Exception as e:
-                logger.error(f"Error formatting validation message: {e}")
-                self._text_box.setPlainText(widget.validation_msg)
-
-    def _format_validation_message(self, raw_msg: str) -> str:
-        """Simple HTML formatting for validation messages, wrapping text naturally."""
-        if not raw_msg.strip():
-            return "<i>Validation in progress...</i>"
-        if raw_msg == "Validation in progress...":
-            return "<i>Validation in progress...</i>"
-
-        raw_msg = escape(raw_msg)
-
-        # Split into lines
-        lines = raw_msg.splitlines()
-        summary = lines[0] if lines else "Validation Result"
-        rest = "\n".join(lines[1:]).strip()
-
-        # Split traceback / final ERROR
-        tb_match = re.search(r"(Traceback.*|ERROR:.*)$", rest, re.DOTALL | re.MULTILINE)
-        if tb_match:
-            main_text = rest[: tb_match.start()].strip()
-            error_detail = tb_match.group().strip()
+                logger.error(
+                    f"##Error formatting validation message for device {widget.device_name}:\n{e}"
+                )
+                self.validation_msg_md.emit(widget.validation_msg)
         else:
-            main_text = rest
-            error_detail = ""
+            self.validation_msg_md.emit("")
 
-        # 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 ""
-        )
+    def _format_markdown_text(self, device_name: str, raw_msg: str) -> str:
+        """
+        Simple HTML formatting for validation messages, wrapping text naturally.
 
-        # Traceback / error in red
-        error_html = (
-            f'<div style="white-space: pre-wrap; color:#A00000;">{error_detail}</div>'
-            if error_detail
-            else ""
-        )
+        Args:
+            device_name (str): The name of the device.
+            raw_msg (str): The raw validation message.
+        """
+        if not raw_msg.strip() or raw_msg.strip() == "Validation in progress...":
+            return f"### Validation in progress for {device_name}... \n\n"
 
-        # 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>"
+        # Regex to capture repeated ERROR patterns
+        pat = re.compile(
+            r"ERROR:\s*(?P<device>[^\s]+)\s+"
+            r"(?P<status>is not valid|is not connectable|failed):\s*"
+            r"(?P<detail>.*?)(?=ERROR:|$)",
+            re.DOTALL,
         )
-        return html
+        blocks = []
+        for m in pat.finditer(raw_msg):
+            dev = m.group("device")
+            status = m.group("status")
+            detail = m.group("detail").strip()
+            lines = [f"## Error for {dev}", f"**{dev} {status}**", f"```\n{detail}\n```"]
+            blocks.append("\n\n".join(lines))
+
+        # Fallback: If no patterns matched, return the raw message
+        if not blocks:
+            return f"## Error for {device_name}\n```\n{raw_msg.strip()}\n```"
+
+        return "\n\n---\n\n".join(blocks)
+
+    def validation_running(self):
+        return self._device_list_items != {}
 
     @SafeSlot()
     def clear_list(self):
@@ -386,6 +364,7 @@ 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."""
@@ -393,6 +372,11 @@ 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
@@ -403,12 +387,32 @@ 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()
-    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()
+    try:
+        config_path = "/Users/appel_c/work_psi_awi/bec_workspace/csaxs_bec/csaxs_bec/device_configs/first_light.yaml"
+        config = [{"name": k, **v} for k, v in yaml_load(config_path).items()]
+    except Exception as e:
+        logger.error(f"Error loading config: {e}")
+        import os
+
+        import bec_lib
+
+        config_path = os.path.join(os.path.dirname(bec_lib.__file__), "configs", "demo_config.yaml")
+        config = [{"name": k, **v} for k, v in yaml_load(config_path).items()]
+
+    config.append({"name": "non_existing_device", "type": "NonExistingDevice"})
+    device_manager_ophyd_test.change_device_configs(config, True, True)
+    layout.addWidget(device_manager_ophyd_test)
     device_manager_ophyd_test.setWindowTitle("Device Manager Ophyd Test")
     device_manager_ophyd_test.resize(800, 600)
+    text_box = QtWidgets.QTextEdit()
+    text_box.setReadOnly(True)
+    layout.addWidget(text_box)
+    device_manager_ophyd_test.validation_msg_md.connect(text_box.setMarkdown)
+    wid.show()
     sys.exit(app.exec_())

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -467,6 +467,8 @@ class ScanControl(BECWidget, QWidget):
         for box in self.kwarg_boxes:
             box_kwargs = box.get_parameters(bec_object)
             kwargs.update(box_kwargs)
+        if self._scan_metadata is not None:
+            kwargs["metadata"] = self._scan_metadata
         return args, kwargs
 
     def restore_scan_parameters(self, scan_name: str):
@@ -519,7 +521,6 @@ class ScanControl(BECWidget, QWidget):
     def run_scan(self):
         """Starts the selected scan with the given parameters."""
         args, kwargs = self.get_scan_parameters()
-        kwargs["metadata"] = self._scan_metadata
         self.scan_args.emit(args)
         scan_function = getattr(self.scans, self.comboBox_scan_selection.currentText())
         if callable(scan_function):

bec_widgets/widgets/control/scan_control/scan_group_box.py

@@ -3,6 +3,7 @@ from typing import Literal, Sequence
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from qtpy.QtCore import Property, Qt, Signal, Slot
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import (
     QCheckBox,
     QComboBox,
@@ -197,12 +198,12 @@ class ScanGroupBox(QGroupBox):
         # Add bundle button
         self.button_add_bundle = QPushButton(self)
         self.button_add_bundle.setIcon(
-            material_icon(icon_name="add", size=(15, 15), convert_to_pixmap=False)
+            material_icon(icon_name="add", size=(15, 15), icon_type=QIcon)
         )
         # Remove bundle button
         self.button_remove_bundle = QPushButton(self)
         self.button_remove_bundle.setIcon(
-            material_icon(icon_name="remove", size=(15, 15), convert_to_pixmap=False)
+            material_icon(icon_name="remove", size=(15, 15), icon_type=QIcon)
         )
         hbox_layout.addWidget(self.button_add_bundle)
         hbox_layout.addWidget(self.button_remove_bundle)

bec_widgets/widgets/editors/jupyter_console/jupyter_console.py

@@ -2,6 +2,7 @@ from bec_ipython_client.main import BECIPythonClient
 from qtconsole.inprocess import QtInProcessKernelManager
 from qtconsole.manager import QtKernelManager
 from qtconsole.rich_jupyter_widget import RichJupyterWidget
+from qtpy.QtCore import Qt
 from qtpy.QtWidgets import QApplication, QMainWindow
 
 
@@ -9,10 +10,10 @@ class BECJupyterConsole(RichJupyterWidget):  # pragma: no cover:
     def __init__(self, inprocess: bool = False):
         super().__init__()
 
-        self.inprocess = None
-        self.client = None
+        self.inprocess = inprocess
+        self.ipyclient = None
 
-        self.kernel_manager, self.kernel_client = self._init_kernel(inprocess=inprocess)
+        self.kernel_manager, self.kernel_client = self._init_kernel(inprocess=self.inprocess)
         self.set_default_style("linux")
         self._init_bec()
 
@@ -35,14 +36,13 @@ class BECJupyterConsole(RichJupyterWidget):  # pragma: no cover:
             self._init_bec_kernel()
 
     def _init_bec_inprocess(self):
-        self.client = BECIPythonClient()
-        self.client.start()
-
+        self.ipyclient = BECIPythonClient()
+        self.ipyclient.start()
         self.kernel_manager.kernel.shell.push(
             {
-                "bec": self.client,
-                "dev": self.client.device_manager.devices,
-                "scans": self.client.scans,
+                "bec": self.ipyclient,
+                "dev": self.ipyclient.device_manager.devices,
+                "scans": self.ipyclient.scans,
             }
         )
 
@@ -57,20 +57,47 @@ class BECJupyterConsole(RichJupyterWidget):  # pragma: no cover:
             """
         )
 
+    def _cleanup_bec(self):
+        if getattr(self, "ipyclient", None) is not None and self.inprocess is True:
+            self.ipyclient.shutdown()
+            self.ipyclient = None
+
     def shutdown_kernel(self):
+        """
+        Shutdown the Jupyter kernel and clean up resources.
+        """
+        self._cleanup_bec()
         self.kernel_client.stop_channels()
         self.kernel_manager.shutdown_kernel()
+        self.kernel_client = None
+        self.kernel_manager = None
 
     def closeEvent(self, event):
         self.shutdown_kernel()
+        event.accept()
+        super().closeEvent(event)
+
+
+class JupyterConsoleWindow(QMainWindow):  # pragma: no cover:
+    def __init__(self, inprocess: bool = True, parent=None):
+        super().__init__(parent)
+        self.console = BECJupyterConsole(inprocess=inprocess)
+        self.setCentralWidget(self.console)
+        self.setAttribute(Qt.WA_DeleteOnClose, True)
+
+    def closeEvent(self, event):
+        # Explicitly close the console so its own closeEvent runs
+        if getattr(self, "console", None) is not None:
+            self.console.close()
+        event.accept()
+        super().closeEvent(event)
 
 
 if __name__ == "__main__":  # pragma: no cover
     import sys
 
     app = QApplication(sys.argv)
-    win = QMainWindow()
-    win.setCentralWidget(BECJupyterConsole(True))
+    win = JupyterConsoleWindow(inprocess=True)
     win.show()
 
     sys.exit(app.exec_())

bec_widgets/widgets/editors/monaco/monaco_dock.py

@@ -0,0 +1,469 @@
+from __future__ import annotations
+
+import os
+import pathlib
+from typing import Any, cast
+
+from bec_lib.logger import bec_logger
+from bec_lib.macro_update_handler import has_executable_code
+from qtpy.QtCore import QEvent, QTimer, Signal
+from qtpy.QtWidgets import QFileDialog, QMessageBox, QToolButton, QVBoxLayout, QWidget
+
+import bec_widgets.widgets.containers.ads as QtAds
+from bec_widgets import BECWidget
+from bec_widgets.widgets.containers.ads import CDockAreaWidget, CDockWidget
+from bec_widgets.widgets.editors.monaco.monaco_widget import MonacoWidget
+
+logger = bec_logger.logger
+
+
+class MonacoDock(BECWidget, QWidget):
+    """
+    MonacoDock is a dock widget that contains Monaco editor instances.
+    It is used to manage multiple Monaco editors in a dockable interface.
+    """
+
+    focused_editor = Signal(object)  # Emitted when the focused editor changes
+    save_enabled = Signal(bool)  # Emitted when the save action is enabled/disabled
+    signature_help = Signal(str)  # Emitted when signature help is requested
+    macro_file_updated = Signal(str)  # Emitted when a macro file is saved
+
+    def __init__(self, parent=None, **kwargs):
+        super().__init__(parent=parent, **kwargs)
+        # Top-level layout hosting a toolbar and the dock manager
+        self._root_layout = QVBoxLayout(self)
+        self._root_layout.setContentsMargins(0, 0, 0, 0)
+        self._root_layout.setSpacing(0)
+
+        self.dock_manager = QtAds.CDockManager(self)
+        self.dock_manager.setStyleSheet("")
+        self.dock_manager.focusedDockWidgetChanged.connect(self._on_focus_event)
+        self._root_layout.addWidget(self.dock_manager)
+        self.dock_manager.installEventFilter(self)
+        self._last_focused_editor: CDockWidget | None = None
+        self.focused_editor.connect(self._on_last_focused_editor_changed)
+        self.add_editor()
+        self._open_files = {}
+
+    def _create_editor(self):
+        init_lsp = len(self.dock_manager.dockWidgets()) == 0
+        widget = MonacoWidget(self, init_lsp=init_lsp)
+        widget.save_enabled.connect(self.save_enabled.emit)
+        widget.editor.signature_help_triggered.connect(self._on_signature_change)
+        count = len(self.dock_manager.dockWidgets())
+        dock = CDockWidget(f"Untitled_{count + 1}")
+        dock.setWidget(widget)
+
+        # Connect to modification status changes to update tab titles
+        widget.save_enabled.connect(
+            lambda modified: self._update_tab_title_for_modification(dock, modified)
+        )
+
+        dock.setFeature(CDockWidget.DockWidgetFeature.DockWidgetDeleteOnClose, True)
+        dock.setFeature(CDockWidget.DockWidgetFeature.CustomCloseHandling, True)
+        dock.setFeature(CDockWidget.DockWidgetFeature.DockWidgetClosable, True)
+        dock.setFeature(CDockWidget.DockWidgetFeature.DockWidgetFloatable, False)
+        dock.setFeature(CDockWidget.DockWidgetFeature.DockWidgetMovable, True)
+
+        dock.closeRequested.connect(lambda: self._on_editor_close_requested(dock, widget))
+
+        return dock
+
+    @property
+    def last_focused_editor(self) -> CDockWidget | None:
+        """
+        Get the last focused editor.
+        """
+        dock_widget = self.dock_manager.focusedDockWidget()
+        if dock_widget is not None and isinstance(dock_widget.widget(), MonacoWidget):
+            self.last_focused_editor = dock_widget
+
+        return self._last_focused_editor
+
+    @last_focused_editor.setter
+    def last_focused_editor(self, editor: CDockWidget | None):
+        self._last_focused_editor = editor
+        self.focused_editor.emit(editor)
+
+    def _on_last_focused_editor_changed(self, editor: CDockWidget | None):
+        if editor is None:
+            self.save_enabled.emit(False)
+            return
+
+        widget = cast(MonacoWidget, editor.widget())
+        if widget.modified:
+            logger.info(f"Editor '{widget.current_file}' has unsaved changes: {widget.get_text()}")
+        self.save_enabled.emit(widget.modified)
+
+    def _update_tab_title_for_modification(self, dock: CDockWidget, modified: bool):
+        """Update the tab title to show modification status with a dot indicator."""
+        current_title = dock.windowTitle()
+
+        # Remove existing modification indicator (dot and space)
+        if current_title.startswith("• "):
+            base_title = current_title[2:]  # Remove "• "
+        else:
+            base_title = current_title
+
+        # Add or remove the modification indicator
+        if modified:
+            new_title = f"• {base_title}"
+        else:
+            new_title = base_title
+
+        dock.setWindowTitle(new_title)
+
+    def _on_signature_change(self, signature: dict):
+        signatures = signature.get("signatures", [])
+        if not signatures:
+            self.signature_help.emit("")
+            return
+
+        active_sig = signatures[signature.get("activeSignature", 0)]
+        active_param = signature.get("activeParameter", 0)  # TODO: Add highlight for active_param
+
+        # Get signature label and documentation
+        label = active_sig.get("label", "")
+        doc_obj = active_sig.get("documentation", {})
+        documentation = doc_obj.get("value", "") if isinstance(doc_obj, dict) else str(doc_obj)
+
+        # Format the markdown output
+        markdown = f"```python\n{label}\n```\n\n{documentation}"
+        self.signature_help.emit(markdown)
+
+    def _on_focus_event(self, old_widget, new_widget) -> None:
+        # Track focus events for the dock widget
+        widget = new_widget.widget()
+        if isinstance(widget, MonacoWidget):
+            self.last_focused_editor = new_widget
+
+    def _on_editor_close_requested(self, dock: CDockWidget, widget: QWidget):
+        # Cast widget to MonacoWidget since we know that's what it is
+        monaco_widget = cast(MonacoWidget, widget)
+
+        # Check if we have unsaved changes
+        if monaco_widget.modified:
+            # Prompt the user to save changes
+            response = QMessageBox.question(
+                self,
+                "Unsaved Changes",
+                "You have unsaved changes. Do you want to save them?",
+                QMessageBox.StandardButton.Yes
+                | QMessageBox.StandardButton.No
+                | QMessageBox.StandardButton.Cancel,
+            )
+            if response == QMessageBox.StandardButton.Yes:
+                self.save_file(monaco_widget)
+            elif response == QMessageBox.StandardButton.Cancel:
+                return
+
+        # Count all editor docks managed by this dock manager
+        total = len(self.dock_manager.dockWidgets())
+        if total <= 1:
+            # Do not remove the last dock; just wipe its editor content
+            # Temporarily disable read-only mode if the editor is read-only
+            # so we can clear the content for reuse
+            monaco_widget.set_readonly(False)
+            monaco_widget.set_text("")
+            dock.setWindowTitle("Untitled")
+            dock.setTabToolTip("Untitled")
+            return
+
+        # Otherwise, proceed to close and delete the dock
+        monaco_widget.close()
+        dock.closeDockWidget()
+        dock.deleteDockWidget()
+        if self.last_focused_editor is dock:
+            self.last_focused_editor = None
+        # After topology changes, make sure single-tab areas get a plus button
+        QTimer.singleShot(0, self._scan_and_fix_areas)
+
+    def _ensure_area_plus(self, area):
+        if area is None:
+            return
+        # Only add once per area
+        if getattr(area, "_monaco_plus_btn", None) is not None:
+            return
+        # If the area has exactly one tab, inject a + button next to the tab bar
+        try:
+            tabbar = area.titleBar().tabBar()
+            count = tabbar.count() if hasattr(tabbar, "count") else 1
+        except Exception:
+            count = 1
+        if count >= 1:
+            plus_btn = QToolButton(area)
+            plus_btn.setText("+")
+            plus_btn.setToolTip("New Monaco Editor")
+            plus_btn.setAutoRaise(True)
+            tb = area.titleBar()
+            idx = tb.indexOf(tb.tabBar())
+            tb.insertWidget(idx + 1, plus_btn)
+            plus_btn.clicked.connect(lambda: self.add_editor(area))
+            # pylint: disable=protected-access
+            area._monaco_plus_btn = plus_btn
+
+    def _scan_and_fix_areas(self):
+        # Find all dock areas under this manager and ensure each single-tab area has a plus button
+        areas = self.dock_manager.findChildren(CDockAreaWidget)
+        for a in areas:
+            self._ensure_area_plus(a)
+
+    def eventFilter(self, obj, event):
+        # Track dock manager events
+        if obj is self.dock_manager and event.type() in (
+            QEvent.Type.ChildAdded,
+            QEvent.Type.ChildRemoved,
+            QEvent.Type.LayoutRequest,
+        ):
+            QTimer.singleShot(0, self._scan_and_fix_areas)
+
+        return super().eventFilter(obj, event)
+
+    def add_editor(
+        self, area: Any | None = None, title: str | None = None, tooltip: str | None = None
+    ):  # Any as qt ads does not return a proper type
+        """
+        Adds a new Monaco editor dock widget to the dock manager.
+        """
+        new_dock = self._create_editor()
+        if title is not None:
+            new_dock.setWindowTitle(title)
+        if tooltip is not None:
+            new_dock.setTabToolTip(tooltip)
+        if area is None:
+            area_obj = self.dock_manager.addDockWidgetTab(
+                QtAds.DockWidgetArea.TopDockWidgetArea, new_dock
+            )
+            self._ensure_area_plus(area_obj)
+        else:
+            # If an area is provided, add the dock to that area
+            self.dock_manager.addDockWidgetTabToArea(new_dock, area)
+            self._ensure_area_plus(area)
+
+        QTimer.singleShot(0, self._scan_and_fix_areas)
+        return new_dock
+
+    def open_file(self, file_name: str, scope: str | None = None) -> None:
+        """
+        Open a file in the specified area. If the file is already open, activate it.
+        """
+        open_files = self._get_open_files()
+        if file_name in open_files:
+            dock = self._get_editor_dock(file_name)
+            if dock is not None:
+                dock.setAsCurrentTab()
+            return
+
+        file = os.path.basename(file_name)
+        # If the current editor is empty, we reuse it
+
+        # For now, the dock manager is only for the editor docks. We can therefore safely assume
+        # that all docks are editor docks.
+        dock_area = self.dock_manager.dockArea(0)
+        if not dock_area:
+            return
+
+        editor_dock = dock_area.currentDockWidget()
+        if not editor_dock:
+            return
+
+        editor_widget = editor_dock.widget() if editor_dock else None
+        if editor_widget:
+            editor_widget = cast(MonacoWidget, editor_dock.widget())
+            if editor_widget.current_file is None and editor_widget.get_text() == "":
+                editor_dock.setWindowTitle(file)
+                editor_dock.setTabToolTip(file_name)
+                editor_widget.open_file(file_name)
+                if scope is not None:
+                    editor_widget.metadata["scope"] = scope
+                return
+
+        # File is not open, create a new editor
+        editor_dock = self.add_editor(title=file, tooltip=file_name)
+        widget = cast(MonacoWidget, editor_dock.widget())
+        widget.open_file(file_name)
+        if scope is not None:
+            widget.metadata["scope"] = scope
+        editor_dock.setAsCurrentTab()
+
+    def save_file(
+        self, widget: MonacoWidget | None = None, force_save_as: bool = False, format_on_save=True
+    ) -> None:
+        """
+        Save the currently focused file.
+
+        Args:
+            widget (MonacoWidget | None): The widget to save. If None, the last focused editor will be used.
+            force_save_as (bool): If True, the "Save As" dialog will be shown even if the file is already saved.
+            format_on_save (bool): If True, format the code before saving if it's a Python file.
+        """
+        if widget is None:
+            widget = self.last_focused_editor.widget() if self.last_focused_editor else None
+        if not widget:
+            return
+        if "macros" in widget.metadata.get("scope", ""):
+            if not self._validate_macros(widget.get_text()):
+                return
+
+        if widget.current_file and not force_save_as:
+            if format_on_save and pathlib.Path(widget.current_file).suffix == ".py":
+                widget.format()
+
+            with open(widget.current_file, "w", encoding="utf-8") as f:
+                f.write(widget.get_text())
+
+            if "macros" in widget.metadata.get("scope", ""):
+                self._update_macros(widget)
+                # Emit signal to refresh macro tree widget
+                self.macro_file_updated.emit(widget.current_file)
+
+            # pylint: disable=protected-access
+            widget._original_content = widget.get_text()
+            widget.save_enabled.emit(False)
+            return
+
+        # Save as option
+        save_file = QFileDialog.getSaveFileName(self, "Save File As", "", "All files (*)")
+
+        if not save_file or not save_file[0]:
+            return
+        # check if we have suffix specified
+        file = pathlib.Path(save_file[0])
+        if file.suffix == "":
+            file = file.with_suffix(".py")
+        if format_on_save and file.suffix == ".py":
+            widget.format()
+
+        text = widget.get_text()
+        with open(file, "w", encoding="utf-8") as f:
+            f.write(text)
+        widget._original_content = text
+
+        # Update the current_file before emitting save_enabled to ensure proper tracking
+        widget._current_file = str(file)
+        widget.save_enabled.emit(False)
+
+        # Find the dock widget containing this monaco widget and update title
+        for dock in self.dock_manager.dockWidgets():
+            if dock.widget() == widget:
+                dock.setWindowTitle(file.name)
+                dock.setTabToolTip(str(file))
+                break
+        if "macros" in widget.metadata.get("scope", ""):
+            self._update_macros(widget)
+            # Emit signal to refresh macro tree widget
+            self.macro_file_updated.emit(str(file))
+
+        logger.debug(f"Save file called, last focused editor: {self.last_focused_editor}")
+
+    def _validate_macros(self, source: str) -> bool:
+        # pylint: disable=protected-access
+        # Ensure the macro does not contain executable code before saving
+        exec_code, line_number = has_executable_code(source)
+        if exec_code:
+            if line_number is None:
+                msg = "The macro contains executable code. Please remove it before saving."
+            else:
+                msg = f"The macro contains executable code on line {line_number}. Please remove it before saving."
+            QMessageBox.warning(self, "Save Error", msg)
+            return False
+        return True
+
+    def _update_macros(self, widget: MonacoWidget):
+        # pylint: disable=protected-access
+        if not widget.current_file:
+            return
+        # Check which macros have changed and broadcast the change
+        macros = self.client.macros._update_handler.get_macros_from_file(widget.current_file)
+        existing_macros = self.client.macros._update_handler.get_existing_macros(
+            widget.current_file
+        )
+
+        removed_macros = set(existing_macros.keys()) - set(macros.keys())
+        added_macros = set(macros.keys()) - set(existing_macros.keys())
+        for name, info in macros.items():
+            if name in added_macros:
+                self.client.macros._update_handler.broadcast(
+                    action="add", name=name, file_path=widget.current_file
+                )
+            if (
+                name in existing_macros
+                and info.get("source", "") != existing_macros[name]["source"]
+            ):
+                self.client.macros._update_handler.broadcast(
+                    action="reload", name=name, file_path=widget.current_file
+                )
+        for name in removed_macros:
+            self.client.macros._update_handler.broadcast(action="remove", name=name)
+
+    def set_vim_mode(self, enabled: bool):
+        """
+        Set Vim mode for all editor widgets.
+
+        Args:
+            enabled (bool): Whether to enable or disable Vim mode.
+        """
+        for widget in self.dock_manager.dockWidgets():
+            editor_widget = cast(MonacoWidget, widget.widget())
+            editor_widget.set_vim_mode_enabled(enabled)
+
+    def _get_open_files(self) -> list[str]:
+        open_files = []
+        for widget in self.dock_manager.dockWidgets():
+            editor_widget = cast(MonacoWidget, widget.widget())
+            if editor_widget.current_file is not None:
+                open_files.append(editor_widget.current_file)
+        return open_files
+
+    def _get_editor_dock(self, file_name: str) -> QtAds.CDockWidget | None:
+        for widget in self.dock_manager.dockWidgets():
+            editor_widget = cast(MonacoWidget, widget.widget())
+            if editor_widget.current_file == file_name:
+                return widget
+        return None
+
+    def set_file_readonly(self, file_name: str, read_only: bool = True) -> bool:
+        """
+        Set a specific file's editor to read-only mode.
+
+        Args:
+            file_name (str): The file path to set read-only
+            read_only (bool): Whether to set read-only mode (default: True)
+
+        Returns:
+            bool: True if the file was found and read-only was set, False otherwise
+        """
+        editor_dock = self._get_editor_dock(file_name)
+        if editor_dock:
+            editor_widget = cast(MonacoWidget, editor_dock.widget())
+            editor_widget.set_readonly(read_only)
+            return True
+        return False
+
+    def set_file_icon(self, file_name: str, icon) -> bool:
+        """
+        Set an icon for a specific file's tab.
+
+        Args:
+            file_name (str): The file path to set icon for
+            icon: The QIcon to set on the tab
+
+        Returns:
+            bool: True if the file was found and icon was set, False otherwise
+        """
+        editor_dock = self._get_editor_dock(file_name)
+        if editor_dock:
+            editor_dock.setIcon(icon)
+            return True
+        return False
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    _dock = MonacoDock()
+    _dock.show()
+    sys.exit(app.exec())

bec_widgets/widgets/editors/monaco/monaco_widget.py

@@ -1,11 +1,24 @@
-from typing import Literal
+from __future__ import annotations
 
+import os
+import traceback
+from typing import TYPE_CHECKING, Literal
+
+import black
+import isort
 import qtmonaco
+from bec_lib.logger import bec_logger
 from qtpy.QtCore import Signal
-from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+from qtpy.QtWidgets import QApplication, QDialog, QVBoxLayout, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import get_theme_name
+from bec_widgets.utils.error_popups import SafeSlot
+
+if TYPE_CHECKING:
+    from bec_widgets.widgets.editors.monaco.scan_control_dialog import ScanControlDialog
+
+logger = bec_logger.logger
 
 
 class MonacoWidget(BECWidget, QWidget):
@@ -14,6 +27,7 @@ class MonacoWidget(BECWidget, QWidget):
     """
 
     text_changed = Signal(str)
+    save_enabled = Signal(bool)
     PLUGIN = True
     ICON_NAME = "code"
     USER_ACCESS = [
@@ -21,6 +35,7 @@ class MonacoWidget(BECWidget, QWidget):
         "get_text",
         "insert_text",
         "delete_line",
+        "open_file",
         "set_language",
         "get_language",
         "set_theme",
@@ -37,7 +52,9 @@ class MonacoWidget(BECWidget, QWidget):
         "screenshot",
     ]
 
-    def __init__(self, parent=None, config=None, client=None, gui_id=None, **kwargs):
+    def __init__(
+        self, parent=None, config=None, client=None, gui_id=None, init_lsp: bool = True, **kwargs
+    ):
         super().__init__(
             parent=parent, client=client, gui_id=gui_id, config=config, theme_update=True, **kwargs
         )
@@ -47,7 +64,30 @@ class MonacoWidget(BECWidget, QWidget):
         layout.addWidget(self.editor)
         self.setLayout(layout)
         self.editor.text_changed.connect(self.text_changed.emit)
+        self.editor.text_changed.connect(self._check_save_status)
         self.editor.initialized.connect(self.apply_theme)
+        self.editor.initialized.connect(self._setup_context_menu)
+        self.editor.context_menu_action_triggered.connect(self._handle_context_menu_action)
+        self._current_file = None
+        self._original_content = ""
+        self.metadata = {}
+        if init_lsp:
+            self.editor.update_workspace_configuration(
+                {
+                    "pylsp": {
+                        "plugins": {
+                            "pylsp-bec": {"service_config": self.client._service_config.config}
+                        }
+                    }
+                }
+            )
+
+    @property
+    def current_file(self):
+        """
+        Get the current file being edited.
+        """
+        return self._current_file
 
     def apply_theme(self, theme: str | None = None) -> None:
         """
@@ -61,14 +101,19 @@ class MonacoWidget(BECWidget, QWidget):
         editor_theme = "vs" if theme == "light" else "vs-dark"
         self.set_theme(editor_theme)
 
-    def set_text(self, text: str) -> None:
+    def set_text(self, text: str, file_name: str | None = None, reset: bool = False) -> None:
         """
         Set the text in the Monaco editor.
 
         Args:
             text (str): The text to set in the editor.
+            file_name (str): Set the file name
+            reset (bool): If True, reset the original content to the new text.
         """
-        self.editor.set_text(text)
+        self._current_file = file_name if file_name else self._current_file
+        if reset:
+            self._original_content = text
+        self.editor.set_text(text, uri=file_name)
 
     def get_text(self) -> str:
         """
@@ -76,6 +121,32 @@ class MonacoWidget(BECWidget, QWidget):
         """
         return self.editor.get_text()
 
+    def format(self) -> None:
+        """
+        Format the current text in the Monaco editor.
+        """
+        if not self.editor:
+            return
+        try:
+            content = self.get_text()
+            try:
+                formatted_content = black.format_str(content, mode=black.Mode(line_length=100))
+            except Exception:  # black.NothingChanged or other formatting exceptions
+                formatted_content = content
+
+            config = isort.Config(
+                profile="black",
+                line_length=100,
+                multi_line_output=3,
+                include_trailing_comma=False,
+                known_first_party=["bec_widgets"],
+            )
+            formatted_content = isort.code(formatted_content, config=config)
+            self.set_text(formatted_content, file_name=self.current_file)
+        except Exception:
+            content = traceback.format_exc()
+            logger.info(content)
+
     def insert_text(self, text: str, line: int | None = None, column: int | None = None) -> None:
         """
         Insert text at the current cursor position or at a specified line and column.
@@ -96,6 +167,32 @@ class MonacoWidget(BECWidget, QWidget):
         """
         self.editor.delete_line(line)
 
+    def open_file(self, file_name: str) -> None:
+        """
+        Open a file in the editor.
+
+        Args:
+            file_name (str): The path + file name of the file that needs to be displayed.
+        """
+
+        if not os.path.exists(file_name):
+            raise FileNotFoundError(f"The specified file does not exist: {file_name}")
+
+        with open(file_name, "r", encoding="utf-8") as file:
+            content = file.read()
+        self.set_text(content, file_name=file_name, reset=True)
+
+    @property
+    def modified(self) -> bool:
+        """
+        Check if the editor content has been modified.
+        """
+        return self._original_content != self.get_text()
+
+    @SafeSlot(str)
+    def _check_save_status(self, _text: str) -> None:
+        self.save_enabled.emit(self.modified)
+
     def set_cursor(
         self,
         line: int,
@@ -213,6 +310,46 @@ class MonacoWidget(BECWidget, QWidget):
         """
         return self.editor.get_lsp_header()
 
+    def _setup_context_menu(self):
+        """Setup custom context menu actions for the Monaco editor."""
+        # Add the "Insert Scan" action to the context menu
+        self.editor.add_action("insert_scan", "Insert Scan", "python")
+        # Add the "Format Code" action to the context menu
+        self.editor.add_action("format_code", "Format Code", "python")
+
+    def _handle_context_menu_action(self, action_id: str):
+        """Handle context menu action triggers."""
+        if action_id == "insert_scan":
+            self._show_scan_control_dialog()
+        elif action_id == "format_code":
+            self._format_code()
+
+    def _show_scan_control_dialog(self):
+        """Show the scan control dialog and insert the generated scan code."""
+        # Import here to avoid circular imports
+        from bec_widgets.widgets.editors.monaco.scan_control_dialog import ScanControlDialog
+
+        dialog = ScanControlDialog(self, client=self.client)
+        self._run_dialog_and_insert_code(dialog)
+
+    def _run_dialog_and_insert_code(self, dialog: ScanControlDialog):
+        """
+        Run the dialog and insert the generated scan code if accepted.
+        It is a separate method to allow easier testing.
+
+        Args:
+            dialog (ScanControlDialog): The scan control dialog instance.
+        """
+        if dialog.exec_() == QDialog.DialogCode.Accepted:
+            scan_code = dialog.get_scan_code()
+            if scan_code:
+                # Insert the scan code at the current cursor position
+                self.insert_text(scan_code)
+
+    def _format_code(self):
+        """Format the current code in the editor."""
+        self.format()
+
 
 if __name__ == "__main__":  # pragma: no cover
     qapp = QApplication([])
@@ -234,7 +371,7 @@ if TYPE_CHECKING:
     scans: Scans
 
 #######################################
-########## User Script #####################
+########## User Script ################
 #######################################
 
 # This is a comment

bec_widgets/widgets/editors/monaco/scan_control_dialog.py

@@ -0,0 +1,145 @@
+"""
+Scan Control Dialog for Monaco Editor
+
+This module provides a dialog wrapper around the ScanControl widget,
+allowing users to configure and generate scan code that can be inserted
+into the Monaco editor.
+"""
+
+from bec_lib.device import Device
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QSize, Qt
+from qtpy.QtWidgets import QDialog, QDialogButtonBox, QPushButton, QVBoxLayout
+
+from bec_widgets.widgets.control.scan_control import ScanControl
+
+logger = bec_logger.logger
+
+
+class ScanControlDialog(QDialog):
+    """
+    Dialog window containing the ScanControl widget for generating scan code.
+
+    This dialog allows users to configure scan parameters and generates
+    Python code that can be inserted into the Monaco editor.
+    """
+
+    def __init__(self, parent=None, client=None):
+        super().__init__(parent)
+        self.setWindowTitle("Insert Scan")
+
+        # Store the client for passing to ScanControl
+        self.client = client
+        self._scan_code = ""
+
+        self._setup_ui()
+
+    def sizeHint(self) -> QSize:
+        return QSize(600, 800)
+
+    def _setup_ui(self):
+        """Setup the dialog UI with ScanControl widget and buttons."""
+        layout = QVBoxLayout(self)
+
+        # Create the scan control widget
+        self.scan_control = ScanControl(parent=self, client=self.client)
+        self.scan_control.show_scan_control_buttons(False)
+        layout.addWidget(self.scan_control)
+
+        # Create dialog buttons
+        button_box = QDialogButtonBox(Qt.Orientation.Horizontal, self)
+
+        # Create custom buttons with appropriate text
+        insert_button = QPushButton("Insert")
+        cancel_button = QPushButton("Cancel")
+
+        button_box.addButton(insert_button, QDialogButtonBox.ButtonRole.AcceptRole)
+        button_box.addButton(cancel_button, QDialogButtonBox.ButtonRole.RejectRole)
+
+        layout.addWidget(button_box)
+
+        # Connect button signals
+        button_box.accepted.connect(self.accept)
+        button_box.rejected.connect(self.reject)
+
+    def _generate_scan_code(self):
+        """Generate Python code for the configured scan."""
+        try:
+            # Get scan parameters from the scan control widget
+            args, kwargs = self.scan_control.get_scan_parameters()
+            scan_name = self.scan_control.current_scan
+
+            if not scan_name:
+                self._scan_code = ""
+                return
+
+            # Process arguments and add device prefix where needed
+            processed_args = self._process_arguments_for_code_generation(args)
+            processed_kwargs = self._process_kwargs_for_code_generation(kwargs)
+
+            # Generate the Python code string
+            code_parts = []
+
+            # Process arguments and keyword arguments
+            all_args = []
+
+            # Add positional arguments
+            if processed_args:
+                all_args.extend(processed_args)
+
+            # Add keyword arguments (excluding metadata)
+            if processed_kwargs:
+                kwargs_strs = [f"{k}={v}" for k, v in processed_kwargs.items()]
+                all_args.extend(kwargs_strs)
+
+            # Join all arguments and create the scan call
+            args_str = ", ".join(all_args)
+            if args_str:
+                code_parts.append(f"scans.{scan_name}({args_str})")
+            else:
+                code_parts.append(f"scans.{scan_name}()")
+
+            self._scan_code = "\n".join(code_parts)
+
+        except Exception as e:
+            logger.error(f"Error generating scan code: {e}")
+            self._scan_code = f"# Error generating scan code: {e}\n"
+
+    def _process_arguments_for_code_generation(self, args):
+        """Process arguments to add device prefixes and proper formatting."""
+        return [self._format_value_for_code(arg) for arg in args]
+
+    def _process_kwargs_for_code_generation(self, kwargs):
+        """Process keyword arguments to add device prefixes and proper formatting."""
+        return {key: self._format_value_for_code(value) for key, value in kwargs.items()}
+
+    def _format_value_for_code(self, value):
+        """Format a single value for code generation."""
+        if isinstance(value, Device):
+            return f"dev.{value.name}"
+        return repr(value)
+
+    def get_scan_code(self) -> str:
+        """
+        Get the generated scan code.
+
+        Returns:
+            str: The Python code for the configured scan.
+        """
+        return self._scan_code
+
+    def accept(self):
+        """Override accept to generate code before closing."""
+        self._generate_scan_code()
+        super().accept()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    dialog = ScanControlDialog()
+    dialog.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/editors/web_console/web_console.py

@@ -172,9 +172,17 @@ class WebConsole(BECWidget, QWidget):
     PLUGIN = True
     ICON_NAME = "terminal"
 
-    def __init__(self, parent=None, config=None, client=None, gui_id=None, **kwargs):
+    def __init__(
+        self,
+        parent=None,
+        config=None,
+        client=None,
+        gui_id=None,
+        startup_cmd: str | None = "bec --nogui",
+        **kwargs,
+    ):
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
-        self._startup_cmd = "bec --nogui"
+        self._startup_cmd = startup_cmd
         self._is_initialized = False
         _web_console_registry.register(self)
         self._token = _web_console_registry._token

bec_widgets/widgets/games/minesweeper.py

@@ -4,7 +4,7 @@ import time
 
 from bec_qthemes import material_icon
 from qtpy.QtCore import QSize, Qt, QTimer, Signal, Slot
-from qtpy.QtGui import QBrush, QColor, QPainter, QPen
+from qtpy.QtGui import QBrush, QColor, QPainter, QPen, QPixmap
 from qtpy.QtWidgets import (
     QApplication,
     QComboBox,
@@ -87,7 +87,7 @@ class Pos(QWidget):
 
         if self.is_revealed:
             if self.is_mine:
-                p.drawPixmap(r, material_icon("experiment", convert_to_pixmap=True, filled=True))
+                p.drawPixmap(r, material_icon("experiment", icon_type=QPixmap, filled=True))
 
             elif self.adjacent_n > 0:
                 pen = QPen(NUM_COLORS[self.adjacent_n])
@@ -103,7 +103,7 @@ class Pos(QWidget):
                 material_icon(
                     "flag",
                     size=(50, 50),
-                    convert_to_pixmap=True,
+                    icon_type=QPixmap,
                     filled=True,
                     color=self.palette().base().color(),
                 ),
@@ -376,13 +376,13 @@ class Minesweeper(BECWidget, QWidget):
         self.status = status
         match status:
             case GameStatus.READY:
-                icon = material_icon(icon_name="add", convert_to_pixmap=False)
+                icon = material_icon(icon_name="add", icon_type=QIcon)
             case GameStatus.PLAYING:
-                icon = material_icon(icon_name="smart_toy", convert_to_pixmap=False)
+                icon = material_icon(icon_name="smart_toy", icon_type=QIcon)
             case GameStatus.FAILED:
-                icon = material_icon(icon_name="error", convert_to_pixmap=False)
+                icon = material_icon(icon_name="error", icon_type=QIcon)
             case GameStatus.SUCCESS:
-                icon = material_icon(icon_name="celebration", convert_to_pixmap=False)
+                icon = material_icon(icon_name="celebration", icon_type=QIcon)
         self.reset_button.setIcon(icon)
 
     def update_timer(self):

bec_widgets/widgets/plots/image/image.py

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

bec_widgets/widgets/plots/image/setting_widgets/image_roi_tree.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 import math
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from bec_lib import bec_logger
 from bec_qthemes import material_icon
 from qtpy.QtCore import QEvent, Qt
-from qtpy.QtGui import QColor
+from qtpy.QtGui import QColor, QIcon
 from qtpy.QtWidgets import (
     QColorDialog,
     QHBoxLayout,
@@ -62,7 +62,7 @@ class ROILockButton(QToolButton):
         movable = self._roi.movable
         self.setChecked(not movable)
         icon = "lock_open_right" if movable else "lock"
-        self.setIcon(material_icon(icon, size=(20, 20), convert_to_pixmap=False))
+        self.setIcon(material_icon(icon, size=(20, 20), icon_type=QIcon))
 
 
 class ROIPropertyTree(BECWidget, QWidget):
@@ -73,11 +73,16 @@ class ROIPropertyTree(BECWidget, QWidget):
     - Children: type, line-width (spin box), coordinates (auto-updating).
 
     Args:
+        parent (QWidget, optional): Parent widget. Defaults to None.
         image_widget (Image): The main Image widget that displays the ImageItem.
             Provides ``plot_item`` and owns an ROIController already.
         controller (ROIController, optional): Optionally pass an external controller.
             If None, the manager uses ``image_widget.roi_controller``.
-        parent (QWidget, optional): Parent widget. Defaults to None.
+        compact (bool, optional): If True, use a compact mode with no tree view,
+            only a toolbar with draw actions. Defaults to False.
+        compact_orientation (str, optional): Orientation of the toolbar in compact mode.
+            Either "vertical" or "horizontal". Defaults to "vertical".
+        compact_color (str, optional): Color of the single active ROI in compact mode.
     """
 
     PLUGIN = False
@@ -92,11 +97,18 @@ class ROIPropertyTree(BECWidget, QWidget):
         parent: QWidget = None,
         image_widget: Image,
         controller: ROIController | None = None,
+        compact: bool = False,
+        compact_orientation: Literal["vertical", "horizontal"] = "vertical",
+        compact_color: str = "#f0f0f0",
     ):
 
         super().__init__(
             parent=parent, config=ConnectionConfig(widget_class=self.__class__.__name__)
         )
+        self.compact = compact
+        self.compact_orient = compact_orientation
+        self.compact_color = compact_color
+        self.single_active_roi: BaseROI | None = None
 
         if controller is None:
             # Use the controller already belonging to the Image widget
@@ -112,22 +124,29 @@ class ROIPropertyTree(BECWidget, QWidget):
 
         self.layout = QVBoxLayout(self)
         self._init_toolbar()
-        self._init_tree()
+        if not self.compact:
+            self._init_tree()
+        else:
+            self.tree = None
 
         # connect controller
         self.controller.roiAdded.connect(self._on_roi_added)
         self.controller.roiRemoved.connect(self._on_roi_removed)
-        self.controller.cleared.connect(self.tree.clear)
+        if not self.compact:
+            self.controller.cleared.connect(self.tree.clear)
 
         # initial load
         for r in self.controller.rois:
             self._on_roi_added(r)
 
-        self.tree.collapseAll()
+        if not self.compact:
+            self.tree.collapseAll()
 
     # --------------------------------------------------------------------- UI
     def _init_toolbar(self):
-        tb = self.toolbar = ModularToolBar(self, orientation="horizontal")
+        tb = self.toolbar = ModularToolBar(
+            self, orientation=self.compact_orient if self.compact else "horizontal"
+        )
         self._draw_actions: dict[str, MaterialIconAction] = {}
         # --- ROI draw actions (toggleable) ---
 
@@ -157,6 +176,29 @@ class ROIPropertyTree(BECWidget, QWidget):
         for mode, act in self._draw_actions.items():
             act.action.toggled.connect(lambda on, m=mode: self._on_draw_action_toggled(m, on))
 
+        if self.compact:
+            tb.components.add_safe(
+                "compact_delete",
+                MaterialIconAction("delete", "Delete Current Roi", checkable=False, parent=self),
+            )
+            bundle.add_action("compact_delete")
+            tb.components.get_action("compact_delete").action.triggered.connect(
+                lambda _: (
+                    self.controller.remove_roi(self.single_active_roi)
+                    if self.single_active_roi is not None
+                    else None
+                )
+            )
+            tb.show_bundles(["roi_draw"])
+            self.layout.addWidget(tb)
+
+            # ROI drawing state (needed even in compact mode)
+            self._roi_draw_mode = None
+            self._roi_start_pos = None
+            self._temp_roi = None
+            self.plot.scene().installEventFilter(self)
+            return
+
         # Expand/Collapse toggle
         self.expand_toggle = MaterialIconAction(
             "unfold_more", "Expand/Collapse", checkable=True, parent=self  # icon when collapsed
@@ -167,11 +209,11 @@ class ROIPropertyTree(BECWidget, QWidget):
             if on:
                 # switched to expanded state
                 self.tree.expandAll()
-                new_icon = material_icon("unfold_less", size=(20, 20), convert_to_pixmap=False)
+                new_icon = material_icon("unfold_less", size=(20, 20), icon_type=QIcon)
             else:
                 # collapsed state
                 self.tree.collapseAll()
-                new_icon = material_icon("unfold_more", size=(20, 20), convert_to_pixmap=False)
+                new_icon = material_icon("unfold_more", size=(20, 20), icon_type=QIcon)
             self.expand_toggle.action.setIcon(new_icon)
 
         self.expand_toggle.action.toggled.connect(_exp_toggled)
@@ -189,7 +231,7 @@ class ROIPropertyTree(BECWidget, QWidget):
             for r in self.controller.rois:
                 r.movable = not checked
             new_icon = material_icon(
-                "lock" if checked else "lock_open_right", size=(20, 20), convert_to_pixmap=False
+                "lock" if checked else "lock_open_right", size=(20, 20), icon_type=QIcon
             )
             self.lock_all_action.action.setIcon(new_icon)
 
@@ -327,13 +369,21 @@ class ROIPropertyTree(BECWidget, QWidget):
             self._set_roi_draw_mode(None)
             # register via controller
             self.controller.add_roi(final_roi)
+            if self.compact:
+                final_roi.line_color = self.compact_color
             return True
         return super().eventFilter(obj, event)
 
     # --------------------------------------------------------- controller slots
     def _on_roi_added(self, roi: BaseROI):
+        if self.compact:
+            roi.line_color = self.compact_color
+            if self.single_active_roi is not None and self.single_active_roi is not roi:
+                self.controller.remove_roi(self.single_active_roi)
+            self.single_active_roi = roi
+            return
         # check the global setting from the toolbar
-        if self.lock_all_action.action.isChecked():
+        if hasattr(self, "lock_all_action") and self.lock_all_action.action.isChecked():
             roi.movable = False
         # parent row with blank action column, name in ROI column
         parent = QTreeWidgetItem(self.tree, ["", "", ""])
@@ -352,11 +402,7 @@ class ROIPropertyTree(BECWidget, QWidget):
         # delete button
         del_btn = QToolButton()
         delete_icon = material_icon(
-            "delete",
-            size=(20, 20),
-            convert_to_pixmap=False,
-            filled=False,
-            color=self.DELETE_BUTTON_COLOR,
+            "delete", size=(20, 20), icon_type=QIcon, filled=False, color=self.DELETE_BUTTON_COLOR
         )
         del_btn.setIcon(delete_icon)
         del_btn.clicked.connect(lambda _=None, r=roi: self._delete_roi(r))
@@ -424,6 +470,10 @@ class ROIPropertyTree(BECWidget, QWidget):
         roi.movable = not roi.movable
 
     def _on_roi_removed(self, roi: BaseROI):
+        if self.compact:
+            if self.single_active_roi is roi:
+                self.single_active_roi = None
+            return
         item = self.roi_items.pop(roi, None)
         if item:
             idx = self.tree.indexOfTopLevelItem(item)
@@ -449,8 +499,9 @@ class ROIPropertyTree(BECWidget, QWidget):
         self.controller.remove_roi(roi)
 
     def cleanup(self):
-        self.cmap.close()
-        self.cmap.deleteLater()
+        if hasattr(self, "cmap"):
+            self.cmap.close()
+            self.cmap.deleteLater()
         if self.controller and hasattr(self.controller, "rois"):
             for roi in self.controller.rois:  # disconnect all signals from ROIs
                 try:
@@ -491,8 +542,8 @@ if __name__ == "__main__":  # pragma: no cover
     # Add the image widget on the left
     ml.addWidget(image_widget)
 
-    # ROI manager linked to that image
-    mgr = ROIPropertyTree(parent=image_widget, image_widget=image_widget)
+    # ROI manager linked to that image with compact mode
+    mgr = ROIPropertyTree(parent=image_widget, image_widget=image_widget, compact=True)
     mgr.setFixedWidth(350)
     ml.addWidget(mgr)
 

bec_widgets/widgets/plots/motor_map/motor_map.py

@@ -767,7 +767,7 @@ class MotorMap(PlotBase):
             float: Motor initial position.
         """
         entry = self.entry_validator.validate_signal(name, None)
-        init_position = round(float(self.dev[name].read()[entry]["value"]), precision)
+        init_position = round(float(self.dev[name].read(cached=True)[entry]["value"]), precision)
         return init_position
 
     def _sync_motor_map_selection_toolbar(self):

bec_widgets/widgets/plots/plot_base.py

@@ -109,6 +109,7 @@ class PlotBase(BECWidget, QWidget):
         self.plot_widget.ci.setContentsMargins(0, 0, 0, 0)
         self.plot_item = pg.PlotItem(viewBox=BECViewBox(enableMenu=True))
         self.plot_widget.addItem(self.plot_item)
+        self.plot_item.visible_items = lambda: self.visible_items
         self.side_panel = SidePanel(self, orientation="left", panel_max_width=280)
 
         # PlotItem Addons
@@ -895,15 +896,20 @@ class PlotBase(BECWidget, QWidget):
             return
         self._apply_autorange_only_visible_curves()
 
-    def _fetch_visible_curves(self):
-        """
-        Fetch all visible curves from the plot item.
-        """
-        visible_curves = []
-        for curve in self.plot_item.curves:
-            if curve.isVisible():
-                visible_curves.append(curve)
-        return visible_curves
+    @property
+    def visible_items(self):
+        crosshair_items = []
+        if self.crosshair:
+            crosshair_items = [
+                self.crosshair.v_line,
+                self.crosshair.h_line,
+                self.crosshair.coord_label,
+            ]
+        return [
+            item
+            for item in self.plot_item.items
+            if item.isVisible() and item not in crosshair_items
+        ]
 
     def _apply_autorange_only_visible_curves(self):
         """
@@ -912,8 +918,9 @@ class PlotBase(BECWidget, QWidget):
         Args:
             curves (list): List of curves to apply autorange to.
         """
-        visible_curves = self._fetch_visible_curves()
-        self.plot_item.autoRange(items=visible_curves if visible_curves else None)
+        visible_items = self.visible_items
+
+        self.plot_item.autoRange(items=visible_items if visible_items else None)
 
     @SafeProperty(int, doc="The font size of the legend font.")
     def legend_label_size(self) -> int:

bec_widgets/widgets/plots/roi/image_roi.py

@@ -174,6 +174,8 @@ class BaseROI(BECConnector):
         self.remove_scale_handles()  # remove any existing handles from pyqtgraph.RectROI
         if movable:
             self.add_scale_handle()  # add custom scale handles
+        if hasattr(self, "sigRemoveRequested"):
+            self.sigRemoveRequested.connect(self.remove)
 
     def set_parent(self, parent: Image):
         """

bec_widgets/widgets/plots/waveform/curve.py

@@ -42,10 +42,15 @@ class CurveConfig(ConnectionConfig):
     pen_style: Literal["solid", "dash", "dot", "dashdot"] | None = Field(
         "solid", description="The style of the pen of the curve."
     )
-    source: Literal["device", "dap", "custom"] = Field(
+    source: Literal["device", "dap", "custom", "history"] = Field(
         "custom", description="The source of the curve."
     )
     signal: DeviceSignal | None = Field(None, description="The signal of the curve.")
+    scan_id: str | None = Field(None, description="Scan ID to be used when `source` is 'history'.")
+    scan_number: int | None = Field(
+        None, description="Scan index to be used when `source` is 'history'."
+    )
+    current_x_mode: str | None = Field(None, description="The current x mode of the history curve.")
     parent_label: str | None = Field(
         None, description="The label of the parent plot, only relevant for dap curves."
     )
@@ -199,7 +204,7 @@ class Curve(BECConnector, pg.PlotDataItem):
         Raises:
             ValueError: If the source is not custom.
         """
-        if self.config.source == "custom":
+        if self.config.source in ["custom", "history"]:
             self.setData(x, y)
         else:
             raise ValueError(f"Source {self.config.source} do not allow custom data setting.")

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

@@ -5,7 +5,34 @@ from typing import TYPE_CHECKING
 
 from bec_lib.logger import bec_logger
 from bec_qthemes._icon.material_icons import material_icon
-from qtpy.QtCore import Qt
+from qtpy.QtGui import QIcon, QValidator
+
+
+class ScanIndexValidator(QValidator):
+    """Validator to allow only 'live' or integer scan numbers from an allowed set."""
+
+    def __init__(self, allowed_scans: set[int] | None = None, parent=None):
+        super().__init__(parent)
+        self.allowed_scans = allowed_scans or set()
+
+    def validate(self, input_str: str, pos: int):
+        # Accept empty or 'live'
+        if input_str == "" or input_str == "live":
+            return QValidator.State.Acceptable, input_str, pos
+        # Allow partial editing of "live"
+        if "live".startswith(input_str):
+            return QValidator.State.Intermediate, input_str, pos
+        # Accept integer only if present in the allowed set
+        if input_str.isdigit():
+            try:
+                num = int(input_str)
+            except ValueError:
+                return QValidator.State.Invalid, input_str, pos
+            if num in self.allowed_scans:
+                return QValidator.State.Acceptable, input_str, pos
+        return QValidator.State.Invalid, input_str, pos
+
+
 from qtpy.QtWidgets import (
     QApplication,
     QComboBox,
@@ -93,8 +120,60 @@ class CurveRow(QTreeWidgetItem):
         # Create columns 1..2, depending on source
         self._init_source_ui()
         # Create columns 3..6 (color, style, width, symbol)
+        self._init_scan_index_ui()
         self._init_style_controls()
 
+    def _init_scan_index_ui(self):
+        """Create the Scan # editable combobox in column 3."""
+        if self.source not in ("device", "history"):
+            return
+        self.scan_index_combo = QComboBox()
+        self.scan_index_combo.setEditable(True)
+        # Populate 'live' and all available history scan indices
+        self.scan_index_combo.addItem("live", None)
+
+        scan_number_list = []
+        scan_id_list = []
+        try:
+            history = getattr(self.curve_tree.client, "history", None)
+            if history is not None:
+                scan_number_list = getattr(history, "_scan_numbers", []) or []
+                scan_id_list = getattr(history, "_scan_ids", []) or []
+        except Exception as e:
+            logger.error(f"Cannot fetch scan numbers from BEC client: {e}")
+            # If scan numbers cannot be fetched, only provide 'live' option
+            scan_number_list = []
+            scan_id_list = []
+
+        # Restrict input to 'live' or valid scan numbers
+        allowed = set()
+        try:
+            allowed = set(int(n) for n in scan_number_list if isinstance(n, (int, str)))
+        except Exception:
+            allowed = set()
+        validator = ScanIndexValidator(allowed, self.scan_index_combo)
+        self.scan_index_combo.lineEdit().setValidator(validator)
+
+        # Add items: show scan numbers, store scan IDs as item data
+        if scan_number_list and scan_id_list and len(scan_number_list) == len(scan_id_list):
+            for num, sid in zip(scan_number_list, scan_id_list):
+                self.scan_index_combo.addItem(str(num), sid)
+        else:
+            logger.error("Scan number and ID lists are mismatched or empty.")
+
+        # Select current based on existing config
+        selected = False
+        if getattr(self.config, "scan_id", None):  # scan_id matching only
+            for i in range(self.scan_index_combo.count()):
+                if self.scan_index_combo.itemData(i) == self.config.scan_id:
+                    self.scan_index_combo.setCurrentIndex(i)
+                    selected = True
+                    break
+        if not selected:
+            self.scan_index_combo.setCurrentText("live")
+
+        self.tree.setItemWidget(self, 3, self.scan_index_combo)
+
     def _init_actions(self):
         """Create the actions widget in column 0, including a delete button and maybe 'Add DAP'."""
         self.actions_widget = QWidget()
@@ -105,23 +184,19 @@ class CurveRow(QTreeWidgetItem):
         # Delete button
         self.delete_button = QToolButton()
         delete_icon = material_icon(
-            "delete",
-            size=(20, 20),
-            convert_to_pixmap=False,
-            filled=False,
-            color=self.DELETE_BUTTON_COLOR,
+            "delete", size=(20, 20), icon_type=QIcon, filled=False, color=self.DELETE_BUTTON_COLOR
         )
         self.delete_button.setIcon(delete_icon)
         self.delete_button.clicked.connect(lambda: self.remove_self())
         actions_layout.addWidget(self.delete_button)
 
         # If device row, add "Add DAP" button
-        if self.source == "device":
+        if self.source in ("device", "history"):
             self.add_dap_button = QToolButton()
             analysis_icon = material_icon(
                 "monitoring",
                 size=(20, 20),
-                convert_to_pixmap=False,
+                icon_type=QIcon,
                 filled=False,
                 color=self.app.theme.colors["FG"].toTuple(),
             )
@@ -134,7 +209,7 @@ class CurveRow(QTreeWidgetItem):
 
     def _init_source_ui(self):
         """Create columns 1 and 2. For device rows, we have device/entry edits; for dap rows, label/model combo."""
-        if self.source == "device":
+        if self.source in ("device", "history"):
             # Device row: columns 1..2 are device line edits
             self.device_edit = DeviceComboBox(parent=self.tree)
             self.device_edit.insertItem(0, "")
@@ -163,7 +238,6 @@ class CurveRow(QTreeWidgetItem):
 
             self.tree.setItemWidget(self, 1, self.device_edit)
             self.tree.setItemWidget(self, 2, self.entry_edit)
-
         else:
             # DAP row: column1= "Model" label, column2= DapComboBox
             self.label_widget = QLabel("Model")
@@ -182,31 +256,31 @@ class CurveRow(QTreeWidgetItem):
             self.tree.setItemWidget(self, 2, self.dap_combo)
 
     def _init_style_controls(self):
-        """Create columns 3..6: color button, style combo, width spin, symbol spin."""
-        # Color in col 3
+        """Create columns 4..7: color button, style combo, width spin, symbol spin."""
+        # Color in col 4
         self.color_button = ColorButtonNative(color=self.config.color)
         self.color_button.color_changed.connect(self._on_color_changed)
-        self.tree.setItemWidget(self, 3, self.color_button)
+        self.tree.setItemWidget(self, 4, self.color_button)
 
-        # Style in col 4
+        # Style in col 5
         self.style_combo = QComboBox()
         self.style_combo.addItems(["solid", "dash", "dot", "dashdot"])
         idx = self.style_combo.findText(self.config.pen_style)
         if idx >= 0:
             self.style_combo.setCurrentIndex(idx)
-        self.tree.setItemWidget(self, 4, self.style_combo)
+        self.tree.setItemWidget(self, 5, self.style_combo)
 
-        # Pen width in col 5
+        # Pen width in col 6
         self.width_spin = QSpinBox()
         self.width_spin.setRange(1, 20)
         self.width_spin.setValue(self.config.pen_width)
-        self.tree.setItemWidget(self, 5, self.width_spin)
+        self.tree.setItemWidget(self, 6, self.width_spin)
 
-        # Symbol size in col 6
+        # Symbol size in col 7
         self.symbol_spin = QSpinBox()
         self.symbol_spin.setRange(1, 20)
         self.symbol_spin.setValue(self.config.symbol_size)
-        self.tree.setItemWidget(self, 6, self.symbol_spin)
+        self.tree.setItemWidget(self, 7, self.symbol_spin)
 
     @SafeSlot(str, verify_sender=True)
     def _on_color_changed(self, new_color: str):
@@ -220,8 +294,8 @@ class CurveRow(QTreeWidgetItem):
         self.config.symbol_color = new_color
 
     def add_dap_row(self):
-        """Create a new DAP row as a child. Only valid if source='device'."""
-        if self.source != "device":
+        """Create a new DAP row as a child. Only valid if source is 'device' or 'history'."""
+        if self.source not in ("device", "history"):
             return
         curve_tree = self.tree.parent()
         parent_label = self.config.label
@@ -299,7 +373,7 @@ class CurveRow(QTreeWidgetItem):
         Returns:
             dict: The serialized config based on the GUI state.
         """
-        if self.source == "device":
+        if self.source in ("device", "history"):
             # Gather device name/entry
             device_name = ""
             device_entry = ""
@@ -320,8 +394,23 @@ class CurveRow(QTreeWidgetItem):
                     )
 
             self.config.signal = DeviceSignal(name=device_name, entry=device_entry)
-            self.config.source = "device"
-            self.config.label = f"{device_name}-{device_entry}"
+            scan_combo_text = self.scan_index_combo.currentText()
+            if scan_combo_text == "live" or scan_combo_text == "":
+                self.config.scan_number = None
+                self.config.scan_id = None
+                self.config.source = "device"
+                self.config.label = f"{device_name}-{device_entry}"
+            if scan_combo_text.isdigit():
+                try:
+                    scan_num = int(scan_combo_text)
+                except ValueError:
+                    scan_num = None
+                self.config.scan_number = scan_num
+                self.config.scan_id = self.scan_index_combo.currentData()
+                self.config.source = "history"
+                # Label history curves with scan number suffix
+                if scan_num is not None:
+                    self.config.label = f"{device_name}-{device_entry}-scan-{scan_num}"
         else:
             # DAP logic
             parent_conf_dict = {}
@@ -454,10 +543,12 @@ class CurveTree(BECWidget, QWidget):
         self.toolbar.show_bundles(["curve_tree"])
 
     def _init_tree(self):
-        """Initialize the QTreeWidget with 7 columns and compact widths."""
+        """Initialize the QTreeWidget with 8 columns and compact widths."""
         self.tree = QTreeWidget()
-        self.tree.setColumnCount(7)
-        self.tree.setHeaderLabels(["Actions", "Name", "Entry", "Color", "Style", "Width", "Symbol"])
+        self.tree.setColumnCount(8)
+        self.tree.setHeaderLabels(
+            ["Actions", "Name", "Entry", "Scan #", "Color", "Style", "Width", "Symbol"]
+        )
 
         header = self.tree.header()
         for idx in range(self.tree.columnCount()):
@@ -467,10 +558,10 @@ class CurveTree(BECWidget, QWidget):
                 header.setSectionResizeMode(idx, QHeaderView.Fixed)
         header.setStretchLastSection(False)
         self.tree.setColumnWidth(0, 90)
-        self.tree.setColumnWidth(3, 70)
-        self.tree.setColumnWidth(4, 80)
-        self.tree.setColumnWidth(5, 50)
+        self.tree.setColumnWidth(4, 70)
+        self.tree.setColumnWidth(5, 80)
         self.tree.setColumnWidth(6, 50)
+        self.tree.setColumnWidth(7, 50)
 
         self.layout.addWidget(self.tree)
 
@@ -594,9 +685,9 @@ class CurveTree(BECWidget, QWidget):
         self.tree.clear()
         self.all_items = []
 
-        device_curves = [c for c in self.waveform.curves if c.config.source == "device"]
+        top_curves = [c for c in self.waveform.curves if c.config.source in ("device", "history")]
         dap_curves = [c for c in self.waveform.curves if c.config.source == "dap"]
-        for dev in device_curves:
+        for dev in top_curves:
             dr = CurveRow(self.tree, parent_item=None, config=dev.config, device_manager=self.dev)
             for dap in dap_curves:
                 if dap.config.parent_label == dev.config.label:

bec_widgets/widgets/plots/waveform/waveform.py

@@ -8,6 +8,7 @@ import numpy as np
 import pyqtgraph as pg
 from bec_lib import bec_logger, messages
 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.scan_data_container import ScanDataContainer
 from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import Qt, QTimer, Signal
 from qtpy.QtWidgets import (
@@ -35,6 +36,9 @@ from bec_widgets.widgets.plots.plot_base import PlotBase
 from bec_widgets.widgets.plots.waveform.curve import Curve, CurveConfig, DeviceSignal
 from bec_widgets.widgets.plots.waveform.settings.curve_settings.curve_setting import CurveSetting
 from bec_widgets.widgets.plots.waveform.utils.roi_manager import WaveformROIManager
+from bec_widgets.widgets.services.scan_history_browser.scan_history_browser import (
+    ScanHistoryBrowser,
+)
 
 logger = bec_logger.logger
 
@@ -166,6 +170,7 @@ class Waveform(PlotBase):
         # Curve data
         self._sync_curves = []
         self._async_curves = []
+        self._history_curves = []
         self._slice_index = None
         self._dap_curves = []
         self._mode = None
@@ -182,12 +187,14 @@ class Waveform(PlotBase):
             "readout_priority": None,
             "label_suffix": "",
         }
+        self._current_x_device: tuple[str, str] | None = None
 
         # Specific GUI elements
         self._init_roi_manager()
         self.dap_summary = None
         self.dap_summary_dialog = None
-        self._add_fit_parameters_popup()
+        self.scan_history_dialog = None
+        self._add_waveform_specific_popup()
         self._enable_roi_toolbar_action(False)  # default state where are no dap curves
         self._init_curve_dialog()
         self.curve_settings_dialog = None
@@ -255,7 +262,7 @@ class Waveform(PlotBase):
         super().add_side_menus()
         self._add_dap_summary_side_menu()
 
-    def _add_fit_parameters_popup(self):
+    def _add_waveform_specific_popup(self):
         """
         Add popups to the Waveform widget.
         """
@@ -265,11 +272,24 @@ class Waveform(PlotBase):
                 icon_name="monitoring", tooltip="Open Fit Parameters", checkable=True, parent=self
             ),
         )
+        self.toolbar.components.add_safe(
+            "scan_history",
+            MaterialIconAction(
+                icon_name="manage_search",
+                tooltip="Open Scan History browser",
+                checkable=True,
+                parent=self,
+            ),
+        )
         self.toolbar.get_bundle("axis_popup").add_action("fit_params")
+        self.toolbar.get_bundle("axis_popup").add_action("scan_history")
 
         self.toolbar.components.get_action("fit_params").action.triggered.connect(
             self.show_dap_summary_popup
         )
+        self.toolbar.components.get_action("scan_history").action.triggered.connect(
+            self.show_scan_history_popup
+        )
 
     @SafeSlot()
     def _reset_view(self):
@@ -417,6 +437,47 @@ class Waveform(PlotBase):
             self.toolbar.components.get_action("roi_linear").action.setChecked(False)
             self._roi_manager.toggle_roi(False)
 
+    ################################################################################
+    # Scan History browser popup
+    # TODO this is so far quick implementation just as popup, we should make scan history also standalone widget later
+    def show_scan_history_popup(self):
+        """
+        Show the scan history popup.
+        """
+        scan_history_action = self.toolbar.components.get_action("scan_history").action
+        if self.scan_history_dialog is None or not self.scan_history_dialog.isVisible():
+            self.scan_history_widget = ScanHistoryBrowser(parent=self)
+            self.scan_history_dialog = QDialog(modal=False)
+            self.scan_history_dialog.setWindowTitle(f"{self.object_name} - Scan History Browser")
+            self.scan_history_dialog.layout = QVBoxLayout(self.scan_history_dialog)
+            self.scan_history_dialog.layout.addWidget(self.scan_history_widget)
+            self.scan_history_widget.scan_history_device_viewer.request_history_plot.connect(
+                lambda scan_id, device_name, signal_name: self.plot(
+                    y_name=device_name, y_entry=signal_name, scan_id=scan_id
+                )
+            )
+            self.scan_history_dialog.finished.connect(self._scan_history_closed)
+            self.scan_history_dialog.show()
+            self.scan_history_dialog.resize(780, 320)
+            scan_history_action.setChecked(True)
+        else:
+            # If already open, bring it to the front
+            self.scan_history_dialog.raise_()
+            self.scan_history_dialog.activateWindow()
+            scan_history_action.setChecked(True)  # keep it toggle
+
+    def _scan_history_closed(self):
+        """
+        Slot for when the scan history dialog is closed.
+        """
+        if self.scan_history_dialog is None:
+            return
+        self.scan_history_widget.close()
+        self.scan_history_widget.deleteLater()
+        self.scan_history_dialog.deleteLater()
+        self.scan_history_dialog = None
+        self.toolbar.components.get_action("scan_history").action.setChecked(False)
+
     ################################################################################
     # Dap Summary
 
@@ -506,7 +567,11 @@ class Waveform(PlotBase):
         self.x_axis_mode["name"] = value
         if value not in ["timestamp", "index", "auto"]:
             self.x_axis_mode["entry"] = self.entry_validator.validate_signal(value, None)
+            self._current_x_device = (value, self.x_axis_mode["entry"])
         self._switch_x_axis_item(mode=value)
+        self._current_x_device = None
+        self._refresh_history_curves()
+        self._update_curve_visibility()
         self.async_signal_update.emit()
         self.sync_signal_update.emit()
         self.plot_item.enableAutoRange(x=True)
@@ -534,6 +599,8 @@ class Waveform(PlotBase):
             return
         self.x_axis_mode["entry"] = self.entry_validator.validate_signal(self.x_mode, value)
         self._switch_x_axis_item(mode="device")
+        self._refresh_history_curves()
+        self._update_curve_visibility()
         self.async_signal_update.emit()
         self.sync_signal_update.emit()
         self.plot_item.enableAutoRange(x=True)
@@ -674,6 +741,8 @@ class Waveform(PlotBase):
         color: str | None = None,
         label: str | None = None,
         dap: str | None = None,
+        scan_id: str | None = None,
+        scan_number: int | None = None,
         **kwargs,
     ) -> Curve:
         """
@@ -696,6 +765,10 @@ class Waveform(PlotBase):
             dap(str): The dap model to use for the curve, only available for sync devices.
             If not specified, none will be added.
             Use the same string as is the name of the LMFit model.
+            scan_id(str):  Optional scan ID. When provided, the curve is treated as a **history** curve and
+                the y‑data (and optional x‑data) are fetched from that historical scan. Such curves are
+                never cleared by live‑scan resets.
+            scan_number(int): Optional scan index. When provided, the curve is treated as a **history** curve and
 
         Returns:
             Curve: The curve object.
@@ -765,6 +838,8 @@ class Waveform(PlotBase):
             label=label,
             color=color,
             source=source,
+            scan_id=scan_id,
+            scan_number=scan_number,
             **kwargs,
         )
 
@@ -772,6 +847,9 @@ class Waveform(PlotBase):
         if source == "device":
             config.signal = DeviceSignal(name=y_name, entry=y_entry)
 
+        if scan_id is not None or scan_number is not None:
+            config.source = "history"
+
         # CREATE THE CURVE
         curve = self._add_curve(config=config, x_data=x_data, y_data=y_data)
 
@@ -810,7 +888,7 @@ class Waveform(PlotBase):
         device_curve = self._find_curve_by_label(device_label)
         if not device_curve:
             raise ValueError(f"No existing curve found with label '{device_label}'.")
-        if device_curve.config.source != "device":
+        if device_curve.config.source not in ("device", "history"):
             raise ValueError(
                 f"Curve '{device_label}' is not a device curve. Only device curves can have DAP."
             )
@@ -819,7 +897,7 @@ class Waveform(PlotBase):
         dev_entry = device_curve.config.signal.entry
 
         # 2) Build a label for the new DAP curve
-        dap_label = f"{dev_name}-{dev_entry}-{dap_name}"
+        dap_label = f"{device_label}-{dap_name}"
 
         # 3) Possibly raise if the DAP curve already exists
         if self._check_curve_id(dap_label):
@@ -872,7 +950,23 @@ class Waveform(PlotBase):
             ValueError: If a duplicate curve label/config is found, or if
                         custom data is missing for `source='custom'`.
         """
+        scan_item: ScanDataContainer | None = None
+        if config.source == "history":
+            scan_item = self.get_history_scan_item(
+                scan_id=config.scan_id, scan_index=config.scan_number
+            )
+            if scan_item is None:
+                raise ValueError(
+                    f"Could not find scan item for history curve '{config.label}' with scan_id='{config.scan_id}' and scan_number='{config.scan_number}'."
+                )
+
+            config.scan_id = scan_item.metadata["bec"]["scan_id"]
+            config.scan_number = scan_item.metadata["bec"]["scan_number"]
+
         label = config.label
+        if config.source == "history":
+            label = f"{config.signal.name}-{config.signal.entry}-scan-{config.scan_number}"
+            config.label = label
         if not label:
             # Fallback label
             label = WidgetContainerUtils.generate_unique_name(
@@ -894,7 +988,7 @@ class Waveform(PlotBase):
                 raise ValueError("For 'custom' curves, x_data and y_data must be provided.")
 
         # Actually create the Curve item
-        curve = self._add_curve_object(name=label, config=config)
+        curve = self._add_curve_object(name=label, config=config, scan_item=scan_item)
 
         # If custom => set initial data
         if config.source == "custom" and x_data is not None and y_data is not None:
@@ -911,6 +1005,8 @@ class Waveform(PlotBase):
             self.setup_dap_for_scan()
             self.roi_enable.emit(True)  # Enable the ROI toolbar action
             self.request_dap()  # Request DAP update directly without blocking proxy
+        if config.source == "history":
+            self._history_curves.append(curve)
 
         QTimer.singleShot(
             150, self.auto_range
@@ -918,22 +1014,182 @@ class Waveform(PlotBase):
 
         return curve
 
-    def _add_curve_object(self, name: str, config: CurveConfig) -> Curve:
+    def _add_curve_object(
+        self, name: str, config: CurveConfig, scan_item: ScanDataContainer | None = None
+    ) -> Curve | None:
         """
         Low-level creation of the PlotDataItem (Curve) from a `CurveConfig`.
 
         Args:
             name (str): The name/label of the curve.
             config (CurveConfig): Configuration model describing the curve.
+            scan_item (ScanDataContainer | None): Optional scan item for history curves.
 
         Returns:
             Curve: The newly created curve object, added to the plot.
         """
         curve = Curve(config=config, name=name, parent_item=self)
         self.plot_item.addItem(curve)
+        if scan_item is not None:
+            self._fetch_history_data_for_curve(curve, scan_item)
         self._categorise_device_curves()
+        curve.visibleChanged.connect(self._refresh_crosshair_markers)
+        curve.visibleChanged.connect(self.auto_range)
         return curve
 
+    def _fetch_history_data_for_curve(
+        self, curve: Curve, scan_item: ScanDataContainer
+    ) -> Curve | None:
+        # Check if the data are already set
+        device = curve.config.signal.name
+        entry = curve.config.signal.entry
+
+        all_devices_used = getattr(
+            getattr(scan_item, "_msg", None), "stored_data_info", None
+        ) or getattr(scan_item, "stored_data_info", None)
+        if all_devices_used is None:
+            curve.remove()
+            raise ValueError(
+                f"No stored data info found in scan item ID:{curve.config.scan_id} for curve '{curve.name()}'. "
+                f"Upgrade BEC to the latest version."
+            )
+
+        # 1. get y data
+        x_data, y_data = None, None
+        if device not in all_devices_used:
+            raise ValueError(f"Device '{device}' not found in scan item ID:{curve.config.scan_id}.")
+        if entry not in all_devices_used[device]:
+            raise ValueError(
+                f"Entry '{entry}' not found in device '{device}' in scan item ID:{curve.config.scan_id}."
+            )
+        y_shape = all_devices_used.get(device).get(entry).shape[0]
+
+        # Determine X-axis data
+        if self.x_axis_mode["name"] == "index":
+            x_data = np.arange(y_shape)
+            curve.config.current_x_mode = "index"
+            self._update_x_label_suffix(" (index)")
+        elif self.x_axis_mode["name"] == "timestamp":
+            y_device = scan_item.devices.get(device)
+            x_data = y_device.get(entry).read().get("timestamp")
+            curve.config.current_x_mode = "timestamp"
+            self._update_x_label_suffix(" (timestamp)")
+        elif self.x_axis_mode["name"] not in ("index", "timestamp", "auto"):  # Custom device mode
+            if self.x_axis_mode["name"] not in all_devices_used:
+                logger.warning(
+                    f"Custom device '{self.x_axis_mode['name']}' not found in scan item of history curve '{curve.name()}'; scan ID: {curve.config.scan_id}."
+                )
+                curve.setVisible(False)
+                return
+            x_entry_custom = self.x_axis_mode.get("entry")
+            if x_entry_custom is None:
+                x_entry_custom = self.entry_validator.validate_signal(
+                    self.x_axis_mode["name"], None
+                )
+            if x_entry_custom not in all_devices_used[self.x_axis_mode["name"]]:
+                logger.warning(
+                    f"Custom entry '{x_entry_custom}' for device '{self.x_axis_mode['name']}' not found in scan item of history curve '{curve.name()}'; scan ID: {curve.config.scan_id}."
+                )
+                curve.setVisible(False)
+                return
+            x_shape = (
+                scan_item._msg.stored_data_info.get(self.x_axis_mode["name"])
+                .get(x_entry_custom)
+                .shape[0]
+            )
+            if x_shape != y_shape:
+                logger.warning(
+                    f"Shape mismatch for x data '{x_shape}' and y data '{y_shape}' in history curve '{curve.name()}'; scan ID: {curve.config.scan_id}."
+                )
+                curve.setVisible(False)
+                return
+            x_device = scan_item.devices.get(self.x_axis_mode["name"])
+            x_data = x_device.get(x_entry_custom).read().get("value")
+            curve.config.current_x_mode = self.x_axis_mode["name"]
+            self._update_x_label_suffix(f" (custom: {self.x_axis_mode['name']}-{x_entry_custom})")
+        elif self.x_axis_mode["name"] == "auto":
+            if (
+                self._current_x_device is None
+            ):  # Scenario where no x device is set yet, because there was no live scan done in this widget yet
+                # If no current x device, use the first motor from scan item
+                scan_motors = self._ensure_str_list(
+                    scan_item.metadata.get("bec").get("scan_report_devices")
+                )
+                if not scan_motors:  # scan was done without reported motor from whatever reason
+                    x_data = np.arange(y_shape)  # Fallback to index
+                    y_data = scan_item.devices.get(device).get(entry).read().get("value")
+                    curve.set_data(x=x_data, y=y_data)
+                    self._update_x_label_suffix(" (auto: index)")
+                    return curve
+                x_entry = self.entry_validator.validate_signal(scan_motors[0], None)
+                if x_entry not in all_devices_used.get(scan_motors[0], {}):
+                    logger.warning(
+                        f"Auto x entry '{x_entry}' for device '{scan_motors[0]}' not found in scan item of history curve '{curve.name()}'; scan ID: {curve.config.scan_id}."
+                    )
+                    curve.setVisible(False)
+                    return
+                if y_shape != all_devices_used.get(scan_motors[0]).get(x_entry, {}).shape[0]:
+                    logger.warning(
+                        f"Shape mismatch for x data '{all_devices_used.get(scan_motors[0]).get(x_entry, {}).get('shape', [0])[0]}' and y data '{y_shape}' in history curve '{curve.name()}'; scan ID: {curve.config.scan_id}."
+                    )
+                    curve.setVisible(False)
+                    return
+                x_data = scan_item.devices.get(scan_motors[0]).get(x_entry).read().get("value")
+                self._current_x_device = (scan_motors[0], x_entry)
+                self._update_x_label_suffix(f" (auto: {scan_motors[0]}-{x_entry})")
+                curve.config.current_x_mode = "auto"
+                self._update_x_label_suffix(f" (auto: {scan_motors[0]}-{x_entry})")
+            else:  # Scan in auto mode was done and live scan already set the current x device
+                if self._current_x_device[0] not in all_devices_used:
+                    logger.warning(
+                        f"Auto x data for device '{self._current_x_device[0]}' "
+                        f"and entry '{self._current_x_device[1]}'"
+                        f" not found in scan item of the history curve {curve.name()}."
+                    )
+                    curve.setVisible(False)
+                    return
+                x_device = scan_item.devices.get(self._current_x_device[0])
+                x_data = x_device.get(self._current_x_device[1]).read().get("value")
+                curve.config.current_x_mode = "auto"
+                self._update_x_label_suffix(
+                    f" (auto: {self._current_x_device[0]}-{self._current_x_device[1]})"
+                )
+        if x_data is None:
+            logger.warning(
+                f"X data for curve '{curve.name()}' could not be determined. "
+                f"Check if the x_mode '{self.x_axis_mode['name']}' is valid for the scan item."
+            )
+            curve.setVisible(False)
+            return
+        if y_data is None:
+            y_data = scan_item.devices.get(device).get(entry).read().get("value")
+            if y_data is None:
+                logger.warning(
+                    f"Y data for curve '{curve.name()}' could not be determined. "
+                    f"Check if the device '{device}' and entry '{entry}' are valid for the scan item."
+                )
+                curve.setVisible(False)
+                return
+        curve.set_data(x=x_data, y=y_data)
+        return curve
+
+    def _refresh_history_curves(self):
+        for curve in self._history_curves:
+            scan_item = self.get_history_scan_item(
+                scan_id=curve.config.scan_id, scan_index=curve.config.scan_number
+            )
+            if scan_item is not None:
+                self._fetch_history_data_for_curve(curve, scan_item)
+            else:
+                logger.warning(f"Scan item for curve {curve.name()} not found.")
+
+    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.
@@ -961,7 +1217,42 @@ class Waveform(PlotBase):
         Clear all data from the plot widget, but keep the curve references.
         """
         for c in self.curves:
-            c.clear_data()
+            if c.config.source != "history":
+                c.clear_data()
+
+    # X-axis compatibility helpers
+    def _is_curve_compatible(self, curve: Curve) -> bool:
+        """
+        Return True when *curve* can be shown with the current x-axis mode.
+
+        - ‘index’, ‘timestamp’ are always compatible.
+        - For history curves we check whether the requested motor
+          (self.x_axis_mode["name"]) exists in the cached
+          history_data_buffer["x"] dictionary.
+        - DAP is done by checking if the parent curve is visible.
+        - Device curves are fetched by update sync/async curves, which solves the compatibility there.
+        """
+        mode = self.x_axis_mode.get("name", "index")
+        if mode in ("index", "timestamp"):  # always compatible - wild west mode
+            return True
+        if curve.config.source == "history":
+            scan_item = self.get_history_scan_item(
+                scan_id=curve.config.scan_id, scan_index=curve.config.scan_number
+            )
+            curve = self._fetch_history_data_for_curve(curve, scan_item)
+            if curve is None:
+                return False
+        if curve.config.source == "dap":
+            parent_curve = self._find_curve_by_label(curve.config.parent_label)
+            if parent_curve.isVisible():
+                return True
+            return False  # DAP curve is not compatible if parent curve is not visible
+        return True
+
+    def _update_curve_visibility(self) -> None:
+        """Show or hide curves according to `_is_curve_compatible`."""
+        for c in self.curves:
+            c.setVisible(self._is_curve_compatible(c))
 
     def clear_all(self):
         """
@@ -1118,12 +1409,13 @@ class Waveform(PlotBase):
             self.reset()
             self.new_scan.emit()
             self.new_scan_id.emit(current_scan_id)
-            self.auto_range(True)
+            self.auto_range_x = True
+            self.auto_range_y = True
             self.old_scan_id = self.scan_id
             self.scan_id = current_scan_id
             self.scan_item = self.queue.scan_storage.find_scan_by_ID(self.scan_id)  # live scan
             self._slice_index = None  # Reset the slice index
-
+            self._update_curve_visibility()
             self._mode = self._categorise_device_curves()
 
             # First trigger to sync and async data
@@ -1201,7 +1493,7 @@ class Waveform(PlotBase):
                 device_data = entry_obj.read()["value"] if entry_obj else None
             x_data = self._get_x_data(device_name, device_entry)
             if x_data is not None:
-                if len(x_data) == 1:
+                if np.isscalar(x_data):
                     self.clear_data()
                     return
             if device_data is not None and x_data is not None:
@@ -1609,6 +1901,7 @@ class Waveform(PlotBase):
                 entry_obj = data.get(x_name, {}).get(x_entry)
                 x_data = entry_obj.read()["value"] if entry_obj else [0]
             new_suffix = f" (custom: {x_name}-{x_entry})"
+            self._current_x_device = (x_name, x_entry)
 
         # 2 User wants timestamp
         if self.x_axis_mode["name"] == "timestamp":
@@ -1623,11 +1916,13 @@ class Waveform(PlotBase):
                 timestamps = entry_obj.read()["timestamp"] if entry_obj else [0]
             x_data = timestamps
             new_suffix = " (timestamp)"
+            self._current_x_device = None
 
         # 3 User wants index
         if self.x_axis_mode["name"] == "index":
             x_data = None
             new_suffix = " (index)"
+            self._current_x_device = None
 
         # 4 Best effort automatic mode
         if self.x_axis_mode["name"] is None or self.x_axis_mode["name"] == "auto":
@@ -1635,6 +1930,7 @@ class Waveform(PlotBase):
             if len(self._async_curves) > 0:
                 x_data = None
                 new_suffix = " (auto: index)"
+                self._current_x_device = None
             # 4.2 If there are sync curves, use the first device from the scan report
             else:
                 try:
@@ -1657,6 +1953,7 @@ class Waveform(PlotBase):
                         entry_obj = data.get(x_name, {}).get(x_entry)
                         x_data = entry_obj.read()["value"] if entry_obj else None
                     new_suffix = f" (auto: {x_name}-{x_entry})"
+                self._current_x_device = (x_name, x_entry)
         self._update_x_label_suffix(new_suffix)
         return x_data
 
@@ -1759,49 +2056,83 @@ class Waveform(PlotBase):
         logger.info(f"Scan {self.scan_id} => mode={self._mode}")
         return mode
 
-    @SafeSlot(int)
-    @SafeSlot(str)
-    @SafeSlot()
-    def update_with_scan_history(self, scan_index: int = None, scan_id: str = None):
+    def get_history_scan_item(
+        self, scan_index: int = None, scan_id: str = None
+    ) -> ScanDataContainer | None:
         """
-        Update the scan curves with the data from the scan storage.
-        Provide only one of scan_id or scan_index.
+        Get scan item from history based on scan_id or scan_index.
+        If both are provided, scan_id takes precedence and the resolved scan_number
+        will be read from the fetched item.
 
         Args:
-            scan_id(str, optional): ScanID of the scan to be updated. Defaults to None.
-            scan_index(int, optional): Index of the scan to be updated. Defaults to None.
+            scan_id (str, optional): ScanID of the scan to fetch. Defaults to None.
+            scan_index (int, optional): Index (scan number) of the scan to fetch. Defaults to None.
+
+        Returns:
+            ScanDataContainer | None: The fetched scan item or None if no item was found.
         """
         if scan_index is not None and scan_id is not None:
-            raise ValueError("Only one of scan_id or scan_index can be provided.")
+            scan_index = None  # Prefer scan_id when both are given
 
         if scan_index is None and scan_id is None:
-            logger.warning(f"Neither scan_id or scan_number was provided, fetching the latest scan")
+            logger.warning("Neither scan_id or scan_number was provided, fetching the latest scan")
             scan_index = -1
 
         if scan_index is None:
-            self.scan_id = scan_id
-            self.scan_item = self.client.history.get_by_scan_id(scan_id)
-            self._emit_signal_update()
-            return
+            return self.client.history.get_by_scan_id(scan_id)
 
         if scan_index == -1:
             scan_item = self.client.queue.scan_storage.current_scan
             if scan_item is not None:
                 if scan_item.status_message is None:
                     logger.warning(f"Scan item with {scan_item.scan_id} has no status message.")
-                    return
-                self.scan_item = scan_item
-                self.scan_id = scan_item.scan_id
-                self._emit_signal_update()
-                return
+                    return None
+                return scan_item
 
         if len(self.client.history) == 0:
-            logger.info("No scans executed so far. Skipping scan history update.")
+            logger.info("No scans executed so far. Cannot fetch scan history.")
+            return None
+
+        # check if scan_index is negative, then fetch it just from the list from the end
+        if int(scan_index) < 0:
+            return self.client.history[scan_index]
+        scan_item = self.client.history.get_by_scan_number(scan_index)
+        if scan_item is None:
+            logger.warning(f"Scan with scan_number {scan_index} not found in history.")
+            return None
+        if isinstance(scan_item, list):
+            if len(scan_item) > 1:
+                logger.warning(
+                    f"Multiple scans found with scan_number {scan_index}. Returning the latest one."
+                )
+            scan_item = scan_item[-1]
+        return scan_item
+
+    @SafeSlot(int)
+    @SafeSlot(str)
+    @SafeSlot()
+    def update_with_scan_history(self, scan_index: int = None, scan_id: str = None):
+        """
+        Update the scan curves with the data from the scan storage.
+        If both arguments are provided, scan_id takes precedence and scan_index is ignored.
+
+        Args:
+            scan_id(str, optional): ScanID of the scan to be updated. Defaults to None.
+            scan_index(int, optional): Index (scan number) of the scan to be updated. Defaults to None.
+        """
+        self.scan_item = self.get_history_scan_item(scan_index=scan_index, scan_id=scan_id)
+
+        if self.scan_item is None:
             return
 
-        self.scan_item = self.client.history[scan_index]
-        metadata = self.scan_item.metadata
-        self.scan_id = metadata["bec"]["scan_id"]
+        if scan_id is not None:
+            self.scan_id = scan_id
+        else:
+            # If scan_number was used, set the scan_id from the fetched item
+            if hasattr(self.scan_item, "metadata"):
+                self.scan_id = self.scan_item.metadata["bec"]["scan_id"]
+            else:
+                self.scan_id = self.scan_item.scan_id
 
         self._emit_signal_update()
 
@@ -2032,6 +2363,9 @@ class Waveform(PlotBase):
         if self.dap_summary_dialog is not None:
             self.dap_summary_dialog.reject()
             self.dap_summary_dialog = None
+        if self.scan_history_dialog is not None:
+            self.scan_history_dialog.reject()
+            self.scan_history_dialog = None
         super().cleanup()
 
 

bec_widgets/widgets/progress/ring_progress_bar/ring.py

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

bec_widgets/widgets/progress/ring_progress_bar/ring_progress_bar.py

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

bec_widgets/widgets/services/bec_queue/bec_queue.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from bec_lib.endpoints import MessageEndpoints
 from bec_qthemes import material_icon
 from qtpy.QtCore import Property, Qt, Signal, Slot
-from qtpy.QtGui import QColor
+from qtpy.QtGui import QColor, QIcon
 from qtpy.QtWidgets import QHeaderView, QLabel, QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget
 
 from bec_widgets.utils.bec_connector import ConnectionConfig
@@ -240,7 +240,7 @@ class BECQueue(BECWidget, CompactPopupWidget):
 
         abort_button.button.setText("")
         abort_button.button.setIcon(
-            material_icon("cancel", color="#cc181e", filled=True, convert_to_pixmap=False)
+            material_icon("cancel", color="#cc181e", filled=True, icon_type=QIcon)
         )
         abort_button.setStyleSheet(
             """

bec_widgets/widgets/services/device_browser/device_browser.py

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

bec_widgets/widgets/services/device_browser/device_browser.ui

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

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

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

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

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

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

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

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

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