feat(dm-view): initial commit for config_view, ophyd_test and dm_widget

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

.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/formatter.yml

@@ -21,7 +21,7 @@ jobs:
           isort --check --diff ./
       
       - name: Check for disallowed imports from PySide
-        run: '! grep -re "from PySide6\." bec_widgets/ | grep  -v -e "PySide6.QtDesigner" -e "PySide6.scripts"'
+        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/pytest.yml

@@ -57,6 +57,14 @@ jobs:
         id: coverage
         run: pytest --random-order --cov=bec_widgets --cov-config=pyproject.toml --cov-branch --cov-report=xml --no-cov-on-fail tests/unit_tests/
 
+      - name: Upload test artifacts
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: image-references
+          path: bec_widgets/tests/reference_failures/
+          if-no-files-found: ignore
+
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v5
         with:

CHANGELOG.md

@@ -1,6 +1,780 @@
 # CHANGELOG
 
 
+## v2.38.0 (2025-08-19)
+
+### Features
+
+- **device_manager**: Devicemanager view of config session
+  ([`6e05157`](https://github.com/bec-project/bec_widgets/commit/6e05157abb61ec569eec10ff7295c28cb6a2ec45))
+
+
+## v2.37.0 (2025-08-19)
+
+### Features
+
+- Add explorer widget
+  ([`1bec9bd`](https://github.com/bec-project/bec_widgets/commit/1bec9bd9b2238ed484e8d25e691326efe5730f6b))
+
+
+## v2.36.0 (2025-08-18)
+
+### Features
+
+- **scan control**: Add support for literals
+  ([`f2e5a85`](https://github.com/bec-project/bec_widgets/commit/f2e5a85e616aa76d4b7ad3b3c76a24ba114ebdd1))
+
+
+## v2.35.0 (2025-08-14)
+
+### Build System
+
+- Pyside6 upgraded to 6.9.0
+  ([`44ba720`](https://github.com/bec-project/bec_widgets/commit/44ba7201b4914d63281bbed5e62d07e5c240595a))
+
+### Features
+
+- **property_manager**: Property manager widget
+  ([`926d722`](https://github.com/bec-project/bec_widgets/commit/926d7229559d189d382fe034b3afbc544e709efa))
+
+
+## v2.34.0 (2025-08-07)
+
+### Bug Fixes
+
+- Plugin widget import machinery
+  ([`9de5484`](https://github.com/bec-project/bec_widgets/commit/9de548446b9975c0f692757c66ffa07b9a849f15))
+
+- lazy import client so plugin widgets can import BECWidgets which use it indirectly - exclude
+  classes originating from bec_widgets core from plugin discovery - better errors
+
+- Use better source for plugin repo name
+  ([`f4af6eb`](https://github.com/bec-project/bec_widgets/commit/f4af6ebc5fabf5b62ec87b580476d93d52690b08))
+
+### Features
+
+- Autoformat compiled file and add docs
+  ([`a923f12`](https://github.com/bec-project/bec_widgets/commit/a923f12c974192909222fcada9eca97325866d74))
+
+- **plugin manager**: Add cli commands
+  ([`49ac7de`](https://github.com/bec-project/bec_widgets/commit/49ac7decf7d4cf461e6437f7285dc6967ee36d96))
+
+
+## v2.33.3 (2025-07-31)
+
+### Bug Fixes
+
+- **scan-history-view**: Account for async loading of scan history
+  ([`6df1d0c`](https://github.com/bec-project/bec_widgets/commit/6df1d0c31fb58c25b01e95e2247277ff2dd5d00e))
+
+### Refactoring
+
+- Improve scan history performance on loading full scan lists
+  ([`a5adf3a`](https://github.com/bec-project/bec_widgets/commit/a5adf3a97d9ff05cef833445c1e6cd8f35a9a2fa))
+
+- Make ids a set, cleanup
+  ([`c1f62ad`](https://github.com/bec-project/bec_widgets/commit/c1f62ad6cb00d9b392a8e0b6247f5260dfb37256))
+
+- Use client callback for scan history reload
+  ([`d22a331`](https://github.com/bec-project/bec_widgets/commit/d22a3317baeccfcc4e074dcef4e3912301d210c5))
+
+- **scan-history**: Add spinner for loading time of history
+  ([`50c84a7`](https://github.com/bec-project/bec_widgets/commit/50c84a766a2b021768fb2c0e8ee00b8e5f058ba7))
+
+- **scan-history**: Fix insert logic; cleanup
+  ([`946752a`](https://github.com/bec-project/bec_widgets/commit/946752a4b05804c2f59cb5c21e4c1d11709a7d44))
+
+
+## v2.33.2 (2025-07-31)
+
+### Bug Fixes
+
+- Delete choice dialog on close
+  ([`23413cf`](https://github.com/bec-project/bec_widgets/commit/23413cffabe721e35bb5bb726ec34d74dc4ffe05))
+
+- Display short lists in SignalDisplay
+  ([`4bbb8fa`](https://github.com/bec-project/bec_widgets/commit/4bbb8fa519e8a90eebfcfa34e157493c9baa7880))
+
+- Don't warn on empty DeviceEdit init
+  ([`f18eeb9`](https://github.com/bec-project/bec_widgets/commit/f18eeb9c5dccbd9348b6ee6d1477a8b7925d40fc))
+
+- Remove config, directly set device+signal
+  ([`32ce8e2`](https://github.com/bec-project/bec_widgets/commit/32ce8e2818ceacda87e48399e3ed4df0cabb2335))
+
+
+## v2.33.1 (2025-07-31)
+
+### Bug Fixes
+
+- **cli**: Ensure guis are not started twice
+  ([`cd81e7f`](https://github.com/bec-project/bec_widgets/commit/cd81e7f9ba40be23f6b930d250f743276720b277))
+
+
+## v2.33.0 (2025-07-29)
+
+### Bug Fixes
+
+- **monaco**: Forward text changed signal
+  ([`a51ef04`](https://github.com/bec-project/bec_widgets/commit/a51ef04cdf0ac8abdb7008d78b13c75b86ce9e06))
+
+### Build System
+
+- Update bec and qtmonaco min dependencies
+  ([`5f925ba`](https://github.com/bec-project/bec_widgets/commit/5f925ba4e3840219e4473d6346ece6746076f718))
+
+### Features
+
+- **monaco**: Add insert, delete and lsp header
+  ([`fc68d2c`](https://github.com/bec-project/bec_widgets/commit/fc68d2cf2d6b161d8e3b9fc9daf6185d9197deba))
+
+- **monaco**: Add vim mode
+  ([`627b49b`](https://github.com/bec-project/bec_widgets/commit/627b49b33a30e45b2bfecb57f090eecfa31af09d))
+
+- **web console**: Add set_readonly method
+  ([`c2e1642`](https://github.com/bec-project/bec_widgets/commit/c2e16429c91de7cc0e672ba36224e9031c1c4234))
+
+- **web console**: Add signal to indicate when the js backend is initialized
+  ([`2b9fe6c`](https://github.com/bec-project/bec_widgets/commit/2b9fe6c9590c8d18b7542307273176e118828681))
+
+### Testing
+
+- **web console**: Add tests for the web console
+  ([`40f4bce`](https://github.com/bec-project/bec_widgets/commit/40f4bce2854bcf333ce261229bd1703b80ced538))
+
+
+## v2.32.0 (2025-07-29)
+
+### Features
+
+- **dock area**: Add screenshot toolbar action
+  ([`fd5af01`](https://github.com/bec-project/bec_widgets/commit/fd5af0184279400ca6d8e5d2042f31be88d180f3))
+
+- **rpc_timeout**: Add decorator to override the rpc timeout
+  ([`8a214c8`](https://github.com/bec-project/bec_widgets/commit/8a214c897899d0d94d5f262591a001c127d1b155))
+
+
+## v2.31.3 (2025-07-29)
+
+### Bug Fixes
+
+- **waveform**: Fallback mechanism for auto mode to use index if scan_report_devices are not
+  available
+  ([`6bf84ae`](https://github.com/bec-project/bec_widgets/commit/6bf84aea2508ff01fe201c045ec055684da88593))
+
+
+## v2.31.2 (2025-07-29)
+
+### Bug Fixes
+
+- **bec widgets**: Always call cleanup of child widgets on cleanup
+  ([`bf86a03`](https://github.com/bec-project/bec_widgets/commit/bf86a030a08b325a08e031ff71d0716a2f2f122b))
+
+
+## v2.31.1 (2025-07-29)
+
+### Bug Fixes
+
+- **image_base**: Fix cleanup of uninitialized image layer
+  ([`c1bdc50`](https://github.com/bec-project/bec_widgets/commit/c1bdc506e8099f178acdccbe0e1109deeeaaca38))
+
+
+## v2.31.0 (2025-07-29)
+
+### Bug Fixes
+
+- **bec_main_window**: Main window have unified status bar on macOS
+  ([`1d0490f`](https://github.com/bec-project/bec_widgets/commit/1d0490fff428d51f2cdb7d35a954a7cd62cbb65c))
+
+- **color_button_native**: Removed BECWidget inheritance
+  ([`e42ffd7`](https://github.com/bec-project/bec_widgets/commit/e42ffd7c015a026d8e0967ac6b5866cbbea7bfed))
+
+- **decimal_spinbox**: Removed BECWidget inheritance
+  ([`2bd6d00`](https://github.com/bec-project/bec_widgets/commit/2bd6d0089955172134afb4d39939890026ed43f0))
+
+- **launch_window**: Logic for custom main window apps adjusted
+  ([`e090ac4`](https://github.com/bec-project/bec_widgets/commit/e090ac49b72fa15ebf1c09164ff3c6de577cb939))
+
+- **plugin_utils**: Plugins can be created from QWidgets, no need for BECWidget base class for
+  plugin creation
+  ([`c2a918e`](https://github.com/bec-project/bec_widgets/commit/c2a918ef4b77ccd7fa43d1bc0b907d55a17a6c95))
+
+- **scan_progressbar**: Added kwargs to init
+  ([`7073e75`](https://github.com/bec-project/bec_widgets/commit/7073e75adf0eeb81f4f8e27eb99fc1b7a395c751))
+
+- **utils**: Plugin template createWidget do not initialise widgets by default
+  ([`728d4ef`](https://github.com/bec-project/bec_widgets/commit/728d4efd9646ffcecd7d1a2f70988a7d7c799124))
+
+- **widgets**: Added missing __init__ files
+  ([`6bbf512`](https://github.com/bec-project/bec_widgets/commit/6bbf5126cf586063ed08d6cd489d6a9af28eac35))
+
+### Features
+
+- **bec_main_window**: Plugin and rpc created
+  ([`e4521d9`](https://github.com/bec-project/bec_widgets/commit/e4521d95286bbc598c3c05f357d247d950477b71))
+
+### Refactoring
+
+- **widgets**: All plugins regenerated
+  ([`10cbb9a`](https://github.com/bec-project/bec_widgets/commit/10cbb9a05cb96a791448caff4ffc4115b76146d7))
+
+### Testing
+
+- **launch_window**: Mainwindow raise test removed, features is supported now
+  ([`0854175`](https://github.com/bec-project/bec_widgets/commit/0854175acbda1d4de71358aec028539552a26448))
+
+
+## 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

bec_widgets/__init__.py

@@ -1,4 +1,20 @@
+import os
+import sys
+
+import PySide6QtAds as QtAds
+
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 
+if sys.platform.startswith("linux"):
+    qt_platform = os.environ.get("QT_QPA_PLATFORM", "")
+    if qt_platform != "offscreen":
+        os.environ["QT_QPA_PLATFORM"] = "xcb"
+
+# Default QtAds configuration
+QtAds.CDockManager.setConfigFlag(QtAds.CDockManager.eConfigFlag.FocusHighlighting, True)
+QtAds.CDockManager.setConfigFlag(
+    QtAds.CDockManager.eConfigFlag.RetainTabSizeWhenCloseButtonHidden, True
+)
+
 __all__ = ["BECWidget", "SafeSlot", "SafeProperty"]

bec_widgets/applications/launch_window.py

@@ -27,11 +27,11 @@ 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
-from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow, UILaunchWindow
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow, BECMainWindowNoRPC
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -395,20 +395,24 @@ class LaunchWindow(BECMainWindow):
             if isinstance(result_widget, BECMainWindow):
                 result_widget.show()
             else:
-                window = BECMainWindow()
+                window = BECMainWindowNoRPC()
                 window.setCentralWidget(result_widget)
                 window.setWindowTitle(f"BEC - {result_widget.objectName()}")
                 window.show()
             return result_widget
 
     def _launch_custom_ui_file(self, ui_file: str | None) -> BECMainWindow:
-        # Load the custom UI file
+        """
+        Load a custom .ui file. If the top-level widget is a MainWindow subclass,
+        instantiate it directly; otherwise, embed it in a UILaunchWindow.
+        """
         if ui_file is None:
             raise ValueError("UI file must be provided for custom UI file launch.")
         filename = os.path.basename(ui_file).split(".")[0]
 
         WidgetContainerUtils.raise_for_invalid_name(filename)
 
+        # Parse the UI to detect top-level widget class
         tree = ET.parse(ui_file)
         root = tree.getroot()
         # Check if the top-level widget is a QMainWindow
@@ -416,19 +420,22 @@ class LaunchWindow(BECMainWindow):
         if widget is None:
             raise ValueError("No widget found in the UI file.")
 
-        if widget.attrib.get("class") == "QMainWindow":
-            raise ValueError(
-                "Loading a QMainWindow from a UI file is currently not supported. "
-                "If you need this, please contact the BEC team or create a ticket on gitlab.psi.ch/bec/bec_widgets."
-            )
+        # Load the UI into a widget
+        loader = UILoader(None)
+        loaded = loader.loader(ui_file)
+
+        # Display the UI in a BECMainWindow
+        if isinstance(loaded, BECMainWindow):
+            window = loaded
+            window.object_name = filename
+        else:
+            window = BECMainWindow(object_name=filename)
+            window.setCentralWidget(loaded)
 
-        window = UILaunchWindow(object_name=filename)
         QApplication.processEvents()
-        result_widget = UILoader(window).loader(ui_file)
-        window.setCentralWidget(result_widget)
-        window.setWindowTitle(f"BEC - {window.object_name}")
+        window.setWindowTitle(f"BEC - {filename}")
         window.show()
-        logger.info(f"Object name of new instance: {result_widget.objectName()}, {window.gui_id}")
+        logger.info(f"Launched custom UI: {filename}, type: {type(window).__name__}")
         return window
 
     def _launch_auto_update(self, auto_update: str) -> AutoUpdates:
@@ -451,7 +458,7 @@ class LaunchWindow(BECMainWindow):
 
         WidgetContainerUtils.raise_for_invalid_name(name)
 
-        window = BECMainWindow()
+        window = BECMainWindowNoRPC()
 
         widget_instance = widget(root_widget=True, object_name=name)
         assert isinstance(widget_instance, QWidget)
@@ -542,7 +549,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

@@ -14,18 +14,21 @@ from typing import TYPE_CHECKING, Literal, TypeAlias, cast
 
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
-from bec_lib.utils.import_utils import lazy_import_from
+from bec_lib.utils.import_utils import lazy_import, lazy_import_from
 from rich.console import Console
 from rich.table import Table
 
-import bec_widgets.cli.client as client
 from bec_widgets.cli.rpc.rpc_base import RPCBase, RPCReference
 from bec_widgets.utils.serialization import register_serializer_extension
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_lib.messages import GUIRegistryStateMessage
+
+    import bec_widgets.cli.client as client
 else:
     GUIRegistryStateMessage = lazy_import_from("bec_lib.messages", "GUIRegistryStateMessage")
+    client = lazy_import("bec_widgets.cli.client")
+
 
 logger = bec_logger.logger
 
@@ -51,7 +54,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)
@@ -151,8 +154,10 @@ def wait_for_server(client: BECGuiClient):
             raise RuntimeError("GUI is not alive")
     try:
         if client._gui_started_event.wait(timeout=timeout):
-            client._gui_started_timer.cancel()
-            client._gui_started_timer.join()
+            if client._gui_started_timer is not None:
+                # cancel the timer, we are done
+                client._gui_started_timer.cancel()
+                client._gui_started_timer.join()
         else:
             raise TimeoutError("Could not connect to GUI server")
     finally:
@@ -261,13 +266,20 @@ class BECGuiClient(RPCBase):
 
     def start(self, wait: bool = False) -> None:
         """Start the GUI server."""
+        logger.warning("Using <gui>.start() is deprecated, use <gui>.show() instead.")
         return self._start(wait=wait)
 
-    def show(self):
-        """Show the GUI window."""
+    def show(self, wait=True) -> None:
+        """
+        Show the GUI window.
+        If the GUI server is not running, it will be started.
+
+        Args:
+            wait(bool): Whether to wait for the server to start. Defaults to True.
+        """
         if self._check_if_server_is_alive():
             return self._show_all()
-        return self.start(wait=True)
+        return self._start(wait=wait)
 
     def hide(self):
         """Hide the GUI window."""
@@ -382,6 +394,9 @@ class BECGuiClient(RPCBase):
         """
         Start the GUI server, and execute callback when it is launched
         """
+        if self._gui_is_alive():
+            self._gui_started_event.set()
+            return
         if self._process is None or self._process.poll() is not None:
             logger.success("GUI starting...")
             self._startup_timeout = 5
@@ -524,7 +539,7 @@ if __name__ == "__main__":  # pragma: no cover
         # Test the client_utils.py module
         gui = BECGuiClient()
 
-        gui.start(wait=True)
+        gui.show(wait=True)
         gui.new().new(widget="Waveform")
         time.sleep(10)
     finally:

bec_widgets/cli/generate_cli.py

@@ -53,7 +53,7 @@ from __future__ import annotations
 {base_imports}
 from bec_lib.logger import bec_logger
 
-from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
+from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
 {"from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets, get_plugin_client_module" if self._base else ""}
 
 logger = bec_logger.logger
@@ -180,7 +180,10 @@ class {class_name}(RPCBase):"""
                     f"Method {method} not found in class {cls.__name__}. "
                     f"Please check the USER_ACCESS list."
                 )
-
+            if hasattr(obj, "__rpc_timeout__"):
+                timeout = {"value": obj.__rpc_timeout__}
+            else:
+                timeout = {}
             if isinstance(obj, (property, QtProperty)):
                 # for the cli, we can map qt properties to regular properties
                 if is_property_setter:
@@ -205,14 +208,26 @@ class {class_name}(RPCBase):"""
     def {method}{str(sig_overload)}: ...
     """
 
-                self.content += """
-    @rpc_call"""
+                self.content += f"""
+    {self._rpc_call(timeout)}"""
             self.content += f"""
     def {method}{str(sig)}:
         \"\"\"
 {doc}
         \"\"\""""
 
+    def _rpc_call(self, timeout_info: dict[str, float | None]):
+        """
+        Decorator to mark a method as an RPC call.
+        This is used to generate the client code for the method.
+        """
+        if not timeout_info:
+            return "@rpc_call"
+        timeout = timeout_info.get("value", None)
+        return f"""
+    @rpc_timeout({timeout})
+    @rpc_call"""
+
     def write(self, file_name: str):
         """
         Write the content to a file, automatically formatted with black.

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,43 @@ 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_timeout(timeout):
+    """
+    A decorator to set a timeout for an RPC call.
+
+    Args:
+        timeout: The timeout in seconds.
+
+    Returns:
+        The decorated function.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            if "timeout" not in kwargs:
+                kwargs["timeout"] = timeout
+            return func(self, *args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
 def rpc_call(func):
     """
     A decorator for calling a function on the server.
@@ -47,15 +85,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/server.py

@@ -7,8 +7,11 @@ import signal
 import sys
 from contextlib import redirect_stderr, redirect_stdout
 
+import darkdetect
 from bec_lib.logger import bec_logger
 from bec_lib.service_config import ServiceConfig
+from bec_qthemes import apply_theme
+from qtmonaco.pylsp_provider import pylsp_server
 from qtpy.QtCore import QSize, Qt
 from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QApplication
@@ -91,6 +94,11 @@ class GUIServer:
         Run the GUI server.
         """
         self.app = QApplication(sys.argv)
+        if darkdetect.isDark():
+            apply_theme("dark")
+        else:
+            apply_theme("light")
+
         self.app.setApplicationName("BEC")
         self.app.gui_id = self.gui_id  # type: ignore
         self.setup_bec_icon()
@@ -142,6 +150,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/examples/device_manager_view/device_manager_view.py

@@ -0,0 +1,206 @@
+from typing import List
+
+import PySide6QtAds as QtAds
+import yaml
+from bec_qthemes import material_icon
+from PySide6QtAds import CDockManager, CDockWidget
+from qtpy.QtCore import Qt, QTimer
+from qtpy.QtWidgets import (
+    QPushButton,
+    QSizePolicy,
+    QSplitter,
+    QStackedLayout,
+    QTreeWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets import BECWidget
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
+from bec_widgets.widgets.control.device_manager.components.device_table_view import DeviceTableView
+from bec_widgets.widgets.control.device_manager.components.dm_config_view import DMConfigView
+from bec_widgets.widgets.control.device_manager.components.dm_ophyd_test import (
+    DeviceManagerOphydTest,
+)
+from bec_widgets.widgets.editors.monaco.monaco_widget import MonacoWidget
+from bec_widgets.widgets.editors.web_console.web_console import WebConsole
+from bec_widgets.widgets.services.bec_status_box.bec_status_box import BECStatusBox
+from bec_widgets.widgets.utility.ide_explorer.ide_explorer import IDEExplorer
+
+
+def set_splitter_weights(splitter: QSplitter, weights: List[float]) -> None:
+    """
+    Apply initial sizes to a splitter using weight ratios, e.g. [1,3,2,1].
+    Works for horizontal or vertical splitters and sets matching stretch factors.
+    """
+
+    def apply():
+        n = splitter.count()
+        if n == 0:
+            return
+        w = list(weights[:n]) + [1] * max(0, n - len(weights))
+        w = [max(0.0, float(x)) for x in w]
+        tot_w = sum(w)
+        if tot_w <= 0:
+            w = [1.0] * n
+            tot_w = float(n)
+        total_px = (
+            splitter.width() if splitter.orientation() == Qt.Horizontal else splitter.height()
+        )
+        if total_px < 2:
+            QTimer.singleShot(0, apply)
+            return
+        sizes = [max(1, int(total_px * (wi / tot_w))) for wi in w]
+        diff = total_px - sum(sizes)
+        if diff != 0:
+            idx = max(range(n), key=lambda i: w[i])
+            sizes[idx] = max(1, sizes[idx] + diff)
+        splitter.setSizes(sizes)
+        for i, wi in enumerate(w):
+            splitter.setStretchFactor(i, max(1, int(round(wi * 100))))
+
+    QTimer.singleShot(0, apply)
+
+
+class DeviceManagerView(BECWidget, QWidget):
+
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+
+        # Top-level layout hosting a toolbar and the dock manager
+        self._root_layout = QVBoxLayout(self)
+        self._root_layout.setContentsMargins(0, 0, 0, 0)
+        self._root_layout.setSpacing(0)
+        self.dock_manager = CDockManager(self)
+        self._root_layout.addWidget(self.dock_manager)
+
+        # Initialize the widgets
+        self.explorer = IDEExplorer(self)  # TODO will be replaced by explorer widget
+        self.device_table_view = DeviceTableView(self)
+        # Placeholder
+        self.dm_config_view = DMConfigView(self)
+
+        # Placeholder for ophyd test
+        WebConsole.startup_cmd = "ipython"
+        self.ophyd_test = DeviceManagerOphydTest(self)
+        self.ophyd_test_dock = QtAds.CDockWidget("Ophyd Test", self)
+        self.ophyd_test_dock.setWidget(self.ophyd_test)
+
+        # Create the dock widgets
+        self.explorer_dock = QtAds.CDockWidget("Explorer", self)
+        self.explorer_dock.setWidget(self.explorer)
+
+        self.device_table_view_dock = QtAds.CDockWidget("Device Table", self)
+        self.device_table_view_dock.setWidget(self.device_table_view)
+
+        # Device Table will be central widget
+        self.dock_manager.setCentralWidget(self.device_table_view_dock)
+
+        self.dm_config_view_dock = QtAds.CDockWidget("YAML Editor", self)
+        self.dm_config_view_dock.setWidget(self.dm_config_view)
+
+        # Add the dock widgets to the dock manager
+        self.dock_manager.addDockWidget(QtAds.DockWidgetArea.LeftDockWidgetArea, self.explorer_dock)
+        monaco_yaml_area = self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.RightDockWidgetArea, self.dm_config_view_dock
+        )
+        self.dock_manager.addDockWidget(
+            QtAds.DockWidgetArea.BottomDockWidgetArea, self.ophyd_test_dock, monaco_yaml_area
+        )
+
+        for dock in self.dock_manager.dockWidgets():
+            # dock.setFeature(CDockWidget.DockWidgetDeleteOnClose, True)#TODO implement according to MonacoDock or AdvancedDockArea
+            # dock.setFeature(CDockWidget.CustomCloseHandling, True) #TODO same
+            dock.setFeature(CDockWidget.DockWidgetClosable, False)
+            dock.setFeature(CDockWidget.DockWidgetFloatable, False)
+            dock.setFeature(CDockWidget.DockWidgetMovable, False)
+
+        # Fetch all dock areas of the dock widgets (on our case always one dock area)
+        for dock in self.dock_manager.dockWidgets():
+            area = dock.dockAreaWidget()
+            area.titleBar().setVisible(False)
+
+        # Apply stretch after the layout is done
+        self.set_default_view([2, 5, 3], [5, 5])
+
+        # Connect slots
+        self.device_table_view.selected_device.connect(self.dm_config_view.on_select_config)
+
+    ####### Default view has to be done with setting up splitters ########
+    def set_default_view(self, horizontal_weights: list, vertical_weights: list):
+        """Apply initial weights to every horizontal and vertical splitter.
+
+        Examples:
+            horizontal_weights = [1, 3, 2, 1]
+            vertical_weights   = [3, 7]  # top:bottom = 30:70
+        """
+        splitters_h = []
+        splitters_v = []
+        for splitter in self.findChildren(QSplitter):
+            if splitter.orientation() == Qt.Horizontal:
+                splitters_h.append(splitter)
+            elif splitter.orientation() == Qt.Vertical:
+                splitters_v.append(splitter)
+
+        def apply_all():
+            for s in splitters_h:
+                set_splitter_weights(s, horizontal_weights)
+            for s in splitters_v:
+                set_splitter_weights(s, vertical_weights)
+
+        QTimer.singleShot(0, apply_all)
+
+    def set_stretch(self, *, horizontal=None, vertical=None):
+        """Update splitter weights and re-apply to all splitters.
+
+        Accepts either a list/tuple of weights (e.g., [1,3,2,1]) or a role dict
+        for convenience: horizontal roles = {"left","center","right"},
+        vertical roles = {"top","bottom"}.
+        """
+
+        def _coerce_h(x):
+            if x is None:
+                return None
+            if isinstance(x, (list, tuple)):
+                return list(map(float, x))
+            if isinstance(x, dict):
+                return [
+                    float(x.get("left", 1)),
+                    float(x.get("center", x.get("middle", 1))),
+                    float(x.get("right", 1)),
+                ]
+            return None
+
+        def _coerce_v(x):
+            if x is None:
+                return None
+            if isinstance(x, (list, tuple)):
+                return list(map(float, x))
+            if isinstance(x, dict):
+                return [float(x.get("top", 1)), float(x.get("bottom", 1))]
+            return None
+
+        h = _coerce_h(horizontal)
+        v = _coerce_v(vertical)
+        if h is None:
+            h = [1, 1, 1]
+        if v is None:
+            v = [1, 1]
+        self.set_default_view(h, v)
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    device_manager_view = DeviceManagerView()
+    config = device_manager_view.client.device_manager._get_redis_device_config()
+    device_manager_view.device_table_view.set_device_config(config)
+    device_manager_view.show()
+    device_manager_view.setWindowTitle("Device Manager View")
+    device_manager_view.resize(1200, 800)
+    # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime
+    sys.exit(app.exec_())

bec_widgets/examples/device_manager_view/device_manager_widget.py

@@ -0,0 +1,73 @@
+"""Top Level wrapper for device_manager widget"""
+
+from __future__ import annotations
+
+from bec_qthemes import material_icon
+from qtpy import QtCore, QtWidgets
+
+from bec_widgets.examples.device_manager_view.device_manager_view import DeviceManagerView
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeSlot
+
+
+class DeviceManagerWidget(BECWidget, QtWidgets.QWidget):
+
+    def __init__(self, parent=None, client=None):
+        super().__init__(client=client, parent=parent)
+        self.stacked_layout = QtWidgets.QStackedLayout()
+        self.stacked_layout.setContentsMargins(0, 0, 0, 0)
+        self.stacked_layout.setSpacing(0)
+        self.stacked_layout.setStackingMode(QtWidgets.QStackedLayout.StackAll)
+        self.setLayout(self.stacked_layout)
+
+        # Add device manager view
+        self.device_manager_view = DeviceManagerView()
+        self.stacked_layout.addWidget(self.device_manager_view)
+
+        # Add overlay widget
+        self._overlay_widget = QtWidgets.QWidget(self)
+        self._customize_overlay()
+        self.stacked_layout.addWidget(self._overlay_widget)
+        self.stacked_layout.setCurrentWidget(self._overlay_widget)
+
+    def _customize_overlay(self):
+        self._overlay_widget.setStyleSheet(
+            "background: qlineargradient(x1:0, y1:0, x2:0, y2:1,stop:0 #ffffff, stop:1 #e0e0e0);"
+        )
+        self._overlay_widget.setAutoFillBackground(True)
+        self._overlay_layout = QtWidgets.QVBoxLayout()
+        self._overlay_layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self._overlay_widget.setLayout(self._overlay_layout)
+        self._overlay_widget.setSizePolicy(
+            QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Expanding
+        )
+        self.button_load_current_config = QtWidgets.QPushButton("Load Current Config")
+        icon = material_icon(icon_name="database", size=(24, 24), convert_to_pixmap=False)
+        self.button_load_current_config.setIcon(icon)
+        self._overlay_layout.addWidget(self.button_load_current_config)
+        self.button_load_current_config.clicked.connect(self._load_config_clicked)
+        self._overlay_widget.setVisible(True)
+
+    @SafeSlot()
+    def _load_config_clicked(self):
+        """Handle click on 'Load Current Config' button."""
+        config = self.client.device_manager._get_redis_device_config()
+        self.device_manager_view.device_table_view.set_device_config(config)
+        self.device_manager_view.ophyd_test.on_device_config_update(config)
+        self.stacked_layout.setCurrentWidget(self.device_manager_view)
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    device_manager = DeviceManagerWidget()
+    # config = device_manager.client.device_manager._get_redis_device_config()
+    # device_manager.device_table_view.set_device_config(config)
+    device_manager.show()
+    device_manager.setWindowTitle("Device Manager View")
+    device_manager.resize(1600, 1200)
+    # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime
+    sys.exit(app.exec_())

bec_widgets/examples/jupyter_console/jupyter_console_window.py

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

bec_widgets/tests/utils.py

@@ -96,9 +96,21 @@ class FakePositioner(BECPositioner):
         }
         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 = {
@@ -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

@@ -77,6 +77,8 @@ class BECConnector:
 
     USER_ACCESS = ["_config_dict", "_get_all_rpc", "_rpc_id"]
     EXIT_HANDLERS = {}
+    widget_removed = Signal()
+    name_established = Signal(str)
 
     def __init__(
         self,
@@ -161,8 +163,6 @@ class BECConnector:
 
         # 2) Enforce unique objectName among siblings with the same BECConnector parent
         self.setParent(parent)
-        if isinstance(self.parent(), QObject) and hasattr(self, "cleanup"):
-            self.parent().destroyed.connect(self._run_cleanup_on_deleted_parent)
 
         # Error popups
         self.error_utility = ErrorPopupUtility()
@@ -186,25 +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.
-        This method is called when the parent is deleted.
-        """
-        if not hasattr(self, "cleanup"):
-            return
-        try:
-            if not self._destroyed:
-                self.cleanup()
-                self._destroyed = True
-        except Exception:
-            content = traceback.format_exc()
-            logger.info(
-                "Failed to run cleanup on deleted parent. "
-                f"This is not necessarily an error as the parent may be deleted before the child and includes already a cleanup. The following exception was raised:\n{content}"
-            )
-
     def change_object_name(self, name: str) -> None:
         """
         Change the object name of the widget. Unregister old name and register the new one.
@@ -225,6 +206,10 @@ class BECConnector:
         self._enforce_unique_sibling_name()
         # 2) Register the object for RPC
         self.rpc_register.add_rpc(self)
+        try:
+            self.name_established.emit(self.object_name)
+        except RuntimeError:
+            return
 
     def _enforce_unique_sibling_name(self):
         """
@@ -471,6 +456,7 @@ class BECConnector:
         # i.e. Curve Item from Waveform
         else:
             self.rpc_register.remove_rpc(self)
+        self.widget_removed.emit()  # Emit the remove signal to notify listeners (eg docks in QtADS)
 
     def get_config(self, dict_output: bool = True) -> dict | BaseModel:
         """

bec_widgets/utils/bec_plugin_helper.py

@@ -38,9 +38,11 @@ def _loaded_submodules_from_specs(
         try:
             submodule.__loader__.exec_module(submodule)
         except Exception as e:
-            logger.error(
-                f"Error loading plugin {submodule}: \n{''.join(traceback.format_exception(e))}"
-            )
+            exception_text = "".join(traceback.format_exception(e))
+            if "(most likely due to a circular import)" in exception_text:
+                logger.warning(f"Circular import encountered while loading {submodule}")
+            else:
+                logger.error(f"Error loading plugin {submodule}: \n{exception_text}")
         yield submodule
 
 
@@ -59,7 +61,8 @@ def _get_widgets_from_module(module: ModuleType) -> BECClassContainer:
         module,
         predicate=lambda item: inspect.isclass(item)
         and issubclass(item, BECWidget)
-        and item is not BECWidget,
+        and item is not BECWidget
+        and not item.__module__.startswith("bec_widgets"),
     )
     return BECClassContainer(
         BECClassInfo(name=k, module=module.__name__, file=module.__loader__.get_filename(), obj=v)

bec_widgets/utils/bec_plugin_manager/create/widget.py

@@ -0,0 +1,86 @@
+import traceback
+from pathlib import Path
+from typing import Annotated
+
+import copier
+import typer
+from bec_lib.logger import bec_logger
+from bec_lib.plugin_helper import plugin_repo_path
+from bec_lib.utils.plugin_manager._constants import ANSWER_KEYS
+from bec_lib.utils.plugin_manager._util import existing_data, git_stage_files, make_commit
+
+from bec_widgets.utils.bec_plugin_manager.edit_ui import open_and_watch_ui_editor
+
+logger = bec_logger.logger
+_app = typer.Typer(rich_markup_mode="rich")
+
+
+def _commit_added_widget(repo: Path, name: str):
+    git_stage_files(repo, [".copier-answers.yml"])
+    git_stage_files(repo / repo.name / "bec_widgets" / "widgets" / name, [])
+    make_commit(repo, f"plugin-manager added new widget: {name}")
+    logger.info(f"Committing new widget {name}")
+
+
+def _widget_exists(widget_list: list[dict[str, str | bool]], name: str):
+    return name in [w["name"] for w in widget_list]
+
+
+def _editor_cb(ctx: typer.Context, value: bool):
+    if value and not ctx.params["use_ui"]:
+        raise typer.BadParameter("Can only open the editor if creating a .ui file!")
+    return value
+
+
+_bold_blue = "\033[34m\033[1m"
+_off = "\033[0m"
+_USE_UI_MSG = "Generate a .ui file for use in bec-designer."
+_OPEN_DESIGNER_MSG = f"""This app can watch for changes and recompile them to a python file imported to the widget whenever it is saved.
+To open this editor independently, you can use {_bold_blue}bec-plugin-manager edit-ui [widget_name]{_off}.
+Open the created widget .ui file in bec-designer now?"""
+
+
+@_app.command()
+def widget(
+    name: Annotated[str, typer.Argument(help="Enter a name for your widget in snake_case")],
+    use_ui: Annotated[bool, typer.Option(prompt=_USE_UI_MSG, help=_USE_UI_MSG)] = True,
+    open_editor: Annotated[
+        bool, typer.Option(prompt=_OPEN_DESIGNER_MSG, help=_OPEN_DESIGNER_MSG, callback=_editor_cb)
+    ] = True,
+):
+    """Create a new widget plugin with the given name.
+
+If [bold white]use_ui[/bold white] is set, a bec-designer .ui file will also be created. If \
+[bold white]open_editor[/bold white] is additionally set, the .ui file will be opened in \
+bec-designer and the compiled python version will be updated when changes are made and saved."""
+    if (formatted_name := name.lower().replace("-", "_")) != name:
+        logger.warning(f"Adjusting widget name from {name} to {formatted_name}")
+    if not formatted_name.isidentifier():
+        logger.error(
+            f"{name} is not a valid name for a widget (even after converting to {formatted_name}) - please enter something in snake_case"
+        )
+        exit(-1)
+    logger.info(f"Adding new widget {formatted_name} to the template...")
+    try:
+        repo = Path(plugin_repo_path())
+        plugin_data = existing_data(repo, [ANSWER_KEYS.VERSION, ANSWER_KEYS.WIDGETS])
+        if _widget_exists(plugin_data[ANSWER_KEYS.WIDGETS], formatted_name):
+            logger.error(f"Widget {formatted_name} already exists!")
+            exit(-1)
+        plugin_data[ANSWER_KEYS.WIDGETS].append({"name": formatted_name, "use_ui": use_ui})
+        copier.run_update(
+            repo,
+            data=plugin_data,
+            defaults=True,
+            unsafe=True,
+            overwrite=True,
+            vcs_ref=plugin_data[ANSWER_KEYS.VERSION],
+        )
+        _commit_added_widget(repo, formatted_name)
+    except Exception:
+        logger.error(traceback.format_exc())
+        logger.error("exiting...")
+        exit(-1)
+    logger.success(f"Added widget {formatted_name}!")
+    if open_editor:
+        open_and_watch_ui_editor(formatted_name)

bec_widgets/utils/bec_plugin_manager/edit_ui.py

@@ -0,0 +1,136 @@
+import re
+import subprocess
+from pathlib import Path
+
+from bec_lib.logger import bec_logger
+from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path
+from watchdog.events import (
+    DirCreatedEvent,
+    DirModifiedEvent,
+    DirMovedEvent,
+    FileCreatedEvent,
+    FileModifiedEvent,
+    FileMovedEvent,
+    FileSystemEvent,
+    FileSystemEventHandler,
+)
+from watchdog.observers import Observer
+
+from bec_widgets.utils.bec_designer import open_designer
+from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets
+from bec_widgets.utils.plugin_utils import get_custom_classes
+
+logger = bec_logger.logger
+
+
+class RecompileHandler(FileSystemEventHandler):
+    def __init__(self, in_file: Path, out_file: Path) -> None:
+        super().__init__()
+        self.in_file = str(in_file)
+        self.out_file = str(out_file)
+        self._pyside_import_re = re.compile(r"from PySide6\.(.*) import ")
+        self._widget_import_re = re.compile(
+            r"^from ([a-zA-Z_]*) import ([a-zA-Z_]*)$", re.MULTILINE
+        )
+        self._widget_modules = {
+            c.name: c.module for c in (get_custom_classes("bec_widgets") + get_all_plugin_widgets())
+        }
+
+    def on_created(self, event: DirCreatedEvent | FileCreatedEvent) -> None:
+        self.recompile(event)
+
+    def on_modified(self, event: DirModifiedEvent | FileModifiedEvent) -> None:
+        self.recompile(event)
+
+    def on_moved(self, event: DirMovedEvent | FileMovedEvent) -> None:
+        self.recompile(event)
+
+    def recompile(self, event: FileSystemEvent) -> None:
+        if event.src_path == self.in_file or event.dest_path == self.in_file:
+            self._recompile()
+
+    def _recompile(self):
+        logger.success(".ui file modified, recompiling...")
+        code = subprocess.call(
+            ["pyside6-uic", "--absolute-imports", self.in_file, "-o", self.out_file]
+        )
+        logger.success(f"compilation exited with code {code}")
+        if code != 0:
+            return
+        self._add_comment_to_file()
+        logger.success("updating imports...")
+        self._update_imports()
+        logger.success("formatting...")
+        code = subprocess.call(
+            ["black", "--line-length=100", "--skip-magic-trailing-comma", self.out_file]
+        )
+        if code != 0:
+            logger.error(f"Error while running black on {self.out_file}, code: {code}")
+            return
+        code = subprocess.call(
+            [
+                "isort",
+                "--line-length=100",
+                "--profile=black",
+                "--multi-line=3",
+                "--trailing-comma",
+                self.out_file,
+            ]
+        )
+        if code != 0:
+            logger.error(f"Error while running isort on {self.out_file}, code: {code}")
+            return
+        logger.success("done!")
+
+    def _add_comment_to_file(self):
+        with open(self.out_file, "r+") as f:
+            initial = f.read()
+            f.seek(0)
+            f.write(f"# Generated from {self.in_file} by bec-plugin-manager - do not edit! \n")
+            f.write(
+                "# Use 'bec-plugin-manager edit-ui [widget_name]' to make changes, and this file will be updated accordingly. \n\n"
+            )
+            f.write(initial)
+
+    def _update_imports(self):
+        with open(self.out_file, "r+") as f:
+            initial = f.read()
+            f.seek(0)
+            qtpy_imports = re.sub(
+                self._pyside_import_re, lambda ob: f"from qtpy.{ob.group(1)} import ", initial
+            )
+            print(self._widget_modules)
+            print(re.findall(self._widget_import_re, qtpy_imports))
+            widget_imports = re.sub(
+                self._widget_import_re,
+                lambda ob: (
+                    f"from {module} import {ob.group(2)}"
+                    if (module := self._widget_modules.get(ob.group(2))) is not None
+                    else ob.group(1)
+                ),
+                qtpy_imports,
+            )
+            f.write(widget_imports)
+            f.truncate()
+
+
+def open_and_watch_ui_editor(widget_name: str):
+    logger.info(f"Opening the editor for {widget_name}, and watching")
+    repo = Path(plugin_repo_path())
+    widget_dir = repo / plugin_package_name() / "bec_widgets" / "widgets" / widget_name
+    ui_file = widget_dir / f"{widget_name}.ui"
+    ui_outfile = widget_dir / f"{widget_name}_ui.py"
+
+    logger.info(
+        f"Opening the editor for {widget_name}, and watching {ui_file} for changes. Whenever you save the file, it will be recompiled to {ui_outfile}"
+    )
+    recompile_handler = RecompileHandler(ui_file, ui_outfile)
+    observer = Observer()
+    observer.schedule(recompile_handler, str(ui_file.parent))
+    observer.start()
+    try:
+        open_designer([str(ui_file)])
+    finally:
+        observer.stop()
+        observer.join()
+    logger.info("Editing session ended, exiting...")

bec_widgets/utils/bec_widget.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
 
+from datetime import datetime
 from typing import TYPE_CHECKING
 
-import darkdetect
+import PySide6QtAds as QtAds
+import shiboken6
 from bec_lib.logger import bec_logger
-from qtpy.QtCore import QObject, Slot
-from qtpy.QtWidgets import QApplication
+from qtpy.QtCore import QObject
+from qtpy.QtWidgets import QApplication, QFileDialog, QWidget
 
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
-from bec_widgets.utils.colors import set_theme
+from bec_widgets.utils.error_popups import SafeConnect, SafeSlot
+from bec_widgets.utils.rpc_decorator import rpc_timeout
+from bec_widgets.utils.widget_io import WidgetHierarchy
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_widgets.widgets.containers.dock import BECDock
@@ -23,7 +27,7 @@ class BECWidget(BECConnector):
     # The icon name is the name of the icon in the icon theme, typically a name taken
     # from fonts.google.com/icons. Override this in subclasses to set the icon name.
     ICON_NAME = "widgets"
-    USER_ACCESS = ["remove"]
+    USER_ACCESS = ["remove", "attach", "detach"]
 
     # pylint: disable=too-many-arguments
     def __init__(
@@ -41,8 +45,7 @@ class BECWidget(BECConnector):
 
         >>> class MyWidget(BECWidget, QWidget):
         >>>     def __init__(self, parent=None, client=None, config=None, gui_id=None):
-        >>>         super().__init__(client=client, config=config, gui_id=gui_id)
-        >>>         QWidget.__init__(self, parent=parent)
+        >>>         super().__init__(parent=parent, client=client, config=config, gui_id=gui_id)
 
 
         Args:
@@ -58,15 +61,6 @@ class BECWidget(BECConnector):
         )
         if not isinstance(self, QObject):
             raise RuntimeError(f"{repr(self)} is not a subclass of QWidget")
-        app = QApplication.instance()
-        if not hasattr(app, "theme"):
-            # DO NOT SET THE THEME TO AUTO! Otherwise, the qwebengineview will segfault
-            # Instead, we will set the theme to the system setting on startup
-            if darkdetect.isDark():
-                set_theme("dark")
-            else:
-                set_theme("light")
-
         if theme_update:
             logger.debug(f"Subscribing to theme updates for {self.__class__.__name__}")
             self._connect_to_theme_change()
@@ -74,9 +68,11 @@ class BECWidget(BECConnector):
     def _connect_to_theme_change(self):
         """Connect to the theme change signal."""
         qapp = QApplication.instance()
-        if hasattr(qapp, "theme_signal"):
-            qapp.theme_signal.theme_updated.connect(self._update_theme)
+        if hasattr(qapp, "theme"):
+            SafeConnect(self, qapp.theme.theme_changed, self._update_theme)
 
+    @SafeSlot(str)
+    @SafeSlot()
     def _update_theme(self, theme: str | None = None):
         """Update the theme."""
         if theme is None:
@@ -87,7 +83,7 @@ class BECWidget(BECConnector):
                 theme = "dark"
         self.apply_theme(theme)
 
-    @Slot(str)
+    @SafeSlot(str)
     def apply_theme(self, theme: str):
         """
         Apply the theme to the widget.
@@ -96,12 +92,63 @@ class BECWidget(BECConnector):
             theme(str, optional): The theme to be applied.
         """
 
+    @SafeSlot()
+    @SafeSlot(str)
+    @rpc_timeout(None)
+    def screenshot(self, file_name: str | None = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+        if not isinstance(self, QWidget):
+            logger.error("Cannot take screenshot of non-QWidget instance")
+            return
+
+        screenshot = self.grab()
+        if file_name is None:
+            file_name, _ = QFileDialog.getSaveFileName(
+                self,
+                "Save Screenshot",
+                f"bec_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png",
+                "PNG Files (*.png);;JPEG Files (*.jpg *.jpeg);;All Files (*)",
+            )
+        if not file_name:
+            return
+        screenshot.save(file_name)
+        logger.info(f"Screenshot saved to {file_name}")
+
+    def attach(self):
+        dock = WidgetHierarchy.find_ancestor(self, QtAds.CDockWidget)
+        if dock is None:
+            return
+
+        if not dock.isFloating():
+            return
+        dock.dockManager().addDockWidget(QtAds.DockWidgetArea.RightDockWidgetArea, dock)
+
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+        dock = WidgetHierarchy.find_ancestor(self, QtAds.CDockWidget)
+        if dock is None:
+            return
+        if dock.isFloating():
+            return
+        dock.setFloating()
+
     def cleanup(self):
         """Cleanup the widget."""
         with RPCRegister.delayed_broadcast():
             # All widgets need to call super().cleanup() in their cleanup method
             logger.info(f"Registry cleanup for widget {self.__class__.__name__}")
             self.rpc_register.remove_rpc(self)
+        children = self.findChildren(BECWidget)
+        for child in children:
+            if not shiboken6.isValid(child):
+                # If the child is not valid, it means it has already been deleted
+                continue
+            child.close()
+            child.deleteLater()
 
     def closeEvent(self, event):
         """Wrap the close even to ensure the rpc_register is cleaned up."""

bec_widgets/utils/colors.py

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

bec_widgets/utils/compact_popup.py

@@ -11,6 +11,7 @@ from qtpy.QtWidgets import (
     QPushButton,
     QSizePolicy,
     QSpacerItem,
+    QToolButton,
     QVBoxLayout,
     QWidget,
 )
@@ -122,15 +123,14 @@ class CompactPopupWidget(QWidget):
         self.compact_view_widget = QWidget(self)
         self.compact_view_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
         QHBoxLayout(self.compact_view_widget)
-        self.compact_view_widget.layout().setSpacing(0)
+        self.compact_view_widget.layout().setSpacing(5)
         self.compact_view_widget.layout().setContentsMargins(0, 0, 0, 0)
         self.compact_view_widget.layout().addSpacerItem(
             QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Fixed)
         )
         self.compact_label = QLabel(self.compact_view_widget)
         self.compact_status = LedLabel(self.compact_view_widget)
-        self.compact_show_popup = QPushButton(self.compact_view_widget)
-        self.compact_show_popup.setFlat(True)
+        self.compact_show_popup = QToolButton(self.compact_view_widget)
         self.compact_show_popup.setIcon(
             material_icon(icon_name="expand_content", size=(10, 10), convert_to_pixmap=False)
         )
@@ -259,12 +259,3 @@ class CompactPopupWidget(QWidget):
     @expand_popup.setter
     def expand_popup(self, popup: bool):
         self._expand_popup = popup
-
-    def closeEvent(self, event):
-        # Called by Qt, on closing - since the children widgets can be
-        # BECWidgets, it is good to explicitely call 'close' on them,
-        # to ensure proper resources cleanup
-        for child in self.container.findChildren(QWidget, options=Qt.FindDirectChildrenOnly):
-            child.close()
-
-        super().closeEvent(event)

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):
@@ -160,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:
@@ -187,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.
@@ -265,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]]:
@@ -316,9 +352,25 @@ class Crosshair(QObject):
                 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(
@@ -358,60 +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
 
-            precision = self._current_precision()
-            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, precision),
-                        round(y_snapped_scaled, precision),
-                    )
-                    self.coordinatesChanged1D.emit(coordinate_to_emit)
-                elif isinstance(item, pg.ImageItem):
-                    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])
-                    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.
@@ -462,15 +528,35 @@ class Crosshair(QObject):
                     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():
@@ -512,8 +598,18 @@ class Crosshair(QObject):
                 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:.{precision}f}"
                 break
@@ -533,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/error_popups.py

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

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

@@ -171,8 +171,9 @@ class TypedForm(BECWidget, QWidget):
 
 
 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,
@@ -204,7 +205,7 @@ class PydanticModelForm(TypedForm):
 
         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)
         )
@@ -264,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

@@ -390,17 +390,29 @@ class ListFormItem(DynamicFormItem):
 
     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_button)
-        self._buttons.addWidget(self._remove_button)
+
+        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()

bec_widgets/utils/generate_designer_plugin.py

@@ -7,7 +7,7 @@ from qtpy.QtCore import QObject
 
 from bec_widgets.utils.name_utils import pascal_to_snake
 
-EXCLUDED_PLUGINS = ["BECConnector", "BECDockArea", "BECDock", "BECFigure"]
+EXCLUDED_PLUGINS = ["BECConnector", "BECDock"]
 _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)

bec_widgets/utils/plugin_templates/plugin.template

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils.bec_designer import designer_material_icon
 {widget_import}
@@ -20,6 +21,8 @@ class {plugin_name_pascal}Plugin(QDesignerCustomWidgetInterface):  # pragma: no
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+           return QWidget()
         t = {plugin_name_pascal}(parent)
         return t
 

bec_widgets/utils/plugin_utils.py

@@ -201,7 +201,7 @@ def get_custom_classes(repo_name: str) -> BECClassContainer:
                     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):
+                    if issubclass(obj, QWidget) or issubclass(obj, BECWidget):
                         class_info.is_widget = True
                     if len(subs) == 1 and (
                         issubclass(obj, QWidget) or issubclass(obj, QGraphicsWidget)

bec_widgets/utils/property_editor.py

@@ -0,0 +1,694 @@
+from __future__ import annotations
+
+from qtpy.QtCore import QLocale, QMetaEnum, Qt, QTimer
+from qtpy.QtGui import QColor, QCursor, QFont, QIcon, QPalette
+from qtpy.QtWidgets import (
+    QCheckBox,
+    QColorDialog,
+    QComboBox,
+    QDoubleSpinBox,
+    QFileDialog,
+    QFontDialog,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLineEdit,
+    QMenu,
+    QPushButton,
+    QSizePolicy,
+    QSpinBox,
+    QToolButton,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class PropertyEditor(QWidget):
+    def __init__(self, target: QWidget, parent: QWidget | None = None, show_only_bec: bool = True):
+        super().__init__(parent)
+        self._target = target
+        self._bec_only = show_only_bec
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        # Name row
+        name_row = QHBoxLayout()
+        name_row.addWidget(QLabel("Name:"))
+        self.name_edit = QLineEdit(target.objectName())
+        self.name_edit.setEnabled(False)  # TODO implement with RPC broadcast
+        name_row.addWidget(self.name_edit)
+        layout.addLayout(name_row)
+
+        # BEC only checkbox
+        filter_row = QHBoxLayout()
+        self.chk_show_qt = QCheckBox("Show Qt properties")
+        self.chk_show_qt.setChecked(False)
+        filter_row.addWidget(self.chk_show_qt)
+        filter_row.addStretch(1)
+        layout.addLayout(filter_row)
+        self.chk_show_qt.toggled.connect(lambda checked: self.set_show_only_bec(not checked))
+
+        # Main tree widget
+        self.tree = QTreeWidget(self)
+        self.tree.setColumnCount(2)
+        self.tree.setHeaderLabels(["Property", "Value"])
+        self.tree.setAlternatingRowColors(True)
+        self.tree.setRootIsDecorated(False)
+        layout.addWidget(self.tree)
+        self._build()
+
+    def _class_chain(self):
+        chain = []
+        mo = self._target.metaObject()
+        while mo is not None:
+            chain.append(mo)
+            mo = mo.superClass()
+        return chain
+
+    def set_show_only_bec(self, flag: bool):
+        self._bec_only = flag
+        self._build()
+
+    def _set_equal_columns(self):
+        header = self.tree.header()
+        header.setSectionResizeMode(0, QHeaderView.Interactive)
+        header.setSectionResizeMode(1, QHeaderView.Interactive)
+        w = self.tree.viewport().width() or self.tree.width()
+        if w > 0:
+            half = max(1, w // 2)
+            self.tree.setColumnWidth(0, half)
+            self.tree.setColumnWidth(1, w - half)
+
+    def _build(self):
+        self.tree.clear()
+        for mo in self._class_chain():
+            class_name = mo.className()
+            if self._bec_only and not self._is_bec_metaobject(mo):
+                continue
+            group_item = QTreeWidgetItem(self.tree, [class_name])
+            group_item.setFirstColumnSpanned(True)
+            start = mo.propertyOffset()
+            end = mo.propertyCount()
+            for i in range(start, end):
+                prop = mo.property(i)
+                if (
+                    not prop.isReadable()
+                    or not prop.isWritable()
+                    or not prop.isStored()
+                    or not prop.isDesignable()
+                ):
+                    continue
+                name = prop.name()
+                if name == "objectName":
+                    continue
+                value = self._target.property(name)
+                self._add_property_row(group_item, name, value, prop)
+            if group_item.childCount() == 0:
+                idx = self.tree.indexOfTopLevelItem(group_item)
+                self.tree.takeTopLevelItem(idx)
+        self.tree.expandAll()
+        QTimer.singleShot(0, self._set_equal_columns)
+
+    def _enum_int(self, obj) -> int:
+        return int(getattr(obj, "value", obj))
+
+    def _make_sizepolicy_editor(self, name: str, sp):
+        if not isinstance(sp, QSizePolicy):
+            return None
+        wrap = QWidget(self)
+        row = QHBoxLayout(wrap)
+        row.setContentsMargins(0, 0, 0, 0)
+        row.setSpacing(4)
+        h_combo = QComboBox(wrap)
+        v_combo = QComboBox(wrap)
+        hs = QSpinBox(wrap)
+        vs = QSpinBox(wrap)
+        for b in (hs, vs):
+            b.setRange(0, 16777215)
+        policies = [
+            (QSizePolicy.Fixed, "Fixed"),
+            (QSizePolicy.Minimum, "Minimum"),
+            (QSizePolicy.Maximum, "Maximum"),
+            (QSizePolicy.Preferred, "Preferred"),
+            (QSizePolicy.Expanding, "Expanding"),
+            (QSizePolicy.MinimumExpanding, "MinExpanding"),
+            (QSizePolicy.Ignored, "Ignored"),
+        ]
+        for pol, text in policies:
+            h_combo.addItem(text, self._enum_int(pol))
+            v_combo.addItem(text, self._enum_int(pol))
+
+        def _set_current(combo, val):
+            idx = combo.findData(self._enum_int(val))
+            if idx >= 0:
+                combo.setCurrentIndex(idx)
+
+        _set_current(h_combo, sp.horizontalPolicy())
+        _set_current(v_combo, sp.verticalPolicy())
+        hs.setValue(sp.horizontalStretch())
+        vs.setValue(sp.verticalStretch())
+
+        def apply_changes():
+            hp = QSizePolicy.Policy(h_combo.currentData())
+            vp = QSizePolicy.Policy(v_combo.currentData())
+            nsp = QSizePolicy(hp, vp)
+            nsp.setHorizontalStretch(hs.value())
+            nsp.setVerticalStretch(vs.value())
+            self._target.setProperty(name, nsp)
+
+        h_combo.currentIndexChanged.connect(lambda _=None: apply_changes())
+        v_combo.currentIndexChanged.connect(lambda _=None: apply_changes())
+        hs.valueChanged.connect(lambda _=None: apply_changes())
+        vs.valueChanged.connect(lambda _=None: apply_changes())
+        row.addWidget(h_combo)
+        row.addWidget(v_combo)
+        row.addWidget(hs)
+        row.addWidget(vs)
+        return wrap
+
+    def _make_locale_editor(self, name: str, loc):
+        if not isinstance(loc, QLocale):
+            return None
+        wrap = QWidget(self)
+        row = QHBoxLayout(wrap)
+        row.setContentsMargins(0, 0, 0, 0)
+        row.setSpacing(4)
+        lang_combo = QComboBox(wrap)
+        country_combo = QComboBox(wrap)
+        for lang in QLocale.Language:
+            try:
+                lang_int = self._enum_int(lang)
+            except Exception:
+                continue
+            if lang_int < 0:
+                continue
+            name_txt = QLocale.languageToString(QLocale.Language(lang_int))
+            lang_combo.addItem(name_txt, lang_int)
+
+        def populate_countries():
+            country_combo.blockSignals(True)
+            country_combo.clear()
+            for terr in QLocale.Country:
+                try:
+                    terr_int = self._enum_int(terr)
+                except Exception:
+                    continue
+                if terr_int < 0:
+                    continue
+                text = QLocale.countryToString(QLocale.Country(terr_int))
+                country_combo.addItem(text, terr_int)
+            cur_country = self._enum_int(loc.country())
+            idx = country_combo.findData(cur_country)
+            if idx >= 0:
+                country_combo.setCurrentIndex(idx)
+            country_combo.blockSignals(False)
+
+        cur_lang = self._enum_int(loc.language())
+        idx = lang_combo.findData(cur_lang)
+        if idx >= 0:
+            lang_combo.setCurrentIndex(idx)
+        populate_countries()
+
+        def apply_locale():
+            lang = QLocale.Language(int(lang_combo.currentData()))
+            country = QLocale.Country(int(country_combo.currentData()))
+            self._target.setProperty(name, QLocale(lang, country))
+
+        lang_combo.currentIndexChanged.connect(lambda _=None: populate_countries())
+        lang_combo.currentIndexChanged.connect(lambda _=None: apply_locale())
+        country_combo.currentIndexChanged.connect(lambda _=None: apply_locale())
+        row.addWidget(lang_combo)
+        row.addWidget(country_combo)
+        return wrap
+
+    def _make_icon_editor(self, name: str, icon):
+        btn = QPushButton(self)
+        btn.setText("Choose…")
+        if isinstance(icon, QIcon) and not icon.isNull():
+            btn.setIcon(icon)
+
+        def pick():
+            path, _ = QFileDialog.getOpenFileName(
+                self, "Select Icon", "", "Images (*.png *.jpg *.jpeg *.bmp *.svg)"
+            )
+            if path:
+                ic = QIcon(path)
+                self._target.setProperty(name, ic)
+                btn.setIcon(ic)
+
+        btn.clicked.connect(pick)
+        return btn
+
+    def _spin_pair(self, ints: bool = True):
+        box1 = QSpinBox(self) if ints else QDoubleSpinBox(self)
+        box2 = QSpinBox(self) if ints else QDoubleSpinBox(self)
+        if ints:
+            box1.setRange(-10_000_000, 10_000_000)
+            box2.setRange(-10_000_000, 10_000_000)
+        else:
+            for b in (box1, box2):
+                b.setDecimals(6)
+                b.setRange(-1e12, 1e12)
+                b.setSingleStep(0.1)
+        row = QHBoxLayout()
+        row.setContentsMargins(0, 0, 0, 0)
+        row.setSpacing(4)
+        wrap = QWidget(self)
+        wrap.setLayout(row)
+        row.addWidget(box1)
+        row.addWidget(box2)
+        return wrap, box1, box2
+
+    def _spin_quad(self, ints: bool = True):
+        s = QSpinBox if ints else QDoubleSpinBox
+        boxes = [s(self) for _ in range(4)]
+        if ints:
+            for b in boxes:
+                b.setRange(-10_000_000, 10_000_000)
+        else:
+            for b in boxes:
+                b.setDecimals(6)
+                b.setRange(-1e12, 1e12)
+                b.setSingleStep(0.1)
+        row = QHBoxLayout()
+        row.setContentsMargins(0, 0, 0, 0)
+        row.setSpacing(4)
+        wrap = QWidget(self)
+        wrap.setLayout(row)
+        for b in boxes:
+            row.addWidget(b)
+        return wrap, boxes
+
+    def _make_font_editor(self, name: str, value):
+        btn = QPushButton(self)
+        if isinstance(value, QFont):
+            btn.setText(f"{value.family()}, {value.pointSize()}pt")
+        else:
+            btn.setText("Select font…")
+
+        def pick():
+            ok, font = QFontDialog.getFont(
+                value if isinstance(value, QFont) else QFont(), self, "Select Font"
+            )
+            if ok:
+                self._target.setProperty(name, font)
+                btn.setText(f"{font.family()}, {font.pointSize()}pt")
+
+        btn.clicked.connect(pick)
+        return btn
+
+    def _make_color_editor(self, initial: QColor, apply_cb):
+        btn = QPushButton(self)
+        if isinstance(initial, QColor):
+            btn.setText(initial.name())
+            btn.setStyleSheet(f"background:{initial.name()};")
+        else:
+            btn.setText("Select color…")
+
+        def pick():
+            col = QColorDialog.getColor(
+                initial if isinstance(initial, QColor) else QColor(), self, "Select Color"
+            )
+            if col.isValid():
+                apply_cb(col)
+                btn.setText(col.name())
+                btn.setStyleSheet(f"background:{col.name()};")
+
+        btn.clicked.connect(pick)
+        return btn
+
+    def _apply_palette_color(
+        self,
+        name: str,
+        pal: QPalette,
+        group: QPalette.ColorGroup,
+        role: QPalette.ColorRole,
+        col: QColor,
+    ):
+        pal.setColor(group, role, col)
+        self._target.setProperty(name, pal)
+
+    def _make_palette_editor(self, name: str, pal: QPalette):
+        if not isinstance(pal, QPalette):
+            return None
+        wrap = QWidget(self)
+        row = QHBoxLayout(wrap)
+        row.setContentsMargins(0, 0, 0, 0)
+        group_combo = QComboBox(wrap)
+        role_combo = QComboBox(wrap)
+        pick_btn = self._make_color_editor(
+            pal.color(QPalette.Active, QPalette.WindowText),
+            lambda col: self._apply_palette_color(
+                name, pal, QPalette.Active, QPalette.WindowText, col
+            ),
+        )
+        groups = [
+            (QPalette.Active, "Active"),
+            (QPalette.Inactive, "Inactive"),
+            (QPalette.Disabled, "Disabled"),
+        ]
+        for g, label in groups:
+            group_combo.addItem(label, int(getattr(g, "value", g)))
+        roles = [
+            (QPalette.WindowText, "WindowText"),
+            (QPalette.Window, "Window"),
+            (QPalette.Base, "Base"),
+            (QPalette.AlternateBase, "AlternateBase"),
+            (QPalette.ToolTipBase, "ToolTipBase"),
+            (QPalette.ToolTipText, "ToolTipText"),
+            (QPalette.Text, "Text"),
+            (QPalette.Button, "Button"),
+            (QPalette.ButtonText, "ButtonText"),
+            (QPalette.BrightText, "BrightText"),
+            (QPalette.Highlight, "Highlight"),
+            (QPalette.HighlightedText, "HighlightedText"),
+        ]
+        for r, label in roles:
+            role_combo.addItem(label, int(getattr(r, "value", r)))
+
+        def rewire_button():
+            g = QPalette.ColorGroup(int(group_combo.currentData()))
+            r = QPalette.ColorRole(int(role_combo.currentData()))
+            col = pal.color(g, r)
+            while row.count() > 2:
+                w = row.takeAt(2).widget()
+                if w:
+                    w.deleteLater()
+            btn = self._make_color_editor(
+                col, lambda c: self._apply_palette_color(name, pal, g, r, c)
+            )
+            row.addWidget(btn)
+
+        group_combo.currentIndexChanged.connect(lambda _: rewire_button())
+        role_combo.currentIndexChanged.connect(lambda _: rewire_button())
+        row.addWidget(group_combo)
+        row.addWidget(role_combo)
+        row.addWidget(pick_btn)
+        return wrap
+
+    def _make_cursor_editor(self, name: str, value):
+        combo = QComboBox(self)
+        shapes = [
+            (Qt.ArrowCursor, "Arrow"),
+            (Qt.IBeamCursor, "IBeam"),
+            (Qt.WaitCursor, "Wait"),
+            (Qt.CrossCursor, "Cross"),
+            (Qt.UpArrowCursor, "UpArrow"),
+            (Qt.SizeAllCursor, "SizeAll"),
+            (Qt.PointingHandCursor, "PointingHand"),
+            (Qt.ForbiddenCursor, "Forbidden"),
+            (Qt.WhatsThisCursor, "WhatsThis"),
+            (Qt.BusyCursor, "Busy"),
+        ]
+        current_shape = None
+        if isinstance(value, QCursor):
+            try:
+                enum_val = value.shape()
+                current_shape = int(getattr(enum_val, "value", enum_val))
+            except Exception:
+                current_shape = None
+        for shape, text in shapes:
+            combo.addItem(text, int(getattr(shape, "value", shape)))
+        if current_shape is not None:
+            idx = combo.findData(current_shape)
+            if idx >= 0:
+                combo.setCurrentIndex(idx)
+
+        def apply_index(i):
+            shape_val = int(combo.itemData(i))
+            self._target.setProperty(name, QCursor(Qt.CursorShape(shape_val)))
+
+        combo.currentIndexChanged.connect(apply_index)
+        return combo
+
+    def _add_property_row(self, parent: QTreeWidgetItem, name: str, value, prop):
+        item = QTreeWidgetItem(parent, [name, ""])
+        editor = self._make_editor(name, value, prop)
+        if editor is not None:
+            self.tree.setItemWidget(item, 1, editor)
+        else:
+            item.setText(1, repr(value))
+
+    def _is_bec_metaobject(self, mo) -> bool:
+        cname = mo.className()
+        for cls in type(self._target).mro():
+            if getattr(cls, "__name__", None) == cname:
+                mod = getattr(cls, "__module__", "")
+                return mod.startswith("bec_widgets")
+        return False
+
+    def _enum_text(self, meta_enum: QMetaEnum, value_int: int) -> str:
+        if not meta_enum.isFlag():
+            key = meta_enum.valueToKey(value_int)
+            return key.decode() if isinstance(key, (bytes, bytearray)) else (key or str(value_int))
+        parts = []
+        for i in range(meta_enum.keyCount()):
+            k = meta_enum.key(i)
+            v = meta_enum.value(i)
+            if value_int & v:
+                k = k.decode() if isinstance(k, (bytes, bytearray)) else k
+                parts.append(k)
+        return " | ".join(parts) if parts else "0"
+
+    def _enum_value_to_int(self, meta_enum: QMetaEnum, value) -> int:
+        try:
+            return int(value)
+        except Exception:
+            pass
+        v = getattr(value, "value", None)
+        if isinstance(v, (int,)):
+            return int(v)
+        n = getattr(value, "name", None)
+        if isinstance(n, str):
+            res = meta_enum.keyToValue(n)
+            if res != -1:
+                return int(res)
+        s = str(value)
+        parts = [p.strip() for p in s.replace(",", "|").split("|")]
+        keys = []
+        for p in parts:
+            if "." in p:
+                p = p.split(".")[-1]
+            keys.append(p)
+        keystr = "|".join(keys)
+        try:
+            res = meta_enum.keysToValue(keystr)
+            if res != -1:
+                return int(res)
+        except Exception:
+            pass
+        return 0
+
+    def _make_enum_editor(self, name: str, value, prop):
+        meta_enum = prop.enumerator()
+        current = self._enum_value_to_int(meta_enum, value)
+
+        if not meta_enum.isFlag():
+            combo = QComboBox(self)
+            for i in range(meta_enum.keyCount()):
+                key = meta_enum.key(i)
+                key = key.decode() if isinstance(key, (bytes, bytearray)) else key
+                combo.addItem(key, meta_enum.value(i))
+            idx = combo.findData(current)
+            if idx < 0:
+                txt = self._enum_text(meta_enum, current)
+                idx = combo.findText(txt)
+            combo.setCurrentIndex(max(idx, 0))
+
+            def apply_index(i):
+                v = combo.itemData(i)
+                self._target.setProperty(name, int(v))
+
+            combo.currentIndexChanged.connect(apply_index)
+            return combo
+
+        btn = QToolButton(self)
+        btn.setText(self._enum_text(meta_enum, current))
+        btn.setPopupMode(QToolButton.InstantPopup)
+        menu = QMenu(btn)
+        actions = []
+        for i in range(meta_enum.keyCount()):
+            key = meta_enum.key(i)
+            key = key.decode() if isinstance(key, (bytes, bytearray)) else key
+            act = menu.addAction(key)
+            act.setCheckable(True)
+            act.setChecked(bool(current & meta_enum.value(i)))
+            actions.append(act)
+        btn.setMenu(menu)
+
+        def apply_flags():
+            flags = 0
+            for i, act in enumerate(actions):
+                if act.isChecked():
+                    flags |= meta_enum.value(i)
+            self._target.setProperty(name, int(flags))
+            btn.setText(self._enum_text(meta_enum, flags))
+
+        menu.triggered.connect(lambda _a: apply_flags())
+        return btn
+
+    def _make_editor(self, name: str, value, prop):
+        from qtpy.QtCore import QPoint, QPointF, QRect, QRectF, QSize, QSizeF
+
+        if prop.isEnumType():
+            return self._make_enum_editor(name, value, prop)
+        if isinstance(value, QColor):
+            return self._make_color_editor(value, lambda col: self._target.setProperty(name, col))
+        if isinstance(value, QFont):
+            return self._make_font_editor(name, value)
+        if isinstance(value, QPalette):
+            return self._make_palette_editor(name, value)
+        if isinstance(value, QCursor):
+            return self._make_cursor_editor(name, value)
+        if isinstance(value, QSizePolicy):
+            ed = self._make_sizepolicy_editor(name, value)
+            if ed is not None:
+                return ed
+        if isinstance(value, QLocale):
+            ed = self._make_locale_editor(name, value)
+            if ed is not None:
+                return ed
+        if isinstance(value, QIcon):
+            ed = self._make_icon_editor(name, value)
+            if ed is not None:
+                return ed
+        if isinstance(value, QSize):
+            wrap, w, h = self._spin_pair(ints=True)
+            w.setValue(value.width())
+            h.setValue(value.height())
+            w.valueChanged.connect(
+                lambda _: self._target.setProperty(name, QSize(w.value(), h.value()))
+            )
+            h.valueChanged.connect(
+                lambda _: self._target.setProperty(name, QSize(w.value(), h.value()))
+            )
+            return wrap
+        if isinstance(value, QSizeF):
+            wrap, w, h = self._spin_pair(ints=False)
+            w.setValue(value.width())
+            h.setValue(value.height())
+            w.valueChanged.connect(
+                lambda _: self._target.setProperty(name, QSizeF(w.value(), h.value()))
+            )
+            h.valueChanged.connect(
+                lambda _: self._target.setProperty(name, QSizeF(w.value(), h.value()))
+            )
+            return wrap
+        if isinstance(value, QPoint):
+            wrap, x, y = self._spin_pair(ints=True)
+            x.setValue(value.x())
+            y.setValue(value.y())
+            x.valueChanged.connect(
+                lambda _: self._target.setProperty(name, QPoint(x.value(), y.value()))
+            )
+            y.valueChanged.connect(
+                lambda _: self._target.setProperty(name, QPoint(x.value(), y.value()))
+            )
+            return wrap
+        if isinstance(value, QPointF):
+            wrap, x, y = self._spin_pair(ints=False)
+            x.setValue(value.x())
+            y.setValue(value.y())
+            x.valueChanged.connect(
+                lambda _: self._target.setProperty(name, QPointF(x.value(), y.value()))
+            )
+            y.valueChanged.connect(
+                lambda _: self._target.setProperty(name, QPointF(x.value(), y.value()))
+            )
+            return wrap
+        if isinstance(value, QRect):
+            wrap, boxes = self._spin_quad(ints=True)
+            for b, v in zip(boxes, (value.x(), value.y(), value.width(), value.height())):
+                b.setValue(v)
+
+            def apply_rect():
+                self._target.setProperty(
+                    name,
+                    QRect(boxes[0].value(), boxes[1].value(), boxes[2].value(), boxes[3].value()),
+                )
+
+            for b in boxes:
+                b.valueChanged.connect(lambda _=None: apply_rect())
+            return wrap
+        if isinstance(value, QRectF):
+            wrap, boxes = self._spin_quad(ints=False)
+            for b, v in zip(boxes, (value.x(), value.y(), value.width(), value.height())):
+                b.setValue(v)
+
+            def apply_rectf():
+                self._target.setProperty(
+                    name,
+                    QRectF(boxes[0].value(), boxes[1].value(), boxes[2].value(), boxes[3].value()),
+                )
+
+            for b in boxes:
+                b.valueChanged.connect(lambda _=None: apply_rectf())
+            return wrap
+        if isinstance(value, bool):
+            w = QCheckBox(self)
+            w.setChecked(bool(value))
+            w.toggled.connect(lambda v: self._target.setProperty(name, v))
+            return w
+        if isinstance(value, int) and not isinstance(value, bool):
+            w = QSpinBox(self)
+            w.setRange(-10_000_000, 10_000_000)
+            w.setValue(int(value))
+            w.valueChanged.connect(lambda v: self._target.setProperty(name, v))
+            return w
+        if isinstance(value, float):
+            w = QDoubleSpinBox(self)
+            w.setDecimals(6)
+            w.setRange(-1e12, 1e12)
+            w.setSingleStep(0.1)
+            w.setValue(float(value))
+            w.valueChanged.connect(lambda v: self._target.setProperty(name, v))
+            return w
+        if isinstance(value, str):
+            w = QLineEdit(self)
+            w.setText(value)
+            w.editingFinished.connect(lambda: self._target.setProperty(name, w.text()))
+            return w
+        return None
+
+
+class DemoApp(QWidget):  # pragma: no cover:
+    def __init__(self):
+        super().__init__()
+
+        layout = QHBoxLayout(self)
+
+        # Create a BECWidget instance example
+        waveform = self.create_waveform()
+
+        # property editor for the BECWidget
+        property_editor = PropertyEditor(waveform, show_only_bec=True)
+
+        layout.addWidget(waveform)
+        layout.addWidget(property_editor)
+
+    def create_waveform(self):
+        """Create a new waveform widget."""
+
+        from bec_widgets.widgets.plots.waveform.waveform import Waveform
+
+        waveform = Waveform(parent=self)
+        waveform.title = "New Waveform"
+        waveform.x_label = "X Axis"
+        waveform.y_label = "Y Axis"
+        return waveform
+
+
+if __name__ == "__main__":  # pragma: no cover:
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    demo = DemoApp()
+    demo.setWindowTitle("Property Editor Demo")
+    demo.resize(1200, 800)
+    demo.show()
+    sys.exit(app.exec())

bec_widgets/utils/round_frame.py

@@ -1,11 +1,12 @@
 import pyqtgraph as pg
-from qtpy.QtCore import Property
+from qtpy.QtCore import Property, Qt
 from qtpy.QtWidgets import QApplication, QFrame, QHBoxLayout, QVBoxLayout, QWidget
 
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
 
 class RoundedFrame(QFrame):
+    # TODO this should be removed completely in favor of QSS styling, no time now
     """
     A custom QFrame with rounded corners and optional theme updates.
     The frame can contain any QWidget, however it is mainly designed to wrap PlotWidgets to provide a consistent look and feel with other BEC Widgets.
@@ -28,6 +29,9 @@ class RoundedFrame(QFrame):
         self.setProperty("skip_settings", True)
         self.setObjectName("roundedFrame")
 
+        # Ensure QSS can paint background/border on this widget
+        self.setAttribute(Qt.WA_StyledBackground, True)
+
         # Create a layout for the frame
         if orientation == "vertical":
             self.layout = QVBoxLayout(self)
@@ -45,22 +49,10 @@ class RoundedFrame(QFrame):
 
         # Automatically apply initial styles to the GraphicalLayoutWidget if applicable
         self.apply_plot_widget_style()
+        self.update_style()
 
     def apply_theme(self, theme: str):
-        """
-        Apply the theme to the frame and its content if theme updates are enabled.
-        """
-        if self.content_widget is not None and isinstance(
-            self.content_widget, pg.GraphicsLayoutWidget
-        ):
-            self.content_widget.setBackground(self.background_color)
-
-        # Update background color based on the theme
-        if theme == "light":
-            self.background_color = "#e9ecef"  # Subtle contrast for light mode
-        else:
-            self.background_color = "#141414"  # Dark mode
-
+        """Deprecated: RoundedFrame no longer handles theme; styling is QSS-driven."""
         self.update_style()
 
     @Property(int)
@@ -77,34 +69,21 @@ class RoundedFrame(QFrame):
         """
         Update the style of the frame based on the background color.
         """
-        if self.background_color:
-            self.setStyleSheet(
-                f"""
+        self.setStyleSheet(
+            f"""
                 QFrame#roundedFrame {{
-                    background-color: {self.background_color}; 
-                    border-radius: {self._radius}; /* Rounded corners */
+                    border-radius: {self._radius}px;
                 }}
             """
-            )
+        )
         self.apply_plot_widget_style()
 
     def apply_plot_widget_style(self, border: str = "none"):
         """
-        Automatically apply background, border, and axis styles to the PlotWidget.
-
-        Args:
-            border (str): Border style (e.g., 'none', '1px solid red').
+        Let QSS/pyqtgraph handle plot styling; avoid overriding here.
         """
         if isinstance(self.content_widget, pg.GraphicsLayoutWidget):
-            # Apply border style via stylesheet
-            self.content_widget.setStyleSheet(
-                f"""
-                GraphicsLayoutWidget {{
-                    border: {border}; /* Explicitly set the border */
-                }}
-            """
-            )
-            self.content_widget.setBackground(self.background_color)
+            self.content_widget.setStyleSheet("")
 
 
 class ExampleApp(QWidget):  # pragma: no cover
@@ -128,24 +107,14 @@ class ExampleApp(QWidget):  # pragma: no cover
         plot_item_2.plot([1, 2, 4, 8, 16, 32], pen="r")
         plot2.plot_item = plot_item_2
 
-        # Wrap PlotWidgets in RoundedFrame
-        rounded_plot1 = RoundedFrame(parent=self, content_widget=plot1)
-        rounded_plot2 = RoundedFrame(parent=self, content_widget=plot2)
-
-        # Add to layout
+        # Add to layout (no RoundedFrame wrapper; QSS styles plots)
         layout.addWidget(dark_button)
-        layout.addWidget(rounded_plot1)
-        layout.addWidget(rounded_plot2)
+        layout.addWidget(plot1)
+        layout.addWidget(plot2)
 
         self.setLayout(layout)
 
-        from qtpy.QtCore import QTimer
-
-        def change_theme():
-            rounded_plot1.apply_theme("light")
-            rounded_plot2.apply_theme("dark")
-
-        QTimer.singleShot(100, change_theme)
+        # Theme flip demo removed; global theming applies automatically
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/utils/rpc_decorator.py

@@ -13,3 +13,17 @@ def register_rpc_methods(cls):
         if getattr(method, "rpc_public", False):
             cls.USER_ACCESS.add(name)
     return cls
+
+
+def rpc_timeout(timeout: float | None):
+    """
+    Decorator to set a timeout for RPC methods.
+    The actual implementation of timeout handling is within the cli module. This decorator
+    is solely to inform the generate-cli command about the timeout value.
+    """
+
+    def decorator(func):
+        func.__rpc_timeout__ = timeout  # Store the timeout value in the function
+        return func
+
+    return decorator

bec_widgets/utils/serialization.py

@@ -1,3 +1,6 @@
+from typing import Type
+
+from bec_lib.codecs import BECCodec
 from bec_lib.serialization import msgpack
 from qtpy.QtCore import QPointF
 
@@ -6,39 +9,26 @@ def register_serializer_extension():
     """
     Register the serializer extension for the BECConnector.
     """
-    if not module_is_registered("bec_widgets.utils.serialization"):
-        msgpack.register_object_hook(encode_qpointf, decode_qpointf)
+    if not msgpack.is_registered(QPointF):
+        msgpack.register_codec(QPointFEncoder)
 
 
-def module_is_registered(module_name: str) -> bool:
-    """
-    Check if the module is registered in the encoder.
+class QPointFEncoder(BECCodec):
+    obj_type: Type = QPointF
 
-    Args:
-        module_name (str): The name of the module to check.
+    @staticmethod
+    def encode(obj: QPointF) -> str:
+        """
+        Encode a QPointF object to a list of floats. As this is mostly used for sending
+        data to the client, it is not necessary to convert it back to a QPointF object.
+        """
+        if isinstance(obj, QPointF):
+            return [obj.x(), obj.y()]
+        return obj
 
-    Returns:
-        bool: True if the module is registered, False otherwise.
-    """
-    # pylint: disable=protected-access
-    for enc in msgpack._encoder:
-        if enc[0].__module__ == module_name:
-            return True
-    return False
-
-
-def encode_qpointf(obj):
-    """
-    Encode a QPointF object to a list of floats. As this is mostly used for sending
-    data to the client, it is not necessary to convert it back to a QPointF object.
-    """
-    if isinstance(obj, QPointF):
-        return [obj.x(), obj.y()]
-    return obj
-
-
-def decode_qpointf(obj):
-    """
-    no-op function since QPointF is encoded as a list of floats.
-    """
-    return obj
+    @staticmethod
+    def decode(type_name: str, data: list[float]) -> list[float]:
+        """
+        no-op function since QPointF is encoded as a list of floats.
+        """
+        return data

bec_widgets/utils/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,526 @@
+# 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)
+        button.setObjectName("toolbarMenuButton")
+        button.setAutoRaise(True)
+        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 apply_theme, get_theme_name
+from bec_widgets.utils.toolbars.actions import MaterialIconAction, ToolBarAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle, ToolbarComponents
+from bec_widgets.utils.toolbars.connections import BundleConnection
+
+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)
+    apply_theme("light")
+    main_window = MainWindow()
+    main_window.show()
+    sys.exit(app.exec_())

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

bec_widgets/utils/widget_state_manager.py

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

bec_widgets/widgets/containers/advanced_dock_area/advanced_dock_area.py

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

bec_widgets/widgets/containers/advanced_dock_area/profile_utils.py

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

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

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

bec_widgets/widgets/containers/auto_update/auto_updates.py

@@ -27,6 +27,7 @@ class AutoUpdates(BECMainWindow):
     _default_dock: BECDock
     USER_ACCESS = ["enabled", "enabled.setter", "selected_device", "selected_device.setter"]
     RPC = True
+    PLUGIN = False
 
     # enforce that subclasses have the same rpc widget class
     rpc_widget_class = "AutoUpdates"

bec_widgets/widgets/containers/dock/bec_dock_area.pyproject

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

bec_widgets/widgets/containers/dock/bec_dock_area_plugin.py

@@ -1,22 +1,19 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-import os
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
-import bec_widgets
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.containers.dock import BECDockArea
+from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='BECDockArea' name='dock_area'>
+    <widget class='BECDockArea' name='bec_dock_area'>
     </widget>
 </ui>
 """
 
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
-
 
 class BECDockAreaPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
@@ -24,6 +21,8 @@ class BECDockAreaPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = BECDockArea(parent)
         return t
 
@@ -31,13 +30,13 @@ class BECDockAreaPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return DOM_XML
 
     def group(self):
-        return "BEC Plots"
+        return "BEC Containers"
 
     def icon(self):
         return designer_material_icon(BECDockArea.ICON_NAME)
 
     def includeFile(self):
-        return "dock_area"
+        return "bec_dock_area"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -52,7 +51,7 @@ class BECDockAreaPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "BECDockArea"
 
     def toolTip(self):
-        return "BECDockArea"
+        return ""
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/containers/dock/dock.py

@@ -389,6 +389,7 @@ class BECDock(BECWidget, Dock):
         if widget in self.widgets:
             self.widgets.remove(widget)
         widget.close()
+        widget.deleteLater()
 
     def delete_all(self):
         """

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
@@ -69,6 +71,7 @@ class BECDockArea(BECWidget, QWidget):
         "detach_dock",
         "attach_all",
         "save_state",
+        "screenshot",
         "restore_state",
     ]
 
@@ -104,145 +107,239 @@ 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),
+        )
+        self.toolbar.components.add_safe(
+            "screenshot",
+            MaterialIconAction(icon_name="photo_camera", tooltip="Take Screenshot", parent=self),
+        )
+
+        bundle = ToolbarBundle("dock_actions", self.toolbar.components)
+        bundle.add_action("attach_all")
+        bundle.add_action("save_state")
+        bundle.add_action("restore_state")
+        bundle.add_action("screenshot")
+        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
+        )
+        self.toolbar.components.get_action("screenshot").action.triggered.connect(self.screenshot)
 
     @SafeSlot()
     def _create_widget_from_toolbar(self, widget_name: str) -> None:
@@ -519,10 +616,10 @@ if __name__ == "__main__":  # pragma: no cover
 
     import sys
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication([])
-    set_theme("auto")
+    apply_theme("dark")
     dock_area = BECDockArea()
     dock_1 = dock_area.new(name="dock_0", widget="DarkModeButton")
     dock_1.new(widget="DarkModeButton")

bec_widgets/widgets/containers/dock/dock_area.pyproject

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

bec_widgets/widgets/containers/dock/register_bec_dock_area.py

@@ -6,7 +6,7 @@ def main():  # pragma: no cover
         return
     from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
 
-    from bec_widgets.widgets.containers.dock.dock_area_plugin import BECDockAreaPlugin
+    from bec_widgets.widgets.containers.dock.bec_dock_area_plugin import BECDockAreaPlugin
 
     QPyDesignerCustomWidgetCollection.addCustomWidget(BECDockAreaPlugin())
 

bec_widgets/widgets/containers/explorer/collapsible_tree_section.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from bec_qthemes import material_icon
+from qtpy.QtCore import QMimeData, Qt, Signal
+from qtpy.QtGui import QDrag
+from qtpy.QtWidgets import QHBoxLayout, QPushButton, QSizePolicy, QVBoxLayout, QWidget
+
+from bec_widgets.utils.colors import get_theme_palette
+from bec_widgets.utils.error_popups import SafeProperty
+
+
+class CollapsibleSection(QWidget):
+    """A widget that combines a header button with any content widget for collapsible sections
+
+    This widget contains a header button with a title and a content widget.
+    The content widget can be any QWidget. The header button can be expanded or collapsed.
+    The header also contains an "Add" button that is only visible when hovering over the section.
+
+    Signals:
+        section_reorder_requested(str, str): Emitted when the section is dragged and dropped
+                                             onto another section for reordering.
+                                             Arguments are (source_title, target_title).
+    """
+
+    section_reorder_requested = Signal(str, str)  # (source_title, target_title)
+
+    def __init__(self, parent=None, title="", indentation=10, show_add_button=False):
+        super().__init__(parent=parent)
+        self.title = title
+        self.content_widget = None
+        self.setAcceptDrops(True)
+        self._expanded = True
+
+        # Setup layout
+        self.main_layout = QVBoxLayout(self)
+        self.main_layout.setContentsMargins(indentation, 0, 0, 0)
+        self.main_layout.setSpacing(0)
+
+        header_layout = QHBoxLayout()
+        header_layout.setContentsMargins(0, 0, 4, 0)
+        header_layout.setSpacing(0)
+
+        # Create header button
+        self.header_button = QPushButton()
+        self.header_button.clicked.connect(self.toggle_expanded)
+
+        # Enable drag and drop for reordering
+        self.header_button.setAcceptDrops(True)
+        self.header_button.mousePressEvent = self._header_mouse_press_event
+        self.header_button.mouseMoveEvent = self._header_mouse_move_event
+        self.header_button.dragEnterEvent = self._header_drag_enter_event
+        self.header_button.dropEvent = self._header_drop_event
+
+        self.drag_start_position = None
+
+        # Add header to layout
+        header_layout.addWidget(self.header_button)
+        header_layout.addStretch()
+
+        self.header_add_button = QPushButton()
+        self.header_add_button.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+        self.header_add_button.setFixedSize(20, 20)
+        self.header_add_button.setToolTip("Add item")
+        self.header_add_button.setVisible(show_add_button)
+
+        self.header_add_button.setIcon(material_icon("add", size=(20, 20)))
+        header_layout.addWidget(self.header_add_button)
+
+        self.main_layout.addLayout(header_layout)
+
+        self._update_expanded_state()
+
+    def set_widget(self, widget):
+        """Set the content widget for this collapsible section"""
+        # Remove existing content widget if any
+        if self.content_widget and self.content_widget.parent() == self:
+            self.main_layout.removeWidget(self.content_widget)
+            self.content_widget.close()
+            self.content_widget.deleteLater()
+
+        self.content_widget = widget
+        if self.content_widget:
+            self.main_layout.addWidget(self.content_widget)
+
+        self._update_expanded_state()
+
+    def _update_appearance(self):
+        """Update the header button appearance based on expanded state"""
+        # Use material icons with consistent sizing to match tree items
+        icon_name = "keyboard_arrow_down" if self.expanded else "keyboard_arrow_right"
+        icon = material_icon(icon_name=icon_name, size=(20, 20), convert_to_pixmap=False)
+
+        self.header_button.setIcon(icon)
+        self.header_button.setText(self.title)
+
+        # Get theme colors
+        palette = get_theme_palette()
+        text_color = palette.text().color().name()
+
+        self.header_button.setStyleSheet(
+            f"""
+            QPushButton {{
+                font-weight: bold;
+                text-align: left;
+                margin: 0;
+                padding: 0px;
+                border: none;
+                background: transparent;
+                color: {text_color};
+                icon-size: 20px 20px;
+            }}
+        """
+        )
+
+    def toggle_expanded(self):
+        """Toggle the expanded state and update size policy"""
+        self.expanded = not self.expanded
+        self._update_expanded_state()
+
+    def _update_expanded_state(self):
+        """Update the expanded state based on current state"""
+        self._update_appearance()
+        if self.expanded:
+            if self.content_widget:
+                self.content_widget.show()
+            self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        else:
+            if self.content_widget:
+                self.content_widget.hide()
+            self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+
+    @SafeProperty(bool)
+    def expanded(self) -> bool:
+        """Get the expanded state"""
+        return self._expanded
+
+    @expanded.setter
+    def expanded(self, value: bool):
+        """Set the expanded state programmatically"""
+        if not isinstance(value, bool):
+            raise ValueError("Expanded state must be a boolean")
+        if self._expanded == value:
+            return
+        self._expanded = value
+        self._update_appearance()
+
+    def connect_add_button(self, slot):
+        """Connect a slot to the add button's clicked signal.
+
+        Args:
+            slot: The function to call when the add button is clicked.
+        """
+        self.header_add_button.clicked.connect(slot)
+
+    def _header_mouse_press_event(self, event):
+        """Handle mouse press on header for drag start"""
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.drag_start_position = event.pos()
+        QPushButton.mousePressEvent(self.header_button, event)
+
+    def _header_mouse_move_event(self, event):
+        """Handle mouse move to start drag operation"""
+        if event.buttons() & Qt.MouseButton.LeftButton and self.drag_start_position is not None:
+
+            # Check if we've moved far enough to start a drag
+            if (event.pos() - self.drag_start_position).manhattanLength() >= 10:
+
+                self._start_drag()
+        QPushButton.mouseMoveEvent(self.header_button, event)
+
+    def _start_drag(self):
+        """Start the drag operation with a properly aligned widget pixmap"""
+        drag = QDrag(self.header_button)
+        mime_data = QMimeData()
+        mime_data.setText(f"section:{self.title}")
+        drag.setMimeData(mime_data)
+
+        # Grab a pixmap of the widget
+        widget_pixmap = self.header_button.grab()
+
+        drag.setPixmap(widget_pixmap)
+
+        # Set the hotspot to where the mouse was pressed on the widget
+        drag.setHotSpot(self.drag_start_position)
+
+        drag.exec_(Qt.MoveAction)
+
+    def _header_drag_enter_event(self, event):
+        """Handle drag enter on header"""
+        if event.mimeData().hasText() and event.mimeData().text().startswith("section:"):
+            event.acceptProposedAction()
+        else:
+            event.ignore()
+
+    def _header_drop_event(self, event):
+        """Handle drop on header"""
+        if event.mimeData().hasText() and event.mimeData().text().startswith("section:"):
+            source_title = event.mimeData().text().replace("section:", "")
+            if source_title != self.title:
+                # Emit signal to parent to handle reordering
+                self.section_reorder_requested.emit(source_title, self.title)
+            event.acceptProposedAction()
+        else:
+            event.ignore()

bec_widgets/widgets/containers/explorer/explorer.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QSizePolicy, QSpacerItem, QSplitter, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.colors import get_theme_palette
+from bec_widgets.widgets.containers.explorer.collapsible_tree_section import CollapsibleSection
+
+
+class Explorer(BECWidget, QWidget):
+    """
+    A widget that combines multiple collapsible sections for an explorer-like interface.
+    Each section can be expanded or collapsed, and sections can be reordered. The explorer
+    can contain also sub-explorers for nested structures.
+    """
+
+    RPC = False
+    PLUGIN = False
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        # Main layout
+        self.main_layout = QVBoxLayout(self)
+        self.main_layout.setContentsMargins(0, 0, 0, 0)
+        self.main_layout.setSpacing(0)
+
+        # Splitter for sections
+        self.splitter = QSplitter(Qt.Orientation.Vertical)
+        self.main_layout.addWidget(self.splitter)
+
+        # Spacer for when all sections are collapsed
+        self.expander = QSpacerItem(0, 0)
+        self.main_layout.addItem(self.expander)
+
+        # Registry of sections
+        self.sections: list[CollapsibleSection] = []
+
+        # Setup splitter styling
+        self._setup_splitter_styling()
+
+    def add_section(self, section: CollapsibleSection) -> None:
+        """
+        Add a collapsible section to the explorer
+
+        Args:
+            section (CollapsibleSection): The section to add
+        """
+        if not isinstance(section, CollapsibleSection):
+            raise TypeError("section must be an instance of CollapsibleSection")
+
+        if section in self.sections:
+            return
+
+        self.sections.append(section)
+        self.splitter.addWidget(section)
+
+        # Connect the section's toggle to update spacer
+        section.header_button.clicked.connect(self._update_spacer)
+
+        # Connect section reordering if supported
+        if hasattr(section, "section_reorder_requested"):
+            section.section_reorder_requested.connect(self._handle_section_reorder)
+
+        self._update_spacer()
+
+    def remove_section(self, section: CollapsibleSection) -> None:
+        """
+        Remove a collapsible section from the explorer
+
+        Args:
+            section (CollapsibleSection): The section to remove
+        """
+        if section not in self.sections:
+            return
+        self.sections.remove(section)
+        section.deleteLater()
+        section.close()
+
+        # Disconnect signals
+        try:
+            section.header_button.clicked.disconnect(self._update_spacer)
+            if hasattr(section, "section_reorder_requested"):
+                section.section_reorder_requested.disconnect(self._handle_section_reorder)
+        except RuntimeError:
+            # Signals already disconnected
+            pass
+
+        self._update_spacer()
+
+    def get_section(self, title: str) -> CollapsibleSection | None:
+        """Get a section by its title"""
+        for section in self.sections:
+            if section.title == title:
+                return section
+        return None
+
+    def _setup_splitter_styling(self) -> None:
+        """Setup the splitter styling with theme colors"""
+        palette = get_theme_palette()
+        separator_color = palette.mid().color()
+
+        self.splitter.setStyleSheet(
+            f"""
+            QSplitter::handle {{
+                height: 0.1px;
+                background-color: rgba({separator_color.red()}, {separator_color.green()}, {separator_color.blue()}, 60);
+            }}
+        """
+        )
+
+    def _update_spacer(self) -> None:
+        """Update the spacer size based on section states"""
+        any_expanded = any(section.expanded for section in self.sections)
+
+        if any_expanded:
+            self.expander.changeSize(0, 0, QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+        else:
+            self.expander.changeSize(
+                0, 10, QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Expanding
+            )
+
+    def _handle_section_reorder(self, source_title: str, target_title: str) -> None:
+        """Handle reordering of sections"""
+        if source_title == target_title:
+            return
+
+        source_section = self.get_section(source_title)
+        target_section = self.get_section(target_title)
+
+        if not source_section or not target_section:
+            return
+
+        # Get current indices
+        source_index = self.splitter.indexOf(source_section)
+        target_index = self.splitter.indexOf(target_section)
+
+        if source_index == -1 or target_index == -1:
+            return
+
+        # Insert at target position
+        self.splitter.insertWidget(target_index, source_section)
+
+        # Update sections
+        self.sections.remove(source_section)
+        self.sections.insert(target_index, source_section)
+
+
+if __name__ == "__main__":
+    import os
+
+    from qtpy.QtWidgets import QApplication, QLabel
+
+    from bec_widgets.widgets.containers.explorer.script_tree_widget import ScriptTreeWidget
+
+    app = QApplication([])
+    explorer = Explorer()
+    section = CollapsibleSection(title="SCRIPTS", indentation=0)
+
+    script_explorer = Explorer()
+    script_widget = ScriptTreeWidget()
+    local_scripts_section = CollapsibleSection(title="Local")
+    local_scripts_section.set_widget(script_widget)
+    script_widget.set_directory(os.path.abspath("./"))
+    script_explorer.add_section(local_scripts_section)
+
+    section.set_widget(script_explorer)
+    explorer.add_section(section)
+    shared_script_section = CollapsibleSection(title="Shared")
+    shared_script_widget = ScriptTreeWidget()
+    shared_script_widget.set_directory(os.path.abspath("./"))
+    shared_script_section.set_widget(shared_script_widget)
+    script_explorer.add_section(shared_script_section)
+    macros_section = CollapsibleSection(title="MACROS", indentation=0)
+    macros_section.set_widget(QLabel("Macros will be implemented later"))
+    explorer.add_section(macros_section)
+    explorer.show()
+    app.exec()

bec_widgets/widgets/containers/explorer/script_tree_widget.py

@@ -0,0 +1,387 @@
+import os
+from pathlib import Path
+
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QModelIndex, QRect, QRegularExpression, QSortFilterProxyModel, Qt, Signal
+from qtpy.QtGui import QAction, QPainter
+from qtpy.QtWidgets import QFileSystemModel, QStyledItemDelegate, QTreeView, QVBoxLayout, QWidget
+
+from bec_widgets.utils.colors import get_theme_palette
+from bec_widgets.utils.toolbars.actions import MaterialIconAction
+
+logger = bec_logger.logger
+
+
+class FileItemDelegate(QStyledItemDelegate):
+    """Custom delegate to show action buttons on hover"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.hovered_index = QModelIndex()
+        self.file_actions: list[QAction] = []
+        self.dir_actions: list[QAction] = []
+        self.button_rects: list[QRect] = []
+        self.current_file_path = ""
+
+    def add_file_action(self, action: QAction) -> None:
+        """Add an action for files"""
+        self.file_actions.append(action)
+
+    def add_dir_action(self, action: QAction) -> None:
+        """Add an action for directories"""
+        self.dir_actions.append(action)
+
+    def clear_actions(self) -> None:
+        """Remove all actions"""
+        self.file_actions.clear()
+        self.dir_actions.clear()
+
+    def paint(self, painter, option, index):
+        """Paint the item with action buttons on hover"""
+        # Paint the default item
+        super().paint(painter, option, index)
+
+        # Early return if not hovering over this item
+        if index != self.hovered_index:
+            return
+
+        tree_view = self.parent()
+        if not isinstance(tree_view, QTreeView):
+            return
+
+        proxy_model = tree_view.model()
+        if not isinstance(proxy_model, QSortFilterProxyModel):
+            return
+
+        source_index = proxy_model.mapToSource(index)
+        source_model = proxy_model.sourceModel()
+        if not isinstance(source_model, QFileSystemModel):
+            return
+
+        is_dir = source_model.isDir(source_index)
+        file_path = source_model.filePath(source_index)
+        self.current_file_path = file_path
+
+        # Choose appropriate actions based on item type
+        actions = self.dir_actions if is_dir else self.file_actions
+        if actions:
+            self._draw_action_buttons(painter, option, actions)
+
+    def _draw_action_buttons(self, painter, option, actions: list[QAction]):
+        """Draw action buttons on the right side"""
+        button_size = 18
+        margin = 4
+        spacing = 2
+
+        # Calculate total width needed for all buttons
+        total_width = len(actions) * button_size + (len(actions) - 1) * spacing
+
+        # Clear previous button rects and create new ones
+        self.button_rects.clear()
+
+        # Calculate starting position (right side of the item)
+        start_x = option.rect.right() - total_width - margin
+        current_x = start_x
+
+        painter.save()
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        # Get theme colors for better integration
+        palette = get_theme_palette()
+        button_bg = palette.button().color()
+        button_bg.setAlpha(150)  # Semi-transparent
+
+        for action in actions:
+            if not action.isVisible():
+                continue
+
+            # Calculate button position
+            button_rect = QRect(
+                current_x,
+                option.rect.top() + (option.rect.height() - button_size) // 2,
+                button_size,
+                button_size,
+            )
+            self.button_rects.append(button_rect)
+
+            # Draw button background
+            painter.setBrush(button_bg)
+            painter.setPen(palette.mid().color())
+            painter.drawRoundedRect(button_rect, 3, 3)
+
+            # Draw action icon
+            icon = action.icon()
+            if not icon.isNull():
+                icon_rect = button_rect.adjusted(2, 2, -2, -2)
+                icon.paint(painter, icon_rect)
+
+            # Move to next button position
+            current_x += button_size + spacing
+
+        painter.restore()
+
+    def editorEvent(self, event, model, option, index):
+        """Handle mouse events for action buttons"""
+        # Early return if not a left click
+        if not (
+            event.type() == event.Type.MouseButtonPress
+            and event.button() == Qt.MouseButton.LeftButton
+        ):
+            return super().editorEvent(event, model, option, index)
+
+        # Early return if not a proxy model
+        if not isinstance(model, QSortFilterProxyModel):
+            return super().editorEvent(event, model, option, index)
+
+        source_index = model.mapToSource(index)
+        source_model = model.sourceModel()
+
+        # Early return if not a file system model
+        if not isinstance(source_model, QFileSystemModel):
+            return super().editorEvent(event, model, option, index)
+
+        is_dir = source_model.isDir(source_index)
+        actions = self.dir_actions if is_dir else self.file_actions
+
+        # Check which button was clicked
+        visible_actions = [action for action in actions if action.isVisible()]
+        for i, button_rect in enumerate(self.button_rects):
+            if button_rect.contains(event.pos()) and i < len(visible_actions):
+                # Trigger the action
+                visible_actions[i].trigger()
+                return True
+
+        return super().editorEvent(event, model, option, index)
+
+    def set_hovered_index(self, index):
+        """Set the currently hovered index"""
+        self.hovered_index = index
+
+
+class ScriptTreeWidget(QWidget):
+    """A simple tree widget for scripts using QFileSystemModel - designed to be injected into CollapsibleSection"""
+
+    file_selected = Signal(str)  # Script file path selected
+    file_open_requested = Signal(str)  # File open button clicked
+    file_renamed = Signal(str, str)  # Old path, new path
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        # Create layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        # Create tree view
+        self.tree = QTreeView()
+        self.tree.setHeaderHidden(True)
+        self.tree.setRootIsDecorated(True)
+
+        # Enable mouse tracking for hover effects
+        self.tree.setMouseTracking(True)
+
+        # Create file system model
+        self.model = QFileSystemModel()
+        self.model.setNameFilters(["*.py"])
+        self.model.setNameFilterDisables(False)
+
+        # Create proxy model to filter out underscore directories
+        self.proxy_model = QSortFilterProxyModel()
+        self.proxy_model.setFilterRegularExpression(QRegularExpression("^[^_].*"))
+        self.proxy_model.setSourceModel(self.model)
+        self.tree.setModel(self.proxy_model)
+
+        # Create and set custom delegate
+        self.delegate = FileItemDelegate(self.tree)
+        self.tree.setItemDelegate(self.delegate)
+
+        # Add default open button for files
+        action = MaterialIconAction(icon_name="file_open", tooltip="Open file", parent=self)
+        action.action.triggered.connect(self._on_file_open_requested)
+        self.delegate.add_file_action(action.action)
+
+        # Remove unnecessary columns
+        self.tree.setColumnHidden(1, True)  # Hide size column
+        self.tree.setColumnHidden(2, True)  # Hide type column
+        self.tree.setColumnHidden(3, True)  # Hide date modified column
+
+        # Apply BEC styling
+        self._apply_styling()
+
+        # Script specific properties
+        self.directory = None
+
+        # Connect signals
+        self.tree.clicked.connect(self._on_item_clicked)
+        self.tree.doubleClicked.connect(self._on_item_double_clicked)
+
+        # Install event filter for hover tracking
+        self.tree.viewport().installEventFilter(self)
+
+        # Add to layout
+        layout.addWidget(self.tree)
+
+    def _apply_styling(self):
+        """Apply styling to the tree widget"""
+        # Get theme colors for subtle tree lines
+        palette = get_theme_palette()
+        subtle_line_color = palette.mid().color()
+        subtle_line_color.setAlpha(80)
+
+        # pylint: disable=f-string-without-interpolation
+        tree_style = f""" 
+            QTreeView {{ 
+                border: none;
+                outline: 0;
+                show-decoration-selected: 0;
+            }}
+            QTreeView::branch {{
+                border-image: none;
+                background: transparent;
+            }}
+
+            QTreeView::item {{
+                border: none;
+                padding: 0px;
+                margin: 0px;
+            }}
+            QTreeView::item:hover {{
+                background: palette(midlight);
+                border: none;
+                padding: 0px;
+                margin: 0px;
+                text-decoration: none;
+            }}
+            QTreeView::item:selected {{
+                background: palette(highlight);
+                color: palette(highlighted-text);
+            }}
+            QTreeView::item:selected:hover {{
+                background: palette(highlight);
+            }}
+        """
+
+        self.tree.setStyleSheet(tree_style)
+
+    def eventFilter(self, obj, event):
+        """Handle mouse move events for hover tracking"""
+        # Early return if not the tree viewport
+        if obj != self.tree.viewport():
+            return super().eventFilter(obj, event)
+
+        if event.type() == event.Type.MouseMove:
+            index = self.tree.indexAt(event.pos())
+            if index.isValid():
+                self.delegate.set_hovered_index(index)
+            else:
+                self.delegate.set_hovered_index(QModelIndex())
+            self.tree.viewport().update()
+            return super().eventFilter(obj, event)
+
+        if event.type() == event.Type.Leave:
+            self.delegate.set_hovered_index(QModelIndex())
+            self.tree.viewport().update()
+            return super().eventFilter(obj, event)
+
+        return super().eventFilter(obj, event)
+
+    def set_directory(self, directory):
+        """Set the scripts directory"""
+        self.directory = directory
+
+        # Early return if directory doesn't exist
+        if not directory or not os.path.exists(directory):
+            return
+
+        root_index = self.model.setRootPath(directory)
+        # Map the source model index to proxy model index
+        proxy_root_index = self.proxy_model.mapFromSource(root_index)
+        self.tree.setRootIndex(proxy_root_index)
+        self.tree.expandAll()
+
+    def _on_item_clicked(self, index: QModelIndex):
+        """Handle item clicks"""
+        # Map proxy index back to source index
+        source_index = self.proxy_model.mapToSource(index)
+
+        # Early return for directories
+        if self.model.isDir(source_index):
+            return
+
+        file_path = self.model.filePath(source_index)
+
+        # Early return if not a valid file
+        if not file_path or not os.path.isfile(file_path):
+            return
+
+        path_obj = Path(file_path)
+
+        # Only emit signal for Python files
+        if path_obj.suffix.lower() == ".py":
+            logger.info(f"Script selected: {file_path}")
+            self.file_selected.emit(file_path)
+
+    def _on_item_double_clicked(self, index: QModelIndex):
+        """Handle item double-clicks"""
+        # Map proxy index back to source index
+        source_index = self.proxy_model.mapToSource(index)
+
+        # Early return for directories
+        if self.model.isDir(source_index):
+            return
+
+        file_path = self.model.filePath(source_index)
+
+        # Early return if not a valid file
+        if not file_path or not os.path.isfile(file_path):
+            return
+
+        # Emit signal to open the file
+        logger.info(f"File open requested via double-click: {file_path}")
+        self.file_open_requested.emit(file_path)
+
+    def _on_file_open_requested(self):
+        """Handle file open action triggered"""
+        logger.info("File open requested")
+        # Early return if no hovered item
+        if not self.delegate.hovered_index.isValid():
+            return
+
+        source_index = self.proxy_model.mapToSource(self.delegate.hovered_index)
+        file_path = self.model.filePath(source_index)
+
+        # Early return if not a valid file
+        if not file_path or not os.path.isfile(file_path):
+            return
+
+        self.file_open_requested.emit(file_path)
+
+    def add_file_action(self, action: QAction) -> None:
+        """Add an action for file items"""
+        self.delegate.add_file_action(action)
+
+    def add_dir_action(self, action: QAction) -> None:
+        """Add an action for directory items"""
+        self.delegate.add_dir_action(action)
+
+    def clear_actions(self) -> None:
+        """Remove all actions from items"""
+        self.delegate.clear_actions()
+
+    def refresh(self):
+        """Refresh the tree view"""
+        if self.directory is None:
+            return
+        self.model.setRootPath("")  # Reset
+        root_index = self.model.setRootPath(self.directory)
+        proxy_root_index = self.proxy_model.mapFromSource(root_index)
+        self.tree.setRootIndex(proxy_root_index)
+
+    def expand_all(self):
+        """Expand all items in the tree"""
+        self.tree.expandAll()
+
+    def collapse_all(self):
+        """Collapse all items in the tree"""
+        self.tree.collapseAll()

bec_widgets/widgets/containers/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/bec_main_window.pyproject

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

bec_widgets/widgets/containers/main_window/bec_main_window_plugin.py

@@ -0,0 +1,73 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+from qtpy.QtCore import QSize
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECMainWindow' name='bec_main_window'>
+    </widget>
+</ui>
+"""
+
+
+class BECMainWindowPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        # We want to initialize BECMainWindow upon starting designer
+        t = BECMainWindow(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Containers"
+
+    def icon(self):
+        return designer_material_icon(BECMainWindow.ICON_NAME)
+
+    def includeFile(self):
+        return "bec_main_window"
+
+    def initialize(self, form_editor):
+        import os
+
+        from qtpy.QtCore import Qt
+        from qtpy.QtWidgets import QApplication
+
+        import bec_widgets
+
+        MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+        QApplication.setAttribute(Qt.AA_DontUseNativeMenuBar, True)
+        app = QApplication.instance()
+        icon = QIcon()
+        icon.addFile(
+            os.path.join(MODULE_PATH, "assets", "app_icons", "BEC-General-App.png"),
+            size=QSize(48, 48),
+        )
+        app.setWindowIcon(icon)
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return True
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "BECMainWindow"
+
+    def toolTip(self):
+        return "BECMainWindow"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/containers/main_window/main_window.py

@@ -1,9 +1,20 @@
+from __future__ import annotations
+
 import os
 
 from bec_lib.endpoints import MessageEndpoints
-from qtpy.QtCore import QEvent, QSize, Qt, QTimer
+from qtpy.QtCore import QEasingCurve, QEvent, QPropertyAnimation, QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QActionGroup, QIcon
-from qtpy.QtWidgets import QApplication, QFrame, QLabel, QMainWindow, QStyle, QVBoxLayout, QWidget
+from qtpy.QtWidgets import (
+    QApplication,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QMainWindow,
+    QStyle,
+    QVBoxLayout,
+    QWidget,
+)
 
 import bec_widgets
 from bec_widgets.utils import UILoader
@@ -11,15 +22,27 @@ from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.widget_io import WidgetHierarchy
+from bec_widgets.widgets.containers.main_window.addons.hover_widget import HoverWidget
+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__)
 
+# Ensure the application does not use the native menu bar on macOS to be consistent with linux development.
+QApplication.setAttribute(Qt.AA_DontUseNativeMenuBar, True)
+
 
 class BECMainWindow(BECWidget, QMainWindow):
-    RPC = False
-    PLUGIN = False
+    RPC = True
+    PLUGIN = True
+    SCAN_PROGRESS_WIDTH = 100  # px
+    STATUS_BAR_WIDGETS_EXPIRE_TIME = 60_000  # milliseconds
 
     def __init__(
         self,
@@ -33,7 +56,16 @@ 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()
 
@@ -42,6 +74,34 @@ class BECMainWindow(BECWidget, QMainWindow):
             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
     ################################################################################
@@ -61,33 +121,163 @@ class BECMainWindow(BECWidget, QMainWindow):
         """
         Prepare the BEC specific widgets in the status bar.
         """
-        status_bar = self.statusBar()
 
         # Left: App‑ID label
         self._app_id_label = QLabel()
         self._app_id_label.setAlignment(
             Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter
         )
-        status_bar.addWidget(self._app_id_label)
+        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._client_info_label = ScrollLabel()
+        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
         )
-        status_bar.addWidget(self._client_info_label, 1)
+        # 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("")
+        )
 
-    def _add_separator(self):
+    ################################################################################
+    # 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.
+        Add a vertically centred separator to the status bar or just return it as a separate object.
         """
         status_bar = self.statusBar()
 
@@ -106,6 +296,8 @@ class BECMainWindow(BECWidget, QMainWindow):
         vbox.addStretch()
         wrapper.setFixedWidth(line.sizeHint().width())
 
+        if separate_object:
+            return wrapper
         status_bar.addWidget(wrapper)
 
     def _init_bec_icon(self):
@@ -165,7 +357,7 @@ class BECMainWindow(BECWidget, QMainWindow):
 
         ########################################
         # Theme menu
-        theme_menu = menu_bar.addMenu("Theme")
+        theme_menu = menu_bar.addMenu("View")
 
         theme_group = QActionGroup(self)
         light_theme_action = QAction("Light Theme", self, checkable=True)
@@ -182,11 +374,12 @@ class BECMainWindow(BECWidget, QMainWindow):
         dark_theme_action.triggered.connect(lambda: self.change_theme("dark"))
 
         # Set the default theme
-        theme = self.app.theme.theme
-        if theme == "light":
-            light_theme_action.setChecked(True)
-        elif theme == "dark":
-            dark_theme_action.setChecked(True)
+        if hasattr(self.app, "theme") and self.app.theme:
+            theme_name = self.app.theme.theme.lower()
+            if "light" in theme_name:
+                light_theme_action.setChecked(True)
+            elif "dark" in theme_name:
+                dark_theme_action.setChecked(True)
 
         ########################################
         # Help menu
@@ -234,10 +427,10 @@ class BECMainWindow(BECWidget, QMainWindow):
             msg(dict): The message to display, should contain:
             meta(dict): Metadata about the message, usually empty.
         """
-        # self._client_info_label.setText("")
         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():
@@ -251,12 +444,12 @@ class BECMainWindow(BECWidget, QMainWindow):
     @SafeSlot(str)
     def change_theme(self, theme: str):
         """
-        Change the theme of the application.
+        Change the theme of the application and propagate it to widgets.
 
         Args:
-            theme(str): The theme to apply, either "light" or "dark".
+            theme(str): Either "light" or "dark".
         """
-        apply_theme(theme)
+        apply_theme(theme)  # emits theme_updated and applies palette globally
 
     def event(self, event):
         if event.type() == QEvent.Type.StatusTip:
@@ -279,21 +472,39 @@ class BECMainWindow(BECWidget, QMainWindow):
                     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
+class BECMainWindowNoRPC(BECMainWindow):
+    RPC = False
+    PLUGIN = False
 
 
 if __name__ == "__main__":
     import sys
 
     app = QApplication(sys.argv)
-    main_window = UILaunchWindow()
+    main_window = BECMainWindow()
     main_window.show()
+    main_window.resize(800, 600)
     sys.exit(app.exec())

bec_widgets/widgets/containers/main_window/register_bec_main_window.py

@@ -0,0 +1,17 @@
+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.containers.main_window.bec_main_window_plugin import (
+        BECMainWindowPlugin,
+    )
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECMainWindowPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

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

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils.bec_designer import designer_material_icon
 from bec_widgets.widgets.control.buttons.button_abort.button_abort import AbortButton
@@ -20,6 +21,8 @@ class AbortButtonPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = AbortButton(parent)
         return t
 

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

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

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

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils.bec_designer import designer_material_icon
 from bec_widgets.widgets.control.buttons.button_reset.button_reset import ResetButton
@@ -20,6 +21,8 @@ class ResetButtonPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = ResetButton(parent)
         return t
 
@@ -48,7 +51,7 @@ class ResetButtonPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "ResetButton"
 
     def toolTip(self):
-        return "A button that reset the scan queue."
+        return "A button that resets the scan queue."
 
     def whatsThis(self):
         return self.toolTip()

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

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils.bec_designer import designer_material_icon
 from bec_widgets.widgets.control.buttons.button_resume.button_resume import ResumeButton
@@ -20,6 +21,8 @@ class ResumeButtonPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = ResumeButton(parent)
         return t
 

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

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

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

@@ -1,10 +1,9 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-import os
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
-import bec_widgets
 from bec_widgets.utils.bec_designer import designer_material_icon
 from bec_widgets.widgets.control.buttons.stop_button.stop_button import StopButton
 
@@ -15,8 +14,6 @@ DOM_XML = """
 </ui>
 """
 
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
-
 
 class StopButtonPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
@@ -24,6 +21,8 @@ class StopButtonPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = StopButton(parent)
         return t
 

bec_widgets/widgets/control/device_control/position_indicator/position_indicator_plugin.py

@@ -1,10 +1,9 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-import os
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
-import bec_widgets
 from bec_widgets.utils.bec_designer import designer_material_icon
 from bec_widgets.widgets.control.device_control.position_indicator.position_indicator import (
     PositionIndicator,
@@ -17,8 +16,6 @@ DOM_XML = """
 </ui>
 """
 
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
-
 
 class PositionIndicatorPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
@@ -26,6 +23,8 @@ class PositionIndicatorPlugin(QDesignerCustomWidgetInterface):  # pragma: no cov
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = PositionIndicator(parent)
         return t
 
@@ -54,7 +53,7 @@ class PositionIndicatorPlugin(QDesignerCustomWidgetInterface):  # pragma: no cov
         return "PositionIndicator"
 
     def toolTip(self):
-        return "PositionIndicator"
+        return ""
 
     def whatsThis(self):
         return self.toolTip()

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_box/positioner_box/positioner_box.py

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

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

@@ -1,12 +1,13 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
-import os
-
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
+from bec_widgets.widgets.control.device_control.positioner_box.positioner_box.positioner_box import (
+    PositionerBox,
+)
 
 DOM_XML = """
 <ui language='c++'>
@@ -14,7 +15,6 @@ DOM_XML = """
     </widget>
 </ui>
 """
-MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 
 
 class PositionerBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
@@ -23,6 +23,8 @@ class PositionerBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = PositionerBox(parent)
         return t
 
@@ -30,7 +32,7 @@ class PositionerBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return DOM_XML
 
     def group(self):
-        return "Device Control"
+        return "BEC Device Control"
 
     def icon(self):
         return designer_material_icon(PositionerBox.ICON_NAME)

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

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils.bec_designer import designer_material_icon
 from bec_widgets.widgets.control.device_control.positioner_box.positioner_box_2d.positioner_box_2d import (
@@ -22,6 +23,8 @@ class PositionerBox2DPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = PositionerBox2D(parent)
         return t
 
@@ -29,7 +32,7 @@ class PositionerBox2DPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return DOM_XML
 
     def group(self):
-        return "Device Control"
+        return "BEC Device Control"
 
     def icon(self):
         return designer_material_icon(PositionerBox2D.ICON_NAME)

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

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

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

@@ -1,12 +1,13 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
-import os
-
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.control.device_control.positioner_box import PositionerControlLine
+from bec_widgets.widgets.control.device_control.positioner_box.positioner_control_line.positioner_control_line import (
+    PositionerControlLine,
+)
 
 DOM_XML = """
 <ui language='c++'>
@@ -14,7 +15,6 @@ DOM_XML = """
     </widget>
 </ui>
 """
-MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 
 
 class PositionerControlLinePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
@@ -23,6 +23,8 @@ class PositionerControlLinePlugin(QDesignerCustomWidgetInterface):  # pragma: no
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = PositionerControlLine(parent)
         return t
 
@@ -30,7 +32,7 @@ class PositionerControlLinePlugin(QDesignerCustomWidgetInterface):  # pragma: no
         return DOM_XML
 
     def group(self):
-        return "Device Control"
+        return "BEC Device Control"
 
     def icon(self):
         return designer_material_icon(PositionerControlLine.ICON_NAME)
@@ -51,7 +53,7 @@ class PositionerControlLinePlugin(QDesignerCustomWidgetInterface):  # pragma: no
         return "PositionerControlLine"
 
     def toolTip(self):
-        return "A widget that controls a single positioner in line form."
+        return "A widget that controls a single device."
 
     def whatsThis(self):
         return self.toolTip()

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

@@ -15,7 +15,7 @@ logger = bec_logger.logger
 
 
 class PositionerGroupBox(QGroupBox):
-    PLUGIN = True
+
     position_update = Signal(float)
 
     def __init__(self, parent, dev_name):
@@ -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()
@@ -55,8 +60,9 @@ class PositionerGroupBox(QGroupBox):
 class PositionerGroup(BECWidget, QWidget):
     """Simple Widget to control a positioner in box form"""
 
+    PLUGIN = True
     ICON_NAME = "grid_view"
-    USER_ACCESS = ["set_positioners"]
+    USER_ACCESS = ["set_positioners", "attach", "detach", "screenshot"]
 
     # Signal emitted to inform listeners about a position update of the first positioner
     position_update = Signal(float)

bec_widgets/widgets/control/device_control/positioner_group/positioner_group.pyproject

@@ -1 +1 @@
-{'files': ['positioner_group.py']}
+{'files': ['positioner_group.py']}

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

@@ -1,9 +1,8 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
-import os
-
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils.bec_designer import designer_material_icon
 from bec_widgets.widgets.control.device_control.positioner_group.positioner_group import (
@@ -16,7 +15,6 @@ DOM_XML = """
     </widget>
 </ui>
 """
-MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 
 
 class PositionerGroupPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
@@ -25,6 +23,8 @@ class PositionerGroupPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = PositionerGroup(parent)
         return t
 
@@ -32,7 +32,7 @@ class PositionerGroupPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return DOM_XML
 
     def group(self):
-        return "Device Control"
+        return "BEC Device Control"
 
     def icon(self):
         return designer_material_icon(PositionerGroup.ICON_NAME)
@@ -53,7 +53,7 @@ class PositionerGroupPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "PositionerGroup"
 
     def toolTip(self):
-        return "Container Widget to control positioners in compact form, in a grid"
+        return "Simple Widget to control a positioner in box form"
 
     def whatsThis(self):
         return self.toolTip()

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.
@@ -112,9 +112,11 @@ class DeviceInputBase(BECWidget):
             WidgetIO.set_value(widget=self, value=device)
             self.config.default = device
         else:
-            logger.warning(f"Device {device} is not in the filtered selection.")
+            logger.warning(
+                f"Device {device} is not in the filtered selection of {self}: {self.devices}."
+            )
 
-    @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,
@@ -131,9 +133,10 @@ class DeviceInputBase(BECWidget):
         # Filter based on readout priority
         devs = [dev for dev in devs if self._check_readout_filter(dev)]
         self.devices = [device.name for device in devs]
-        self.set_device(current_device)
+        if current_device != "":
+            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 +149,7 @@ class DeviceInputBase(BECWidget):
 
     ### QtProperties ###
 
-    @Property(
+    @SafeProperty(
         "QStringList",
         doc="List of devices. If updated, it will disable the apply filters property.",
     )
@@ -165,7 +168,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 +180,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 +190,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 +203,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 +216,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 +229,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 +242,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 +255,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 +268,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 +281,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 +294,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

@@ -6,7 +6,7 @@ from qtpy.QtCore import Property
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.filter_io import FilterIO
+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
 
@@ -55,7 +55,7 @@ class DeviceSignalInputBase(BECWidget):
         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
         )
 
@@ -69,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:
@@ -108,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)
@@ -271,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_combo_box.pyproject

@@ -1,3 +1 @@
-{
-    "files": ["device_combobox.py"]
-}
+{'files': ['device_combobox.py']}

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

@@ -1,22 +1,19 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-import os
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
-import bec_widgets
 from bec_widgets.utils.bec_designer import designer_material_icon
 from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='DeviceComboBox' name='device_combobox'>
+    <widget class='DeviceComboBox' name='device_combo_box'>
     </widget>
 </ui>
 """
 
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
-
 
 class DeviceComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
@@ -24,6 +21,8 @@ class DeviceComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = DeviceComboBox(parent)
         return t
 
@@ -37,7 +36,7 @@ class DeviceComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return designer_material_icon(DeviceComboBox.ICON_NAME)
 
     def includeFile(self):
-        return "device_combobox"
+        return "device_combo_box"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -52,7 +51,7 @@ class DeviceComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "DeviceComboBox"
 
     def toolTip(self):
-        return "Device ComboBox Example for BEC Widgets"
+        return ""
 
     def whatsThis(self):
         return self.toolTip()

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

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

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

bec_widgets/widgets/control/device_input/device_line_edit/device_line_edit.pyproject

@@ -1,3 +1 @@
-{
-    "files": ["device_line_edit.py"]
-}
+{'files': ['device_line_edit.py']}

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

@@ -1,10 +1,9 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-import os
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
-import bec_widgets
 from bec_widgets.utils.bec_designer import designer_material_icon
 from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
     DeviceLineEdit,
@@ -17,8 +16,6 @@ DOM_XML = """
 </ui>
 """
 
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
-
 
 class DeviceLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
@@ -26,6 +23,8 @@ class DeviceLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = DeviceLineEdit(parent)
         return t
 
@@ -54,7 +53,7 @@ class DeviceLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "DeviceLineEdit"
 
     def toolTip(self):
-        return "Device LineEdit Example for BEC Widgets with autocomplete."
+        return ""
 
     def whatsThis(self):
         return self.toolTip()

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

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils.bec_designer import designer_material_icon
 from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
@@ -20,6 +21,8 @@ class SignalComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = SignalComboBox(parent)
         return t
 
@@ -48,7 +51,7 @@ class SignalComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "SignalComboBox"
 
     def toolTip(self):
-        return "Signal ComboBox Example for BEC Widgets with autocomplete."
+        return ""
 
     def whatsThis(self):
         return self.toolTip()

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

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 from bec_lib.device import Positioner
 from qtpy.QtCore import QSize, Signal
 from qtpy.QtWidgets import QComboBox, QSizePolicy
 
-from bec_widgets.utils.error_popups import SafeSlot
+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 (
@@ -54,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.
@@ -90,6 +93,69 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
                 self.insertItem(0, "Hinted Signals")
                 self.model().item(0).setEnabled(False)
 
+    @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.
@@ -102,21 +168,21 @@ 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
     # pylint: disable=import-outside-toplevel
     from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
-    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.utils.colors import apply_theme
 
     app = QApplication([])
-    set_theme("dark")
+    apply_theme("dark")
     widget = QWidget()
     widget.setFixedSize(200, 200)
     layout = QVBoxLayout()

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

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