scratch - device manager

Automatically generated by python-semantic-release

.github/workflows/child_repos.yml

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

.github/workflows/ci.yml

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

CHANGELOG.md

@@ -1,6 +1,510 @@
 # CHANGELOG
 
 
+## 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

bec_widgets/applications/launch_window.py

@@ -31,7 +31,7 @@ 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)

bec_widgets/cli/client.py

@@ -12,7 +12,7 @@ from typing import Literal, Optional
 
 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
 
 logger = bec_logger.logger
@@ -29,6 +29,7 @@ class _WidgetsEnumType(str, enum.Enum):
 _Widgets = {
     "AbortButton": "AbortButton",
     "BECDockArea": "BECDockArea",
+    "BECMainWindow": "BECMainWindow",
     "BECProgressBar": "BECProgressBar",
     "BECQueue": "BECQueue",
     "BECStatusBox": "BECStatusBox",
@@ -37,20 +38,24 @@ _Widgets = {
     "DeviceBrowser": "DeviceBrowser",
     "DeviceComboBox": "DeviceComboBox",
     "DeviceLineEdit": "DeviceLineEdit",
+    "Heatmap": "Heatmap",
     "Image": "Image",
     "LogPanel": "LogPanel",
     "Minesweeper": "Minesweeper",
+    "MonacoWidget": "MonacoWidget",
     "MotorMap": "MotorMap",
     "MultiWaveform": "MultiWaveform",
     "PositionIndicator": "PositionIndicator",
     "PositionerBox": "PositionerBox",
     "PositionerBox2D": "PositionerBox2D",
     "PositionerControlLine": "PositionerControlLine",
+    "PositionerGroup": "PositionerGroup",
     "ResetButton": "ResetButton",
     "ResumeButton": "ResumeButton",
     "RingProgressBar": "RingProgressBar",
     "SBBMonitor": "SBBMonitor",
     "ScanControl": "ScanControl",
+    "ScanProgressBar": "ScanProgressBar",
     "ScatterWaveform": "ScatterWaveform",
     "SignalComboBox": "SignalComboBox",
     "SignalLabel": "SignalLabel",
@@ -409,6 +414,13 @@ class BECDockArea(RPCBase):
             dict: The state of the dock area.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @rpc_call
     def restore_state(
         self, state: "dict" = None, missing: "Literal['ignore', 'error']" = "ignore", extra="bottom"
@@ -423,6 +435,14 @@ class BECDockArea(RPCBase):
         """
 
 
+class BECMainWindow(RPCBase):
+    @rpc_call
+    def remove(self):
+        """
+        Cleanup the BECConnector
+        """
+
+
 class BECProgressBar(RPCBase):
     """A custom progress bar with smooth transitions. The displayed text can be customized using a template."""
 
@@ -1181,6 +1201,551 @@ class EllipticalROI(RPCBase):
         """
 
 
+class Heatmap(RPCBase):
+    """Heatmap widget for visualizing 2d grid data with color mapping for the z-axis."""
+
+    @property
+    @rpc_call
+    def enable_toolbar(self) -> "bool":
+        """
+        Show Toolbar.
+        """
+
+    @enable_toolbar.setter
+    @rpc_call
+    def enable_toolbar(self) -> "bool":
+        """
+        Show Toolbar.
+        """
+
+    @property
+    @rpc_call
+    def enable_side_panel(self) -> "bool":
+        """
+        Show Side Panel
+        """
+
+    @enable_side_panel.setter
+    @rpc_call
+    def enable_side_panel(self) -> "bool":
+        """
+        Show Side Panel
+        """
+
+    @property
+    @rpc_call
+    def enable_fps_monitor(self) -> "bool":
+        """
+        Enable the FPS monitor.
+        """
+
+    @enable_fps_monitor.setter
+    @rpc_call
+    def enable_fps_monitor(self) -> "bool":
+        """
+        Enable the FPS monitor.
+        """
+
+    @rpc_call
+    def set(self, **kwargs):
+        """
+        Set the properties of the plot widget.
+
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+
+        Possible properties:
+            - title: str
+            - x_label: str
+            - y_label: str
+            - x_scale: Literal["linear", "log"]
+            - y_scale: Literal["linear", "log"]
+            - x_lim: tuple
+            - y_lim: tuple
+            - legend_label_size: int
+        """
+
+    @property
+    @rpc_call
+    def title(self) -> "str":
+        """
+        Set title of the plot.
+        """
+
+    @title.setter
+    @rpc_call
+    def title(self) -> "str":
+        """
+        Set title of the plot.
+        """
+
+    @property
+    @rpc_call
+    def x_label(self) -> "str":
+        """
+        The set label for the x-axis.
+        """
+
+    @x_label.setter
+    @rpc_call
+    def x_label(self) -> "str":
+        """
+        The set label for the x-axis.
+        """
+
+    @property
+    @rpc_call
+    def y_label(self) -> "str":
+        """
+        The set label for the y-axis.
+        """
+
+    @y_label.setter
+    @rpc_call
+    def y_label(self) -> "str":
+        """
+        The set label for the y-axis.
+        """
+
+    @property
+    @rpc_call
+    def x_limits(self) -> "QPointF":
+        """
+        Get the x limits of the plot.
+        """
+
+    @x_limits.setter
+    @rpc_call
+    def x_limits(self) -> "QPointF":
+        """
+        Get the x limits of the plot.
+        """
+
+    @property
+    @rpc_call
+    def y_limits(self) -> "QPointF":
+        """
+        Get the y limits of the plot.
+        """
+
+    @y_limits.setter
+    @rpc_call
+    def y_limits(self) -> "QPointF":
+        """
+        Get the y limits of the plot.
+        """
+
+    @property
+    @rpc_call
+    def x_grid(self) -> "bool":
+        """
+        Show grid on the x-axis.
+        """
+
+    @x_grid.setter
+    @rpc_call
+    def x_grid(self) -> "bool":
+        """
+        Show grid on the x-axis.
+        """
+
+    @property
+    @rpc_call
+    def y_grid(self) -> "bool":
+        """
+        Show grid on the y-axis.
+        """
+
+    @y_grid.setter
+    @rpc_call
+    def y_grid(self) -> "bool":
+        """
+        Show grid on the y-axis.
+        """
+
+    @property
+    @rpc_call
+    def inner_axes(self) -> "bool":
+        """
+        Show inner axes of the plot widget.
+        """
+
+    @inner_axes.setter
+    @rpc_call
+    def inner_axes(self) -> "bool":
+        """
+        Show inner axes of the plot widget.
+        """
+
+    @property
+    @rpc_call
+    def outer_axes(self) -> "bool":
+        """
+        Show the outer axes of the plot widget.
+        """
+
+    @outer_axes.setter
+    @rpc_call
+    def outer_axes(self) -> "bool":
+        """
+        Show the outer axes of the plot widget.
+        """
+
+    @property
+    @rpc_call
+    def auto_range_x(self) -> "bool":
+        """
+        Set auto range for the x-axis.
+        """
+
+    @auto_range_x.setter
+    @rpc_call
+    def auto_range_x(self) -> "bool":
+        """
+        Set auto range for the x-axis.
+        """
+
+    @property
+    @rpc_call
+    def auto_range_y(self) -> "bool":
+        """
+        Set auto range for the y-axis.
+        """
+
+    @auto_range_y.setter
+    @rpc_call
+    def auto_range_y(self) -> "bool":
+        """
+        Set auto range for the y-axis.
+        """
+
+    @property
+    @rpc_call
+    def minimal_crosshair_precision(self) -> "int":
+        """
+        Minimum decimal places for crosshair when dynamic precision is enabled.
+        """
+
+    @minimal_crosshair_precision.setter
+    @rpc_call
+    def minimal_crosshair_precision(self) -> "int":
+        """
+        Minimum decimal places for crosshair when dynamic precision is enabled.
+        """
+
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
+    @property
+    @rpc_call
+    def color_map(self) -> "str":
+        """
+        Set the color map of the image.
+        """
+
+    @color_map.setter
+    @rpc_call
+    def color_map(self) -> "str":
+        """
+        Set the color map of the image.
+        """
+
+    @property
+    @rpc_call
+    def v_range(self) -> "QPointF":
+        """
+        Set the v_range of the main image.
+        """
+
+    @v_range.setter
+    @rpc_call
+    def v_range(self) -> "QPointF":
+        """
+        Set the v_range of the main image.
+        """
+
+    @property
+    @rpc_call
+    def v_min(self) -> "float":
+        """
+        Get the minimum value of the v_range.
+        """
+
+    @v_min.setter
+    @rpc_call
+    def v_min(self) -> "float":
+        """
+        Get the minimum value of the v_range.
+        """
+
+    @property
+    @rpc_call
+    def v_max(self) -> "float":
+        """
+        Get the maximum value of the v_range.
+        """
+
+    @v_max.setter
+    @rpc_call
+    def v_max(self) -> "float":
+        """
+        Get the maximum value of the v_range.
+        """
+
+    @property
+    @rpc_call
+    def lock_aspect_ratio(self) -> "bool":
+        """
+        Whether the aspect ratio is locked.
+        """
+
+    @lock_aspect_ratio.setter
+    @rpc_call
+    def lock_aspect_ratio(self) -> "bool":
+        """
+        Whether the aspect ratio is locked.
+        """
+
+    @property
+    @rpc_call
+    def autorange(self) -> "bool":
+        """
+        Whether autorange is enabled.
+        """
+
+    @autorange.setter
+    @rpc_call
+    def autorange(self) -> "bool":
+        """
+        Whether autorange is enabled.
+        """
+
+    @property
+    @rpc_call
+    def autorange_mode(self) -> "str":
+        """
+        Autorange mode.
+
+        Options:
+            - "max": Use the maximum value of the image for autoranging.
+            - "mean": Use the mean value of the image for autoranging.
+        """
+
+    @autorange_mode.setter
+    @rpc_call
+    def autorange_mode(self) -> "str":
+        """
+        Autorange mode.
+
+        Options:
+            - "max": Use the maximum value of the image for autoranging.
+            - "mean": Use the mean value of the image for autoranging.
+        """
+
+    @rpc_call
+    def enable_colorbar(
+        self,
+        enabled: "bool",
+        style: "Literal['full', 'simple']" = "full",
+        vrange: "tuple[int, int] | None" = None,
+    ):
+        """
+        Enable the colorbar and switch types of colorbars.
+
+        Args:
+            enabled(bool): Whether to enable the colorbar.
+            style(Literal["full", "simple"]): The type of colorbar to enable.
+            vrange(tuple): The range of values to use for the colorbar.
+        """
+
+    @property
+    @rpc_call
+    def enable_simple_colorbar(self) -> "bool":
+        """
+        Enable the simple colorbar.
+        """
+
+    @enable_simple_colorbar.setter
+    @rpc_call
+    def enable_simple_colorbar(self) -> "bool":
+        """
+        Enable the simple colorbar.
+        """
+
+    @property
+    @rpc_call
+    def enable_full_colorbar(self) -> "bool":
+        """
+        Enable the full colorbar.
+        """
+
+    @enable_full_colorbar.setter
+    @rpc_call
+    def enable_full_colorbar(self) -> "bool":
+        """
+        Enable the full colorbar.
+        """
+
+    @property
+    @rpc_call
+    def interpolation_method(self) -> "str":
+        """
+        The interpolation method used for the heatmap.
+        """
+
+    @interpolation_method.setter
+    @rpc_call
+    def interpolation_method(self) -> "str":
+        """
+        The interpolation method used for the heatmap.
+        """
+
+    @property
+    @rpc_call
+    def oversampling_factor(self) -> "float":
+        """
+        The oversampling factor for grid resolution.
+        """
+
+    @oversampling_factor.setter
+    @rpc_call
+    def oversampling_factor(self) -> "float":
+        """
+        The oversampling factor for grid resolution.
+        """
+
+    @property
+    @rpc_call
+    def enforce_interpolation(self) -> "bool":
+        """
+        Whether to enforce interpolation even for grid scans.
+        """
+
+    @enforce_interpolation.setter
+    @rpc_call
+    def enforce_interpolation(self) -> "bool":
+        """
+        Whether to enforce interpolation even for grid scans.
+        """
+
+    @property
+    @rpc_call
+    def fft(self) -> "bool":
+        """
+        Whether FFT postprocessing is enabled.
+        """
+
+    @fft.setter
+    @rpc_call
+    def fft(self) -> "bool":
+        """
+        Whether FFT postprocessing is enabled.
+        """
+
+    @property
+    @rpc_call
+    def log(self) -> "bool":
+        """
+        Whether logarithmic scaling is applied.
+        """
+
+    @log.setter
+    @rpc_call
+    def log(self) -> "bool":
+        """
+        Whether logarithmic scaling is applied.
+        """
+
+    @property
+    @rpc_call
+    def main_image(self) -> "ImageItem":
+        """
+        Access the main image item.
+        """
+
+    @rpc_call
+    def add_roi(
+        self,
+        kind: "Literal['rect', 'circle', 'ellipse']" = "rect",
+        name: "str | None" = None,
+        line_width: "int | None" = 5,
+        pos: "tuple[float, float] | None" = (10, 10),
+        size: "tuple[float, float] | None" = (50, 50),
+        movable: "bool" = True,
+        **pg_kwargs,
+    ) -> "RectangularROI | CircularROI":
+        """
+        Add a ROI to the image.
+
+        Args:
+            kind(str): The type of ROI to add. Options are "rect" or "circle".
+            name(str): The name of the ROI.
+            line_width(int): The line width of the ROI.
+            pos(tuple): The position of the ROI.
+            size(tuple): The size of the ROI.
+            movable(bool): Whether the ROI is movable.
+            **pg_kwargs: Additional arguments for the ROI.
+
+        Returns:
+            RectangularROI | CircularROI: The created ROI object.
+        """
+
+    @rpc_call
+    def remove_roi(self, roi: "int | str"):
+        """
+        Remove an ROI by index or label via the ROIController.
+        """
+
+    @property
+    @rpc_call
+    def rois(self) -> "list[BaseROI]":
+        """
+        Get the list of ROIs.
+        """
+
+    @rpc_call
+    def plot(
+        self,
+        x_name: "str",
+        y_name: "str",
+        z_name: "str",
+        x_entry: "None | str" = None,
+        y_entry: "None | str" = None,
+        z_entry: "None | str" = None,
+        color_map: "str | None" = "plasma",
+        validate_bec: "bool" = True,
+        interpolation: "Literal['linear', 'nearest'] | None" = None,
+        enforce_interpolation: "bool | None" = None,
+        oversampling_factor: "float | None" = None,
+        lock_aspect_ratio: "bool | None" = None,
+        show_config_label: "bool | None" = None,
+        reload: "bool" = False,
+    ):
+        """
+        Plot the heatmap with the given x, y, and z data.
+
+        Args:
+            x_name (str): The name of the x-axis signal.
+            y_name (str): The name of the y-axis signal.
+            z_name (str): The name of the z-axis signal.
+            x_entry (str | None): The entry for the x-axis signal.
+            y_entry (str | None): The entry for the y-axis signal.
+            z_entry (str | None): The entry for the z-axis signal.
+            color_map (str | None): The color map to use for the heatmap.
+            validate_bec (bool): Whether to validate the entries against BEC signals.
+            interpolation (Literal["linear", "nearest"] | None): The interpolation method to use.
+            enforce_interpolation (bool | None): Whether to enforce interpolation even for grid scans.
+            oversampling_factor (float | None): Factor to oversample the grid resolution.
+            lock_aspect_ratio (bool | None): Whether to lock the aspect ratio of the image.
+            show_config_label (bool | None): Whether to show the configuration label in the heatmap.
+            reload (bool): Whether to reload the heatmap with new data.
+        """
+
+
 class Image(RPCBase):
     """Image widget for displaying 2D data."""
 
@@ -1413,6 +1978,13 @@ class Image(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def color_map(self) -> "str":
@@ -1879,6 +2451,146 @@ class LogPanel(RPCBase):
 class Minesweeper(RPCBase): ...
 
 
+class MonacoWidget(RPCBase):
+    """A simple Monaco editor widget"""
+
+    @rpc_call
+    def set_text(self, text: str) -> None:
+        """
+        Set the text in the Monaco editor.
+
+        Args:
+            text (str): The text to set in the editor.
+        """
+
+    @rpc_call
+    def get_text(self) -> str:
+        """
+        Get the current text from the Monaco editor.
+        """
+
+    @rpc_call
+    def insert_text(self, text: str, line: int | None = None, column: int | None = None) -> None:
+        """
+        Insert text at the current cursor position or at a specified line and column.
+
+        Args:
+            text (str): The text to insert.
+            line (int, optional): The line number (1-based) to insert the text at. Defaults to None.
+            column (int, optional): The column number (1-based) to insert the text at. Defaults to None.
+        """
+
+    @rpc_call
+    def delete_line(self, line: int | None = None) -> None:
+        """
+        Delete a line in the Monaco editor.
+
+        Args:
+            line (int, optional): The line number (1-based) to delete. If None, the current line will be deleted.
+        """
+
+    @rpc_call
+    def set_language(self, language: str) -> None:
+        """
+        Set the programming language for syntax highlighting in the Monaco editor.
+
+        Args:
+            language (str): The programming language to set (e.g., "python", "javascript").
+        """
+
+    @rpc_call
+    def get_language(self) -> str:
+        """
+        Get the current programming language set in the Monaco editor.
+        """
+
+    @rpc_call
+    def set_theme(self, theme: str) -> None:
+        """
+        Set the theme for the Monaco editor.
+
+        Args:
+            theme (str): The theme to set (e.g., "vs-dark", "light").
+        """
+
+    @rpc_call
+    def get_theme(self) -> str:
+        """
+        Get the current theme of the Monaco editor.
+        """
+
+    @rpc_call
+    def set_readonly(self, read_only: bool) -> None:
+        """
+        Set the Monaco editor to read-only mode.
+
+        Args:
+            read_only (bool): If True, the editor will be read-only.
+        """
+
+    @rpc_call
+    def set_cursor(
+        self,
+        line: int,
+        column: int = 1,
+        move_to_position: Literal[None, "center", "top", "position"] = None,
+    ) -> None:
+        """
+        Set the cursor position in the Monaco editor.
+
+        Args:
+            line (int): Line number (1-based).
+            column (int): Column number (1-based), defaults to 1.
+            move_to_position (Literal[None, "center", "top", "position"], optional): Position to move the cursor to.
+        """
+
+    @rpc_call
+    def current_cursor(self) -> dict[str, int]:
+        """
+        Get the current cursor position in the Monaco editor.
+
+        Returns:
+            dict[str, int]: A dictionary with keys 'line' and 'column' representing the cursor position.
+        """
+
+    @rpc_call
+    def set_minimap_enabled(self, enabled: bool) -> None:
+        """
+        Enable or disable the minimap in the Monaco editor.
+
+        Args:
+            enabled (bool): If True, the minimap will be enabled; otherwise, it will be disabled.
+        """
+
+    @rpc_call
+    def set_vim_mode_enabled(self, enabled: bool) -> None:
+        """
+        Enable or disable Vim mode in the Monaco editor.
+
+        Args:
+            enabled (bool): If True, Vim mode will be enabled; otherwise, it will be disabled.
+        """
+
+    @rpc_call
+    def set_lsp_header(self, header: str) -> None:
+        """
+        Set the LSP (Language Server Protocol) header for the Monaco editor.
+        The header is used to provide context for language servers but is not displayed in the editor.
+
+        Args:
+            header (str): The LSP header to set.
+        """
+
+    @rpc_call
+    def get_lsp_header(self) -> str:
+        """
+        Get the current LSP header set in the Monaco editor.
+
+        Returns:
+            str: The LSP header.
+        """
+
+
 class MotorMap(RPCBase):
     """Motor map widget for plotting motor positions in 2D including a trace of the last points."""
 
@@ -2153,6 +2865,13 @@ class MotorMap(RPCBase):
         The font size of the legend font.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def color(self) -> "tuple":
@@ -2558,6 +3277,13 @@ class MultiWaveform(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def highlighted_index(self):
@@ -2772,6 +3498,13 @@ class PositionerBox(RPCBase):
             positioner (Positioner | str) : Positioner to set, accepts str or the device
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class PositionerBox2D(RPCBase):
     """Simple Widget to control two positioners in box form"""
@@ -2794,6 +3527,13 @@ class PositionerBox2D(RPCBase):
             positioner (Positioner | str) : Positioner to set, accepts str or the device
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class PositionerControlLine(RPCBase):
     """A widget that controls a single device."""
@@ -2807,6 +3547,13 @@ class PositionerControlLine(RPCBase):
             positioner (Positioner | str) : Positioner to set, accepts str or the device
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class PositionerGroup(RPCBase):
     """Simple Widget to control a positioner in box form"""
@@ -3265,6 +4012,13 @@ class ScanControl(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class ScanProgressBar(RPCBase):
     """Widget to display a progress bar that is hooked up to the scan progress of a scan."""
@@ -3573,6 +4327,13 @@ class ScatterWaveform(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def main_curve(self) -> "ScatterCurve":
@@ -3746,6 +4507,76 @@ class SignalLabel(RPCBase):
         Show the button to select the signal to display
         """
 
+    @property
+    @rpc_call
+    def show_hinted_signals(self) -> "bool":
+        """
+        In the signal selection menu, show hinted signals
+        """
+
+    @show_hinted_signals.setter
+    @rpc_call
+    def show_hinted_signals(self) -> "bool":
+        """
+        In the signal selection menu, show hinted signals
+        """
+
+    @property
+    @rpc_call
+    def show_normal_signals(self) -> "bool":
+        """
+        In the signal selection menu, show normal signals
+        """
+
+    @show_normal_signals.setter
+    @rpc_call
+    def show_normal_signals(self) -> "bool":
+        """
+        In the signal selection menu, show normal signals
+        """
+
+    @property
+    @rpc_call
+    def show_config_signals(self) -> "bool":
+        """
+        In the signal selection menu, show config signals
+        """
+
+    @show_config_signals.setter
+    @rpc_call
+    def show_config_signals(self) -> "bool":
+        """
+        In the signal selection menu, show config signals
+        """
+
+    @property
+    @rpc_call
+    def display_array_data(self) -> "bool":
+        """
+        Displays the full data from array signals if set to True.
+        """
+
+    @display_array_data.setter
+    @rpc_call
+    def display_array_data(self) -> "bool":
+        """
+        Displays the full data from array signals if set to True.
+        """
+
+    @property
+    @rpc_call
+    def max_list_display_len(self) -> "int":
+        """
+        For small lists, the max length to display
+        """
+
+    @max_list_display_len.setter
+    @rpc_call
+    def max_list_display_len(self) -> "int":
+        """
+        For small lists, the max length to display
+        """
+
 
 class SignalLineEdit(RPCBase):
     """Line edit widget for device input with autocomplete for device names."""
@@ -3821,14 +4652,6 @@ class TextBox(RPCBase):
         """
 
 
-class UILaunchWindow(RPCBase):
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class VSCodeEditor(RPCBase):
     """A widget to display the VSCode editor."""
 
@@ -4077,6 +4900,15 @@ class Waveform(RPCBase):
         Set auto range for the y-axis.
         """
 
+    @rpc_call
+    def auto_range(self, value: "bool" = True):
+        """
+        On demand apply autorange to the plot item based on the visible curves.
+
+        Args:
+            value(bool): If True, apply autorange to the visible curves.
+        """
+
     @property
     @rpc_call
     def x_log(self) -> "bool":
@@ -4133,6 +4965,13 @@ class Waveform(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def curves(self) -> "list[Curve]":

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

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

bec_widgets/utils/bec_connector.py

@@ -161,8 +161,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,24 +184,6 @@ class BECConnector:
         except:
             logger.error(f"Error getting parent_id for {self.__class__.__name__}")
 
-    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.

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 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 SafeSlot
+from bec_widgets.utils.rpc_decorator import rpc_timeout
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_widgets.widgets.containers.dock import BECDock
@@ -87,7 +91,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 +100,43 @@ 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 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/compact_popup.py

@@ -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/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/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/toolbars/performance.py

@@ -2,6 +2,7 @@ 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
@@ -42,11 +43,15 @@ class PerformanceConnection(BundleConnection):
         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(
-            lambda checked: setattr(self.target_widget, "enable_fps_monitor", checked)
+            self.set_fps_monitor
         )
 
     def disconnect(self):
@@ -54,5 +59,6 @@ class PerformanceConnection(BundleConnection):
             return
         # Disconnect the action from the target widget's method
         self.components.get_action_reference("fps_monitor")().action.toggled.disconnect(
-            lambda checked: setattr(self.target_widget, "enable_fps_monitor", checked)
+            self.set_fps_monitor
         )
+        self._connected = False

bec_widgets/utils/widget_io.py

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

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

@@ -28,6 +28,7 @@ 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
@@ -70,6 +71,7 @@ class BECDockArea(BECWidget, QWidget):
         "detach_dock",
         "attach_all",
         "save_state",
+        "screenshot",
         "restore_state",
     ]
 
@@ -154,6 +156,9 @@ class BECDockArea(BECWidget, QWidget):
                         filled=True,
                         parent=self,
                     ),
+                    "heatmap": MaterialIconAction(
+                        icon_name=Heatmap.ICON_NAME, tooltip="Add Heatmap", filled=True, parent=self
+                    ),
                 },
             ),
         )
@@ -263,11 +268,16 @@ class BECDockArea(BECWidget, QWidget):
             "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):
@@ -291,6 +301,9 @@ class BECDockArea(BECWidget, QWidget):
         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
         menu_devices.actions["scan_control"].action.triggered.connect(
@@ -326,6 +339,7 @@ class BECDockArea(BECWidget, QWidget):
         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:

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

@@ -19,20 +19,28 @@ from qtpy.QtWidgets import (
 import bec_widgets
 from bec_widgets.utils import UILoader
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import apply_theme
+from bec_widgets.utils.colors import apply_theme, set_theme
 from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.widget_io import WidgetHierarchy
 from bec_widgets.widgets.containers.main_window.addons.hover_widget import HoverWidget
+from bec_widgets.widgets.containers.main_window.addons.notification_center.notification_banner import (
+    BECNotificationBroker,
+    NotificationCentre,
+    NotificationIndicator,
+)
 from bec_widgets.widgets.containers.main_window.addons.scroll_label import ScrollLabel
 from bec_widgets.widgets.containers.main_window.addons.web_links import BECWebLinksMixin
 from bec_widgets.widgets.progress.scan_progressbar.scan_progressbar import ScanProgressBar
 
 MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
+# 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
 
@@ -50,6 +58,14 @@ class BECMainWindow(BECWidget, QMainWindow):
         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()
 
@@ -58,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
     ################################################################################
@@ -94,6 +138,26 @@ class BECMainWindow(BECWidget, QMainWindow):
         # 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
 
@@ -379,12 +443,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)
+        set_theme(theme)  # emits theme_updated and applies palette globally
 
     def event(self, event):
         if event.type() == QEvent.Type.StatusTip:
@@ -430,15 +494,16 @@ class BECMainWindow(BECWidget, QMainWindow):
         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_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_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

@@ -33,7 +33,7 @@ class PositionerBox(PositionerBoxBase):
     PLUGIN = True
     RPC = True
 
-    USER_ACCESS = ["set_positioner"]
+    USER_ACCESS = ["set_positioner", "screenshot"]
     device_changed = Signal(str, str)
     # Signal emitted to inform listeners about a position update
     position_update = Signal(float)

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

@@ -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", "screenshot"]
 
     device_changed_hor = Signal(str, str)
     device_changed_ver = Signal(str, str)

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,6 +60,7 @@ 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"]
 

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

@@ -112,7 +112,9 @@ 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}."
+            )
 
     @SafeSlot()
     def update_devices_from_filters(self):
@@ -131,7 +133,8 @@ 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)
 
     @SafeSlot(list)
     def set_available_devices(self, devices: list[str]):

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

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

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,
@@ -61,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.
@@ -93,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.

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,31 @@ 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.
@@ -142,6 +170,10 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
             return
         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

bec_widgets/widgets/control/device_input/signal_line_edit/signal_line_edit_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_line_edit.signal_line_edit import (
@@ -22,6 +23,8 @@ class SignalLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = SignalLineEdit(parent)
         return t
 
@@ -50,7 +53,7 @@ class SignalLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "SignalLineEdit"
 
     def toolTip(self):
-        return "Signal LineEdit Example for BEC Widgets with autocomplete."
+        return ""
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/control/device_manager/device_manager.py

@@ -0,0 +1,998 @@
+from __future__ import annotations
+
+from qtpy.QtCore import QSize, QSortFilterProxyModel, Qt
+from qtpy.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QDialog,
+    QFormLayout,
+    QFrame,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLineEdit,
+    QListWidget,
+    QListWidgetItem,
+    QMessageBox,
+    QPushButton,
+    QScrollArea,
+    QSizePolicy,
+    QSplitter,
+    QTableWidget,
+    QTableWidgetItem,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+from thefuzz import fuzz
+
+from bec_widgets.utils.bec_table import BECTable
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import ErrorPopupUtility, SafeSlot
+from bec_widgets.widgets.utility.toggle.toggle import ToggleSwitch
+
+
+class CheckBoxCenterWidget(QWidget):
+    """Widget to center a checkbox in a table cell."""
+
+    def __init__(self, checked=False, parent=None):
+        super().__init__(parent)
+        layout = QHBoxLayout(self)
+        layout.setAlignment(Qt.AlignCenter)
+        layout.setContentsMargins(4, 0, 4, 0)  # Reduced margins for more compact layout
+
+        self.checkbox = QCheckBox()
+        self.checkbox.setChecked(checked)
+        self.checkbox.setEnabled(False)  # Read-only
+
+        # Store the value for sorting
+        self.value = checked
+
+        layout.addWidget(self.checkbox)
+
+
+class TextLabelWidget(QWidget):
+    """Widget to display text with word wrapping in a table cell."""
+
+    def __init__(self, text="", parent=None):
+        super().__init__(parent)
+        # Use a layout with minimal margins to maximize text display area
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(2, 2, 2, 2)
+        layout.setSpacing(0)
+
+        # Create label with word wrap enabled
+        self.label = QLabel(text)
+        self.label.setWordWrap(True)
+        self.label.setTextInteractionFlags(Qt.TextSelectableByMouse)
+        self.label.setAlignment(Qt.AlignLeft | Qt.AlignTop)  # Align to top-left
+
+        # Make sure label expands to fill available space
+        self.label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+
+        # Store the text value for sorting
+        self.value = text
+
+        layout.addWidget(self.label)
+
+        # Make sure the widget itself uses an expanding size policy
+        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.MinimumExpanding)
+
+        # Ensure we have a reasonable height to start with
+        # This helps ensure text is visible before resizing calculations
+        min_height = 40 if text else 20
+        self.setMinimumHeight(min_height)
+
+    def setText(self, text):
+        """Set the text of the label."""
+        self.label.setText(text)
+        self.value = text
+        # Trigger layout update
+        self.updateGeometry()
+
+    def sizeHint(self):
+        """Provide a size hint based on the text content."""
+        # Get the width of our container (usually the table cell)
+        width = self.width() or 300
+
+        # If text is empty, return minimal size
+        if not self.value:
+            return QSize(width, 20)
+
+        # Calculate height for wrapped text
+        font_metrics = self.label.fontMetrics()
+
+        # Estimate how much space the text will need when wrapped
+        text_rect = font_metrics.boundingRect(
+            0,
+            0,
+            width - 10,
+            1000,  # Width constraint, virtually unlimited height
+            Qt.TextWordWrap,
+            self.value,
+        )
+
+        # Add some padding
+        height = text_rect.height() + 8
+
+        return QSize(width, max(30, height))
+
+    def resizeEvent(self, event):
+        """Handle resize events to ensure text is properly displayed."""
+        super().resizeEvent(event)
+
+        # When resized (especially width change), update layout to ensure text wrapping works
+        self.label.updateGeometry()
+        self.updateGeometry()
+
+
+class SortableTableWidgetItem(QTableWidgetItem):
+    """Table widget item that enables proper sorting for different data types."""
+
+    def __lt__(self, other):
+        """Compare items for sorting."""
+        if self.text() == "Yes" and other.text() == "No":
+            return True
+        elif self.text() == "No" and other.text() == "Yes":
+            return False
+        else:
+            return self.text().lower() < other.text().lower()
+
+
+class DeviceTagsWidget(BECWidget, QWidget):
+    """Widget to display devices grouped by their tags in containers."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+
+        self.layout = QVBoxLayout(self)
+        self.setLayout(self.layout)
+
+        # Title
+        self.title_label = QLabel("Device Tags")
+        self.title_label.setStyleSheet("font-weight: bold; font-size: 14px;")
+        self.layout.addWidget(self.title_label)
+
+        # Search bar for tags
+        self.search_layout = QHBoxLayout()
+        self.search_label = QLabel("Search:")
+        self.search_input = QLineEdit()
+        self.search_input.setPlaceholderText("Filter tags...")
+        self.search_input.setClearButtonEnabled(True)
+        self.search_input.textChanged.connect(self.filter_tags)
+        self.search_layout.addWidget(self.search_label)
+        self.search_layout.addWidget(self.search_input)
+        self.layout.addLayout(self.search_layout)
+
+        # Create a scroll area for tag containers
+        self.scroll_area = QScrollArea()
+        self.scroll_area.setWidgetResizable(True)
+        self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+        self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+
+        # Create a widget to hold all tag containers
+        self.scroll_widget = QWidget()
+        self.scroll_layout = QVBoxLayout(self.scroll_widget)
+        self.scroll_layout.setSpacing(10)
+        self.scroll_layout.setContentsMargins(5, 5, 5, 5)
+        self.scroll_layout.setAlignment(Qt.AlignTop)
+
+        self.scroll_area.setWidget(self.scroll_widget)
+        self.layout.addWidget(self.scroll_area)
+
+        # Initialize with empty data
+        self.all_devices = []
+        self.active_devices = []
+        self.device_tags = {}  # Maps tag names to lists of device names
+        self.tag_containers = {}  # Maps tag names to their container widgets
+
+        # Load initial data
+        self.update_tags()
+
+    def update_tags(self):
+        """Update the tags containers with current device information."""
+        try:
+            # Get device config
+            config = self.client.device_manager._get_redis_device_config()
+
+            # Clear current data
+            self.all_devices = []
+            self.active_devices = []
+            self.device_tags = {}
+
+            # Process device config
+            for device_info in config:
+                device_name = device_info.get("name", "Unknown")
+                self.all_devices.append(device_name)
+
+                # Add to active devices if enabled
+                if device_info.get("enabled", False):
+                    self.active_devices.append(device_name)
+
+                # Process device tags
+                tags = device_info.get("deviceTags", [])
+                for tag in tags:
+                    if tag not in self.device_tags:
+                        self.device_tags[tag] = []
+                    self.device_tags[tag].append(device_name)
+
+            # Update the tag containers
+            self.populate_tag_containers()
+
+        except Exception as e:
+            ErrorPopupUtility().show_error_message(
+                "Device Tags Error", f"Error updating device tags: {str(e)}", self
+            )
+
+    def populate_tag_containers(self):
+        """Populate the containers with current tag and device data."""
+        # Save current filter before clearing
+        current_filter = self.search_input.text() if hasattr(self, "search_input") else ""
+
+        # Clear existing containers
+        for i in reversed(range(self.scroll_layout.count())):
+            widget = self.scroll_layout.itemAt(i).widget()
+            if widget:
+                widget.setParent(None)
+                widget.deleteLater()
+
+        self.tag_containers = {}
+
+        # Add tag containers
+        for tag, devices in sorted(self.device_tags.items()):
+            # Create container frame for this tag
+            container = QFrame()
+            container.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
+            container.setStyleSheet(
+                "QFrame { background-color: palette(window); border: 1px solid palette(mid); border-radius: 4px; }"
+            )
+
+            container_layout = QVBoxLayout(container)
+            container_layout.setContentsMargins(10, 10, 10, 10)
+
+            # Add tag header with status indicator
+            header_layout = QHBoxLayout()
+
+            # Tag name label
+            tag_label = QLabel(tag)
+            tag_label.setStyleSheet("font-weight: bold;")
+            header_layout.addWidget(tag_label)
+
+            # Spacer to push status to the right
+            header_layout.addStretch()
+
+            # Status indicator
+            all_devices_count = len(devices)
+            active_devices_count = sum(1 for d in devices if d in self.active_devices)
+
+            if active_devices_count == 0:
+                status_text = "None"
+                status_color = "red"
+            elif active_devices_count == all_devices_count:
+                status_text = "All"
+                status_color = "green"
+            else:
+                status_text = f"{active_devices_count}/{all_devices_count}"
+                status_color = "orange"
+
+            status_label = QLabel(status_text)
+            status_label.setStyleSheet(f"color: {status_color}; font-weight: bold;")
+            header_layout.addWidget(status_label)
+
+            container_layout.addLayout(header_layout)
+
+            # Add divider line
+            line = QFrame()
+            line.setFrameShape(QFrame.HLine)
+            line.setFrameShadow(QFrame.Sunken)
+            container_layout.addWidget(line)
+
+            # Add device list
+            device_list = QListWidget()
+            device_list.setAlternatingRowColors(True)
+            device_list.setMaximumHeight(150)  # Limit height
+
+            # Add devices to the list
+            for device_name in sorted(devices):
+                item = QListWidgetItem(device_name)
+                if device_name in self.active_devices:
+                    item.setForeground(Qt.green)
+                else:
+                    item.setForeground(Qt.red)
+                device_list.addItem(item)
+
+            container_layout.addWidget(device_list)
+
+            # Add to the scroll layout
+            self.scroll_layout.addWidget(container)
+            self.tag_containers[tag] = container
+
+        # Add a stretch at the end to push all containers to the top
+        self.scroll_layout.addStretch()
+
+        # Reapply filter if there was one
+        if current_filter:
+            self.filter_tags(current_filter)
+
+    @SafeSlot(str)
+    def filter_tags(self, text):
+        """Filter the tag containers based on search text."""
+        if not hasattr(self, "tag_containers"):
+            return
+
+        text = text.lower()
+
+        # Show/hide tag containers based on filter
+        for tag, container in self.tag_containers.items():
+            if not text or text in tag.lower():
+                # Tag matches filter
+                container.show()
+            else:
+                # Check if any device in this tag matches
+                matches = False
+                for device in self.device_tags.get(tag, []):
+                    if text in device.lower():
+                        matches = True
+                        break
+
+                container.setVisible(matches)
+
+    @SafeSlot()
+    def add_devices_by_tag(self):
+        """Add devices with the selected tags to the active configuration."""
+        # This would be implemented for drag-and-drop in the future
+
+    @SafeSlot()
+    def remove_devices_by_tag(self):
+        """Remove devices with the selected tags from the active configuration."""
+        # This would be implemented for drag-and-drop in the future
+
+
+class DeviceManager(BECWidget, QWidget):
+    """Widget to display the current device configuration in a table."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+
+        # Main layout for the entire widget
+        self.main_layout = QHBoxLayout(self)
+        self.setLayout(self.main_layout)
+
+        # Create a splitter to hold the device tags widget and device table
+        self.splitter = QSplitter(Qt.Horizontal)
+
+        # Create device tags widget
+        self.device_tags_widget = DeviceTagsWidget(self)
+        self.splitter.addWidget(self.device_tags_widget)
+
+        # Create container for device table and its controls
+        self.table_container = QWidget()
+        self.layout = QVBoxLayout(self.table_container)
+
+        # Create search bar
+        self.search_layout = QHBoxLayout()
+        self.search_label = QLabel("Search:")
+        self.search_input = QLineEdit()
+        self.search_input.setPlaceholderText(
+            "Filter devices (approximate matching)..."
+        )  # Default to fuzzy search
+        self.search_input.setClearButtonEnabled(True)
+        self.search_input.textChanged.connect(self.filter_devices)
+        self.search_layout.addWidget(self.search_label)
+        self.search_layout.addWidget(self.search_input)
+
+        # Add exact match toggle
+        self.fuzzy_toggle_layout = QHBoxLayout()
+        self.fuzzy_toggle_label = QLabel("Exact Match:")
+        self.fuzzy_toggle = ToggleSwitch()
+        self.fuzzy_toggle.setChecked(False)  # Default to fuzzy search (toggle OFF)
+        self.fuzzy_toggle.stateChanged.connect(self.on_fuzzy_toggle_changed)
+        self.fuzzy_toggle.setToolTip(
+            "Toggle between approximate matching (OFF) and exact matching (ON)"
+        )
+        self.fuzzy_toggle_label.setToolTip(
+            "Toggle between approximate matching (OFF) and exact matching (ON)"
+        )
+        self.fuzzy_toggle_layout.addWidget(self.fuzzy_toggle_label)
+        self.fuzzy_toggle_layout.addWidget(self.fuzzy_toggle)
+        self.fuzzy_toggle_layout.addStretch()
+
+        # Add both search components to the layout
+        self.search_controls = QHBoxLayout()
+        self.search_controls.addLayout(self.search_layout)
+        self.search_controls.addSpacing(20)  # Add some space between the search box and toggle
+        self.search_controls.addLayout(self.fuzzy_toggle_layout)
+
+        self.layout.addLayout(self.search_controls)
+
+        # Create table widget
+        self.device_table = BECTable()
+        self.device_table.setEditTriggers(QTableWidget.NoEditTriggers)  # Make table read-only
+        self.device_table.setSelectionBehavior(QTableWidget.SelectRows)
+        self.device_table.setAlternatingRowColors(True)
+        self.layout.addWidget(self.device_table)
+
+        # Connect custom sorting handler
+        self.device_table.horizontalHeader().sectionClicked.connect(self.handle_header_click)
+        self.current_sort_section = 0
+        self.current_sort_order = Qt.AscendingOrder
+
+        # Make table resizable
+        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        self.device_table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+
+        # Don't stretch the last section to prevent it from changing width
+        self.device_table.horizontalHeader().setStretchLastSection(False)
+        self.device_table.verticalHeader().setVisible(False)
+
+        # Set up initial headers
+        self.headers = [
+            "Name",
+            "Device Class",
+            "Readout Priority",
+            "Enabled",
+            "Read Only",
+            "Documentation",
+        ]
+        self.device_table.setColumnCount(len(self.headers))
+        self.device_table.setHorizontalHeaderLabels(self.headers)
+
+        # Set initial column resize modes
+        header = self.device_table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.ResizeToContents)  # Name
+        header.setSectionResizeMode(1, QHeaderView.ResizeToContents)  # Device Class
+        header.setSectionResizeMode(2, QHeaderView.ResizeToContents)  # Readout Priority
+        header.setSectionResizeMode(3, QHeaderView.Fixed)  # Enabled
+        header.setSectionResizeMode(4, QHeaderView.Fixed)  # Read Only
+        header.setSectionResizeMode(5, QHeaderView.Stretch)  # Documentation
+
+        # Connect resize signal to adjust row heights when table is resized
+        self.device_table.horizontalHeader().sectionResized.connect(self.on_table_resized)
+
+        # Set fixed width for checkbox columns
+        self.device_table.setColumnWidth(3, 70)  # Enabled column
+        self.device_table.setColumnWidth(4, 70)  # Read Only column
+
+        # Ensure column widths stay fixed
+        header.setMinimumSectionSize(70)
+        header.setDefaultSectionSize(100)
+
+        # Enable sorting by clicking column headers
+        self.device_table.setSortingEnabled(False)  # We'll handle sorting manually
+        self.device_table.horizontalHeader().setSortIndicatorShown(True)
+        self.device_table.horizontalHeader().setSectionsClickable(True)
+
+        # Add buttons for adding/removing devices
+        self.button_layout = QHBoxLayout()
+
+        # Add device button
+        self.add_device_button = QPushButton("Add Device")
+        self.add_device_button.clicked.connect(self.add_device)
+        self.button_layout.addWidget(self.add_device_button)
+
+        # Remove device button
+        self.remove_device_button = QPushButton("Remove Device")
+        self.remove_device_button.clicked.connect(self.remove_device)
+        self.button_layout.addWidget(self.remove_device_button)
+
+        # Add buttons to main layout
+        self.layout.addLayout(self.button_layout)
+
+        # Add the table container to the splitter
+        self.splitter.addWidget(self.table_container)
+
+        # Set initial sizes (30% for tags, 70% for table)
+        self.splitter.setSizes([300, 700])
+
+        # Add the splitter to the main layout
+        self.main_layout.addWidget(self.splitter)
+
+        # Connect signals between widgets
+        self.connect_signals()
+
+        # Load initial data
+        self.update_device_table()
+
+    def connect_signals(self):
+        """Connect signals between the device table and tags widget."""
+        # Connect add devices by tag button to update the table
+        if hasattr(self.device_tags_widget, "add_tag_button"):
+            self.device_tags_widget.add_tag_button.clicked.connect(self.update_device_table)
+
+        # Connect remove devices by tag button to update the table
+        if hasattr(self.device_tags_widget, "remove_tag_button"):
+            self.device_tags_widget.remove_tag_button.clicked.connect(self.update_device_table)
+
+    @SafeSlot(int, int, int)
+    def on_table_resized(self, column, old_width, new_width):
+        """Handle table column resize events to readjust row heights for text wrapping."""
+        # Only handle resizes of the documentation column
+        if column == 5:
+            # Update all rows with TextLabelWidgets in the documentation column
+            for row in range(self.device_table.rowCount()):
+                doc_widget = self.device_table.cellWidget(row, 5)
+                if doc_widget and isinstance(doc_widget, TextLabelWidget):
+                    # Trigger recalculation of text wrapping
+                    doc_widget.updateGeometry()
+
+                    # Force the table to recalculate row heights
+                    if doc_widget.value:
+                        # Get text metrics
+                        font_metrics = doc_widget.label.fontMetrics()
+
+                        # Calculate new text height with word wrap
+                        text_rect = font_metrics.boundingRect(
+                            0,
+                            0,
+                            new_width - 10,
+                            2000,  # New width constraint
+                            Qt.TextWordWrap,
+                            doc_widget.value,
+                        )
+
+                        # Update row height
+                        row_height = text_rect.height() + 16
+                        self.device_table.setRowHeight(row, max(40, row_height))
+
+    @SafeSlot()
+    def update_device_table(self):
+        """Update the device table with the current device configuration."""
+        try:
+            # Get device config (always a list of dictionaries)
+            config = self.client.device_manager._get_redis_device_config()
+
+            # Clear existing rows
+            self.device_table.setRowCount(0)
+
+            # Add devices to the table
+            for device_info in config:
+                row_position = self.device_table.rowCount()
+                self.device_table.insertRow(row_position)
+
+                # Set device name
+                self.device_table.setItem(
+                    row_position, 0, SortableTableWidgetItem(device_info.get("name", "Unknown"))
+                )
+
+                # Set device class
+                device_class = device_info.get("deviceClass", "Unknown")
+                self.device_table.setItem(row_position, 1, SortableTableWidgetItem(device_class))
+
+                # Set readout priority
+                readout_priority = device_info.get("readoutPriority", "Unknown")
+                self.device_table.setItem(
+                    row_position, 2, SortableTableWidgetItem(readout_priority)
+                )
+
+                # Set enabled status as checkbox
+                enabled_checkbox = CheckBoxCenterWidget(device_info.get("enabled", False))
+                self.device_table.setCellWidget(row_position, 3, enabled_checkbox)
+
+                # Set read-only status as checkbox
+                readonly_checkbox = CheckBoxCenterWidget(device_info.get("readOnly", False))
+                self.device_table.setCellWidget(row_position, 4, readonly_checkbox)
+
+                # Set documentation using text label widget with word wrap
+                documentation = device_info.get("documentation", "")
+                doc_widget = TextLabelWidget(documentation)
+                self.device_table.setCellWidget(row_position, 5, doc_widget)
+
+            # First, ensure the table is updated to show the new widgets
+            self.device_table.viewport().update()
+
+            # Force a layout update to get proper sizes
+            self.device_table.resizeRowsToContents()
+
+            # Then adjust row heights with better calculation for wrapped text
+            for row in range(self.device_table.rowCount()):
+                doc_widget = self.device_table.cellWidget(row, 5)
+                if doc_widget and isinstance(doc_widget, TextLabelWidget):
+                    text = doc_widget.value
+                    if text:
+                        # Get the column width
+                        col_width = self.device_table.columnWidth(5)
+
+                        # Calculate appropriate height for the text
+                        font_metrics = doc_widget.label.fontMetrics()
+
+                        # Calculate text rectangle with word wrap
+                        text_rect = font_metrics.boundingRect(
+                            0,
+                            0,
+                            col_width - 10,
+                            2000,  # Width constraint with large height
+                            Qt.TextWordWrap,
+                            text,
+                        )
+
+                        # Set row height with additional padding
+                        row_height = text_rect.height() + 16
+                        self.device_table.setRowHeight(row, max(40, row_height))
+
+                        # Update the widget to reflect the new size
+                        doc_widget.updateGeometry()
+
+            # Apply current sort if any
+            if hasattr(self, "current_sort_section") and self.current_sort_section >= 0:
+                self.sort_table(self.current_sort_section, self.current_sort_order)
+                self.device_table.horizontalHeader().setSortIndicator(
+                    self.current_sort_section, self.current_sort_order
+                )
+
+            # Reset the filter to make sure search works with new data
+            if hasattr(self, "search_input"):
+                current_filter = self.search_input.text()
+                if current_filter:
+                    self.filter_devices(current_filter)
+
+            # Update the device tags widget
+            self.device_tags_widget.update_tags()
+
+        except Exception as e:
+            ErrorPopupUtility().show_error_message(
+                "Device Manager Error", f"Error updating device table: {str(e)}", self
+            )
+
+    @SafeSlot(bool)
+    def on_fuzzy_toggle_changed(self, enabled):
+        """
+        Handle exact match toggle state change.
+
+        When toggle is ON (enabled=True): Use exact matching
+        When toggle is OFF (enabled=False): Use fuzzy/approximate matching
+        """
+        # Update search mode label
+        if hasattr(self, "search_input"):
+            # Store original stylesheet to restore it later
+            original_style = self.search_input.styleSheet()
+
+            # Set placeholder text based on mode
+            if enabled:  # Toggle ON = Exact match
+                self.search_input.setPlaceholderText("Filter devices (exact match)...")
+                print("Toggle switched ON: Using EXACT match mode")
+            else:  # Toggle OFF = Approximate/fuzzy match
+                self.search_input.setPlaceholderText("Filter devices (approximate matching)...")
+                print("Toggle switched OFF: Using FUZZY match mode")
+
+            # Visual feedback - briefly highlight the search box with appropriate color
+            highlight_color = "#3498db"  # Blue for feedback
+            self.search_input.setStyleSheet(f"border: 2px solid {highlight_color};")
+
+            # Create a one-time timer to restore the original style after a short delay
+            from qtpy.QtCore import QTimer
+
+            QTimer.singleShot(500, lambda: self.search_input.setStyleSheet(original_style))
+
+            # Log the toggle state for debugging
+            print(
+                f"Search mode changed: Exact match = {enabled}, Toggle isChecked = {self.fuzzy_toggle.isChecked()}"
+            )
+
+        # When toggle changes, reapply current search with new mode
+        current_text = self.search_input.text()
+
+        # Always reapply the filter, even if text is empty
+        # This ensures all rows are properly shown/hidden based on the new mode
+        self.filter_devices(current_text)
+
+    @SafeSlot(str)
+    def filter_devices(self, text):
+        """Filter devices in the table based on exact or approximate matching."""
+        # Always show all rows when search is empty, regardless of match mode
+        if not text:
+            for row in range(self.device_table.rowCount()):
+                self.device_table.setRowHidden(row, False)
+            return
+
+        # Get current search mode
+        # When toggle is ON, we use exact match
+        # When toggle is OFF, we use fuzzy/approximate match
+        use_exact_match = hasattr(self, "fuzzy_toggle") and self.fuzzy_toggle.isChecked()
+
+        # Debug print to verify which mode is being used
+        print(f"Filtering with exact match: {use_exact_match}, search text: '{text}'")
+
+        # Threshold for fuzzy matching (0-100, higher is more strict)
+        threshold = 80
+
+        # Prepare search text (lowercase for case-insensitive search)
+        search_text = text.lower()
+
+        # Count of matched rows for feedback (but avoid double-counting)
+        visible_rows = 0
+        total_rows = self.device_table.rowCount()
+
+        # Filter rows using either exact or approximate matching
+        for row in range(total_rows):
+            row_visible = False
+
+            # Check name and device class columns (0 and 1)
+            for col in [0, 1]:  # Name and Device Class columns
+                item = self.device_table.item(row, col)
+                if not item:
+                    continue
+
+                cell_text = item.text().lower()
+
+                if use_exact_match:
+                    # EXACT MATCH: Simple substring check
+                    if search_text in cell_text:
+                        row_visible = True
+                        break
+                else:
+                    # FUZZY MATCH: Use approximate matching
+                    match_ratio = fuzz.partial_ratio(search_text, cell_text)
+                    if match_ratio >= threshold:
+                        row_visible = True
+                        break
+
+            # Hide or show this row
+            self.device_table.setRowHidden(row, not row_visible)
+
+            # Count visible rows for potential feedback
+            if row_visible:
+                visible_rows += 1
+
+    @SafeSlot(int)
+    def handle_header_click(self, section):
+        """Handle column header click to sort the table."""
+        # Toggle sort order if clicking the same section
+        if section == self.current_sort_section:
+            self.current_sort_order = (
+                Qt.DescendingOrder
+                if self.current_sort_order == Qt.AscendingOrder
+                else Qt.AscendingOrder
+            )
+        else:
+            self.current_sort_section = section
+            self.current_sort_order = Qt.AscendingOrder
+
+        # Update sort indicator
+        self.device_table.horizontalHeader().setSortIndicator(
+            self.current_sort_section, self.current_sort_order
+        )
+
+        # Perform the sort
+        self.sort_table(section, self.current_sort_order)
+
+    def sort_table(self, column, order):
+        """Sort the table by the specified column and order."""
+        row_count = self.device_table.rowCount()
+        if row_count <= 1:
+            return  # Nothing to sort
+
+        # Collect all rows for sorting
+        rows_data = []
+        for row in range(row_count):
+            # Create a safe copy of the row data
+            row_data = {}
+            row_data["items"] = []
+            row_data["widgets"] = []
+            row_data["hidden"] = self.device_table.isRowHidden(row)
+            row_data["sort_key"] = None
+
+            # Extract sort key for this row
+            if column in [3, 4]:  # Checkbox columns
+                widget = self.device_table.cellWidget(row, column)
+                if widget and hasattr(widget, "value"):
+                    row_data["sort_key"] = widget.value
+                else:
+                    row_data["sort_key"] = False
+            else:  # Text columns
+                item = self.device_table.item(row, column)
+                if item:
+                    row_data["sort_key"] = item.text().lower()
+                else:
+                    row_data["sort_key"] = ""
+
+            # Collect all items and widgets in the row
+            for col in range(self.device_table.columnCount()):
+                if col in [3, 4]:  # Checkbox columns
+                    widget = self.device_table.cellWidget(row, col)
+                    if widget:
+                        # Store the widget value to recreate it
+                        is_checked = False
+                        if hasattr(widget, "value"):
+                            is_checked = widget.value
+                        elif hasattr(widget, "checkbox"):
+                            is_checked = widget.checkbox.isChecked()
+                        row_data["widgets"].append((col, "checkbox", is_checked))
+                elif col == 5:  # Documentation column with TextLabelWidget
+                    widget = self.device_table.cellWidget(row, col)
+                    if widget and isinstance(widget, TextLabelWidget):
+                        text = widget.value
+                        row_data["widgets"].append((col, "textlabel", text))
+                    else:
+                        row_data["widgets"].append((col, "textlabel", ""))
+                else:
+                    item = self.device_table.item(row, col)
+                    if item:
+                        row_data["items"].append((col, item.text()))
+                    else:
+                        row_data["items"].append((col, ""))
+
+            rows_data.append(row_data)
+
+        # Sort the rows
+        reverse = order == Qt.DescendingOrder
+        sorted_rows = sorted(rows_data, key=lambda x: x["sort_key"], reverse=reverse)
+
+        # Rebuild the table with sorted data
+        self.device_table.setUpdatesEnabled(False)  # Disable updates while rebuilding
+
+        # Clear and rebuild the table
+        self.device_table.clearContents()
+        self.device_table.setRowCount(row_count)
+
+        for row, row_data in enumerate(sorted_rows):
+            # Add text items
+            for col, text in row_data["items"]:
+                self.device_table.setItem(row, col, SortableTableWidgetItem(text))
+
+            # Add widgets
+            for col, widget_type, value in row_data["widgets"]:
+                if widget_type == "checkbox":
+                    checkbox = CheckBoxCenterWidget(value)
+                    self.device_table.setCellWidget(row, col, checkbox)
+                elif widget_type == "textlabel":
+                    text_label = TextLabelWidget(value)
+                    self.device_table.setCellWidget(row, col, text_label)
+
+            # Restore hidden state
+            self.device_table.setRowHidden(row, row_data["hidden"])
+
+        self.device_table.setUpdatesEnabled(True)  # Re-enable updates
+
+    @SafeSlot()
+    def show_add_device_dialog(self):
+        """Show the dialog for adding a new device."""
+        # Call the add_device method to handle the dialog and logic
+        self.add_device()
+
+    @SafeSlot()
+    def add_device(self):
+        """Simulate adding a new device to the configuration."""
+        try:
+            # Create and show the add device dialog
+            dialog = AddDeviceDialog(self)
+            if dialog.exec():
+                # Get device config from dialog
+                device_config = dialog.get_device_config()
+                device_name = device_config.get("name")
+
+                # Print the action that would be taken (simulation only)
+                print(f"Would add device: {device_name} with config: {device_config}")
+
+                # Show simulation message
+                QMessageBox.information(
+                    self,
+                    "Device Addition Simulated",
+                    f"Would add device: {device_name} (simulation only)",
+                )
+
+                # Update the device tags widget
+                self.device_tags_widget.update_tags()
+
+        except Exception as e:
+            ErrorPopupUtility().show_error_message(
+                "Device Manager Error", f"Error in add device simulation: {str(e)}", self
+            )
+
+    @SafeSlot()
+    def remove_device(self):
+        """Simulate removing selected device(s) from the configuration."""
+        selected_rows = self.device_table.selectionModel().selectedRows()
+
+        if not selected_rows:
+            QMessageBox.information(self, "No Selection", "Please select a device to remove.")
+            return
+
+        # Confirm deletion
+        device_count = len(selected_rows)
+        message = f"Are you sure you want to remove {device_count} device{'s' if device_count > 1 else ''}?"
+        confirmation = QMessageBox.question(
+            self, "Confirm Removal", message, QMessageBox.Yes | QMessageBox.No
+        )
+
+        if confirmation == QMessageBox.Yes:
+            try:
+                # Get device names from selected rows
+                device_names = []
+                for index in selected_rows:
+                    row = index.row()
+                    device_name = self.device_table.item(row, 0).text()
+                    device_names.append(device_name)
+
+                # Print removal action instead of actual removal
+                print(f"Would remove devices: {device_names}")
+
+                # Show simulation message
+                QMessageBox.information(
+                    self,
+                    "Device Removal Simulated",
+                    f"Would remove {device_count} device{'s' if device_count > 1 else ''} (simulation only)",
+                )
+
+                # Update the device tags widget
+                self.device_tags_widget.update_tags()
+
+            except Exception as e:
+                ErrorPopupUtility().show_error_message(
+                    "Device Manager Error", f"Error in remove device simulation: {str(e)}", self
+                )
+
+
+class AddDeviceDialog(QDialog):
+    """Dialog for adding a new device to the configuration."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Add New Device")
+        self.setMinimumWidth(400)
+
+        # Create layout
+        self.layout = QVBoxLayout(self)
+        self.form_layout = QFormLayout()
+
+        # Device name
+        self.name_input = QLineEdit()
+        self.form_layout.addRow("Device Name:", self.name_input)
+
+        # Device class
+        self.device_class_input = QLineEdit()
+        self.device_class_input.setText("ophyd_devices.SimPositioner")
+        self.form_layout.addRow("Device Class:", self.device_class_input)
+
+        # Readout priority
+        self.readout_priority_combo = QComboBox()
+        self.readout_priority_combo.addItems(["baseline", "monitored", "async", "on_request"])
+        self.form_layout.addRow("Readout Priority:", self.readout_priority_combo)
+
+        # Enabled checkbox
+        self.enabled_checkbox = QCheckBox()
+        self.enabled_checkbox.setChecked(True)
+        self.form_layout.addRow("Enabled:", self.enabled_checkbox)
+
+        # Read-only checkbox
+        self.readonly_checkbox = QCheckBox()
+        self.form_layout.addRow("Read Only:", self.readonly_checkbox)
+
+        # Documentation text
+        self.documentation_input = QLineEdit()
+        self.form_layout.addRow("Documentation:", self.documentation_input)
+
+        # Add form to layout
+        self.layout.addLayout(self.form_layout)
+
+        # Add buttons
+        self.button_layout = QHBoxLayout()
+        self.cancel_button = QPushButton("Cancel")
+        self.cancel_button.clicked.connect(self.reject)
+        self.add_button = QPushButton("Add Device")
+        self.add_button.clicked.connect(self.accept)
+        self.button_layout.addWidget(self.cancel_button)
+        self.button_layout.addWidget(self.add_button)
+
+        self.layout.addLayout(self.button_layout)
+
+    def get_device_config(self):
+        """Get the device configuration from the dialog."""
+        return {
+            "name": self.name_input.text(),
+            "deviceClass": self.device_class_input.text(),
+            "readoutPriority": self.readout_priority_combo.currentText(),
+            "enabled": self.enabled_checkbox.isChecked(),
+            "readOnly": self.readonly_checkbox.isChecked(),
+            "documentation": self.documentation_input.text(),
+            "deviceConfig": {},  # Empty config for now
+        }
+
+
+if __name__ == "__main__":
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication([])
+    window = DeviceManager()
+    window.show()
+    app.exec_()

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -45,6 +45,7 @@ class ScanControl(BECWidget, QWidget):
     Widget to submit new scans to the queue.
     """
 
+    USER_ACCESS = ["remove", "screenshot"]
     PLUGIN = True
     ICON_NAME = "tune"
     ARG_BOX_POSITION: int = 2
@@ -169,8 +170,8 @@ class ScanControl(BECWidget, QWidget):
         self.layout.addWidget(self._metadata_form)
         self._metadata_form.update_with_new_scan(self.comboBox_scan_selection.currentText())
         self.scan_selected.connect(self._metadata_form.update_with_new_scan)
-        self._metadata_form.metadata_updated.connect(self.update_scan_metadata)
-        self._metadata_form.metadata_cleared.connect(self.update_scan_metadata)
+        self._metadata_form.form_data_updated.connect(self.update_scan_metadata)
+        self._metadata_form.form_data_cleared.connect(self.update_scan_metadata)
         self._metadata_form.validate_form()
 
     def populate_scans(self):

bec_widgets/widgets/control/scan_control/scan_control_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.scan_control.scan_control import ScanControl
@@ -20,6 +21,8 @@ class ScanControlPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = ScanControl(parent)
         return t
 
@@ -27,7 +30,7 @@ class ScanControlPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return DOM_XML
 
     def group(self):
-        return "Device Control"
+        return "BEC Device Control"
 
     def icon(self):
         return designer_material_icon(ScanControl.ICON_NAME)
@@ -48,7 +51,7 @@ class ScanControlPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "ScanControl"
 
     def toolTip(self):
-        return "ScanControl"
+        return ""
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/dap/dap_combo_box/dap_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.dap.dap_combo_box.dap_combo_box import DapComboBox
@@ -20,6 +21,8 @@ class DapComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = DapComboBox(parent)
         return t
 

bec_widgets/widgets/dap/lmfit_dialog/lm_fit_dialog_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.dap.lmfit_dialog.lmfit_dialog import LMFitDialog
@@ -20,6 +21,8 @@ class LMFitDialogPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         self._form_editor = None
 
     def createWidget(self, parent):
+        if parent is None:
+            return QWidget()
         t = LMFitDialog(parent)
         return t
 
@@ -48,7 +51,7 @@ class LMFitDialogPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "LMFitDialog"
 
     def toolTip(self):
-        return "LMFitDialog"
+        return "Dialog for displaying the fit summary and params for LMFit DAP processes"
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/editors/monaco/core/__init__.py

@@ -1,6 +0,0 @@
-from .monaco_widget import MonacoWidget
-
-
-def _pyinstaller_hooks_dir():
-    from pathlib import Path
-    return [str(Path(__file__).with_name("_pyinstaller").resolve())]

bec_widgets/widgets/editors/monaco/core/index.html

@@ -1,40 +0,0 @@
-<!DOCTYPE html>
-
-<style>
-    * {
-        padding: 0;
-        margin: 0;
-    }
-
-    html,
-    body {
-        min-height: 100% !important;
-        height: 100%;
-        overflow: hidden;
-    }
-    #container {
-        width: 100%;
-        height: 100%;
-        overflow: hidden;
-        position: relative;
-    }
-    
-</style>
-
-<html>
-
-<head>
-    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
-    <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
-</head>
-
-<body>
-
-    <div id="container"></div>
-
-    <script src="monaco-editor/min/vs/loader.js"></script>
-    <script type="text/javascript" src="qrc:///qtwebchannel/qwebchannel.js"></script>
-    <script type="text/javascript" src="index.js"></script>
-</body>
-
-</html>

bec_widgets/widgets/editors/monaco/core/index.js

@@ -1,71 +0,0 @@
-var bridge = null;
-var editor = null;
-
-require.config({ paths: { vs: "monaco-editor/min/vs" } });
-require(["vs/editor/editor.main"], () => {
-  container = document.getElementById("container");
-  editor = monaco.editor.create(container, {
-    fontFamily: "Verdana",
-    automaticLayout: true,
-  });
-  editor.onDidChangeModelContent((event) => {
-    sendToPython("value", editor.getModel().getValue());
-  });
-  editor.onDidChangeModelLanguage((event) => {
-    sendToPython("language", event.newLanguage);
-  });
-  monaco.languages.registerCompletionItemProvider("python", {
-    triggerCharacters: ["."],
-    provideCompletionItems: function (model, position, context, token) {
-      return new Promise((resolve, reject) => {
-        const value = model.getValue();
-        sendToPython("completion", {
-          code: value,
-          line: position.lineNumber,
-          column: position.column,
-          context: context,
-          token: token,
-        });
-        bridge.completion.connect((data) => {
-          const completionItems = JSON.parse(data);
-          resolve({ suggestions: completionItems });
-        });
-      });
-    },
-  });
-});
-
-function init() {
-  sendToPython("value", editor.getModel().getValue());
-  sendToPython("language", editor.getModel().getLanguageId());
-  sendToPython("theme", editor._themeService._theme.themeName);
-}
-
-function sendToPython(name, value) {
-  bridge.receive_from_js(name, JSON.stringify(value));
-}
-
-function updateFromPython(name, value) {
-  var data = JSON.parse(value);
-  switch (name) {
-    case "value":
-      editor.getModel().setValue(data);
-      break;
-    case "language":
-      monaco.editor.setModelLanguage(editor.getModel(), data);
-      break;
-    case "theme":
-      monaco.editor.setTheme(data);
-      sendToPython("theme", editor._themeService._theme.themeName);
-      break;
-  }
-}
-
-window.onload = function () {
-  new QWebChannel(qt.webChannelTransport, function (channel) {
-    bridge = channel.objects.bridge;
-    bridge.sendDataChanged.connect(updateFromPython);
-    bridge.init();
-    init();
-  });
-};

bec_widgets/widgets/editors/monaco/core/monaco-editor/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 - present Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

bec_widgets/widgets/editors/monaco/core/monaco-editor/README.md

@@ -1,96 +0,0 @@
-# Monaco Editor
-
-[![Build Status](https://dev.azure.com/ms/monaco-editor/_apis/build/status/microsoft.monaco-editor?label=website)](https://dev.azure.com/ms/monaco-editor/_build/latest?definitionId=3)
-
-The Monaco Editor is the code editor which powers [VS Code](https://github.com/microsoft/vscode), with the features better described [here](https://code.visualstudio.com/docs/editor/editingevolved).
-
-Please note that this repository contains no source code for the code editor, it only contains the scripts to package everything together and ship the `monaco-editor` npm module.
-
-![image](https://user-images.githubusercontent.com/5047891/94183711-290c0780-fea3-11ea-90e3-c88ff9d21bd6.png)
-
-## Try it out
-
-Try the editor out [on our website](https://microsoft.github.io/monaco-editor/index.html).
-
-## Installing
-
-```
-$ npm install monaco-editor
-```
-
-You will get:
-
-- inside `esm`: ESM version of the editor (compatible with e.g. webpack)
-- inside `dev`: AMD bundled, not minified
-- inside `min`: AMD bundled, and minified
-- inside `min-maps`: source maps for `min`
-- `monaco.d.ts`: this specifies the API of the editor (this is what is actually versioned, everything else is considered private and might break with any release).
-
-It is recommended to develop against the `dev` version, and in production to use the `min` version.
-
-## Documentation
-
-- Learn how to integrate the editor with these [complete samples](./samples/).
-  - [Integrate the AMD version](./docs/integrate-amd.md).
-  - [Integrate the ESM version](./docs/integrate-esm.md)
-- Learn how to use the editor API and try out your own customizations in the [playground](https://microsoft.github.io/monaco-editor/playground.html).
-- Explore the [API docs](https://microsoft.github.io/monaco-editor/api/index.html) or read them straight from [`monaco.d.ts`](https://github.com/microsoft/monaco-editor/blob/main/website/typedoc/monaco.d.ts).
-- Read [this guide](https://github.com/microsoft/monaco-editor/wiki/Accessibility-Guide-for-Integrators) to ensure the editor is accessible to all your users!
-- Create a Monarch tokenizer for a new programming language [in the Monarch playground](https://microsoft.github.io/monaco-editor/monarch.html).
-- Ask questions on [StackOverflow](https://stackoverflow.com/questions/tagged/monaco-editor)! Search open and closed issues, there are a lot of tips in there!
-
-## Issues
-
-Create [issues](https://github.com/microsoft/monaco-editor/issues) in this repository for anything related to the Monaco Editor. Always mention **the version** of the editor when creating issues and **the browser** you're having trouble in. Please search for existing issues to avoid duplicates.
-
-## FAQ
-
-❓ **What is the relationship between VS Code and the Monaco Editor?**
-
-The Monaco Editor is generated straight from VS Code's sources with some shims around services the code needs to make it run in a web browser outside of its home.
-
-❓ **What is the relationship between VS Code's version and the Monaco Editor's version?**
-
-None. The Monaco Editor is a library and it reflects directly the source code.
-
-❓ **I've written an extension for VS Code, will it work on the Monaco Editor in a browser?**
-
-No.
-
-> Note: If the extension is fully based on the [LSP](https://microsoft.github.io/language-server-protocol/) and if the language server is authored in JavaScript, then it would be possible.
-
-❓ **Why all these web workers and why should I care?**
-
-Language services create web workers to compute heavy stuff outside of the UI thread. They cost hardly anything in terms of resource overhead and you shouldn't worry too much about them, as long as you get them to work (see above the cross-domain case).
-
-❓ **What is this `loader.js`? Can I use `require.js`?**
-
-It is an AMD loader that we use in VS Code. Yes.
-
-❓ **I see the warning "Could not create web worker". What should I do?**
-
-HTML5 does not allow pages loaded on `file://` to create web workers. Please load the editor with a web server on `http://` or `https://` schemes.
-
-❓ **Is the editor supported in mobile browsers or mobile web app frameworks?**
-
-No.
-
-❓ **Why doesn't the editor support TextMate grammars?**
-
-- Please see https://github.com/bolinfest/monaco-tm which puts together `monaco-editor`, `vscode-oniguruma` and `vscode-textmate` to get TM grammar support in the editor.
-
-❓ **What about IE 11 support?**
-
-- The Monaco Editor no longer supports IE 11. The last version that was tested on IE 11 is `0.18.1`.
-
-## Development setup
-
-Please see [CONTRIBUTING](./CONTRIBUTING.md)
-
-## Code of Conduct
-
-This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
-
-## License
-
-Licensed under the [MIT](https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt) License.

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/apex/apex.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/apex/apex", ["require","require"],(require)=>{
-var moduleExports=(()=>{var i=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var d=e=>i(e,"__esModule",{value:!0});var g=(e,t)=>{for(var o in t)i(e,o,{get:t[o],enumerable:!0})},p=(e,t,o,a)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of c(t))!l.call(e,s)&&(o||s!=="default")&&i(e,s,{get:()=>t[s],enumerable:!(a=r(t,s))||a.enumerable});return e};var m=(e=>(t,o)=>e&&e.get(t)||(o=p(d({}),t,1),e&&e.set(t,o),o))(typeof WeakMap!="undefined"?new WeakMap:0);var y={};g(y,{conf:()=>u,language:()=>h});var u={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"<",close:">"}],folding:{markers:{start:new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),end:new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")}}},f=["abstract","activate","and","any","array","as","asc","assert","autonomous","begin","bigdecimal","blob","boolean","break","bulk","by","case","cast","catch","char","class","collect","commit","const","continue","convertcurrency","decimal","default","delete","desc","do","double","else","end","enum","exception","exit","export","extends","false","final","finally","float","for","from","future","get","global","goto","group","having","hint","if","implements","import","in","inner","insert","instanceof","int","interface","into","join","last_90_days","last_month","last_n_days","last_week","like","limit","list","long","loop","map","merge","native","new","next_90_days","next_month","next_n_days","next_week","not","null","nulls","number","object","of","on","or","outer","override","package","parallel","pragma","private","protected","public","retrieve","return","returning","rollback","savepoint","search","select","set","short","sort","stat","static","strictfp","super","switch","synchronized","system","testmethod","then","this","this_month","this_week","throw","throws","today","tolabel","tomorrow","transaction","transient","trigger","true","try","type","undelete","update","upsert","using","virtual","void","volatile","webservice","when","where","while","yesterday"],b=e=>e.charAt(0).toUpperCase()+e.substr(1),n=[];f.forEach(e=>{n.push(e),n.push(e.toUpperCase()),n.push(b(e))});var h={defaultToken:"",tokenPostfix:".apex",keywords:n,operators:["=",">","<","!","~","?",":","==","<=",">=","!=","&&","||","++","--","+","-","*","/","&","|","^","%","<<",">>",">>>","+=","-=","*=","/=","&=","|=","^=","%=","<<=",">>=",">>>="],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,digits:/\d+(_+\d+)*/,octaldigits:/[0-7]+(_+[0-7]+)*/,binarydigits:/[0-1]+(_+[0-1]+)*/,hexdigits:/[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,tokenizer:{root:[[/[a-z_$][\w$]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],[/[A-Z][\w\$]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"type.identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/@\s*[a-zA-Z_\$][\w\$]*/,"annotation"],[/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/,"number.float"],[/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/,"number.float"],[/(@digits)[fFdD]/,"number.float"],[/(@digits)[lL]?/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/"/,"string",'@string."'],[/'/,"string","@string.'"],[/'[^\\']'/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*\*(?!\/)/,"comment.doc","@apexdoc"],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],apexdoc:[[/[^\/*]+/,"comment.doc"],[/\*\//,"comment.doc","@pop"],[/[\/*]/,"comment.doc"]],string:[[/[^\\"']+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}]]}};return m(y);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/azcli/azcli.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/azcli/azcli", ["require","require"],(require)=>{
-var moduleExports=(()=>{var s=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var r=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=t=>s(t,"__esModule",{value:!0});var k=(t,e)=>{for(var n in e)s(t,n,{get:e[n],enumerable:!0})},p=(t,e,n,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of r(e))!l.call(t,o)&&(n||o!=="default")&&s(t,o,{get:()=>e[o],enumerable:!(a=i(e,o))||a.enumerable});return t};var f=(t=>(e,n)=>t&&t.get(e)||(n=p(c({}),e,1),t&&t.set(e,n),n))(typeof WeakMap!="undefined"?new WeakMap:0);var m={};k(m,{conf:()=>g,language:()=>d});var g={comments:{lineComment:"#"}},d={defaultToken:"keyword",ignoreCase:!0,tokenPostfix:".azcli",str:/[^#\s]/,tokenizer:{root:[{include:"@comment"},[/\s-+@str*\s*/,{cases:{"@eos":{token:"key.identifier",next:"@popall"},"@default":{token:"key.identifier",next:"@type"}}}],[/^-+@str*\s*/,{cases:{"@eos":{token:"key.identifier",next:"@popall"},"@default":{token:"key.identifier",next:"@type"}}}]],type:[{include:"@comment"},[/-+@str*\s*/,{cases:{"@eos":{token:"key.identifier",next:"@popall"},"@default":"key.identifier"}}],[/@str+\s*/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}]],comment:[[/#.*$/,{cases:{"@eos":{token:"comment",next:"@popall"}}}]]}};return f(m);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/bat/bat.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/bat/bat", ["require","require"],(require)=>{
-var moduleExports=(()=>{var n=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var i=Object.prototype.hasOwnProperty;var g=o=>n(o,"__esModule",{value:!0});var c=(o,e)=>{for(var s in e)n(o,s,{get:e[s],enumerable:!0})},p=(o,e,s,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of l(e))!i.call(o,t)&&(s||t!=="default")&&n(o,t,{get:()=>e[t],enumerable:!(a=r(e,t))||a.enumerable});return o};var d=(o=>(e,s)=>o&&o.get(e)||(s=p(g({}),e,1),o&&o.set(e,s),s))(typeof WeakMap!="undefined"?new WeakMap:0);var u={};c(u,{conf:()=>m,language:()=>k});var m={comments:{lineComment:"REM"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],surroundingPairs:[{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],folding:{markers:{start:new RegExp("^\\s*(::\\s*|REM\\s+)#region"),end:new RegExp("^\\s*(::\\s*|REM\\s+)#endregion")}}},k={defaultToken:"",ignoreCase:!0,tokenPostfix:".bat",brackets:[{token:"delimiter.bracket",open:"{",close:"}"},{token:"delimiter.parenthesis",open:"(",close:")"},{token:"delimiter.square",open:"[",close:"]"}],keywords:/call|defined|echo|errorlevel|exist|for|goto|if|pause|set|shift|start|title|not|pushd|popd/,symbols:/[=><!~?&|+\-*\/\^;\.,]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/^(\s*)(rem(?:\s.*|))$/,["","comment"]],[/(\@?)(@keywords)(?!\w)/,[{token:"keyword"},{token:"keyword.$2"}]],[/[ \t\r\n]+/,""],[/setlocal(?!\w)/,"keyword.tag-setlocal"],[/endlocal(?!\w)/,"keyword.tag-setlocal"],[/[a-zA-Z_]\w*/,""],[/:\w*/,"metatag"],[/%[^%]+%/,"variable"],[/%%[\w]+(?!\w)/,"variable"],[/[{}()\[\]]/,"@brackets"],[/@symbols/,"delimiter"],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/,"number.hex"],[/\d+/,"number"],[/[;,.]/,"delimiter"],[/"/,"string",'@string."'],[/'/,"string","@string.'"]],string:[[/[^\\"'%]+/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/%[\w ]+%/,"variable"],[/%%[\w]+(?!\w)/,"variable"],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}],[/$/,"string","@popall"]]}};return d(u);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/bicep/bicep.js

@@ -1,11 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/bicep/bicep", ["require","require"],(require)=>{
-var moduleExports=(()=>{var r=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var g=e=>r(e,"__esModule",{value:!0});var l=(e,n)=>{for(var t in n)r(e,t,{get:n[t],enumerable:!0})},m=(e,n,t,i)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of c(n))!a.call(e,o)&&(t||o!=="default")&&r(e,o,{get:()=>n[o],enumerable:!(i=s(n,o))||i.enumerable});return e};var p=(e=>(n,t)=>e&&e.get(n)||(t=m(g({}),n,1),e&&e.set(n,t),t))(typeof WeakMap!="undefined"?new WeakMap:0);var L={};l(L,{conf:()=>w,language:()=>y});var k=e=>`\\b${e}\\b`,x="[_a-zA-Z]",u="[_a-zA-Z0-9]",d=k(`${x}${u}*`),b=["targetScope","resource","module","param","var","output","for","in","if","existing"],f=["true","false","null"],C="[ \\t\\r\\n]",$="[0-9]+",w={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"'",close:"'"},{open:"'''",close:"'''"}],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"'",close:"'",notIn:["string","comment"]},{open:"'''",close:"'''",notIn:["string","comment"]}],autoCloseBefore:`:.,=}])' 
-	`,indentationRules:{increaseIndentPattern:new RegExp("^((?!\\/\\/).)*(\\{[^}\"'`]*|\\([^)\"'`]*|\\[[^\\]\"'`]*)$"),decreaseIndentPattern:new RegExp("^((?!.*?\\/\\*).*\\*/)?\\s*[\\}\\]].*$")}},y={defaultToken:"",tokenPostfix:".bicep",brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"}],symbols:/[=><!~?:&|+\-*/^%]+/,keywords:b,namedLiterals:f,escapes:"\\\\(u{[0-9A-Fa-f]+}|n|r|t|\\\\|'|\\${)",tokenizer:{root:[{include:"@expression"},{include:"@whitespace"}],stringVerbatim:[{regex:"(|'|'')[^']",action:{token:"string"}},{regex:"'''",action:{token:"string.quote",next:"@pop"}}],stringLiteral:[{regex:"\\${",action:{token:"delimiter.bracket",next:"@bracketCounting"}},{regex:"[^\\\\'$]+",action:{token:"string"}},{regex:"@escapes",action:{token:"string.escape"}},{regex:"\\\\.",action:{token:"string.escape.invalid"}},{regex:"'",action:{token:"string",next:"@pop"}}],bracketCounting:[{regex:"{",action:{token:"delimiter.bracket",next:"@bracketCounting"}},{regex:"}",action:{token:"delimiter.bracket",next:"@pop"}},{include:"expression"}],comment:[{regex:"[^\\*]+",action:{token:"comment"}},{regex:"\\*\\/",action:{token:"comment",next:"@pop"}},{regex:"[\\/*]",action:{token:"comment"}}],whitespace:[{regex:C},{regex:"\\/\\*",action:{token:"comment",next:"@comment"}},{regex:"\\/\\/.*$",action:{token:"comment"}}],expression:[{regex:"'''",action:{token:"string.quote",next:"@stringVerbatim"}},{regex:"'",action:{token:"string.quote",next:"@stringLiteral"}},{regex:$,action:{token:"number"}},{regex:d,action:{cases:{"@keywords":{token:"keyword"},"@namedLiterals":{token:"keyword"},"@default":{token:"identifier"}}}}]}};return p(L);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/cameligo/cameligo.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/cameligo/cameligo", ["require","require"],(require)=>{
-var moduleExports=(()=>{var s=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=o=>s(o,"__esModule",{value:!0});var m=(o,e)=>{for(var t in e)s(o,t,{get:e[t],enumerable:!0})},p=(o,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of a(e))!l.call(o,n)&&(t||n!=="default")&&s(o,n,{get:()=>e[n],enumerable:!(r=i(e,n))||r.enumerable});return o};var d=(o=>(e,t)=>o&&o.get(e)||(t=p(c({}),e,1),o&&o.set(e,t),t))(typeof WeakMap!="undefined"?new WeakMap:0);var k={};m(k,{conf:()=>g,language:()=>u});var g={comments:{lineComment:"//",blockComment:["(*","*)"]},brackets:[["{","}"],["[","]"],["(",")"],["<",">"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"},{open:'"',close:'"'},{open:"(*",close:"*)"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"},{open:'"',close:'"'},{open:"(*",close:"*)"}]},u={defaultToken:"",tokenPostfix:".cameligo",ignoreCase:!0,brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"},{open:"<",close:">",token:"delimiter.angle"}],keywords:["abs","assert","block","Bytes","case","Crypto","Current","else","failwith","false","for","fun","if","in","let","let%entry","let%init","List","list","Map","map","match","match%nat","mod","not","operation","Operation","of","record","Set","set","sender","skip","source","String","then","to","true","type","with"],typeKeywords:["int","unit","string","tz","nat","bool"],operators:["=",">","<","<=",">=","<>",":",":=","and","mod","or","+","-","*","/","@","&","^","%","->","<-","&&","||"],symbols:/[=><:@\^&|+\-*\/\^%]+/,tokenizer:{root:[[/[a-zA-Z_][\w]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/\$[0-9a-fA-F]{1,16}/,"number.hex"],[/\d+/,"number"],[/[;,.]/,"delimiter"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/'/,"string","@string"],[/'[^\\']'/,"string"],[/'/,"string.invalid"],[/\#\d+/,"string"]],comment:[[/[^\(\*]+/,"comment"],[/\*\)/,"comment","@pop"],[/\(\*/,"comment"]],string:[[/[^\\']+/,"string"],[/\\./,"string.escape.invalid"],[/'/,{token:"string.quote",bracket:"@close",next:"@pop"}]],whitespace:[[/[ \t\r\n]+/,"white"],[/\(\*/,"comment","@comment"],[/\/\/.*$/,"comment"]]}};return d(k);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/coffee/coffee.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/coffee/coffee", ["require","require"],(require)=>{
-var moduleExports=(()=>{var s=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var l=n=>s(n,"__esModule",{value:!0});var p=(n,e)=>{for(var r in e)s(n,r,{get:e[r],enumerable:!0})},c=(n,e,r,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of g(e))!a.call(n,t)&&(r||t!=="default")&&s(n,t,{get:()=>e[t],enumerable:!(o=i(e,t))||o.enumerable});return n};var d=(n=>(e,r)=>n&&n.get(e)||(r=c(l({}),e,1),n&&n.set(e,r),r))(typeof WeakMap!="undefined"?new WeakMap:0);var u={};p(u,{conf:()=>x,language:()=>m});var x={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{blockComment:["###","###"],lineComment:"#"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*#region\\b"),end:new RegExp("^\\s*#endregion\\b")}}},m={defaultToken:"",ignoreCase:!0,tokenPostfix:".coffee",brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"}],regEx:/\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,keywords:["and","or","is","isnt","not","on","yes","@","no","off","true","false","null","this","new","delete","typeof","in","instanceof","return","throw","break","continue","debugger","if","else","switch","for","while","do","try","catch","finally","class","extends","super","undefined","then","unless","until","loop","of","by","when"],symbols:/[=><!~?&%|+\-*\/\^\.,\:]+/,escapes:/\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/\@[a-zA-Z_]\w*/,"variable.predefined"],[/[a-zA-Z_]\w*/,{cases:{this:"variable.predefined","@keywords":{token:"keyword.$0"},"@default":""}}],[/[ \t\r\n]+/,""],[/###/,"comment","@comment"],[/#.*$/,"comment"],["///",{token:"regexp",next:"@hereregexp"}],[/^(\s*)(@regEx)/,["","regexp"]],[/(\()(\s*)(@regEx)/,["@brackets","","regexp"]],[/(\,)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\=)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\:)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\[)(\s*)(@regEx)/,["@brackets","","regexp"]],[/(\!)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\&)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\|)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\?)(\s*)(@regEx)/,["delimiter","","regexp"]],[/(\{)(\s*)(@regEx)/,["@brackets","","regexp"]],[/(\;)(\s*)(@regEx)/,["","","regexp"]],[/}/,{cases:{"$S2==interpolatedstring":{token:"string",next:"@pop"},"@default":"@brackets"}}],[/[{}()\[\]]/,"@brackets"],[/@symbols/,"delimiter"],[/\d+[eE]([\-+]?\d+)?/,"number.float"],[/\d+\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F]+/,"number.hex"],[/0[0-7]+(?!\d)/,"number.octal"],[/\d+/,"number"],[/[,.]/,"delimiter"],[/"""/,"string",'@herestring."""'],[/'''/,"string","@herestring.'''"],[/"/,{cases:{"@eos":"string","@default":{token:"string",next:'@string."'}}}],[/'/,{cases:{"@eos":"string","@default":{token:"string",next:"@string.'"}}}]],string:[[/[^"'\#\\]+/,"string"],[/@escapes/,"string.escape"],[/\./,"string.escape.invalid"],[/\./,"string.escape.invalid"],[/#{/,{cases:{'$S2=="':{token:"string",next:"root.interpolatedstring"},"@default":"string"}}],[/["']/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}],[/#/,"string"]],herestring:[[/("""|''')/,{cases:{"$1==$S2":{token:"string",next:"@pop"},"@default":"string"}}],[/[^#\\'"]+/,"string"],[/['"]+/,"string"],[/@escapes/,"string.escape"],[/\./,"string.escape.invalid"],[/#{/,{token:"string.quote",next:"root.interpolatedstring"}],[/#/,"string"]],comment:[[/[^#]+/,"comment"],[/###/,"comment","@pop"],[/#/,"comment"]],hereregexp:[[/[^\\\/#]+/,"regexp"],[/\\./,"regexp"],[/#.*$/,"comment"],["///[igm]*",{token:"regexp",next:"@pop"}],[/\//,"regexp"]]}};return d(u);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/csharp/csharp.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/csharp/csharp", ["require","require"],(require)=>{
-var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var l=t=>s(t,"__esModule",{value:!0});var p=(t,e)=>{for(var n in e)s(t,n,{get:e[n],enumerable:!0})},g=(t,e,n,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of a(e))!c.call(t,o)&&(n||o!=="default")&&s(t,o,{get:()=>e[o],enumerable:!(i=r(e,o))||i.enumerable});return t};var d=(t=>(e,n)=>t&&t.get(e)||(n=g(l({}),e,1),t&&t.set(e,n),n))(typeof WeakMap!="undefined"?new WeakMap:0);var f={};p(f,{conf:()=>m,language:()=>u});var m={wordPattern:/(-?\d*\.\d\w*)|([^\`\~\!\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"'",close:"'",notIn:["string","comment"]},{open:'"',close:'"',notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"},{open:'"',close:'"'}],folding:{markers:{start:new RegExp("^\\s*#region\\b"),end:new RegExp("^\\s*#endregion\\b")}}},u={defaultToken:"",tokenPostfix:".cs",brackets:[{open:"{",close:"}",token:"delimiter.curly"},{open:"[",close:"]",token:"delimiter.square"},{open:"(",close:")",token:"delimiter.parenthesis"},{open:"<",close:">",token:"delimiter.angle"}],keywords:["extern","alias","using","bool","decimal","sbyte","byte","short","ushort","int","uint","long","ulong","char","float","double","object","dynamic","string","assembly","is","as","ref","out","this","base","new","typeof","void","checked","unchecked","default","delegate","var","const","if","else","switch","case","while","do","for","foreach","in","break","continue","goto","return","throw","try","catch","finally","lock","yield","from","let","where","join","on","equals","into","orderby","ascending","descending","select","group","by","namespace","partial","class","field","event","method","param","public","protected","internal","private","abstract","sealed","static","struct","readonly","volatile","virtual","override","params","get","set","add","remove","operator","true","false","implicit","explicit","interface","enum","null","async","await","fixed","sizeof","stackalloc","unsafe","nameof","when"],namespaceFollows:["namespace","using"],parenFollows:["if","for","while","switch","foreach","using","catch","when"],operators:["=","??","||","&&","|","^","&","==","!=","<=",">=","<<","+","-","*","/","%","!","~","++","--","+=","-=","*=","/=","%=","&=","|=","^=","<<=",">>=",">>","=>"],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/\@?[a-zA-Z_]\w*/,{cases:{"@namespaceFollows":{token:"keyword.$0",next:"@namespace"},"@keywords":{token:"keyword.$0",next:"@qualified"},"@default":{token:"identifier",next:"@qualified"}}}],{include:"@whitespace"},[/}/,{cases:{"$S2==interpolatedstring":{token:"string.quote",next:"@pop"},"$S2==litinterpstring":{token:"string.quote",next:"@pop"},"@default":"@brackets"}}],[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?[fFdD]?/,"number.float"],[/0[xX][0-9a-fA-F_]+/,"number.hex"],[/0[bB][01_]+/,"number.hex"],[/[0-9_]+/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"/,{token:"string.quote",next:"@string"}],[/\$\@"/,{token:"string.quote",next:"@litinterpstring"}],[/\@"/,{token:"string.quote",next:"@litstring"}],[/\$"/,{token:"string.quote",next:"@interpolatedstring"}],[/'[^\\']'/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],qualified:[[/[a-zA-Z_][\w]*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],[/\./,"delimiter"],["","","@pop"]],namespace:[{include:"@whitespace"},[/[A-Z]\w*/,"namespace"],[/[\.=]/,"delimiter"],["","","@pop"]],comment:[[/[^\/*]+/,"comment"],["\\*/","comment","@pop"],[/[\/*]/,"comment"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,{token:"string.quote",next:"@pop"}]],litstring:[[/[^"]+/,"string"],[/""/,"string.escape"],[/"/,{token:"string.quote",next:"@pop"}]],litinterpstring:[[/[^"{]+/,"string"],[/""/,"string.escape"],[/{{/,"string.escape"],[/}}/,"string.escape"],[/{/,{token:"string.quote",next:"root.litinterpstring"}],[/"/,{token:"string.quote",next:"@pop"}]],interpolatedstring:[[/[^\\"{]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/{{/,"string.escape"],[/}}/,"string.escape"],[/{/,{token:"string.quote",next:"root.interpolatedstring"}],[/"/,{token:"string.quote",next:"@pop"}]],whitespace:[[/^[ \t\v\f]*#((r)|(load))(?=\s)/,"directive.csx"],[/^[ \t\v\f]*#\w.*$/,"namespace.cpp"],[/[ \t\v\f\r\n]+/,""],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]]}};return d(f);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/csp/csp.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/csp/csp", ["require","require"],(require)=>{
-var moduleExports=(()=>{var o=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var a=r=>o(r,"__esModule",{value:!0});var c=(r,t)=>{for(var e in t)o(r,e,{get:t[e],enumerable:!0})},q=(r,t,e,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of u(t))!g.call(r,s)&&(e||s!=="default")&&o(r,s,{get:()=>t[s],enumerable:!(n=i(t,s))||n.enumerable});return r};var f=(r=>(t,e)=>r&&r.get(t)||(e=q(a({}),t,1),r&&r.set(t,e),e))(typeof WeakMap!="undefined"?new WeakMap:0);var d={};c(d,{conf:()=>l,language:()=>p});var l={brackets:[],autoClosingPairs:[],surroundingPairs:[]},p={keywords:[],typeKeywords:[],tokenPostfix:".csp",operators:[],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/child-src/,"string.quote"],[/connect-src/,"string.quote"],[/default-src/,"string.quote"],[/font-src/,"string.quote"],[/frame-src/,"string.quote"],[/img-src/,"string.quote"],[/manifest-src/,"string.quote"],[/media-src/,"string.quote"],[/object-src/,"string.quote"],[/script-src/,"string.quote"],[/style-src/,"string.quote"],[/worker-src/,"string.quote"],[/base-uri/,"string.quote"],[/plugin-types/,"string.quote"],[/sandbox/,"string.quote"],[/disown-opener/,"string.quote"],[/form-action/,"string.quote"],[/frame-ancestors/,"string.quote"],[/report-uri/,"string.quote"],[/report-to/,"string.quote"],[/upgrade-insecure-requests/,"string.quote"],[/block-all-mixed-content/,"string.quote"],[/require-sri-for/,"string.quote"],[/reflected-xss/,"string.quote"],[/referrer/,"string.quote"],[/policy-uri/,"string.quote"],[/'self'/,"string.quote"],[/'unsafe-inline'/,"string.quote"],[/'unsafe-eval'/,"string.quote"],[/'strict-dynamic'/,"string.quote"],[/'unsafe-hashed-attributes'/,"string.quote"]]}};return f(d);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/css/css.js

@@ -1,12 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/css/css", ["require","require"],(require)=>{
-var moduleExports=(()=>{var r=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var m=t=>r(t,"__esModule",{value:!0});var c=(t,e)=>{for(var n in e)r(t,n,{get:e[n],enumerable:!0})},d=(t,e,n,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of s(e))!l.call(t,o)&&(n||o!=="default")&&r(t,o,{get:()=>e[o],enumerable:!(i=a(e,o))||i.enumerable});return t};var u=(t=>(e,n)=>t&&t.get(e)||(n=d(m({}),e,1),t&&t.set(e,n),n))(typeof WeakMap!="undefined"?new WeakMap:0);var g={};c(g,{conf:()=>p,language:()=>k});var p={wordPattern:/(#?-?\d*\.\d\w*%?)|((::|[@#.!:])?[\w-?]+%?)|::|[@#.!:]/g,comments:{blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}",notIn:["string","comment"]},{open:"[",close:"]",notIn:["string","comment"]},{open:"(",close:")",notIn:["string","comment"]},{open:'"',close:'"',notIn:["string","comment"]},{open:"'",close:"'",notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),end:new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")}}},k={defaultToken:"",tokenPostfix:".css",ws:`[ 	
-\r\f]*`,identifier:"-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",brackets:[{open:"{",close:"}",token:"delimiter.bracket"},{open:"[",close:"]",token:"delimiter.bracket"},{open:"(",close:")",token:"delimiter.parenthesis"},{open:"<",close:">",token:"delimiter.angle"}],tokenizer:{root:[{include:"@selector"}],selector:[{include:"@comments"},{include:"@import"},{include:"@strings"},["[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)",{token:"keyword",next:"@keyframedeclaration"}],["[@](page|content|font-face|-moz-document)",{token:"keyword"}],["[@](charset|namespace)",{token:"keyword",next:"@declarationbody"}],["(url-prefix)(\\()",["attribute.value",{token:"delimiter.parenthesis",next:"@urldeclaration"}]],["(url)(\\()",["attribute.value",{token:"delimiter.parenthesis",next:"@urldeclaration"}]],{include:"@selectorname"},["[\\*]","tag"],["[>\\+,]","delimiter"],["\\[",{token:"delimiter.bracket",next:"@selectorattribute"}],["{",{token:"delimiter.bracket",next:"@selectorbody"}]],selectorbody:[{include:"@comments"},["[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))","attribute.name","@rulevalue"],["}",{token:"delimiter.bracket",next:"@pop"}]],selectorname:[["(\\.|#(?=[^{])|%|(@identifier)|:)+","tag"]],selectorattribute:[{include:"@term"},["]",{token:"delimiter.bracket",next:"@pop"}]],term:[{include:"@comments"},["(url-prefix)(\\()",["attribute.value",{token:"delimiter.parenthesis",next:"@urldeclaration"}]],["(url)(\\()",["attribute.value",{token:"delimiter.parenthesis",next:"@urldeclaration"}]],{include:"@functioninvocation"},{include:"@numbers"},{include:"@name"},{include:"@strings"},["([<>=\\+\\-\\*\\/\\^\\|\\~,])","delimiter"],[",","delimiter"]],rulevalue:[{include:"@comments"},{include:"@strings"},{include:"@term"},["!important","keyword"],[";","delimiter","@pop"],["(?=})",{token:"",next:"@pop"}]],warndebug:[["[@](warn|debug)",{token:"keyword",next:"@declarationbody"}]],import:[["[@](import)",{token:"keyword",next:"@declarationbody"}]],urldeclaration:[{include:"@strings"},[`[^)\r
-]+`,"string"],["\\)",{token:"delimiter.parenthesis",next:"@pop"}]],parenthizedterm:[{include:"@term"},["\\)",{token:"delimiter.parenthesis",next:"@pop"}]],declarationbody:[{include:"@term"},[";","delimiter","@pop"],["(?=})",{token:"",next:"@pop"}]],comments:[["\\/\\*","comment","@comment"],["\\/\\/+.*","comment"]],comment:[["\\*\\/","comment","@pop"],[/[^*/]+/,"comment"],[/./,"comment"]],name:[["@identifier","attribute.value"]],numbers:[["-?(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?",{token:"attribute.value.number",next:"@units"}],["#[0-9a-fA-F_]+(?!\\w)","attribute.value.hex"]],units:[["(em|ex|ch|rem|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?","attribute.value.unit","@pop"]],keyframedeclaration:[["@identifier","attribute.value"],["{",{token:"delimiter.bracket",switchTo:"@keyframebody"}]],keyframebody:[{include:"@term"},["{",{token:"delimiter.bracket",next:"@selectorbody"}],["}",{token:"delimiter.bracket",next:"@pop"}]],functioninvocation:[["@identifier\\(",{token:"attribute.value",next:"@functionarguments"}]],functionarguments:[["\\$@identifier@ws:","attribute.name"],["[,]","delimiter"],{include:"@term"},["\\)",{token:"attribute.value",next:"@pop"}]],strings:[['~?"',{token:"string",next:"@stringenddoublequote"}],["~?'",{token:"string",next:"@stringendquote"}]],stringenddoublequote:[["\\\\.","string"],['"',{token:"string",next:"@pop"}],[/[^\\"]+/,"string"],[".","string"]],stringendquote:[["\\\\.","string"],["'",{token:"string",next:"@pop"}],[/[^\\']+/,"string"],[".","string"]]}};return u(g);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/dart/dart.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/dart/dart", ["require","require"],(require)=>{
-var moduleExports=(()=>{var r=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var p=n=>r(n,"__esModule",{value:!0});var g=(n,e)=>{for(var o in e)r(n,o,{get:e[o],enumerable:!0})},l=(n,e,o,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of c(e))!a.call(n,t)&&(o||t!=="default")&&r(n,t,{get:()=>e[t],enumerable:!(s=i(e,t))||s.enumerable});return n};var d=(n=>(e,o)=>n&&n.get(e)||(o=l(p({}),e,1),n&&n.set(e,o),o))(typeof WeakMap!="undefined"?new WeakMap:0);var u={};g(u,{conf:()=>m,language:()=>x});var m={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"'",close:"'",notIn:["string","comment"]},{open:'"',close:'"',notIn:["string"]},{open:"`",close:"`",notIn:["string","comment"]},{open:"/**",close:" */",notIn:["string"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"<",close:">"},{open:"'",close:"'"},{open:"(",close:")"},{open:'"',close:'"'},{open:"`",close:"`"}],folding:{markers:{start:/^\s*\s*#?region\b/,end:/^\s*\s*#?endregion\b/}}},x={defaultToken:"invalid",tokenPostfix:".dart",keywords:["abstract","dynamic","implements","show","as","else","import","static","assert","enum","in","super","async","export","interface","switch","await","extends","is","sync","break","external","library","this","case","factory","mixin","throw","catch","false","new","true","class","final","null","try","const","finally","on","typedef","continue","for","operator","var","covariant","Function","part","void","default","get","rethrow","while","deferred","hide","return","with","do","if","set","yield"],typeKeywords:["int","double","String","bool"],operators:["+","-","*","/","~/","%","++","--","==","!=",">","<",">=","<=","=","-=","/=","%=",">>=","^=","+=","*=","~/=","<<=","&=","!=","||","&&","&","|","^","~","<<",">>","!",">>>","??","?",":","|="],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,digits:/\d+(_+\d+)*/,octaldigits:/[0-7]+(_+[0-7]+)*/,binarydigits:/[0-1]+(_+[0-1]+)*/,hexdigits:/[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,regexpctl:/[(){}\[\]\$\^|\-*+?\.]/,regexpesc:/\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,tokenizer:{root:[[/[{}]/,"delimiter.bracket"],{include:"common"}],common:[[/[a-z_$][\w$]*/,{cases:{"@typeKeywords":"type.identifier","@keywords":"keyword","@default":"identifier"}}],[/[A-Z_$][\w\$]*/,"type.identifier"],{include:"@whitespace"},[/\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,{token:"regexp",bracket:"@open",next:"@regexp"}],[/@[a-zA-Z]+/,"annotation"],[/[()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/!(?=([^=]|$))/,"delimiter"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/(@digits)[eE]([\-+]?(@digits))?/,"number.float"],[/(@digits)\.(@digits)([eE][\-+]?(@digits))?/,"number.float"],[/0[xX](@hexdigits)n?/,"number.hex"],[/0[oO]?(@octaldigits)n?/,"number.octal"],[/0[bB](@binarydigits)n?/,"number.binary"],[/(@digits)n?/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/"/,"string","@string_double"],[/'/,"string","@string_single"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*\*(?!\/)/,"comment.doc","@jsdoc"],[/\/\*/,"comment","@comment"],[/\/\/\/.*$/,"comment.doc"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],jsdoc:[[/[^\/*]+/,"comment.doc"],[/\*\//,"comment.doc","@pop"],[/[\/*]/,"comment.doc"]],regexp:[[/(\{)(\d+(?:,\d*)?)(\})/,["regexp.escape.control","regexp.escape.control","regexp.escape.control"]],[/(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,["regexp.escape.control",{token:"regexp.escape.control",next:"@regexrange"}]],[/(\()(\?:|\?=|\?!)/,["regexp.escape.control","regexp.escape.control"]],[/[()]/,"regexp.escape.control"],[/@regexpctl/,"regexp.escape.control"],[/[^\\\/]/,"regexp"],[/@regexpesc/,"regexp.escape"],[/\\\./,"regexp.invalid"],[/(\/)([gimsuy]*)/,[{token:"regexp",bracket:"@close",next:"@pop"},"keyword.other"]]],regexrange:[[/-/,"regexp.escape.control"],[/\^/,"regexp.invalid"],[/@regexpesc/,"regexp.escape"],[/[^\]]/,"regexp"],[/\]/,{token:"regexp.escape.control",next:"@pop",bracket:"@close"}]],string_double:[[/[^\\"\$]+/,"string"],[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"],[/\$\w+/,"identifier"]],string_single:[[/[^\\'\$]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/'/,"string","@pop"],[/\$\w+/,"identifier"]]}};return d(u);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/dockerfile/dockerfile.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/dockerfile/dockerfile", ["require","require"],(require)=>{
-var moduleExports=(()=>{var a=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var r=Object.getOwnPropertyNames;var i=Object.prototype.hasOwnProperty;var p=o=>a(o,"__esModule",{value:!0});var g=(o,e)=>{for(var n in e)a(o,n,{get:e[n],enumerable:!0})},c=(o,e,n,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of r(e))!i.call(o,s)&&(n||s!=="default")&&a(o,s,{get:()=>e[s],enumerable:!(t=l(e,s))||t.enumerable});return o};var u=(o=>(e,n)=>o&&o.get(e)||(n=c(p({}),e,1),o&&o.set(e,n),n))(typeof WeakMap!="undefined"?new WeakMap:0);var f={};g(f,{conf:()=>d,language:()=>k});var d={brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}]},k={defaultToken:"",tokenPostfix:".dockerfile",variable:/\${?[\w]+}?/,tokenizer:{root:[{include:"@whitespace"},{include:"@comment"},[/(ONBUILD)(\s+)/,["keyword",""]],[/(ENV)(\s+)([\w]+)/,["keyword","",{token:"variable",next:"@arguments"}]],[/(FROM|MAINTAINER|RUN|EXPOSE|ENV|ADD|ARG|VOLUME|LABEL|USER|WORKDIR|COPY|CMD|STOPSIGNAL|SHELL|HEALTHCHECK|ENTRYPOINT)/,{token:"keyword",next:"@arguments"}]],arguments:[{include:"@whitespace"},{include:"@strings"},[/(@variable)/,{cases:{"@eos":{token:"variable",next:"@popall"},"@default":"variable"}}],[/\\/,{cases:{"@eos":"","@default":""}}],[/./,{cases:{"@eos":{token:"",next:"@popall"},"@default":""}}]],whitespace:[[/\s+/,{cases:{"@eos":{token:"",next:"@popall"},"@default":""}}]],comment:[[/(^#.*$)/,"comment","@popall"]],strings:[[/\\'$/,"","@popall"],[/\\'/,""],[/'$/,"string","@popall"],[/'/,"string","@stringBody"],[/"$/,"string","@popall"],[/"/,"string","@dblStringBody"]],stringBody:[[/[^\\\$']/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}],[/\\./,"string.escape"],[/'$/,"string","@popall"],[/'/,"string","@pop"],[/(@variable)/,"variable"],[/\\$/,"string"],[/$/,"string","@popall"]],dblStringBody:[[/[^\\\$"]/,{cases:{"@eos":{token:"string",next:"@popall"},"@default":"string"}}],[/\\./,"string.escape"],[/"$/,"string","@popall"],[/"/,"string","@pop"],[/(@variable)/,"variable"],[/\\$/,"string"],[/$/,"string","@popall"]]}};return u(f);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/flow9/flow9.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/flow9/flow9", ["require","require"],(require)=>{
-var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=o=>s(o,"__esModule",{value:!0});var m=(o,e)=>{for(var n in e)s(o,n,{get:e[n],enumerable:!0})},p=(o,e,n,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of a(e))!l.call(o,t)&&(n||t!=="default")&&s(o,t,{get:()=>e[t],enumerable:!(i=r(e,t))||i.enumerable});return o};var g=(o=>(e,n)=>o&&o.get(e)||(n=p(c({}),e,1),o&&o.set(e,n),n))(typeof WeakMap!="undefined"?new WeakMap:0);var d={};m(d,{conf:()=>f,language:()=>u});var f={comments:{blockComment:["/*","*/"],lineComment:"//"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}",notIn:["string"]},{open:"[",close:"]",notIn:["string"]},{open:"(",close:")",notIn:["string"]},{open:'"',close:'"',notIn:["string"]},{open:"'",close:"'",notIn:["string"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"},{open:"<",close:">"}]},u={defaultToken:"",tokenPostfix:".flow",keywords:["import","require","export","forbid","native","if","else","cast","unsafe","switch","default"],types:["io","mutable","bool","int","double","string","flow","void","ref","true","false","with"],operators:["=",">","<","<=",">=","==","!","!=",":=","::=","&&","||","+","-","*","/","@","&","%",":","->","\\","$","??","^"],symbols:/[@$=><!~?:&|+\-*\\\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/[a-zA-Z_]\w*/,{cases:{"@keywords":"keyword","@types":"type","@default":"identifier"}}],{include:"@whitespace"},[/[{}()\[\]]/,"delimiter"],[/[<>](?!@symbols)/,"delimiter"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"/,"string","@string"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"]]}};return g(d);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/fsharp/fsharp.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/fsharp/fsharp", ["require","require"],(require)=>{
-var moduleExports=(()=>{var s=Object.defineProperty;var r=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=n=>s(n,"__esModule",{value:!0});var g=(n,e)=>{for(var t in e)s(n,t,{get:e[t],enumerable:!0})},f=(n,e,t,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of a(e))!l.call(n,o)&&(t||o!=="default")&&s(n,o,{get:()=>e[o],enumerable:!(i=r(e,o))||i.enumerable});return n};var m=(n=>(e,t)=>n&&n.get(e)||(t=f(c({}),e,1),n&&n.set(e,t),t))(typeof WeakMap!="undefined"?new WeakMap:0);var p={};g(p,{conf:()=>u,language:()=>d});var u={comments:{lineComment:"//",blockComment:["(*","*)"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{markers:{start:new RegExp("^\\s*//\\s*#region\\b|^\\s*\\(\\*\\s*#region(.*)\\*\\)"),end:new RegExp("^\\s*//\\s*#endregion\\b|^\\s*\\(\\*\\s*#endregion\\s*\\*\\)")}}},d={defaultToken:"",tokenPostfix:".fs",keywords:["abstract","and","atomic","as","assert","asr","base","begin","break","checked","component","const","constraint","constructor","continue","class","default","delegate","do","done","downcast","downto","elif","else","end","exception","eager","event","external","extern","false","finally","for","fun","function","fixed","functor","global","if","in","include","inherit","inline","interface","internal","land","lor","lsl","lsr","lxor","lazy","let","match","member","mod","module","mutable","namespace","method","mixin","new","not","null","of","open","or","object","override","private","parallel","process","protected","pure","public","rec","return","static","sealed","struct","sig","then","to","true","tailcall","trait","try","type","upcast","use","val","void","virtual","volatile","when","while","with","yield"],symbols:/[=><!~?:&|+\-*\^%;\.,\/]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,integersuffix:/[uU]?[yslnLI]?/,floatsuffix:/[fFmM]?/,tokenizer:{root:[[/[a-zA-Z_]\w*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/\[<.*>\]/,"annotation"],[/^#(if|else|endif)/,"keyword"],[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,"delimiter"],[/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/,"number.float"],[/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/,"number.float"],[/0x[0-9a-fA-F]+LF/,"number.float"],[/0x[0-9a-fA-F]+(@integersuffix)/,"number.hex"],[/0b[0-1]+(@integersuffix)/,"number.bin"],[/\d+(@integersuffix)/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"""/,"string",'@string."""'],[/"/,"string",'@string."'],[/\@"/,{token:"string.quote",next:"@litstring"}],[/'[^\\']'B?/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],whitespace:[[/[ \t\r\n]+/,""],[/\(\*(?!\))/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^*(]+/,"comment"],[/\*\)/,"comment","@pop"],[/\*/,"comment"],[/\(\*\)/,"comment"],[/\(/,"comment"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/("""|"B?)/,{cases:{"$#==$S2":{token:"string",next:"@pop"},"@default":"string"}}]],litstring:[[/[^"]+/,"string"],[/""/,"string.escape"],[/"/,{token:"string.quote",next:"@pop"}]]}};return m(p);})();
-return moduleExports;
-});

bec_widgets/widgets/editors/monaco/core/monaco-editor/min/vs/basic-languages/go/go.js

@@ -1,10 +0,0 @@
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-define("vs/basic-languages/go/go", ["require","require"],(require)=>{
-var moduleExports=(()=>{var s=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var m=n=>s(n,"__esModule",{value:!0});var l=(n,e)=>{for(var o in e)s(n,o,{get:e[o],enumerable:!0})},g=(n,e,o,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of a(e))!c.call(n,t)&&(o||t!=="default")&&s(n,t,{get:()=>e[t],enumerable:!(r=i(e,t))||r.enumerable});return n};var p=(n=>(e,o)=>n&&n.get(e)||(o=g(m({}),e,1),n&&n.set(e,o),o))(typeof WeakMap!="undefined"?new WeakMap:0);var f={};l(f,{conf:()=>u,language:()=>d});var u={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"`",close:"`",notIn:["string"]},{open:'"',close:'"',notIn:["string"]},{open:"'",close:"'",notIn:["string","comment"]}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:"`",close:"`"},{open:'"',close:'"'},{open:"'",close:"'"}]},d={defaultToken:"",tokenPostfix:".go",keywords:["break","case","chan","const","continue","default","defer","else","fallthrough","for","func","go","goto","if","import","interface","map","package","range","return","select","struct","switch","type","var","bool","true","false","uint8","uint16","uint32","uint64","int8","int16","int32","int64","float32","float64","complex64","complex128","byte","rune","uint","int","uintptr","string","nil"],operators:["+","-","*","/","%","&","|","^","<<",">>","&^","+=","-=","*=","/=","%=","&=","|=","^=","<<=",">>=","&^=","&&","||","<-","++","--","==","<",">","=","!","!=","<=",">=",":=","...","(",")","","]","{","}",",",";",".",":"],symbols:/[=><!~?:&|+\-*\/\^%]+/,escapes:/\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,tokenizer:{root:[[/[a-zA-Z_]\w*/,{cases:{"@keywords":{token:"keyword.$0"},"@default":"identifier"}}],{include:"@whitespace"},[/\[\[.*\]\]/,"annotation"],[/^\s*#\w+/,"keyword"],[/[{}()\[\]]/,"@brackets"],[/[<>](?!@symbols)/,"@brackets"],[/@symbols/,{cases:{"@operators":"delimiter","@default":""}}],[/\d*\d+[eE]([\-+]?\d+)?/,"number.float"],[/\d*\.\d+([eE][\-+]?\d+)?/,"number.float"],[/0[xX][0-9a-fA-F']*[0-9a-fA-F]/,"number.hex"],[/0[0-7']*[0-7]/,"number.octal"],[/0[bB][0-1']*[0-1]/,"number.binary"],[/\d[\d']*/,"number"],[/\d/,"number"],[/[;,.]/,"delimiter"],[/"([^"\\]|\\.)*$/,"string.invalid"],[/"/,"string","@string"],[/`/,"string","@rawstring"],[/'[^\\']'/,"string"],[/(')(@escapes)(')/,["string","string.escape","string"]],[/'/,"string.invalid"]],whitespace:[[/[ \t\r\n]+/,""],[/\/\*\*(?!\/)/,"comment.doc","@doccomment"],[/\/\*/,"comment","@comment"],[/\/\/.*$/,"comment"]],comment:[[/[^\/*]+/,"comment"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],doccomment:[[/[^\/*]+/,"comment.doc"],[/\/\*/,"comment.doc.invalid"],[/\*\//,"comment.doc","@pop"],[/[\/*]/,"comment.doc"]],string:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"]],rawstring:[[/[^\`]/,"string"],[/`/,"string","@pop"]]}};return p(f);})();
-return moduleExports;
-});