feat:added launch script

.gitlab-ci.yml

@@ -22,13 +22,6 @@ workflow:
 
 include:
   - template: Security/Secret-Detection.gitlab-ci.yml
-  - project: "bec/awi_utils"
-    file: "/templates/check-packages-job.yml"
-    inputs:
-      stage: test
-      path: "."
-      pytest_args: "-v --random-order tests/"
-      exclude_packages: ""
 
 # different stages in the pipeline
 stages:
@@ -38,22 +31,8 @@ stages:
   - End2End
   - Deploy
 
-.install-qt-webengine-deps: &install-qt-webengine-deps
-  - apt-get -y install libnss3 libxdamage1 libasound2 libatomic1 libxcursor1
-  - export QTWEBENGINE_DISABLE_SANDBOX=1
-
-.clone-repos: &clone-repos
-  - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-  - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-  - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-
-.install-os-packages: &install-os-packages
-  - apt-get update
-  - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-  - *install-qt-webengine-deps
-
 before_script:
-  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then
+  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then 
     echo -e "\033[35;1m Using branch $CHILD_PIPELINE_BRANCH of BEC Widgets \033[0;m";
     test -d bec_widgets || git clone --branch $CHILD_PIPELINE_BRANCH https://gitlab.psi.ch/bec/bec_widgets.git; cd bec_widgets;
     fi
@@ -96,21 +75,18 @@ pylint-check:
     - apt-get update
     - apt-get install -y bc
   script:
-    - git fetch origin $CI_MERGE_REQUEST_TARGET_BRANCH_NAME
     # Identify changed Python files
     - if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then
-      TARGET_BRANCH_COMMIT_SHA=$(git rev-parse origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME);
-      CHANGED_FILES=$(git diff --name-only $TARGET_BRANCH_COMMIT_SHA HEAD | grep '\.py$' || true);
+        TARGET_BRANCH_COMMIT_SHA=$(git rev-parse $CI_MERGE_REQUEST_TARGET_BRANCH_NAME);
+        CHANGED_FILES=$(git diff --name-only $SOURCE_BRANCH_COMMIT_SHA $TARGET_BRANCH_COMMIT_SHA | grep '\.py$' || true);
       else
-      CHANGED_FILES=$(git diff --name-only $CI_COMMIT_BEFORE_SHA $CI_COMMIT_SHA | grep '\.py$' || true);
+        CHANGED_FILES=$(git diff --name-only $CI_COMMIT_BEFORE_SHA $CI_COMMIT_SHA | grep '\.py$' || true);
       fi
     - if [ -z "$CHANGED_FILES" ]; then echo "No Python files changed."; exit 0; fi
 
-    - echo "Changed Python files:"
-      - $CHANGED_FILES
     # Run pylint only on changed files
     - mkdir ./pylint
-    - pylint $CHANGED_FILES --output-format=text | tee ./pylint/pylint_changed_files.log || pylint-exit $?
+    - pylint $CHANGED_FILES --output-format=text . | tee ./pylint/pylint_changed_files.log || pylint-exit $?
     - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint_changed_files.log)
     - echo "Pylint score is $PYLINT_SCORE"
 
@@ -127,13 +103,15 @@ tests:
   stage: test
   needs: []
   variables:
-    QT_QPA_PLATFORM: "offscreen"
+      QT_QPA_PLATFORM: "offscreen"
   script:
-    - *clone-repos
-    - *install-os-packages
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
     - pip install -e ./bec/bec_lib[dev]
-    - pip install -e ./bec/bec_ipython_client
-    - pip install -e .[dev,pyqt6]
+    - pip install -e .[dev,pyside6]
     - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
     - coverage report
     - coverage xml
@@ -145,32 +123,140 @@ tests:
         coverage_format: cobertura
         path: coverage.xml
 
-test-matrix:
-  parallel:
-    matrix:
-      - PYTHON_VERSION:
-          - "3.10"
-          - "3.11"
-          - "3.12"
-        QT_PCKG:
-          - "pyside6"
-          - "pyqt5"
-          - "pyqt6"
-
+tests-3.10-pyside6:
+  extends: "tests"
   stage: AdditionalTests
-  needs: []
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-    PYTHON_VERSION: ""
-    QT_PCKG: ""
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:$PYTHON_VERSION
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.10
   script:
-    - *clone-repos
-    - *install-os-packages
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
     - pip install -e ./bec/bec_lib[dev]
-    - pip install -e ./bec/bec_ipython_client
-    - pip install -e .[dev,$QT_PCKG]
-    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
+    - pip install -e .[dev,pyside6]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
+    - coverage report
+    - coverage xml
+  allow_failure: true
+
+tests-3.12-pyside6:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.12
+  script:
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e .[dev,pyside6]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
+    - coverage report
+    - coverage xml
+  allow_failure: true
+
+tests-3.10-pyqt5:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.10
+  script:
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e .[dev,pyqt5]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
+    - coverage report
+    - coverage xml
+  allow_failure: true
+
+tests-3.11-pyqt5:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
+  script:
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e .[dev,pyqt5]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
+    - coverage report
+    - coverage xml
+  allow_failure: true
+
+tests-3.12-pyqt5:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.12
+  script:
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e .[dev,pyqt5]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
+    - coverage report
+    - coverage xml
+  allow_failure: true
+
+tests-3.10-pyqt6:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.10
+  script:
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e .[dev,pyqt6]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
+    - coverage report
+    - coverage xml
+  allow_failure: true
+
+tests-3.11-pyqt6:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
+  script:
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e .[dev,pyqt6]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
+    - coverage report
+    - coverage xml
+  allow_failure: true
+
+tests-3.12-pyqt6:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.12
+  script:
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e .[dev,pyqt6]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
+    - coverage report
+    - coverage xml
   allow_failure: true
 
 end-2-end-conda:
@@ -181,25 +267,29 @@ end-2-end-conda:
   variables:
     QT_QPA_PLATFORM: "offscreen"
   script:
-    - *clone-repos
-    - *install-os-packages
+    - apt-get update
+    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
     - conda config --prepend channels conda-forge
     - conda config --set channel_priority strict
     - conda config --set always_yes yes --set changeps1 no
-    - conda create -q -n test-environment python=3.11
+    - conda create -q -n test-environment python=3.10
     - conda init bash
     - source ~/.bashrc
     - conda activate test-environment
 
+    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+
     - cd ./bec
     - source ./bin/install_bec_dev.sh -t
 
     - pip install -e ./bec_lib[dev]
     - pip install -e ./bec_ipython_client[dev]
     - cd ../
-    - pip install -e .[dev,pyqt6]
+    - pip install -e .[dev,pyside6]
     - cd ./tests/end-2-end
-    - pytest -v --start-servers --flush-redis --random-order
+    - pytest --start-servers --flush-redis --random-order
 
   artifacts:
     when: on_failure
@@ -233,7 +323,7 @@ semver:
     - pip install python-semantic-release==9.* wheel build twine
     - export GL_TOKEN=$CI_UPDATES
     - semantic-release -vv version
-
+    
     # check if any artifacts were created
     - if [ ! -d dist ]; then echo No release will be made; exit 0; fi
     - twine upload dist/* -u __token__ -p $CI_PYPI_TOKEN --skip-existing
@@ -249,7 +339,7 @@ pages:
   variables:
     TARGET_BRANCH: $CI_COMMIT_REF_NAME
   rules:
-    - if: "$CI_COMMIT_TAG != null"
+    - if: '$CI_COMMIT_TAG != null'
       variables:
         TARGET_BRANCH: $CI_COMMIT_TAG
     - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'

CHANGELOG.md

@@ -1,180 +1,171 @@
 # CHANGELOG
 
-## v0.67.0 (2024-06-21)
 
-### Documentation
 
-* docs: add widget to documentation ([`6fa1c06`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6fa1c06053131dabd084bb3cf13c853b5d3ce833))
+## v0.55.0 (2024-05-24)
 
 ### Feature
 
-* feat: introduce BECStatusBox Widget ([`443b6c1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/443b6c1d7b02c772fda02e2d1eefd5bd40249e0c))
+* feat(widgets/progressbar): SpiralProgressBar added with rpc interface ([`76bd0d3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/76bd0d339ac9ae9e8a3baa0d0d4e951ec1d09670))
+
+
+## v0.54.0 (2024-05-24)
+
+### Build
+
+* build: added pyqt6 as sphinx build dependency ([`a47a8ec`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a47a8ec413934cf7fce8d5b7a5913371d4b3b4a5))
+
+### Feature
+
+* feat(figure): changes to support direct plot functionality ([`fc4d0f3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fc4d0f3bb2a7c2fca9c326d86eb68b305bcd548b))
 
 ### Refactor
 
-* refactor: Change inheritance to QTreeWidget from QWidget ([`d2f2b20`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d2f2b206bb0eab60b8a9b0d0ac60a6b7887fa6fb))
+* refactor(reconstruction): repository structure is changed to separate assets needed for each widget ([`3455c60`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3455c602361d3b5cc3ff9190f9d2870474becf8a))
 
-### Test
+* refactor(clean-up): 1st generation widgets are removed ([`edc25fb`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/edc25fbf9d5a0321e5f0a80b492b6337df807849))
 
-* test: add test suite for bec_status_box and status_item ([`5d4ca81`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5d4ca816cdedec4c88aba9eb326f85392504ea1c))
 
-### Unknown
-
-* Update file requirements.txt ([`505a5ec`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/505a5ec8334ff4422913b3a7b79d39bcb42ad535))
-
-## v0.66.1 (2024-06-20)
+## v0.53.3 (2024-05-16)
 
 ### Fix
 
-* fix: fixed shutdown for pyside ([`2718bc6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2718bc624731301756df524d0d5beef6cb1c1430))
+* fix: removed apparently unnecessary sleep while waiting for an rpc response ([`7d64cac`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7d64cac6610b39d3553ff650354f78ead8ee6b55))
 
-## v0.66.0 (2024-06-20)
 
-### Feature
-
-* feat(rpc): discover widgets automatically ([`ef25f56`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ef25f5638032f931ceb292540ada618508bb2aed))
-
-## v0.65.2 (2024-06-20)
-
-### Fix
-
-* fix(pyqt): webengine must be imported before qcoreapplication ([`cbbd23a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/cbbd23aa33095141e4c265719d176c4aa8c25996))
-
-## v0.65.1 (2024-06-20)
-
-### Fix
-
-* fix: prevent segfault by closing the QCoreApplication, if any ([`fa344a5`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fa344a5799b07a2d8ace63cc7010b69bc4ed6f1d))
-
-## v0.65.0 (2024-06-20)
-
-### Feature
-
-* feat(device_input): DeviceLineEdit with QCompleter added ([`50e41ff`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/50e41ff26160ec26d77feb6d519e4dad902a9b9b))
-
-* feat(device_combobox): DeviceInputBase and DeviceComboBox added ([`430b282`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/430b282039806e3fbc6cf98e958861a065760620))
-
-### Fix
-
-* fix(device_input_base): bug with setting config and overwriting default device and filter ([`d79f7e9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d79f7e9ccde03dc77819ca556c79736d30f7821a))
-
-### Test
-
-* test(device_input): tests added ([`1a0a98a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1a0a98a45367db414bed813bbd346b3e1ae8d550))
-
-## v0.64.2 (2024-06-19)
-
-### Fix
-
-* fix(client_utils): added close rpc command to shutdown of gui from bec_ipython_client ([`e5a7d47`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e5a7d47b21cbf066f740f1d11d7c9ea7c70f3080))
-
-## v0.64.1 (2024-06-19)
-
-### Fix
-
-* fix(widgets): removed widget module import of sub widgets ([`216511b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/216511b951ff0e15b6d7c70133095f3ac45c23f4))
-
-### Refactor
-
-* refactor(utils): moved get_rpc_widgets to plugin_utils ([`6dabbf8`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6dabbf874fbbdde89c34a7885bf95aa9c895a28b))
-
-### Test
-
-* test: moved rpc_classes test ([`b3575eb`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b3575eb06852b456cde915dfda281a3e778e3aeb))
-
-## v0.64.0 (2024-06-19)
+## v0.53.2 (2024-05-15)
 
 ### Ci
 
-* ci: add job optional dependency check ([`27426ce`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/27426ce7a52b4cbad7f3bef114d6efe6ad73bd7f))
+* ci: added echo to highlight the current branch ([`0490e80`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0490e80c48563e4fb486bce903b3ce1f08863e83))
+
+### Fix
+
+* fix: check device class without importing to speed up initial import time ([`9f8fbdd`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9f8fbdd5fc13cf2be10eacb41e10cf742864cd92))
+
+* fix: speed up initial import times using lazy import (from bec_lib) ([`d1e6cd3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d1e6cd388c6c9f345f52d6096d8a75a1fa7e6934))
+
+* fix: adapt to bec_lib changes (no more submodules in `__init__.py`) ([`5d09a13`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5d09a13d8820a8bdb900733c97593b723a2fce1d))
+
+
+## v0.53.1 (2024-05-09)
+
+### Ci
+
+* ci: fixed rtd pages url ([`8ff3610`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8ff36105d1e637c429915b4bfc2852d54a3c6f19))
+
+### Fix
+
+* fix: docs config ([`0f6a5e5`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0f6a5e5fa9530969c98a9266c9ca7b89a378ff70))
+
+
+## v0.53.0 (2024-05-09)
+
+### Ci
+
+* ci: use formatter config of toml file ([`5cc816d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5cc816d0af73e20c648e044a027c589704ab1625))
 
 ### Documentation
 
-* docs: fix links in developer section ([`9e16f2f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9e16f2faf9c59a5d36ae878512c5a910cca31e69))
-
-* docs: refactor developer section, add widget tutorial ([`2a36d93`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2a36d9364f242bf42e4cda4b50e6f46aa3833bbd))
+* docs: update install instructions ([`57ee735`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/57ee735e5c2436d45a285507cdc939daa20e8e8f))
 
 ### Feature
 
-* feat: add option to change size of the fonts ([`ea805d1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ea805d1362fc084d3b703b6f81b0180072f0825d))
+* feat: moved to pyproject.toml; closes #162 ([`c86ce30`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c86ce302a964d71ee631f0817609ab5aa0e3ab0f))
 
 ### Fix
 
-* fix(plot_base): font size is set with setScale which is scaling the whole legend window ([`5d66720`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5d6672069ea1cbceb62104f66c127e4e3c23e4a4))
-
-### Test
-
-* test: add tests ([`140ad83`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/140ad83380808928edf7953e23c762ab72a0a1e9))
-
-## v0.63.2 (2024-06-14)
-
-### Fix
-
-* fix: do not import "server" in client, prevents from having trouble with QApplication creation order
-
-Like with QtWebEngine ([`6f96498`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6f96498de66358b89f3a2035627eed2e02dde5a1))
-
-### Unknown
-
-* Reapply "feat: implement non-polling, interruptible waiting of gui instruction response with timeout"
-
-This reverts commit fe04dd80e59a0e74f7fdea603e0642707ecc7c2a. ([`836b6e6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/836b6e64f694916d6b6f909dedf11a4a6d2c86a4))
-
-## v0.63.1 (2024-06-13)
-
-### Fix
-
-* fix: just terminate the remote process in close() instead of communicating
-
-The proper finalization sequence will be executed by the remote process
-on SIGTERM ([`9263f8e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9263f8ef5c17ae7a007a1a564baf787b39061756))
-
-## v0.63.0 (2024-06-13)
-
-### Documentation
-
-* docs: add documentation ([`bc709c4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/bc709c4184c985d4e721f9ea7d1b3dad5e9153a7))
-
-### Feature
-
-* feat: add textbox widget ([`d9d4e3c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d9d4e3c9bf73ab2a5629c2867b50fc91e69489ec))
+* fix: fixed semver job and upgraded to v9 ([`32e1a9d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/32e1a9d8472eb1c25d30697d407a8ffecd04e75d))
 
 ### Refactor
 
-* refactor: add pydantic config, add change_theme ([`6b8432f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6b8432f5b20a71175a3537b5f6832b76e3b67d73))
+* refactor: applied formatter ([`4117fd7`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4117fd7b5b2090ff4fb7ad9e0d92cc87cd13ed5f))
 
-### Test
 
-* test: add test for text box ([`b49462a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b49462abeb186e56bac79d2ef0b0add1ef28a1a5))
-
-### Unknown
-
-* Revert "feat: implement non-polling, interruptible waiting of gui instruction response with timeout"
-
-This reverts commit abc6caa2d0b6141dfbe1f3d025f78ae14deddcb3 ([`fe04dd8`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fe04dd80e59a0e74f7fdea603e0642707ecc7c2a))
-
-## v0.62.0 (2024-06-12)
-
-### Feature
-
-* feat: implement non-polling, interruptible waiting of gui instruction response with timeout ([`abc6caa`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/abc6caa2d0b6141dfbe1f3d025f78ae14deddcb3))
-
-### Unknown
-
-* doc: add documentation about creating custom GUI applications embedding BEC Widgets ([`17a0068`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/17a00687579f5efab1990cd83862ec0e78198633))
-
-## v0.61.0 (2024-06-12)
-
-### Feature
-
-* feat(widgets/stop_button): General stop button added ([`61ba08d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/61ba08d0b8df9f48f5c54c7c2b4e6d395206e7e6))
-
-### Refactor
-
-* refactor: improve labe of auto_update script ([`40b5688`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/40b568815893cd41af3531bb2e647ca1e2e315f4))
-
-## v0.60.0 (2024-06-08)
+## v0.52.1 (2024-05-08)
 
 ### Fix
 
-* fix: removed BECConnector from rpc client interface ([`6428e38`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6428e38ab94c15a2c904e75cc6404bb6d0394e04))
+* fix(docstrings): docstrings formating fixed for sphinx to properly format readdocs ([`7f2f7cd`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7f2f7cd07a14876617cd83cedde8c281fdc52c3a))
+
+
+## v0.52.0 (2024-05-07)
+
+### Ci
+
+* ci: fixed support for child pipelines ([`e65c7f3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e65c7f3be895ada407bd358edf67d569d2cab08e))
+
+### Feature
+
+* feat(utils/layout_manager): added GridLayoutManager to extend functionalities of native QGridLayout ([`fcd6ef0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fcd6ef0975dc872f69c9d6fb2b8a1ad04a423aae))
+
+* feat(widget/dock): BECDock and BECDock area for dockable windows ([`d8ff8af`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d8ff8afcd474660a6069bbdab05f10a65f221727))
+
+### Fix
+
+* fix(widgets/dock): BECDockArea close overwrites the default pyqtgraph Container close + minor improvements ([`ceae979`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ceae979f375ecc33c5c97148f197655c1ca57b6c))
+
+### Refactor
+
+* refactor(widget/plots): WidgetConfig changed to SubplotConfig ([`03fa1f2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/03fa1f26d0fa6b58ed05556fb2438d1e62f6c107))
+
+
+## v0.51.0 (2024-05-07)
+
+### Build
+
+* build(cli): changed repo name to bec_widgets ([`799ea55`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/799ea554de9a7f3720d100be4886a63f02c6a390))
+
+* build(setup): fakeredis added to dev env ([`df32350`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/df323504fea024a97304d96c2e39e61450714069))
+
+* build(setup): PyQt6 version is set to 6.7 ([`0ab8aa3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0ab8aa3a2fe51b5c38b25fca44c1c422bb42478d))
+
+### Ci
+
+* ci: added rule for parent-child pipelines ([`e085125`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e0851250eecb85503db929d37f75d2ba366308a6))
+
+### Feature
+
+* feat(utils): added plugin helper to find and load ([`5ece269`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5ece269adb0e9b0c2a468f1dfbaa6212e86d3561))
+
+
+## v0.50.2 (2024-04-30)
+
+### Fix
+
+* fix: 'disconnect_slot' has to be symmetric with 'connect_slot' regarding QtThreadSafeCallback ([`0dfcaa4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0dfcaa4b708948af0a40ec7cf34d03ff1e96ffac))
+
+
+## v0.50.1 (2024-04-29)
+
+### Fix
+
+* fix(cli): BECFigure takes the port to connect to redis from the current BECClient, supporting plugins ([`57cb136`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/57cb136a098e87a452414bf44e627edb562f6799))
+
+
+## v0.50.0 (2024-04-29)
+
+### Feature
+
+* feat(plots): universal cleanup and remove also for children items ([`381d713`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/381d713837bb9217c58ba1d8b89691aa35c9f5ec))
+
+* feat(rpc/rpc_register): singleton rpc register for all rpc connections for session ([`a898e7e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a898e7e4f14e9ae854703dddbd1eb8c50cb640ff))
+
+### Fix
+
+* fix(widgets/figure): access pattern changed for getting widgets by coordinates for rpc ([`13c018a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/13c018a79704a7497c140df57179d294e43ecffa))
+
+* fix(plots): cleanup policy reviewed for children items ([`8f20a0b`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8f20a0b3b1b5dd117b36b45645717190b9ee9cbf))
+
+* fix(rpc/client_utils): getoutput more transparent + error handling ([`6b6a6b2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6b6a6b2249f24d3d02bd5fcd7ef1c63ed794c304))
+
+* fix(rpc_register): thread lock for listign all connections ([`2ca3267`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2ca32675ec3f00137e2140259db51f6e5aa7bb71))
+
+### Test
+
+* test(cli/rpc_register): e2e RPCRegister ([`4f261be`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4f261be4c7cfe54501443d031f9266f4f838f6e2))
+
+* test(cli/rpc_register): rpc_register tests added ([`40eb75f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/40eb75f85a4d99d498b086a37e799276a9d2ac3f))
+
+
+## v0.49.1 (2024-04-26)

bec_widgets/cli/__init__.py

@@ -1 +1,8 @@
-from .client import *
+from bec_lib.utils.import_utils import lazy_import_from
+
+# from .auto_updates import AutoUpdates, ScanInfo
+# TODO: put back when Pydantic gets faster
+AutoUpdates, ScanInfo = lazy_import_from(
+    "bec_widgets.cli.auto_updates", ("AutoUpdates", "ScanInfo")
+)
+from .client import BECDockArea, BECFigure

bec_widgets/cli/auto_updates.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from pydantic import BaseModel
 
 if TYPE_CHECKING:
-    from .client import BECDockArea, BECFigure
+    from .client import BECFigure
 
 
 class ScanInfo(BaseModel):
@@ -15,24 +15,12 @@ class ScanInfo(BaseModel):
     scan_report_devices: list
     monitored_devices: list
     status: str
-    model_config: dict = {"validate_assignment": True}
 
 
 class AutoUpdates:
-    create_default_dock: bool = False
-    enabled: bool = False
-    dock_name: str = None
-
-    def __init__(self, gui: BECDockArea):
-        self.gui = gui
-
-    def start_default_dock(self):
-        """
-        Create a default dock for the auto updates.
-        """
-        dock = self.gui.add_dock("default_figure")
-        dock.add_widget("BECFigure")
-        self.dock_name = "default_figure"
+    def __init__(self, figure: BECFigure, enabled: bool = True):
+        self.enabled = enabled
+        self.figure = figure
 
     @staticmethod
     def get_scan_info(msg) -> ScanInfo:
@@ -56,18 +44,6 @@ class AutoUpdates:
             status=status,
         )
 
-    def get_default_figure(self) -> BECFigure | None:
-        """
-        Get the default figure from the GUI.
-        """
-        dock = self.gui.panels.get(self.dock_name, [])
-        if not dock:
-            return None
-        widgets = dock.widget_list
-        if not widgets:
-            return None
-        return widgets[0]
-
     def run(self, msg):
         """
         Run the update function if enabled.
@@ -110,44 +86,33 @@ class AutoUpdates:
         """
         Simple line scan.
         """
-        fig = self.get_default_figure()
-        if not fig:
-            return
         dev_x = info.scan_report_devices[0]
-        dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
+        dev_y = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
         if not dev_y:
             return
-        fig.clear_all()
-        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
+        self.figure.clear_all()
+        plt = self.figure.plot(dev_x, dev_y)
         plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
 
     def simple_grid_scan(self, info: ScanInfo) -> None:
         """
         Simple grid scan.
         """
-        fig = self.get_default_figure()
-        if not fig:
-            return
         dev_x = info.scan_report_devices[0]
         dev_y = info.scan_report_devices[1]
-        dev_z = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
-        fig.clear_all()
-        plt = fig.plot(
-            x_name=dev_x, y_name=dev_y, z_name=dev_z, label=f"Scan {info.scan_number} - {dev_z}"
-        )
+        dev_z = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
+        self.figure.clear_all()
+        plt = self.figure.plot(dev_x, dev_y, dev_z, label=f"Scan {info.scan_number}")
         plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
 
     def best_effort(self, info: ScanInfo) -> None:
         """
         Best effort scan.
         """
-        fig = self.get_default_figure()
-        if not fig:
-            return
         dev_x = info.scan_report_devices[0]
-        dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
+        dev_y = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
         if not dev_y:
             return
-        fig.clear_all()
-        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
+        self.figure.clear_all()
+        plt = self.figure.plot(dev_x, dev_y, label=f"Scan {info.scan_number}")
         plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)

bec_widgets/cli/client_utils.py

@@ -14,18 +14,13 @@ from typing import TYPE_CHECKING
 
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.utils.import_utils import isinstance_based_on_class_name, lazy_import, lazy_import_from
-from qtpy.QtCore import QEventLoop, QSocketNotifier, QTimer
+from qtpy.QtCore import QCoreApplication
 
 import bec_widgets.cli.client as client
-from bec_widgets.cli.auto_updates import AutoUpdates
 
 if TYPE_CHECKING:
     from bec_lib.device import DeviceBase
 
-    from bec_widgets.cli.client import BECDockArea, BECFigure
-
-from bec_lib.serialization import MsgpackSerialization
-
 messages = lazy_import("bec_lib.messages")
 # from bec_lib.connector import MessageObject
 MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
@@ -63,66 +58,20 @@ def rpc_call(func):
     return wrapper
 
 
-def _get_output(process) -> None:
-    try:
-        os.set_blocking(process.stdout.fileno(), False)
-        os.set_blocking(process.stderr.fileno(), False)
-        while process.poll() is None:
-            readylist, _, _ = select.select([process.stdout, process.stderr], [], [], 1)
-            if process.stdout in readylist:
-                output = process.stdout.read(1024)
-                if output:
-                    print(output, end="")
-            if process.stderr in readylist:
-                error_output = process.stderr.read(1024)
-                if error_output:
-                    print(error_output, end="", file=sys.stderr)
-    except Exception as e:
-        print(f"Error reading process output: {str(e)}")
-
-
-def _start_plot_process(gui_id, gui_class, config) -> None:
-    """
-    Start the plot in a new process.
-    """
-    # pylint: disable=subprocess-run-check
-    command = [
-        "bec-gui-server",
-        "--id",
-        gui_id,
-        "--config",
-        config,
-        "--gui_class",
-        gui_class.__name__,
-    ]
-    env_dict = os.environ.copy()
-    env_dict["PYTHONUNBUFFERED"] = "1"
-    process = subprocess.Popen(
-        command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env_dict
-    )
-    process_output_processing_thread = threading.Thread(target=_get_output, args=(process,))
-    process_output_processing_thread.start()
-    return process, process_output_processing_thread
-
-
 class BECGuiClientMixin:
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._process = None
-        self._process_output_processing_thread = None
-        self.auto_updates = self._get_update_script()
+        self.update_script = self._get_update_script()
         self._target_endpoint = MessageEndpoints.scan_status()
         self._selected_device = None
         self.stderr_output = []
 
-    def _get_update_script(self) -> AutoUpdates | None:
+    def _get_update_script(self) -> AutoUpdates:
         eps = imd.entry_points(group="bec.widgets.auto_updates")
         for ep in eps:
             if ep.name == "plugin_widgets_update":
-                try:
-                    return ep.load()(gui=self)
-                except Exception as e:
-                    print(f"Error loading auto update script from plugin: {str(e)}")
+                return ep.load()(figure=self)
         return None
 
     @property
@@ -148,7 +97,7 @@ class BECGuiClientMixin:
 
     @staticmethod
     def _handle_msg_update(msg: MessageObject, parent: BECGuiClientMixin) -> None:
-        if parent.auto_updates is not None:
+        if parent.update_script is not None:
             # pylint: disable=protected-access
             parent._update_script_msg_parser(msg.value)
 
@@ -156,37 +105,60 @@ class BECGuiClientMixin:
         if isinstance(msg, messages.ScanStatusMessage):
             if not self.gui_is_alive():
                 return
-            self.auto_updates.run(msg)
+            self.update_script.run(msg)
 
     def show(self) -> None:
         """
         Show the figure.
         """
         if self._process is None or self._process.poll() is not None:
-            self._start_update_script()
-            self._process, self._process_output_processing_thread = _start_plot_process(
-                self._gui_id, self.__class__, self._client._service_config.redis
-            )
+            self._start_plot_process()
         while not self.gui_is_alive():
             print("Waiting for GUI to start...")
             time.sleep(1)
 
     def close(self) -> None:
         """
-        Close the gui window.
+        Close the figure.
         """
         if self._process is None:
             return
-
-        self._run_rpc("close", (), wait_for_rpc_response=False)
-        while self.gui_is_alive():
-            time.sleep(0.2)
-
+        if self.gui_is_alive():
+            self._run_rpc("close", (), wait_for_rpc_response=True)
+        else:
+            self._run_rpc("close", (), wait_for_rpc_response=False)
+        self._process.terminate()
+        self._process_output_processing_thread.join()
+        self._process = None
         self._client.shutdown()
-        if self._process:
-            self._process.terminate()
-            self._process_output_processing_thread.join()
-            self._process = None
+
+    def _start_plot_process(self) -> None:
+        """
+        Start the plot in a new process.
+        """
+        self._start_update_script()
+        # pylint: disable=subprocess-run-check
+        config = self._client._service_config.redis
+        monitor_module = importlib.import_module("bec_widgets.cli.server")
+        monitor_path = monitor_module.__file__
+        gui_class = self.__class__.__name__
+
+        command = [
+            sys.executable,
+            "-u",
+            monitor_path,
+            "--id",
+            self._gui_id,
+            "--config",
+            config,
+            "--gui_class",
+            gui_class,
+        ]
+        self._process = subprocess.Popen(
+            command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        self._process_output_processing_thread = threading.Thread(target=self._get_output)
+        self._process_output_processing_thread.start()
 
     def print_log(self) -> None:
         """
@@ -198,6 +170,26 @@ class BECGuiClientMixin:
         # Flush list
         self.stderr_output.clear()
 
+    def _get_output(self) -> str:
+        try:
+            os.set_blocking(self._process.stdout.fileno(), False)
+            os.set_blocking(self._process.stderr.fileno(), False)
+            while self._process.poll() is None:
+                readylist, _, _ = select.select(
+                    [self._process.stdout, self._process.stderr], [], [], 1
+                )
+                if self._process.stdout in readylist:
+                    output = self._process.stdout.read(1024)
+                    if output:
+                        print(output, end="")
+                if self._process.stderr in readylist:
+                    error_output = self._process.stderr.read(1024)
+                    if error_output:
+                        print(error_output, end="", file=sys.stderr)
+                        self.stderr_output.append(error_output)
+        except Exception as e:
+            print(f"Error reading process output: {str(e)}")
+
 
 class RPCResponseTimeoutError(Exception):
     """Exception raised when an RPC response is not received within the expected time."""
@@ -208,48 +200,6 @@ class RPCResponseTimeoutError(Exception):
         )
 
 
-class QtRedisMessageWaiter:
-    def __init__(self, redis_connector, message_to_wait):
-        self.ev_loop = QEventLoop()
-        self.response = None
-        self.connector = redis_connector
-        self.message_to_wait = message_to_wait
-        self.pubsub = redis_connector._redis_conn.pubsub()
-        self.pubsub.subscribe(self.message_to_wait.endpoint)
-        fd = self.pubsub.connection._sock.fileno()
-        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
-        self.notifier.activated.connect(self._pubsub_readable)
-
-    def _msg_received(self, msg_obj):
-        self.response = msg_obj.value
-        self.ev_loop.quit()
-
-    def wait(self, timeout=1):
-        timer = QTimer()
-        timer.singleShot(timeout * 1000, self.ev_loop.quit)
-        self.ev_loop.exec_()
-        timer.stop()
-        self.notifier.setEnabled(False)
-        self.pubsub.close()
-        return self.response
-
-    def _pubsub_readable(self, fd):
-        while True:
-            msg = self.pubsub.get_message()
-            if msg:
-                if msg["type"] == "subscribe":
-                    # get_message buffers, so we may already have the answer
-                    # let's check...
-                    continue
-                else:
-                    break
-            else:
-                return
-        channel = msg["channel"].decode()
-        msg = MessageObject(topic=channel, value=MsgpackSerialization.loads(msg["data"]))
-        self.connector._execute_callback(self._msg_received, msg, {})
-
-
 class RPCBase:
     def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
         self._client = BECDispatcher().client
@@ -276,7 +226,7 @@ class RPCBase:
             parent = parent._parent
         return parent
 
-    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=3, **kwargs):
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, **kwargs):
         """
         Run the RPC call.
 
@@ -298,24 +248,16 @@ class RPCBase:
 
         # pylint: disable=protected-access
         receiver = self._root._gui_id
-        if wait_for_rpc_response:
-            redis_msg = QtRedisMessageWaiter(
-                self._client.connector, MessageEndpoints.gui_instruction_response(request_id)
-            )
-
         self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
 
-        if wait_for_rpc_response:
-            response = redis_msg.wait(timeout)
-
-            if response is None:
-                raise RPCResponseTimeoutError(request_id, timeout)
-
-            # get class name
-            if not response.accepted:
-                raise ValueError(response.message["error"])
-            msg_result = response.message.get("result")
-            return self._create_widget_from_msg_result(msg_result)
+        if not wait_for_rpc_response:
+            return None
+        response = self._wait_for_response(request_id)
+        # get class name
+        if not response.content["accepted"]:
+            raise ValueError(response.content["message"]["error"])
+        msg_result = response.content["message"].get("result")
+        return self._create_widget_from_msg_result(msg_result)
 
     def _create_widget_from_msg_result(self, msg_result):
         if msg_result is None:
@@ -338,6 +280,30 @@ class RPCBase:
             return cls(parent=self, **msg_result)
         return msg_result
 
+    def _wait_for_response(self, request_id: str, timeout: int = 5):
+        """
+        Wait for the response from the server.
+
+        Args:
+            request_id(str): The request ID.
+            timeout(int): The timeout in seconds.
+
+        Returns:
+            The response from the server.
+        """
+        start_time = time.time()
+        response = None
+
+        while response is None and self.gui_is_alive() and (time.time() - start_time) < timeout:
+            response = self._client.connector.get(
+                MessageEndpoints.gui_instruction_response(request_id)
+            )
+            QCoreApplication.processEvents()  # keep UI responsive (and execute signals/slots)
+        if response is None and (time.time() - start_time) >= timeout:
+            raise RPCResponseTimeoutError(request_id, timeout)
+
+        return response
+
     def gui_is_alive(self):
         """
         Check if the GUI is alive.

bec_widgets/cli/generate_cli.py

@@ -1,16 +1,10 @@
 # pylint: disable=missing-module-docstring
 from __future__ import annotations
 
-import argparse
 import inspect
-import os
 import sys
-from typing import Literal
 
 import black
-import isort
-
-from bec_widgets.utils.plugin_utils import get_rpc_classes
 
 if sys.version_info >= (3, 11):
     from typing import get_overloads
@@ -20,52 +14,30 @@ else:
         "If you want to use the real function 'typing.get_overloads()', please use Python 3.11 or later."
     )
 
-    def get_overloads(_obj):
-        """
-        Dummy function for Python versions before 3.11.
-        """
+    def get_overloads(obj):
+        # Dummy function for Python versions before 3.11
         return []
 
 
 class ClientGenerator:
     def __init__(self):
         self.header = """# This file was automatically generated by generate_cli.py\n
-import enum
-from typing import Literal, Optional, overload
-
-from bec_widgets.cli.client_utils import RPCBase, rpc_call, BECGuiClientMixin
-
-# pylint: skip-file"""
+from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECGuiClientMixin
+from typing import Literal, Optional, overload"""
 
         self.content = ""
 
-    def generate_client(
-        self, published_classes: dict[Literal["connector_classes", "top_level_classes"], list[type]]
-    ):
+    def generate_client(self, published_classes: list):
         """
         Generate the client for the published classes.
 
         Args:
-            published_classes(dict): A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
+            published_classes(list): The list of published classes (e.g. [BECWaveform1D, BECFigure]).
         """
-        self.write_client_enum(published_classes["top_level_classes"])
-        for cls in published_classes["connector_classes"]:
+        for cls in published_classes:
             self.content += "\n\n"
             self.generate_content_for_class(cls)
 
-    def write_client_enum(self, published_classes: list[type]):
-        """
-        Write the client enum to the content.
-        """
-        self.content += """
-class Widgets(str, enum.Enum):
-    \"\"\"
-    Enum for the available widgets.
-    \"\"\"
-    """
-        for cls in published_classes:
-            self.content += f'{cls.__name__} = "{cls.__name__}"\n    '
-
     def generate_content_for_class(self, cls):
         """
         Generate the content for the class.
@@ -75,6 +47,11 @@ class Widgets(str, enum.Enum):
         """
 
         class_name = cls.__name__
+        module = cls.__module__
+
+        # Generate the header
+        #         self.header += f"""
+        # from {module} import {class_name}"""
 
         # Generate the content
         if cls.__name__ == "BECDockArea":
@@ -124,41 +101,39 @@ class {class_name}(RPCBase):"""
         except black.NothingChanged:
             formatted_content = full_content
 
-        isort.Config(
-            profile="black",
-            line_length=100,
-            multi_line_output=3,
-            include_trailing_comma=True,
-            known_first_party=["bec_widgets"],
-        )
-        formatted_content = isort.code(formatted_content)
-
         with open(file_name, "w", encoding="utf-8") as file:
             file.write(formatted_content)
 
 
-def main():
-    """
-    Main entry point for the script, controlled by command line arguments.
-    """
-
-    parser = argparse.ArgumentParser(description="Auto-generate the client for RPC widgets")
-    parser.add_argument("--core", action="store_true", help="Whether to generate the core client")
-
-    args = parser.parse_args()
-
-    if args.core:
-        current_path = os.path.dirname(__file__)
-        client_path = os.path.join(current_path, "client.py")
-
-        rpc_classes = get_rpc_classes("bec_widgets")
-        rpc_classes["connector_classes"].sort(key=lambda x: x.__name__)
-
-        generator = ClientGenerator()
-        generator.generate_client(rpc_classes)
-        generator.write(client_path)
-
-
 if __name__ == "__main__":  # pragma: no cover
-    sys.argv = ["generate_cli.py", "--core"]
-    main()
+    import os
+
+    from bec_widgets.utils import BECConnector
+    from bec_widgets.widgets import BECDock, BECDockArea, BECFigure, SpiralProgressBar
+    from bec_widgets.widgets.figure.plots.image.image import BECImageShow
+    from bec_widgets.widgets.figure.plots.image.image_item import BECImageItem
+    from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap
+    from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase
+    from bec_widgets.widgets.figure.plots.waveform.waveform import BECWaveform
+    from bec_widgets.widgets.figure.plots.waveform.waveform_curve import BECCurve
+    from bec_widgets.widgets.spiral_progress_bar.ring import Ring
+
+    current_path = os.path.dirname(__file__)
+    client_path = os.path.join(current_path, "client.py")
+    clss = [
+        BECPlotBase,
+        BECWaveform,
+        BECFigure,
+        BECCurve,
+        BECImageShow,
+        BECConnector,
+        BECImageItem,
+        BECMotorMap,
+        BECDock,
+        BECDockArea,
+        SpiralProgressBar,
+        Ring,
+    ]
+    generator = ClientGenerator()
+    generator.generate_client(clss)
+    generator.write(client_path)

bec_widgets/cli/rpc_wigdet_handler.py

@@ -1,37 +1,15 @@
 from bec_widgets.utils import BECConnector
+from bec_widgets.widgets.figure import BECFigure
+from bec_widgets.widgets.spiral_progress_bar.spiral_progress_bar import SpiralProgressBar
 
 
 class RPCWidgetHandler:
     """Handler class for creating widgets from RPC messages."""
 
-    def __init__(self):
-        self._widget_classes = None
+    widget_classes = {"BECFigure": BECFigure, "SpiralProgressBar": SpiralProgressBar}
 
-    @property
-    def widget_classes(self):
-        """
-        Get the available widget classes.
-
-        Returns:
-            dict: The available widget classes.
-        """
-        if self._widget_classes is None:
-            self.update_available_widgets()
-        return self._widget_classes
-
-    def update_available_widgets(self):
-        """
-        Update the available widgets.
-
-        Returns:
-            None
-        """
-        from bec_widgets.utils.plugin_utils import get_rpc_classes
-
-        clss = get_rpc_classes("bec_widgets")
-        self._widget_classes = {cls.__name__: cls for cls in clss["top_level_classes"]}
-
-    def create_widget(self, widget_type, **kwargs) -> BECConnector:
+    @staticmethod
+    def create_widget(widget_type, **kwargs) -> BECConnector:
         """
         Create a widget from an RPC message.
 
@@ -42,12 +20,7 @@ class RPCWidgetHandler:
         Returns:
             widget(BECConnector): The created widget.
         """
-        if self._widget_classes is None:
-            self.update_available_widgets()
-        widget_class = self._widget_classes.get(widget_type)
+        widget_class = RPCWidgetHandler.widget_classes.get(widget_type)
         if widget_class:
             return widget_class(**kwargs)
         raise ValueError(f"Unknown widget type: {widget_type}")
-
-
-widget_handler = RPCWidgetHandler()

bec_widgets/cli/server.py

@@ -40,7 +40,7 @@ class BECWidgetsCLIServer:
         self._shutdown_event = False
         self._heartbeat_timer = QTimer()
         self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
-        self._heartbeat_timer.start(200)
+        self._heartbeat_timer.start(200)  # Emit heartbeat every 1 seconds
 
     def on_rpc_update(self, msg: dict, metadata: dict):
         request_id = metadata.get("request_id")
@@ -105,7 +105,7 @@ class BECWidgetsCLIServer:
             self.client.connector.set(
                 MessageEndpoints.gui_heartbeat(self.gui_id),
                 messages.StatusMessage(name=self.gui_id, status=1, info={}),
-                expire=1,
+                expire=10,
             )
 
     def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
@@ -114,7 +114,7 @@ class BECWidgetsCLIServer:
         self.client.shutdown()
 
 
-def main():
+if __name__ == "__main__":  # pragma: no cover
     import argparse
     import os
     import sys
@@ -166,7 +166,3 @@ def main():
 
     app.aboutToQuit.connect(server.shutdown)
     sys.exit(app.exec())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/examples/eiger_plot/eiger_plot.py

@@ -0,0 +1,313 @@
+import json
+import os
+import threading
+
+import h5py
+import numpy as np
+import pyqtgraph as pg
+import zmq
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtGui import QKeySequence
+from qtpy.QtWidgets import QDialog, QFileDialog, QFrame, QLabel, QShortcut, QVBoxLayout, QWidget
+
+from bec_widgets.utils import UILoader
+
+# from scipy.stats import multivariate_normal
+
+
+class EigerPlot(QWidget):
+    update_signal = pyqtSignal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        # pg.setConfigOptions(background="w", foreground="k", antialias=True)
+
+        current_path = os.path.dirname(__file__)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "eiger_plot.ui"), self)
+
+        # Set widow name
+        self.setWindowTitle("Eiger Plot")
+
+        self.hist_lims = None
+        self.mask = None
+        self.image = None
+
+        # UI
+        self.init_ui()
+        self.hook_signals()
+        self.key_bindings()
+
+        # ZMQ Consumer
+        self._zmq_consumer_exit_event = threading.Event()
+        self._zmq_consumer_thread = self.start_zmq_consumer()
+
+    def close(self):
+        super().close()
+        self._zmq_consumer_exit_event.set()
+        self._zmq_consumer_thread.join()
+
+    def init_ui(self):
+        # Create Plot and add ImageItem
+        self.plot_item = pg.PlotItem()
+        self.plot_item.setAspectLocked(True)
+        self.imageItem = pg.ImageItem()
+        self.plot_item.addItem(self.imageItem)
+
+        # Setting up histogram
+        self.hist = pg.HistogramLUTItem()
+        self.hist.setImageItem(self.imageItem)
+        self.hist.gradient.loadPreset("magma")
+        self.update_hist()
+
+        # Adding Items to Graphical Layout
+        self.glw_layout = QVBoxLayout(self.ui.glw_placeholder)
+        self.glw = pg.GraphicsLayoutWidget()
+        self.glw_layout.addWidget(self.glw)
+        self.glw.addItem(self.plot_item)
+        self.glw.addItem(self.hist)
+
+    def hook_signals(self):
+        # Buttons
+        # self.pushButton_test.clicked.connect(self.start_sim_stream)
+        self.ui.pushButton_mask.clicked.connect(self.load_mask_dialog)
+        self.ui.pushButton_delete_mask.clicked.connect(self.delete_mask)
+        self.ui.pushButton_help.clicked.connect(self.show_help_dialog)
+
+        # SpinBoxes
+        self.ui.doubleSpinBox_hist_min.valueChanged.connect(self.update_hist)
+        self.ui.doubleSpinBox_hist_max.valueChanged.connect(self.update_hist)
+
+        # Signal/Slots
+        self.update_signal.connect(self.on_image_update)
+
+    def key_bindings(self):
+        # Key bindings for rotation
+        rotate_plus = QShortcut(QKeySequence("Ctrl+A"), self)
+        rotate_minus = QShortcut(QKeySequence("Ctrl+Z"), self)
+        self.ui.comboBox_rotation.setToolTip("Increase rotation: Ctrl+A\nDecrease rotation: Ctrl+Z")
+        self.ui.checkBox_transpose.setToolTip("Toggle transpose: Ctrl+T")
+
+        max_index = self.ui.comboBox_rotation.count() - 1  # Maximum valid index
+
+        rotate_plus.activated.connect(
+            lambda: self.ui.comboBox_rotation.setCurrentIndex(
+                min(self.ui.comboBox_rotation.currentIndex() + 1, max_index)
+            )
+        )
+
+        rotate_minus.activated.connect(
+            lambda: self.ui.comboBox_rotation.setCurrentIndex(
+                max(self.ui.comboBox_rotation.currentIndex() - 1, 0)
+            )
+        )
+
+        # Key bindings for transpose
+        transpose = QShortcut(QKeySequence("Ctrl+T"), self)
+        transpose.activated.connect(self.ui.checkBox_transpose.toggle)
+
+        FFT = QShortcut(QKeySequence("Ctrl+F"), self)
+        FFT.activated.connect(self.ui.checkBox_FFT.toggle)
+        self.ui.checkBox_FFT.setToolTip("Toggle FFT: Ctrl+F")
+
+        log = QShortcut(QKeySequence("Ctrl+L"), self)
+        log.activated.connect(self.ui.checkBox_log.toggle)
+        self.ui.checkBox_log.setToolTip("Toggle log: Ctrl+L")
+
+        mask = QShortcut(QKeySequence("Ctrl+M"), self)
+        mask.activated.connect(self.ui.pushButton_mask.click)
+        self.ui.pushButton_mask.setToolTip("Load mask: Ctrl+M")
+
+        delete_mask = QShortcut(QKeySequence("Ctrl+D"), self)
+        delete_mask.activated.connect(self.ui.pushButton_delete_mask.click)
+        self.ui.pushButton_delete_mask.setToolTip("Delete mask: Ctrl+D")
+
+    def update_hist(self):
+        self.hist_levels = [
+            self.ui.doubleSpinBox_hist_min.value(),
+            self.ui.doubleSpinBox_hist_max.value(),
+        ]
+        self.hist.setLevels(min=self.hist_levels[0], max=self.hist_levels[1])
+        self.hist.setHistogramRange(
+            self.hist_levels[0] - 0.1 * self.hist_levels[0],
+            self.hist_levels[1] + 0.1 * self.hist_levels[1],
+        )
+
+    def load_mask_dialog(self):
+        options = QFileDialog.Options()
+        options |= QFileDialog.ReadOnly
+        file_name, _ = QFileDialog.getOpenFileName(
+            self, "Select Mask File", "", "H5 Files (*.h5);;All Files (*)", options=options
+        )
+        if file_name:
+            self.load_mask(file_name)
+
+    def load_mask(self, path):
+        try:
+            with h5py.File(path, "r") as f:
+                self.mask = f["data"][...]
+            if self.mask is not None:
+                # Set label to mask name without path
+                self.label_mask.setText(os.path.basename(path))
+        except KeyError as e:
+            # Update GUI with the error message
+            print(f"Error: {str(e)}")
+
+    def delete_mask(self):
+        self.mask = None
+        self.label_mask.setText("No Mask")
+
+    @pyqtSlot()
+    def on_image_update(self):
+        # TODO first rotate then transpose
+        if self.mask is not None:
+            # self.image = np.ma.masked_array(self.image, mask=self.mask) #TODO test if np works
+            self.image = self.image * (1 - self.mask) + 1
+
+        if self.ui.checkBox_FFT.isChecked():
+            self.image = np.abs(np.fft.fftshift(np.fft.fft2(self.image)))
+
+        if self.ui.comboBox_rotation.currentIndex() > 0:  # rotate
+            self.image = np.rot90(
+                self.image, k=self.ui.comboBox_rotation.currentIndex(), axes=(0, 1)
+            )
+
+        if self.ui.checkBox_transpose.isChecked():  # transpose
+            self.image = np.transpose(self.image)
+
+        if self.ui.checkBox_log.isChecked():
+            self.image = np.log10(self.image)
+
+        self.imageItem.setImage(self.image, autoLevels=False)
+
+    ###############################
+    # ZMQ Consumer
+    ###############################
+
+    def start_zmq_consumer(self):
+        consumer_thread = threading.Thread(
+            target=self.zmq_consumer, args=(self._zmq_consumer_exit_event,), daemon=True
+        )
+        consumer_thread.start()
+        return consumer_thread
+
+    def zmq_consumer(self, exit_event):
+        print("starting consumer")
+        live_stream_url = "tcp://129.129.95.38:20000"
+        receiver = zmq.Context().socket(zmq.SUB)
+        receiver.connect(live_stream_url)
+        receiver.setsockopt_string(zmq.SUBSCRIBE, "")
+
+        poller = zmq.Poller()
+        poller.register(receiver, zmq.POLLIN)
+
+        # code could be a bit simpler here, testing exit_event in
+        # 'while' condition, but like this it is easier for the
+        # 'test_zmq_consumer' test
+        while True:
+            if poller.poll(1000):  # 1s timeout
+                raw_meta, raw_data = receiver.recv_multipart(zmq.NOBLOCK)
+
+                meta = json.loads(raw_meta.decode("utf-8"))
+                self.image = np.frombuffer(raw_data, dtype=meta["type"]).reshape(meta["shape"])
+                self.update_signal.emit()
+            if exit_event.is_set():
+                break
+
+        receiver.disconnect(live_stream_url)
+
+    ###############################
+    # just simulations from here
+    ###############################
+
+    def show_help_dialog(self):
+        dialog = QDialog(self)
+        dialog.setWindowTitle("Help")
+
+        layout = QVBoxLayout()
+
+        # Key bindings section
+        layout.addWidget(QLabel("Keyboard Shortcuts:"))
+
+        key_bindings = [
+            ("Ctrl+A", "Increase rotation"),
+            ("Ctrl+Z", "Decrease rotation"),
+            ("Ctrl+T", "Toggle transpose"),
+            ("Ctrl+F", "Toggle FFT"),
+            ("Ctrl+L", "Toggle log scale"),
+            ("Ctrl+M", "Load mask"),
+            ("Ctrl+D", "Delete mask"),
+        ]
+
+        for keys, action in key_bindings:
+            layout.addWidget(QLabel(f"{keys} - {action}"))
+
+        # Separator
+        separator = QFrame()
+        separator.setFrameShape(QFrame.HLine)
+        separator.setFrameShadow(QFrame.Sunken)
+        layout.addWidget(separator)
+
+        # Histogram section
+        layout.addWidget(QLabel("Histogram:"))
+        layout.addWidget(
+            QLabel(
+                "Use the Double Spin Boxes to adjust the minimum and maximum values of the histogram."
+            )
+        )
+
+        # Another Separator
+        another_separator = QFrame()
+        another_separator.setFrameShape(QFrame.HLine)
+        another_separator.setFrameShadow(QFrame.Sunken)
+        layout.addWidget(another_separator)
+
+        # Mask section
+        layout.addWidget(QLabel("Mask:"))
+        layout.addWidget(
+            QLabel(
+                "Use 'Load Mask' to load a mask from an H5 file. 'Delete Mask' removes the current mask."
+            )
+        )
+
+        dialog.setLayout(layout)
+        dialog.exec()
+
+    ###############################
+    # just simulations from here
+    ###############################
+    # def start_sim_stream(self):
+    #     sim_stream_thread = threading.Thread(target=self.sim_stream, daemon=True)
+    #     sim_stream_thread.start()
+    #
+    # def sim_stream(self):
+    #     for i in range(100):
+    #         # Generate 100x100 image of random noise
+    #         self.image = np.random.rand(100, 100) * 0.2
+    #
+    #         # Define Gaussian parameters
+    #         x, y = np.mgrid[0:50, 0:50]
+    #         pos = np.dstack((x, y))
+    #
+    #         # Center at (25, 25) longer along y-axis
+    #         rv = multivariate_normal(mean=[25, 25], cov=[[25, 0], [0, 80]])
+    #
+    #         # Generate Gaussian in the first quadrant
+    #         gaussian_quadrant = rv.pdf(pos) * 40
+    #
+    #         # Place Gaussian in the first quadrant
+    #         self.image[0:50, 0:50] += gaussian_quadrant * 10
+    #
+    #         self.update_signal.emit()
+    #         time.sleep(0.1)
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    plot = EigerPlot()
+    plot.show()
+    sys.exit(app.exec())

bec_widgets/examples/eiger_plot/eiger_plot.ui

@@ -0,0 +1,200 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>874</width>
+    <height>762</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_2" stretch="1,4">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QGroupBox" name="groupBox">
+       <property name="title">
+        <string>Plot Control</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout">
+        <item row="0" column="0">
+         <widget class="QLabel" name="label">
+          <property name="text">
+           <string>Histogram MIN</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
+         <widget class="QDoubleSpinBox" name="doubleSpinBox_hist_min">
+          <property name="minimum">
+           <double>-100000.000000000000000</double>
+          </property>
+          <property name="maximum">
+           <double>100000.000000000000000</double>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
+         <widget class="QLabel" name="label_2">
+          <property name="text">
+           <string>Histogram MAX</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
+         <widget class="QDoubleSpinBox" name="doubleSpinBox_hist_max">
+          <property name="minimum">
+           <double>-100000.000000000000000</double>
+          </property>
+          <property name="maximum">
+           <double>100000.000000000000000</double>
+          </property>
+          <property name="value">
+           <double>2.000000000000000</double>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="groupBox_2">
+       <property name="title">
+        <string>Data Control</string>
+       </property>
+       <layout class="QVBoxLayout" name="verticalLayout">
+        <item>
+         <widget class="QCheckBox" name="checkBox_FFT">
+          <property name="enabled">
+           <bool>true</bool>
+          </property>
+          <property name="text">
+           <string>FFT</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="checkBox_log">
+          <property name="text">
+           <string>log</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="pushButton_mask">
+          <property name="text">
+           <string>Load Mask</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="pushButton_delete_mask">
+          <property name="text">
+           <string>Delete Mask</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="groupBox_3">
+       <property name="title">
+        <string>Orientation</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout_2">
+        <item row="2" column="1">
+         <widget class="QComboBox" name="comboBox_rotation">
+          <item>
+           <property name="text">
+            <string>0</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>90</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>180</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>270</string>
+           </property>
+          </item>
+         </widget>
+        </item>
+        <item row="2" column="0">
+         <widget class="QLabel" name="label_3">
+          <property name="text">
+           <string>Rotation</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="0" colspan="2">
+         <widget class="QCheckBox" name="checkBox_transpose">
+          <property name="text">
+           <string>Transpose</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="groupBox_4">
+       <property name="title">
+        <string>Help</string>
+       </property>
+       <layout class="QVBoxLayout" name="verticalLayout_3">
+        <item>
+         <widget class="QLabel" name="label_mask">
+          <property name="text">
+           <string>No Mask</string>
+          </property>
+          <property name="alignment">
+           <set>Qt::AlignCenter</set>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="pushButton_help">
+          <property name="text">
+           <string>Help</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QWidget" name="glw_placeholder" native="true"/>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -2,32 +2,35 @@ import os
 
 import numpy as np
 import pyqtgraph as pg
-import qdarktheme
+from pyqtgraph.Qt import QtWidgets
 from qtconsole.inprocess import QtInProcessKernelManager
 from qtconsole.rich_jupyter_widget import RichJupyterWidget
 from qtpy.QtCore import QSize
 from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
+from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils import BECDispatcher, UILoader
+from bec_widgets.widgets import BECFigure
 from bec_widgets.widgets.dock.dock_area import BECDockArea
-from bec_widgets.widgets.figure import BECFigure
-from bec_widgets.widgets.jupyter_console.jupyter_console import BECJupyterConsole
+from bec_widgets.widgets.spiral_progress_bar.spiral_progress_bar import SpiralProgressBar
 
-# class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
-#     def __init__(self):
-#         super().__init__()
-#
-#         self.kernel_manager = QtInProcessKernelManager()
-#         self.kernel_manager.start_kernel(show_banner=False)
-#         self.kernel_client = self.kernel_manager.client()
-#         self.kernel_client.start_channels()
-#
-#         self.kernel_manager.kernel.shell.push({"np": np, "pg": pg})
-#
-#     def shutdown_kernel(self):
-#         self.kernel_client.stop_channels()
-#         self.kernel_manager.shutdown_kernel()
+
+class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
+    def __init__(self):
+        super().__init__()
+
+        self.kernel_manager = QtInProcessKernelManager()
+        self.kernel_manager.start_kernel(show_banner=False)
+        self.kernel_client = self.kernel_manager.client()
+        self.kernel_client.start_channels()
+
+        self.kernel_manager.kernel.shell.push({"np": np, "pg": pg})
+        # self.set_console_font_size(70)
+
+    def shutdown_kernel(self):
+        self.kernel_client.stop_channels()
+        self.kernel_manager.shutdown_kernel()
 
 
 class JupyterConsoleWindow(QWidget):  # pragma: no cover:
@@ -43,27 +46,32 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
 
         self.ui.splitter.setSizes([200, 100])
         self.safe_close = False
+        # self.figure.clean_signal.connect(self.confirm_close)
+
+        self.register = RPCRegister()
+        self.register.add_rpc(self.figure)
 
         # console push
-        if self.console.inprocess is True:
-            self.console.kernel_manager.kernel.shell.push(
-                {
-                    "np": np,
-                    "pg": pg,
-                    "fig": self.figure,
-                    "dock": self.dock,
-                    "w1": self.w1,
-                    "w2": self.w2,
-                    "w3": self.w3,
-                    "d0": self.d0,
-                    "d1": self.d1,
-                    "d2": self.d2,
-                    "fig0": self.fig0,
-                    "fig1": self.fig1,
-                    "fig2": self.fig2,
-                    "bar": self.bar,
-                }
-            )
+        self.console.kernel_manager.kernel.shell.push(
+            {
+                "fig": self.figure,
+                "register": self.register,
+                "dock": self.dock,
+                "w1": self.w1,
+                "w2": self.w2,
+                "w3": self.w3,
+                "d1": self.d1,
+                "d2": self.d2,
+                "d3": self.d3,
+                "bar": self.bar,
+                "b2a": self.button_2_a,
+                "b2b": self.button_2_b,
+                "b2c": self.button_2_c,
+                "bec": self.figure.client,
+                "scans": self.figure.client.scans,
+                "dev": self.figure.client.device_manager.devices,
+            }
+        )
 
     def _init_ui(self):
         # Plotting window
@@ -82,14 +90,14 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self._init_dock()
 
         self.console_layout = QVBoxLayout(self.ui.widget_console)
-        self.console = BECJupyterConsole(inprocess=True)
+        self.console = JupyterConsoleWidget()
         self.console_layout.addWidget(self.console)
+        self.console.set_default_style("linux")
 
     def _init_figure(self):
-        self.figure.plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="cividis")
+        self.figure.plot(x_name="samx", y_name="bpm4d")
         self.figure.motor_map("samx", "samy")
         self.figure.image("eiger", color_map="viridis", vrange=(0, 100))
-        self.figure.add_plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="magma")
 
         self.figure.change_layout(2, 2)
 
@@ -98,26 +106,30 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.w3 = self.figure[1, 0]
 
         # curves for w1
+        self.w1.add_curve_scan("samx", "samy", "bpm4i", pen_style="dash")
+        self.w1.add_curve_scan("samx", "samy", "bpm3a", pen_style="dash")
         self.c1 = self.w1.get_config()
 
     def _init_dock(self):
+        self.button_1 = QtWidgets.QPushButton("Button 1 ")
+        self.button_2_a = QtWidgets.QPushButton("Button to be added at place 0,0 in d3")
+        self.button_2_b = QtWidgets.QPushButton("button after without postions specified")
+        self.button_2_c = QtWidgets.QPushButton("button super late")
+        self.button_3 = QtWidgets.QPushButton("Button above Figure ")
+        self.bar = SpiralProgressBar()
 
-        self.d0 = self.dock.add_dock(name="dock_0")
-        self.fig0 = self.d0.add_widget("BECFigure")
-        data = np.random.rand(10, 2)
-        self.fig0.plot(data, label="2d Data")
-        self.fig0.image("eiger", vrange=(0, 100))
+        self.label_2 = QtWidgets.QLabel("label which is added separately")
+        self.label_3 = QtWidgets.QLabel("Label above figure")
 
-        self.d1 = self.dock.add_dock(name="dock_1", position="right")
-        self.fig1 = self.d1.add_widget("BECFigure")
-        self.fig1.plot(x_name="samx", y_name="bpm4i")
-        self.fig1.plot(x_name="samx", y_name="bpm3a")
-
-        self.d2 = self.dock.add_dock(name="dock_2", position="bottom")
-        self.fig2 = self.d2.add_widget("BECFigure", row=0, col=0)
-        self.fig2.plot(x_name="samx", y_name="bpm4i")
-        self.bar = self.d2.add_widget("SpiralProgressBar", row=0, col=1)
-        self.bar.set_diameter(200)
+        self.d1 = self.dock.add_dock(widget=self.button_1, position="left")
+        self.d1.addWidget(self.label_2)
+        self.d2 = self.dock.add_dock(widget=self.bar, position="right")
+        self.d3 = self.dock.add_dock(name="figure")
+        self.fig_dock3 = BECFigure()
+        self.fig_dock3.plot(x_name="samx", y_name="bpm4d")
+        self.d3.add_widget(self.label_3)
+        self.d3.add_widget(self.button_3)
+        self.d3.add_widget(self.fig_dock3)
 
         self.dock.save_state()
 
@@ -136,18 +148,16 @@ if __name__ == "__main__":  # pragma: no cover
 
     module_path = os.path.dirname(bec_widgets.__file__)
 
-    app = QApplication(sys.argv)
-    app.setApplicationName("Jupyter Console")
-    app.setApplicationDisplayName("Jupyter Console")
-    qdarktheme.setup_theme("auto")
-    icon = QIcon()
-    icon.addFile(os.path.join(module_path, "assets", "terminal_icon.png"), size=QSize(48, 48))
-    app.setWindowIcon(icon)
-
     bec_dispatcher = BECDispatcher()
     client = bec_dispatcher.client
     client.start()
 
+    app = QApplication(sys.argv)
+    app.setApplicationName("Jupyter Console")
+    app.setApplicationDisplayName("Jupyter Console")
+    icon = QIcon()
+    icon.addFile(os.path.join(module_path, "assets", "terminal_icon.png"), size=QSize(48, 48))
+    app.setWindowIcon(icon)
     win = JupyterConsoleWindow()
     win.show()
 

bec_widgets/examples/mca_readout/mca_plot.py

@@ -0,0 +1,159 @@
+# import simulation_progress as SP
+import numpy as np
+import pyqtgraph as pg
+from bec_lib import messages
+from bec_lib.endpoints import MessageEndpoints
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+
+class StreamApp(QWidget):
+    update_signal = pyqtSignal()
+    new_scan_id = pyqtSignal(str)
+
+    def __init__(self, device, sub_device):
+        super().__init__()
+        pg.setConfigOptions(background="w", foreground="k")
+        self.init_ui()
+
+        self.setWindowTitle("MCA readout")
+
+        self.data = None
+        self.scan_id = None
+        self.stream_consumer = None
+
+        self.device = device
+        self.sub_device = sub_device
+
+        self.start_device_consumer()
+
+        # self.start_device_consumer(self.device)  # for simulation
+
+        self.new_scan_id.connect(self.create_new_stream_consumer)
+        self.update_signal.connect(self.plot_new)
+
+    def init_ui(self):
+        # Create layout and add widgets
+        self.layout = QVBoxLayout()
+        self.setLayout(self.layout)
+
+        # Create plot
+        self.glw = pg.GraphicsLayoutWidget()
+        self.layout.addWidget(self.glw)
+
+        # Create Plot and add ImageItem
+        self.plot_item = pg.PlotItem()
+        self.plot_item.setAspectLocked(False)
+        self.imageItem = pg.ImageItem()
+        # self.plot_item1D = pg.PlotItem()
+        # self.plot_item.addItem(self.imageItem)
+        # self.plot_item.addItem(self.plot_item1D)
+
+        # Setting up histogram
+        # self.hist = pg.HistogramLUTItem()
+        # self.hist.setImageItem(self.imageItem)
+        # self.hist.gradient.loadPreset("magma")
+        # self.update_hist()
+
+        # Adding Items to Graphical Layout
+        self.glw.addItem(self.plot_item)
+        # self.glw.addItem(self.hist)
+
+    @pyqtSlot(str)
+    def create_new_stream_consumer(self, scan_id: str):
+        print(f"Creating new stream consumer for scan_id: {scan_id}")
+
+        self.connect_stream_consumer(scan_id, self.device)
+
+    def connect_stream_consumer(self, scan_id, device):
+        if self.stream_consumer is not None:
+            self.stream_consumer.shutdown()
+
+        self.stream_consumer = connector.stream_consumer(
+            topics=MessageEndpoints.device_async_readback(scan_id=scan_id, device=device),
+            cb=self._streamer_cb,
+            parent=self,
+        )
+
+        self.stream_consumer.start()
+
+    def start_device_consumer(self):
+        self.device_consumer = connector.consumer(
+            topics=MessageEndpoints.scan_status(), cb=self._device_cv, parent=self
+        )
+
+        self.device_consumer.start()
+
+    # def start_device_consumer(self, device): #for simulation
+    #     self.device_consumer = connector.consumer(
+    #         topics=MessageEndpoints.device_status(device), cb=self._device_cv, parent=self
+    #     )
+    #
+    #     self.device_consumer.start()
+
+    def plot_new(self):
+        print(f"Printing data from plot update: {self.data}")
+        self.plot_item.plot(self.data[0])
+        # self.imageItem.setImage(self.data, autoLevels=False)
+
+    @staticmethod
+    def _streamer_cb(msg, *, parent, **_kwargs) -> None:
+        msgMCS = msg.value
+        print(msgMCS)
+        row = msgMCS.content["signals"][parent.sub_device]
+        metadata = msgMCS.metadata
+
+        # Check if the current number of rows is odd
+        # if parent.data is not None and parent.data.shape[0] % 2 == 1:
+        #     row = np.flip(row)  # Flip the row
+        print(f"Printing data from callback update: {row}")
+        parent.data = np.array([row])
+        # if parent.data is None:
+        #     parent.data = np.array([row])
+        # else:
+        #     parent.data = np.vstack((parent.data, row))
+
+        parent.update_signal.emit()
+
+    @staticmethod
+    def _device_cv(msg, *, parent, **_kwargs) -> None:
+        print("Getting ScanID")
+
+        msgDEV = msg.value
+
+        current_scan_id = msgDEV.content["scan_id"]
+
+        if parent.scan_id is None:
+            parent.scan_id = current_scan_id
+            parent.new_scan_id.emit(current_scan_id)
+            print(f"New scan_id: {current_scan_id}")
+
+        if current_scan_id != parent.scan_id:
+            parent.scan_id = current_scan_id
+            # parent.data = None
+            # parent.imageItem.clear()
+            parent.new_scan_id.emit(current_scan_id)
+
+            print(f"New scan_id: {current_scan_id}")
+
+
+if __name__ == "__main__":
+    import argparse
+
+    from bec_lib.redis_connector import RedisConnector
+
+    parser = argparse.ArgumentParser(description="Stream App.")
+    parser.add_argument("--port", type=str, default="pc15543:6379", help="Port for RedisConnector")
+    parser.add_argument("--device", type=str, default="mcs", help="Device name")
+    parser.add_argument("--sub_device", type=str, default="mca4", help="Sub-device name")
+
+    args = parser.parse_args()
+
+    connector = RedisConnector(args.port)
+
+    app = QApplication([])
+    streamApp = StreamApp(device=args.device, sub_device=args.sub_device)
+
+    streamApp.show()
+    app.exec()

bec_widgets/examples/mca_readout/mca_sim.py

@@ -0,0 +1,28 @@
+import time
+
+from bec_lib import messages
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.redis_connector import RedisConnector
+
+connector = RedisConnector("localhost:6379")
+metadata = {}
+
+scan_id = "ScanID1"
+
+metadata.update(
+    {"scan_id": scan_id, "async_update": "append"}  # this will be different for each scan
+)
+for ii in range(20):
+    data = {"mca1": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "mca2": [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]}
+    msg = messages.DeviceMessage(signals=data, metadata=metadata).dumps()
+
+    connector.xadd(
+        topic=MessageEndpoints.device_async_readback(
+            scan_id=scan_id, device="mca"
+        ),  # scan_id will be different for each scan
+        msg={"data": msg},  # TODO should be msg_dict
+        expire=1800,
+    )
+
+    print(f"Sent {ii}")
+    time.sleep(0.5)

bec_widgets/examples/motor_movement/config_example.yaml

@@ -0,0 +1,17 @@
+selected_motors:
+  motor_x: "samx"
+  motor_y: "samy"
+
+plot_motors:
+  max_points: 1000
+  num_dim_points: 100
+  scatter_size: 5
+  precision: 3
+  mode_lock: False # "Individual" or "Start/Stop". False to unlock
+  extra_columns:
+    - sample name: "sample 1"
+    - step_x [mu]: 25
+    - step_y [mu]: 25
+    - exp_time [s]: 1
+    - start: 1
+    - tilt [deg]: 0

bec_widgets/examples/motor_movement/csax_bec_config.yaml

@@ -0,0 +1,10 @@
+redis:
+  host: pc15543
+  port: 6379
+mongodb:
+  host: localhost
+  port: 27017
+scibec:
+  host: http://localhost
+  port: 3030
+  beamline: MyBeamline

bec_widgets/examples/motor_movement/csaxs_config.yaml

@@ -0,0 +1,17 @@
+selected_motors:
+  motor_x: "samx"
+  motor_y: "samy"
+
+plot_motors:
+  max_points: 1000
+  num_dim_points: 100
+  scatter_size: 5
+  precision: 3
+  mode_lock: Start/Stop # "Individual" or "Start/Stop"
+  extra_columns:
+    - sample name: "sample 1"
+    - step_x [mu]: 25
+    - step_y [mu]: 25
+    - exp_time [s]: 1
+    - start: 1
+    - tilt [deg]: 0

bec_widgets/examples/stream_plot/line_plot.ui

@@ -0,0 +1,148 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>845</width>
+    <height>635</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Line Plot</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0">
+    <widget class="QSplitter" name="splitter">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <widget class="QSplitter" name="splitter_plot">
+      <property name="sizePolicy">
+       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+        <horstretch>1</horstretch>
+        <verstretch>1</verstretch>
+       </sizepolicy>
+      </property>
+      <property name="orientation">
+       <enum>Qt::Vertical</enum>
+      </property>
+      <widget class="QWidget" name="glw_plot_placeholder" native="true"/>
+      <widget class="QWidget" name="glw_image_placeholder" native="true"/>
+     </widget>
+     <widget class="QWidget" name="layoutWidget">
+      <layout class="QVBoxLayout" name="verticalLayout" stretch="1,1,1,15">
+       <item>
+        <widget class="QPushButton" name="pushButton_generate">
+         <property name="text">
+          <string>Generate 1D and 2D data without stream</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="groupBox">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="title">
+          <string>1st angle of azimutal segment (deg)</string>
+         </property>
+         <layout class="QHBoxLayout" name="horizontalLayout">
+          <item>
+           <widget class="QDoubleSpinBox" name="doubleSpinBox">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="maximum">
+             <double>360.000000000000000</double>
+            </property>
+            <property name="singleStep">
+             <double>0.250000000000000</double>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QComboBox" name="comboBox">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <item>
+             <property name="text">
+              <string>f1amp</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>f2amp</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>f2 phase</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <layout class="QHBoxLayout" name="horizontalLayout_2">
+         <item>
+          <widget class="QLabel" name="label">
+           <property name="text">
+            <string>Precision</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QSpinBox" name="spinBox_precision">
+           <property name="value">
+            <number>4</number>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <widget class="QTableWidget" name="cursor_table">
+         <property name="textElideMode">
+          <enum>Qt::ElideMiddle</enum>
+         </property>
+         <column>
+          <property name="text">
+           <string>Display</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>X</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>Y</string>
+          </property>
+         </column>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/examples/stream_plot/stream_plot.py

@@ -0,0 +1,342 @@
+import os
+import threading
+import time
+
+import numpy as np
+import pyqtgraph
+import pyqtgraph as pg
+from bec_lib import messages
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.redis_connector import RedisConnector
+from pyqtgraph import mkBrush, mkPen
+from pyqtgraph.Qt import QtCore, QtWidgets
+from qtpy.QtCore import Signal, Slot
+from qtpy.QtWidgets import QTableWidgetItem, QVBoxLayout
+
+from bec_widgets.utils import Colors, Crosshair, UILoader
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+
+class StreamPlot(QtWidgets.QWidget):
+    update_signal = Signal()
+    roi_signal = Signal(tuple)
+
+    def __init__(self, name="", y_value_list=["gauss_bpm"], client=None, parent=None) -> None:
+        """
+        Basic plot widget for displaying scan data.
+
+        Args:
+            name (str, optional): Name of the plot. Defaults to "".
+            y_value_list (list, optional): List of signals to be plotted. Defaults to ["gauss_bpm"].
+        """
+
+        # Client and device manager from BEC
+        self.client = BECDispatcher().client if client is None else client
+
+        super(StreamPlot, self).__init__()
+        # Set style for pyqtgraph plots
+        pg.setConfigOption("background", "w")
+        pg.setConfigOption("foreground", "k")
+        current_path = os.path.dirname(__file__)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "line_plot.ui"), self)
+
+        self._idle_time = 100
+        self.connector = RedisConnector(["localhost:6379"])
+
+        self.y_value_list = y_value_list
+        self.previous_y_value_list = None
+        self.plotter_data_x = []
+        self.plotter_data_y = []
+
+        self.plotter_scan_id = None
+
+        self._current_proj = None
+        self._current_metadata_ep = "px_stream/projection_{}/metadata"
+
+        self.proxy_update = pg.SignalProxy(self.update_signal, rateLimit=25, slot=self.update)
+
+        self._data_retriever_thread_exit_event = threading.Event()
+        self.data_retriever = threading.Thread(
+            target=self.on_projection, args=(self._data_retriever_thread_exit_event,), daemon=True
+        )
+        self.data_retriever.start()
+
+        ##########################
+        # UI
+        ##########################
+        self.init_ui()
+        self.init_curves()
+        self.hook_crosshair()
+
+    def close(self):
+        super().close()
+        self._data_retriever_thread_exit_event.set()
+        self.data_retriever.join()
+
+    def init_ui(self):
+        """Setup all ui elements"""
+        ##########################
+        # 1D Plot
+        ##########################
+
+        # LabelItem for ROI
+        self.label_plot = pg.LabelItem(justify="center")
+        self.glw_plot_layout = QVBoxLayout(self.ui.glw_plot_placeholder)
+        self.glw_plot = pg.GraphicsLayoutWidget()
+        self.glw_plot_layout.addWidget(self.glw_plot)
+        self.glw_plot.addItem(self.label_plot)
+        self.label_plot.setText("ROI region")
+
+        # ROI selector - so far from [-1,1] #TODO update to scale with xrange
+        self.roi_selector = pg.LinearRegionItem([-1, 1])
+
+        self.glw_plot.nextRow()  # TODO update of cursor
+        self.label_plot_moved = pg.LabelItem(justify="center")
+        self.glw_plot.addItem(self.label_plot_moved)
+        self.label_plot_moved.setText("Actual coordinates (X, Y)")
+
+        # Label for coordinates clicked
+        self.glw_plot.nextRow()
+        self.label_plot_clicked = pg.LabelItem(justify="center")
+        self.glw_plot.addItem(self.label_plot_clicked)
+        self.label_plot_clicked.setText("Clicked coordinates (X, Y)")
+
+        # 1D PlotItem
+        self.glw_plot.nextRow()
+        self.plot = pg.PlotItem()
+        self.plot.setLogMode(True, True)
+        self.glw_plot.addItem(self.plot)
+        self.plot.addLegend()
+
+        ##########################
+        # 2D Plot
+        ##########################
+
+        # Label for coordinates moved
+        self.label_image_moved = pg.LabelItem(justify="center")
+        self.glw_image_layout = QVBoxLayout(self.ui.glw_image_placeholder)
+        self.glw_image = pg.GraphicsLayoutWidget()
+        self.glw_plot_layout.addWidget(self.glw_image)
+        self.glw_image.addItem(self.label_image_moved)
+        self.label_image_moved.setText("Actual coordinates (X, Y)")
+
+        # Label for coordinates clicked
+        self.glw_image.nextRow()
+        self.label_image_clicked = pg.LabelItem(justify="center")
+        self.glw_image.addItem(self.label_image_clicked)
+        self.label_image_clicked.setText("Clicked coordinates (X, Y)")
+
+        # TODO try to lock aspect ratio with view
+
+        # # Create a window
+        # win = pg.GraphicsLayoutWidget()
+        # win.show()
+        #
+        # # Create a ViewBox
+        # view = win.addViewBox()
+        #
+        # # Lock the aspect ratio
+        # view.setAspectLocked(True)
+
+        # # Create an ImageItem
+        # image_item = pg.ImageItem(np.random.random((100, 100)))
+        #
+        # # Add the ImageItem to the ViewBox
+        # view.addItem(image_item)
+
+        # 2D ImageItem
+        self.glw_image.nextRow()
+        self.plot_image = pg.PlotItem()
+        self.glw_image.addItem(self.plot_image)
+
+    def init_curves(self):
+        # init of 1D plot
+        self.plot.clear()
+
+        self.curves = []
+        self.pens = []
+        self.brushs = []
+
+        self.color_list = Colors.golden_angle_color(colormap="CET-R2", num=len(self.y_value_list))
+
+        for ii, y_value in enumerate(self.y_value_list):
+            pen = mkPen(color=self.color_list[ii], width=2, style=QtCore.Qt.DashLine)
+            brush = mkBrush(color=self.color_list[ii])
+            curve = pg.PlotDataItem(symbolBrush=brush, pen=pen, skipFiniteCheck=True, name=y_value)
+            self.plot.addItem(curve)
+            self.curves.append(curve)
+            self.pens.append(pen)
+            self.brushs.append(brush)
+
+        # check if roi selector is in the plot
+        if self.roi_selector not in self.plot.items:
+            self.plot.addItem(self.roi_selector)
+
+        # init of 2D plot
+        self.plot_image.clear()
+
+        self.img = pg.ImageItem()
+        self.plot_image.addItem(self.img)
+
+        # hooking signals
+        self.hook_crosshair()
+        self.init_table()
+
+    def splitter_sizes(self): ...
+
+    def hook_crosshair(self):
+        self.crosshair_1d = Crosshair(self.plot, precision=4)
+
+        self.crosshair_1d.coordinatesChanged1D.connect(
+            lambda x, y: self.label_plot_moved.setText(f"Moved : ({x}, {y})")
+        )
+        self.crosshair_1d.coordinatesClicked1D.connect(
+            lambda x, y: self.label_plot_clicked.setText(f"Moved : ({x}, {y})")
+        )
+
+        self.crosshair_1d.coordinatesChanged1D.connect(
+            lambda x, y: self.update_table(table_widget=self.cursor_table, x=x, y_values=y)
+        )
+
+        self.crosshair_2D = Crosshair(self.plot_image)
+
+        self.crosshair_2D.coordinatesChanged2D.connect(
+            lambda x, y: self.label_image_moved.setText(f"Moved : ({x}, {y})")
+        )
+        self.crosshair_2D.coordinatesClicked2D.connect(
+            lambda x, y: self.label_image_clicked.setText(f"Moved : ({x}, {y})")
+        )
+
+        # ROI
+        self.roi_selector.sigRegionChangeFinished.connect(self.get_roi_region)
+
+    def get_roi_region(self):
+        """For testing purpose now, get roi region and print it to self.label as tuple"""
+        region = self.roi_selector.getRegion()
+        self.label_plot.setText(f"x = {(10 ** region[0]):.4f}, y ={(10 ** region[1]):.4f}")
+        return_dict = {
+            "horiz_roi": [
+                np.where(self.plotter_data_x[0] > 10 ** region[0])[0][0],
+                np.where(self.plotter_data_x[0] < 10 ** region[1])[0][-1],
+            ]
+        }
+        msg = messages.DeviceMessage(signals=return_dict).dumps()
+        self.connector.set_and_publish("px_stream/gui_event", msg=msg)
+        self.roi_signal.emit(region)
+
+    def init_table(self):
+        # Init number of rows in table according to n of devices
+        self.ui.cursor_table.setRowCount(len(self.y_value_list))
+        # self.table.setHorizontalHeaderLabels(["(X, Y) - Moved", "(X, Y) - Clicked"]) #TODO can be dynamic
+        self.ui.cursor_table.setVerticalHeaderLabels(self.y_value_list)
+        self.ui.cursor_table.resizeColumnsToContents()
+
+    def update_table(self, table_widget, x, y_values):
+        for i, y in enumerate(y_values):
+            table_widget.setItem(i, 1, QTableWidgetItem(str(x)))
+            table_widget.setItem(i, 2, QTableWidgetItem(str(y)))
+            table_widget.resizeColumnsToContents()
+
+    def update(self):
+        """Update the plot with the new data."""
+
+        # check if QTable was initialised and if list of devices was changed
+        # if self.y_value_list != self.previous_y_value_list:
+        #     self.setup_cursor_table()
+        #     self.previous_y_value_list = self.y_value_list.copy() if self.y_value_list else None
+
+        self.curves[0].setData(self.plotter_data_x[0], self.plotter_data_y[0])
+
+    @staticmethod
+    def flip_even_rows(arr):
+        arr_copy = np.copy(arr)  # Create a writable copy
+        arr_copy[1::2, :] = arr_copy[1::2, ::-1]
+        return arr_copy
+
+    @staticmethod
+    def remove_curve_by_name(plot: pyqtgraph.PlotItem, name: str) -> None:
+        # def remove_curve_by_name(plot: pyqtgraph.PlotItem, checkbox: QtWidgets.QCheckBox, name: str) -> None:
+        """Removes a curve from the given plot by the specified name.
+
+        Args:
+            plot (pyqtgraph.PlotItem): The plot from which to remove the curve.
+            name (str): The name of the curve to remove.
+        """
+        # if checkbox.isChecked():
+        for item in plot.items:
+            if isinstance(item, pg.PlotDataItem) and getattr(item, "opts", {}).get("name") == name:
+                plot.removeItem(item)
+                return
+
+        # else:
+        #     return
+
+    def on_projection(self, exit_event):
+        while not exit_event.is_set():
+            if self._current_proj is None:
+                time.sleep(0.1)
+                continue
+            endpoint = f"px_stream/projection_{self._current_proj}/data"
+            msgs = self.client.connector.lrange(topic=endpoint, start=-1, end=-1)
+            data = msgs
+            if not data:
+                continue
+            with np.errstate(divide="ignore", invalid="ignore"):
+                self.plotter_data_y = [
+                    np.sum(
+                        np.sum(data[-1].content["signals"]["data"] * self._current_norm, axis=1)
+                        / np.sum(self._current_norm, axis=0),
+                        axis=0,
+                    ).squeeze()
+                ]
+
+            self.update_signal.emit()
+
+    @Slot(dict, dict)
+    def on_dap_update(self, data: dict, metadata: dict):
+        flipped_data = self.flip_even_rows(data["data"]["z"])
+
+        self.img.setImage(flipped_data)
+
+    @Slot(dict, dict)
+    def new_proj(self, content: dict, _metadata: dict):
+        proj_nr = content["signals"]["proj_nr"]
+        endpoint = f"px_stream/projection_{proj_nr}/metadata"
+        msg_raw = self.client.connector.get(topic=endpoint)
+        msg = messages.DeviceMessage.loads(msg_raw)
+        self._current_q = msg.content["signals"]["q"]
+        self._current_norm = msg.content["signals"]["norm_sum"]
+        self._current_metadata = msg.content["signals"]["metadata"]
+
+        self.plotter_data_x = [self._current_q]
+        self._current_proj = proj_nr
+
+
+if __name__ == "__main__":
+    import argparse
+
+    # from bec_widgets import ctrl_c  # TODO uncomment when ctrl_c is ready to be compatible with qtpy
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--signals", help="specify recorded signals", nargs="+", default=["gauss_bpm"]
+    )
+    # default = ["gauss_bpm", "bpm4i", "bpm5i", "bpm6i", "xert"],
+    value = parser.parse_args()
+    print(f"Plotting signals for: {', '.join(value.signals)}")
+
+    # Client from dispatcher
+    bec_dispatcher = BECDispatcher()
+    client = bec_dispatcher.client
+
+    app = QtWidgets.QApplication([])
+    # ctrl_c.setup(app) # TODO uncomment when ctrl_c is ready to be compatible with qtpy
+    plot = StreamPlot(y_value_list=value.signals, client=client)
+
+    bec_dispatcher.connect_slot(plot.new_proj, "px_stream/proj_nr")
+    bec_dispatcher.connect_slot(
+        plot.on_dap_update, MessageEndpoints.processed_data("px_dap_worker")
+    )
+    plot.show()
+    # client.callbacks.register("scan_segment", plot, sync=False)
+    app.exec()

bec_widgets/plugin/main.py

@@ -0,0 +1,17 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+"""PySide6 port of the Qt Designer taskmenuextension example from Qt v6.x"""
+
+import sys
+
+from bec_ipython_client.main import BECIPythonClient
+from PySide6.QtWidgets import QApplication
+from tictactoe import TicTacToe
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    window = TicTacToe()
+    window.state = "-X-XO----"
+    window.show()
+    sys.exit(app.exec())

bec_widgets/plugin/plugin_launch.py

@@ -0,0 +1,24 @@
+import os
+import subprocess
+import sys
+
+from PySide6.scripts.pyside_tool import designer
+
+import bec_widgets
+
+
+def main():
+    # os.environ["PYSIDE_DESIGNER_PLUGINS"] = os.path.join(
+    #     "/Users/janwyzula/PSI/bec_widgets/bec_widgets/plugin"
+    # )
+    os.environ["PYSIDE_DESIGNER_PLUGINS"] = os.path.join(
+        os.path.dirname(bec_widgets.__file__), "widgets/motor_control/selection"
+    )
+    # os.environ["PYTHONFRAMEWORKPREFIX"] = os.path.join(
+    #     os.path.dirname(bec_widgets.__file__), "widgets/motor_control/selection"
+    # )
+    designer()
+
+
+if __name__ == "__main__":
+    main()

bec_widgets/plugin/registertictactoe.py

@@ -0,0 +1,12 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+from tictactoe import TicTacToe
+from tictactoeplugin import TicTacToePlugin
+
+# Set PYSIDE_DESIGNER_PLUGINS to point to this directory and load the plugin
+
+
+if __name__ == "__main__":
+    QPyDesignerCustomWidgetCollection.addCustomWidget(TicTacToePlugin())

bec_widgets/plugin/taskmenuextension.pyproject

@@ -0,0 +1,4 @@
+{
+    "files": ["tictactoe.py", "main.py", "registertictactoe.py", "tictactoeplugin.py",
+    "tictactoetaskmenu.py"]
+}

bec_widgets/plugin/tictactoe.py

@@ -0,0 +1,135 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from PySide6.QtCore import Property, QPoint, QRect, QSize, Qt, Slot
+from PySide6.QtGui import QPainter, QPen
+from PySide6.QtWidgets import QWidget
+
+EMPTY = "-"
+CROSS = "X"
+NOUGHT = "O"
+DEFAULT_STATE = "---------"
+
+
+class TicTacToe(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._state = DEFAULT_STATE
+        self._turn_number = 0
+
+    def minimumSizeHint(self):
+        return QSize(200, 200)
+
+    def sizeHint(self):
+        return QSize(200, 200)
+
+    def setState(self, new_state):
+        self._turn_number = 0
+        self._state = DEFAULT_STATE
+        for position in range(min(9, len(new_state))):
+            mark = new_state[position]
+            if mark == CROSS or mark == NOUGHT:
+                self._turn_number += 1
+                self._change_state_at(position, mark)
+            position += 1
+        self.update()
+
+    def state(self):
+        return self._state
+
+    @Slot()
+    def clear_board(self):
+        self._state = DEFAULT_STATE
+        self._turn_number = 0
+        self.update()
+
+    def _change_state_at(self, pos, new_state):
+        self._state = self._state[:pos] + new_state + self._state[pos + 1 :]
+
+    def mousePressEvent(self, event):
+        if self._turn_number == 9:
+            self.clear_board()
+            return
+        for position in range(9):
+            cell = self._cell_rect(position)
+            if cell.contains(event.position().toPoint()):
+                if self._state[position] == EMPTY:
+                    new_state = CROSS if self._turn_number % 2 == 0 else NOUGHT
+                    self._change_state_at(position, new_state)
+                    self._turn_number += 1
+                    self.update()
+
+    def paintEvent(self, event):
+        with QPainter(self) as painter:
+            painter.setRenderHint(QPainter.Antialiasing)
+
+            painter.setPen(QPen(Qt.darkGreen, 1))
+            painter.drawLine(self._cell_width(), 0, self._cell_width(), self.height())
+            painter.drawLine(2 * self._cell_width(), 0, 2 * self._cell_width(), self.height())
+            painter.drawLine(0, self._cell_height(), self.width(), self._cell_height())
+            painter.drawLine(0, 2 * self._cell_height(), self.width(), 2 * self._cell_height())
+
+            painter.setPen(QPen(Qt.darkBlue, 2))
+
+            for position in range(9):
+                cell = self._cell_rect(position)
+                if self._state[position] == CROSS:
+                    painter.drawLine(cell.topLeft(), cell.bottomRight())
+                    painter.drawLine(cell.topRight(), cell.bottomLeft())
+                elif self._state[position] == NOUGHT:
+                    painter.drawEllipse(cell)
+
+            painter.setPen(QPen(Qt.yellow, 3))
+
+            for position in range(0, 8, 3):
+                if (
+                    self._state[position] != EMPTY
+                    and self._state[position + 1] == self._state[position]
+                    and self._state[position + 2] == self._state[position]
+                ):
+                    y = self._cell_rect(position).center().y()
+                    painter.drawLine(0, y, self.width(), y)
+                    self._turn_number = 9
+
+            for position in range(3):
+                if (
+                    self._state[position] != EMPTY
+                    and self._state[position + 3] == self._state[position]
+                    and self._state[position + 6] == self._state[position]
+                ):
+                    x = self._cell_rect(position).center().x()
+                    painter.drawLine(x, 0, x, self.height())
+                    self._turn_number = 9
+
+            if (
+                self._state[0] != EMPTY
+                and self._state[4] == self._state[0]
+                and self._state[8] == self._state[0]
+            ):
+                painter.drawLine(0, 0, self.width(), self.height())
+                self._turn_number = 9
+
+            if (
+                self._state[2] != EMPTY
+                and self._state[4] == self._state[2]
+                and self._state[6] == self._state[2]
+            ):
+                painter.drawLine(0, self.height(), self.width(), 0)
+                self._turn_number = 9
+
+    def _cell_rect(self, position):
+        h_margin = self.width() / 30
+        v_margin = self.height() / 30
+        row = int(position / 3)
+        column = position - 3 * row
+        pos = QPoint(column * self._cell_width() + h_margin, row * self._cell_height() + v_margin)
+        size = QSize(self._cell_width() - 2 * h_margin, self._cell_height() - 2 * v_margin)
+        return QRect(pos, size)
+
+    def _cell_width(self):
+        return self.width() / 3
+
+    def _cell_height(self):
+        return self.height() / 3
+
+    state = Property(str, state, setState)

bec_widgets/plugin/tictactoeplugin.py

@@ -0,0 +1,68 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from PySide6.QtDesigner import QDesignerCustomWidgetInterface
+from PySide6.QtGui import QIcon
+from tictactoe import TicTacToe
+from tictactoetaskmenu import TicTacToeTaskMenuFactory
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='TicTacToe' name='ticTacToe'>
+        <property name='geometry'>
+            <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>200</width>
+                <height>200</height>
+            </rect>
+        </property>
+        <property name='state'>
+            <string>-X-XO----</string>
+        </property>
+    </widget>
+</ui>
+"""
+
+
+class TicTacToePlugin(QDesignerCustomWidgetInterface):
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = TicTacToe(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "tictactoe"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+        manager = form_editor.extensionManager()
+        iid = TicTacToeTaskMenuFactory.task_menu_iid()
+        manager.registerExtensions(TicTacToeTaskMenuFactory(manager), iid)
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "TicTacToe"
+
+    def toolTip(self):
+        return "Tic Tac Toe Example, demonstrating class QDesignerTaskMenuExtension (Python)"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/plugin/tictactoetaskmenu.py

@@ -0,0 +1,67 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from PySide6.QtCore import Slot
+from PySide6.QtDesigner import QExtensionFactory, QPyDesignerTaskMenuExtension
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import QDialog, QDialogButtonBox, QVBoxLayout
+from tictactoe import TicTacToe
+
+
+class TicTacToeDialog(QDialog):
+    def __init__(self, parent):
+        super().__init__(parent)
+        layout = QVBoxLayout(self)
+        self._ticTacToe = TicTacToe(self)
+        layout.addWidget(self._ticTacToe)
+        button_box = QDialogButtonBox(
+            QDialogButtonBox.Ok | QDialogButtonBox.Cancel | QDialogButtonBox.Reset
+        )
+        button_box.accepted.connect(self.accept)
+        button_box.rejected.connect(self.reject)
+        reset_button = button_box.button(QDialogButtonBox.Reset)
+        reset_button.clicked.connect(self._ticTacToe.clear_board)
+        layout.addWidget(button_box)
+
+    def set_state(self, new_state):
+        self._ticTacToe.setState(new_state)
+
+    def state(self):
+        return self._ticTacToe.state
+
+
+class TicTacToeTaskMenu(QPyDesignerTaskMenuExtension):
+    def __init__(self, ticTacToe, parent):
+        super().__init__(parent)
+        self._ticTacToe = ticTacToe
+        self._edit_state_action = QAction("Edit State...", None)
+        self._edit_state_action.triggered.connect(self._edit_state)
+
+    def taskActions(self):
+        return [self._edit_state_action]
+
+    def preferredEditAction(self):
+        return self._edit_state_action
+
+    @Slot()
+    def _edit_state(self):
+        dialog = TicTacToeDialog(self._ticTacToe)
+        dialog.set_state(self._ticTacToe.state)
+        if dialog.exec() == QDialog.Accepted:
+            self._ticTacToe.state = dialog.state()
+
+
+class TicTacToeTaskMenuFactory(QExtensionFactory):
+    def __init__(self, extension_manager):
+        super().__init__(extension_manager)
+
+    @staticmethod
+    def task_menu_iid():
+        return "org.qt-project.Qt.Designer.TaskMenu"
+
+    def createExtension(self, object, iid, parent):
+        if iid != TicTacToeTaskMenuFactory.task_menu_iid():
+            return None
+        if object.__class__.__name__ != "TicTacToe":
+            return None
+        return TicTacToeTaskMenu(object, parent)

bec_widgets/utils/__init__.py

@@ -1,5 +1,3 @@
-from qtpy.QtWebEngineWidgets import QWebEngineView
-
 from .bec_connector import BECConnector, ConnectionConfig
 from .bec_dispatcher import BECDispatcher
 from .bec_table import BECTable

bec_widgets/utils/bec_connector.py

@@ -20,10 +20,8 @@ class ConnectionConfig(BaseModel):
     gui_id: Optional[str] = Field(
         default=None, validate_default=True, description="The GUI ID of the widget."
     )
-    model_config: dict = {"validate_assignment": True}
 
     @field_validator("gui_id")
-    @classmethod
     def generate_gui_id(cls, v, values):
         """Generate a GUI ID if none is provided."""
         if v is None:

bec_widgets/utils/bec_dispatcher.py

@@ -9,7 +9,7 @@ import redis
 from bec_lib.client import BECClient
 from bec_lib.redis_connector import MessageObject, RedisConnector
 from bec_lib.service_config import ServiceConfig
-from qtpy.QtCore import PYQT5, PYQT6, PYSIDE2, PYSIDE6, QCoreApplication, QObject
+from qtpy.QtCore import QObject
 from qtpy.QtCore import Signal as pyqtSignal
 
 if TYPE_CHECKING:
@@ -71,7 +71,6 @@ class BECDispatcher:
 
     _instance = None
     _initialized = False
-    qapp = None
 
     def __new__(cls, client=None, config: str = None, *args, **kwargs):
         if cls._instance is None:
@@ -83,9 +82,6 @@ class BECDispatcher:
         if self._initialized:
             return
 
-        if not QCoreApplication.instance():
-            BECDispatcher.qapp = QCoreApplication([])
-
         self._slots = collections.defaultdict(set)
         self.client = client
 
@@ -116,16 +112,6 @@ class BECDispatcher:
         cls._instance = None
         cls._initialized = False
 
-        if not cls.qapp:
-            return
-
-        # shutdown QCoreApp if it exists
-        if PYQT5 or PYQT6:
-            cls.qapp.exit()
-        elif PYSIDE2 or PYSIDE6:
-            cls.qapp.shutdown()
-        cls.qapp = None
-
     def connect_slot(
         self, slot: Callable, topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]]
     ) -> None:

bec_widgets/utils/colors.py

@@ -1,14 +1,11 @@
-import re
 from typing import Literal
 
 import numpy as np
 import pyqtgraph as pg
-from pydantic_core import PydanticCustomError
 from qtpy.QtGui import QColor
 
 
 class Colors:
-
     @staticmethod
     def golden_ratio(num: int) -> list:
         """Calculate the golden ratio for a given number of angles.
@@ -66,211 +63,3 @@ class Colors:
             else:
                 raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
         return colors
-
-    @staticmethod
-    def validate_color(color: tuple | str) -> tuple | str:
-        """
-        Validate the color input if it is HEX or RGBA compatible. Can be used in any pydantic model as a field validator.
-
-        Args:
-            color(tuple|str): The color to be validated. Can be a tuple of RGBA values or a HEX string.
-
-        Returns:
-            tuple|str: The validated color.
-        """
-        CSS_COLOR_NAMES = {
-            "aliceblue",
-            "antiquewhite",
-            "aqua",
-            "aquamarine",
-            "azure",
-            "beige",
-            "bisque",
-            "black",
-            "blanchedalmond",
-            "blue",
-            "blueviolet",
-            "brown",
-            "burlywood",
-            "cadetblue",
-            "chartreuse",
-            "chocolate",
-            "coral",
-            "cornflowerblue",
-            "cornsilk",
-            "crimson",
-            "cyan",
-            "darkblue",
-            "darkcyan",
-            "darkgoldenrod",
-            "darkgray",
-            "darkgreen",
-            "darkgrey",
-            "darkkhaki",
-            "darkmagenta",
-            "darkolivegreen",
-            "darkorange",
-            "darkorchid",
-            "darkred",
-            "darksalmon",
-            "darkseagreen",
-            "darkslateblue",
-            "darkslategray",
-            "darkslategrey",
-            "darkturquoise",
-            "darkviolet",
-            "deeppink",
-            "deepskyblue",
-            "dimgray",
-            "dimgrey",
-            "dodgerblue",
-            "firebrick",
-            "floralwhite",
-            "forestgreen",
-            "fuchsia",
-            "gainsboro",
-            "ghostwhite",
-            "gold",
-            "goldenrod",
-            "gray",
-            "green",
-            "greenyellow",
-            "grey",
-            "honeydew",
-            "hotpink",
-            "indianred",
-            "indigo",
-            "ivory",
-            "khaki",
-            "lavender",
-            "lavenderblush",
-            "lawngreen",
-            "lemonchiffon",
-            "lightblue",
-            "lightcoral",
-            "lightcyan",
-            "lightgoldenrodyellow",
-            "lightgray",
-            "lightgreen",
-            "lightgrey",
-            "lightpink",
-            "lightsalmon",
-            "lightseagreen",
-            "lightskyblue",
-            "lightslategray",
-            "lightslategrey",
-            "lightsteelblue",
-            "lightyellow",
-            "lime",
-            "limegreen",
-            "linen",
-            "magenta",
-            "maroon",
-            "mediumaquamarine",
-            "mediumblue",
-            "mediumorchid",
-            "mediumpurple",
-            "mediumseagreen",
-            "mediumslateblue",
-            "mediumspringgreen",
-            "mediumturquoise",
-            "mediumvioletred",
-            "midnightblue",
-            "mintcream",
-            "mistyrose",
-            "moccasin",
-            "navajowhite",
-            "navy",
-            "oldlace",
-            "olive",
-            "olivedrab",
-            "orange",
-            "orangered",
-            "orchid",
-            "palegoldenrod",
-            "palegreen",
-            "paleturquoise",
-            "palevioletred",
-            "papayawhip",
-            "peachpuff",
-            "peru",
-            "pink",
-            "plum",
-            "powderblue",
-            "purple",
-            "red",
-            "rosybrown",
-            "royalblue",
-            "saddlebrown",
-            "salmon",
-            "sandybrown",
-            "seagreen",
-            "seashell",
-            "sienna",
-            "silver",
-            "skyblue",
-            "slateblue",
-            "slategray",
-            "slategrey",
-            "snow",
-            "springgreen",
-            "steelblue",
-            "tan",
-            "teal",
-            "thistle",
-            "tomato",
-            "turquoise",
-            "violet",
-            "wheat",
-            "white",
-            "whitesmoke",
-            "yellow",
-            "yellowgreen",
-        }
-        if isinstance(color, str):
-            hex_pattern = re.compile(r"^#(?:[0-9a-fA-F]{3}){1,2}$")
-            if hex_pattern.match(color):
-                return color
-            elif color.lower() in CSS_COLOR_NAMES:
-                return color
-            else:
-                raise PydanticCustomError(
-                    "unsupported color",
-                    "The color must be a valid HEX string or CSS Color.",
-                    {"wrong_value": color},
-                )
-        elif isinstance(color, tuple):
-            if len(color) != 4:
-                raise PydanticCustomError(
-                    "unsupported color",
-                    "The color must be a tuple of 4 elements (R, G, B, A).",
-                    {"wrong_value": color},
-                )
-            for value in color:
-                if not 0 <= value <= 255:
-                    raise PydanticCustomError(
-                        "unsupported color",
-                        f"The color values must be between 0 and 255 in RGBA format (R,G,B,A)",
-                        {"wrong_value": color},
-                    )
-            return color
-
-    @staticmethod
-    def validate_color_map(color_map: str) -> str:
-        """
-        Validate the colormap input if it is supported by pyqtgraph. Can be used in any pydantic model as a field validator. If validation fails it prints all available colormaps from pyqtgraph instance.
-
-        Args:
-            color_map(str): The colormap to be validated.
-
-        Returns:
-            str: The validated colormap.
-        """
-        available_colormaps = pg.colormap.listMaps()
-        if color_map not in available_colormaps:
-            raise PydanticCustomError(
-                "unsupported colormap",
-                f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose on the following: {available_colormaps}.",
-                {"wrong_value": color_map},
-            )
-        return color_map

bec_widgets/utils/crosshair.py

@@ -174,11 +174,11 @@ class Crosshair(QObject):
                 if isinstance(item, pg.PlotDataItem):
                     if x is None or all(v is None for v in y_values):
                         return
-                    coordinate_to_emit = (
+                    coordinance_to_emit = (
                         round(x, self.precision),
                         [round(y_val, self.precision) for y_val in y_values],
                     )
-                    self.coordinatesChanged1D.emit(coordinate_to_emit)
+                    self.coordinatesChanged1D.emit(coordinance_to_emit)
                     for i, y_val in enumerate(y_values):
                         self.marker_moved_1d[i].setData(
                             [x if not self.is_log_x else np.log10(x)],
@@ -187,8 +187,8 @@ class Crosshair(QObject):
                 elif isinstance(item, pg.ImageItem):
                     if x is None or y_values is None:
                         return
-                    coordinate_to_emit = (x, y_values)
-                    self.coordinatesChanged2D.emit(coordinate_to_emit)
+                    coordinance_to_emit = (x, y_values)
+                    self.coordinatesChanged2D.emit(coordinance_to_emit)
 
     def mouse_clicked(self, event):
         """Handles the mouse clicked event, updating the crosshair position and emitting signals.

bec_widgets/utils/plugin_utils.py

@@ -1,10 +1,6 @@
-import importlib
 import inspect
-import os
-from typing import Literal
 
 from bec_lib.plugin_helper import _get_available_plugins
-from qtpy.QtWidgets import QGraphicsWidget, QWidget
 
 from bec_widgets.utils import BECConnector
 
@@ -42,47 +38,3 @@ def get_plugin_widgets() -> dict[str, BECConnector]:
 
 def _filter_plugins(obj):
     return inspect.isclass(obj) and issubclass(obj, BECConnector)
-
-
-def get_rpc_classes(
-    repo_name: str,
-) -> dict[Literal["connector_classes", "top_level_classes"], list[type]]:
-    """
-    Get all RPC-enabled classes in the specified repository.
-
-    Args:
-        repo_name(str): The name of the repository.
-
-    Returns:
-        dict: A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
-    """
-    connector_classes = []
-    top_level_classes = []
-    anchor_module = importlib.import_module(f"{repo_name}.widgets")
-    directory = os.path.dirname(anchor_module.__file__)
-    for root, _, files in sorted(os.walk(directory)):
-        for file in files:
-            if not file.endswith(".py") or file.startswith("__"):
-                continue
-
-            path = os.path.join(root, file)
-            subs = os.path.dirname(os.path.relpath(path, directory)).split("/")
-            if len(subs) == 1 and not subs[0]:
-                module_name = file.split(".")[0]
-            else:
-                module_name = ".".join(subs + [file.split(".")[0]])
-
-            module = importlib.import_module(f"{repo_name}.widgets.{module_name}")
-
-            for name in dir(module):
-                obj = getattr(module, name)
-                if not hasattr(obj, "__module__") or obj.__module__ != module.__name__:
-                    continue
-                if isinstance(obj, type) and issubclass(obj, BECConnector):
-                    connector_classes.append(obj)
-                    if len(subs) == 1 and (
-                        issubclass(obj, QWidget) or issubclass(obj, QGraphicsWidget)
-                    ):
-                        top_level_classes.append(obj)
-
-    return {"connector_classes": connector_classes, "top_level_classes": top_level_classes}

bec_widgets/widgets/__init__.py

@@ -1,5 +1,4 @@
-# from .buttons import StopButton
-# from .dock import BECDock, BECDockArea
-# from .figure import BECFigure, FigureConfig
-# from .scan_control import ScanControl
-# from .spiral_progress_bar import SpiralProgressBar
+from .dock import BECDock, BECDockArea
+from .figure import BECFigure, FigureConfig
+from .scan_control import ScanControl
+from .spiral_progress_bar import SpiralProgressBar

bec_widgets/widgets/bec_status_box/bec_status_box.py

@@ -1,352 +0,0 @@
-"""This module contains the BECStatusBox widget, which displays the status of different BEC services in a collapsible tree widget.
-The widget automatically updates the status of all running BEC services, and displays their status.
-"""
-
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-
-import qdarktheme
-from bec_lib.utils.import_utils import lazy_import_from
-from pydantic import BaseModel, Field, field_validator
-from qtpy.QtCore import QObject, QTimer, Signal, Slot
-from qtpy.QtWidgets import QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget
-
-from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
-from bec_widgets.widgets.bec_status_box.status_item import StatusItem
-
-if TYPE_CHECKING:
-    from bec_lib.client import BECClient
-
-# TODO : Put normal imports back when Pydantic gets faster
-BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
-
-
-class BECStatusBoxConfig(ConnectionConfig):
-    pass
-
-
-class BECServiceInfoContainer(BaseModel):
-    """Container to store information about the BEC services."""
-
-    service_name: str
-    status: BECStatus | str = Field(
-        default="NOTCONNECTED",
-        description="The status of the service. Can be any of the BECStatus names, or NOTCONNECTED.",
-    )
-    info: dict
-    metrics: dict | None
-    model_config: dict = {"validate_assignment": True}
-
-    @field_validator("status")
-    @classmethod
-    def validate_status(cls, v):
-        """Validate input for status. Accept BECStatus and NOTCONNECTED.
-
-        Args:
-            v (BECStatus | str): The input value.
-
-        Returns:
-            str: The validated status.
-        """
-        if v in list(BECStatus.__members__.values()):
-            return v.name
-        if v in list(BECStatus.__members__.keys()) or v == "NOTCONNECTED":
-            return v
-        raise ValueError(
-            f"Status must be one of {BECStatus.__members__.values()} or 'NOTCONNECTED'. Input {v}"
-        )
-
-
-class BECServiceStatusMixin(QObject):
-    """A mixin class to update the service status, and metrics.
-    It emits a signal 'services_update' when the service status is updated.
-
-    Args:
-        client (BECClient): The client object to connect to the BEC server.
-    """
-
-    services_update = Signal(dict, dict)
-
-    def __init__(self, client: BECClient):
-        super().__init__()
-        self.client = client
-        self._service_update_timer = QTimer()
-        self._service_update_timer.timeout.connect(self._get_service_status)
-        self._service_update_timer.start(1000)
-
-    def _get_service_status(self):
-        """Pull latest service and metrics updates from REDIS for all services, and emit both via 'services_update' signal."""
-        # pylint: disable=protected-access
-        self.client._update_existing_services()
-        self.services_update.emit(self.client._services_info, self.client._services_metric)
-
-
-class BECStatusBox(BECConnector, QTreeWidget):
-    """A widget to display the status of different BEC services.
-    This widget automatically updates the status of all running BEC services, and displays their status.
-    Information about the individual services is collapsible, and double clicking on
-    the individual service will display the metrics about the service.
-
-    Args:
-        parent Optional : The parent widget for the BECStatusBox. Defaults to None.
-        service_name Optional(str): The name of the top service label. Defaults to "BEC Server".
-        client Optional(BECClient): The client object to connect to the BEC server. Defaults to None
-        config Optional(BECStatusBoxConfig | dict): The configuration for the status box. Defaults to None.
-        gui_id Optional(str): The unique id for the widget. Defaults to None.
-    """
-
-    CORE_SERVICES = ["DeviceServer", "ScanServer", "SciHub", "ScanBundler", "FileWriterManager"]
-
-    service_update = Signal(dict)
-    bec_core_state = Signal(str)
-
-    def __init__(
-        self,
-        parent=None,
-        service_name: str = "BEC Server",
-        client: BECClient = None,
-        config: BECStatusBoxConfig | dict = None,
-        gui_id: str = None,
-    ):
-        if config is None:
-            config = BECStatusBoxConfig(widget_class=self.__class__.__name__)
-        else:
-            if isinstance(config, dict):
-                config = BECStatusBoxConfig(**config)
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QTreeWidget.__init__(self, parent=parent)
-
-        self.service_name = service_name
-        self.config = config
-
-        self.bec_service_info_container = {}
-        self.tree_items = {}
-        self.tree_top_item = None
-        self.bec_service_status = BECServiceStatusMixin(client=self.client)
-
-        self.init_ui()
-        self.bec_service_status.services_update.connect(self.update_service_status)
-        self.bec_core_state.connect(self.update_top_item_status)
-        self.itemDoubleClicked.connect(self.on_tree_item_double_clicked)
-
-    def init_ui(self) -> None:
-        """Initialize the UI for the status box, and add QTreeWidget as the basis for the status box."""
-        self.init_ui_tree_widget()
-        top_label = self._create_status_widget(self.service_name, status=BECStatus.IDLE)
-        self.tree_top_item = QTreeWidgetItem()
-        self.tree_top_item.setExpanded(True)
-        self.tree_top_item.setDisabled(True)
-        self.addTopLevelItem(self.tree_top_item)
-        self.setItemWidget(self.tree_top_item, 0, top_label)
-        self.service_update.connect(top_label.update_config)
-
-    def _create_status_widget(
-        self, service_name: str, status=BECStatus, info: dict = None, metrics: dict = None
-    ) -> StatusItem:
-        """Creates a StatusItem (QWidget) for the given service, and stores all relevant
-        information about the service in the bec_service_info_container.
-
-        Args:
-            service_name (str): The name of the service.
-            status (BECStatus): The status of the service.
-            info Optional(dict): The information about the service. Default is {}
-            metric Optional(dict): Metrics for the respective service. Default is None
-
-        Returns:
-            StatusItem: The status item widget.
-        """
-        if info is None:
-            info = {}
-        self._update_bec_service_container(service_name, status, info, metrics)
-        item = StatusItem(
-            parent=self,
-            config={
-                "service_name": service_name,
-                "status": status.name,
-                "info": info,
-                "metrics": metrics,
-            },
-        )
-        return item
-
-    @Slot(str)
-    def update_top_item_status(self, status: BECStatus) -> None:
-        """Method to update the status of the top item in the tree widget.
-        Gets the status from the Signal 'bec_core_state' and updates the StatusItem via the signal 'service_update'.
-
-        Args:
-            status (BECStatus): The state of the core services.
-        """
-        self.bec_service_info_container[self.service_name].status = status
-        self.service_update.emit(self.bec_service_info_container[self.service_name].model_dump())
-
-    def _update_bec_service_container(
-        self, service_name: str, status: BECStatus, info: dict, metrics: dict = None
-    ) -> None:
-        """Update the bec_service_info_container with the newest status and metrics for the BEC service.
-        If information about the service already exists, it will create a new entry.
-
-        Args:
-            service_name (str): The name of the service.
-            service_info (StatusMessage): A class containing the service status.
-            service_metric (ServiceMetricMessage): A class containing the service metrics.
-        """
-        container = self.bec_service_info_container.get(service_name, None)
-        if container:
-            container.status = status
-            container.info = info
-            container.metrics = metrics
-            return
-        service_info_item = BECServiceInfoContainer(
-            service_name=service_name, status=status, info=info, metrics=metrics
-        )
-        self.bec_service_info_container.update({service_name: service_info_item})
-
-    @Slot(dict, dict)
-    def update_service_status(self, services_info: dict, services_metric: dict) -> None:
-        """Callback function services_metric from BECServiceStatusMixin.
-        It updates the status of all services.
-
-        Args:
-            services_info (dict): A dictionary containing the service status for all running BEC services.
-            services_metric (dict): A dictionary containing the service metrics for all running BEC services.
-        """
-        checked = []
-        services_info = self.update_core_services(services_info, services_metric)
-        checked.extend(self.CORE_SERVICES)
-
-        for service_name, msg in sorted(services_info.items()):
-            checked.append(service_name)
-            metric_msg = services_metric.get(service_name, None)
-            metrics = metric_msg.metrics if metric_msg else None
-            if service_name in self.tree_items:
-                self._update_bec_service_container(
-                    service_name=service_name, status=msg.status, info=msg.info, metrics=metrics
-                )
-                self.service_update.emit(self.bec_service_info_container[service_name].model_dump())
-                continue
-
-            item_widget = self._create_status_widget(
-                service_name=service_name, status=msg.status, info=msg.info, metrics=metrics
-            )
-            item = QTreeWidgetItem()
-            item.setDisabled(True)
-            self.service_update.connect(item_widget.update_config)
-            self.tree_top_item.addChild(item)
-            self.setItemWidget(item, 0, item_widget)
-            self.tree_items.update({service_name: (item, item_widget)})
-
-        self.check_redundant_tree_items(checked)
-
-    def update_core_services(self, services_info: dict, services_metric: dict) -> dict:
-        """Method to process status and metrics updates of core services (stored in CORE_SERVICES).
-        If a core services is not connected, it should not be removed from the status widget
-
-        Args:
-            services_info (dict): A dictionary containing the service status of different services.
-            services_metric (dict): A dictionary containing the service metrics of different services.
-
-        Returns:
-            dict: The services_info dictionary after removing the info updates related to the CORE_SERVICES
-        """
-        bec_core_state = "RUNNING"
-        for service_name in sorted(self.CORE_SERVICES):
-            metric_msg = services_metric.get(service_name, None)
-            metrics = metric_msg.metrics if metric_msg else None
-            if service_name not in services_info:
-                self.bec_service_info_container[service_name].status = "NOTCONNECTED"
-                bec_core_state = "ERROR"
-            else:
-                msg = services_info.pop(service_name)
-                self._update_bec_service_container(
-                    service_name=service_name, status=msg.status, info=msg.info, metrics=metrics
-                )
-                bec_core_state = (
-                    "RUNNING" if (msg.status.value > 1 and bec_core_state == "RUNNING") else "ERROR"
-                )
-
-            if service_name in self.tree_items:
-                self.service_update.emit(self.bec_service_info_container[service_name].model_dump())
-                continue
-            self.add_tree_item(service_name, msg.status, msg.info, metrics)
-
-        self.bec_core_state.emit(bec_core_state)
-        return services_info
-
-    def check_redundant_tree_items(self, checked: list) -> None:
-        """Utility method to check and remove redundant objects from the BECStatusBox.
-
-        Args:
-            checked (list): A list of services that are currently running.
-        """
-        to_be_deleted = [key for key in self.tree_items if key not in checked]
-
-        for key in to_be_deleted:
-            item, _ = self.tree_items.pop(key)
-            self.tree_top_item.removeChild(item)
-
-    def add_tree_item(
-        self, service_name: str, status: BECStatus, info: dict = None, metrics: dict = None
-    ) -> None:
-        """Method to add a new QTreeWidgetItem together with a StatusItem to the tree widget.
-
-        Args:
-            service_name (str): The name of the service.
-            service_status_msg (StatusMessage): The status of the service.
-            metrics (dict): The metrics of the service.
-        """
-        item_widget = self._create_status_widget(
-            service_name=service_name, status=status, info=info, metrics=metrics
-        )
-        item = QTreeWidgetItem()
-        self.service_update.connect(item_widget.update_config)
-        self.tree_top_item.addChild(item)
-        self.setItemWidget(item, 0, item_widget)
-        self.tree_items.update({service_name: (item, item_widget)})
-
-    def init_ui_tree_widget(self) -> None:
-        """Initialise the tree widget for the status box."""
-        self.setHeaderHidden(True)
-        self.setStyleSheet(
-            "QTreeWidget::item:!selected "
-            "{ "
-            "border: 1px solid gainsboro; "
-            "border-left: none; "
-            "border-top: none; "
-            "}"
-            "QTreeWidget::item:selected {}"
-        )
-
-    @Slot(QTreeWidgetItem, int)
-    def on_tree_item_double_clicked(self, item: QTreeWidgetItem, column: int) -> None:
-        """Callback function for double clicks on individual QTreeWidgetItems in the collapsed section.
-
-        Args:
-            item (QTreeWidgetItem): The item that was double clicked.
-            column (int): The column that was double clicked.
-        """
-        for _, (tree_item, status_widget) in self.tree_items.items():
-            if tree_item == item:
-                status_widget.show_popup()
-
-    def closeEvent(self, event):
-        super().cleanup()
-        QTreeWidget().closeEvent(event)
-
-
-def main():
-    """Main method to run the BECStatusBox widget."""
-    # pylint: disable=import-outside-toplevel
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    qdarktheme.setup_theme("auto")
-    main_window = BECStatusBox()
-    main_window.show()
-    sys.exit(app.exec())
-
-
-if __name__ == "__main__":
-    main()

bec_widgets/widgets/bec_status_box/status_item.py

@@ -1,171 +0,0 @@
-""" Module for a StatusItem widget to display status and metrics for a BEC service.
-The widget is bound to be used with the BECStatusBox widget."""
-
-import enum
-import sys
-from datetime import datetime
-
-import qdarktheme
-from bec_lib.utils.import_utils import lazy_import_from
-from pydantic import Field
-from qtpy.QtCore import Qt, Slot
-from qtpy.QtWidgets import QDialog, QHBoxLayout, QLabel, QStyle, QVBoxLayout, QWidget
-
-from bec_widgets.utils.bec_connector import ConnectionConfig
-
-# TODO : Put normal imports back when Pydantic gets faster
-BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
-
-
-class IconsEnum(enum.Enum):
-    """Enum class for icons in the status item widget."""
-
-    RUNNING = "SP_DialogApplyButton"
-    BUSY = "SP_BrowserReload"
-    IDLE = "SP_MessageBoxWarning"
-    ERROR = "SP_DialogCancelButton"
-    NOTCONNECTED = "SP_TitleBarContextHelpButton"
-
-
-class StatusWidgetConfig(ConnectionConfig):
-    """Configuration class for the status item widget."""
-
-    service_name: str
-    status: str
-    info: dict
-    metrics: dict | None
-    icon_size: tuple = Field(default=(24, 24), description="The size of the icon in the widget.")
-    font_size: int = Field(16, description="The font size of the text in the widget.")
-
-
-class StatusItem(QWidget):
-    """A widget to display the status of a service.
-
-    Args:
-        parent: The parent widget.
-        config (dict): The configuration for the service.
-    """
-
-    def __init__(self, parent=None, config: dict = None):
-        if config is None:
-            config = StatusWidgetConfig(widget_class=self.__class__.__name__)
-        else:
-            if isinstance(config, dict):
-                config = StatusWidgetConfig(**config)
-            self.config = config
-        QWidget.__init__(self, parent=parent)
-        self.parent = parent
-        self.layout = None
-        self.config = config
-        self._popup_label_ref = {}
-        self._label = None
-        self._icon = None
-        self.init_ui()
-
-    def init_ui(self) -> None:
-        """Init the UI for the status item widget."""
-        self.layout = QHBoxLayout()
-        self.layout.setContentsMargins(5, 5, 5, 5)
-        self.setLayout(self.layout)
-        self._label = QLabel()
-        self._icon = QLabel()
-        self.layout.addWidget(self._label)
-        self.layout.addWidget(self._icon)
-        self.update_ui()
-
-    @Slot(dict)
-    def update_config(self, config: dict) -> None:
-        """Update the configuration of the status item widget.
-        This method is invoked from the parent widget.
-        The UI values are later updated based on the new configuration.
-
-        Args:
-            config (dict): Config updates from parent widget.
-        """
-        if config["service_name"] != self.config.service_name:
-            return
-        self.config.status = config["status"]
-        self.config.info = config["info"]
-        self.config.metrics = config["metrics"]
-        self.update_ui()
-
-    def update_ui(self) -> None:
-        """Update the UI of the labels, and popup dialog."""
-        self.set_text()
-        self.set_status()
-        self._set_popup_text()
-
-    def set_text(self) -> None:
-        """Set the text of the QLabel basae on the config."""
-        service = self.config.service_name
-        status = self.config.status
-        if "BECClient" in service.split("/"):
-            service = service.split("/")[0] + "/..." + service.split("/")[1][-4:]
-        if status == "NOTCONNECTED":
-            status = "NOT CONNECTED"
-        text = f"{service} is {status}"
-        self._label.setText(text)
-
-    def set_status(self) -> None:
-        """Set the status icon for the status item widget."""
-        icon_name = IconsEnum[self.config.status].value
-        icon = self.style().standardIcon(getattr(QStyle.StandardPixmap, icon_name))
-        self._icon.setPixmap(icon.pixmap(*self.config.icon_size))
-        self._icon.setAlignment(Qt.AlignmentFlag.AlignRight)
-
-    def show_popup(self) -> None:
-        """Method that is invoked when the user double clicks on the StatusItem widget."""
-        dialog = QDialog(self)
-        dialog.setWindowTitle(f"{self.config.service_name} Details")
-        layout = QVBoxLayout()
-        popup_label = self._make_popup_label()
-        self._set_popup_text()
-        layout.addWidget(popup_label)
-        dialog.setLayout(layout)
-        dialog.finished.connect(self._cleanup_popup_label)
-        dialog.exec()
-
-    def _make_popup_label(self) -> QLabel:
-        """Create a QLabel for the popup dialog.
-
-        Returns:
-            QLabel: The label for the popup dialog.
-        """
-        label = QLabel()
-        label.setWordWrap(True)
-        self._popup_label_ref.update({"label": label})
-        return label
-
-    def _set_popup_text(self) -> None:
-        """Compile the metrics text for the status item widget."""
-        if self._popup_label_ref.get("label") is None:
-            return
-        metrics_text = (
-            f"<b>SERVICE:</b> {self.config.service_name}<br><b>STATUS:</b> {self.config.status}<br>"
-        )
-        if self.config.metrics:
-            for key, value in self.config.metrics.items():
-                if key == "create_time":
-                    value = datetime.fromtimestamp(value).strftime("%Y-%m-%d %H:%M:%S")
-                metrics_text += f"<b>{key.upper()}:</b> {value}<br>"
-        self._popup_label_ref["label"].setText(metrics_text)
-
-    def _cleanup_popup_label(self) -> None:
-        """Cleanup the popup label."""
-        self._popup_label_ref.clear()
-
-
-def main():
-    """Run the status item widget."""
-    # pylint: disable=import-outside-toplevel
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    qdarktheme.setup_theme("auto")
-    main_window = StatusItem()
-    main_window.show()
-    sys.exit(app.exec())
-
-
-if __name__ == "__main__":
-    main()

bec_widgets/widgets/buttons/__init__.py

@@ -1 +0,0 @@
-from .stop_button.stop_button import StopButton

bec_widgets/widgets/buttons/stop_button/stop_button.py

@@ -1,32 +0,0 @@
-from qtpy.QtWidgets import QPushButton
-
-from bec_widgets.utils import BECConnector
-
-
-class StopButton(BECConnector, QPushButton):
-    """A button that stops the current scan."""
-
-    def __init__(self, parent=None, client=None, config=None, gui_id=None):
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QPushButton.__init__(self, parent=parent)
-
-        self.get_bec_shortcuts()
-        self.setText("Stop")
-        self.setStyleSheet("background-color:  #cc181e; color: white")
-        self.clicked.connect(self.stop_scan)
-
-    def stop_scan(self):
-        """Stop the scan."""
-        self.queue.request_scan_abortion()
-        self.queue.request_queue_reset()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    widget = StopButton()
-    widget.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/device_inputs/__init__.py

@@ -1,2 +0,0 @@
-from .device_combobox.device_combobox import DeviceComboBox
-from .device_line_edit.device_line_edit import DeviceLineEdit

bec_widgets/widgets/device_inputs/device_combobox/device_combobox.py

@@ -1,95 +0,0 @@
-from typing import TYPE_CHECKING
-
-from qtpy.QtWidgets import QComboBox
-
-from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputBase, DeviceInputConfig
-
-if TYPE_CHECKING:
-    from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputConfig
-
-
-class DeviceComboBox(DeviceInputBase, QComboBox):
-    """
-    Line edit widget for device input with autocomplete for device names.
-
-    Args:
-        parent: Parent widget.
-        client: BEC client object.
-        config: Device input configuration.
-        gui_id: GUI ID.
-        device_filter: Device filter, name of the device class.
-        default_device: Default device name.
-        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
-    """
-
-    def __init__(
-        self,
-        parent=None,
-        client=None,
-        config: DeviceInputConfig = None,
-        gui_id: str | None = None,
-        device_filter: str | None = None,
-        default_device: str | None = None,
-        arg_name: str | None = None,
-    ):
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QComboBox.__init__(self, parent=parent)
-
-        self.populate_combobox()
-
-        if arg_name is not None:
-            self.config.arg_name = arg_name
-        if device_filter is not None:
-            self.set_device_filter(device_filter)
-        if default_device is not None:
-            self.set_default_device(default_device)
-
-    def set_device_filter(self, device_filter: str):
-        """
-        Set the device filter.
-
-        Args:
-            device_filter(str): Device filter, name of the device class.
-        """
-        super().set_device_filter(device_filter)
-        self.populate_combobox()
-
-    def set_default_device(self, default_device: str):
-        """
-        Set the default device.
-
-        Args:
-            default_device(str): Default device name.
-        """
-        super().set_default_device(default_device)
-        self.setCurrentText(default_device)
-
-    def populate_combobox(self):
-        """Populate the combobox with the devices."""
-        self.devices = self.get_device_list(self.config.device_filter)
-        self.clear()
-        self.addItems(self.devices)
-
-    def get_device(self) -> object:
-        """
-        Get the selected device object.
-
-        Returns:
-            object: Device object.
-        """
-        device_name = self.currentText()
-        device_obj = getattr(self.dev, device_name.lower(), None)
-        if device_obj is None:
-            raise ValueError(f"Device {device_name} is not found.")
-        return device_obj
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    w = DeviceComboBox(default_device="samx")
-    w.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/device_inputs/device_input_base.py

@@ -1,120 +0,0 @@
-from __future__ import annotations
-
-from bec_widgets.utils import BECConnector, ConnectionConfig
-
-
-class DeviceInputConfig(ConnectionConfig):
-    device_filter: str | list[str] | None = None
-    default_device: str | None = None
-    arg_name: str | None = None
-
-
-class DeviceInputBase(BECConnector):
-    """
-    Mixin class for device input widgets. This class provides methods to get the device list and device object based
-    on the current text of the widget.
-    """
-
-    def __init__(self, client=None, config=None, gui_id=None):
-        if config is None:
-            config = DeviceInputConfig(widget_class=self.__class__.__name__)
-        else:
-            if isinstance(config, dict):
-                config = DeviceInputConfig(**config)
-            self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id)
-
-        self.get_bec_shortcuts()
-        self._devices = []
-
-    @property
-    def devices(self) -> list[str]:
-        """
-        Get the list of devices.
-
-        Returns:
-            list[str]: List of devices.
-        """
-        return self._devices
-
-    @devices.setter
-    def devices(self, value: list[str]):
-        """
-        Set the list of devices.
-
-        Args:
-            value: List of devices.
-        """
-        self._devices = value
-
-    def set_device_filter(self, device_filter: str | list[str]):
-        """
-        Set the device filter.
-
-        Args:
-            device_filter(str): Device filter, name of the device class.
-        """
-        self.validate_device_filter(device_filter)
-        self.config.device_filter = device_filter
-
-    def set_default_device(self, default_device: str):
-        """
-        Set the default device.
-
-        Args:
-            default_device(str): Default device name.
-        """
-        self.validate_device(default_device)
-        self.config.default_device = default_device
-
-    def get_device_list(self, filter: str | list[str] | None = None) -> list[str]:
-        """
-        Get the list of device names based on the filter of current BEC client.
-
-        Args:
-            filter(str|None): Class name filter to apply on the device list.
-
-        Returns:
-            devices(list[str]): List of device names.
-        """
-        all_devices = self.dev.enabled_devices
-        if filter is not None:
-            self.validate_device_filter(filter)
-            if isinstance(filter, str):
-                filter = [filter]
-            devices = [device.name for device in all_devices if device.__class__.__name__ in filter]
-        else:
-            devices = [device.name for device in all_devices]
-        return devices
-
-    def get_available_filters(self):
-        """
-        Get the available device classes which can be used as filters.
-        """
-        all_devices = self.dev.enabled_devices
-        filters = {device.__class__.__name__ for device in all_devices}
-        return filters
-
-    def validate_device_filter(self, filter: str | list[str]) -> None:
-        """
-        Validate the device filter if the class name is present in the current BEC instance.
-
-        Args:
-            filter(str|list[str]): Class name to use as a device filter.
-        """
-        if isinstance(filter, str):
-            filter = [filter]
-        available_filters = self.get_available_filters()
-        for f in filter:
-            if f not in available_filters:
-                raise ValueError(f"Device filter {f} is not valid.")
-
-    def validate_device(self, device: str) -> None:
-        """
-        Validate the device if it is present in current BEC instance.
-
-        Args:
-            device(str): Device to validate.
-        """
-        if device not in self.get_device_list(self.config.device_filter):
-            raise ValueError(f"Device {device} is not valid.")

bec_widgets/widgets/device_inputs/device_line_edit/device_line_edit.py

@@ -1,102 +0,0 @@
-from typing import TYPE_CHECKING
-
-from qtpy.QtWidgets import QCompleter, QLineEdit
-
-from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputBase, DeviceInputConfig
-
-if TYPE_CHECKING:
-    from bec_widgets.widgets.device_inputs.device_input_base import DeviceInputConfig
-
-
-class DeviceLineEdit(DeviceInputBase, QLineEdit):
-    """
-    Line edit widget for device input with autocomplete for device names.
-
-    Args:
-        parent: Parent widget.
-        client: BEC client object.
-        config: Device input configuration.
-        gui_id: GUI ID.
-        device_filter: Device filter, name of the device class.
-        default_device: Default device name.
-        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
-    """
-
-    def __init__(
-        self,
-        parent=None,
-        client=None,
-        config: DeviceInputConfig = None,
-        gui_id: str | None = None,
-        device_filter: str | list[str] | None = None,
-        default_device: str | None = None,
-        arg_name: str | None = None,
-    ):
-        QLineEdit.__init__(self, parent=parent)
-        DeviceInputBase.__init__(self, client=client, config=config, gui_id=gui_id)
-
-        self.completer = QCompleter(self)
-        self.setCompleter(self.completer)
-        self.populate_completer()
-
-        if arg_name is not None:
-            self.config.arg_name = arg_name
-        if device_filter is not None:
-            self.set_device_filter(device_filter)
-        if default_device is not None:
-            self.set_default_device(default_device)
-
-    def set_device_filter(self, device_filter: str | list[str]):
-        """
-        Set the device filter.
-
-        Args:
-            device_filter (str | list[str]): Device filter, name of the device class.
-        """
-        super().set_device_filter(device_filter)
-        self.populate_completer()
-
-    def set_default_device(self, default_device: str):
-        """
-        Set the default device.
-
-        Args:
-            default_device (str): Default device name.
-        """
-        super().set_default_device(default_device)
-        self.setText(default_device)
-
-    def populate_completer(self):
-        """Populate the completer with the devices."""
-        self.devices = self.get_device_list(self.config.device_filter)
-        self.completer.setModel(self.create_completer_model(self.devices))
-
-    def create_completer_model(self, devices: list[str]):
-        """Create a model for the completer."""
-        from qtpy.QtCore import QStringListModel
-
-        return QStringListModel(devices, self)
-
-    def get_device(self) -> object:
-        """
-        Get the selected device object.
-
-        Returns:
-            object: Device object.
-        """
-        device_name = self.text()
-        device_obj = getattr(self.dev, device_name.lower(), None)
-        if device_obj is None:
-            raise ValueError(f"Device {device_name} is not found.")
-        return device_obj
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    w = DeviceLineEdit(default_device="samx")
-    w.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/device_selection/device_combobox.py

@@ -0,0 +1,14 @@
+from qtpy.QtWidgets import QComboBox
+
+from bec_widgets.utils import BECConnector, ConnectionConfig
+
+
+class DeviceCombobox(BECConnector, QComboBox):
+    def __init__(self, parent=None, client=None, config=None, gui_id=None):
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QComboBox.__init__(self, parent=parent)
+
+        self.get_bec_shortcuts()
+
+        def get_device(self):
+            return getattr(self.dev, self.text().lower())

bec_widgets/widgets/dock/dock.py

@@ -1,21 +1,21 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Literal, Optional
+from typing import TYPE_CHECKING, Literal, Optional
 
 from pydantic import Field
 from pyqtgraph.dockarea import Dock
 
-from bec_widgets.cli.rpc_wigdet_handler import widget_handler
+from bec_widgets.cli.rpc_wigdet_handler import RPCWidgetHandler
 from bec_widgets.utils import BECConnector, ConnectionConfig, GridLayoutManager
 
 if TYPE_CHECKING:
     from qtpy.QtWidgets import QWidget
 
-    from bec_widgets.widgets.dock import BECDockArea
+    from bec_widgets.widgets import BECDockArea
 
 
 class DockConfig(ConnectionConfig):
-    widgets: dict[str, Any] = Field({}, description="The widgets in the dock.")
+    widgets: dict[str, ConnectionConfig] = Field({}, description="The widgets in the dock.")
     position: Literal["bottom", "top", "left", "right", "above", "below"] = Field(
         "bottom", description="The position of the dock."
     )
@@ -26,14 +26,13 @@ class DockConfig(ConnectionConfig):
 
 class BECDock(BECConnector, Dock):
     USER_ACCESS = [
-        "config_dict",
         "rpc_id",
         "widget_list",
         "show_title_bar",
         "hide_title_bar",
         "get_widgets_positions",
         "set_title",
-        "add_widget",
+        "add_widget_bec",
         "list_eligible_widgets",
         "move_widget",
         "remove_widget",
@@ -63,6 +62,8 @@ class BECDock(BECConnector, Dock):
         super().__init__(client=client, config=config, gui_id=gui_id)
         Dock.__init__(self, name=name, **kwargs)
 
+        self.parent_dock_area = parent_dock_area
+
         # Layout Manager
         self.layout_manager = GridLayoutManager(self.layout)
 
@@ -71,8 +72,8 @@ class BECDock(BECConnector, Dock):
         old_area = source.area
         self.setOrientation("horizontal", force=True)
         super().dropEvent(event)
-        if old_area in self.orig_area.tempAreas and old_area != self.orig_area:
-            self.orig_area.removeTempArea(old_area)
+        if old_area in self.parent_dock_area.tempAreas and old_area != self.parent_dock_area:
+            self.parent_dock_area.removeTempArea(old_area)
 
     def float(self):
         """
@@ -91,7 +92,7 @@ class BECDock(BECConnector, Dock):
             super().float()
 
     @property
-    def widget_list(self) -> list[BECConnector]:
+    def widget_list(self) -> list:
         """
         Get the widgets in the dock.
 
@@ -101,7 +102,7 @@ class BECDock(BECConnector, Dock):
         return self.widgets
 
     @widget_list.setter
-    def widget_list(self, value: list[BECConnector]):
+    def widget_list(self, value: list):
         self.widgets = value
 
     def hide_title_bar(self):
@@ -127,9 +128,8 @@ class BECDock(BECConnector, Dock):
         Args:
             title(str): The title of the dock.
         """
-        self.orig_area.docks[title] = self.orig_area.docks.pop(self.name())
+        self.parent_dock_area.docks[title] = self.parent_dock_area.docks.pop(self.name())
         self.setTitle(title)
-        self._name = title
 
     def get_widgets_positions(self) -> dict:
         """
@@ -149,17 +149,48 @@ class BECDock(BECConnector, Dock):
         Returns:
             list: The list of eligible widgets.
         """
-        return list(widget_handler.widget_classes.keys())
+        return list(RPCWidgetHandler.widget_classes.keys())
 
-    def add_widget(
+    def add_widget_bec(
         self,
-        widget: BECConnector | str,
+        widget_type: str,
         row=None,
         col=0,
         rowspan=1,
         colspan=1,
         shift: Literal["down", "up", "left", "right"] = "down",
-    ) -> BECConnector:
+    ):
+        """
+        Add a widget to the dock.
+
+        Args:
+            widget_type(str): The widget to add. Only BEC RPC widgets from RPCWidgetHandler are allowed.
+            row(int): The row to add the widget to. If None, the widget will be added to the next available row.
+            col(int): The column to add the widget to.
+            rowspan(int): The number of rows the widget should span.
+            colspan(int): The number of columns the widget should span.
+            shift(Literal["down", "up", "left", "right"]): The direction to shift the widgets if the position is occupied.
+        """
+        if row is None:
+            row = self.layout.rowCount()
+
+        if self.layout_manager.is_position_occupied(row, col):
+            self.layout_manager.shift_widgets(shift, start_row=row)
+
+        widget = RPCWidgetHandler.create_widget(widget_type)
+        self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
+
+        return widget
+
+    def add_widget(
+        self,
+        widget: QWidget,
+        row=None,
+        col=0,
+        rowspan=1,
+        colspan=1,
+        shift: Literal["down", "up", "left", "right"] = "down",
+    ):
         """
         Add a widget to the dock.
 
@@ -177,18 +208,8 @@ class BECDock(BECConnector, Dock):
         if self.layout_manager.is_position_occupied(row, col):
             self.layout_manager.shift_widgets(shift, start_row=row)
 
-        if isinstance(widget, str):
-            widget = widget_handler.create_widget(widget)
-        else:
-            widget = widget
-
         self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
 
-        if hasattr(widget, "config"):
-            self.config.widgets[widget.gui_id] = widget.config
-
-        return widget
-
     def move_widget(self, widget: QWidget, new_row: int, new_col: int):
         """
         Move a widget to a new position in the layout.
@@ -204,7 +225,7 @@ class BECDock(BECConnector, Dock):
         """
         Attach the dock to the parent dock area.
         """
-        self.orig_area.removeTempArea(self.area)
+        self.parent_dock_area.removeTempArea(self.area)
 
     def detach(self):
         """
@@ -221,7 +242,6 @@ class BECDock(BECConnector, Dock):
         """
         widget = self.rpc_register.get_rpc_by_id(widget_rpc_id)
         self.layout.removeWidget(widget)
-        self.config.widgets.pop(widget_rpc_id, None)
         widget.close()
 
     def remove(self):
@@ -229,7 +249,7 @@ class BECDock(BECConnector, Dock):
         Remove the dock from the parent dock area.
         """
         # self.cleanup()
-        self.orig_area.remove_dock(self.name())
+        self.parent_dock_area.remove_dock(self.name())
 
     def cleanup(self):
         """

bec_widgets/widgets/dock/dock_area.py

@@ -16,14 +16,10 @@ from .dock import BECDock, DockConfig
 
 class DockAreaConfig(ConnectionConfig):
     docks: dict[str, DockConfig] = Field({}, description="The docks in the dock area.")
-    docks_state: Optional[dict] = Field(
-        None, description="The state of the docks in the dock area."
-    )
 
 
 class BECDockArea(BECConnector, DockArea):
     USER_ACCESS = [
-        "config_dict",
         "panels",
         "save_state",
         "remove_dock",
@@ -33,7 +29,6 @@ class BECDockArea(BECConnector, DockArea):
         "detach_dock",
         "attach_all",
         "get_all_rpc",
-        "temp_areas",
     ]
 
     def __init__(
@@ -61,7 +56,7 @@ class BECDockArea(BECConnector, DockArea):
             painter.drawText(self.rect(), Qt.AlignCenter, "Add docks using 'add_dock' method")
 
     @property
-    def panels(self) -> dict[str, BECDock]:
+    def panels(self) -> dict:
         """
         Get the docks in the dock area.
         Returns:
@@ -70,23 +65,10 @@ class BECDockArea(BECConnector, DockArea):
         return dict(self.docks)
 
     @panels.setter
-    def panels(self, value: dict[str, BECDock]):
+    def panels(self, value: dict):
+
         self.docks = WeakValueDictionary(value)
 
-    @property
-    def temp_areas(self) -> list:
-        """
-        Get the temporary areas in the dock area.
-
-        Returns:
-            list: The temporary areas in the dock area.
-        """
-        return list(map(str, self.tempAreas))
-
-    @temp_areas.setter
-    def temp_areas(self, value: list):
-        self.tempAreas = list(map(str, value))
-
     def restore_state(
         self, state: dict = None, missing: Literal["ignore", "error"] = "ignore", extra="bottom"
     ):
@@ -99,7 +81,7 @@ class BECDockArea(BECConnector, DockArea):
             extra(str): Extra docks that are in the dockarea but that are not mentioned in state will be added to the bottom of the dockarea, unless otherwise specified by the extra argument.
         """
         if state is None:
-            state = self.config.docks_state
+            state = self._last_state
         self.restoreState(state, missing=missing, extra=extra)
 
     def save_state(self) -> dict:
@@ -109,9 +91,8 @@ class BECDockArea(BECConnector, DockArea):
         Returns:
             dict: The state of the dock area.
         """
-        last_state = self.saveState()
-        self.config.docks_state = last_state
-        return last_state
+        self._last_state = self.saveState()
+        return self._last_state
 
     def remove_dock(self, name: str):
         """
@@ -121,7 +102,6 @@ class BECDockArea(BECConnector, DockArea):
             name(str): The name of the dock to remove.
         """
         dock = self.docks.pop(name, None)
-        self.config.docks.pop(name, None)
         if dock:
             dock.close()
             if len(self.docks) <= 1:
@@ -137,7 +117,6 @@ class BECDockArea(BECConnector, DockArea):
         position: Literal["bottom", "top", "left", "right", "above", "below"] = None,
         relative_to: BECDock | None = None,
         closable: bool = False,
-        floating: bool = False,
         prefix: str = "dock",
         widget: str | QWidget | None = None,
         row: int = None,
@@ -153,7 +132,6 @@ class BECDockArea(BECConnector, DockArea):
             position(Literal["bottom", "top", "left", "right", "above", "below"]): The position of the dock.
             relative_to(BECDock): The dock to which the new dock should be added relative to.
             closable(bool): Whether the dock is closable.
-            floating(bool): Whether the dock is detached after creating.
             prefix(str): The prefix for the dock name if no name is provided.
             widget(str|QWidget|None): The widget to be added to the dock. While using RPC, only BEC RPC widgets from RPCWidgetHandler are allowed.
             row(int): The row of the added widget.
@@ -188,14 +166,14 @@ class BECDockArea(BECConnector, DockArea):
                 dock.show_title_bar()
 
         if widget is not None and isinstance(widget, str):
-            dock.add_widget(widget=widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
+            dock.add_widget_bec(
+                widget_type=widget, row=row, col=col, rowspan=rowspan, colspan=colspan
+            )
         elif widget is not None and isinstance(widget, QWidget):
             dock.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
         if self._instructions_visible:
             self._instructions_visible = False
             self.update()
-        if floating:
-            dock.detach()
         return dock
 
     def detach_dock(self, dock_name: str) -> BECDock:
@@ -209,7 +187,7 @@ class BECDockArea(BECConnector, DockArea):
             BECDock: The undocked dock.
         """
         dock = self.docks[dock_name]
-        dock.detach()
+        self.floatDock(dock)
         return dock
 
     def attach_all(self):

bec_widgets/widgets/figure/figure.py

@@ -26,7 +26,7 @@ class FigureConfig(ConnectionConfig):
     theme: Literal["dark", "light"] = Field("dark", description="The theme of the figure widget.")
     num_cols: int = Field(1, description="The number of columns in the figure widget.")
     num_rows: int = Field(1, description="The number of rows in the figure widget.")
-    widgets: dict[str, Waveform1DConfig | ImageConfig | MotorMapConfig | SubplotConfig] = Field(
+    widgets: dict[str, SubplotConfig] = Field(
         {}, description="The list of widgets to be added to the figure widget."
     )
 
@@ -184,9 +184,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         """
         self._widgets = value
 
-    def _init_waveform(
+    def add_plot(
         self,
-        waveform,
         x_name: str = None,
         y_name: str = None,
         z_name: str = None,
@@ -199,45 +198,33 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         color_map_z: Optional[str] = "plasma",
         label: Optional[str] = None,
         validate: bool = True,
-    ):
+        row: int = None,
+        col: int = None,
+        config=None,
+        **axis_kwargs,
+    ) -> BECWaveform:
         """
-        Configure the waveform based on the provided parameters.
+        Add a Waveform1D plot to the figure at the specified position.
 
         Args:
-            waveform (BECWaveform): The waveform to configure.
-            x (list | np.ndarray): Custom x data to plot.
-            y (list | np.ndarray): Custom y data to plot.
-            x_name (str): The name of the device for the x-axis.
-            y_name (str): The name of the device for the y-axis.
-            z_name (str): The name of the device for the z-axis.
-            x_entry (str): The name of the entry for the x-axis.
-            y_entry (str): The name of the entry for the y-axis.
-            z_entry (str): The name of the entry for the z-axis.
-            color (str): The color of the curve.
-            color_map_z (str): The color map to use for the z-axis.
-            label (str): The label of the curve.
-            validate (bool): If True, validate the device names and entries.
+            widget_id(str): The unique identifier of the widget. If not provided, a unique ID will be generated.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Additional configuration for the widget.
+            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
         """
-        if x is not None and y is None:
-            if isinstance(x, np.ndarray):
-                if x.ndim == 1:
-                    y = np.arange(x.size)
-                    waveform.add_curve_custom(x=np.arange(x.size), y=x, color=color, label=label)
-                    return waveform
-                if x.ndim == 2:
-                    waveform.add_curve_custom(x=x[:, 0], y=x[:, 1], color=color, label=label)
-                    return waveform
-            elif isinstance(x, list):
-                y = np.arange(len(x))
-                waveform.add_curve_custom(x=np.arange(len(x)), y=x, color=color, label=label)
-                return waveform
-            else:
-                raise ValueError(
-                    "Invalid input. Provide either device names (x_name, y_name) or custom data."
-                )
-        if x is not None and y is not None:
-            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
-            return waveform
+        widget_id = str(uuid.uuid4())
+        waveform = self.add_widget(
+            widget_type="Waveform1D",
+            widget_id=widget_id,
+            row=row,
+            col=col,
+            config=config,
+            **axis_kwargs,
+        )
+
+        # TODO remove repetition from .plot method
+
         # User wants to add scan curve -> 1D Waveform
         if x_name is not None and y_name is not None and z_name is None and x is None and y is None:
             waveform.add_curve_scan(
@@ -275,73 +262,6 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
         return waveform
 
-    def add_plot(
-        self,
-        x: list | np.ndarray = None,
-        y: list | np.ndarray = None,
-        x_name: str = None,
-        y_name: str = None,
-        z_name: str = None,
-        x_entry: str = None,
-        y_entry: str = None,
-        z_entry: str = None,
-        color: Optional[str] = None,
-        color_map_z: Optional[str] = "plasma",
-        label: Optional[str] = None,
-        validate: bool = True,
-        row: int = None,
-        col: int = None,
-        config=None,
-        **axis_kwargs,
-    ) -> BECWaveform:
-        """
-        Add a Waveform1D plot to the figure at the specified position.
-
-        Args:
-            x(list | np.ndarray): Custom x data to plot.
-            y(list | np.ndarray): Custom y data to plot.
-            x_name(str): The name of the device for the x-axis.
-            y_name(str): The name of the device for the y-axis.
-            z_name(str): The name of the device for the z-axis.
-            x_entry(str): The name of the entry for the x-axis.
-            y_entry(str): The name of the entry for the y-axis.
-            z_entry(str): The name of the entry for the z-axis.
-            color(str): The color of the curve.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str): The label of the curve.
-            validate(bool): If True, validate the device names and entries.
-            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
-            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
-            config(dict): Additional configuration for the widget.
-            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
-        """
-        widget_id = str(uuid.uuid4())
-        waveform = self.add_widget(
-            widget_type="Waveform1D",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
-        )
-
-        waveform = self._init_waveform(
-            waveform=waveform,
-            x=x,
-            y=y,
-            x_name=x_name,
-            y_name=y_name,
-            z_name=z_name,
-            x_entry=x_entry,
-            y_entry=y_entry,
-            z_entry=z_entry,
-            color=color,
-            color_map_z=color_map_z,
-            label=label,
-            validate=validate,
-        )
-        return waveform
-
     @typechecked
     def plot(
         self,
@@ -389,60 +309,69 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         else:
             waveform = self.add_plot(**axis_kwargs)
 
-        waveform = self._init_waveform(
-            waveform=waveform,
-            x=x,
-            y=y,
-            x_name=x_name,
-            y_name=y_name,
-            z_name=z_name,
-            x_entry=x_entry,
-            y_entry=y_entry,
-            z_entry=z_entry,
-            color=color,
-            color_map_z=color_map_z,
-            label=label,
-            validate=validate,
-        )
-        # TODO remove repetition from .plot method
-        return waveform
+        if x is not None and y is None:
+            if isinstance(x, np.ndarray):
+                if x.ndim == 1:
+                    y = np.arange(x.size)
+                    waveform.add_curve_custom(x=np.arange(x.size), y=x, color=color, label=label)
+                    return waveform
+                if x.ndim == 2:
+                    waveform.add_curve_custom(x=x[:, 0], y=x[:, 1], color=color, label=label)
+                    return waveform
+            elif isinstance(x, list):
+                y = np.arange(len(x))
+                waveform.add_curve_custom(x=np.arange(len(x)), y=x, color=color, label=label)
+                return waveform
+            else:
+                raise ValueError(
+                    "Invalid input. Provide either device names (x_name, y_name) or custom data."
+                )
+        if x is not None and y is not None:
+            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
+            return waveform
 
-    def _init_image(
-        self,
-        image,
-        monitor: str = None,
-        color_bar: Literal["simple", "full"] = "full",
-        color_map: str = "magma",
-        data: np.ndarray = None,
-        vrange: tuple[float, float] = None,
-    ) -> BECImageShow:
-        """
-        Configure the image based on the provided parameters.
-
-        Args:
-            image (BECImageShow): The image to configure.
-            monitor (str): The name of the monitor to display.
-            color_bar (Literal["simple","full"]): The type of color bar to display.
-            color_map (str): The color map to use for the image.
-            data (np.ndarray): Custom data to display.
-        """
-        if monitor is not None and data is None:
-            image.add_monitor_image(
-                monitor=monitor, color_map=color_map, vrange=vrange, color_bar=color_bar
+        # User wants to add scan curve -> 1D Waveform
+        if x_name is not None and y_name is not None and z_name is None and x is None and y is None:
+            waveform.add_curve_scan(
+                x_name=x_name,
+                y_name=y_name,
+                x_entry=x_entry,
+                y_entry=y_entry,
+                color=color,
+                color_map_z="plasma",
+                label=label,
+                validate=validate,
             )
-        elif data is not None and monitor is None:
-            image.add_custom_image(
-                name="custom", data=data, color_map=color_map, vrange=vrange, color_bar=color_bar
+        # User wants to add scan curve -> 2D Waveform Scatter
+        elif (
+            x_name is not None
+            and y_name is not None
+            and z_name is not None
+            and x is None
+            and y is None
+        ):
+            waveform.add_curve_scan(
+                x_name=x_name,
+                y_name=y_name,
+                z_name=z_name,
+                x_entry=x_entry,
+                y_entry=y_entry,
+                z_entry=z_entry,
+                color=color,
+                color_map_z=color_map_z,
+                label=label,
+                validate=validate,
             )
-        elif data is None and monitor is None:
-            # Setting appearance
-            if vrange is not None:
-                image.set_vrange(vmin=vrange[0], vmax=vrange[1])
-            if color_map is not None:
-                image.set_color_map(color_map)
+        # User wants to add custom curve
+        elif (
+            x is not None and y is not None and x_name is None and y_name is None and z_name is None
+        ):
+            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
         else:
-            raise ValueError("Invalid input. Provide either monitor name or custom data.")
-        return image
+            raise ValueError(
+                "Invalid input. Provide either device names (x_name, y_name) or custom data."
+            )
+        return waveform
 
     def image(
         self,
@@ -476,14 +405,23 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         else:
             image = self.add_image(color_bar=color_bar, **axis_kwargs)
 
-        image = self._init_image(
-            image=image,
-            monitor=monitor,
-            color_bar=color_bar,
-            color_map=color_map,
-            data=data,
-            vrange=vrange,
-        )
+        # Setting data #TODO check logic if monitor or data are already created
+        if monitor is not None and data is None:
+            image.add_monitor_image(
+                monitor=monitor, color_map=color_map, vrange=vrange, color_bar=color_bar
+            )
+        elif data is not None and monitor is None:
+            image.add_custom_image(
+                name="custom", data=data, color_map=color_map, vrange=vrange, color_bar=color_bar
+            )
+        elif data is None and monitor is None:
+            # Setting appearance
+            if vrange is not None:
+                image.set_vrange(vmin=vrange[0], vmax=vrange[1])
+            if color_map is not None:
+                image.set_color_map(color_map)
+        else:
+            raise ValueError("Invalid input. Provide either monitor name or custom data.")
         return image
 
     def add_image(
@@ -534,14 +472,22 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             config=config,
             **axis_kwargs,
         )
-        image = self._init_image(
-            image=image,
-            monitor=monitor,
-            color_bar=color_bar,
-            color_map=color_map,
-            data=data,
-            vrange=vrange,
-        )
+        # TODO remove repetition from .image method
+        if monitor is not None and data is None:
+            image.add_monitor_image(
+                monitor=monitor, color_map=color_map, vrange=vrange, color_bar=color_bar
+            )
+        elif data is not None and monitor is None:
+            image.add_custom_image(
+                name="custom", data=data, color_map=color_map, vrange=vrange, color_bar=color_bar
+            )
+        elif data is None and monitor is None:
+            # Setting appearance
+            if vrange is not None:
+                image.set_vrange(vmin=vrange[0], vmax=vrange[1])
+            if color_map is not None:
+                image.set_color_map(color_map)
+
         return image
 
     def motor_map(self, motor_x: str = None, motor_y: str = None, **axis_kwargs) -> BECMotorMap:
@@ -711,12 +657,6 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         qdarktheme.setup_theme(theme)
         self.setBackground("k" if theme == "dark" else "w")
         self.config.theme = theme
-        for plot in self.widget_list:
-            plot.set_x_label(plot.plot_item.getAxis("bottom").label.toPlainText())
-            plot.set_y_label(plot.plot_item.getAxis("left").label.toPlainText())
-            if plot.plot_item.titleLabel.text:
-                plot.set_title(plot.plot_item.titleLabel.text)
-            plot.set_legend_label_size()
 
     def _remove_by_coordinates(self, row: int, col: int) -> None:
         """

bec_widgets/widgets/figure/plots/image/image.py

@@ -53,6 +53,7 @@ class BECImageShow(BECPlotBase):
         "set_y_lim",
         "set_grid",
         "lock_aspect_ratio",
+        "plot",
         "remove",
         "images",
     ]

bec_widgets/widgets/figure/plots/image/image_processor.py

@@ -19,7 +19,6 @@ class ProcessingConfig(BaseModel):
     rotation: Optional[int] = Field(
         None, description="The rotation angle of the monitor data before displaying."
     )
-    model_config: dict = {"validate_assignment": True}
 
 
 class ImageProcessor:

bec_widgets/widgets/figure/plots/motor_map/motor_map.py

@@ -317,7 +317,7 @@ class BECMotorMap(BECPlotBase):
         Returns:
             float: Motor initial position.
         """
-        init_position = round(float(self.dev[name].read()[entry]["value"]), precision)
+        init_position = round(self.dev[name].read()[entry]["value"], precision)
         return init_position
 
     def _validate_signal_entries(
@@ -403,7 +403,7 @@ class BECMotorMap(BECPlotBase):
         # Update plot title
         precision = self.config.precision
         self.set_title(
-            f"Motor position: ({round(float(current_x),precision)}, {round(float(current_y),precision)})"
+            f"Motor position: ({round(current_x,precision)}, {round(current_y,precision)})"
         )
 
     @pyqtSlot(dict)

bec_widgets/widgets/figure/plots/plot_base.py

@@ -5,8 +5,6 @@ from typing import Literal, Optional
 import numpy as np
 import pyqtgraph as pg
 from pydantic import BaseModel, Field
-from qtpy import QT_VERSION
-from qtpy.QtGui import QFont, QFontDatabase, QFontInfo
 from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils import BECConnector, ConnectionConfig
@@ -14,21 +12,14 @@ from bec_widgets.utils import BECConnector, ConnectionConfig
 
 class AxisConfig(BaseModel):
     title: Optional[str] = Field(None, description="The title of the axes.")
-    title_size: Optional[int] = Field(None, description="The font size of the title.")
     x_label: Optional[str] = Field(None, description="The label for the x-axis.")
-    x_label_size: Optional[int] = Field(None, description="The font size of the x-axis label.")
     y_label: Optional[str] = Field(None, description="The label for the y-axis.")
-    y_label_size: Optional[int] = Field(None, description="The font size of the y-axis label.")
-    legend_label_size: Optional[int] = Field(
-        None, description="The font size of the legend labels."
-    )
     x_scale: Literal["linear", "log"] = Field("linear", description="The scale of the x-axis.")
     y_scale: Literal["linear", "log"] = Field("linear", description="The scale of the y-axis.")
     x_lim: Optional[tuple] = Field(None, description="The limits of the x-axis.")
     y_lim: Optional[tuple] = Field(None, description="The limits of the y-axis.")
     x_grid: bool = Field(False, description="Show grid on the x-axis.")
     y_grid: bool = Field(False, description="Show grid on the y-axis.")
-    model_config: dict = {"validate_assignment": True}
 
 
 class SubplotConfig(ConnectionConfig):
@@ -57,8 +48,8 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
         "set_y_lim",
         "set_grid",
         "lock_aspect_ratio",
+        "plot",
         "remove",
-        "set_legend_label_size",
     ]
 
     def __init__(
@@ -94,7 +85,6 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
             - y_scale: Literal["linear", "log"]
             - x_lim: tuple
             - y_lim: tuple
-            - legend_label_size: int
         """
         # Mapping of keywords to setter methods
         method_map = {
@@ -105,7 +95,6 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
             "y_scale": self.set_y_scale,
             "x_lim": self.set_x_lim,
             "y_lim": self.set_y_lim,
-            "legend_label_size": self.set_legend_label_size,
         }
         for key, value in kwargs.items():
             if key in method_map:
@@ -127,79 +116,34 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
 
         self.set(**{k: v for k, v in config_mappings.items() if v is not None})
 
-    def set_legend_label_size(self, size: int = None):
-        """
-        Set the font size of the legend.
-
-        Args:
-            size(int): Font size of the legend.
-        """
-        if not self.plot_item.legend:
-            return
-        if self.config.axis.legend_label_size or size:
-            if size:
-                self.config.axis.legend_label_size = size
-                scale = (
-                    size / 9
-                )  # 9 is the default font size of the legend, so we always scale it against 9
-                self.plot_item.legend.setScale(scale)
-
-    def get_text_color(self):
-        return "#FFF" if self.figure.config.theme == "dark" else "#000"
-
-    def set_title(self, title: str, size: int = None):
+    def set_title(self, title: str):
         """
         Set the title of the plot widget.
 
         Args:
             title(str): Title of the plot widget.
-            size(int): Font size of the title.
         """
-        if self.config.axis.title_size or size:
-            if size:
-                self.config.axis.title_size = size
-            style = {"color": self.get_text_color(), "size": f"{self.config.axis.title_size}pt"}
-        else:
-            style = {}
-        self.plot_item.setTitle(title, **style)
+        self.plot_item.setTitle(title)
         self.config.axis.title = title
 
-    def set_x_label(self, label: str, size: int = None):
+    def set_x_label(self, label: str):
         """
         Set the label of the x-axis.
 
         Args:
             label(str): Label of the x-axis.
-            size(int): Font size of the label.
         """
-        if self.config.axis.x_label_size or size:
-            if size:
-                self.config.axis.x_label_size = size
-            style = {
-                "color": self.get_text_color(),
-                "font-size": f"{self.config.axis.x_label_size}pt",
-            }
-        else:
-            style = {}
-        self.plot_item.setLabel("bottom", label, **style)
+        self.plot_item.setLabel("bottom", label)
         self.config.axis.x_label = label
 
-    def set_y_label(self, label: str, size: int = None):
+    def set_y_label(self, label: str):
         """
         Set the label of the y-axis.
 
         Args:
             label(str): Label of the y-axis.
-            size(int): Font size of the label.
         """
-        if self.config.axis.y_label_size or size:
-            if size:
-                self.config.axis.y_label_size = size
-            color = self.get_text_color()
-            style = {"color": color, "font-size": f"{self.config.axis.y_label_size}pt"}
-        else:
-            style = {}
-        self.plot_item.setLabel("left", label, **style)
+        self.plot_item.setLabel("left", label)
         self.config.axis.y_label = label
 
     def set_x_scale(self, scale: Literal["linear", "log"] = "linear"):
@@ -293,6 +237,19 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
         """
         self.plot_item.setAspectLocked(lock)
 
+    def plot(self, data_x: list | np.ndarray, data_y: list | np.ndarray, **kwargs):
+        """
+        Plot custom data on the plot widget. These data are not saved in config.
+
+        Args:
+            data_x(list|np.ndarray): x-axis data
+            data_y(list|np.ndarray): y-axis data
+            **kwargs: Keyword arguments for the plot.
+        """
+        # TODO very basic so far, add more options
+        # TODO decide name of the method
+        self.plot_item.plot(data_x, data_y, **kwargs)
+
     def remove(self):
         """Remove the plot widget from the figure."""
         if self.figure is not None:

bec_widgets/widgets/figure/plots/waveform/waveform.py

@@ -35,7 +35,8 @@ class BECWaveform(BECPlotBase):
     USER_ACCESS = [
         "rpc_id",
         "config_dict",
-        "plot",
+        "add_curve_scan",
+        "add_curve_custom",
         "remove_curve",
         "scan_history",
         "curves",
@@ -53,8 +54,8 @@ class BECWaveform(BECPlotBase):
         "set_y_lim",
         "set_grid",
         "lock_aspect_ratio",
+        "plot",
         "remove",
-        "set_legend_label_size",
     ]
     scan_signal_update = pyqtSignal()
 
@@ -199,57 +200,6 @@ class BECWaveform(BECPlotBase):
         else:
             raise ValueError("Identifier must be either an integer (index) or a string (curve_id).")
 
-    def plot(
-        self,
-        x: list | np.ndarray | None = None,
-        y: list | np.ndarray | None = None,
-        x_name: str | None = None,
-        y_name: str | None = None,
-        z_name: str | None = None,
-        x_entry: str | None = None,
-        y_entry: str | None = None,
-        z_entry: str | None = None,
-        color: str | None = None,
-        color_map_z: str | None = "plasma",
-        label: str | None = None,
-        validate: bool = True,
-    ) -> BECCurve:
-        """
-        Plot a curve to the plot widget.
-        Args:
-            x(list | np.ndarray): Custom x data to plot.
-            y(list | np.ndarray): Custom y data to plot.
-            x_name(str): The name of the device for the x-axis.
-            y_name(str): The name of the device for the y-axis.
-            z_name(str): The name of the device for the z-axis.
-            x_entry(str): The name of the entry for the x-axis.
-            y_entry(str): The name of the entry for the y-axis.
-            z_entry(str): The name of the entry for the z-axis.
-            color(str): The color of the curve.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str): The label of the curve.
-            validate(bool): If True, validate the device names and entries.
-
-        Returns:
-            BECCurve: The curve object.
-        """
-
-        if x is not None and y is not None:
-            return self.add_curve_custom(x=x, y=y, label=label, color=color)
-        else:
-            return self.add_curve_scan(
-                x_name=x_name,
-                y_name=y_name,
-                z_name=z_name,
-                x_entry=x_entry,
-                y_entry=y_entry,
-                z_entry=z_entry,
-                color=color,
-                color_map_z=color_map_z,
-                label=label,
-                validate_bec=validate,
-            )
-
     def add_curve_custom(
         self,
         x: list | np.ndarray,
@@ -302,6 +252,33 @@ class BECWaveform(BECPlotBase):
         )
         return curve
 
+    def _add_curve_object(
+        self,
+        name: str,
+        source: str,
+        config: CurveConfig,
+        data: tuple[list | np.ndarray, list | np.ndarray] = None,
+    ) -> BECCurve:
+        """
+        Add a curve object to the plot widget.
+
+        Args:
+            name(str): ID of the curve.
+            source(str): Source of the curve.
+            config(CurveConfig): Configuration of the curve.
+            data(tuple[list|np.ndarray,list|np.ndarray], optional): Data (x,y) to be plotted. Defaults to None.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        curve = BECCurve(config=config, name=name, parent_item=self.plot_item)
+        self._curves_data[source][name] = curve
+        self.plot_item.addItem(curve)
+        self.config.curves[name] = curve.config
+        if data is not None:
+            curve.setData(data[0], data[1])
+        return curve
+
     def add_curve_scan(
         self,
         x_name: str,
@@ -364,7 +341,7 @@ class BECWaveform(BECPlotBase):
             parent_id=self.gui_id,
             label=label,
             color=color,
-            color_map_z=color_map_z,
+            color_map=color_map_z,
             source=curve_source,
             signals=Signal(
                 source=curve_source,
@@ -377,34 +354,6 @@ class BECWaveform(BECPlotBase):
         curve = self._add_curve_object(name=label, source=curve_source, config=curve_config)
         return curve
 
-    def _add_curve_object(
-        self,
-        name: str,
-        source: str,
-        config: CurveConfig,
-        data: tuple[list | np.ndarray, list | np.ndarray] = None,
-    ) -> BECCurve:
-        """
-        Add a curve object to the plot widget.
-
-        Args:
-            name(str): ID of the curve.
-            source(str): Source of the curve.
-            config(CurveConfig): Configuration of the curve.
-            data(tuple[list|np.ndarray,list|np.ndarray], optional): Data (x,y) to be plotted. Defaults to None.
-
-        Returns:
-            BECCurve: The curve object.
-        """
-        curve = BECCurve(config=config, name=name, parent_item=self)
-        self._curves_data[source][name] = curve
-        self.plot_item.addItem(curve)
-        self.config.curves[name] = curve.config
-        if data is not None:
-            curve.setData(data[0], data[1])
-        self.set_legend_label_size()
-        return curve
-
     def _validate_signal_entries(
         self,
         x_name: str,
@@ -565,7 +514,7 @@ class BECWaveform(BECPlotBase):
                 if curve.config.signals.z:
                     data_z = data[z_name][z_entry].val
                     color_z = self._make_z_gradient(
-                        data_z, curve.config.color_map_z
+                        data_z, curve.config.colormap
                     )  # TODO decide how to implement custom gradient
             except TypeError:
                 continue
@@ -628,6 +577,7 @@ class BECWaveform(BECPlotBase):
         Returns:
             dict | pd.DataFrame: Data of all curves in the specified format.
         """
+
         data = {}
         try:
             import pandas as pd

bec_widgets/widgets/figure/plots/waveform/waveform_curve.py

@@ -1,16 +1,12 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Literal, Optional
+from typing import Any, Literal, Optional
 
 import pyqtgraph as pg
-from pydantic import BaseModel, Field, field_validator
-from pydantic_core import PydanticCustomError
+from pydantic import BaseModel, Field
 from qtpy import QtCore
 
-from bec_widgets.utils import BECConnector, Colors, ConnectionConfig
-
-if TYPE_CHECKING:
-    from bec_widgets.widgets.figure.plots.waveform import BECWaveform1D
+from bec_widgets.utils import BECConnector, ConnectionConfig
 
 
 class SignalData(BaseModel):
@@ -21,7 +17,6 @@ class SignalData(BaseModel):
     unit: Optional[str] = None  # todo implement later
     modifier: Optional[str] = None  # todo implement later
     limits: Optional[list[float]] = None  # todo implement later
-    model_config: dict = {"validate_assignment": True}
 
 
 class Signal(BaseModel):
@@ -31,17 +26,14 @@ class Signal(BaseModel):
     x: SignalData  # TODO maybe add metadata for config gui later
     y: SignalData
     z: Optional[SignalData] = None
-    model_config: dict = {"validate_assignment": True}
 
 
 class CurveConfig(ConnectionConfig):
     parent_id: Optional[str] = Field(None, description="The parent plot of the curve.")
     label: Optional[str] = Field(None, description="The label of the curve.")
-    color: Optional[str | tuple] = Field(None, description="The color of the curve.")
+    color: Optional[Any] = Field(None, description="The color of the curve.")
     symbol: Optional[str] = Field("o", description="The symbol of the curve.")
-    symbol_color: Optional[str | tuple] = Field(
-        None, description="The color of the symbol of the curve."
-    )
+    symbol_color: Optional[str] = Field(None, description="The color of the symbol of the curve.")
     symbol_size: Optional[int] = Field(5, description="The size of the symbol of the curve.")
     pen_width: Optional[int] = Field(2, description="The width of the pen of the curve.")
     pen_style: Optional[Literal["solid", "dash", "dot", "dashdot"]] = Field(
@@ -49,15 +41,7 @@ class CurveConfig(ConnectionConfig):
     )
     source: Optional[str] = Field(None, description="The source of the curve.")
     signals: Optional[Signal] = Field(None, description="The signal of the curve.")
-    color_map_z: Optional[str] = Field(
-        "plasma", description="The colormap of the curves z gradient.", validate_default=True
-    )
-
-    model_config: dict = {"validate_assignment": True}
-
-    _validate_color_map_z = field_validator("color_map_z")(Colors.validate_color_map)
-    _validate_color = field_validator("color")(Colors.validate_color)
-    _validate_symbol_color = field_validator("symbol_color")(Colors.validate_color)
+    colormap: Optional[str] = Field("plasma", description="The colormap of the curves z gradient.")
 
 
 class BECCurve(BECConnector, pg.PlotDataItem):
@@ -68,7 +52,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         "set",
         "set_data",
         "set_color",
-        "set_color_map_z",
+        "set_colormap",
         "set_symbol",
         "set_symbol_color",
         "set_symbol_size",
@@ -82,7 +66,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         name: Optional[str] = None,
         config: Optional[CurveConfig] = None,
         gui_id: Optional[str] = None,
-        parent_item: Optional[BECWaveform1D] = None,
+        parent_item: Optional[pg.PlotItem] = None,
         **kwargs,
     ):
         if config is None:
@@ -144,7 +128,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         # Mapping of keywords to setter methods
         method_map = {
             "color": self.set_color,
-            "color_map_z": self.set_color_map_z,
+            "colormap": self.set_colormap,
             "symbol": self.set_symbol,
             "symbol_color": self.set_symbol_color,
             "symbol_size": self.set_symbol_size,
@@ -219,16 +203,14 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         self.config.pen_style = pen_style
         self.apply_config()
 
-    def set_color_map_z(self, colormap: str):
+    def set_colormap(self, colormap: str):
         """
         Set the colormap for the scatter plot z gradient.
 
         Args:
             colormap(str): Colormap for the scatter plot.
         """
-        self.config.color_map_z = colormap
-        self.apply_config()
-        self.parent_item.scan_history(-1)
+        self.config.colormap = colormap
 
     def get_data(self) -> tuple[np.ndarray, np.ndarray]:
         """

bec_widgets/widgets/jupyter_console/jupyter_console.py

@@ -1,72 +0,0 @@
-from bec_ipython_client.main import BECIPythonClient
-from qtconsole.inprocess import QtInProcessKernelManager
-from qtconsole.manager import QtKernelManager
-from qtconsole.rich_jupyter_widget import RichJupyterWidget
-from qtpy.QtWidgets import QApplication, QMainWindow
-
-
-class BECJupyterConsole(RichJupyterWidget):  # pragma: no cover:
-    def __init__(self, inprocess: bool = False):
-        super().__init__()
-
-        self.inprocess = None
-
-        self.kernel_manager, self.kernel_client = self._init_kernel(inprocess=inprocess)
-        self.set_default_style("linux")
-        self._init_bec()
-
-    def _init_kernel(self, inprocess: bool = False, kernel_name: str = "python3"):
-        self.inprocess = inprocess
-        if inprocess is True:
-            print("starting inprocess kernel")
-            kernel_manager = QtInProcessKernelManager()
-        else:
-            kernel_manager = QtKernelManager(kernel_name=kernel_name)
-        kernel_manager.start_kernel()
-        kernel_client = kernel_manager.client()
-        kernel_client.start_channels()
-        return kernel_manager, kernel_client
-
-    def _init_bec(self):
-        if self.inprocess is True:
-            self._init_bec_inprocess()
-        else:
-            self._init_bec_kernel()
-
-    def _init_bec_inprocess(self):
-        self.client = BECIPythonClient()
-        self.client.start()
-
-        self.kernel_manager.kernel.shell.push(
-            {
-                "bec": self.client,
-                "dev": self.client.device_manager.devices,
-                "scans": self.client.scans,
-            }
-        )
-
-    def _init_bec_kernel(self):
-        self.execute(
-            """
-            from bec_ipython_client.main import BECIPythonClient
-            bec = BECIPythonClient()
-            bec.start()
-            dev = bec.device_manager.devices if bec else None
-            scans = bec.scans if bec else None
-            """
-        )
-
-    def shutdown_kernel(self):
-        self.kernel_client.stop_channels()
-        self.kernel_manager.shutdown_kernel()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    app = QApplication(sys.argv)
-    win = QMainWindow()
-    win.setCentralWidget(BECJupyterConsole(True))
-    win.show()
-
-    sys.exit(app.exec_())

bec_widgets/widgets/motor_control/movement_absolute/movement_absolute.py

@@ -1,12 +1,12 @@
 import os
 
+from qtpy.QtWidgets import QWidget
 from qtpy import uic
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
-from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils import UILoader
-from bec_widgets.widgets.motor_control.motor_control import MotorControlErrors, MotorControlWidget
+from bec_widgets.widgets.motor_control.motor_control import MotorControlWidget, MotorControlErrors
 
 
 class MotorControlAbsolute(MotorControlWidget):

bec_widgets/widgets/motor_control/movement_relative/movement_relative.py

@@ -7,7 +7,6 @@ from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtGui import QKeySequence
 from qtpy.QtWidgets import QDoubleSpinBox, QShortcut, QWidget
 
-from bec_widgets.utils import UILoader
 from bec_widgets.widgets.motor_control.motor_control import MotorControlWidget
 
 
@@ -28,7 +27,7 @@ class MotorControlRelative(MotorControlWidget):
         """Load the UI from the .ui file."""
         # Loading UI
         current_path = os.path.dirname(__file__)
-        self.ui = UILoader().load_ui(os.path.join(current_path, "movement_relative.ui"), self)
+        uic.loadUi(os.path.join(current_path, "movement_relative.ui"), self)
 
     def _init_ui(self):
         """Initialize the UI."""
@@ -52,15 +51,15 @@ class MotorControlRelative(MotorControlWidget):
 
         # Update step precision
         self.precision = self.config["motor_control"]["precision"]
-        self.ui.spinBox_precision.setValue(self.precision)
+        self.spinBox_precision.setValue(self.precision)
 
         # Update step sizes
-        self.ui.spinBox_step_x.setValue(self.config["motor_control"]["step_size_x"])
-        self.ui.spinBox_step_y.setValue(self.config["motor_control"]["step_size_y"])
+        self.spinBox_step_x.setValue(self.config["motor_control"]["step_size_x"])
+        self.spinBox_step_y.setValue(self.config["motor_control"]["step_size_y"])
 
         # Checkboxes for keyboard shortcuts and x/y step size link
-        self.ui.checkBox_same_xy.setChecked(self.config["motor_control"]["step_x_y_same"])
-        self.ui.checkBox_enableArrows.setChecked(self.config["motor_control"]["move_with_arrows"])
+        self.checkBox_same_xy.setChecked(self.config["motor_control"]["step_x_y_same"])
+        self.checkBox_enableArrows.setChecked(self.config["motor_control"]["move_with_arrows"])
 
         self._init_ui()
 
@@ -68,32 +67,30 @@ class MotorControlRelative(MotorControlWidget):
         """Initialize the motor control elements"""
 
         # Connect checkbox and spinBoxes
-        self.ui.checkBox_same_xy.stateChanged.connect(self._sync_step_sizes)
-        self.ui.spinBox_step_x.valueChanged.connect(self._update_step_size_x)
-        self.ui.spinBox_step_y.valueChanged.connect(self._update_step_size_y)
+        self.checkBox_same_xy.stateChanged.connect(self._sync_step_sizes)
+        self.spinBox_step_x.valueChanged.connect(self._update_step_size_x)
+        self.spinBox_step_y.valueChanged.connect(self._update_step_size_y)
 
-        self.ui.toolButton_right.clicked.connect(
+        self.toolButton_right.clicked.connect(
             lambda: self.move_motor_relative(self.motor_x, "x", 1)
         )
-        self.ui.toolButton_left.clicked.connect(
+        self.toolButton_left.clicked.connect(
             lambda: self.move_motor_relative(self.motor_x, "x", -1)
         )
-        self.ui.toolButton_up.clicked.connect(
-            lambda: self.move_motor_relative(self.motor_y, "y", 1)
-        )
-        self.ui.toolButton_down.clicked.connect(
+        self.toolButton_up.clicked.connect(lambda: self.move_motor_relative(self.motor_y, "y", 1))
+        self.toolButton_down.clicked.connect(
             lambda: self.move_motor_relative(self.motor_y, "y", -1)
         )
 
         # Switch between key shortcuts active
-        self.ui.checkBox_enableArrows.stateChanged.connect(self._update_arrow_key_shortcuts)
+        self.checkBox_enableArrows.stateChanged.connect(self._update_arrow_key_shortcuts)
         self._update_arrow_key_shortcuts()
 
         # Enable/Disable GUI
         self.motor_thread.lock_gui.connect(self.enable_motor_controls)
 
         # Precision update
-        self.ui.spinBox_precision.valueChanged.connect(lambda x: self._update_precision(x))
+        self.spinBox_precision.valueChanged.connect(lambda x: self._update_precision(x))
 
         # Error messages
         self.motor_thread.motor_error.connect(
@@ -101,7 +98,7 @@ class MotorControlRelative(MotorControlWidget):
         )
 
         # Stop Button
-        self.ui.pushButton_stop.clicked.connect(self.motor_thread.stop_movement)
+        self.pushButton_stop.clicked.connect(self.motor_thread.stop_movement)
 
     def _init_keyboard_shortcuts(self) -> None:
         """Initialize the keyboard shortcuts"""
@@ -110,42 +107,42 @@ class MotorControlRelative(MotorControlWidget):
         increase_x_shortcut = QShortcut(QKeySequence("Ctrl+A"), self)
         decrease_x_shortcut = QShortcut(QKeySequence("Ctrl+Z"), self)
         increase_x_shortcut.activated.connect(
-            lambda: self._change_step_size(self.ui.spinBox_step_x, 2)
+            lambda: self._change_step_size(self.spinBox_step_x, 2)
         )
         decrease_x_shortcut.activated.connect(
-            lambda: self._change_step_size(self.ui.spinBox_step_x, 0.5)
+            lambda: self._change_step_size(self.spinBox_step_x, 0.5)
         )
-        self.ui.spinBox_step_x.setToolTip("Increase step size: Ctrl+A\nDecrease step size: Ctrl+Z")
+        self.spinBox_step_x.setToolTip("Increase step size: Ctrl+A\nDecrease step size: Ctrl+Z")
 
         # Increase/decrease step size for Y motor
         increase_y_shortcut = QShortcut(QKeySequence("Alt+A"), self)
         decrease_y_shortcut = QShortcut(QKeySequence("Alt+Z"), self)
         increase_y_shortcut.activated.connect(
-            lambda: self._change_step_size(self.ui.spinBox_step_y, 2)
+            lambda: self._change_step_size(self.spinBox_step_y, 2)
         )
         decrease_y_shortcut.activated.connect(
-            lambda: self._change_step_size(self.ui.spinBox_step_y, 0.5)
+            lambda: self._change_step_size(self.spinBox_step_y, 0.5)
         )
-        self.ui.spinBox_step_y.setToolTip("Increase step size: Alt+A\nDecrease step size: Alt+Z")
+        self.spinBox_step_y.setToolTip("Increase step size: Alt+A\nDecrease step size: Alt+Z")
 
         # Stop Button
-        self.ui.pushButton_stop.setShortcut("Ctrl+X")
-        self.ui.pushButton_stop.setToolTip("Ctrl+X")
+        self.pushButton_stop.setShortcut("Ctrl+X")
+        self.pushButton_stop.setToolTip("Ctrl+X")
 
     def _update_arrow_key_shortcuts(self) -> None:
         """Update the arrow key shortcuts based on the checkbox state."""
-        if self.ui.checkBox_enableArrows.isChecked():
+        if self.checkBox_enableArrows.isChecked():
             # Set the arrow key shortcuts for motor movement
-            self.ui.toolButton_right.setShortcut(Qt.Key_Right)
-            self.ui.toolButton_left.setShortcut(Qt.Key_Left)
-            self.ui.toolButton_up.setShortcut(Qt.Key_Up)
-            self.ui.toolButton_down.setShortcut(Qt.Key_Down)
+            self.toolButton_right.setShortcut(Qt.Key_Right)
+            self.toolButton_left.setShortcut(Qt.Key_Left)
+            self.toolButton_up.setShortcut(Qt.Key_Up)
+            self.toolButton_down.setShortcut(Qt.Key_Down)
         else:
             # Clear the shortcuts
-            self.ui.toolButton_right.setShortcut("")
-            self.ui.toolButton_left.setShortcut("")
-            self.ui.toolButton_up.setShortcut("")
-            self.ui.toolButton_down.setShortcut("")
+            self.toolButton_right.setShortcut("")
+            self.toolButton_left.setShortcut("")
+            self.toolButton_up.setShortcut("")
+            self.toolButton_down.setShortcut("")
 
     def _update_precision(self, precision: int) -> None:
         """
@@ -153,8 +150,8 @@ class MotorControlRelative(MotorControlWidget):
         Args:
             precision(int): Precision of the coordinates.
         """
-        self.ui.spinBox_step_x.setDecimals(precision)
-        self.ui.spinBox_step_y.setDecimals(precision)
+        self.spinBox_step_x.setDecimals(precision)
+        self.spinBox_step_y.setDecimals(precision)
         self.precision_signal.emit(precision)
 
     def _change_step_size(self, spinBox: QDoubleSpinBox, factor: float) -> None:
@@ -170,21 +167,21 @@ class MotorControlRelative(MotorControlWidget):
 
     def _sync_step_sizes(self):
         """Sync step sizes based on checkbox state."""
-        if self.ui.checkBox_same_xy.isChecked():
-            value = self.ui.spinBox_step_x.value()
-            self.ui.spinBox_step_y.setValue(value)
+        if self.checkBox_same_xy.isChecked():
+            value = self.spinBox_step_x.value()
+            self.spinBox_step_y.setValue(value)
 
     def _update_step_size_x(self):
         """Update step size for x if checkbox is checked."""
-        if self.ui.checkBox_same_xy.isChecked():
-            value = self.ui.spinBox_step_x.value()
-            self.ui.spinBox_step_y.setValue(value)
+        if self.checkBox_same_xy.isChecked():
+            value = self.spinBox_step_x.value()
+            self.spinBox_step_y.setValue(value)
 
     def _update_step_size_y(self):
         """Update step size for y if checkbox is checked."""
-        if self.ui.checkBox_same_xy.isChecked():
-            value = self.ui.spinBox_step_y.value()
-            self.ui.spinBox_step_x.setValue(value)
+        if self.checkBox_same_xy.isChecked():
+            value = self.spinBox_step_y.value()
+            self.spinBox_step_x.setValue(value)
 
     @pyqtSlot(str, str)
     def change_motors(self, motor_x: str, motor_y: str):
@@ -209,11 +206,11 @@ class MotorControlRelative(MotorControlWidget):
         """
 
         # Disable or enable all controls within the motorControl_absolute group box
-        for widget in self.ui.motorControl.findChildren(QWidget):
+        for widget in self.motorControl.findChildren(QWidget):
             widget.setEnabled(disable)
 
         # Enable the pushButton_stop if the motor is moving
-        self.ui.pushButton_stop.setEnabled(True)
+        self.pushButton_stop.setEnabled(True)
 
     def move_motor_relative(self, motor, axis: str, direction: int) -> None:
         """
@@ -224,7 +221,7 @@ class MotorControlRelative(MotorControlWidget):
             direction(int): Direction to move. 1 for positive, -1 for negative.
         """
         if axis == "x":
-            step = direction * self.ui.spinBox_step_x.value()
+            step = direction * self.spinBox_step_x.value()
         elif axis == "y":
-            step = direction * self.ui.spinBox_step_y.value()
+            step = direction * self.spinBox_step_y.value()
         self.motor_thread.move_relative(motor, step)

bec_widgets/widgets/motor_control/selection/motor_selection_launch.py

@@ -0,0 +1,30 @@
+import qdarktheme
+from qtpy.QtWidgets import QApplication
+
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.widgets.motor_control.selection.selection import MotorControlSelection
+
+CONFIG_DEFAULT = {
+    "motor_control": {
+        "motor_x": "samx",
+        "motor_y": "samy",
+        "step_size_x": 3,
+        "step_size_y": 5,
+        "precision": 4,
+        "step_x_y_same": False,
+        "move_with_arrows": False,
+    }
+}
+if __name__ == "__main__":
+    bec_dispatcher = BECDispatcher()
+    # BECclient global variables
+    client = bec_dispatcher.client
+    client.start()
+
+    app = QApplication([])
+    qdarktheme.setup_theme("auto")
+    motor_control = MotorControlSelection(client=client, config=CONFIG_DEFAULT)
+
+    window = motor_control
+    window.show()
+    app.exec()

bec_widgets/widgets/motor_control/selection/registerselection.py

@@ -0,0 +1,13 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from selection import MotorControlSelection
+from selectionplugin import MotorControlSelectionPlugin
+
+from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+# Set PYSIDE_DESIGNER_PLUGINS to point to this directory and load the plugin
+
+
+if __name__ == "__main__":
+    QPyDesignerCustomWidgetCollection.addCustomWidget(MotorControlSelectionPlugin())

bec_widgets/widgets/motor_control/selection/selection.pyproject

@@ -0,0 +1,4 @@
+{
+    "files": ["selection.py", "motor_selection_launch.py", "registertictactoe.py", "tictactoeplugin.py",
+    "tictactoetaskmenu.py"]
+}

bec_widgets/widgets/motor_control/selection/selectionplugin.py

@@ -0,0 +1,58 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from selection import MotorControlSelection
+
+from PySide6.QtGui import QIcon
+from PySide6.QtDesigner import QDesignerCustomWidgetInterface
+
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='MotorControlSelection' name='selection'>
+    </widget>
+</ui>
+"""
+
+
+class MotorControlSelectionPlugin(QDesignerCustomWidgetInterface):
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = MotorControlSelection(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return QIcon()
+
+    def includeFile(self):
+        return "selection"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+        # manager = form_editor.extensionManager()
+        # iid = TicTacToeTaskMenuFactory.task_menu_iid()
+        # manager.registerExtensions(TicTacToeTaskMenuFactory(manager), iid)
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "MotorControlSelection"
+
+    def toolTip(self):
+        return "MotorControl Selection Example for BEC Widgets"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/spiral_progress_bar/ring.py

@@ -13,21 +13,20 @@ from bec_widgets.utils import BECConnector, ConnectionConfig
 class RingConnections(BaseModel):
     slot: Literal["on_scan_progress", "on_device_readback"] = None
     endpoint: EndpointInfo | str = None
-    model_config: dict = {"validate_assignment": True}
 
     @field_validator("endpoint")
     def validate_endpoint(cls, v, values):
         slot = values.data["slot"]
-        v = v.endpoint if isinstance(v, EndpointInfo) else v
+        endpoint = v.endpoint if isinstance(v, EndpointInfo) else v
         if slot == "on_scan_progress":
-            if v != "scans/scan_progress":
+            if endpoint != "scans/scan_progress":
                 raise PydanticCustomError(
                     "unsupported endpoint",
                     "For slot 'on_scan_progress', endpoint must be MessageEndpoint.scan_progress or 'scans/scan_progress'.",
                     {"wrong_value": v},
                 )
         elif slot == "on_device_readback":
-            if not v.startswith("internal/devices/readback/"):
+            if not endpoint.startswith("internal/devices/readback/"):
                 raise PydanticCustomError(
                     "unsupported endpoint",
                     "For slot 'on_device_readback', endpoint must be MessageEndpoint.device_readback(device) or 'internal/devices/readback/{device}'.",
@@ -37,7 +36,6 @@ class RingConnections(BaseModel):
 
 
 class RingConfig(ConnectionConfig):
-    value: int | float | None = Field(0, description="Value for the progress bars.")
     direction: int | None = Field(
         -1, description="Direction of the progress bars. -1 for clockwise, 1 for counter-clockwise."
     )
@@ -50,14 +48,14 @@ class RingConfig(ConnectionConfig):
         description="Background color for the progress bars. Can be tuple (R, G, B, A) or string HEX Code.",
     )
     index: int | None = Field(0, description="Index of the progress bar. 0 is outer ring.")
-    line_width: int | None = Field(10, description="Line widths for the progress bars.")
+    line_width: int | None = Field(5, description="Line widths for the progress bars.")
     start_position: int | None = Field(
         90,
         description="Start position for the progress bars in degrees. Default is 90 degrees - corespons to "
         "the top of the ring.",
     )
-    min_value: int | float | None = Field(0, description="Minimum value for the progress bars.")
-    max_value: int | float | None = Field(100, description="Maximum value for the progress bars.")
+    min_value: int | None = Field(0, description="Minimum value for the progress bars.")
+    max_value: int | None = Field(100, description="Maximum value for the progress bars.")
     precision: int | None = Field(3, description="Precision for the progress bars.")
     update_behaviour: Literal["manual", "auto"] | None = Field(
         "auto", description="Update behaviour for the progress bars."
@@ -78,7 +76,7 @@ class Ring(BECConnector):
         "set_line_width",
         "set_min_max_values",
         "set_start_angle",
-        "set_update",
+        "set_connections",
         "reset_connection",
     ]
 
@@ -104,6 +102,7 @@ class Ring(BECConnector):
         self.background_color = None
         self.start_position = None
         self.config = config
+        self.value = 0
         self.RID = None
         self._init_config_params()
 
@@ -115,75 +114,31 @@ class Ring(BECConnector):
             self.set_connections(self.config.connections.slot, self.config.connections.endpoint)
 
     def set_value(self, value: int | float):
-        """
-        Set the value for the ring widget
-
-        Args:
-            value(int | float): Value for the ring widget
-        """
-        self.config.value = round(
-            float(max(self.config.min_value, min(self.config.max_value, value))),
-            self.config.precision,
+        self.value = round(
+            max(self.config.min_value, min(self.config.max_value, value)), self.config.precision
         )
 
     def set_color(self, color: str | tuple):
-        """
-        Set the color for the ring widget
-
-        Args:
-            color(str | tuple): Color for the ring widget. Can be HEX code or tuple (R, G, B, A).
-        """
         self.config.color = color
         self.color = self.convert_color(color)
 
     def set_background(self, color: str | tuple):
-        """
-        Set the background color for the ring widget
-
-        Args:
-            color(str | tuple): Background color for the ring widget. Can be HEX code or tuple (R, G, B, A).
-        """
         self.config.background_color = color
         self.color = self.convert_color(color)
 
     def set_line_width(self, width: int):
-        """
-        Set the line width for the ring widget
-
-        Args:
-            width(int): Line width for the ring widget
-        """
         self.config.line_width = width
 
-    def set_min_max_values(self, min_value: int | float, max_value: int | float):
-        """
-        Set the min and max values for the ring widget.
-
-        Args:
-            min_value(int | float): Minimum value for the ring widget
-            max_value(int | float): Maximum value for the ring widget
-        """
+    def set_min_max_values(self, min_value: int, max_value: int):
         self.config.min_value = min_value
         self.config.max_value = max_value
 
     def set_start_angle(self, start_angle: int):
-        """
-        Set the start angle for the ring widget
-
-        Args:
-            start_angle(int): Start angle for the ring widget in degrees
-        """
         self.config.start_position = start_angle
         self.start_position = start_angle * 16
 
     @staticmethod
     def convert_color(color):
-        """
-        Convert the color to QColor
-
-        Args:
-            color(str | tuple): Color for the ring widget. Can be HEX code or tuple (R, G, B, A).
-        """
         converted_color = None
         if isinstance(color, str):
             converted_color = QtGui.QColor(color)
@@ -191,39 +146,7 @@ class Ring(BECConnector):
             converted_color = QtGui.QColor(*color)
         return converted_color
 
-    def set_update(self, mode: Literal["manual", "scan", "device"], device: str = None):
-        """
-        Set the update mode for the ring widget.
-        Modes:
-        - "manual": Manual update mode, the value is set by the user.
-        - "scan": Update mode for the scan progress. The value is updated by the current scan progress.
-        - "device": Update mode for the device readback. The value is updated by the device readback. Take into account that user has to set the device name and limits.
-
-        Args:
-            mode(str): Update mode for the ring widget. Can be "manual", "scan" or "device"
-            device(str): Device name for the device readback mode, only used when mode is "device"
-        """
-        if mode == "manual":
-            self.bec_dispatcher.disconnect_slot(
-                getattr(self, self.config.connections.slot), self.config.connections.endpoint
-            )
-            self.config.connections.slot = None
-            self.config.connections.endpoint = None
-        elif mode == "scan":
-            self.set_connections("on_scan_progress", "scans/scan_progress")
-        elif mode == "device":
-            self.set_connections("on_device_readback", f"internal/devices/readback/{device}")
-
-        self.parent_progress_widget.enable_auto_updates(False)
-
     def set_connections(self, slot: str, endpoint: str | EndpointInfo):
-        """
-        Set the connections for the ring widget
-
-        Args:
-            slot(str): Slot for the ring widget update. Can be "on_scan_progress" or "on_device_readback".
-            endpoint(str | EndpointInfo): Endpoint for the ring widget update. Endpoint has to match the slot type.
-        """
         if self.config.connections.endpoint == endpoint and self.config.connections.slot == slot:
             return
         else:
@@ -234,22 +157,12 @@ class Ring(BECConnector):
             self.bec_dispatcher.connect_slot(getattr(self, slot), endpoint)
 
     def reset_connection(self):
-        """
-        Reset the connections for the ring widget. Disconnect the current slot and endpoint.
-        """
         self.bec_dispatcher.disconnect_slot(
             self.config.connections.slot, self.config.connections.endpoint
         )
         self.config.connections = RingConnections()
 
     def on_scan_progress(self, msg, meta):
-        """
-        Update the ring widget with the scan progress.
-
-        Args:
-            msg(dict): Message with the scan progress
-            meta(dict): Metadata for the message
-        """
         current_RID = meta.get("RID", None)
         if current_RID != self.RID:
             self.set_min_max_values(0, msg.get("max_value", 100))
@@ -257,13 +170,6 @@ class Ring(BECConnector):
         self.parent_progress_widget.update()
 
     def on_device_readback(self, msg, meta):
-        """
-        Update the ring widget with the device readback.
-
-        Args:
-            msg(dict): Message with the device readback
-            meta(dict): Metadata for the message
-        """
         if isinstance(self.config.connections.endpoint, EndpointInfo):
             endpoint = self.config.connections.endpoint.endpoint
         else:

bec_widgets/widgets/spiral_progress_bar/spiral_progress_bar.py

@@ -15,9 +15,7 @@ from bec_widgets.widgets.spiral_progress_bar.ring import Ring, RingConfig
 
 
 class SpiralProgressBarConfig(ConnectionConfig):
-    color_map: Optional[str] = Field(
-        "magma", description="Color scheme for the progress bars.", validate_default=True
-    )
+    color_map: str | None = Field("magma", description="Color scheme for the progress bars.")
     min_number_of_bars: int | None = Field(
         1, description="Minimum number of progress bars to display."
     )
@@ -25,7 +23,7 @@ class SpiralProgressBarConfig(ConnectionConfig):
         10, description="Maximum number of progress bars to display."
     )
     num_bars: int | None = Field(1, description="Number of progress bars to display.")
-    gap: int | None = Field(20, description="Gap between progress bars.")
+    gap: int | None = Field(10, description="Gap between progress bars.")
     auto_updates: bool | None = Field(
         True, description="Enable or disable updates based on scan queue status."
     )
@@ -61,7 +59,16 @@ class SpiralProgressBarConfig(ConnectionConfig):
                 )
         return v
 
-    _validate_colormap = field_validator("color_map")(Colors.validate_color_map)
+    @field_validator("color_map")
+    def validate_color_map(cls, v, values):
+        if v is not None and v != "":
+            if v not in pg.colormap.listMaps():
+                raise PydanticCustomError(
+                    "unsupported colormap",
+                    f"Colormap '{v}' not found in the current installation of pyqtgraph",
+                    {"wrong_value": v},
+                )
+        return v
 
 
 class SpiralProgressBar(BECConnector, QWidget):
@@ -108,10 +115,11 @@ class SpiralProgressBar(BECConnector, QWidget):
         self.entry_validator = EntryValidator(self.dev)
 
         self.RID = None
+        self.values = None
 
         # For updating bar behaviour
         self._auto_updates = True
-        self._rings = None
+        self._rings = []
 
         if num_bars is not None:
             self.config.num_bars = max(
@@ -179,22 +187,13 @@ class SpiralProgressBar(BECConnector, QWidget):
             Ring: Ring object.
         """
         if self.config.num_bars < self.config.max_number_of_bars:
-            ring_index = self.config.num_bars
-            ring_config = RingConfig(
-                widget_class="Ring",
-                index=ring_index,
-                start_positions=90 * 16,
-                directions=-1,
-                **kwargs,
-            )
-            ring = Ring(parent_progress_widget=self, config=ring_config)
+            ring = Ring(parent_progress_widget=self, **kwargs)
+            ring.config.index = self.config.num_bars
             self.config.num_bars += 1
             self._rings.append(ring)
             self.config.rings.append(ring.config)
             if self.config.color_map:
                 self.set_colors_from_map(self.config.color_map)
-            base_line_width = self._rings[ring.config.index].config.line_width
-            self.set_line_widths(base_line_width, ring.config.index)
             self.update()
             return ring
 
@@ -213,7 +212,6 @@ class SpiralProgressBar(BECConnector, QWidget):
         self._reindex_rings()
         if self.config.color_map:
             self.set_colors_from_map(self.config.color_map)
-        del ring
         self.update()
 
     def _reindex_rings(self):
@@ -272,30 +270,9 @@ class SpiralProgressBar(BECConnector, QWidget):
         num_bars = max(
             self.config.min_number_of_bars, min(num_bars, self.config.max_number_of_bars)
         )
-        current_num_bars = self.config.num_bars
-
-        if num_bars > current_num_bars:
-            for i in range(current_num_bars, num_bars):
-                new_ring_config = RingConfig(
-                    widget_class="Ring", index=i, start_positions=90 * 16, directions=-1
-                )
-                self.config.rings.append(new_ring_config)
-                new_ring = Ring(parent_progress_widget=self, config=new_ring_config)
-                self._rings.append(new_ring)
-
-        elif num_bars < current_num_bars:
-            for i in range(current_num_bars - 1, num_bars - 1, -1):
-                self.remove_ring(i)
-
-        self.config.num_bars = num_bars
-
-        if self.config.color_map:
-            self.set_colors_from_map(self.config.color_map)
-
-        base_line_width = self._rings[0].config.line_width
-        self.set_line_widths(base_line_width)
-
-        self.update()
+        if num_bars != self.config.num_bars:
+            self.config.num_bars = num_bars
+            self.initialize_bars()
 
     def set_value(self, values: int | list, ring_index: int = None):
         """
@@ -361,6 +338,7 @@ class SpiralProgressBar(BECConnector, QWidget):
             colors = self._adjust_list_to_bars(colors)
             for ring, color in zip(self._rings, colors):
                 ring.set_color(color)
+            self.config.color_map = None
         self.update()
 
     def set_line_widths(self, widths: int | list[int], bar_index: int = None):
@@ -456,13 +434,6 @@ class SpiralProgressBar(BECConnector, QWidget):
 
     @Slot(dict, dict)
     def on_scan_queue_status(self, msg, meta):
-        """
-        Slot to handle scan queue status messages. Decides what update to perform based on the scan queue status.
-
-        Args:
-            msg(dict): Message from the BEC.
-            meta(dict): Metadata from the BEC.
-        """
         primary_queue = msg.get("queue").get("primary")
         info = primary_queue.get("info", None)
 
@@ -473,6 +444,8 @@ class SpiralProgressBar(BECConnector, QWidget):
                 if report_instructions:
                     instruction_type = list(report_instructions[0].keys())[0]
                     if instruction_type == "scan_progress":
+                        if self.config.num_bars != 1:
+                            self.set_number_of_bars(1)
                         self._hook_scan_progress(ring_index=0)
                     elif instruction_type == "readback":
                         devices = report_instructions[0].get("readback").get("devices")
@@ -489,12 +462,6 @@ class SpiralProgressBar(BECConnector, QWidget):
                     #     print("hook device_progress")
 
     def _hook_scan_progress(self, ring_index: int = None):
-        """
-        Hook the scan progress to the progress bars.
-
-        Args:
-            ring_index(int): Index of the progress bar to hook the scan progress to.
-        """
         if ring_index is not None:
             ring = self._find_ring_by_index(ring_index)
         else:
@@ -506,15 +473,6 @@ class SpiralProgressBar(BECConnector, QWidget):
             ring.set_connections("on_scan_progress", MessageEndpoints.scan_progress())
 
     def _hook_readback(self, bar_index: int, device: str, min: float | int, max: float | int):
-        """
-        Hook the readback values to the progress bars.
-
-        Args:
-            bar_index(int): Index of the progress bar to hook the readback values to.
-            device(str): Device to readback values from.
-            min(float|int): Minimum value for the progress bar.
-            max(float|int): Maximum value for the progress bar.
-        """
         ring = self._find_ring_by_index(bar_index)
         ring.set_min_max_values(min, max)
         endpoint = MessageEndpoints.device_readback(device)
@@ -586,7 +544,7 @@ class SpiralProgressBar(BECConnector, QWidget):
             pen = QtGui.QPen(ring.color, ring.config.line_width, QtCore.Qt.SolidLine)
             pen.setCapStyle(QtCore.Qt.RoundCap)
             painter.setPen(pen)
-            proportion = (ring.config.value - ring.config.min_value) / (
+            proportion = (ring.value - ring.config.min_value) / (
                 (ring.config.max_value - ring.config.min_value) + 1e-3
             )
             angle = int(proportion * 360 * 16 * ring.config.direction)

bec_widgets/widgets/text_box/text_box.py

@@ -1,127 +0,0 @@
-import re
-
-from pydantic import Field, field_validator
-from qtpy.QtWidgets import QTextEdit
-
-from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
-from bec_widgets.utils.colors import Colors
-
-
-class TextBoxConfig(ConnectionConfig):
-
-    theme: str = Field("dark", description="The theme of the figure widget.")
-    font_color: str = Field("#FFF", description="The font color of the text")
-    background_color: str = Field("#000", description="The background color of the widget.")
-    font_size: int = Field(16, description="The font size of the text in the widget.")
-    text: str = Field("", description="The text to display in the widget.")
-
-    @classmethod
-    @field_validator("theme")
-    def validate_theme(cls, v):
-        """Validate the theme of the figure widget."""
-        if v not in ["dark", "light"]:
-            raise ValueError("Theme must be either 'dark' or 'light'")
-        return v
-
-    _validate_font_color = field_validator("font_color")(Colors.validate_color)
-    _validate_background_color = field_validator("background_color")(Colors.validate_color)
-
-
-class TextBox(BECConnector, QTextEdit):
-
-    USER_ACCESS = ["set_color", "set_text", "set_font_size"]
-
-    def __init__(self, text: str = "", parent=None, client=None, config=None, gui_id=None):
-        if config is None:
-            config = TextBoxConfig(widget_class=self.__class__.__name__)
-        else:
-            if isinstance(config, dict):
-                config = TextBoxConfig(**config)
-            self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QTextEdit.__init__(self, parent=parent)
-
-        self.config = config
-        self.setReadOnly(True)
-        self.setGeometry(self.rect())
-        self.set_color(self.config.background_color, self.config.font_color)
-        if not text:
-            text = "<h1>Welcome to the BEC Widget TextBox</h1><p>A widget that allows user to display text in plain and HTML format.</p><p>This is an example of displaying HTML text.</p>"
-        self.set_text(text)
-
-    def change_theme(self) -> None:
-        """
-        Change the theme of the figure widget.
-        """
-        if self.config.theme == "dark":
-            theme = "light"
-            font_color = "#000"
-            background_color = "#FFF"
-        else:
-            theme = "dark"
-            font_color = "#FFF"
-            background_color = "#000"
-        self.config.theme = theme
-        self.set_color(background_color, font_color)
-
-    def set_color(self, background_color: str, font_color: str) -> None:
-        """Set the background color of the widget.
-
-        Args:
-            background_color (str): The color to set the background in HEX.
-            font_color (str): The color to set the font in HEX.
-
-        """
-        self.config.background_color = background_color
-        self.config.font_color = font_color
-        self._update_stylesheet()
-
-    def set_font_size(self, size: int) -> None:
-        """Set the font size of the text in the widget.
-
-        Args:
-            size (int): The font size to set.
-        """
-        self.config.font_size = size
-        self._update_stylesheet()
-
-    def _update_stylesheet(self):
-        """Update the stylesheet of the widget."""
-        self.setStyleSheet(
-            f"background-color: {self.config.background_color}; color: {self.config.font_color}; font-size: {self.config.font_size}px"
-        )
-
-    def set_text(self, text: str) -> None:
-        """Set the text of the widget.
-
-        Args:
-            text (str): The text to set.
-        """
-        if self.is_html(text):
-            self.setHtml(text)
-        else:
-            self.setPlainText(text)
-        self.config.text = text
-
-    def is_html(self, text: str) -> bool:
-        """Check if the text contains HTML tags.
-
-        Args:
-            text (str): The text to check.
-
-        Returns:
-            bool: True if the text contains HTML tags, False otherwise.
-        """
-        return bool(re.search(r"<[a-zA-Z/][^>]*>", text))
-
-
-if __name__ == "__main__":
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-
-    widget = TextBox()
-    widget.show()
-    sys.exit(app.exec())

bec_widgets/widgets/website/website.py

@@ -1,65 +0,0 @@
-from qtpy.QtCore import QUrl
-from qtpy.QtWebEngineWidgets import QWebEngineView
-from qtpy.QtWidgets import QApplication
-
-from bec_widgets.utils import BECConnector
-
-
-class WebsiteWidget(BECConnector, QWebEngineView):
-    """
-    A simple widget to display a website
-    """
-
-    USER_ACCESS = ["set_url", "get_url", "reload", "back", "forward"]
-
-    def __init__(self, url: str = None, parent=None, config=None, client=None, gui_id=None):
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QWebEngineView.__init__(self, parent=parent)
-        self.set_url(url)
-
-    def set_url(self, url: str) -> None:
-        """
-        Set the url of the website widget
-
-        Args:
-            url (str): The url to set
-        """
-        if not url:
-            return
-        self.setUrl(QUrl(url))
-
-    def get_url(self) -> str:
-        """
-        Get the current url of the website widget
-
-        Returns:
-            str: The current url
-        """
-        return self.url().toString()
-
-    def reload(self):
-        """
-        Reload the website
-        """
-        QWebEngineView.reload(self)
-
-    def back(self):
-        """
-        Go back in the history
-        """
-        QWebEngineView.back(self)
-
-    def forward(self):
-        """
-        Go forward in the history
-        """
-        QWebEngineView.forward(self)
-
-
-if __name__ == "__main__":
-    import sys
-
-    app = QApplication(sys.argv)
-    mainWin = WebsiteWidget("https://scilog.psi.ch")
-    mainWin.show()
-    sys.exit(app.exec())

docs/assets/apps_48dp.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" height="48px" viewBox="0 0 24 24" width="48px" fill="#000000"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M4 8h4V4H4v4zm6 12h4v-4h-4v4zm-6 0h4v-4H4v4zm0-6h4v-4H4v4zm6 0h4v-4h-4v4zm6-10v4h4V4h-4zm-6 4h4V4h-4v4zm6 6h4v-4h-4v4zm0 6h4v-4h-4v4z"/></svg>

docs/assets/display_settings_48dp.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 20 20" height="48px" viewBox="0 0 20 20" width="48px" fill="#000000"><g><rect fill="none" height="20" width="20" x="0"/></g><g><g><path d="M16.5,3h-13C2.67,3,2,3.67,2,4.5v9C2,14.33,2.67,15,3.5,15H7v2h6v-2h3.5c0.83,0,1.5-0.67,1.5-1.5v-9 C18,3.67,17.33,3,16.5,3z M16.5,13.5h-13v-9h13V13.5z"/><rect height="1" width="7" x="5" y="7"/><polygon points="14,8 15,8 15,7 14,7 14,6 13,6 13,9 14,9"/><rect height="1" width="7" x="8" y="10"/><polygon points="6,12 7,12 7,9 6,9 6,10 5,10 5,11 6,11"/></g></g></svg>

docs/assets/index_api.svg

@@ -1,97 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="99.058548mm"
-   height="89.967583mm"
-   viewBox="0 0 99.058554 89.967582"
-   version="1.1"
-   id="svg1040"
-   inkscape:version="0.92.4 (f8dce91, 2019-08-02)"
-   sodipodi:docname="index_api.svg">
-  <defs
-     id="defs1034" />
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="0.35"
-     inkscape:cx="533.74914"
-     inkscape:cy="10.90433"
-     inkscape:document-units="mm"
-     inkscape:current-layer="layer1"
-     showgrid="false"
-     fit-margin-top="0"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0"
-     inkscape:window-width="930"
-     inkscape:window-height="472"
-     inkscape:window-x="2349"
-     inkscape:window-y="267"
-     inkscape:window-maximized="0" />
-  <metadata
-     id="metadata1037">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(195.19933,-1.0492759)">
-    <g
-       id="g1008"
-       transform="matrix(1.094977,0,0,1.094977,-521.5523,-198.34055)">
-      <path
-         inkscape:connector-curvature="0"
-         id="path899"
-         d="M 324.96812,187.09499 H 303.0455 v 72.1639 h 22.67969"
-         style="fill:none;stroke:#5a5a5a;stroke-width:10;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path899-3"
-         d="m 361.58921,187.09499 h 21.92262 v 72.1639 h -22.67969"
-         style="fill:none;stroke:#5a5a5a;stroke-width:10;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
-      <g
-         transform="translate(415.87139,46.162126)"
-         id="g944">
-        <circle
-           style="fill:#5a5a5a;fill-opacity:1;stroke:#5a5a5a;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-           id="path918"
-           cx="-84.40152"
-           cy="189.84375"
-           r="2.2293637" />
-        <circle
-           style="fill:#5a5a5a;fill-opacity:1;stroke:#5a5a5a;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-           id="path918-5"
-           cx="-72.949402"
-           cy="189.84375"
-           r="2.2293637" />
-        <circle
-           style="fill:#5a5a5a;fill-opacity:1;stroke:#5a5a5a;stroke-width:4.53704548;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-           id="path918-6"
-           cx="-61.497284"
-           cy="189.84375"
-           r="2.2293637" />
-      </g>
-    </g>
-  </g>
-</svg>

docs/assets/index_contribute.svg

@@ -1,76 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="89.624855mm"
-   height="89.96759mm"
-   viewBox="0 0 89.62486 89.96759"
-   version="1.1"
-   id="svg1040"
-   inkscape:version="0.92.4 (f8dce91, 2019-08-02)"
-   sodipodi:docname="index_contribute.svg">
-  <defs
-     id="defs1034" />
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="0.35"
-     inkscape:cx="683.11893"
-     inkscape:cy="-59.078181"
-     inkscape:document-units="mm"
-     inkscape:current-layer="layer1"
-     showgrid="false"
-     fit-margin-top="0"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0"
-     inkscape:window-width="930"
-     inkscape:window-height="472"
-     inkscape:window-x="2349"
-     inkscape:window-y="267"
-     inkscape:window-maximized="0" />
-  <metadata
-     id="metadata1037">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(234.72009,17.466935)">
-    <g
-       id="g875"
-       transform="matrix(0.99300176,0,0,0.99300176,-133.24106,-172.58804)">
-      <path
-         sodipodi:nodetypes="ccc"
-         inkscape:connector-curvature="0"
-         id="path869"
-         d="m -97.139881,161.26069 47.247024,40.25446 -47.247024,40.25446"
-         style="fill:none;stroke:#5a5a5a;stroke-width:10;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path871"
-         d="m -49.514879,241.81547 h 32.505951"
-         style="fill:none;stroke:#5a5a5a;stroke-width:10;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
-    </g>
-  </g>
-</svg>

docs/assets/index_getting_started.svg

@@ -1,66 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="101.09389mm"
-   height="89.96759mm"
-   viewBox="0 0 101.09389 89.96759"
-   version="1.1"
-   id="svg1040"
-   inkscape:version="0.92.4 (f8dce91, 2019-08-02)"
-   sodipodi:docname="index_getting_started.svg">
-  <defs
-     id="defs1034" />
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="0.35"
-     inkscape:cx="-93.242129"
-     inkscape:cy="-189.9825"
-     inkscape:document-units="mm"
-     inkscape:current-layer="layer1"
-     showgrid="false"
-     fit-margin-top="0"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0"
-     inkscape:window-width="1875"
-     inkscape:window-height="1056"
-     inkscape:window-x="1965"
-     inkscape:window-y="0"
-     inkscape:window-maximized="1" />
-  <metadata
-     id="metadata1037">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(2.9219487,-8.5995374)">
-    <path
-       style="fill:#5a5a5a;fill-opacity:1;stroke-width:0.20233451"
-       d="M 37.270955,98.335591 C 33.358064,97.07991 31.237736,92.52319 32.964256,89.08022 c 0.18139,-0.361738 4.757999,-5.096629 10.17021,-10.521968 l 9.84041,-9.864254 -4.03738,-4.041175 -4.037391,-4.041172 -4.96415,4.916665 c -3.61569,3.581096 -5.238959,5.04997 -5.975818,5.407377 l -1.011682,0.490718 H 17.267525 1.5866055 L 0.65034544,70.96512 C -2.2506745,69.535833 -3.5952145,66.18561 -2.5925745,62.884631 c 0.53525,-1.762217 1.61699004,-3.050074 3.22528014,-3.839847 l 1.15623996,-0.56778 13.2591094,-0.05613 13.259111,-0.05613 11.5262,-11.527539 11.526199,-11.527528 H 40.622647 c -12.145542,0 -12.189222,-0.0046 -13.752801,-1.445851 -2.229871,-2.055423 -2.162799,-5.970551 0.135998,-7.938238 1.475193,-1.262712 1.111351,-1.238469 18.588522,-1.238469 12.899229,0 16.035311,0.05193 16.692589,0.276494 0.641832,0.219264 2.590731,2.051402 9.416301,8.852134 l 8.606941,8.575638 h 6.848168 c 4.837422,0 7.092281,0.07311 7.679571,0.249094 0.48064,0.144008 1.22985,0.634863 1.77578,1.163429 2.383085,2.307333 1.968685,6.539886 -0.804989,8.221882 -0.571871,0.346781 -1.38284,0.687226 -1.80217,0.756523 -0.41933,0.06928 -4.2741,0.127016 -8.56615,0.128238 -6.56998,0.0016 -7.977492,-0.04901 -8.902732,-0.321921 -0.975569,-0.287742 -1.400468,-0.622236 -3.783999,-2.978832 l -2.685021,-2.654679 -5.05411,5.051071 -5.0541,5.051081 3.926292,3.947202 c 2.365399,2.378001 4.114289,4.309171 4.399158,4.857713 0.39266,0.75606 0.47311,1.219412 0.474321,2.731516 0.003,3.083647 0.620779,2.331942 -13.598011,16.531349 -10.273768,10.259761 -12.679778,12.563171 -13.500979,12.92519 -1.267042,0.55857 -3.156169,0.681342 -4.390271,0.285321 z m 40.130741,-65.45839 c -2.212909,-0.579748 -3.782711,-1.498393 -5.51275,-3.226063 -2.522111,-2.518633 -3.633121,-5.181304 -3.633121,-8.707194 0,-3.530699 1.11238,-6.197124 3.631161,-8.704043 4.866751,-4.8438383 12.324781,-4.8550953 17.211791,-0.026 3.908758,3.862461 4.818578,9.377999 2.372188,14.380771 -0.846209,1.730481 -3.39493,4.326384 -5.143839,5.239072 -2.69708,1.407492 -6.042829,1.798628 -8.92543,1.043434 z"
-       id="path1000"
-       inkscape:connector-curvature="0" />
-  </g>
-</svg>

docs/assets/index_user_guide.svg

@@ -1,67 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="123.72241mm"
-   height="89.96759mm"
-   viewBox="0 0 123.72242 89.96759"
-   version="1.1"
-   id="svg1040"
-   inkscape:version="0.92.4 (f8dce91, 2019-08-02)"
-   sodipodi:docname="index_userguide.svg">
-  <defs
-     id="defs1034" />
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="0.35"
-     inkscape:cx="332.26618"
-     inkscape:cy="83.744004"
-     inkscape:document-units="mm"
-     inkscape:current-layer="layer1"
-     showgrid="false"
-     fit-margin-top="0"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0"
-     inkscape:window-width="930"
-     inkscape:window-height="472"
-     inkscape:window-x="2349"
-     inkscape:window-y="267"
-     inkscape:window-maximized="0" />
-  <metadata
-     id="metadata1037">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(141.8903,-20.32143)">
-    <path
-       style="fill:#5a5a5a;fill-opacity:1;stroke-width:0.20483544"
-       d="m -139.53374,110.1657 c -0.80428,-0.24884 -1.71513,-1.11296 -2.07107,-1.96486 -0.23905,-0.57214 -0.28453,-6.28104 -0.28453,-35.720988 0,-38.274546 -0.079,-35.840728 1.19849,-36.91568 0.58869,-0.495345 4.63766,-2.187548 8.47998,-3.544073 l 1.58749,-0.560453 v -3.309822 c 0,-3.025538 0.0396,-3.388179 0.46086,-4.222122 0.68808,-1.362003 1.38671,-1.714455 4.60319,-2.322195 4.12797,-0.779966 5.13304,-0.912766 8.81544,-1.16476 11.80964,-0.808168 22.80911,2.509277 30.965439,9.3392 1.750401,1.465747 3.840861,3.5635 5.0903,5.108065 l 0.659122,0.814805 0.659109,-0.814805 c 1.249431,-1.544565 3.33988,-3.642318 5.09029,-5.108065 8.156331,-6.829923 19.155791,-10.147368 30.965441,-9.3392 3.682389,0.251994 4.68748,0.384794 8.81544,1.16476 3.21647,0.60774 3.91511,0.960192 4.60318,2.322195 0.4213,0.833943 0.46087,1.196584 0.46087,4.222122 v 3.309822 l 1.58748,0.560453 c 4.10165,1.448077 7.98852,3.072753 8.5259,3.563743 1.22643,1.120567 1.15258,-1.245868 1.15258,36.927177 0,34.567591 -0.005,35.083151 -0.40663,35.903991 -0.22365,0.45804 -0.73729,1.05665 -1.14143,1.33024 -1.22281,0.82783 -2.17721,0.70485 -5.86813,-0.7561 -9.19595,-3.63998 -18.956011,-6.38443 -26.791332,-7.53353 -3.02827,-0.44412 -9.26189,-0.61543 -11.77821,-0.3237 -5.19357,0.60212 -8.736108,2.05527 -11.700039,4.79936 -0.684501,0.63371 -1.466141,1.23646 -1.736979,1.33942 -0.63859,0.2428 -4.236521,0.2428 -4.875112,0 -0.27083,-0.10296 -1.05247,-0.70571 -1.73696,-1.33942 -2.96395,-2.74409 -6.50648,-4.19724 -11.700058,-4.79936 -2.516312,-0.29173 -8.749941,-0.12042 -11.778201,0.3237 -7.78194,1.14127 -17.39965,3.83907 -26.73341,7.49883 -3.38325,1.32658 -4.15525,1.50926 -5.11851,1.21125 z m 4.2107,-5.34052 c 5.86759,-2.29858 14.40398,-4.922695 20.2018,-6.210065 6.31584,-1.402418 8.5236,-1.646248 14.91592,-1.647338 4.68699,-7.94e-4 6.013661,0.0632 7.257809,0.3497 0.837332,0.19286 1.561052,0.312028 1.60828,0.264819 0.147111,-0.147119 -1.803289,-1.307431 -4.154879,-2.471801 -8.12511,-4.023029 -18.27311,-4.986568 -29.0861,-2.761718 -1.09536,0.22538 -2.32708,0.40827 -2.73715,0.406418 -1.12787,-0.005 -2.3054,-0.76382 -2.84516,-1.8332 l -0.46086,-0.913098 V 62.99179 35.97471 l -0.56331,0.138329 c -0.30981,0.07608 -1.89985,0.665075 -3.5334,1.308881 -2.27551,0.896801 -2.96414,1.252878 -2.94452,1.522563 0.014,0.193604 0.0372,15.284513 0.0512,33.535345 0.014,18.250839 0.0538,33.183322 0.0884,33.183322 0.0346,0 1.02543,-0.3771 2.20198,-0.83801 z m 113.006991,-32.697216 -0.0518,-33.535203 -3.17495,-1.272156 c -1.74623,-0.699685 -3.33627,-1.278755 -3.53341,-1.286819 -0.33966,-0.01389 -0.35847,1.401778 -0.35847,26.980216 v 26.994863 l -0.46087,0.913112 c -0.53976,1.06939 -1.71729,1.828088 -2.84515,1.833189 -0.41008,0.0021 -1.6418,-0.181031 -2.73716,-0.406421 -11.888201,-2.446089 -22.84337,-1.046438 -31.491022,4.02332 -1.68175,0.985941 -2.216748,1.467501 -1.36534,1.228942 1.575181,-0.441362 4.990592,-0.73864 8.524862,-0.742011 5.954408,-0.005 11.43046,0.791951 19.10874,2.78333 3.9516,1.024874 12.1555,3.687454 15.6699,5.085704 1.23926,0.49306 2.36869,0.90517 2.50985,0.9158 0.20489,0.0155 0.2462,-6.745894 0.20483,-33.515866 z m -59.76135,-2.233777 V 40.065438 l -0.95972,-1.357442 c -1.380522,-1.952627 -5.376262,-5.847994 -7.64336,-7.45136 -3.778692,-2.672401 -9.063392,-4.943324 -13.672511,-5.875304 -3.19731,-0.646503 -5.23069,-0.833103 -9.05886,-0.831312 -4.37716,0.0021 -7.70223,0.349169 -11.83461,1.235469 l -1.07538,0.230645 v 31.242342 c 0,26.565778 0.0426,31.226011 0.28429,31.133261 0.15637,-0.06 1.42379,-0.297169 2.81648,-0.527026 12.37657,-2.042634 23.21658,-0.346861 32.521639,5.087596 2.10018,1.226558 5.20202,3.618878 6.880942,5.30692 0.788609,0.792909 1.502978,1.446609 1.587468,1.452679 0.0845,0.006 0.153622,-13.411893 0.153622,-29.817719 z m 5.80221,28.3766 c 6.21476,-6.141601 15.08488,-10.061509 25.025529,-11.05933 4.262419,-0.427849 11.579921,-0.0054 16.017661,0.924912 0.75932,0.15916 1.45259,0.244888 1.54058,0.190498 0.088,-0.05434 0.16003,-14.060382 0.16003,-31.124436 V 26.176883 l -0.52136,-0.198219 c -0.66893,-0.254325 -4.77649,-0.95482 -7.159981,-1.221048 -2.41372,-0.269605 -8.559851,-0.266589 -10.759229,0.0052 -6.458111,0.798299 -12.584091,3.083792 -17.405651,6.49374 -2.267091,1.603366 -6.262831,5.498733 -7.64336,7.45136 l -0.959721,1.357438 v 29.828747 c 0,16.405812 0.0532,29.828746 0.11802,29.828746 0.065,0 0.77928,-0.65347 1.587482,-1.452149 z"
-       id="path845"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="csscccscsssscsssssscscsccsccsccscsscccccccscccccccccsccscscscccscccsccssccsscccscccccsccccsccscsccsscc" />
-  </g>
-</svg>

docs/assets/rocket_launch_48dp.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 20 20" height="48px" viewBox="0 0 20 20" width="48px" fill="#000000"><g><rect fill="none" height="20" width="20" x="0"/></g><g><g><path d="M14.45,10.86l0.26,2.1c0.06,0.46-0.1,0.92-0.43,1.25l-3.55,3.55l-1.41-4.24l-2.83-2.83L2.25,9.27l3.55-3.55 c0.33-0.33,0.79-0.49,1.25-0.43l2.1,0.26C13.92,0.78,17.8,2.2,17.8,2.2C17.8,2.2,19.22,6.08,14.45,10.86z M10.2,6.62 C9.18,7.64,8.37,9.06,7.9,9.97l2.12,2.12c0.91-0.46,2.34-1.27,3.36-2.3C16.18,7,16.54,4.67,16.5,3.5C15.33,3.46,13,3.82,10.2,6.62 z M14,7.5C14,6.68,13.32,6,12.5,6C11.67,6,11,6.68,11,7.5S11.67,9,12.5,9C13.32,9,14,8.33,14,7.5z M7.99,6.92L6.86,6.78L5.02,8.61 l1.62,0.54C6.97,8.52,7.43,7.71,7.99,6.92z M10.85,13.36l0.54,1.62l1.83-1.83l-0.14-1.14C12.29,12.57,11.48,13.03,10.85,13.36z M5.25,12.5c-0.62,0-1.18,0.25-1.59,0.66C2.44,14.38,2,18,2,18s3.62-0.44,4.84-1.66c0.41-0.41,0.66-0.97,0.66-1.59 C7.5,13.51,6.49,12.5,5.25,12.5z M5.78,15.28c-0.44,0.44-1.87,0.81-1.87,0.81s0.37-1.43,0.81-1.87c0.29-0.29,0.77-0.29,1.06,0 S6.07,14.99,5.78,15.28z"/></g></g></svg>

docs/conf.py

@@ -64,7 +64,6 @@ add_module_names = False  # Remove namespaces from class/method signatures
 autodoc_inherit_docstrings = True  # If no docstring, inherit from base class
 set_type_checking_flag = True  # Enable 'expensive' imports for sphinx_autodoc_typehints
 autoclass_content = "both"  # Include both class docstring and __init__
-autodoc_mock_imports = ["pyqtgraph"]
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ["_templates"]
@@ -77,5 +76,6 @@ language = "Python"
 
 html_theme = "pydata_sphinx_theme"
 html_static_path = ["_static"]
-html_css_files = ["custom.css"]
-html_logo = "../bec_widgets/assets/bec_widgets_icon.png"
+html_css_files = ["css/custom.css"]
+html_logo = "_static/bec.png"
+html_theme_options = {"show_nav_level": 1, "navbar_align": "content"}

docs/developer/developer.md

@@ -1,46 +1,26 @@
 (developer)=
-# Developer 
-
-Welcome to the BEC Widgets developer guide! This section is intended for developers who want to contribute to the development of BEC Widgets.
+# Development
 
 ```{toctree}
 ---
-maxdepth: 2
+maxdepth: 1
 hidden: true
 ---
+reference/
+```
 
-getting_started/getting_started.md
-widgets/widgets.md
-api_reference/api_reference.md
+To contribute to the development of BEC Widgets, start by setting up the development environment:
+
+1. **Clone the Repository**: 
+```bash
+git clone https://gitlab.psi.ch/bec/bec_widgets
+cd bec_widgets
+```
+2. **Install in Editable Mode**:
+
+Installing the package in editable mode allows you to make changes to the code and test them in real-time.
+```bash
+pip install -e .[dev,pyqt6]
 ```
 
 
-***
-
-````{grid} 2
-:gutter: 5
-
-```{grid-item-card}
-:link: developer.getting_started
-:link-type: ref
-:img-top: /assets/rocket_launch_48dp.svg
-:text-align: center
-
-## Getting Started
-
-Learn how to install BEC Widgets and get started with the framework.
-```
-
-```{grid-item-card}
-:link: developer.widgets
-:link-type: ref
-:img-top: /assets/apps_48dp.svg
-:text-align: center
-
-## Widgets
-
-Learn about the building blocks of larger applications: widgets.
-```
-````
-
-

docs/developer/getting_started/development.md

@@ -1,27 +0,0 @@
-(developer.development)=
-# Development
-
-If you like to contribute to the development of BEC Widgets, you can follow the steps below to set up your development environment.
-BEC Widgets works in conjunction with [BEC](https://bec.readthedocs.io/en/latest/). 
-Therefore, we recommend that you install BEC first following the [developer instructions](https://bec.readthedocs.io/en/latest/developer/getting_started/install_developer_env.html) and include BEC Widgets. 
-
-If you already have a BEC environment set up, you can install BEC Widgets in editable mode into your BEC Python environment.
-
-**Prerequisites**
-1. **Python Version:** BEC Widgets requires Python version 3.10 or higher. Verify your Python version to ensure compatibility.
-2. **BEC Installation:** BEC Widgets works in conjunction with BEC. While BEC is a dependency and will be installed automatically, you can find more information about BEC and its installation process in the [BEC documentation](https://beamline-experiment-control.readthedocs.io/en/latest/).
-
-**Clone the Repository**: 
-```bash
-git clone https://gitlab.psi.ch/bec/bec_widgets
-cd bec_widgets
-```
-**Install in Editable Mode**:
-
-Please install the package in editable mode into your BEC Python environemnt. 
-```bash
-pip install -e '.[dev,pyqt6]'
-```
-This installs the package together with [PyQT6](https://www.riverbankcomputing.com/static/Docs/PyQt6/introduction.html). 
-
-

docs/developer/getting_started/getting_started.md

@@ -1,12 +0,0 @@
-(developer.getting_started)=
-# Getting Started
-This section provides valuable information for developers who want to contribute to the development of BEC Widgets. The guide will help you set up the development environment, understand the modular development concept of BEC Widgets, and contribute to the project.
-
-```{toctree}
----
-maxdepth: 2
-hidden: false
----
-
-development/
-```

docs/developer/reference.md

@@ -1,5 +1,4 @@
-(api_reference)=
-# API Reference
+## API Reference
 
 ```{eval-rst}
 .. autosummary::
@@ -8,5 +7,4 @@
    :recursive:
 
    bec_widgets
-
 ```

docs/developer/widgets/widgets.md

@@ -1,11 +0,0 @@
-(developer.widgets)=
-# Widgets
-This section provides an introduction to the building blocks of BEC Widgets: widgets. Widgets are the basic components of the graphical user interface (GUI) and are used to create larger applications. We will cover key topics such as how to develop new widgets or how to customise existing widgets. For details on the already available widgets and their usage, please refer to user section about [widgets](#user.widgets)
-
-```{toctree}
----
-maxdepth: 2
-hidden: false
----
-
-```

docs/index.md

@@ -1,70 +1,39 @@
 # BEC Widgets documentation
 
-A flexible and extensible framework for building graphical user interfaces in Python, optimized for use in the BEC environment.
-
 <br><br>
 
-<br><br>
-
-````{grid} 2
+````{grid} 3
 :gutter: 5
 
-```{grid-item-card}
+```{grid-item-card}  Introduction
 :link: introduction
 :link-type: ref
-:img-top: /assets/index_getting_started.svg
-:text-align: center
 
-## Introduction
-
-General information about BEC Widgets.
+General information.
 ```
 
-```{grid-item-card}
+```{grid-item-card}  User
 :link: user
 :link-type: ref
-:img-top:  /assets/index_user_guide.svg
-:text-align: center
 
-## User guide
-
-Information for users of BEC Widgets.
+Information for users.
 ```
 
-```{grid-item-card} 
+```{grid-item-card}  Developer
 :link: developer
 :link-type: ref
-:img-top: /assets/index_contribute.svg
-:text-align: center
 
-## Developer guide
-
-Information for developers of BEC Widgets. 
+Information for developers.
 ```
-
-```{grid-item-card} 
-:link: api_reference
-:link-type: ref
-:img-top: /assets/index_api.svg
-:text-align: center
-
-## API reference
-
-Comprehensive reference of all BEC Widget classes, functions, and methods.
-```
-
 ````
 
 
 ```{toctree}
 ---
 numbered: true
-maxdepth: 2
-hidden: true
+maxdepth: 1
 ---
 
 introduction/introduction
 user/user
 developer/developer
-api_reference/api_reference
-```

docs/requirements.txt

@@ -7,6 +7,5 @@ sphinx-copybutton
 myst-parser
 sphinx-design
 PyQt6
-PyQt6-WebEngine
 bec-widgets
 tomli

docs/user/api_reference/api_reference.md

@@ -1,11 +0,0 @@
-(user.api_reference)=
-# User API Reference
-
-```{eval-rst}
-.. autosummary::
-   :toctree: _autosummary
-   :template: custom-module-template.rst
-
-    bec_widgets.cli.client
-
-```

docs/user/applications/applications.md

@@ -1,10 +0,0 @@
-(user.applications)=
-# Applications
-
-**Coming soon**
-
-```{toctree}
----
-maxdepth: 1
-hidden: true
----

docs/user/apps.md

@@ -0,0 +1,39 @@
+(user.apps)=
+# Applications
+
+In the `bec_widgets/examples` directory, you will find practical applications that demonstrate the capabilities of BEC Widgets in real-world scenarios. These applications showcase the adaptability and functionality of the framework for various beamline experiment needs.
+
+**Motor Alignment Tool**
+
+This tool assists in aligning motors with samples during experiments. It enables users to move motors, visually track their movement, and record positions for precise alignment.
+
+- **Location:** `bec_widgets/examples/motor_movement`
+- **Further Details:** [Motor Alignment Tool Documentation](#user.apps.motor_app) 
+
+**General Plotting Live Acquisition Tool**
+
+This application is designed for live data visualization. It allows users to view real-time signals from detectors in a multi-grid layout, facilitating immediate analysis during experiments.
+
+- **Location:** `bec_widgets/examples/plot_app`
+- **Further Details:** [General Plotting Live Acquisition Tool Documentation](#user.apps.plot_app) 
+
+
+**Modular Application**
+
+A bespoke application built entirely using BEC Widgets' modular components. This example illustrates the framework's flexibility in creating customized GUIs tailored to specific experimental setups.
+
+- **Location:** `bec_widgets/examples/modular_app`
+- **Further Details:** [Modular Application](#user.apps.modular_app) 
+
+---
+Note: The documentation for these applications is currently under development. The provided links will direct you to their respective pages once the documentation is complete.
+
+```{toctree}
+---
+maxdepth: 1
+hidden: true
+---
+
+apps/motor_app
+apps/plot_app
+apps/modular_app

docs/user/apps/modular_app.md

@@ -0,0 +1,6 @@
+(user.apps.modular_app)=
+
+# Modular Application
+
+
+_to be added..._

docs/user/apps/motor_app.md

@@ -0,0 +1,34 @@
+(user.apps.motor_app)=
+# Motor Alignment
+
+The Motor Alignment Application is a key component of the BEC Widgets suite, designed to facilitate precise alignment of motors. 
+Users can easily launch this app using the script located at  `/bec_widgets/example/motor_movement/motor_example.py` script. 
+The application's primary function is to enable users to align motors to specific positions and to visually track the motor's trajectory.
+
+## Controlling Motors
+
+In the top middle panel of the application, users will find combobox dropdown menus for selecting the motors they wish to track on the x and y axes of the motor map. 
+These motors are automatically loaded from the current active BEC instance, ensuring seamless integration and ease of use.
+
+There are two primary methods to control motor movements:
+
+
+1. **Manual Control with Arrow Keys:** Users can manually drive the motors using arrow keys. Before doing so, they need to select the step size for each motor, allowing for precise and incremental movements.
+2. **Direct Position Entry:** Alternatively, users can input a desired position in the text input box and then click the Go button. This action will move the motor directly to the specified coordinates.
+
+As the motors are moved, their trajectory is plotted in real-time, providing users with a visual representation of the motor's path. This feature is particularly useful for understanding the movement patterns and making necessary adjustments.
+
+
+## Saving and Exporting Data
+
+Users have the ability to save the current motor position in a table widget. This functionality is beneficial for recalling and returning to specific positions. By clicking the Go button in the table widget, the motors will automatically move back to the saved position.
+
+Additionally, users can annotate each saved position with notes and comments directly in the table widget. This feature is invaluable for keeping track of specific alignment settings or observations. The contents of the table, including the notes, can be exported to a .csv file. This exported data can be used for initiating scans or for record-keeping purposes.
+
+The table widget also supports saving and loading functionalities, allowing users to preserve their motor positions and notes across sessions. The saved files are in a user-friendly format for ease of access and use.
+
+
+## Example of Use
+
+![Motor app example](motor_app_10fps.gif)
+

docs/user/apps/plot_app.md

@@ -0,0 +1,6 @@
+(user.apps.plot_app)=
+
+# General Plotting Tool
+
+
+_to be added..._

docs/user/customisation.md

@@ -1,118 +1,8 @@
 (user.customisation)=
 # Customisation
 
-## Leveraging BEC Widgets in custom GUI applications
+BEC Widgets are designed to be used with QtDesigner to quicly design GUI.
 
-BEC Widgets can be used to compose a complete Qt graphical application, along with
-other QWidgets. The only requirement is to connect to BEC servers in order to get
-data, or to interact with BEC components. This role is devoted to the BECDispatcher,
-a singleton object which has to be instantiated **after the QApplication is created**.
-
-A typical BEC Widgets custom application "main" entry point should follow the template
-below: 
-
-```
-import argparse
-import sys
-
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-from qtpy.QtWidgets import QApplication
-
-# optional command line arguments processing
-parser = argparse.ArgumentParser(description="...")
-parser.add_argument( ...)
-...
-args = parser.parse_args()
-
-# creation of the Qt application
-app = QApplication([])
-
-# creation of BEC Dispatcher
-# /!\ important: after the QApplication has been instantiated
-bec_dispatcher = BECDispatcher()
-client = bec_dispatcher.client
-client.start()
-
-# (optional) processing of command line args,
-# creation of a main window depending on the command line arguments (or not)
-if args.xxx == "...":
-    window = ...
- 
-# display of the main window and start of Qt event loop
-window.show()
-sys.exit(app.exec())
-```
-
-The main "window" object presents the layout of widgets to the user and allows
-users to interact. BEC Widgets must be placed in the window:
-
-```
-from qtpy.QWidgets import QMainWindow
-from bec_widgets.widgets.figure import BECFigure
-
-window = QMainWindow()
-bec_figure = BECFigure(gui_id="my_gui_app_id")
-window.setCentralWidget(bec_figure)
-
-# prepare to plot samx motor vs bpm4i value
-bec_figure.plot(x_name="samx", y_name="bpm4i")
-```
-
-In the example just above, the resulting application will show a plot of samx
-positions on the horizontal axis, and beam intensity on the vertical axis
-(when the next scan will be started).
-
-It is important to ensure proper cleanup of the resources is done when application
-quits:
-
-```
-def final_cleanup():
-    bec_figure.clear_all()
-    bec_figure.client.shutdown()
-
-window.aboutToQuit.connect(final_cleanup)
-```
-
-Final example:
-
-```
-import sys
-from qtpy.QtWidgets import QMainWindow, QApplication
-from bec_widgets.widgets.figure import BECFigure
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
-# creation of the Qt application
-app = QApplication([])
-
-# creation of BEC Dispatcher
-bec_dispatcher = BECDispatcher()
-client = bec_dispatcher.client
-client.start()
-
-# creation of main window
-window = QMainWindow()
-
-# inserting BEC Widgets
-bec_figure = BECFigure(parent=window, gui_id="my_gui_app_id")
-window.setCentralWidget(bec_figure)
-
-bec_figure.plot(x_name="samx", y_name="bpm4i")
-
-# ensuring proper cleanup
-def final_cleanup():
-    bec_figure.clear_all()
-    bec_figure.client.shutdown()
-
-app.aboutToQuit.connect(final_cleanup)
-
-# execution
-window.show()
-sys.exit(app.exec())
-```
-
-## Writing applications using Qt Designer
-
-BEC Widgets are designed to be used with QtDesigner to quickly design GUI.
 
 ## Example of promoting widgets in Qt Designer
 

docs/user/getting_started/auto_updates.md

@@ -1,82 +0,0 @@
-(user.auto_updates)=
-# Auto updates
-BEC Widgets provides a simple way to update the entire GUI configuration based on events. These events can be of different types, such as a new scan being started or completed, a button being pressed, a device reporting an error or the existence of a specific metadata key. This allows the users to streamline the experience of the GUI and to focus on the data and the analysis, rather than on the GUI itself.
-
-The default auto update only takes control over a single `BECFigure` widget, which is automatically added to the GUI instance. The update instance is accessible via the `bec.gui.auto_updates` object. The user can disable / enable the auto updates by setting the `enabled` attribute of the `bec.gui.auto_updates` object, e.g. 
-
-```python
-bec.gui.auto_updates.enabled = False
-```
-
-Without further customization, the auto update will automatically update the `BECFigure` widget based on the currently performed scan. The behaviour is determined by the `handler` method of the `AutoUpdate` class: 
-
-````{dropdown} Auto Updates Handler
-:icon: code-square
-:animate: fade-in-slide-down
-:open: 
-```{literalinclude} ../../../bec_widgets/cli/auto_updates.py
-:pyobject: AutoUpdates.handler
-```
-````
-
-As shown, the default handler switches between different scan names and updates the `BECFigure` widget accordingly. If the scan is a line scan, the `simple_line_scan` update method is executed. 
-
-````{dropdown} Auto Updates Simple Line Scan
-:icon: code-square
-:animate: fade-in-slide-down
-:open: 
-```{literalinclude} ../../../bec_widgets/cli/auto_updates.py
-:pyobject: AutoUpdates.simple_line_scan
-```
-````
-
-As it can be seen from the above snippet, the update method gets the default figure by calling the `get_default_figure` method. If the figure is not found, maybe because the user has deleted or closed it, no update is performed. If the figure is found, the scan info is used to extract the first reported device for the x axis and the first device of the monitored devices for the y axis. The y axis can also be set by the user using the `selected_device` attribute:
-
-```python
-bec.gui.auto_updates.selected_device = 'bpm4i'
-```
-
-
-````{dropdown} Auto Updates Code
-:icon: code-square
-:animate: fade-in-slide-down
-```{literalinclude} ../../../bec_widgets/cli/auto_updates.py
-```
-````
-
-## Custom Auto Updates
-The beamline can customize their default behaviour through customized auto update classes. This can be achieved by modifying the class located in the beamline plugin repository: `<beamline_plugin>/bec_widgets/auto_updates.py`. The class should inherit from the `AutoUpdates` class and overwrite the `handler` method. 
-
-```python
-from bec_widgets.cli.auto_updates import AutoUpdates, ScanInfo
-
-
-class PlotUpdate(AutoUpdates):
-    create_default_dock = True
-    enabled = True
-
-    # def simple_line_scan(self, info: ScanInfo) -> None:
-    #     """
-    #     Simple line scan.
-    #     """
-    #     fig = self.get_default_figure()
-    #     if not fig:
-    #         return
-    #     dev_x = info.scan_report_devices[0]
-    #     dev_y = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
-    #     if not dev_y:
-    #         return
-    #     fig.clear_all()
-    #     plt = fig.plot(x_name=dev_x, y_name=dev_y)
-    #     plt.set(title=f"Custom Plot {info.scan_number}", x_label=dev_x, y_label=dev_y)
-
-    def handler(self, info: ScanInfo) -> None:
-        # EXAMPLES:
-        # if info.scan_name == "line_scan" and info.scan_report_devices:
-        #     self.simple_line_scan(info)
-        #     return
-        # if info.scan_name == "grid_scan" and info.scan_report_devices:
-        #     self.run_grid_scan_update(info)
-        #     return
-        super().handler(info)
-```

docs/user/getting_started/getting_started.md

@@ -1,14 +0,0 @@
-(user.getting_started)=
-# Getting Started
-This section provides a comprehensive guide to getting started with BEC Widgets. Whether you are new to BEC Widgets or looking to refresh your knowledge, this guide will help you set up and navigate the framework with ease.
-
-```{toctree}
----
-maxdepth: 2
-hidden: true
----
-
-installation/
-quick_start/
-auto_updates/
-```

docs/user/getting_started/quick_start.md

@@ -1,110 +0,0 @@
-(user.command_line_introduction)=
-# Quick start
-In order to use BEC Widgets as a plotting tool for BEC, it needs to be [installed](#user.installation) in the same Python environment as the BEC IPython client (please refer to the [BEC documentation](https://bec.readthedocs.io/en/latest/user/command_line_interface.html#start-up) for more details). Upon startup, the client will automatically launch a GUI and store it as a `bec.gui` object in the client. The GUI backend will also be automatically connect to the BEC server, giving access to all information on the server and allowing the user to visualize the data in real-time.
-
-## BECDockArea
-The `bec.gui` object is your entry point to BEC Widgets. It is a [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) instance that can be composed of multiple [`BECDock`](/api_reference/_autosummary/bec_widgets.cli.client.BECDock)s that can be attached / detached to the main area. These docks allow users to freely arrange and customize the widgets they add to the gui, providing a flexible and customizable interface to visualize data. 
-
-**Schema of the BECDockArea**
-
-![BECDockArea.png](BECDockArea.png)
-
-## Widgets
-Widgets are the building blocks of the BEC Widgets framework. They are the visual components that allow users to interact with the data and control the behavior of the application. Each dock can contain multiple widgets, albeit we recommend for most use cases a single widget per dock. BEC Widgets provides a set of core widgets (cf. [widgets](#user.widgets)). More widgets can be added by the users, and we invite you to explore the [developer documentation](developer.widgets) to learn how to create custom widgets.
-For the introduction given here, we will focus on the `BECFigure` widget, as it is the most commonly used widget for visualizing data from BEC. The same access pattern can be used for all other widgets.
-
-**BECFigure**
-
-The [`BECFigure`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure) widget is one of the core widgets developed for BEC and can be used to visualize different plot types, such as [1D waveforms](user.widgets.waveform_1d), [2D scatter plots](user.widgets.scatter_2d), [position maps](user.widgets.motor_map) and [2D images](user.widgets.image_2d). 
-If BEC Widgets is installed, the default behaviour of BEC is to automatically add a BECFigure Widget to the existing GUI instance. This widget is directly accessible via the `fig` object from the client. Moreover, a best-effort attempt is made to automatically determine the best plot type based on the currently performed scan. This behaviour can be changed or disabled by the user. For more details, please refer to the [auto update](user.auto_updates) section.
-
-<!-- We also provide two methods [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.plot), [`image()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.image) and [`motor_map()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.motor_map) as shortcuts to add a plot, image or motor map to the BECFigure. -->
-
-**Waveform Plot** 
-
- The [`BECWaveForm`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform) is a widget that can be used to visualize 1D waveform data, i.e. to plot data of a monitor against a motor position. The method [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.plot) of BECFigure adds a BECWaveForm widget to the figure, and returns the plot object. 
-
-```python
-plt = fig.plot(x_name='samx', y_name='bpm4i')
-```
-Here, we create a new plot with a subscription to the devices `samx` and `bpm4i` and assign the plot to the object `plt`. We can now use this object to further customize the plot, e.g. changing the title ([`set_title()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_title)), axis labels ([`set_x_label()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_x_label)) or limits ([`set_x_lim()`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform.rst#bec_widgets.cli.client.BECWaveform.set_x_lim)). We invite you to explore the API of the BECWaveForm in the [documentation](user.widgets.waveform_1d) or directly in the command line.
-
-To plot custom data, i.e. data that is not directly available through a scan in BEC, we can use the same method, but provide the data directly to the plot. 
-
-```python
-plt = fig.plot([1,2,3,4], [1,4,9,16])
-# or 
-plt = fig.plot(x=[1,2,3,4], y=[1,4,9,16])
-# or 
-plt = fig.plot(x=np.array([1,2,3,4]), y=np.array([1,4,9,16]))
-# or 
-plt = fig.plot(np.random.rand(10,2))
-```
-
-**Scatter Plot**
-
-The [`BECWaveForm`](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveForm) widget can also be used to visualize 2D scatter plots. More details on setting up the scatter plot are available in the widget documentation of the [scatter plot](user.widgets.scatter_2d).
-
-**Motor Map**
-
-The [`BECMotorMap`](/api_reference/_autosummary/bec_widgets.cli.client.BECMotorMap) widget can be used to visualize the position of motors. It's focused on tracking and visualizing the position of motors, crucial for precise alignment and movement tracking during scans. More details on setting up the motor map are available in the widget documentation of the [motor map](user.widgets.motor_map).
-
-**Image Plot**
-
-The [`BECImageItem`](/api_reference/_autosummary/bec_widgets.cli.client.BECImageItem) widget can be used to visualize 2D image data for example a camera. More details on setting up the image plot are available in the widget documentation of the [image plot](user.widgets.image).
-
-### Useful Commands
-We recommend users to explore the API of the widgets by themselves since we assume that the user interface is supposed to be intuitive and self-explanatory. We appreciate feedback from user in order to constantly improve the experience and allow easy access to the gui, widgets and their functionality. We recommend checking the [API documentation](user.api_reference), but also by using BEC Widgets, exploring the available functions and check their dockstrings.
-```python
-gui.add_dock? # shows the dockstring of the add_dock method
-```
-
-In addition, we list below a few useful commands that can be used to interface with the widgets:
-
-```python
-gui.panels # returns a dictionary of all docks in the gui
-gui.add_dock() # adds a new dock to the gui
-
-dock = gui.panels['dock_2']
-dock.add_widget('BECFigure') # adds a new widget of BECFigure to the dock
-dock.widget_list # returns a list of all widgets in the dock
-
-figure = dock.widget_list[0] # assigns the created BECFigure to figure
-plt = figure.plot(x_name='samx', y_name='bpm4i') # adds a BECWaveForm plot to the figure
-plt.curves # returns a list of all curves in the plot
-```
-
-We note that commands can also be chained. For example, `gui.add_dock().add_widget('BECFigure')` will add a new dock to the gui and add a new widget of `BECFigure` to the dock. 
-
-## Composing a larger GUI
-The example given above introduces BEC Widgets with its different components, and provides an overview of how to interact with the widgets. Nevertheless, another power aspect of BEC Widgets lies in the ability to compose a larger GUI with multiple docks and widgets. This section aims to provide a tutorial like guide on how to compose a more complex GUI that (A) live-plots a 1D waveform, (B) plots data from a camera, and (C) tracks the positions of two motors.
-Let's assume BEC was just started and the `gui` object is available in the client. A single dock is already attached together with a BEC Figure. Let's add the 1D waveform to this dock, change the color of the line to white and add the title *1D Waveform* to the plot.
-
-```python
-plt = fig.plot(x_name='samx', y_name='bpm4i')
-plt.curves[0].set_color(color="white")
-plt.set_title('1D Waveform')
-```
-
-Next, we add 2 new docks to the gui, one to plot the data of a camera and one to track the positions of two motors. 
-```ipython
-cam_widget= gui.add_dock(name="cam_dock").add_widget('BECFigure').image("eiger")
-motor_widget = gui.add_dock(name="mot_dock").add_widget('BECFigure').motor_map("samx", "samy")
-```
-Note, we chain commands here which is possible since the `add_dock` and `add_widget` methods return the dock and the widget respectively. We can now further customize the widgets by changing the title, axis labels, etc.
-
-```python
-cam_widget.set_title("Camera Image Eiger")
-cam_widget.set_vrange(vmin=0, vmax=100)
-```
-As a final step, we can now add also a SpiralProgressBar to a new dock, and perform a grid_scan with the motors *samx* and *samy*.
-As you see in the example below, all docks are arranged below each other. This is the default behavior of the `add_dock` method. However, the docks can be freely arranged by drag and drop as desired by the user. We invite you to explore this by yourself following the example in the video, and build your custom GUI with BEC Widgets.
-
-```python
-prog_bar = gui.add_dock(name="prog_dock").add_widget('SpiralProgressBar')
-prog_bar.set_line_widths(15)
-scans.grid_scan(dev.samy, -2, 2, 10, dev.samx, -5, 5, 10, exp_time=0.1, relative=False)
-```
-
-![gui_complex_gui](./gui_complex_gui.gif)
-

docs/user/installation.md

@@ -1,5 +1,7 @@
 (user.installation)=
 # Installation
+
+
 **Prerequisites**
 
 Before installing BEC Widgets, please ensure the following requirements are met:
@@ -9,17 +11,28 @@ Before installing BEC Widgets, please ensure the following requirements are met:
 
 **Standard Installation**
 
-To install BEC Widgets using the pip package manager, execute the following command in your terminal for getting the default PyQT6 version into your python environment for BEC:
-
+Install BEC Widgets using the pip package manager. Open your terminal and execute:
 
 ```bash
-pip install 'bec_widgets[pyqt6]'
+pip install bec_widgets
 ```
 
-In case you want to use PyQt5, you can install it by using the following command:
+This command installs BEC Widgets along with its dependencies, including the default PyQt6.
+
+**Selecting a PyQt Version**
+
+BEC Widgets supports both PyQt5 and PyQt6. To install a specific version, use:
+
+For PyQt6:
 
 ```bash
-pip install 'bec_widgets[pyqt5]'
+pip install bec_widgets[pyqt6]
+```
+
+For PyQt5:
+
+```bash
+pip install bec_widgets[pyqt5]
 ```
 
 **Troubleshooting**