2.30.6

Automatically generated by python-semantic-release

.github/workflows/child_repos.yml

@@ -0,0 +1,64 @@
+name: Run Pytest with Coverage
+on: 
+  workflow_call:
+    inputs:
+      BEC_CORE_BRANCH:
+        description: 'Branch for BEC Core'
+        required: false
+        default: 'main'
+        type: string
+      OPHYD_DEVICES_BRANCH:
+        description: 'Branch for Ophyd Devices'
+        required: false
+        default: 'main'
+        type: string
+      BEC_WIDGETS_BRANCH:
+        description: 'Branch for BEC Widgets'
+        required: false
+        default: 'main'
+        type: string
+
+
+jobs:
+  bec:
+    name: BEC Unit Tests
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash -el {0}
+
+    steps:
+      - name: Checkout BEC
+        uses: actions/checkout@v4
+        with:
+          repository: bec-project/bec
+          ref: ${{ inputs.BEC_CORE_BRANCH }}
+
+      - name: Install BEC and dependencies
+        uses: ./.github/actions/bec_install
+        with:
+          BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH }}
+          OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH }}
+          PYTHON_VERSION: '3.11'
+      - name: Run Pytest
+        run: |
+          cd ./bec
+          pip install pytest pytest-random-order
+          pytest -v --maxfail=2 --junitxml=report.xml --random-order ./bec_server/tests ./bec_ipython_client/tests/client_tests ./bec_lib/tests
+  bec-e2e-test:
+    name: BEC End2End Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout BEC
+        uses: actions/checkout@v4
+        with:
+          repository: bec-project/bec
+          ref: ${{ inputs.BEC_CORE_BRANCH }}
+
+      - name: Run E2E Tests
+        uses: ./.github/actions/bec_e2e_install
+        with:
+          BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH }}
+          OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH }}
+          BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH }}
+          PYTHON_VERSION: '3.11'

.github/workflows/ci.yml

@@ -57,4 +57,24 @@ jobs:
   end2end-test:
     needs: [check_pr_status, formatter]
     if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/end2end-conda.yml
+    uses: ./.github/workflows/end2end-conda.yml
+
+  child-repos:
+    needs: [check_pr_status, formatter]
+    if: needs.check_pr_status.outputs.branch-pr == ''
+    uses: ./.github/workflows/child_repos.yml
+    with:
+      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
+      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main'}} 
+      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
+  
+  plugin_repos:
+    needs: [check_pr_status, formatter]
+    if: needs.check_pr_status.outputs.branch-pr == ''
+    uses: bec-project/bec/.github/workflows/plugin_repos.yml@main
+    with:
+      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
+      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
+
+    secrets:
+      GH_READ_TOKEN: ${{ secrets.GH_READ_TOKEN }}

.github/workflows/end2end-conda.yml

@@ -12,6 +12,7 @@ jobs:
       CHILD_PIPELINE_BRANCH: main  # Set the branch you want for ophyd_devices
       BEC_CORE_BRANCH: main        # Set the branch you want for bec
       OPHYD_DEVICES_BRANCH: main   # Set the branch you want for ophyd_devices
+      PLUGIN_REPO_BRANCH: main     # Set the branch you want for the plugin repo
       PROJECT_PATH: ${{ github.repository }}
       QTWEBENGINE_DISABLE_SANDBOX: 1
       QT_QPA_PLATFORM: "offscreen"
@@ -39,10 +40,19 @@ jobs:
           echo -e "\033[35;1m Using branch $OPHYD_DEVICES_BRANCH of OPHYD_DEVICES \033[0;m";
           git clone --branch $OPHYD_DEVICES_BRANCH https://github.com/bec-project/ophyd_devices.git
           export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+          echo -e "\033[35;1m Using branch $PLUGIN_REPO_BRANCH of bec_testing_plugin \033[0;m";
+          git clone --branch $PLUGIN_REPO_BRANCH https://github.com/bec-project/bec_testing_plugin.git
           cd ./bec
           conda create -q -n test-environment python=3.11
           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
+          pip install -e ./ophyd_devices -e .[dev,pyside6] -e ./bec_testing_plugin
+          pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end
+
+      - name: Upload logs if job fails
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: pytest-logs
+          path: ./logs/*.log
+          retention-days: 7

.github/workflows/formatter.yml

@@ -14,10 +14,15 @@ jobs:
 
       - name: Run black and isort
         run: |
-          pip install black isort
-          pip install -e .[dev]
+          pip install uv
+          uv pip install --system black isort
+          uv pip install --system -e .[dev]
           black --check --diff --color .
           isort --check --diff ./
+      
+      - name: Check for disallowed imports from PySide
+        run: '! grep -re "from PySide6\." bec_widgets/ tests/ | grep  -v -e "PySide6.QtDesigner" -e "PySide6.scripts"'
+
   Pylint:
     runs-on: ubuntu-latest
 

.github/workflows/pytest-matrix.yml

@@ -56,4 +56,4 @@ jobs:
       - name: Run Pytest
         run: |
           pip install pytest pytest-random-order
-          pytest -v --maxfail=2 --junitxml=report.xml --random-order ./tests/unit_tests
+          pytest -v --junitxml=report.xml --random-order ./tests/unit_tests

.github/workflows/stale-issues.yml

@@ -0,0 +1,15 @@
+name: 'Close stale issues and PRs'
+on:
+  schedule:
+    - cron: '00 10 * * *'
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v9
+        with:
+          stale-issue-message: 'This issue is stale because it has been open 60 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
+          stale-pr-message: 'This PR is stale because it has been open 60 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
+          days-before-stale: 60
+          days-before-close: 7

CHANGELOG.md

@@ -1,6 +1,972 @@
 # CHANGELOG
 
 
+## v2.30.6 (2025-07-26)
+
+### Bug Fixes
+
+- **waveform**: Autorange is applied with 150ms delay after curve is added
+  ([`61e5bde`](https://github.com/bec-project/bec_widgets/commit/61e5bde15f0e1ebe185ddbe81cd71ad581ae6009))
+
+
+## v2.30.5 (2025-07-25)
+
+### Bug Fixes
+
+- **positioner-box**: Test to fix handling of none integer values for precision
+  ([`b718b43`](https://github.com/bec-project/bec_widgets/commit/b718b438bacff6eb6cd6015f1a67dcf75c05dce4))
+
+### Refactoring
+
+- **positioner-box**: Cleanup, accept float precision
+  ([`4d5df96`](https://github.com/bec-project/bec_widgets/commit/4d5df9608a9438b9f6d7508c323eb3772e53f37d))
+
+
+## v2.30.4 (2025-07-25)
+
+### Bug Fixes
+
+- **cli**: Remove stderr from cli output when not using rpc
+  ([`b4e0664`](https://github.com/bec-project/bec_widgets/commit/b4e0664011682cae9966aa2632210a6b60e11714))
+
+
+## v2.30.3 (2025-07-23)
+
+### Bug Fixes
+
+- Cleanup subscriptions in device browser
+  ([`0d81bdd`](https://github.com/bec-project/bec_widgets/commit/0d81bdd4ddb4ec474a414b107cbc7fc865253934))
+
+
+## v2.30.2 (2025-07-23)
+
+### Bug Fixes
+
+- Factor out device name function and add test
+  ([`8eb8225`](https://github.com/bec-project/bec_widgets/commit/8eb8225a7f56014d6093aa142b3a5d071837982e))
+
+- **rpc_base**: Rpc_call wrapper passes full_name for Devices indeed of name
+  ([`491d044`](https://github.com/bec-project/bec_widgets/commit/491d04467c8ce4e116d61e614895d1dcc6b4b201))
+
+### Testing
+
+- **test_plotting_framework_e2e**: Added test for waveform with passing device from dev container
+  ([`3fd09fc`](https://github.com/bec-project/bec_widgets/commit/3fd09fceef2ffa7e7c3eee20176304bafb00d0db))
+
+
+## v2.30.1 (2025-07-22)
+
+### Bug Fixes
+
+- Ignore KeyError in SignalLabel
+  ([`608590c`](https://github.com/bec-project/bec_widgets/commit/608590c5421368d5bba0e4b0f5187d90cac323be))
+
+
+## v2.30.0 (2025-07-22)
+
+### Bug Fixes
+
+- **device_browser**: Display signal for signals
+  ([`3384ca0`](https://github.com/bec-project/bec_widgets/commit/3384ca02bdb5a2798ad3339ecf3e2ba7c121e28f))
+
+- **device_signal_display**: Don't read omitted
+  ([`b9af36a`](https://github.com/bec-project/bec_widgets/commit/b9af36a4f1c91e910d4fc738b17b90e92287a7e3))
+
+- **signal_label**: Rewrite reading selection logic
+  ([`cd17a4a`](https://github.com/bec-project/bec_widgets/commit/cd17a4aad905296eb0460ecc27e5920f5c2e8fe5))
+
+- **signal_label**: Show all signals by default
+  ([`22beadc`](https://github.com/bec-project/bec_widgets/commit/22beadcad061b328c986414f30fef57b64bad693))
+
+- **signal_label**: Update signal from dialog correctly
+  ([`959cedb`](https://github.com/bec-project/bec_widgets/commit/959cedbbd5a123eef5f3370287bf6476c48caab9))
+
+- **signal_label**: Use read() instead of get() for init
+  ([`f0dc992`](https://github.com/bec-project/bec_widgets/commit/f0dc99258607a5cc8af51686d01f7fd54ae2779f))
+
+### Chores
+
+- Update client.py
+  ([`fd1f994`](https://github.com/bec-project/bec_widgets/commit/fd1f9941e046b7ae1e247dde39c20bcbc37ac189))
+
+### Features
+
+- **signal_label**: Property to display array data or not
+  ([`ca4f975`](https://github.com/bec-project/bec_widgets/commit/ca4f97503bf06363e8e8a5d494a9857223da4104))
+
+
+## v2.29.0 (2025-07-22)
+
+### Features
+
+- **notification_banner**: Notification centre for alarms implemented into BECMainWindow
+  ([`cd9d22d`](https://github.com/bec-project/bec_widgets/commit/cd9d22d0b40d633af76cb1188b57feb7b6a5dbf2))
+
+### Refactoring
+
+- **notification_banner**: Becnotificationbroker done as singleton to sync all windows in the
+  session
+  ([`7cda2ed`](https://github.com/bec-project/bec_widgets/commit/7cda2ed846d3c27799f4f15f6c5c667631b1ca55))
+
+
+## v2.28.0 (2025-07-21)
+
+### Features
+
+- Disable editing while scan active
+  ([`1397655`](https://github.com/bec-project/bec_widgets/commit/13976557fbdb71a1161029521d81a655d25dd134))
+
+- Remove and readd device for config changes
+  ([`8489ef4`](https://github.com/bec-project/bec_widgets/commit/8489ef4a69d69b39648b1a9270012f14f95c6121))
+
+- Save and load config from devicebrowser
+  ([`7f0098f`](https://github.com/bec-project/bec_widgets/commit/7f0098f1533d419cc75801c4d6cbea485c7bbf94))
+
+
+## v2.27.1 (2025-07-17)
+
+### Bug Fixes
+
+- **image_roi_tree**: Rois signals are disconnected when roi tree widget is closed
+  ([`00e3713`](https://github.com/bec-project/bec_widgets/commit/00e3713181916a432e4e9dec8a0d80205914cf77))
+
+
+## v2.27.0 (2025-07-17)
+
+### Features
+
+- Add monaco editor
+  ([`2373c7e`](https://github.com/bec-project/bec_widgets/commit/2373c7e996566a5b84c5a50e1c3e69de885713db))
+
+
+## v2.26.0 (2025-07-17)
+
+### Bug Fixes
+
+- **config label**: Reset offset when toggling the label action
+  ([`b8ae7b2`](https://github.com/bec-project/bec_widgets/commit/b8ae7b2e96071b6dc59dae7ffa72bbedc6aaea23))
+
+- **performance_bundle**: Fix performance bundle cleanup
+  ([`23674cc`](https://github.com/bec-project/bec_widgets/commit/23674ccf592a2caa0b57ae64ad1499c270b7d469))
+
+### Features
+
+- **device combobox**: Add option to insert an empty element
+  ([`debd347`](https://github.com/bec-project/bec_widgets/commit/debd347b64a3d2ca07ddcd5ef3a3394d1ffb67e3))
+
+- **heatmap**: Add interpolation and oversampling UI components
+  ([`1d8069e`](https://github.com/bec-project/bec_widgets/commit/1d8069e391412e3096a3c1e7181398dd4e609650))
+
+### Refactoring
+
+- **image_base**: Cleanup
+  ([`46a9178`](https://github.com/bec-project/bec_widgets/commit/46a91784d237137128965ad585e38085e931e5d4))
+
+### Testing
+
+- **history**: Add history message helper methods to conftest
+  ([`44cc061`](https://github.com/bec-project/bec_widgets/commit/44cc06137ccfbc087bdd3005156ff28effe05f23))
+
+
+## v2.25.0 (2025-07-17)
+
+### Bug Fixes
+
+- **bec-progressbar**: Add flag for theme update
+  ([`694a6c4`](https://github.com/bec-project/bec_widgets/commit/694a6c49608b68e25dc0c76b58855b96f3f0ef0b))
+
+### Continuous Integration
+
+- **bec**: Add child_repos test for bec (unit and e2e tests)
+  ([`a9c8995`](https://github.com/bec-project/bec_widgets/commit/a9c8995ac0b39f6bc327887f43f7d4d6e6e89db2))
+
+- **plugin**: Add plugin repository test to BW ci
+  ([`2b06e34`](https://github.com/bec-project/bec_widgets/commit/2b06e34ecff8c0a92a2b235f375e837729736b2a))
+
+### Features
+
+- **scan-history-browser**: Add history browser and history metadata viewer
+  ([`9caae4c`](https://github.com/bec-project/bec_widgets/commit/9caae4cf40d3876175b827abb735ae227ae0bcea))
+
+### Refactoring
+
+- Add additional components for history metadata, device view and popup ui
+  ([`cf97cc1`](https://github.com/bec-project/bec_widgets/commit/cf97cc1805e16073c7849d1f9375e2ebd2176b70))
+
+- Cleanup, add compact popup view for scan_history_browser and update tests
+  ([`25b2737`](https://github.com/bec-project/bec_widgets/commit/25b2737aacfaa45f255afb6ebf467d5781165a8e))
+
+
+## v2.24.1 (2025-07-15)
+
+### Bug Fixes
+
+- Update signal label for device_edit changes
+  ([`bde5238`](https://github.com/bec-project/bec_widgets/commit/bde523806fdb6ab224b485f65b615f89dfe20b7b))
+
+
+## v2.24.0 (2025-07-15)
+
+### Bug Fixes
+
+- Hide validity LED, show message as tooltip
+  ([`530797a`](https://github.com/bec-project/bec_widgets/commit/530797a5568957dde9f47f417310f5c4d2493906))
+
+- Validate some config data
+  ([`c660e51`](https://github.com/bec-project/bec_widgets/commit/c660e5141f191a782c224ee1b83536793639eecb))
+
+- **device_browser**: Un-nest exception
+  ([`8b2d605`](https://github.com/bec-project/bec_widgets/commit/8b2d6052e808f8b4063e5f45c40e4460524f044e))
+
+### Documentation
+
+- Docstring for config dialog
+  ([`1925e6a`](https://github.com/bec-project/bec_widgets/commit/1925e6ac7f98875eb5980637ae3293e22b459e28))
+
+### Features
+
+- (#495) add devices through browser
+  ([`170be0c`](https://github.com/bec-project/bec_widgets/commit/170be0c7d3bb1f6e5f2305958909ef68cd987fbd))
+
+- **#495**: Add validation against existing device names
+  ([`900153b`](https://github.com/bec-project/bec_widgets/commit/900153bc0b8cec7bad82e23b3772c66e84900a17))
+
+- **device_browser**: Connect update to item refresh
+  ([`130cc24`](https://github.com/bec-project/bec_widgets/commit/130cc24b351684358558ab81c0111f10f9abb11f))
+
+- **device_browser**: Device deletion from config
+  ([`8dc7265`](https://github.com/bec-project/bec_widgets/commit/8dc72656ef46ae7be886f9da59beb768f5381b4f))
+
+
+## v2.23.0 (2025-07-11)
+
+### Features
+
+- **widget_finder**: Widget to fetch any other widget by class from currently running app
+  ([`a9fce17`](https://github.com/bec-project/bec_widgets/commit/a9fce175b720ad85a5cefcab99d79fbcb971ff4a))
+
+- **widget_io**: Utility function to find widget in the app by class
+  ([`783d042`](https://github.com/bec-project/bec_widgets/commit/783d042e8c469774fc8407921462a99c96f6d408))
+
+
+## v2.22.2 (2025-07-11)
+
+### Bug Fixes
+
+- **plot_base**: Autorange takes into account only visible curves
+  ([`7643986`](https://github.com/bec-project/bec_widgets/commit/76439866c1fd09cb7d9d48dfccdc7b1943bfbc0f))
+
+
+## v2.22.1 (2025-07-11)
+
+### Bug Fixes
+
+- **crosshair**: Crosshair mouse_moved can be set manually
+  ([`63a8da6`](https://github.com/bec-project/bec_widgets/commit/63a8da680d263a50102aacf463ec6f6252562f9d))
+
+- **heatmap**: Fix pixel size calculation for arbitrary shapes
+  ([`6c49425`](https://github.com/bec-project/bec_widgets/commit/6c494258f82059a2472f43bb8287390ce1aba704))
+
+
+## v2.22.0 (2025-07-10)
+
+### Bug Fixes
+
+- **crosshair**: Add slot to reset mouse markers
+  ([`adaad4f`](https://github.com/bec-project/bec_widgets/commit/adaad4f4d5ebf775a337e23a944ba9eb289d01a0))
+
+- **crosshair**: Fix crosshair support for transformations
+  ([`3ba0fc4`](https://github.com/bec-project/bec_widgets/commit/3ba0fc4b442e5926f27a13f09d628c30987f2cf8))
+
+- **image**: Reset crosshair on new scan
+  ([`e594de3`](https://github.com/bec-project/bec_widgets/commit/e594de3ca39970f91f5842693eeb1fac393eaa34))
+
+- **image item**: Fix processor for nans in images
+  ([`39c316d`](https://github.com/bec-project/bec_widgets/commit/39c316d6eadfdfbd483661b67720a7e224a46712))
+
+- **image_base**: Move cbar init to image base
+  ([`8929778`](https://github.com/bec-project/bec_widgets/commit/8929778f073c40a9eabba7eda2415fc9af1072bb))
+
+- **image_processor**: Support for nans in nd arrays
+  ([`a6fc799`](https://github.com/bec-project/bec_widgets/commit/a6fc7993a3d22cfd086310c8e6dad3f9f3d1e9fe))
+
+### Features
+
+- Add heatmap widget
+  ([`0c76b0c`](https://github.com/bec-project/bec_widgets/commit/0c76b0c49598d1456aab266b483de327788028fd))
+
+- **image_item**: Add support for qtransform
+  ([`324a5bd`](https://github.com/bec-project/bec_widgets/commit/324a5bd3d9ed278495c6ba62453b02061900ae32))
+
+
+## v2.21.4 (2025-07-08)
+
+### Bug Fixes
+
+- **image_roi_tree**: Changing color dialog from ColorButtonNative is open once
+  ([`244bca4`](https://github.com/bec-project/bec_widgets/commit/244bca4e1ec7c00109534b9f503ff2eb125c1ffe))
+
+
+## v2.21.3 (2025-07-03)
+
+### Bug Fixes
+
+- **connector**: Remove safeslot for now
+  ([`25f28c4`](https://github.com/bec-project/bec_widgets/commit/25f28c47e32af1be7778803dc27d8c2a367172ed))
+
+### Refactoring
+
+- **toolbar**: Split toolbar into components, bundles and connections
+  ([`db720e8`](https://github.com/bec-project/bec_widgets/commit/db720e8fa46bb2fb10c73afa1b4f039cd256d68b))
+
+
+## v2.21.2 (2025-06-30)
+
+### Bug Fixes
+
+- **waveform**: Fix waveform categorisation for aborted scans
+  ([`09c5a44`](https://github.com/bec-project/bec_widgets/commit/09c5a443aac675f02fa1e38179deb9863af152e2))
+
+### Testing
+
+- Assert config for equality, not identity
+  ([`3f5ab14`](https://github.com/bec-project/bec_widgets/commit/3f5ab142a3cb5446261c4faebdc7b13f10ef4a80))
+
+
+## v2.21.1 (2025-06-29)
+
+### Bug Fixes
+
+- **sbb monitor**: Add missing pyproject file
+  ([`371bc48`](https://github.com/bec-project/bec_widgets/commit/371bc485d060404433082c9e3e00780961ce6ae3))
+
+
+## v2.21.0 (2025-06-28)
+
+### Features
+
+- **sbb monitor**: Add sbb monitor widget
+  ([`3d59c25`](https://github.com/bec-project/bec_widgets/commit/3d59c25aa93590a62ab4d31a4ab08589402bf407))
+
+
+## v2.20.1 (2025-06-28)
+
+### Bug Fixes
+
+- **signal input base**: Unregister callback to avoid accessing deleted qt objects
+  ([`7ba8863`](https://github.com/bec-project/bec_widgets/commit/7ba8863d6a0c21f772e4ef8a5d4180c2a7ab49cb))
+
+
+## v2.20.0 (2025-06-26)
+
+### Bug Fixes
+
+- **curve_settings**: Larger minimalWidth for the x device combobox selection
+  ([`48a0e58`](https://github.com/bec-project/bec_widgets/commit/48a0e5831feccd30f24218821bbc9d73f8c47933))
+
+### Features
+
+- **waveform**: Move x axis selection to a combobox
+  ([`d10328c`](https://github.com/bec-project/bec_widgets/commit/d10328cb5c775a9b7b40ed4e9f2889e63eb039ff))
+
+### Refactoring
+
+- **curve settings**: Move signal logic to SignalCombobox
+  ([`e841468`](https://github.com/bec-project/bec_widgets/commit/e84146889210165de1c4e63eb20b39f30cc5c623))
+
+### Testing
+
+- **curve settings**: Add curve tree elements to the dialog test
+  ([`1e9dd4c`](https://github.com/bec-project/bec_widgets/commit/1e9dd4cd2561d37bdda1cd86b511295c259b2831))
+
+
+## v2.19.4 (2025-06-26)
+
+### Bug Fixes
+
+- **curve tree**: Remove manual interception of the close event; call parent cleanup
+  ([`bc3085a`](https://github.com/bec-project/bec_widgets/commit/bc3085ab8cb6688da358df4a7c07fc213a99f2df))
+
+- **waveform**: Curve tree elements must clean up signal combobox
+  ([`9cba696`](https://github.com/bec-project/bec_widgets/commit/9cba696afd3300a76678dfdc4226604696cc3696))
+
+
+## v2.19.3 (2025-06-25)
+
+### Bug Fixes
+
+- **scan_control**: Safeguard against empty history; reversed history to fetch the newest scan
+  ([`29a26b1`](https://github.com/bec-project/bec_widgets/commit/29a26b19f9ab829b0d877c3233613a0936db0a12))
+
+
+## v2.19.2 (2025-06-23)
+
+### Bug Fixes
+
+- **scan_control**: Scan parameters fetched from the scan_history, fix #707
+  ([`4456297`](https://github.com/bec-project/bec_widgets/commit/4456297beb940b147882f96caee6fb19aaf93c73))
+
+### Build System
+
+- Bec_lib 3.44 required
+  ([`9f3dcc3`](https://github.com/bec-project/bec_widgets/commit/9f3dcc3ab30a2c238ffffa8d594735ccaf6f1ca4))
+
+### Refactoring
+
+- **scan_control**: Request_last_executed_scan_parameters logic adjusted
+  ([`57f75bd`](https://github.com/bec-project/bec_widgets/commit/57f75bd4d506ca4d8dc982f3051d0d4c29b0d41c))
+
+
+## v2.19.1 (2025-06-23)
+
+### Bug Fixes
+
+- **launch_window**: Number of remaining connections extended to 4
+  ([`7484f51`](https://github.com/bec-project/bec_widgets/commit/7484f5160c8c6d632fd27996035ff6c0dda2e657))
+
+
+## v2.19.0 (2025-06-23)
+
+### Bug Fixes
+
+- **ci**: Extend check for pyside import to tests
+  ([`d5a40da`](https://github.com/bec-project/bec_widgets/commit/d5a40dabc74753acad05e3eb6b121499fc1e03d7))
+
+### Features
+
+- (#494) add signal display to device browser
+  ([`f3da6e9`](https://github.com/bec-project/bec_widgets/commit/f3da6e959e0416827ee5d02e34e6ad0ecfc8e5e7))
+
+- (#494) add tabbed layout for device item
+  ([`3378051`](https://github.com/bec-project/bec_widgets/commit/337805125098c3e028a17b74ef6d9ae4b9ba3d6d))
+
+- (#494) display device signals
+  ([`3a10341`](https://github.com/bec-project/bec_widgets/commit/3a103410e7448256a56b59bb3276fee056ec42a0))
+
+
+## v2.18.0 (2025-06-22)
+
+### Bug Fixes
+
+- Make settings dialog resizable
+  ([`5a564a5`](https://github.com/bec-project/bec_widgets/commit/5a564a5f3f3229e6407ea52a59d3e63319dc214a))
+
+- **curve settings**: Add initial size hint
+  ([`a9708f6`](https://github.com/bec-project/bec_widgets/commit/a9708f6d8f15c42b142488da1e392a8f3179932a))
+
+### Features
+
+- **curve settings**: Add combobox selection for device and signal
+  ([`eea5f7e`](https://github.com/bec-project/bec_widgets/commit/eea5f7ebbd2b477b3ed19c7efcc76390dd391f26))
+
+- **device combobox**: Emit reset event if validation fails
+  ([`4c2c0c5`](https://github.com/bec-project/bec_widgets/commit/4c2c0c5525d593d8ec7fd554336cb11adbe32de2))
+
+- **FilterIO**: Add support for item data
+  ([`8e8acd6`](https://github.com/bec-project/bec_widgets/commit/8e8acd672c0deb8dcd928886fb574452ac956de7))
+
+- **signal combobox**: Add reset_selection slot
+  ([`b51de1a`](https://github.com/bec-project/bec_widgets/commit/b51de1a00e4b17c44cab23e5097391c6fa8ea0e2))
+
+### Refactoring
+
+- **device input**: Refactor to SafeProperty and SafeSlot
+  ([`6e2f2ce`](https://github.com/bec-project/bec_widgets/commit/6e2f2cea91ba3af33e9891532506f4b0b65b90c8))
+
+
+## v2.17.0 (2025-06-22)
+
+### Bug Fixes
+
+- **bec_progressbar**: Layout and sizing adjustments
+  ([`b02c870`](https://github.com/bec-project/bec_widgets/commit/b02c870dbfecb4bc6921ec4c915dac0e67beb9b4))
+
+- **launch_window**: Number of remaining connections increase to 2 to include the ScanProgressBar
+  ([`3bbb8da`](https://github.com/bec-project/bec_widgets/commit/3bbb8daa24348613f62bde667a446d37dcec8fb0))
+
+- **main_window**: Labels and sizing of scan progress adopted
+  ([`aca6efb`](https://github.com/bec-project/bec_widgets/commit/aca6efb567528eb3c68521a59b4f9903a5616c6f))
+
+- **scan_progressbar**: Cleanup adjusted
+  ([`e8ae972`](https://github.com/bec-project/bec_widgets/commit/e8ae9725fa86b7db52a147ca5a2acc62fa2ccf43))
+
+- **scan_progressbar**: Mapping of bec progress states to the progressbar enums
+  ([`88b42e4`](https://github.com/bec-project/bec_widgets/commit/88b42e49e30a0aa0edc2de4d970408f4be5bde6b))
+
+### Build System
+
+- Update min dependency of bec to 3.42.4
+  ([`a4274ff`](https://github.com/bec-project/bec_widgets/commit/a4274ff8cd9f3e73a61b2eaf902c172c028d21b0))
+
+### Features
+
+- **main_window**: Added scan progress bar to BECMainWindow status bar
+  ([`497e394`](https://github.com/bec-project/bec_widgets/commit/497e394deb5cfe36c8fc4f769fef26f109fd1c1f))
+
+- **main_window**: Timer to show hide scan progress when it is relevant only
+  ([`9ff1706`](https://github.com/bec-project/bec_widgets/commit/9ff170660edd9e03f99eccee60b5e20fc1cf5a8d))
+
+- **progressbar**: Added padding as designer property
+  ([`a451625`](https://github.com/bec-project/bec_widgets/commit/a451625a5ab804ca8259f9c9f83c4f9ebbea4a5b))
+
+- **progressbar**: State setting and dynamic corner radius
+  ([`d3a9e09`](https://github.com/bec-project/bec_widgets/commit/d3a9e0903a263d735ecab3a2ad9319c9d5e86092))
+
+- **scan_progressbar**: Added oneline design for compact applications
+  ([`d5ca7b8`](https://github.com/bec-project/bec_widgets/commit/d5ca7b84337cf60aa66f961d357ae66994f53c7a))
+
+- **scan_progressbar**: Added progressbar with hooks to scan progress and device progress
+  ([`c4b8538`](https://github.com/bec-project/bec_widgets/commit/c4b85381a41e4742567680864668ee83d498b1d1))
+
+### Refactoring
+
+- **progressbar**: Change slot / property to safeslot / safeproperty
+  ([`92d0ffe`](https://github.com/bec-project/bec_widgets/commit/92d0ffee65babc718fafd60131d0a4f291e5ca2b))
+
+### Testing
+
+- **scan progress**: Add test for queue update logic
+  ([`b2a46e2`](https://github.com/bec-project/bec_widgets/commit/b2a46e284d45e97dd9853d1a3c8e95de7e530267))
+
+- **scan_progress**: Tests extended
+  ([`6c04eac`](https://github.com/bec-project/bec_widgets/commit/6c04eac18c887526b333f58fc1118c3b4029abd8))
+
+
+## v2.16.2 (2025-06-20)
+
+### Bug Fixes
+
+- **waveform**: Asyncsignal are handled with the same update mechanism as async readback
+  ([`a3ffcef`](https://github.com/bec-project/bec_widgets/commit/a3ffcefe8085fa1a88d679f8ef6adfdff786492e))
+
+### Testing
+
+- **utils**: Dmmock can fetch get_bec_signals method
+  ([`3146d98`](https://github.com/bec-project/bec_widgets/commit/3146d98c572ff2bb8ab77f71b75d9612e364ffe0))
+
+
+## v2.16.1 (2025-06-20)
+
+### Bug Fixes
+
+- **scatter**: Fix tab order
+  ([`235aabf`](https://github.com/bec-project/bec_widgets/commit/235aabf307ef0c01a51a5cd8be4eb53915ed360c))
+
+
+## v2.16.0 (2025-06-17)
+
+### Bug Fixes
+
+- Adjust height of list widget
+  ([`11131ef`](https://github.com/bec-project/bec_widgets/commit/11131ef14c7e8714a4eaf70256da9e5835d60810))
+
+- Make website test robust
+  ([`4d8c07c`](https://github.com/bec-project/bec_widgets/commit/4d8c07cdd142bab4c0d8224c43e66517a02da7c1))
+
+- Parse config on submission and reload after
+  ([`5e4c129`](https://github.com/bec-project/bec_widgets/commit/5e4c129af6ae6644e4bb94f4129c6770fd26542d))
+
+- Pass on kwargs from PydanticModelForm
+  ([`a55f561`](https://github.com/bec-project/bec_widgets/commit/a55f561971a9ce2295cd835cd5cb6ce436d6c693))
+
+- Put waiting in thread
+  ([`1a350c3`](https://github.com/bec-project/bec_widgets/commit/1a350c3b16da0d990afd53d14934040e5e063177))
+
+- Reset dict table properly
+  ([`5623547`](https://github.com/bec-project/bec_widgets/commit/5623547e926b86eeb5e2164fa6ec9e36b99b8f63))
+
+- Scale dict widget height
+  ([`dea2568`](https://github.com/bec-project/bec_widgets/commit/dea2568de370450ca871fe7bf3573eec9acf8122))
+
+- Tidy up form widget formatting
+  ([`8f4c8e4`](https://github.com/bec-project/bec_widgets/commit/8f4c8e45b3d4a15c67e36cd52d475c3117eca1d3))
+
+### Features
+
+- Add a widget to edit lists in forms
+  ([`7fc85ba`](https://github.com/bec-project/bec_widgets/commit/7fc85bac7fff8555b73d28eefe9a538540d574b9))
+
+- Add set form item
+  ([`be73349`](https://github.com/bec-project/bec_widgets/commit/be73349c706582c144813f70dbc477372057de86))
+
+- Allow editing device config from browser
+  ([`886964b`](https://github.com/bec-project/bec_widgets/commit/886964bb54d2f3923fb6baf198652bb05cf28eb2))
+
+- Generate combobox for literal str
+  ([`138d4ca`](https://github.com/bec-project/bec_widgets/commit/138d4cabbd50e3c86ab18e9cdc25bbb5cdabc511))
+
+### Performance Improvements
+
+- Replace wait with waitUntil
+  ([`d626caa`](https://github.com/bec-project/bec_widgets/commit/d626caae3dc71683134cc47073bc131eba4820f5))
+
+### Refactoring
+
+- Move device config form to module
+  ([`9ce31c9`](https://github.com/bec-project/bec_widgets/commit/9ce31c9833ae38721b2246cdcac50f1154fba99d))
+
+- Rename field widgets
+  ([`b0d03c0`](https://github.com/bec-project/bec_widgets/commit/b0d03c0648cd365143dfed27d4755d6f5b9c7a45))
+
+### Testing
+
+- Add tests for config dialog
+  ([`a9613a0`](https://github.com/bec-project/bec_widgets/commit/a9613a07b0cd9cd9455fd996d124c77218c9388f))
+
+
+## v2.15.1 (2025-06-16)
+
+### Bug Fixes
+
+- **main_window**: Added expiration timer for scroll label for ClientInfoMessage
+  ([`187bf49`](https://github.com/bec-project/bec_widgets/commit/187bf493a5b18299a10939901b9ed7e308435092))
+
+- **scroll_label**: Updating label during scrolling is done imminently, regardless scrolling
+  ([`1612933`](https://github.com/bec-project/bec_widgets/commit/1612933dd9689f2bf480ad81811c051201a9ff70))
+
+
+## v2.15.0 (2025-06-15)
+
+### Bug Fixes
+
+- **main_window**: Central widget cleanup check to not remove None
+  ([`644be62`](https://github.com/bec-project/bec_widgets/commit/644be621f20cf09037da763f6217df9d1e4642bc))
+
+### Features
+
+- **main_window**: Main window can display the messages from the send_client_info as a scrolling
+  horizontal text; closes #700
+  ([`0dec78a`](https://github.com/bec-project/bec_widgets/commit/0dec78afbaddbef98d20949d3a0ba4e0dc8529df))
+
+### Refactoring
+
+- **main_window**: App id is displayed as QLabel instead of message
+  ([`57b9a57`](https://github.com/bec-project/bec_widgets/commit/57b9a57a631f267a8cb3622bf73035ffb15510e6))
+
+### Testing
+
+- **main_window**: Becmainwindow tests extended
+  ([`30acc4c`](https://github.com/bec-project/bec_widgets/commit/30acc4c236bfbfed19f56512b264a52b4359e6c1))
+
+
+## v2.14.0 (2025-06-13)
+
+### Features
+
+- **image_roi**: Added EllipticalROI
+  ([`af8db0b`](https://github.com/bec-project/bec_widgets/commit/af8db0bede32dd10ad72671a8c2978ca884f4994))
+
+### Refactoring
+
+- **image_roi_tree**: Shape switch logic adjusted to reduce code repetition
+  ([`f0d48a0`](https://github.com/bec-project/bec_widgets/commit/f0d48a05085bb8c628e516d4a976d776ee63c7c3))
+
+
+## v2.13.2 (2025-06-13)
+
+### Bug Fixes
+
+- Allow sets in generated form types
+  ([`32fd959`](https://github.com/bec-project/bec_widgets/commit/32fd959e675108265f35139b44d02ba966bd37e2))
+
+
+## v2.13.1 (2025-06-12)
+
+### Bug Fixes
+
+- **main_window**: Event filter applied on QEvent.Type.StatusTip; closes #698
+  ([`9f853b0`](https://github.com/bec-project/bec_widgets/commit/9f853b08640f0ffff9f5b59c6d5e0dd3e210d4f6))
+
+
+## v2.13.0 (2025-06-10)
+
+### Bug Fixes
+
+- **roi**: Removed roi handle adding/removing inconsistencies
+  ([`f904499`](https://github.com/bec-project/bec_widgets/commit/f9044996f6d62cdbb693149934b09625fb39fd55))
+
+### Features
+
+- **image_roi_tree**: Lock/unlock rois possible through the ROIPropertyTree
+  ([`594185d`](https://github.com/bec-project/bec_widgets/commit/594185dde9c73991489f2154507f1c3d3822c5b4))
+
+- **roi**: Rois can be lock to be not moved by mouse
+  ([`46d7e3f`](https://github.com/bec-project/bec_widgets/commit/46d7e3f5170a5f8b444043bc49651921816f7003))
+
+
+## v2.12.4 (2025-06-10)
+
+### Bug Fixes
+
+- **image_roi**: Coordinates are emitted correctly when handles are inverted; closes #672
+  ([`9ef418b`](https://github.com/bec-project/bec_widgets/commit/9ef418bf5597d4be77adc3c0c88c1c1619c9aa2f))
+
+### Continuous Integration
+
+- Add stale issue job
+  ([`b3ce680`](https://github.com/bec-project/bec_widgets/commit/b3ce68070d58cdd76559cbd7db04cdbcc6c1f075))
+
+
+## v2.12.3 (2025-06-05)
+
+### Bug Fixes
+
+- **crosshair**: Use objectName instead of config for retrieving the monitor name
+  ([`edfac87`](https://github.com/bec-project/bec_widgets/commit/edfac87868605b4b755f7732b2841673de53bc3f))
+
+- **device_combobox**: Tuple entries of preview signals are checked in DeviceComboBoxes just for the
+  relevant device
+  ([`12f5233`](https://github.com/bec-project/bec_widgets/commit/12f523374586d55499f80baf56a50b6ef486cd43))
+
+- **image**: Preview signals can be used in Image widget; update logic adjusted; closes #683
+  ([`2711164`](https://github.com/bec-project/bec_widgets/commit/271116453d1ef5316b19457d04613b6ddc939cdb))
+
+### Build System
+
+- Update min dependency of bec to 3.38
+  ([`3740ac8`](https://github.com/bec-project/bec_widgets/commit/3740ac8e325a489d59faca648896ffcea29e1a02))
+
+
+## v2.12.2 (2025-06-05)
+
+### Bug Fixes
+
+- **waveform**: Safeguard for history data access, closes #571; removed return values "none"
+  ([`8570538`](https://github.com/bec-project/bec_widgets/commit/85705383e4aff2f83f76d342db0a13380aeca42f))
+
+
+## v2.12.1 (2025-06-05)
+
+### Bug Fixes
+
+- **crosshair**: Emitted name from crosshair 2D is objectName of image or its id
+  ([`3e2544e`](https://github.com/bec-project/bec_widgets/commit/3e2544e52a84b30a5acb4a7874025fa359a3c58d))
+
+
+## v2.12.0 (2025-06-04)
+
+### Bug Fixes
+
+- Exclude metadata from RPC
+  ([`718116a`](https://github.com/bec-project/bec_widgets/commit/718116afc3a724658c4cd57b76e93249a66a9ebd))
+
+- Grid formatting in TypedForm
+  ([`5949121`](https://github.com/bec-project/bec_widgets/commit/594912136e2118de1a4de5213c2f668952f28a84))
+
+- Make generate plugin robust to multiline init
+  ([`a10e6f7`](https://github.com/bec-project/bec_widgets/commit/a10e6f7820309d590e832f2bca44ca1db8ef72a1))
+
+instead of str.find, use multiline regex with whitespace
+
+- **device browser**: Mocks and utils for tests
+  ([`e0e26c2`](https://github.com/bec-project/bec_widgets/commit/e0e26c205bf930d680e01910f87489decc7fbcdb))
+
+### Features
+
+- (#493) add dict to dynamic form types
+  ([`92d1d64`](https://github.com/bec-project/bec_widgets/commit/92d1d6435d6e8c05851804eb76605a4abeec01bb))
+
+- (#493) add helpers to dynamic form widgets
+  ([`a25c1a8`](https://github.com/bec-project/bec_widgets/commit/a25c1a8039078c92789b717b3f8a553c75814c33))
+
+- (#493) device browser to display config
+  ([`5188b38`](https://github.com/bec-project/bec_widgets/commit/5188b38c86f543d2abc742411b64fa127c6c0c16))
+
+- Add clickable label util
+  ([`2dda58f`](https://github.com/bec-project/bec_widgets/commit/2dda58f7d2adf1f41c6ce4fad02d55bd9aa200fa))
+
+
+## v2.11.0 (2025-06-04)
+
+### Bug Fixes
+
+- **image item**: Propagate remove call to parent class
+  ([`e211e4d`](https://github.com/bec-project/bec_widgets/commit/e211e4d7161cc4fc4b2f7cd18f058e070f5b4b7a))
+
+- **image layer**: Add layer main if it does not exist
+  ([`7eb2f54`](https://github.com/bec-project/bec_widgets/commit/7eb2f54e0ed556e0c30a4e14ded75e32dcf3d531))
+
+- **image_item**: Do not disconnect the monitor from within the image item
+  ([`4c0bd97`](https://github.com/bec-project/bec_widgets/commit/4c0bd977fc2b82680bbace763f5ffb19ed664f72))
+
+### Features
+
+- **image_layer**: Add default name for image layers
+  ([`4a343b2`](https://github.com/bec-project/bec_widgets/commit/4a343b204112c53e593e9bb43642d21f268dfa85))
+
+### Refactoring
+
+- **image**: Disconnect when layer is removed
+  ([`8a299a8`](https://github.com/bec-project/bec_widgets/commit/8a299a8268f3c21bbdc6629ad1f1f50a0aa0948b))
+
+- **image**: Introduce image base and image layer; rename vrange to v_range
+  ([`10f292d`](https://github.com/bec-project/bec_widgets/commit/10f292def9d1551bca0d8f63c0a94799c08ff507))
+
+- **image**: Move image item creation to layer manager
+  ([`c2b0c8c`](https://github.com/bec-project/bec_widgets/commit/c2b0c8c4336302ec4a7807c31b3f3b78a413c1aa))
+
+- **image**: Removed access to image item config
+  ([`99ecf6a`](https://github.com/bec-project/bec_widgets/commit/99ecf6a18f2e87d68f3de3abf56d97f7e6467912))
+
+- **image_base**: Move default color map to image layer
+  ([`92b89e7`](https://github.com/bec-project/bec_widgets/commit/92b89e72750fc0ab72ea51f865032133c49a7f18))
+
+- **image_base**: Renamed layers to layer_manager and added public methods for accessing the layer
+  manager
+  ([`92dade0`](https://github.com/bec-project/bec_widgets/commit/92dade09508ff3940e0b5dc99917302d61b03bc8))
+
+- **image_item**: Emit object name with removed signal
+  ([`a4f3117`](https://github.com/bec-project/bec_widgets/commit/a4f311794132c6c24370cb2f5b5e0725b12587fd))
+
+- **image_item**: Removed outdated image item config
+  ([`3e789ca`](https://github.com/bec-project/bec_widgets/commit/3e789ca35b6d0cf2d8ae9677bc65b7f0ca4eabc7))
+
+### Testing
+
+- Improve error message for widgets that are not properly cleaned up
+  ([`7c47505`](https://github.com/bec-project/bec_widgets/commit/7c47505c5a147885ca2e854e13c1eb3fddaf5489))
+
+
+## v2.10.3 (2025-06-04)
+
+### Bug Fixes
+
+- **color_button_native**: Popup logic to choose color moved to ColorButtonNative
+  ([`2d0ed94`](https://github.com/bec-project/bec_widgets/commit/2d0ed94f3feb38dfc9645f2c3b9d6a06b92637bb))
+
+
+## v2.10.2 (2025-06-03)
+
+### Bug Fixes
+
+- Remove unnecessary PySide imports
+  ([`1df6c19`](https://github.com/bec-project/bec_widgets/commit/1df6c1925b6ec88df8d7a1a5a79a5ddc6b1161b5))
+
+### Continuous Integration
+
+- Check for disallowed imports from PySide
+  ([`6b939ac`](https://github.com/bec-project/bec_widgets/commit/6b939ac34d01cdbb0e8e32a0bd4e56cad032e75b))
+
+
+## v2.10.1 (2025-06-02)
+
+### Bug Fixes
+
+- **console**: Qt console widget deleted
+  ([`cd4e90a`](https://github.com/bec-project/bec_widgets/commit/cd4e90a79fcdbc96f4ec23db22375d05a48731db))
+
+### Build System
+
+- Pyte removed from dependencies
+  ([`a64cf0d`](https://github.com/bec-project/bec_widgets/commit/a64cf0dd871c1419e02d3803c74cc45966baac19))
+
+
+## v2.10.0 (2025-06-02)
+
+### Bug Fixes
+
+- **waveform**: Waveform only update async data when scan is currently running
+  ([`f90150d`](https://github.com/bec-project/bec_widgets/commit/f90150d1c708331d4ee78f82ebf5ef23cd81fd17))
+
+### Continuous Integration
+
+- Add job logs to e2e test
+  ([`d12bd9f`](https://github.com/bec-project/bec_widgets/commit/d12bd9fe1a010babc94dc86405d1b75a2b07534c))
+
+- Fix artifact version
+  ([`2b4454a`](https://github.com/bec-project/bec_widgets/commit/2b4454a291bc69399ddd08780c44e1339825fb36))
+
+### Features
+
+- **waveform**: Large async dataset warning popup
+  ([`d0c1ac0`](https://github.com/bec-project/bec_widgets/commit/d0c1ac0cf5d421d14c9e050ccf5832cd30ca0764))
+
+
+## v2.9.2 (2025-05-30)
+
+### Bug Fixes
+
+- Logpanel error cycle
+  ([`d9dc60e`](https://github.com/bec-project/bec_widgets/commit/d9dc60ee9974e2e6e6005378cc17ef088a4ded2c))
+
+- Move log panel to bec connector and add rate limiter
+  ([`7322cd1`](https://github.com/bec-project/bec_widgets/commit/7322cd194fcf7f56d41c86ecbcd97a5d8bd60c3e))
+
+- **log_panel**: Removed lambda callback method
+  ([`9112616`](https://github.com/bec-project/bec_widgets/commit/91126168b62f3e1623521ceb205dd854287cfef7))
+
+
+## v2.9.1 (2025-05-30)
+
+### Bug Fixes
+
+- Make registry update log message debug level
+  ([`12f8c82`](https://github.com/bec-project/bec_widgets/commit/12f8c82eb59ed6a7273b57126efe340bf37b65cc))
+
+
+## v2.9.0 (2025-05-30)
+
+### Bug Fixes
+
+- **DeviceSignalInput**: Improve robustness
+  ([`91195ae`](https://github.com/bec-project/bec_widgets/commit/91195ae0fdf024daf2daaa4ea2963992b4e40e04))
+
+use set for storing filter properties to allow multiple set to true or false
+
+### Code Style
+
+- Typing in bec_dispatcher
+  ([`a6c5c21`](https://github.com/bec-project/bec_widgets/commit/a6c5c21afaa6dcf33ce71027e8730354ee34e3b4))
+
+### Documentation
+
+- Add usage docs for signal label widget
+  ([`2b9919b`](https://github.com/bec-project/bec_widgets/commit/2b9919bb34a66708f4b910ffc17dc253e9b7f70d))
+
+### Features
+
+- (#569) add signal label widget
+  ([`822e7d0`](https://github.com/bec-project/bec_widgets/commit/822e7d06ff7479d006ae99942fed5e2c836831ce))
+
+add a widget which shows the current value of a signal from BEC. configurable with many properties
+  in designer. intended for use mainly in static GUIs.
+
+
+## v2.8.4 (2025-05-30)
+
+### Bug Fixes
+
+- **crosshair**: Label decimal precision is dynamically scaled with the plot zoom; API of all
+  affected widgets adjusted; option added to PlotBase; closes #637
+  ([`c8128fa`](https://github.com/bec-project/bec_widgets/commit/c8128faf79c43487921aada9dbf1869ef5bda93c))
+
+
+## v2.8.3 (2025-05-30)
+
+### Bug Fixes
+
+- Guard plugin repo import in e2e test
+  ([`bf172b8`](https://github.com/bec-project/bec_widgets/commit/bf172b8431ec207f39206d2a0446908f7186858a))
+
+### Refactoring
+
+- Store modules with widget search
+  ([`b225a7c`](https://github.com/bec-project/bec_widgets/commit/b225a7cc90b55697211c28d9411b6f85c8077217))
+
+### Testing
+
+- **e2e**: Add tests involving plugin repo
+  ([`05329ab`](https://github.com/bec-project/bec_widgets/commit/05329ab50fe10ffc3c19ef3eb408912bb9068de3))
+
+
+## v2.8.2 (2025-05-27)
+
+### Bug Fixes
+
+- **image_roi**: Rois are invertible by default, fixes resizing bug when adding from ROI manager
+  ([`0bdd4e8`](https://github.com/bec-project/bec_widgets/commit/0bdd4e86a24a61b5365febcb2fcbde0532117053))
+
+
 ## v2.8.1 (2025-05-27)
 
 ### Bug Fixes

bec_widgets/applications/launch_window.py

@@ -27,7 +27,7 @@ from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.name_utils import pascal_to_snake
 from bec_widgets.utils.plugin_utils import get_plugin_auto_updates
 from bec_widgets.utils.round_frame import RoundedFrame
-from bec_widgets.utils.toolbar import ModularToolBar
+from bec_widgets.utils.toolbars.toolbar import ModularToolBar
 from bec_widgets.utils.ui_loader import UILoader
 from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
 from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
@@ -242,7 +242,7 @@ class LaunchWindow(BECMainWindow):
         )
 
         # plugin widgets
-        self.available_widgets: dict[str, BECWidget] = get_all_plugin_widgets()
+        self.available_widgets: dict[str, type[BECWidget]] = get_all_plugin_widgets().as_dict()
         if self.available_widgets:
             plugin_repo_name = next(iter(self.available_widgets.values())).__module__.split(".")[0]
             plugin_repo_name = plugin_repo_name.removesuffix("_bec").upper()
@@ -542,7 +542,7 @@ class LaunchWindow(BECMainWindow):
         remaining_connections = [
             connection for connection in connections.values() if connection.parent_id != self.gui_id
         ]
-        return len(remaining_connections) <= 1
+        return len(remaining_connections) <= 4
 
     def _turn_off_the_lights(self, connections: dict):
         """

bec_widgets/cli/client_utils.py

@@ -51,7 +51,7 @@ def _filter_output(output: str) -> str:
 
 
 def _get_output(process, logger) -> None:
-    log_func = {process.stdout: logger.debug, process.stderr: logger.error}
+    log_func = {process.stdout: logger.debug, process.stderr: logger.info}
     stream_buffer = {process.stdout: [], process.stderr: []}
     try:
         os.set_blocking(process.stdout.fileno(), False)

bec_widgets/cli/generate_cli.py

@@ -111,7 +111,7 @@ _Widgets = {
             self.content += """
 
 try:
-    _plugin_widgets = get_all_plugin_widgets()
+    _plugin_widgets = get_all_plugin_widgets().as_dict()
     plugin_client = get_plugin_client_module()
     Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
 

bec_widgets/cli/rpc/rpc_base.py

@@ -7,6 +7,7 @@ from functools import wraps
 from typing import TYPE_CHECKING, Any, cast
 
 from bec_lib.client import BECClient
+from bec_lib.device import DeviceBaseWithConfig
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.utils.import_utils import lazy_import, lazy_import_from
 
@@ -24,6 +25,20 @@ else:
 # pylint: disable=protected-access
 
 
+def _name_arg(arg):
+    if isinstance(arg, DeviceBaseWithConfig):
+        # if dev.<device> is passed to GUI, it passes full_name
+        if hasattr(arg, "full_name"):
+            return arg.full_name
+    elif hasattr(arg, "name"):
+        return arg.name
+    return arg
+
+
+def _transform_args_kwargs(args, kwargs) -> tuple[tuple, dict]:
+    return tuple(_name_arg(arg) for arg in args), {k: _name_arg(v) for k, v in kwargs.items()}
+
+
 def rpc_call(func):
     """
     A decorator for calling a function on the server.
@@ -47,15 +62,7 @@ def rpc_call(func):
                 return None  # func(*args, **kwargs)
             caller_frame = caller_frame.f_back
 
-        out = []
-        for arg in args:
-            if hasattr(arg, "name"):
-                arg = arg.name
-            out.append(arg)
-        args = tuple(out)
-        for key, val in kwargs.items():
-            if hasattr(val, "name"):
-                kwargs[key] = val.name
+        args, kwargs = _transform_args_kwargs(args, kwargs)
         if not self._root._gui_is_alive():
             raise RuntimeError("GUI is not alive")
         return self._run_rpc(func.__name__, *args, **kwargs)

bec_widgets/cli/rpc/rpc_widget_handler.py

@@ -31,10 +31,9 @@ class RPCWidgetHandler:
         Returns:
             None
         """
-        clss = get_custom_classes("bec_widgets")
-        self._widget_classes = get_all_plugin_widgets() | {
-            cls.__name__: cls for cls in clss.widgets if cls.__name__ not in IGNORE_WIDGETS
-        }
+        self._widget_classes = (
+            get_custom_classes("bec_widgets") + get_all_plugin_widgets()
+        ).as_dict(IGNORE_WIDGETS)
 
     def create_widget(self, widget_type, **kwargs) -> BECWidget:
         """

bec_widgets/cli/server.py

@@ -9,6 +9,7 @@ from contextlib import redirect_stderr, redirect_stdout
 
 from bec_lib.logger import bec_logger
 from bec_lib.service_config import ServiceConfig
+from qtmonaco.pylsp_provider import pylsp_server
 from qtpy.QtCore import QSize, Qt
 from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QApplication
@@ -142,6 +143,8 @@ class GUIServer:
         """
         Shutdown the GUI server.
         """
+        if pylsp_server.is_running():
+            pylsp_server.stop()
         if self.dispatcher:
             self.dispatcher.stop_cli_server()
             self.dispatcher.disconnect_all()

bec_widgets/tests/utils.py

@@ -19,7 +19,7 @@ class FakeDevice(BECDevice):
             "readoutPriority": "baseline",
             "deviceClass": "ophyd.Device",
             "deviceConfig": {},
-            "deviceTags": ["user device"],
+            "deviceTags": {"user device"},
             "enabled": enabled,
             "readOnly": False,
             "name": self.name,
@@ -89,16 +89,28 @@ class FakePositioner(BECPositioner):
             "readoutPriority": "baseline",
             "deviceClass": "ophyd_devices.SimPositioner",
             "deviceConfig": {"delay": 1, "tolerance": 0.01, "update_frequency": 400},
-            "deviceTags": ["user motors"],
+            "deviceTags": {"user motors"},
             "enabled": enabled,
             "readOnly": False,
             "name": self.name,
         }
         self._info = {
             "signals": {
-                "readback": {"kind_str": "hinted"},  # hinted
-                "setpoint": {"kind_str": "normal"},  # normal
-                "velocity": {"kind_str": "config"},  # config
+                "readback": {
+                    "kind_str": "hinted",
+                    "component_name": "readback",
+                    "obj_name": self.name,
+                },  # hinted
+                "setpoint": {
+                    "kind_str": "normal",
+                    "component_name": "setpoint",
+                    "obj_name": f"{self.name}_setpoint",
+                },  # normal
+                "velocity": {
+                    "kind_str": "config",
+                    "component_name": "velocity",
+                    "obj_name": f"{self.name}_velocity",
+                },  # config
             }
         }
         self.signals = {
@@ -184,8 +196,8 @@ class FakePositioner(BECPositioner):
 class Positioner(FakePositioner):
     """just placeholder for testing embedded isinstance check in DeviceCombobox"""
 
-    def __init__(self, name="test", limits=None, read_value=1.0):
-        super().__init__(name, limits, read_value)
+    def __init__(self, name="test", limits=None, read_value=1.0, enabled=True):
+        super().__init__(name, limits=limits, read_value=read_value, enabled=enabled)
 
 
 class Device(FakeDevice):
@@ -210,6 +222,39 @@ class DMMock:
         for device in devices:
             self.devices[device.name] = device
 
+    def get_bec_signals(self, signal_class_name: str):
+        """
+        Emulate DeviceManager.get_bec_signals for unit-tests.
+
+        For “AsyncSignal” we list every device whose readout_priority is
+        ReadoutPriority.ASYNC and build a minimal tuple
+        (device_name, signal_name, signal_info_dict) that matches the real
+        API shape used by Waveform._check_async_signal_found.
+        """
+        signals: list[tuple[str, str, dict]] = []
+        if signal_class_name != "AsyncSignal":
+            return signals
+
+        for device in self.devices.values():
+            if getattr(device, "readout_priority", None) == ReadoutPriority.ASYNC:
+                device_name = device.name
+                signal_name = device.name  # primary signal in our mocks
+                signal_info = {
+                    "component_name": signal_name,
+                    "obj_name": signal_name,
+                    "kind_str": "hinted",
+                    "signal_class": signal_class_name,
+                    "metadata": {
+                        "connected": True,
+                        "precision": None,
+                        "read_access": True,
+                        "timestamp": 0.0,
+                        "write_access": True,
+                    },
+                }
+                signals.append((device_name, signal_name, signal_info))
+        return signals
+
 
 DEVICES = [
     FakePositioner("samx", limits=[-10, 10], read_value=2.0),

bec_widgets/utils/bec_connector.py

@@ -186,7 +186,6 @@ class BECConnector:
         except:
             logger.error(f"Error getting parent_id for {self.__class__.__name__}")
 
-    @SafeSlot()
     def _run_cleanup_on_deleted_parent(self) -> None:
         """
         Run cleanup on the deleted parent.

bec_widgets/utils/bec_dispatcher.py

@@ -163,7 +163,7 @@ class BECDispatcher:
     def connect_slot(
         self,
         slot: Callable,
-        topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]],
+        topics: EndpointInfo | str | list[EndpointInfo] | list[str],
         cb_info: dict | None = None,
         **kwargs,
     ) -> None:
@@ -172,7 +172,7 @@ class BECDispatcher:
         Args:
             slot (Callable): A slot method/function that accepts two inputs: content and metadata of
                 the corresponding pub/sub message
-            topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
+            topics EndpointInfo | str | list[EndpointInfo] | list[str]: A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
             cb_info (dict | None): A dictionary containing information about the callback. Defaults to None.
         """
         qt_slot = QtThreadSafeCallback(cb=slot, cb_info=cb_info)
@@ -183,13 +183,15 @@ class BECDispatcher:
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
         qt_slot.topics.update(set(topics_str))
 
-    def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
+    def disconnect_slot(
+        self, slot: Callable, topics: EndpointInfo | str | list[EndpointInfo] | list[str]
+    ):
         """
         Disconnect a slot from a topic.
 
         Args:
             slot(Callable): The slot to disconnect
-            topics(Union[str, list]): The topic(s) to disconnect from
+            topics EndpointInfo | str | list[EndpointInfo] | list[str]: A topic or list of topics to unsub from.
         """
         # find the right slot to disconnect from ;
         # slot callbacks are wrapped in QtThreadSafeCallback objects,

bec_widgets/utils/bec_plugin_helper.py

@@ -3,12 +3,17 @@ from __future__ import annotations
 import importlib.metadata
 import inspect
 import pkgutil
+import traceback
 from importlib import util as importlib_util
 from importlib.machinery import FileFinder, ModuleSpec, SourceFileLoader
 from types import ModuleType
 from typing import Generator
 
-from bec_widgets.utils.bec_widget import BECWidget
+from bec_lib.logger import bec_logger
+
+from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
+
+logger = bec_logger.logger
 
 
 def _submodule_specs(module: ModuleType) -> tuple[ModuleSpec | None, ...]:
@@ -30,7 +35,12 @@ def _loaded_submodules_from_specs(
         assert isinstance(
             submodule.__loader__, SourceFileLoader
         ), "Module found from FileFinder should have SourceFileLoader!"
-        submodule.__loader__.exec_module(submodule)
+        try:
+            submodule.__loader__.exec_module(submodule)
+        except Exception as e:
+            logger.error(
+                f"Error loading plugin {submodule}: \n{''.join(traceback.format_exception(e))}"
+            )
         yield submodule
 
 
@@ -41,27 +51,29 @@ def _submodule_by_name(module: ModuleType, name: str):
     return None
 
 
-def _get_widgets_from_module(module: ModuleType) -> dict[str, "type[BECWidget]"]:
-    """Find any BECWidget subclasses in the given module and return them with their names."""
+def _get_widgets_from_module(module: ModuleType) -> BECClassContainer:
+    """Find any BECWidget subclasses in the given module and return them with their info."""
     from bec_widgets.utils.bec_widget import BECWidget  # avoid circular import
 
-    return dict(
-        inspect.getmembers(
-            module,
-            predicate=lambda item: inspect.isclass(item)
-            and issubclass(item, BECWidget)
-            and item is not BECWidget,
-        )
+    classes = inspect.getmembers(
+        module,
+        predicate=lambda item: inspect.isclass(item)
+        and issubclass(item, BECWidget)
+        and item is not BECWidget,
+    )
+    return BECClassContainer(
+        BECClassInfo(name=k, module=module.__name__, file=module.__loader__.get_filename(), obj=v)
+        for k, v in classes
     )
 
 
-def _all_widgets_from_all_submods(module):
+def _all_widgets_from_all_submods(module) -> BECClassContainer:
     """Recursively load submodules, find any BECWidgets, and return them all as a flat dict."""
     widgets = _get_widgets_from_module(module)
     if not hasattr(module, "__path__"):
         return widgets
     for submod in _loaded_submodules_from_specs(_submodule_specs(module)):
-        widgets.update(_all_widgets_from_all_submods(submod))
+        widgets += _all_widgets_from_all_submods(submod)
     return widgets
 
 
@@ -75,15 +87,16 @@ def get_plugin_client_module() -> ModuleType | None:
     return _submodule_by_name(plugin, "client") if (plugin := user_widget_plugin()) else None
 
 
-def get_all_plugin_widgets() -> dict[str, "type[BECWidget]"]:
+def get_all_plugin_widgets() -> BECClassContainer:
     """If there is a plugin repository installed, load all widgets from it."""
     if plugin := user_widget_plugin():
         return _all_widgets_from_all_submods(plugin)
     else:
-        return {}
+        return BECClassContainer()
 
 
 if __name__ == "__main__":  # pragma: no cover
-    #  print(get_all_plugin_widgets())
+
     client = get_plugin_client_module()
+    print(get_all_plugin_widgets())
     ...

bec_widgets/utils/clickable_label.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from qtpy.QtCore import Signal
+from qtpy.QtGui import QMouseEvent
+from qtpy.QtWidgets import QLabel
+
+
+class ClickableLabel(QLabel):
+    clicked = Signal()
+
+    def mouseReleaseEvent(self, ev: QMouseEvent) -> None:
+        self.clicked.emit()
+        return super().mouseReleaseEvent(ev)

bec_widgets/utils/colors.py

@@ -15,12 +15,15 @@ if TYPE_CHECKING:  # pragma: no cover
     from bec_qthemes._main import AccentColors
 
 
-def get_theme_palette():
+def get_theme_name():
     if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
-        theme = "dark"
+        return "dark"
     else:
-        theme = QApplication.instance().theme.theme
-    return bec_qthemes.load_palette(theme)
+        return QApplication.instance().theme.theme
+
+
+def get_theme_palette():
+    return bec_qthemes.load_palette(get_theme_name())
 
 
 def get_accent_colors() -> AccentColors | None:

bec_widgets/utils/crosshair.py

@@ -5,9 +5,13 @@ from typing import Any
 
 import numpy as np
 import pyqtgraph as pg
-from qtpy.QtCore import QObject, Qt, Signal, Slot
+from qtpy.QtCore import QObject, QPointF, Qt, Signal
+from qtpy.QtGui import QCursor, QTransform
 from qtpy.QtWidgets import QApplication
 
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.plots.image.image_item import ImageItem
+
 
 class CrosshairScatterItem(pg.ScatterPlotItem):
     def setDownsampling(self, ds=None, auto=None, method=None):
@@ -34,13 +38,21 @@ class Crosshair(QObject):
     coordinatesChanged2D = Signal(tuple)
     coordinatesClicked2D = Signal(tuple)
 
-    def __init__(self, plot_item: pg.PlotItem, precision: int = 3, parent=None):
+    def __init__(
+        self,
+        plot_item: pg.PlotItem,
+        precision: int | None = None,
+        *,
+        min_precision: int = 2,
+        parent=None,
+    ):
         """
         Crosshair for 1D and 2D plots.
 
         Args:
             plot_item (pyqtgraph.PlotItem): The plot item to which the crosshair will be attached.
-            precision (int, optional): Number of decimal places to round the coordinates to. Defaults to None.
+            precision (int | None, optional): Fixed number of decimal places to display. If *None*, precision is chosen dynamically from the current view range.
+            min_precision (int, optional): The lower bound (in decimal places) used when dynamic precision is enabled. Defaults to 2.
             parent (QObject, optional): Parent object for the QObject. Defaults to None.
         """
         super().__init__(parent)
@@ -48,7 +60,9 @@ class Crosshair(QObject):
         self.is_log_x = None
         self.is_derivative = None
         self.plot_item = plot_item
-        self.precision = precision
+        self._precision = precision
+        self._min_precision = max(0, int(min_precision))  # ensure non‑negative
+
         self.v_line = pg.InfiniteLine(angle=90, movable=False)
         self.v_line.skip_auto_range = True
         self.h_line = pg.InfiniteLine(angle=0, movable=False)
@@ -93,6 +107,56 @@ class Crosshair(QObject):
 
         self._connect_to_theme_change()
 
+    @property
+    def precision(self) -> int | None:
+        """Fixed number of decimals; ``None`` enables dynamic mode."""
+        return self._precision
+
+    @precision.setter
+    def precision(self, value: int | None):
+        """
+        Set the fixed number of decimals to display.
+
+        Args:
+            value(int | None): The number of decimals to display. If `None`, dynamic precision is used based on the view range.
+        """
+        self._precision = value
+
+    @property
+    def min_precision(self) -> int:
+        """Lower bound on decimals when dynamic precision is used."""
+        return self._min_precision
+
+    @min_precision.setter
+    def min_precision(self, value: int):
+        """
+        Set the lower bound on decimals when dynamic precision is used.
+
+        Args:
+            value(int): The minimum number of decimals to display. Must be non-negative.
+        """
+        self._min_precision = max(0, int(value))
+
+    def _current_precision(self) -> int:
+        """
+        Get the current precision based on the view range or fixed precision.
+        """
+        if self._precision is not None:
+            return self._precision
+
+        # Dynamically choose precision from the smaller visible span
+        view_range = self.plot_item.vb.viewRange()
+        x_span = abs(view_range[0][1] - view_range[0][0])
+        y_span = abs(view_range[1][1] - view_range[1][0])
+
+        # Ignore zero spans that can appear during initialisation
+        spans = [s for s in (x_span, y_span) if s > 0]
+        span = min(spans) if spans else 1.0
+
+        exponent = np.floor(np.log10(span))  # order of magnitude
+        decimals = max(0, int(-exponent) + 1)
+        return max(self._min_precision, decimals)
+
     def _connect_to_theme_change(self):
         """Connect to the theme change signal."""
         qapp = QApplication.instance()
@@ -100,7 +164,7 @@ class Crosshair(QObject):
             qapp.theme_signal.theme_updated.connect(self._update_theme)
             self._update_theme()
 
-    @Slot(str)
+    @SafeSlot(str)
     def _update_theme(self, theme: str | None = None):
         """Update the theme."""
         if theme is None:
@@ -127,7 +191,7 @@ class Crosshair(QObject):
         self.coord_label.fill = pg.mkBrush(label_bg_color)
         self.coord_label.border = pg.mkPen(None)
 
-    @Slot(int)
+    @SafeSlot(int)
     def update_highlighted_curve(self, curve_index: int):
         """
         Update the highlighted curve in the case of multiple curves in a plot item.
@@ -205,15 +269,47 @@ class Crosshair(QObject):
                     [0, 0], size=[item.image.shape[0], 1], pen=pg.mkPen("r", width=2), movable=False
                 )
                 self.marker_2d_row.skip_auto_range = True
+                if item.image_transform is not None:
+                    self.marker_2d_row.setTransform(item.image_transform)
                 self.plot_item.addItem(self.marker_2d_row)
 
                 # Create vertical ROI for column highlighting
                 self.marker_2d_col = pg.ROI(
                     [0, 0], size=[1, item.image.shape[1]], pen=pg.mkPen("r", width=2), movable=False
                 )
+                if item.image_transform is not None:
+                    self.marker_2d_col.setTransform(item.image_transform)
                 self.marker_2d_col.skip_auto_range = True
                 self.plot_item.addItem(self.marker_2d_col)
 
+    @SafeSlot()
+    def update_markers_on_image_change(self):
+        """
+        Update markers when the image changes, e.g. when the
+        image shape or transformation changes.
+        """
+        for item in self.items:
+            if not isinstance(item, pg.ImageItem):
+                continue
+            if self.marker_2d_row is not None:
+                self.marker_2d_row.setSize([item.image.shape[0], 1])
+                self.marker_2d_row.setTransform(item.image_transform)
+            if self.marker_2d_col is not None:
+                self.marker_2d_col.setSize([1, item.image.shape[1]])
+                self.marker_2d_col.setTransform(item.image_transform)
+            # Get the current mouse position
+            views = self.plot_item.vb.scene().views()
+            if not views:
+                return
+            view = views[0]
+            global_pos = QCursor.pos()
+            view_pos = view.mapFromGlobal(global_pos)
+            scene_pos = view.mapToScene(view_pos)
+
+            if self.plot_item.vb.sceneBoundingRect().contains(scene_pos):
+                plot_pt = self.plot_item.vb.mapSceneToView(scene_pos)
+                self.mouse_moved(manual_pos=(plot_pt.x(), plot_pt.y()))
+
     def snap_to_data(
         self, x: float, y: float
     ) -> tuple[None, None] | tuple[defaultdict[Any, list], defaultdict[Any, list]]:
@@ -252,13 +348,29 @@ class Crosshair(QObject):
                     y_values[name] = closest_y
                     x_values[name] = closest_x
             elif isinstance(item, pg.ImageItem):  # 2D plot
-                name = item.config.monitor or str(id(item))
+                name = item.objectName() or str(id(item))
                 image_2d = item.image
                 if image_2d is None:
                     continue
-                # Clip the x and y values to the image dimensions to avoid out of bounds errors
-                y_values[name] = int(np.clip(y, 0, image_2d.shape[1] - 1))
-                x_values[name] = int(np.clip(x, 0, image_2d.shape[0] - 1))
+                # Map scene coordinates (plot units) back to image pixel coordinates
+                if item.image_transform is not None:
+                    inv_transform, _ = item.image_transform.inverted()
+                    xy_trans = inv_transform.map(QPointF(x, y))
+                else:
+                    xy_trans = QPointF(x, y)
+
+                # Define valid pixel coordinate bounds
+                min_x_px, min_y_px = 0, 0
+                max_x_px = image_2d.shape[0] - 1  # columns
+                max_y_px = image_2d.shape[1] - 1  # rows
+
+                # Clip the mapped coordinates to the image bounds
+                px = int(np.clip(xy_trans.x(), min_x_px, max_x_px))
+                py = int(np.clip(xy_trans.y(), min_y_px, max_y_px))
+
+                # Store snapped pixel positions
+                x_values[name] = px
+                y_values[name] = py
 
         if x_values and y_values:
             if all(v is None for v in x_values.values()) or all(
@@ -298,59 +410,74 @@ class Crosshair(QObject):
 
         return list_x[original_index], list_y[original_index]
 
-    def mouse_moved(self, event):
-        """Handles the mouse moved event, updating the crosshair position and emitting signals.
+    @SafeSlot(object, tuple)
+    def mouse_moved(self, event=None, manual_pos=None):
+        """
+        Handles the mouse moved event, updating the crosshair position and emitting signals.
 
         Args:
-            event: The mouse moved event
+            event(object): The mouse moved event, which contains the scene position.
+            manual_pos(tuple, optional): A tuple containing the (x, y) coordinates to manually set the crosshair position.
         """
-        pos = event[0]
+        # Determine target (x, y) in *plot* coordinates
+        if manual_pos is not None:
+            x, y = manual_pos
+        else:
+            if event is None:
+                return  # nothing to do
+            scene_pos = event[0]  # SignalProxy bundle
+            if not self.plot_item.vb.sceneBoundingRect().contains(scene_pos):
+                return
+            view_pos = self.plot_item.vb.mapSceneToView(scene_pos)
+            x, y = view_pos.x(), view_pos.y()
+
+        # Update cross‑hair visuals
+        self.v_line.setPos(x)
+        self.h_line.setPos(y)
+
         self.update_markers()
-        if self.plot_item.vb.sceneBoundingRect().contains(pos):
-            mouse_point = self.plot_item.vb.mapSceneToView(pos)
-            x, y = mouse_point.x(), mouse_point.y()
-            self.v_line.setPos(x)
-            self.h_line.setPos(y)
-            scaled_x, scaled_y = self.scale_emitted_coordinates(mouse_point.x(), mouse_point.y())
-            self.crosshairChanged.emit((scaled_x, scaled_y))
-            self.positionChanged.emit((x, y))
+        scaled_x, scaled_y = self.scale_emitted_coordinates(x, y)
+        self.crosshairChanged.emit((scaled_x, scaled_y))
+        self.positionChanged.emit((x, y))
 
-            x_snap_values, y_snap_values = self.snap_to_data(x, y)
-            if x_snap_values is None or y_snap_values is None:
-                return
-            if all(v is None for v in x_snap_values.values()) or all(
-                v is None for v in y_snap_values.values()
-            ):
-                # not sure how we got here, but just to be safe...
-                return
+        snap_x_vals, snap_y_vals = self.snap_to_data(x, y)
+        if snap_x_vals is None or snap_y_vals is None:
+            return
+        if all(v is None for v in snap_x_vals.values()) or all(
+            v is None for v in snap_y_vals.values()
+        ):
+            return
 
-            for item in self.items:
-                if isinstance(item, pg.PlotDataItem):
-                    name = item.name() or str(id(item))
-                    x, y = x_snap_values[name], y_snap_values[name]
-                    if x is None or y is None:
-                        continue
-                    self.marker_moved_1d[name].setData([x], [y])
-                    x_snapped_scaled, y_snapped_scaled = self.scale_emitted_coordinates(x, y)
-                    coordinate_to_emit = (
-                        name,
-                        round(x_snapped_scaled, self.precision),
-                        round(y_snapped_scaled, self.precision),
-                    )
-                    self.coordinatesChanged1D.emit(coordinate_to_emit)
-                elif isinstance(item, pg.ImageItem):
-                    name = item.config.monitor or str(id(item))
-                    x, y = x_snap_values[name], y_snap_values[name]
-                    if x is None or y is None:
-                        continue
-                    # Set position of horizontal ROI (row)
-                    self.marker_2d_row.setPos([0, y])
-                    # Set position of vertical ROI (column)
-                    self.marker_2d_col.setPos([x, 0])
-                    coordinate_to_emit = (name, x, y)
-                    self.coordinatesChanged2D.emit(coordinate_to_emit)
-                else:
+        precision = self._current_precision()
+
+        for item in self.items:
+            if isinstance(item, pg.PlotDataItem):
+                name = item.name() or str(id(item))
+                sx, sy = snap_x_vals[name], snap_y_vals[name]
+                if sx is None or sy is None:
                     continue
+                self.marker_moved_1d[name].setData([sx], [sy])
+                sx_s, sy_s = self.scale_emitted_coordinates(sx, sy)
+                self.coordinatesChanged1D.emit(
+                    (name, round(sx_s, precision), round(sy_s, precision))
+                )
+
+            elif isinstance(item, pg.ImageItem):
+                name = item.objectName() or str(id(item))
+                px, py = snap_x_vals[name], snap_y_vals[name]
+                if px is None or py is None:
+                    continue
+
+                # Respect image transforms
+                if isinstance(item, ImageItem) and item.image_transform is not None:
+                    row, col = self._get_transformed_position(px, py, item.image_transform)
+                    self.marker_2d_row.setPos(row)
+                    self.marker_2d_col.setPos(col)
+                else:
+                    self.marker_2d_row.setPos([0, py])
+                    self.marker_2d_col.setPos([px, 0])
+
+                self.coordinatesChanged2D.emit((name, px, py))
 
     def mouse_clicked(self, event):
         """Handles the mouse clicked event, updating the crosshair position and emitting signals.
@@ -380,6 +507,7 @@ class Crosshair(QObject):
                 # not sure how we got here, but just to be safe...
                 return
 
+            precision = self._current_precision()
             for item in self.items:
                 if isinstance(item, pg.PlotDataItem):
                     name = item.name() or str(id(item))
@@ -391,24 +519,44 @@ class Crosshair(QObject):
                     x_snapped_scaled, y_snapped_scaled = self.scale_emitted_coordinates(x, y)
                     coordinate_to_emit = (
                         name,
-                        round(x_snapped_scaled, self.precision),
-                        round(y_snapped_scaled, self.precision),
+                        round(x_snapped_scaled, precision),
+                        round(y_snapped_scaled, precision),
                     )
                     self.coordinatesClicked1D.emit(coordinate_to_emit)
                 elif isinstance(item, pg.ImageItem):
-                    name = item.config.monitor or str(id(item))
+                    name = item.objectName() or str(id(item))
                     x, y = x_snap_values[name], y_snap_values[name]
                     if x is None or y is None:
                         continue
-                    # Set position of horizontal ROI (row)
-                    self.marker_2d_row.setPos([0, y])
-                    # Set position of vertical ROI (column)
-                    self.marker_2d_col.setPos([x, 0])
+
+                    if isinstance(item, ImageItem) and item.image_transform is not None:
+                        row, col = self._get_transformed_position(x, y, item.image_transform)
+                        self.marker_2d_row.setPos(row)
+                        self.marker_2d_col.setPos(col)
+                    else:
+                        self.marker_2d_row.setPos([0, y])
+                        self.marker_2d_col.setPos([x, 0])
+
                     coordinate_to_emit = (name, x, y)
                     self.coordinatesClicked2D.emit(coordinate_to_emit)
                 else:
                     continue
 
+    def _get_transformed_position(
+        self, x: float, y: float, transform: QTransform
+    ) -> tuple[QPointF, QPointF]:
+        """
+        Maps the given x and y coordinates to the transformed position using the provided transform.
+        Args:
+            x (float): The x-coordinate to transform.
+            y (float): The y-coordinate to transform.
+            transform (QTransform): The transformation to apply.
+        """
+        origin = transform.map(QPointF(0, 0))
+        row = transform.map(QPointF(0, y)) - origin
+        col = transform.map(QPointF(x, 0)) - origin
+        return row, col
+
     def clear_markers(self):
         """Clears the markers from the plot."""
         for marker in self.marker_moved_1d.values():
@@ -443,16 +591,27 @@ class Crosshair(QObject):
         """
         x, y = pos
         x_scaled, y_scaled = self.scale_emitted_coordinates(x, y)
-        text = f"({x_scaled:.{self.precision}g}, {y_scaled:.{self.precision}g})"
+        precision = self._current_precision()
+        text = f"({x_scaled:.{precision}f}, {y_scaled:.{precision}f})"
         for item in self.items:
             if isinstance(item, pg.ImageItem):
                 image = item.image
                 if image is None:
                     continue
-                ix = int(np.clip(x, 0, image.shape[0] - 1))
-                iy = int(np.clip(y, 0, image.shape[1] - 1))
+
+                if item.image_transform is not None:
+                    inv_transform, _ = item.image_transform.inverted()
+                    pt = inv_transform.map(QPointF(x, y))
+                    px, py = pt.x(), pt.y()
+                else:
+                    px, py = x, y
+
+                # Clip to valid pixel indices
+                ix = int(np.clip(px, 0, image.shape[0] - 1))  # column
+                iy = int(np.clip(py, 0, image.shape[1] - 1))  # row
+
                 intensity = image[ix, iy]
-                text += f"\nIntensity: {intensity:.{self.precision}g}"
+                text += f"\nIntensity: {intensity:.{precision}f}"
                 break
         # Update coordinate label
         self.coord_label.setText(text)
@@ -470,15 +629,19 @@ class Crosshair(QObject):
         self.is_derivative = self.plot_item.ctrl.derivativeCheck.isChecked()
         self.clear_markers()
 
-    def cleanup(self):
+    @SafeSlot()
+    def reset(self):
+        """Resets the crosshair to its initial state."""
         if self.marker_2d_row is not None:
             self.plot_item.removeItem(self.marker_2d_row)
             self.marker_2d_row = None
         if self.marker_2d_col is not None:
             self.plot_item.removeItem(self.marker_2d_col)
             self.marker_2d_col = None
+        self.clear_markers()
+
+    def cleanup(self):
+        self.reset()
         self.plot_item.removeItem(self.v_line)
         self.plot_item.removeItem(self.h_line)
         self.plot_item.removeItem(self.coord_label)
-
-        self.clear_markers()

bec_widgets/utils/entry_validator.py

@@ -28,6 +28,10 @@ class EntryValidator:
         if not available_entries:
             available_entries = [name]
 
+        # edge case for if name is passed instead of full_name, should not happen
+        if entry in signals_dict:
+            entry = signals_dict[entry].get("obj_name", entry)
+
         if entry is None or entry == "":
             entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
         if entry not in available_entries:

bec_widgets/utils/expandable_frame.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 from bec_qthemes import material_icon
+from qtpy.QtCore import Signal
 from qtpy.QtWidgets import (
+    QApplication,
     QFrame,
     QHBoxLayout,
     QLabel,
@@ -12,15 +14,20 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
+from bec_widgets.utils.clickable_label import ClickableLabel
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 
 
 class ExpandableGroupFrame(QFrame):
 
+    expansion_state_changed = Signal()
+
     EXPANDED_ICON_NAME: str = "collapse_all"
     COLLAPSED_ICON_NAME: str = "expand_all"
 
-    def __init__(self, title: str, parent: QWidget | None = None, expanded: bool = True) -> None:
+    def __init__(
+        self, parent: QWidget | None = None, title: str = "", expanded: bool = True, icon: str = ""
+    ) -> None:
         super().__init__(parent=parent)
         self._expanded = expanded
 
@@ -29,19 +36,33 @@ class ExpandableGroupFrame(QFrame):
         self._layout = QVBoxLayout()
         self._layout.setContentsMargins(0, 0, 0, 0)
         self.setLayout(self._layout)
-        self._title_layout = QHBoxLayout()
-        self._layout.addLayout(self._title_layout)
-        self._expansion_button = QToolButton()
-        self._update_icon()
-        self._title = QLabel(f"<b>{title}</b>")
-        self._title_layout.addWidget(self._expansion_button)
-        self._title_layout.addWidget(self._title)
+
+        self._create_title_layout(title, icon)
 
         self._contents = QWidget(self)
         self._layout.addWidget(self._contents)
 
         self._expansion_button.clicked.connect(self.switch_expanded_state)
         self.expanded = self._expanded  # type: ignore
+        self.expansion_state_changed.emit()
+
+    def _create_title_layout(self, title: str, icon: str):
+        self._title_layout = QHBoxLayout()
+        self._layout.addLayout(self._title_layout)
+
+        self._title = ClickableLabel(f"<b>{title}</b>")
+        self._title_icon = ClickableLabel()
+        self._title_layout.addWidget(self._title_icon)
+        self._title_layout.addWidget(self._title)
+        self.icon_name = icon
+        self._title.clicked.connect(self.switch_expanded_state)
+        self._title_icon.clicked.connect(self.switch_expanded_state)
+
+        self._title_layout.addStretch(1)
+
+        self._expansion_button = QToolButton()
+        self._update_expansion_icon()
+        self._title_layout.addWidget(self._expansion_button, stretch=1)
 
     def set_layout(self, layout: QLayout) -> None:
         self._contents.setLayout(layout)
@@ -50,7 +71,8 @@ class ExpandableGroupFrame(QFrame):
     @SafeSlot()
     def switch_expanded_state(self):
         self.expanded = not self.expanded  # type: ignore
-        self._update_icon()
+        self._update_expansion_icon()
+        self.expansion_state_changed.emit()
 
     @SafeProperty(bool)
     def expanded(self):  # type: ignore
@@ -61,8 +83,9 @@ class ExpandableGroupFrame(QFrame):
         self._expanded = expanded
         self._contents.setVisible(expanded)
         self.updateGeometry()
+        self.adjustSize()
 
-    def _update_icon(self):
+    def _update_expansion_icon(self):
         self._expansion_button.setIcon(
             material_icon(icon_name=self.EXPANDED_ICON_NAME, size=(10, 10), convert_to_pixmap=False)
             if self.expanded
@@ -70,3 +93,36 @@ class ExpandableGroupFrame(QFrame):
                 icon_name=self.COLLAPSED_ICON_NAME, size=(10, 10), convert_to_pixmap=False
             )
         )
+
+    @SafeProperty(str)
+    def icon_name(self):  # type: ignore
+        return self._title_icon_name
+
+    @icon_name.setter
+    def icon_name(self, icon_name: str):
+        self._title_icon_name = icon_name
+        self._set_title_icon(self._title_icon_name)
+
+    def _set_title_icon(self, icon_name: str):
+        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)
+            )
+        else:
+            self._title_icon.setVisible(False)
+
+
+# Application example
+if __name__ == "__main__":  # pragma: no cover
+
+    app = QApplication([])
+    frame = ExpandableGroupFrame()
+    layout = QVBoxLayout()
+    frame.set_layout(layout)
+    layout.addWidget(QLabel("test1"))
+    layout.addWidget(QLabel("test2"))
+    layout.addWidget(QLabel("test3"))
+
+    frame.show()
+    app.exec()

bec_widgets/utils/filter_io.py

@@ -8,6 +8,8 @@ from bec_lib.logger import bec_logger
 from qtpy.QtCore import QStringListModel
 from qtpy.QtWidgets import QComboBox, QCompleter, QLineEdit
 
+from bec_widgets.utils.ophyd_kind_util import Kind
+
 logger = bec_logger.logger
 
 
@@ -15,11 +17,13 @@ class WidgetFilterHandler(ABC):
     """Abstract base class for widget filter handlers"""
 
     @abstractmethod
-    def set_selection(self, widget, selection: list) -> None:
+    def set_selection(self, widget, selection: list[str | tuple]) -> None:
         """Set the filtered_selection for the widget
 
         Args:
-            selection (list): Filtered selection of items
+            widget: Widget instance
+            selection (list[str | tuple]): Filtered selection of items.
+                If tuple, it contains (text, data) pairs.
         """
 
     @abstractmethod
@@ -34,17 +38,37 @@ class WidgetFilterHandler(ABC):
             bool: True if the input text is in the filtered selection
         """
 
+    @abstractmethod
+    def update_with_kind(
+        self, kind: Kind, signal_filter: set, device_info: dict, device_name: str
+    ) -> list[str | tuple]:
+        """Update the selection based on the kind of signal.
+
+        Args:
+            kind (Kind): The kind of signal to filter.
+            signal_filter (set): Set of signal kinds to filter.
+            device_info (dict): Dictionary containing device information.
+            device_name (str): Name of the device.
+
+        Returns:
+            list[str | tuple]: A list of filtered signals based on the kind.
+        """
+        # This method should be implemented in subclasses or extended as needed
+
 
 class LineEditFilterHandler(WidgetFilterHandler):
     """Handler for QLineEdit widget"""
 
-    def set_selection(self, widget: QLineEdit, selection: list) -> None:
+    def set_selection(self, widget: QLineEdit, selection: list[str | tuple]) -> None:
         """Set the selection for the widget to the completer model
 
         Args:
             widget (QLineEdit): The QLineEdit widget
-            selection (list): Filtered selection of items
+            selection (list[str | tuple]): Filtered selection of items. If tuple, it contains (text, data) pairs.
         """
+        if isinstance(selection, tuple):
+            # If selection is a tuple, it contains (text, data) pairs
+            selection = [text for text, _ in selection]
         if not isinstance(widget.completer, QCompleter):
             completer = QCompleter(widget)
             widget.setCompleter(completer)
@@ -64,19 +88,47 @@ class LineEditFilterHandler(WidgetFilterHandler):
         model_data = [model.data(model.index(i)) for i in range(model.rowCount())]
         return text in model_data
 
+    def update_with_kind(
+        self, kind: Kind, signal_filter: set, device_info: dict, device_name: str
+    ) -> list[str | tuple]:
+        """Update the selection based on the kind of signal.
+
+        Args:
+            kind (Kind): The kind of signal to filter.
+            signal_filter (set): Set of signal kinds to filter.
+            device_info (dict): Dictionary containing device information.
+            device_name (str): Name of the device.
+
+        Returns:
+            list[str | tuple]: A list of filtered signals based on the kind.
+        """
+
+        return [
+            signal
+            for signal, signal_info in device_info.items()
+            if kind in signal_filter and (signal_info.get("kind_str", None) == str(kind.name))
+        ]
+
 
 class ComboBoxFilterHandler(WidgetFilterHandler):
     """Handler for QComboBox widget"""
 
-    def set_selection(self, widget: QComboBox, selection: list) -> None:
+    def set_selection(self, widget: QComboBox, selection: list[str | tuple]) -> None:
         """Set the selection for the widget to the completer model
 
         Args:
             widget (QComboBox): The QComboBox widget
-            selection (list): Filtered selection of items
+            selection (list[str | tuple]): Filtered selection of items. If tuple, it contains (text, data) pairs.
         """
         widget.clear()
-        widget.addItems(selection)
+        if len(selection) == 0:
+            return
+        for element in selection:
+            if isinstance(element, str):
+                widget.addItem(element)
+            elif isinstance(element, tuple):
+                # If element is a tuple, it contains (text, data) pairs
+                widget.addItem(*element)
 
     def check_input(self, widget: QComboBox, text: str) -> bool:
         """Check if the input text is in the filtered selection
@@ -90,6 +142,40 @@ class ComboBoxFilterHandler(WidgetFilterHandler):
         """
         return text in [widget.itemText(i) for i in range(widget.count())]
 
+    def update_with_kind(
+        self, kind: Kind, signal_filter: set, device_info: dict, device_name: str
+    ) -> list[str | tuple]:
+        """Update the selection based on the kind of signal.
+
+        Args:
+            kind (Kind): The kind of signal to filter.
+            signal_filter (set): Set of signal kinds to filter.
+            device_info (dict): Dictionary containing device information.
+            device_name (str): Name of the device.
+
+        Returns:
+            list[str | tuple]: A list of filtered signals based on the kind.
+        """
+        out = []
+        for signal, signal_info in device_info.items():
+            if kind not in signal_filter or (signal_info.get("kind_str", None) != str(kind.name)):
+                continue
+            obj_name = signal_info.get("obj_name", "")
+            component_name = signal_info.get("component_name", "")
+            signal_wo_device = obj_name.removeprefix(f"{device_name}_")
+            if not signal_wo_device:
+                signal_wo_device = obj_name
+
+            if signal_wo_device != signal and component_name.replace(".", "_") != signal_wo_device:
+                # If the object name is not the same as the signal name, we use the object name
+                # to display in the combobox.
+                out.append((f"{signal_wo_device} ({signal})", signal_info))
+            else:
+                # If the object name is the same as the signal name, we do not change it.
+                out.append((signal, signal_info))
+
+        return out
+
 
 class FilterIO:
     """Public interface to set filters for input widgets.
@@ -99,13 +185,14 @@ class FilterIO:
     _handlers = {QLineEdit: LineEditFilterHandler, QComboBox: ComboBoxFilterHandler}
 
     @staticmethod
-    def set_selection(widget, selection: list, ignore_errors=True):
+    def set_selection(widget, selection: list[str | tuple], ignore_errors=True):
         """
         Retrieve value from the widget instance.
 
         Args:
             widget: Widget instance.
-            selection(list): List of filtered selection items.
+            selection (list[str | tuple]): Filtered selection of items.
+                If tuple, it contains (text, data) pairs.
             ignore_errors(bool, optional): Whether to ignore if no handler is found.
         """
         handler_class = FilterIO._find_handler(widget)
@@ -139,6 +226,35 @@ class FilterIO:
             )
         return None
 
+    @staticmethod
+    def update_with_kind(
+        widget, kind: Kind, signal_filter: set, device_info: dict, device_name: str
+    ) -> list[str | tuple]:
+        """
+        Update the selection based on the kind of signal.
+
+        Args:
+            widget: Widget instance.
+            kind (Kind): The kind of signal to filter.
+            signal_filter (set): Set of signal kinds to filter.
+            device_info (dict): Dictionary containing device information.
+            device_name (str): Name of the device.
+
+        Returns:
+            list[str | tuple]: A list of filtered signals based on the kind.
+        """
+        handler_class = FilterIO._find_handler(widget)
+        if handler_class:
+            return handler_class().update_with_kind(
+                kind=kind,
+                signal_filter=signal_filter,
+                device_info=device_info,
+                device_name=device_name,
+            )
+        raise ValueError(
+            f"No matching handler for widget type: {type(widget)} in handler list {FilterIO._handlers}"
+        )
+
     @staticmethod
     def _find_handler(widget):
         """

bec_widgets/utils/forms_from_types/forms.py

@@ -1,76 +1,107 @@
 from __future__ import annotations
 
-from decimal import Decimal
 from types import NoneType
+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.QtWidgets import QGridLayout, QLabel, QLayout, QVBoxLayout, QWidget
+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.forms_from_types.items import FormItemSpec, widget_from_type
+from bec_widgets.utils.error_popups import SafeProperty
+from bec_widgets.utils.forms_from_types import styles
+from bec_widgets.utils.forms_from_types.items import (
+    DynamicFormItem,
+    DynamicFormItemType,
+    FormItemSpec,
+    widget_from_type,
+)
 
 logger = bec_logger.logger
 
 
+class GridRow(NamedTuple):
+    i: int
+    label: QLabel
+    widget: DynamicFormItem
+
+
 class TypedForm(BECWidget, QWidget):
     PLUGIN = True
     ICON_NAME = "list_alt"
 
     value_changed = Signal()
 
-    RPC = False
+    RPC = True
+    USER_ACCESS = ["enabled", "enabled.setter"]
 
     def __init__(
         self,
         parent=None,
         items: list[tuple[str, type]] | None = None,
         form_item_specs: list[FormItemSpec] | None = None,
+        enabled: bool = True,
+        pretty_display: bool = False,
         client=None,
         **kwargs,
     ):
         """Widget with a list of form items based on a list of types.
 
         Args:
-            items (list[tuple[str, type]]): list of tuples of a name for the field and its type.
-                                            Should be a type supported by the logic in items.py
-            form_item_specs (list[FormItemSpec]): list of form item specs, equivalent to items.
-                                                  only one of items or form_item_specs should be
-                                                  supplied.
-
+            items (list[tuple[str, type]]):         list of tuples of a name for the field and its type.
+                                                    Should be a type supported by the logic in items.py
+            form_item_specs (list[FormItemSpec]):   list of form item specs, equivalent to items.
+                                                    only one of items or form_item_specs should be
+                                                    supplied.
+            enabled (bool, optional):               whether fields are enabled for editing.
+            pretty_display (bool, optional): Whether to use a pretty display for the widget. Defaults to False. If True, disables the widget, doesn't add a clear button, and adapts the stylesheet for non-editable display.
         """
-        if (items is not None and form_item_specs is not None) or (
-            items is None and form_item_specs is None
-        ):
-            raise ValueError("Must specify one and only one of items and form_item_specs")
+        if items is not None and form_item_specs is not None:
+            logger.error(
+                "Must specify one and only one of items and form_item_specs! Ignoring `items`."
+            )
+            items = None
+        if items is None and form_item_specs is None:
+            logger.error("Must specify one and only one of items and form_item_specs!")
+            items = []
         super().__init__(parent=parent, client=client, **kwargs)
-        self._items = (
-            form_item_specs
-            if form_item_specs is not None
-            else [
-                FormItemSpec(name=name, item_type=item_type)
-                for name, item_type in items  # type: ignore
-            ]
-        )
+        self._items = form_item_specs or [
+            FormItemSpec(name=name, item_type=item_type, pretty_display=pretty_display)
+            for name, item_type in items  # type: ignore
+        ]
+        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
         self._layout = QVBoxLayout()
         self._layout.setContentsMargins(0, 0, 0, 0)
         self.setLayout(self._layout)
 
+        self._enabled: bool = enabled
+
         self._form_grid_container = QWidget(parent=self)
+        self._form_grid_container.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
         self._form_grid = QWidget(parent=self._form_grid_container)
+        self._form_grid.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
         self._layout.addWidget(self._form_grid_container)
         self._form_grid_container.setLayout(QVBoxLayout())
         self._form_grid.setLayout(self._new_grid_layout())
 
+        self._widget_types: dict | None = None
+        self._widget_from_type = widget_from_type
+        self._post_init()
+
+    def _post_init(self):
+        """Override this if a subclass should do things after super().__init__ and before populate()"""
         self.populate()
+        self.enabled = self._enabled  # type: ignore # QProperty
 
     def populate(self):
         self._clear_grid()
         for r, item in enumerate(self._items):
             self._add_griditem(item, r)
+        gl: QGridLayout = self._form_grid.layout()
+        gl.setRowStretch(gl.rowCount(), 1)
 
     def _add_griditem(self, item: FormItemSpec, row: int):
         grid = self._form_grid.layout()
@@ -78,19 +109,22 @@ class TypedForm(BECWidget, QWidget):
         label.setProperty("_model_field_name", item.name)
         label.setToolTip(item.info.description or item.name)
         grid.addWidget(label, row, 0)
-        widget = widget_from_type(item.item_type)(parent=self, spec=item)
+        widget = self._widget_from_type(item, self._widget_types)(parent=self, spec=item)
         widget.valueChanged.connect(self.value_changed)
+        widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
         grid.addWidget(widget, row, 1)
 
-    def _dict_from_grid(self) -> dict[str, str | int | float | Decimal | bool]:
+    def enumerate_form_widgets(self):
+        """Return a generator over the rows of the form, with the row number, the label widget (to
+        which the field name is attached as a property "_model_field_name"), and the entry widget"""
         grid: QGridLayout = self._form_grid.layout()  # type: ignore
+        for i in range(grid.rowCount() - 1):  # One extra row for stretch
+            yield GridRow(i, grid.itemAtPosition(i, 0).widget(), grid.itemAtPosition(i, 1).widget())
+
+    def _dict_from_grid(self) -> dict[str, DynamicFormItemType]:
         return {
-            grid.itemAtPosition(i, 0)
-            .widget()
-            .property("_model_field_name"): grid.itemAtPosition(i, 1)
-            .widget()
-            .getValue()  # type: ignore # we only add 'DynamicFormItem's here
-            for i in range(grid.rowCount())
+            row.label.property("_model_field_name"): row.widget.getValue()
+            for row in self.enumerate_form_widgets()
         }
 
     def _clear_grid(self):
@@ -103,10 +137,13 @@ class TypedForm(BECWidget, QWidget):
             old_layout.deleteLater()
             self._form_grid.deleteLater()
         self._form_grid = QWidget()
-
+        self._form_grid.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
         self._form_grid.setLayout(self._new_grid_layout())
         self._form_grid_container.layout().addWidget(self._form_grid)
 
+        self.update_size()
+
+    def update_size(self):
         self._form_grid.adjustSize()
         self._form_grid_container.adjustSize()
         self.adjustSize()
@@ -114,27 +151,61 @@ class TypedForm(BECWidget, QWidget):
     def _new_grid_layout(self):
         new_grid = QGridLayout()
         new_grid.setContentsMargins(0, 0, 0, 0)
-        new_grid.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
         return new_grid
 
+    @property
+    def widget_dict(self):
+        return {
+            row.label.property("_model_field_name"): row.widget
+            for row in self.enumerate_form_widgets()
+        }
+
+    @SafeProperty(bool)
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value: bool):
+        self._enabled = value
+        self.setEnabled(value)
+
 
 class PydanticModelForm(TypedForm):
-    metadata_updated = Signal(dict)
-    metadata_cleared = Signal(NoneType)
+    form_data_updated = Signal(dict)
+    form_data_cleared = Signal(NoneType)
+    validity_proc = Signal(bool)
 
-    def __init__(self, parent=None, metadata_model: type[BaseModel] = None, client=None, **kwargs):
+    def __init__(
+        self,
+        parent=None,
+        data_model: type[BaseModel] | None = None,
+        enabled: bool = True,
+        pretty_display: bool = False,
+        client=None,
+        **kwargs,
+    ):
         """
         A form generated from a pydantic model.
 
         Args:
-            metadata_model (type[BaseModel]): the model class for which to generate a form.
+            data_model (type[BaseModel]): the model class for which to generate a form.
+            enabled (bool, optional): whether fields are enabled for editing.
+            pretty_display (bool, optional): Whether to use a pretty display for the widget. Defaults to False. If True, disables the widget, doesn't add a clear button, and adapts the stylesheet for non-editable display.
+
         """
-        self._md_schema = metadata_model
-        super().__init__(parent=parent, form_item_specs=self._form_item_specs(), client=client)
+        self._pretty_display = pretty_display
+        self._md_schema = data_model
+        super().__init__(
+            parent=parent,
+            form_item_specs=self._form_item_specs(),
+            enabled=enabled,
+            client=client,
+            **kwargs,
+        )
 
         self._validity = CompactPopupWidget()
         self._validity.compact_view = True  # type: ignore
-        self._validity.label = "Metadata validity"  # 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)
         )
@@ -143,13 +214,40 @@ class PydanticModelForm(TypedForm):
         self._layout.addWidget(self._validity)
         self.value_changed.connect(self.validate_form)
 
+        self._connect_to_theme_change()
+
+    def set_pretty_display_theme(self, theme: str = "dark"):
+        if self._pretty_display:
+            self.setStyleSheet(styles.pretty_display_theme(theme))
+
+    def _connect_to_theme_change(self):
+        """Connect to the theme change signal."""
+        qapp = QApplication.instance()
+        if hasattr(qapp, "theme_signal"):
+            qapp.theme_signal.theme_updated.connect(self.set_pretty_display_theme)  # type: ignore
+
     def set_schema(self, schema: type[BaseModel]):
         self._md_schema = schema
         self.populate()
 
+    def set_data(self, data: BaseModel):
+        """Fill the data for the form.
+
+        Args:
+            data (BaseModel):   the data to enter into the form. Must be the same type as the
+                                currently set schema, raises TypeError otherwise."""
+        if not self._md_schema:
+            raise ValueError("Schema not set - can't set data")
+        if not isinstance(data, self._md_schema):
+            raise TypeError(f"Supplied data {data} not of type {self._md_schema}")
+        for form_item in self.enumerate_form_widgets():
+            form_item.widget.setValue(getattr(data, form_item.label.property("_model_field_name")))
+
     def _form_item_specs(self):
         return [
-            FormItemSpec(name=name, info=info, item_type=info.annotation)
+            FormItemSpec(
+                name=name, info=info, item_type=info.annotation, pretty_display=self._pretty_display
+            )
             for name, info in self._md_schema.model_fields.items()
         ]
 
@@ -167,16 +265,18 @@ class PydanticModelForm(TypedForm):
     def validate_form(self, *_) -> bool:
         """validate the currently entered metadata against the pydantic schema.
         If successful, returns on metadata_emitted and returns true.
-        Otherwise, emits on metadata_cleared and returns false."""
+        Otherwise, emits on form_data_cleared and returns false."""
         try:
             metadata_dict = self.get_form_data()
             self._md_schema.model_validate(metadata_dict)
             self._validity.set_global_state("success")
             self._validity_message.setText("No errors!")
-            self.metadata_updated.emit(metadata_dict)
+            self.form_data_updated.emit(metadata_dict)
+            self.validity_proc.emit(True)
             return True
         except ValidationError as e:
             self._validity.set_global_state("emergency")
             self._validity_message.setText(str(e))
-            self.metadata_cleared.emit(None)
+            self.form_data_cleared.emit(None)
+            self.validity_proc.emit(False)
             return False

bec_widgets/utils/forms_from_types/items.py

@@ -1,31 +1,44 @@
 from __future__ import annotations
 
+import typing
 from abc import abstractmethod
 from decimal import Decimal
-from types import UnionType
-from typing import Callable, Protocol
+from types import GenericAlias, UnionType
+from typing import Callable, Final, Iterable, Literal, NamedTuple, OrderedDict, get_args
 
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 from pydantic.fields import FieldInfo
-from qtpy.QtCore import Signal  # type: ignore
+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.QtWidgets import (
     QApplication,
     QButtonGroup,
     QCheckBox,
+    QComboBox,
     QDoubleSpinBox,
     QGridLayout,
     QHBoxLayout,
     QLabel,
     QLayout,
     QLineEdit,
+    QListWidget,
+    QListWidgetItem,
+    QPushButton,
     QRadioButton,
+    QSizePolicy,
     QSpinBox,
     QToolButton,
+    QVBoxLayout,
     QWidget,
 )
 
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.widget_io import WidgetIO
+from bec_widgets.widgets.editors.dict_backed_table import DictBackedTable
 from bec_widgets.widgets.editors.scan_metadata._util import (
     clearable_required,
     field_default,
@@ -34,6 +47,7 @@ from bec_widgets.widgets.editors.scan_metadata._util import (
     field_minlen,
     field_precision,
 )
+from bec_widgets.widgets.utility.toggle.toggle import ToggleSwitch
 
 logger = bec_logger.logger
 
@@ -46,9 +60,36 @@ class FormItemSpec(BaseModel):
     """
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
-    item_type: type | UnionType
+
+    item_type: type | UnionType | GenericAlias
     name: str
     info: FieldInfo = FieldInfo()
+    pretty_display: bool = Field(
+        default=False,
+        description="Whether to use a pretty display for the widget. Defaults to False. If True, disables the widget, doesn't add a clear button, and adapts the stylesheet for non-editable display.",
+    )
+
+    @field_validator("item_type", mode="before")
+    @classmethod
+    def _validate_type(cls, v):
+        allowed_primitives = [str, int, float, bool]
+        if isinstance(v, (type, UnionType)):
+            return v
+        if isinstance(v, GenericAlias):
+            if v.__origin__ in [list, dict, set] and all(
+                arg in allowed_primitives for arg in v.__args__
+            ):
+                return v
+            raise ValueError(
+                f"Generics of type {v} are not supported - only lists, dicts and sets of primitive types {allowed_primitives}"
+            )
+        if type(v) is type(Literal[""]):  # _LiteralGenericAlias is not exported from typing
+            arg_types = set(type(arg) for arg in v.__args__)
+            if len(arg_types) != 1:
+                raise ValueError("Mixtures of literal types are not supported!")
+            if (t := arg_types.pop()) in allowed_primitives:
+                return t
+            raise ValueError(f"Literals of type {t} are not supported")
 
 
 class ClearableBoolEntry(QWidget):
@@ -94,10 +135,20 @@ class ClearableBoolEntry(QWidget):
         self._false.setToolTip(tooltip)
 
 
+DynamicFormItemType = str | int | float | Decimal | bool | dict | list | None
+
+
 class DynamicFormItem(QWidget):
     valueChanged = Signal()
 
     def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
+        """
+        Initializes the form item widget.
+
+        Args:
+            parent (QWidget | None, optional): The parent widget. Defaults to None.
+            spec (FormItemSpec): The specification for the form item.
+        """
         super().__init__(parent)
         self._spec = spec
         self._layout = QHBoxLayout()
@@ -107,11 +158,17 @@ class DynamicFormItem(QWidget):
         self._desc = self._spec.info.description
         self.setLayout(self._layout)
         self._add_main_widget()
-        if clearable_required(spec.info):
-            self._add_clear_button()
+        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)
+        if not spec.pretty_display:
+            if clearable_required(spec.info):
+                self._add_clear_button()
+        else:
+            self._set_pretty_display()
 
     @abstractmethod
-    def getValue(self): ...
+    def getValue(self) -> DynamicFormItemType: ...
 
     @abstractmethod
     def setValue(self, value): ...
@@ -121,6 +178,11 @@ class DynamicFormItem(QWidget):
         """Add the main data entry widget to self._main_widget and appply any
         constraints from the field info"""
 
+    def _set_pretty_display(self):
+        self.setEnabled(False)
+        if button := getattr(self, "_clear_button", None):
+            button.setVisible(False)
+
     def _describe(self, pad=" "):
         return pad + (self._desc if self._desc else "")
 
@@ -138,7 +200,7 @@ class DynamicFormItem(QWidget):
         self.valueChanged.emit()
 
 
-class StrMetadataField(DynamicFormItem):
+class StrFormItem(DynamicFormItem):
     def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
         super().__init__(parent=parent, spec=spec)
         self._main_widget.textChanged.connect(self._value_changed)
@@ -163,11 +225,11 @@ class StrMetadataField(DynamicFormItem):
 
     def setValue(self, value: str):
         if value is None:
-            self._main_widget.setText("")
-        self._main_widget.setText(value)
+            return self._main_widget.setText("")
+        self._main_widget.setText(str(value))
 
 
-class IntMetadataField(DynamicFormItem):
+class IntFormItem(DynamicFormItem):
     def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
         super().__init__(parent=parent, spec=spec)
         self._main_widget.textChanged.connect(self._value_changed)
@@ -196,18 +258,18 @@ class IntMetadataField(DynamicFormItem):
         self._main_widget.setValue(value)
 
 
-class FloatDecimalMetadataField(DynamicFormItem):
+class FloatDecimalFormItem(DynamicFormItem):
     def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
         super().__init__(parent=parent, spec=spec)
         self._main_widget.textChanged.connect(self._value_changed)
 
     def _add_main_widget(self) -> None:
+        precision = field_precision(self._spec.info)
         self._main_widget = QDoubleSpinBox()
         self._layout.addWidget(self._main_widget)
-        min_, max_ = field_limits(self._spec.info, int)
+        min_, max_ = field_limits(self._spec.info, float, precision)
         self._main_widget.setMinimum(min_)
         self._main_widget.setMaximum(max_)
-        precision = field_precision(self._spec.info)
         if precision:
             self._main_widget.setDecimals(precision)
         minstr = f"{float(min_):.3f}" if abs(min_) <= 1000 else f"{float(min_):.3e}"
@@ -224,13 +286,13 @@ class FloatDecimalMetadataField(DynamicFormItem):
             return self._default
         return self._main_widget.value()
 
-    def setValue(self, value: float):
+    def setValue(self, value: float | Decimal):
         if value is None:
             self._main_widget.clear()
-        self._main_widget.setValue(value)
+        self._main_widget.setValue(float(value))
 
 
-class BoolMetadataField(DynamicFormItem):
+class BoolFormItem(DynamicFormItem):
     def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
         super().__init__(parent=parent, spec=spec)
         self._main_widget.stateChanged.connect(self._value_changed)
@@ -251,36 +313,312 @@ class BoolMetadataField(DynamicFormItem):
         self._main_widget.setChecked(value)
 
 
-def widget_from_type(annotation: type | UnionType | None) -> type[DynamicFormItem]:
-    if annotation in [str, str | None]:
-        return StrMetadataField
-    if annotation in [int, int | None]:
-        return IntMetadataField
-    if annotation in [float, float | None, Decimal, Decimal | None]:
-        return FloatDecimalMetadataField
-    if annotation in [bool, bool | None]:
-        return BoolMetadataField
-    else:
-        logger.warning(f"Type {annotation} is not (yet) supported in metadata form creation.")
-        return StrMetadataField
+class BoolToggleFormItem(BoolFormItem):
+    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
+        if spec.info.default is PydanticUndefined:
+            spec.info.default = False
+        super().__init__(parent=parent, spec=spec)
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = ToggleSwitch()
+        self._layout.addWidget(self._main_widget)
+        self._main_widget.setToolTip(self._describe(""))
+        if self._default is not None:
+            self._main_widget.setChecked(self._default)
+
+
+class DictFormItem(DynamicFormItem):
+    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
+        super().__init__(parent=parent, spec=spec)
+        self._main_widget.data_changed.connect(self._value_changed)
+        if spec.info.default is not PydanticUndefined:
+            self._main_widget.set_default(spec.info.default)
+
+    def _set_pretty_display(self):
+        self._main_widget.set_button_visibility(False)
+        super()._set_pretty_display()
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = DictBackedTable(self, [])
+        self._layout.addWidget(self._main_widget)
+        self._main_widget.setToolTip(self._describe(""))
+
+    def getValue(self):
+        return self._main_widget.dump_dict()
+
+    def setValue(self, value):
+        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]
+    widget: type[QWidget]
+    default: int | float | str
+
+
+class ListFormItem(DynamicFormItem):
+    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
+        if spec.info.annotation is list:
+            self._types = _ItemAndWidgetType(str, QLineEdit, "")
+        elif isinstance(spec.info.annotation, GenericAlias):
+            args = set(typing.get_args(spec.info.annotation))
+            if args == {str}:
+                self._types = _ItemAndWidgetType(str, QLineEdit, "")
+            if args == {int}:
+                self._types = _ItemAndWidgetType(int, QSpinBox, 0)
+            if args == {float} or args == {int, float}:
+                self._types = _ItemAndWidgetType(float, QDoubleSpinBox, 0.0)
+        else:
+            self._types = _ItemAndWidgetType(str, QLineEdit, "")
+        super().__init__(parent=parent, spec=spec)
+        self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
+        self._main_widget: QListWidget
+        self._data = []
+        self._min_lines = 2 if spec.pretty_display else 4
+        self._repop(self._data)
+
+    def sizeHint(self):
+        default = super().sizeHint()
+        return QSize(default.width(), QFontMetrics(self.font()).height() * 6)
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = QListWidget()
+        self._layout.addWidget(self._main_widget)
+        self._layout.setAlignment(Qt.AlignmentFlag.AlignTop)
+        self._add_buttons()
+
+    def _add_buttons(self):
+        self._button_holder = QWidget()
+        self._button_holder.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
+        self._buttons = QVBoxLayout()
+        self._buttons.setContentsMargins(0, 0, 0, 0)
+        self._button_holder.setLayout(self._buttons)
+        self._layout.addWidget(self._button_holder)
+
+        self._add_remove_button_holder = QWidget()
+        self._add_remove_button_layout = QHBoxLayout()
+        self._add_remove_button_layout.setContentsMargins(0, 0, 0, 0)
+        self._add_remove_button_holder.setLayout(self._add_remove_button_layout)
+
+        self._add_button = QPushButton("+")
+        self._add_button.setMinimumHeight(15)
+        self._add_button.setToolTip("add a new row")
+        self._remove_button = QPushButton("-")
+        self._remove_button.setMinimumHeight(15)
+        self._remove_button.setToolTip("delete the focused row (if any)")
+        self._add_button.clicked.connect(self._add_row)
+        self._remove_button.clicked.connect(self._delete_row)
+
+        self._buttons.addWidget(self._add_remove_button_holder)
+        self._add_remove_button_layout.addWidget(self._add_button)
+        self._add_remove_button_layout.addWidget(self._remove_button)
+
+    def _set_pretty_display(self):
+        super()._set_pretty_display()
+        self._button_holder.setHidden(True)
+
+    def _repop(self, data):
+        self._main_widget.clear()
+        for val in data:
+            self._add_list_item(val)
+        self.scale_to_data()
+
+    def _add_data_item(self, val=None):
+        val = val or self._types.default
+        self._data.append(val)
+        self._add_list_item(val)
+        self._repop(self._data)
+
+    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)
+        WidgetIO.set_value(item_widget, val)
+        self._main_widget.setItemWidget(item, item_widget)
+        self._main_widget.addItem(item)
+        WidgetIO.connect_widget_change_signal(item_widget, self._update)
+        return item_widget
+
+    def _update(self, _, value, *args):
+        self._data[self._main_widget.currentRow()] = value
+
+    @SafeSlot()
+    def _add_row(self):
+        self._add_data_item(self._types.default)
+        self._repop(self._data)
+
+    @SafeSlot()
+    def _delete_row(self):
+        if selected := self._main_widget.currentItem():
+            self._main_widget.removeItemWidget(selected)
+            row = self._main_widget.currentRow()
+            self._main_widget.takeItem(row)
+            self._data.pop(row)
+        self._repop(self._data)
+
+    @SafeSlot()
+    def clear(self):
+        self._repop([])
+
+    def getValue(self):
+        return self._data
+
+    def setValue(self, value: Iterable):
+        if set(map(type, value)) | {self._types.item} != {self._types.item}:
+            raise ValueError(f"This widget only accepts items of type {self._types.item}")
+        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))
+
+    def scale_to_data(self, *_):
+        self.set_max_height_in_lines(self._main_widget.count() + 1)
+
+
+class SetFormItem(ListFormItem):
+    def _add_main_widget(self) -> None:
+        super()._add_main_widget()
+        self._add_item_field = self._types.widget()
+        self._buttons.addWidget(QLabel("Add new:"))
+        self._buttons.addWidget(self._add_item_field)
+        self.setSizePolicy(QSizePolicy.Policy.MinimumExpanding, QSizePolicy.Policy.Minimum)
+
+    @SafeSlot()
+    def _add_row(self):
+        self._add_data_item(WidgetIO.get_value(self._add_item_field))
+        self._repop(self._data)
+
+    def _update(self, _, value, *args):
+        if value in self._data:
+            return
+        return super()._update(_, value, *args)
+
+    def _add_data_item(self, val=None):
+        val = val or self._types.default
+        if val == self._types.default or val in self._data:
+            return
+        self._data.append(val)
+        self._add_list_item(val)
+
+    def _add_list_item(self, val):
+        item_widget = super()._add_list_item(val)
+        if isinstance(item_widget, QLineEdit):
+            item_widget.setReadOnly(True)
+        return item_widget
+
+    def getValue(self):
+        return set(self._data)
+
+    def setValue(self, value: set):
+        return super().setValue(set(value))
+
+
+class StrLiteralFormItem(DynamicFormItem):
+    def _add_main_widget(self) -> None:
+        self._main_widget = QComboBox()
+        self._options = get_args(self._spec.info.annotation)
+        for opt in self._options:
+            self._main_widget.addItem(opt)
+        self._layout.addWidget(self._main_widget)
+
+    def getValue(self):
+        return self._main_widget.currentText()
+
+    def setValue(self, value: str | None):
+        if value is None:
+            self.clear()
+        for i in range(self._main_widget.count()):
+            if self._main_widget.itemText(i) == value:
+                self._main_widget.setCurrentIndex(i)
+                return
+        raise ValueError(f"Cannot set value: {value}, options are: {self._options}")
+
+    def clear(self):
+        self._main_widget.setCurrentIndex(-1)
+
+
+WidgetTypeRegistry = OrderedDict[str, tuple[Callable[[FormItemSpec], bool], type[DynamicFormItem]]]
+
+DEFAULT_WIDGET_TYPES: Final[WidgetTypeRegistry] = OrderedDict() | {
+    # dict literals are ordered already but TypedForm subclasses may modify coppies of this dict
+    # and delete/insert keys or change the order
+    "literal_str": (
+        lambda spec: type(spec.info.annotation) is type(Literal[""])
+        and set(type(arg) for arg in get_args(spec.info.annotation)) == {str},
+        StrLiteralFormItem,
+    ),
+    "str": (lambda spec: spec.item_type in [str, str | None, None], StrFormItem),
+    "int": (lambda spec: spec.item_type in [int, int | None], IntFormItem),
+    "float_decimal": (
+        lambda spec: spec.item_type in [float, float | None, Decimal, Decimal | None],
+        FloatDecimalFormItem,
+    ),
+    "bool": (lambda spec: spec.item_type in [bool, bool | None], BoolFormItem),
+    "dict": (
+        lambda spec: spec.item_type in [dict, dict | None]
+        or (isinstance(spec.item_type, GenericAlias) and spec.item_type.__origin__ is dict),
+        DictFormItem,
+    ),
+    "list": (
+        lambda spec: spec.item_type in [list, list | None]
+        or (isinstance(spec.item_type, GenericAlias) and spec.item_type.__origin__ is list),
+        ListFormItem,
+    ),
+    "set": (
+        lambda spec: spec.item_type in [set, set | None]
+        or (isinstance(spec.item_type, GenericAlias) and spec.item_type.__origin__ is set),
+        SetFormItem,
+    ),
+}
+
+
+def widget_from_type(
+    spec: FormItemSpec, widget_types: WidgetTypeRegistry | None = None
+) -> type[DynamicFormItem]:
+    widget_types = widget_types or DEFAULT_WIDGET_TYPES
+    for predicate, widget_type in widget_types.values():
+        if predicate(spec):
+            return widget_type
+    logger.warning(
+        f"Type {spec.item_type=} / {spec.info.annotation=} is not (yet) supported in dynamic form creation."
+    )
+    return StrFormItem
 
 
 if __name__ == "__main__":  # pragma: no cover
 
     class TestModel(BaseModel):
+        value0: set = Field(set(["a", "b"]))
         value1: str | None = Field(None)
         value2: bool | None = Field(None)
         value3: bool = Field(True)
         value4: int = Field(123)
         value5: int | None = Field()
+        value6: list[int] = Field()
+        value7: list = Field()
 
     app = QApplication([])
     w = QWidget()
     layout = QGridLayout()
     w.setLayout(layout)
+    items = []
     for i, (field_name, info) in enumerate(TestModel.model_fields.items()):
+        spec = spec = FormItemSpec(item_type=info.annotation, name=field_name, info=info)
         layout.addWidget(QLabel(field_name), i, 0)
-        layout.addWidget(widget_from_type(info.annotation)(info), i, 1)
+        widg = widget_from_type(spec)(spec=spec)
+        items.append(widg)
+        layout.addWidget(widg, i, 1)
+
+    items[6].setValue([1, 2, 3, 4])
+    items[7].setValue(["1", "2", "asdfg", "qwerty"])
 
     w.show()
     app.exec()

bec_widgets/utils/forms_from_types/styles.py

@@ -0,0 +1,21 @@
+import bec_qthemes
+
+
+def pretty_display_theme(theme: str = "dark"):
+    palette = bec_qthemes.load_palette(theme)
+    foreground = palette.text().color().name()
+    background = palette.base().color().name()
+    border = palette.shadow().color().name()
+    accent = palette.accent().color().name()
+    return f"""
+QWidget {{color: {foreground}; background-color: {background}}}
+QLabel {{ font-weight: bold; }}
+QLineEdit,QLabel,QTreeView {{ border-style: solid; border-width: 2px; border-color: {border} }}
+QRadioButton {{ color: {foreground}; }}
+QRadioButton::indicator::checked {{ color: {accent}; }}
+QCheckBox {{ color: {accent}; }}
+"""
+
+
+if __name__ == "__main__":
+    print(pretty_display_theme())

bec_widgets/utils/generate_designer_plugin.py

@@ -8,6 +8,9 @@ from qtpy.QtCore import QObject
 from bec_widgets.utils.name_utils import pascal_to_snake
 
 EXCLUDED_PLUGINS = ["BECConnector", "BECDockArea", "BECDock", "BECFigure"]
+_PARENT_ARG_REGEX = r".__init__\(\s*(?:parent\)|parent=parent,?|parent,?)"
+_SELF_PARENT_ARG_REGEX = r".__init__\(\s*self,\s*(?:parent\)|parent=parent,?|parent,?)"
+SUPER_INIT_REGEX = re.compile(r"super\(\)" + _PARENT_ARG_REGEX, re.MULTILINE)
 
 
 class PluginFilenames(NamedTuple):
@@ -90,34 +93,20 @@ class DesignerPluginGenerator:
 
         # Check if the widget class calls the super constructor with parent argument
         init_source = inspect.getsource(self.widget.__init__)
-        cls_init_found = (
-            bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent=parent") > 0)
-            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent)") > 0)
-            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent,") > 0)
-        )
-        super_init_found = (
-            bool(
-                init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent=parent") > 0
-            )
-            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent,") > 0)
-            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent)") > 0)
+        class_re = re.compile(base_cls[0].__name__ + _SELF_PARENT_ARG_REGEX, re.MULTILINE)
+        cls_init_found = class_re.search(init_source) is not None
+        super_self_re = re.compile(
+            rf"super\({base_cls[0].__name__}, self\)" + _PARENT_ARG_REGEX, re.MULTILINE
         )
+        super_init_found = super_self_re.search(init_source) is not None
         if issubclass(self.widget.__bases__[0], QObject) and not super_init_found:
-            super_init_found = (
-                bool(init_source.find("super().__init__(parent=parent") > 0)
-                or bool(init_source.find("super().__init__(parent,") > 0)
-                or bool(init_source.find("super().__init__(parent)") > 0)
-            )
+            super_init_found = SUPER_INIT_REGEX.search(init_source) is not None
 
         # for the new style classes, we only have one super call. We can therefore check if the
         # number of __init__ calls is 2 (the class itself and the super class)
         num_inits = re.findall(r"__init__", init_source)
         if len(num_inits) == 2 and not super_init_found:
-            super_init_found = bool(
-                init_source.find("super().__init__(parent=parent") > 0
-                or init_source.find("super().__init__(parent,") > 0
-                or init_source.find("super().__init__(parent)") > 0
-            )
+            super_init_found = SUPER_INIT_REGEX.search(init_source) is not None
 
         if not cls_init_found and not super_init_found:
             raise ValueError(

bec_widgets/utils/plugin_utils.py

@@ -4,7 +4,7 @@ import importlib
 import inspect
 import os
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Iterable
 
 from bec_lib.plugin_helper import _get_available_plugins
 from qtpy.QtWidgets import QGraphicsWidget, QWidget
@@ -90,15 +90,15 @@ class BECClassInfo:
     name: str
     module: str
     file: str
-    obj: type
+    obj: type[BECWidget]
     is_connector: bool = False
     is_widget: bool = False
     is_plugin: bool = False
 
 
 class BECClassContainer:
-    def __init__(self):
-        self._collection: list[BECClassInfo] = []
+    def __init__(self, initial: Iterable[BECClassInfo] = []):
+        self._collection: list[BECClassInfo] = list(initial)
 
     def __repr__(self):
         return str(list(cl.name for cl in self.collection))
@@ -106,6 +106,16 @@ class BECClassContainer:
     def __iter__(self):
         return self._collection.__iter__()
 
+    def __add__(self, other: BECClassContainer):
+        return BECClassContainer((*self, *(c for c in other if c.name not in self.names)))
+
+    def as_dict(self, ignores: list[str] = []) -> dict[str, type[BECWidget]]:
+        """get a dict of {name: Type} for all the entries in the collection.
+
+        Args:
+            ignores(list[str]): a list of class names to exclude from the dictionary."""
+        return {c.name: c.obj for c in self if c.name not in ignores}
+
     def add_class(self, class_info: BECClassInfo):
         """
         Add a class to the collection.
@@ -115,53 +125,44 @@ class BECClassContainer:
         """
         self.collection.append(class_info)
 
+    @property
+    def names(self):
+        """Return a list of class names"""
+        return [c.name for c in self]
+
     @property
     def collection(self):
-        """
-        Get the collection of classes.
-        """
+        """Get the collection of classes."""
         return self._collection
 
     @property
     def connector_classes(self):
-        """
-        Get all connector classes.
-        """
+        """Get all connector classes."""
         return [info.obj for info in self.collection if info.is_connector]
 
     @property
     def top_level_classes(self):
-        """
-        Get all top-level classes.
-        """
+        """Get all top-level classes."""
         return [info.obj for info in self.collection if info.is_plugin]
 
     @property
     def plugins(self):
-        """
-        Get all plugins. These are all classes that are on the top level and are widgets.
-        """
+        """Get all plugins. These are all classes that are on the top level and are widgets."""
         return [info.obj for info in self.collection if info.is_widget and info.is_plugin]
 
     @property
     def widgets(self):
-        """
-        Get all widgets. These are all classes inheriting from BECWidget.
-        """
+        """Get all widgets. These are all classes inheriting from BECWidget."""
         return [info.obj for info in self.collection if info.is_widget]
 
     @property
     def rpc_top_level_classes(self):
-        """
-        Get all top-level classes that are RPC-enabled. These are all classes that users can choose from.
-        """
+        """Get all top-level classes that are RPC-enabled. These are all classes that users can choose from."""
         return [info.obj for info in self.collection if info.is_plugin and info.is_connector]
 
     @property
     def classes(self):
-        """
-        Get all classes.
-        """
+        """Get all classes."""
         return [info.obj for info in self.collection]
 
 
@@ -197,7 +198,7 @@ def get_custom_classes(repo_name: str) -> BECClassContainer:
                 if not hasattr(obj, "__module__") or obj.__module__ != module.__name__:
                     continue
                 if isinstance(obj, type):
-                    class_info = BECClassInfo(name=name, module=module_name, file=path, obj=obj)
+                    class_info = BECClassInfo(name=name, module=module.__name__, file=path, obj=obj)
                     if issubclass(obj, BECConnector):
                         class_info.is_connector = True
                     if issubclass(obj, BECWidget):

bec_widgets/utils/rpc_server.py

@@ -195,7 +195,7 @@ class RPCServer:
             return
         self._broadcasted_data = data
 
-        logger.info(f"Broadcasting registry update: {data} for {self.gui_id}")
+        logger.debug(f"Broadcasting registry update: {data} for {self.gui_id}")
         self.client.connector.xadd(
             MessageEndpoints.gui_registry_state(self.gui_id),
             msg_dict={"data": messages.GUIRegistryStateMessage(state=data)},

bec_widgets/utils/settings_dialog.py

@@ -1,5 +1,5 @@
 from bec_lib.logger import bec_logger
-from PySide6.QtGui import QCloseEvent
+from qtpy.QtGui import QCloseEvent
 from qtpy.QtWidgets import QDialog, QDialogButtonBox, QHBoxLayout, QPushButton, QVBoxLayout, QWidget
 
 from bec_widgets.utils.error_popups import SafeSlot

bec_widgets/utils/side_panel.py

@@ -16,7 +16,8 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
-from bec_widgets.utils.toolbar import MaterialIconAction, ModularToolBar
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle
+from bec_widgets.utils.toolbars.toolbar import MaterialIconAction, ModularToolBar
 
 
 class SidePanel(QWidget):
@@ -61,7 +62,7 @@ class SidePanel(QWidget):
             self.main_layout.setContentsMargins(0, 0, 0, 0)
             self.main_layout.setSpacing(0)
 
-            self.toolbar = ModularToolBar(parent=self, target_widget=self, orientation="vertical")
+            self.toolbar = ModularToolBar(parent=self, orientation="vertical")
 
             self.container = QWidget()
             self.container.layout = QVBoxLayout(self.container)
@@ -92,7 +93,7 @@ class SidePanel(QWidget):
             self.main_layout.setContentsMargins(0, 0, 0, 0)
             self.main_layout.setSpacing(0)
 
-            self.toolbar = ModularToolBar(parent=self, target_widget=self, orientation="horizontal")
+            self.toolbar = ModularToolBar(parent=self, orientation="horizontal")
 
             self.container = QWidget()
             self.container.layout = QVBoxLayout(self.container)
@@ -288,8 +289,16 @@ class SidePanel(QWidget):
 
         # Add an action to the toolbar if action_id, icon_name, and tooltip are provided
         if action_id is not None and icon_name is not None and tooltip is not None:
-            action = MaterialIconAction(icon_name=icon_name, tooltip=tooltip, checkable=True)
-            self.toolbar.add_action(action_id, action, target_widget=self)
+            action = MaterialIconAction(
+                icon_name=icon_name, tooltip=tooltip, checkable=True, parent=self
+            )
+            self.toolbar.components.add_safe(action_id, action)
+            bundle = ToolbarBundle(action_id, self.toolbar.components)
+            bundle.add_action(action_id)
+            self.toolbar.add_bundle(bundle)
+            shown_bundles = self.toolbar.shown_bundles
+            shown_bundles.append(action_id)
+            self.toolbar.show_bundles(shown_bundles)
 
             def on_action_toggled(checked: bool):
                 if self.switching_actions:

bec_widgets/utils/toolbars/actions.py

@@ -0,0 +1,524 @@
+# pylint: disable=no-name-in-module
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from typing import Dict, Literal
+
+from bec_lib.device import ReadoutPriority
+from bec_lib.logger import bec_logger
+from bec_qthemes._icon.material_icons import material_icon
+from qtpy.QtCore import QSize, Qt, QTimer
+from qtpy.QtGui import QAction, QColor, QIcon
+from qtpy.QtWidgets import (
+    QApplication,
+    QComboBox,
+    QHBoxLayout,
+    QLabel,
+    QMenu,
+    QSizePolicy,
+    QStyledItemDelegate,
+    QToolBar,
+    QToolButton,
+    QWidget,
+)
+
+import bec_widgets
+from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
+from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
+
+logger = bec_logger.logger
+
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+
+
+class NoCheckDelegate(QStyledItemDelegate):
+    """To reduce space in combo boxes by removing the checkmark."""
+
+    def initStyleOption(self, option, index):
+        super().initStyleOption(option, index)
+        # Remove any check indicator
+        option.checkState = Qt.Unchecked
+
+
+class LongPressToolButton(QToolButton):
+    def __init__(self, *args, long_press_threshold=500, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.long_press_threshold = long_press_threshold
+        self._long_press_timer = QTimer(self)
+        self._long_press_timer.setSingleShot(True)
+        self._long_press_timer.timeout.connect(self.handleLongPress)
+        self._pressed = False
+        self._longPressed = False
+
+    def mousePressEvent(self, event):
+        self._pressed = True
+        self._longPressed = False
+        self._long_press_timer.start(self.long_press_threshold)
+        super().mousePressEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        self._pressed = False
+        if self._longPressed:
+            self._longPressed = False
+            self._long_press_timer.stop()
+            event.accept()  # Prevent normal click action after a long press
+            return
+        self._long_press_timer.stop()
+        super().mouseReleaseEvent(event)
+
+    def handleLongPress(self):
+        if self._pressed:
+            self._longPressed = True
+            self.showMenu()
+
+
+class ToolBarAction(ABC):
+    """
+    Abstract base class for toolbar actions.
+
+    Args:
+        icon_path (str, optional): The name of the icon file from `assets/toolbar_icons`. Defaults to None.
+        tooltip (str, optional): The tooltip for the action. Defaults to None.
+        checkable (bool, optional): Whether the action is checkable. Defaults to False.
+    """
+
+    def __init__(self, icon_path: str = None, tooltip: str = None, checkable: bool = False):
+        self.icon_path = (
+            os.path.join(MODULE_PATH, "assets", "toolbar_icons", icon_path) if icon_path else None
+        )
+        self.tooltip = tooltip
+        self.checkable = checkable
+        self.action = None
+
+    @abstractmethod
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """Adds an action or widget to a toolbar.
+
+        Args:
+            toolbar (QToolBar): The toolbar to add the action or widget to.
+            target (QWidget): The target widget for the action.
+        """
+
+    def cleanup(self):
+        """Cleans up the action, if necessary."""
+        pass
+
+
+class SeparatorAction(ToolBarAction):
+    """Separator action for the toolbar."""
+
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        toolbar.addSeparator()
+
+
+class QtIconAction(ToolBarAction):
+    def __init__(self, standard_icon, tooltip=None, checkable=False, parent=None):
+        super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
+        self.standard_icon = standard_icon
+        self.icon = QApplication.style().standardIcon(standard_icon)
+        self.action = QAction(icon=self.icon, text=self.tooltip, parent=parent)
+        self.action.setCheckable(self.checkable)
+
+    def add_to_toolbar(self, toolbar, target):
+        toolbar.addAction(self.action)
+
+    def get_icon(self):
+        return self.icon
+
+
+class MaterialIconAction(ToolBarAction):
+    """
+    Action with a Material icon for the toolbar.
+
+    Args:
+        icon_name (str, optional): The name of the Material icon. Defaults to None.
+        tooltip (str, optional): The tooltip for the action. Defaults to None.
+        checkable (bool, optional): Whether the action is checkable. Defaults to False.
+        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.
+        parent (QWidget or None, optional): Parent widget for the underlying QAction.
+    """
+
+    def __init__(
+        self,
+        icon_name: str = None,
+        tooltip: str = None,
+        checkable: bool = False,
+        filled: bool = False,
+        color: str | tuple | QColor | dict[Literal["dark", "light"], str] | None = None,
+        parent=None,
+    ):
+        super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
+        self.icon_name = icon_name
+        self.filled = filled
+        self.color = color
+        # 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,
+        )
+        if parent is None:
+            logger.warning(
+                "MaterialIconAction was created without a parent. Please consider adding one. Using None as parent may cause issues."
+            )
+        self.action = QAction(icon=self.icon, text=self.tooltip, parent=parent)
+        self.action.setCheckable(self.checkable)
+
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """
+        Adds the action to the toolbar.
+
+        Args:
+            toolbar(QToolBar): The toolbar to add the action to.
+            target(QWidget): The target widget for the action.
+        """
+        toolbar.addAction(self.action)
+
+    def get_icon(self):
+        """
+        Returns the icon for the action.
+
+        Returns:
+            QIcon: The icon for the action.
+        """
+        return self.icon
+
+
+class DeviceSelectionAction(ToolBarAction):
+    """
+    Action for selecting a device in a combobox.
+
+    Args:
+        label (str): The label for the combobox.
+        device_combobox (DeviceComboBox): The combobox for selecting the device.
+    """
+
+    def __init__(self, label: str | None = None, device_combobox=None):
+        super().__init__()
+        self.label = label
+        self.device_combobox = device_combobox
+        self.device_combobox.currentIndexChanged.connect(lambda: self.set_combobox_style("#ffa700"))
+
+    def add_to_toolbar(self, toolbar, target):
+        widget = QWidget(parent=target)
+        layout = QHBoxLayout(widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        if self.label is not None:
+            label = QLabel(text=f"{self.label}", parent=target)
+            layout.addWidget(label)
+        if self.device_combobox is not None:
+            layout.addWidget(self.device_combobox)
+            toolbar.addWidget(widget)
+
+    def set_combobox_style(self, color: str):
+        self.device_combobox.setStyleSheet(f"QComboBox {{ background-color: {color}; }}")
+
+
+class SwitchableToolBarAction(ToolBarAction):
+    """
+    A split toolbar action that combines a main action and a drop-down menu for additional actions.
+
+    The main button displays the currently selected action's icon and tooltip. Clicking on the main button
+    triggers that action. Clicking on the drop-down arrow displays a menu with alternative actions. When an
+    alternative action is selected, it becomes the new default and its callback is immediately executed.
+
+    This design mimics the behavior seen in Adobe Photoshop or Affinity Designer toolbars.
+
+    Args:
+        actions (dict): A dictionary mapping a unique key to a ToolBarAction instance.
+        initial_action (str, optional): The key of the initial default action. If not provided, the first action is used.
+        tooltip (str, optional): An optional tooltip for the split action; if provided, it overrides the default action's tooltip.
+        checkable (bool, optional): Whether the action is checkable. Defaults to True.
+        parent (QWidget, optional): Parent widget for the underlying QAction.
+    """
+
+    def __init__(
+        self,
+        actions: Dict[str, ToolBarAction],
+        initial_action: str = None,
+        tooltip: str = None,
+        checkable: bool = True,
+        default_state_checked: bool = False,
+        parent=None,
+    ):
+        super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
+        self.actions = actions
+        self.current_key = initial_action if initial_action is not None else next(iter(actions))
+        self.parent = parent
+        self.checkable = checkable
+        self.default_state_checked = default_state_checked
+        self.main_button = None
+        self.menu_actions: Dict[str, QAction] = {}
+
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """
+        Adds the split action to the toolbar.
+
+        Args:
+            toolbar (QToolBar): The toolbar to add the action to.
+            target (QWidget): The target widget for the action.
+        """
+        self.main_button = LongPressToolButton(toolbar)
+        self.main_button.setPopupMode(QToolButton.MenuButtonPopup)
+        self.main_button.setCheckable(self.checkable)
+        default_action = self.actions[self.current_key]
+        self.main_button.setIcon(default_action.get_icon())
+        self.main_button.setToolTip(default_action.tooltip)
+        self.main_button.clicked.connect(self._trigger_current_action)
+        menu = QMenu(self.main_button)
+        for key, action_obj in self.actions.items():
+            menu_action = QAction(
+                icon=action_obj.get_icon(), text=action_obj.tooltip, parent=self.main_button
+            )
+            menu_action.setIconVisibleInMenu(True)
+            menu_action.setCheckable(self.checkable)
+            menu_action.setChecked(key == self.current_key)
+            menu_action.triggered.connect(lambda checked, k=key: self.set_default_action(k))
+            menu.addAction(menu_action)
+        self.main_button.setMenu(menu)
+        if self.default_state_checked:
+            self.main_button.setChecked(True)
+        self.action = toolbar.addWidget(self.main_button)
+
+    def _trigger_current_action(self):
+        """
+        Triggers the current action associated with the main button.
+        """
+        action_obj = self.actions[self.current_key]
+        action_obj.action.trigger()
+
+    def set_default_action(self, key: str):
+        """
+        Sets the default action for the split action.
+
+        Args:
+            key(str): The key of the action to set as default.
+        """
+        if self.main_button is None:
+            return
+        self.current_key = key
+        new_action = self.actions[self.current_key]
+        self.main_button.setIcon(new_action.get_icon())
+        self.main_button.setToolTip(new_action.tooltip)
+        # Update check state of menu items
+        for k, menu_act in self.actions.items():
+            menu_act.action.setChecked(False)
+        new_action.action.trigger()
+        # Active action chosen from menu is always checked, uncheck through main button
+        if self.checkable:
+            new_action.action.setChecked(True)
+            self.main_button.setChecked(True)
+
+    def block_all_signals(self, block: bool = True):
+        """
+        Blocks or unblocks all signals for the actions in the toolbar.
+
+        Args:
+            block (bool): Whether to block signals. Defaults to True.
+        """
+        if self.main_button is not None:
+            self.main_button.blockSignals(block)
+
+        for action in self.actions.values():
+            action.action.blockSignals(block)
+
+    @contextmanager
+    def signal_blocker(self):
+        """
+        Context manager to block signals for all actions in the toolbar.
+        """
+        self.block_all_signals(True)
+        try:
+            yield
+        finally:
+            self.block_all_signals(False)
+
+    def set_state_all(self, state: bool):
+        """
+        Uncheck all actions in the toolbar.
+        """
+        for action in self.actions.values():
+            action.action.setChecked(state)
+        if self.main_button is None:
+            return
+        self.main_button.setChecked(state)
+
+    def get_icon(self) -> QIcon:
+        return self.actions[self.current_key].get_icon()
+
+
+class WidgetAction(ToolBarAction):
+    """
+    Action for adding any widget to the toolbar.
+    Please note that the injected widget must be life-cycled by the parent widget,
+    i.e., the widget must be properly cleaned up outside of this action. The WidgetAction
+    will not perform any cleanup on the widget itself, only on the container that holds it.
+
+    Args:
+        label (str|None): The label for the widget.
+        widget (QWidget): The widget to be added to the toolbar.
+        adjust_size (bool): Whether to adjust the size of the widget based on its contents. Defaults to True.
+    """
+
+    def __init__(
+        self,
+        label: str | None = None,
+        widget: QWidget = None,
+        adjust_size: bool = True,
+        parent=None,
+    ):
+        super().__init__(icon_path=None, tooltip=label, checkable=False)
+        self.label = label
+        self.widget = widget
+        self.container = None
+        self.adjust_size = adjust_size
+
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """
+        Adds the widget to the toolbar.
+
+        Args:
+            toolbar (QToolBar): The toolbar to add the widget to.
+            target (QWidget): The target widget for the action.
+        """
+        self.container = QWidget(parent=target)
+        layout = QHBoxLayout(self.container)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        if self.label is not None:
+            label_widget = QLabel(text=f"{self.label}", parent=target)
+            label_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
+            label_widget.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
+            layout.addWidget(label_widget)
+
+        if isinstance(self.widget, QComboBox) and self.adjust_size:
+            self.widget.setSizeAdjustPolicy(QComboBox.AdjustToContents)
+
+            size_policy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+            self.widget.setSizePolicy(size_policy)
+
+            self.widget.setMinimumWidth(self.calculate_minimum_width(self.widget))
+
+        layout.addWidget(self.widget)
+
+        toolbar.addWidget(self.container)
+        # Store the container as the action to allow toggling visibility.
+        self.action = self.container
+
+    def cleanup(self):
+        """
+        Cleans up the action by closing and deleting the container widget.
+        This method will be called automatically when the toolbar is cleaned up.
+        """
+        if self.container is not None:
+            self.container.close()
+            self.container.deleteLater()
+        return super().cleanup()
+
+    @staticmethod
+    def calculate_minimum_width(combo_box: QComboBox) -> int:
+        font_metrics = combo_box.fontMetrics()
+        max_width = max(font_metrics.width(combo_box.itemText(i)) for i in range(combo_box.count()))
+        return max_width + 60
+
+
+class ExpandableMenuAction(ToolBarAction):
+    """
+    Action for an expandable menu in the toolbar.
+
+    Args:
+        label (str): The label for the menu.
+        actions (dict): A dictionary of actions to populate the menu.
+        icon_path (str, optional): The path to the icon file. Defaults to None.
+    """
+
+    def __init__(self, label: str, actions: dict, icon_path: str = None):
+        super().__init__(icon_path, label)
+        self.actions = actions
+
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        button = QToolButton(toolbar)
+        if self.icon_path:
+            button.setIcon(QIcon(self.icon_path))
+        button.setText(self.tooltip)
+        button.setPopupMode(QToolButton.InstantPopup)
+        button.setStyleSheet(
+            """
+                   QToolButton {
+                       font-size: 14px;
+                   }
+                   QMenu {
+                       font-size: 14px;
+                   }
+               """
+        )
+        menu = QMenu(button)
+        for action_container in self.actions.values():
+            action: QAction = action_container.action
+            action.setIconVisibleInMenu(True)
+            if action_container.icon_path:
+                icon = QIcon()
+                icon.addFile(action_container.icon_path, size=QSize(20, 20))
+                action.setIcon(icon)
+            elif hasattr(action, "get_icon") and callable(action_container.get_icon):
+                sub_icon = action_container.get_icon()
+                if sub_icon and not sub_icon.isNull():
+                    action.setIcon(sub_icon)
+            action.setCheckable(action_container.checkable)
+            menu.addAction(action)
+        button.setMenu(menu)
+        toolbar.addWidget(button)
+
+
+class DeviceComboBoxAction(WidgetAction):
+    """
+    Action for a device selection combobox in the toolbar.
+
+    Args:
+        label (str): The label for the combobox.
+        device_combobox (QComboBox): The combobox for selecting the device.
+    """
+
+    def __init__(
+        self,
+        target_widget: QWidget,
+        device_filter: list[BECDeviceFilter] | None = None,
+        readout_priority_filter: (
+            str | ReadoutPriority | list[str] | list[ReadoutPriority] | None
+        ) = None,
+        tooltip: str | None = None,
+        add_empty_item: bool = False,
+        no_check_delegate: bool = False,
+    ):
+        self.combobox = DeviceComboBox(
+            parent=target_widget,
+            device_filter=device_filter,
+            readout_priority_filter=readout_priority_filter,
+        )
+        super().__init__(widget=self.combobox, adjust_size=False)
+
+        if add_empty_item:
+            self.combobox.addItem("", None)
+            self.combobox.setCurrentText("")
+        if tooltip is not None:
+            self.combobox.setToolTip(tooltip)
+        if no_check_delegate:
+            self.combobox.setItemDelegate(NoCheckDelegate(self.combobox))
+
+    def cleanup(self):
+        """
+        Cleans up the action by closing and deleting the combobox widget.
+        This method will be called automatically when the toolbar is cleaned up.
+        """
+        if self.combobox is not None:
+            self.combobox.close()
+            self.combobox.deleteLater()
+        return super().cleanup()

bec_widgets/utils/toolbars/bundles.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING, DefaultDict
+from weakref import ReferenceType
+
+import louie
+from bec_lib.logger import bec_logger
+from pydantic import BaseModel
+
+from bec_widgets.utils.toolbars.actions import SeparatorAction, ToolBarAction
+
+if TYPE_CHECKING:
+    from bec_widgets.utils.toolbars.connections import BundleConnection
+    from bec_widgets.utils.toolbars.toolbar import ModularToolBar
+
+logger = bec_logger.logger
+
+
+class ActionInfo(BaseModel):
+    action: ToolBarAction
+    toolbar_bundle: ToolbarBundle | None = None
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class ToolbarComponents:
+    def __init__(self, toolbar: ModularToolBar):
+        """
+        Initializes the toolbar components.
+
+        Args:
+            toolbar (ModularToolBar): The toolbar to which the components will be added.
+        """
+        self.toolbar = toolbar
+
+        self._components: dict[str, ActionInfo] = {}
+        self.add("separator", SeparatorAction())
+
+    def add(self, name: str, component: ToolBarAction):
+        """
+        Adds a component to the toolbar.
+
+        Args:
+            component (ToolBarAction): The component to add.
+        """
+        if name in self._components:
+            raise ValueError(f"Component with name '{name}' already exists.")
+        self._components[name] = ActionInfo(action=component, toolbar_bundle=None)
+
+    def add_safe(self, name: str, component: ToolBarAction):
+        """
+        Adds a component to the toolbar, ensuring it does not already exist.
+
+        Args:
+            name (str): The name of the component.
+            component (ToolBarAction): The component to add.
+        """
+        if self.exists(name):
+            logger.info(f"Component with name '{name}' already exists. Skipping addition.")
+            return
+        self.add(name, component)
+
+    def exists(self, name: str) -> bool:
+        """
+        Checks if a component exists in the toolbar.
+
+        Args:
+            name (str): The name of the component to check.
+
+        Returns:
+            bool: True if the component exists, False otherwise.
+        """
+        return name in self._components
+
+    def get_action_reference(self, name: str) -> ReferenceType[ToolBarAction]:
+        """
+        Retrieves a component by name.
+
+        Args:
+            name (str): The name of the component to retrieve.
+
+        """
+        if not self.exists(name):
+            raise KeyError(f"Component with name '{name}' does not exist.")
+        return louie.saferef.safe_ref(self._components[name].action)
+
+    def get_action(self, name: str) -> ToolBarAction:
+        """
+        Retrieves a component by name.
+
+        Args:
+            name (str): The name of the component to retrieve.
+
+        Returns:
+            ToolBarAction: The action associated with the given name.
+        """
+        if not self.exists(name):
+            raise KeyError(
+                f"Component with name '{name}' does not exist. The following components are available: {list(self._components.keys())}"
+            )
+        return self._components[name].action
+
+    def set_bundle(self, name: str, bundle: ToolbarBundle):
+        """
+        Sets the bundle for a component.
+
+        Args:
+            name (str): The name of the component.
+            bundle (ToolbarBundle): The bundle to set.
+        """
+        if not self.exists(name):
+            raise KeyError(f"Component with name '{name}' does not exist.")
+        comp = self._components[name]
+        if comp.toolbar_bundle is not None:
+            logger.info(
+                f"Component '{name}' already has a bundle ({comp.toolbar_bundle.name}). Setting it to {bundle.name}."
+            )
+            comp.toolbar_bundle.bundle_actions.pop(name, None)
+        comp.toolbar_bundle = bundle
+
+    def remove_action(self, name: str):
+        """
+        Removes a component from the toolbar.
+
+        Args:
+            name (str): The name of the component to remove.
+        """
+        if not self.exists(name):
+            raise KeyError(f"Action with ID '{name}' does not exist.")
+        action_info = self._components.pop(name)
+        if action_info.toolbar_bundle:
+            action_info.toolbar_bundle.bundle_actions.pop(name, None)
+            self.toolbar.refresh()
+            action_info.toolbar_bundle = None
+        if hasattr(action_info.action, "cleanup"):
+            # Call cleanup if the action has a cleanup method
+            action_info.action.cleanup()
+
+    def cleanup(self):
+        """
+        Cleans up the toolbar components by removing all actions and bundles.
+        """
+        for action_info in self._components.values():
+            if hasattr(action_info.action, "cleanup"):
+                # Call cleanup if the action has a cleanup method
+                action_info.action.cleanup()
+        self._components.clear()
+
+
+class ToolbarBundle:
+    def __init__(self, name: str, components: ToolbarComponents):
+        """
+        Initializes a new bundle component.
+
+        Args:
+            bundle_name (str): Unique identifier for the bundle.
+        """
+        self.name = name
+        self.components = components
+        self.bundle_actions: DefaultDict[str, ReferenceType[ToolBarAction]] = defaultdict()
+        self._connections: dict[str, BundleConnection] = {}
+
+    def add_action(self, name: str):
+        """
+        Adds an action to the bundle.
+
+        Args:
+            name (str): Unique identifier for the action.
+            action (ToolBarAction): The action to add.
+        """
+        if name in self.bundle_actions:
+            raise ValueError(f"Action with name '{name}' already exists in bundle '{self.name}'.")
+        if not self.components.exists(name):
+            raise ValueError(
+                f"Component with name '{name}' does not exist in the toolbar. Please add it first using the `ToolbarComponents.add` method."
+            )
+        self.bundle_actions[name] = self.components.get_action_reference(name)
+        self.components.set_bundle(name, self)
+
+    def remove_action(self, name: str):
+        """
+        Removes an action from the bundle.
+
+        Args:
+            name (str): The name of the action to remove.
+        """
+        if name not in self.bundle_actions:
+            raise KeyError(f"Action with name '{name}' does not exist in bundle '{self.name}'.")
+        del self.bundle_actions[name]
+
+    def add_separator(self):
+        """
+        Adds a separator action to the bundle.
+        """
+        self.add_action("separator")
+
+    def add_connection(self, name: str, connection):
+        """
+        Adds a connection to the bundle.
+
+        Args:
+            name (str): Unique identifier for the connection.
+            connection: The connection to add.
+        """
+        if name in self._connections:
+            raise ValueError(
+                f"Connection with name '{name}' already exists in bundle '{self.name}'."
+            )
+        self._connections[name] = connection
+
+    def remove_connection(self, name: str):
+        """
+        Removes a connection from the bundle.
+
+        Args:
+            name (str): The name of the connection to remove.
+        """
+        if name not in self._connections:
+            raise KeyError(f"Connection with name '{name}' does not exist in bundle '{self.name}'.")
+        self._connections[name].disconnect()
+        del self._connections[name]
+
+    def get_connection(self, name: str):
+        """
+        Retrieves a connection by name.
+
+        Args:
+            name (str): The name of the connection to retrieve.
+
+        Returns:
+            The connection associated with the given name.
+        """
+        if name not in self._connections:
+            raise KeyError(f"Connection with name '{name}' does not exist in bundle '{self.name}'.")
+        return self._connections[name]
+
+    def disconnect(self):
+        """
+        Disconnects all connections in the bundle.
+        """
+        for connection in self._connections.values():
+            connection.disconnect()
+        self._connections.clear()

bec_widgets/utils/toolbars/connections.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+
+from qtpy.QtCore import QObject
+
+
+class BundleConnection(QObject):
+    bundle_name: str
+
+    @abstractmethod
+    def connect(self):
+        """
+        Connects the bundle to the target widget or application.
+        This method should be implemented by subclasses to define how the bundle interacts with the target.
+        """
+
+    @abstractmethod
+    def disconnect(self):
+        """
+        Disconnects the bundle from the target widget or application.
+        This method should be implemented by subclasses to define how to clean up connections.
+        """

bec_widgets/utils/toolbars/performance.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+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.connections import BundleConnection
+
+if TYPE_CHECKING:
+    from bec_widgets.utils.toolbars.toolbar import ToolbarComponents
+
+
+def performance_bundle(components: ToolbarComponents) -> ToolbarBundle:
+    """
+    Creates a performance toolbar bundle.
+
+    Args:
+        components (ToolbarComponents): The components to be added to the bundle.
+
+    Returns:
+        ToolbarBundle: The performance toolbar bundle.
+    """
+    components.add_safe(
+        "fps_monitor",
+        MaterialIconAction(
+            icon_name="speed", tooltip="Show FPS Monitor", checkable=True, parent=components.toolbar
+        ),
+    )
+    bundle = ToolbarBundle("performance", components)
+    bundle.add_action("fps_monitor")
+    return bundle
+
+
+class PerformanceConnection(BundleConnection):
+
+    def __init__(self, components: ToolbarComponents, target_widget=None):
+        self.bundle_name = "performance"
+        self.components = components
+        self.target_widget = target_widget
+        if not hasattr(self.target_widget, "enable_fps_monitor"):
+            raise AttributeError("Target widget must implement 'enable_fps_monitor'.")
+        super().__init__()
+        self._connected = False
+
+    @SafeSlot(bool)
+    def set_fps_monitor(self, enabled: bool):
+        setattr(self.target_widget, "enable_fps_monitor", enabled)
+
+    def connect(self):
+        self._connected = True
+        # Connect the action to the target widget's method
+        self.components.get_action_reference("fps_monitor")().action.toggled.connect(
+            self.set_fps_monitor
+        )
+
+    def disconnect(self):
+        if not self._connected:
+            return
+        # Disconnect the action from the target widget's method
+        self.components.get_action_reference("fps_monitor")().action.toggled.disconnect(
+            self.set_fps_monitor
+        )
+        self._connected = False

bec_widgets/utils/toolbars/toolbar.py

@@ -0,0 +1,513 @@
+# pylint: disable=no-name-in-module
+from __future__ import annotations
+
+import sys
+from collections import defaultdict
+from typing import DefaultDict, Literal
+
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QSize, Qt
+from qtpy.QtGui import QAction, QColor
+from qtpy.QtWidgets import QApplication, QLabel, QMainWindow, QMenu, QToolBar, QVBoxLayout, QWidget
+
+from bec_widgets.utils.colors import get_theme_name, set_theme
+from bec_widgets.utils.toolbars.actions import MaterialIconAction, ToolBarAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle, ToolbarComponents
+from bec_widgets.utils.toolbars.connections import BundleConnection
+
+logger = bec_logger.logger
+
+# Ensure that icons are shown in menus (especially on macOS)
+QApplication.setAttribute(Qt.AA_DontShowIconsInMenus, False)
+
+
+class ModularToolBar(QToolBar):
+    """Modular toolbar with optional automatic initialization.
+
+    Args:
+        parent (QWidget, optional): The parent widget of the toolbar. Defaults to None.
+        actions (dict, optional): A dictionary of action creators to populate the toolbar. Defaults to None.
+        target_widget (QWidget, optional): The widget that the actions will target. Defaults to None.
+        orientation (Literal["horizontal", "vertical"], optional): The initial orientation of the toolbar. Defaults to "horizontal".
+        background_color (str, optional): The background color of the toolbar. Defaults to "rgba(0, 0, 0, 0)".
+    """
+
+    def __init__(
+        self,
+        parent=None,
+        orientation: Literal["horizontal", "vertical"] = "horizontal",
+        background_color: str = "rgba(0, 0, 0, 0)",
+    ):
+        super().__init__(parent=parent)
+
+        self.background_color = background_color
+        self.set_background_color(self.background_color)
+
+        # Set the initial orientation
+        self.set_orientation(orientation)
+
+        self.components = ToolbarComponents(self)
+
+        # Initialize bundles
+        self.bundles: dict[str, ToolbarBundle] = {}
+        self.shown_bundles: list[str] = []
+
+        #########################
+        # outdated items... remove
+        self.available_widgets: DefaultDict[str, ToolBarAction] = defaultdict()
+        ########################
+
+    def new_bundle(self, name: str) -> ToolbarBundle:
+        """
+        Creates a new bundle component.
+
+        Args:
+            name (str): Unique identifier for the bundle.
+
+        Returns:
+            ToolbarBundle: The new bundle component.
+        """
+        if name in self.bundles:
+            raise ValueError(f"Bundle with name '{name}' already exists.")
+        bundle = ToolbarBundle(name=name, components=self.components)
+        self.bundles[name] = bundle
+        return bundle
+
+    def add_bundle(self, bundle: ToolbarBundle):
+        """
+        Adds a bundle component to the toolbar.
+
+        Args:
+            bundle (ToolbarBundle): The bundle component to add.
+        """
+        if bundle.name in self.bundles:
+            raise ValueError(f"Bundle with name '{bundle.name}' already exists.")
+        self.bundles[bundle.name] = bundle
+        if not bundle.bundle_actions:
+            logger.warning(f"Bundle '{bundle.name}' has no actions.")
+
+    def remove_bundle(self, name: str):
+        """
+        Removes a bundle component by name.
+
+        Args:
+            name (str): The name of the bundle to remove.
+        """
+        if name not in self.bundles:
+            raise KeyError(f"Bundle with name '{name}' does not exist.")
+        del self.bundles[name]
+        if name in self.shown_bundles:
+            self.shown_bundles.remove(name)
+        logger.info(f"Bundle '{name}' removed from the toolbar.")
+
+    def get_bundle(self, name: str) -> ToolbarBundle:
+        """
+        Retrieves a bundle component by name.
+
+        Args:
+            name (str): The name of the bundle to retrieve.
+
+        Returns:
+            ToolbarBundle: The bundle component.
+        """
+        if name not in self.bundles:
+            raise KeyError(
+                f"Bundle with name '{name}' does not exist. Available bundles: {list(self.bundles.keys())}"
+            )
+        return self.bundles[name]
+
+    def show_bundles(self, bundle_names: list[str]):
+        """
+        Sets the bundles to be shown for the toolbar.
+
+        Args:
+            bundle_names (list[str]): A list of bundle names to show. If a bundle is not in this list, its actions will be hidden.
+        """
+        self.clear()
+        for requested_bundle in bundle_names:
+            bundle = self.get_bundle(requested_bundle)
+            for bundle_action in bundle.bundle_actions.values():
+                action = bundle_action()
+                if action is None:
+                    logger.warning(
+                        f"Action for bundle '{requested_bundle}' has been deleted. Skipping."
+                    )
+                    continue
+                action.add_to_toolbar(self, self.parent())
+            separator = self.components.get_action_reference("separator")()
+            if separator is not None:
+                separator.add_to_toolbar(self, self.parent())
+        self.update_separators()  # Ensure separators are updated after showing bundles
+        self.shown_bundles = bundle_names
+
+    def add_action(self, action_name: str, action: ToolBarAction):
+        """
+        Adds a single action to the toolbar. It will create a new bundle
+        with the same name as the action.
+
+        Args:
+            action_name (str): Unique identifier for the action.
+            action (ToolBarAction): The action to add.
+        """
+        self.components.add_safe(action_name, action)
+        bundle = ToolbarBundle(name=action_name, components=self.components)
+        bundle.add_action(action_name)
+        self.add_bundle(bundle)
+
+    def hide_action(self, action_name: str):
+        """
+        Hides a specific action in the toolbar.
+
+        Args:
+            action_name (str): Unique identifier for the action to hide.
+        """
+        action = self.components.get_action(action_name)
+        if hasattr(action, "action") and action.action is not None:
+            action.action.setVisible(False)
+            self.update_separators()
+
+    def show_action(self, action_name: str):
+        """
+        Shows a specific action in the toolbar.
+
+        Args:
+            action_name (str): Unique identifier for the action to show.
+        """
+        action = self.components.get_action(action_name)
+        if hasattr(action, "action") and action.action is not None:
+            action.action.setVisible(True)
+            self.update_separators()
+
+    @property
+    def toolbar_actions(self) -> list[ToolBarAction]:
+        """
+        Returns a list of all actions currently in the toolbar.
+
+        Returns:
+            list[ToolBarAction]: List of actions in the toolbar.
+        """
+        actions = []
+        for bundle in self.shown_bundles:
+            if bundle not in self.bundles:
+                continue
+            for action in self.bundles[bundle].bundle_actions.values():
+                action_instance = action()
+                if action_instance is not None:
+                    actions.append(action_instance)
+        return actions
+
+    def refresh(self):
+        """Refreshes the toolbar by clearing and re-populating it."""
+        self.clear()
+        self.show_bundles(self.shown_bundles)
+
+    def connect_bundle(self, connection_name: str, connector: BundleConnection):
+        """
+        Connects a bundle to a target widget or application.
+
+        Args:
+            bundle_name (str): The name of the bundle to connect.
+            connector (BundleConnection): The connector instance that implements the connection logic.
+        """
+        bundle_name = connector.bundle_name
+        if bundle_name not in self.bundles:
+            raise KeyError(f"Bundle with name '{bundle_name}' does not exist.")
+        connector.connect()
+        self.bundles[bundle_name].add_connection(connection_name, connector)
+
+    def disconnect_bundle(self, bundle_name: str, connection_name: str | None = None):
+        """
+        Disconnects a bundle connection.
+
+        Args:
+            bundle_name (str): The name of the bundle to disconnect.
+            connection_name (str): The name of the connection to disconnect. If None, disconnects all connections for the bundle.
+        """
+        if bundle_name not in self.bundles:
+            raise KeyError(f"Bundle with name '{bundle_name}' does not exist.")
+        bundle = self.bundles[bundle_name]
+        if connection_name is None:
+            # Disconnect all connections in the bundle
+            bundle.disconnect()
+        else:
+            bundle.remove_connection(name=connection_name)
+
+    def set_background_color(self, color: str = "rgba(0, 0, 0, 0)"):
+        """
+        Sets the background color and other appearance settings.
+
+        Args:
+            color (str): The background color of the toolbar.
+        """
+        self.setIconSize(QSize(20, 20))
+        self.setMovable(False)
+        self.setFloatable(False)
+        self.setContentsMargins(0, 0, 0, 0)
+        self.background_color = color
+        self.setStyleSheet(f"QToolBar {{ background-color: {color}; border: none; }}")
+
+    def set_orientation(self, orientation: Literal["horizontal", "vertical"]):
+        """Sets the orientation of the toolbar.
+
+        Args:
+            orientation (Literal["horizontal", "vertical"]): The desired orientation of the toolbar.
+        """
+        if orientation == "horizontal":
+            self.setOrientation(Qt.Horizontal)
+        elif orientation == "vertical":
+            self.setOrientation(Qt.Vertical)
+        else:
+            raise ValueError("Orientation must be 'horizontal' or 'vertical'.")
+
+    def update_material_icon_colors(self, new_color: str | tuple | QColor):
+        """
+        Updates the color of all MaterialIconAction icons.
+
+        Args:
+            new_color (str | tuple | QColor): The new color.
+        """
+        for action in self.available_widgets.values():
+            if isinstance(action, MaterialIconAction):
+                action.color = new_color
+                updated_icon = action.get_icon()
+                action.action.setIcon(updated_icon)
+
+    def contextMenuEvent(self, event):
+        """
+        Overrides the context menu event to show toolbar actions with checkboxes and icons.
+
+        Args:
+            event (QContextMenuEvent): The context menu event.
+        """
+        menu = QMenu(self)
+        theme = get_theme_name()
+        if theme == "dark":
+            menu.setStyleSheet(
+                """
+                QMenu {
+                    background-color: rgba(50, 50, 50, 0.9);
+                    border: 1px solid rgba(255, 255, 255, 0.2);
+                }
+                QMenu::item:selected {
+                    background-color: rgba(0, 0, 255, 0.2);
+                }
+            """
+            )
+        else:
+            # Light theme styling
+            menu.setStyleSheet(
+                """
+                QMenu {
+                    background-color: rgba(255, 255, 255, 0.9);
+                    border: 1px solid rgba(0, 0, 0, 0.2);
+                }
+                QMenu::item:selected {
+                    background-color: rgba(0, 0, 255, 0.2);
+                }
+            """
+            )
+        for ii, bundle in enumerate(self.shown_bundles):
+            self.handle_bundle_context_menu(menu, bundle)
+            if ii < len(self.shown_bundles) - 1:
+                menu.addSeparator()
+        menu.triggered.connect(self.handle_menu_triggered)
+        menu.exec_(event.globalPos())
+
+    def handle_bundle_context_menu(self, menu: QMenu, bundle_id: str):
+        """
+        Adds bundle actions to the context menu.
+
+        Args:
+            menu (QMenu): The context menu.
+            bundle_id (str): The bundle identifier.
+        """
+        bundle = self.bundles.get(bundle_id)
+        if not bundle:
+            return
+        for act_id in bundle.bundle_actions:
+            toolbar_action = self.components.get_action(act_id)
+            if not isinstance(toolbar_action, ToolBarAction) or not hasattr(
+                toolbar_action, "action"
+            ):
+                continue
+            qaction = toolbar_action.action
+            if not isinstance(qaction, QAction):
+                continue
+            self._add_qaction_to_menu(menu, qaction, toolbar_action, act_id)
+
+    def _add_qaction_to_menu(
+        self, menu: QMenu, qaction: QAction, toolbar_action: ToolBarAction, act_id: str
+    ):
+        display_name = qaction.text() or toolbar_action.tooltip or act_id
+        menu_action = QAction(display_name, self)
+        menu_action.setCheckable(True)
+        menu_action.setChecked(qaction.isVisible())
+        menu_action.setData(act_id)  # Store the action_id
+
+        # Set the icon if available
+        if qaction.icon() and not qaction.icon().isNull():
+            menu_action.setIcon(qaction.icon())
+        menu.addAction(menu_action)
+
+    def handle_action_context_menu(self, menu: QMenu, action_id: str):
+        """
+        Adds a single toolbar action to the context menu.
+
+        Args:
+            menu (QMenu): The context menu to which the action is added.
+            action_id (str): Unique identifier for the action.
+        """
+        toolbar_action = self.available_widgets.get(action_id)
+        if not isinstance(toolbar_action, ToolBarAction) or not hasattr(toolbar_action, "action"):
+            return
+        qaction = toolbar_action.action
+        if not isinstance(qaction, QAction):
+            return
+        display_name = qaction.text() or toolbar_action.tooltip or action_id
+        menu_action = QAction(display_name, self)
+        menu_action.setCheckable(True)
+        menu_action.setChecked(qaction.isVisible())
+        menu_action.setIconVisibleInMenu(True)
+        menu_action.setData(action_id)  # Store the action_id
+
+        # Set the icon if available
+        if qaction.icon() and not qaction.icon().isNull():
+            menu_action.setIcon(qaction.icon())
+
+        menu.addAction(menu_action)
+
+    def handle_menu_triggered(self, action):
+        """
+        Handles the triggered signal from the context menu.
+
+        Args:
+            action: Action triggered.
+        """
+        action_id = action.data()
+        if action_id:
+            self.toggle_action_visibility(action_id)
+
+    def toggle_action_visibility(self, action_id: str, visible: bool | None = None):
+        """
+        Toggles the visibility of a specific action.
+
+        Args:
+            action_id (str): Unique identifier.
+            visible (bool): Whether the action should be visible. If None, toggles the current visibility.
+        """
+        if not self.components.exists(action_id):
+            return
+        tool_action = self.components.get_action(action_id)
+        if hasattr(tool_action, "action") and tool_action.action is not None:
+            if visible is None:
+                visible = not tool_action.action.isVisible()
+            tool_action.action.setVisible(visible)
+        self.update_separators()
+
+    def update_separators(self):
+        """
+        Hide separators that are adjacent to another separator or have no non-separator actions between them.
+        """
+        toolbar_actions = self.actions()
+        # First pass: set visibility based on surrounding non-separator actions.
+        for i, action in enumerate(toolbar_actions):
+            if not action.isSeparator():
+                continue
+            prev_visible = None
+            for j in range(i - 1, -1, -1):
+                if toolbar_actions[j].isVisible():
+                    prev_visible = toolbar_actions[j]
+                    break
+            next_visible = None
+            for j in range(i + 1, len(toolbar_actions)):
+                if toolbar_actions[j].isVisible():
+                    next_visible = toolbar_actions[j]
+                    break
+            if (prev_visible is None or prev_visible.isSeparator()) and (
+                next_visible is None or next_visible.isSeparator()
+            ):
+                action.setVisible(False)
+            else:
+                action.setVisible(True)
+        # Second pass: ensure no two visible separators are adjacent.
+        prev = None
+        for action in toolbar_actions:
+            if action.isVisible() and action.isSeparator():
+                if prev and prev.isSeparator():
+                    action.setVisible(False)
+                else:
+                    prev = action
+            else:
+                if action.isVisible():
+                    prev = action
+
+        if not toolbar_actions:
+            return
+
+        # Make sure the first visible action is not a separator
+        for i, action in enumerate(toolbar_actions):
+            if action.isVisible():
+                if action.isSeparator():
+                    action.setVisible(False)
+                break
+
+        # Make sure the last visible action is not a separator
+        for i, action in enumerate(reversed(toolbar_actions)):
+            if action.isVisible():
+                if action.isSeparator():
+                    action.setVisible(False)
+                break
+
+    def cleanup(self):
+        """
+        Cleans up the toolbar by removing all actions and bundles.
+        """
+        # First, disconnect all bundles
+        for bundle_name in list(self.bundles.keys()):
+            self.disconnect_bundle(bundle_name)
+
+        # Clear all components
+        self.components.cleanup()
+        self.bundles.clear()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from bec_widgets.utils.toolbars.performance import PerformanceConnection, performance_bundle
+    from bec_widgets.widgets.plots.toolbar_components.plot_export import plot_export_bundle
+
+    class MainWindow(QMainWindow):  # pragma: no cover
+        def __init__(self):
+            super().__init__()
+            self.setWindowTitle("Toolbar / ToolbarBundle Demo")
+            self.central_widget = QWidget()
+            self.setCentralWidget(self.central_widget)
+            self.test_label = QLabel(text="This is a test label.")
+            self.central_widget.layout = QVBoxLayout(self.central_widget)
+            self.central_widget.layout.addWidget(self.test_label)
+
+            self.toolbar = ModularToolBar(parent=self)
+            self.addToolBar(self.toolbar)
+            self.toolbar.add_bundle(performance_bundle(self.toolbar.components))
+            self.toolbar.add_bundle(plot_export_bundle(self.toolbar.components))
+            self.toolbar.connect_bundle(
+                "base", PerformanceConnection(self.toolbar.components, self)
+            )
+            self.toolbar.show_bundles(["performance", "plot_export"])
+            self.toolbar.get_bundle("performance").add_action("save")
+            self.toolbar.refresh()
+
+        def enable_fps_monitor(self, enabled: bool):
+            """
+            Example method to enable or disable FPS monitoring.
+            This method should be implemented in the target widget.
+            """
+            if enabled:
+                self.test_label.setText("FPS Monitor Enabled")
+            else:
+                self.test_label.setText("FPS Monitor Disabled")
+
+    app = QApplication(sys.argv)
+    set_theme("light")
+    main_window = MainWindow()
+    main_window.show()
+    sys.exit(app.exec_())

bec_widgets/utils/ui_loader.py

@@ -9,7 +9,7 @@ from bec_widgets.utils.plugin_utils import get_custom_classes
 logger = bec_logger.logger
 
 if PYSIDE6:
-    from PySide6.QtUiTools import QUiLoader
+    from qtpy.QtUiTools import QUiLoader
 
     class CustomUiLoader(QUiLoader):
         def __init__(self, baseinstance, custom_widgets: dict | None = None):
@@ -31,12 +31,9 @@ class UILoader:
     def __init__(self, parent=None):
         self.parent = parent
 
-        widgets = get_custom_classes("bec_widgets").classes
-
-        self.custom_widgets = {widget.__name__: widget for widget in widgets}
-
-        plugin_widgets = get_all_plugin_widgets()
-        self.custom_widgets.update(plugin_widgets)
+        self.custom_widgets = (
+            get_custom_classes("bec_widgets") + get_all_plugin_widgets()
+        ).as_dict()
 
         if PYSIDE6:
             self.loader = self.load_ui_pyside6

bec_widgets/utils/widget_io.py

@@ -264,6 +264,48 @@ class WidgetIO:
                 return WidgetIO._handlers[base]
         return None
 
+    @staticmethod
+    def find_widgets(widget_class: QWidget | str, recursive: bool = True) -> list[QWidget]:
+        """
+        Return widgets matching the given class (or class-name string).
+
+        Args:
+            widget_class: Either a QWidget subclass or its class-name as a string.
+            recursive: If True (default), traverse all top-level widgets and their children;
+                       if False, scan app.allWidgets() for a flat list.
+
+        Returns:
+            List of QWidget instances matching the class or class-name.
+        """
+        app = QApplication.instance()
+        if app is None:
+            raise RuntimeError("No QApplication instance found.")
+
+        # Match by class-name string
+        if isinstance(widget_class, str):
+            name = widget_class
+            if recursive:
+                result: list[QWidget] = []
+                for top in app.topLevelWidgets():
+                    if top.__class__.__name__ == name:
+                        result.append(top)
+                    result.extend(
+                        w for w in top.findChildren(QWidget) if w.__class__.__name__ == name
+                    )
+                return result
+            return [w for w in app.allWidgets() if w.__class__.__name__ == name]
+
+        # Match by actual class
+        if recursive:
+            result: list[QWidget] = []
+            for top in app.topLevelWidgets():
+                if isinstance(top, widget_class):
+                    result.append(top)
+                result.extend(top.findChildren(widget_class))
+            return result
+
+        return [w for w in app.allWidgets() if isinstance(w, widget_class)]
+
 
 ################## for exporting and importing widget hierarchies ##################
 

bec_widgets/widgets/containers/dock/dock_area.py

@@ -15,18 +15,20 @@ from bec_widgets.utils import ConnectionConfig, WidgetContainerUtils
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.name_utils import pascal_to_snake
-from bec_widgets.utils.toolbar import (
+from bec_widgets.utils.toolbars.actions import (
     ExpandableMenuAction,
     MaterialIconAction,
-    ModularToolBar,
-    SeparatorAction,
+    WidgetAction,
 )
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle
+from bec_widgets.utils.toolbars.toolbar import ModularToolBar
 from bec_widgets.utils.widget_io import WidgetHierarchy
 from bec_widgets.widgets.containers.dock.dock import BECDock, DockConfig
 from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
 from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
 from bec_widgets.widgets.control.scan_control.scan_control import ScanControl
 from bec_widgets.widgets.editors.vscode.vscode import VSCodeEditor
+from bec_widgets.widgets.plots.heatmap.heatmap import Heatmap
 from bec_widgets.widgets.plots.image.image import Image
 from bec_widgets.widgets.plots.motor_map.motor_map import MotorMap
 from bec_widgets.widgets.plots.multi_waveform.multi_waveform import MultiWaveform
@@ -104,145 +106,233 @@ class BECDockArea(BECWidget, QWidget):
 
         self.dark_mode_button = DarkModeButton(parent=self, toolbar=True)
         self.dock_area = DockArea(parent=self)
-        self.toolbar = ModularToolBar(
-            parent=self,
-            actions={
-                "menu_plots": ExpandableMenuAction(
-                    label="Add Plot ",
-                    actions={
-                        "waveform": MaterialIconAction(
-                            icon_name=Waveform.ICON_NAME, tooltip="Add Waveform", filled=True
-                        ),
-                        "scatter_waveform": MaterialIconAction(
-                            icon_name=ScatterWaveform.ICON_NAME,
-                            tooltip="Add Scatter Waveform",
-                            filled=True,
-                        ),
-                        "multi_waveform": MaterialIconAction(
-                            icon_name=MultiWaveform.ICON_NAME,
-                            tooltip="Add Multi Waveform",
-                            filled=True,
-                        ),
-                        "image": MaterialIconAction(
-                            icon_name=Image.ICON_NAME, tooltip="Add Image", filled=True
-                        ),
-                        "motor_map": MaterialIconAction(
-                            icon_name=MotorMap.ICON_NAME, tooltip="Add Motor Map", filled=True
-                        ),
-                    },
-                ),
-                "separator_0": SeparatorAction(),
-                "menu_devices": ExpandableMenuAction(
-                    label="Add Device Control ",
-                    actions={
-                        "scan_control": MaterialIconAction(
-                            icon_name=ScanControl.ICON_NAME, tooltip="Add Scan Control", filled=True
-                        ),
-                        "positioner_box": MaterialIconAction(
-                            icon_name=PositionerBox.ICON_NAME, tooltip="Add Device Box", filled=True
-                        ),
-                    },
-                ),
-                "separator_1": SeparatorAction(),
-                "menu_utils": ExpandableMenuAction(
-                    label="Add Utils ",
-                    actions={
-                        "queue": MaterialIconAction(
-                            icon_name=BECQueue.ICON_NAME, tooltip="Add Scan Queue", filled=True
-                        ),
-                        "vs_code": MaterialIconAction(
-                            icon_name=VSCodeEditor.ICON_NAME, tooltip="Add VS Code", filled=True
-                        ),
-                        "status": MaterialIconAction(
-                            icon_name=BECStatusBox.ICON_NAME,
-                            tooltip="Add BEC Status Box",
-                            filled=True,
-                        ),
-                        "progress_bar": MaterialIconAction(
-                            icon_name=RingProgressBar.ICON_NAME,
-                            tooltip="Add Circular ProgressBar",
-                            filled=True,
-                        ),
-                        # FIXME temporarily disabled  -> issue #644
-                        "log_panel": MaterialIconAction(
-                            icon_name=LogPanel.ICON_NAME,
-                            tooltip="Add LogPanel - Disabled",
-                            filled=True,
-                        ),
-                    },
-                ),
-                "separator_2": SeparatorAction(),
-                "attach_all": MaterialIconAction(
-                    icon_name="zoom_in_map", tooltip="Attach all floating docks"
-                ),
-                "save_state": MaterialIconAction(icon_name="bookmark", tooltip="Save Dock State"),
-                "restore_state": MaterialIconAction(
-                    icon_name="frame_reload", tooltip="Restore Dock State"
-                ),
-            },
-            target_widget=self,
-        )
+        self.toolbar = ModularToolBar(parent=self)
+        self._setup_toolbar()
 
         self.layout.addWidget(self.toolbar)
         self.layout.addWidget(self.dock_area)
-        self.spacer = QWidget(parent=self)
-        self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        self.toolbar.addWidget(self.spacer)
-        self.toolbar.addWidget(self.dark_mode_button)
+
         self._hook_toolbar()
+        self.toolbar.show_bundles(
+            ["menu_plots", "menu_devices", "menu_utils", "dock_actions", "dark_mode"]
+        )
 
     def minimumSizeHint(self):
         return QSize(800, 600)
 
+    def _setup_toolbar(self):
+
+        # Add plot menu
+        self.toolbar.components.add_safe(
+            "menu_plots",
+            ExpandableMenuAction(
+                label="Add Plot ",
+                actions={
+                    "waveform": MaterialIconAction(
+                        icon_name=Waveform.ICON_NAME,
+                        tooltip="Add Waveform",
+                        filled=True,
+                        parent=self,
+                    ),
+                    "scatter_waveform": MaterialIconAction(
+                        icon_name=ScatterWaveform.ICON_NAME,
+                        tooltip="Add Scatter Waveform",
+                        filled=True,
+                        parent=self,
+                    ),
+                    "multi_waveform": MaterialIconAction(
+                        icon_name=MultiWaveform.ICON_NAME,
+                        tooltip="Add Multi Waveform",
+                        filled=True,
+                        parent=self,
+                    ),
+                    "image": MaterialIconAction(
+                        icon_name=Image.ICON_NAME, tooltip="Add Image", filled=True, parent=self
+                    ),
+                    "motor_map": MaterialIconAction(
+                        icon_name=MotorMap.ICON_NAME,
+                        tooltip="Add Motor Map",
+                        filled=True,
+                        parent=self,
+                    ),
+                    "heatmap": MaterialIconAction(
+                        icon_name=Heatmap.ICON_NAME, tooltip="Add Heatmap", filled=True, parent=self
+                    ),
+                },
+            ),
+        )
+
+        bundle = ToolbarBundle("menu_plots", self.toolbar.components)
+        bundle.add_action("menu_plots")
+        self.toolbar.add_bundle(bundle)
+
+        # Add control menu
+        self.toolbar.components.add_safe(
+            "menu_devices",
+            ExpandableMenuAction(
+                label="Add Device Control ",
+                actions={
+                    "scan_control": MaterialIconAction(
+                        icon_name=ScanControl.ICON_NAME,
+                        tooltip="Add Scan Control",
+                        filled=True,
+                        parent=self,
+                    ),
+                    "positioner_box": MaterialIconAction(
+                        icon_name=PositionerBox.ICON_NAME,
+                        tooltip="Add Device Box",
+                        filled=True,
+                        parent=self,
+                    ),
+                },
+            ),
+        )
+        bundle = ToolbarBundle("menu_devices", self.toolbar.components)
+        bundle.add_action("menu_devices")
+        self.toolbar.add_bundle(bundle)
+
+        # Add utils menu
+        self.toolbar.components.add_safe(
+            "menu_utils",
+            ExpandableMenuAction(
+                label="Add Utils ",
+                actions={
+                    "queue": MaterialIconAction(
+                        icon_name=BECQueue.ICON_NAME,
+                        tooltip="Add Scan Queue",
+                        filled=True,
+                        parent=self,
+                    ),
+                    "vs_code": MaterialIconAction(
+                        icon_name=VSCodeEditor.ICON_NAME,
+                        tooltip="Add VS Code",
+                        filled=True,
+                        parent=self,
+                    ),
+                    "status": MaterialIconAction(
+                        icon_name=BECStatusBox.ICON_NAME,
+                        tooltip="Add BEC Status Box",
+                        filled=True,
+                        parent=self,
+                    ),
+                    "progress_bar": MaterialIconAction(
+                        icon_name=RingProgressBar.ICON_NAME,
+                        tooltip="Add Circular ProgressBar",
+                        filled=True,
+                        parent=self,
+                    ),
+                    # FIXME temporarily disabled -> issue #644
+                    "log_panel": MaterialIconAction(
+                        icon_name=LogPanel.ICON_NAME,
+                        tooltip="Add LogPanel - Disabled",
+                        filled=True,
+                        parent=self,
+                    ),
+                    "sbb_monitor": MaterialIconAction(
+                        icon_name="train", tooltip="Add SBB Monitor", filled=True, parent=self
+                    ),
+                },
+            ),
+        )
+        bundle = ToolbarBundle("menu_utils", self.toolbar.components)
+        bundle.add_action("menu_utils")
+        self.toolbar.add_bundle(bundle)
+
+        ########## Dock Actions ##########
+        spacer = QWidget(parent=self)
+        spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        self.toolbar.components.add_safe("spacer", WidgetAction(widget=spacer, adjust_size=False))
+
+        self.toolbar.components.add_safe(
+            "dark_mode", WidgetAction(widget=self.dark_mode_button, adjust_size=False)
+        )
+
+        bundle = ToolbarBundle("dark_mode", self.toolbar.components)
+        bundle.add_action("spacer")
+        bundle.add_action("dark_mode")
+        self.toolbar.add_bundle(bundle)
+
+        self.toolbar.components.add_safe(
+            "attach_all",
+            MaterialIconAction(
+                icon_name="zoom_in_map", tooltip="Attach all floating docks", parent=self
+            ),
+        )
+
+        self.toolbar.components.add_safe(
+            "save_state",
+            MaterialIconAction(icon_name="bookmark", tooltip="Save Dock State", parent=self),
+        )
+        self.toolbar.components.add_safe(
+            "restore_state",
+            MaterialIconAction(icon_name="frame_reload", tooltip="Restore Dock State", parent=self),
+        )
+
+        bundle = ToolbarBundle("dock_actions", self.toolbar.components)
+        bundle.add_action("attach_all")
+        bundle.add_action("save_state")
+        bundle.add_action("restore_state")
+        self.toolbar.add_bundle(bundle)
+
     def _hook_toolbar(self):
-        # Menu Plot
-        self.toolbar.widgets["menu_plots"].widgets["waveform"].triggered.connect(
+        menu_plots = self.toolbar.components.get_action("menu_plots")
+        menu_devices = self.toolbar.components.get_action("menu_devices")
+        menu_utils = self.toolbar.components.get_action("menu_utils")
+
+        menu_plots.actions["waveform"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="Waveform")
         )
-        self.toolbar.widgets["menu_plots"].widgets["scatter_waveform"].triggered.connect(
+
+        menu_plots.actions["scatter_waveform"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="ScatterWaveform")
         )
-        self.toolbar.widgets["menu_plots"].widgets["multi_waveform"].triggered.connect(
+        menu_plots.actions["multi_waveform"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="MultiWaveform")
         )
-        self.toolbar.widgets["menu_plots"].widgets["image"].triggered.connect(
+        menu_plots.actions["image"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="Image")
         )
-        self.toolbar.widgets["menu_plots"].widgets["motor_map"].triggered.connect(
+        menu_plots.actions["motor_map"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="MotorMap")
         )
+        menu_plots.actions["heatmap"].action.triggered.connect(
+            lambda: self._create_widget_from_toolbar(widget_name="Heatmap")
+        )
 
         # Menu Devices
-        self.toolbar.widgets["menu_devices"].widgets["scan_control"].triggered.connect(
+        menu_devices.actions["scan_control"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="ScanControl")
         )
-        self.toolbar.widgets["menu_devices"].widgets["positioner_box"].triggered.connect(
+        menu_devices.actions["positioner_box"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="PositionerBox")
         )
 
         # Menu Utils
-        self.toolbar.widgets["menu_utils"].widgets["queue"].triggered.connect(
+        menu_utils.actions["queue"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="BECQueue")
         )
-        self.toolbar.widgets["menu_utils"].widgets["status"].triggered.connect(
+        menu_utils.actions["status"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="BECStatusBox")
         )
-        self.toolbar.widgets["menu_utils"].widgets["vs_code"].triggered.connect(
+        menu_utils.actions["vs_code"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="VSCodeEditor")
         )
-        self.toolbar.widgets["menu_utils"].widgets["progress_bar"].triggered.connect(
+        menu_utils.actions["progress_bar"].action.triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="RingProgressBar")
         )
         # FIXME temporarily disabled -> issue #644
-        self.toolbar.widgets["menu_utils"].widgets["log_panel"].setEnabled(False)
-        # self.toolbar.widgets["menu_utils"].widgets["log_panel"].triggered.connect(
-        #     lambda: self._create_widget_from_toolbar(widget_name="LogPanel")
-        # )
+        menu_utils.actions["log_panel"].action.setEnabled(False)
+
+        menu_utils.actions["sbb_monitor"].action.triggered.connect(
+            lambda: self._create_widget_from_toolbar(widget_name="SBBMonitor")
+        )
 
         # Icons
-        self.toolbar.widgets["attach_all"].action.triggered.connect(self.attach_all)
-        self.toolbar.widgets["save_state"].action.triggered.connect(self.save_state)
-        self.toolbar.widgets["restore_state"].action.triggered.connect(self.restore_state)
+        self.toolbar.components.get_action("attach_all").action.triggered.connect(self.attach_all)
+        self.toolbar.components.get_action("save_state").action.triggered.connect(self.save_state)
+        self.toolbar.components.get_action("restore_state").action.triggered.connect(
+            self.restore_state
+        )
 
     @SafeSlot()
     def _create_widget_from_toolbar(self, widget_name: str) -> None:

bec_widgets/widgets/containers/main_window/addons/hover_widget.py

@@ -0,0 +1,115 @@
+import sys
+
+from qtpy.QtCore import QPoint, Qt
+from qtpy.QtWidgets import QApplication, QHBoxLayout, QLabel, QProgressBar, QVBoxLayout, QWidget
+
+
+class WidgetTooltip(QWidget):
+    """Frameless, always-on-top window that behaves like a tooltip."""
+
+    def __init__(self, content: QWidget) -> None:
+        super().__init__(None, Qt.ToolTip | Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)
+        self.setAttribute(Qt.WA_ShowWithoutActivating)
+        self.setMouseTracking(True)
+        self.content = content
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(6, 6, 6, 6)
+        layout.addWidget(self.content)
+        self.adjustSize()
+
+    def leaveEvent(self, _event) -> None:
+        self.hide()
+
+    def show_above(self, global_pos: QPoint, offset: int = 8) -> None:
+        self.adjustSize()
+        screen = QApplication.screenAt(global_pos) or QApplication.primaryScreen()
+        screen_geo = screen.availableGeometry()
+        geom = self.geometry()
+
+        x = global_pos.x() - geom.width() // 2
+        y = global_pos.y() - geom.height() - offset
+
+        x = max(screen_geo.left(), min(x, screen_geo.right() - geom.width()))
+        y = max(screen_geo.top(), min(y, screen_geo.bottom() - geom.height()))
+
+        self.move(x, y)
+        self.show()
+
+
+class HoverWidget(QWidget):
+
+    def __init__(self, parent: QWidget | None = None, *, simple: QWidget, full: QWidget):
+        super().__init__(parent)
+        self._simple = simple
+        self._full = full
+        self._full.setVisible(False)
+        self._tooltip = None
+
+        lay = QVBoxLayout(self)
+        lay.setContentsMargins(0, 0, 0, 0)
+        lay.addWidget(simple)
+
+    def enterEvent(self, event):
+        # suppress empty-label tooltips for labels
+        if isinstance(self._full, QLabel) and not self._full.text():
+            return
+
+        if self._tooltip is None:  # first time only
+            self._tooltip = WidgetTooltip(self._full)
+            self._full.setVisible(True)
+
+        centre = self.mapToGlobal(self.rect().center())
+        self._tooltip.show_above(centre)
+        super().enterEvent(event)
+
+    def leaveEvent(self, event):
+        if self._tooltip and self._tooltip.isVisible():
+            self._tooltip.hide()
+        super().leaveEvent(event)
+
+    def close(self):
+        if self._tooltip:
+            self._tooltip.close()
+            self._tooltip.deleteLater()
+            self._tooltip = None
+        super().close()
+
+
+################################################################################
+# Demo
+# Just a simple example to show how the HoverWidget can be used to display
+# a tooltip with a full widget inside (two different widgets are used
+# for the simple and full versions).
+################################################################################
+
+
+class DemoSimpleWidget(QLabel):  # pragma: no cover
+    """A simple widget to be used as a trigger for the tooltip."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setText("Hover me for a preview!")
+
+
+class DemoFullWidget(QProgressBar):  # pragma: no cover
+    """A full widget to be shown in the tooltip."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setRange(0, 100)
+        self.setValue(75)
+        self.setFixedWidth(320)
+        self.setFixedHeight(30)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication(sys.argv)
+
+    window = QWidget()
+    window.layout = QHBoxLayout(window)
+    hover_widget = HoverWidget(simple=DemoSimpleWidget(), full=DemoFullWidget())
+    window.layout.addWidget(hover_widget)
+    window.show()
+
+    sys.exit(app.exec_())

bec_widgets/widgets/containers/main_window/addons/scroll_label.py

@@ -0,0 +1,110 @@
+from qtpy.QtCore import QTimer
+from qtpy.QtGui import QFontMetrics, QPainter
+from qtpy.QtWidgets import QLabel
+
+
+class ScrollLabel(QLabel):
+    """A QLabel that scrolls its text horizontally across the widget."""
+
+    def __init__(self, parent=None, speed_ms=30, step_px=1, delay_ms=2000):
+        super().__init__(parent=parent)
+        self._offset = 0
+        self._text_width = 0
+
+        # scrolling timer (runs continuously once started)
+        self._timer = QTimer(self)
+        self._timer.setInterval(speed_ms)
+        self._timer.timeout.connect(self._scroll)
+
+        # delay‑before‑scroll timer (single‑shot)
+        self._delay_timer = QTimer(self)
+        self._delay_timer.setSingleShot(True)
+        self._delay_timer.setInterval(delay_ms)
+        self._delay_timer.timeout.connect(self._timer.start)
+
+        self._step_px = step_px
+
+    def setText(self, text):
+        """
+        Overridden to ensure that new text replaces the current one
+        immediately.
+        If the label was already scrolling (or in its delay phase),
+        the next message starts **without** the extra delay.
+        """
+        # Determine whether the widget was already in a scrolling cycle
+        was_scrolling = self._timer.isActive() or self._delay_timer.isActive()
+
+        super().setText(text)
+
+        fm = QFontMetrics(self.font())
+        self._text_width = fm.horizontalAdvance(text)
+        self._offset = 0
+
+        # Skip the delay when we were already scrolling
+        self._update_timer(skip_delay=was_scrolling)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        self._update_timer()
+
+    def _update_timer(self, *, skip_delay: bool = False):
+        """
+        Decide whether to start or stop scrolling.
+
+        If the text is wider than the visible area, start a single‑shot
+        delay timer (2s by default). Scrolling begins only after this
+        delay. Any change (resize or new text) restarts the logic.
+        """
+        needs_scroll = self._text_width > self.width()
+
+        if needs_scroll:
+            # Reset any running timers
+            if self._timer.isActive():
+                self._timer.stop()
+            if self._delay_timer.isActive():
+                self._delay_timer.stop()
+
+            self._offset = 0
+
+            # Start scrolling immediately when we should skip the delay,
+            # otherwise apply the configured delay_ms interval
+            if skip_delay:
+                self._timer.start()
+            else:
+                self._delay_timer.start()
+        else:
+            if self._delay_timer.isActive():
+                self._delay_timer.stop()
+            if self._timer.isActive():
+                self._timer.stop()
+            self.update()
+
+    def _scroll(self):
+        self._offset += self._step_px
+        if self._offset >= self._text_width:
+            self._offset = 0
+        self.update()
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.TextAntialiasing)
+        text = self.text()
+        if not text:
+            return
+        fm = QFontMetrics(self.font())
+        y = (self.height() + fm.ascent() - fm.descent()) // 2
+        if self._text_width <= self.width():
+            painter.drawText(0, y, text)
+        else:
+            x = -self._offset
+            gap = 50  # space between repeating text blocks
+            while x < self.width():
+                painter.drawText(x, y, text)
+                x += self._text_width + gap
+
+    def cleanup(self):
+        """Stop all timers to prevent memory leaks."""
+        if self._timer.isActive():
+            self._timer.stop()
+        if self._delay_timer.isActive():
+            self._delay_timer.stop()

bec_widgets/widgets/containers/main_window/main_window.py

@@ -1,17 +1,36 @@
+from __future__ import annotations
+
 import os
 
-from qtpy.QtCore import QSize
+from bec_lib.endpoints import MessageEndpoints
+from qtpy.QtCore import QEasingCurve, QEvent, QPropertyAnimation, QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QActionGroup, QIcon
-from qtpy.QtWidgets import QApplication, QMainWindow, QStyle
+from qtpy.QtWidgets import (
+    QApplication,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QMainWindow,
+    QStyle,
+    QVBoxLayout,
+    QWidget,
+)
 
 import bec_widgets
 from bec_widgets.utils import UILoader
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import apply_theme
-from bec_widgets.utils.container_utils import WidgetContainerUtils
+from bec_widgets.utils.colors import apply_theme, set_theme
 from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.widget_io import WidgetHierarchy
+from bec_widgets.widgets.containers.main_window.addons.hover_widget import HoverWidget
+from bec_widgets.widgets.containers.main_window.addons.notification_center.notification_banner import (
+    BECNotificationBroker,
+    NotificationCentre,
+    NotificationIndicator,
+)
+from bec_widgets.widgets.containers.main_window.addons.scroll_label import ScrollLabel
 from bec_widgets.widgets.containers.main_window.addons.web_links import BECWebLinksMixin
+from bec_widgets.widgets.progress.scan_progressbar.scan_progressbar import ScanProgressBar
 
 MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
@@ -19,6 +38,8 @@ MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 class BECMainWindow(BECWidget, QMainWindow):
     RPC = False
     PLUGIN = False
+    SCAN_PROGRESS_WIDTH = 100  # px
+    STATUS_BAR_WIDGETS_EXPIRE_TIME = 60_000  # milliseconds
 
     def __init__(
         self,
@@ -32,10 +53,55 @@ class BECMainWindow(BECWidget, QMainWindow):
         super().__init__(parent=parent, gui_id=gui_id, **kwargs)
 
         self.app = QApplication.instance()
+        self.status_bar = self.statusBar()
         self.setWindowTitle(window_title)
+
+        # Notification Centre overlay
+        self.notification_centre = NotificationCentre(parent=self)  # Notification layer
+        self.notification_broker = BECNotificationBroker()
+        self._nc_margin = 16
+        self._position_notification_centre()
+
+        # Init ui
         self._init_ui()
         self._connect_to_theme_change()
 
+        # Connections to BEC Notifications
+        self.bec_dispatcher.connect_slot(
+            self.display_client_message, MessageEndpoints.client_info()
+        )
+
+    def setCentralWidget(self, widget: QWidget, qt_default: bool = False):  # type: ignore[override]
+        """
+        Re‑implement QMainWindow.setCentralWidget so that the *main content*
+        widget always lives on the lower layer of the stacked layout that
+        hosts our notification overlays.
+
+        Args:
+            widget: The widget that should become the new central content.
+            qt_default: When *True* the call is forwarded to the base class so
+                that Qt behaves exactly as the original implementation (used
+                during __init__ when we first install ``self._full_content``).
+        """
+        super().setCentralWidget(widget)
+        self.notification_centre.raise_()
+        self.statusBar().raise_()
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        self._position_notification_centre()
+
+    def _position_notification_centre(self):
+        """Keep the notification panel at a fixed margin top-right."""
+        if not hasattr(self, "notification_centre"):
+            return
+        margin = getattr(self, "_nc_margin", 16)  # px
+        nc = self.notification_centre
+        nc.move(self.width() - nc.width() - margin, margin)
+
+    ################################################################################
+    # MainWindow Elements Initialization
+    ################################################################################
     def _init_ui(self):
 
         # Set the icon
@@ -43,40 +109,209 @@ class BECMainWindow(BECWidget, QMainWindow):
 
         # Set Menu and Status bar
         self._setup_menu_bar()
+        self._init_status_bar_widgets()
 
         # BEC Specific UI
         self.display_app_id()
 
+    def _init_status_bar_widgets(self):
+        """
+        Prepare the BEC specific widgets in the status bar.
+        """
+
+        # Left: App‑ID label
+        self._app_id_label = QLabel()
+        self._app_id_label.setAlignment(
+            Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter
+        )
+        self.status_bar.addWidget(self._app_id_label)
+
+        # Add a separator after the app ID label
+        self._add_separator()
+
+        # Centre: Client‑info label (stretch=1 so it expands)
+        self._add_client_info_label()
+
+        # Add scan_progress bar with display logic
+        self._add_scan_progress_bar()
+
+        # Setup NotificationIndicator to bottom right of the status bar
+        self._add_notification_indicator()
+
+    ################################################################################
+    # Notification indicator and Notification Centre helpers
+
+    def _add_notification_indicator(self):
+        """
+        Add the notification indicator to the status bar and hook the signals.
+        """
+        # Add the notification indicator to the status bar
+        self.notification_indicator = NotificationIndicator(self)
+        self.status_bar.addPermanentWidget(self.notification_indicator)
+
+        # Connect the notification broker to the indicator
+        self.notification_centre.counts_updated.connect(self.notification_indicator.update_counts)
+        self.notification_indicator.filter_changed.connect(self.notification_centre.apply_filter)
+        self.notification_indicator.show_all_requested.connect(self.notification_centre.show_all)
+        self.notification_indicator.hide_all_requested.connect(self.notification_centre.hide_all)
+
+    ################################################################################
+    # Client message status bar widget helpers
+
+    def _add_client_info_label(self):
+        """
+        Add a client info label to the status bar.
+        This label will display messages from the BEC dispatcher.
+        """
+
+        # Scroll label for client info in Status Bar
+        self._client_info_label = ScrollLabel(self)
+        self._client_info_label.setAlignment(
+            Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter
+        )
+        # Full label used in the hover widget
+        self._client_info_label_full = QLabel(self)
+        self._client_info_label_full.setAlignment(
+            Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter
+        )
+        # Hover widget to show the full client info label
+        self._client_info_hover = HoverWidget(
+            self, simple=self._client_info_label, full=self._client_info_label_full
+        )
+        self.status_bar.addWidget(self._client_info_hover, 1)
+
+        # Timer to automatically clear client messages once they expire
+        self._client_info_expire_timer = QTimer(self)
+        self._client_info_expire_timer.setSingleShot(True)
+        self._client_info_expire_timer.timeout.connect(lambda: self._client_info_label.setText(""))
+        self._client_info_expire_timer.timeout.connect(
+            lambda: self._client_info_label_full.setText("")
+        )
+
+    ################################################################################
+    # Progress‑bar helpers
+    def _add_scan_progress_bar(self):
+
+        # Setting HoverWidget for the scan progress bar - minimal and full version
+        self._scan_progress_bar_simple = ScanProgressBar(self, one_line_design=True)
+        self._scan_progress_bar_simple.show_elapsed_time = False
+        self._scan_progress_bar_simple.show_remaining_time = False
+        self._scan_progress_bar_simple.show_source_label = False
+        self._scan_progress_bar_simple.progressbar.label_template = ""
+        self._scan_progress_bar_simple.progressbar.setFixedHeight(8)
+        self._scan_progress_bar_simple.progressbar.setFixedWidth(80)
+        self._scan_progress_bar_full = ScanProgressBar(self)
+        self._scan_progress_hover = HoverWidget(
+            self, simple=self._scan_progress_bar_simple, full=self._scan_progress_bar_full
+        )
+
+        # Bundle the progress bar with a separator
+        separator = self._add_separator(separate_object=True)
+        self._scan_progress_bar_with_separator = QWidget()
+        self._scan_progress_bar_with_separator.layout = QHBoxLayout(
+            self._scan_progress_bar_with_separator
+        )
+        self._scan_progress_bar_with_separator.layout.setContentsMargins(0, 0, 0, 0)
+        self._scan_progress_bar_with_separator.layout.setSpacing(0)
+        self._scan_progress_bar_with_separator.layout.addWidget(separator)
+        self._scan_progress_bar_with_separator.layout.addWidget(self._scan_progress_hover)
+
+        # Set Size
+        self._scan_progress_bar_target_width = self.SCAN_PROGRESS_WIDTH
+        self._scan_progress_bar_with_separator.setMaximumWidth(self._scan_progress_bar_target_width)
+
+        self.status_bar.addWidget(self._scan_progress_bar_with_separator)
+
+        # Visibility logic
+        self._scan_progress_bar_with_separator.hide()
+        self._scan_progress_bar_with_separator.setMaximumWidth(0)
+
+        # Timer for hiding logic
+        self._scan_progress_hide_timer = QTimer(self)
+        self._scan_progress_hide_timer.setSingleShot(True)
+        self._scan_progress_hide_timer.setInterval(self.STATUS_BAR_WIDGETS_EXPIRE_TIME)
+        self._scan_progress_hide_timer.timeout.connect(self._animate_hide_scan_progress_bar)
+
+        # Show / hide behaviour
+        self._scan_progress_bar_simple.progress_started.connect(self._show_scan_progress_bar)
+        self._scan_progress_bar_simple.progress_finished.connect(self._delay_hide_scan_progress_bar)
+
+    def _show_scan_progress_bar(self):
+        if self._scan_progress_hide_timer.isActive():
+            self._scan_progress_hide_timer.stop()
+        if self._scan_progress_bar_with_separator.isVisible():
+            return
+
+        # Make visible and reset width
+        self._scan_progress_bar_with_separator.show()
+        self._scan_progress_bar_with_separator.setMaximumWidth(0)
+
+        self._show_container_anim = QPropertyAnimation(
+            self._scan_progress_bar_with_separator, b"maximumWidth", self
+        )
+        self._show_container_anim.setDuration(300)
+        self._show_container_anim.setStartValue(0)
+        self._show_container_anim.setEndValue(self._scan_progress_bar_target_width)
+        self._show_container_anim.setEasingCurve(QEasingCurve.OutCubic)
+        self._show_container_anim.start()
+
+    def _delay_hide_scan_progress_bar(self):
+        """Start the countdown to hide the scan progress bar."""
+        if hasattr(self, "_scan_progress_hide_timer"):
+            self._scan_progress_hide_timer.start()
+
+    def _animate_hide_scan_progress_bar(self):
+        """Shrink container to the right, then hide."""
+        self._hide_container_anim = QPropertyAnimation(
+            self._scan_progress_bar_with_separator, b"maximumWidth", self
+        )
+        self._hide_container_anim.setDuration(300)
+        self._hide_container_anim.setStartValue(self._scan_progress_bar_with_separator.width())
+        self._hide_container_anim.setEndValue(0)
+        self._hide_container_anim.setEasingCurve(QEasingCurve.InCubic)
+        self._hide_container_anim.finished.connect(self._scan_progress_bar_with_separator.hide)
+        self._hide_container_anim.start()
+
+    def _add_separator(self, separate_object: bool = False) -> QWidget | None:
+        """
+        Add a vertically centred separator to the status bar or just return it as a separate object.
+        """
+        status_bar = self.statusBar()
+
+        # The actual line
+        line = QFrame()
+        line.setFrameShape(QFrame.VLine)
+        line.setFrameShadow(QFrame.Sunken)
+        line.setFixedHeight(status_bar.sizeHint().height() - 2)
+
+        # Wrapper to center the line vertically -> work around for QFrame not being able to center itself
+        wrapper = QWidget()
+        vbox = QVBoxLayout(wrapper)
+        vbox.setContentsMargins(0, 0, 0, 0)
+        vbox.addStretch()
+        vbox.addWidget(line, alignment=Qt.AlignHCenter)
+        vbox.addStretch()
+        wrapper.setFixedWidth(line.sizeHint().width())
+
+        if separate_object:
+            return wrapper
+        status_bar.addWidget(wrapper)
+
     def _init_bec_icon(self):
         icon = self.app.windowIcon()
         if icon.isNull():
-            print("No icon is set, setting default icon")
             icon = QIcon()
             icon.addFile(
                 os.path.join(MODULE_PATH, "assets", "app_icons", "bec_widgets_icon.png"),
                 size=QSize(48, 48),
             )
             self.app.setWindowIcon(icon)
-        else:
-            print("An icon is set")
 
     def load_ui(self, ui_file):
         loader = UILoader(self)
         self.ui = loader.loader(ui_file)
         self.setCentralWidget(self.ui)
 
-    def display_app_id(self):
-        """
-        Display the app ID in the status bar.
-        """
-        if self.bec_dispatcher.cli_server is None:
-            status_message = "Not connected"
-        else:
-            # Get the server ID from the dispatcher
-            server_id = self.bec_dispatcher.cli_server.gui_id
-            status_message = f"App ID: {server_id}"
-        self.statusBar().showMessage(status_message)
-
     def _fetch_theme(self) -> str:
         return self.app.theme.theme
 
@@ -164,14 +399,64 @@ class BECMainWindow(BECWidget, QMainWindow):
         help_menu.addAction(widgets_docs)
         help_menu.addAction(bug_report)
 
+    ################################################################################
+    # Status Bar Addons
+    ################################################################################
+    def display_app_id(self):
+        """
+        Display the app ID in the status bar.
+        """
+        if self.bec_dispatcher.cli_server is None:
+            status_message = "Not connected"
+        else:
+            # Get the server ID from the dispatcher
+            server_id = self.bec_dispatcher.cli_server.gui_id
+            status_message = f"App ID: {server_id}"
+        self._app_id_label.setText(status_message)
+
+    @SafeSlot(dict, dict)
+    def display_client_message(self, msg: dict, meta: dict):
+        """
+        Display a client message in the status bar.
+
+        Args:
+            msg(dict): The message to display, should contain:
+            meta(dict): Metadata about the message, usually empty.
+        """
+        message = msg.get("message", "")
+        expiration = msg.get("expire", 0)  # 0 → never expire
+        self._client_info_label.setText(message)
+        self._client_info_label_full.setText(message)
+
+        # Restart the expiration timer if necessary
+        if hasattr(self, "_client_info_expire_timer") and self._client_info_expire_timer.isActive():
+            self._client_info_expire_timer.stop()
+        if expiration and expiration > 0:
+            self._client_info_expire_timer.start(int(expiration * 1000))
+
+    ################################################################################
+    # General and Cleanup Methods
+    ################################################################################
     @SafeSlot(str)
     def change_theme(self, theme: str):
-        apply_theme(theme)
+        """
+        Change the theme of the application and propagate it to widgets.
+
+        Args:
+            theme(str): Either "light" or "dark".
+        """
+        set_theme(theme)  # emits theme_updated and applies palette globally
+
+    def event(self, event):
+        if event.type() == QEvent.Type.StatusTip:
+            return True
+        return super().event(event)
 
     def cleanup(self):
         central_widget = self.centralWidget()
-        central_widget.close()
-        central_widget.deleteLater()
+        if central_widget is not None:
+            central_widget.close()
+            central_widget.deleteLater()
         if not isinstance(central_widget, BECWidget):
             # if the central widget is not a BECWidget, we need to call the cleanup method
             # of all widgets whose parent is the current BECMainWindow
@@ -182,8 +467,39 @@ class BECMainWindow(BECWidget, QMainWindow):
                     child.cleanup()
                     child.close()
                     child.deleteLater()
+
+        # Timer cleanup
+        if hasattr(self, "_client_info_expire_timer") and self._client_info_expire_timer.isActive():
+            self._client_info_expire_timer.stop()
+        if hasattr(self, "_scan_progress_hide_timer") and self._scan_progress_hide_timer.isActive():
+            self._scan_progress_hide_timer.stop()
+
+        ########################################
+        # Status bar widgets cleanup
+
+        # Client info label cleanup
+        self._client_info_label.cleanup()
+        self._client_info_hover.close()
+        self._client_info_hover.deleteLater()
+        # Scan progress bar cleanup
+        self._scan_progress_bar_simple.close()
+        self._scan_progress_bar_simple.deleteLater()
+        self._scan_progress_bar_full.close()
+        self._scan_progress_bar_full.deleteLater()
+        self._scan_progress_hover.close()
+        self._scan_progress_hover.deleteLater()
         super().cleanup()
 
 
 class UILaunchWindow(BECMainWindow):
     RPC = True
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    main_window = UILaunchWindow()
+    main_window.show()
+    main_window.resize(800, 600)
+    sys.exit(app.exec())

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

@@ -138,7 +138,11 @@ class PositionerBoxBase(BECWidget, CompactPopupWidget):
         signals = msg_content.get("signals", {})
         # pylint: disable=protected-access
         hinted_signals = self.dev[device]._hints
-        precision = self.dev[device].precision
+        precision = getattr(self.dev[device], "precision", 8)
+        try:
+            precision = int(precision)
+        except (TypeError, ValueError):
+            precision = int(8)
 
         spinner = ui_components["spinner"]
         position_indicator = ui_components["position_indicator"]
@@ -178,11 +182,13 @@ class PositionerBoxBase(BECWidget, CompactPopupWidget):
             spinner.setVisible(False)
 
         if readback_val is not None:
-            readback.setText(f"{readback_val:.{precision}f}")
+            text = f"{readback_val:.{precision}f}"
+            readback.setText(text)
             position_emit(readback_val)
 
         if setpoint_val is not None:
-            setpoint.setText(f"{setpoint_val:.{precision}f}")
+            text = f"{setpoint_val:.{precision}f}"
+            setpoint.setText(text)
 
         limits = self.dev[device].limits
         limit_update(limits)
@@ -205,10 +211,13 @@ class PositionerBoxBase(BECWidget, CompactPopupWidget):
         ui["readback"].setToolTip(f"{device} readback")
         ui["setpoint"].setToolTip(f"{device} setpoint")
         ui["step_size"].setToolTip(f"Step size for {device}")
-        precision = self.dev[device].precision
-        if precision is not None:
-            ui["step_size"].setDecimals(precision)
-            ui["step_size"].setValue(10**-precision * 10)
+        precision = getattr(self.dev[device], "precision", 8)
+        try:
+            precision = int(precision)
+        except (TypeError, ValueError):
+            precision = int(8)
+        ui["step_size"].setDecimals(precision)
+        ui["step_size"].setValue(10**-precision * 10)
 
     def _swap_readback_signal_connection(self, slot, old_device, new_device):
         self.bec_dispatcher.disconnect_slot(slot, MessageEndpoints.device_readback(old_device))

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

@@ -45,7 +45,12 @@ class PositionerGroupBox(QGroupBox):
 
     def _on_position_update(self, pos: float):
         self.position_update.emit(pos)
-        self.widget.label = f"%.{self.widget.dev[self.widget.device].precision}f" % pos
+        precision = getattr(self.widget.dev[self.widget.device], "precision", 8)
+        try:
+            precision = int(precision)
+        except (TypeError, ValueError):
+            precision = int(8)
+        self.widget.label = f"{pos:.{precision}f}"
 
     def close(self):
         self.widget.close()

bec_widgets/widgets/control/device_input/base_classes/device_input_base.py

@@ -6,10 +6,10 @@ from bec_lib.device import ComputedSignal, Device, Positioner, ReadoutPriority
 from bec_lib.device import Signal as BECSignal
 from bec_lib.logger import bec_logger
 from pydantic import field_validator
-from qtpy.QtCore import Property, Signal, Slot
 
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.filter_io import FilterIO
 from bec_widgets.utils.widget_io import WidgetIO
 
@@ -100,7 +100,7 @@ class DeviceInputBase(BECWidget):
 
     ### QtSlots ###
 
-    @Slot(str)
+    @SafeSlot(str)
     def set_device(self, device: str):
         """
         Set the device.
@@ -114,7 +114,7 @@ class DeviceInputBase(BECWidget):
         else:
             logger.warning(f"Device {device} is not in the filtered selection.")
 
-    @Slot()
+    @SafeSlot()
     def update_devices_from_filters(self):
         """Update the devices based on the current filter selection
         in self.device_filter and self.readout_filter. If apply_filter is False,
@@ -133,7 +133,7 @@ class DeviceInputBase(BECWidget):
         self.devices = [device.name for device in devs]
         self.set_device(current_device)
 
-    @Slot(list)
+    @SafeSlot(list)
     def set_available_devices(self, devices: list[str]):
         """
         Set the devices. If a device in the list is not valid, it will not be considered.
@@ -146,7 +146,7 @@ class DeviceInputBase(BECWidget):
 
     ### QtProperties ###
 
-    @Property(
+    @SafeProperty(
         "QStringList",
         doc="List of devices. If updated, it will disable the apply filters property.",
     )
@@ -165,7 +165,7 @@ class DeviceInputBase(BECWidget):
         self.config.devices = value
         FilterIO.set_selection(widget=self, selection=value)
 
-    @Property(str)
+    @SafeProperty(str)
     def default(self):
         """Get the default device name. If set through this property, it will update only if the device is within the filtered selection."""
         return self.config.default
@@ -177,7 +177,7 @@ class DeviceInputBase(BECWidget):
         self.config.default = value
         WidgetIO.set_value(widget=self, value=value)
 
-    @Property(bool)
+    @SafeProperty(bool)
     def apply_filter(self):
         """Apply the filters on the devices."""
         return self.config.apply_filter
@@ -187,7 +187,7 @@ class DeviceInputBase(BECWidget):
         self.config.apply_filter = value
         self.update_devices_from_filters()
 
-    @Property(bool)
+    @SafeProperty(bool)
     def filter_to_device(self):
         """Include devices in filters."""
         return BECDeviceFilter.DEVICE in self.device_filter
@@ -200,7 +200,7 @@ class DeviceInputBase(BECWidget):
             self._device_filter.remove(BECDeviceFilter.DEVICE)
         self.update_devices_from_filters()
 
-    @Property(bool)
+    @SafeProperty(bool)
     def filter_to_positioner(self):
         """Include devices of type Positioner in filters."""
         return BECDeviceFilter.POSITIONER in self.device_filter
@@ -213,7 +213,7 @@ class DeviceInputBase(BECWidget):
             self._device_filter.remove(BECDeviceFilter.POSITIONER)
         self.update_devices_from_filters()
 
-    @Property(bool)
+    @SafeProperty(bool)
     def filter_to_signal(self):
         """Include devices of type Signal in filters."""
         return BECDeviceFilter.SIGNAL in self.device_filter
@@ -226,7 +226,7 @@ class DeviceInputBase(BECWidget):
             self._device_filter.remove(BECDeviceFilter.SIGNAL)
         self.update_devices_from_filters()
 
-    @Property(bool)
+    @SafeProperty(bool)
     def filter_to_computed_signal(self):
         """Include devices of type ComputedSignal in filters."""
         return BECDeviceFilter.COMPUTED_SIGNAL in self.device_filter
@@ -239,7 +239,7 @@ class DeviceInputBase(BECWidget):
             self._device_filter.remove(BECDeviceFilter.COMPUTED_SIGNAL)
         self.update_devices_from_filters()
 
-    @Property(bool)
+    @SafeProperty(bool)
     def readout_monitored(self):
         """Include devices with readout priority Monitored in filters."""
         return ReadoutPriority.MONITORED in self.readout_filter
@@ -252,7 +252,7 @@ class DeviceInputBase(BECWidget):
             self._readout_filter.remove(ReadoutPriority.MONITORED)
         self.update_devices_from_filters()
 
-    @Property(bool)
+    @SafeProperty(bool)
     def readout_baseline(self):
         """Include devices with readout priority Baseline in filters."""
         return ReadoutPriority.BASELINE in self.readout_filter
@@ -265,7 +265,7 @@ class DeviceInputBase(BECWidget):
             self._readout_filter.remove(ReadoutPriority.BASELINE)
         self.update_devices_from_filters()
 
-    @Property(bool)
+    @SafeProperty(bool)
     def readout_async(self):
         """Include devices with readout priority Async in filters."""
         return ReadoutPriority.ASYNC in self.readout_filter
@@ -278,7 +278,7 @@ class DeviceInputBase(BECWidget):
             self._readout_filter.remove(ReadoutPriority.ASYNC)
         self.update_devices_from_filters()
 
-    @Property(bool)
+    @SafeProperty(bool)
     def readout_continuous(self):
         """Include devices with readout priority continuous in filters."""
         return ReadoutPriority.CONTINUOUS in self.readout_filter
@@ -291,7 +291,7 @@ class DeviceInputBase(BECWidget):
             self._readout_filter.remove(ReadoutPriority.CONTINUOUS)
         self.update_devices_from_filters()
 
-    @Property(bool)
+    @SafeProperty(bool)
     def readout_on_request(self):
         """Include devices with readout priority OnRequest in filters."""
         return ReadoutPriority.ON_REQUEST in self.readout_filter

bec_widgets/widgets/control/device_input/base_classes/device_signal_input_base.py

@@ -1,11 +1,12 @@
 from bec_lib.callback_handler import EventType
 from bec_lib.device import Signal
 from bec_lib.logger import bec_logger
-from qtpy.QtCore import Property, Slot
+from qtpy.QtCore import Property
 
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.filter_io import FilterIO
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.filter_io import FilterIO, LineEditFilterHandler
 from bec_widgets.utils.ophyd_kind_util import Kind
 from bec_widgets.utils.widget_io import WidgetIO
 
@@ -49,18 +50,18 @@ class DeviceSignalInputBase(BECWidget):
 
         self._device = None
         self.get_bec_shortcuts()
-        self._signal_filter = []
+        self._signal_filter = set()
         self._signals = []
         self._hinted_signals = []
         self._normal_signals = []
         self._config_signals = []
-        self.bec_dispatcher.client.callbacks.register(
+        self._device_update_register = self.bec_dispatcher.client.callbacks.register(
             EventType.DEVICE_UPDATE, self.update_signals_from_filters
         )
 
     ### Qt Slots ###
 
-    @Slot(str)
+    @SafeSlot(str)
     def set_signal(self, signal: str):
         """
         Set the signal.
@@ -68,7 +69,7 @@ class DeviceSignalInputBase(BECWidget):
         Args:
             signal (str): signal name.
         """
-        if self.validate_signal(signal) is True:
+        if self.validate_signal(signal):
             WidgetIO.set_value(widget=self, value=signal)
             self.config.default = signal
         else:
@@ -76,7 +77,7 @@ class DeviceSignalInputBase(BECWidget):
                 f"Signal {signal} not found for device {self.device} and filtered selection {self.signal_filter}."
             )
 
-    @Slot(str)
+    @SafeSlot(str)
     def set_device(self, device: str | None):
         """
         Set the device. If device is not valid, device will be set to None which happens
@@ -90,8 +91,8 @@ class DeviceSignalInputBase(BECWidget):
             self._device = device
         self.update_signals_from_filters()
 
-    @Slot(dict, dict)
-    @Slot()
+    @SafeSlot(dict, dict)
+    @SafeSlot()
     def update_signals_from_filters(
         self, content: dict | None = None, metadata: dict | None = None
     ):
@@ -107,25 +108,32 @@ class DeviceSignalInputBase(BECWidget):
         if not self.validate_device(self._device):
             self._device = None
             self.config.device = self._device
-            return
-        device = self.get_device_object(self._device)
-        # See above convention for Signals and ComputedSignals
-        if isinstance(device, Signal):
-            self._signals = [self._device]
-            self._hinted_signals = [self._device]
+            self._signals = []
+            self._hinted_signals = []
             self._normal_signals = []
             self._config_signals = []
             FilterIO.set_selection(widget=self, selection=self._signals)
             return
+        device = self.get_device_object(self._device)
         device_info = device._info.get("signals", {})
 
+        # See above convention for Signals and ComputedSignals
+        if isinstance(device, Signal):
+            self._signals = [(self._device, {})]
+            self._hinted_signals = [(self._device, {})]
+            self._normal_signals = []
+            self._config_signals = []
+            FilterIO.set_selection(widget=self, selection=self._signals)
+            return
+
         def _update(kind: Kind):
-            return [
-                signal
-                for signal, signal_info in device_info.items()
-                if kind in self.signal_filter
-                and (signal_info.get("kind_str", None) == str(kind.name))
-            ]
+            return FilterIO.update_with_kind(
+                widget=self,
+                kind=kind,
+                signal_filter=self.signal_filter,
+                device_info=device_info,
+                device_name=self._device,
+            )
 
         self._hinted_signals = _update(Kind.hinted)
         self._normal_signals = _update(Kind.normal)
@@ -158,9 +166,9 @@ class DeviceSignalInputBase(BECWidget):
     @include_hinted_signals.setter
     def include_hinted_signals(self, value: bool):
         if value:
-            self._signal_filter.append(Kind.hinted)
+            self._signal_filter.add(Kind.hinted)
         else:
-            self._signal_filter.remove(Kind.hinted)
+            self._signal_filter.discard(Kind.hinted)
         self.update_signals_from_filters()
 
     @Property(bool)
@@ -171,9 +179,9 @@ class DeviceSignalInputBase(BECWidget):
     @include_normal_signals.setter
     def include_normal_signals(self, value: bool):
         if value:
-            self._signal_filter.append(Kind.normal)
+            self._signal_filter.add(Kind.normal)
         else:
-            self._signal_filter.remove(Kind.normal)
+            self._signal_filter.discard(Kind.normal)
         self.update_signals_from_filters()
 
     @Property(bool)
@@ -184,9 +192,9 @@ class DeviceSignalInputBase(BECWidget):
     @include_config_signals.setter
     def include_config_signals(self, value: bool):
         if value:
-            self._signal_filter.append(Kind.config)
+            self._signal_filter.add(Kind.config)
         else:
-            self._signal_filter.remove(Kind.config)
+            self._signal_filter.discard(Kind.config)
         self.update_signals_from_filters()
 
     ### Properties and Methods ###
@@ -270,11 +278,21 @@ class DeviceSignalInputBase(BECWidget):
         Args:
             signal(str): Signal to validate.
         """
-        if signal in self.signals:
-            return True
+        for entry in self.signals:
+            if isinstance(entry, tuple):
+                entry = entry[0]
+            if entry == signal:
+                return True
         return False
 
     def _process_config_input(self, config: DeviceSignalInputBaseConfig | dict | None):
         if config is None:
             return DeviceSignalInputBaseConfig(widget_class=self.__class__.__name__)
         return DeviceSignalInputBaseConfig.model_validate(config)
+
+    def cleanup(self):
+        """
+        Cleanup the widget.
+        """
+        self.bec_dispatcher.client.callbacks.remove(self._device_update_register)
+        super().cleanup()

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

@@ -5,6 +5,7 @@ from qtpy.QtGui import QPainter, QPaintEvent, QPen
 from qtpy.QtWidgets import QComboBox, QSizePolicy
 
 from bec_widgets.utils.colors import get_accent_colors
+from bec_widgets.utils.error_popups import SafeProperty
 from bec_widgets.widgets.control.device_input.base_classes.device_input_base import (
     BECDeviceFilter,
     DeviceInputBase,
@@ -34,6 +35,7 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
     PLUGIN = True
 
     device_selected = Signal(str)
+    device_reset = Signal()
     device_config_update = Signal()
 
     def __init__(
@@ -60,6 +62,7 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
         self._callback_id = None
         self._is_valid_input = False
         self._accent_colors = get_accent_colors()
+        self._set_first_element_as_empty = False
         # We do not consider the config that is passed here, this produced problems
         # with QtDesigner, since config and input arguments may differ and resolve properly
         # Implementing this logic and config recoverage is postponed.
@@ -92,6 +95,31 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
         self.currentTextChanged.connect(self.check_validity)
         self.check_validity(self.currentText())
 
+    @SafeProperty(bool)
+    def set_first_element_as_empty(self) -> bool:
+        """
+        Whether the first element in the combobox should be empty.
+        This is useful to allow the user to select a device from the list.
+        """
+        return self._set_first_element_as_empty
+
+    @set_first_element_as_empty.setter
+    def set_first_element_as_empty(self, value: bool) -> None:
+        """
+        Set whether the first element in the combobox should be empty.
+        This is useful to allow the user to select a device from the list.
+
+        Args:
+            value (bool): True if the first element should be empty, False otherwise.
+        """
+        self._set_first_element_as_empty = value
+        if self._set_first_element_as_empty:
+            self.insertItem(0, "")
+            self.setCurrentIndex(0)
+        else:
+            if self.count() > 0 and self.itemText(0) == "":
+                self.removeItem(0)
+
     def on_device_update(self, action: str, content: dict) -> None:
         """
         Callback for device update events. Triggers the device_update signal.
@@ -147,8 +175,28 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
             self.device_selected.emit(input_text)
         else:
             self._is_valid_input = False
+            self.device_reset.emit()
         self.update()
 
+    def validate_device(self, device: str) -> bool:  # type: ignore[override]
+        """
+        Extend validation so that preview‑signal pseudo‑devices (labels like
+        ``"eiger_preview"``) are accepted as valid choices.
+
+        The validation run only on device not on the preview‑signal.
+
+        Args:
+            device: The text currently entered/selected.
+
+        Returns:
+            True if the device is a genuine BEC device *or* one of the
+            whitelisted preview‑signal entries.
+        """
+        idx = self.findText(device)
+        if idx >= 0 and isinstance(self.itemData(idx), tuple):
+            device = self.itemData(idx)[0]  # type: ignore[assignment]
+        return super().validate_device(device)
+
 
 if __name__ == "__main__":  # pragma: no cover
     # pylint: disable=import-outside-toplevel

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

@@ -1,11 +1,15 @@
+from __future__ import annotations
+
 from bec_lib.device import Positioner
-from qtpy.QtCore import QSize, Signal, Slot
+from qtpy.QtCore import QSize, Signal
 from qtpy.QtWidgets import QComboBox, QSizePolicy
 
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.filter_io import ComboBoxFilterHandler, FilterIO
 from bec_widgets.utils.ophyd_kind_util import Kind
 from bec_widgets.widgets.control.device_input.base_classes.device_signal_input_base import (
     DeviceSignalInputBase,
+    DeviceSignalInputBaseConfig,
 )
 
 
@@ -35,7 +39,7 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
         self,
         parent=None,
         client=None,
-        config: DeviceSignalInputBase = None,
+        config: DeviceSignalInputBaseConfig | None = None,
         gui_id: str | None = None,
         device: str | None = None,
         signal_filter: str | list[str] | None = None,
@@ -52,6 +56,7 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
 
         self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
         self.setMinimumSize(QSize(100, 0))
+        self._set_first_element_as_empty = True
         # We do not consider the config that is passed here, this produced problems
         # with QtDesigner, since config and input arguments may differ and resolve properly
         # Implementing this logic and config recoverage is postponed.
@@ -65,9 +70,13 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
         if default is not None:
             self.set_signal(default)
 
-    def update_signals_from_filters(self):
+    @SafeSlot()
+    @SafeSlot(dict, dict)
+    def update_signals_from_filters(
+        self, content: dict | None = None, metadata: dict | None = None
+    ):
         """Update the filters for the combobox"""
-        super().update_signals_from_filters()
+        super().update_signals_from_filters(content, metadata)
         # pylint: disable=protected-access
         if FilterIO._find_handler(self) is ComboBoxFilterHandler:
             if len(self._config_signals) > 0:
@@ -84,7 +93,70 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
                 self.insertItem(0, "Hinted Signals")
                 self.model().item(0).setEnabled(False)
 
-    @Slot(str)
+    @SafeProperty(bool)
+    def set_first_element_as_empty(self) -> bool:
+        """
+        Whether the first element in the combobox should be empty.
+        This is useful to allow the user to select a device from the list.
+        """
+        return self._set_first_element_as_empty
+
+    @set_first_element_as_empty.setter
+    def set_first_element_as_empty(self, value: bool) -> None:
+        """
+        Set whether the first element in the combobox should be empty.
+        This is useful to allow the user to select a device from the list.
+
+        Args:
+            value (bool): True if the first element should be empty, False otherwise.
+        """
+        self._set_first_element_as_empty = value
+        if self._set_first_element_as_empty:
+            self.insertItem(0, "")
+            self.setCurrentIndex(0)
+        else:
+            if self.count() > 0 and self.itemText(0) == "":
+                self.removeItem(0)
+
+    def set_to_obj_name(self, obj_name: str) -> bool:
+        """
+        Set the combobox to the object name of the signal.
+
+        Args:
+            obj_name (str): Object name of the signal.
+
+        Returns:
+            bool: True if the object name was found and set, False otherwise.
+        """
+        for i in range(self.count()):
+            signal_data = self.itemData(i)
+            if signal_data and signal_data.get("obj_name") == obj_name:
+                self.setCurrentIndex(i)
+                return True
+        return False
+
+    def set_to_first_enabled(self) -> bool:
+        """
+        Set the combobox to the first enabled item.
+
+        Returns:
+            bool: True if an enabled item was found and set, False otherwise.
+        """
+        for i in range(self.count()):
+            if self.model().item(i).isEnabled():
+                self.setCurrentIndex(i)
+                return True
+        return False
+
+    @SafeSlot()
+    def reset_selection(self):
+        """Reset the selection of the combobox."""
+        self.clear()
+        self.setItemText(0, "Select a device")
+        self.update_signals_from_filters()
+        self.device_signal_changed.emit("")
+
+    @SafeSlot(str)
     def on_text_changed(self, text: str):
         """Slot for text changed. If a device is selected and the signal is changed and valid it emits a signal.
         For a positioner, the readback value has to be renamed to the device name.
@@ -96,11 +168,11 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
             return
         if self.validate_signal(text) is False:
             return
-        if text == "readback" and isinstance(self.get_device_object(self.device), Positioner):
-            device_signal = self.device
-        else:
-            device_signal = f"{self.device}_{text}"
-        self.device_signal_changed.emit(device_signal)
+        self.device_signal_changed.emit(text)
+
+    @property
+    def selected_signal_comp_name(self) -> str:
+        return dict(self.signals).get(self.currentText(), {}).get("component_name", "")
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -89,6 +89,7 @@ class ScanControl(BECWidget, QWidget):
         self.config.allowed_scans = allowed_scans
 
         self._scan_metadata: dict | None = None
+        self._metadata_form = ScanMetadata(parent=self)
 
         # Create and set main layout
         self._init_UI()
@@ -165,12 +166,11 @@ class ScanControl(BECWidget, QWidget):
         self.layout.addStretch()
 
     def _add_metadata_form(self):
-        self._metadata_form = ScanMetadata(parent=self)
         self.layout.addWidget(self._metadata_form)
         self._metadata_form.update_with_new_scan(self.comboBox_scan_selection.currentText())
         self.scan_selected.connect(self._metadata_form.update_with_new_scan)
-        self._metadata_form.metadata_updated.connect(self.update_scan_metadata)
-        self._metadata_form.metadata_cleared.connect(self.update_scan_metadata)
+        self._metadata_form.form_data_updated.connect(self.update_scan_metadata)
+        self._metadata_form.form_data_cleared.connect(self.update_scan_metadata)
         self._metadata_form.validate_form()
 
     def populate_scans(self):
@@ -203,35 +203,40 @@ class ScanControl(BECWidget, QWidget):
         """
         Requests the last executed scan parameters from BEC and restores them to the scan control widget.
         """
-        enabled = self.toggle.checked
-        current_scan = self.comboBox_scan_selection.currentText()
-        if enabled:
-            history = self.client.connector.lrange(MessageEndpoints.scan_queue_history(), 0, -1)
+        self.last_scan_found = False
+        if not self.toggle.checked:
+            return
 
-            for scan in history:
-                scan_name = scan.content["info"]["request_blocks"][-1]["msg"].content["scan_type"]
-                if scan_name == current_scan:
-                    args_dict = scan.content["info"]["request_blocks"][-1]["msg"].content[
-                        "parameter"
-                    ]["args"]
-                    args_list = []
-                    for key, value in args_dict.items():
-                        args_list.append(key)
-                        args_list.extend(value)
-                    if len(args_list) > 1 and self.arg_box is not None:
-                        self.arg_box.set_parameters(args_list)
-                    kwargs = scan.content["info"]["request_blocks"][-1]["msg"].content["parameter"][
-                        "kwargs"
-                    ]
-                    if kwargs and self.kwarg_boxes:
-                        for box in self.kwarg_boxes:
-                            box.set_parameters(kwargs)
-                    self.last_scan_found = True
-                    break
-                else:
-                    self.last_scan_found = False
-        else:
-            self.last_scan_found = False
+        current_scan = self.comboBox_scan_selection.currentText()
+        history = (
+            self.client.connector.xread(
+                MessageEndpoints.scan_history(), from_start=True, user_id=self.object_name
+            )
+            or []
+        )
+
+        for scan in reversed(history):
+            scan_data = scan.get("data")
+            if not scan_data:
+                continue
+
+            if scan_data.scan_name != current_scan:
+                continue
+
+            ri = getattr(scan_data, "request_inputs", {}) or {}
+            args_list = ri.get("arg_bundle", [])
+            if args_list and self.arg_box:
+                self.arg_box.set_parameters(args_list)
+
+            inputs = ri.get("inputs", {})
+            kwargs = ri.get("kwargs", {})
+            merged = {**inputs, **kwargs}
+            if merged and self.kwarg_boxes:
+                for box in self.kwarg_boxes:
+                    box.set_parameters(merged)
+
+            self.last_scan_found = True
+            break
 
     @SafeProperty(str)
     def current_scan(self):

bec_widgets/widgets/editors/console/console.py

@@ -1,870 +0,0 @@
-"""
-BECConsole is a Qt widget that runs a Bash shell.
-
-BECConsole VT100 emulation is powered by Pyte,
-(https://github.com/selectel/pyte).
-"""
-
-import collections
-import fcntl
-import html
-import os
-import pty
-import re
-import signal
-import sys
-import time
-
-import pyte
-from pygments.token import Token
-from pyte.screens import History
-from qtpy import QtCore, QtGui, QtWidgets
-from qtpy.QtCore import Property as pyqtProperty
-from qtpy.QtCore import QSize, QSocketNotifier, Qt, QTimer
-from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtGui import QClipboard, QColor, QPalette, QTextCursor
-from qtpy.QtWidgets import QApplication, QHBoxLayout, QScrollBar, QSizePolicy
-
-from bec_widgets.utils.error_popups import SafeSlot as Slot
-
-ansi_colors = {
-    "black": "#000000",
-    "red": "#CD0000",
-    "green": "#00CD00",
-    "brown": "#996633",  # Brown, replacing the yellow
-    "blue": "#0000EE",
-    "magenta": "#CD00CD",
-    "cyan": "#00CDCD",
-    "white": "#E5E5E5",
-    "brightblack": "#7F7F7F",
-    "brightred": "#FF0000",
-    "brightgreen": "#00FF00",
-    "brightyellow": "#FFFF00",
-    "brightblue": "#5C5CFF",
-    "brightmagenta": "#FF00FF",
-    "brightcyan": "#00FFFF",
-    "brightwhite": "#FFFFFF",
-}
-
-control_keys_mapping = {
-    QtCore.Qt.Key_A: b"\x01",  # Ctrl-A
-    QtCore.Qt.Key_B: b"\x02",  # Ctrl-B
-    QtCore.Qt.Key_C: b"\x03",  # Ctrl-C
-    QtCore.Qt.Key_D: b"\x04",  # Ctrl-D
-    QtCore.Qt.Key_E: b"\x05",  # Ctrl-E
-    QtCore.Qt.Key_F: b"\x06",  # Ctrl-F
-    QtCore.Qt.Key_G: b"\x07",  # Ctrl-G (Bell)
-    QtCore.Qt.Key_H: b"\x08",  # Ctrl-H (Backspace)
-    QtCore.Qt.Key_I: b"\x09",  # Ctrl-I (Tab)
-    QtCore.Qt.Key_J: b"\x0a",  # Ctrl-J (Line Feed)
-    QtCore.Qt.Key_K: b"\x0b",  # Ctrl-K (Vertical Tab)
-    QtCore.Qt.Key_L: b"\x0c",  # Ctrl-L (Form Feed)
-    QtCore.Qt.Key_M: b"\x0d",  # Ctrl-M (Carriage Return)
-    QtCore.Qt.Key_N: b"\x0e",  # Ctrl-N
-    QtCore.Qt.Key_O: b"\x0f",  # Ctrl-O
-    QtCore.Qt.Key_P: b"\x10",  # Ctrl-P
-    QtCore.Qt.Key_Q: b"\x11",  # Ctrl-Q
-    QtCore.Qt.Key_R: b"\x12",  # Ctrl-R
-    QtCore.Qt.Key_S: b"\x13",  # Ctrl-S
-    QtCore.Qt.Key_T: b"\x14",  # Ctrl-T
-    QtCore.Qt.Key_U: b"\x15",  # Ctrl-U
-    QtCore.Qt.Key_V: b"\x16",  # Ctrl-V
-    QtCore.Qt.Key_W: b"\x17",  # Ctrl-W
-    QtCore.Qt.Key_X: b"\x18",  # Ctrl-X
-    QtCore.Qt.Key_Y: b"\x19",  # Ctrl-Y
-    QtCore.Qt.Key_Z: b"\x1a",  # Ctrl-Z
-    QtCore.Qt.Key_Escape: b"\x1b",  # Ctrl-Escape
-    QtCore.Qt.Key_Backslash: b"\x1c",  # Ctrl-\
-    QtCore.Qt.Key_Underscore: b"\x1f",  # Ctrl-_
-}
-
-normal_keys_mapping = {
-    QtCore.Qt.Key_Return: b"\n",
-    QtCore.Qt.Key_Space: b" ",
-    QtCore.Qt.Key_Enter: b"\n",
-    QtCore.Qt.Key_Tab: b"\t",
-    QtCore.Qt.Key_Backspace: b"\x08",
-    QtCore.Qt.Key_Home: b"\x47",
-    QtCore.Qt.Key_End: b"\x4f",
-    QtCore.Qt.Key_Left: b"\x02",
-    QtCore.Qt.Key_Up: b"\x10",
-    QtCore.Qt.Key_Right: b"\x06",
-    QtCore.Qt.Key_Down: b"\x0e",
-    QtCore.Qt.Key_PageUp: b"\x49",
-    QtCore.Qt.Key_PageDown: b"\x51",
-    QtCore.Qt.Key_F1: b"\x1b\x31",
-    QtCore.Qt.Key_F2: b"\x1b\x32",
-    QtCore.Qt.Key_F3: b"\x1b\x33",
-    QtCore.Qt.Key_F4: b"\x1b\x34",
-    QtCore.Qt.Key_F5: b"\x1b\x35",
-    QtCore.Qt.Key_F6: b"\x1b\x36",
-    QtCore.Qt.Key_F7: b"\x1b\x37",
-    QtCore.Qt.Key_F8: b"\x1b\x38",
-    QtCore.Qt.Key_F9: b"\x1b\x39",
-    QtCore.Qt.Key_F10: b"\x1b\x30",
-    QtCore.Qt.Key_F11: b"\x45",
-    QtCore.Qt.Key_F12: b"\x46",
-}
-
-
-def QtKeyToAscii(event):
-    """
-    Convert the Qt key event to the corresponding ASCII sequence for
-    the terminal. This works fine for standard alphanumerical characters, but
-    most other characters require terminal specific control sequences.
-
-    The conversion below works for TERM="linux" terminals.
-    """
-    if sys.platform == "darwin":
-        # special case for MacOS
-        # /!\ Qt maps ControlModifier to CMD
-        # CMD-C, CMD-V for copy/paste
-        # CTRL-C and other modifiers -> key mapping
-        if event.modifiers() == QtCore.Qt.MetaModifier:
-            if event.key() == Qt.Key_Backspace:
-                return control_keys_mapping.get(Qt.Key_W)
-            return control_keys_mapping.get(event.key())
-        elif event.modifiers() == QtCore.Qt.ControlModifier:
-            if event.key() == Qt.Key_C:
-                # copy
-                return "copy"
-            elif event.key() == Qt.Key_V:
-                # paste
-                return "paste"
-            return None
-        else:
-            return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
-    if event.modifiers() == QtCore.Qt.ControlModifier:
-        return control_keys_mapping.get(event.key())
-    else:
-        return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
-
-
-class Screen(pyte.HistoryScreen):
-    def __init__(self, stdin_fd, cols, rows, historyLength):
-        super().__init__(cols, rows, historyLength, ratio=1 / rows)
-        self._fd = stdin_fd
-
-    def write_process_input(self, data):
-        """Response to CPR request (for example),
-        this can be for other requests
-        """
-        try:
-            os.write(self._fd, data.encode("utf-8"))
-        except (IOError, OSError):
-            pass
-
-    def resize(self, lines, columns):
-        lines = lines or self.lines
-        columns = columns or self.columns
-
-        if lines == self.lines and columns == self.columns:
-            return  # No changes.
-
-        self.dirty.clear()
-        self.dirty.update(range(lines))
-
-        self.save_cursor()
-        if lines < self.lines:
-            if lines <= self.cursor.y:
-                nlines_to_move_up = self.lines - lines
-                for i in range(nlines_to_move_up):
-                    line = self.buffer[i]  # .pop(0)
-                    self.history.top.append(line)
-                self.cursor_position(0, 0)
-                self.delete_lines(nlines_to_move_up)
-                self.restore_cursor()
-                self.cursor.y -= nlines_to_move_up
-        else:
-            self.restore_cursor()
-
-        self.lines, self.columns = lines, columns
-        self.history = History(
-            self.history.top,
-            self.history.bottom,
-            1 / self.lines,
-            self.history.size,
-            self.history.position,
-        )
-        self.set_margins()
-
-
-class Backend(QtCore.QObject):
-    """
-    Poll Bash.
-
-    This class will run as a qsocketnotifier (started in ``_TerminalWidget``) and poll the
-    file descriptor of the Bash terminal.
-    """
-
-    # Signals to communicate with ``_TerminalWidget``.
-    dataReady = pyqtSignal(object)
-    processExited = pyqtSignal()
-
-    def __init__(self, fd, cols, rows):
-        super().__init__()
-
-        # File descriptor that connects to Bash process.
-        self.fd = fd
-
-        # Setup Pyte (hard coded display size for now).
-        self.screen = Screen(self.fd, cols, rows, 10000)
-        self.stream = pyte.ByteStream()
-        self.stream.attach(self.screen)
-
-        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
-        self.notifier.activated.connect(self._fd_readable)
-
-    def _fd_readable(self):
-        """
-        Poll the Bash output, run it through Pyte, and notify
-        """
-        # Read the shell output until the file descriptor is closed.
-        try:
-            out = os.read(self.fd, 2**16)
-        except OSError:
-            self.processExited.emit()
-            self.notifier.setEnabled(False)
-            return
-
-        # Feed output into Pyte's state machine and send the new screen
-        # output to the GUI
-        self.stream.feed(out)
-        self.dataReady.emit(self.screen)
-
-
-class BECConsole(QtWidgets.QWidget):
-    """Container widget for the terminal text area"""
-
-    PLUGIN = True
-    ICON_NAME = "terminal"
-
-    prompt = pyqtSignal(bool)
-
-    def __init__(self, parent=None, cols=132):
-        super().__init__(parent)
-
-        self.term = _TerminalWidget(self, cols, rows=43)
-        self.term.prompt.connect(self.prompt)  # forward signal from term to this widget
-
-        self.scroll_bar = QScrollBar(Qt.Vertical, self)
-        # self.scroll_bar.hide()
-        layout = QHBoxLayout(self)
-        layout.addWidget(self.term)
-        layout.addWidget(self.scroll_bar)
-        layout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
-        layout.setContentsMargins(0, 0, 0, 0)
-        self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)
-
-        pal = QPalette()
-        self.set_bgcolor(pal.window().color())
-        self.set_fgcolor(pal.windowText().color())
-        self.term.set_scroll_bar(self.scroll_bar)
-        self.set_cmd("bec --nogui")
-
-        self._check_designer_timer = QTimer()
-        self._check_designer_timer.timeout.connect(self.check_designer)
-        self._check_designer_timer.start(1000)
-
-    def minimumSizeHint(self):
-        size = self.term.sizeHint()
-        size.setWidth(size.width() + self.scroll_bar.width())
-        return size
-
-    def sizeHint(self):
-        return self.minimumSizeHint()
-
-    def check_designer(self, calls={"n": 0}):
-        calls["n"] += 1
-        if self.term.fd is not None:
-            # already started
-            self._check_designer_timer.stop()
-        elif self.window().windowTitle().endswith("[Preview]"):
-            # assuming Designer preview -> start
-            self._check_designer_timer.stop()
-            self.term.start()
-        elif calls["n"] >= 3:
-            # assuming not in Designer -> stop checking
-            self._check_designer_timer.stop()
-
-    def get_rows(self):
-        return self.term.rows
-
-    def set_rows(self, rows):
-        self.term.rows = rows
-        self.adjustSize()
-        self.updateGeometry()
-
-    def get_cols(self):
-        return self.term.cols
-
-    def set_cols(self, cols):
-        self.term.cols = cols
-        self.adjustSize()
-        self.updateGeometry()
-
-    def get_bgcolor(self):
-        return QColor.fromString(self.term.bg_color)
-
-    def set_bgcolor(self, color):
-        self.term.bg_color = color.name(QColor.HexRgb)
-
-    def get_fgcolor(self):
-        return QColor.fromString(self.term.fg_color)
-
-    def set_fgcolor(self, color):
-        self.term.fg_color = color.name(QColor.HexRgb)
-
-    def get_cmd(self):
-        return self.term._cmd
-
-    def set_cmd(self, cmd):
-        self.term._cmd = cmd
-        if self.term.fd is None:
-            # not started yet
-            self.term.clear()
-            self.term.appendHtml(f"<h2>BEC Console - {repr(cmd)}</h2>")
-
-    def start(self, deactivate_ctrl_d=True):
-        self.term.start(deactivate_ctrl_d=deactivate_ctrl_d)
-
-    def push(self, text, hit_return=False):
-        """Push some text to the terminal"""
-        return self.term.push(text, hit_return=hit_return)
-
-    def execute_command(self, command):
-        self.push(command, hit_return=True)
-
-    def set_prompt_tokens(self, *tokens):
-        """Prepare regexp to identify prompt, based on tokens
-
-        Tokens are returned from get_ipython().prompts.in_prompt_tokens()
-        """
-        regex_parts = []
-        for token_type, token_value in tokens:
-            if token_type == Token.PromptNum:  # Handle dynamic prompt number
-                regex_parts.append(r"[\d\?]+")  # Match one or more digits or '?'
-            else:
-                # Escape other prompt parts (e.g., "In [", "]: ")
-                if not token_value:
-                    regex_parts.append(".+?")  # arbitrary string
-                else:
-                    regex_parts.append(re.escape(token_value))
-
-        # Combine into a single regex
-        prompt_pattern = "".join(regex_parts)
-        self.term._prompt_re = re.compile(prompt_pattern + r"\s*$")
-
-    def terminate(self, timeout=10):
-        self.term.stop(timeout=timeout)
-
-    def send_ctrl_c(self, timeout=None):
-        self.term.send_ctrl_c(timeout)
-
-    cols = pyqtProperty(int, get_cols, set_cols)
-    rows = pyqtProperty(int, get_rows, set_rows)
-    bgcolor = pyqtProperty(QColor, get_bgcolor, set_bgcolor)
-    fgcolor = pyqtProperty(QColor, get_fgcolor, set_fgcolor)
-    cmd = pyqtProperty(str, get_cmd, set_cmd)
-
-
-class _TerminalWidget(QtWidgets.QPlainTextEdit):
-    """
-    Start ``Backend`` process and render Pyte output as text.
-    """
-
-    prompt = pyqtSignal(bool)
-
-    def __init__(self, parent, cols=125, rows=50, **kwargs):
-        # regexp to match prompt
-        self._prompt_re = None
-        # last prompt
-        self._prompt_str = None
-        # process pid
-        self.pid = None
-        # file descriptor to communicate with the subprocess
-        self.fd = None
-        self.backend = None
-        # command to execute
-        self._cmd = ""
-        # should ctrl-d be deactivated ? (prevent Python exit)
-        self._deactivate_ctrl_d = False
-
-        # Default colors
-        pal = QPalette()
-        self._fg_color = pal.text().color().name()
-        self._bg_color = pal.base().color().name()
-
-        # Specify the terminal size in terms of lines and columns.
-        self._rows = rows
-        self._cols = cols
-        self.output = collections.deque()
-
-        super().__init__(parent)
-
-        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Expanding)
-
-        # Disable default scrollbars (we use our own, to be set via .set_scroll_bar())
-        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-        self.scroll_bar = None
-
-        # Use Monospace fonts and disable line wrapping.
-        self.setFont(QtGui.QFont("Courier", 9))
-        self.setFont(QtGui.QFont("Monospace"))
-        self.setLineWrapMode(QtWidgets.QPlainTextEdit.NoWrap)
-        fmt = QtGui.QFontMetrics(self.font())
-        char_width = fmt.width("w")
-        self.setCursorWidth(char_width)
-
-        self.adjustSize()
-        self.updateGeometry()
-        self.update_stylesheet()
-
-    @property
-    def bg_color(self):
-        return self._bg_color
-
-    @bg_color.setter
-    def bg_color(self, hexcolor):
-        self._bg_color = hexcolor
-        self.update_stylesheet()
-
-    @property
-    def fg_color(self):
-        return self._fg_color
-
-    @fg_color.setter
-    def fg_color(self, hexcolor):
-        self._fg_color = hexcolor
-        self.update_stylesheet()
-
-    def update_stylesheet(self):
-        self.setStyleSheet(
-            f"QPlainTextEdit {{ border: 0; color: {self._fg_color}; background-color: {self._bg_color}; }} "
-        )
-
-    @property
-    def rows(self):
-        return self._rows
-
-    @rows.setter
-    def rows(self, rows: int):
-        if self.backend is None:
-            # not initialized yet, ok to change
-            self._rows = rows
-            self.adjustSize()
-            self.updateGeometry()
-        else:
-            raise RuntimeError("Cannot change rows after console is started.")
-
-    @property
-    def cols(self):
-        return self._cols
-
-    @cols.setter
-    def cols(self, cols: int):
-        if self.fd is None:
-            # not initialized yet, ok to change
-            self._cols = cols
-            self.adjustSize()
-            self.updateGeometry()
-        else:
-            raise RuntimeError("Cannot change cols after console is started.")
-
-    def start(self, deactivate_ctrl_d: bool = False):
-        self._deactivate_ctrl_d = deactivate_ctrl_d
-
-        self.update_term_size()
-
-        # Start the Bash process
-        self.pid, self.fd = self.fork_shell()
-
-        if self.fd:
-            # Create the ``Backend`` object
-            self.backend = Backend(self.fd, self.cols, self.rows)
-            self.backend.dataReady.connect(self.data_ready)
-            self.backend.processExited.connect(self.process_exited)
-        else:
-            self.process_exited()
-
-    def process_exited(self):
-        self.fd = None
-        self.clear()
-        self.appendHtml(f"<br><h2>{repr(self._cmd)} - Process exited.</h2>")
-        self.setReadOnly(True)
-
-    def send_ctrl_c(self, wait_prompt=True, timeout=None):
-        """Send CTRL-C to the process
-
-        If wait_prompt=True (default), wait for a new prompt after CTRL-C
-        If no prompt is displayed after 'timeout' seconds, TimeoutError is raised
-        """
-        os.kill(self.pid, signal.SIGINT)
-        if wait_prompt:
-            timeout_error = False
-            if timeout:
-
-                def set_timeout_error():
-                    nonlocal timeout_error
-                    timeout_error = True
-
-                timeout_timer = QTimer()
-                timeout_timer.singleShot(timeout * 1000, set_timeout_error)
-            while self._prompt_str is None:
-                QApplication.instance().process_events()
-                if timeout_error:
-                    raise TimeoutError(
-                        f"CTRL-C: could not get back to prompt after {timeout} seconds."
-                    )
-
-    def _is_running(self):
-        if os.waitpid(self.pid, os.WNOHANG) == (0, 0):
-            return True
-        return False
-
-    def stop(self, kill=True, timeout=None):
-        """Stop the running process
-
-        SIGTERM is the default signal for terminating processes.
-
-        If kill=True (default), SIGKILL will be sent if the process does not exit after timeout
-        """
-        # try to exit gracefully
-        os.kill(self.pid, signal.SIGTERM)
-
-        # wait until process is truly dead
-        t0 = time.perf_counter()
-        while self._is_running():
-            time.sleep(1)
-            if timeout is not None and time.perf_counter() - t0 > timeout:
-                # still alive after 'timeout' seconds
-                if kill:
-                    # send SIGKILL and make a last check in loop
-                    os.kill(self.pid, signal.SIGKILL)
-                    kill = False
-                else:
-                    # still running after timeout...
-                    raise TimeoutError(
-                        f"Could not terminate process with pid: {self.pid} within timeout"
-                    )
-        self.process_exited()
-
-    def data_ready(self, screen):
-        """Handle new screen: redraw, set scroll bar max and slider, move cursor to its position
-
-        This method is triggered via a signal from ``Backend``.
-        """
-        self.redraw_screen()
-        self.adjust_scroll_bar()
-        self.move_cursor()
-
-    def minimumSizeHint(self):
-        """Return minimum size for current cols and rows"""
-        fmt = QtGui.QFontMetrics(self.font())
-        char_width = fmt.width("w")
-        char_height = fmt.height()
-        width = char_width * self.cols
-        height = char_height * self.rows
-        return QSize(width, height)
-
-    def sizeHint(self):
-        return self.minimumSizeHint()
-
-    def set_scroll_bar(self, scroll_bar):
-        self.scroll_bar = scroll_bar
-        self.scroll_bar.setMinimum(0)
-        self.scroll_bar.valueChanged.connect(self.scroll_value_change)
-
-    def scroll_value_change(self, value, old={"value": -1}):
-        if self.backend is None:
-            return
-        if old["value"] == -1:
-            old["value"] = self.scroll_bar.maximum()
-        if value <= old["value"]:
-            # scroll up
-            # value is number of lines from the start
-            nlines = old["value"] - value
-            # history ratio gives prev_page == 1 line
-            for i in range(nlines):
-                self.backend.screen.prev_page()
-        else:
-            # scroll down
-            nlines = value - old["value"]
-            for i in range(nlines):
-                self.backend.screen.next_page()
-        old["value"] = value
-        self.redraw_screen()
-
-    def adjust_scroll_bar(self):
-        sb = self.scroll_bar
-        sb.valueChanged.disconnect(self.scroll_value_change)
-        tmp = len(self.backend.screen.history.top) + len(self.backend.screen.history.bottom)
-        sb.setMaximum(tmp if tmp > 0 else 0)
-        sb.setSliderPosition(tmp if tmp > 0 else 0)
-        # if tmp > 0:
-        #    # show scrollbar, but delayed - prevent recursion with widget size change
-        #    QTimer.singleShot(0, scrollbar.show)
-        # else:
-        #    QTimer.singleShot(0, scrollbar.hide)
-        sb.valueChanged.connect(self.scroll_value_change)
-
-    def write(self, data):
-        try:
-            os.write(self.fd, data)
-        except (IOError, OSError):
-            self.process_exited()
-
-    @Slot(object)
-    def keyPressEvent(self, event):
-        """
-        Redirect all keystrokes to the terminal process.
-        """
-        if self.fd is None:
-            # not started
-            return
-        # Convert the Qt key to the correct ASCII code.
-        if (
-            self._deactivate_ctrl_d
-            and event.modifiers() == QtCore.Qt.ControlModifier
-            and event.key() == QtCore.Qt.Key_D
-        ):
-            return None
-
-        code = QtKeyToAscii(event)
-        if code == "copy":
-            # MacOS only: CMD-C handling
-            self.copy()
-        elif code == "paste":
-            # MacOS only: CMD-V handling
-            self._push_clipboard()
-        elif code is not None:
-            self.write(code)
-
-    def push(self, text, hit_return=False):
-        """
-        Write 'text' to terminal
-        """
-        self.write(text.encode("utf-8"))
-        if hit_return:
-            self.write(b"\n")
-
-    def contextMenuEvent(self, event):
-        if self.fd is None:
-            return
-        menu = self.createStandardContextMenu()
-        for action in menu.actions():
-            # remove all actions except copy and paste
-            if "opy" in action.text():
-                # redefine text without shortcut
-                # since it probably clashes with control codes (like CTRL-C etc)
-                action.setText("Copy")
-                continue
-            if "aste" in action.text():
-                # redefine text without shortcut
-                action.setText("Paste")
-                # paste -> have to insert with self.push
-                action.triggered.connect(self._push_clipboard)
-                continue
-            menu.removeAction(action)
-        menu.exec_(event.globalPos())
-
-    def _push_clipboard(self):
-        clipboard = QApplication.instance().clipboard()
-        self.push(clipboard.text())
-
-    def move_cursor(self):
-        textCursor = self.textCursor()
-        textCursor.setPosition(0)
-        textCursor.movePosition(
-            QTextCursor.Down, QTextCursor.MoveAnchor, self.backend.screen.cursor.y
-        )
-        textCursor.movePosition(
-            QTextCursor.Right, QTextCursor.MoveAnchor, self.backend.screen.cursor.x
-        )
-        self.setTextCursor(textCursor)
-
-    def mouseReleaseEvent(self, event):
-        if self.fd is None:
-            return
-        if event.button() == Qt.MiddleButton:
-            # push primary selection buffer ("mouse clipboard") to terminal
-            clipboard = QApplication.instance().clipboard()
-            if clipboard.supportsSelection():
-                self.push(clipboard.text(QClipboard.Selection))
-            return None
-        elif event.button() == Qt.LeftButton:
-            # left button click
-            textCursor = self.textCursor()
-            if textCursor.selectedText():
-                # mouse was used to select text -> nothing to do
-                pass
-            else:
-                # a simple 'click', move scrollbar to end
-                self.scroll_bar.setSliderPosition(self.scroll_bar.maximum())
-                self.move_cursor()
-                return None
-        return super().mouseReleaseEvent(event)
-
-    def redraw_screen(self):
-        """
-        Render the screen as formatted text into the widget.
-        """
-        screen = self.backend.screen
-
-        # Clear the widget
-        if screen.dirty:
-            self.clear()
-            while len(self.output) < (max(screen.dirty) + 1):
-                self.output.append("")
-            while len(self.output) > (max(screen.dirty) + 1):
-                self.output.pop()
-
-            # Prepare the HTML output
-            for line_no in screen.dirty:
-                line = text = ""
-                style = old_style = ""
-                old_idx = 0
-                for idx, ch in screen.buffer[line_no].items():
-                    text += " " * (idx - old_idx - 1)
-                    old_idx = idx
-                    style = f"{'background-color:%s;' % ansi_colors.get(ch.bg, ansi_colors['black']) if ch.bg!='default' else ''}{'color:%s;' % ansi_colors.get(ch.fg, ansi_colors['white']) if ch.fg!='default' else ''}{'font-weight:bold;' if ch.bold else ''}{'font-style:italic;' if ch.italics else ''}"
-                    if style != old_style:
-                        if old_style:
-                            line += f"<span style={repr(old_style)}>{html.escape(text, quote=True)}</span>"
-                        else:
-                            line += html.escape(text, quote=True)
-                        text = ""
-                        old_style = style
-                    text += ch.data
-                if style:
-                    line += f"<span style={repr(style)}>{html.escape(text, quote=True)}</span>"
-                else:
-                    line += html.escape(text, quote=True)
-                # do a check at the cursor position:
-                # it is possible x pos > output line length,
-                # for example if last escape codes are "cursor forward" past end of text,
-                # like IPython does for "..." prompt (in a block, like "for" loop or "while" for example)
-                # In this case, cursor is at 12 but last text output is at 8 -> insert spaces
-                if line_no == screen.cursor.y:
-                    llen = len(screen.buffer[line_no])
-                    if llen < screen.cursor.x:
-                        line += " " * (screen.cursor.x - llen)
-                self.output[line_no] = line
-            # fill the text area with HTML contents in one go
-            self.appendHtml(f"<pre>{chr(10).join(self.output)}</pre>")
-
-            if self._prompt_re is not None:
-                text_buf = self.toPlainText()
-                prompt = self._prompt_re.search(text_buf)
-                if prompt is None:
-                    if self._prompt_str:
-                        self.prompt.emit(False)
-                    self._prompt_str = None
-                else:
-                    prompt_str = prompt.string.rstrip()
-                    if prompt_str != self._prompt_str:
-                        self._prompt_str = prompt_str
-                        self.prompt.emit(True)
-
-            # did updates, all clean
-            screen.dirty.clear()
-
-    def update_term_size(self):
-        fmt = QtGui.QFontMetrics(self.font())
-        char_width = fmt.width("w")
-        char_height = fmt.height()
-        self._cols = int(self.width() / char_width)
-        self._rows = int(self.height() / char_height)
-
-    def resizeEvent(self, event):
-        self.update_term_size()
-        if self.fd:
-            self.backend.screen.resize(self._rows, self._cols)
-            self.redraw_screen()
-            self.adjust_scroll_bar()
-            self.move_cursor()
-
-    def wheelEvent(self, event):
-        if not self.fd:
-            return
-        y = event.angleDelta().y()
-        if y > 0:
-            self.backend.screen.prev_page()
-        else:
-            self.backend.screen.next_page()
-        self.redraw_screen()
-
-    def fork_shell(self):
-        """
-        Fork the current process and execute bec in shell.
-        """
-        try:
-            pid, fd = pty.fork()
-        except (IOError, OSError):
-            return False
-        if pid == 0:
-            try:
-                ls = os.environ["LANG"].split(".")
-            except KeyError:
-                ls = []
-            if len(ls) < 2:
-                ls = ["en_US", "UTF-8"]
-            os.putenv("COLUMNS", str(self.cols))
-            os.putenv("LINES", str(self.rows))
-            os.putenv("TERM", "linux")
-            os.putenv("LANG", ls[0] + ".UTF-8")
-            if not self._cmd:
-                self._cmd = os.environ["SHELL"]
-            cmd = self._cmd
-            if isinstance(cmd, str):
-                cmd = cmd.split()
-            try:
-                os.execvp(cmd[0], cmd)
-            except (IOError, OSError):
-                pass
-            os._exit(0)
-        else:
-            # We are in the parent process.
-            # Set file control
-            fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK)
-            return pid, fd
-
-
-if __name__ == "__main__":
-    import os
-    import sys
-
-    from qtpy import QtGui, QtWidgets
-
-    # Create the Qt application and console.
-    app = QtWidgets.QApplication([])
-    mainwin = QtWidgets.QMainWindow()
-    title = "BECConsole"
-    mainwin.setWindowTitle(title)
-
-    console = BECConsole(mainwin)
-    mainwin.setCentralWidget(console)
-
-    def check_prompt(at_prompt):
-        if at_prompt:
-            print("NEW PROMPT")
-        else:
-            print("EXECUTING SOMETHING...")
-
-    console.set_prompt_tokens(
-        (Token.OutPromptNum, "•"),
-        (Token.Prompt, ""),  # will match arbitrary string,
-        (Token.Prompt, " ["),
-        (Token.PromptNum, "3"),
-        (Token.Prompt, "/"),
-        (Token.PromptNum, "1"),
-        (Token.Prompt, "] "),
-        (Token.Prompt, "❯❯"),
-    )
-    console.prompt.connect(check_prompt)
-    console.start()
-
-    # Show widget and launch Qt's event loop.
-    mainwin.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/editors/console/console.pyproject

@@ -1 +0,0 @@
-{'files': ['console.py']}

bec_widgets/widgets/editors/dict_backed_table.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 from typing import Any
 
+from qtpy import QtWidgets
 from qtpy.QtCore import QAbstractTableModel, QModelIndex, Qt, Signal  # type: ignore
+from qtpy.QtGui import QFontMetrics
 from qtpy.QtWidgets import (
     QApplication,
     QHBoxLayout,
@@ -13,7 +15,9 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
-from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
+
+_NOT_SET = object()
 
 
 class DictBackedTableModel(QAbstractTableModel):
@@ -25,6 +29,7 @@ class DictBackedTableModel(QAbstractTableModel):
             data (list[list[str]]): list of key-value pairs to initialise with"""
         super().__init__()
         self._data: list[list[str]] = data
+        self._default = _NOT_SET
         self._disallowed_keys: list[str] = []
 
     # pylint: disable=missing-function-docstring
@@ -45,8 +50,15 @@ class DictBackedTableModel(QAbstractTableModel):
 
     def data(self, index, role=Qt.ItemDataRole):
         if index.isValid():
-            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
-                return str(self._data[index.row()][index.column()])
+            if role in [
+                Qt.ItemDataRole.DisplayRole,
+                Qt.ItemDataRole.EditRole,
+                Qt.ItemDataRole.ToolTipRole,
+            ]:
+                try:
+                    return str(self._data[index.row()][index.column()])
+                except IndexError:
+                    return None
 
     def setData(self, index, value, role):
         if role == Qt.ItemDataRole.EditRole:
@@ -57,6 +69,12 @@ class DictBackedTableModel(QAbstractTableModel):
             return True
         return False
 
+    def replaceData(self, data: dict):
+        self.delete_rows(list(range(len(self._data))))
+        self.resetInternalData()
+        self._data = [[str(k), str(v)] for k, v in data.items()]
+        self.dataChanged.emit(self.index(0, 0), self.index(len(self._data), 1))
+
     def update_disallowed_keys(self, keys: list[str]):
         """Set the list of keys which may not be used.
 
@@ -66,7 +84,7 @@ class DictBackedTableModel(QAbstractTableModel):
         for i, item in enumerate(self._data):
             if item[0] in self._disallowed_keys:
                 self._data[i][0] = ""
-                self.dataChanged.emit(self.index(i, 0), self.index(i, 0))
+                self.dataChanged.emit(self.index(i, 0), self.index(i, 1))
 
     def _other_keys(self, row: int):
         return [r[0] for r in self._data[:row] + self._data[row + 1 :]]
@@ -95,45 +113,74 @@ class DictBackedTableModel(QAbstractTableModel):
     @SafeSlot()
     def add_row(self):
         self.insertRow(self.rowCount())
+        self.dataChanged.emit(self.index(self.rowCount(), 0), self.index(self.rowCount(), 1), 0)
 
     @SafeSlot(list)
     def delete_rows(self, rows: list[int]):
         # delete from the end so indices stay correct
         for row in sorted(rows, reverse=True):
+            self.dataChanged.emit(self.index(row, 0), self.index(row, 1), 0)
             self.removeRows(row, 1, QModelIndex())
 
+    def set_default(self, value: dict | None):
+        self._default = value
+
     def dump_dict(self):
-        if self._data == [[]]:
+        if self._data in [[], [[]], [["", ""]]]:
+            if self._default is not _NOT_SET:
+                return self._default
             return {}
         return dict(self._data)
 
+    def length(self):
+        return len(self._data)
+
 
 class DictBackedTable(QWidget):
     delete_rows = Signal(list)
-    data_updated = Signal()
+    data_changed = Signal(dict)
 
-    def __init__(self, initial_data: list[list[str]]):
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        initial_data: list[list[str]] = [],
+        autoscale_to_data: bool = True,
+    ):
         """Widget which uses a DictBackedTableModel to display an editable table
         which can be extracted as a dict.
 
         Args:
             initial_data (list[list[str]]): list of key-value pairs to initialise with
         """
-        super().__init__()
+        super().__init__(parent)
 
         self._layout = QHBoxLayout()
         self.setLayout(self._layout)
+        self._layout.setContentsMargins(0, 0, 0, 0)
+
         self._table_model = DictBackedTableModel(initial_data)
         self._table_view = QTreeView()
+
         self._table_view.setModel(self._table_model)
+        self._min_lines = 3
+        self.set_height_in_lines(len(initial_data))
         self._table_view.setSizePolicy(
-            QSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
+            QSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
         )
         self._table_view.setAlternatingRowColors(True)
+        self._table_view.setUniformRowHeights(True)
+        self._table_view.setWordWrap(False)
+        self._table_view.header().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        self._table_view.header().setSectionResizeMode(5, QtWidgets.QHeaderView.Stretch)
+        self.autoscale = autoscale_to_data
+        if self.autoscale:
+            self.data_changed.connect(self.scale_to_data)
         self._layout.addWidget(self._table_view)
 
+        self._button_holder = QWidget()
         self._buttons = QVBoxLayout()
-        self._layout.addLayout(self._buttons)
+        self._button_holder.setLayout(self._buttons)
+        self._layout.addWidget(self._button_holder)
         self._add_button = QPushButton("+")
         self._add_button.setToolTip("add a new row")
         self._remove_button = QPushButton("-")
@@ -143,11 +190,21 @@ class DictBackedTable(QWidget):
         self._add_button.clicked.connect(self._table_model.add_row)
         self._remove_button.clicked.connect(self.delete_selected_rows)
         self.delete_rows.connect(self._table_model.delete_rows)
-        self._table_model.dataChanged.connect(self._emit_data_updated)
 
-    def _emit_data_updated(self, *args, **kwargs):
-        """Just to swallow the args"""
-        self.data_updated.emit()
+        self._table_model.dataChanged.connect(lambda *_: self.data_changed.emit(self.dump_dict()))
+
+    def set_default(self, value: dict | None):
+        self._table_model.set_default(value)
+
+    def set_button_visibility(self, value: bool):
+        self._button_holder.setVisible(value)
+
+    @SafeSlot()
+    def clear(self):
+        self._table_model.replaceData({})
+
+    def replace_data(self, data: dict | None):
+        self._table_model.replaceData(data or {})
 
     def delete_selected_rows(self):
         """Delete rows which are part of the selection model"""
@@ -167,6 +224,29 @@ class DictBackedTable(QWidget):
             keys (list[str]): list of keys which are forbidden."""
         self._table_model.update_disallowed_keys(keys)
 
+    def set_height_in_lines(self, lines: int):
+        self._table_view.setMaximumHeight(
+            int(QFontMetrics(self._table_view.font()).height() * max(lines + 2, self._min_lines))
+        )
+
+    @SafeSlot()
+    @SafeSlot(dict)
+    def scale_to_data(self, *_):
+        self.set_height_in_lines(self._table_model.length())
+
+    @SafeProperty(bool)
+    def autoscale(self):  # type: ignore
+        return self._autoscale
+
+    @autoscale.setter
+    def autoscale(self, autoscale: bool):
+        self._autoscale = autoscale
+        if self._autoscale:
+            self.scale_to_data()
+            self.data_changed.connect(self.scale_to_data)
+        else:
+            self.data_changed.disconnect(self.scale_to_data)
+
 
 if __name__ == "__main__":  # pragma: no cover
     from bec_widgets.utils.colors import set_theme
@@ -174,6 +254,6 @@ if __name__ == "__main__":  # pragma: no cover
     app = QApplication([])
     set_theme("dark")
 
-    window = DictBackedTable([["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
+    window = DictBackedTable(None, [["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
     window.show()
     app.exec()

bec_widgets/widgets/editors/monaco/monaco_widget.py

@@ -0,0 +1,188 @@
+from typing import Literal
+
+import qtmonaco
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.colors import get_theme_name
+
+
+class MonacoWidget(BECWidget, QWidget):
+    """
+    A simple Monaco editor widget
+    """
+
+    PLUGIN = True
+    ICON_NAME = "code"
+    USER_ACCESS = [
+        "set_text",
+        "get_text",
+        "set_language",
+        "get_language",
+        "set_theme",
+        "get_theme",
+        "set_readonly",
+        "set_cursor",
+        "current_cursor",
+        "set_minimap_enabled",
+    ]
+
+    def __init__(self, parent=None, config=None, client=None, gui_id=None, **kwargs):
+        super().__init__(
+            parent=parent, client=client, gui_id=gui_id, config=config, theme_update=True, **kwargs
+        )
+        layout = QVBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.editor = qtmonaco.Monaco(self)
+        layout.addWidget(self.editor)
+        self.setLayout(layout)
+        self.editor.initialized.connect(self.apply_theme)
+
+    def apply_theme(self, theme: str | None = None) -> None:
+        """
+        Apply the current theme to the Monaco editor.
+
+        Args:
+            theme (str, optional): The theme to apply. If None, the current theme will be used.
+        """
+        if theme is None:
+            theme = get_theme_name()
+        editor_theme = "vs" if theme == "light" else "vs-dark"
+        self.set_theme(editor_theme)
+
+    def set_text(self, text: str) -> None:
+        """
+        Set the text in the Monaco editor.
+
+        Args:
+            text (str): The text to set in the editor.
+        """
+        self.editor.set_text(text)
+
+    def get_text(self) -> str:
+        """
+        Get the current text from the Monaco editor.
+        """
+        return self.editor.get_text()
+
+    def set_cursor(
+        self,
+        line: int,
+        column: int = 1,
+        move_to_position: Literal[None, "center", "top", "position"] = None,
+    ) -> None:
+        """
+        Set the cursor position in the Monaco editor.
+
+        Args:
+            line (int): Line number (1-based).
+            column (int): Column number (1-based), defaults to 1.
+            move_to_position (Literal[None, "center", "top", "position"], optional): Position to move the cursor to.
+        """
+        self.editor.set_cursor(line, column, move_to_position)
+
+    def current_cursor(self) -> dict[str, int]:
+        """
+        Get the current cursor position in the Monaco editor.
+
+        Returns:
+            dict[str, int]: A dictionary with keys 'line' and 'column' representing the cursor position.
+        """
+        return self.editor.current_cursor
+
+    def set_language(self, language: str) -> None:
+        """
+        Set the programming language for syntax highlighting in the Monaco editor.
+
+        Args:
+            language (str): The programming language to set (e.g., "python", "javascript").
+        """
+        self.editor.set_language(language)
+
+    def get_language(self) -> str:
+        """
+        Get the current programming language set in the Monaco editor.
+        """
+        return self.editor.get_language()
+
+    def set_readonly(self, read_only: bool) -> None:
+        """
+        Set the Monaco editor to read-only mode.
+
+        Args:
+            read_only (bool): If True, the editor will be read-only.
+        """
+        self.editor.set_readonly(read_only)
+
+    def set_theme(self, theme: str) -> None:
+        """
+        Set the theme for the Monaco editor.
+
+        Args:
+            theme (str): The theme to set (e.g., "vs-dark", "light").
+        """
+        self.editor.set_theme(theme)
+
+    def get_theme(self) -> str:
+        """
+        Get the current theme of the Monaco editor.
+        """
+        return self.editor.get_theme()
+
+    def set_minimap_enabled(self, enabled: bool) -> None:
+        """
+        Enable or disable the minimap in the Monaco editor.
+
+        Args:
+            enabled (bool): If True, the minimap will be enabled; otherwise, it will be disabled.
+        """
+        self.editor.set_minimap_enabled(enabled)
+
+    def set_highlighted_lines(self, start_line: int, end_line: int) -> None:
+        """
+        Highlight a range of lines in the Monaco editor.
+
+        Args:
+            start_line (int): The starting line number (1-based).
+            end_line (int): The ending line number (1-based).
+        """
+        self.editor.set_highlighted_lines(start_line, end_line)
+
+    def clear_highlighted_lines(self) -> None:
+        """
+        Clear any highlighted lines in the Monaco editor.
+        """
+        self.editor.clear_highlighted_lines()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    qapp = QApplication([])
+    widget = MonacoWidget()
+    # set the default size
+    widget.resize(800, 600)
+    widget.set_language("python")
+    widget.set_theme("vs-dark")
+    widget.editor.set_minimap_enabled(False)
+    widget.set_text(
+        """
+import numpy as np
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from bec_lib.devicemanager import DeviceContainer
+    from bec_lib.scans import Scans
+    dev: DeviceContainer
+    scans: Scans
+
+#######################################
+########## User Script #####################
+#######################################
+
+# This is a comment
+def hello_world():
+    print("Hello, world!")
+            """
+    )
+    widget.set_highlighted_lines(1, 3)
+    widget.show()
+    qapp.exec_()

bec_widgets/widgets/editors/monaco/monaco_widget.pyproject

@@ -0,0 +1 @@
+{'files': ['monaco_widget.py']}

bec_widgets/widgets/editors/monaco/monaco_widget_plugin.py

@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.editors.monaco.monaco_widget import MonacoWidget
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='MonacoWidget' name='monaco_widget'>
+    </widget>
+</ui>
+"""
+
+
+class MonacoWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = MonacoWidget(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Developer"
+
+    def icon(self):
+        return designer_material_icon(MonacoWidget.ICON_NAME)
+
+    def includeFile(self):
+        return "monaco_widget"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "MonacoWidget"
+
+    def toolTip(self):
+        return ""
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/editors/monaco/register_monaco_widget.py

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.editors.monaco.monaco_widget_plugin import MonacoWidgetPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(MonacoWidgetPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/editors/sbb_monitor/register_sbb_monitor.py

@@ -6,9 +6,9 @@ def main():  # pragma: no cover
         return
     from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
 
-    from bec_widgets.widgets.editors.console.console_plugin import BECConsolePlugin
+    from bec_widgets.widgets.editors.sbb_monitor.sbb_monitor_plugin import SBBMonitorPlugin
 
-    QPyDesignerCustomWidgetCollection.addCustomWidget(BECConsolePlugin())
+    QPyDesignerCustomWidgetCollection.addCustomWidget(SBBMonitorPlugin())
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/widgets/editors/sbb_monitor/sbb_monitor.py

@@ -0,0 +1,15 @@
+from bec_widgets.widgets.editors.website.website import WebsiteWidget
+
+
+class SBBMonitor(WebsiteWidget):
+    """
+    A widget to display the SBB monitor website.
+    """
+
+    PLUGIN = True
+    ICON_NAME = "train"
+    USER_ACCESS = []
+
+    def __init__(self, parent=None, **kwargs):
+        url = "https://free.oevplus.ch/monitor/?viewType=splitView&layout=1&showClock=true&showPerron=true&stationGroup1Title=Villigen%2C%20PSI%20West&stationGroup2Title=Siggenthal-Würenlingen&station_1_id=85%3A3592&station_1_name=Villigen%2C%20PSI%20West&station_1_quantity=5&station_1_group=1&station_2_id=85%3A3502&station_2_name=Siggenthal-Würenlingen&station_2_quantity=5&station_2_group=2"
+        super().__init__(parent=parent, url=url, **kwargs)

bec_widgets/widgets/editors/sbb_monitor/sbb_monitor.pyproject

@@ -0,0 +1 @@
+{'files': ['sbb_monitor.py']}

bec_widgets/widgets/editors/sbb_monitor/sbb_monitor_plugin.py

@@ -1,43 +1,39 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-import os
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
 
-import bec_widgets
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.editors.console.console import BECConsole
+from bec_widgets.widgets.editors.sbb_monitor.sbb_monitor import SBBMonitor
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='BECConsole' name='bec_console'>
+    <widget class='SBBMonitor' name='sbb_monitor'>
     </widget>
 </ui>
 """
 
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
-
-class BECConsolePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+class SBBMonitorPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
         super().__init__()
         self._form_editor = None
 
     def createWidget(self, parent):
-        t = BECConsole(parent)
+        t = SBBMonitor(parent)
         return t
 
     def domXml(self):
         return DOM_XML
 
     def group(self):
-        return "BEC Console"
+        return ""
 
     def icon(self):
-        return designer_material_icon(BECConsole.ICON_NAME)
+        return designer_material_icon(SBBMonitor.ICON_NAME)
 
     def includeFile(self):
-        return "bec_console"
+        return "sbb_monitor"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -49,10 +45,10 @@ class BECConsolePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return self._form_editor is not None
 
     def name(self):
-        return "BECConsole"
+        return "SBBMonitor"
 
     def toolTip(self):
-        return "A terminal-like vt100 widget."
+        return ""
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/editors/scan_metadata/_util.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sys
 from decimal import Decimal
-from math import inf, nextafter
+from math import copysign, inf, nextafter
 from typing import TYPE_CHECKING, TypeVar, get_args
 
 from annotated_types import Ge, Gt, Le, Lt
@@ -23,16 +23,19 @@ _MAXFLOAT = sys.float_info.max
 T = TypeVar("T", int, float, Decimal)
 
 
-def field_limits(info: FieldInfo, type_: type[T]) -> tuple[T, T]:
+def field_limits(info: FieldInfo, type_: type[T], prec: int | None = None) -> tuple[T, T]:
+    def _nextafter(x, y):
+        return nextafter(x, y) if prec is None else x + (10 ** (-prec)) * (copysign(1, y))
+
     _min = _MININT if type_ is int else _MINFLOAT
     _max = _MAXINT if type_ is int else _MAXFLOAT
     for md in info.metadata:
         if isinstance(md, Ge):
             _min = type_(md.ge)  # type: ignore
         if isinstance(md, Gt):
-            _min = type_(md.gt) + 1 if type_ is int else nextafter(type_(md.gt), inf)  # type: ignore
+            _min = type_(md.gt) + 1 if type_ is int else _nextafter(type_(md.gt), inf)  # type: ignore
         if isinstance(md, Lt):
-            _max = type_(md.lt) - 1 if type_ is int else nextafter(type_(md.lt), -inf)  # type: ignore
+            _max = type_(md.lt) - 1 if type_ is int else _nextafter(type_(md.lt), -inf)  # type: ignore
         if isinstance(md, Le):
             _max = type_(md.le)  # type: ignore
     return _min, _max  # type: ignore
@@ -64,4 +67,6 @@ def field_default(info: FieldInfo):
 
 
 def clearable_required(info: FieldInfo):
-    return type(None) in get_args(info.annotation) or info.is_required()
+    return type(None) in get_args(info.annotation) or (
+        info.is_required() and info.default is PydanticUndefined
+    )

bec_widgets/widgets/editors/scan_metadata/scan_metadata.py

@@ -16,6 +16,9 @@ logger = bec_logger.logger
 
 
 class ScanMetadata(PydanticModelForm):
+
+    RPC = False
+
     def __init__(
         self,
         parent=None,
@@ -36,16 +39,18 @@ class ScanMetadata(PydanticModelForm):
 
         # self.populate() gets called in super().__init__
         # so make sure self._additional_metadata exists
-        self._additional_md_box = ExpandableGroupFrame("Additional metadata", expanded=False)
+        self._additional_md_box = ExpandableGroupFrame(
+            parent, "Additional metadata", expanded=False
+        )
         self._additional_md_box_layout = QHBoxLayout()
         self._additional_md_box.set_layout(self._additional_md_box_layout)
 
-        self._additional_metadata = DictBackedTable(initial_extras or [])
+        self._additional_metadata = DictBackedTable(parent, initial_extras or [])
         self._scan_name = scan_name or ""
         self._md_schema = get_metadata_schema_for_scan(self._scan_name)
-        self._additional_metadata.data_updated.connect(self.validate_form)
+        self._additional_metadata.data_changed.connect(self.validate_form)
 
-        super().__init__(parent=parent, metadata_model=self._md_schema, client=client, **kwargs)
+        super().__init__(parent=parent, data_model=self._md_schema, client=client, **kwargs)
 
         self._layout.addWidget(self._additional_md_box)
         self._additional_md_box_layout.addWidget(self._additional_metadata)
@@ -127,6 +132,7 @@ if __name__ == "__main__":  # pragma: no cover
         w.setLayout(layout)
 
         scan_metadata = ScanMetadata(
+            parent=w,
             scan_name="grid_scan",
             initial_extras=[["key1", "value1"], ["key2", "value2"], ["key3", "value3"]],
         )

bec_widgets/widgets/plots/heatmap/heatmap.py

@@ -0,0 +1,989 @@
+from __future__ import annotations
+
+import json
+from typing import Literal
+
+import numpy as np
+import pyqtgraph as pg
+from bec_lib import bec_logger, messages
+from bec_lib.endpoints import MessageEndpoints
+from pydantic import BaseModel, Field, field_validator
+from qtpy.QtCore import QTimer, Signal
+from qtpy.QtGui import QTransform
+from scipy.interpolate import (
+    CloughTocher2DInterpolator,
+    LinearNDInterpolator,
+    NearestNDInterpolator,
+)
+from scipy.spatial import cKDTree
+from toolz import partition
+
+from bec_widgets.utils import Colors
+from bec_widgets.utils.bec_connector import ConnectionConfig
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
+from bec_widgets.utils.settings_dialog import SettingsDialog
+from bec_widgets.utils.toolbars.actions import MaterialIconAction
+from bec_widgets.widgets.plots.heatmap.settings.heatmap_setting import HeatmapSettings
+from bec_widgets.widgets.plots.image.image_base import ImageBase
+from bec_widgets.widgets.plots.image.image_item import ImageItem
+
+logger = bec_logger.logger
+
+
+class HeatmapDeviceSignal(BaseModel):
+    """The configuration of a signal in the scatter waveform widget."""
+
+    name: str
+    entry: str
+
+    model_config: dict = {"validate_assignment": True}
+
+
+class HeatmapConfig(ConnectionConfig):
+    parent_id: str | None = Field(None, description="The parent plot of the curve.")
+    color_map: str | None = Field(
+        "plasma", description="The color palette of the heatmap widget.", validate_default=True
+    )
+    color_bar: Literal["full", "simple"] | None = Field(
+        None, description="The type of the color bar."
+    )
+    interpolation: Literal["linear", "nearest", "clough"] = Field(
+        "linear", description="The interpolation method for the heatmap."
+    )
+    oversampling_factor: float = Field(
+        1.0,
+        description="Factor to oversample the grid resolution (1.0 = no oversampling, 2.0 = 2x resolution).",
+    )
+    show_config_label: bool = Field(
+        True, description="Whether to show the configuration label in the heatmap."
+    )
+    enforce_interpolation: bool = Field(
+        False, description="Whether to use the interpolation mode even for grid scans."
+    )
+    lock_aspect_ratio: bool = Field(
+        False, description="Whether to lock the aspect ratio of the image."
+    )
+    x_device: HeatmapDeviceSignal | None = Field(
+        None, description="The x device signal of the heatmap."
+    )
+    y_device: HeatmapDeviceSignal | None = Field(
+        None, description="The y device signal of the heatmap."
+    )
+    z_device: HeatmapDeviceSignal | None = Field(
+        None, description="The z device signal of the heatmap."
+    )
+
+    model_config: dict = {"validate_assignment": True}
+    _validate_color_palette = field_validator("color_map")(Colors.validate_color_map)
+
+
+class Heatmap(ImageBase):
+    """
+    Heatmap widget for visualizing 2d grid data with color mapping for the z-axis.
+    """
+
+    USER_ACCESS = [
+        # General PlotBase Settings
+        "enable_toolbar",
+        "enable_toolbar.setter",
+        "enable_side_panel",
+        "enable_side_panel.setter",
+        "enable_fps_monitor",
+        "enable_fps_monitor.setter",
+        "set",
+        "title",
+        "title.setter",
+        "x_label",
+        "x_label.setter",
+        "y_label",
+        "y_label.setter",
+        "x_limits",
+        "x_limits.setter",
+        "y_limits",
+        "y_limits.setter",
+        "x_grid",
+        "x_grid.setter",
+        "y_grid",
+        "y_grid.setter",
+        "inner_axes",
+        "inner_axes.setter",
+        "outer_axes",
+        "outer_axes.setter",
+        "auto_range_x",
+        "auto_range_x.setter",
+        "auto_range_y",
+        "auto_range_y.setter",
+        "minimal_crosshair_precision",
+        "minimal_crosshair_precision.setter",
+        # ImageView Specific Settings
+        "color_map",
+        "color_map.setter",
+        "v_range",
+        "v_range.setter",
+        "v_min",
+        "v_min.setter",
+        "v_max",
+        "v_max.setter",
+        "lock_aspect_ratio",
+        "lock_aspect_ratio.setter",
+        "autorange",
+        "autorange.setter",
+        "autorange_mode",
+        "autorange_mode.setter",
+        "enable_colorbar",
+        "enable_simple_colorbar",
+        "enable_simple_colorbar.setter",
+        "enable_full_colorbar",
+        "enable_full_colorbar.setter",
+        "interpolation_method",
+        "interpolation_method.setter",
+        "oversampling_factor",
+        "oversampling_factor.setter",
+        "enforce_interpolation",
+        "enforce_interpolation.setter",
+        "fft",
+        "fft.setter",
+        "log",
+        "log.setter",
+        "main_image",
+        "add_roi",
+        "remove_roi",
+        "rois",
+        "plot",
+    ]
+
+    PLUGIN = True
+    RPC = True
+    ICON_NAME = "dataset"
+
+    new_scan = Signal()
+    new_scan_id = Signal(str)
+    sync_signal_update = Signal()
+    heatmap_property_changed = Signal()
+
+    def __init__(self, parent=None, config: HeatmapConfig | None = None, **kwargs):
+        if config is None:
+            config = HeatmapConfig(
+                widget_class=self.__class__.__name__,
+                parent_id=None,
+                color_map="plasma",
+                color_bar=None,
+                interpolation="linear",
+                oversampling_factor=1.0,
+                lock_aspect_ratio=False,
+                x_device=None,
+                y_device=None,
+                z_device=None,
+            )
+        super().__init__(parent=parent, config=config, theme_update=True, **kwargs)
+        self._image_config = config
+        self.scan_id = None
+        self.old_scan_id = None
+        self.scan_item = None
+        self.status_message = None
+        self._grid_index = None
+        self.heatmap_dialog = None
+        bg_color = pg.mkColor((240, 240, 240, 150))
+        self.config_label = pg.LegendItem(
+            labelTextColor=(0, 0, 0), offset=(-30, 1), brush=pg.mkBrush(bg_color), horSpacing=0
+        )
+        self.config_label.setParentItem(self.plot_item.vb)
+        self.config_label.setVisible(False)
+        self.reload = False
+        self.bec_dispatcher.connect_slot(self.on_scan_status, MessageEndpoints.scan_status())
+        self.bec_dispatcher.connect_slot(self.on_scan_progress, MessageEndpoints.scan_progress())
+        self.heatmap_property_changed.connect(lambda: self.sync_signal_update.emit())
+
+        self.proxy_update_sync = pg.SignalProxy(
+            self.sync_signal_update, rateLimit=5, slot=self.update_plot
+        )
+        self._init_toolbar_heatmap()
+        self.toolbar.show_bundles(
+            [
+                "heatmap_settings",
+                "plot_export",
+                "image_crosshair",
+                "mouse_interaction",
+                "image_autorange",
+                "image_colorbar",
+                "image_processing",
+                "axis_popup",
+                "interpolation_info",
+            ]
+        )
+
+    @property
+    def main_image(self) -> ImageItem:
+        """Access the main image item."""
+        return self.layer_manager["main"].image
+
+    ################################################################################
+    # Widget Specific GUI interactions
+    ################################################################################
+
+    @SafeSlot(str)
+    def apply_theme(self, theme: str):
+        """
+        Apply the current theme to the heatmap widget.
+        """
+        super().apply_theme(theme)
+        if theme == "dark":
+            brush = pg.mkBrush(pg.mkColor(50, 50, 50, 150))
+            color = pg.mkColor(255, 255, 255)
+        else:
+            brush = pg.mkBrush(pg.mkColor(240, 240, 240, 150))
+            color = pg.mkColor(0, 0, 0)
+        if hasattr(self, "config_label"):
+            self.config_label.setBrush(brush)
+            self.config_label.setLabelTextColor(color)
+            self.redraw_config_label()
+
+    @SafeSlot(popup_error=True)
+    def plot(
+        self,
+        x_name: str,
+        y_name: str,
+        z_name: str,
+        x_entry: None | str = None,
+        y_entry: None | str = None,
+        z_entry: None | str = None,
+        color_map: str | None = "plasma",
+        validate_bec: bool = True,
+        interpolation: Literal["linear", "nearest"] | None = None,
+        enforce_interpolation: bool | None = None,
+        oversampling_factor: float | None = None,
+        lock_aspect_ratio: bool | None = None,
+        show_config_label: bool | None = None,
+        reload: bool = False,
+    ):
+        """
+        Plot the heatmap with the given x, y, and z data.
+
+        Args:
+            x_name (str): The name of the x-axis signal.
+            y_name (str): The name of the y-axis signal.
+            z_name (str): The name of the z-axis signal.
+            x_entry (str | None): The entry for the x-axis signal.
+            y_entry (str | None): The entry for the y-axis signal.
+            z_entry (str | None): The entry for the z-axis signal.
+            color_map (str | None): The color map to use for the heatmap.
+            validate_bec (bool): Whether to validate the entries against BEC signals.
+            interpolation (Literal["linear", "nearest"] | None): The interpolation method to use.
+            enforce_interpolation (bool | None): Whether to enforce interpolation even for grid scans.
+            oversampling_factor (float | None): Factor to oversample the grid resolution.
+            lock_aspect_ratio (bool | None): Whether to lock the aspect ratio of the image.
+            show_config_label (bool | None): Whether to show the configuration label in the heatmap.
+            reload (bool): Whether to reload the heatmap with new data.
+        """
+        if validate_bec:
+            x_entry = self.entry_validator.validate_signal(x_name, x_entry)
+            y_entry = self.entry_validator.validate_signal(y_name, y_entry)
+            z_entry = self.entry_validator.validate_signal(z_name, z_entry)
+
+        if x_entry is None or y_entry is None or z_entry is None:
+            raise ValueError("x, y, and z entries must be provided.")
+        if x_name is None or y_name is None or z_name is None:
+            raise ValueError("x, y, and z names must be provided.")
+
+        if interpolation is None:
+            interpolation = self._image_config.interpolation
+
+        if oversampling_factor is None:
+            oversampling_factor = self._image_config.oversampling_factor
+
+        if enforce_interpolation is None:
+            enforce_interpolation = self._image_config.enforce_interpolation
+
+        if lock_aspect_ratio is None:
+            lock_aspect_ratio = self._image_config.lock_aspect_ratio
+
+        if show_config_label is None:
+            show_config_label = self._image_config.show_config_label
+
+        self._image_config = HeatmapConfig(
+            parent_id=self.gui_id,
+            x_device=HeatmapDeviceSignal(name=x_name, entry=x_entry),
+            y_device=HeatmapDeviceSignal(name=y_name, entry=y_entry),
+            z_device=HeatmapDeviceSignal(name=z_name, entry=z_entry),
+            color_map=color_map,
+            color_bar=None,
+            interpolation=interpolation,
+            oversampling_factor=oversampling_factor,
+            enforce_interpolation=enforce_interpolation,
+            lock_aspect_ratio=lock_aspect_ratio,
+            show_config_label=show_config_label,
+        )
+        self.color_map = color_map
+        self.reload = reload
+        self.update_labels()
+
+        self._fetch_running_scan()
+        self.sync_signal_update.emit()
+
+    def _fetch_running_scan(self):
+        scan = self.client.queue.scan_storage.current_scan
+        if scan is not None:
+            self.scan_item = scan
+            self.scan_id = scan.scan_id
+        elif self.client.history and len(self.client.history) > 0:
+            self.scan_item = self.client.history[-1]
+            self.scan_id = self.client.history._scan_ids[-1]
+            self.old_scan_id = None
+
+    def update_labels(self):
+        """
+        Update the labels of the x, y, and z axes.
+        """
+        if self._image_config is None:
+            return
+        x_name = self._image_config.x_device.name
+        y_name = self._image_config.y_device.name
+        z_name = self._image_config.z_device.name
+
+        if x_name is not None:
+            self.x_label = x_name  # type: ignore
+            x_dev = self.dev.get(x_name)
+            if x_dev and hasattr(x_dev, "egu"):
+                self.x_label_units = x_dev.egu()
+        if y_name is not None:
+            self.y_label = y_name  # type: ignore
+            y_dev = self.dev.get(y_name)
+            if y_dev and hasattr(y_dev, "egu"):
+                self.y_label_units = y_dev.egu()
+        if z_name is not None:
+            self.title = z_name
+
+    def _init_toolbar_heatmap(self):
+        """
+        Initialize the toolbar for the heatmap widget, adding actions for heatmap settings.
+        """
+        self.toolbar.add_action(
+            "heatmap_settings",
+            MaterialIconAction(
+                icon_name="scatter_plot",
+                tooltip="Show Heatmap Settings",
+                checkable=True,
+                parent=self,
+            ),
+        )
+
+        self.toolbar.components.get_action("heatmap_settings").action.triggered.connect(
+            self.show_heatmap_settings
+        )
+
+        # disable all processing actions except for the fft and log
+        bundle = self.toolbar.get_bundle("image_processing")
+        for name, action in bundle.bundle_actions.items():
+            if name not in ["image_processing_fft", "image_processing_log"]:
+                action().action.setVisible(False)
+
+        self.toolbar.add_action(
+            "interpolation_info",
+            MaterialIconAction(
+                icon_name="info", tooltip="Show Interpolation Info", checkable=True, parent=self
+            ),
+        )
+        self.toolbar.components.get_action("interpolation_info").action.triggered.connect(
+            self.toggle_interpolation_info
+        )
+        self.toolbar.components.get_action("interpolation_info").action.setChecked(
+            self._image_config.show_config_label
+        )
+
+    def show_heatmap_settings(self):
+        """
+        Show the heatmap settings dialog.
+        """
+        heatmap_settings_action = self.toolbar.components.get_action("heatmap_settings").action
+        if self.heatmap_dialog is None or not self.heatmap_dialog.isVisible():
+            heatmap_settings = HeatmapSettings(parent=self, target_widget=self, popup=True)
+            self.heatmap_dialog = SettingsDialog(
+                self, settings_widget=heatmap_settings, window_title="Heatmap Settings", modal=False
+            )
+            self.heatmap_dialog.resize(700, 350)
+            # When the dialog is closed, update the toolbar icon and clear the reference
+            self.heatmap_dialog.finished.connect(self._heatmap_dialog_closed)
+            self.heatmap_dialog.show()
+            heatmap_settings_action.setChecked(True)
+        else:
+            # If already open, bring it to the front
+            self.heatmap_dialog.raise_()
+            self.heatmap_dialog.activateWindow()
+            heatmap_settings_action.setChecked(True)  # keep it toggled
+
+    def toggle_interpolation_info(self):
+        """
+        Toggle the visibility of the interpolation info label.
+        """
+        self._image_config.show_config_label = not self._image_config.show_config_label
+        self.toolbar.components.get_action("interpolation_info").action.setChecked(
+            self._image_config.show_config_label
+        )
+        self.redraw_config_label()
+
+    def _heatmap_dialog_closed(self):
+        """
+        Slot for when the heatmap settings dialog is closed.
+        """
+        self.heatmap_dialog = None
+        self.toolbar.components.get_action("heatmap_settings").action.setChecked(False)
+
+    @SafeSlot(dict, dict)
+    def on_scan_status(self, msg: dict, meta: dict):
+        """
+        Initial scan status message handler, which is triggered at the begging and end of scan.
+
+        Args:
+            msg(dict): The message content.
+            meta(dict): The message metadata.
+        """
+        current_scan_id = msg.get("scan_id", None)
+        if current_scan_id is None:
+            return
+        if current_scan_id != self.scan_id:
+            self.reset()
+            self.new_scan.emit()
+            self.new_scan_id.emit(current_scan_id)
+            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)  # type: ignore
+
+            # First trigger to update the scan curves
+            self.sync_signal_update.emit()
+
+    @SafeSlot(dict, dict)
+    def on_scan_progress(self, msg: dict, meta: dict):
+        self.sync_signal_update.emit()
+        status = msg.get("done")
+        if status:
+            QTimer.singleShot(100, self.update_plot)
+            QTimer.singleShot(300, self.update_plot)
+
+    @SafeSlot(verify_sender=True)
+    def update_plot(self, _=None) -> None:
+        """
+        Update the plot with the current data.
+        """
+        if self.scan_item is None:
+            logger.info("No scan executed so far; skipping update.")
+            return
+        data, access_key = self._fetch_scan_data_and_access()
+        if data == "none":
+            logger.info("No scan executed so far; skipping update.")
+            return
+
+        if self._image_config is None:
+            return
+        try:
+            x_name = self._image_config.x_device.name
+            x_entry = self._image_config.x_device.entry
+            y_name = self._image_config.y_device.name
+            y_entry = self._image_config.y_device.entry
+            z_name = self._image_config.z_device.name
+            z_entry = self._image_config.z_device.entry
+        except AttributeError:
+            return
+
+        if access_key == "val":
+            x_data = data.get(x_name, {}).get(x_entry, {}).get(access_key, None)
+            y_data = data.get(y_name, {}).get(y_entry, {}).get(access_key, None)
+            z_data = data.get(z_name, {}).get(z_entry, {}).get(access_key, None)
+        else:
+            x_data = data.get(x_name, {}).get(x_entry, {}).read().get("value", None)
+            y_data = data.get(y_name, {}).get(y_entry, {}).read().get("value", None)
+            z_data = data.get(z_name, {}).get(z_entry, {}).read().get("value", None)
+
+            if not isinstance(x_data, list):
+                x_data = x_data.tolist() if isinstance(x_data, np.ndarray) else None
+            if not isinstance(y_data, list):
+                y_data = y_data.tolist() if isinstance(y_data, np.ndarray) else None
+            if not isinstance(z_data, list):
+                z_data = z_data.tolist() if isinstance(z_data, np.ndarray) else None
+
+        if x_data is None or y_data is None or z_data is None:
+            logger.warning("x, y, or z data is None; skipping update.")
+            return
+        if len(x_data) != len(y_data) or len(x_data) != len(z_data):
+            logger.warning(
+                "x, y, and z data lengths do not match; skipping update. "
+                f"Lengths: x={len(x_data)}, y={len(y_data)}, z={len(z_data)}"
+            )
+            return
+
+        if hasattr(self.scan_item, "status_message"):
+            scan_msg = self.scan_item.status_message
+        elif hasattr(self.scan_item, "metadata"):
+            metadata = self.scan_item.metadata["bec"]
+            status = metadata["exit_status"]
+            scan_id = metadata["scan_id"]
+            scan_name = metadata["scan_name"]
+            scan_type = metadata["scan_type"]
+            scan_number = metadata["scan_number"]
+            request_inputs = metadata["request_inputs"]
+            if "arg_bundle" in request_inputs and isinstance(request_inputs["arg_bundle"], str):
+                # Convert the arg_bundle from a JSON string to a dictionary
+                request_inputs["arg_bundle"] = json.loads(request_inputs["arg_bundle"])
+            positions = metadata.get("positions", [])
+            positions = positions.tolist() if isinstance(positions, np.ndarray) else positions
+
+            scan_msg = messages.ScanStatusMessage(
+                status=status,
+                scan_id=scan_id,
+                scan_name=scan_name,
+                scan_number=scan_number,
+                scan_type=scan_type,
+                request_inputs=request_inputs,
+                info={"positions": positions},
+            )
+        else:
+            scan_msg = None
+
+        if scan_msg is None:
+            logger.warning("Scan message is None; skipping update.")
+            return
+        self.status_message = scan_msg
+
+        if self._image_config.show_config_label:
+            self.redraw_config_label()
+
+        img, transform = self.get_image_data(x_data=x_data, y_data=y_data, z_data=z_data)
+        if img is None:
+            logger.warning("Image data is None; skipping update.")
+            return
+
+        if self._color_bar is not None:
+            self._color_bar.blockSignals(True)
+        self.main_image.set_data(img, transform=transform)
+        if self._color_bar is not None:
+            self._color_bar.blockSignals(False)
+        self.image_updated.emit()
+        if self.crosshair is not None:
+            self.crosshair.update_markers_on_image_change()
+
+    def redraw_config_label(self):
+        scan_msg = self.status_message
+        if scan_msg is None:
+            return
+        if not self._image_config.show_config_label:
+            self.config_label.setVisible(False)
+            return
+
+        self.config_label.setOffset((-30, 1))
+        self.config_label.setVisible(True)
+        self.config_label.clear()
+        self.config_label.addItem(self.plot_item, f"Scan: {scan_msg.scan_number}")
+        self.config_label.addItem(self.plot_item, f"Scan Name: {scan_msg.scan_name}")
+        if scan_msg.scan_name != "grid_scan" or self._image_config.enforce_interpolation:
+            self.config_label.addItem(
+                self.plot_item, f"Interpolation: {self._image_config.interpolation}"
+            )
+            self.config_label.addItem(
+                self.plot_item, f"Oversampling: {self._image_config.oversampling_factor}x"
+            )
+
+    def get_image_data(
+        self,
+        x_data: list[float] | None = None,
+        y_data: list[float] | None = None,
+        z_data: list[float] | None = None,
+    ) -> tuple[np.ndarray | None, QTransform | None]:
+        """
+        Get the image data for the heatmap. Depending on the scan type, it will
+        either pre-allocate the grid (grid_scan) or interpolate the data (step scan).
+
+        Args:
+            x_data (np.ndarray): The x data.
+            y_data (np.ndarray): The y data.
+            z_data (np.ndarray): The z data.
+            msg (messages.ScanStatusMessage): The scan status message.
+
+        Returns:
+            tuple[np.ndarray, QTransform]: The image data and the QTransform.
+        """
+        msg = self.status_message
+        if x_data is None or y_data is None or z_data is None or msg is None:
+            logger.warning("x, y, or z data is None; skipping update.")
+            return None, None
+
+        if msg.scan_name == "grid_scan" and not self._image_config.enforce_interpolation:
+            # We only support the grid scan mode if both scanning motors
+            # are configured in the heatmap config.
+            device_x = self._image_config.x_device.entry
+            device_y = self._image_config.y_device.entry
+            if (
+                device_x in msg.request_inputs["arg_bundle"]
+                and device_y in msg.request_inputs["arg_bundle"]
+            ):
+                return self.get_grid_scan_image(z_data, msg)
+        if len(z_data) < 4:
+            # LinearNDInterpolator requires at least 4 points to interpolate
+            return None, None
+        return self.get_step_scan_image(x_data, y_data, z_data, msg)
+
+    def get_grid_scan_image(
+        self, z_data: list[float], msg: messages.ScanStatusMessage
+    ) -> tuple[np.ndarray, QTransform]:
+        """
+        Get the image data for a grid scan.
+        Args:
+            z_data (np.ndarray): The z data.
+            msg (messages.ScanStatusMessage): The scan status message.
+
+        Returns:
+            tuple[np.ndarray, QTransform]: The image data and the QTransform.
+        """
+
+        args = self.arg_bundle_to_dict(4, msg.request_inputs["arg_bundle"])
+
+        shape = (
+            args[self._image_config.x_device.entry][-1],
+            args[self._image_config.y_device.entry][-1],
+        )
+
+        data = self.main_image.raw_data
+
+        if data is None or data.shape != shape:
+            data = np.empty(shape)
+            data.fill(np.nan)
+
+        def _get_grid_data(axis, snaked=True):
+            x_grid, y_grid = np.meshgrid(axis[0], axis[1])
+            if snaked:
+                y_grid.T[::2] = np.fliplr(y_grid.T[::2])
+            x_flat = x_grid.T.ravel()
+            y_flat = y_grid.T.ravel()
+            positions = np.vstack((x_flat, y_flat)).T
+            return positions
+
+        snaked = msg.request_inputs["kwargs"].get("snaked", True)
+
+        # If the scan's fast axis is x, we need to swap the x and y axes
+        swap = bool(msg.request_inputs["arg_bundle"][4] == self._image_config.x_device.entry)
+
+        # calculate the QTransform to put (0,0) at the axis origin
+        scan_pos = np.asarray(msg.info["positions"])
+        x_min = min(scan_pos[:, 0])
+        x_max = max(scan_pos[:, 0])
+        y_min = min(scan_pos[:, 1])
+        y_max = max(scan_pos[:, 1])
+
+        x_range = x_max - x_min
+        y_range = y_max - y_min
+
+        pixel_size_x = x_range / (shape[0] - 1)
+        pixel_size_y = y_range / (shape[1] - 1)
+
+        transform = QTransform()
+        if swap:
+            transform.scale(pixel_size_y, pixel_size_x)
+            transform.translate(y_min / pixel_size_y - 0.5, x_min / pixel_size_x - 0.5)
+        else:
+            transform.scale(pixel_size_x, pixel_size_y)
+            transform.translate(x_min / pixel_size_x - 0.5, y_min / pixel_size_y - 0.5)
+
+        target_positions = _get_grid_data(
+            (np.arange(shape[int(swap)]), np.arange(shape[int(not swap)])), snaked=snaked
+        )
+
+        # Fill the data array with the z values
+        if self._grid_index is None or self.reload:
+            self._grid_index = 0
+            self.reload = False
+
+        for i in range(self._grid_index, len(z_data)):
+            data[target_positions[i, int(swap)], target_positions[i, int(not swap)]] = z_data[i]
+        self._grid_index = len(z_data)
+        return data, transform
+
+    def get_step_scan_image(
+        self,
+        x_data: list[float],
+        y_data: list[float],
+        z_data: list[float],
+        msg: messages.ScanStatusMessage,
+    ) -> tuple[np.ndarray, QTransform]:
+        """
+        Get the image data for an arbitrary step scan.
+
+        Args:
+            x_data (list[float]): The x data.
+            y_data (list[float]): The y data.
+            z_data (list[float]): The z data.
+            msg (messages.ScanStatusMessage): The scan status message.
+
+        Returns:
+            tuple[np.ndarray, QTransform]: The image data and the QTransform.
+        """
+        xy_data = np.column_stack((x_data, y_data))
+        grid_x, grid_y, transform = self.get_image_grid(xy_data)
+
+        # Interpolate the z data onto the grid
+        if self._image_config.interpolation == "linear":
+            interp = LinearNDInterpolator(xy_data, z_data)
+        elif self._image_config.interpolation == "nearest":
+            interp = NearestNDInterpolator(xy_data, z_data)
+        elif self._image_config.interpolation == "clough":
+            interp = CloughTocher2DInterpolator(xy_data, z_data)
+        else:
+            raise ValueError(
+                "Interpolation method must be either 'linear', 'nearest', or 'clough'."
+            )
+        grid_z = interp(grid_x, grid_y)
+
+        return grid_z, transform
+
+    def get_image_grid(self, positions) -> tuple[np.ndarray, np.ndarray, QTransform]:
+        """
+        LRU-cached calculation of the grid for the image. The lru cache is indexed by the scan_id
+        to avoid recalculating the grid for the same scan.
+
+        Args:
+            _scan_id (str): The scan ID. Needed for caching but not used in the function.
+
+        Returns:
+            tuple[np.ndarray, np.ndarray, QTransform]: The grid x and y coordinates and the QTransform.
+        """
+        base_width, base_height = self.estimate_image_resolution(positions)
+
+        # Apply oversampling factor
+        factor = self._image_config.oversampling_factor
+
+        # Apply oversampling
+        width = int(base_width * factor)
+        height = int(base_height * factor)
+
+        # Create grid
+        grid_x, grid_y = np.mgrid[
+            min(positions[:, 0]) : max(positions[:, 0]) : width * 1j,
+            min(positions[:, 1]) : max(positions[:, 1]) : height * 1j,
+        ]
+
+        # Calculate transform
+        x_min, x_max = min(positions[:, 0]), max(positions[:, 0])
+        y_min, y_max = min(positions[:, 1]), max(positions[:, 1])
+        x_range = x_max - x_min
+        y_range = y_max - y_min
+        x_scale = x_range / width
+        y_scale = y_range / height
+
+        transform = QTransform()
+        transform.scale(x_scale, y_scale)
+        transform.translate(x_min / x_scale - 0.5, y_min / y_scale - 0.5)
+
+        return grid_x, grid_y, transform
+
+    @staticmethod
+    def estimate_image_resolution(coords: np.ndarray) -> tuple[int, int]:
+        """
+        Estimate the number of pixels needed for the image based on the coordinates.
+
+        Args:
+            coords (np.ndarray): The coordinates of the points.
+
+        Returns:
+            tuple[int, int]: The estimated width and height of the image."""
+        if coords.ndim != 2 or coords.shape[1] != 2:
+            raise ValueError("Input must be an (m x 2) array of (x, y) coordinates.")
+
+        x_min, x_max = coords[:, 0].min(), coords[:, 0].max()
+        y_min, y_max = coords[:, 1].min(), coords[:, 1].max()
+
+        tree = cKDTree(coords)
+        distances, _ = tree.query(coords, k=2)
+        distances = distances[:, 1]  # Get the second nearest neighbor distance
+        avg_distance = np.mean(distances)
+
+        width_extent = x_max - x_min
+        height_extent = y_max - y_min
+
+        # Calculate the number of pixels needed based on the average distance
+        width_pixels = int(np.ceil(width_extent / avg_distance))
+        height_pixels = int(np.ceil(height_extent / avg_distance))
+
+        return max(1, width_pixels), max(1, height_pixels)
+
+    def arg_bundle_to_dict(self, bundle_size: int, args: list) -> dict:
+        """
+        Convert the argument bundle to a dictionary.
+
+        Args:
+            args (list): The argument bundle.
+
+        Returns:
+            dict: The dictionary representation of the argument bundle.
+        """
+        params = {}
+        for cmds in partition(bundle_size, args):
+            params[cmds[0]] = list(cmds[1:])
+        return params
+
+    def _fetch_scan_data_and_access(self):
+        """
+        Decide whether the widget is in live or historical mode
+        and return the appropriate data dict and access key.
+
+        Returns:
+            data_dict (dict): The data structure for the current scan.
+            access_key (str): Either 'val' (live) or 'value' (history).
+        """
+        if self.scan_item is None:
+            # Optionally fetch the latest from history if nothing is set
+            # self.update_with_scan_history(-1)
+            if self.scan_item is None:
+                logger.info("No scan executed so far; skipping update.")
+                return "none", "none"
+
+        if hasattr(self.scan_item, "live_data"):
+            # Live scan
+            return self.scan_item.live_data, "val"
+
+        # Historical
+        scan_devices = self.scan_item.devices
+        return scan_devices, "value"
+
+    def reset(self):
+        self._grid_index = None
+        self.main_image.clear()
+        if self.crosshair is not None:
+            self.crosshair.reset()
+        super().reset()
+
+    @SafeProperty(str)
+    def interpolation_method(self) -> str:
+        """
+        The interpolation method used for the heatmap.
+        """
+        return self._image_config.interpolation
+
+    @interpolation_method.setter
+    def interpolation_method(self, value: str):
+        """
+        Set the interpolation method for the heatmap.
+        Args:
+            value(str): The interpolation method, either 'linear' or 'nearest'.
+        """
+        if value not in ["linear", "nearest"]:
+            raise ValueError("Interpolation method must be either 'linear' or 'nearest'.")
+        self._image_config.interpolation = value
+        self.heatmap_property_changed.emit()
+
+    @SafeProperty(float)
+    def oversampling_factor(self) -> float:
+        """
+        The oversampling factor for grid resolution.
+        """
+        return self._image_config.oversampling_factor
+
+    @oversampling_factor.setter
+    def oversampling_factor(self, value: float):
+        """
+        Set the oversampling factor for grid resolution.
+        Args:
+            value(float): The oversampling factor (1.0 = no oversampling, 2.0 = 2x resolution).
+        """
+        if value <= 0:
+            raise ValueError("Oversampling factor must be greater than 0.")
+        self._image_config.oversampling_factor = value
+        self.heatmap_property_changed.emit()
+
+    @SafeProperty(bool)
+    def enforce_interpolation(self) -> bool:
+        """
+        Whether to enforce interpolation even for grid scans.
+        """
+        return self._image_config.enforce_interpolation
+
+    @enforce_interpolation.setter
+    def enforce_interpolation(self, value: bool):
+        """
+        Set whether to enforce interpolation even for grid scans.
+
+        Args:
+            value(bool): Whether to enforce interpolation.
+        """
+        self._image_config.enforce_interpolation = value
+        self.heatmap_property_changed.emit()
+
+    ################################################################################
+    # Post Processing
+    ################################################################################
+
+    @SafeProperty(bool)
+    def fft(self) -> bool:
+        """
+        Whether FFT postprocessing is enabled.
+        """
+        return self.main_image.fft
+
+    @fft.setter
+    def fft(self, enable: bool):
+        """
+        Set FFT postprocessing.
+
+        Args:
+            enable(bool): Whether to enable FFT postprocessing.
+        """
+        self.main_image.fft = enable
+
+    @SafeProperty(bool)
+    def log(self) -> bool:
+        """
+        Whether logarithmic scaling is applied.
+        """
+        return self.main_image.log
+
+    @log.setter
+    def log(self, enable: bool):
+        """
+        Set logarithmic scaling.
+
+        Args:
+            enable(bool): Whether to enable logarithmic scaling.
+        """
+        self.main_image.log = enable
+
+    @SafeProperty(int)
+    def num_rotation_90(self) -> int:
+        """
+        The number of 90° rotations to apply counterclockwise.
+        """
+        return self.main_image.num_rotation_90
+
+    @num_rotation_90.setter
+    def num_rotation_90(self, value: int):
+        """
+        Set the number of 90° rotations to apply counterclockwise.
+
+        Args:
+            value(int): The number of 90° rotations to apply.
+        """
+        self.main_image.num_rotation_90 = value
+
+    @SafeProperty(bool)
+    def transpose(self) -> bool:
+        """
+        Whether the image is transposed.
+        """
+        return self.main_image.transpose
+
+    @transpose.setter
+    def transpose(self, enable: bool):
+        """
+        Set the image to be transposed.
+
+        Args:
+            enable(bool): Whether to enable transposing the image.
+        """
+        self.main_image.transpose = enable
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    heatmap = Heatmap()
+    heatmap.plot(x_name="samx", y_name="samy", z_name="bpm4i", oversampling_factor=5.0)
+    heatmap.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/plots/heatmap/heatmap.pyproject

@@ -0,0 +1 @@
+{'files': ['heatmap.py']}

bec_widgets/widgets/plots/heatmap/heatmap_plugin.py

@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.plots.heatmap.heatmap import Heatmap
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='Heatmap' name='heatmap'>
+    </widget>
+</ui>
+"""
+
+
+class HeatmapPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = Heatmap(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "Plot Widgets"
+
+    def icon(self):
+        return designer_material_icon(Heatmap.ICON_NAME)
+
+    def includeFile(self):
+        return "heatmap"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "Heatmap"
+
+    def toolTip(self):
+        return ""
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/plots/heatmap/register_heatmap.py

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.plots.heatmap.heatmap_plugin import HeatmapPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(HeatmapPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/plots/heatmap/settings/heatmap_setting.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+from qtpy.QtWidgets import QFrame, QScrollArea, QVBoxLayout
+
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.settings_dialog import SettingWidget
+
+if TYPE_CHECKING:
+    from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import (
+        SignalComboBox,
+    )
+
+
+class HeatmapSettings(SettingWidget):
+    def __init__(self, parent=None, target_widget=None, popup=False, *args, **kwargs):
+        super().__init__(parent=parent, *args, **kwargs)
+
+        # This is a settings widget that depends on the target widget
+        # and should mirror what is in the target widget.
+        # Saving settings for this widget could result in recursively setting the target widget.
+        self.setProperty("skip_settings", True)
+
+        current_path = os.path.dirname(__file__)
+        if popup:
+            form = UILoader().load_ui(
+                os.path.join(current_path, "heatmap_settings_horizontal.ui"), self
+            )
+        else:
+            form = UILoader().load_ui(
+                os.path.join(current_path, "heatmap_settings_vertical.ui"), self
+            )
+
+        self.target_widget = target_widget
+        self.popup = popup
+
+        # # Scroll area
+        self.scroll_area = QScrollArea(self)
+        self.scroll_area.setWidgetResizable(True)
+        self.scroll_area.setFrameShape(QFrame.NoFrame)
+        self.scroll_area.setWidget(form)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.layout.addWidget(self.scroll_area)
+        self.ui = form
+
+        self.fetch_all_properties()
+
+        self.target_widget.heatmap_property_changed.connect(self.fetch_all_properties)
+        if popup is False:
+            self.ui.button_apply.clicked.connect(self.accept_changes)
+
+        self.ui.x_name.setFocus()
+
+    @SafeSlot()
+    def fetch_all_properties(self):
+        """
+        Fetch all properties from the target widget and update the settings widget.
+        """
+        if not self.target_widget:
+            return
+
+        # Get properties from the target widget
+        color_map = getattr(self.target_widget, "color_map", None)
+
+        # Default values for device properties
+        x_name, x_entry = None, None
+        y_name, y_entry = None, None
+        z_name, z_entry = None, None
+
+        # Safely access device properties
+        if hasattr(self.target_widget, "_image_config") and self.target_widget._image_config:
+            config = self.target_widget._image_config
+
+            if hasattr(config, "x_device") and config.x_device:
+                x_name = getattr(config.x_device, "name", None)
+                x_entry = getattr(config.x_device, "entry", None)
+
+            if hasattr(config, "y_device") and config.y_device:
+                y_name = getattr(config.y_device, "name", None)
+                y_entry = getattr(config.y_device, "entry", None)
+
+            if hasattr(config, "z_device") and config.z_device:
+                z_name = getattr(config.z_device, "name", None)
+                z_entry = getattr(config.z_device, "entry", None)
+
+        # Apply the properties to the settings widget
+        if hasattr(self.ui, "color_map"):
+            self.ui.color_map.colormap = color_map
+
+        if hasattr(self.ui, "x_name"):
+            self.ui.x_name.set_device(x_name)
+        if hasattr(self.ui, "x_entry") and x_entry is not None:
+            self.ui.x_entry.set_to_obj_name(x_entry)
+
+        if hasattr(self.ui, "y_name"):
+            self.ui.y_name.set_device(y_name)
+        if hasattr(self.ui, "y_entry") and y_entry is not None:
+            self.ui.y_entry.set_to_obj_name(y_entry)
+
+        if hasattr(self.ui, "z_name"):
+            self.ui.z_name.set_device(z_name)
+        if hasattr(self.ui, "z_entry") and z_entry is not None:
+            self.ui.z_entry.set_to_obj_name(z_entry)
+
+        if hasattr(self.ui, "interpolation"):
+            self.ui.interpolation.setCurrentText(
+                getattr(self.target_widget._image_config, "interpolation", "linear")
+            )
+        if hasattr(self.ui, "oversampling_factor"):
+            self.ui.oversampling_factor.setValue(
+                getattr(self.target_widget._image_config, "oversampling_factor", 1.0)
+            )
+        if hasattr(self.ui, "enforce_interpolation"):
+            self.ui.enforce_interpolation.setChecked(
+                getattr(self.target_widget._image_config, "enforce_interpolation", False)
+            )
+
+    def _get_signal_name(self, signal: SignalComboBox) -> str:
+        """
+        Get the signal name from the signal combobox.
+        Args:
+            signal (SignalComboBox): The signal combobox to get the name from.
+        Returns:
+            str: The signal name.
+        """
+        device_entry = signal.currentText()
+        index = signal.findText(device_entry)
+        if index == -1:
+            return device_entry
+
+        device_entry_info = signal.itemData(index)
+        if device_entry_info:
+            device_entry = device_entry_info.get("obj_name", device_entry)
+
+        return device_entry if device_entry else ""
+
+    @SafeSlot()
+    def accept_changes(self):
+        """
+        Apply all properties from the settings widget to the target widget.
+        """
+        x_name = self.ui.x_name.currentText()
+        x_entry = self._get_signal_name(self.ui.x_entry)
+        y_name = self.ui.y_name.currentText()
+        y_entry = self._get_signal_name(self.ui.y_entry)
+        z_name = self.ui.z_name.currentText()
+        z_entry = self._get_signal_name(self.ui.z_entry)
+        validate_bec = self.ui.validate_bec.checked
+        color_map = self.ui.color_map.colormap
+        interpolation = self.ui.interpolation.currentText()
+        oversampling_factor = self.ui.oversampling_factor.value()
+        enforce_interpolation = self.ui.enforce_interpolation.isChecked()
+
+        self.target_widget.plot(
+            x_name=x_name,
+            y_name=y_name,
+            z_name=z_name,
+            x_entry=x_entry,
+            y_entry=y_entry,
+            z_entry=z_entry,
+            color_map=color_map,
+            validate_bec=validate_bec,
+            interpolation=interpolation,
+            oversampling_factor=oversampling_factor,
+            enforce_interpolation=enforce_interpolation,
+            reload=True,
+        )
+
+    def cleanup(self):
+        self.ui.x_name.close()
+        self.ui.x_name.deleteLater()
+        self.ui.x_entry.close()
+        self.ui.x_entry.deleteLater()
+        self.ui.y_name.close()
+        self.ui.y_name.deleteLater()
+        self.ui.y_entry.close()
+        self.ui.y_entry.deleteLater()
+        self.ui.z_name.close()
+        self.ui.z_name.deleteLater()
+        self.ui.z_entry.close()
+        self.ui.z_entry.deleteLater()
+        self.ui.interpolation.close()
+        self.ui.interpolation.deleteLater()

bec_widgets/widgets/plots/heatmap/settings/heatmap_settings_horizontal.ui

@@ -0,0 +1,433 @@
+<?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>826</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_2">
+     <item>
+      <widget class="QGroupBox" name="groupBox_4">
+       <property name="title">
+        <string>Interpolation</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout_4">
+        <item row="1" column="2" alignment="Qt::AlignmentFlag::AlignRight">
+         <widget class="ToggleSwitch" name="enforce_interpolation">
+          <property name="toolTip">
+           <string>Use the interpolation mode even for grid scans</string>
+          </property>
+          <property name="checked" stdset="0">
+           <bool>false</bool>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
+         <widget class="QLabel" name="label_9">
+          <property name="toolTip">
+           <string>Use the interpolation mode even for grid scans</string>
+          </property>
+          <property name="text">
+           <string>Enforce Interpolation</string>
+          </property>
+         </widget>
+        </item>
+        <item row="5" column="2">
+         <widget class="QDoubleSpinBox" name="oversampling_factor">
+          <property name="decimals">
+           <number>1</number>
+          </property>
+          <property name="minimum">
+           <double>1.000000000000000</double>
+          </property>
+          <property name="maximum">
+           <double>10.000000000000000</double>
+          </property>
+         </widget>
+        </item>
+        <item row="3" column="2">
+         <widget class="QComboBox" name="interpolation">
+          <property name="minimumSize">
+           <size>
+            <width>100</width>
+            <height>26</height>
+           </size>
+          </property>
+          <item>
+           <property name="text">
+            <string>linear</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>nearest</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>clough</string>
+           </property>
+          </item>
+         </widget>
+        </item>
+        <item row="5" column="1">
+         <widget class="QLabel" name="label_10">
+          <property name="text">
+           <string>Oversampling</string>
+          </property>
+         </widget>
+        </item>
+        <item row="3" column="1">
+         <widget class="QLabel" name="label_8">
+          <property name="maximumSize">
+           <size>
+            <width>16777215</width>
+            <height>50</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>Interpolation Method</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer">
+       <property name="orientation">
+        <enum>Qt::Orientation::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>16</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item alignment="Qt::AlignmentFlag::AlignRight">
+      <widget class="QGroupBox" name="groupBox_5">
+       <property name="title">
+        <string>General</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout_5">
+        <item row="2" column="1">
+         <widget class="QLabel" name="label_7">
+          <property name="maximumSize">
+           <size>
+            <width>16777215</width>
+            <height>50</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>Validate BEC</string>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="3" alignment="Qt::AlignmentFlag::AlignRight">
+         <widget class="ToggleSwitch" name="validate_bec"/>
+        </item>
+        <item row="3" column="3" alignment="Qt::AlignmentFlag::AlignRight">
+         <widget class="BECColorMapWidget" name="color_map">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="maximumSize">
+           <size>
+            <width>16777215</width>
+            <height>50</height>
+           </size>
+          </property>
+         </widget>
+        </item>
+        <item row="3" column="1">
+         <widget class="QLabel" name="label_11">
+          <property name="text">
+           <string>Colormap</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="Line" name="line">
+     <property name="orientation">
+      <enum>Qt::Orientation::Horizontal</enum>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QGroupBox" name="groupBox">
+       <property name="title">
+        <string>X Device</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout">
+        <item row="0" column="0">
+         <widget class="QLabel" name="label">
+          <property name="text">
+           <string>Name</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
+         <widget class="QLabel" name="label_2">
+          <property name="text">
+           <string>Signal</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
+         <widget class="DeviceComboBox" name="x_name">
+          <property name="editable">
+           <bool>true</bool>
+          </property>
+          <property name="set_first_element_as_empty" stdset="0">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
+         <widget class="SignalComboBox" name="x_entry">
+          <property name="editable">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="groupBox_2">
+       <property name="title">
+        <string>Y Device</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout_2">
+        <item row="0" column="0">
+         <widget class="QLabel" name="label_3">
+          <property name="text">
+           <string>Name</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
+         <widget class="QLabel" name="label_4">
+          <property name="text">
+           <string>Signal</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
+         <widget class="DeviceComboBox" name="y_name">
+          <property name="editable">
+           <bool>true</bool>
+          </property>
+          <property name="set_first_element_as_empty" stdset="0">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
+         <widget class="SignalComboBox" name="y_entry">
+          <property name="editable">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="groupBox_3">
+       <property name="title">
+        <string>Z Device</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout_3">
+        <item row="0" column="0">
+         <widget class="QLabel" name="label_5">
+          <property name="text">
+           <string>Name</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
+         <widget class="QLabel" name="label_6">
+          <property name="text">
+           <string>Signal</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
+         <widget class="DeviceComboBox" name="z_name">
+          <property name="editable">
+           <bool>true</bool>
+          </property>
+          <property name="set_first_element_as_empty" stdset="0">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
+         <widget class="SignalComboBox" name="z_entry">
+          <property name="editable">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>DeviceComboBox</class>
+   <extends>QComboBox</extends>
+   <header>device_combobox</header>
+  </customwidget>
+  <customwidget>
+   <class>SignalComboBox</class>
+   <extends>QComboBox</extends>
+   <header>signal_combo_box</header>
+  </customwidget>
+  <customwidget>
+   <class>ToggleSwitch</class>
+   <extends>QWidget</extends>
+   <header>toggle_switch</header>
+  </customwidget>
+  <customwidget>
+   <class>BECColorMapWidget</class>
+   <extends>QWidget</extends>
+   <header>bec_color_map_widget</header>
+  </customwidget>
+ </customwidgets>
+ <tabstops>
+  <tabstop>x_name</tabstop>
+  <tabstop>y_name</tabstop>
+  <tabstop>z_name</tabstop>
+  <tabstop>x_entry</tabstop>
+  <tabstop>y_entry</tabstop>
+  <tabstop>z_entry</tabstop>
+  <tabstop>interpolation</tabstop>
+  <tabstop>oversampling_factor</tabstop>
+ </tabstops>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>x_name</sender>
+   <signal>device_reset()</signal>
+   <receiver>x_entry</receiver>
+   <slot>reset_selection()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>254</x>
+     <y>226</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>254</x>
+     <y>267</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>x_name</sender>
+   <signal>currentTextChanged(QString)</signal>
+   <receiver>x_entry</receiver>
+   <slot>set_device(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>254</x>
+     <y>226</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>254</x>
+     <y>267</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>y_name</sender>
+   <signal>device_reset()</signal>
+   <receiver>y_entry</receiver>
+   <slot>reset_selection()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>526</x>
+     <y>226</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>526</x>
+     <y>267</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>y_name</sender>
+   <signal>currentTextChanged(QString)</signal>
+   <receiver>y_entry</receiver>
+   <slot>set_device(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>526</x>
+     <y>226</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>526</x>
+     <y>267</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>z_name</sender>
+   <signal>device_reset()</signal>
+   <receiver>z_entry</receiver>
+   <slot>reset_selection()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>798</x>
+     <y>226</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>798</x>
+     <y>267</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>z_name</sender>
+   <signal>currentTextChanged(QString)</signal>
+   <receiver>z_entry</receiver>
+   <slot>set_device(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>798</x>
+     <y>226</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>798</x>
+     <y>267</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

bec_widgets/widgets/plots/heatmap/settings/heatmap_settings_vertical.ui

@@ -0,0 +1,374 @@
+<?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>305</width>
+    <height>629</height>
+   </rect>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>16777215</width>
+    <height>629</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QPushButton" name="button_apply">
+     <property name="text">
+      <string>Apply</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="BECColorMapWidget" name="color_map"/>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QLabel" name="label_7">
+       <property name="text">
+        <string>Validate BEC</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="ToggleSwitch" name="validate_bec">
+       <property name="checked" stdset="0">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string>X Device</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout">
+      <item row="0" column="0">
+       <widget class="QLabel" name="label">
+        <property name="text">
+         <string>Name</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Signal</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="DeviceComboBox" name="x_name">
+        <property name="editable">
+         <bool>true</bool>
+        </property>
+        <property name="set_first_element_as_empty" stdset="0">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="SignalComboBox" name="x_entry">
+        <property name="editable">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="groupBox_2">
+     <property name="title">
+      <string>Y Device</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_3">
+        <property name="text">
+         <string>Name</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_4">
+        <property name="text">
+         <string>Signal</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="DeviceComboBox" name="y_name">
+        <property name="editable">
+         <bool>true</bool>
+        </property>
+        <property name="set_first_element_as_empty" stdset="0">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="SignalComboBox" name="y_entry">
+        <property name="editable">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="groupBox_3">
+     <property name="title">
+      <string>Z Device</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_3">
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_5">
+        <property name="text">
+         <string>Name</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="DeviceComboBox" name="z_name">
+        <property name="editable">
+         <bool>true</bool>
+        </property>
+        <property name="set_first_element_as_empty" stdset="0">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="SignalComboBox" name="z_entry">
+        <property name="editable">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_6">
+        <property name="text">
+         <string>Signal</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="Line" name="line">
+     <property name="orientation">
+      <enum>Qt::Orientation::Horizontal</enum>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="groupBox_4">
+     <property name="title">
+      <string>Interpolation</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_4">
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_8">
+        <property name="text">
+         <string>Interpolation Method</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QComboBox" name="interpolation">
+        <item>
+         <property name="text">
+          <string>linear</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>nearest</string>
+         </property>
+        </item>
+       </widget>
+      </item>
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_9">
+        <property name="text">
+         <string>Enforce Interpolation</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1" alignment="Qt::AlignmentFlag::AlignRight">
+       <widget class="ToggleSwitch" name="enforce_interpolation">
+        <property name="enabled">
+         <bool>true</bool>
+        </property>
+        <property name="checked" stdset="0">
+         <bool>false</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_10">
+        <property name="text">
+         <string>Oversampling</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QDoubleSpinBox" name="oversampling_factor">
+        <property name="minimum">
+         <double>1.000000000000000</double>
+        </property>
+        <property name="maximum">
+         <double>10.000000000000000</double>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>DeviceComboBox</class>
+   <extends>QComboBox</extends>
+   <header>device_combobox</header>
+  </customwidget>
+  <customwidget>
+   <class>SignalComboBox</class>
+   <extends>QComboBox</extends>
+   <header>signal_combo_box</header>
+  </customwidget>
+  <customwidget>
+   <class>ToggleSwitch</class>
+   <extends>QWidget</extends>
+   <header>toggle_switch</header>
+  </customwidget>
+  <customwidget>
+   <class>BECColorMapWidget</class>
+   <extends>QWidget</extends>
+   <header>bec_color_map_widget</header>
+  </customwidget>
+ </customwidgets>
+ <tabstops>
+  <tabstop>x_name</tabstop>
+  <tabstop>y_name</tabstop>
+  <tabstop>z_name</tabstop>
+  <tabstop>button_apply</tabstop>
+  <tabstop>x_entry</tabstop>
+  <tabstop>y_entry</tabstop>
+  <tabstop>z_entry</tabstop>
+ </tabstops>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>x_name</sender>
+   <signal>device_reset()</signal>
+   <receiver>x_entry</receiver>
+   <slot>reset_selection()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>113</x>
+     <y>178</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>110</x>
+     <y>183</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>x_name</sender>
+   <signal>currentTextChanged(QString)</signal>
+   <receiver>x_entry</receiver>
+   <slot>set_device(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>160</x>
+     <y>178</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>159</x>
+     <y>188</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>y_name</sender>
+   <signal>device_reset()</signal>
+   <receiver>y_entry</receiver>
+   <slot>reset_selection()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>92</x>
+     <y>278</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>92</x>
+     <y>287</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>y_name</sender>
+   <signal>currentTextChanged(QString)</signal>
+   <receiver>y_entry</receiver>
+   <slot>set_device(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>136</x>
+     <y>277</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>135</x>
+     <y>290</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>z_name</sender>
+   <signal>device_reset()</signal>
+   <receiver>z_entry</receiver>
+   <slot>reset_selection()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>106</x>
+     <y>376</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>112</x>
+     <y>397</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>z_name</sender>
+   <signal>currentTextChanged(QString)</signal>
+   <receiver>z_entry</receiver>
+   <slot>set_device(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>164</x>
+     <y>376</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>168</x>
+     <y>389</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

bec_widgets/widgets/plots/image/image_item.py

@@ -7,6 +7,7 @@ import pyqtgraph as pg
 from bec_lib.logger import bec_logger
 from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import Signal
+from qtpy.QtGui import QTransform
 
 from bec_widgets.utils import BECConnector, Colors, ConnectionConfig
 from bec_widgets.widgets.plots.image.image_processor import (
@@ -21,9 +22,6 @@ logger = bec_logger.logger
 # noinspection PyDataclass
 class ImageItemConfig(ConnectionConfig):  # TODO review config
     parent_id: str | None = Field(None, description="The parent plot of the image.")
-    monitor: str | None = Field(None, description="The name of the monitor.")
-    monitor_type: Literal["1d", "2d", "auto"] = Field("auto", description="The type of monitor.")
-    source: str | None = Field(None, description="The source of the curve.")
     color_map: str | None = Field("plasma", description="The color map of the image.")
     downsample: bool | None = Field(True, description="Whether to downsample the image.")
     opacity: float | None = Field(1.0, description="The opacity of the image.")
@@ -43,6 +41,7 @@ class ImageItemConfig(ConnectionConfig):  # TODO review config
 
 
 class ImageItem(BECConnector, pg.ImageItem):
+
     RPC = True
     USER_ACCESS = [
         "color_map",
@@ -69,12 +68,13 @@ class ImageItem(BECConnector, pg.ImageItem):
     ]
 
     vRangeChangedManually = Signal(tuple)
+    removed = Signal(str)
 
     def __init__(
         self,
         config: Optional[ImageItemConfig] = None,
         gui_id: Optional[str] = None,
-        parent_image=None,
+        parent_image=None,  # FIXME: rename to parent
         **kwargs,
     ):
         if config is None:
@@ -86,6 +86,7 @@ class ImageItem(BECConnector, pg.ImageItem):
             self.set_parent(parent_image)
         else:
             self.parent_image = None
+        self.image_transform = None
         super().__init__(config=config, gui_id=gui_id, **kwargs)
 
         self.raw_data = None
@@ -101,8 +102,9 @@ class ImageItem(BECConnector, pg.ImageItem):
     def parent(self):
         return self.parent_image
 
-    def set_data(self, data: np.ndarray):
+    def set_data(self, data: np.ndarray, transform: QTransform | None = None):
         self.raw_data = data
+        self.image_transform = transform
         self._process_image()
 
     ################################################################################
@@ -211,12 +213,19 @@ class ImageItem(BECConnector, pg.ImageItem):
         """
         Reprocess the current raw data and update the image display.
         """
-        if self.raw_data is not None:
-            autorange = self.config.autorange
-            self._image_processor.set_config(self.config.processing)
-            processed_data = self._image_processor.process_image(self.raw_data)
-            self.setImage(processed_data, autoLevels=False)
-            self.autorange = autorange
+        if self.raw_data is None:
+            return
+
+        if np.all(np.isnan(self.raw_data)):
+            return
+
+        autorange = self.config.autorange
+        self._image_processor.set_config(self.config.processing)
+        processed_data = self._image_processor.process_image(self.raw_data)
+        self.setImage(processed_data, autoLevels=False)
+        if self.image_transform is not None:
+            self.setTransform(self.image_transform)
+        self.autorange = autorange
 
     @property
     def fft(self) -> bool:
@@ -274,6 +283,8 @@ class ImageItem(BECConnector, pg.ImageItem):
         self.buffer = []
         self.max_len = 0
 
-    def remove(self):
-        self.parent().disconnect_monitor(self.config.monitor)
+    def remove(self, emit: bool = True):
         self.clear()
+        super().remove()
+        if emit:
+            self.removed.emit(self.objectName())

bec_widgets/widgets/plots/image/image_processor.py

@@ -27,7 +27,12 @@ class ImageStats:
         Returns:
             ImageStats: The statistics of the image data.
         """
-        return cls(maximum=np.max(data), minimum=np.min(data), mean=np.mean(data), std=np.std(data))
+        return cls(
+            maximum=np.nanmax(data),
+            minimum=np.nanmin(data),
+            mean=np.nanmean(data),
+            std=np.nanstd(data),
+        )
 
 
 # noinspection PyDataclass
@@ -81,7 +86,7 @@ class ImageProcessor(QObject):
         Returns:
             np.ndarray: The processed data.
         """
-        return np.abs(np.fft.fftshift(np.fft.fft2(data)))
+        return np.abs(np.fft.fftshift(np.fft.fft2(np.nan_to_num(data))))
 
     def rotation(self, data: np.ndarray, rotate_90: int) -> np.ndarray:
         """

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

@@ -3,11 +3,13 @@ from __future__ import annotations
 import math
 from typing import TYPE_CHECKING
 
+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.QtWidgets import (
     QColorDialog,
+    QHBoxLayout,
     QHeaderView,
     QSpinBox,
     QToolButton,
@@ -19,10 +21,13 @@ from qtpy.QtWidgets import (
 
 from bec_widgets import BECWidget
 from bec_widgets.utils import BECDispatcher, ConnectionConfig
-from bec_widgets.utils.toolbar import MaterialIconAction, ModularToolBar
+from bec_widgets.utils.toolbars.actions import WidgetAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle
+from bec_widgets.utils.toolbars.toolbar import MaterialIconAction, ModularToolBar
 from bec_widgets.widgets.plots.roi.image_roi import (
     BaseROI,
     CircularROI,
+    EllipticalROI,
     RectangularROI,
     ROIController,
 )
@@ -35,6 +40,31 @@ if TYPE_CHECKING:
     from bec_widgets.widgets.plots.image.image import Image
 
 
+logger = bec_logger.logger
+
+
+class ROILockButton(QToolButton):
+    """Keeps its icon and checked state in sync with a single ROI."""
+
+    def __init__(self, roi: BaseROI, parent=None):
+        super().__init__(parent)
+        self.setCheckable(True)
+        self._roi = roi
+        self.clicked.connect(self._toggle)
+        roi.movableChanged.connect(lambda _: self._sync())
+        self._sync()
+
+    def _toggle(self):
+        # checked -> locked -> movable = False
+        self._roi.movable = not self.isChecked()
+
+    def _sync(self):
+        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))
+
+
 class ROIPropertyTree(BECWidget, QWidget):
     """
     Two-column tree:  [ROI]  [Properties]
@@ -97,18 +127,41 @@ class ROIPropertyTree(BECWidget, QWidget):
 
     # --------------------------------------------------------------------- UI
     def _init_toolbar(self):
-        tb = ModularToolBar(self, self, orientation="horizontal")
+        tb = self.toolbar = ModularToolBar(self, orientation="horizontal")
+        self._draw_actions: dict[str, MaterialIconAction] = {}
         # --- ROI draw actions (toggleable) ---
-        self.add_rect_action = MaterialIconAction("add_box", "Add Rect ROI", True, self)
-        self.add_circle_action = MaterialIconAction("add_circle", "Add Circle ROI", True, self)
-        tb.add_action("Add Rect ROI", self.add_rect_action, self)
-        tb.add_action("Add Circle ROI", self.add_circle_action, self)
+
+        tb.components.add_safe(
+            "roi_rectangle",
+            MaterialIconAction("add_box", "Add Rect ROI", checkable=True, parent=self),
+        )
+        tb.components.add_safe(
+            "roi_circle",
+            MaterialIconAction("add_circle", "Add Circle ROI", checkable=True, parent=self),
+        )
+        tb.components.add_safe(
+            "roi_ellipse",
+            MaterialIconAction("vignette", "Add Ellipse ROI", checkable=True, parent=self),
+        )
+        bundle = ToolbarBundle("roi_draw", tb.components)
+        bundle.add_action("roi_rectangle")
+        bundle.add_action("roi_circle")
+        bundle.add_action("roi_ellipse")
+        tb.add_bundle(bundle)
+
+        self._draw_actions = {
+            "rect": tb.components.get_action("roi_rectangle"),
+            "circle": tb.components.get_action("roi_circle"),
+            "ellipse": tb.components.get_action("roi_ellipse"),
+        }
+        for mode, act in self._draw_actions.items():
+            act.action.toggled.connect(lambda on, m=mode: self._on_draw_action_toggled(m, on))
 
         # Expand/Collapse toggle
         self.expand_toggle = MaterialIconAction(
             "unfold_more", "Expand/Collapse", checkable=True, parent=self  # icon when collapsed
         )
-        tb.add_action("Expand/Collapse", self.expand_toggle, self)
+        tb.components.add_safe("expand_toggle", self.expand_toggle)
 
         def _exp_toggled(on: bool):
             if on:
@@ -124,26 +177,47 @@ class ROIPropertyTree(BECWidget, QWidget):
         self.expand_toggle.action.toggled.connect(_exp_toggled)
 
         self.expand_toggle.action.setChecked(False)
+
+        # Lock/Unlock all ROIs
+        self.lock_all_action = MaterialIconAction(
+            "lock_open_right", "Lock/Unlock all ROIs", checkable=True, parent=self
+        )
+        tb.components.add_safe("lock_unlock_all", self.lock_all_action)
+
+        def _lock_all(checked: bool):
+            # checked -> everything locked (movable = False)
+            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
+            )
+            self.lock_all_action.action.setIcon(new_icon)
+
+        self.lock_all_action.action.toggled.connect(_lock_all)
+
         # colormap widget
         self.cmap = BECColorMapWidget(cmap=self.controller.colormap)
-        tb.addWidget(QWidget())  # spacer
-        tb.addWidget(self.cmap)
+
+        tb.components.add_safe("roi_tree_spacer", WidgetAction(widget=QWidget()))
+        tb.components.add_safe("roi_tree_cmap", WidgetAction(widget=self.cmap))
+
         self.cmap.colormap_changed_signal.connect(self.controller.set_colormap)
         self.layout.addWidget(tb)
         self.controller.paletteChanged.connect(lambda cmap: setattr(self.cmap, "colormap", cmap))
 
+        bundle = ToolbarBundle("roi_tools", tb.components)
+        bundle.add_action("expand_toggle")
+        bundle.add_action("lock_unlock_all")
+        bundle.add_action("roi_tree_spacer")
+        bundle.add_action("roi_tree_cmap")
+        tb.add_bundle(bundle)
+
+        tb.show_bundles(["roi_draw", "roi_tools"])
+
         # ROI drawing state
-        self._roi_draw_mode = None  # 'rect' | 'circle' | None
+        self._roi_draw_mode = None  # 'rect' | 'circle' | 'ellipse' | None
         self._roi_start_pos = None  # QPointF in image coords
         self._temp_roi = None  # live ROI being resized while dragging
-
-        # toggle handlers
-        self.add_rect_action.action.toggled.connect(
-            lambda on: self._set_roi_draw_mode("rect" if on else None)
-        )
-        self.add_circle_action.action.toggled.connect(
-            lambda on: self._set_roi_draw_mode("circle" if on else None)
-        )
         # capture mouse events on the plot scene
         self.plot.scene().installEventFilter(self)
 
@@ -173,16 +247,12 @@ class ROIPropertyTree(BECWidget, QWidget):
         return str(value)
 
     def _set_roi_draw_mode(self, mode: str | None):
-        # Ensure only the selected action is toggled on
-        if mode == "rect":
-            self.add_rect_action.action.setChecked(True)
-            self.add_circle_action.action.setChecked(False)
-        elif mode == "circle":
-            self.add_rect_action.action.setChecked(False)
-            self.add_circle_action.action.setChecked(True)
-        else:
-            self.add_rect_action.action.setChecked(False)
-            self.add_circle_action.action.setChecked(False)
+        # Update toolbar actions so that only the selected mode is checked
+        for m, act in self._draw_actions.items():
+            act.action.blockSignals(True)
+            act.action.setChecked(m == mode)
+            act.action.blockSignals(False)
+
         self._roi_draw_mode = mode
         self._roi_start_pos = None
         # remove any unfinished temp ROI
@@ -190,6 +260,15 @@ class ROIPropertyTree(BECWidget, QWidget):
             self.plot.removeItem(self._temp_roi)
             self._temp_roi = None
 
+    def _on_draw_action_toggled(self, mode: str, checked: bool):
+        if checked:
+            # Activate selected mode
+            self._set_roi_draw_mode(mode)
+        else:
+            # If the active mode is being unchecked, clear mode
+            if self._roi_draw_mode == mode:
+                self._set_roi_draw_mode(None)
+
     def eventFilter(self, obj, event):
         if self._roi_draw_mode is None:
             return super().eventFilter(obj, event)
@@ -202,12 +281,18 @@ class ROIPropertyTree(BECWidget, QWidget):
                     parent_image=self.image_widget,
                     resize_handles=False,
                 )
-            if self._roi_draw_mode == "circle":
+            elif self._roi_draw_mode == "circle":
                 self._temp_roi = CircularROI(
                     pos=[self._roi_start_pos.x() - 2.5, self._roi_start_pos.y() - 2.5],
                     size=[5, 5],
                     parent_image=self.image_widget,
                 )
+            elif self._roi_draw_mode == "ellipse":
+                self._temp_roi = EllipticalROI(
+                    pos=[self._roi_start_pos.x() - 2.5, self._roi_start_pos.y() - 2.5],
+                    size=[5, 5],
+                    parent_image=self.image_widget,
+                )
             self.plot.addItem(self._temp_roi)
             return True
         elif event.type() == QEvent.GraphicsSceneMouseMove and self._temp_roi is not None:
@@ -217,13 +302,19 @@ class ROIPropertyTree(BECWidget, QWidget):
 
             if self._roi_draw_mode == "rect":
                 self._temp_roi.setSize([dx, dy])
-            if self._roi_draw_mode == "circle":
+            elif self._roi_draw_mode == "circle":
                 r = max(
                     1, math.hypot(dx, dy)
                 )  # radius never smaller than 1 for safety of handle mapping, otherwise SEGFAULT
                 d = 2 * r  # diameter
                 self._temp_roi.setPos(self._roi_start_pos.x() - r, self._roi_start_pos.y() - r)
                 self._temp_roi.setSize([d, d])
+            elif self._roi_draw_mode == "ellipse":
+                # Safeguard: enforce a minimum ellipse width/height of 2 px
+                min_dim = 2.0
+                w = dx if abs(dx) >= min_dim else math.copysign(min_dim, dx or 1.0)
+                h = dy if abs(dy) >= min_dim else math.copysign(min_dim, dy or 1.0)
+                self._temp_roi.setSize([w, h])
             return True
         elif (
             event.type() == QEvent.GraphicsSceneMouseRelease
@@ -235,18 +326,30 @@ class ROIPropertyTree(BECWidget, QWidget):
             self._temp_roi = None
             self._set_roi_draw_mode(None)
             # register via controller
-            final_roi.add_scale_handle()
             self.controller.add_roi(final_roi)
             return True
         return super().eventFilter(obj, event)
 
     # --------------------------------------------------------- controller slots
     def _on_roi_added(self, roi: BaseROI):
+        # check the global setting from the toolbar
+        if self.lock_all_action.action.isChecked():
+            roi.movable = False
         # parent row with blank action column, name in ROI column
         parent = QTreeWidgetItem(self.tree, ["", "", ""])
         parent.setText(self.COL_ROI, roi.label)
         parent.setFlags(parent.flags() | Qt.ItemIsEditable)
-        # --- delete button in actions column ---
+        # --- actions widget (lock/unlock + delete) ---
+        actions_widget = QWidget()
+        actions_layout = QHBoxLayout(actions_widget)
+        actions_layout.setContentsMargins(0, 0, 0, 0)
+        actions_layout.setSpacing(3)
+
+        # lock / unlock toggle
+        lock_btn = ROILockButton(roi, parent=self)
+        actions_layout.addWidget(lock_btn)
+
+        # delete button
         del_btn = QToolButton()
         delete_icon = material_icon(
             "delete",
@@ -256,12 +359,17 @@ class ROIPropertyTree(BECWidget, QWidget):
             color=self.DELETE_BUTTON_COLOR,
         )
         del_btn.setIcon(delete_icon)
-        self.tree.setItemWidget(parent, self.COL_ACTION, del_btn)
         del_btn.clicked.connect(lambda _=None, r=roi: self._delete_roi(r))
+        actions_layout.addWidget(del_btn)
+
+        # install composite widget into the tree
+        self.tree.setItemWidget(parent, self.COL_ACTION, actions_widget)
         # color button
         color_btn = ColorButtonNative(parent=self, color=roi.line_color)
         self.tree.setItemWidget(parent, self.COL_PROPS, color_btn)
-        color_btn.clicked.connect(lambda: self._pick_color(roi, color_btn))
+        color_btn.color_changed.connect(
+            lambda new_color, r=roi: setattr(r, "line_color", new_color)
+        )
 
         # child rows (3 columns: action, ROI, properties)
         QTreeWidgetItem(parent, ["", "Type", roi.__class__.__name__])
@@ -309,6 +417,12 @@ class ROIPropertyTree(BECWidget, QWidget):
         for c in range(3):
             self.tree.resizeColumnToContents(c)
 
+    def _toggle_movable(self, roi: BaseROI):
+        """
+        Toggle the `movable` property of the given ROI.
+        """
+        roi.movable = not roi.movable
+
     def _on_roi_removed(self, roi: BaseROI):
         item = self.roi_items.pop(roi, None)
         if item:
@@ -337,6 +451,18 @@ class ROIPropertyTree(BECWidget, QWidget):
     def cleanup(self):
         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:
+                    if isinstance(roi, RectangularROI):
+                        roi.edgesChanged.disconnect()
+                    else:
+                        roi.centerChanged.disconnect()
+                    roi.penChanged.disconnect()
+                    roi.nameChanged.disconnect()
+                except (RuntimeError, TypeError) as e:
+                    logger.error(f"Failed to disconnect roi qt signal: {e}")
+
         super().cleanup()
 
 
@@ -345,7 +471,7 @@ if __name__ == "__main__":  # pragma: no cover
     import sys
 
     import numpy as np
-    from qtpy.QtWidgets import QApplication, QHBoxLayout, QVBoxLayout
+    from qtpy.QtWidgets import QApplication
 
     from bec_widgets.widgets.plots.image.image import Image
 

bec_widgets/widgets/plots/image/toolbar_bundles/image_selection.py

@@ -1,60 +0,0 @@
-from bec_lib.device import ReadoutPriority
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import QComboBox, QStyledItemDelegate
-
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.toolbar import ToolbarBundle, WidgetAction
-from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
-from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
-
-
-class NoCheckDelegate(QStyledItemDelegate):
-    """To reduce space in combo boxes by removing the checkmark."""
-
-    def initStyleOption(self, option, index):
-        super().initStyleOption(option, index)
-        # Remove any check indicator
-        option.checkState = Qt.Unchecked
-
-
-class MonitorSelectionToolbarBundle(ToolbarBundle):
-    """
-    A bundle of actions for a toolbar that controls monitor selection on a plot.
-    """
-
-    def __init__(self, bundle_id="device_selection", target_widget=None, **kwargs):
-        super().__init__(bundle_id=bundle_id, actions=[], **kwargs)
-        self.target_widget = target_widget
-
-        # 1) Device combo box
-        self.device_combo_box = DeviceComboBox(
-            parent=self.target_widget,
-            device_filter=BECDeviceFilter.DEVICE,
-            readout_priority_filter=[ReadoutPriority.ASYNC],
-        )
-        self.device_combo_box.addItem("", None)
-        self.device_combo_box.setCurrentText("")
-        self.device_combo_box.setToolTip("Select Device")
-        self.device_combo_box.setFixedWidth(150)
-        self.device_combo_box.setItemDelegate(NoCheckDelegate(self.device_combo_box))
-
-        self.add_action("monitor", WidgetAction(widget=self.device_combo_box, adjust_size=False))
-
-        # 2) Dimension combo box
-        self.dim_combo_box = QComboBox(parent=self.target_widget)
-        self.dim_combo_box.addItems(["auto", "1d", "2d"])
-        self.dim_combo_box.setCurrentText("auto")
-        self.dim_combo_box.setToolTip("Monitor Dimension")
-        self.dim_combo_box.setFixedWidth(100)
-        self.dim_combo_box.setItemDelegate(NoCheckDelegate(self.dim_combo_box))
-
-        self.add_action("dim_combo", WidgetAction(widget=self.dim_combo_box, adjust_size=False))
-
-        # Connect slots, a device will be connected upon change of any combobox
-        self.device_combo_box.currentTextChanged.connect(lambda: self.connect_monitor())
-        self.dim_combo_box.currentTextChanged.connect(lambda: self.connect_monitor())
-
-    @SafeSlot()
-    def connect_monitor(self):
-        dim = self.dim_combo_box.currentText()
-        self.target_widget.image(monitor=self.device_combo_box.currentText(), monitor_type=dim)

bec_widgets/widgets/plots/image/toolbar_bundles/processing.py

@@ -1,92 +0,0 @@
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.toolbar import MaterialIconAction, ToolbarBundle
-
-
-class ImageProcessingToolbarBundle(ToolbarBundle):
-    """
-    A bundle of actions for a toolbar that controls processing of monitor.
-    """
-
-    def __init__(self, bundle_id="mouse_interaction", target_widget=None, **kwargs):
-        super().__init__(bundle_id=bundle_id, actions=[], **kwargs)
-        self.target_widget = target_widget
-
-        self.fft = MaterialIconAction(
-            icon_name="fft", tooltip="Toggle FFT", checkable=True, parent=self.target_widget
-        )
-        self.log = MaterialIconAction(
-            icon_name="log_scale", tooltip="Toggle Log", checkable=True, parent=self.target_widget
-        )
-        self.transpose = MaterialIconAction(
-            icon_name="transform",
-            tooltip="Transpose Image",
-            checkable=True,
-            parent=self.target_widget,
-        )
-        self.right = MaterialIconAction(
-            icon_name="rotate_right",
-            tooltip="Rotate image clockwise by 90 deg",
-            parent=self.target_widget,
-        )
-        self.left = MaterialIconAction(
-            icon_name="rotate_left",
-            tooltip="Rotate image counterclockwise by 90 deg",
-            parent=self.target_widget,
-        )
-        self.reset = MaterialIconAction(
-            icon_name="reset_settings", tooltip="Reset Image Settings", parent=self.target_widget
-        )
-
-        self.add_action("fft", self.fft)
-        self.add_action("log", self.log)
-        self.add_action("transpose", self.transpose)
-        self.add_action("rotate_right", self.right)
-        self.add_action("rotate_left", self.left)
-        self.add_action("reset", self.reset)
-
-        self.fft.action.triggered.connect(self.toggle_fft)
-        self.log.action.triggered.connect(self.toggle_log)
-        self.transpose.action.triggered.connect(self.toggle_transpose)
-        self.right.action.triggered.connect(self.rotate_right)
-        self.left.action.triggered.connect(self.rotate_left)
-        self.reset.action.triggered.connect(self.reset_settings)
-
-    @SafeSlot()
-    def toggle_fft(self):
-        checked = self.fft.action.isChecked()
-        self.target_widget.fft = checked
-
-    @SafeSlot()
-    def toggle_log(self):
-        checked = self.log.action.isChecked()
-        self.target_widget.log = checked
-
-    @SafeSlot()
-    def toggle_transpose(self):
-        checked = self.transpose.action.isChecked()
-        self.target_widget.transpose = checked
-
-    @SafeSlot()
-    def rotate_right(self):
-        if self.target_widget.num_rotation_90 is None:
-            return
-        rotation = (self.target_widget.num_rotation_90 - 1) % 4
-        self.target_widget.num_rotation_90 = rotation
-
-    @SafeSlot()
-    def rotate_left(self):
-        if self.target_widget.num_rotation_90 is None:
-            return
-        rotation = (self.target_widget.num_rotation_90 + 1) % 4
-        self.target_widget.num_rotation_90 = rotation
-
-    @SafeSlot()
-    def reset_settings(self):
-        self.target_widget.fft = False
-        self.target_widget.log = False
-        self.target_widget.transpose = False
-        self.target_widget.num_rotation_90 = 0
-
-        self.fft.action.setChecked(False)
-        self.log.action.setChecked(False)
-        self.transpose.action.setChecked(False)

bec_widgets/widgets/plots/image/toolbar_components/image_base_actions.py

@@ -0,0 +1,390 @@
+from __future__ import annotations
+
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.toolbars.actions import MaterialIconAction, SwitchableToolBarAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle, ToolbarComponents
+from bec_widgets.utils.toolbars.connections import BundleConnection
+
+
+def image_roi_bundle(components: ToolbarComponents) -> ToolbarBundle:
+    """
+    Creates a toolbar bundle for ROI and crosshair interaction.
+
+    Args:
+        components (ToolbarComponents): The components to be added to the bundle.
+
+    Returns:
+        ToolbarBundle: The ROI toolbar bundle.
+    """
+    components.add_safe(
+        "image_crosshair",
+        MaterialIconAction(
+            icon_name="point_scan",
+            tooltip="Show Crosshair",
+            checkable=True,
+            parent=components.toolbar,
+        ),
+    )
+    components.add_safe(
+        "image_crosshair_roi",
+        MaterialIconAction(
+            icon_name="my_location",
+            tooltip="Show Crosshair with ROI plots",
+            checkable=True,
+            parent=components.toolbar,
+        ),
+    )
+    components.add_safe(
+        "image_switch_crosshair",
+        SwitchableToolBarAction(
+            actions={
+                "crosshair": components.get_action_reference("image_crosshair")(),
+                "crosshair_roi": components.get_action_reference("image_crosshair_roi")(),
+            },
+            initial_action="crosshair",
+            tooltip="Crosshair",
+            checkable=True,
+            parent=components.toolbar,
+        ),
+    )
+    bundle = ToolbarBundle("image_crosshair", components)
+    bundle.add_action("image_switch_crosshair")
+    return bundle
+
+
+class ImageRoiConnection(BundleConnection):
+    """
+    Connection class for the ROI toolbar bundle.
+    """
+
+    def __init__(self, components: ToolbarComponents, target_widget=None):
+        self.bundle_name = "roi"
+        self.components = components
+        self.target_widget = target_widget
+        if not hasattr(self.target_widget, "toggle_roi_panels") or not hasattr(
+            self.target_widget, "toggle_crosshair"
+        ):
+            raise AttributeError(
+                "Target widget must implement 'toggle_roi_panels' and 'toggle_crosshair'."
+            )
+        super().__init__()
+        self._connected = False
+
+    def connect(self):
+        self._connected = True
+        # Connect the action to the target widget's method
+        self.components.get_action("image_crosshair").action.toggled.connect(
+            self.target_widget.toggle_crosshair
+        )
+        self.components.get_action("image_crosshair_roi").action.triggered.connect(
+            self.target_widget.toggle_roi_panels
+        )
+
+    def disconnect(self):
+        if not self._connected:
+            return
+        # Disconnect the action from the target widget's method
+        self.components.get_action("image_crosshair").action.toggled.disconnect(
+            self.target_widget.toggle_crosshair
+        )
+        self.components.get_action("image_crosshair_roi").action.triggered.disconnect(
+            self.target_widget.toggle_roi_panels
+        )
+
+
+def image_autorange(components: ToolbarComponents) -> ToolbarBundle:
+    """
+    Creates a toolbar bundle for image autorange functionality.
+
+    Args:
+        components (ToolbarComponents): The components to be added to the bundle.
+
+    Returns:
+        ToolbarBundle: The autorange toolbar bundle.
+    """
+    components.add_safe(
+        "image_autorange_mean",
+        MaterialIconAction(
+            icon_name="hdr_auto",
+            tooltip="Enable Auto Range (Mean)",
+            checkable=True,
+            parent=components.toolbar,
+        ),
+    )
+    components.add_safe(
+        "image_autorange_max",
+        MaterialIconAction(
+            icon_name="hdr_auto",
+            tooltip="Enable Auto Range (Max)",
+            checkable=True,
+            parent=components.toolbar,
+            filled=True,
+        ),
+    )
+    components.add_safe(
+        "image_autorange",
+        SwitchableToolBarAction(
+            actions={
+                "mean": components.get_action_reference("image_autorange_mean")(),
+                "max": components.get_action_reference("image_autorange_max")(),
+            },
+            initial_action="mean",
+            tooltip="Autorange",
+            checkable=True,
+            parent=components.toolbar,
+            default_state_checked=True,
+        ),
+    )
+    bundle = ToolbarBundle("image_autorange", components)
+    bundle.add_action("image_autorange")
+    return bundle
+
+
+def image_colorbar(components: ToolbarComponents) -> ToolbarBundle:
+    """
+    Creates a toolbar bundle for image colorbar functionality.
+
+    Args:
+        components (ToolbarComponents): The components to be added to the bundle.
+
+    Returns:
+        ToolbarBundle: The colorbar toolbar bundle.
+    """
+    components.add_safe(
+        "image_full_colorbar",
+        MaterialIconAction(
+            icon_name="edgesensor_low",
+            tooltip="Enable Full Colorbar",
+            checkable=True,
+            parent=components.toolbar,
+        ),
+    )
+    components.add_safe(
+        "image_simple_colorbar",
+        MaterialIconAction(
+            icon_name="smartphone",
+            tooltip="Enable Simple Colorbar",
+            checkable=True,
+            parent=components.toolbar,
+        ),
+    )
+    components.add_safe(
+        "image_colorbar_switch",
+        SwitchableToolBarAction(
+            actions={
+                "full_colorbar": components.get_action_reference("image_full_colorbar")(),
+                "simple_colorbar": components.get_action_reference("image_simple_colorbar")(),
+            },
+            initial_action="full_colorbar",
+            tooltip="Colorbar",
+            checkable=True,
+            parent=components.toolbar,
+        ),
+    )
+    bundle = ToolbarBundle("image_colorbar", components)
+    bundle.add_action("image_colorbar_switch")
+    return bundle
+
+
+class ImageColorbarConnection(BundleConnection):
+    """
+    Connection class for the image colorbar toolbar bundle.
+    """
+
+    def __init__(self, components: ToolbarComponents, target_widget=None):
+        self.bundle_name = "image_colorbar"
+        self.components = components
+        self.target_widget = target_widget
+        if not hasattr(self.target_widget, "enable_colorbar"):
+            raise AttributeError("Target widget must implement 'enable_colorbar' method.")
+        super().__init__()
+        self._connected = False
+
+    def _enable_full_colorbar(self, checked: bool):
+        """
+        Enable or disable the full colorbar based on the checked state.
+        """
+        self.target_widget.enable_colorbar(checked, style="full")
+
+    def _enable_simple_colorbar(self, checked: bool):
+        """
+        Enable or disable the simple colorbar based on the checked state.
+        """
+        self.target_widget.enable_colorbar(checked, style="simple")
+
+    def connect(self):
+        self._connected = True
+        # Connect the action to the target widget's method
+        self.components.get_action("image_full_colorbar").action.toggled.connect(
+            self._enable_full_colorbar
+        )
+        self.components.get_action("image_simple_colorbar").action.toggled.connect(
+            self._enable_simple_colorbar
+        )
+
+    def disconnect(self):
+        if not self._connected:
+            return
+        # Disconnect the action from the target widget's method
+        self.components.get_action("image_full_colorbar").action.toggled.disconnect(
+            self._enable_full_colorbar
+        )
+        self.components.get_action("image_simple_colorbar").action.toggled.disconnect(
+            self._enable_simple_colorbar
+        )
+
+
+def image_processing(components: ToolbarComponents) -> ToolbarBundle:
+    """
+    Creates a toolbar bundle for image processing functionality.
+
+    Args:
+        components (ToolbarComponents): The components to be added to the bundle.
+
+    Returns:
+        ToolbarBundle: The image processing toolbar bundle.
+    """
+    components.add_safe(
+        "image_processing_fft",
+        MaterialIconAction(
+            icon_name="fft", tooltip="Toggle FFT", checkable=True, parent=components.toolbar
+        ),
+    )
+    components.add_safe(
+        "image_processing_log",
+        MaterialIconAction(
+            icon_name="log_scale", tooltip="Toggle Log", checkable=True, parent=components.toolbar
+        ),
+    )
+    components.add_safe(
+        "image_processing_transpose",
+        MaterialIconAction(
+            icon_name="transform",
+            tooltip="Transpose Image",
+            checkable=True,
+            parent=components.toolbar,
+        ),
+    )
+    components.add_safe(
+        "image_processing_rotate_right",
+        MaterialIconAction(
+            icon_name="rotate_right",
+            tooltip="Rotate image clockwise by 90 deg",
+            parent=components.toolbar,
+        ),
+    )
+    components.add_safe(
+        "image_processing_rotate_left",
+        MaterialIconAction(
+            icon_name="rotate_left",
+            tooltip="Rotate image counterclockwise by 90 deg",
+            parent=components.toolbar,
+        ),
+    )
+    components.add_safe(
+        "image_processing_reset",
+        MaterialIconAction(
+            icon_name="reset_settings", tooltip="Reset Image Settings", parent=components.toolbar
+        ),
+    )
+    bundle = ToolbarBundle("image_processing", components)
+    bundle.add_action("image_processing_fft")
+    bundle.add_action("image_processing_log")
+    bundle.add_action("image_processing_transpose")
+    bundle.add_action("image_processing_rotate_right")
+    bundle.add_action("image_processing_rotate_left")
+    bundle.add_action("image_processing_reset")
+    return bundle
+
+
+class ImageProcessingConnection(BundleConnection):
+    """
+    Connection class for the image processing toolbar bundle.
+    """
+
+    def __init__(self, components: ToolbarComponents, target_widget=None):
+        self.bundle_name = "image_processing"
+        self.components = components
+        self.target_widget = target_widget
+        if (
+            not hasattr(self.target_widget, "fft")
+            or not hasattr(self.target_widget, "log")
+            or not hasattr(self.target_widget, "transpose")
+            or not hasattr(self.target_widget, "num_rotation_90")
+        ):
+            raise AttributeError(
+                "Target widget must implement 'fft', 'log', 'transpose', and 'num_rotation_90' attributes."
+            )
+        super().__init__()
+        self.fft = components.get_action("image_processing_fft")
+        self.log = components.get_action("image_processing_log")
+        self.transpose = components.get_action("image_processing_transpose")
+        self.right = components.get_action("image_processing_rotate_right")
+        self.left = components.get_action("image_processing_rotate_left")
+        self.reset = components.get_action("image_processing_reset")
+        self._connected = False
+
+    @SafeSlot()
+    def toggle_fft(self):
+        checked = self.fft.action.isChecked()
+        self.target_widget.fft = checked
+
+    @SafeSlot()
+    def toggle_log(self):
+        checked = self.log.action.isChecked()
+        self.target_widget.log = checked
+
+    @SafeSlot()
+    def toggle_transpose(self):
+        checked = self.transpose.action.isChecked()
+        self.target_widget.transpose = checked
+
+    @SafeSlot()
+    def rotate_right(self):
+        if self.target_widget.num_rotation_90 is None:
+            return
+        rotation = (self.target_widget.num_rotation_90 - 1) % 4
+        self.target_widget.num_rotation_90 = rotation
+
+    @SafeSlot()
+    def rotate_left(self):
+        if self.target_widget.num_rotation_90 is None:
+            return
+        rotation = (self.target_widget.num_rotation_90 + 1) % 4
+        self.target_widget.num_rotation_90 = rotation
+
+    @SafeSlot()
+    def reset_settings(self):
+        self.target_widget.fft = False
+        self.target_widget.log = False
+        self.target_widget.transpose = False
+        self.target_widget.num_rotation_90 = 0
+
+        self.fft.action.setChecked(False)
+        self.log.action.setChecked(False)
+        self.transpose.action.setChecked(False)
+
+    def connect(self):
+        """
+        Connect the actions to the target widget's methods.
+        """
+        self._connected = True
+        self.fft.action.triggered.connect(self.toggle_fft)
+        self.log.action.triggered.connect(self.toggle_log)
+        self.transpose.action.triggered.connect(self.toggle_transpose)
+        self.right.action.triggered.connect(self.rotate_right)
+        self.left.action.triggered.connect(self.rotate_left)
+        self.reset.action.triggered.connect(self.reset_settings)
+
+    def disconnect(self):
+        """
+        Disconnect the actions from the target widget's methods.
+        """
+        if not self._connected:
+            return
+        self.fft.action.triggered.disconnect(self.toggle_fft)
+        self.log.action.triggered.disconnect(self.toggle_log)
+        self.transpose.action.triggered.disconnect(self.toggle_transpose)
+        self.right.action.triggered.disconnect(self.rotate_right)
+        self.left.action.triggered.disconnect(self.rotate_left)
+        self.reset.action.triggered.disconnect(self.reset_settings)

bec_widgets/widgets/plots/motor_map/motor_map.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import numpy as np
 import pyqtgraph as pg
 from bec_lib import bec_logger
 from bec_lib.endpoints import MessageEndpoints
@@ -15,12 +14,12 @@ from bec_widgets.utils import Colors, ConnectionConfig
 from bec_widgets.utils.colors import set_theme
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.settings_dialog import SettingsDialog
-from bec_widgets.utils.toolbar import MaterialIconAction
+from bec_widgets.utils.toolbars.toolbar import MaterialIconAction
 from bec_widgets.widgets.plots.motor_map.settings.motor_map_settings import MotorMapSettings
-from bec_widgets.widgets.plots.motor_map.toolbar_bundles.motor_selection import (
-    MotorSelectionToolbarBundle,
+from bec_widgets.widgets.plots.motor_map.toolbar_components.motor_selection import (
+    MotorSelectionAction,
 )
-from bec_widgets.widgets.plots.plot_base import PlotBase
+from bec_widgets.widgets.plots.plot_base import PlotBase, UIMode
 
 logger = bec_logger.logger
 
@@ -182,33 +181,60 @@ class MotorMap(PlotBase):
         self.proxy_update_plot = pg.SignalProxy(
             self.update_signal, rateLimit=25, slot=self._update_plot
         )
+        self._init_motor_map_toolbar()
         self._add_motor_map_settings()
 
     ################################################################################
     # Widget Specific GUI interactions
     ################################################################################
 
-    def _init_toolbar(self):
+    def _init_motor_map_toolbar(self):
         """
         Initialize the toolbar for the motor map widget.
         """
-        self.motor_selection_bundle = MotorSelectionToolbarBundle(
-            bundle_id="motor_selection", target_widget=self
-        )
-        self.toolbar.add_bundle(self.motor_selection_bundle, target_widget=self)
-        super()._init_toolbar()
-        self.toolbar.widgets["reset_legend"].action.setVisible(False)
+        motor_selection = MotorSelectionAction(parent=self)
+        self.toolbar.add_action("motor_selection", motor_selection)
 
-        self.reset_legend_action = MaterialIconAction(
-            icon_name="history", tooltip="Reset the position of legend."
+        motor_selection.motor_x.currentTextChanged.connect(self.on_motor_selection_changed)
+        motor_selection.motor_y.currentTextChanged.connect(self.on_motor_selection_changed)
+
+        self.toolbar.components.get_action("reset_legend").action.setVisible(False)
+
+        reset_legend = MaterialIconAction(
+            icon_name="history",
+            tooltip="Reset the position of legend.",
+            checkable=False,
+            parent=self,
         )
-        self.toolbar.add_action_to_bundle(
-            bundle_id="roi",
-            action_id="motor_map_history",
-            action=self.reset_legend_action,
-            target_widget=self,
+        self.toolbar.components.add_safe("reset_motor_map_legend", reset_legend)
+        self.toolbar.get_bundle("roi").add_action("reset_motor_map_legend")
+        reset_legend.action.triggered.connect(self.reset_history)
+
+        settings_brightness = MaterialIconAction(
+            icon_name="settings_brightness",
+            tooltip="Show Motor Map Settings",
+            checkable=True,
+            parent=self,
         )
-        self.reset_legend_action.action.triggered.connect(self.reset_history)
+        self.toolbar.components.add_safe("motor_map_settings", settings_brightness)
+        self.toolbar.get_bundle("axis_popup").add_action("motor_map_settings")
+
+        settings_brightness.action.triggered.connect(self.show_motor_map_settings)
+
+        bundles = ["motor_selection", "plot_export", "mouse_interaction", "roi"]
+        if self.ui_mode == UIMode.POPUP:
+            bundles.append("axis_popup")
+        self.toolbar.show_bundles(bundles)
+
+    @SafeSlot()
+    def on_motor_selection_changed(self, _):
+        action: MotorSelectionAction = self.toolbar.components.get_action("motor_selection")
+        motor_x = action.motor_x.currentText()
+        motor_y = action.motor_y.currentText()
+
+        if motor_x != "" and motor_y != "":
+            if motor_x != self.config.x_motor.name or motor_y != self.config.y_motor.name:
+                self.map(motor_x, motor_y)
 
     def _add_motor_map_settings(self):
         """Add the motor map settings to the side panel."""
@@ -221,32 +247,11 @@ class MotorMap(PlotBase):
             title="Motor Map Settings",
         )
 
-    def add_popups(self):
-        """
-        Add popups to the ScatterWaveform widget.
-        """
-        super().add_popups()
-        scatter_curve_setting_action = MaterialIconAction(
-            icon_name="settings_brightness",
-            tooltip="Show Motor Map Settings",
-            checkable=True,
-            parent=self,
-        )
-        self.toolbar.add_action_to_bundle(
-            bundle_id="popup_bundle",
-            action_id="motor_map_settings",
-            action=scatter_curve_setting_action,
-            target_widget=self,
-        )
-        self.toolbar.widgets["motor_map_settings"].action.triggered.connect(
-            self.show_motor_map_settings
-        )
-
     def show_motor_map_settings(self):
         """
         Show the DAP summary popup.
         """
-        action = self.toolbar.widgets["motor_map_settings"].action
+        action = self.toolbar.components.get_action("motor_map_settings").action
         if self.motor_map_settings is None or not self.motor_map_settings.isVisible():
             motor_map_settings = MotorMapSettings(parent=self, target_widget=self, popup=True)
             self.motor_map_settings = SettingsDialog(
@@ -272,7 +277,7 @@ class MotorMap(PlotBase):
         """
         self.motor_map_settings.deleteLater()
         self.motor_map_settings = None
-        self.toolbar.widgets["motor_map_settings"].action.setChecked(False)
+        self.toolbar.components.get_action("motor_map_settings").action.setChecked(False)
 
     ################################################################################
     # Widget Specific Properties
@@ -766,20 +771,21 @@ class MotorMap(PlotBase):
         """
         Sync the motor map selection toolbar with the current motor map.
         """
-        if self.motor_selection_bundle is not None:
-            motor_x = self.motor_selection_bundle.motor_x.currentText()
-            motor_y = self.motor_selection_bundle.motor_y.currentText()
+        motor_selection = self.toolbar.components.get_action("motor_selection")
 
-            if motor_x != self.config.x_motor.name:
-                self.motor_selection_bundle.motor_x.blockSignals(True)
-                self.motor_selection_bundle.motor_x.set_device(self.config.x_motor.name)
-                self.motor_selection_bundle.motor_x.check_validity(self.config.x_motor.name)
-                self.motor_selection_bundle.motor_x.blockSignals(False)
-            if motor_y != self.config.y_motor.name:
-                self.motor_selection_bundle.motor_y.blockSignals(True)
-                self.motor_selection_bundle.motor_y.set_device(self.config.y_motor.name)
-                self.motor_selection_bundle.motor_y.check_validity(self.config.y_motor.name)
-                self.motor_selection_bundle.motor_y.blockSignals(False)
+        motor_x = motor_selection.motor_x.currentText()
+        motor_y = motor_selection.motor_y.currentText()
+
+        if motor_x != self.config.x_motor.name:
+            motor_selection.motor_x.blockSignals(True)
+            motor_selection.motor_x.set_device(self.config.x_motor.name)
+            motor_selection.motor_x.check_validity(self.config.x_motor.name)
+            motor_selection.motor_x.blockSignals(False)
+        if motor_y != self.config.y_motor.name:
+            motor_selection.motor_y.blockSignals(True)
+            motor_selection.motor_y.set_device(self.config.y_motor.name)
+            motor_selection.motor_y.check_validity(self.config.y_motor.name)
+            motor_selection.motor_y.blockSignals(False)
 
     ################################################################################
     # Export Methods
@@ -795,10 +801,6 @@ class MotorMap(PlotBase):
         data = {"x": self._buffer["x"], "y": self._buffer["y"]}
         return data
 
-    def cleanup(self):
-        self.motor_selection_bundle.cleanup()
-        super().cleanup()
-
 
 class DemoApp(QMainWindow):  # pragma: no cover
     def __init__(self):

bec_widgets/widgets/plots/motor_map/toolbar_bundles/motor_selection.py

@@ -1,70 +0,0 @@
-from bec_lib.device import ReadoutPriority
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import QStyledItemDelegate
-
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.toolbar import ToolbarBundle, WidgetAction
-from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
-from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
-
-
-class NoCheckDelegate(QStyledItemDelegate):
-    """To reduce space in combo boxes by removing the checkmark."""
-
-    def initStyleOption(self, option, index):
-        super().initStyleOption(option, index)
-        # Remove any check indicator
-        option.checkState = Qt.Unchecked
-
-
-class MotorSelectionToolbarBundle(ToolbarBundle):
-    """
-    A bundle of actions for a toolbar that selects motors.
-    """
-
-    def __init__(self, bundle_id="motor_selection", target_widget=None, **kwargs):
-        super().__init__(bundle_id=bundle_id, actions=[], **kwargs)
-        self.target_widget = target_widget
-
-        # Motor X
-        self.motor_x = DeviceComboBox(
-            parent=self.target_widget, device_filter=[BECDeviceFilter.POSITIONER]
-        )
-        self.motor_x.addItem("", None)
-        self.motor_x.setCurrentText("")
-        self.motor_x.setToolTip("Select Motor X")
-        self.motor_x.setItemDelegate(NoCheckDelegate(self.motor_x))
-
-        # Motor X
-        self.motor_y = DeviceComboBox(
-            parent=self.target_widget, device_filter=[BECDeviceFilter.POSITIONER]
-        )
-        self.motor_y.addItem("", None)
-        self.motor_y.setCurrentText("")
-        self.motor_y.setToolTip("Select Motor Y")
-        self.motor_y.setItemDelegate(NoCheckDelegate(self.motor_y))
-
-        self.add_action("motor_x", WidgetAction(widget=self.motor_x, adjust_size=False))
-        self.add_action("motor_y", WidgetAction(widget=self.motor_y, adjust_size=False))
-
-        # Connect slots, a device will be connected upon change of any combobox
-        self.motor_x.currentTextChanged.connect(lambda: self.connect_motors())
-        self.motor_y.currentTextChanged.connect(lambda: self.connect_motors())
-
-    @SafeSlot()
-    def connect_motors(self):
-        motor_x = self.motor_x.currentText()
-        motor_y = self.motor_y.currentText()
-
-        if motor_x != "" and motor_y != "":
-            if (
-                motor_x != self.target_widget.config.x_motor.name
-                or motor_y != self.target_widget.config.y_motor.name
-            ):
-                self.target_widget.map(motor_x, motor_y)
-
-    def cleanup(self):
-        self.motor_x.close()
-        self.motor_x.deleteLater()
-        self.motor_y.close()
-        self.motor_y.deleteLater()

bec_widgets/widgets/plots/motor_map/toolbar_components/motor_selection.py

@@ -0,0 +1,51 @@
+from qtpy.QtWidgets import QHBoxLayout, QToolBar, QWidget
+
+from bec_widgets.utils.toolbars.actions import NoCheckDelegate, ToolBarAction
+from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
+from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
+
+
+class MotorSelectionAction(ToolBarAction):
+    def __init__(self, parent=None):
+        super().__init__(icon_path=None, tooltip=None, checkable=False)
+        self.motor_x = DeviceComboBox(parent=parent, device_filter=[BECDeviceFilter.POSITIONER])
+        self.motor_x.addItem("", None)
+        self.motor_x.setCurrentText("")
+        self.motor_x.setToolTip("Select Motor X")
+        self.motor_x.setItemDelegate(NoCheckDelegate(self.motor_x))
+        self.motor_y = DeviceComboBox(parent=parent, device_filter=[BECDeviceFilter.POSITIONER])
+        self.motor_y.addItem("", None)
+        self.motor_y.setCurrentText("")
+        self.motor_y.setToolTip("Select Motor Y")
+        self.motor_y.setItemDelegate(NoCheckDelegate(self.motor_y))
+
+        self.container = QWidget(parent)
+        layout = QHBoxLayout(self.container)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        layout.addWidget(self.motor_x)
+        layout.addWidget(self.motor_y)
+        self.container.setLayout(layout)
+        self.action = self.container
+
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        """
+        Adds the widget to the toolbar.
+
+        Args:
+            toolbar (QToolBar): The toolbar to add the widget to.
+            target (QWidget): The target widget for the action.
+        """
+
+        toolbar.addWidget(self.container)
+
+    def cleanup(self):
+        """
+        Cleans up the action, if necessary.
+        """
+        self.motor_x.close()
+        self.motor_x.deleteLater()
+        self.motor_y.close()
+        self.motor_y.deleteLater()
+        self.container.close()
+        self.container.deleteLater()

bec_widgets/widgets/plots/multi_waveform/multi_waveform.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from collections import deque
+from typing import TYPE_CHECKING, cast
 
 import pyqtgraph as pg
 from bec_lib.endpoints import MessageEndpoints
@@ -12,13 +13,15 @@ from qtpy.QtWidgets import QWidget
 from bec_widgets.utils import Colors, ConnectionConfig
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.side_panel import SidePanel
+from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.plots.multi_waveform.settings.control_panel import (
     MultiWaveformControlPanel,
 )
-from bec_widgets.widgets.plots.multi_waveform.toolbar_bundles.monitor_selection import (
-    MultiWaveformSelectionToolbarBundle,
+from bec_widgets.widgets.plots.multi_waveform.toolbar_components.monitor_selection import (
+    monitor_selection_bundle,
 )
 from bec_widgets.widgets.plots.plot_base import PlotBase
+from bec_widgets.widgets.utility.visual.colormap_widget.colormap_widget import BECColorMapWidget
 
 logger = bec_logger.logger
 
@@ -91,6 +94,8 @@ class MultiWaveform(PlotBase):
         "y_log.setter",
         "legend_label_size",
         "legend_label_size.setter",
+        "minimal_crosshair_precision",
+        "minimal_crosshair_precision.setter",
         # MultiWaveform Specific RPC Access
         "highlighted_index",
         "highlighted_index.setter",
@@ -139,33 +144,54 @@ class MultiWaveform(PlotBase):
         self.visible_curves = []
         self.number_of_visible_curves = 0
 
-        self._init_control_panel()
+        self._init_multiwaveform_toolbar()
 
     ################################################################################
     # Widget Specific GUI interactions
     ################################################################################
-    def _init_toolbar(self):
-        self.monitor_selection_bundle = MultiWaveformSelectionToolbarBundle(
-            bundle_id="motor_selection", target_widget=self
+    def _init_multiwaveform_toolbar(self):
+        self.toolbar.add_bundle(
+            monitor_selection_bundle(self.toolbar.components, target_widget=self)
         )
-        self.toolbar.add_bundle(self.monitor_selection_bundle, target_widget=self)
-        super()._init_toolbar()
-        self.toolbar.widgets["reset_legend"].action.setVisible(False)
+        self.toolbar.toggle_action_visibility("reset_legend", visible=False)
+
+        combobox = self.toolbar.components.get_action("monitor_selection").widget
+        combobox.currentTextChanged.connect(self.connect_monitor)
+
+        cmap = self.toolbar.components.get_action("color_map").widget
+        cmap.colormap_changed_signal.connect(self.change_colormap)
+
+        bundles = self.toolbar.shown_bundles
+        bundles.insert(0, "monitor_selection")
+        self.toolbar.show_bundles(bundles)
+
+        self._init_control_panel()
 
     def _init_control_panel(self):
-        self.control_panel = SidePanel(self, orientation="top", panel_max_width=90)
-        self.layout_manager.add_widget_relative(
-            self.control_panel, self.round_plot_widget, "bottom"
-        )
+        control_panel = SidePanel(self, orientation="top", panel_max_width=90)
+        self.layout_manager.add_widget_relative(control_panel, self.round_plot_widget, "bottom")
         self.controls = MultiWaveformControlPanel(parent=self, target_widget=self)
-        self.control_panel.add_menu(
+        control_panel.add_menu(
             action_id="control",
             icon_name="tune",
             tooltip="Show Control panel",
             widget=self.controls,
             title=None,
         )
-        self.control_panel.toolbar.widgets["control"].action.trigger()
+        control_panel.toolbar.components.get_action("control").action.trigger()
+
+    @SafeSlot()
+    def connect_monitor(self, _):
+        combobox = self.toolbar.components.get_action("monitor_selection").widget
+        monitor = combobox.currentText()
+
+        if monitor != "":
+            if monitor != self.config.monitor:
+                self.config.monitor = monitor
+
+    @SafeSlot(str)
+    def change_colormap(self, colormap: str):
+        self.color_palette = colormap
 
     ################################################################################
     # Widget Specific Properties
@@ -486,23 +512,30 @@ class MultiWaveform(PlotBase):
         """
         Sync the motor map selection toolbar with the current motor map.
         """
-        if self.monitor_selection_bundle is not None:
-            monitor = self.monitor_selection_bundle.monitor.currentText()
-            color_palette = self.monitor_selection_bundle.colormap_widget.colormap
 
-            if monitor != self.config.monitor:
-                self.monitor_selection_bundle.monitor.blockSignals(True)
-                self.monitor_selection_bundle.monitor.set_device(self.config.monitor)
-                self.monitor_selection_bundle.monitor.check_validity(self.config.monitor)
-                self.monitor_selection_bundle.monitor.blockSignals(False)
+        combobox_widget: DeviceComboBox = cast(
+            DeviceComboBox, self.toolbar.components.get_action("monitor_selection").widget
+        )
+        cmap_widget: BECColorMapWidget = cast(
+            BECColorMapWidget, self.toolbar.components.get_action("color_map").widget
+        )
 
-            if color_palette != self.config.color_palette:
-                self.monitor_selection_bundle.colormap_widget.blockSignals(True)
-                self.monitor_selection_bundle.colormap_widget.colormap = self.config.color_palette
-                self.monitor_selection_bundle.colormap_widget.blockSignals(False)
+        monitor = combobox_widget.currentText()
+        color_palette = cmap_widget.colormap
+
+        if monitor != self.config.monitor:
+            combobox_widget.setCurrentText(monitor)
+            combobox_widget.blockSignals(True)
+            combobox_widget.set_device(self.config.monitor)
+            combobox_widget.check_validity(self.config.monitor)
+            combobox_widget.blockSignals(False)
+
+        if color_palette != self.config.color_palette:
+            cmap_widget.blockSignals(True)
+            cmap_widget.colormap = self.config.color_palette
+            cmap_widget.blockSignals(False)
 
     def cleanup(self):
         self._disconnect_monitor()
         self.clear_curves()
-        self.monitor_selection_bundle.cleanup()
         super().cleanup()

bec_widgets/widgets/plots/multi_waveform/toolbar_components/monitor_selection.py

@@ -1,9 +1,11 @@
 from bec_lib.device import ReadoutPriority
 from qtpy.QtCore import Qt
-from qtpy.QtWidgets import QStyledItemDelegate
+from qtpy.QtWidgets import QStyledItemDelegate, QWidget
 
 from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.toolbar import ToolbarBundle, WidgetAction
+from bec_widgets.utils.toolbars.actions import DeviceComboBoxAction, WidgetAction
+from bec_widgets.utils.toolbars.bundles import ToolbarComponents
+from bec_widgets.utils.toolbars.toolbar import ToolbarBundle
 from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.utility.visual.colormap_widget.colormap_widget import BECColorMapWidget
@@ -18,6 +20,37 @@ class NoCheckDelegate(QStyledItemDelegate):
         option.checkState = Qt.Unchecked
 
 
+def monitor_selection_bundle(
+    components: ToolbarComponents, target_widget: QWidget
+) -> ToolbarBundle:
+    """
+    Creates a monitor selection toolbar bundle.
+
+    Args:
+        components (ToolbarComponents): The components to be added to the bundle.
+
+    Returns:
+        ToolbarBundle: The monitor selection toolbar bundle.
+    """
+    components.add_safe(
+        "monitor_selection",
+        DeviceComboBoxAction(
+            target_widget=target_widget,
+            device_filter=[BECDeviceFilter.DEVICE],
+            readout_priority_filter=ReadoutPriority.ASYNC,
+            add_empty_item=True,
+            no_check_delegate=True,
+        ),
+    )
+    components.add_safe(
+        "color_map", WidgetAction(widget=BECColorMapWidget(cmap="plasma"), adjust_size=False)
+    )
+    bundle = ToolbarBundle("monitor_selection", components)
+    bundle.add_action("monitor_selection")
+    bundle.add_action("color_map")
+    return bundle
+
+
 class MultiWaveformSelectionToolbarBundle(ToolbarBundle):
     """
     A bundle of actions for a toolbar that selects motors.

bec_widgets/widgets/plots/plot_base.py

@@ -14,17 +14,25 @@ from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.fps_counter import FPSCounter
 from bec_widgets.utils.plot_indicator_items import BECArrowItem, BECTickItem
 from bec_widgets.utils.round_frame import RoundedFrame
-from bec_widgets.utils.settings_dialog import SettingsDialog
 from bec_widgets.utils.side_panel import SidePanel
-from bec_widgets.utils.toolbar import MaterialIconAction, ModularToolBar, ToolbarBundle
+from bec_widgets.utils.toolbars.performance import PerformanceConnection, performance_bundle
+from bec_widgets.utils.toolbars.toolbar import ModularToolBar
 from bec_widgets.utils.widget_state_manager import WidgetStateManager
 from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
 from bec_widgets.widgets.plots.setting_menus.axis_settings import AxisSettings
-from bec_widgets.widgets.plots.toolbar_bundles.mouse_interactions import (
-    MouseInteractionToolbarBundle,
+from bec_widgets.widgets.plots.toolbar_components.axis_settings_popup import (
+    AxisSettingsPopupConnection,
+    axis_popup_bundle,
 )
-from bec_widgets.widgets.plots.toolbar_bundles.plot_export import PlotExportBundle
-from bec_widgets.widgets.plots.toolbar_bundles.roi_bundle import ROIBundle
+from bec_widgets.widgets.plots.toolbar_components.mouse_interactions import (
+    MouseInteractionConnection,
+    mouse_interaction_bundle,
+)
+from bec_widgets.widgets.plots.toolbar_components.plot_export import (
+    PlotExportConnection,
+    plot_export_bundle,
+)
+from bec_widgets.widgets.plots.toolbar_components.roi import RoiConnection, roi_bundle
 
 logger = bec_logger.logger
 
@@ -102,8 +110,6 @@ class PlotBase(BECWidget, QWidget):
         self.plot_item = pg.PlotItem(viewBox=BECViewBox(enableMenu=True))
         self.plot_widget.addItem(self.plot_item)
         self.side_panel = SidePanel(self, orientation="left", panel_max_width=280)
-        self.toolbar = ModularToolBar(parent=self, target_widget=self, orientation="horizontal")
-        self._init_toolbar()
 
         # PlotItem Addons
         self.plot_item.addLegend()
@@ -116,11 +122,15 @@ class PlotBase(BECWidget, QWidget):
         self._user_y_label = ""
         self._y_label_suffix = ""
         self._y_axis_units = ""
+        self._minimal_crosshair_precision = 3
 
         # Plot Indicator Items
         self.tick_item = BECTickItem(parent=self, plot_item=self.plot_item)
         self.arrow_item = BECArrowItem(parent=self, plot_item=self.plot_item)
 
+        self.toolbar = ModularToolBar(parent=self, orientation="horizontal")
+        self._init_toolbar()
+
         self._init_ui()
 
         self._connect_to_theme_change()
@@ -145,36 +155,33 @@ class PlotBase(BECWidget, QWidget):
         self.plot_item.vb.sigStateChanged.connect(self.viewbox_state_changed)
 
     def _init_toolbar(self):
-        self.popup_bundle = None
-        self.performance_bundle = ToolbarBundle("performance")
-        self.plot_export_bundle = PlotExportBundle("plot_export", target_widget=self)
-        self.mouse_bundle = MouseInteractionToolbarBundle("mouse_interaction", target_widget=self)
-        # self.state_export_bundle = SaveStateBundle("state_export", target_widget=self) #TODO ATM disabled, cannot be used in DockArea, which is exposed to the user
-        self.roi_bundle = ROIBundle("roi", target_widget=self)
+        self.toolbar.add_bundle(performance_bundle(self.toolbar.components))
+        self.toolbar.add_bundle(plot_export_bundle(self.toolbar.components))
+        self.toolbar.add_bundle(mouse_interaction_bundle(self.toolbar.components))
+        self.toolbar.add_bundle(roi_bundle(self.toolbar.components))
+        self.toolbar.add_bundle(axis_popup_bundle(self.toolbar.components))
 
-        # Add elements to toolbar
-        self.toolbar.add_bundle(self.plot_export_bundle, target_widget=self)
-        # self.toolbar.add_bundle(self.state_export_bundle, target_widget=self) #TODO ATM disabled, cannot be used in DockArea, which is exposed to the user
-        self.toolbar.add_bundle(self.mouse_bundle, target_widget=self)
-        self.toolbar.add_bundle(self.roi_bundle, target_widget=self)
-
-        self.performance_bundle.add_action(
-            "fps_monitor",
-            MaterialIconAction(
-                icon_name="speed", tooltip="Show FPS Monitor", checkable=True, parent=self
-            ),
+        self.toolbar.connect_bundle(
+            "plot_base", PlotExportConnection(self.toolbar.components, self)
         )
-        self.toolbar.add_bundle(self.performance_bundle, target_widget=self)
-
-        self.toolbar.widgets["fps_monitor"].action.toggled.connect(
-            lambda checked: setattr(self, "enable_fps_monitor", checked)
+        self.toolbar.connect_bundle(
+            "plot_base", PerformanceConnection(self.toolbar.components, self)
+        )
+        self.toolbar.connect_bundle(
+            "plot_base", MouseInteractionConnection(self.toolbar.components, self)
+        )
+        self.toolbar.connect_bundle("plot_base", RoiConnection(self.toolbar.components, self))
+        self.toolbar.connect_bundle(
+            "plot_base", AxisSettingsPopupConnection(self.toolbar.components, self)
         )
 
         # hide some options by default
         self.toolbar.toggle_action_visibility("fps_monitor", False)
 
         # Get default viewbox state
-        self.mouse_bundle.get_viewbox_mode()
+        self.toolbar.show_bundles(
+            ["plot_export", "mouse_interaction", "roi", "performance", "axis_popup"]
+        )
 
     def add_side_menus(self):
         """Adds multiple menus to the side panel."""
@@ -191,45 +198,6 @@ class PlotBase(BECWidget, QWidget):
         except ValueError:
             return
 
-    def add_popups(self):
-        """
-        Add popups to the toolbar.
-        """
-        self.popup_bundle = ToolbarBundle("popup_bundle")
-        settings = MaterialIconAction(
-            icon_name="settings", tooltip="Show Axis Settings", checkable=True, parent=self
-        )
-        self.popup_bundle.add_action("axis", settings)
-        self.toolbar.add_bundle(self.popup_bundle, target_widget=self)
-        self.toolbar.widgets["axis"].action.triggered.connect(self.show_axis_settings_popup)
-
-    def show_axis_settings_popup(self):
-        """
-        Show the axis settings dialog.
-        """
-        settings_action = self.toolbar.widgets["axis"].action
-        if self.axis_settings_dialog is None or not self.axis_settings_dialog.isVisible():
-            axis_setting = AxisSettings(parent=self, target_widget=self, popup=True)
-            self.axis_settings_dialog = SettingsDialog(
-                self, settings_widget=axis_setting, window_title="Axis Settings", modal=False
-            )
-            # When the dialog is closed, update the toolbar icon and clear the reference
-            self.axis_settings_dialog.finished.connect(self._axis_settings_closed)
-            self.axis_settings_dialog.show()
-            settings_action.setChecked(True)
-        else:
-            # If already open, bring it to the front
-            self.axis_settings_dialog.raise_()
-            self.axis_settings_dialog.activateWindow()
-            settings_action.setChecked(True)  # keep it toggled
-
-    def _axis_settings_closed(self):
-        """
-        Slot for when the axis settings dialog is closed.
-        """
-        self.axis_settings_dialog = None
-        self.toolbar.widgets["axis"].action.setChecked(False)
-
     def reset_legend(self):
         """In the case that the legend is not visible, reset it to be visible to top left corner"""
         self.plot_item.legend.autoAnchor(50)
@@ -256,22 +224,23 @@ class PlotBase(BECWidget, QWidget):
             raise ValueError("ui_mode must be an instance of UIMode")
         self._ui_mode = mode
 
-        # First, clear both UI elements:
-        if self.popup_bundle is not None:
-            for action_id in self.toolbar.bundles["popup_bundle"]:
-                self.toolbar.widgets[action_id].action.setVisible(False)
-            if self.axis_settings_dialog is not None and self.axis_settings_dialog.isVisible():
-                self.axis_settings_dialog.close()
-        self.side_panel.hide()
-
         # Now, apply the new mode:
         if mode == UIMode.POPUP:
-            if self.popup_bundle is None:
-                self.add_popups()
-            else:
-                for action_id in self.toolbar.bundles["popup_bundle"]:
-                    self.toolbar.widgets[action_id].action.setVisible(True)
+            shown_bundles = self.toolbar.shown_bundles
+            if "axis_popup" not in shown_bundles:
+                shown_bundles.append("axis_popup")
+            self.toolbar.show_bundles(shown_bundles)
+            self.side_panel.hide()
+
         elif mode == UIMode.SIDE:
+            shown_bundles = self.toolbar.shown_bundles
+            if "axis_popup" in shown_bundles:
+                shown_bundles.remove("axis_popup")
+            self.toolbar.show_bundles(shown_bundles)
+            pb_connection = self.toolbar.bundles["axis_popup"].get_connection("plot_base")
+            if pb_connection.axis_settings_dialog is not None:
+                pb_connection.axis_settings_dialog.close()
+                pb_connection.axis_settings_dialog = None
             self.add_side_menus()
             self.side_panel.show()
 
@@ -912,6 +881,38 @@ class PlotBase(BECWidget, QWidget):
         """
         self.plot_item.enableAutoRange(y=value)
 
+    def auto_range(self, value: bool = True):
+        """
+        On demand apply autorange to the plot item based on the visible curves.
+
+        Args:
+            value(bool): If True, apply autorange to the visible curves.
+        """
+        if not value:
+            self.plot_item.enableAutoRange(x=False, y=False)
+            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
+
+    def _apply_autorange_only_visible_curves(self):
+        """
+        Apply autorange to the plot item based on the provided curves.
+
+        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)
+
     @SafeProperty(int, doc="The font size of the legend font.")
     def legend_label_size(self) -> int:
         """
@@ -978,7 +979,9 @@ class PlotBase(BECWidget, QWidget):
     def hook_crosshair(self) -> None:
         """Hook the crosshair to all plots."""
         if self.crosshair is None:
-            self.crosshair = Crosshair(self.plot_item, precision=3)
+            self.crosshair = Crosshair(
+                self.plot_item, min_precision=self._minimal_crosshair_precision
+            )
             self.crosshair.crosshairChanged.connect(self.crosshair_position_changed)
             self.crosshair.crosshairClicked.connect(self.crosshair_position_clicked)
             self.crosshair.coordinatesChanged1D.connect(self.crosshair_coordinates_changed)
@@ -1006,6 +1009,29 @@ class PlotBase(BECWidget, QWidget):
 
         self.unhook_crosshair()
 
+    @SafeProperty(
+        int, doc="Minimum decimal places for crosshair when dynamic precision is enabled."
+    )
+    def minimal_crosshair_precision(self) -> int:
+        """
+        Minimum decimal places for crosshair when dynamic precision is enabled.
+        """
+        return self._minimal_crosshair_precision
+
+    @minimal_crosshair_precision.setter
+    def minimal_crosshair_precision(self, value: int):
+        """
+        Set the minimum decimal places for crosshair when dynamic precision is enabled.
+
+        Args:
+            value(int): The minimum decimal places to set.
+        """
+        value_int = max(0, int(value))
+        self._minimal_crosshair_precision = value_int
+        if self.crosshair is not None:
+            self.crosshair.min_precision = value_int
+        self.property_changed.emit("minimal_crosshair_precision", value_int)
+
     @SafeSlot()
     def reset(self) -> None:
         """Reset the plot widget."""
@@ -1014,6 +1040,7 @@ class PlotBase(BECWidget, QWidget):
             self.crosshair.update_markers()
 
     def cleanup(self):
+        self.toolbar.cleanup()
         self.unhook_crosshair()
         self.unhook_fps_monitor(delete_label=True)
         self.tick_item.cleanup()
@@ -1061,8 +1088,12 @@ if __name__ == "__main__":  # pragma: no cover:
 
     from qtpy.QtWidgets import QApplication
 
+    from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
+
     app = QApplication(sys.argv)
-    window = PlotBase()
-    window.show()
+    launch_window = BECMainWindow()
+    pb = PlotBase(popups=False)
+    launch_window.setCentralWidget(pb)
+    launch_window.show()
 
     sys.exit(app.exec_())

bec_widgets/widgets/plots/roi/image_roi.py

@@ -104,9 +104,12 @@ class BaseROI(BECConnector):
 
     nameChanged = Signal(str)
     penChanged = Signal()
+    movableChanged = Signal(bool)
     USER_ACCESS = [
         "label",
         "label.setter",
+        "movable",
+        "movable.setter",
         "line_color",
         "line_color.setter",
         "line_width",
@@ -127,6 +130,7 @@ class BaseROI(BECConnector):
         label: str | None = None,
         line_color: str | None = None,
         line_width: int = 5,
+        movable: bool = True,
         # all remaining pg.*ROI kwargs (pos, size, pen, …)
         **pg_kwargs,
     ):
@@ -150,15 +154,27 @@ class BaseROI(BECConnector):
         self.parent_plot_item = parent_image.plot_item
         object_name = label.replace("-", "_").replace(" ", "_") if label else None
         super().__init__(
-            object_name=object_name, config=config, gui_id=gui_id, removable=True, **pg_kwargs
+            object_name=object_name,
+            config=config,
+            gui_id=gui_id,
+            removable=True,
+            invertible=True,
+            movable=movable,
+            **pg_kwargs,
         )
 
         self._label = label or "ROI"
         self._line_color = line_color or "#ffffff"
         self._line_width = line_width
         self._description = True
+        self._movable = movable
         self.setPen(mkPen(self._line_color, width=self._line_width))
 
+        # Reset Handles to avoid inherited handles from pyqtgraph
+        self.remove_scale_handles()  # remove any existing handles from pyqtgraph.RectROI
+        if movable:
+            self.add_scale_handle()  # add custom scale handles
+
     def set_parent(self, parent: Image):
         """
         Sets the parent image for this ROI.
@@ -177,6 +193,40 @@ class BaseROI(BECConnector):
         """
         return self.parent_image
 
+    @property
+    def movable(self) -> bool:
+        """
+        Gets whether this ROI is movable.
+
+        Returns:
+            bool: True if the ROI can be moved, False otherwise.
+        """
+        return self._movable
+
+    @movable.setter
+    def movable(self, value: bool):
+        """
+        Sets whether this ROI is movable.
+
+        If the new value is different from the current value, this method updates
+        the internal state and emits the penChanged signal.
+
+        Args:
+            value (bool): True to make the ROI movable, False to make it fixed.
+        """
+        if value != self._movable:
+            self._movable = value
+            # All relevant properties from pyqtgraph to block movement
+            self.translatable = value
+            self.rotatable = value
+            self.resizable = value
+            self.removable = value
+            if value:
+                self.add_scale_handle()  # add custom scale handles
+            else:
+                self.remove_scale_handles()  # remove custom scale handles
+            self.movableChanged.emit(value)
+
     @property
     def label(self) -> str:
         """
@@ -332,8 +382,18 @@ class BaseROI(BECConnector):
         )
 
     def add_scale_handle(self):
+        """Add scale handles to the ROI."""
         return
 
+    def remove_scale_handles(self):
+        """Remove all scale handles from the ROI."""
+        handles = self.handles
+        for i in range(len(handles)):
+            try:
+                self.removeHandle(0)
+            except IndexError:
+                continue
+
     def set_position(self, x: float, y: float):
         """
         Sets the position of the ROI.
@@ -350,12 +410,7 @@ class BaseROI(BECConnector):
         if controller and self in controller.rois:
             controller.remove_roi(self)
             return  # controller will call back into this method once deregistered
-        handles = self.handles
-        for i in range(len(handles)):
-            try:
-                self.removeHandle(0)
-            except IndexError:
-                continue
+        self.remove_scale_handles()
         self.rpc_register.remove_rpc(self)
         self.parent_image.plot_item.removeItem(self)
         viewBox = self.parent_plot_item.vb
@@ -394,6 +449,7 @@ class RectangularROI(BaseROI, pg.RectROI):
         label: str | None = None,
         line_color: str | None = None,
         line_width: int = 5,
+        movable: bool = True,
         resize_handles: bool = True,
         **extra_pg,
     ):
@@ -424,6 +480,7 @@ class RectangularROI(BaseROI, pg.RectROI):
             pos=pos,
             size=size,
             pen=pen,
+            movable=movable,
             **extra_pg,
         )
 
@@ -432,6 +489,23 @@ class RectangularROI(BaseROI, pg.RectROI):
         self.hoverPen = fn.mkPen(color=(255, 0, 0), width=3, style=QtCore.Qt.DashLine)
         self.handleHoverPen = fn.mkPen("lime", width=4)
 
+    def _normalized_edges(self) -> tuple[float, float, float, float]:
+        """
+        Return rectangle edges as (left, bottom, right, top) with consistent
+        ordering even when the ROI has been inverted by its scale handles.
+
+        Returns:
+            tuple: A tuple containing the left, bottom, right, and top edges
+                of the ROI rectangle in normalized coordinates.
+        """
+        x0, y0 = self.pos().x(), self.pos().y()
+        w, h = self.state["size"]
+        x_left = min(x0, x0 + w)
+        x_right = max(x0, x0 + w)
+        y_bottom = min(y0, y0 + h)
+        y_top = max(y0, y0 + h)
+        return x_left, y_bottom, x_right, y_top
+
     def add_scale_handle(self):
         """
         Add scale handles at every corner and edge of the ROI.
@@ -453,24 +527,17 @@ class RectangularROI(BaseROI, pg.RectROI):
         self.addScaleHandle([0, 0.5], [1, 0.5])  # left edge
         self.addScaleHandle([1, 0.5], [0, 0.5])  # right edge
 
-        self.handlePen = fn.mkPen("#ffff00", width=5)  # bright yellow outline
-        self.handleHoverPen = fn.mkPen("#00ffff", width=4)  # cyan, thicker when hovered
-        self.handleBrush = (200, 200, 0, 120)  # semi-transparent fill
-        self.handleHoverBrush = (0, 255, 255, 160)
-
     def _on_region_changed(self):
         """
-        Handles ROI region change events.
+        Handles changes to the ROI's region.
 
         This method is called whenever the ROI's position or size changes.
         It calculates the new corner coordinates and emits the edgesChanged signal
         with the updated coordinates.
         """
-        x0, y0 = self.pos().x(), self.pos().y()
-        w, h = self.state["size"]
-        self.edgesChanged.emit(x0, y0, x0 + w, y0 + h)
-        viewBox = self.parent_plot_item.vb
-        viewBox.update()
+        x_left, y_bottom, x_right, y_top = self._normalized_edges()
+        self.edgesChanged.emit(x_left, y_bottom, x_right, y_top)
+        self.parent_plot_item.vb.update()
 
     def mouseDragEvent(self, ev):
         """
@@ -484,9 +551,8 @@ class RectangularROI(BaseROI, pg.RectROI):
         """
         super().mouseDragEvent(ev)
         if ev.isFinish():
-            x0, y0 = self.pos().x(), self.pos().y()
-            w, h = self.state["size"]
-            self.edgesReleased.emit(x0, y0, x0 + w, y0 + h)
+            x_left, y_bottom, x_right, y_top = self._normalized_edges()
+            self.edgesReleased.emit(x_left, y_bottom, x_right, y_top)
 
     def get_coordinates(self, typed: bool | None = None) -> dict | tuple:
         """
@@ -505,17 +571,16 @@ class RectangularROI(BaseROI, pg.RectROI):
         if typed is None:
             typed = self.description
 
-        x0, y0 = self.pos().x(), self.pos().y()
-        w, h = self.state["size"]
-        x1, y1 = x0 + w, y0 + h
+        x_left, y_bottom, x_right, y_top = self._normalized_edges()
+
         if typed:
             return {
-                "bottom_left": (x0, y0),
-                "bottom_right": (x1, y0),
-                "top_left": (x0, y1),
-                "top_right": (x1, y1),
+                "bottom_left": (x_left, y_bottom),
+                "bottom_right": (x_right, y_bottom),
+                "top_left": (x_left, y_top),
+                "top_right": (x_right, y_top),
             }
-        return ((x0, y0), (x1, y0), (x0, y1), (x1, y1))
+        return (x_left, y_bottom), (x_right, y_bottom), (x_left, y_top), (x_right, y_top)
 
     def _lookup_scene_image(self):
         """
@@ -563,6 +628,7 @@ class CircularROI(BaseROI, pg.CircleROI):
         label: str | None = None,
         line_color: str | None = None,
         line_width: int = 5,
+        movable: bool = True,
         **extra_pg,
     ):
         """
@@ -594,10 +660,19 @@ class CircularROI(BaseROI, pg.CircleROI):
             pos=pos,
             size=size,
             pen=pen,
+            movable=movable,
             **extra_pg,
         )
         self.sigRegionChanged.connect(self._on_region_changed)
         self._adorner = LabelAdorner(self)
+        self.hoverPen = fn.mkPen(color=(255, 0, 0), width=3, style=QtCore.Qt.DashLine)
+        self.handleHoverPen = fn.mkPen("lime", width=4)
+
+    def add_scale_handle(self):
+        """
+        Adds scale handles to the circular ROI.
+        """
+        self._addHandles()  # wrapper around pg.CircleROI._addHandles
 
     def _on_region_changed(self):
         """
@@ -649,7 +724,7 @@ class CircularROI(BaseROI, pg.CircleROI):
         if typed is None:
             typed = self.description
 
-        d = self.state["size"][0]
+        d = abs(self.state["size"][0])
         cx = self.pos().x() + d / 2
         cy = self.pos().y() + d / 2
 
@@ -675,6 +750,92 @@ class CircularROI(BaseROI, pg.CircleROI):
         return None
 
 
+class EllipticalROI(BaseROI, pg.EllipseROI):
+    """
+    Elliptical Region of Interest with centre/width/height tracking and auto-labelling.
+
+    Mirrors the behaviour of ``CircularROI`` but supports independent
+    horizontal and vertical radii.
+    """
+
+    centerChanged = Signal(float, float, float, float)  # cx, cy, width, height
+    centerReleased = Signal(float, float, float, float)
+
+    def __init__(
+        self,
+        *,
+        pos,
+        size,
+        pen=None,
+        config: ConnectionConfig | None = None,
+        gui_id: str | None = None,
+        parent_image: Image | None = None,
+        label: str | None = None,
+        line_color: str | None = None,
+        line_width: int = 5,
+        movable: bool = True,
+        **extra_pg,
+    ):
+        super().__init__(
+            config=config,
+            gui_id=gui_id,
+            parent_image=parent_image,
+            label=label,
+            line_color=line_color,
+            line_width=line_width,
+            pos=pos,
+            size=size,
+            pen=pen,
+            movable=movable,
+            **extra_pg,
+        )
+
+        self.sigRegionChanged.connect(self._on_region_changed)
+        self._adorner = LabelAdorner(self)
+        self.hoverPen = fn.mkPen(color=(255, 0, 0), width=3, style=QtCore.Qt.DashLine)
+        self.handleHoverPen = fn.mkPen("lime", width=4)
+
+    def add_scale_handle(self):
+        """Add scale handles to the elliptical ROI."""
+        self._addHandles()  # delegates to pg.EllipseROI
+
+    def _on_region_changed(self):
+        w = abs(self.state["size"][0])
+        h = abs(self.state["size"][1])
+        cx = self.pos().x() + w / 2
+        cy = self.pos().y() + h / 2
+        self.centerChanged.emit(cx, cy, w, h)
+        self.parent_plot_item.vb.update()
+
+    def mouseDragEvent(self, ev):
+        super().mouseDragEvent(ev)
+        if ev.isFinish():
+            w = abs(self.state["size"][0])
+            h = abs(self.state["size"][1])
+            cx = self.pos().x() + w / 2
+            cy = self.pos().y() + h / 2
+            self.centerReleased.emit(cx, cy, w, h)
+
+    def get_coordinates(self, typed: bool | None = None) -> dict | tuple:
+        """
+        Return the ellipse's centre and size.
+
+        Args:
+            typed (bool | None): If True returns dict; otherwise tuple.
+        """
+        if typed is None:
+            typed = self.description
+
+        w, h = map(abs, self.state["size"])  # raw diameters
+        major, minor = (w, h) if w >= h else (h, w)
+        cx = self.pos().x() + w / 2
+        cy = self.pos().y() + h / 2
+
+        if typed:
+            return {"center_x": cx, "center_y": cy, "major_axis": major, "minor_axis": minor}
+        return (cx, cy, major, minor)
+
+
 class ROIController(QObject):
     """Manages a collection of ROIs (Regions of Interest) with palette-assigned colors.
 

bec_widgets/widgets/plots/scatter_waveform/scatter_waveform.py

@@ -13,7 +13,7 @@ from bec_widgets.utils import Colors, ConnectionConfig
 from bec_widgets.utils.colors import set_theme
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.settings_dialog import SettingsDialog
-from bec_widgets.utils.toolbar import MaterialIconAction
+from bec_widgets.utils.toolbars.toolbar import MaterialIconAction
 from bec_widgets.widgets.plots.plot_base import PlotBase, UIMode
 from bec_widgets.widgets.plots.scatter_waveform.scatter_curve import (
     ScatterCurve,
@@ -82,6 +82,8 @@ class ScatterWaveform(PlotBase):
         "y_log.setter",
         "legend_label_size",
         "legend_label_size.setter",
+        "minimal_crosshair_precision",
+        "minimal_crosshair_precision.setter",
         # Scatter Waveform Specific RPC Access
         "main_curve",
         "color_map",
@@ -129,8 +131,8 @@ class ScatterWaveform(PlotBase):
         self.proxy_update_sync = pg.SignalProxy(
             self.sync_signal_update, rateLimit=25, slot=self.update_sync_curves
         )
-        if self.ui_mode == UIMode.SIDE:
-            self._init_scatter_curve_settings()
+
+        self._init_scatter_curve_settings()
         self.update_with_scan_history(-1)
 
     ################################################################################
@@ -141,44 +143,40 @@ class ScatterWaveform(PlotBase):
         """
         Initialize the scatter curve settings menu.
         """
+        if self.ui_mode == UIMode.SIDE:
+            self.scatter_curve_settings = ScatterCurveSettings(
+                parent=self, target_widget=self, popup=False
+            )
+            self.side_panel.add_menu(
+                action_id="scatter_curve",
+                icon_name="scatter_plot",
+                tooltip="Show Scatter Curve Settings",
+                widget=self.scatter_curve_settings,
+                title="Scatter Curve Settings",
+            )
+        else:
+            scatter_curve_action = MaterialIconAction(
+                icon_name="scatter_plot",
+                tooltip="Show Scatter Curve Settings",
+                checkable=True,
+                parent=self,
+            )
+            self.toolbar.components.add_safe("scatter_waveform_settings", scatter_curve_action)
+            self.toolbar.get_bundle("axis_popup").add_action("scatter_waveform_settings")
+            scatter_curve_action.action.triggered.connect(self.show_scatter_curve_settings)
 
-        self.scatter_curve_settings = ScatterCurveSettings(
-            parent=self, target_widget=self, popup=False
-        )
-        self.side_panel.add_menu(
-            action_id="scatter_curve",
-            icon_name="scatter_plot",
-            tooltip="Show Scatter Curve Settings",
-            widget=self.scatter_curve_settings,
-            title="Scatter Curve Settings",
-        )
-
-    def add_popups(self):
-        """
-        Add popups to the ScatterWaveform widget.
-        """
-        super().add_popups()
-        scatter_curve_setting_action = MaterialIconAction(
-            icon_name="scatter_plot",
-            tooltip="Show Scatter Curve Settings",
-            checkable=True,
-            parent=self,
-        )
-        self.toolbar.add_action_to_bundle(
-            bundle_id="popup_bundle",
-            action_id="scatter_waveform_settings",
-            action=scatter_curve_setting_action,
-            target_widget=self,
-        )
-        self.toolbar.widgets["scatter_waveform_settings"].action.triggered.connect(
-            self.show_scatter_curve_settings
-        )
+        shown_bundles = self.toolbar.shown_bundles
+        if "performance" in shown_bundles:
+            shown_bundles.remove("performance")
+        self.toolbar.show_bundles(shown_bundles)
 
     def show_scatter_curve_settings(self):
         """
         Show the scatter curve settings dialog.
         """
-        scatter_settings_action = self.toolbar.widgets["scatter_waveform_settings"].action
+        scatter_settings_action = self.toolbar.components.get_action(
+            "scatter_waveform_settings"
+        ).action
         if self.scatter_dialog is None or not self.scatter_dialog.isVisible():
             scatter_settings = ScatterCurveSettings(parent=self, target_widget=self, popup=True)
             self.scatter_dialog = SettingsDialog(
@@ -203,7 +201,7 @@ class ScatterWaveform(PlotBase):
         Slot for when the scatter curve settings dialog is closed.
         """
         self.scatter_dialog = None
-        self.toolbar.widgets["scatter_waveform_settings"].action.setChecked(False)
+        self.toolbar.components.get_action("scatter_waveform_settings").action.setChecked(False)
 
     ################################################################################
     # Widget Specific Properties

bec_widgets/widgets/plots/scatter_waveform/settings/scatter_curve_settings_horizontal.ui

@@ -141,6 +141,14 @@
    <header>bec_color_map_widget</header>
   </customwidget>
  </customwidgets>
+ <tabstops>
+  <tabstop>x_name</tabstop>
+  <tabstop>x_entry</tabstop>
+  <tabstop>y_name</tabstop>
+  <tabstop>y_entry</tabstop>
+  <tabstop>z_name</tabstop>
+  <tabstop>z_entry</tabstop>
+ </tabstops>
  <resources/>
  <connections>
   <connection>

bec_widgets/widgets/plots/setting_menus/axis_settings.py

@@ -60,6 +60,7 @@ class AxisSettings(SettingWidget):
             self.ui.y_grid,
             self.ui.inner_axes,
             self.ui.outer_axes,
+            self.ui.minimal_crosshair_precision,
         ]:
             WidgetIO.connect_widget_change_signal(widget, self.set_property)
 
@@ -121,6 +122,7 @@ class AxisSettings(SettingWidget):
             self.ui.y_max,
             self.ui.y_log,
             self.ui.y_grid,
+            self.ui.minimal_crosshair_precision,
         ]:
             property_name = widget.objectName()
             value = getattr(self.target_widget, property_name)
@@ -144,6 +146,7 @@ class AxisSettings(SettingWidget):
             self.ui.y_grid,
             self.ui.outer_axes,
             self.ui.inner_axes,
+            self.ui.minimal_crosshair_precision,
         ]:
             property_name = widget.objectName()
             value = WidgetIO.get_value(widget)

bec_widgets/widgets/plots/setting_menus/axis_settings_horizontal.ui

@@ -14,97 +14,6 @@
             <string>Form</string>
         </property>
         <layout class="QGridLayout" name="gridLayout">
-            <item row="1" column="0">
-                <widget class="QLabel" name="label">
-                    <property name="text">
-                        <string>Inner Axes</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="1" column="1">
-                <widget class="ToggleSwitch" name="inner_axes"/>
-            </item>
-            <item row="1" column="2">
-                <widget class="QLabel" name="label_outer_axes">
-                    <property name="text">
-                        <string>Outer Axes</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="1" column="3">
-                <widget class="ToggleSwitch" name="outer_axes">
-                    <property name="checked" stdset="0">
-                        <bool>false</bool>
-                    </property>
-                </widget>
-            </item>
-            <item row="2" column="0" colspan="2">
-                <widget class="QGroupBox" name="x_axis_box">
-                    <property name="title">
-                        <string>X Axis</string>
-                    </property>
-                    <layout class="QGridLayout" name="gridLayout_4">
-                        <item row="5" column="0">
-                            <widget class="QLabel" name="x_grid_label">
-                                <property name="text">
-                                    <string>Grid</string>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="3" column="2">
-                            <widget class="ToggleSwitch" name="x_log">
-                                <property name="checked" stdset="0">
-                                    <bool>false</bool>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="2" column="0">
-                            <widget class="QLabel" name="x_max_label">
-                                <property name="text">
-                                    <string>Max</string>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="5" column="2">
-                            <widget class="ToggleSwitch" name="x_grid">
-                                <property name="checked" stdset="0">
-                                    <bool>false</bool>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="3" column="0">
-                            <widget class="QLabel" name="x_scale_label">
-                                <property name="text">
-                                    <string>Log</string>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="1" column="0" colspan="2">
-                            <widget class="QLabel" name="x_min_label">
-                                <property name="text">
-                                    <string>Min</string>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="0" column="0">
-                            <widget class="QLabel" name="x_label_label">
-                                <property name="text">
-                                    <string>Label</string>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="0" column="2">
-                            <widget class="QLineEdit" name="x_label"/>
-                        </item>
-                        <item row="1" column="2">
-                            <widget class="BECSpinBox" name="x_min"/>
-                        </item>
-                        <item row="2" column="2">
-                            <widget class="BECSpinBox" name="x_max"/>
-                        </item>
-                    </layout>
-                </widget>
-            </item>
             <item row="2" column="2" colspan="2">
                 <widget class="QGroupBox" name="y_axis_box">
                     <property name="title">
@@ -179,6 +88,87 @@
                     </layout>
                 </widget>
             </item>
+            <item row="1" column="3">
+                <widget class="ToggleSwitch" name="outer_axes">
+                    <property name="checked" stdset="0">
+                        <bool>false</bool>
+                    </property>
+                </widget>
+            </item>
+            <item row="1" column="0">
+                <widget class="QLabel" name="label">
+                    <property name="text">
+                        <string>Inner Axes</string>
+                    </property>
+                </widget>
+            </item>
+            <item row="2" column="0" colspan="2">
+                <widget class="QGroupBox" name="x_axis_box">
+                    <property name="title">
+                        <string>X Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_4">
+                        <item row="5" column="0">
+                            <widget class="QLabel" name="x_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="2">
+                            <widget class="ToggleSwitch" name="x_log">
+                                <property name="checked" stdset="0">
+                                    <bool>false</bool>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="x_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="5" column="2">
+                            <widget class="ToggleSwitch" name="x_grid">
+                                <property name="checked" stdset="0">
+                                    <bool>false</bool>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="x_scale_label">
+                                <property name="text">
+                                    <string>Log</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="x_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="x_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="x_label"/>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="BECSpinBox" name="x_min"/>
+                        </item>
+                        <item row="2" column="2">
+                            <widget class="BECSpinBox" name="x_max"/>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
             <item row="0" column="0" colspan="4">
                 <layout class="QHBoxLayout" name="horizontalLayout">
                     <item>
@@ -191,8 +181,41 @@
                     <item>
                         <widget class="QLineEdit" name="title"/>
                     </item>
+                    <item>
+                        <widget class="QLabel" name="label_2">
+                            <property name="text">
+                                <string>Precision</string>
+                            </property>
+                        </widget>
+                    </item>
+                    <item>
+                        <widget class="QSpinBox" name="minimal_crosshair_precision">
+                            <property name="toolTip">
+                                <string>Minimal Crosshair Precision</string>
+                            </property>
+                            <property name="alignment">
+                                <set>Qt::AlignmentFlag::AlignCenter</set>
+                            </property>
+                            <property name="maximum">
+                                <number>20</number>
+                            </property>
+                            <property name="value">
+                                <number>3</number>
+                            </property>
+                        </widget>
+                    </item>
                 </layout>
             </item>
+            <item row="1" column="2">
+                <widget class="QLabel" name="label_outer_axes">
+                    <property name="text">
+                        <string>Outer Axes</string>
+                    </property>
+                </widget>
+            </item>
+            <item row="1" column="1">
+                <widget class="ToggleSwitch" name="inner_axes"/>
+            </item>
         </layout>
     </widget>
     <customwidgets>

bec_widgets/widgets/plots/setting_menus/axis_settings_vertical.ui

@@ -6,15 +6,84 @@
             <rect>
                 <x>0</x>
                 <y>0</y>
-                <width>241</width>
-                <height>526</height>
+                <width>250</width>
+                <height>612</height>
             </rect>
         </property>
         <property name="windowTitle">
             <string>Form</string>
         </property>
-        <layout class="QGridLayout" name="gridLayout">
-            <item row="4" column="0" colspan="2">
+        <layout class="QVBoxLayout" name="verticalLayout">
+            <item>
+                <widget class="QGroupBox" name="general_box">
+                    <property name="title">
+                        <string>General</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_2">
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="label_outer_axes">
+                                <property name="text">
+                                    <string>Outer Axes</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="1">
+                            <widget class="ToggleSwitch" name="outer_axes">
+                                <property name="checked" stdset="0">
+                                    <bool>false</bool>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="1">
+                            <widget class="QLineEdit" name="title"/>
+                        </item>
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="label">
+                                <property name="text">
+                                    <string>Inner Axes</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0">
+                            <widget class="QLabel" name="plot_title_label">
+                                <property name="text">
+                                    <string>Plot Title</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="1">
+                            <widget class="ToggleSwitch" name="inner_axes"/>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="label_2">
+                                <property name="toolTip">
+                                    <string>Minimal Crosshair Precision</string>
+                                </property>
+                                <property name="text">
+                                    <string>Precision</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="1">
+                            <widget class="QSpinBox" name="minimal_crosshair_precision">
+                                <property name="toolTip">
+                                    <string>Minimal Crosshair Precision</string>
+                                </property>
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="maximum">
+                                    <number>20</number>
+                                </property>
+                                <property name="value">
+                                    <number>3</number>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+            <item>
                 <widget class="QGroupBox" name="x_axis_box">
                     <property name="title">
                         <string>X Axis</string>
@@ -81,28 +150,7 @@
                     </layout>
                 </widget>
             </item>
-            <item row="0" column="0" colspan="2">
-                <layout class="QHBoxLayout" name="horizontalLayout">
-                    <item>
-                        <widget class="QLabel" name="plot_title_label">
-                            <property name="text">
-                                <string>Plot Title</string>
-                            </property>
-                        </widget>
-                    </item>
-                    <item>
-                        <widget class="QLineEdit" name="title"/>
-                    </item>
-                </layout>
-            </item>
-            <item row="2" column="0">
-                <widget class="QLabel" name="label_outer_axes">
-                    <property name="text">
-                        <string>Outer Axes</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="5" column="0" colspan="2">
+            <item>
                 <widget class="QGroupBox" name="y_axis_box">
                     <property name="title">
                         <string>Y Axis</string>
@@ -169,23 +217,6 @@
                     </layout>
                 </widget>
             </item>
-            <item row="2" column="1">
-                <widget class="ToggleSwitch" name="outer_axes">
-                    <property name="checked" stdset="0">
-                        <bool>false</bool>
-                    </property>
-                </widget>
-            </item>
-            <item row="1" column="0">
-                <widget class="QLabel" name="label">
-                    <property name="text">
-                        <string>Inner Axes</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="1" column="1">
-                <widget class="ToggleSwitch" name="inner_axes"/>
-            </item>
         </layout>
     </widget>
     <customwidgets>

bec_widgets/widgets/plots/toolbar_bundles/mouse_interactions.py

@@ -1,108 +0,0 @@
-import pyqtgraph as pg
-from qtpy.QtCore import QTimer
-
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.toolbar import MaterialIconAction, SwitchableToolBarAction, ToolbarBundle
-
-
-class MouseInteractionToolbarBundle(ToolbarBundle):
-    """
-    A bundle of actions that are hooked in this constructor itself,
-    so that you can immediately connect the signals and toggle states.
-
-    This bundle is for a toolbar that controls mouse interactions on a plot.
-    """
-
-    def __init__(self, bundle_id="mouse_interaction", target_widget=None, **kwargs):
-        super().__init__(bundle_id=bundle_id, actions=[], **kwargs)
-        self.target_widget = target_widget
-        self.mouse_mode = None
-
-        # Create each MaterialIconAction with a parent
-        # so the signals can fire even if the toolbar isn't added yet.
-        drag = MaterialIconAction(
-            icon_name="drag_pan",
-            tooltip="Drag Mouse Mode",
-            checkable=True,
-            parent=self.target_widget,  # or any valid parent
-        )
-        rect = MaterialIconAction(
-            icon_name="frame_inspect",
-            tooltip="Rectangle Zoom Mode",
-            checkable=True,
-            parent=self.target_widget,
-        )
-        auto = MaterialIconAction(
-            icon_name="open_in_full",
-            tooltip="Autorange Plot",
-            checkable=False,
-            parent=self.target_widget,
-        )
-
-        self.switch_mouse_action = SwitchableToolBarAction(
-            actions={"drag_mode": drag, "rectangle_mode": rect},
-            initial_action="drag_mode",
-            tooltip="Mouse Modes",
-            checkable=True,
-            parent=self.target_widget,
-        )
-
-        # Add them to the bundle
-        self.add_action("switch_mouse", self.switch_mouse_action)
-        self.add_action("auto_range", auto)
-
-        # Immediately connect signals
-        drag.action.toggled.connect(self.enable_mouse_pan_mode)
-        rect.action.toggled.connect(self.enable_mouse_rectangle_mode)
-        auto.action.triggered.connect(self.autorange_plot)
-
-    def get_viewbox_mode(self):
-        """
-        Returns the current interaction mode of a PyQtGraph ViewBox and sets the corresponding action.
-        """
-
-        if self.target_widget:
-            viewbox = self.target_widget.plot_item.getViewBox()
-            if viewbox.getState()["mouseMode"] == 3:
-                self.switch_mouse_action.set_default_action("drag_mode")
-                self.switch_mouse_action.main_button.setChecked(True)
-                self.mouse_mode = "PanMode"
-            elif viewbox.getState()["mouseMode"] == 1:
-                self.switch_mouse_action.set_default_action("rectangle_mode")
-                self.switch_mouse_action.main_button.setChecked(True)
-                self.mouse_mode = "RectMode"
-
-    @SafeSlot(bool)
-    def enable_mouse_rectangle_mode(self, checked: bool):
-        """
-        Enable the rectangle zoom mode on the plot widget.
-        """
-        if self.mouse_mode == "RectMode":
-            self.switch_mouse_action.main_button.setChecked(True)
-            return
-        self.actions["switch_mouse"].actions["drag_mode"].action.setChecked(not checked)
-        if self.target_widget and checked:
-            self.target_widget.plot_item.getViewBox().setMouseMode(pg.ViewBox.RectMode)
-            self.mouse_mode = "RectMode"
-
-    @SafeSlot(bool)
-    def enable_mouse_pan_mode(self, checked: bool):
-        """
-        Enable the pan mode on the plot widget.
-        """
-        if self.mouse_mode == "PanMode":
-            self.switch_mouse_action.main_button.setChecked(True)
-            return
-        self.actions["switch_mouse"].actions["rectangle_mode"].action.setChecked(not checked)
-        if self.target_widget and checked:
-            self.target_widget.plot_item.getViewBox().setMouseMode(pg.ViewBox.PanMode)
-            self.mouse_mode = "PanMode"
-
-    @SafeSlot()
-    def autorange_plot(self):
-        """
-        Enable autorange on the plot widget.
-        """
-        if self.target_widget:
-            self.target_widget.auto_range_x = True
-            self.target_widget.auto_range_y = True