feat:added launch script

Automatically generated by python-semantic-release

.git_hooks/pre-commit

@@ -1,2 +1,3 @@
-black --line-length=100 $(git diff --cached --name-only --diff-filter=ACM -- '***.py')
-git add $(git diff --cached --name-only --diff-filter=ACM -- '***.py')
+black --line-length=100 $(git diff --cached --name-only --diff-filter=ACM -- '*.py')
+isort --line-length=100 --profile=black --multi-line=3 --trailing-comma $(git diff --cached --name-only --diff-filter=ACM -- '*.py')
+git add $(git diff --cached --name-only --diff-filter=ACM -- '*.py')

.gitlab-ci.yml

@@ -1,33 +1,59 @@
 # This file is a template, and might need editing before it works on your project.
 # Official language image. Look for the different tagged releases at:
 # https://hub.docker.com/r/library/python/tags/
-image: $CI_DOCKER_REGISTRY/python:3.9
+image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
 #commands to run in the Docker container before starting each job.
 variables:
   DOCKER_TLS_CERTDIR: ""
+  BEC_CORE_BRANCH: "main"
+  OPHYD_DEVICES_BRANCH: "main"
+  CHILD_PIPELINE_BRANCH: $CI_DEFAULT_BRANCH
+
+workflow:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+    - if: $CI_PIPELINE_SOURCE == "web"
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+    - if: $CI_PIPELINE_SOURCE == "parent_pipeline"
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
+      when: never
+    - if: $CI_COMMIT_BRANCH
 
 include:
   - template: Security/Secret-Detection.gitlab-ci.yml
 
-
 # different stages in the pipeline
 stages:
   - Formatter
   - test
+  - AdditionalTests
+  - End2End
   - Deploy
 
+before_script:
+  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then 
+    echo -e "\033[35;1m Using branch $CHILD_PIPELINE_BRANCH of BEC Widgets \033[0;m";
+    test -d bec_widgets || git clone --branch $CHILD_PIPELINE_BRANCH https://gitlab.psi.ch/bec/bec_widgets.git; cd bec_widgets;
+    fi
+
 formatter:
   stage: Formatter
   needs: []
   script:
-    - pip install black
-    - black --check --diff --color --line-length=100 ./
+    - pip install black isort
+    - isort --check --diff ./
+    - black --check --diff --color ./
+  rules:
+    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
+
 pylint:
   stage: Formatter
   needs: []
-  script:
+  before_script:
     - pip install pylint pylint-exit anybadge
-    - pip install -e .[dev]
+    - pip install -e .[dev,pyqt6]
+  script:
     - mkdir ./pylint
     - pylint ./bec_widgets --output-format=text --output=./pylint/pylint.log | tee ./pylint/pylint.log || pylint-exit $?
     - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint.log)
@@ -37,6 +63,41 @@ pylint:
     paths:
       - ./pylint/
     expire_in: 1 week
+  rules:
+    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
+
+pylint-check:
+  stage: Formatter
+  needs: []
+  allow_failure: true
+  before_script:
+    - pip install pylint pylint-exit anybadge
+    - apt-get update
+    - apt-get install -y bc
+  script:
+    # Identify changed Python files
+    - if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then
+        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);
+      fi
+    - if [ -z "$CHANGED_FILES" ]; then echo "No Python files changed."; exit 0; fi
+
+    # Run pylint only on changed files
+    - mkdir ./pylint
+    - pylint $CHANGED_FILES --output-format=text . | tee ./pylint/pylint_changed_files.log || pylint-exit $?
+    - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint_changed_files.log)
+    - echo "Pylint score is $PYLINT_SCORE"
+
+    # Fail the job if the pylint score is below 9
+    - if [ "$(echo "$PYLINT_SCORE < 9" | bc)" -eq 1 ]; then echo "Your pylint score is below the acceptable threshold (9)."; exit 1; fi
+  artifacts:
+    paths:
+      - ./pylint/
+    expire_in: 1 week
+  rules:
+    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
 
 tests:
   stage: test
@@ -44,18 +105,205 @@ tests:
   variables:
       QT_QPA_PLATFORM: "offscreen"
   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 x11-utils libxkbcommon-x11-0 
-    - pip install .[dev]
-    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests
+    - 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
   coverage: '/(?i)total.*? (100(?:\.0+)?\%|[1-9]?\d(?:\.\d+)?\%)$/'
   artifacts:
     reports:
       junit: report.xml
-      cobertura: coverage.xml
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage.xml
 
+tests-3.10-pyside6:
+  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,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:
+  stage: End2End
+  needs: []
+  image: continuumio/miniconda3
+  allow_failure: false
+  variables:
+    QT_QPA_PLATFORM: "offscreen"
+  script:
+    - 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.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,pyside6]
+    - cd ./tests/end-2-end
+    - pytest --start-servers --flush-redis --random-order
+
+  artifacts:
+    when: on_failure
+    paths:
+      - ./logs/*.log
+    expire_in: 1 week
+
+  rules:
+    - if: '$CI_PIPELINE_SOURCE == "schedule"'
+    - if: '$CI_PIPELINE_SOURCE == "web"'
+    - if: '$CI_PIPELINE_SOURCE == "pipeline"'
+    - if: '$CI_PIPELINE_SOURCE == "parent_pipeline"'
+    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"'
+    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
 
 semver:
   stage: Deploy
@@ -71,31 +319,29 @@ semver:
     - git fetch --tags
     - git tag
 
-    # build
-    - pip install python-semantic-release==7.* wheel
+    # build and publish package
+    - pip install python-semantic-release==9.* wheel build twine
     - export GL_TOKEN=$CI_UPDATES
-    - export REPOSITORY_USERNAME=__token__
-    - export REPOSITORY_PASSWORD=$CI_PYPI_TOKEN
-    - >
-      semantic-release publish -v DEBUG 
-      -D version_variable=./setup.py:__version__  
-      -D hvcs=gitlab 
-      
+    - semantic-release -vv version
+    
+    # check if any artifacts were created
+    - if [ ! -d dist ]; then echo No release will be made; exit 0; fi
+    - twine upload dist/* -u __token__ -p $CI_PYPI_TOKEN --skip-existing
+    - semantic-release publish
+
   allow_failure: false
   rules:
-    - if: '$CI_COMMIT_REF_NAME == "master"'
+    - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
 
-# pages:
-#   stage: Deploy
-#   needs: ["tests"]
-#   script:
-#     - git clone --branch $OPHYD_DEVICES_BRANCH https://oauth2:$CI_OPHYD_DEVICES_KEY@gitlab.psi.ch/bec/ophyd_devices.git
-#     - export OPHYD_DEVICES_PATH=$PWD/ophyd_devices    
-#     - pip install -r ./docs/source/requirements.txt
-#     - apt-get install -y gcc
-#     - *install-bec-services    
-#     - cd ./docs/source; make html
-#     - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/beamline-experiment-control/221870/
-#   rules:
-#     - if: '$CI_COMMIT_REF_NAME == "master"'
-#     - if: '$CI_COMMIT_REF_NAME == "production"'
+pages:
+  stage: Deploy
+  needs: ["semver"]
+  variables:
+    TARGET_BRANCH: $CI_COMMIT_REF_NAME
+  rules:
+    - if: '$CI_COMMIT_TAG != null'
+      variables:
+        TARGET_BRANCH: $CI_COMMIT_TAG
+    - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
+  script:
+    - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/bec-widgets/253243/

.gitlab/issue_templates/bug_report_template.md

@@ -0,0 +1,17 @@
+## Bug report
+
+## Summary
+
+[Provide a brief description of the bug.]
+
+## Expected Behavior vs Actual Behavior
+
+[Describe what you expected to happen and what actually happened.]
+
+## Steps to Reproduce
+
+[Outline the steps that lead to the bug's occurrence. Be specific and provide a clear sequence of actions.]
+
+## Related Issues
+
+[Paste links to any related issues or feature requests.]

.gitlab/issue_templates/documentation_update_template.md

@@ -0,0 +1,27 @@
+## Documentation Section
+
+[Specify the section or page of the documentation that needs updating]
+
+## Current Information
+
+[Provide the current information in the documentation that needs to be updated]
+
+## Proposed Update
+
+[Describe the proposed update or correction. Be specific about the changes that need to be made]
+
+## Reason for Update
+
+[Explain the reason for the documentation update. Include any recent changes, new features, or corrections that necessitate the update]
+
+## Additional Context
+
+[Include any additional context or information that can help the documentation team understand the update better]
+
+## Attachments
+
+[Attach any files, screenshots, or references that can assist in making the documentation update]
+
+## Priority
+
+[Assign a priority level to the documentation update based on its urgency. Use a scale such as Low, Medium, High]

.gitlab/issue_templates/feature_request_template.md

@@ -0,0 +1,40 @@
+## Feature Summary
+
+[Provide a brief and clear summary of the new feature you are requesting]
+
+## Problem Description
+
+[Explain the problem or need that this feature aims to address. Be specific about the issues or gaps in the current functionality]
+
+## Use Case
+
+[Describe a real-world scenario or use case where this feature would be beneficial. Explain how it would improve the user experience or workflow]
+
+## Proposed Solution
+
+[If you have a specific solution in mind, describe it here. Explain how it would work and how it would address the problem described above]
+
+## Benefits
+
+[Explain the benefits and advantages of implementing this feature. Highlight how it adds value to the product or improves user satisfaction]
+
+## Alternatives Considered
+
+[If you've considered alternative solutions or workarounds, mention them here. Explain why the proposed feature is the preferred option]
+
+## Impact on Existing Functionality
+
+[Discuss how the new feature might impact or interact with existing features. Address any potential conflicts or dependencies]
+
+## Priority
+
+[Assign a priority level to the feature request based on its importance. Use a scale such as Low, Medium, High]
+
+## Attachments
+
+[Include any relevant attachments, such as sketches, diagrams, or references that can help the development team understand your feature request better]
+
+## Additional Information
+
+[Provide any additional information that might be relevant to the feature request, such as user feedback, market trends, or similar features in other products]
+

.gitlab/merge_request_templates/default.md

@@ -0,0 +1,28 @@
+## Description
+
+[Provide a brief description of the changes introduced by this merge request.]
+
+## Related Issues
+
+[Cite any related issues or feature requests that are addressed or resolved by this merge request. Use the gitlab syntax for linking issues, for example, `fixes #123` or `closes #123`.]
+
+## Type of Change
+
+- Change 1
+- Change 2
+
+## Potential side effects
+
+[Describe any potential side effects or risks of merging this MR.]
+
+## Screenshots / GIFs (if applicable)
+
+[Include any relevant screenshots or GIFs to showcase the changes made.]
+
+## Additional Comments
+
+[Add any additional comments or information that may be helpful for reviewers.]
+
+## Definition of Done
+- [ ] Documentation is up-to-date.
+

.pylintrc

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

.readthedocs.yaml

@@ -0,0 +1,25 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the version of Python and other tools you might need
+build:
+  os: ubuntu-20.04
+  tools:
+    python: "3.10"
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+   configuration: docs/conf.py
+
+# If using Sphinx, optionally build your docs in additional formats such as PDF
+# formats:
+#    - pdf
+
+# Optionally declare the Python requirements required to build your docs
+python:
+   install:
+   - requirements: docs/requirements.txt

CHANGELOG.md

@@ -1,142 +1,171 @@
-# Changelog
+# CHANGELOG
 
-<!--next-version-placeholder-->
 
-## v0.7.0 (2023-08-28)
+
+## v0.55.0 (2024-05-24)
 
 ### Feature
 
-* Labels of current motors are shown in motors limits ([`413e435`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/413e4356cfde6e2432682332e470eb69427ad397))
-* Total number of points, scatter size and number of point to dim after last position can be changed from GUI ([`e0b52fc`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/e0b52fcedca46d913d1677b45f9815eccd92e8f7))
-* Speed and frequency can be updated from GUI ([`f391a2f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f391a2fd004f1dc8187cfe12d60f856427ae01ec))
-* Speed and frequency is retrieved from devices ([`ce98164`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ce9816480b82373895b602d1a1bca7d1d9725f01))
-* Delete coordinate table row by DELETE or BACKSPACE key ([`5dd0af6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5dd0af6894a5d97457d60ef18b098e40856e4875))
-* Motor selection ([`cab32be`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cab32be0092185870b5a12398103475342c8b1fd))
-* New GUI ([`0226188`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0226188079f1dac4eece6b1a6fa330620f1504bc))
-* Keyboard shortcut to go to coordinates ([`3c0e595`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3c0e5955d40a67935b8fb064d5c52fd3f29bd1a1))
-* Ability to choose how many points should be dimmed before reaching the threshold + total number of point which should be stored. ([`9eae697`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9eae697df8a2f3961454db9ed397353f110c0e67))
-* Stop movement function, one callback function for 2 motors, move_finished is emitted in move_motor function not in callback ([`187c748`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/187c748e87264448d5026d9fa2f15b5fc9a55949))
-* Controls are disabled while motor is moving and enabled when motor movement is finished ([`ed84293`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ed842931971fbf87ed2f3e366eb822531ef5aacc))
-* Motor coordinates are now scatter instead of image ([`3f6d5c6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3f6d5c66411459703c402f7449e8b1abae9a2b08))
-* Going to absolute coordinates saves coordinate in the table for later use with tag ([`8be98c9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/8be98c9bb6af941a69c593c62d5c52339d2262bc))
-* Table with coordinates getting initial coordinates of motor ([`92388c3`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/92388c3cab7e024978aaa2906afbd698015dec66))
-* Motor move to absolute (X,Y) coordinates ([`cbe27e4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cbe27e46cfb6282c71844641e1ed6059e8fa96bf))
-* Motor limits can be changed by spinBoxes ([`2d1665c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/2d1665c76b8174d9fffa3442afa98fe1ea6ac207))
-* Switch for keyboard shortcuts for motor movement ([`cac4562`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cac45626fc9a315f9012b110760a92e27e5ed226))
-* Setting map according to motor limits ([`512e698`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/512e698e26d9eef05b4f430475ccc268b68ad632))
-* Map of motor position ([`e6952a6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/e6952a6d13c84487fd6ab08056f1f5b46d594b8a))
-* Motor_example.py created, motor samx and samy can be moved by buttons ([`947ba9f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/947ba9f8b730e96082cb51ff6894734a0e119ca1))
+* 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(reconstruction): repository structure is changed to separate assets needed for each widget ([`3455c60`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3455c602361d3b5cc3ff9190f9d2870474becf8a))
+
+* refactor(clean-up): 1st generation widgets are removed ([`edc25fb`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/edc25fbf9d5a0321e5f0a80b492b6337df807849))
+
+
+## v0.53.3 (2024-05-16)
 
 ### Fix
 
-* Line_plot.py default changed back to "gauss_bpm" ([`64708bc`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/64708bc1b2e6a4256da9123d0215fc87e0afa455))
-* Motor selection is disabled while motor is moving ([`c7e35d7`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c7e35d7da69853343aa7eee53c8ad988eb490d93))
-* Init_motor_map receive motor position from motor_thread ([`95ead71`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/95ead7117e59e0979aec51b85b49537ab728cad4))
-* Motor movement absolute fixed - movement by thread ([`11aa15f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/11aa15fefda7433e885cc8586f93c97af83b0c48))
+* fix: removed apparently unnecessary sleep while waiting for an rpc response ([`7d64cac`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7d64cac6610b39d3553ff650354f78ead8ee6b55))
 
-## v0.6.3 (2023-08-17)
+
+## v0.53.2 (2024-05-15)
+
+### Ci
+
+* ci: added echo to highlight the current branch ([`0490e80`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0490e80c48563e4fb486bce903b3ce1f08863e83))
 
 ### Fix
 
-* Crosshair handles dynamic changes of number of curves in 1D plot ([`242737b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/242737b516af7c524a6c8a98db566815f0f4ab65))
+* 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
 
-* Crosshair class documentation ([`8a60cad`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/8a60cad9187df2b2bc93dc78dd01ceb42df9c9af))
-
-## v0.6.2 (2023-08-17)
-
-### Fix
-
-* Correct coordinates for cursor table ([`ce54daf`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ce54daf754cb2410790216585467c0ffcc8e3587))
-
-## v0.6.1 (2023-08-14)
-
-### Fix
-
-* Crosshair snaps to correct coordinates also with logx and logy ([`167a891`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/167a891c474b09ef7738e473c4a2e89dbbcbe881))
-
-## v0.6.0 (2023-08-11)
+* docs: update install instructions ([`57ee735`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/57ee735e5c2436d45a285507cdc939daa20e8e8f))
 
 ### Feature
 
-* New GUI for line_plot.py ([`b57b3bb`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b57b3bb1afc7c85acc7ed328ac8a219f392869f1))
-* Cursor universal signals ([`20e9516`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/20e951659558b7fc023e357bfe07d812c5fd020a))
-
-## v0.5.0 (2023-08-11)
-
-### Feature
-
-* Add generic connect function for slots ([`6a3df34`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/6a3df34cdfbec2434153362ded630305e5dc5e28))
-* Add possibility to provide service config ([`8c9a9c9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/8c9a9c93535ee77c0622b483a3157af367ebce1f))
+* feat: moved to pyproject.toml; closes #162 ([`c86ce30`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c86ce302a964d71ee631f0817609ab5aa0e3ab0f))
 
 ### Fix
 
-* Dispatcher argparse and scan_plot tests ([`67f619e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/67f619ee897e0040c6310e67d69fbb2e0685293d))
-* Gui event removing bugs ([`a9dd191`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a9dd191629295ca476e2f9a1b9944ff355216583))
+* fix: fixed semver job and upgraded to v9 ([`32e1a9d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/32e1a9d8472eb1c25d30697d407a8ffecd04e75d))
 
-## v0.4.0 (2023-08-11)
+### Refactor
 
-### Feature
+* refactor: applied formatter ([`4117fd7`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4117fd7b5b2090ff4fb7ad9e0d92cc87cd13ed5f))
 
-* Cursor universal for 1D and 2D ([`f75554b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f75554bd7b072207847956a8720b9a62c20ba2c8))
-* Added qt_utils package with general Crosshair function ([`5353fed`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5353fed7bfe1819819fa3348ec93d2d0ba540628))
-* 2D plot updating ([`d32088b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d32088b643a4d0613c32fb464a0a55a3b6b684d6))
-* Metadata available on_dap_update ([`18b5d46`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/18b5d46678619a972815532629ce96c121f5fcc9))
-* Plotting from streamer ([`bb806c1`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/bb806c149dee88023ecb647b523cbd5189ea9001))
-* Added Legend to plot ([`0feca4b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0feca4b1578820ec1f5f3ead3073e4d45c23798b))
-* Cursor coordinate as a QTable ([`a999f76`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a999f7669a12910ad66e10a6d2e75197b2dce1c2))
-* Changed from PlotItem to GraphicsLayoutWidget, added LabelItem ([`075cc79`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/075cc79d6fa011803cf4a06fbff8faa951c1b59f))
-* Add display_ui_file.py ([`91d8ffa`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/91d8ffacffcbeebdf7623caf62e07244c4dcee16))
-* Add disconnect_dap_slot ([`1325704`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1325704750ebab897e3dcae80c9d455bfbbf886f))
-* Inherit from GraphicsView for consistency with 2D plot ([`d8c101c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d8c101cdd7f960a152a1f318911cac6eecf6bad4))
-* Add BECScanPlot2D ([`67905e8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/67905e896c81383f57c268db544b3314104bda38))
-* Emit the full bec message to slots ([`1bb3020`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1bb30207038f3a54c0e96dbbbcd1ea7f6c70eca2))
+
+## v0.52.1 (2024-05-08)
 
 ### Fix
 
-* Q selection for gui_event signal ([`0bf452a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0bf452ad1b7d9ad941e2ef4b8d61ec4ed5266415))
-* Fixed logic in data subscription ([`c2d469b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c2d469b4543fcf237b274399b83969cc2213b61b))
-* Scan_plot to accept metadata from dap signal ([`7bec0b5`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/7bec0b5e6c1663670f8fcc2fc6aa6c8b6df28b61))
-* Plotting latest 1d curves ([`378be81`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/378be81bf6dd5e9239f8f1fb908cafc97161c79d))
-* Testing the data structure of plotting ([`4fb0a3b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4fb0a3b058957f5b37227ff7c8e9bdf5259a1cde))
-* Fix examples when run directly as a script ([`cd11ee5`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cd11ee51c1c725255e748a32b89a74487e84a631))
-* Module paths ([`e7f644c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/e7f644c5079a8665d7d872eb0b27ed7da6cbd078))
+* fix(docstrings): docstrings formating fixed for sphinx to properly format readdocs ([`7f2f7cd`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7f2f7cd07a14876617cd83cedde8c281fdc52c3a))
 
-## v0.3.0 (2023-07-19)
+
+## v0.52.0 (2024-05-07)
+
+### Ci
+
+* ci: fixed support for child pipelines ([`e65c7f3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e65c7f3be895ada407bd358edf67d569d2cab08e))
 
 ### Feature
 
-* Add auto-computed color_list from colormaps ([`3e1708b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3e1708bf48bc15a25c0d01242fff28d6db868e02))
-* Add functionality for plotting multiple signals ([`10e2906`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/10e29064455f50bc3b66c55b4361575957db1489))
-* Added lineplot widget ([`989a3f0`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/989a3f080839b98f1e1c2118600cddf449120124))
-* Added ctrl_c from grum ([`8fee13a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/8fee13a67bef3ed6ed6de9d47438f04687f548d8))
+* 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
 
-* Add warning for non-existing signalz ([`48075e4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/48075e4fe3187f6ac8d0b61f94f8df73b8fd6daf))
-* Documentation and bugfix for mouse_moved ([`a460f3c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a460f3c0bd7b9e106a758bc330f361868407b1e3))
+* fix(widgets/dock): BECDockArea close overwrites the default pyqtgraph Container close + minor improvements ([`ceae979`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ceae979f375ecc33c5c97148f197655c1ca57b6c))
 
-### Documentation
+### Refactor
 
-* Add notes about qt designer install via conda-forge ([`d8038a8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d8038a8cd0efa3a16df403390164603e4e8afdd8))
-* Added license ([`db2d33e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/db2d33e8912dc493cce9ee7f09d8336155110079))
+* refactor(widget/plots): WidgetConfig changed to SubplotConfig ([`03fa1f2`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/03fa1f26d0fa6b58ed05556fb2438d1e62f6c107))
 
-## v0.2.1 (2023-07-13)
+
+## 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
 
-* Fixed setup config (wrong name) ([`947db1e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/947db1e0f32b067e67f94a7c8321da5194b1547b))
-* Fixed bec_lib dependency ([`86f4def`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/86f4deffd899111e8997010487ec54c6c62c43ab))
+* fix: &#39;disconnect_slot&#39; has to be symmetric with &#39;connect_slot&#39; regarding QtThreadSafeCallback ([`0dfcaa4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0dfcaa4b708948af0a40ec7cf34d03ff1e96ffac))
 
-## v0.2.0 (2023-07-13)
+
+## 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
 
-* Move ivan's qtwidgets to bec-widgets ([`34e5ed2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/34e5ed2cf7e6128a51c110db8870d9560f2b2831))
+* feat(plots): universal cleanup and remove also for children items ([`381d713`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/381d713837bb9217c58ba1d8b89691aa35c9f5ec))
 
-## v0.1.0 (2023-07-11)
+* feat(rpc/rpc_register): singleton rpc register for all rpc connections for session ([`a898e7e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a898e7e4f14e9ae854703dddbd1eb8c50cb640ff))
 
-### Feature
+### Fix
 
-* Added config plotter ([`db274c6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/db274c644f643f830c35b6a92edd328bf7e24f59))
+* 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)

README.md

@@ -1,2 +1,74 @@
 # BEC Widgets
 
+BEC Widgets is a GUI framework designed for interaction with [BEC (Beamline Experiment Control)](https://gitlab.psi.ch/bec/bec).
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install BEC Widgets:
+
+```bash
+pip install bec_widgets PyQt6
+```
+
+For development purposes, you can clone the repository and install the package locally in editable mode:
+
+```bash
+git clone https://gitlab.psi.ch/bec/bec-widgets
+cd bec_widgets
+pip install -e .[dev,pyqt6]
+```
+
+BEC Widgets currently supports both PyQt5 and PyQt6, however, no default distribution is specified. As a result, users must install one of the supported
+Python Qt distributions manually.
+
+To select a specific Python Qt distribution, install the package with an additional tag:
+
+```bash
+pip install bec_widgets[pyqt6]
+```
+or 
+
+```bash
+pip install bec_widgets[pyqt5]
+```
+## Documentation
+
+Documentation of BEC Widgets can be found [here](https://bec-widgets.readthedocs.io/en/latest/). The documentation of the BEC can be found [here](https://bec.readthedocs.io/en/latest/).
+
+## Contributing
+
+All commits should use the Angular commit scheme:
+
+> #### <a name="commit-header"></a>Angular Commit Message Header
+> 
+> ```
+> <type>(<scope>): <short summary>
+>   │       │             │
+>   │       │             └─⫸ Summary in present tense. Not capitalized. No period at the end.
+>   │       │
+>   │       └─⫸ Commit Scope: animations|bazel|benchpress|common|compiler|compiler-cli|core|
+>   │                          elements|forms|http|language-service|localize|platform-browser|
+>   │                          platform-browser-dynamic|platform-server|router|service-worker|
+>   │                          upgrade|zone.js|packaging|changelog|docs-infra|migrations|ngcc|ve|
+>   │                          devtools
+>   │
+>   └─⫸ Commit Type: build|ci|docs|feat|fix|perf|refactor|test
+> ```
+> 
+> The `<type>` and `<summary>` fields are mandatory, the `(<scope>)` field is optional.
+
+> ##### Type
+> 
+> Must be one of the following:
+> 
+> * **build**: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
+> * **ci**: Changes to our CI configuration files and scripts (examples: CircleCi, SauceLabs)
+> * **docs**: Documentation only changes
+> * **feat**: A new feature
+> * **fix**: A bug fix
+> * **perf**: A code change that improves performance
+> * **refactor**: A code change that neither fixes a bug nor adds a feature
+> * **test**: Adding missing tests or correcting existing tests
+
+## License
+
+[BSD-3-Clause](https://choosealicense.com/licenses/bsd-3-clause/)

bec_widgets/basic_plot.py

@@ -1,457 +0,0 @@
-import os
-import threading
-import time
-import warnings
-from typing import Any
-
-import numpy as np
-import pyqtgraph
-import pyqtgraph as pg
-from bec_lib.core import BECMessage
-from PyQt5.QtCore import pyqtSlot
-from PyQt5.QtWidgets import QCheckBox, QTableWidgetItem
-from pyqtgraph import mkBrush, mkColor, mkPen
-from pyqtgraph.Qt import QtCore, QtWidgets, uic
-from pyqtgraph.Qt.QtCore import pyqtSignal
-
-from bec_widgets.bec_dispatcher import bec_dispatcher
-from bec_lib.core.redis_connector import MessageObject, RedisConnector
-
-client = bec_dispatcher.client
-
-
-class BasicPlot(QtWidgets.QWidget):
-    update_signal = pyqtSignal()
-    roi_signal = pyqtSignal(tuple)
-
-    def __init__(self, name="", y_value_list=["gauss_bpm"]) -> 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"].
-        """
-
-        super(BasicPlot, self).__init__()
-        # Set style for pyqtgraph plots
-        pg.setConfigOption("background", "w")
-        pg.setConfigOption("foreground", "k")
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "basic_plot.ui"), self)
-
-        # Set splitter distribution of widgets
-        self.splitter.setSizes([3, 1])
-
-        self._idle_time = 100
-        self.title = ""
-        self.label_bottom = ""
-        self.label_left = ""
-        self.producer = RedisConnector(["localhost:6379"]).producer()
-
-        self.scan_motors = []
-        self.y_value_list = y_value_list
-        self.previous_y_value_list = None
-        self.plotter_data_x = []
-        self.plotter_data_y = []
-        self.curves = []
-        self.pens = []
-        self.brushs = []
-
-        self.plotter_scan_id = None
-
-        # TODO to be moved to utils function
-        plotstyles = {
-            "symbol": "o",
-            "symbolSize": 10,
-        }
-
-        color_list = BasicPlot.golden_angle_color(colormap="CET-R2", num=len(self.y_value_list))
-
-        # setup plots - GraphicsLayoutWidget
-        # LabelItem
-        self.label = pg.LabelItem(justify="center")
-        self.glw.addItem(self.label)
-        self.label.setText("ROI region")
-
-        # PlotItem - main window
-        self.glw.nextRow()
-        self.plot = pg.PlotItem()
-        self.plot.setLogMode(True, True)
-        self.glw.addItem(self.plot)
-        self.plot.addLegend()
-
-        # ImageItem - 2D view #TODO add 2D plot for ROI and 1D plot for mouse click
-        self.glw.nextRow()
-        self.plot_roi = pg.PlotItem()
-        self.img = pg.ImageItem()
-        self.glw.addItem(self.plot_roi)
-        self.plot_roi.addItem(self.img)
-
-        # ROI selector - so far from [-1,1] #TODO update to scale with xrange
-        self.roi_selector = pg.LinearRegionItem([-1, 1])
-
-        for ii, y_value in enumerate(self.y_value_list):
-            pen = mkPen(color=color_list[ii], width=2, style=QtCore.Qt.DashLine)
-            brush = mkBrush(color=color_list[ii])
-            curve = pg.PlotDataItem(
-                **plotstyles, 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)
-
-        self.add_crosshair(self.plot)
-        self.add_crosshair(self.plot_roi)
-
-        self.crosshair_v = pg.InfiniteLine(angle=90, movable=False)
-        self.crosshair_h = pg.InfiniteLine(angle=0, movable=False)
-        #
-        # for plot in (self.plot_roi, self.plot):
-        #     plot.addItem(self.crosshair_v, ignoreBounds=True)
-        #     plot.addItem(self.crosshair_h, ignoreBounds=True)
-
-        # self.plot.addItem(self.crosshair_v, ignoreBounds=True)
-        # self.plot.addItem(self.crosshair_h, ignoreBounds=True)
-
-        # self.plot_roi.addItem(self.crosshair_v, ignoreBounds=True)
-        # self.plot_roi.addItem(self.crosshair_h, ignoreBounds=True)
-
-        # Add textItems
-        self.add_text_items()
-
-        # Manage signals
-        self.proxy = pg.SignalProxy(
-            self.plot.scene().sigMouseMoved, rateLimit=60, slot=self.mouse_moved
-        )
-        self.proxy_update = pg.SignalProxy(self.update_signal, rateLimit=25, slot=self.update)
-        self.roi_selector.sigRegionChangeFinished.connect(self.get_roi_region)
-
-        # Debug functions
-        self.pushButton_debug.clicked.connect(self.generate_2D_data_update)
-        # self.generate_2D_data()
-
-        self._current_proj = None
-        self._current_metadata_ep = "px_stream/projection_{}/metadata"
-
-        self.data_retriever = threading.Thread(target=self.on_projection, daemon=True)
-        self.data_retriever.start()
-
-    def debug(self):
-        """
-        Debug button just for quick testing
-        """
-
-    def generate_2D_data(self):
-        data = np.random.normal(size=(1, 100))
-        self.img.setImage(data)
-
-    def generate_2D_data_update(self):
-        data = np.random.normal(size=(200, 300))
-        self.img.setImage(data, levels=(0.2, 0.5))
-
-    def add_crosshair(self, plot):
-        crosshair_v = pg.InfiniteLine(angle=90, movable=False)
-        crosshair_h = pg.InfiniteLine(angle=0, movable=False)
-
-        plot.addItem(crosshair_v)
-        plot.addItem(crosshair_h)
-
-    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.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 = BECMessage.DeviceMessage(signals=return_dict).dumps()
-        self.producer.set_and_publish("px_stream/gui_event", msg=msg)
-        self.roi_signal.emit(region)
-
-    def add_text_items(self):  # TODO probably can be removed
-        """Add text items to the plot"""
-
-        # self.mouse_box_data.setText("Mouse cursor")
-        # TODO Via StyleSheet, one may set the color of the full QLabel
-        # self.mouse_box_data.setStyleSheet(f"QLabel {{color : rgba{self.pens[0].color().getRgb()}}}")
-
-    def mouse_moved(self, event: tuple) -> None:
-        """
-        Update the mouse table with the current mouse position and the corresponding data.
-
-        Args:
-            event (tuple):  Mouse event containing the position of the mouse cursor.
-                            The position is stored in first entry as horizontal, vertical pixel.
-        """
-        pos = event[0]
-        if not self.plot.sceneBoundingRect().contains(pos):
-            return
-        mousePoint = self.plot.vb.mapSceneToView(pos)
-        self.crosshair_v.setPos(mousePoint.x())
-        self.crosshair_h.setPos(mousePoint.y())
-        if not self.plotter_data_x:
-            return
-
-        closest_point = self.closest_x_y_value(
-            mousePoint.x(), self.plotter_data_x[0], self.plotter_data_y[0]
-        )
-        # self.precision = 3
-        # ii = 0
-        # y_value = self.y_value_list[ii]
-        # x_data = f"{10**closest_point[0]:.{self.precision}f}"
-        # y_data = f"{10**closest_point[1]:.{self.precision}f}"
-        #
-        # # Write coordinate to QTable
-        # self.mouse_table.setItem(ii, 1, QTableWidgetItem(str(y_value)))
-        # self.mouse_table.setItem(ii, 2, QTableWidgetItem(str(x_data)))
-        # self.mouse_table.setItem(ii, 3, QTableWidgetItem(str(y_data)))
-        #
-        # self.mouse_table.resizeColumnsToContents()
-
-    def closest_x_y_value(self, input_value, list_x, list_y) -> tuple:
-        """
-        Find the closest x and y value to the input value.
-
-        Args:
-            input_value (float): Input value
-            list_x (list): List of x values
-            list_y (list): List of y values
-
-        Returns:
-            tuple: Closest x and y value
-        """
-        arr = np.asarray(list_x)
-        i = (np.abs(arr - input_value)).argmin()
-        return list_x[i], list_y[i]
-
-    def update(self):
-        """Update the plot with the new data."""
-        # check if roi selector is in the plot
-        if self.roi_selector not in self.plot.items:
-            self.plot.addItem(self.roi_selector)
-
-        # 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])
-        # if len(self.plotter_data_x[0]) <= 1:
-        #     return
-        # self.plot.setLabel("bottom", self.label_bottom)
-        # self.plot.setLabel("left", self.label_left)
-        # for ii in range(len(self.y_value_list)):
-        #     self.curves[0].setData(self.plotter_data_x[0], self.plotter_data_y[0])
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, data: dict, metadata: dict) -> None:
-        """Update function that is called during the scan callback. To avoid
-        too many renderings, the GUI is only processing events every <_idle_time> ms.
-
-        Args:
-            data (dict): Dictionary containing a new scan segment
-            metadata (dict): Scan metadata
-
-        """
-        if metadata["scanID"] != self.plotter_scan_id:
-            self.plotter_scan_id = metadata["scanID"]
-            self._reset_plot_data()
-
-        self.title = f"Scan {metadata['scan_number']}"
-
-        self.scan_motors = scan_motors = metadata.get("scan_report_devices")
-        # client = BECClient()
-        remove_y_value_index = [
-            index
-            for index, y_value in enumerate(self.y_value_list)
-            if y_value not in client.device_manager.devices
-        ]
-        if remove_y_value_index:
-            for ii in sorted(remove_y_value_index, reverse=True):
-                # TODO Use bec warning message??? to be discussed with Klaus
-                warnings.warn(
-                    f"Warning: no matching signal for {self.y_value_list[ii]} found in list of devices. Removing from plot."
-                )
-                self.remove_curve_by_name(self.plot, self.y_value_list[ii])
-                self.y_value_list.pop(ii)
-
-        self.precision = client.device_manager.devices[scan_motors[0]]._info["describe"][
-            scan_motors[0]
-        ]["precision"]
-        # TODO after update of bec_lib, this will be new way to access data
-        # self.precision = client.device_manager.devices[scan_motors[0]].precision
-
-        x = data["data"][scan_motors[0]][scan_motors[0]]["value"]
-        self.plotter_data_x.append(x)
-        for ii, y_value in enumerate(self.y_value_list):
-            y = data["data"][y_value][y_value]["value"]
-            self.plotter_data_y[ii].append(y)
-        self.label_bottom = scan_motors[0]
-        self.label_left = f"{', '.join(self.y_value_list)}"
-
-        # print(f'metadata scan N{metadata["scan_number"]}') #TODO put as label on top of plot
-        # print(f'Data point = {data["point_id"]}') #TODO can be used for progress bar
-
-        if len(self.plotter_data_x) <= 1:
-            return
-        self.update_signal.emit()
-
-    def _reset_plot_data(self):
-        """Reset the plot data."""
-        self.plotter_data_x = []
-        self.plotter_data_y = []
-        for ii in range(len(self.y_value_list)):
-            self.curves[ii].setData([], [])
-            self.plotter_data_y.append([])
-
-    def setup_cursor_table(self):
-        """QTable formatting according to N of devices displayed in plot."""
-
-        # Init number of rows in table according to n of devices
-        self.mouse_table.setRowCount(len(self.y_value_list))
-
-        for ii, y_value in enumerate(self.y_value_list):
-            checkbox = QCheckBox()
-            checkbox.setChecked(True)
-            # TODO just for testing, will be replaced by removing/adding curve
-            checkbox.stateChanged.connect(lambda: print("status Changed"))
-            # checkbox.stateChanged.connect(lambda: self.remove_curve_by_name(plot=self.plot, checkbox=checkbox, name=y_value))
-            self.mouse_table.setCellWidget(ii, 0, checkbox)
-            self.mouse_table.setItem(ii, 1, QTableWidgetItem(str(y_value)))
-
-            self.mouse_table.resizeColumnsToContents()
-
-    @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
-
-    @staticmethod
-    def golden_ratio(num: int) -> list:
-        """Calculate the golden ratio for a given number of angles.
-
-        Args:
-            num (int): Number of angles
-        """
-        phi = 2 * np.pi * ((1 + np.sqrt(5)) / 2)
-        angles = []
-        for ii in range(num):
-            x = np.cos(ii * phi)
-            y = np.sin(ii * phi)
-            angle = np.arctan2(y, x)
-            angles.append(angle)
-        return angles
-
-    @staticmethod
-    def golden_angle_color(colormap: str, num: int) -> list:
-        """
-        Extract num colors for from the specified colormap following golden angle distribution.
-
-        Args:
-            colormap (str): Name of the colormap
-            num (int): Number of requested colors
-
-        Returns:
-            list: List of colors with length <num>
-
-        Raises:
-            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
-        """
-
-        cmap = pg.colormap.get(colormap)
-        cmap_colors = cmap.color
-        if num > len(cmap_colors):
-            raise ValueError(
-                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
-            )
-        angles = BasicPlot.golden_ratio(len(cmap_colors))
-        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
-        colors = [
-            mkColor(tuple((cmap_colors[int(ii)] * 255).astype(int))) for ii in color_selection[:num]
-        ]
-        return colors
-
-    def on_projection(self):
-        while True:
-            if self._current_proj is None:
-                time.sleep(0.1)
-                continue
-            endpoint = f"px_stream/projection_{self._current_proj}/data"
-            msgs = client.producer.lrange(topic=endpoint, start=-1, end=-1)
-            data = [BECMessage.DeviceMessage.loads(msg) for msg in 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()
-
-    @pyqtSlot(dict, dict)
-    def on_dap_update(self, data: dict, metadata: dict):
-        self.img.setImage(data["z"].T)
-        # time.sleep(0,1)
-
-    @pyqtSlot(dict)
-    def new_proj(self, data):
-        proj_nr = data["proj_nr"]
-        endpoint = f"px_stream/projection_{proj_nr}/metadata"
-        msg_raw = client.producer.get(topic=endpoint)
-        msg = BECMessage.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
-    from bec_widgets.bec_dispatcher import bec_dispatcher
-
-    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 = bec_dispatcher.client
-    # client.start()
-    app = QtWidgets.QApplication([])
-    ctrl_c.setup(app)
-    plot = BasicPlot(y_value_list=value.signals)
-    # bec_dispatcher.connect(plot)
-    bec_dispatcher.connect_proj_id(plot.new_proj)
-    bec_dispatcher.connect_dap_slot(plot.on_dap_update, "px_dap_worker")
-    plot.show()
-    # client.callbacks.register("scan_segment", plot, sync=False)
-    app.exec_()

bec_widgets/basic_plot.ui

@@ -1,77 +0,0 @@
-<?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="QHBoxLayout" name="horizontalLayout">
-   <item>
-    <widget class="QSplitter" name="splitter">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="opaqueResize">
-      <bool>false</bool>
-     </property>
-     <widget class="QWidget" name="verticalLayoutWidget">
-      <layout class="QVBoxLayout" name="verticalLayout">
-       <item>
-        <widget class="QPushButton" name="pushButton_debug">
-         <property name="text">
-          <string>Debug</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="GraphicsLayoutWidget" name="glw"/>
-       </item>
-      </layout>
-     </widget>
-     <widget class="QTableWidget" name="mouse_table">
-      <property name="textElideMode">
-       <enum>Qt::ElideMiddle</enum>
-      </property>
-      <column>
-       <property name="text">
-        <string>Display</string>
-       </property>
-      </column>
-      <column>
-       <property name="text">
-        <string>Device</string>
-       </property>
-      </column>
-      <column>
-       <property name="text">
-        <string>X</string>
-       </property>
-      </column>
-      <column>
-       <property name="text">
-        <string>Y</string>
-       </property>
-      </column>
-     </widget>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>GraphicsLayoutWidget</class>
-   <extends>QGraphicsView</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>

bec_widgets/bec_dispatcher.py

@@ -1,227 +0,0 @@
-import argparse
-import itertools
-import os
-from dataclasses import dataclass
-from threading import RLock
-
-from bec_lib import BECClient
-from bec_lib.core import BECMessage, MessageEndpoints, ServiceConfig
-from bec_lib.core.redis_connector import RedisConsumerThreaded
-from PyQt5.QtCore import QObject, pyqtSignal
-
-
-@dataclass
-class _BECDap:
-    """Utility class to keep track of slots associated with a particular dap redis consumer"""
-
-    consumer: RedisConsumerThreaded
-    slots = set()
-
-
-# Adding a new pyqt signal requres a class factory, as they must be part of the class definition
-# and cannot be dynamically added as class attributes after the class has been defined.
-_signal_class_factory = (
-    type(f"Signal{i}", (QObject,), dict(signal=pyqtSignal("PyQt_PyObject")))
-    for i in itertools.count()
-)
-
-
-@dataclass
-class _Connection:
-    """Utility class to keep track of slots connected to a particular redis consumer"""
-
-    consumer: RedisConsumerThreaded
-    slots = set()
-    # keep a reference to a new signal class, so it is not gc'ed
-    _signal_container = next(_signal_class_factory)()
-
-    def __post_init__(self):
-        self.signal = self._signal_container.signal
-
-
-class _BECDispatcher(QObject):
-    new_scan = pyqtSignal(dict, dict)
-    scan_segment = pyqtSignal(dict, dict)
-    new_dap_data = pyqtSignal(dict, dict)
-
-    new_projection_id = pyqtSignal(dict)
-    new_projection_data = pyqtSignal(dict)
-
-    def __init__(self, bec_config=None):
-        super().__init__()
-        self.client = BECClient()
-
-        # TODO: this is a workaround for now to provide service config within qtdesigner, but is
-        # it possible to provide config via a cli arg?
-        if bec_config is None and os.path.isfile("bec_config.yaml"):
-            bec_config = "bec_config.yaml"
-
-        self.client.initialize(config=ServiceConfig(config_path=bec_config))
-
-        self._slot_signal_map = {
-            "on_scan_segment": self.scan_segment,
-            "on_new_scan": self.new_scan,
-        }
-        self._daps = {}
-        self._connections = {}
-
-        self._scan_id = None
-        scan_lock = RLock()
-
-        # self.new_projection_id.connect(self.new_projection_data)
-
-        def _scan_segment_cb(msg):
-            msg = BECMessage.ScanMessage.loads(msg.value)[0]
-            with scan_lock:
-                # TODO: use ScanStatusMessage instead?
-                scan_id = msg.content["scanID"]
-                if self._scan_id != scan_id:
-                    self._scan_id = scan_id
-                    self.new_scan.emit(msg.content, msg.metadata)
-            self.scan_segment.emit(msg.content, msg.metadata)
-
-        scan_segment_topic = MessageEndpoints.scan_segment()
-        self._scan_segment_thread = self.client.connector.consumer(
-            topics=scan_segment_topic,
-            cb=_scan_segment_cb,
-        )
-        self._scan_segment_thread.start()
-
-    def connect(self, widget):
-        for slot_name, signal in self._slot_signal_map.items():
-            slot = getattr(widget, slot_name, None)
-            if callable(slot):
-                signal.connect(slot)
-
-    def connect_slot(self, slot, topic):
-        # create new connection for topic if it doesn't exist
-        if topic not in self._connections:
-
-            def cb(msg):
-                msg = BECMessage.MessageReader.loads(msg.value)
-                self._connections[topic].signal.emit(msg)
-
-            consumer = self.client.connector.consumer(topics=topic, cb=cb)
-            consumer.start()
-
-            self._connections[topic] = _Connection(consumer)
-
-        # connect slot if it's not connected
-        if slot not in self._connections[topic].slots:
-            self._connections[topic].signal.connect(slot)
-            self._connections[topic].slots.add(slot)
-
-    def disconnect_slot(self, slot, topic):
-        if topic not in self._connections:
-            return
-
-        if slot not in self._connections[topic].slots:
-            return
-
-        self._connections[topic].signal.disconnect(slot)
-        self._connections[topic].slots.remove(slot)
-
-        if not self._connections[topic].slots:
-            # shutdown consumer if there are no more connected slots
-            self._connections[topic].consumer.shutdown()
-            del self._connections[topic]
-
-    def connect_dap_slot(self, slot, dap_name):
-        if dap_name not in self._daps:
-            # create a new consumer and connect slot
-
-            def _dap_cb(msg):
-                msg = BECMessage.ProcessedDataMessage.loads(msg.value)
-                self.new_dap_data.emit(msg.content["data"], msg.metadata)
-
-            dap_ep = MessageEndpoints.processed_data(dap_name)
-            consumer = self.client.connector.consumer(topics=dap_ep, cb=_dap_cb)
-            consumer.start()
-
-            self.new_dap_data.connect(slot)
-
-            self._daps[dap_name] = _BECDap(consumer)
-            self._daps[dap_name].slots.add(slot)
-
-        else:
-            # connect slot if it's not yet connected
-            if slot not in self._daps[dap_name].slots:
-                self.new_dap_data.connect(slot)
-                self._daps[dap_name].slots.add(slot)
-
-    def disconnect_dap_slot(self, slot, dap_name):
-        if dap_name not in self._daps:
-            return
-
-        if slot not in self._daps[dap_name].slots:
-            return
-
-        self.new_dap_data.disconnect(slot)
-        self._daps[dap_name].slots.remove(slot)
-
-        if not self._daps[dap_name].slots:
-            # shutdown consumer if there are no more connected slots
-            self._daps[dap_name].consumer.shutdown()
-            del self._daps[dap_name]
-
-    # def connect_proj_data(self, slot):
-    #     keys = self.client.producer.keys("px_stream/projection_*")
-    #     keys = keys or []
-    #
-    #     def _dap_cb(msg):
-    #         msg = BECMessage.DeviceMessage.loads(msg.value)
-    #         self.new_projection_data.emit(msg.content["data"])
-    #
-    #     proj_numbers = set(key.decode().split("px_stream/projection_")[1].split("/")[0] for key in keys)
-    #     last_proj_id = sorted(proj_numbers)[-1]
-    #     dap_ep = MessageEndpoints.processed_data(f"px_stream/projection_{last_proj_id}/")
-    #
-    #     consumer = self.client.connector.consumer(topics=dap_ep, cb=_dap_cb)
-    #     consumer.start()
-    #
-    #     self.new_projection_data.connect(slot)
-
-    def connect_proj_id(self, slot):
-        def _dap_cb(msg):
-            msg = BECMessage.DeviceMessage.loads(msg.value)
-            self.new_projection_id.emit(msg.content["signals"])
-
-        dap_ep = "px_stream/proj_nr"
-        consumer = self.client.connector.consumer(topics=dap_ep, cb=_dap_cb)
-        consumer.start()
-
-        self.new_projection_id.connect(slot)
-
-    def connect_proj_data(self, slot: object, data_ep: str) -> object:
-        def _dap_cb(msg):
-            msg = BECMessage.DeviceMessage.loads(msg.value)
-            self.new_projection_data.emit(msg.content["signals"])
-
-        consumer = self.client.connector.consumer(topics=data_ep, cb=_dap_cb)
-        consumer.start()
-        self._daps[data_ep] = _BECDap(consumer)
-        self._daps[data_ep].slots.add(slot)
-
-        self.new_projection_data.connect(slot)
-
-    def disconnect_proj_data(self, slot, data_ep):
-        if data_ep not in self._daps:
-            return
-
-        if slot not in self._daps[data_ep].slots:
-            return
-
-        self.new_projection_data.disconnect(slot)
-        self._daps[data_ep].slots.remove(slot)
-
-        if not self._daps[data_ep].slots:
-            # shutdown consumer if there are no more connected slots
-            self._daps[data_ep].consumer.shutdown()
-            del self._daps[data_ep]
-
-
-parser = argparse.ArgumentParser()
-parser.add_argument("--bec-config", default=None)
-args, _ = parser.parse_known_args()
-
-bec_dispatcher = _BECDispatcher(args.bec_config)

bec_widgets/cli/__init__.py

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

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from .client import BECFigure
+
+
+class ScanInfo(BaseModel):
+    scan_id: str
+    scan_number: int
+    scan_name: str
+    scan_report_devices: list
+    monitored_devices: list
+    status: str
+
+
+class AutoUpdates:
+    def __init__(self, figure: BECFigure, enabled: bool = True):
+        self.enabled = enabled
+        self.figure = figure
+
+    @staticmethod
+    def get_scan_info(msg) -> ScanInfo:
+        """
+        Update the script with the given data.
+        """
+        info = msg.info
+        status = msg.status
+        scan_id = msg.scan_id
+        scan_number = info.get("scan_number", 0)
+        scan_name = info.get("scan_name", "Unknown")
+        scan_report_devices = info.get("scan_report_devices", [])
+        monitored_devices = info.get("readout_priority", {}).get("monitored", [])
+        monitored_devices = [dev for dev in monitored_devices if dev not in scan_report_devices]
+        return ScanInfo(
+            scan_id=scan_id,
+            scan_number=scan_number,
+            scan_name=scan_name,
+            scan_report_devices=scan_report_devices,
+            monitored_devices=monitored_devices,
+            status=status,
+        )
+
+    def run(self, msg):
+        """
+        Run the update function if enabled.
+        """
+        if not self.enabled:
+            return
+        if msg.status != "open":
+            return
+        info = self.get_scan_info(msg)
+        self.handler(info)
+
+    @staticmethod
+    def get_selected_device(monitored_devices, selected_device):
+        """
+        Get the selected device for the plot. If no device is selected, the first
+        device in the monitored devices list is selected.
+        """
+        if selected_device:
+            return selected_device
+        if len(monitored_devices) > 0:
+            sel_device = monitored_devices[0]
+            return sel_device
+        return None
+
+    def handler(self, info: ScanInfo) -> None:
+        """
+        Default update function.
+        """
+        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.simple_grid_scan(info)
+            return
+        if info.scan_report_devices:
+            self.best_effort(info)
+            return
+
+    def simple_line_scan(self, info: ScanInfo) -> None:
+        """
+        Simple line scan.
+        """
+        dev_x = info.scan_report_devices[0]
+        dev_y = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
+        if not dev_y:
+            return
+        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.
+        """
+        dev_x = info.scan_report_devices[0]
+        dev_y = info.scan_report_devices[1]
+        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.
+        """
+        dev_x = info.scan_report_devices[0]
+        dev_y = self.get_selected_device(info.monitored_devices, self.figure.selected_device)
+        if not dev_y:
+            return
+        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

@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import importlib
+import importlib.metadata as imd
+import os
+import select
+import subprocess
+import sys
+import threading
+import time
+import uuid
+from functools import wraps
+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 QCoreApplication
+
+import bec_widgets.cli.client as client
+
+if TYPE_CHECKING:
+    from bec_lib.device import DeviceBase
+
+messages = lazy_import("bec_lib.messages")
+# from bec_lib.connector import MessageObject
+MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
+BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
+
+
+def rpc_call(func):
+    """
+    A decorator for calling a function on the server.
+
+    Args:
+        func: The function to call.
+
+    Returns:
+        The result of the function call.
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # we could rely on a strict type check here, but this is more flexible
+        # moreover, it would anyway crash for objects...
+        out = []
+        for arg in args:
+            if hasattr(arg, "name"):
+                arg = arg.name
+            out.append(arg)
+        args = tuple(out)
+        for key, val in kwargs.items():
+            if hasattr(val, "name"):
+                kwargs[key] = val.name
+        if not self.gui_is_alive():
+            raise RuntimeError("GUI is not alive")
+        return self._run_rpc(func.__name__, *args, **kwargs)
+
+    return wrapper
+
+
+class BECGuiClientMixin:
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._process = None
+        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:
+        eps = imd.entry_points(group="bec.widgets.auto_updates")
+        for ep in eps:
+            if ep.name == "plugin_widgets_update":
+                return ep.load()(figure=self)
+        return None
+
+    @property
+    def selected_device(self):
+        """
+        Selected device for the plot.
+        """
+        return self._selected_device
+
+    @selected_device.setter
+    def selected_device(self, device: str | DeviceBase):
+        if isinstance_based_on_class_name(device, "bec_lib.device.DeviceBase"):
+            self._selected_device = device.name
+        elif isinstance(device, str):
+            self._selected_device = device
+        else:
+            raise ValueError("Device must be a string or a device object")
+
+    def _start_update_script(self) -> None:
+        self._client.connector.register(
+            self._target_endpoint, cb=self._handle_msg_update, parent=self
+        )
+
+    @staticmethod
+    def _handle_msg_update(msg: MessageObject, parent: BECGuiClientMixin) -> None:
+        if parent.update_script is not None:
+            # pylint: disable=protected-access
+            parent._update_script_msg_parser(msg.value)
+
+    def _update_script_msg_parser(self, msg: messages.BECMessage) -> None:
+        if isinstance(msg, messages.ScanStatusMessage):
+            if not self.gui_is_alive():
+                return
+            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_plot_process()
+        while not self.gui_is_alive():
+            print("Waiting for GUI to start...")
+            time.sleep(1)
+
+    def close(self) -> None:
+        """
+        Close the figure.
+        """
+        if self._process is None:
+            return
+        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()
+
+    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:
+        """
+        Print the log of the plot process.
+        """
+        if self._process is None:
+            return
+        print("".join(self.stderr_output))
+        # 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."""
+
+    def __init__(self, request_id, timeout):
+        super().__init__(
+            f"RPC response not received within {timeout} seconds for request ID {request_id}"
+        )
+
+
+class RPCBase:
+    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
+        self._client = BECDispatcher().client
+        self._config = config if config is not None else {}
+        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())
+        self._parent = parent
+        super().__init__()
+        # print(f"RPCBase: {self._gui_id}")
+
+    def __repr__(self):
+        type_ = type(self)
+        qualname = type_.__qualname__
+        return f"<{qualname} object at {hex(id(self))}>"
+
+    @property
+    def _root(self):
+        """
+        Get the root widget. This is the BECFigure widget that holds
+        the anchor gui_id.
+        """
+        parent = self
+        # pylint: disable=protected-access
+        while parent._parent is not None:
+            parent = parent._parent
+        return parent
+
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, **kwargs):
+        """
+        Run the RPC call.
+
+        Args:
+            method: The method to call.
+            args: The arguments to pass to the method.
+            wait_for_rpc_response: Whether to wait for the RPC response.
+            kwargs: The keyword arguments to pass to the method.
+
+        Returns:
+            The result of the RPC call.
+        """
+        request_id = str(uuid.uuid4())
+        rpc_msg = messages.GUIInstructionMessage(
+            action=method,
+            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
+            metadata={"request_id": request_id},
+        )
+
+        # pylint: disable=protected-access
+        receiver = self._root._gui_id
+        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
+
+        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:
+            return None
+        if isinstance(msg_result, list):
+            return [self._create_widget_from_msg_result(res) for res in msg_result]
+        if isinstance(msg_result, dict):
+            if "__rpc__" not in msg_result:
+                return {
+                    key: self._create_widget_from_msg_result(val) for key, val in msg_result.items()
+                }
+            cls = msg_result.pop("widget_class", None)
+            msg_result.pop("__rpc__", None)
+
+            if not cls:
+                return msg_result
+
+            cls = getattr(client, cls)
+            # print(msg_result)
+            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.
+        """
+        heart = self._client.connector.get(MessageEndpoints.gui_heartbeat(self._root._gui_id))
+        return heart is not None

bec_widgets/cli/generate_cli.py

@@ -0,0 +1,139 @@
+# pylint: disable=missing-module-docstring
+from __future__ import annotations
+
+import inspect
+import sys
+
+import black
+
+if sys.version_info >= (3, 11):
+    from typing import get_overloads
+else:
+    print(
+        "Python version is less than 3.11, using dummy function for get_overloads. "
+        "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
+        return []
+
+
+class ClientGenerator:
+    def __init__(self):
+        self.header = """# This file was automatically generated by generate_cli.py\n
+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: list):
+        """
+        Generate the client for the published classes.
+
+        Args:
+            published_classes(list): The list of published classes (e.g. [BECWaveform1D, BECFigure]).
+        """
+        for cls in published_classes:
+            self.content += "\n\n"
+            self.generate_content_for_class(cls)
+
+    def generate_content_for_class(self, cls):
+        """
+        Generate the content for the class.
+
+        Args:
+            cls: The class for which to generate the content.
+        """
+
+        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":
+            self.content += f"""
+class {class_name}(RPCBase, BECGuiClientMixin):"""
+        else:
+            self.content += f"""
+class {class_name}(RPCBase):"""
+        for method in cls.USER_ACCESS:
+            obj = getattr(cls, method)
+            if isinstance(obj, property):
+                self.content += """
+    @property
+    @rpc_call"""
+                sig = str(inspect.signature(obj.fget))
+                doc = inspect.getdoc(obj.fget)
+            else:
+                sig = str(inspect.signature(obj))
+                doc = inspect.getdoc(obj)
+                overloads = get_overloads(obj)
+                for overload in overloads:
+                    sig_overload = str(inspect.signature(overload))
+                    self.content += f"""
+    @overload
+    def {method}{str(sig_overload)}: ...
+    """
+
+                self.content += """
+    @rpc_call"""
+            self.content += f"""
+    def {method}{str(sig)}:
+        \"\"\"
+{doc}
+        \"\"\""""
+
+    def write(self, file_name: str):
+        """
+        Write the content to a file, automatically formatted with black.
+
+        Args:
+            file_name(str): The name of the file to write to.
+        """
+        # Combine header and content, then format with black
+        full_content = self.header + "\n" + self.content
+        try:
+            formatted_content = black.format_str(full_content, mode=black.FileMode(line_length=100))
+        except black.NothingChanged:
+            formatted_content = full_content
+
+        with open(file_name, "w", encoding="utf-8") as file:
+            file.write(formatted_content)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    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_register.py

@@ -0,0 +1,80 @@
+from threading import Lock
+from weakref import WeakValueDictionary
+
+from qtpy.QtCore import QObject
+
+
+class RPCRegister:
+    """
+    A singleton class that keeps track of all the RPC objects registered in the system for CLI usage.
+    """
+
+    _instance = None
+    _initialized = False
+    _lock = Lock()
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(RPCRegister, cls).__new__(cls)
+            cls._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self._rpc_register = WeakValueDictionary()
+        self._initialized = True
+
+    def add_rpc(self, rpc: QObject):
+        """
+        Add an RPC object to the register.
+
+        Args:
+            rpc(QObject): The RPC object to be added to the register.
+        """
+        if not hasattr(rpc, "gui_id"):
+            raise ValueError("RPC object must have a 'gui_id' attribute.")
+        self._rpc_register[rpc.gui_id] = rpc
+
+    def remove_rpc(self, rpc: str):
+        """
+        Remove an RPC object from the register.
+
+        Args:
+            rpc(str): The RPC object to be removed from the register.
+        """
+        if not hasattr(rpc, "gui_id"):
+            raise ValueError(f"RPC object {rpc} must have a 'gui_id' attribute.")
+        self._rpc_register.pop(rpc.gui_id, None)
+
+    def get_rpc_by_id(self, gui_id: str) -> QObject:
+        """
+        Get an RPC object by its ID.
+
+        Args:
+            gui_id(str): The ID of the RPC object to be retrieved.
+
+        Returns:
+            QObject: The RPC object with the given ID.
+        """
+        rpc_object = self._rpc_register.get(gui_id, None)
+        return rpc_object
+
+    def list_all_connections(self) -> dict:
+        """
+        List all the registered RPC objects.
+
+        Returns:
+            dict: A dictionary containing all the registered RPC objects.
+        """
+        with self._lock:
+            connections = dict(self._rpc_register)
+        return connections
+
+    @classmethod
+    def reset_singleton(cls):
+        """
+        Reset the singleton instance.
+        """
+        cls._instance = None
+        cls._initialized = False

bec_widgets/cli/rpc_wigdet_handler.py

@@ -0,0 +1,26 @@
+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."""
+
+    widget_classes = {"BECFigure": BECFigure, "SpiralProgressBar": SpiralProgressBar}
+
+    @staticmethod
+    def create_widget(widget_type, **kwargs) -> BECConnector:
+        """
+        Create a widget from an RPC message.
+
+        Args:
+            widget_type(str): The type of the widget.
+            **kwargs: The keyword arguments for the widget.
+
+        Returns:
+            widget(BECConnector): The created widget.
+        """
+        widget_class = RPCWidgetHandler.widget_classes.get(widget_type)
+        if widget_class:
+            return widget_class(**kwargs)
+        raise ValueError(f"Unknown widget type: {widget_type}")

bec_widgets/cli/server.py

@@ -0,0 +1,168 @@
+import inspect
+from typing import Union
+
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.utils.import_utils import lazy_import
+from qtpy.QtCore import QTimer
+
+from bec_widgets.cli.rpc_register import RPCRegister
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.widgets.dock.dock_area import BECDockArea
+from bec_widgets.widgets.figure import BECFigure
+
+messages = lazy_import("bec_lib.messages")
+
+
+class BECWidgetsCLIServer:
+
+    def __init__(
+        self,
+        gui_id: str = None,
+        dispatcher: BECDispatcher = None,
+        client=None,
+        config=None,
+        gui_class: Union["BECFigure", "BECDockArea"] = BECFigure,
+    ) -> None:
+        self.dispatcher = BECDispatcher(config=config) if dispatcher is None else dispatcher
+        self.client = self.dispatcher.client if client is None else client
+        self.client.start()
+        self.gui_id = gui_id
+        self.gui = gui_class(gui_id=self.gui_id)
+        self.rpc_register = RPCRegister()
+        self.rpc_register.add_rpc(self.gui)
+
+        self.dispatcher.connect_slot(
+            self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
+        )
+
+        # Setup QTimer for heartbeat
+        self._shutdown_event = False
+        self._heartbeat_timer = QTimer()
+        self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
+        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")
+        try:
+            obj = self.get_object_from_config(msg["parameter"])
+            method = msg["action"]
+            args = msg["parameter"].get("args", [])
+            kwargs = msg["parameter"].get("kwargs", {})
+            res = self.run_rpc(obj, method, args, kwargs)
+        except Exception as e:
+            print(e)
+            self.send_response(request_id, False, {"error": str(e)})
+        else:
+            self.send_response(request_id, True, {"result": res})
+
+    def send_response(self, request_id: str, accepted: bool, msg: dict):
+        self.client.connector.set_and_publish(
+            MessageEndpoints.gui_instruction_response(request_id),
+            messages.RequestResponseMessage(accepted=accepted, message=msg),
+            expire=60,
+        )
+
+    def get_object_from_config(self, config: dict):
+        gui_id = config.get("gui_id")
+        obj = self.rpc_register.get_rpc_by_id(gui_id)
+        if obj is None:
+            raise ValueError(f"Object with gui_id {gui_id} not found")
+        return obj
+
+    def run_rpc(self, obj, method, args, kwargs):
+        method_obj = getattr(obj, method)
+        # check if the method accepts args and kwargs
+        if not callable(method_obj):
+            res = method_obj
+        else:
+            sig = inspect.signature(method_obj)
+            if sig.parameters:
+                res = method_obj(*args, **kwargs)
+            else:
+                res = method_obj()
+
+        if isinstance(res, list):
+            res = [self.serialize_object(obj) for obj in res]
+        elif isinstance(res, dict):
+            res = {key: self.serialize_object(val) for key, val in res.items()}
+        else:
+            res = self.serialize_object(res)
+        return res
+
+    def serialize_object(self, obj):
+        if isinstance(obj, BECConnector):
+            return {
+                "gui_id": obj.gui_id,
+                "widget_class": obj.__class__.__name__,
+                "config": obj.config.model_dump(),
+                "__rpc__": True,
+            }
+        return obj
+
+    def emit_heartbeat(self):
+        if self._shutdown_event is False:
+            self.client.connector.set(
+                MessageEndpoints.gui_heartbeat(self.gui_id),
+                messages.StatusMessage(name=self.gui_id, status=1, info={}),
+                expire=10,
+            )
+
+    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
+        self._shutdown_event = True
+        self._heartbeat_timer.stop()
+        self.client.shutdown()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import argparse
+    import os
+    import sys
+
+    from qtpy.QtCore import QSize
+    from qtpy.QtGui import QIcon
+    from qtpy.QtWidgets import QApplication, QMainWindow
+
+    import bec_widgets
+
+    app = QApplication(sys.argv)
+    app.setApplicationName("BEC Figure")
+    module_path = os.path.dirname(bec_widgets.__file__)
+    icon = QIcon()
+    icon.addFile(os.path.join(module_path, "assets", "bec_widgets_icon.png"), size=QSize(48, 48))
+    app.setWindowIcon(icon)
+
+    win = QMainWindow()
+    win.setWindowTitle("BEC Widgets")
+
+    parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
+    parser.add_argument("--id", type=str, help="The id of the server")
+    parser.add_argument(
+        "--gui_class",
+        type=str,
+        help="Name of the gui class to be rendered. Possible values: \n- BECFigure\n- BECDockArea",
+    )
+    parser.add_argument("--config", type=str, help="Config to connect to redis.")
+
+    args = parser.parse_args()
+
+    if args.gui_class == "BECFigure":
+        gui_class = BECFigure
+    elif args.gui_class == "BECDockArea":
+        gui_class = BECDockArea
+    else:
+        print(
+            "Please specify a valid gui_class to run. Use -h for help."
+            "\n Starting with default gui_class BECFigure."
+        )
+        gui_class = BECFigure
+
+    server = BECWidgetsCLIServer(gui_id=args.id, config=args.config, gui_class=gui_class)
+
+    gui = server.gui
+    win.setCentralWidget(gui)
+    win.resize(800, 600)
+    win.show()
+
+    app.aboutToQuit.connect(server.shutdown)
+    sys.exit(app.exec())

bec_widgets/config_plotter.py

@@ -1,129 +0,0 @@
-from typing import List
-
-import numpy as np
-import pyqtgraph as pg
-from pyqtgraph import mkPen
-from pyqtgraph.Qt import QtCore, QtWidgets
-
-
-class ConfigPlotter(pg.GraphicsWidget):
-    """
-    ConfigPlotter is a widget that can be used to plot data from multiple channels
-    in a grid layout. The layout is specified by a list of dicts, where each dict
-    specifies the position of the plot in the grid, the channels to plot, and the
-    type of plot to use. The plot type is specified by the name of the pyqtgraph
-    item to use. For example, to plot a single channel in a PlotItem, the config
-    would look like this:
-
-    config = [
-        {
-            "cols": 1,
-            "rows": 1,
-            "y": 0,
-            "x": 0,
-            "config": {"channels": ["a"], "label_xy": ["", "a"], "item": "PlotItem"},
-        }
-    ]
-
-    """
-
-    def __init__(self, configs: List[dict], parent=None):
-        super().__init__(parent)
-        self.configs = configs
-        self.plots = {}
-        self._init_ui()
-        self._init_plots()
-
-    def _init_ui(self):
-        pg.setConfigOption("background", "w")
-        pg.setConfigOption("foreground", "k")
-
-        # pylint: disable=no-member
-        self.pen = mkPen(color=(56, 76, 107), width=4, style=QtCore.Qt.SolidLine)
-
-        self.view = pg.GraphicsView()
-        self.view.setAntialiasing(True)
-        self.view.show()
-
-        self.layout = pg.GraphicsLayout()
-        self.view.setCentralWidget(self.layout)
-
-    def _init_plots(self):
-        for config in self.configs:
-            channels = config["config"]["channels"]
-            for channel in channels:
-                item = pg.PlotItem()
-                self.layout.addItem(
-                    item,
-                    row=config["y"],
-                    col=config["x"],
-                    rowspan=config["rows"],
-                    colspan=config["cols"],
-                )
-
-                # call the corresponding init function, e.g. init_plotitem
-                init_func = getattr(self, f"init_{config['config']['item']}")
-                init_func(channel, config["config"], item)
-
-                # self.init_ImageItem(channel, config["config"], item)
-
-    def init_PlotItem(self, channel: str, config: dict, item: pg.GraphicsItem):
-        """
-        Initialize a PlotItem
-
-        Args:
-            channel(str): channel to plot
-            config(dict): config dict for the channel
-            item(pg.GraphicsItem): PlotItem to plot the data
-        """
-        # pylint: disable=invalid-name
-        plot_data = item.plot(np.random.rand(100), pen=self.pen)
-        item.setLabel("left", channel)
-        self.plots[channel] = {"item": item, "plot_data": plot_data}
-
-    def init_ImageItem(self, channel: str, config: dict, item: pg.GraphicsItem):
-        """
-        Initialize an ImageItem
-
-        Args:
-            channel(str): channel to plot
-            config(dict): config dict for the channel
-            item(pg.GraphicsItem): ImageItem to plot the data
-        """
-        # pylint: disable=invalid-name
-        img = pg.ImageItem()
-        item.addItem(img)
-        img.setImage(np.random.rand(100, 100))
-        self.plots[channel] = {"item": item, "plot_data": img}
-
-
-if __name__ == "__main__":
-    import sys
-
-    CONFIG = [
-        {
-            "cols": 1,
-            "rows": 1,
-            "y": 0,
-            "x": 0,
-            "config": {"channels": ["a"], "label_xy": ["", "a"], "item": "PlotItem"},
-        },
-        {
-            "cols": 1,
-            "rows": 1,
-            "y": 1,
-            "x": 0,
-            "config": {"channels": ["b"], "label_xy": ["", "b"], "item": "PlotItem"},
-        },
-        {
-            "cols": 1,
-            "rows": 2,
-            "y": 0,
-            "x": 1,
-            "config": {"channels": ["c"], "label_xy": ["", "c"], "item": "ImageItem"},
-        },
-    ]
-
-    app = QtWidgets.QApplication(sys.argv)
-    win = ConfigPlotter(CONFIG)
-    pg.exec()

bec_widgets/ctrl_c.py

@@ -1,38 +0,0 @@
-import signal
-import socket
-from PyQt5.QtNetwork import QAbstractSocket
-
-
-def setup(app):
-    app.signalwatchdog = SignalWatchdog()  # need to store to keep socket pair alive
-    signal.signal(signal.SIGINT, make_quit_handler(app))
-
-
-def make_quit_handler(app):
-    def handler(*args):
-        print()  # make ^C appear on its own line
-        app.quit()
-
-    return handler
-
-
-class SignalWatchdog(QAbstractSocket):
-    def __init__(self):
-        """
-        Propagates system signals from Python to QEventLoop
-        adapted from https://stackoverflow.com/a/65802260/655404
-        """
-        super().__init__(QAbstractSocket.SctpSocket, None)
-
-        self.writer, self.reader = writer, reader = socket.socketpair()
-        writer.setblocking(False)
-
-        fd_writer = writer.fileno()
-        fd_reader = reader.fileno()
-
-        signal.set_wakeup_fd(fd_writer)  # Python hook
-        self.setSocketDescriptor(fd_reader)  # Qt hook
-
-        self.readyRead.connect(
-            lambda: None
-        )  # dummy function call that lets the Python interpreter run

bec_widgets/display_ui_file.py

@@ -1,33 +0,0 @@
-import os
-import sys
-
-from PyQt5 import QtWidgets, uic
-
-
-class UI(QtWidgets.QWidget):
-    def __init__(self, uipath):
-        super().__init__()
-
-        self.ui = uic.loadUi(uipath, self)
-
-        _, fname = os.path.split(uipath)
-        self.setWindowTitle(fname)
-
-        self.show()
-
-
-def main():
-    """A basic script to display UI file
-
-    Run the script, passing UI file path as an argument, e.g.
-    $ python bec_widgets/display_ui_file.py bec_widgets/line_plot.ui
-    """
-    app = QtWidgets.QApplication(sys.argv)
-
-    UI(sys.argv[1])
-
-    sys.exit(app.exec_())
-
-
-if __name__ == "__main__":
-    main()

bec_widgets/examples/__init__.py

@@ -0,0 +1,9 @@
+from .motor_movement import (
+    MotorControlApp,
+    MotorControlMap,
+    MotorControlPanel,
+    MotorControlPanelAbsolute,
+    MotorControlPanelRelative,
+    MotorCoordinateTable,
+    MotorThread,
+)

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

@@ -0,0 +1,165 @@
+import os
+
+import numpy as np
+import pyqtgraph as pg
+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.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})
+        # 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:
+    """A widget that contains a Jupyter console linked to BEC Widgets with full API access (contains Qt and pyqtgraph API)."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        current_path = os.path.dirname(__file__)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "jupyter_console_window.ui"), self)
+
+        self._init_ui()
+
+        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
+        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
+        self.glw_1_layout = QVBoxLayout(self.ui.glw)  # Create a new QVBoxLayout
+        self.figure = BECFigure(parent=self, gui_id="remote")  # Create a new BECDeviceMonitor
+        self.glw_1_layout.addWidget(self.figure)  # Add BECDeviceMonitor to the layout
+
+        self.dock_layout = QVBoxLayout(self.ui.dock_placeholder)
+        self.dock = BECDockArea(gui_id="remote")
+        self.dock_layout.addWidget(self.dock)
+
+        # add stuff to figure
+        self._init_figure()
+
+        # init dock for testing
+        self._init_dock()
+
+        self.console_layout = QVBoxLayout(self.ui.widget_console)
+        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="bpm4d")
+        self.figure.motor_map("samx", "samy")
+        self.figure.image("eiger", color_map="viridis", vrange=(0, 100))
+
+        self.figure.change_layout(2, 2)
+
+        self.w1 = self.figure[0, 0]
+        self.w2 = self.figure[0, 1]
+        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.label_2 = QtWidgets.QLabel("label which is added separately")
+        self.label_3 = QtWidgets.QLabel("Label above figure")
+
+        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()
+
+    def closeEvent(self, event):
+        """Override to handle things when main window is closed."""
+        self.dock.cleanup()
+        self.figure.clear_all()
+        self.figure.client.shutdown()
+        super().closeEvent(event)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    import bec_widgets
+
+    module_path = os.path.dirname(bec_widgets.__file__)
+
+    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()
+
+    app.aboutToQuit.connect(win.close)
+    sys.exit(app.exec_())

bec_widgets/examples/jupyter_console/jupyter_console_window.ui

@@ -0,0 +1,54 @@
+<?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>2104</width>
+    <height>966</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Plotting Console</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_4">
+   <item>
+    <widget class="QSplitter" name="splitter">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <widget class="QTabWidget" name="tabWidget">
+      <property name="currentIndex">
+       <number>0</number>
+      </property>
+      <widget class="QWidget" name="tab_1">
+       <attribute name="title">
+        <string>BECDock</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="verticalLayout">
+        <item>
+         <widget class="QWidget" name="dock_placeholder" native="true"/>
+        </item>
+       </layout>
+      </widget>
+      <widget class="QWidget" name="tab_2">
+       <attribute name="title">
+        <string>BECFigure</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="verticalLayout_3">
+        <item>
+         <widget class="QWidget" name="glw" native="true"/>
+        </item>
+       </layout>
+      </widget>
+     </widget>
+     <widget class="QWidget" name="widget_console" native="true"/>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

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/__init__.py

@@ -0,0 +1,9 @@
+from .motor_control_compilations import (
+    MotorControlApp,
+    MotorControlMap,
+    MotorControlPanel,
+    MotorControlPanelAbsolute,
+    MotorControlPanelRelative,
+    MotorCoordinateTable,
+    MotorThread,
+)

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/motor_movement/motor_control_compilations.py

@@ -0,0 +1,250 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+
+import qdarktheme
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QApplication, QSplitter, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.widgets.motor_control.motor_control import MotorThread
+from bec_widgets.widgets.motor_control.motor_table.motor_table import MotorCoordinateTable
+from bec_widgets.widgets.motor_control.movement_absolute.movement_absolute import (
+    MotorControlAbsolute,
+)
+from bec_widgets.widgets.motor_control.movement_relative.movement_relative import (
+    MotorControlRelative,
+)
+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": 3,
+        "precision": 4,
+        "step_x_y_same": False,
+        "move_with_arrows": False,
+    },
+    "plot_settings": {
+        "colormap": "Greys",
+        "scatter_size": 5,
+        "max_points": 1000,
+        "num_dim_points": 100,
+        "precision": 2,
+        "num_columns": 1,
+        "background_value": 25,
+    },
+    "motors": [
+        {
+            "plot_name": "Motor Map",
+            "x_label": "Motor X",
+            "y_label": "Motor Y",
+            "signals": {
+                "x": [{"name": "samx", "entry": "samx"}],
+                "y": [{"name": "samy", "entry": "samy"}],
+            },
+        }
+    ],
+}
+
+
+class MotorControlApp(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        # Widgets
+        self.motor_control_panel = MotorControlPanel(client=self.client, config=self.config)
+        # Create MotorMap
+        # self.motion_map = MotorMap(client=self.client, config=self.config)
+        # Create MotorCoordinateTable
+        self.motor_table = MotorCoordinateTable(client=self.client, config=self.config)
+
+        # Create the splitter and add MotorMap and MotorControlPanel
+        splitter = QSplitter(Qt.Horizontal)
+        # splitter.addWidget(self.motion_map)
+        splitter.addWidget(self.motor_control_panel)
+        splitter.addWidget(self.motor_table)
+
+        # Set the main layout
+        layout = QVBoxLayout(self)
+        layout.addWidget(splitter)
+        self.setLayout(layout)
+
+        # Connecting signals and slots
+        # self.motor_control_panel.selection_widget.selected_motors_signal.connect(
+        #     lambda x, y: self.motion_map.change_motors(x, y, 0)
+        # )
+        self.motor_control_panel.absolute_widget.coordinates_signal.connect(
+            self.motor_table.add_coordinate
+        )
+        self.motor_control_panel.relative_widget.precision_signal.connect(
+            self.motor_table.set_precision
+        )
+        self.motor_control_panel.relative_widget.precision_signal.connect(
+            self.motor_control_panel.absolute_widget.set_precision
+        )
+
+        # self.motor_table.plot_coordinates_signal.connect(self.motion_map.plot_saved_coordinates)
+
+
+class MotorControlMap(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        # Widgets
+        self.motor_control_panel = MotorControlPanel(client=self.client, config=self.config)
+        # Create MotorMap
+        # self.motion_map = MotorMap(client=self.client, config=self.config)
+
+        # Create the splitter and add MotorMap and MotorControlPanel
+        splitter = QSplitter(Qt.Horizontal)
+        # splitter.addWidget(self.motion_map)
+        splitter.addWidget(self.motor_control_panel)
+
+        # Set the main layout
+        layout = QVBoxLayout(self)
+        layout.addWidget(splitter)
+        self.setLayout(layout)
+
+        # Connecting signals and slots
+        # self.motor_control_panel.selection_widget.selected_motors_signal.connect(
+        #     lambda x, y: self.motion_map.change_motors(x, y, 0)
+        # )
+
+
+class MotorControlPanel(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        self.motor_thread = MotorThread(client=self.client)
+
+        self.selection_widget = MotorControlSelection(
+            client=self.client, config=self.config, motor_thread=self.motor_thread
+        )
+        self.relative_widget = MotorControlRelative(
+            client=self.client, config=self.config, motor_thread=self.motor_thread
+        )
+        self.absolute_widget = MotorControlAbsolute(
+            client=self.client, config=self.config, motor_thread=self.motor_thread
+        )
+
+        layout = QVBoxLayout(self)
+
+        layout.addWidget(self.selection_widget)
+        layout.addWidget(self.relative_widget)
+        layout.addWidget(self.absolute_widget)
+
+        # Connecting signals and slots
+        self.selection_widget.selected_motors_signal.connect(self.relative_widget.change_motors)
+        self.selection_widget.selected_motors_signal.connect(self.absolute_widget.change_motors)
+
+        # Set the window to a fixed size based on its contents
+        # self.layout().setSizeConstraint(layout.SetFixedSize)
+
+
+class MotorControlPanelAbsolute(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        self.motor_thread = MotorThread(client=self.client)
+
+        self.selection_widget = MotorControlSelection(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+        self.absolute_widget = MotorControlAbsolute(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.selection_widget)
+        layout.addWidget(self.absolute_widget)
+
+        # Connecting signals and slots
+        self.selection_widget.selected_motors_signal.connect(self.absolute_widget.change_motors)
+
+
+class MotorControlPanelRelative(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        self.motor_thread = MotorThread(client=self.client)
+
+        self.selection_widget = MotorControlSelection(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+        self.relative_widget = MotorControlRelative(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.selection_widget)
+        layout.addWidget(self.relative_widget)
+
+        # Connecting signals and slots
+        self.selection_widget.selected_motors_signal.connect(self.relative_widget.change_motors)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="Run various Motor Control Widgets compositions.")
+    parser.add_argument(
+        "-v",
+        "--variant",
+        type=str,
+        choices=["app", "map", "panel", "panel_abs", "panel_rel"],
+        help="Select the variant of the motor control to run. "
+        "'app' for the full application, "
+        "'map' for MotorMap, "
+        "'panel' for the MotorControlPanel, "
+        "'panel_abs' for MotorControlPanel with absolute control, "
+        "'panel_rel' for MotorControlPanel with relative control.",
+    )
+
+    args = parser.parse_args()
+
+    bec_dispatcher = BECDispatcher()
+    client = bec_dispatcher.client
+    client.start()
+
+    app = QApplication([])
+    qdarktheme.setup_theme("auto")
+
+    if args.variant == "app":
+        window = MotorControlApp(client=client)  # , config=CONFIG_DEFAULT)
+    elif args.variant == "map":
+        window = MotorControlMap(client=client)  # , config=CONFIG_DEFAULT)
+    elif args.variant == "panel":
+        window = MotorControlPanel(client=client)  # , config=CONFIG_DEFAULT)
+    elif args.variant == "panel_abs":
+        window = MotorControlPanelAbsolute(client=client)  # , config=CONFIG_DEFAULT)
+    elif args.variant == "panel_rel":
+        window = MotorControlPanelRelative(client=client)  # , config=CONFIG_DEFAULT)
+    else:
+        print("Please specify a valid variant to run. Use -h for help.")
+        print("Running the full application by default.")
+        window = MotorControlApp(client=client)  # , config=CONFIG_DEFAULT)
+
+    window.show()
+    sys.exit(app.exec())

bec_widgets/examples/motor_movement/motor_controller.ui

@@ -6,10 +6,16 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>1129</width>
-    <height>550</height>
+    <width>1561</width>
+    <height>748</height>
    </rect>
   </property>
+  <property name="minimumSize">
+   <size>
+    <width>1409</width>
+    <height>748</height>
+   </size>
+  </property>
   <property name="windowTitle">
    <string>Motor Controller</string>
   </property>
@@ -29,9 +35,21 @@
        <height>471</height>
       </size>
      </property>
-     <layout class="QVBoxLayout" name="verticalLayout_6">
+     <layout class="QVBoxLayout" name="verticalLayout_6" stretch="1,1,1,0,1">
+      <property name="spacing">
+       <number>1</number>
+      </property>
+      <property name="sizeConstraint">
+       <enum>QLayout::SetMinimumSize</enum>
+      </property>
       <item>
        <widget class="QGroupBox" name="motorSelection">
+        <property name="minimumSize">
+         <size>
+          <width>261</width>
+          <height>145</height>
+         </size>
+        </property>
         <property name="title">
          <string>Motor Selection</string>
         </property>
@@ -71,6 +89,9 @@
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::Minimum</enum>
+        </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
@@ -81,6 +102,12 @@
       </item>
       <item>
        <widget class="QGroupBox" name="motorControl">
+        <property name="minimumSize">
+         <size>
+          <width>261</width>
+          <height>339</height>
+         </size>
+        </property>
         <property name="title">
          <string>Motor Relative</string>
         </property>
@@ -93,12 +120,137 @@
           </widget>
          </item>
          <item>
-          <layout class="QGridLayout" name="gridLayout">
+          <widget class="QCheckBox" name="checkBox_same_xy">
+           <property name="text">
+            <string>Step [X] = Step [Y]</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <layout class="QGridLayout" name="step_grid">
+           <item row="2" column="0">
+            <widget class="QLabel" name="label_step_y">
+             <property name="minimumSize">
+              <size>
+               <width>111</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Step [Y]</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_2">
+             <property name="minimumSize">
+              <size>
+               <width>111</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Decimal</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="1">
+            <widget class="QDoubleSpinBox" name="spinBox_step_x">
+             <property name="minimumSize">
+              <size>
+               <width>110</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>0.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>99.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+             <property name="value">
+              <double>1.000000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label_step_x">
+             <property name="minimumSize">
+              <size>
+               <width>111</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Step [X]</string>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="1">
+            <widget class="QDoubleSpinBox" name="spinBox_step_y">
+             <property name="minimumSize">
+              <size>
+               <width>110</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>0.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>99.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+             <property name="value">
+              <double>1.000000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1">
+            <widget class="QSpinBox" name="spinBox_precision">
+             <property name="minimumSize">
+              <size>
+               <width>110</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="maximum">
+              <number>8</number>
+             </property>
+             <property name="value">
+              <number>2</number>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QGridLayout" name="direction_grid">
            <property name="sizeConstraint">
             <enum>QLayout::SetDefaultConstraint</enum>
            </property>
            <item row="1" column="2" alignment="Qt::AlignHCenter|Qt::AlignVCenter">
             <widget class="QToolButton" name="toolButton_up">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
              <property name="text">
               <string>...</string>
              </property>
@@ -122,6 +274,12 @@
            </item>
            <item row="3" column="2" alignment="Qt::AlignHCenter|Qt::AlignVCenter">
             <widget class="QToolButton" name="toolButton_down">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
              <property name="text">
               <string>...</string>
              </property>
@@ -132,6 +290,12 @@
            </item>
            <item row="2" column="1">
             <widget class="QToolButton" name="toolButton_left">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
              <property name="text">
               <string>...</string>
              </property>
@@ -155,6 +319,12 @@
            </item>
            <item row="2" column="3">
             <widget class="QToolButton" name="toolButton_right">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
              <property name="text">
               <string>...</string>
              </property>
@@ -189,19 +359,6 @@
              </property>
             </spacer>
            </item>
-           <item row="2" column="2">
-            <widget class="QDoubleSpinBox" name="spinBox_step">
-             <property name="minimum">
-              <double>0.100000000000000</double>
-             </property>
-             <property name="singleStep">
-              <double>0.100000000000000</double>
-             </property>
-             <property name="value">
-              <double>1.000000000000000</double>
-             </property>
-            </widget>
-           </item>
           </layout>
          </item>
         </layout>
@@ -212,33 +369,71 @@
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::Minimum</enum>
+        </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
-          <height>13</height>
+          <height>18</height>
          </size>
         </property>
        </spacer>
       </item>
       <item>
        <widget class="QGroupBox" name="motorControl_absolute">
+        <property name="minimumSize">
+         <size>
+          <width>261</width>
+          <height>195</height>
+         </size>
+        </property>
         <property name="title">
          <string>Move Absolute</string>
         </property>
         <layout class="QVBoxLayout" name="verticalLayout">
+         <item>
+          <widget class="QCheckBox" name="checkBox_save_with_go">
+           <property name="text">
+            <string>Save position with Go</string>
+           </property>
+          </widget>
+         </item>
          <item>
           <layout class="QGridLayout" name="gridLayout_3">
-           <item row="0" column="1">
-            <widget class="QLabel" name="label_6">
-             <property name="text">
-              <string>X</string>
-             </property>
+           <item row="1" column="1">
+            <widget class="QDoubleSpinBox" name="spinBox_absolute_y">
              <property name="alignment">
               <set>Qt::AlignCenter</set>
              </property>
+             <property name="minimum">
+              <double>-500.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>500.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
             </widget>
            </item>
-           <item row="0" column="2">
+           <item row="1" column="0">
+            <widget class="QDoubleSpinBox" name="spinBox_absolute_x">
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>-500.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>500.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1">
             <widget class="QLabel" name="label_7">
              <property name="text">
               <string>Y</string>
@@ -248,39 +443,41 @@
              </property>
             </widget>
            </item>
-           <item row="1" column="0">
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_6">
+             <property name="text">
+              <string>X</string>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QHBoxLayout" name="horizontalLayout_2">
+           <item>
+            <widget class="QPushButton" name="pushButton_save">
+             <property name="text">
+              <string>Save</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QPushButton" name="pushButton_set">
+             <property name="text">
+              <string>Set</string>
+             </property>
+            </widget>
+           </item>
+           <item>
             <widget class="QPushButton" name="pushButton_go_absolute">
              <property name="text">
               <string>Go</string>
              </property>
             </widget>
            </item>
-           <item row="1" column="1">
-            <widget class="QDoubleSpinBox" name="spinBox_absolute_x">
-             <property name="minimum">
-              <double>-500.000000000000000</double>
-             </property>
-             <property name="maximum">
-              <double>500.000000000000000</double>
-             </property>
-             <property name="singleStep">
-              <double>0.100000000000000</double>
-             </property>
-            </widget>
-           </item>
-           <item row="1" column="2">
-            <widget class="QDoubleSpinBox" name="spinBox_absolute_y">
-             <property name="minimum">
-              <double>-500.000000000000000</double>
-             </property>
-             <property name="maximum">
-              <double>500.000000000000000</double>
-             </property>
-             <property name="singleStep">
-              <double>0.100000000000000</double>
-             </property>
-            </widget>
-           </item>
           </layout>
          </item>
          <item>
@@ -309,6 +506,44 @@
        <string>Coordinates</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_3">
+       <item>
+        <layout class="QHBoxLayout" name="horizontalLayout_3">
+         <item>
+          <spacer name="horizontalSpacer_3">
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>40</width>
+             <height>20</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QLabel" name="label">
+           <property name="text">
+            <string>Entries Mode:</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QComboBox" name="comboBox_mode">
+           <item>
+            <property name="text">
+             <string>Individual</string>
+            </property>
+           </item>
+           <item>
+            <property name="text">
+             <string>Start/Stop</string>
+            </property>
+           </item>
+          </widget>
+         </item>
+        </layout>
+       </item>
        <item>
         <widget class="QTableWidget" name="tableWidget_coordinates">
          <property name="selectionMode">
@@ -319,12 +554,17 @@
          </property>
          <column>
           <property name="text">
-           <string>Tag</string>
+           <string>Show</string>
           </property>
          </column>
          <column>
           <property name="text">
-           <string>Show</string>
+           <string>Move</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>Tag</string>
           </property>
          </column>
          <column>
@@ -337,13 +577,57 @@
            <string>Y</string>
           </property>
          </column>
-         <column>
-          <property name="text">
-           <string>Move</string>
-          </property>
-         </column>
         </widget>
        </item>
+       <item>
+        <layout class="QGridLayout" name="gridLayout">
+         <item row="1" column="1">
+          <widget class="QPushButton" name="pushButton_resize_table">
+           <property name="text">
+            <string>Resize Table</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="1">
+          <widget class="QCheckBox" name="checkBox_resize_auto">
+           <property name="text">
+            <string>Resize Auto</string>
+           </property>
+           <property name="checked">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="0">
+          <widget class="QPushButton" name="pushButton_importCSV">
+           <property name="text">
+            <string>Import CSV</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="0">
+          <widget class="QPushButton" name="pushButton_exportCSV">
+           <property name="text">
+            <string>Export CSV</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="0">
+          <widget class="QPushButton" name="pushButton_help">
+           <property name="text">
+            <string>Help</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="1">
+          <widget class="QPushButton" name="pushButton_duplicate">
+           <property name="text">
+            <string>Duplicate Last Entry</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_settings">
@@ -353,26 +637,13 @@
       <layout class="QVBoxLayout" name="verticalLayout_4">
        <item>
         <widget class="QGroupBox" name="motorLimits">
+         <property name="enabled">
+          <bool>false</bool>
+         </property>
          <property name="title">
           <string>Motor Limits</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_2">
-          <item row="3" column="1">
-           <widget class="QSpinBox" name="spinBox_y_min">
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-            <property name="minimum">
-             <number>-1000</number>
-            </property>
-            <property name="maximum">
-             <number>1000</number>
-            </property>
-            <property name="value">
-             <number>-100</number>
-            </property>
-           </widget>
-          </item>
           <item row="2" column="1">
            <widget class="QPushButton" name="pushButton_updateLimits">
             <property name="text">
@@ -380,22 +651,6 @@
             </property>
            </widget>
           </item>
-          <item row="2" column="2">
-           <widget class="QSpinBox" name="spinBox_x_max">
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-            <property name="minimum">
-             <number>-1000</number>
-            </property>
-            <property name="maximum">
-             <number>1000</number>
-            </property>
-            <property name="value">
-             <number>100</number>
-            </property>
-           </widget>
-          </item>
           <item row="0" column="1">
            <widget class="QLabel" name="label_Y_max">
             <property name="text">
@@ -406,38 +661,6 @@
             </property>
            </widget>
           </item>
-          <item row="1" column="1">
-           <widget class="QSpinBox" name="spinBox_y_max">
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-            <property name="minimum">
-             <number>-1000</number>
-            </property>
-            <property name="maximum">
-             <number>1000</number>
-            </property>
-            <property name="value">
-             <number>100</number>
-            </property>
-           </widget>
-          </item>
-          <item row="2" column="0">
-           <widget class="QSpinBox" name="spinBox_x_min">
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-            <property name="minimum">
-             <number>-1000</number>
-            </property>
-            <property name="maximum">
-             <number>1000</number>
-            </property>
-            <property name="value">
-             <number>-100</number>
-            </property>
-           </widget>
-          </item>
           <item row="4" column="1">
            <widget class="QLabel" name="label_Y_min">
             <property name="text">
@@ -468,190 +691,68 @@
             </property>
            </widget>
           </item>
+          <item row="1" column="1">
+           <widget class="QDoubleSpinBox" name="spinBox_y_max">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="1">
+           <widget class="QDoubleSpinBox" name="spinBox_y_min">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QDoubleSpinBox" name="spinBox_x_min">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="2">
+           <widget class="QDoubleSpinBox" name="spinBox_x_max">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox_2">
          <property name="title">
-          <string>Motor Config</string>
+          <string>Plotting Options</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_5">
-          <item row="3" column="1">
-           <widget class="QSpinBox" name="spinBox_3">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-           </widget>
-          </item>
-          <item row="3" column="2">
-           <widget class="QSpinBox" name="spinBox_6">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-           </widget>
-          </item>
-          <item row="0" column="1">
-           <widget class="QLabel" name="label_9">
-            <property name="text">
-             <string>X</string>
-            </property>
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-           </widget>
-          </item>
-          <item row="1" column="0">
-           <widget class="QLabel" name="label">
-            <property name="text">
-             <string>Speed</string>
-            </property>
-           </widget>
-          </item>
-          <item row="1" column="1">
-           <widget class="QSpinBox" name="spinBox_speed_x">
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-            <property name="maximum">
-             <number>1000</number>
-            </property>
-           </widget>
-          </item>
-          <item row="2" column="1">
-           <widget class="QSpinBox" name="spinBox_update_frequency_x">
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-            <property name="maximum">
-             <number>500</number>
-            </property>
-           </widget>
-          </item>
-          <item row="1" column="2">
-           <widget class="QSpinBox" name="spinBox_speed_y">
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-            <property name="maximum">
-             <number>1000</number>
-            </property>
-           </widget>
-          </item>
-          <item row="0" column="2">
-           <widget class="QLabel" name="label_10">
-            <property name="text">
-             <string>Y</string>
-            </property>
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-           </widget>
-          </item>
-          <item row="5" column="0">
-           <widget class="QLabel" name="label_15">
-            <property name="text">
-             <string>Max Points</string>
-            </property>
-           </widget>
-          </item>
-          <item row="6" column="1" colspan="2">
-           <widget class="QSpinBox" name="spinBox_num_dim_points">
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-            <property name="minimum">
-             <number>10</number>
-            </property>
-            <property name="maximum">
-             <number>1000</number>
-            </property>
-            <property name="singleStep">
-             <number>10</number>
-            </property>
-            <property name="value">
-             <number>100</number>
-            </property>
-           </widget>
-          </item>
-          <item row="2" column="0">
-           <widget class="QLabel" name="label_2">
-            <property name="text">
-             <string>Update Frequency</string>
-            </property>
-           </widget>
-          </item>
-          <item row="4" column="2">
-           <widget class="QDoubleSpinBox" name="doubleSpinBox_2">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-           </widget>
-          </item>
-          <item row="4" column="0">
-           <widget class="QLabel" name="label_3">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="text">
-             <string>Tolerance</string>
-            </property>
-           </widget>
-          </item>
-          <item row="4" column="1">
-           <widget class="QDoubleSpinBox" name="doubleSpinBox">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-           </widget>
-          </item>
-          <item row="2" column="2">
-           <widget class="QSpinBox" name="spinBox_update_frequency_y">
-            <property name="alignment">
-             <set>Qt::AlignCenter</set>
-            </property>
-            <property name="maximum">
-             <number>500</number>
-            </property>
-           </widget>
-          </item>
-          <item row="0" column="0">
-           <widget class="QPushButton" name="pushButton_update_config">
-            <property name="text">
-             <string>Update</string>
-            </property>
-           </widget>
-          </item>
-          <item row="3" column="0">
-           <widget class="QLabel" name="label_4">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="text">
-             <string>Decimal Precision</string>
-            </property>
-           </widget>
-          </item>
-          <item row="6" column="0">
-           <widget class="QLabel" name="label_16">
-            <property name="text">
-             <string>N dim</string>
-            </property>
-           </widget>
-          </item>
-          <item row="5" column="1" colspan="2">
+          <item row="0" column="1" colspan="2">
            <widget class="QSpinBox" name="spinBox_max_points">
             <property name="alignment">
              <set>Qt::AlignCenter</set>
@@ -670,14 +771,14 @@
             </property>
            </widget>
           </item>
-          <item row="7" column="0">
-           <widget class="QLabel" name="label_11">
+          <item row="0" column="0">
+           <widget class="QLabel" name="label_15">
             <property name="text">
-             <string>Scatter Size</string>
+             <string>Max Points</string>
             </property>
            </widget>
           </item>
-          <item row="7" column="1" colspan="2">
+          <item row="2" column="1" colspan="2">
            <widget class="QSpinBox" name="spinBox_scatter_size">
             <property name="alignment">
              <set>Qt::AlignCenter</set>
@@ -693,6 +794,53 @@
             </property>
            </widget>
           </item>
+          <item row="2" column="0">
+           <widget class="QLabel" name="label_11">
+            <property name="text">
+             <string>Scatter Size</string>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="0" colspan="3">
+           <widget class="QPushButton" name="pushButton_update_config">
+            <property name="text">
+             <string>Update Settings</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1" colspan="2">
+           <widget class="QSpinBox" name="spinBox_num_dim_points">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <number>10</number>
+            </property>
+            <property name="maximum">
+             <number>1000</number>
+            </property>
+            <property name="singleStep">
+             <number>10</number>
+            </property>
+            <property name="value">
+             <number>100</number>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0">
+           <widget class="QLabel" name="label_16">
+            <property name="text">
+             <string>N dim</string>
+            </property>
+           </widget>
+          </item>
+          <item row="4" column="0" colspan="3">
+           <widget class="QPushButton" name="pushButton_enableGUI">
+            <property name="text">
+             <string>Enable Control GUI</string>
+            </property>
+           </widget>
+          </item>
          </layout>
         </widget>
        </item>
@@ -703,6 +851,16 @@
        <string>Queue</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_2">
+       <item>
+        <widget class="QLabel" name="label_3">
+         <property name="text">
+          <string>Work in progress</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignCenter</set>
+         </property>
+        </widget>
+       </item>
        <item>
         <widget class="QPushButton" name="pushButton_5">
          <property name="enabled">
@@ -725,7 +883,7 @@
          </column>
          <column>
           <property name="text">
-           <string>scanID</string>
+           <string>scan_id</string>
           </property>
          </column>
          <column>

bec_widgets/examples/plotting/crosshair_example.py

@@ -1,168 +0,0 @@
-import numpy as np
-import pyqtgraph as pg
-from PyQt5.QtWidgets import (
-    QApplication,
-    QVBoxLayout,
-    QLabel,
-    QWidget,
-    QHBoxLayout,
-    QTableWidget,
-    QTableWidgetItem,
-    QSpinBox,
-)
-from pyqtgraph import mkPen
-from pyqtgraph.Qt import QtCore
-from bec_widgets.qt_utils import Crosshair
-
-
-class ExampleApp(QWidget):
-    def __init__(self):
-        super().__init__()
-
-        # Layout
-        self.layout = QHBoxLayout()
-        self.setLayout(self.layout)
-
-        ##########################
-        # 1D Plot
-        ##########################
-
-        # PlotWidget
-        self.plot_widget_1d = pg.PlotWidget(title="1D PlotWidget with multiple curves")
-        self.plot_item_1d = self.plot_widget_1d.getPlotItem()
-        self.plot_item_1d.setLogMode(True, True)
-
-        # 1D Datasets
-        self.x_data = np.linspace(0, 10, 1000)
-
-        def gauss(x, mu, sigma):
-            return (1 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - mu) / sigma) ** 2)
-
-        # same convention as in line_plot.py
-        self.y_value_list = [
-            gauss(self.x_data, 1, 1),
-            gauss(self.x_data, 1.5, 3),
-            abs(np.sin(self.x_data)),
-            abs(np.cos(self.x_data)),
-            abs(np.sin(2 * self.x_data)),
-        ]  # List of y-values for multiple curves
-
-        self.curve_names = ["Gauss(1,1)", "Gauss(1.5,3)", "Abs(Sine)", "Abs(Cosine)", "Abs(Sine2x)"]
-        self.curves = []
-
-        ##########################
-        # 2D Plot
-        ##########################
-        self.plot_widget_2d = pg.PlotWidget(title="2D plot with crosshair and ROI square")
-        self.data_2D = np.random.random((100, 200))
-        self.plot_item_2d = self.plot_widget_2d.getPlotItem()
-        self.image_item = pg.ImageItem(self.data_2D)
-        self.plot_item_2d.addItem(self.image_item)
-
-        ##########################
-        # Table
-        ##########################
-        self.table = QTableWidget(len(self.curve_names), 2)
-        self.table.setHorizontalHeaderLabels(["(X, Y) - Moved", "(X, Y) - Clicked"])
-        self.table.setVerticalHeaderLabels(self.curve_names)
-        self.table.resizeColumnsToContents()
-
-        ##########################
-        # Spinbox for N curves
-        ##########################
-        self.spin_box = QSpinBox()
-        self.spin_box.setMinimum(0)
-        self.spin_box.setMaximum(len(self.y_value_list))
-        self.spin_box.setValue(2)
-        self.spin_box.valueChanged.connect(lambda: self.update_curves(self.spin_box.value()))
-
-        ##########################
-        # Adding widgets to layout
-        ##########################
-
-        ##### left side #####
-        self.column1 = QVBoxLayout()
-        self.layout.addLayout(self.column1)
-
-        # SpinBox
-        self.spin_row = QHBoxLayout()
-        self.column1.addLayout(self.spin_row)
-        self.spin_row.addWidget(QLabel("Number of curves:"))
-        self.spin_row.addWidget(self.spin_box)
-
-        # label
-        self.clicked_label_1d = QLabel("Clicked Coordinates (1D):")
-        self.column1.addWidget(self.clicked_label_1d)
-
-        # table
-        self.column1.addWidget(self.table)
-
-        # 1D plot
-        self.column1.addWidget(self.plot_widget_1d)
-
-        ##### left side #####
-        self.column2 = QVBoxLayout()
-        self.layout.addLayout(self.column2)
-
-        # labels
-        self.clicked_label_2d = QLabel("Clicked Coordinates (2D):")
-        self.moved_label_2d = QLabel("Moved Coordinates (2D):")
-        self.column2.addWidget(self.clicked_label_2d)
-        self.column2.addWidget(self.moved_label_2d)
-
-        # 2D plot
-        self.column2.addWidget(self.plot_widget_2d)
-
-        self.update_curves(2)  # just Gaussian curves
-
-    def hook_crosshair(self):
-        self.crosshair_1d = Crosshair(self.plot_item_1d, precision=10)
-        self.crosshair_1d.coordinatesChanged1D.connect(
-            lambda x, y: self.update_table(self.table, x, y, column=0)
-        )
-        self.crosshair_1d.coordinatesClicked1D.connect(
-            lambda x, y: self.update_table(self.table, x, y, column=1)
-        )
-        # 2D
-        self.crosshair_2d = Crosshair(self.plot_item_2d)
-        self.crosshair_2d.coordinatesChanged2D.connect(
-            lambda x, y: self.moved_label_2d.setText(f"Mouse Moved Coordinates (2D): x={x}, y={y}")
-        )
-        self.crosshair_2d.coordinatesClicked2D.connect(
-            lambda x, y: self.clicked_label_2d.setText(f"Clicked Coordinates (2D): x={x}, y={y}")
-        )
-
-    def update_table(self, table_widget, x, y_values, column):
-        """Update the table with the new coordinates"""
-        for i, y in enumerate(y_values):
-            table_widget.setItem(i, column, QTableWidgetItem(f"({x}, {y})"))
-            table_widget.resizeColumnsToContents()
-
-    def update_curves(self, num_curves):
-        """Update the number of curves"""
-
-        self.plot_item_1d.clear()
-
-        # Curves
-        color_list = ["#384c6b", "#e28a2b", "#5E3023", "#e41a1c", "#984e83", "#4daf4a"]
-        self.plot_item_1d.addLegend()
-        self.curves = []
-
-        y_value_list = self.y_value_list[:num_curves]
-
-        for ii, y_value in enumerate(y_value_list):
-            pen = mkPen(color=color_list[ii], width=2, style=QtCore.Qt.DashLine)
-            curve = pg.PlotDataItem(
-                self.x_data, y_value, pen=pen, skipFiniteCheck=True, name=self.curve_names[ii]
-            )
-            self.plot_item_1d.addItem(curve)
-            self.curves.append(curve)
-
-        self.hook_crosshair()
-
-
-if __name__ == "__main__":
-    app = QApplication([])
-    window = ExampleApp()
-    window.show()
-    app.exec_()

bec_widgets/examples/stream_plot/line_plot.ui

@@ -29,10 +29,10 @@
       <property name="orientation">
        <enum>Qt::Vertical</enum>
       </property>
-      <widget class="GraphicsLayoutWidget" name="glw_plot"/>
-      <widget class="GraphicsLayoutWidget" name="glw_image"/>
+      <widget class="QWidget" name="glw_plot_placeholder" native="true"/>
+      <widget class="QWidget" name="glw_image_placeholder" native="true"/>
      </widget>
-     <widget class="QWidget" name="">
+     <widget class="QWidget" name="layoutWidget">
       <layout class="QVBoxLayout" name="verticalLayout" stretch="1,1,1,15">
        <item>
         <widget class="QPushButton" name="pushButton_generate">
@@ -143,13 +143,6 @@
    </item>
   </layout>
  </widget>
- <customwidgets>
-  <customwidget>
-   <class>GraphicsLayoutWidget</class>
-   <extends>QGraphicsView</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
- </customwidgets>
  <resources/>
  <connections/>
 </ui>

bec_widgets/examples/stream_plot/stream_plot.py

@@ -1,32 +1,27 @@
 import os
 import threading
 import time
-import warnings
-from typing import Any
 
 import numpy as np
 import pyqtgraph
 import pyqtgraph as pg
-from bec_lib.core import BECMessage
-from PyQt5.QtCore import pyqtSlot
-from PyQt5.QtWidgets import QCheckBox, QTableWidgetItem
-from pyqtgraph import mkBrush, mkColor, mkPen
-from pyqtgraph.Qt import QtCore, QtWidgets, uic
-from pyqtgraph.Qt.QtCore import pyqtSignal
+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.bec_dispatcher import bec_dispatcher
-from bec_lib.core.redis_connector import MessageObject, RedisConnector
-
-from qt_utils import Crosshair
-
-client = bec_dispatcher.client
+from bec_widgets.utils import Colors, Crosshair, UILoader
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 
-class BasicPlot(QtWidgets.QWidget):
-    update_signal = pyqtSignal()
-    roi_signal = pyqtSignal(tuple)
+class StreamPlot(QtWidgets.QWidget):
+    update_signal = Signal()
+    roi_signal = Signal(tuple)
 
-    def __init__(self, name="", y_value_list=["gauss_bpm"]) -> None:
+    def __init__(self, name="", y_value_list=["gauss_bpm"], client=None, parent=None) -> None:
         """
         Basic plot widget for displaying scan data.
 
@@ -35,15 +30,18 @@ class BasicPlot(QtWidgets.QWidget):
             y_value_list (list, optional): List of signals to be plotted. Defaults to ["gauss_bpm"].
         """
 
-        super(BasicPlot, self).__init__()
+        # 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__)
-        uic.loadUi(os.path.join(current_path, "line_plot.ui"), self)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "line_plot.ui"), self)
 
         self._idle_time = 100
-        self.producer = RedisConnector(["localhost:6379"]).producer()
+        self.connector = RedisConnector(["localhost:6379"])
 
         self.y_value_list = y_value_list
         self.previous_y_value_list = None
@@ -57,23 +55,23 @@ class BasicPlot(QtWidgets.QWidget):
 
         self.proxy_update = pg.SignalProxy(self.update_signal, rateLimit=25, slot=self.update)
 
-        self.data_retriever = threading.Thread(target=self.on_projection, daemon=True)
+        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()
 
-        # self.comboBox.currentIndexChanged.connect(lambda : print(f'current comboText: {self.comboBox.currentText()}'))
-        # self.comboBox.currentIndexChanged.connect(lambda: print(f'current comboIndex: {self.comboBox.currentIndex()}'))
-        #
-        # self.doubleSpinBox.valueChanged.connect(lambda : print('Spin Changed'))
-
-        # self.splitterH_main.setSizes([1, 1])
-
         ##########################
         # UI
         ##########################
         self.init_ui()
         self.init_curves()
         self.hook_crosshair()
-        self.pushButton_generate.clicked.connect(self.generate_data)
+
+    def close(self):
+        super().close()
+        self._data_retriever_thread_exit_event.set()
+        self.data_retriever.join()
 
     def init_ui(self):
         """Setup all ui elements"""
@@ -83,6 +81,9 @@ class BasicPlot(QtWidgets.QWidget):
 
         # 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")
 
@@ -113,6 +114,9 @@ class BasicPlot(QtWidgets.QWidget):
 
         # 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)")
 
@@ -153,9 +157,7 @@ class BasicPlot(QtWidgets.QWidget):
         self.pens = []
         self.brushs = []
 
-        self.color_list = BasicPlot.golden_angle_color(
-            colormap="CET-R2", num=len(self.y_value_list)
-        )
+        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)
@@ -180,8 +182,7 @@ class BasicPlot(QtWidgets.QWidget):
         self.hook_crosshair()
         self.init_table()
 
-    def splitter_sizes(self):
-        ...
+    def splitter_sizes(self): ...
 
     def hook_crosshair(self):
         self.crosshair_1d = Crosshair(self.plot, precision=4)
@@ -209,34 +210,6 @@ class BasicPlot(QtWidgets.QWidget):
         # ROI
         self.roi_selector.sigRegionChangeFinished.connect(self.get_roi_region)
 
-    def generate_data(self):
-        def gauss(x, mu, sigma):
-            return (1 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - mu) / sigma) ** 2)
-
-        self.plotter_data_x = np.linspace(0, 10, 1000)
-        self.plotter_data_y = [
-            gauss(self.plotter_data_x, 1, 1),
-            gauss(self.plotter_data_x, 1.5, 3),
-            np.sin(self.plotter_data_x),
-            np.cos(self.plotter_data_x),
-            np.sin(2 * self.plotter_data_x),
-        ]  # List of y-values for multiple curves
-        self.y_value_list = ["Gauss (1,1)", "Gauss (1.5,3)"]  # ["Sine"]#, "Cosine", "Sine2x"]
-
-        # Curves
-        color_list = ["#384c6b", "#e28a2b", "#5E3023", "#e41a1c", "#984e83", "#4daf4a"]
-
-        self.init_curves()
-
-        for ii in range(len(self.y_value_list)):
-            self.curves[ii].setData(self.plotter_data_x, self.plotter_data_y[ii])
-
-        self.data_2D = np.random.random((150, 30))
-        self.img.setImage(self.data_2D)
-
-        if self.roi_selector not in self.plot.items:
-            self.plot.addItem(self.roi_selector)
-
     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()
@@ -247,16 +220,16 @@ class BasicPlot(QtWidgets.QWidget):
                 np.where(self.plotter_data_x[0] < 10 ** region[1])[0][-1],
             ]
         }
-        msg = BECMessage.DeviceMessage(signals=return_dict).dumps()
-        self.producer.set_and_publish("px_stream/gui_event", msg=msg)
+        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.cursor_table.setRowCount(len(self.y_value_list))
+        self.ui.cursor_table.setRowCount(len(self.y_value_list))
         # self.table.setHorizontalHeaderLabels(["(X, Y) - Moved", "(X, Y) - Clicked"]) #TODO can be dynamic
-        self.cursor_table.setVerticalHeaderLabels(self.y_value_list)
-        self.cursor_table.resizeColumnsToContents()
+        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):
@@ -274,6 +247,12 @@ class BasicPlot(QtWidgets.QWidget):
 
         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:
@@ -292,59 +271,14 @@ class BasicPlot(QtWidgets.QWidget):
         # else:
         #     return
 
-    @staticmethod
-    def golden_ratio(num: int) -> list:
-        """Calculate the golden ratio for a given number of angles.
-
-        Args:
-            num (int): Number of angles
-        """
-        phi = 2 * np.pi * ((1 + np.sqrt(5)) / 2)
-        angles = []
-        for ii in range(num):
-            x = np.cos(ii * phi)
-            y = np.sin(ii * phi)
-            angle = np.arctan2(y, x)
-            angles.append(angle)
-        return angles
-
-    @staticmethod
-    def golden_angle_color(colormap: str, num: int) -> list:
-        """
-        Extract num colors for from the specified colormap following golden angle distribution.
-
-        Args:
-            colormap (str): Name of the colormap
-            num (int): Number of requested colors
-
-        Returns:
-            list: List of colors with length <num>
-
-        Raises:
-            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
-        """
-
-        cmap = pg.colormap.get(colormap)
-        cmap_colors = cmap.color
-        if num > len(cmap_colors):
-            raise ValueError(
-                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
-            )
-        angles = BasicPlot.golden_ratio(len(cmap_colors))
-        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
-        colors = [
-            mkColor(tuple((cmap_colors[int(ii)] * 255).astype(int))) for ii in color_selection[:num]
-        ]
-        return colors
-
-    def on_projection(self):
-        while True:
+    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 = client.producer.lrange(topic=endpoint, start=-1, end=-1)
-            data = [BECMessage.DeviceMessage.loads(msg) for msg in msgs]
+            msgs = self.client.connector.lrange(topic=endpoint, start=-1, end=-1)
+            data = msgs
             if not data:
                 continue
             with np.errstate(divide="ignore", invalid="ignore"):
@@ -358,16 +292,18 @@ class BasicPlot(QtWidgets.QWidget):
 
             self.update_signal.emit()
 
-    @pyqtSlot(dict, dict)
+    @Slot(dict, dict)
     def on_dap_update(self, data: dict, metadata: dict):
-        self.img.setImage(data["z"])
+        flipped_data = self.flip_even_rows(data["data"]["z"])
 
-    @pyqtSlot(dict)
-    def new_proj(self, data):
-        proj_nr = data["proj_nr"]
+        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 = client.producer.get(topic=endpoint)
-        msg = BECMessage.DeviceMessage.loads(msg_raw)
+        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"]
@@ -379,30 +315,28 @@ class BasicPlot(QtWidgets.QWidget):
 if __name__ == "__main__":
     import argparse
 
-    from bec_widgets import ctrl_c
-    from bec_widgets.bec_dispatcher import bec_dispatcher
+    # 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"],
+        "--signals", help="specify recorded signals", nargs="+", default=["gauss_bpm"]
     )
     # default = ["gauss_bpm", "bpm4i", "bpm5i", "bpm6i", "xert"],
-    # dispatcher = bec_dispatcher
     value = parser.parse_args()
     print(f"Plotting signals for: {', '.join(value.signals)}")
+
+    # Client from dispatcher
+    bec_dispatcher = BECDispatcher()
     client = bec_dispatcher.client
-    # client.start()
+
     app = QtWidgets.QApplication([])
-    ctrl_c.setup(app)
-    plot = BasicPlot(y_value_list=value.signals)
-    # bec_dispatcher.connect(plot)
-    bec_dispatcher.connect_proj_id(plot.new_proj)
-    bec_dispatcher.connect_dap_slot(plot.on_dap_update, "px_dap_worker")
-    plot.roi_signal.connect(lambda x: print(f"signal from ROI {x}"))
-    plot.roi_signal.connect(lambda x: bec_dispatcher.getStuff(x))
+    # 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_()
+    app.exec()

bec_widgets/line_plot_legacy.py

@@ -1,360 +0,0 @@
-import os
-import warnings
-from typing import Any
-
-import numpy as np
-import pyqtgraph
-import pyqtgraph as pg
-from PyQt5.QtCore import pyqtSlot
-from PyQt5.QtWidgets import QTableWidgetItem, QCheckBox
-
-from bec_lib import BECClient
-from pyqtgraph import mkBrush, mkColor, mkPen
-from pyqtgraph.Qt import QtCore, QtWidgets, uic
-from pyqtgraph.Qt.QtCore import pyqtSignal
-
-
-class BasicPlot(QtWidgets.QWidget):
-    update_signal = pyqtSignal()
-    roi_signal = pyqtSignal(tuple)
-
-    def __init__(self, name="", y_value_list=["gauss_bpm"]) -> 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"].
-        """
-
-        super(BasicPlot, self).__init__()
-        # Set style for pyqtgraph plots
-        pg.setConfigOption("background", "w")
-        pg.setConfigOption("foreground", "k")
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "line_plot.ui"), self)
-
-        # Set splitter distribution of widgets
-        self.splitter.setSizes([5, 2])
-
-        self._idle_time = 100
-        self.title = ""
-        self.label_bottom = ""
-        self.label_left = ""
-
-        self.scan_motors = []
-        self.y_value_list = y_value_list
-        self.previous_y_value_list = None
-        self.plotter_data_x = []
-        self.plotter_data_y = []
-        self.curves = []
-        self.pens = []
-        self.brushs = []
-
-        self.plotter_scan_id = None
-
-        # TODO to be moved to utils function
-        plotstyles = {
-            "symbol": "o",
-            "symbolSize": 10,
-        }
-        color_list = ["#384c6b", "#e28a2b", "#5E3023", "#e41a1c", "#984e83", "#4daf4a"]
-        color_list = BasicPlot.golden_angle_color(colormap="CET-R2", num=len(self.y_value_list))
-
-        # setup plots - GraphicsLayoutWidget
-        # LabelItem
-        self.label = pg.LabelItem(justify="center")
-        self.glw.addItem(self.label)
-        self.label.setText("test label")
-
-        # PlotItem - main window
-        self.glw.nextRow()
-        self.plot = pg.PlotItem()
-        self.glw.addItem(self.plot)
-        self.plot.addLegend()
-
-        # PlotItem - ROI window - disabled for now #TODO add 2D plot for ROI and 1D plot for mouse click
-        # self.glw.nextRow()
-        # self.plot_roi = pg.PlotItem()
-        # self.glw.addItem(self.plot_roi)
-
-        # ROI selector - so far from [-1,1] #TODO update to scale with xrange
-        self.roi_selector = pg.LinearRegionItem([-1, 1])
-
-        for ii, y_value in enumerate(self.y_value_list):
-            pen = mkPen(color=color_list[ii], width=2, style=QtCore.Qt.DashLine)
-            brush = mkBrush(color=color_list[ii])
-            curve = pg.PlotDataItem(
-                **plotstyles, 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)
-
-        self.crosshair_v = pg.InfiniteLine(angle=90, movable=False)
-        self.crosshair_h = pg.InfiniteLine(angle=0, movable=False)
-        self.plot.addItem(self.crosshair_v, ignoreBounds=True)
-        self.plot.addItem(self.crosshair_h, ignoreBounds=True)
-
-        # Add textItems
-        self.add_text_items()
-
-        # Manage signals
-        self.proxy = pg.SignalProxy(
-            self.plot.scene().sigMouseMoved, rateLimit=60, slot=self.mouse_moved
-        )
-        self.proxy_update = pg.SignalProxy(self.update_signal, rateLimit=25, slot=self.update)
-        self.roi_selector.sigRegionChangeFinished.connect(self.get_roi_region)
-        self.pushButton_debug.clicked.connect(self.debug)
-
-    def debug(self):
-        """
-        Debug button just for quick testing
-        """
-
-    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.setText(f"x = {region[0]:.4f}, y ={region[1]:.4f}")
-        self.roi_signal.emit(region)
-
-    def add_text_items(self):  # TODO probably can be removed
-        """Add text items to the plot"""
-
-        # self.mouse_box_data.setText("Mouse cursor")
-        # TODO Via StyleSheet, one may set the color of the full QLabel
-        # self.mouse_box_data.setStyleSheet(f"QLabel {{color : rgba{self.pens[0].color().getRgb()}}}")
-
-    def mouse_moved(self, event: tuple) -> None:
-        """
-        Update the mouse table with the current mouse position and the corresponding data.
-
-        Args:
-            event (tuple):  Mouse event containing the position of the mouse cursor.
-                            The position is stored in first entry as horizontal, vertical pixel.
-        """
-        pos = event[0]
-        if not self.plot.sceneBoundingRect().contains(pos):
-            return
-        mousePoint = self.plot.vb.mapSceneToView(pos)
-        self.crosshair_v.setPos(mousePoint.x())
-        self.crosshair_h.setPos(mousePoint.y())
-        if not self.plotter_data_x:
-            return
-
-        for ii, y_value in enumerate(self.y_value_list):
-            closest_point = self.closest_x_y_value(
-                mousePoint.x(), self.plotter_data_x, self.plotter_data_y[ii]
-            )
-            # TODO fix text wobble in plot, see plot when it crosses 0
-            x_data = f"{closest_point[0]:.{self.precision}f}"
-            y_data = f"{closest_point[1]:.{self.precision}f}"
-
-            # Write coordinate to QTable
-            self.mouse_table.setItem(ii, 1, QTableWidgetItem(str(y_value)))
-            self.mouse_table.setItem(ii, 2, QTableWidgetItem(str(x_data)))
-            self.mouse_table.setItem(ii, 3, QTableWidgetItem(str(y_data)))
-
-            self.mouse_table.resizeColumnsToContents()
-
-    def closest_x_y_value(self, input_value, list_x, list_y) -> tuple:
-        """
-        Find the closest x and y value to the input value.
-
-        Args:
-            input_value (float): Input value
-            list_x (list): List of x values
-            list_y (list): List of y values
-
-        Returns:
-            tuple: Closest x and y value
-        """
-        arr = np.asarray(list_x)
-        i = (np.abs(arr - input_value)).argmin()
-        return list_x[i], list_y[i]
-
-    def update(self):
-        """Update the plot with the new data."""
-        # check if roi selector is in the plot
-        if self.roi_selector not in self.plot.items:
-            self.plot.addItem(self.roi_selector)
-
-        # 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
-
-        if len(self.plotter_data_x) <= 1:
-            return
-        self.plot.setLabel("bottom", self.label_bottom)
-        self.plot.setLabel("left", self.label_left)
-        for ii in range(len(self.y_value_list)):
-            self.curves[ii].setData(self.plotter_data_x, self.plotter_data_y[ii])
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, data: dict, metadata: dict) -> None:
-        """Update function that is called during the scan callback. To avoid
-        too many renderings, the GUI is only processing events every <_idle_time> ms.
-
-        Args:
-            data (dict): Dictionary containing a new scan segment
-            metadata (dict): Scan metadata
-
-        """
-        if metadata["scanID"] != self.plotter_scan_id:
-            self.plotter_scan_id = metadata["scanID"]
-            self._reset_plot_data()
-
-        self.title = f"Scan {metadata['scan_number']}"
-
-        self.scan_motors = scan_motors = metadata.get("scan_report_devices")
-        # client = BECClient()
-        remove_y_value_index = [
-            index
-            for index, y_value in enumerate(self.y_value_list)
-            if y_value not in client.device_manager.devices
-        ]
-        if remove_y_value_index:
-            for ii in sorted(remove_y_value_index, reverse=True):
-                # TODO Use bec warning message??? to be discussed with Klaus
-                warnings.warn(
-                    f"Warning: no matching signal for {self.y_value_list[ii]} found in list of devices. Removing from plot."
-                )
-                self.remove_curve_by_name(self.plot, self.y_value_list[ii])
-                self.y_value_list.pop(ii)
-
-        self.precision = client.device_manager.devices[scan_motors[0]]._info["describe"][
-            scan_motors[0]
-        ]["precision"]
-        # TODO after update of bec_lib, this will be new way to access data
-        # self.precision = client.device_manager.devices[scan_motors[0]].precision
-
-        x = data["data"][scan_motors[0]][scan_motors[0]]["value"]
-        self.plotter_data_x.append(x)
-        for ii, y_value in enumerate(self.y_value_list):
-            y = data["data"][y_value][y_value]["value"]
-            self.plotter_data_y[ii].append(y)
-        self.label_bottom = scan_motors[0]
-        self.label_left = f"{', '.join(self.y_value_list)}"
-
-        # print(f'metadata scan N{metadata["scan_number"]}') #TODO put as label on top of plot
-        # print(f'Data point = {data["point_id"]}') #TODO can be used for progress bar
-
-        if len(self.plotter_data_x) <= 1:
-            return
-        self.update_signal.emit()
-
-    def _reset_plot_data(self):
-        """Reset the plot data."""
-        self.plotter_data_x = []
-        self.plotter_data_y = []
-        for ii in range(len(self.y_value_list)):
-            self.curves[ii].setData([], [])
-            self.plotter_data_y.append([])
-
-    def setup_cursor_table(self):
-        """QTable formatting according to N of devices displayed in plot."""
-
-        # Init number of rows in table according to n of devices
-        self.mouse_table.setRowCount(len(self.y_value_list))
-
-        for ii, y_value in enumerate(self.y_value_list):
-            checkbox = QCheckBox()
-            checkbox.setChecked(True)
-            # TODO just for testing, will be replaced by removing/adding curve
-            checkbox.stateChanged.connect(lambda: print("status Changed"))
-            # checkbox.stateChanged.connect(lambda: self.remove_curve_by_name(plot=self.plot, checkbox=checkbox, name=y_value))
-            self.mouse_table.setCellWidget(ii, 0, checkbox)
-            self.mouse_table.setItem(ii, 1, QTableWidgetItem(str(y_value)))
-
-            self.mouse_table.resizeColumnsToContents()
-
-    @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
-
-    @staticmethod
-    def golden_ratio(num: int) -> list:
-        """Calculate the golden ratio for a given number of angles.
-
-        Args:
-            num (int): Number of angles
-        """
-        phi = 2 * np.pi * ((1 + np.sqrt(5)) / 2)
-        angles = []
-        for ii in range(num):
-            x = np.cos(ii * phi)
-            y = np.sin(ii * phi)
-            angle = np.arctan2(y, x)
-            angles.append(angle)
-        return angles
-
-    @staticmethod
-    def golden_angle_color(colormap: str, num: int) -> list:
-        """
-        Extract num colors for from the specified colormap following golden angle distribution.
-
-        Args:
-            colormap (str): Name of the colormap
-            num (int): Number of requested colors
-
-        Returns:
-            list: List of colors with length <num>
-
-        Raises:
-            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
-        """
-
-        cmap = pg.colormap.get(colormap)
-        cmap_colors = cmap.color
-        if num > len(cmap_colors):
-            raise ValueError(
-                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
-            )
-        angles = BasicPlot.golden_ratio(len(cmap_colors))
-        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
-        colors = [
-            mkColor(tuple((cmap_colors[int(ii)] * 255).astype(int))) for ii in color_selection[:num]
-        ]
-        return colors
-
-
-if __name__ == "__main__":
-    import argparse
-    from bec_widgets.bec_dispatcher import bec_dispatcher
-
-    from bec_widgets import ctrl_c
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--signals",
-        help="specify recorded signals",
-        nargs="+",
-        default=["gauss_bpm", "bpm4i", "bpm5i", "bpm6i", "xert"],
-    )
-    value = parser.parse_args()
-    print(f"Plotting signals for: {', '.join(value.signals)}")
-    client = bec_dispatcher.client
-    # client.start()
-    app = QtWidgets.QApplication([])
-    ctrl_c.setup(app)
-    plot = BasicPlot(y_value_list=value.signals)
-    bec_dispatcher.connect(plot)
-    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/qt_utils/__init__.py

@@ -1 +0,0 @@
-from .crosshair import Crosshair

bec_widgets/qtdesigner_plugins/scan2d_plot_plugin.py

@@ -1,56 +0,0 @@
-from PyQt5.QtDesigner import QPyDesignerCustomWidgetPlugin
-from PyQt5.QtGui import QIcon
-
-from bec_widgets.scan2d_plot import BECScanPlot2D
-
-
-class BECScanPlot2DPlugin(QPyDesignerCustomWidgetPlugin):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-
-        self._initialized = False
-
-    def initialize(self, formEditor):
-        if self._initialized:
-            return
-
-        self._initialized = True
-
-    def isInitialized(self):
-        return self._initialized
-
-    def createWidget(self, parent):
-        return BECScanPlot2D(parent)
-
-    def name(self):
-        return "BECScanPlot2D"
-
-    def group(self):
-        return "BEC widgets"
-
-    def icon(self):
-        return QIcon()
-
-    def toolTip(self):
-        return "BEC plot for 2D scans"
-
-    def whatsThis(self):
-        return "BEC plot for 2D scans"
-
-    def isContainer(self):
-        return False
-
-    def domXml(self):
-        return (
-            '<widget class="BECScanPlot2D" name="BECScanPlot2D">\n'
-            ' <property name="toolTip" >\n'
-            "  <string>BEC plot for 2D scans</string>\n"
-            " </property>\n"
-            ' <property name="whatsThis" >\n'
-            "  <string>BEC plot for 2D scans in Python using PyQt.</string>\n"
-            " </property>\n"
-            "</widget>\n"
-        )
-
-    def includeFile(self):
-        return "scan2d_plot"

bec_widgets/qtdesigner_plugins/scan_plot_plugin.py

@@ -1,56 +0,0 @@
-from PyQt5.QtDesigner import QPyDesignerCustomWidgetPlugin
-from PyQt5.QtGui import QIcon
-
-from bec_widgets.scan_plot import BECScanPlot
-
-
-class BECScanPlotPlugin(QPyDesignerCustomWidgetPlugin):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-
-        self._initialized = False
-
-    def initialize(self, formEditor):
-        if self._initialized:
-            return
-
-        self._initialized = True
-
-    def isInitialized(self):
-        return self._initialized
-
-    def createWidget(self, parent):
-        return BECScanPlot(parent)
-
-    def name(self):
-        return "BECScanPlot"
-
-    def group(self):
-        return "BEC widgets"
-
-    def icon(self):
-        return QIcon()
-
-    def toolTip(self):
-        return "BEC plot for scans"
-
-    def whatsThis(self):
-        return "BEC plot for scans"
-
-    def isContainer(self):
-        return False
-
-    def domXml(self):
-        return (
-            '<widget class="BECScanPlot" name="BECScanPlot">\n'
-            ' <property name="toolTip" >\n'
-            "  <string>BEC plot for scans</string>\n"
-            " </property>\n"
-            ' <property name="whatsThis" >\n'
-            "  <string>BEC plot for scans in Python using PyQt.</string>\n"
-            " </property>\n"
-            "</widget>\n"
-        )
-
-    def includeFile(self):
-        return "scan_plot"

bec_widgets/readme.md

@@ -1,12 +0,0 @@
-Add/modify the path in the following variable to make the plugin avaiable in Qt Designer:
-```
-$ export PYQTDESIGNERPATH=/<path to repo>/bec_widgets/qtdesigner_plugins
-```
-
-It can be done when activating a conda environment (run with the corresponding env already activated):
-```
-$ conda env config vars set PYQTDESIGNERPATH=/<path to repo>/bec_widgets/qtdesigner_plugins
-```
-
-All the available conda-forge `pyqt >=5.15` packages don't seem to support loading Qt Designer
-python plugins at the time of writing. Use `pyqt =5.12` to solve the issue for now.

bec_widgets/scan2d_plot.py

@@ -1,140 +0,0 @@
-import numpy as np
-import pyqtgraph as pg
-from bec_lib.core.logger import bec_logger
-from PyQt5.QtCore import pyqtProperty, pyqtSlot
-
-from bec_widgets.bec_dispatcher import bec_dispatcher
-
-logger = bec_logger.logger
-
-
-pg.setConfigOptions(background="w", foreground="k", antialias=True)
-
-
-class BECScanPlot2D(pg.GraphicsView):
-    def __init__(self, parent=None, background="default"):
-        super().__init__(parent, background)
-        bec_dispatcher.connect(self)
-
-        self._x_channel = ""
-        self._y_channel = ""
-        self._z_channel = ""
-
-        self._xpos = []
-        self._ypos = []
-
-        self._x_ind = None
-        self._y_ind = None
-
-        self.plot_item = pg.PlotItem()
-        self.setCentralItem(self.plot_item)
-        self.plot_item.setAspectLocked(True)
-
-        self.imageItem = pg.ImageItem()
-        self.plot_item.addItem(self.imageItem)
-
-    @pyqtSlot(dict, dict)
-    def on_new_scan(self, _scan_segment, metadata):
-        # TODO: Do we reset in case of a scan type change?
-        self.imageItem.clear()
-
-        # TODO: better to check the number of coordinates in metadata["positions"]?
-        if metadata["scan_name"] != "grid_scan":
-            return
-
-        positions = [sorted(set(pos)) for pos in zip(*metadata["positions"])]
-
-        motors = metadata["scan_motors"]
-        if self.x_channel and self.y_channel:
-            self._x_ind = motors.index(self.x_channel) if self.x_channel in motors else None
-            self._y_ind = motors.index(self.y_channel) if self.y_channel in motors else None
-        elif not self.x_channel and not self.y_channel:
-            # Plot the first and second motors along x and y axes respectively
-            self._x_ind = 0
-            self._y_ind = 1
-        else:
-            logger.warning(
-                f"X and Y channels should be either both empty or both set in {self.objectName()}"
-            )
-
-        if self._x_ind is None or self._y_ind is None:
-            return
-
-        xpos = positions[self._x_ind]
-        ypos = positions[self._y_ind]
-
-        self._xpos = xpos
-        self._ypos = ypos
-
-        self.imageItem.setImage(np.zeros(shape=(len(xpos), len(ypos))))
-
-        w = max(xpos) - min(xpos)
-        h = max(ypos) - min(ypos)
-        w_pix = w / (len(xpos) - 1)
-        h_pix = h / (len(ypos) - 1)
-        self.imageItem.setRect(min(xpos) - w_pix / 2, min(ypos) - h_pix / 2, w + w_pix, h + h_pix)
-
-        self.plot_item.setLabel("bottom", motors[self._x_ind])
-        self.plot_item.setLabel("left", motors[self._y_ind])
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, scan_segment, metadata):
-        if not self.z_channel or metadata["scan_name"] != "grid_scan":
-            return
-
-        if self._x_ind is None or self._y_ind is None:
-            return
-
-        point_coord = metadata["positions"][scan_segment["point_id"]]
-
-        x_coord_ind = self._xpos.index(point_coord[self._x_ind])
-        y_coord_ind = self._ypos.index(point_coord[self._y_ind])
-
-        data = scan_segment["data"]
-        z_new = data[self.z_channel][self.z_channel]["value"]
-
-        image = self.imageItem.image
-        image[x_coord_ind, y_coord_ind] = z_new
-        self.imageItem.setImage()
-
-    @pyqtProperty(str)
-    def x_channel(self):
-        return self._x_channel
-
-    @x_channel.setter
-    def x_channel(self, new_val):
-        self._x_channel = new_val
-        self.plot_item.setLabel("bottom", new_val)
-
-    @pyqtProperty(str)
-    def y_channel(self):
-        return self._y_channel
-
-    @y_channel.setter
-    def y_channel(self, new_val):
-        self._y_channel = new_val
-        self.plot_item.setLabel("left", new_val)
-
-    @pyqtProperty(str)
-    def z_channel(self):
-        return self._z_channel
-
-    @z_channel.setter
-    def z_channel(self, new_val):
-        self._z_channel = new_val
-
-
-if __name__ == "__main__":
-    import sys
-
-    from PyQt5.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-
-    plot = BECScanPlot2D()
-    # If x_channel and y_channel are both omitted, they will be inferred from each running grid scan
-    plot.z_channel = "bpm3y"
-
-    plot.show()
-
-    sys.exit(app.exec_())

bec_widgets/scan_plot.py

@@ -1,137 +0,0 @@
-import itertools
-
-import pyqtgraph as pg
-from bec_lib.core.logger import bec_logger
-from PyQt5.QtCore import pyqtProperty, pyqtSlot
-
-from bec_widgets.bec_dispatcher import bec_dispatcher
-
-logger = bec_logger.logger
-
-
-pg.setConfigOptions(background="w", foreground="k", antialias=True)
-COLORS = ["#fd7f6f", "#7eb0d5", "#b2e061", "#bd7ebe", "#ffb55a"]
-
-
-class BECScanPlot(pg.GraphicsView):
-    def __init__(self, parent=None, background="default"):
-        super().__init__(parent, background)
-        bec_dispatcher.connect(self)
-
-        self.view = pg.PlotItem()
-        self.setCentralItem(self.view)
-
-        self._x_channel = ""
-        self._y_channel_list = []
-
-        self.scan_curves = {}
-        self.dap_curves = {}
-
-    @pyqtSlot(dict, dict)
-    def on_new_scan(self, _scan_segment, _metadata):
-        for plot_curve in {**self.scan_curves, **self.dap_curves}.values():
-            plot_curve.setData(x=[], y=[])
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, scan_segment, _metadata):
-        if not self.x_channel:
-            return
-
-        data = scan_segment["data"]
-
-        if self.x_channel not in data:
-            logger.warning(f"Unknown channel `{self.x_channel}` for X data in {self.objectName()}")
-            return
-
-        x_new = data[self.x_channel][self.x_channel]["value"]
-        for chan, plot_curve in self.scan_curves.items():
-            if not chan:
-                continue
-
-            if chan not in data:
-                logger.warning(f"Unknown channel `{chan}` for Y data in {self.objectName()}")
-                continue
-
-            y_new = data[chan][chan]["value"]
-            x, y = plot_curve.getData()  # TODO: is it a good approach?
-            if x is None:
-                x = []
-            if y is None:
-                y = []
-
-            plot_curve.setData(x=[*x, x_new], y=[*y, y_new])
-
-    @pyqtSlot(dict, dict)
-    def redraw_dap(self, data, _metadata):
-        for chan, plot_curve in self.dap_curves.items():
-            if not chan:
-                continue
-
-            if chan not in data:
-                logger.warning(f"Unknown channel `{chan}` for DAP data in {self.objectName()}")
-                continue
-
-            x_new = data[chan]["x"]
-            y_new = data[chan]["y"]
-
-            plot_curve.setData(x=x_new, y=y_new)
-
-    @pyqtProperty("QStringList")
-    def y_channel_list(self):
-        return self._y_channel_list
-
-    @y_channel_list.setter
-    def y_channel_list(self, new_list):
-        # TODO: do we want to care about dap/not dap here?
-        chan_removed = [chan for chan in self._y_channel_list if chan not in new_list]
-        if chan_removed and chan_removed[0].startswith("dap."):
-            chan_removed = chan_removed[0].partition("dap.")[-1]
-            bec_dispatcher.disconnect_dap_slot(self.redraw_dap, chan_removed)
-
-        self._y_channel_list = new_list
-
-        # Prepare plot for a potentially different list of y channels
-        self.view.clear()
-
-        self.view.addLegend()
-        colors = itertools.cycle(COLORS)
-
-        for y_chan in new_list:
-            if y_chan.startswith("dap."):
-                y_chan = y_chan.partition("dap.")[-1]
-                curves = self.dap_curves
-                bec_dispatcher.connect_dap_slot(self.redraw_dap, y_chan)
-            else:
-                curves = self.scan_curves
-
-            curves[y_chan] = self.view.plot(
-                x=[], y=[], pen=pg.mkPen(color=next(colors), width=2), name=y_chan
-            )
-
-        if len(new_list) == 1:
-            self.view.setLabel("left", new_list[0])
-
-    @pyqtProperty(str)
-    def x_channel(self):
-        return self._x_channel
-
-    @x_channel.setter
-    def x_channel(self, new_val):
-        self._x_channel = new_val
-        self.view.setLabel("bottom", new_val)
-
-
-if __name__ == "__main__":
-    import sys
-
-    from PyQt5.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-
-    plot = BECScanPlot()
-    plot.x_channel = "samx"
-    plot.y_channel_list = ["bpm3y", "bpm6y"]
-
-    plot.show()
-
-    sys.exit(app.exec_())

bec_widgets/utils/__init__.py

@@ -0,0 +1,11 @@
+from .bec_connector import BECConnector, ConnectionConfig
+from .bec_dispatcher import BECDispatcher
+from .bec_table import BECTable
+from .colors import Colors
+from .container_utils import WidgetContainerUtils
+from .crosshair import Crosshair
+from .entry_validator import EntryValidator
+from .layout_manager import GridLayoutManager
+from .rpc_decorator import register_rpc_methods, rpc_public
+from .ui_loader import UILoader
+from .validator_delegate import DoubleValidationDelegate

bec_widgets/utils/bec_connector.py

@@ -0,0 +1,170 @@
+# pylint: disable = no-name-in-module,missing-module-docstring
+from __future__ import annotations
+
+import time
+from typing import Optional, Type
+
+from bec_lib.utils.import_utils import lazy_import, lazy_import_from
+from pydantic import BaseModel, Field, field_validator
+from qtpy.QtCore import Slot as pyqtSlot
+
+from bec_widgets.cli.rpc_register import RPCRegister
+
+BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
+
+
+class ConnectionConfig(BaseModel):
+    """Configuration for BECConnector mixin class"""
+
+    widget_class: str = Field(default="NonSpecifiedWidget", description="The class of the widget.")
+    gui_id: Optional[str] = Field(
+        default=None, validate_default=True, description="The GUI ID of the widget."
+    )
+
+    @field_validator("gui_id")
+    def generate_gui_id(cls, v, values):
+        """Generate a GUI ID if none is provided."""
+        if v is None:
+            widget_class = values.data["widget_class"]
+            v = f"{widget_class}_{str(time.time())}"
+            return v
+        return v
+
+
+class BECConnector:
+    """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
+
+    USER_ACCESS = ["config_dict", "get_all_rpc"]
+
+    def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
+        # BEC related connections
+        self.bec_dispatcher = BECDispatcher(client=client)
+        self.client = self.bec_dispatcher.client if client is None else client
+
+        if config:
+            self.config = config
+            self.config.widget_class = self.__class__.__name__
+        else:
+            print(
+                f"No initial config found for {self.__class__.__name__}.\n"
+                f"Initializing with default config."
+            )
+            self.config = ConnectionConfig(widget_class=self.__class__.__name__)
+
+        if gui_id:
+            self.config.gui_id = gui_id
+            self.gui_id = gui_id
+        else:
+            self.gui_id = self.config.gui_id
+
+        # register widget to rpc register
+        self.rpc_register = RPCRegister()
+        self.rpc_register.add_rpc(self)
+
+    def get_all_rpc(self) -> dict:
+        """Get all registered RPC objects."""
+        all_connections = self.rpc_register.list_all_connections()
+        return dict(all_connections)
+
+    @property
+    def rpc_id(self) -> str:
+        """Get the RPC ID of the widget."""
+        return self.gui_id
+
+    @rpc_id.setter
+    def rpc_id(self, rpc_id: str) -> None:
+        """Set the RPC ID of the widget."""
+        self.gui_id = rpc_id
+
+    @property
+    def config_dict(self) -> dict:
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+        return self.config.model_dump()
+
+    @config_dict.setter
+    def config_dict(self, config: BaseModel) -> None:
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+        self.config = config
+
+    @pyqtSlot(str)
+    def set_gui_id(self, gui_id: str) -> None:
+        """
+        Set the GUI ID for the widget.
+
+        Args:
+            gui_id(str): GUI ID
+        """
+        self.config.gui_id = gui_id
+        self.gui_id = gui_id
+
+    def get_obj_by_id(self, obj_id: str):
+        if obj_id == self.gui_id:
+            return self
+
+    def get_bec_shortcuts(self):
+        """Get BEC shortcuts for the widget."""
+        self.dev = self.client.device_manager.devices
+        self.scans = self.client.scans
+        self.queue = self.client.queue
+        self.scan_storage = self.queue.scan_storage
+        self.dap = self.client.dap
+
+    def update_client(self, client) -> None:
+        """Update the client and device manager from BEC and create object for BEC shortcuts.
+
+        Args:
+            client: BEC client
+        """
+        self.client = client
+        self.get_bec_shortcuts()
+
+    @pyqtSlot(ConnectionConfig)  # TODO can be also dict
+    def on_config_update(self, config: ConnectionConfig | dict) -> None:
+        """
+        Update the configuration for the widget.
+
+        Args:
+            config(ConnectionConfig): Configuration settings.
+        """
+        if isinstance(config, dict):
+            config = ConnectionConfig(**config)
+            # TODO add error handler
+
+        self.config = config
+
+    def get_config(self, dict_output: bool = True) -> dict | BaseModel:
+        """
+        Get the configuration of the widget.
+
+        Args:
+            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
+
+        Returns:
+            dict: The configuration of the plot widget.
+        """
+        if dict_output:
+            return self.config.model_dump()
+        else:
+            return self.config
+
+    def cleanup(self):
+        """Cleanup the widget."""
+        self.rpc_register.remove_rpc(self)
+        all_connections = self.rpc_register.list_all_connections()
+        if len(all_connections) == 0:
+            print("No more connections. Shutting down GUI BEC client.")
+            self.client.shutdown()
+
+    # def closeEvent(self, event):
+    #     self.cleanup()
+    #     super().closeEvent(event)

bec_widgets/utils/bec_dispatcher.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import argparse
+import collections
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Union
+
+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 QObject
+from qtpy.QtCore import Signal as pyqtSignal
+
+if TYPE_CHECKING:
+    from bec_lib.endpoints import EndpointInfo
+
+
+class QtThreadSafeCallback(QObject):
+    cb_signal = pyqtSignal(dict, dict)
+
+    def __init__(self, cb):
+        super().__init__()
+
+        self.cb = cb
+        self.cb_signal.connect(self.cb)
+
+    def __hash__(self):
+        # make 2 differents QtThreadSafeCallback to look
+        # identical when used as dictionary keys, if the
+        # callback is the same
+        return id(self.cb)
+
+    def __call__(self, msg_content, metadata):
+        self.cb_signal.emit(msg_content, metadata)
+
+
+class QtRedisConnector(RedisConnector):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def _execute_callback(self, cb, msg, kwargs):
+        if not isinstance(cb, QtThreadSafeCallback):
+            return super()._execute_callback(cb, msg, kwargs)
+        # if msg.msg_type == "bundle_message":
+        #    # big warning: how to handle bundle messages?
+        #    # message with messages inside ; which slot to call?
+        #    # bundle_msg = msg
+        #    # for msg in bundle_msg:
+        #    #    ...
+        #    # for now, only consider the 1st message
+        #    msg = msg[0]
+        #    raise RuntimeError(f"
+        if isinstance(msg, MessageObject):
+            if isinstance(msg.value, list):
+                msg = msg.value[0]
+            else:
+                msg = msg.value
+
+            # we can notice kwargs are lost when passed to Qt slot
+            metadata = msg.metadata
+            cb(msg.content, metadata)
+        else:
+            # from stream
+            msg = msg["data"]
+            cb(msg.content, msg.metadata)
+
+
+class BECDispatcher:
+    """Utility class to keep track of slots connected to a particular redis connector"""
+
+    _instance = None
+    _initialized = False
+
+    def __new__(cls, client=None, config: str = None, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(BECDispatcher, cls).__new__(cls)
+            cls._initialized = False
+        return cls._instance
+
+    def __init__(self, client=None, config: str = None):
+        if self._initialized:
+            return
+
+        self._slots = collections.defaultdict(set)
+        self.client = client
+
+        if self.client is None:
+            if config is not None:
+                host, port = config.split(":")
+                redis_config = {"host": host, "port": port}
+                self.client = BECClient(
+                    config=ServiceConfig(redis=redis_config), connector_cls=QtRedisConnector
+                )  # , forced=True)
+            else:
+                self.client = BECClient(connector_cls=QtRedisConnector)  # , forced=True)
+        else:
+            if self.client.started:
+                # have to reinitialize client to use proper connector
+                self.client.shutdown()
+            self.client._BECClient__init_params["connector_cls"] = QtRedisConnector
+
+        try:
+            self.client.start()
+        except redis.exceptions.ConnectionError:
+            print("Could not connect to Redis, skipping start of BECClient.")
+
+        self._initialized = True
+
+    @classmethod
+    def reset_singleton(cls):
+        cls._instance = None
+        cls._initialized = False
+
+    def connect_slot(
+        self, slot: Callable, topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]]
+    ) -> None:
+        """Connect widget's pyqt slot, so that it is called on new pub/sub topic message.
+
+        Args:
+            slot (Callable): A slot method/function that accepts two inputs: content and metadata of
+                the corresponding pub/sub message
+            topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
+        """
+        slot = QtThreadSafeCallback(slot)
+        self.client.connector.register(topics, cb=slot)
+        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
+        self._slots[slot].update(set(topics_str))
+
+    def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
+        # find the right slot to disconnect from ;
+        # slot callbacks are wrapped in QtThreadSafeCallback objects,
+        # but the slot we receive here is the original callable
+        for connected_slot in self._slots:
+            if connected_slot.cb == slot:
+                break
+        else:
+            return
+        self.client.connector.unregister(topics, cb=connected_slot)
+        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
+        self._slots[slot].difference_update(set(topics_str))
+        if not self._slots[slot]:
+            del self._slots[slot]
+
+    def disconnect_topics(self, topics: Union[str, list]):
+        self.client.connector.unregister(topics)
+        topics_str, _ = self.client.connector._convert_endpointinfo(topics)
+        for slot in list(self._slots.keys()):
+            slot_topics = self._slots[slot]
+            slot_topics.difference_update(set(topics_str))
+            if not slot_topics:
+                del self._slots[slot]
+
+    def disconnect_all(self, *args, **kwargs):
+        self.disconnect_topics(self.client.connector._topics_cb)

bec_widgets/utils/bec_table.py

@@ -0,0 +1,21 @@
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QTableWidget
+
+
+class BECTable(QTableWidget):
+    """Table widget with custom keyPressEvent to delete rows with backspace or delete key"""
+
+    def keyPressEvent(self, event) -> None:
+        """
+        Delete selected rows with backspace or delete key
+
+        Args:
+            event: keyPressEvent
+        """
+        if event.key() in (Qt.Key_Backspace, Qt.Key_Delete):
+            selected_ranges = self.selectedRanges()
+            for selected_range in selected_ranges:
+                for row in range(selected_range.topRow(), selected_range.bottomRow() + 1):
+                    self.removeRow(row)
+        else:
+            super().keyPressEvent(event)

bec_widgets/utils/colors.py

@@ -0,0 +1,65 @@
+from typing import Literal
+
+import numpy as np
+import pyqtgraph as pg
+from qtpy.QtGui import QColor
+
+
+class Colors:
+    @staticmethod
+    def golden_ratio(num: int) -> list:
+        """Calculate the golden ratio for a given number of angles.
+
+        Args:
+            num (int): Number of angles
+
+        Returns:
+            list: List of angles calculated using the golden ratio.
+        """
+        phi = 2 * np.pi * ((1 + np.sqrt(5)) / 2)
+        angles = []
+        for ii in range(num):
+            x = np.cos(ii * phi)
+            y = np.sin(ii * phi)
+            angle = np.arctan2(y, x)
+            angles.append(angle)
+        return angles
+
+    @staticmethod
+    def golden_angle_color(
+        colormap: str, num: int, format: Literal["QColor", "HEX", "RGB"] = "QColor"
+    ) -> list:
+        """
+        Extract num colors from the specified colormap following golden angle distribution and return them in the specified format.
+
+        Args:
+            colormap (str): Name of the colormap.
+            num (int): Number of requested colors.
+            format (Literal["QColor","HEX","RGB"]): The format of the returned colors ('RGB', 'HEX', 'QColor').
+
+        Returns:
+            list: List of colors in the specified format.
+
+        Raises:
+            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
+        """
+        cmap = pg.colormap.get(colormap)
+        cmap_colors = cmap.getColors(mode="float")
+        if num > len(cmap_colors):
+            raise ValueError(
+                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
+            )
+        angles = Colors.golden_ratio(len(cmap_colors))
+        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
+        colors = []
+        for ii in color_selection[:num]:
+            color = cmap_colors[int(ii)]
+            if format.upper() == "HEX":
+                colors.append(QColor.fromRgbF(*color).name())
+            elif format.upper() == "RGB":
+                colors.append(tuple((np.array(color) * 255).astype(int)))
+            elif format.upper() == "QCOLOR":
+                colors.append(QColor.fromRgbF(*color))
+            else:
+                raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
+        return colors

bec_widgets/utils/container_utils.py

@@ -0,0 +1,48 @@
+import itertools
+from typing import Type
+
+from qtpy.QtWidgets import QWidget
+
+
+class WidgetContainerUtils:
+
+    @staticmethod
+    def generate_unique_widget_id(container: dict, prefix: str = "widget") -> str:
+        """
+        Generate a unique widget ID.
+
+        Args:
+            container(dict): The container of widgets.
+            prefix(str): The prefix of the widget ID.
+
+        Returns:
+            widget_id(str): The unique widget ID.
+        """
+        existing_ids = set(container.keys())
+        for i in itertools.count(1):
+            widget_id = f"{prefix}_{i}"
+            if widget_id not in existing_ids:
+                return widget_id
+
+    @staticmethod
+    def find_first_widget_by_class(
+        container: dict, widget_class: Type[QWidget], can_fail: bool = True
+    ) -> QWidget | None:
+        """
+        Find the first widget of a given class in the figure.
+
+        Args:
+            container(dict): The container of widgets.
+            widget_class(Type): The class of the widget to find.
+            can_fail(bool): If True, the method will return None if no widget is found. If False, it will raise an error.
+
+        Returns:
+            widget: The widget of the given class.
+        """
+        for widget_id, widget in container.items():
+            if isinstance(widget, widget_class):
+                return widget
+        if can_fail:
+            return None
+        else:
+            raise ValueError(f"No widget of class {widget_class} found.")

bec_widgets/utils/crosshair.py

@@ -1,19 +1,23 @@
 import numpy as np
 import pyqtgraph as pg
-from PyQt5.QtCore import QObject, pyqtSignal
+
+# from qtpy.QtCore import QObject, pyqtSignal
+from qtpy.QtCore import QObject
+from qtpy.QtCore import Signal as pyqtSignal
 
 
 class Crosshair(QObject):
     # Signal for 1D plot
-    coordinatesChanged1D = pyqtSignal(float, list)
-    coordinatesClicked1D = pyqtSignal(float, list)
+    coordinatesChanged1D = pyqtSignal(tuple)
+    coordinatesClicked1D = pyqtSignal(tuple)
     # Signal for 2D plot
-    coordinatesChanged2D = pyqtSignal(float, float)
-    coordinatesClicked2D = pyqtSignal(float, float)
+    coordinatesChanged2D = pyqtSignal(tuple)
+    coordinatesClicked2D = pyqtSignal(tuple)
 
-    def __init__(self, plot_item: pg.PlotItem, precision: int = None, parent=None):
+    def __init__(self, plot_item: pg.PlotItem, precision: int = 3, parent=None):
         """
         Crosshair for 1D and 2D plots.
+
         Args:
             plot_item (pyqtgraph.PlotItem): The plot item to which the crosshair will be attached.
             precision (int, optional): Number of decimal places to round the coordinates to. Defaults to None.
@@ -63,9 +67,19 @@ class Crosshair(QObject):
                     size=10, pen=pg.mkPen(None), brush=pg.mkBrush(color)
                 )
                 self.marker_moved_1d.append(marker_moved)
-                self.marker_clicked_1d.append(marker_clicked)
                 self.plot_item.addItem(marker_moved)
-                self.plot_item.addItem(marker_clicked)
+                # Create glowing effect markers for clicked events
+                marker_clicked_list = []
+                for size, alpha in [(18, 64), (14, 128), (10, 255)]:
+                    marker_clicked = pg.ScatterPlotItem(
+                        size=size,
+                        pen=pg.mkPen(None),
+                        brush=pg.mkBrush(color.red(), color.green(), color.blue(), alpha),
+                    )
+                    marker_clicked_list.append(marker_clicked)
+                    self.plot_item.addItem(marker_clicked)
+
+                self.marker_clicked_1d.append(marker_clicked_list)
             elif isinstance(item, pg.ImageItem):  # 2D plot
                 self.marker_2d = pg.ROI(
                     [0, 0], size=[1, 1], pen=pg.mkPen("r", width=2), movable=False
@@ -109,7 +123,8 @@ class Crosshair(QObject):
         if y_values_1d:
             if all(v is None for v in x_values_1d) or all(v is None for v in y_values_1d):
                 return None, None
-            return x, y_values_1d
+            closest_x = min(x_values_1d, key=lambda xi: abs(xi - x))  # Snap x to closest data point
+            return closest_x, y_values_1d
 
         # Handle 2D plot
         if image_2d is not None:
@@ -159,10 +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
-                    self.coordinatesChanged1D.emit(
+                    coordinance_to_emit = (
                         round(x, self.precision),
                         [round(y_val, self.precision) for y_val in y_values],
                     )
+                    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)],
@@ -171,7 +187,8 @@ class Crosshair(QObject):
                 elif isinstance(item, pg.ImageItem):
                     if x is None or y_values is None:
                         return
-                    self.coordinatesChanged2D.emit(x, y_values)
+                    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.
@@ -194,19 +211,22 @@ class Crosshair(QObject):
                 if isinstance(item, pg.PlotDataItem):
                     if x is None or all(v is None for v in y_values):
                         return
-                    self.coordinatesClicked1D.emit(
+                    coordinate_to_emit = (
                         round(x, self.precision),
                         [round(y_val, self.precision) for y_val in y_values],
                     )
+                    self.coordinatesClicked1D.emit(coordinate_to_emit)
                     for i, y_val in enumerate(y_values):
-                        self.marker_clicked_1d[i].setData(
-                            [x if not self.is_log_x else np.log10(x)],
-                            [y_val if not self.is_log_y else np.log10(y_val)],
-                        )
+                        for marker in self.marker_clicked_1d[i]:
+                            marker.setData(
+                                [x if not self.is_log_x else np.log10(x)],
+                                [y_val if not self.is_log_y else np.log10(y_val)],
+                            )
                 elif isinstance(item, pg.ImageItem):
                     if x is None or y_values is None:
                         return
-                    self.coordinatesClicked2D.emit(x, y_values)
+                    coordinate_to_emit = (x, y_values)
+                    self.coordinatesClicked2D.emit(coordinate_to_emit)
                     self.marker_2d.setPos([x, y_values])
 
     def check_log(self):

bec_widgets/utils/entry_validator.py

@@ -0,0 +1,42 @@
+class EntryValidator:
+    def __init__(self, devices):
+        self.devices = devices
+
+    def validate_signal(self, name: str, entry: str = None) -> str:
+        """
+        Validate a signal entry for a given device. If the entry is not provided, the first signal entry will be used from the device hints.
+
+        Args:
+            name(str): Device name
+            entry(str): Signal entry
+
+        Returns:
+            str: Signal entry
+        """
+        if name not in self.devices:
+            raise ValueError(f"Device '{name}' not found in current BEC session")
+
+        device = self.devices[name]
+        description = device.describe()
+
+        if entry is None:
+            entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
+        if entry not in description:
+            raise ValueError(f"Entry '{entry}' not found in device '{name}' signals")
+
+        return entry
+
+    def validate_monitor(self, monitor: str) -> str:
+        """
+        Validate a monitor entry for a given device.
+
+        Args:
+            monitor(str): Monitor entry
+
+        Returns:
+            str: Monitor entry
+        """
+        if monitor not in self.devices:
+            raise ValueError(f"Device '{monitor}' not found in current BEC session")
+
+        return monitor

bec_widgets/utils/layout_manager.py

@@ -0,0 +1,121 @@
+from collections import OrderedDict
+from typing import Literal
+
+from qtpy.QtWidgets import QGridLayout, QWidget
+
+
+class GridLayoutManager:
+    """
+    GridLayoutManager class is used to manage widgets in a QGridLayout and extend its functionality.
+
+    The GridLayoutManager class provides methods to add, move, and check the position of widgets in a QGridLayout.
+    It also provides a method to get the positions of all widgets in the layout.
+
+    Args:
+        layout(QGridLayout): The layout to manage.
+    """
+
+    def __init__(self, layout: QGridLayout):
+        self.layout = layout
+
+    def is_position_occupied(self, row: int, col: int) -> bool:
+        """
+        Check if the position in the layout is occupied by a widget.
+
+        Args:
+            row(int): The row to check.
+            col(int): The column to check.
+
+        Returns:
+            bool: True if the position is occupied, False otherwise.
+        """
+        for i in range(self.layout.count()):
+            widget_row, widget_col, _, _ = self.layout.getItemPosition(i)
+            if widget_row == row and widget_col == col:
+                return True
+        return False
+
+    def shift_widgets(
+        self,
+        direction: Literal["down", "up", "left", "right"] = "down",
+        start_row: int = 0,
+        start_col: int = 0,
+    ):
+        """
+        Shift widgets in the layout in the specified direction starting from the specified position.
+
+        Args:
+            direction(str): The direction to shift the widgets. Can be "down", "up", "left", or "right".
+            start_row(int): The row to start shifting from. Default is 0.
+            start_col(int): The column to start shifting from. Default is 0.
+        """
+        for i in reversed(range(self.layout.count())):
+            widget_item = self.layout.itemAt(i)
+            widget = widget_item.widget()
+            row, col, rowspan, colspan = self.layout.getItemPosition(i)
+            if direction == "down" and row >= start_row:
+                self.layout.addWidget(widget, row + 1, col, rowspan, colspan)
+            elif direction == "up" and row > start_row:
+                self.layout.addWidget(widget, row - 1, col, rowspan, colspan)
+            elif direction == "right" and col >= start_col:
+                self.layout.addWidget(widget, row, col + 1, rowspan, colspan)
+            elif direction == "left" and col > start_col:
+                self.layout.addWidget(widget, row, col - 1, rowspan, colspan)
+
+    def move_widget(self, widget: QWidget, new_row: int, new_col: int):
+        """
+        Move a widget to a new position in the layout.
+
+        Args:
+            widget(QWidget): The widget to move.
+            new_row(int): The new row to move the widget to.
+            new_col(int): The new column to move the widget to.
+        """
+        self.layout.removeWidget(widget)
+        self.layout.addWidget(widget, new_row, new_col)
+
+    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 layout at the specified position.
+
+        Args:
+            widget(QWidget): The widget to add.
+            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. Default is 0.
+            rowspan(int): The number of rows the widget will span. Default is 1.
+            colspan(int): The number of columns the widget will span. Default is 1.
+            shift(str): The direction to shift the widgets if the position is occupied. Can be "down", "up", "left", or "right".
+        """
+        if row is None:
+            row = self.layout.rowCount()
+        if self.is_position_occupied(row, col):
+            self.shift_widgets(shift, start_row=row)
+        self.layout.addWidget(widget, row, col, rowspan, colspan)
+
+    def get_widgets_positions(self) -> dict:
+        """
+        Get the positions of all widgets in the layout.
+        Returns:
+            dict: A dictionary with the positions of the widgets in the layout.
+
+        """
+        positions = []
+        for i in range(self.layout.count()):
+            widget_item = self.layout.itemAt(i)
+            widget = widget_item.widget()
+            if widget:
+                position = self.layout.getItemPosition(i)
+                positions.append((position, widget))
+        positions.sort(key=lambda x: (x[0][0], x[0][1], x[0][2], x[0][3]))
+        ordered_positions = OrderedDict()
+        for pos, widget in positions:
+            ordered_positions[pos] = widget
+        return ordered_positions

bec_widgets/utils/plugin_utils.py

@@ -0,0 +1,40 @@
+import inspect
+
+from bec_lib.plugin_helper import _get_available_plugins
+
+from bec_widgets.utils import BECConnector
+
+
+def get_plugin_widgets() -> dict[str, BECConnector]:
+    """
+    Get all available widgets from the plugin directory. Widgets are classes that inherit from BECConnector.
+    The plugins are provided through python plugins and specified in the respective pyproject.toml file using
+    the following key:
+
+        [project.entry-points."bec.widgets.user_widgets"]
+        plugin_widgets = "path.to.plugin.module"
+
+    e.g.
+        [project.entry-points."bec.widgets.user_widgets"]
+        plugin_widgets = "pxiii_bec.bec_widgets.widgets"
+
+        assuming that the widgets module for the package pxiii_bec is located at pxiii_bec/bec_widgets/widgets and
+        contains the widgets to be loaded within the pxiii_bec/bec_widgets/widgets/__init__.py file.
+
+    Returns:
+        dict[str, BECConnector]: A dictionary of widget names and their respective classes.
+    """
+    modules = _get_available_plugins("bec.widgets.user_widgets")
+    loaded_plugins = {}
+    print(modules)
+    for module in modules:
+        mods = inspect.getmembers(module, predicate=_filter_plugins)
+        for name, mod_cls in mods:
+            if name in loaded_plugins:
+                print(f"Duplicated widgets plugin {name}.")
+            loaded_plugins[name] = mod_cls
+    return loaded_plugins
+
+
+def _filter_plugins(obj):
+    return inspect.isclass(obj) and issubclass(obj, BECConnector)

bec_widgets/utils/rpc_decorator.py

@@ -0,0 +1,15 @@
+def rpc_public(func):
+    func.rpc_public = True  # Mark the function for later processing by the class decorator
+    return func
+
+
+def register_rpc_methods(cls):
+    """
+    Class decorator to scan for rpc_public methods and add them to USER_ACCESS.
+    """
+    if not hasattr(cls, "USER_ACCESS"):
+        cls.USER_ACCESS = set()
+    for name, method in cls.__dict__.items():
+        if getattr(method, "rpc_public", False):
+            cls.USER_ACCESS.add(name)
+    return cls

bec_widgets/utils/thread_checker.py

@@ -0,0 +1,37 @@
+import threading
+
+
+class ThreadTracker:
+    def __init__(self, exclude_names=None):
+        self.exclude_names = exclude_names if exclude_names else []
+        self.initial_threads = self._capture_threads()
+
+    def _capture_threads(self):
+        return set(
+            th
+            for th in threading.enumerate()
+            if not any(ex_name in th.name for ex_name in self.exclude_names)
+            and th is not threading.main_thread()
+        )
+
+    def _thread_info(self, threads):
+        return ", \n".join(f"{th.name}(ID: {th.ident})" for th in threads)
+
+    def check_unfinished_threads(self):
+        current_threads = self._capture_threads()
+        additional_threads = current_threads - self.initial_threads
+        closed_threads = self.initial_threads - current_threads
+        if additional_threads:
+            raise Exception(
+                f"###### Initial threads ######:\n {self._thread_info(self.initial_threads)}\n"
+                f"###### Current threads ######:\n {self._thread_info(current_threads)}\n"
+                f"###### Closed threads ######:\n {self._thread_info(closed_threads)}\n"
+                f"###### Unfinished threads ######:\n {self._thread_info(additional_threads)}"
+            )
+        else:
+            print(
+                "All threads properly closed.\n"
+                f"###### Initial threads ######:\n {self._thread_info(self.initial_threads)}\n"
+                f"###### Current threads ######:\n {self._thread_info(current_threads)}\n"
+                f"###### Closed threads ######:\n {self._thread_info(closed_threads)}"
+            )

bec_widgets/utils/ui_loader.py

@@ -0,0 +1,58 @@
+from qtpy import QT_VERSION
+from qtpy.QtCore import QFile, QIODevice
+
+
+class UILoader:
+    """Universal UI loader for PyQt5, PyQt6, PySide2, and PySide6."""
+
+    def __init__(self, parent=None):
+        self.parent = parent
+        if QT_VERSION.startswith("5"):
+            # PyQt5 or PySide2
+            from qtpy import uic
+
+            self.loader = uic.loadUi
+        elif QT_VERSION.startswith("6"):
+            # PyQt6 or PySide6
+            try:
+                from PySide6.QtUiTools import QUiLoader
+
+                self.loader = self.load_ui_pyside6
+            except ImportError:
+                from PyQt6.uic import loadUi
+
+                self.loader = loadUi
+
+    def load_ui_pyside6(self, ui_file, parent=None):
+        """
+        Specific loader for PySide6 using QUiLoader.
+        Args:
+            ui_file(str): Path to the .ui file.
+            parent(QWidget): Parent widget.
+
+        Returns:
+            QWidget: The loaded widget.
+        """
+        from PySide6.QtUiTools import QUiLoader
+
+        loader = QUiLoader(parent)
+        file = QFile(ui_file)
+        if not file.open(QIODevice.ReadOnly):
+            raise IOError(f"Cannot open file: {ui_file}")
+        widget = loader.load(file, parent)
+        file.close()
+        return widget
+
+    def load_ui(self, ui_file, parent=None):
+        """
+        Universal UI loader method.
+        Args:
+            ui_file(str): Path to the .ui file.
+            parent(QWidget): Parent widget.
+
+        Returns:
+            QWidget: The loaded widget.
+        """
+        if parent is None:
+            parent = self.parent
+        return self.loader(ui_file, parent)

bec_widgets/utils/validator_delegate.py

@@ -0,0 +1,13 @@
+# from qtpy.QtGui import QDoubleValidator
+# from qtpy.QtWidgets import QStyledItemDelegate, QLineEdit
+
+from qtpy.QtGui import QDoubleValidator
+from qtpy.QtWidgets import QLineEdit, QStyledItemDelegate
+
+
+class DoubleValidationDelegate(QStyledItemDelegate):
+    def createEditor(self, parent, option, index):
+        editor = QLineEdit(parent)
+        validator = QDoubleValidator()
+        editor.setValidator(validator)
+        return editor

bec_widgets/utils/widget_io.py

@@ -0,0 +1,325 @@
+# pylint: disable=no-name-in-module
+from abc import ABC, abstractmethod
+
+from qtpy.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QComboBox,
+    QDoubleSpinBox,
+    QLabel,
+    QLineEdit,
+    QSpinBox,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class WidgetHandler(ABC):
+    """Abstract base class for all widget handlers."""
+
+    @abstractmethod
+    def get_value(self, widget: QWidget):
+        """Retrieve value from the widget instance."""
+
+    @abstractmethod
+    def set_value(self, widget: QWidget, value):
+        """Set a value on the widget instance."""
+
+
+class LineEditHandler(WidgetHandler):
+    """Handler for QLineEdit widgets."""
+
+    def get_value(self, widget: QLineEdit) -> str:
+        return widget.text()
+
+    def set_value(self, widget: QLineEdit, value: str) -> None:
+        widget.setText(value)
+
+
+class ComboBoxHandler(WidgetHandler):
+    """Handler for QComboBox widgets."""
+
+    def get_value(self, widget: QComboBox) -> int:
+        return widget.currentIndex()
+
+    def set_value(self, widget: QComboBox, value: int) -> None:
+        widget.setCurrentIndex(value)
+
+
+class TableWidgetHandler(WidgetHandler):
+    """Handler for QTableWidget widgets."""
+
+    def get_value(self, widget: QTableWidget) -> list:
+        return [
+            [
+                widget.item(row, col).text() if widget.item(row, col) else ""
+                for col in range(widget.columnCount())
+            ]
+            for row in range(widget.rowCount())
+        ]
+
+    def set_value(self, widget: QTableWidget, value) -> None:
+        for row, row_values in enumerate(value):
+            for col, cell_value in enumerate(row_values):
+                item = QTableWidgetItem(str(cell_value))
+                widget.setItem(row, col, item)
+
+
+class SpinBoxHandler(WidgetHandler):
+    """Handler for QSpinBox and QDoubleSpinBox widgets."""
+
+    def get_value(self, widget):
+        return widget.value()
+
+    def set_value(self, widget, value):
+        widget.setValue(value)
+
+
+class CheckBoxHandler(WidgetHandler):
+    """Handler for QCheckBox widgets."""
+
+    def get_value(self, widget):
+        return widget.isChecked()
+
+    def set_value(self, widget, value):
+        widget.setChecked(value)
+
+
+class LabelHandler(WidgetHandler):
+    """Handler for QLabel widgets."""
+
+    def get_value(self, widget):
+        return widget.text()
+
+    def set_value(self, widget, value):
+        widget.setText(value)
+
+
+class WidgetIO:
+    """Public interface for getting and setting values using handler mapping"""
+
+    _handlers = {
+        QLineEdit: LineEditHandler,
+        QComboBox: ComboBoxHandler,
+        QTableWidget: TableWidgetHandler,
+        QSpinBox: SpinBoxHandler,
+        QDoubleSpinBox: SpinBoxHandler,
+        QCheckBox: CheckBoxHandler,
+        QLabel: LabelHandler,
+    }
+
+    @staticmethod
+    def get_value(widget, ignore_errors=False):
+        """
+        Retrieve value from the widget instance.
+
+        Args:
+            widget: Widget instance.
+            ignore_errors(bool, optional): Whether to ignore if no handler is found.
+        """
+        handler_class = WidgetIO._handlers.get(type(widget))
+        if handler_class:
+            return handler_class().get_value(widget)  # Instantiate the handler
+        if not ignore_errors:
+            raise ValueError(f"No handler for widget type: {type(widget)}")
+        return None
+
+    @staticmethod
+    def set_value(widget, value, ignore_errors=False):
+        """
+        Set a value on the widget instance.
+
+        Args:
+            widget: Widget instance.
+            value: Value to set.
+            ignore_errors(bool, optional): Whether to ignore if no handler is found.
+        """
+        handler_class = WidgetIO._handlers.get(type(widget))
+        if handler_class:
+            handler_class().set_value(widget, value)  # Instantiate the handler
+        elif not ignore_errors:
+            raise ValueError(f"No handler for widget type: {type(widget)}")
+
+
+################## for exporting and importing widget hierarchies ##################
+
+
+class WidgetHierarchy:
+    @staticmethod
+    def print_widget_hierarchy(
+        widget,
+        indent: int = 0,
+        grab_values: bool = False,
+        prefix: str = "",
+        exclude_internal_widgets: bool = True,
+    ) -> None:
+        """
+        Print the widget hierarchy to the console.
+
+        Args:
+            widget: Widget to print the hierarchy of
+            indent(int, optional): Level of indentation.
+            grab_values(bool,optional): Whether to grab the values of the widgets.
+            prefix(stc,optional): Custom string prefix for indentation.
+            exclude_internal_widgets(bool,optional): Whether to exclude internal widgets (e.g. QComboBox in PyQt6).
+        """
+        widget_info = f"{widget.__class__.__name__} ({widget.objectName()})"
+        if grab_values:
+            value = WidgetIO.get_value(widget, ignore_errors=True)
+            value_str = f" [value: {value}]" if value is not None else ""
+            widget_info += value_str
+
+        print(prefix + widget_info)
+
+        children = widget.children()
+        for child in children:
+            if (
+                exclude_internal_widgets
+                and isinstance(widget, QComboBox)
+                and child.__class__.__name__ in ["QFrame", "QBoxLayout", "QListView"]
+            ):
+                continue
+            child_prefix = prefix + "  "
+            arrow = "├─ " if child != children[-1] else "└─ "
+            WidgetHierarchy.print_widget_hierarchy(
+                child, indent + 1, grab_values, prefix=child_prefix + arrow
+            )
+
+    @staticmethod
+    def export_config_to_dict(
+        widget: QWidget,
+        config: dict = None,
+        indent: int = 0,
+        grab_values: bool = False,
+        print_hierarchy: bool = False,
+        save_all: bool = True,
+        exclude_internal_widgets: bool = True,
+    ) -> dict:
+        """
+        Export the widget hierarchy to a dictionary.
+
+        Args:
+            widget: Widget to print the hierarchy of.
+            config(dict,optional): Dictionary to export the hierarchy to.
+            indent(int,optional): Level of indentation.
+            grab_values(bool,optional): Whether to grab the values of the widgets.
+            print_hierarchy(bool,optional): Whether to print the hierarchy to the console.
+            save_all(bool,optional): Whether to save all widgets or only those with values.
+            exclude_internal_widgets(bool,optional): Whether to exclude internal widgets (e.g. QComboBox in PyQt6).
+        Returns:
+            config(dict): Dictionary containing the widget hierarchy.
+        """
+        if config is None:
+            config = {}
+        widget_info = f"{widget.__class__.__name__} ({widget.objectName()})"
+
+        # if grab_values and type(widget) in WidgetIO._handlers:
+        if grab_values:
+            value = WidgetIO.get_value(widget, ignore_errors=True)
+            if value is not None or save_all:
+                if widget_info not in config:
+                    config[widget_info] = {}
+                if value is not None:
+                    config[widget_info]["value"] = value
+
+        if print_hierarchy:
+            WidgetHierarchy.print_widget_hierarchy(widget, indent, grab_values)
+
+        for child in widget.children():
+            # Skip internal widgets of QComboBox in PyQt6
+            if (
+                exclude_internal_widgets
+                and isinstance(widget, QComboBox)
+                and child.__class__.__name__ in ["QFrame", "QBoxLayout", "QListView"]
+            ):
+                continue
+            child_config = WidgetHierarchy.export_config_to_dict(
+                child, None, indent + 1, grab_values, print_hierarchy, save_all
+            )
+            if child_config or save_all:
+                if widget_info not in config:
+                    config[widget_info] = {}
+                config[widget_info].update(child_config)
+
+        return config
+
+    @staticmethod
+    def import_config_from_dict(widget, config: dict, set_values: bool = False) -> None:
+        """
+        Import the widget hierarchy from a dictionary.
+
+        Args:
+            widget: Widget to import the hierarchy to.
+            config:
+            set_values:
+        """
+        widget_name = f"{widget.__class__.__name__} ({widget.objectName()})"
+        widget_config = config.get(widget_name, {})
+        for child in widget.children():
+            child_name = f"{child.__class__.__name__} ({child.objectName()})"
+            child_config = widget_config.get(child_name)
+            if child_config is not None:
+                value = child_config.get("value")
+                if set_values and value is not None:
+                    WidgetIO.set_value(child, value)
+                WidgetHierarchy.import_config_from_dict(child, widget_config, set_values)
+
+
+# Example application to demonstrate the usage of the functions
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication([])
+
+    # Create instance of WidgetHierarchy
+    widget_hierarchy = WidgetHierarchy()
+
+    # Create a simple widget hierarchy for demonstration purposes
+    main_widget = QWidget()
+    layout = QVBoxLayout(main_widget)
+    line_edit = QLineEdit(main_widget)
+    combo_box = QComboBox(main_widget)
+    table_widget = QTableWidget(2, 2, main_widget)
+    spin_box = QSpinBox(main_widget)
+    layout.addWidget(line_edit)
+    layout.addWidget(combo_box)
+    layout.addWidget(table_widget)
+    layout.addWidget(spin_box)
+
+    # Add text items to the combo box
+    combo_box.addItems(["Option 1", "Option 2", "Option 3"])
+
+    main_widget.show()
+
+    # Hierarchy of original widget
+    print(30 * "#")
+    print(f"Widget hierarchy for {main_widget.objectName()}:")
+    print(30 * "#")
+    config_dict = widget_hierarchy.export_config_to_dict(
+        main_widget, grab_values=True, print_hierarchy=True
+    )
+    print(30 * "#")
+    print(f"Config dict: {config_dict}")
+
+    # Hierarchy of new widget and set values
+    new_config_dict = {
+        "QWidget ()": {
+            "QLineEdit ()": {"value": "New Text"},
+            "QComboBox ()": {"value": 1},
+            "QTableWidget ()": {"value": [["a", "b"], ["c", "d"]]},
+            "QSpinBox ()": {"value": 10},
+        }
+    }
+    widget_hierarchy.import_config_from_dict(main_widget, new_config_dict, set_values=True)
+    print(30 * "#")
+    config_dict_new = widget_hierarchy.export_config_to_dict(
+        main_widget, grab_values=True, print_hierarchy=True
+    )
+    config_dict_new_reduced = widget_hierarchy.export_config_to_dict(
+        main_widget, grab_values=True, print_hierarchy=True, save_all=False
+    )
+    print(30 * "#")
+    print(f"Config dict new FULL: {config_dict_new}")
+    print(f"Config dict new REDUCED: {config_dict_new_reduced}")
+
+    app.exec()

bec_widgets/utils/yaml_dialog.py

@@ -0,0 +1,64 @@
+# pylint: disable=no-name-in-module
+
+from typing import Union
+
+import yaml
+from qtpy.QtWidgets import QFileDialog
+
+
+def load_yaml(instance) -> Union[dict, None]:
+    """
+    Load YAML file from disk.
+
+    Args:
+        instance: Instance of the calling widget.
+
+    Returns:
+        dict: Configuration data loaded from the YAML file.
+    """
+    options = QFileDialog.Options()
+    file_path, _ = QFileDialog.getOpenFileName(
+        instance, "Load Settings", "", "YAML Files (*.yaml *.yml);;All Files (*)", options=options
+    )
+
+    if not file_path:
+        return None
+    try:
+        with open(file_path, "r") as file:
+            config = yaml.safe_load(file)
+        return config
+
+    except FileNotFoundError:
+        print(f"The file {file_path} was not found.")
+    except PermissionError:
+        print(f"Permission denied for file {file_path}.")
+    except yaml.YAMLError as e:
+        print(f"Error parsing YAML file {file_path}: {e}")
+    except Exception as e:
+        print(f"An error occurred while loading the settings from {file_path}: {e}")
+
+
+def save_yaml(instance, config: dict) -> None:
+    """
+    Save YAML file to disk.
+
+    Args:
+        instance: Instance of the calling widget.
+        config: Configuration data to be saved.
+    """
+    options = QFileDialog.Options()
+    file_path, _ = QFileDialog.getSaveFileName(
+        instance, "Save Settings", "", "YAML Files (*.yaml *.yml);;All Files (*)", options=options
+    )
+
+    if not file_path:
+        return
+    try:
+        if not (file_path.endswith(".yaml") or file_path.endswith(".yml")):
+            file_path += ".yaml"
+
+        with open(file_path, "w") as file:
+            yaml.dump(config, file)
+            print(f"Settings saved to {file_path}")
+    except Exception as e:
+        print(f"An error occurred while saving the settings to {file_path}: {e}")

bec_widgets/widgets/__init__.py

@@ -0,0 +1,4 @@
+from .dock import BECDock, BECDockArea
+from .figure import BECFigure, FigureConfig
+from .scan_control import ScanControl
+from .spiral_progress_bar import SpiralProgressBar

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/__init__.py

@@ -0,0 +1,2 @@
+from .dock import BECDock
+from .dock_area import BECDockArea

bec_widgets/widgets/dock/dock.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, Optional
+
+from pydantic import Field
+from pyqtgraph.dockarea import Dock
+
+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 import BECDockArea
+
+
+class DockConfig(ConnectionConfig):
+    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."
+    )
+    parent_dock_area: Optional[str] = Field(
+        None, description="The GUI ID of parent dock area of the dock."
+    )
+
+
+class BECDock(BECConnector, Dock):
+    USER_ACCESS = [
+        "rpc_id",
+        "widget_list",
+        "show_title_bar",
+        "hide_title_bar",
+        "get_widgets_positions",
+        "set_title",
+        "add_widget_bec",
+        "list_eligible_widgets",
+        "move_widget",
+        "remove_widget",
+        "remove",
+        "attach",
+        "detach",
+    ]
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        parent_dock_area: BECDockArea | None = None,
+        config: DockConfig | None = None,
+        name: str | None = None,
+        client=None,
+        gui_id: str | None = None,
+        **kwargs,
+    ) -> None:
+        if config is None:
+            config = DockConfig(
+                widget_class=self.__class__.__name__, parent_dock_area=parent_dock_area.gui_id
+            )
+        else:
+            if isinstance(config, dict):
+                config = DockConfig(**config)
+            self.config = config
+        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)
+
+    def dropEvent(self, event):
+        source = event.source()
+        old_area = source.area
+        self.setOrientation("horizontal", force=True)
+        super().dropEvent(event)
+        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):
+        """
+        Float the dock.
+        Overwrites the default pyqtgraph dock float.
+        """
+
+        # need to check if the dock is temporary and if it is the only dock in the area
+        # fixes bug in pyqtgraph detaching
+        if self.area.temporary == True and len(self.area.docks) <= 1:
+            return
+        elif self.area.temporary == True and len(self.area.docks) > 1:
+            self.area.docks.pop(self.name(), None)
+            super().float()
+        else:
+            super().float()
+
+    @property
+    def widget_list(self) -> list:
+        """
+        Get the widgets in the dock.
+
+        Returns:
+            widgets(list): The widgets in the dock.
+        """
+        return self.widgets
+
+    @widget_list.setter
+    def widget_list(self, value: list):
+        self.widgets = value
+
+    def hide_title_bar(self):
+        """
+        Hide the title bar of the dock.
+        """
+        # self.hideTitleBar() #TODO pyqtgraph looks bugged ATM, doing my implementation
+        self.label.hide()
+        self.labelHidden = True
+
+    def show_title_bar(self):
+        """
+        Hide the title bar of the dock.
+        """
+        # self.showTitleBar() #TODO pyqtgraph looks bugged ATM, doing my implementation
+        self.label.show()
+        self.labelHidden = False
+
+    def set_title(self, title: str):
+        """
+        Set the title of the dock.
+
+        Args:
+            title(str): The title of the dock.
+        """
+        self.parent_dock_area.docks[title] = self.parent_dock_area.docks.pop(self.name())
+        self.setTitle(title)
+
+    def get_widgets_positions(self) -> dict:
+        """
+        Get the positions of the widgets in the dock.
+
+        Returns:
+            dict: The positions of the widgets in the dock as dict -> {(row, col, rowspan, colspan):widget}
+        """
+        return self.layout_manager.get_widgets_positions()
+
+    def list_eligible_widgets(
+        self,
+    ) -> list:  # TODO can be moved to some util mixin like container class for rpc widgets
+        """
+        List all widgets that can be added to the dock.
+
+        Returns:
+            list: The list of eligible widgets.
+        """
+        return list(RPCWidgetHandler.widget_classes.keys())
+
+    def add_widget_bec(
+        self,
+        widget_type: str,
+        row=None,
+        col=0,
+        rowspan=1,
+        colspan=1,
+        shift: Literal["down", "up", "left", "right"] = "down",
+    ):
+        """
+        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.
+
+        Args:
+            widget(QWidget): The widget to add.
+            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)
+
+        self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
+
+    def move_widget(self, widget: QWidget, new_row: int, new_col: int):
+        """
+        Move a widget to a new position in the layout.
+
+        Args:
+            widget(QWidget): The widget to move.
+            new_row(int): The new row to move the widget to.
+            new_col(int): The new column to move the widget to.
+        """
+        self.layout_manager.move_widget(widget, new_row, new_col)
+
+    def attach(self):
+        """
+        Attach the dock to the parent dock area.
+        """
+        self.parent_dock_area.removeTempArea(self.area)
+
+    def detach(self):
+        """
+        Detach the dock from the parent dock area.
+        """
+        self.float()
+
+    def remove_widget(self, widget_rpc_id: str):
+        """
+        Remove a widget from the dock.
+
+        Args:
+            widget_rpc_id(str): The ID of the widget to remove.
+        """
+        widget = self.rpc_register.get_rpc_by_id(widget_rpc_id)
+        self.layout.removeWidget(widget)
+        widget.close()
+
+    def remove(self):
+        """
+        Remove the dock from the parent dock area.
+        """
+        # self.cleanup()
+        self.parent_dock_area.remove_dock(self.name())
+
+    def cleanup(self):
+        """
+        Clean up the dock, including all its widgets.
+        """
+        for widget in self.widgets:
+            if hasattr(widget, "cleanup"):
+                widget.cleanup()
+        super().cleanup()
+
+    def close(self):
+        """
+        Close the dock area and cleanup.
+        Has to be implemented to overwrite pyqtgraph event accept in Container close.
+        """
+        self.cleanup()
+        super().close()

bec_widgets/widgets/dock/dock_area.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+from weakref import WeakValueDictionary
+
+from pydantic import Field
+from pyqtgraph.dockarea.DockArea import DockArea
+from qtpy.QtCore import Qt
+from qtpy.QtGui import QPainter, QPaintEvent
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import BECConnector, ConnectionConfig, WidgetContainerUtils
+
+from .dock import BECDock, DockConfig
+
+
+class DockAreaConfig(ConnectionConfig):
+    docks: dict[str, DockConfig] = Field({}, description="The docks in the dock area.")
+
+
+class BECDockArea(BECConnector, DockArea):
+    USER_ACCESS = [
+        "panels",
+        "save_state",
+        "remove_dock",
+        "restore_state",
+        "add_dock",
+        "clear_all",
+        "detach_dock",
+        "attach_all",
+        "get_all_rpc",
+    ]
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        config: DockAreaConfig | None = None,
+        client=None,
+        gui_id: str = None,
+    ) -> None:
+        if config is None:
+            config = DockAreaConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = DockAreaConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        DockArea.__init__(self, parent=parent)
+
+        self._instructions_visible = True
+
+    def paintEvent(self, event: QPaintEvent):
+        super().paintEvent(event)
+        if self._instructions_visible:
+            painter = QPainter(self)
+            painter.drawText(self.rect(), Qt.AlignCenter, "Add docks using 'add_dock' method")
+
+    @property
+    def panels(self) -> dict:
+        """
+        Get the docks in the dock area.
+        Returns:
+            dock_dict(dict): The docks in the dock area.
+        """
+        return dict(self.docks)
+
+    @panels.setter
+    def panels(self, value: dict):
+
+        self.docks = WeakValueDictionary(value)
+
+    def restore_state(
+        self, state: dict = None, missing: Literal["ignore", "error"] = "ignore", extra="bottom"
+    ):
+        """
+        Restore the state of the dock area. If no state is provided, the last state is restored.
+
+        Args:
+            state(dict): The state to restore.
+            missing(Literal['ignore','error']): What to do if a dock is missing.
+            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._last_state
+        self.restoreState(state, missing=missing, extra=extra)
+
+    def save_state(self) -> dict:
+        """
+        Save the state of the dock area.
+
+        Returns:
+            dict: The state of the dock area.
+        """
+        self._last_state = self.saveState()
+        return self._last_state
+
+    def remove_dock(self, name: str):
+        """
+        Remove a dock by name and ensure it is properly closed and cleaned up.
+
+        Args:
+            name(str): The name of the dock to remove.
+        """
+        dock = self.docks.pop(name, None)
+        if dock:
+            dock.close()
+            if len(self.docks) <= 1:
+                for dock in self.docks.values():
+                    dock.hide_title_bar()
+
+        else:
+            raise ValueError(f"Dock with name {name} does not exist.")
+
+    def add_dock(
+        self,
+        name: str = None,
+        position: Literal["bottom", "top", "left", "right", "above", "below"] = None,
+        relative_to: BECDock | None = None,
+        closable: bool = False,
+        prefix: str = "dock",
+        widget: str | QWidget | None = None,
+        row: int = None,
+        col: int = 0,
+        rowspan: int = 1,
+        colspan: int = 1,
+    ) -> BECDock:
+        """
+        Add a dock to the dock area. Dock has QGridLayout as layout manager by default.
+
+        Args:
+            name(str): The name of the dock to be displayed and for further references. Has to be unique.
+            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.
+            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.
+            col(int): The column of the added widget.
+            rowspan(int): The rowspan of the added widget.
+            colspan(int): The colspan of the added widget.
+
+        Returns:
+            BECDock: The created dock.
+        """
+        if name is None:
+            name = WidgetContainerUtils.generate_unique_widget_id(
+                container=self.docks, prefix=prefix
+            )
+
+        if name in set(self.docks.keys()):
+            raise ValueError(f"Dock with name {name} already exists.")
+
+        if position is None:
+            position = "bottom"
+
+        dock = BECDock(name=name, parent_dock_area=self, closable=closable)
+        dock.config.position = position
+        self.config.docks[name] = dock.config
+
+        self.addDock(dock=dock, position=position, relativeTo=relative_to)
+
+        if len(self.docks) <= 1:
+            dock.hide_title_bar()
+        elif len(self.docks) > 1:
+            for dock in self.docks.values():
+                dock.show_title_bar()
+
+        if widget is not None and isinstance(widget, str):
+            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()
+        return dock
+
+    def detach_dock(self, dock_name: str) -> BECDock:
+        """
+        Undock a dock from the dock area.
+
+        Args:
+            dock_name(str): The dock to undock.
+
+        Returns:
+            BECDock: The undocked dock.
+        """
+        dock = self.docks[dock_name]
+        self.floatDock(dock)
+        return dock
+
+    def attach_all(self):
+        """
+        Return all floating docks to the dock area.
+        """
+        while self.tempAreas:
+            for temp_area in self.tempAreas:
+                self.removeTempArea(temp_area)
+
+    def clear_all(self):
+        """
+        Close all docks and remove all temp areas.
+        """
+        self.attach_all()
+        for dock in dict(self.docks).values():
+            dock.remove()
+
+    def cleanup(self):
+        """
+        Cleanup the dock area.
+        """
+        self.clear_all()
+        super().cleanup()
+
+    def close(self):
+        """
+        Close the dock area and cleanup.
+        Has to be implemented to overwrite pyqtgraph event accept in Container close.
+        """
+        self.cleanup()
+        super().close()

bec_widgets/widgets/figure/__init__.py

@@ -0,0 +1 @@
+from .figure import BECFigure, FigureConfig

bec_widgets/widgets/figure/figure.py

@@ -0,0 +1,812 @@
+# pylint: disable = no-name-in-module,missing-module-docstring
+from __future__ import annotations
+
+import uuid
+from collections import defaultdict
+from typing import Literal, Optional
+
+import numpy as np
+import pyqtgraph as pg
+import qdarktheme
+from pydantic import Field
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtWidgets import QWidget
+from typeguard import typechecked
+
+from bec_widgets.utils import BECConnector, ConnectionConfig, WidgetContainerUtils
+from bec_widgets.widgets.figure.plots.image.image import BECImageShow, ImageConfig
+from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap, MotorMapConfig
+from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
+from bec_widgets.widgets.figure.plots.waveform.waveform import BECWaveform, Waveform1DConfig
+
+
+class FigureConfig(ConnectionConfig):
+    """Configuration for BECFigure. Inheriting from ConnectionConfig widget_class and gui_id"""
+
+    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, SubplotConfig] = Field(
+        {}, description="The list of widgets to be added to the figure widget."
+    )
+
+
+class WidgetHandler:
+    """Factory for creating and configuring BEC widgets for BECFigure."""
+
+    def __init__(self):
+        self.widget_factory = {
+            "PlotBase": (BECPlotBase, SubplotConfig),
+            "Waveform1D": (BECWaveform, Waveform1DConfig),
+            "ImShow": (BECImageShow, ImageConfig),
+            "MotorMap": (BECMotorMap, MotorMapConfig),
+        }
+
+    def create_widget(
+        self,
+        widget_type: str,
+        widget_id: str,
+        parent_figure,
+        parent_id: str,
+        config: dict = None,
+        **axis_kwargs,
+    ) -> BECPlotBase:
+        """
+        Create and configure a widget based on its type.
+
+        Args:
+            widget_type (str): The type of the widget to create.
+            widget_id (str): Unique identifier for the widget.
+            parent_id (str): Identifier of the parent figure.
+            config (dict, optional): Additional configuration for the widget.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECPlotBase: The created and configured widget instance.
+        """
+        entry = self.widget_factory.get(widget_type)
+        if not entry:
+            raise ValueError(f"Unsupported widget type: {widget_type}")
+
+        widget_class, config_class = entry
+        if config is not None and isinstance(config, config_class):
+            config = config.model_dump()
+        widget_config_dict = {
+            "widget_class": widget_class.__name__,
+            "parent_id": parent_id,
+            "gui_id": widget_id,
+            **(config if config is not None else {}),
+        }
+        widget_config = config_class(**widget_config_dict)
+        widget = widget_class(
+            config=widget_config, parent_figure=parent_figure, client=parent_figure.client
+        )
+
+        if axis_kwargs:
+            widget.set(**axis_kwargs)
+
+        return widget
+
+
+class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
+    USER_ACCESS = [
+        "rpc_id",
+        "config_dict",
+        "axes",
+        "widgets",
+        "add_plot",
+        "add_image",
+        "add_motor_map",
+        "plot",
+        "image",
+        "motor_map",
+        "remove",
+        "change_layout",
+        "change_theme",
+        "clear_all",
+        "get_all_rpc",
+        "widget_list",
+    ]
+
+    clean_signal = pyqtSignal()
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        config: Optional[FigureConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ) -> None:
+        if config is None:
+            config = FigureConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = FigureConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        pg.GraphicsLayoutWidget.__init__(self, parent)
+
+        self.widget_handler = WidgetHandler()
+
+        # Widget container to reference widgets by 'widget_id'
+        self._widgets = defaultdict(dict)
+
+        # Container to keep track of the grid
+        self.grid = []
+
+    def __getitem__(self, key: tuple | str):
+        if isinstance(key, tuple) and len(key) == 2:
+            return self.axes(*key)
+        elif isinstance(key, str):
+            widget = self._widgets.get(key)
+            if widget is None:
+                raise KeyError(f"No widget with ID {key}")
+            return self._widgets.get(key)
+        else:
+            raise TypeError(
+                "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
+            )
+
+    @property
+    def widget_list(self) -> list[BECPlotBase]:
+        """
+        Access all widget in BECFigure as a list
+        Returns:
+            list[BECPlotBase]: List of all widgets in the figure.
+        """
+        axes = [value for value in self._widgets.values() if isinstance(value, BECPlotBase)]
+        return axes
+
+    @widget_list.setter
+    def widget_list(self, value: list[BECPlotBase]):
+        """
+        Access all widget in BECFigure as a list
+        Returns:
+            list[BECPlotBase]: List of all widgets in the figure.
+        """
+        self._axes = value
+
+    @property
+    def widgets(self) -> dict:
+        """
+        All widgets within the figure with gui ids as keys.
+        Returns:
+            dict: All widgets within the figure.
+        """
+        return self._widgets
+
+    @widgets.setter
+    def widgets(self, value: dict):
+        """
+        All widgets within the figure with gui ids as keys.
+        Returns:
+            dict: All widgets within the figure.
+        """
+        self._widgets = value
+
+    def add_plot(
+        self,
+        x_name: str = None,
+        y_name: str = None,
+        z_name: str = None,
+        x_entry: str = None,
+        y_entry: str = None,
+        z_entry: str = None,
+        x: list | np.ndarray = None,
+        y: list | np.ndarray = 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:
+            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.
+        """
+        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(
+                x_name=x_name,
+                y_name=y_name,
+                x_entry=x_entry,
+                y_entry=y_entry,
+                validate=validate,
+                color=color,
+                label=label,
+            )
+        # User wants to add scan curve -> 2D Waveform Scatter
+        if (
+            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,
+            )
+        # 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:
+            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
+
+        return waveform
+
+    @typechecked
+    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,
+        **axis_kwargs,
+    ) -> BECWaveform:
+        """
+        Add a 1D waveform plot to the figure. Always access the first waveform widget in the figure.
+
+        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.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECWaveform: The waveform plot widget.
+        """
+        waveform = WidgetContainerUtils.find_first_widget_by_class(
+            self._widgets, BECWaveform, can_fail=True
+        )
+        if waveform is not None:
+            if axis_kwargs:
+                waveform.set(**axis_kwargs)
+        else:
+            waveform = self.add_plot(**axis_kwargs)
+
+        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
+
+        # 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,
+            )
+        # 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,
+            )
+        # 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 device names (x_name, y_name) or custom data."
+            )
+        return waveform
+
+    def image(
+        self,
+        monitor: str = None,
+        color_bar: Literal["simple", "full"] = "full",
+        color_map: str = "magma",
+        data: np.ndarray = None,
+        vrange: tuple[float, float] = None,
+        **axis_kwargs,
+    ) -> BECImageShow:
+        """
+        Add an image to the figure. Always access the first image widget in the figure.
+
+        Args:
+            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.
+            vrange(tuple[float, float]): The range of values to display.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECImageShow: The image widget.
+        """
+        image = WidgetContainerUtils.find_first_widget_by_class(
+            self._widgets, BECImageShow, can_fail=True
+        )
+        if image is not None:
+            if axis_kwargs:
+                image.set(**axis_kwargs)
+        else:
+            image = self.add_image(color_bar=color_bar, **axis_kwargs)
+
+        # 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(
+        self,
+        monitor: str = None,
+        color_bar: Literal["simple", "full"] = "full",
+        color_map: str = "magma",
+        data: np.ndarray = None,
+        vrange: tuple[float, float] = None,
+        row: int = None,
+        col: int = None,
+        config=None,
+        **axis_kwargs,
+    ) -> BECImageShow:
+        """
+        Add an image to the figure at the specified position.
+
+        Args:
+            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.
+            vrange(tuple[float, float]): The range of values to display.
+            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: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECImageShow: The image widget.
+        """
+
+        widget_id = str(uuid.uuid4())
+        if config is None:
+            config = ImageConfig(
+                widget_class="BECImageShow",
+                gui_id=widget_id,
+                parent_id=self.gui_id,
+                color_map=color_map,
+                color_bar=color_bar,
+                vrange=vrange,
+            )
+        image = self.add_widget(
+            widget_type="ImShow",
+            widget_id=widget_id,
+            row=row,
+            col=col,
+            config=config,
+            **axis_kwargs,
+        )
+        # 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:
+        """
+        Add a motor map to the figure. Always access the first motor map widget in the figure.
+
+        Args:
+            motor_x(str): The name of the motor for the X axis.
+            motor_y(str): The name of the motor for the Y axis.
+            **axis_kwargs: Additional axis properties to set on the widget after creation.
+
+        Returns:
+            BECMotorMap: The motor map widget.
+        """
+        motor_map = WidgetContainerUtils.find_first_widget_by_class(
+            self._widgets, BECMotorMap, can_fail=True
+        )
+        if motor_map is not None:
+            if axis_kwargs:
+                motor_map.set(**axis_kwargs)
+        else:
+            motor_map = self.add_motor_map(**axis_kwargs)
+
+        if motor_x is not None and motor_y is not None:
+            motor_map.change_motors(motor_x, motor_y)
+
+        return motor_map
+
+    def add_motor_map(
+        self,
+        motor_x: str = None,
+        motor_y: str = None,
+        row: int = None,
+        col: int = None,
+        config=None,
+        **axis_kwargs,
+    ) -> BECMotorMap:
+        """
+
+        Args:
+            motor_x(str): The name of the motor for the X axis.
+            motor_y(str): The name of the motor for the Y axis.
+            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:
+
+        Returns:
+            BECMotorMap: The motor map widget.
+        """
+        widget_id = str(uuid.uuid4())
+        if config is None:
+            config = MotorMapConfig(
+                widget_class="BECMotorMap", gui_id=widget_id, parent_id=self.gui_id
+            )
+        motor_map = self.add_widget(
+            widget_type="MotorMap",
+            widget_id=widget_id,
+            row=row,
+            col=col,
+            config=config,
+            **axis_kwargs,
+        )
+
+        if motor_x is not None and motor_y is not None:
+            motor_map.change_motors(motor_x, motor_y)
+
+        return motor_map
+
+    def add_widget(
+        self,
+        widget_type: Literal["PlotBase", "Waveform1D", "ImShow"] = "PlotBase",
+        widget_id: str = None,
+        row: int = None,
+        col: int = None,
+        config=None,
+        **axis_kwargs,
+    ) -> BECPlotBase:
+        """
+        Add a widget to the figure at the specified position.
+
+        Args:
+            widget_type(Literal["PlotBase","Waveform1D"]): The type of the widget to add.
+            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 not widget_id:
+            widget_id = str(uuid.uuid4())
+        if widget_id in self._widgets:
+            raise ValueError(f"Widget with ID '{widget_id}' already exists.")
+
+        widget = self.widget_handler.create_widget(
+            widget_type=widget_type,
+            widget_id=widget_id,
+            parent_figure=self,
+            parent_id=self.gui_id,
+            config=config,
+            **axis_kwargs,
+        )
+
+        # Check if position is occupied
+        if row is not None and col is not None:
+            if self.getItem(row, col):
+                raise ValueError(f"Position at row {row} and column {col} is already occupied.")
+            else:
+                widget.config.row = row
+                widget.config.col = col
+
+                # Add widget to the figure
+                self.addItem(widget, row=row, col=col)
+        else:
+            row, col = self._find_next_empty_position()
+            widget.config.row = row
+            widget.config.col = col
+
+            # Add widget to the figure
+            self.addItem(widget, row=row, col=col)
+
+        # Update num_cols and num_rows based on the added widget
+        self.config.num_rows = max(self.config.num_rows, row + 1)
+        self.config.num_cols = max(self.config.num_cols, col + 1)
+
+        # Saving config for future referencing
+        self.config.widgets[widget_id] = widget.config
+        self._widgets[widget_id] = widget
+
+        # Reflect the grid coordinates
+        self._change_grid(widget_id, row, col)
+
+        return widget
+
+    def remove(
+        self,
+        row: int = None,
+        col: int = None,
+        widget_id: str = None,
+        coordinates: tuple[int, int] = None,
+    ) -> None:
+        """
+        Remove a widget from the figure. Can be removed by its unique identifier or by its coordinates.
+
+        Args:
+            row(int): The row coordinate of the widget to remove.
+            col(int): The column coordinate of the widget to remove.
+            widget_id(str): The unique identifier of the widget to remove.
+            coordinates(tuple[int, int], optional): The coordinates of the widget to remove.
+        """
+        if widget_id:
+            self._remove_by_id(widget_id)
+        elif row is not None and col is not None:
+            self._remove_by_coordinates(row, col)
+        elif coordinates:
+            self._remove_by_coordinates(*coordinates)
+        else:
+            raise ValueError("Must provide either widget_id or coordinates for removal.")
+
+    def change_theme(self, theme: Literal["dark", "light"]) -> None:
+        """
+        Change the theme of the figure widget.
+
+        Args:
+            theme(Literal["dark","light"]): The theme to set for the figure widget.
+        """
+        qdarktheme.setup_theme(theme)
+        self.setBackground("k" if theme == "dark" else "w")
+        self.config.theme = theme
+
+    def _remove_by_coordinates(self, row: int, col: int) -> None:
+        """
+        Remove a widget from the figure by its coordinates.
+
+        Args:
+            row(int): The row coordinate of the widget to remove.
+            col(int): The column coordinate of the widget to remove.
+        """
+        widget = self.axes(row, col)
+        if widget:
+            widget_id = widget.config.gui_id
+            if widget_id in self._widgets:
+                self._remove_by_id(widget_id)
+
+    def _remove_by_id(self, widget_id: str) -> None:
+        """
+        Remove a widget from the figure by its unique identifier.
+
+        Args:
+            widget_id(str): The unique identifier of the widget to remove.
+        """
+        if widget_id in self._widgets:
+            widget = self._widgets.pop(widget_id)
+            widget.cleanup()
+            self.removeItem(widget)
+            self.grid[widget.config.row][widget.config.col] = None
+            self._reindex_grid()
+            if widget_id in self.config.widgets:
+                self.config.widgets.pop(widget_id)
+        else:
+            raise ValueError(f"Widget with ID '{widget_id}' does not exist.")
+
+    def axes(self, row: int, col: int) -> BECPlotBase:
+        """
+        Get widget by its coordinates in the figure.
+
+        Args:
+            row(int): the row coordinate
+            col(int): the column coordinate
+
+        Returns:
+            BECPlotBase: the widget at the given coordinates
+        """
+        widget = self.getItem(row, col)
+        if widget is None:
+            raise ValueError(f"No widget at coordinates ({row}, {col})")
+        return widget
+
+    def _find_next_empty_position(self):
+        """Find the next empty position (new row) in the figure."""
+        row, col = 0, 0
+        while self.getItem(row, col):
+            row += 1
+        return row, col
+
+    def _change_grid(self, widget_id: str, row: int, col: int):
+        """
+        Change the grid to reflect the new position of the widget.
+
+        Args:
+            widget_id(str): The unique identifier of the widget.
+            row(int): The new row coordinate of the widget in the figure.
+            col(int): The new column coordinate of the widget in the figure.
+        """
+        while len(self.grid) <= row:
+            self.grid.append([])
+        row = self.grid[row]
+        while len(row) <= col:
+            row.append(None)
+        row[col] = widget_id
+
+    def _reindex_grid(self):
+        """Reindex the grid to remove empty rows and columns."""
+        new_grid = []
+        for row in self.grid:
+            new_row = [widget for widget in row if widget is not None]
+            if new_row:
+                new_grid.append(new_row)
+        #
+        # Update the config of each object to reflect its new position
+        for row_idx, row in enumerate(new_grid):
+            for col_idx, widget in enumerate(row):
+                self._widgets[widget].config.row, self._widgets[widget].config.col = (
+                    row_idx,
+                    col_idx,
+                )
+
+        self.grid = new_grid
+        self._replot_layout()
+
+    def _replot_layout(self):
+        """Replot the layout based on the current grid configuration."""
+        self.clear()
+        for row_idx, row in enumerate(self.grid):
+            for col_idx, widget in enumerate(row):
+                self.addItem(self._widgets[widget], row=row_idx, col=col_idx)
+
+    def change_layout(self, max_columns=None, max_rows=None):
+        """
+        Reshuffle the layout of the figure to adjust to a new number of max_columns or max_rows.
+        If both max_columns and max_rows are provided, max_rows is ignored.
+
+        Args:
+            max_columns (Optional[int]): The new maximum number of columns in the figure.
+            max_rows (Optional[int]): The new maximum number of rows in the figure.
+        """
+        # Calculate total number of widgets
+        total_widgets = len(self._widgets)
+
+        if max_columns:
+            # Calculate the required number of rows based on max_columns
+            required_rows = (total_widgets + max_columns - 1) // max_columns
+            new_grid = [[None for _ in range(max_columns)] for _ in range(required_rows)]
+        elif max_rows:
+            # Calculate the required number of columns based on max_rows
+            required_columns = (total_widgets + max_rows - 1) // max_rows
+            new_grid = [[None for _ in range(required_columns)] for _ in range(max_rows)]
+        else:
+            # If neither max_columns nor max_rows is specified, just return without changing the layout
+            return
+
+        # Populate the new grid with widgets' IDs
+        current_idx = 0
+        for widget_id, widget in self._widgets.items():
+            row = current_idx // len(new_grid[0])
+            col = current_idx % len(new_grid[0])
+            new_grid[row][col] = widget_id
+            current_idx += 1
+
+        self.config.num_rows = row
+        self.config.num_cols = col
+
+        # Update widgets' positions and replot them according to the new grid
+        self.grid = new_grid
+        self._reindex_grid()  # This method should be updated to handle reshuffling correctly
+        self._replot_layout()  # Assumes this method re-adds widgets to the layout based on self.grid
+
+    def clear_all(self):
+        """Clear all widgets from the figure and reset to default state"""
+        for widget in list(self._widgets.values()):
+            widget.remove()
+        # self.clear()
+        self._widgets = defaultdict(dict)
+        self.grid = []
+        theme = self.config.theme
+        self.config = FigureConfig(
+            widget_class=self.__class__.__name__, gui_id=self.gui_id, theme=theme
+        )
+
+    def cleanup(self):
+        self.clear_all()
+        super().cleanup()

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

@@ -0,0 +1,560 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Literal, Optional
+
+import numpy as np
+from bec_lib.endpoints import MessageEndpoints
+from pydantic import Field, ValidationError
+from qtpy.QtCore import QThread
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import EntryValidator
+from bec_widgets.widgets.figure.plots.image.image_item import BECImageItem, ImageItemConfig
+from bec_widgets.widgets.figure.plots.image.image_processor import ImageProcessor, ProcessorWorker
+from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
+
+
+class ImageConfig(SubplotConfig):
+    images: dict[str, ImageItemConfig] = Field(
+        {},
+        description="The configuration of the images. The key is the name of the image (source).",
+    )
+
+
+class BECImageShow(BECPlotBase):
+    USER_ACCESS = [
+        "rpc_id",
+        "config_dict",
+        "add_image_by_config",
+        "get_image_config",
+        "get_image_dict",
+        "add_monitor_image",
+        "add_custom_image",
+        "set_vrange",
+        "set_color_map",
+        "set_autorange",
+        "set_monitor",
+        "set_processing",
+        "set_image_properties",
+        "set_fft",
+        "set_log",
+        "set_rotation",
+        "set_transpose",
+        "toggle_threading",
+        "set",
+        "set_title",
+        "set_x_label",
+        "set_y_label",
+        "set_x_scale",
+        "set_y_scale",
+        "set_x_lim",
+        "set_y_lim",
+        "set_grid",
+        "lock_aspect_ratio",
+        "plot",
+        "remove",
+        "images",
+    ]
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        parent_figure=None,
+        config: Optional[ImageConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = ImageConfig(widget_class=self.__class__.__name__)
+        super().__init__(
+            parent=parent, parent_figure=parent_figure, config=config, client=client, gui_id=gui_id
+        )
+        # Get bec shortcuts dev, scans, queue, scan_storage, dap
+        self.get_bec_shortcuts()
+        self.entry_validator = EntryValidator(self.dev)
+        self._images = defaultdict(dict)
+        self.apply_config(self.config)
+        self.processor = ImageProcessor()
+        self.use_threading = False  # TODO WILL be moved to the init method and to figure method
+
+    def _create_thread_worker(self, device: str, image: np.ndarray):
+        thread = QThread()
+        worker = ProcessorWorker(self.processor)
+        worker.moveToThread(thread)
+
+        # Connect signals and slots
+        thread.started.connect(lambda: worker.process_image(device, image))
+        worker.processed.connect(self.update_image)
+        worker.finished.connect(thread.quit)
+        worker.finished.connect(thread.wait)
+        worker.finished.connect(worker.deleteLater)
+        thread.finished.connect(thread.deleteLater)
+
+        thread.start()
+
+    def find_image_by_monitor(self, item_id: str) -> BECImageItem:
+        """
+        Find the widget by its gui_id.
+
+        Args:
+            item_id(str): The gui_id of the widget.
+
+        Returns:
+            BECImageItem: The widget with the given gui_id.
+        """
+        for source, images in self._images.items():
+            for key, value in images.items():
+                if key == item_id and isinstance(value, BECImageItem):
+                    return value
+                elif isinstance(value, dict):
+                    result = self.find_image_by_monitor(item_id)
+                    if result is not None:
+                        return result
+
+    def apply_config(self, config: dict | SubplotConfig):
+        """
+        Apply the configuration to the 1D waveform widget.
+
+        Args:
+            config(dict|SubplotConfig): Configuration settings.
+            replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
+        """
+        if isinstance(config, dict):
+            try:
+                config = ImageConfig(**config)
+            except ValidationError as e:
+                print(f"Validation error when applying config to BECImageShow: {e}")
+                return
+        self.config = config
+        self.plot_item.clear()
+
+        self.apply_axis_config()
+        self._images = defaultdict(dict)
+
+        # TODO extend by adding image by config
+
+    def change_gui_id(self, new_gui_id: str):
+        """
+        Change the GUI ID of the image widget and update the parent_id in all associated curves.
+
+        Args:
+            new_gui_id (str): The new GUI ID to be set for the image widget.
+        """
+        self.gui_id = new_gui_id
+        self.config.gui_id = new_gui_id
+
+        for source, images in self._images.items():
+            for id, image_item in images.items():
+                image_item.config.parent_id = new_gui_id
+
+    def add_image_by_config(self, config: ImageItemConfig | dict) -> BECImageItem:
+        """
+        Add an image to the widget by configuration.
+
+        Args:
+            config(ImageItemConfig|dict): The configuration of the image.
+
+        Returns:
+            BECImageItem: The image object.
+        """
+        if isinstance(config, dict):
+            config = ImageItemConfig(**config)
+            config.parent_id = self.gui_id
+        name = config.monitor if config.monitor is not None else config.gui_id
+        image = self._add_image_object(source=config.source, name=name, config=config)
+        return image
+
+    def get_image_config(self, image_id, dict_output: bool = True) -> ImageItemConfig | dict:
+        """
+        Get the configuration of the image.
+
+        Args:
+            image_id(str): The ID of the image.
+            dict_output(bool): Whether to return the configuration as a dictionary. Defaults to True.
+
+        Returns:
+            ImageItemConfig|dict: The configuration of the image.
+        """
+        for source, images in self._images.items():
+            for id, image in images.items():
+                if id == image_id:
+                    if dict_output:
+                        return image.config.dict()
+                    else:
+                        return image.config  # TODO check if this works
+
+    @property
+    def images(self) -> list[BECImageItem]:
+        """
+        Get the list of images.
+        Returns:
+            list[BECImageItem]: The list of images.
+        """
+        images = []
+        for source, images_dict in self._images.items():
+            for id, image in images_dict.items():
+                images.append(image)
+        return images
+
+    @images.setter
+    def images(self, value: dict[str, dict[str, BECImageItem]]):
+        """
+        Set the images from a dictionary.
+
+        Args:
+            value (dict[str, dict[str, BECImageItem]]): The images to set, organized by source and id.
+        """
+        self._images = value
+
+    def get_image_dict(self) -> dict[str, dict[str, BECImageItem]]:
+        """
+        Get all images.
+
+        Returns:
+            dict[str, dict[str, BECImageItem]]: The dictionary of images.
+        """
+        return self._images
+
+    def add_monitor_image(
+        self,
+        monitor: str,
+        color_map: Optional[str] = "magma",
+        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        downsample: Optional[bool] = True,
+        opacity: Optional[float] = 1.0,
+        vrange: Optional[tuple[int, int]] = None,
+        # post_processing: Optional[PostProcessingConfig] = None,
+        **kwargs,
+    ) -> BECImageItem:
+        image_source = "device_monitor"
+
+        image_exits = self._check_image_id(monitor, self._images)
+        if image_exits:
+            raise ValueError(
+                f"Monitor with ID '{monitor}' already exists in widget '{self.gui_id}'."
+            )
+
+        monitor = self.entry_validator.validate_monitor(monitor)
+
+        image_config = ImageItemConfig(
+            widget_class="BECImageItem",
+            parent_id=self.gui_id,
+            color_map=color_map,
+            color_bar=color_bar,
+            downsample=downsample,
+            opacity=opacity,
+            vrange=vrange,
+            # post_processing=post_processing,
+            **kwargs,
+        )
+
+        image = self._add_image_object(source=image_source, name=monitor, config=image_config)
+        self._connect_device_monitor(monitor)
+        return image
+
+    def add_custom_image(
+        self,
+        name: str,
+        data: Optional[np.ndarray] = None,
+        color_map: Optional[str] = "magma",
+        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        downsample: Optional[bool] = True,
+        opacity: Optional[float] = 1.0,
+        vrange: Optional[tuple[int, int]] = None,
+        # post_processing: Optional[PostProcessingConfig] = None,
+        **kwargs,
+    ):
+        image_source = "device_monitor"
+
+        image_exits = self._check_curve_id(name, self._images)
+        if image_exits:
+            raise ValueError(f"Monitor with ID '{name}' already exists in widget '{self.gui_id}'.")
+
+        image_config = ImageItemConfig(
+            widget_class="BECImageItem",
+            parent_id=self.gui_id,
+            monitor=name,
+            color_map=color_map,
+            color_bar=color_bar,
+            downsample=downsample,
+            opacity=opacity,
+            vrange=vrange,
+            # post_processing=post_processing,
+            **kwargs,
+        )
+
+        image = self._add_image_object(source=image_source, config=image_config, data=data)
+        return image
+
+    def apply_setting_to_images(
+        self, setting_method_name: str, args: list, kwargs: dict, image_id: str = None
+    ):
+        """
+        Apply a setting to all images or a specific image by its ID.
+
+        Args:
+            setting_method_name (str): The name of the method to apply (e.g., 'set_color_map').
+            args (list): Positional arguments for the setting method.
+            kwargs (dict): Keyword arguments for the setting method.
+            image_id (str, optional): The ID of the specific image to apply the setting to. If None, applies to all images.
+        """
+        if image_id:
+            image = self.find_image_by_monitor(image_id)
+            if image:
+                getattr(image, setting_method_name)(*args, **kwargs)
+        else:
+            for source, images in self._images.items():
+                for _, image in images.items():
+                    getattr(image, setting_method_name)(*args, **kwargs)
+
+    def set_vrange(self, vmin: float, vmax: float, name: str = None):
+        """
+        Set the range of the color bar.
+        If name is not specified, then set vrange for all images.
+
+        Args:
+            vmin(float): Minimum value of the color bar.
+            vmax(float): Maximum value of the color bar.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_vrange", args=[vmin, vmax], kwargs={}, image_id=name)
+
+    def set_color_map(self, cmap: str, name: str = None):
+        """
+        Set the color map of the image.
+        If name is not specified, then set color map for all images.
+
+        Args:
+            cmap(str): The color map of the image.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_color_map", args=[cmap], kwargs={}, image_id=name)
+
+    def set_autorange(self, enable: bool = False, name: str = None):
+        """
+        Set the autoscale of the image.
+
+        Args:
+            enable(bool): Whether to autoscale the color bar.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_autorange", args=[enable], kwargs={}, image_id=name)
+
+    def set_monitor(self, monitor: str, name: str = None):
+        """
+        Set the monitor of the image.
+        If name is not specified, then set monitor for all images.
+
+        Args:
+            monitor(str): The name of the monitor.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_monitor", args=[monitor], kwargs={}, image_id=name)
+
+    def set_processing(self, name: str = None, **kwargs):
+        """
+        Set the post processing of the image.
+        If name is not specified, then set post processing for all images.
+
+        Args:
+            name(str): The name of the image. If None, apply to all images.
+            **kwargs: Keyword arguments for the properties to be set.
+        Possible properties:
+            - fft: bool
+            - log: bool
+            - rot: int
+            - transpose: bool
+        """
+        self.apply_setting_to_images("set", args=[], kwargs=kwargs, image_id=name)
+
+    def set_image_properties(self, name: str = None, **kwargs):
+        """
+        Set the properties of the image.
+
+        Args:
+            name(str): The name of the image. If None, apply to all images.
+            **kwargs: Keyword arguments for the properties to be set.
+        Possible properties:
+            - downsample: bool
+            - color_map: str
+            - monitor: str
+            - opacity: float
+            - vrange: tuple[int,int]
+            - fft: bool
+            - log: bool
+            - rot: int
+            - transpose: bool
+        """
+        self.apply_setting_to_images("set", args=[], kwargs=kwargs, image_id=name)
+
+    def set_fft(self, enable: bool = False, name: str = None):
+        """
+        Set the FFT of the image.
+        If name is not specified, then set FFT for all images.
+
+        Args:
+            enable(bool): Whether to perform FFT on the monitor data.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_fft", args=[enable], kwargs={}, image_id=name)
+
+    def set_log(self, enable: bool = False, name: str = None):
+        """
+        Set the log of the image.
+        If name is not specified, then set log for all images.
+
+        Args:
+            enable(bool): Whether to perform log on the monitor data.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_log", args=[enable], kwargs={}, image_id=name)
+
+    def set_rotation(self, deg_90: int = 0, name: str = None):
+        """
+        Set the rotation of the image.
+        If name is not specified, then set rotation for all images.
+
+        Args:
+            deg_90(int): The rotation angle of the monitor data before displaying.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_rotation", args=[deg_90], kwargs={}, image_id=name)
+
+    def set_transpose(self, enable: bool = False, name: str = None):
+        """
+        Set the transpose of the image.
+        If name is not specified, then set transpose for all images.
+
+        Args:
+            enable(bool): Whether to transpose the monitor data before displaying.
+            name(str): The name of the image. If None, apply to all images.
+        """
+        self.apply_setting_to_images("set_transpose", args=[enable], kwargs={}, image_id=name)
+
+    def toggle_threading(self, use_threading: bool):
+        """
+        Toggle threading for the widgets postprocessing and updating.
+
+        Args:
+            use_threading(bool): Whether to use threading.
+        """
+        self.use_threading = use_threading
+        if self.use_threading is False and self.thread.isRunning():
+            self.cleanup()
+
+    @pyqtSlot(dict)
+    def on_image_update(self, msg: dict):
+        """
+        Update the image of the device monitor from bec.
+
+        Args:
+            msg(dict): The message from bec.
+        """
+        data = msg["data"]
+        device = msg["device"]
+        image_to_update = self._images["device_monitor"][device]
+        processing_config = image_to_update.config.processing
+        self.processor.set_config(processing_config)
+        if self.use_threading:
+            self._create_thread_worker(device, data)
+        else:
+            data = self.processor.process_image(data)
+            self.update_image(device, data)
+
+    @pyqtSlot(str, np.ndarray)
+    def update_image(self, device: str, data: np.ndarray):
+        """
+        Update the image of the device monitor.
+
+        Args:
+            device(str): The name of the device.
+            data(np.ndarray): The data to be updated.
+        """
+        image_to_update = self._images["device_monitor"][device]
+        image_to_update.updateImage(data, autoLevels=image_to_update.config.autorange)
+
+    def _connect_device_monitor(self, monitor: str):
+        """
+        Connect to the device monitor.
+
+        Args:
+            monitor(str): The name of the monitor.
+        """
+        image_item = self.find_image_by_monitor(monitor)
+        try:
+            previous_monitor = image_item.config.monitor
+        except AttributeError:
+            previous_monitor = None
+        if previous_monitor != monitor:
+            if previous_monitor:
+                self.bec_dispatcher.disconnect_slot(
+                    self.on_image_update, MessageEndpoints.device_monitor(previous_monitor)
+                )
+            if monitor:
+                self.bec_dispatcher.connect_slot(
+                    self.on_image_update, MessageEndpoints.device_monitor(monitor)
+                )
+                image_item.set_monitor(monitor)
+
+    def _add_image_object(
+        self, source: str, name: str, config: ImageItemConfig, data=None
+    ) -> BECImageItem:  # TODO fix types
+        config.parent_id = self.gui_id
+        image = BECImageItem(config=config, parent_image=self)
+        self.plot_item.addItem(image)
+        self._images[source][name] = image
+        self.config.images[name] = config
+        if data is not None:
+            image.setImage(data)
+        return image
+
+    def _check_image_id(self, val: Any, dict_to_check: dict) -> bool:
+        """
+        Check if val is in the values of the dict_to_check or in the values of the nested dictionaries.
+
+        Args:
+            val(Any): Value to check.
+            dict_to_check(dict): Dictionary to check.
+
+        Returns:
+            bool: True if val is in the values of the dict_to_check or in the values of the nested dictionaries, False otherwise.
+        """
+        if val in dict_to_check.keys():
+            return True
+        for key in dict_to_check:
+            if isinstance(dict_to_check[key], dict):
+                if self._check_image_id(val, dict_to_check[key]):
+                    return True
+        return False
+
+    def _validate_monitor(self, monitor: str, validate_bec: bool = True):
+        """
+        Validate the monitor name.
+
+        Args:
+            monitor(str): The name of the monitor.
+            validate_bec(bool): Whether to validate the monitor name with BEC.
+
+        Returns:
+            bool: True if the monitor name is valid, False otherwise.
+        """
+        if not monitor or monitor == "":
+            return False
+        if validate_bec:
+            return monitor in self.dev
+        return True
+
+    def cleanup(self):
+        """
+        Clean up the widget.
+        """
+        for monitor in self._images["device_monitor"]:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(monitor)
+            )
+        for image in self.images:
+            image.cleanup()
+
+        super().cleanup()

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

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, Optional
+
+import numpy as np
+import pyqtgraph as pg
+from pydantic import Field
+
+from bec_widgets.utils import BECConnector, ConnectionConfig
+from bec_widgets.widgets.figure.plots.image.image_processor import ProcessingConfig
+
+if TYPE_CHECKING:
+    from bec_widgets.widgets.figure.plots.image.image import BECImageShow
+
+
+class ImageItemConfig(ConnectionConfig):
+    parent_id: Optional[str] = Field(None, description="The parent plot of the image.")
+    monitor: Optional[str] = Field(None, description="The name of the monitor.")
+    source: Optional[str] = Field(None, description="The source of the curve.")
+    color_map: Optional[str] = Field("magma", description="The color map of the image.")
+    downsample: Optional[bool] = Field(True, description="Whether to downsample the image.")
+    opacity: Optional[float] = Field(1.0, description="The opacity of the image.")
+    vrange: Optional[tuple[int, int]] = Field(
+        None, description="The range of the color bar. If None, the range is automatically set."
+    )
+    color_bar: Optional[Literal["simple", "full"]] = Field(
+        "simple", description="The type of the color bar."
+    )
+    autorange: Optional[bool] = Field(True, description="Whether to autorange the color bar.")
+    processing: ProcessingConfig = Field(
+        default_factory=ProcessingConfig, description="The post processing of the image."
+    )
+
+
+class BECImageItem(BECConnector, pg.ImageItem):
+    USER_ACCESS = [
+        "rpc_id",
+        "config_dict",
+        "set",
+        "set_fft",
+        "set_log",
+        "set_rotation",
+        "set_transpose",
+        "set_opacity",
+        "set_autorange",
+        "set_color_map",
+        "set_auto_downsample",
+        "set_monitor",
+        "set_vrange",
+        "get_data",
+    ]
+
+    def __init__(
+        self,
+        config: Optional[ImageItemConfig] = None,
+        gui_id: Optional[str] = None,
+        parent_image: Optional[BECImageShow] = None,
+        **kwargs,
+    ):
+        if config is None:
+            config = ImageItemConfig(widget_class=self.__class__.__name__)
+            self.config = config
+        else:
+            self.config = config
+        super().__init__(config=config, gui_id=gui_id)
+        pg.ImageItem.__init__(self)
+
+        self.parent_image = parent_image
+        self.colorbar_bar = None
+
+        self._add_color_bar(
+            self.config.color_bar, self.config.vrange
+        )  # TODO can also support None to not have any colorbar
+        self.apply_config()
+        if kwargs:
+            self.set(**kwargs)
+
+    def apply_config(self):
+        """
+        Apply current configuration.
+        """
+        self.set_color_map(self.config.color_map)
+        self.set_auto_downsample(self.config.downsample)
+        if self.config.vrange is not None:
+            self.set_vrange(vrange=self.config.vrange)
+
+    def set(self, **kwargs):
+        """
+        Set the properties of the image.
+
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+
+        Possible properties:
+            - downsample
+            - color_map
+            - monitor
+            - opacity
+            - vrange
+            - fft
+            - log
+            - rot
+            - transpose
+        """
+        method_map = {
+            "downsample": self.set_auto_downsample,
+            "color_map": self.set_color_map,
+            "monitor": self.set_monitor,
+            "opacity": self.set_opacity,
+            "vrange": self.set_vrange,
+            "fft": self.set_fft,
+            "log": self.set_log,
+            "rot": self.set_rotation,
+            "transpose": self.set_transpose,
+        }
+        for key, value in kwargs.items():
+            if key in method_map:
+                method_map[key](value)
+            else:
+                print(f"Warning: '{key}' is not a recognized property.")
+
+    def set_fft(self, enable: bool = False):
+        """
+        Set the FFT of the image.
+
+        Args:
+            enable(bool): Whether to perform FFT on the monitor data.
+        """
+        self.config.processing.fft = enable
+
+    def set_log(self, enable: bool = False):
+        """
+        Set the log of the image.
+
+        Args:
+            enable(bool): Whether to perform log on the monitor data.
+        """
+        self.config.processing.log = enable
+        if enable and self.color_bar and self.config.color_bar == "full":
+            self.color_bar.autoHistogramRange()
+
+    def set_rotation(self, deg_90: int = 0):
+        """
+        Set the rotation of the image.
+
+        Args:
+            deg_90(int): The rotation angle of the monitor data before displaying.
+        """
+        self.config.processing.rotation = deg_90
+
+    def set_transpose(self, enable: bool = False):
+        """
+        Set the transpose of the image.
+
+        Args:
+            enable(bool): Whether to transpose the image.
+        """
+        self.config.processing.transpose = enable
+
+    def set_opacity(self, opacity: float = 1.0):
+        """
+        Set the opacity of the image.
+
+        Args:
+            opacity(float): The opacity of the image.
+        """
+        self.setOpacity(opacity)
+        self.config.opacity = opacity
+
+    def set_autorange(self, autorange: bool = False):
+        """
+        Set the autorange of the color bar.
+
+        Args:
+            autorange(bool): Whether to autorange the color bar.
+        """
+        self.config.autorange = autorange
+        if self.color_bar is not None:
+            self.color_bar.autoHistogramRange()
+
+    def set_color_map(self, cmap: str = "magma"):
+        """
+        Set the color map of the image.
+
+        Args:
+            cmap(str): The color map of the image.
+        """
+        self.setColorMap(cmap)
+        if self.color_bar is not None:
+            if self.config.color_bar == "simple":
+                self.color_bar.setColorMap(cmap)
+            elif self.config.color_bar == "full":
+                self.color_bar.gradient.loadPreset(cmap)
+        self.config.color_map = cmap
+
+    def set_auto_downsample(self, auto: bool = True):
+        """
+        Set the auto downsample of the image.
+
+        Args:
+            auto(bool): Whether to downsample the image.
+        """
+        self.setAutoDownsample(auto)
+        self.config.downsample = auto
+
+    def set_monitor(self, monitor: str):
+        """
+        Set the monitor of the image.
+
+        Args:
+            monitor(str): The name of the monitor.
+        """
+        self.config.monitor = monitor
+
+    def set_vrange(self, vmin: float = None, vmax: float = None, vrange: tuple[int, int] = None):
+        """
+        Set the range of the color bar.
+
+        Args:
+            vmin(float): Minimum value of the color bar.
+            vmax(float): Maximum value of the color bar.
+        """
+        if vrange is not None:
+            vmin, vmax = vrange
+        self.setLevels([vmin, vmax])
+        self.config.vrange = (vmin, vmax)
+        self.config.autorange = False
+        if self.color_bar is not None:
+            if self.config.color_bar == "simple":
+                self.color_bar.setLevels(low=vmin, high=vmax)
+            elif self.config.color_bar == "full":
+                self.color_bar.setLevels(min=vmin, max=vmax)
+                self.color_bar.setHistogramRange(vmin - 0.1 * vmin, vmax + 0.1 * vmax)
+
+    def get_data(self) -> np.ndarray:
+        """
+        Get the data of the image.
+        Returns:
+            np.ndarray: The data of the image.
+        """
+        return self.image
+
+    def _add_color_bar(
+        self, color_bar_style: str = "simple", vrange: Optional[tuple[int, int]] = None
+    ):
+        """
+        Add color bar to the layout.
+
+        Args:
+            style(Literal["simple,full"]): The style of the color bar.
+            vrange(tuple[int,int]): The range of the color bar.
+        """
+        if color_bar_style == "simple":
+            self.color_bar = pg.ColorBarItem(colorMap=self.config.color_map)
+            if vrange is not None:
+                self.color_bar.setLevels(low=vrange[0], high=vrange[1])
+            self.color_bar.setImageItem(self)
+            self.parent_image.addItem(self.color_bar)  # , row=0, col=1)
+            self.config.color_bar = "simple"
+        elif color_bar_style == "full":
+            # Setting histogram
+            self.color_bar = pg.HistogramLUTItem()
+            self.color_bar.setImageItem(self)
+            self.color_bar.gradient.loadPreset(self.config.color_map)
+            if vrange is not None:
+                self.color_bar.setLevels(min=vrange[0], max=vrange[1])
+                self.color_bar.setHistogramRange(
+                    vrange[0] - 0.1 * vrange[0], vrange[1] + 0.1 * vrange[1]
+                )
+
+            # Adding histogram to the layout
+            self.parent_image.addItem(self.color_bar)  # , row=0, col=1)
+
+            # save settings
+            self.config.color_bar = "full"
+        else:
+            raise ValueError("style should be 'simple' or 'full'")

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

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import numpy as np
+from pydantic import BaseModel, Field
+from qtpy.QtCore import QObject, Signal, Slot
+
+
+class ProcessingConfig(BaseModel):
+    fft: Optional[bool] = Field(False, description="Whether to perform FFT on the monitor data.")
+    log: Optional[bool] = Field(False, description="Whether to perform log on the monitor data.")
+    center_of_mass: Optional[bool] = Field(
+        False, description="Whether to calculate the center of mass of the monitor data."
+    )
+    transpose: Optional[bool] = Field(
+        False, description="Whether to transpose the monitor data before displaying."
+    )
+    rotation: Optional[int] = Field(
+        None, description="The rotation angle of the monitor data before displaying."
+    )
+
+
+class ImageProcessor:
+    """
+    Class for processing the image data.
+    """
+
+    def __init__(self, config: ProcessingConfig = None):
+        if config is None:
+            config = ProcessingConfig()
+        self.config = config
+
+    def set_config(self, config: ProcessingConfig):
+        """
+        Set the configuration of the processor.
+
+        Args:
+            config(ProcessingConfig): The configuration of the processor.
+        """
+        self.config = config
+
+    def FFT(self, data: np.ndarray) -> np.ndarray:
+        """
+        Perform FFT on the data.
+
+        Args:
+            data(np.ndarray): The data to be processed.
+
+        Returns:
+            np.ndarray: The processed data.
+        """
+        return np.abs(np.fft.fftshift(np.fft.fft2(data)))
+
+    def rotation(self, data: np.ndarray, rotate_90: int) -> np.ndarray:
+        """
+        Rotate the data by 90 degrees n times.
+
+        Args:
+            data(np.ndarray): The data to be processed.
+            rotate_90(int): The number of 90 degree rotations.
+
+        Returns:
+            np.ndarray: The processed data.
+        """
+        return np.rot90(data, k=rotate_90, axes=(0, 1))
+
+    def transpose(self, data: np.ndarray) -> np.ndarray:
+        """
+        Transpose the data.
+
+        Args:
+            data(np.ndarray): The data to be processed.
+
+        Returns:
+            np.ndarray: The processed data.
+        """
+        return np.transpose(data)
+
+    def log(self, data: np.ndarray) -> np.ndarray:
+        """
+        Perform log on the data.
+
+        Args:
+            data(np.ndarray): The data to be processed.
+
+        Returns:
+            np.ndarray: The processed data.
+        """
+        # TODO this is not final solution -> data should stay as int16
+        data = data.astype(np.float32)
+        offset = 1e-6
+        data_offset = data + offset
+        return np.log10(data_offset)
+
+    # def center_of_mass(self, data: np.ndarray) -> tuple:  # TODO check functionality
+    #     return np.unravel_index(np.argmax(data), data.shape)
+
+    def process_image(self, data: np.ndarray) -> np.ndarray:
+        """
+        Process the data according to the configuration.
+
+        Args:
+            data(np.ndarray): The data to be processed.
+
+        Returns:
+            np.ndarray: The processed data.
+        """
+        if self.config.fft:
+            data = self.FFT(data)
+        if self.config.rotation is not None:
+            data = self.rotation(data, self.config.rotation)
+        if self.config.transpose:
+            data = self.transpose(data)
+        if self.config.log:
+            data = self.log(data)
+        return data
+
+
+class ProcessorWorker(QObject):
+    """
+    Worker for processing the image data.
+    """
+
+    processed = Signal(str, np.ndarray)
+    stopRequested = Signal()
+    finished = Signal()
+
+    def __init__(self, processor):
+        super().__init__()
+        self.processor = processor
+        self._isRunning = False
+        self.stopRequested.connect(self.stop)
+
+    @Slot(str, np.ndarray)
+    def process_image(self, device: str, image: np.ndarray):
+        """
+        Process the image data.
+
+        Args:
+            device(str): The name of the device.
+            image(np.ndarray): The image data.
+        """
+        self._isRunning = True
+        processed_image = self.processor.process_image(image)
+        self._isRunning = False
+        if not self._isRunning:
+            self.processed.emit(device, processed_image)
+            self.finished.emit()
+
+    def stop(self):
+        self._isRunning = False

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

@@ -0,0 +1,435 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Optional, Union
+
+import numpy as np
+import pyqtgraph as pg
+from bec_lib.endpoints import MessageEndpoints
+from pydantic import Field
+from qtpy import QtCore, QtGui
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import EntryValidator
+from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
+from bec_widgets.widgets.figure.plots.waveform.waveform import Signal, SignalData
+
+
+class MotorMapConfig(SubplotConfig):
+    signals: Optional[Signal] = Field(None, description="Signals of the motor map")
+    color_map: Optional[str] = Field(
+        "Greys", description="Color scheme of the motor position gradient."
+    )  # TODO decide if useful for anything, or just keep GREYS always
+    scatter_size: Optional[int] = Field(5, description="Size of the scatter points.")
+    max_points: Optional[int] = Field(1000, description="Maximum number of points to display.")
+    num_dim_points: Optional[int] = Field(
+        100,
+        description="Number of points to dim before the color remains same for older recorded position.",
+    )
+    precision: Optional[int] = Field(2, description="Decimal precision of the motor position.")
+    background_value: Optional[int] = Field(
+        25, description="Background value of the motor map."
+    )  # TODO can be percentage from 255 calculated
+
+
+class BECMotorMap(BECPlotBase):
+    USER_ACCESS = [
+        "config_dict",
+        "change_motors",
+        "set_max_points",
+        "set_precision",
+        "set_num_dim_points",
+        "set_background_value",
+        "set_scatter_size",
+        "get_data",
+    ]
+
+    # QT Signals
+    update_signal = pyqtSignal()
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        parent_figure=None,
+        config: Optional[MotorMapConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = MotorMapConfig(widget_class=self.__class__.__name__)
+        super().__init__(
+            parent=parent, parent_figure=parent_figure, config=config, client=client, gui_id=gui_id
+        )
+
+        # Get bec shortcuts dev, scans, queue, scan_storage, dap
+        self.get_bec_shortcuts()
+        self.entry_validator = EntryValidator(self.dev)
+
+        self.motor_x = None
+        self.motor_y = None
+        self.database_buffer = {"x": [], "y": []}
+        self.plot_components = defaultdict(dict)  # container for plot components
+
+        # connect update signal to update plot
+        self.proxy_update_plot = pg.SignalProxy(
+            self.update_signal, rateLimit=25, slot=self._update_plot
+        )
+
+    # TODO decide if needed to implement, maybe there will be no children widgets for motormap for now...
+    # def find_widget_by_id(self, item_id: str) -> BECCurve:
+    #     """
+    #     Find the curve by its ID.
+    #     Args:
+    #         item_id(str): ID of the curve.
+    #
+    #     Returns:
+    #         BECCurve: The curve object.
+    #     """
+    #     for curve in self.plot_item.curves:
+    #         if curve.gui_id == item_id:
+    #             return curve
+
+    @pyqtSlot(str, str, str, str, bool)
+    def change_motors(
+        self,
+        motor_x: str,
+        motor_y: str,
+        motor_x_entry: str = None,
+        motor_y_entry: str = None,
+        validate_bec: bool = True,
+    ) -> None:
+        """
+        Change the active motors for the plot.
+
+        Args:
+            motor_x(str): Motor name for the X axis.
+            motor_y(str): Motor name for the Y axis.
+            motor_x_entry(str): Motor entry for the X axis.
+            motor_y_entry(str): Motor entry for the Y axis.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        """
+        motor_x_entry, motor_y_entry = self._validate_signal_entries(
+            motor_x, motor_y, motor_x_entry, motor_y_entry, validate_bec
+        )
+
+        motor_x_limit = self._get_motor_limit(motor_x)
+        motor_y_limit = self._get_motor_limit(motor_y)
+
+        signal = Signal(
+            source="device_readback",
+            x=SignalData(name=motor_x, entry=motor_x_entry, limits=motor_x_limit),
+            y=SignalData(name=motor_y, entry=motor_y_entry, limits=motor_y_limit),
+        )
+        self.config.signals = signal
+
+        # reconnect the signals
+        self._connect_motor_to_slots()
+
+        # Redraw the motor map
+        self._make_motor_map()
+
+    def get_data(self) -> dict:
+        """
+        Get the data of the motor map.
+        Returns:
+            dict: Data of the motor map.
+        """
+        data = {"x": self.database_buffer["x"], "y": self.database_buffer["y"]}
+        return data
+
+    # TODO setup all visual properties
+    def set_max_points(self, max_points: int) -> None:
+        """
+        Set the maximum number of points to display.
+
+        Args:
+            max_points(int): Maximum number of points to display.
+        """
+        self.config.max_points = max_points
+
+    def set_precision(self, precision: int) -> None:
+        """
+        Set the decimal precision of the motor position.
+
+        Args:
+            precision(int): Decimal precision of the motor position.
+        """
+        self.config.precision = precision
+
+    def set_num_dim_points(self, num_dim_points: int) -> None:
+        """
+        Set the number of dim points for the motor map.
+
+        Args:
+            num_dim_points(int): Number of dim points.
+        """
+        self.config.num_dim_points = num_dim_points
+
+    def set_background_value(self, background_value: int) -> None:
+        """
+        Set the background value of the motor map.
+
+        Args:
+            background_value(int): Background value of the motor map.
+        """
+        self.config.background_value = background_value
+
+    def set_scatter_size(self, scatter_size: int) -> None:
+        """
+        Set the scatter size of the motor map plot.
+
+        Args:
+            scatter_size(int): Size of the scatter points.
+        """
+        self.config.scatter_size = scatter_size
+
+    def _disconnect_current_motors(self):
+        """Disconnect the current motors from the slots."""
+        if self.motor_x is not None and self.motor_y is not None:
+            endpoints = [
+                MessageEndpoints.device_readback(self.motor_x),
+                MessageEndpoints.device_readback(self.motor_y),
+            ]
+            self.bec_dispatcher.disconnect_slot(self.on_device_readback, endpoints)
+
+    def _connect_motor_to_slots(self):
+        """Connect motors to slots."""
+        self._disconnect_current_motors()
+
+        self.motor_x = self.config.signals.x.name
+        self.motor_y = self.config.signals.y.name
+
+        endpoints = [
+            MessageEndpoints.device_readback(self.motor_x),
+            MessageEndpoints.device_readback(self.motor_y),
+        ]
+
+        self.bec_dispatcher.connect_slot(self.on_device_readback, endpoints)
+
+    def _make_motor_map(self):
+        """
+        Create the motor map plot.
+        """
+        # Create limit map
+        motor_x_limit = self.config.signals.x.limits
+        motor_y_limit = self.config.signals.y.limits
+        self.plot_components["limit_map"] = self._make_limit_map(motor_x_limit, motor_y_limit)
+        self.plot_item.addItem(self.plot_components["limit_map"])
+        self.plot_components["limit_map"].setZValue(-1)
+
+        # Create scatter plot
+        scatter_size = self.config.scatter_size
+        self.plot_components["scatter"] = pg.ScatterPlotItem(
+            size=scatter_size, brush=pg.mkBrush(255, 255, 255, 255)
+        )
+        self.plot_item.addItem(self.plot_components["scatter"])
+        self.plot_components["scatter"].setZValue(0)
+
+        # Enable Grid
+        self.set_grid(True, True)
+
+        # Add the crosshair for initial motor coordinates
+        initial_position_x = self._get_motor_init_position(
+            self.motor_x, self.config.signals.x.entry, self.config.precision
+        )
+        initial_position_y = self._get_motor_init_position(
+            self.motor_y, self.config.signals.y.entry, self.config.precision
+        )
+
+        self.database_buffer["x"] = [initial_position_x]
+        self.database_buffer["y"] = [initial_position_y]
+
+        self.plot_components["scatter"].setData([initial_position_x], [initial_position_y])
+        self._add_coordinantes_crosshair(initial_position_x, initial_position_y)
+
+        # Set default labels for the plot
+        self.set(x_label=f"Motor X ({self.motor_x})", y_label=f"Motor Y ({self.motor_y})")
+
+    def _add_coordinantes_crosshair(self, x: float, y: float) -> None:
+        """
+        Add crosshair to the plot to highlight the current position.
+
+        Args:
+            x(float): X coordinate.
+            y(float): Y coordinate.
+        """
+
+        # Crosshair to highlight the current position
+        highlight_H = pg.InfiniteLine(
+            angle=0, movable=False, pen=pg.mkPen(color="r", width=1, style=QtCore.Qt.DashLine)
+        )
+        highlight_V = pg.InfiniteLine(
+            angle=90, movable=False, pen=pg.mkPen(color="r", width=1, style=QtCore.Qt.DashLine)
+        )
+
+        # Add crosshair to the curve list for future referencing
+        self.plot_components["highlight_H"] = highlight_H
+        self.plot_components["highlight_V"] = highlight_V
+
+        # Add crosshair to the plot
+        self.plot_item.addItem(highlight_H)
+        self.plot_item.addItem(highlight_V)
+
+        highlight_V.setPos(x)
+        highlight_H.setPos(y)
+
+    def _make_limit_map(self, limits_x: list, limits_y: list) -> pg.ImageItem:
+        """
+        Create a limit map for the motor map plot.
+
+        Args:
+            limits_x(list): Motor limits for the x axis.
+            limits_y(list): Motor limits for the y axis.
+
+        Returns:
+            pg.ImageItem: Limit map.
+        """
+        limit_x_min, limit_x_max = limits_x
+        limit_y_min, limit_y_max = limits_y
+
+        map_width = int(limit_x_max - limit_x_min + 1)
+        map_height = int(limit_y_max - limit_y_min + 1)
+
+        # Create limits map
+        background_value = self.config.background_value
+        limit_map_data = np.full((map_width, map_height), background_value, dtype=np.float32)
+        limit_map = pg.ImageItem()
+        limit_map.setImage(limit_map_data)
+
+        # Translate and scale the image item to match the motor coordinates
+        tr = QtGui.QTransform()
+        tr.translate(limit_x_min, limit_y_min)
+        limit_map.setTransform(tr)
+
+        return limit_map
+
+    def _get_motor_init_position(self, name: str, entry: str, precision: int) -> float:
+        """
+        Get the motor initial position from the config.
+
+        Args:
+            name(str): Motor name.
+            entry(str): Motor entry.
+            precision(int): Decimal precision of the motor position.
+
+        Returns:
+            float: Motor initial position.
+        """
+        init_position = round(self.dev[name].read()[entry]["value"], precision)
+        return init_position
+
+    def _validate_signal_entries(
+        self,
+        x_name: str,
+        y_name: str,
+        x_entry: str | None,
+        y_entry: str | None,
+        validate_bec: bool = True,
+    ) -> tuple[str, str]:
+        """
+        Validate the signal name and entry.
+
+        Args:
+            x_name(str): Name of the x signal.
+            y_name(str): Name of the y signal.
+            x_entry(str|None): Entry of the x signal.
+            y_entry(str|None): Entry of the y signal.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+
+        Returns:
+            tuple[str,str]: Validated x and y entries.
+        """
+        if validate_bec:
+            x_entry = self.entry_validator.validate_signal(x_name, x_entry)
+            y_entry = self.entry_validator.validate_signal(y_name, y_entry)
+        else:
+            x_entry = x_name if x_entry is None else x_entry
+            y_entry = y_name if y_entry is None else y_entry
+        return x_entry, y_entry
+
+    def _get_motor_limit(self, motor: str) -> Union[list | None]:  # TODO check if works correctly
+        """
+        Get the motor limit from the config.
+
+        Args:
+            motor(str): Motor name.
+
+        Returns:
+            float: Motor limit.
+        """
+        try:
+            limits = self.dev[motor].limits
+            if limits == [0, 0]:
+                return None
+            return limits
+        except AttributeError:  # TODO maybe not needed, if no limits it returns [0,0]
+            # If the motor doesn't have a 'limits' attribute, return a default value or raise a custom exception
+            print(f"The device '{motor}' does not have defined limits.")
+            return None
+
+    def _update_plot(self):
+        """Update the motor map plot."""
+        x = self.database_buffer["x"]
+        y = self.database_buffer["y"]
+
+        # Setup gradient brush for history
+        brushes = [pg.mkBrush(50, 50, 50, 255)] * len(x)
+
+        # Calculate the decrement step based on self.num_dim_points
+        num_dim_points = self.config.num_dim_points
+        decrement_step = (255 - 50) / num_dim_points
+        for i in range(1, min(num_dim_points + 1, len(x) + 1)):
+            brightness = max(60, 255 - decrement_step * (i - 1))
+            brushes[-i] = pg.mkBrush(brightness, brightness, brightness, 255)
+        brushes[-1] = pg.mkBrush(255, 255, 255, 255)  # Newest point is always full brightness
+        scatter_size = self.config.scatter_size
+
+        # Update the scatter plot
+        self.plot_components["scatter"].setData(
+            x=x, y=y, brush=brushes, pen=None, size=scatter_size
+        )
+
+        # Get last know position for crosshair
+        current_x = x[-1]
+        current_y = y[-1]
+
+        # Update the crosshair
+        self.plot_components["highlight_V"].setPos(current_x)
+        self.plot_components["highlight_H"].setPos(current_y)
+
+        # TODO not update title but some label
+        # Update plot title
+        precision = self.config.precision
+        self.set_title(
+            f"Motor position: ({round(current_x,precision)}, {round(current_y,precision)})"
+        )
+
+    @pyqtSlot(dict)
+    def on_device_readback(self, msg: dict) -> None:
+        """
+        Update the motor map plot with the new motor position.
+
+        Args:
+            msg(dict): Message from the device readback.
+        """
+        if self.motor_x is None or self.motor_y is None:
+            return
+
+        if self.motor_x in msg["signals"]:
+            x = msg["signals"][self.motor_x]["value"]
+            self.database_buffer["x"].append(x)
+            self.database_buffer["y"].append(self.database_buffer["y"][-1])
+
+        elif self.motor_y in msg["signals"]:
+            y = msg["signals"][self.motor_y]["value"]
+            self.database_buffer["y"].append(y)
+            self.database_buffer["x"].append(self.database_buffer["x"][-1])
+
+        self.update_signal.emit()
+
+    def cleanup(self):
+        """Cleanup the widget."""
+        self._disconnect_current_motors()
+        super().cleanup()

bec_widgets/widgets/figure/plots/plot_base.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+import numpy as np
+import pyqtgraph as pg
+from pydantic import BaseModel, Field
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import BECConnector, ConnectionConfig
+
+
+class AxisConfig(BaseModel):
+    title: Optional[str] = Field(None, description="The title of the axes.")
+    x_label: Optional[str] = Field(None, description="The label for the x-axis.")
+    y_label: Optional[str] = Field(None, description="The label for the y-axis.")
+    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.")
+
+
+class SubplotConfig(ConnectionConfig):
+    parent_id: Optional[str] = Field(None, description="The parent figure of the plot.")
+
+    # Coordinates in the figure
+    row: int = Field(0, description="The row coordinate in the figure.")
+    col: int = Field(0, description="The column coordinate in the figure.")
+
+    # Appearance settings
+    axis: AxisConfig = Field(
+        default_factory=AxisConfig, description="The axis configuration of the plot."
+    )
+
+
+class BECPlotBase(BECConnector, pg.GraphicsLayout):
+    USER_ACCESS = [
+        "config_dict",
+        "set",
+        "set_title",
+        "set_x_label",
+        "set_y_label",
+        "set_x_scale",
+        "set_y_scale",
+        "set_x_lim",
+        "set_y_lim",
+        "set_grid",
+        "lock_aspect_ratio",
+        "plot",
+        "remove",
+    ]
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,  # TODO decide if needed for this class
+        parent_figure=None,
+        config: Optional[SubplotConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = SubplotConfig(widget_class=self.__class__.__name__)
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        pg.GraphicsLayout.__init__(self, parent)
+
+        self.figure = parent_figure
+        self.plot_item = self.addPlot(row=0, col=0)
+
+        self.add_legend()
+
+    def set(self, **kwargs) -> None:
+        """
+        Set the properties of the plot widget.
+
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+
+        Possible properties:
+            - title: str
+            - x_label: str
+            - y_label: str
+            - x_scale: Literal["linear", "log"]
+            - y_scale: Literal["linear", "log"]
+            - x_lim: tuple
+            - y_lim: tuple
+        """
+        # Mapping of keywords to setter methods
+        method_map = {
+            "title": self.set_title,
+            "x_label": self.set_x_label,
+            "y_label": self.set_y_label,
+            "x_scale": self.set_x_scale,
+            "y_scale": self.set_y_scale,
+            "x_lim": self.set_x_lim,
+            "y_lim": self.set_y_lim,
+        }
+        for key, value in kwargs.items():
+            if key in method_map:
+                method_map[key](value)
+            else:
+                print(f"Warning: '{key}' is not a recognized property.")
+
+    def apply_axis_config(self):
+        """Apply the axis configuration to the plot widget."""
+        config_mappings = {
+            "title": self.config.axis.title,
+            "x_label": self.config.axis.x_label,
+            "y_label": self.config.axis.y_label,
+            "x_scale": self.config.axis.x_scale,
+            "y_scale": self.config.axis.y_scale,
+            "x_lim": self.config.axis.x_lim,
+            "y_lim": self.config.axis.y_lim,
+        }
+
+        self.set(**{k: v for k, v in config_mappings.items() if v is not None})
+
+    def set_title(self, title: str):
+        """
+        Set the title of the plot widget.
+
+        Args:
+            title(str): Title of the plot widget.
+        """
+        self.plot_item.setTitle(title)
+        self.config.axis.title = title
+
+    def set_x_label(self, label: str):
+        """
+        Set the label of the x-axis.
+
+        Args:
+            label(str): Label of the x-axis.
+        """
+        self.plot_item.setLabel("bottom", label)
+        self.config.axis.x_label = label
+
+    def set_y_label(self, label: str):
+        """
+        Set the label of the y-axis.
+
+        Args:
+            label(str): Label of the y-axis.
+        """
+        self.plot_item.setLabel("left", label)
+        self.config.axis.y_label = label
+
+    def set_x_scale(self, scale: Literal["linear", "log"] = "linear"):
+        """
+        Set the scale of the x-axis.
+
+        Args:
+            scale(Literal["linear", "log"]): Scale of the x-axis.
+        """
+        self.plot_item.setLogMode(x=(scale == "log"))
+        self.config.axis.x_scale = scale
+
+    def set_y_scale(self, scale: Literal["linear", "log"] = "linear"):
+        """
+        Set the scale of the y-axis.
+
+        Args:
+            scale(Literal["linear", "log"]): Scale of the y-axis.
+        """
+        self.plot_item.setLogMode(y=(scale == "log"))
+        self.config.axis.y_scale = scale
+
+    def set_x_lim(self, *args) -> None:
+        """
+        Set the limits of the x-axis. This method can accept either two separate arguments
+        for the minimum and maximum x-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_x_lim(x_min, x_max)
+            set_x_lim((x_min, x_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (x_min and x_max)
+                   or a single tuple with two integers.
+        """
+        if len(args) == 1 and isinstance(args[0], tuple):
+            x_min, x_max = args[0]
+        elif len(args) == 2:
+            x_min, x_max = args
+        else:
+            raise ValueError("set_x_lim expects either two separate arguments or a single tuple")
+
+        self.plot_item.setXRange(x_min, x_max)
+        self.config.axis.x_lim = (x_min, x_max)
+
+    def set_y_lim(self, *args) -> None:
+        """
+        Set the limits of the y-axis. This method can accept either two separate arguments
+        for the minimum and maximum y-axis values, or a single tuple containing both limits.
+
+        Usage:
+            set_y_lim(y_min, y_max)
+            set_y_lim((y_min, y_max))
+
+        Args:
+            *args: A variable number of arguments. Can be two integers (y_min and y_max)
+                   or a single tuple with two integers.
+        """
+        if len(args) == 1 and isinstance(args[0], tuple):
+            y_min, y_max = args[0]
+        elif len(args) == 2:
+            y_min, y_max = args
+        else:
+            raise ValueError("set_y_lim expects either two separate arguments or a single tuple")
+
+        self.plot_item.setYRange(y_min, y_max)
+        self.config.axis.y_lim = (y_min, y_max)
+
+    def set_grid(self, x: bool = False, y: bool = False):
+        """
+        Set the grid of the plot widget.
+
+        Args:
+            x(bool): Show grid on the x-axis.
+            y(bool): Show grid on the y-axis.
+        """
+        self.plot_item.showGrid(x, y)
+        self.config.axis.x_grid = x
+        self.config.axis.y_grid = y
+
+    def add_legend(self):
+        """Add legend to the plot"""
+        self.plot_item.addLegend()
+
+    def lock_aspect_ratio(self, lock):
+        """
+        Lock aspect ratio.
+
+        Args:
+            lock(bool): True to lock, False to unlock.
+        """
+        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:
+            self.cleanup()
+            self.figure.remove(widget_id=self.gui_id)
+
+    def cleanup(self):
+        """Cleanup the plot widget."""
+        super().cleanup()

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

@@ -0,0 +1,616 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Literal, Optional
+
+import numpy as np
+import pyqtgraph as pg
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.scan_data import ScanData
+from pydantic import Field, ValidationError
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import Colors, EntryValidator
+from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
+from bec_widgets.widgets.figure.plots.waveform.waveform_curve import (
+    BECCurve,
+    CurveConfig,
+    Signal,
+    SignalData,
+)
+
+
+class Waveform1DConfig(SubplotConfig):
+    color_palette: Literal["plasma", "viridis", "inferno", "magma"] = Field(
+        "plasma", description="The color palette of the figure widget."
+    )  # TODO can be extended to all colormaps from current pyqtgraph session
+    curves: dict[str, CurveConfig] = Field(
+        {}, description="The list of curves to be added to the 1D waveform widget."
+    )
+
+
+class BECWaveform(BECPlotBase):
+    USER_ACCESS = [
+        "rpc_id",
+        "config_dict",
+        "add_curve_scan",
+        "add_curve_custom",
+        "remove_curve",
+        "scan_history",
+        "curves",
+        "get_curve",
+        "get_curve_config",
+        "apply_config",
+        "get_all_data",
+        "set",
+        "set_title",
+        "set_x_label",
+        "set_y_label",
+        "set_x_scale",
+        "set_y_scale",
+        "set_x_lim",
+        "set_y_lim",
+        "set_grid",
+        "lock_aspect_ratio",
+        "plot",
+        "remove",
+    ]
+    scan_signal_update = pyqtSignal()
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        parent_figure=None,
+        config: Optional[Waveform1DConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = Waveform1DConfig(widget_class=self.__class__.__name__)
+        super().__init__(
+            parent=parent, parent_figure=parent_figure, config=config, client=client, gui_id=gui_id
+        )
+
+        self._curves_data = defaultdict(dict)
+        self.scan_id = None
+
+        # Scan segment update proxy
+        self.proxy_update_plot = pg.SignalProxy(
+            self.scan_signal_update, rateLimit=25, slot=self._update_scan_segment_plot
+        )
+
+        # Get bec shortcuts dev, scans, queue, scan_storage, dap
+        self.get_bec_shortcuts()
+
+        # Connect dispatcher signals
+        self.bec_dispatcher.connect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+
+        self.entry_validator = EntryValidator(self.dev)
+
+        self.add_legend()
+        self.apply_config(self.config)
+
+    def apply_config(self, config: dict | SubplotConfig, replot_last_scan: bool = False):
+        """
+        Apply the configuration to the 1D waveform widget.
+
+        Args:
+            config(dict|SubplotConfig): Configuration settings.
+            replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
+        """
+        if isinstance(config, dict):
+            try:
+                config = Waveform1DConfig(**config)
+            except ValidationError as e:
+                print(f"Validation error when applying config to BECWaveform1D: {e}")
+                return
+
+        self.config = config
+        self.plot_item.clear()  # TODO not sure if on the plot or layout level
+
+        self.apply_axis_config()
+        # Reset curves
+        self._curves_data = defaultdict(dict)
+        self._curves = self.plot_item.curves
+        for curve_id, curve_config in self.config.curves.items():
+            self.add_curve_by_config(curve_config)
+        if replot_last_scan:
+            self.scan_history(scan_index=-1)
+
+    def change_gui_id(self, new_gui_id: str):
+        """
+        Change the GUI ID of the waveform widget and update the parent_id in all associated curves.
+
+        Args:
+            new_gui_id (str): The new GUI ID to be set for the waveform widget.
+        """
+        # Update the gui_id in the waveform widget itself
+        self.gui_id = new_gui_id
+        self.config.gui_id = new_gui_id
+
+        for curve in self.curves:
+            curve.config.parent_id = new_gui_id
+
+    def add_curve_by_config(self, curve_config: CurveConfig | dict) -> BECCurve:
+        """
+        Add a curve to the plot widget by its configuration.
+
+        Args:
+            curve_config(CurveConfig|dict): Configuration of the curve to be added.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        if isinstance(curve_config, dict):
+            curve_config = CurveConfig(**curve_config)
+        curve = self._add_curve_object(
+            name=curve_config.label, source=curve_config.source, config=curve_config
+        )
+        return curve
+
+    def get_curve_config(self, curve_id: str, dict_output: bool = True) -> CurveConfig | dict:
+        """
+        Get the configuration of a curve by its ID.
+
+        Args:
+            curve_id(str): ID of the curve.
+
+        Returns:
+            CurveConfig|dict: Configuration of the curve.
+        """
+        for source, curves in self._curves_data.items():
+            if curve_id in curves:
+                if dict_output:
+                    return curves[curve_id].config.model_dump()
+                else:
+                    return curves[curve_id].config
+
+    @property
+    def curves(self) -> list[BECCurve]:
+        """
+        Get the curves of the plot widget as a list
+        Returns:
+            list: List of curves.
+        """
+        return self._curves
+
+    @curves.setter
+    def curves(self, value: list[BECCurve]):
+        self._curves = value
+
+    def get_curve(self, identifier) -> BECCurve:
+        """
+        Get the curve by its index or ID.
+
+        Args:
+            identifier(int|str): Identifier of the curve. Can be either an integer (index) or a string (curve_id).
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        if isinstance(identifier, int):
+            return self.plot_item.curves[identifier]
+        elif isinstance(identifier, str):
+            for source_type, curves in self._curves_data.items():
+                if identifier in curves:
+                    return curves[identifier]
+            raise ValueError(f"Curve with ID '{identifier}' not found.")
+        else:
+            raise ValueError("Identifier must be either an integer (index) or a string (curve_id).")
+
+    def add_curve_custom(
+        self,
+        x: list | np.ndarray,
+        y: list | np.ndarray,
+        label: str = None,
+        color: str = None,
+        **kwargs,
+    ) -> BECCurve:
+        """
+        Add a custom data curve to the plot widget.
+
+        Args:
+            x(list|np.ndarray): X data of the curve.
+            y(list|np.ndarray): Y data of the curve.
+            label(str, optional): Label of the curve. Defaults to None.
+            color(str, optional): Color of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        curve_source = "custom"
+        curve_id = label or f"Curve {len(self.plot_item.curves) + 1}"
+
+        curve_exits = self._check_curve_id(curve_id, self._curves_data)
+        if curve_exits:
+            raise ValueError(
+                f"Curve with ID '{curve_id}' already exists in widget '{self.gui_id}'."
+            )
+
+        color = (
+            color
+            or Colors.golden_angle_color(
+                colormap=self.config.color_palette, num=len(self.plot_item.curves) + 1, format="HEX"
+            )[-1]
+        )
+
+        # Create curve by config
+        curve_config = CurveConfig(
+            widget_class="BECCurve",
+            parent_id=self.gui_id,
+            label=curve_id,
+            color=color,
+            source=curve_source,
+            **kwargs,
+        )
+
+        curve = self._add_curve_object(
+            name=curve_id, source=curve_source, config=curve_config, data=(x, y)
+        )
+        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,
+        y_name: str,
+        z_name: Optional[str] = None,
+        x_entry: Optional[str] = None,
+        y_entry: Optional[str] = None,
+        z_entry: Optional[str] = None,
+        color: Optional[str] = None,
+        color_map_z: Optional[str] = "plasma",
+        label: Optional[str] = None,
+        validate_bec: bool = True,
+        **kwargs,
+    ) -> BECCurve:
+        """
+        Add a curve to the plot widget from the scan segment.
+
+        Args:
+            x_name(str): Name of the x signal.
+            x_entry(str): Entry of the x signal.
+            y_name(str): Name of the y signal.
+            y_entry(str): Entry of the y signal.
+            z_name(str): Name of the z signal.
+            z_entry(str): Entry of the z signal.
+            color(str, optional): Color of the curve. Defaults to None.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str, optional): Label of the curve. Defaults to None.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        # Check if curve already exists
+        curve_source = "scan_segment"
+
+        # Get entry if not provided and validate
+        x_entry, y_entry, z_entry = self._validate_signal_entries(
+            x_name, y_name, z_name, x_entry, y_entry, z_entry, validate_bec
+        )
+
+        if z_name is not None and z_entry is not None:
+            label = label or f"{z_name}-{z_entry}"
+        else:
+            label = label or f"{y_name}-{y_entry}"
+
+        curve_exits = self._check_curve_id(label, self._curves_data)
+        if curve_exits:
+            raise ValueError(f"Curve with ID '{label}' already exists in widget '{self.gui_id}'.")
+
+        color = (
+            color
+            or Colors.golden_angle_color(
+                colormap=self.config.color_palette, num=len(self.plot_item.curves) + 1, format="HEX"
+            )[-1]
+        )
+
+        # Create curve by config
+        curve_config = CurveConfig(
+            widget_class="BECCurve",
+            parent_id=self.gui_id,
+            label=label,
+            color=color,
+            color_map=color_map_z,
+            source=curve_source,
+            signals=Signal(
+                source=curve_source,
+                x=SignalData(name=x_name, entry=x_entry),
+                y=SignalData(name=y_name, entry=y_entry),
+                z=SignalData(name=z_name, entry=z_entry) if z_name else None,
+            ),
+            **kwargs,
+        )
+        curve = self._add_curve_object(name=label, source=curve_source, config=curve_config)
+        return curve
+
+    def _validate_signal_entries(
+        self,
+        x_name: str,
+        y_name: str,
+        z_name: str | None,
+        x_entry: str | None,
+        y_entry: str | None,
+        z_entry: str | None,
+        validate_bec: bool = True,
+    ) -> tuple[str, str, str | None]:
+        """
+        Validate the signal name and entry.
+
+        Args:
+            x_name(str): Name of the x signal.
+            y_name(str): Name of the y signal.
+            z_name(str): Name of the z signal.
+            x_entry(str|None): Entry of the x signal.
+            y_entry(str|None): Entry of the y signal.
+            z_entry(str|None): Entry of the z signal.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+
+        Returns:
+            tuple[str,str,str|None]: Validated x, y, z entries.
+        """
+        if validate_bec:
+            x_entry = self.entry_validator.validate_signal(x_name, x_entry)
+            y_entry = self.entry_validator.validate_signal(y_name, y_entry)
+            if z_name:
+                z_entry = self.entry_validator.validate_signal(z_name, z_entry)
+        else:
+            x_entry = x_name if x_entry is None else x_entry
+            y_entry = y_name if y_entry is None else y_entry
+            z_entry = z_name if z_entry is None else z_entry
+        return x_entry, y_entry, z_entry
+
+    def _check_curve_id(self, val: Any, dict_to_check: dict) -> bool:
+        """
+        Check if val is in the values of the dict_to_check or in the values of the nested dictionaries.
+
+        Args:
+            val(Any): Value to check.
+            dict_to_check(dict): Dictionary to check.
+
+        Returns:
+            bool: True if val is in the values of the dict_to_check or in the values of the nested dictionaries, False otherwise.
+        """
+        if val in dict_to_check.keys():
+            return True
+        for key in dict_to_check:
+            if isinstance(dict_to_check[key], dict):
+                if self._check_curve_id(val, dict_to_check[key]):
+                    return True
+        return False
+
+    def remove_curve(self, *identifiers):
+        """
+        Remove a curve from the plot widget.
+
+        Args:
+            *identifiers: Identifier of the curve to be removed. Can be either an integer (index) or a string (curve_id).
+        """
+        for identifier in identifiers:
+            if isinstance(identifier, int):
+                self._remove_curve_by_order(identifier)
+            elif isinstance(identifier, str):
+                self._remove_curve_by_id(identifier)
+            else:
+                raise ValueError(
+                    "Each identifier must be either an integer (index) or a string (curve_id)."
+                )
+
+    def _remove_curve_by_id(self, curve_id):
+        """
+        Remove a curve by its ID from the plot widget.
+
+        Args:
+            curve_id(str): ID of the curve to be removed.
+        """
+        for source, curves in self._curves_data.items():
+            if curve_id in curves:
+                curve = curves.pop(curve_id)
+                self.plot_item.removeItem(curve)
+                del self.config.curves[curve_id]
+                if curve in self.plot_item.curves:
+                    self.plot_item.curves.remove(curve)
+                return
+        raise KeyError(f"Curve with ID '{curve_id}' not found.")
+
+    def _remove_curve_by_order(self, N):
+        """
+        Remove a curve by its order from the plot widget.
+
+        Args:
+            N(int): Order of the curve to be removed.
+        """
+        if N < len(self.plot_item.curves):
+            curve = self.plot_item.curves[N]
+            curve_id = curve.name()  # Assuming curve's name is used as its ID
+            self.plot_item.removeItem(curve)
+            del self.config.curves[curve_id]
+            # Remove from self.curve_data
+            for source, curves in self._curves_data.items():
+                if curve_id in curves:
+                    del curves[curve_id]
+                    break
+        else:
+            raise IndexError(f"Curve order {N} out of range.")
+
+    @pyqtSlot(dict, dict)
+    def on_scan_segment(self, msg: dict, metadata: dict):
+        """
+        Handle new scan segments and saves data to a dictionary. Linked through bec_dispatcher.
+
+        Args:
+            msg (dict): Message received with scan data.
+            metadata (dict): Metadata of the scan.
+        """
+        current_scan_id = msg.get("scan_id", None)
+        if current_scan_id is None:
+            return
+
+        if current_scan_id != self.scan_id:
+            self.scan_id = current_scan_id
+            self.scan_segment_data = self.queue.scan_storage.find_scan_by_ID(
+                self.scan_id
+            )  # TODO do scan access through BECFigure
+
+        self.scan_signal_update.emit()
+
+    def _update_scan_segment_plot(self):
+        """Update the plot with the data from the scan segment."""
+        data = self.scan_segment_data.data
+        self._update_scan_curves(data)
+
+    def _update_scan_curves(self, data: ScanData):
+        """
+        Update the scan curves with the data from the scan segment.
+
+        Args:
+            data(ScanData): Data from the scan segment.
+        """
+        data_x = None
+        data_y = None
+        data_z = None
+        for curve_id, curve in self._curves_data["scan_segment"].items():
+            x_name = curve.config.signals.x.name
+            x_entry = curve.config.signals.x.entry
+            y_name = curve.config.signals.y.name
+            y_entry = curve.config.signals.y.entry
+            if curve.config.signals.z:
+                z_name = curve.config.signals.z.name
+                z_entry = curve.config.signals.z.entry
+
+            try:
+                data_x = data[x_name][x_entry].val
+                data_y = data[y_name][y_entry].val
+                if curve.config.signals.z:
+                    data_z = data[z_name][z_entry].val
+                    color_z = self._make_z_gradient(
+                        data_z, curve.config.colormap
+                    )  # TODO decide how to implement custom gradient
+            except TypeError:
+                continue
+
+            if data_z is not None and color_z is not None:
+                curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
+            else:
+                curve.setData(data_x, data_y)
+
+    def _make_z_gradient(self, data_z: list | np.ndarray, colormap: str) -> list | None:
+        """
+        Make a gradient color for the z values.
+
+        Args:
+            data_z(list|np.ndarray): Z values.
+            colormap(str): Colormap for the gradient color.
+
+        Returns:
+            list: List of colors for the z values.
+        """
+        # Normalize z_values for color mapping
+        z_min, z_max = np.min(data_z), np.max(data_z)
+
+        if z_max != z_min:  # Ensure that there is a range in the z values
+            z_values_norm = (data_z - z_min) / (z_max - z_min)
+            colormap = pg.colormap.get(colormap)  # using colormap from global settings
+            colors = [colormap.map(z, mode="qcolor") for z in z_values_norm]
+            return colors
+        else:
+            return None
+
+    def scan_history(self, scan_index: int = None, scan_id: str = None):
+        """
+        Update the scan curves with the data from the scan storage.
+        Provide only one of scan_id or scan_index.
+
+        Args:
+            scan_id(str, optional): ScanID of the scan to be updated. Defaults to None.
+            scan_index(int, optional): Index of the scan to be updated. Defaults to None.
+        """
+        if scan_index is not None and scan_id is not None:
+            raise ValueError("Only one of scan_id or scan_index can be provided.")
+
+        if scan_index is not None:
+            self.scan_id = self.queue.scan_storage.storage[scan_index].scan_id
+            data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data
+        elif scan_id is not None:
+            self.scan_id = scan_id
+            data = self.queue.scan_storage.find_scan_by_ID(self.scan_id).data
+
+        self._update_scan_curves(data)
+
+    def get_all_data(self, output: Literal["dict", "pandas"] = "dict") -> dict | pd.DataFrame:
+        """
+        Extract all curve data into a dictionary or a pandas DataFrame.
+
+        Args:
+            output (Literal["dict", "pandas"]): Format of the output data.
+
+        Returns:
+            dict | pd.DataFrame: Data of all curves in the specified format.
+        """
+
+        data = {}
+        try:
+            import pandas as pd
+        except ImportError:
+            pd = None
+            if output == "pandas":
+                print(
+                    "Pandas is not installed. "
+                    "Please install pandas using 'pip install pandas'."
+                    "Output will be dictionary instead."
+                )
+                output = "dict"
+
+        for curve in self.plot_item.curves:
+            x_data, y_data = curve.get_data()
+            if x_data is not None or y_data is not None:
+                if output == "dict":
+                    data[curve.name()] = {"x": x_data.tolist(), "y": y_data.tolist()}
+                elif output == "pandas" and pd is not None:
+                    data[curve.name()] = pd.DataFrame({"x": x_data, "y": y_data})
+
+        if output == "pandas" and pd is not None:
+            combined_data = pd.concat(
+                [data[curve.name()] for curve in self.plot_item.curves],
+                axis=1,
+                keys=[curve.name() for curve in self.plot_item.curves],
+            )
+            return combined_data
+        return data
+
+    def cleanup(self):
+        """Cleanup the widget connection from BECDispatcher."""
+        self.bec_dispatcher.disconnect_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
+        for curve in self.curves:
+            curve.cleanup()
+        super().cleanup()

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

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+
+import pyqtgraph as pg
+from pydantic import BaseModel, Field
+from qtpy import QtCore
+
+from bec_widgets.utils import BECConnector, ConnectionConfig
+
+
+class SignalData(BaseModel):
+    """The data configuration of a signal in the 1D waveform widget for x and y axis."""
+
+    name: str
+    entry: str
+    unit: Optional[str] = None  # todo implement later
+    modifier: Optional[str] = None  # todo implement later
+    limits: Optional[list[float]] = None  # todo implement later
+
+
+class Signal(BaseModel):
+    """The configuration of a signal in the 1D waveform widget."""
+
+    source: str
+    x: SignalData  # TODO maybe add metadata for config gui later
+    y: SignalData
+    z: Optional[SignalData] = None
+
+
+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[Any] = Field(None, description="The color of the curve.")
+    symbol: Optional[str] = Field("o", description="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(
+        "solid", description="The style of the pen of the curve."
+    )
+    source: Optional[str] = Field(None, description="The source of the curve.")
+    signals: Optional[Signal] = Field(None, description="The signal of the curve.")
+    colormap: Optional[str] = Field("plasma", description="The colormap of the curves z gradient.")
+
+
+class BECCurve(BECConnector, pg.PlotDataItem):
+    USER_ACCESS = [
+        "remove",
+        "rpc_id",
+        "config_dict",
+        "set",
+        "set_data",
+        "set_color",
+        "set_colormap",
+        "set_symbol",
+        "set_symbol_color",
+        "set_symbol_size",
+        "set_pen_width",
+        "set_pen_style",
+        "get_data",
+    ]
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        config: Optional[CurveConfig] = None,
+        gui_id: Optional[str] = None,
+        parent_item: Optional[pg.PlotItem] = None,
+        **kwargs,
+    ):
+        if config is None:
+            config = CurveConfig(label=name, widget_class=self.__class__.__name__)
+            self.config = config
+        else:
+            self.config = config
+            # config.widget_class = self.__class__.__name__
+        super().__init__(config=config, gui_id=gui_id)
+        pg.PlotDataItem.__init__(self, name=name)
+
+        self.parent_item = parent_item
+        self.apply_config()
+        if kwargs:
+            self.set(**kwargs)
+
+    def apply_config(self):
+        pen_style_map = {
+            "solid": QtCore.Qt.SolidLine,
+            "dash": QtCore.Qt.DashLine,
+            "dot": QtCore.Qt.DotLine,
+            "dashdot": QtCore.Qt.DashDotLine,
+        }
+        pen_style = pen_style_map.get(self.config.pen_style, QtCore.Qt.SolidLine)
+
+        pen = pg.mkPen(color=self.config.color, width=self.config.pen_width, style=pen_style)
+        self.setPen(pen)
+
+        if self.config.symbol:
+            symbol_color = self.config.symbol_color or self.config.color
+            brush = pg.mkBrush(color=symbol_color)
+
+            self.setSymbolBrush(brush)
+            self.setSymbolSize(self.config.symbol_size)
+            self.setSymbol(self.config.symbol)
+
+    def set_data(self, x, y):
+        if self.config.source == "custom":
+            self.setData(x, y)
+        else:
+            raise ValueError(f"Source {self.config.source} do not allow custom data setting.")
+
+    def set(self, **kwargs):
+        """
+        Set the properties of the curve.
+
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+
+        Possible properties:
+            - color: str
+            - symbol: str
+            - symbol_color: str
+            - symbol_size: int
+            - pen_width: int
+            - pen_style: Literal["solid", "dash", "dot", "dashdot"]
+        """
+
+        # Mapping of keywords to setter methods
+        method_map = {
+            "color": self.set_color,
+            "colormap": self.set_colormap,
+            "symbol": self.set_symbol,
+            "symbol_color": self.set_symbol_color,
+            "symbol_size": self.set_symbol_size,
+            "pen_width": self.set_pen_width,
+            "pen_style": self.set_pen_style,
+        }
+        for key, value in kwargs.items():
+            if key in method_map:
+                method_map[key](value)
+            else:
+                print(f"Warning: '{key}' is not a recognized property.")
+
+    def set_color(self, color: str, symbol_color: Optional[str] = None):
+        """
+        Change the color of the curve.
+
+        Args:
+            color(str): Color of the curve.
+            symbol_color(str, optional): Color of the symbol. Defaults to None.
+        """
+        self.config.color = color
+        self.config.symbol_color = symbol_color or color
+        self.apply_config()
+
+    def set_symbol(self, symbol: str):
+        """
+        Change the symbol of the curve.
+
+        Args:
+            symbol(str): Symbol of the curve.
+        """
+        self.config.symbol = symbol
+        self.apply_config()
+
+    def set_symbol_color(self, symbol_color: str):
+        """
+        Change the symbol color of the curve.
+
+        Args:
+            symbol_color(str): Color of the symbol.
+        """
+        self.config.symbol_color = symbol_color
+        self.apply_config()
+
+    def set_symbol_size(self, symbol_size: int):
+        """
+        Change the symbol size of the curve.
+
+        Args:
+            symbol_size(int): Size of the symbol.
+        """
+        self.config.symbol_size = symbol_size
+        self.apply_config()
+
+    def set_pen_width(self, pen_width: int):
+        """
+        Change the pen width of the curve.
+
+        Args:
+            pen_width(int): Width of the pen.
+        """
+        self.config.pen_width = pen_width
+        self.apply_config()
+
+    def set_pen_style(self, pen_style: Literal["solid", "dash", "dot", "dashdot"]):
+        """
+        Change the pen style of the curve.
+
+        Args:
+            pen_style(Literal["solid", "dash", "dot", "dashdot"]): Style of the pen.
+        """
+        self.config.pen_style = pen_style
+        self.apply_config()
+
+    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.colormap = colormap
+
+    def get_data(self) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Get the data of the curve.
+        Returns:
+            tuple[np.ndarray,np.ndarray]: X and Y data of the curve.
+        """
+        x_data, y_data = self.getData()
+        return x_data, y_data
+
+    def remove(self):
+        """Remove the curve from the plot."""
+        self.parent_item.removeItem(self)
+        self.cleanup()