feat: added websitewidget

feat: added simple vscode widget
0.46.6
2026-04-13 20:20:55 +02:00 · 2024-04-23 09:23:17 +02:00 · 2024-04-21 10:08:44 +02:00 · 2024-04-19 16:51:51 +00:00 · 2024-04-19 18:18:25 +02:00 · 2024-04-19 13:34:44 +02:00
117 changed files with 11558 additions and 3425 deletions
--- a/.git_hooks/pre-commit
+++ b/.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')
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,10 +1,22 @@
 # 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.10
 #commands to run in the Docker container before starting each job.
 variables:
  DOCKER_TLS_CERTDIR: ""
+  BEC_CORE_BRANCH: "main"
+  OPHYD_DEVICES_BRANCH: "main"
+
+workflow:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+    - if: $CI_PIPELINE_SOURCE == "web"
+    - if: $CI_PIPELINE_SOURCE == "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
@@ -15,13 +27,15 @@ stages:
  - Formatter
  - test
  - AdditionalTests
+  - End2End
  - Deploy

 formatter:
  stage: Formatter
  needs: []
  script:
-    - pip install black
+    - pip install black isort
+    - isort --check --diff --line-length=100 --profile=black --multi-line=3 --trailing-comma ./
    - black --check --diff --color --line-length=100 ./
 pylint:
  stage: Formatter
@@ -77,10 +91,14 @@ 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 libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-    - pip install .[dev]
-    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e .[dev]
+    - 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+)?\%)$/'
@@ -91,35 +109,64 @@ tests:
        coverage_format: cobertura
        path: coverage.xml

-#tests-3.9-pyqt5: #todo enable when we decide what qt distributions we want to support
-#  extends: "tests"
-#  stage: AdditionalTests
-#  image: $CI_DOCKER_REGISTRY/python:3.9
-#  script:
-#    - apt-get update
-#    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-#    - pip install .[dev,pyqt5]
-#    - pytest -v --random-order ./tests
-
-tests-3.10:
-  extends: "tests"
-  stage: AdditionalTests
-  image: $CI_DOCKER_REGISTRY/python:3.10
-  allow_failure: true
-

 tests-3.11:
  extends: "tests"
  stage: AdditionalTests
-  image: $CI_DOCKER_REGISTRY/python:3.11
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
  allow_failure: true

 tests-3.12:
  extends: "tests"
  stage: AdditionalTests
-  image: $CI_DOCKER_REGISTRY/python:3.12
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.12
  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]
+    - 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_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"'
+    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
+

 semver:
  stage: Deploy
@@ -141,13 +188,14 @@ semver:
    - 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 publish -v DEBUG
+      -D version_variable=./setup.py:__version__
+      -D hvcs=gitlab
+      -D branch=main

  allow_failure: false
  rules:
-    - if: '$CI_COMMIT_REF_NAME == "master"'
+    - if: '$CI_COMMIT_REF_NAME == "main"'

 pages:
  stage: Deploy
@@ -158,6 +206,6 @@ pages:
    - if: '$CI_COMMIT_TAG != null'
      variables:
        TARGET_BRANCH: $CI_COMMIT_TAG
-    - if: '$CI_COMMIT_REF_NAME == "master"'
+    - if: '$CI_COMMIT_REF_NAME == "main"'
  script:
    - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/bec-widgets/253243/
--- a/.pylintrc
+++ b/.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.
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -9,7 +9,7 @@ version: 2
 build:
  os: ubuntu-20.04
  tools:
-    python: "3.9"
+    python: "3.10"

 # Build documentation in the docs/ directory with Sphinx
 sphinx:
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,274 @@

 <!--next-version-placeholder-->

+## v0.46.6 (2024-04-19)
+
+### Fix
+
+* **cli:** Fixed support for devices as cli input ([`1111610`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1111610f3206c5c46db6b4bd1e8827f1a4cd9e3f))
+
+## v0.46.5 (2024-04-19)
+
+### Fix
+
+* **widgets/figure:** Individual cleanup disabled, making stuck rpc ([`ff52100`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ff52100e234debdfb5ccc0869352cfafde52ac93))
+* **plots/waveform:** Colormap is correctly passed from BECFigure ([`026c079`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/026c0792bee25723013fffe57ccff10d9b652913))
+
+## v0.46.4 (2024-04-16)
+
+### Fix
+
+* Renaming of bec_client to bec_ipython_client ([`4da625e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4da625e4398bdd937c2b788592f15f7530148292))
+* **plots/motor_map:** User can get data as dict from BECMotorMap ([`c12f2ce`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c12f2cee80b13137a2b70e2d121a079e20d124e2))
+* **plots/image:** User can get data as np.ndarray from BECImageItem ([`c2c583f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c2c583fce6f28981990c504dd065705124e40e44))
+* **rpc/server:** Server can accept client or dispatcher ([`ecdf0f1`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ecdf0f122b628ee378b80793d498cedafe50fbf8))
+
+## v0.46.3 (2024-04-11)
+
+### Fix
+
+* **test_fake_redis:** TestMessage fixed to pydantic BaseModel ([`0b86a00`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0b86a0009d9366b710294a3ab55cb9f4894472c0))
+* **plots/motor_map:** Removed single callback flag for connecting device_readback motors ([`49327a8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/49327a8dbde270c67bc0ce7c757fd4a3eae118b4))
+* **cli/client_utils:** Print_log is buffered; add output processing thread ([`285bf01`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/285bf0164b6deb91678f03ab2a190680b6d83a02))
+* Producer->connector ([`9def373`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9def3734afb361ac2d5cc933661766cdc440e09d))
+
+## v0.46.2 (2024-04-10)
+
+### Fix
+
+* **widget/plots:** Added "get_config" to all children of `BECConnector` to USER_ACCESS ([`ee617b7`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ee617b73a2fcad8194394182fcecb0dd4f583a8e))
+
+## v0.46.1 (2024-04-10)
+
+### Fix
+
+* **rpc/client:** Correct name for RPC class BECWaveform (instead of BECWaveform1D) ([`cf29035`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cf29035e283e55efa547cbac88e8b622190dfc4d))
+
+## v0.46.0 (2024-04-09)
+
+### Feature
+
+* **plot/waveform1d:** BECWaveform1D can show z data of scatter coded to different detector like BECMonitor2DScatter; BECWaveform1D name changed to BECWaveform ([`3d399ba`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3d399ba1f5d85bc67964febcf8921355f9f1c285))
+
+## v0.45.0 (2024-03-26)
+
+### Feature
+
+* **plots/bec_figure:** Motor Map integrated to BECFigure ([`b8519e8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b8519e8770f8ffc46a1255c18119fc7978ff1d39))
+* **plots/bec_motor_map:** BECMotorMap build on BECPlotBase ([`0f69c34`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0f69c346cd24b7afcd23f444525a170e062b0368))
+
+### Documentation
+
+* Added api reference; closes #123 ([`88014d2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/88014d24c1c272a6deea7436a6fa058bdb06fb57))
+
+## v0.44.5 (2024-03-25)
+
+### Fix
+
+* Circular imports ([`c5826f8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c5826f8887ed44d15d05c8ed0e337080b3146c5a))
+
+## v0.44.4 (2024-03-22)
+
+### Fix
+
+* **cli/server:** Thread heartbeat replaced with QTimer ([`e6b0657`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/e6b065767c8605aaef6ed6032ba893d3900b552c))
+* **cli/server:** Removed BECFigure.start(), the QApplication event loop is started by server.py ([`f3a96de`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f3a96dedd7ba49f9a1b713f6a5565f2b3dbb141e))
+
+## v0.44.3 (2024-03-21)
+
+### Fix
+
+* **cli:** Don't call user script if gui is not alive ([`a92aead`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a92aead7698fa98d6f7f582d030845d0b940ea2d))
+* **cli:** Added gui heartbeat ([`882cf55`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/882cf55fc5266a2cfb610702e834badff3ad0428))
+
+## v0.44.2 (2024-03-20)
+
+### Fix
+
+* **utils/bec_dispatcher:** Try/except to start client, to avoid crash when redis is not running ([`9ccd4ea`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9ccd4ea235be4c4332045b7a7f09d6cc6291f7ff))
+* **utils/bec_dispatcher:** Bec_dispatcher adjusted to the new BECClient; dropped support to inject bec_config.yaml, instead BECClient can be passed as arg ([`86416d5`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/86416d50cb850b42d312fe17fc46f0b4743dc940))
+
+## v0.44.1 (2024-03-19)
+
+### Fix
+
+* **examples/motor_compilation:** Motor_control_compilations.py do not have any hardcoded config anymore ([`14f901f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/14f901f1bea2ba7b79903c4743e37384e11533d3))
+
+## v0.44.0 (2024-03-18)
+
+### Feature
+
+* **cli:** Added update script to BECFigure ([`9049e0d`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9049e0d27fe9a3860e21ffc3b350eb69e567b71c))
+
+### Fix
+
+* **cli:** Removed hard-coded signal ([`203ae09`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/203ae0960688608fb609a742a23e5994bfe9805c))
+* **cli:** Fixed cleanup procedure ([`2d39c5e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/2d39c5e4d18bbb66a5f3340fce7f8944dd4ba19f))
+
+## v0.43.2 (2024-03-18)
+
+### Fix
+
+* **cli/server:** Added QApplications to enter separate QT event loop ensuring that QT objects are not deleted ([`d0f9bf1`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d0f9bf17339296a60301e5e6ffe602db369c6c7c))
+
+## v0.43.1 (2024-03-15)
+
+### Fix
+
+* **plots/image:** Same access pattern for image and image_item for setting up parameters, autorange of z scale disabled by default ([`b8d4e69`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b8d4e697ac2a5929a1374ce1778046efc3f8187a))
+* **widget/various:** Corrected USER_ACCESS methods for children widgets to include inherited methods to RPC ([`4664661`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4664661cfb4e8bd4a6adb71f2050b25d0b4f3d36))
+* **widgets/figure:** Added widgets can be accessed as a list (fig.axes) or as a dictionary (fig.widgets) ([`fcf918c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/fcf918c48862d069b9fe69cbba7dbecbe7429790))
+
+## v0.43.0 (2024-03-14)
+
+### Feature
+
+* **plots/image:** Image processor can run in threaded or non-threaded version ([`4865b10`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4865b10ced6b321974e7b4b4db12786fe21fd916))
+* **plots/image:** Change stream processor to QThread with connector.get_last; cleanup method for BECFigure to kill all threads if App is closed during acquisition ([`7ffedd9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/7ffedd9cebb382fc22f24a6b0b46823db6378d89))
+* **plots/image:** Basic image visualisation, getting data are based on stream_connector (deprecated) ([`9ad0055`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9ad0055336dba50886504a616db6f9f63b23beb3))
+
+### Fix
+
+* **plots/waveform1d:** Curves_data access disabled ([`598479b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/598479bb555a6cd077d5a137052d91314e5af6b7))
+* **cli:** Find_widget_by_id for BECImageShow changed to be compatible with RPC logic ([`4ef6ae9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4ef6ae90f2afd5e2442465c11ce5165517cd4218))
+* **plots/image:** Access pattern for ImageItems in BECImageShow ([`3362fab`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3362fabed7ccd611b35f524c1970aeefbf3a9faf))
+* **cli:** Fix cli connector.send to set_and_publish for gui_instruction_response ([`4076698`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/407669853097b40e6fba7d43da001f083140ad74))
+
+## v0.42.1 (2024-03-10)
+
+### Fix
+
+* **various:** Repo cleanup, removed - [plot_app, one_plot, scan_plot, scan2d_plot, crosshair_example, qtplugins], tests adjusted ([`f3b3c2f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f3b3c2f526d66687b3cc596a5877921953dd0803))
+
+## v0.42.0 (2024-03-07)
+
+### Feature
+
+* **utils/bec_dispatcher:** BECDispatcher can register redis stream ([`4c0a7bb`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4c0a7bbec7abafc7d04a8aaf10dabd7e668fa908))
+
+## v0.41.4 (2024-03-07)
+
+### Fix
+
+* **utils/bec_dispatcher:** BECDispatcher can accept new EndpointInfo dataclass. ([`c319dac`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c319dacb24e64930af258a81484feeadcb1bc341))
+
+## v0.41.3 (2024-03-01)
+
+### Fix
+
+* **cli/generate_cli:** Typing.get_overloads are only used if the python version is higher than 3.11 ([`f386563`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f386563aa162eaca9202af16574860bf3eb5a092))
+* **cli/generate_cli:** Added automatic black formatting; added black as a dependency ([`d89f596`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d89f596a5d0f0674b1ef3268a9cfee5e32b64ba5))
+
+## v0.41.2 (2024-02-28)
+
+### Fix
+
+* **utils/bec_dispatcher:** Msg is unp[acked from dict before accessing .content ([`bb1f066`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/bb1f066c3c5e5076a8906e309030cfb47a6cad12))
+
+## v0.41.1 (2024-02-26)
+
+### Fix
+
+* **bec_dispatcher:** Handle redis connection errors more gracefully ([`a2ed2eb`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a2ed2ebe00c623eb183b03f8182ffd672fbf9e1e))
+* **bec_dispatcher:** Adapt code to redis connector refactoring ([`8127fc2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/8127fc2960bebd3e862dbe55ac9401af4a6dccb6))
+
+## v0.41.0 (2024-02-26)
+
+### Feature
+
+* **widgets/waveform1d:** Data can be exported from rendered curve ([`5fc8047`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/5fc8047c8ff971cdc2807d02743eae56d288f4d7))
+* **widgets/figure:** Clear_all method for BECFigure ([`0363fd5`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0363fd5194320a7ea868ef883f8022ea464d0298))
+* **widgets/Waveform1D:** Waveform1D can be fully constructed by config ([`9a5c86e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9a5c86ea35178b9cab270fc35e668dd22f3ec8da))
+* **widgets/figure.py:** Dark/light theme changer ([`08534a4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/08534a4739ec8e85d82a00ab639411dd0198e9d8))
+* **utils/entry_validator:** Possibility to validate add_scan_curve with current BEC session ([`1db77b9`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1db77b969bcf9b38716ae3d38bf4695b2b8c1f37))
+* **cli:** Added cli interface, rebased ([`a61bf36`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a61bf36df5d54ad44f78479c2474c4e38e68ed26))
+* Curve can be modified after adding to the plot ([`684592a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/684592ae37e9dd5328a96018c78ca242e10395b2))
+* Waveform1d.py curves can be removed by identifier by order(int) or by curve_id(str) ([`f0ed243`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f0ed243c9197b7d1aab0d99a15e9ba175708ec90))
+* Waveform1d.py curves can be stylised; access scan history by index or scanID ([`cba3863`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/cba3863e5a9ac1187ea643be67db6cfc36b44ee2))
+* Start method for BECFigure, jupyter console .ui added to git ([`1d26b23`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1d26b2322147d9ea5a6a245e1648c00986f80881))
+* Added @user_access from bec_lib.utils ([`b827e9e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b827e9eaa77f8b64433bb7a54e40ab5ccd86f4b6))
+* Plot can be removed from BECFigure ([`60d150a`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/60d150a41193aa7659285cf3612965f1a3c57244))
+* Figure.py create widget factory ([`c781b1b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c781b1b4e4121c4ec6fc8871a4cdf6f494913138))
+* Waveform1d.py draft ([`565e475`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/565e475ace72ccc103d71ea98af1dcaf04f37861))
+* Rpc decorator to add methods to USER_ACCESS ([`b676877`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b6768772424a3ad5ee7e271de19131f8065eef09))
+* BECFigure and BECPlotBase created ([`9ef331c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/9ef331c272b88f725de9b8497fdf906056c0738b))
+* BECConnector -> mixin class for all BEC Widget to hook them to BEC client ([`91447a2`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/91447a2d6234de1e8f2bac792e822bfda556abba))
+
+### Fix
+
+* **cli/client_utils:** "__rpc__" pop from msg_results ([`ebb36f6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ebb36f62ddc1c5013435f9e7727648b977b6b732))
+* **tests:** BECDispatcher fixture putted back ([`644f103`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/644f1031f6ff27064111565b0882cb8b2544aa2f))
+* **cli/rpc:** Rpc client can return any type of object + config dict of the widgets ([`fd711b4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/fd711b475f268fbdb59739da0a428f0355b25bac))
+* **cli/rpc:** Server access children widget.find_widget_by_id(gui_id) ([`57132a4`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/57132a472165c55bf99e1994d09f5fe3586c24da))
+* **cli:** Fixed property access, rebased ([`f71dc5c`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f71dc5c5abdd6b8b585cb9b502b11ef513d7813e))
+* **rpc_server:** Fixed gui_id lookup ([`4630d78`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/4630d78fc28109da7daf53e49dd3cdb9b8084941))
+* **cli:** Fixed rpc construction of nested widgets ([`da640e8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/da640e888d575b536fdd5d7adbf1df3eda802219))
+* **plots/waveform1d:** Pandas import clean up, export curves with none skipped ([`35cd4fd`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/35cd4fd6f176ba670fad5d9fec44b305094280d6))
+* **widgets/plots:** Added placeholder for cleanup method to BECPlotBase ([`24c7737`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/24c77376b232c3846a1d6be360ec46acc077b48d))
+* **widget/figure:** Add cleanup method to disconnect all slots before removing Waveform1D from layout ([`a28b9c8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/a28b9c8981d1058e4dc4146463f16c53413e8db9))
+* **rpc:** Added annotations to pass py3.9 tests ([`c6bdf0b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/c6bdf0b6a5b12c054863b101a3944efc366686cb))
+* **rpc:** Connection to on_rpc_update done through bec_dispatcher ([`1c2fb8b`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/1c2fb8b972d4cb28cead11989461aea010c4571d))
+* After removing plot from BECFigure, the coordinates are correctly resigned ([`d678a85`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/d678a85957c13c1fda2b52692c0d3b9b7ff40834))
+* Removed DI references, fixed set when adding plot by fig ([`7c15d75`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/7c15d750117aec9e75111853074630a44dca87ae))
+
+## v0.40.1 (2024-02-23)
+
+### Fix
+
+* **utils/bec_dispatcher:** _do_disconnect_slot will shutdown consumer of slots/signals which were already disconnected ([`feca7a3`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/feca7a3dcde6d0befa415db64fc8f9bbf0c06e52))
+
+## v0.40.0 (2024-02-16)
+
+### Feature
+
+* **utils.colors:** Golden_angle_color utility can return colors as a  list of QColor, RGB or HEC ([`5125909`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/51259097fa23ff861eac3f7c63624ea591bf1bd3))
+
+## v0.39.0 (2024-02-12)
+
+### Feature
+
+* Added full app with all motor movement related widgets into motor_control_compilations.py ([`fa4ca93`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/fa4ca935bb39fdba4c6500ce9569d47400190e65))
+* MotorCoordinateTable mode_switch added for "Individual" and "Start/Stop" modes ([`2f96e10`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/2f96e10b9deb76eedd8f6b6e201ba3b0e526a6f0))
+* Motor_control.py MotorCoordinateTable added basic version to store coordinates and show them in motor_map.py ([`031cb09`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/031cb094e7f8a7be4a295bea99b7ca8e095db8d7))
+* Active motors from motor_map.py can be changed by slot without changing the whole config ([`17f1458`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/17f14581d7c4662a2f5814ea477dfae8ef6de555))
+* Control panels compilations ([`8361736`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/83617366796ce2926650e38a1a9cec296befd3c6))
+* Comboboxes of motor selection are changed to orange if the motors are not connected yet ([`0b9927f`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/0b9927fcf5f46410d05187b2e5a83f97a6ca9246))
+* Motor_control.py MotorControl widgets - Absolute + Relative movement, MotorSelection, ErrorMessage popups ([`6fe08e6`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/6fe08e6b8206bcaaa292b7ff0e6b0d32b883f24f))
+
+## v0.38.2 (2024-02-07)
+
+### Fix
+
+* Adapt code to BEC 1.0 ([`b36131e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/b36131eed5c3a3ea58c0fa4d083e63a3717cdf22))
+
+## v0.38.1 (2024-01-26)
+
+### Fix
+
+* Monitor.py replots last scan after changing config with new signals; config_dialog.py checks if the new config is valid with BEC ([`ab275b8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/ab275b8e5f226d6c5d22a844c4c0fae0fdc66108))
+
+### Documentation
+
+* 2D waveform scatter plot changed to 2D scatter plot ([`812ffaf`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/812ffaf8eafc3f8c3a6973717149e4befba2c395))
+* Documentation for example apps and widgets updated ([`f7a4967`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/f7a496723c3fd113867a712928e06636e3212e1a))
+
+## v0.38.0 (2024-01-23)
+
+### Feature
+
+* BECMonitor2DScatter for plotting x/y/z signal as a mesh of scatter plot ([`75090b8`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/75090b857526fa642218986806d0daeb1dec0914))
+
+### Fix
+
+* Monitor_scatter_2D.py changed to new BECDispatcher definition ([`747e97e`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/747e97e0c924cdedb85e9fe7d47512002b791b10))
+
+## v0.37.1 (2024-01-23)
+
+### Fix
+
+* **tests:** Ensure BEC service is shutdown after bec dispatcher test ([`4664568`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/46645686725a2acb7196dbd1a504c98dbf2e4b5d))
+* **tests:** Ensure threads started during plot tests are properly stopped ([`3fb6644`](https://gitlab.psi.ch/bec/bec-widgets/-/commit/3fb6644543b4065236216b70a583641956a09a60))
+
 ## v0.37.0 (2024-01-17)

 ### Feature
--- a/bec_widgets/cli/init.py
+++ b/bec_widgets/cli/init.py
@@ -0,0 +1 @@
+from .client import BECFigure
--- a/bec_widgets/cli/client.py
+++ b/bec_widgets/cli/client.py
--- a/bec_widgets/cli/client_utils.py
+++ b/bec_widgets/cli/client_utils.py
@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import importlib
+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 import MessageEndpoints, messages
+from bec_lib.connector import MessageObject
+from bec_lib.device import DeviceBase
+from qtpy.QtCore import QCoreApplication
+
+import bec_widgets.cli.client as client
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+if TYPE_CHECKING:
+    from bec_widgets.cli.client import BECFigure
+
+
+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
+
+
+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 update_script(figure: BECFigure, msg):
+    """
+    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]
+
+    if scan_name == "line_scan" and scan_report_devices:
+        dev_x = scan_report_devices[0]
+        dev_y = get_selected_device(monitored_devices, figure.selected_device)
+        print(f"Selected device: {dev_y}")
+        if not dev_y:
+            return
+        figure.clear_all()
+        plt = figure.plot(dev_x, dev_y)
+        plt.set(title=f"Scan {scan_number}", x_label=dev_x, y_label=dev_y)
+    elif scan_name == "grid_scan" and scan_report_devices:
+        print(f"Scan {scan_number} is running")
+        dev_x = scan_report_devices[0]
+        dev_y = scan_report_devices[1]
+        dev_z = get_selected_device(monitored_devices, figure.selected_device)
+        figure.clear_all()
+        plt = figure.plot(dev_x, dev_y, dev_z, label=f"Scan {scan_number}")
+        plt.set(title=f"Scan {scan_number}", x_label=dev_x, y_label=dev_y)
+    elif scan_report_devices:
+        dev_x = scan_report_devices[0]
+        dev_y = get_selected_device(monitored_devices, figure.selected_device)
+        if not dev_y:
+            return
+        figure.clear_all()
+        plt = figure.plot(dev_x, dev_y, label=f"Scan {scan_number}")
+        plt.set(title=f"Scan {scan_number}", x_label=dev_x, y_label=dev_y)
+
+
+class BECFigureClientMixin:
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._process = None
+        self.update_script = update_script
+        self._target_endpoint = MessageEndpoints.scan_status()
+        self._selected_device = None
+        self.stderr_output = []
+
+    @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(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: BECFigureClientMixin) -> 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
+            if msg.status == "open":
+                self.update_script(self, 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
+        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
+        monitor_module = importlib.import_module("bec_widgets.cli.server")
+        monitor_path = monitor_module.__file__
+
+        command = [sys.executable, "-u", monitor_path, "--id", self._gui_id]
+        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:
+        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:
+                # print("*"*10, self._process.stdout.read(1024), flush=True, end="")
+                self._process.stdout.read(1024)
+            if self._process.stderr in readylist:
+                # print("!"*10, self._process.stderr.read(1024), flush=True, end="", file=sys.stderr)
+                print(self._process.stderr.read(1024), flush=True, end="", file=sys.stderr)
+                self.stderr_output.append(self._process.stderr.read(1024))
+
+
+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},
+        )
+        # print(f"RPCBase: {rpc_msg}")
+        # 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):
+        """
+        Wait for the response from the server.
+        """
+        response = None
+        while response is None and self.gui_is_alive():
+            response = self._client.connector.get(
+                MessageEndpoints.gui_instruction_response(request_id)
+            )
+            QCoreApplication.processEvents()  # keep UI responsive (and execute signals/slots)
+        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
--- a/bec_widgets/cli/generate_cli.py
+++ b/bec_widgets/cli/generate_cli.py
@@ -0,0 +1,130 @@
+# 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, BECFigureClientMixin
+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__ == "BECFigure":
+            self.content += f"""
+class {class_name}(RPCBase, BECFigureClientMixin):"""
+        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.figure import BECFigure
+    from bec_widgets.widgets.plots import BECImageShow, BECMotorMap, BECPlotBase, BECWaveform
+    from bec_widgets.widgets.plots.image import BECImageItem
+    from bec_widgets.widgets.plots.waveform import BECCurve
+
+    current_path = os.path.dirname(__file__)
+    client_path = os.path.join(current_path, "client.py")
+    clss = [
+        BECPlotBase,
+        BECWaveform,
+        BECFigure,
+        BECCurve,
+        BECImageShow,
+        BECConnector,
+        BECImageItem,
+        BECMotorMap,
+    ]
+    generator = ClientGenerator()
+    generator.generate_client(clss)
+    generator.write(client_path)
--- a/bec_widgets/cli/server.py
+++ b/bec_widgets/cli/server.py
@@ -0,0 +1,137 @@
+import inspect
+
+from bec_lib import MessageEndpoints, messages
+from qtpy.QtCore import QTimer
+
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.widgets.figure import BECFigure
+from bec_widgets.widgets.plots import BECCurve, BECImageShow, BECWaveform
+
+
+class BECWidgetsCLIServer:
+    WIDGETS = [BECWaveform, BECFigure, BECCurve, BECImageShow]
+
+    def __init__(self, gui_id: str = None, dispatcher: BECDispatcher = None, client=None) -> None:
+        self.dispatcher = BECDispatcher() 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.fig = BECFigure(gui_id=self.gui_id)
+
+        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(1000)  # Emit heartbeat every 1 seconds
+
+    def on_rpc_update(self, msg: dict, metadata: dict):
+        request_id = metadata.get("request_id")
+        try:
+            method = msg["action"]
+            args = msg["parameter"].get("args", [])
+            kwargs = msg["parameter"].get("kwargs", {})
+            obj = self.get_object_from_config(msg["parameter"])
+            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")
+        # check if the object is the figure
+        if gui_id == self.fig.gui_id:
+            return self.fig
+        # check if the object is a widget
+        if gui_id in self.fig._widgets:
+            obj = self.fig._widgets[config["gui_id"]]
+            return obj
+        if self.fig._widgets:
+            for widget in self.fig._widgets.values():
+                item = widget.find_widget_by_id(gui_id)
+                if item:
+                    return item
+
+        raise ValueError(f"Object with gui_id {gui_id} not found")
+
+    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,
+            )
+        print("Heartbeat emitted")
+
+    def shutdown(self):
+        self._shutdown_event = True
+        self._heartbeat_timer.stop()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import argparse
+    import sys
+
+    from qtpy.QtWidgets import QApplication, QMainWindow
+
+    app = QApplication(sys.argv)
+    app.setApplicationName("BEC Figure")
+    win = QMainWindow()
+
+    parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
+    parser.add_argument("--id", type=str, help="The id of the server")
+
+    args = parser.parse_args()
+
+    server = BECWidgetsCLIServer(gui_id=args.id)
+    # server = BECWidgetsCLIServer(gui_id="test")
+
+    fig = server.fig
+    win.setCentralWidget(fig)
+    win.show()
+
+    app.aboutToQuit.connect(server.shutdown)
+    sys.exit(app.exec())
--- a/bec_widgets/examples/init.py
+++ b/bec_widgets/examples/init.py
@@ -0,0 +1,9 @@
+from .motor_movement import (
+    MotorControlApp,
+    MotorControlMap,
+    MotorControlPanel,
+    MotorControlPanelAbsolute,
+    MotorControlPanelRelative,
+    MotorCoordinateTable,
+    MotorThread,
+)
--- a/bec_widgets/examples/crosshair_example/crosshair_example.py
+++ b/bec_widgets/examples/crosshair_example/crosshair_example.py
@@ -1,168 +0,0 @@
-import numpy as np
-import pyqtgraph as pg
-from qtpy.QtWidgets import (
-    QApplication,
-    QVBoxLayout,
-    QLabel,
-    QWidget,
-    QHBoxLayout,
-    QTableWidget,
-    QTableWidgetItem,
-    QSpinBox,
-)
-from pyqtgraph import mkPen
-from pyqtgraph.Qt import QtCore
-from bec_widgets.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()
--- a/bec_widgets/examples/eiger_plot/eiger_plot.py
+++ b/bec_widgets/examples/eiger_plot/eiger_plot.py
@@ -6,20 +6,11 @@ import h5py
 import numpy as np
 import pyqtgraph as pg
 import zmq
+from pyqtgraph.Qt import uic
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtGui import QKeySequence
-from qtpy.QtWidgets import (
-    QWidget,
-    QFileDialog,
-    QShortcut,
-    QDialog,
-    QVBoxLayout,
-    QLabel,
-    QFrame,
-)
-from pyqtgraph.Qt import uic
-
+from qtpy.QtWidgets import QDialog, QFileDialog, QFrame, QLabel, QShortcut, QVBoxLayout, QWidget

 # from scipy.stats import multivariate_normal

@@ -47,7 +38,13 @@ class EigerPlot(QWidget):
        self.key_bindings()

        # ZMQ Consumer
-        self.start_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
@@ -182,25 +179,36 @@ class EigerPlot(QWidget):
    ###############################

    def start_zmq_consumer(self):
-        consumer_thread = threading.Thread(target=self.zmq_consumer, daemon=True).start()
+        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):
-        try:
-            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, "")
+    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)

-            while True:
-                raw_meta, raw_data = receiver.recv_multipart()
                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

-        finally:
-            receiver.disconnect(live_stream_url)
-            receiver.context.term()
+        receiver.disconnect(live_stream_url)

    ###############################
    # just simulations from here
@@ -290,6 +298,7 @@ class EigerPlot(QWidget):

 if __name__ == "__main__":
    import sys
+
    from qtpy.QtWidgets import QApplication

    app = QApplication(sys.argv)
--- a/bec_widgets/examples/crosshair_example/init.py
+++ b/bec_widgets/examples/crosshair_example/init.py
--- a/bec_widgets/examples/jupyter_console/jupyter_console_window.py
+++ b/bec_widgets/examples/jupyter_console/jupyter_console_window.py
@@ -0,0 +1,102 @@
+import os
+
+import numpy as np
+import pyqtgraph as pg
+from pyqtgraph.Qt import uic
+from qtconsole.inprocess import QtInProcessKernelManager
+from qtconsole.rich_jupyter_widget import RichJupyterWidget
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.widgets import BECFigure
+
+
+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__)
+        uic.loadUi(os.path.join(current_path, "jupyter_console_window.ui"), self)
+
+        self._init_ui()
+
+        self.splitter.setSizes([200, 100])
+        self.safe_close = False
+        # self.figure.clean_signal.connect(self.confirm_close)
+
+        # console push
+        self.console.kernel_manager.kernel.shell.push(
+            {
+                "fig": self.figure,
+                "w1": self.w1,
+                "w2": self.w2,
+                "w3": self.w3,
+                "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.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
+
+        # add stuff to figure
+        self._init_figure()
+
+        self.console_layout = QVBoxLayout(self.widget_console)
+        self.console = JupyterConsoleWidget()
+        self.console_layout.addWidget(self.console)
+        self.console.set_default_style("linux")
+
+    def _init_figure(self):
+        self.figure.plot("samx", "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()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    bec_dispatcher = BECDispatcher()
+    client = bec_dispatcher.client
+    client.start()
+
+    app = QApplication(sys.argv)
+    app.setApplicationName("Jupyter Console")
+    win = JupyterConsoleWindow()
+    win.show()
+
+    sys.exit(app.exec_())
--- a/bec_widgets/examples/jupyter_console/jupyter_console_window.ui
+++ b/bec_widgets/examples/jupyter_console/jupyter_console_window.ui
@@ -0,0 +1,30 @@
+<?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">
+   <item>
+    <widget class="QSplitter" name="splitter">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <widget class="QWidget" name="glw" native="true"/>
+     <widget class="QWidget" name="widget_console" native="true"/>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
--- a/bec_widgets/examples/mca_readout/mca_plot.py
+++ b/bec_widgets/examples/mca_readout/mca_plot.py
@@ -1,19 +1,15 @@
 # import simulation_progress as SP
 import numpy as np
 import pyqtgraph as pg
-from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
-from qtpy.QtWidgets import (
-    QApplication,
-    QVBoxLayout,
-    QWidget,
-)
-
 from bec_lib import MessageEndpoints, messages
+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_scanID = pyqtSignal(str)
+    new_scan_id = pyqtSignal(str)

    def __init__(self, device, sub_device):
        super().__init__()
@@ -23,7 +19,7 @@ class StreamApp(QWidget):
        self.setWindowTitle("MCA readout")

        self.data = None
-        self.scanID = None
+        self.scan_id = None
        self.stream_consumer = None

        self.device = device
@@ -33,7 +29,7 @@ class StreamApp(QWidget):

        # self.start_device_consumer(self.device)  # for simulation

-        self.new_scanID.connect(self.create_new_stream_consumer)
+        self.new_scan_id.connect(self.create_new_stream_consumer)
        self.update_signal.connect(self.plot_new)

    def init_ui(self):
@@ -64,17 +60,17 @@ class StreamApp(QWidget):
        # self.glw.addItem(self.hist)

    @pyqtSlot(str)
-    def create_new_stream_consumer(self, scanID: str):
-        print(f"Creating new stream consumer for scanID: {scanID}")
+    def create_new_stream_consumer(self, scan_id: str):
+        print(f"Creating new stream consumer for scan_id: {scan_id}")

-        self.connect_stream_consumer(scanID, self.device)
+        self.connect_stream_consumer(scan_id, self.device)

-    def connect_stream_consumer(self, scanID, 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(scanID=scanID, device=device),
+            topics=MessageEndpoints.device_async_readback(scan_id=scan_id, device=device),
            cb=self._streamer_cb,
            parent=self,
        )
@@ -102,7 +98,7 @@ class StreamApp(QWidget):

    @staticmethod
    def _streamer_cb(msg, *, parent, **_kwargs) -> None:
-        msgMCS = messages.DeviceMessage.loads(msg.value)
+        msgMCS = msg.value
        print(msgMCS)
        row = msgMCS.content["signals"][parent.sub_device]
        metadata = msgMCS.metadata
@@ -123,26 +119,27 @@ class StreamApp(QWidget):
    def _device_cv(msg, *, parent, **_kwargs) -> None:
        print("Getting ScanID")

-        msgDEV = messages.ScanStatusMessage.loads(msg.value)
+        msgDEV = msg.value

-        current_scanID = msgDEV.content["scanID"]
+        current_scan_id = msgDEV.content["scan_id"]

-        if parent.scanID is None:
-            parent.scanID = current_scanID
-            parent.new_scanID.emit(current_scanID)
-            print(f"New scanID: {current_scanID}")
+        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_scanID != parent.scanID:
-            parent.scanID = current_scanID
+        if current_scan_id != parent.scan_id:
+            parent.scan_id = current_scan_id
            # parent.data = None
            # parent.imageItem.clear()
-            parent.new_scanID.emit(current_scanID)
+            parent.new_scan_id.emit(current_scan_id)

-            print(f"New scanID: {current_scanID}")
+            print(f"New scan_id: {current_scan_id}")


 if __name__ == "__main__":
    import argparse
+
    from bec_lib import RedisConnector

    parser = argparse.ArgumentParser(description="Stream App.")
--- a/bec_widgets/examples/mca_readout/mca_sim.py
+++ b/bec_widgets/examples/mca_readout/mca_sim.py
@@ -1,32 +1,24 @@
-from bec_lib import messages, MessageEndpoints, RedisConnector
 import time

+from bec_lib import MessageEndpoints, RedisConnector, messages
+
 connector = RedisConnector("localhost:6379")
-producer = connector.producer()
 metadata = {}

-scanID = "ScanID1"
+scan_id = "ScanID1"

 metadata.update(
-    {
-        "scanID": scanID,  # this will be different for each scan
-        "async_update": "append",
-    }
+    {"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()
+    msg = messages.DeviceMessage(signals=data, metadata=metadata).dumps()

-    # producer.send(topic=MessageEndpoints.device_status(device="mca"), msg=msg)
-
-    producer.xadd(
+    connector.xadd(
        topic=MessageEndpoints.device_async_readback(
-            scanID=scanID, device="mca"
-        ),  # scanID will be different for each scan
-        msg={"data": msg},
+            scan_id=scan_id, device="mca"
+        ),  # scan_id will be different for each scan
+        msg={"data": msg},  # TODO should be msg_dict
        expire=1800,
    )

--- a/bec_widgets/examples/modular_app/modular_app.py
+++ b/bec_widgets/examples/modular_app/modular_app.py
@@ -1,8 +1,9 @@
 import os

 from qtpy import uic
-from qtpy.QtWidgets import QMainWindow, QApplication
+from qtpy.QtWidgets import QApplication, QMainWindow

+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 from bec_widgets.widgets import BECMonitor

 # some default configs for demonstration purposes
@@ -166,7 +167,7 @@ class ModularApp(QMainWindow):
        super(ModularApp, self).__init__(parent)

        # Client and device manager from BEC
-        self.client = bec_dispatcher.client if client is None else client
+        self.client = BECDispatcher().client if client is None else client

        # Loading UI
        current_path = os.path.dirname(__file__)
@@ -187,10 +188,8 @@ class ModularApp(QMainWindow):


 if __name__ == "__main__":
-    from bec_widgets.utils.bec_dispatcher import bec_dispatcher
-
    # BECclient global variables
-    client = bec_dispatcher.client
+    client = BECDispatcher().client
    client.start()

    app = QApplication([])
--- a/bec_widgets/examples/motor_movement/init.py
+++ b/bec_widgets/examples/motor_movement/init.py
@@ -0,0 +1,9 @@
+from .motor_control_compilations import (
+    MotorControlApp,
+    MotorControlMap,
+    MotorControlPanel,
+    MotorControlPanelAbsolute,
+    MotorControlPanelRelative,
+    MotorCoordinateTable,
+    MotorThread,
+)
--- a/bec_widgets/examples/motor_movement/motor_control_compilations.py
+++ b/bec_widgets/examples/motor_movement/motor_control_compilations.py
@@ -0,0 +1,255 @@
+# 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 import (
+    MotorControlAbsolute,
+    MotorControlRelative,
+    MotorControlSelection,
+    MotorCoordinateTable,
+    MotorMap,
+    MotorThread,
+)
+
+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)
+
+        # Set the window to a fixed size based on its contents
+        self.layout().setSizeConstraint(layout.SetFixedSize)
+
+
+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)
+
+        # Set the window to a fixed size based on its contents
+        self.layout().setSizeConstraint(layout.SetFixedSize)
+
+
+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())
--- a/bec_widgets/examples/motor_movement/motor_controller.ui
+++ b/bec_widgets/examples/motor_movement/motor_controller.ui
@@ -883,7 +883,7 @@
         </column>
         <column>
          <property name="text">
-           <string>scanID</string>
+           <string>scan_id</string>
          </property>
         </column>
         <column>
--- a/bec_widgets/examples/motor_movement/motor_example.py
+++ b/bec_widgets/examples/motor_movement/motor_example.py
@@ -5,29 +5,28 @@ from functools import partial

 import numpy as np
 import pyqtgraph as pg
+from bec_lib import MessageEndpoints, messages
+from pyqtgraph.Qt import QtCore, QtWidgets, uic
 from qtpy import QtGui
-from qtpy.QtCore import QThread, Slot as pyqtSlot
-from qtpy.QtCore import Signal as pyqtSignal, Qt
-from qtpy.QtGui import QDoubleValidator
-from qtpy.QtGui import QKeySequence
+from qtpy.QtCore import Qt, QThread
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtGui import QDoubleValidator, QKeySequence
 from qtpy.QtWidgets import (
    QApplication,
-    QWidget,
-    QFileDialog,
    QDialog,
-    QVBoxLayout,
-    QLabel,
-    QPushButton,
+    QFileDialog,
    QFrame,
+    QLabel,
+    QMessageBox,
+    QPushButton,
+    QShortcut,
+    QVBoxLayout,
+    QWidget,
 )
-from qtpy.QtWidgets import QMessageBox
-from qtpy.QtWidgets import QShortcut
-from pyqtgraph.Qt import QtWidgets, uic, QtCore

-from bec_lib import MessageEndpoints, messages
 from bec_widgets.utils import DoubleValidationDelegate

-
 # TODO - General features
 #  - put motor status (moving, stopped, etc)
 #  - add mouse interactions with the plot -> click to select coordinates, double click to move?
@@ -1297,7 +1296,7 @@ class MotorControl(QThread):

    @staticmethod
    def _device_status_callback_motors(msg, *, parent, **_kwargs) -> None:
-        deviceMSG = messages.DeviceMessage.loads(msg.value)
+        deviceMSG = msg.value
        if parent.motor_x.name in deviceMSG.content["signals"]:
            parent.current_x = deviceMSG.content["signals"][parent.motor_x.name]["value"]
        elif parent.motor_y.name in deviceMSG.content["signals"]:
@@ -1306,9 +1305,9 @@ class MotorControl(QThread):


 if __name__ == "__main__":
-    import yaml
    import argparse

+    import yaml
    from bec_lib import BECClient, ServiceConfig

    parser = argparse.ArgumentParser(description="Motor App")
--- a/bec_widgets/examples/oneplot/config_gaussworker.yaml
+++ b/bec_widgets/examples/oneplot/config_gaussworker.yaml
@@ -1,3 +0,0 @@
-x_value: "samx"
-y_values: ["gauss_bpm", "gauss_adc1", "gauss_adc2"]
-dap_worker: "gaussian_fit_worker_3"
--- a/bec_widgets/examples/oneplot/config_noworker.yaml
+++ b/bec_widgets/examples/oneplot/config_noworker.yaml
@@ -1,3 +0,0 @@
-x_value: "samx"
-y_values: ["gauss_bpm", "gauss_adc1", "gauss_adc2"]
-dap_worker: None
--- a/bec_widgets/examples/oneplot/oneplot.py
+++ b/bec_widgets/examples/oneplot/oneplot.py
@@ -1,271 +0,0 @@
-import os
-
-import numpy as np
-import qtpy.QtWidgets
-import pyqtgraph as pg
-from bec_lib import MessageEndpoints
-from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
-from qtpy.QtWidgets import QApplication, QTableWidgetItem, QWidget
-from pyqtgraph import mkBrush, mkColor, mkPen
-from pyqtgraph.Qt import QtCore, uic
-
-from bec_widgets.utils import Crosshair, ctrl_c
-
-
-# TODO implement:
-#   - implement scanID database for visualizing previous scans
-#   - multiple signals for different monitors
-#   - change how dap is handled in bec_dispatcher to handle more workers
-
-
-class PlotApp(QWidget):
-    """
-    Main class for the PlotApp used to plot two signals from the BEC.
-
-    Attributes:
-        update_signal (pyqtSignal): Signal to trigger plot updates.
-        update_dap_signal (pyqtSignal): Signal to trigger DAP updates.
-
-    Args:
-        x_value (str): The x device/signal for plotting.
-        y_values (list of str): List of y device/signals for plotting.
-        dap_worker (str, optional): DAP process to specify. Set to None to disable.
-        parent (QWidget, optional): Parent widget.
-    """
-
-    update_signal = pyqtSignal()
-    update_dap_signal = pyqtSignal()
-
-    def __init__(self, x_value, y_values, dap_worker=None, parent=None):
-        super(PlotApp, self).__init__(parent)
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "oneplot.ui"), self)
-
-        self.x_value = x_value
-        self.y_values = y_values
-        self.dap_worker = dap_worker
-
-        self.scanID = None
-        self.data_x = []
-        self.data_y = []
-
-        self.dap_x = np.array([])
-        self.dap_y = np.array([])
-
-        self.fit = None
-
-        self.init_ui()
-        self.init_curves()
-        self.hook_crosshair()
-
-        self.proxy_update_plot = pg.SignalProxy(
-            self.update_signal, rateLimit=25, slot=self.update_plot
-        )
-        self.proxy_update_fit = pg.SignalProxy(
-            self.update_dap_signal, rateLimit=25, slot=self.update_fit_table
-        )
-
-    def init_ui(self) -> None:
-        """Initialize the UI components."""
-        self.plot = pg.PlotItem()
-        self.glw.addItem(self.plot)
-        self.plot.setLabel("bottom", self.x_value)
-        self.plot.setLabel("left", ", ".join(self.y_values))
-        self.plot.addLegend()
-
-    def init_curves(self) -> None:
-        """Initialize curve data and properties."""
-        self.plot.clear()
-
-        self.curves_data = []
-        self.curves_dap = []
-
-        colors_y_values = PlotApp.golden_angle_color(colormap="CET-R2", num=len(self.y_values))
-        # colors_y_daps = PlotApp.golden_angle_color(
-        #     colormap="CET-I2", num=len(self.dap_worker)
-        # )  # TODO adapt for multiple dap_workers
-
-        # Initialize curves for y_values
-        for ii, (signal, color) in enumerate(zip(self.y_values, colors_y_values)):
-            pen_curve = mkPen(color=color, width=2, style=QtCore.Qt.DashLine)
-            brush_curve = mkBrush(color=color)
-            curve_data = pg.PlotDataItem(
-                symbolSize=5,
-                symbolBrush=brush_curve,
-                pen=pen_curve,
-                skipFiniteCheck=True,
-                name=f"{signal}",
-            )
-            self.curves_data.append(curve_data)
-            self.plot.addItem(curve_data)
-
-        # Initialize curves for DAP if dap_worker is not None
-        if self.dap_worker is not None:
-            # for ii, (monitor, color) in enumerate(zip(self.dap_worker, colors_y_daps)):#TODO adapt for multiple dap_workers
-            pen_dap = mkPen(color="#3b5998", width=2, style=QtCore.Qt.DashLine)
-            curve_dap = pg.PlotDataItem(
-                pen=pen_dap, skipFiniteCheck=True, symbolSize=5, name=f"{self.dap_worker}"
-            )
-            self.curves_dap.append(curve_dap)
-            self.plot.addItem(curve_dap)
-
-        self.tableWidget_crosshair.setRowCount(len(self.y_values))
-        self.tableWidget_crosshair.setVerticalHeaderLabels(self.y_values)
-        self.hook_crosshair()
-
-    def hook_crosshair(self) -> None:
-        """Attach the crosshair to the plot."""
-        self.crosshair_1d = Crosshair(self.plot, precision=3)
-        self.crosshair_1d.coordinatesChanged1D.connect(
-            lambda x, y: self.update_table(self.tableWidget_crosshair, x, y, column=0)
-        )
-        self.crosshair_1d.coordinatesClicked1D.connect(
-            lambda x, y: self.update_table(self.tableWidget_crosshair, x, y, column=1)
-        )
-
-    def update_table(
-        self, table_widget: qtpy.QtWidgets.QTableWidget, x: float, y_values: list, column: int
-    ) -> None:
-        for i, y in enumerate(y_values):
-            table_widget.setItem(i, column, QTableWidgetItem(f"({x}, {y})"))
-            table_widget.resizeColumnsToContents()
-
-    def update_plot(self) -> None:
-        """Update the plot data."""
-        for ii, curve in enumerate(self.curves_data):
-            curve.setData(self.data_x, self.data_y[ii])
-
-        if self.dap_worker is not None:
-            # for ii, curve in enumerate(self.curves_dap): #TODO adapt for multiple dap_workers
-            #     curve.setData(self.dap_x, self.dap_y[ii])
-            self.curves_dap[0].setData(self.dap_x, self.dap_y)
-
-    def update_fit_table(self):
-        """Update the table for fit data."""
-
-        self.tableWidget_fit.setData(self.fit)
-
-    @pyqtSlot(dict, dict)
-    def on_dap_update(self, msg: dict, metadata: dict) -> None:
-        """
-        Update DAP  related data.
-
-        Args:
-            msg (dict): Message received with data.
-            metadata (dict): Metadata of the DAP.
-        """
-
-        # TODO adapt for multiple dap_workers
-        self.dap_x = msg[self.dap_worker]["x"]
-        self.dap_y = msg[self.dap_worker]["y"]
-
-        self.fit = metadata["fit_parameters"]
-
-        self.update_dap_signal.emit()
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(self, msg: dict, metadata: dict):
-        """
-        Handle new scan segments.
-
-        Args:
-            msg (dict): Message received with scan data.
-            metadata (dict): Metadata of the scan.
-        """
-        current_scanID = msg["scanID"]
-
-        if current_scanID != self.scanID:
-            self.scanID = current_scanID
-            self.data_x = []
-            self.data_y = [[] for _ in self.y_values]
-            self.init_curves()
-
-        dev_x = self.x_value
-        data_x = msg["data"][dev_x][dev[dev_x]._hints[0]]["value"]
-        self.data_x.append(data_x)
-
-        for ii, dev_y in enumerate(self.y_values):
-            data_y = msg["data"][dev_y][dev[dev_y]._hints[0]]["value"]
-            self.data_y[ii].append(data_y)
-
-        self.update_signal.emit()
-
-    @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 = PlotApp.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 yaml
-
-    from bec_widgets.utils.bec_dispatcher import bec_dispatcher
-
-    with open("config_noworker.yaml", "r") as file:
-        config = yaml.safe_load(file)
-
-    x_value = config["x_value"]
-    y_values = config["y_values"]
-    dap_worker = config["dap_worker"]
-
-    dap_worker = None if dap_worker == "None" else dap_worker
-
-    # BECclient global variables
-    client = bec_dispatcher.client
-    client.start()
-
-    dev = client.device_manager.devices
-    scans = client.scans
-    queue = client.queue
-
-    app = QApplication([])
-    plotApp = PlotApp(x_value=x_value, y_values=y_values, dap_worker=dap_worker)
-
-    # Connecting signals from bec_dispatcher
-    bec_dispatcher.connect_slot(plotApp.on_dap_update, MessageEndpoints.processed_data(dap_worker))
-    bec_dispatcher.connect_slot(plotApp.on_scan_segment, MessageEndpoints.scan_segment())
-    ctrl_c.setup(app)
-
-    window = plotApp
-    window.show()
-    app.exec()
--- a/bec_widgets/examples/oneplot/oneplot.ui
+++ b/bec_widgets/examples/oneplot/oneplot.ui
@@ -1,75 +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>547</width>
-    <height>653</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout" stretch="1,2">
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout" stretch="2,1">
-     <item>
-      <widget class="QGroupBox" name="groupBox">
-       <property name="title">
-        <string>Cursor</string>
-       </property>
-       <layout class="QGridLayout" name="gridLayout">
-        <item row="0" column="0">
-         <widget class="QTableWidget" name="tableWidget_crosshair">
-          <column>
-           <property name="text">
-            <string>Moved</string>
-           </property>
-          </column>
-          <column>
-           <property name="text">
-            <string>Clicked</string>
-           </property>
-          </column>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="groupBox_2">
-       <property name="title">
-        <string>Fit</string>
-       </property>
-       <layout class="QGridLayout" name="gridLayout_2">
-        <item row="0" column="0">
-         <widget class="TableWidget" name="tableWidget_fit"/>
-        </item>
-       </layout>
-      </widget>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <widget class="GraphicsLayoutWidget" name="glw"/>
-   </item>
-  </layout>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>GraphicsLayoutWidget</class>
-   <extends>QGraphicsView</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
-  <customwidget>
-   <class>TableWidget</class>
-   <extends>QTableWidget</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>
--- a/bec_widgets/examples/plot_app/config_example.yaml
+++ b/bec_widgets/examples/plot_app/config_example.yaml
@@ -1,130 +0,0 @@
-plot_settings:
-  background_color: "black"
-  num_columns: 2
-  colormap: "plasma"
-  scan_types: False # True to show scan types
-
-# example to use without scan_type -> only one general configuration
-plot_data:
-  - plot_name: "BPM4i plots vs samy"
-    x:
-      label: 'Motor Y'
-      signals:
-        - name: "samy"
-#          entry: "samy" # here I also forgot to specify entry
-    y:
-      label: 'bpm4i'
-      signals:
-        - name: "bpm4i"
-          entry: "bpm4i"
-          # I will not specify entry, because I want to take hint from gauss_adc2
-  - plot_name: "BPM4i plots vs samx"
-    x:
-      label: 'Motor Y'
-      signals:
-        - name: "samy"
-#          entry: "samy" # here I also forgot to specify entry
-    y:
-      label: 'bpm4i'
-      signals:
-        - name: "bpm4i"
-          entry: "bpm4i"
-          # I will not specify entry, because I want to take hint from gauss_adc2
-  - plot_name: "MCS Channel 4 (Cyberstar) vs samx"
-    x:
-      label: 'Motor X'
-      signals:
-        - name: "samx"
-          entry: "samx"
-    y:
-      label: 'mcs4 cyberstar'
-      signals:
-        - name: "mcs"
-          entry: "mca4"
-  - plot_name: "MCS Channel 4 (Cyberstar) vs samy"
-    x:
-      label: 'Motor X'
-      signals:
-        - name: "samy"
-          entry: "samy"
-    y:
-      label: 'mcs4 cyberstar'
-      signals:
-        - name: "mcs"
-          entry: "mca4"
-
-
-
-# example to use with scan_type -> different configuration for different scan types
-#plot_data:
-#  line_scan:
-#    - plot_name: "BPM plot"
-#      x:
-#        label: 'Motor X'
-#        signals:
-#          - name: "samx"
-#  #          entry: "samx"
-#      y:
-#        label: 'BPM'
-#        signals:
-#          - name: "gauss_bpm"
-#            entry: "gauss_bpm"
-#          - name: "gauss_adc1"
-#            entry: "gauss_adc1"
-#          - name: "gauss_adc2"
-#            entry: "gauss_adc2"
-#
-#    - plot_name: "Multi"
-#      x:
-#        label: 'Motor X'
-#        signals:
-#          - name: "samx"
-#            entry: "samx"
-#      y:
-#        label: 'Multi'
-#        signals:
-#          - name: "gauss_bpm"
-#            entry: "gauss_bpm"
-#          - name: "samx"
-#            entry: ["samx", "samx_setpoint"]
-#
-#  grid_scan:
-#    - plot_name: "Grid plot 1"
-#      x:
-#        label: 'Motor X'
-#        signals:
-#          - name: "samx"
-#            entry: "samx"
-#      y:
-#        label: 'BPM'
-#        signals:
-#          - name: "gauss_bpm"
-#            entry: "gauss_bpm"
-#          - name: "gauss_adc1"
-#            entry: "gauss_adc1"
-#    - plot_name: "Grid plot 2"
-#      x:
-#        label: 'Motor X'
-#        signals:
-#          - name: "samx"
-#            entry: "samx"
-#      y:
-#        label: 'BPM'
-#        signals:
-#          - name: "gauss_bpm"
-#            entry: "gauss_bpm"
-#          - name: "gauss_adc1"
-#            entry: "gauss_adc1"
-#
-#    - plot_name: "Grid plot 3"
-#      x:
-#        label: 'Motor Y'
-#        signals:
-#          - name: "samy"
-#            entry: "samy"
-#      y:
-#        label: 'BPM'
-#        signals:
-#          - name: "gauss_bpm"
-#            entry: "gauss_bpm"
-
--- a/bec_widgets/examples/plot_app/config_scans_example.yaml
+++ b/bec_widgets/examples/plot_app/config_scans_example.yaml
@@ -1,91 +0,0 @@
-plot_settings:
-  background_color: "black"
-  num_columns: 2
-  colormap: "plasma"
-  scan_types: True # True to show scan types
-
-# example to use with scan_type -> different configuration for different scan types
-plot_data:
-  line_scan:
-    - plot_name: "BPM plot"
-      x:
-        label: 'Motor X'
-        signals:
-          - name: "samx"
-  #          entry: "samx"
-      y:
-        label: 'BPM'
-        signals:
-          - name: "gauss_bpm"
-            entry: "gauss_bpm"
-          - name: "gauss_adc1"
-            entry: "gauss_adc1"
-          - name: "gauss_adc2"
-            entry: "gauss_adc2"
-
-    - plot_name: "Multi"
-      x:
-        label: 'Motor X'
-        signals:
-          - name: "samx"
-            entry: "samx"
-      y:
-        label: 'Multi'
-        signals:
-          - name: "gauss_bpm"
-            entry: "gauss_bpm"
-          - name: "samx"
-            entry: ["samx", "samx_setpoint"]
-
-  grid_scan:
-    - plot_name: "Grid plot 1"
-      x:
-        label: 'Motor X'
-        signals:
-          - name: "samx"
-            entry: "samx"
-      y:
-        label: 'BPM'
-        signals:
-          - name: "gauss_bpm"
-            entry: "gauss_bpm"
-          - name: "gauss_adc1"
-            entry: "gauss_adc1"
-    - plot_name: "Grid plot 2"
-      x:
-        label: 'Motor X'
-        signals:
-          - name: "samx"
-            entry: "samx"
-      y:
-        label: 'BPM'
-        signals:
-          - name: "gauss_bpm"
-            entry: "gauss_bpm"
-          - name: "gauss_adc1"
-            entry: "gauss_adc1"
-
-    - plot_name: "Grid plot 3"
-      x:
-        label: 'Motor Y'
-        signals:
-          - name: "samy"
-            entry: "samy"
-      y:
-        label: 'BPM'
-        signals:
-          - name: "gauss_bpm"
-            entry: "gauss_bpm"
-
-    - plot_name: "Grid plot 4"
-      x:
-        label: 'Motor Y'
-        signals:
-          - name: "samy"
-            entry: "samy"
-      y:
-        label: 'BPM'
-        signals:
-          - name: "gauss_adc3"
-            entry: "gauss_adc3"
-
--- a/bec_widgets/examples/plot_app/plot_app.py
+++ b/bec_widgets/examples/plot_app/plot_app.py
@@ -1,730 +0,0 @@
-import logging
-import os
-
-# import traceback
-
-import pyqtgraph
-import pyqtgraph as pg
-
-from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
-
-from qtpy.QtWidgets import (
-    QApplication,
-    QWidget,
-    QTableWidgetItem,
-    QTableWidget,
-    QFileDialog,
-    QMessageBox,
-)
-from pyqtgraph import ColorButton
-from pyqtgraph import mkBrush, mkPen
-from pyqtgraph.Qt import QtCore, uic
-from pyqtgraph.Qt import QtWidgets
-
-from bec_lib import MessageEndpoints
-from bec_widgets.utils import Crosshair, Colors
-
-
-# TODO implement:
-#   - implement scanID database for visualizing previous scans
-
-
-class PlotApp(QWidget):
-    """
-    Main class for PlotApp, designed to plot multiple signals in a grid layout
-    based on a flexible YAML configuration.
-
-    Attributes:
-        update_signal (pyqtSignal): Signal to trigger plot updates.
-        plot_data (list of dict): List of dictionaries containing plot configurations.
-                                  Each dictionary specifies x and y signals, including their
-                                  name and entry, for a particular plot.
-
-    Args:
-        config (dict): Configuration dictionary containing all settings for the plotting app.
-                      It should include the following keys:
-                      - 'plot_settings': Dictionary containing global plot settings.
-                      - 'plot_data': List of dictionaries specifying the signals to plot.
-        parent (QWidget, optional): Parent widget.
-
-    Example:
-        General Plot Configuration:
-        {
-            'plot_settings': {'background_color': 'black', 'num_columns': 2, 'colormap': 'plasma', 'scan_types': False},
-            'plot_data': [
-                {
-                    'plot_name': 'Plot A',
-                    'x': {'label': 'X-axis', 'signals': [{'name': 'device_x', 'entry': 'entry_x'}]},
-                    'y': {'label': 'Y-axis', 'signals': [{'name': 'device_y', 'entry': 'entry_y'}]}
-                }
-            ]
-        }
-
-        Different Scans Mode Configuration:
-        {
-            'plot_settings': {'background_color': 'black', 'num_columns': 2, 'colormap': 'plasma', 'scan_types': True},
-            'plot_data': {
-                'scan_type_1': [
-                    {
-                        'plot_name': 'Plot 1',
-                        'x': {'label': 'X-axis', 'signals': [{'name': 'device_x1', 'entry': 'entry_x1'}]},
-                        'y': {'label': 'Y-axis', 'signals': [{'name': 'device_y1', 'entry': 'entry_y1'}]}
-                    }
-                ],
-                'scan_type_2': [
-                    {
-                        'plot_name': 'Plot 2',
-                        'x': {'label': 'X-axis', 'signals': [{'name': 'device_x2', 'entry': 'entry_x2'}]},
-                        'y': {'label': 'Y-axis', 'signals': [{'name': 'device_y2', 'entry': 'entry_y2'}]}
-                    }
-                ]
-            }
-        }
-    """
-
-    update_signal = pyqtSignal()
-    update_dap_signal = pyqtSignal()
-
-    def __init__(self, config: dict, client=None, parent=None):
-        super(PlotApp, self).__init__(parent)
-
-        # Error handler
-        self.error_handler = ErrorHandler(parent=self)
-
-        # Client and device manager from BEC
-        self.client = bec_dispatcher.client if client is None else client
-        self.dev = self.client.device_manager.devices
-
-        # Loading UI
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "plot_app.ui"), self)
-
-        self.data = {}
-
-        self.crosshairs = None
-        self.plots = None
-        self.curves_data = None
-        self.grid_coordinates = None
-        self.scanID = None
-
-        self.user_colors = {}  # key: (plot_name, y_name, y_entry), value: color
-
-        # Default config
-        self.config = config
-
-        # Validate the configuration before proceeding
-        self.load_config(self.config)
-
-        # Default splitter size
-        self.splitter.setSizes([400, 100])
-
-        # Buttons
-        self.pushButton_save.clicked.connect(self.save_settings_to_yaml)
-        self.pushButton_load.clicked.connect(self.load_settings_from_yaml)
-
-        # Connect the update signal to the update plot method
-        self.proxy_update_plot = pg.SignalProxy(
-            self.update_signal, rateLimit=25, slot=self.update_plot
-        )
-
-        # Change layout of plots when the number of columns is changed in GUI
-        self.spinBox_N_columns.valueChanged.connect(lambda x: self.init_ui(x))
-
-    def load_config(self, config: dict) -> None:
-        """
-        Load and validate the configuration, retrying until a valid configuration is provided or the user cancels.
-        Args:
-            config (dict): Configuration dictionary form .yaml file.
-
-        Returns:
-            None
-        """
-        valid_config = False
-        self.error_handler.set_retry_action(self.load_settings_from_yaml)
-        while not valid_config:
-            if config is None:
-                self.config = (
-                    self.load_settings_from_yaml()
-                )  # Load config if it hasn't been loaded yet
-            try:  # Validate loaded config file
-                self.error_handler.validate_config_file(config)
-                valid_config = True
-            except ValueError as e:
-                self.config = None  # Reset config_to_test to force reloading configuration
-                self.config = self.error_handler.handle_error(str(e))
-        if valid_config is True:  # Initialize config if validation succeeds
-            self.init_config(self.config)
-
-    def init_config(self, config: dict) -> None:
-        """
-        Initializes or update the configuration settings for the PlotApp.
-
-        Args:
-            config (dict): Dictionary containing plot settings and data configurations.
-        """
-
-        # YAML config
-        self.plot_settings = config.get("plot_settings", {})
-        self.plot_data_config = config.get("plot_data", {})
-        self.scan_types = self.plot_settings.get("scan_types", False)
-
-        if self.scan_types is False:  # Device tracking mode
-            self.plot_data = self.plot_data_config  # TODO logic has to be improved
-        else:  # setup first line scan as default, then changed with different scan type
-            self.plot_data = self.plot_data_config[list(self.plot_data_config.keys())[0]]
-
-        # Setting global plot settings
-        self.init_plot_background(self.plot_settings["background_color"])
-
-        # Initialize the UI
-        self.init_ui(self.plot_settings["num_columns"])
-        self.spinBox_N_columns.setValue(
-            self.plot_settings["num_columns"]
-        )  # TODO has to be checked if it will not setup more columns than plots
-        self.spinBox_N_columns.setMaximum(len(self.plot_data))
-
-    def init_plot_background(self, background_color: str) -> None:
-        """
-        Initialize plot settings based on the background color.
-
-        Args:
-            background_color (str): The background color ('white' or 'black').
-
-        This method sets the background and foreground colors for pyqtgraph.
-        If the background is dark ('black'), the foreground will be set to 'white',
-        and vice versa.
-        """
-        if background_color.lower() == "black":
-            pg.setConfigOption("background", "k")
-            pg.setConfigOption("foreground", "w")
-        elif background_color.lower() == "white":
-            pg.setConfigOption("background", "w")
-            pg.setConfigOption("foreground", "k")
-        else:
-            raise ValueError(
-                f"Invalid background color {background_color}. Allowed values are 'white' or 'black'."
-            )
-
-        # TODO simplify -> find way how to setup also foreground color
-        # if background_color.lower() not in ["black", "white"]:
-        #     raise ValueError(
-        #         f"Invalid background color {background_color}. Allowed values are 'white' or 'black'."
-        #     )
-        # self.glw.setBackground(background_color.lower())
-
-    def init_ui(self, num_columns: int = 3) -> None:
-        """
-        Initialize the UI components, create plots and store their grid positions.
-
-        Args:
-            num_columns (int): Number of columns to wrap the layout.
-
-        This method initializes a dictionary `self.plots` to store the plot objects
-        along with their corresponding x and y signal names. It dynamically arranges
-        the plots in a grid layout based on the given number of columns and dynamically
-        stretches the last plots to fit the remaining space.
-        """
-        self.glw.clear()
-        self.plots = {}
-        self.grid_coordinates = []
-
-        num_plots = len(self.plot_data)
-
-        # Check if num_columns exceeds the number of plots
-        if num_columns >= num_plots:
-            num_columns = num_plots
-            self.plot_settings["num_columns"] = num_columns  # Update the settings
-            print(
-                f"Warning: num_columns in the YAML file was greater than the number of plots. Resetting num_columns to number of plots:{num_columns}."
-            )
-        else:
-            self.plot_settings["num_columns"] = num_columns  # Update the settings
-
-        num_rows = num_plots // num_columns
-        last_row_cols = num_plots % num_columns
-        remaining_space = num_columns - last_row_cols
-
-        for i, plot_config in enumerate(self.plot_data):
-            row, col = i // num_columns, i % num_columns
-            colspan = 1
-
-            if row == num_rows and remaining_space > 0:
-                if last_row_cols == 1:
-                    colspan = num_columns
-                else:
-                    colspan = remaining_space // last_row_cols + 1
-                    remaining_space -= colspan - 1
-                    last_row_cols -= 1
-
-            plot_name = plot_config.get("plot_name", "")
-            x_label = plot_config["x"].get("label", "")
-            y_label = plot_config["y"].get("label", "")
-
-            plot = self.glw.addPlot(row=row, col=col, colspan=colspan, title=plot_name)
-            plot.setLabel("bottom", x_label)
-            plot.setLabel("left", y_label)
-            plot.addLegend()
-
-            self.plots[plot_name] = plot
-            self.grid_coordinates.append((row, col))
-
-        self.init_curves()
-
-    def init_curves(self) -> None:
-        """
-        Initialize curve data and properties, and update table row labels.
-
-        This method initializes a nested dictionary `self.curves_data` to store
-        the curve objects for each x and y signal pair. It also updates the row labels
-        in `self.tableWidget_crosshair` to include the grid position for each y-value.
-        """
-        self.curves_data = {}
-        row_labels = []
-
-        for idx, plot_config in enumerate(self.plot_data):
-            plot_name = plot_config.get("plot_name", "")
-            plot = self.plots[plot_name]
-            plot.clear()
-
-            y_configs = plot_config["y"]["signals"]
-            colors_ys = Colors.golden_angle_color(
-                colormap=self.plot_settings["colormap"], num=len(y_configs)
-            )
-
-            curve_list = []
-            for i, (y_config, color) in enumerate(zip(y_configs, colors_ys)):
-                # print(y_config)
-                y_name = y_config["name"]
-                y_entries = y_config.get("entry", [y_name])
-
-                if not isinstance(y_entries, list):
-                    y_entries = [y_entries]
-
-                for y_entry in y_entries:
-                    user_color = self.user_colors.get((plot_name, y_name, y_entry), None)
-                    color_to_use = user_color if user_color else color
-
-                    pen_curve = mkPen(color=color_to_use, width=2, style=QtCore.Qt.DashLine)
-                    brush_curve = mkBrush(color=color_to_use)
-
-                    curve_data = pg.PlotDataItem(
-                        symbolSize=5,
-                        symbolBrush=brush_curve,
-                        pen=pen_curve,
-                        skipFiniteCheck=True,
-                        name=f"{y_name} ({y_entry})",
-                    )
-
-                    curve_list.append((y_name, y_entry, curve_data))
-                    plot.addItem(curve_data)
-                    row_labels.append(f"{y_name} ({y_entry}) - {plot_name}")
-
-                    # Create a ColorButton and set its color
-                    color_btn = ColorButton()
-                    color_btn.setColor(color_to_use)
-                    color_btn.sigColorChanged.connect(
-                        lambda btn=color_btn, plot=plot_name, yname=y_name, yentry=y_entry, curve=curve_data: self.change_curve_color(
-                            btn, plot, yname, yentry, curve
-                        )
-                    )
-
-                    # Add the ColorButton as a QWidget to the table
-                    color_widget = QtWidgets.QWidget()
-                    layout = QtWidgets.QHBoxLayout()
-                    layout.addWidget(color_btn)
-                    layout.setContentsMargins(0, 0, 0, 0)
-                    color_widget.setLayout(layout)
-
-                    row = len(row_labels) - 1  # The row index in the table
-                    self.tableWidget_crosshair.setCellWidget(row, 2, color_widget)
-
-            self.curves_data[plot_name] = curve_list
-
-        self.tableWidget_crosshair.setRowCount(len(row_labels))
-        self.tableWidget_crosshair.setVerticalHeaderLabels(row_labels)
-        self.hook_crosshair()
-
-    def change_curve_color(
-        self,
-        btn: pyqtgraph.ColorButton,
-        plot_name: str,
-        y_name: str,
-        y_entry: str,
-        curve: pyqtgraph.PlotDataItem,
-    ) -> None:
-        """
-        Change the color of a curve and update the corresponding ColorButton.
-
-        Args:
-            btn (ColorButton): The ColorButton that was clicked.
-            plot_name (str): The name of the plot where the curve belongs.
-            y_name (str): The name of the y signal.
-            y_entry (str): The entry of the y signal.
-            curve (PlotDataItem): The curve to be changed.
-        """
-        color = btn.color()
-        pen_curve = mkPen(color=color, width=2, style=QtCore.Qt.DashLine)
-        brush_curve = mkBrush(color=color)
-        curve.setPen(pen_curve)
-        curve.setSymbolBrush(brush_curve)
-        self.user_colors[(plot_name, y_name, y_entry)] = color
-
-    def hook_crosshair(self) -> None:
-        """Attach crosshairs to each plot and connect them to the update_table method."""
-        self.crosshairs = {}
-        for plot_name, plot in self.plots.items():
-            crosshair = Crosshair(plot, precision=3)
-            crosshair.coordinatesChanged1D.connect(
-                lambda x, y, plot=plot: self.update_table(
-                    self.tableWidget_crosshair, x, y, column=0, plot=plot
-                )
-            )
-            crosshair.coordinatesClicked1D.connect(
-                lambda x, y, plot=plot: self.update_table(
-                    self.tableWidget_crosshair, x, y, column=1, plot=plot
-                )
-            )
-            self.crosshairs[plot_name] = crosshair
-
-    def update_table(
-        self, table_widget: QTableWidget, x: float, y_values: list, column: int, plot: pg.PlotItem
-    ) -> None:
-        """
-        Update the table with coordinates based on cursor movements and clicks.
-
-        Args:
-            table_widget (QTableWidget): The table to be updated.
-            x (float): The x-coordinate from the plot.
-            y_values (list): The y-coordinates from the plot.
-            column (int): The column in the table to be updated.
-            plot (PlotItem): The plot from which the coordinates are taken.
-
-        This method calculates the correct row in the table for each y-value
-        and updates the cell at (row, column) with the new x and y coordinates.
-        """
-        plot_name = [name for name, value in self.plots.items() if value == plot][0]
-
-        starting_row = 0
-        for plot_config in self.plot_data:
-            if plot_config.get("plot_name", "") == plot_name:
-                break
-            for y_config in plot_config.get("y", {}).get("signals", []):
-                y_entries = y_config.get("entry", [y_config.get("name", "")])
-                if not isinstance(y_entries, list):
-                    y_entries = [y_entries]
-                starting_row += len(y_entries)
-
-        for i, y in enumerate(y_values):
-            row = starting_row + i
-            table_widget.setItem(row, column, QTableWidgetItem(f"({x}, {y})"))
-            table_widget.resizeColumnsToContents()
-
-    def update_plot(self) -> None:
-        """Update the plot data based on the stored data dictionary."""
-        for plot_name, curve_list in self.curves_data.items():
-            for y_name, y_entry, curve in curve_list:
-                x_config = next(
-                    (pc["x"] for pc in self.plot_data if pc.get("plot_name") == plot_name), {}
-                )
-                x_signal_config = x_config["signals"][0]
-                x_name = x_signal_config.get("name", "")
-                x_entry = x_signal_config.get("entry", x_name)
-
-                key = (x_name, x_entry, y_name, y_entry)
-                data_x = self.data.get(key, {}).get("x", [])
-                data_y = self.data.get(key, {}).get("y", [])
-
-                curve.setData(data_x, data_y)
-
-    @pyqtSlot(dict, dict)
-    def on_scan_segment(
-        self, msg, metadata
-    ) -> None:  # TODO the logic should be separated from GUI operation
-        """
-        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_scanID = msg.get("scanID", None)
-        if current_scanID is None:
-            return
-
-        if current_scanID != self.scanID:
-            if self.scan_types is False:
-                self.plot_data = self.plot_data_config
-            elif self.scan_types is True:
-                currentName = metadata.get("scan_name")
-                if currentName is None:
-                    raise ValueError(
-                        f"Scan name not found in metadata. Please check the scan_name in the YAML config or in bec "
-                        f"configuration."
-                    )
-                self.plot_data = self.plot_data_config.get(currentName, [])
-                if self.plot_data == []:
-                    raise ValueError(
-                        f"Scan name {currentName} not found in the YAML config. Please check the scan_name in the "
-                        f"YAML config or in bec configuration."
-                    )
-
-                # Init UI
-                self.init_ui(self.plot_settings["num_columns"])
-                self.spinBox_N_columns.setValue(
-                    self.plot_settings["num_columns"]
-                )  # TODO has to be checked if it will not setup more columns than plots
-                self.spinBox_N_columns.setMaximum(len(self.plot_data))
-
-            self.scanID = current_scanID
-            self.data = {}
-            self.init_curves()
-
-        for plot_config in self.plot_data:
-            plot_name = plot_config.get("plot_name", "Unnamed Plot")
-            x_config = plot_config["x"]
-            x_signal_config = x_config["signals"][0]  # Assuming there's at least one signal for x
-
-            x_name = x_signal_config.get("name", "")
-            if not x_name:
-                raise ValueError(f"Name for x signal must be specified in plot: {plot_name}.")
-
-            x_entry_list = x_signal_config.get("entry", [])
-            if not x_entry_list:
-                x_entry_list = (
-                    self.dev[x_name]._hints if hasattr(self.dev[x_name], "_hints") else [x_name]
-                )
-
-            if not isinstance(x_entry_list, list):
-                x_entry_list = [x_entry_list]
-
-            y_configs = plot_config["y"]["signals"]
-
-            for x_entry in x_entry_list:
-                for y_config in y_configs:
-                    y_name = y_config.get("name", "")
-                    if not y_name:
-                        raise ValueError(
-                            f"Name for y signal must be specified in plot: {plot_name}."
-                        )
-
-                    y_entry_list = y_config.get("entry", [])
-                    if not y_entry_list:
-                        y_entry_list = (
-                            self.dev[y_name]._hints
-                            if hasattr(self.dev[y_name], "_hints")
-                            else [y_name]
-                        )
-
-                    if not isinstance(y_entry_list, list):
-                        y_entry_list = [y_entry_list]
-
-                    for y_entry in y_entry_list:
-                        key = (x_name, x_entry, y_name, y_entry)
-
-                        data_x = msg["data"].get(x_name, {}).get(x_entry, {}).get("value", None)
-                        data_y = msg["data"].get(y_name, {}).get(y_entry, {}).get("value", None)
-
-                        if data_x is None:
-                            raise ValueError(
-                                f"Incorrect entry '{x_entry}' specified for x in plot: {plot_name}, x name: {x_name}"
-                            )
-
-                        if data_y is None:
-                            if hasattr(self.dev[y_name], "_hints"):
-                                raise ValueError(
-                                    f"Incorrect entry '{y_entry}' specified for y in plot: {plot_name}, y name: {y_name}"
-                                )
-                            else:
-                                raise ValueError(
-                                    f"No hints available for y in plot: {plot_name}, and name '{y_name}' did not work as entry"
-                                )
-
-                        if data_x is not None:
-                            self.data.setdefault(key, {}).setdefault("x", []).append(data_x)
-
-                        if data_y is not None:
-                            self.data.setdefault(key, {}).setdefault("y", []).append(data_y)
-
-        self.update_signal.emit()
-
-    def save_settings_to_yaml(self):
-        """Save the current settings to a .yaml file using a file dialog."""
-        options = QFileDialog.Options()
-        options |= QFileDialog.DontUseNativeDialog
-        file_path, _ = QFileDialog.getSaveFileName(
-            self, "Save Settings", "", "YAML Files (*.yaml);;All Files (*)", options=options
-        )
-
-        if file_path:
-            try:
-                if not file_path.endswith(".yaml"):
-                    file_path += ".yaml"
-
-                with open(file_path, "w") as file:
-                    yaml.dump(
-                        {"plot_settings": self.plot_settings, "plot_data": self.plot_data_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}")
-
-    def load_settings_from_yaml(self) -> dict:  # TODO can be replace by the utils function
-        """Load settings from a .yaml file using a file dialog and update the current settings."""
-        options = QFileDialog.Options()
-        options |= QFileDialog.DontUseNativeDialog
-        file_path, _ = QFileDialog.getOpenFileName(
-            self, "Load Settings", "", "YAML Files (*.yaml);;All Files (*)", options=options
-        )
-
-        if file_path:
-            try:
-                with open(file_path, "r") as file:
-                    self.config = yaml.safe_load(file)
-                    self.load_config(self.config)  # validate new config
-                return config
-            except FileNotFoundError:
-                print(f"The file {file_path} was not found.")
-            except Exception as e:
-                print(f"An error occurred while loading the settings from {file_path}: {e}")
-                return None  # Return None on exception to indicate failure
-
-
-class ErrorHandler:
-    def __init__(self, parent=None):
-        self.parent = parent
-        self.errors = []
-        self.retry_action = None
-        logging.basicConfig(level=logging.ERROR)  # Configure logging
-
-    def set_retry_action(self, action):
-        self.retry_action = action  # Store a reference to the retry action
-
-    def handle_error(self, error_message: str):
-        # logging.error(f"{error_message}\n{traceback.format_exc()}") #TODO decide if useful
-
-        choice = QMessageBox.critical(
-            self.parent,
-            "Error",
-            f"{error_message}\n\nWould you like to retry?",
-            QMessageBox.Retry | QMessageBox.Cancel,
-        )
-        if choice == QMessageBox.Retry and self.retry_action is not None:
-            return self.retry_action()
-        else:
-            exit(1)  # Exit the program if the user selects Cancel or if no retry_action is provided
-
-    def validate_config_file(self, config: dict) -> None:
-        """
-        Validate the configuration dictionary.
-        Args:
-            config (dict): Configuration dictionary form .yaml file.
-
-        Returns:
-            None
-        """
-        self.errors = []
-
-        # Validate common keys
-        required_top_level_keys = ["plot_settings", "plot_data"]
-        for key in required_top_level_keys:
-            if key not in config:
-                self.errors.append(f"Missing required key: {key}")
-
-        # Only continue if no errors so far
-        if not self.errors:
-            # Determine the configuration mode (device or scan)
-            plot_settings = config.get("plot_settings", {})
-            scan_types = plot_settings.get("scan_types", False)
-
-            plot_data = config.get("plot_data", [])
-
-            if scan_types:
-                # Validate scan mode configuration
-                for scan_type, plots in plot_data.items():
-                    for i, plot_config in enumerate(plots):
-                        self.validate_plot_config(plot_config, i)
-            else:
-                # Validate device mode configuration
-                for i, plot_config in enumerate(plot_data):
-                    self.validate_plot_config(plot_config, i)
-
-        if self.errors != []:
-            self.handle_error("\n".join(self.errors))
-
-    def validate_plot_config(self, plot_config: dict, i: int):
-        """
-        Validate individual plot configuration.
-        Args:
-            plot_config (dict): Individual plot configuration.
-            i (int): Index of the plot configuration.
-
-        Returns:
-            None
-        """
-        for axis in ["x", "y"]:
-            axis_config = plot_config.get(axis)
-            plot_name = plot_config.get("plot_name", "")
-            if axis_config is None:
-                error_msg = f"Missing '{axis}' configuration in plot {i} - {plot_name}"
-                logging.error(error_msg)  # Log the error
-                self.errors.append(error_msg)
-
-            signals_config = axis_config.get("signals")
-            if signals_config is None:
-                error_msg = (
-                    f"Missing 'signals' configuration for {axis} axis in plot {i} - '{plot_name}'"
-                )
-                logging.error(error_msg)  # Log the error
-                self.errors.append(error_msg)
-            elif not isinstance(signals_config, list) or len(signals_config) == 0:
-                error_msg = (
-                    f"'signals' configuration for {axis} axis in plot {i} must be a non-empty list"
-                )
-                logging.error(error_msg)  # Log the error
-                self.errors.append(error_msg)
-            # TODO add condition for name and entry
-
-
-if __name__ == "__main__":
-    import yaml
-    import argparse
-
-    # from bec_widgets import ctrl_c
-    from bec_widgets.utils.bec_dispatcher import bec_dispatcher
-
-    parser = argparse.ArgumentParser(description="Plotting App")
-    parser.add_argument(
-        "--config",
-        "-c",
-        help="Path to the .yaml configuration file",
-        default="config_example.yaml",
-    )
-    args = parser.parse_args()
-
-    try:
-        with open(args.config, "r") as file:
-            config = yaml.safe_load(file)
-
-    except FileNotFoundError:
-        print(f"The file {args.config} was not found.")
-        exit(1)
-    except Exception as e:
-        print(f"An error occurred while loading the config file: {e}")
-        exit(1)
-
-    # BECclient global variables
-    client = bec_dispatcher.client
-    client.start()
-
-    app = QApplication([])
-    plotApp = PlotApp(config=config, client=client)
-
-    # Connecting signals from bec_dispatcher
-    bec_dispatcher.connect_slot(plotApp.on_scan_segment, MessageEndpoints.scan_segment())
-    # ctrl_c.setup(app)
-
-    window = plotApp
-    window.show()
-    app.exec()
--- a/bec_widgets/examples/plot_app/plot_app.ui
+++ b/bec_widgets/examples/plot_app/plot_app.ui
@@ -1,115 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>MultiWindow</class>
- <widget class="QWidget" name="MultiWindow">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>1248</width>
-    <height>564</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>MultiWindow</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <widget class="QSplitter" name="splitter">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <widget class="GraphicsLayoutWidget" name="glw"/>
-     <widget class="QWidget" name="">
-      <layout class="QGridLayout" name="gridLayout_2">
-       <item row="1" column="0">
-        <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>
-       <item row="2" column="0" colspan="3">
-        <widget class="QGroupBox" name="groupBox">
-         <property name="title">
-          <string>Cursor</string>
-         </property>
-         <layout class="QGridLayout" name="gridLayout">
-          <item row="0" column="0">
-           <widget class="QTableWidget" name="tableWidget_crosshair">
-            <column>
-             <property name="text">
-              <string>Moved</string>
-             </property>
-            </column>
-            <column>
-             <property name="text">
-              <string>Clicked</string>
-             </property>
-            </column>
-            <column>
-             <property name="text">
-              <string>Color</string>
-             </property>
-            </column>
-           </widget>
-          </item>
-         </layout>
-        </widget>
-       </item>
-       <item row="1" column="1">
-        <widget class="QLabel" name="label">
-         <property name="text">
-          <string>Number of Columns:</string>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="2">
-        <widget class="QSpinBox" name="spinBox_N_columns">
-         <property name="minimum">
-          <number>1</number>
-         </property>
-         <property name="maximum">
-          <number>10</number>
-         </property>
-         <property name="value">
-          <number>3</number>
-         </property>
-        </widget>
-       </item>
-       <item row="0" column="1">
-        <widget class="QPushButton" name="pushButton_load">
-         <property name="text">
-          <string>Load Config</string>
-         </property>
-        </widget>
-       </item>
-       <item row="0" column="2">
-        <widget class="QPushButton" name="pushButton_save">
-         <property name="text">
-          <string>Save Config</string>
-         </property>
-        </widget>
-       </item>
-      </layout>
-     </widget>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>GraphicsLayoutWidget</class>
-   <extends>QGraphicsView</extends>
-   <header>pyqtgraph.h</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>
--- a/bec_widgets/examples/stream_plot/stream_plot.py
+++ b/bec_widgets/examples/stream_plot/stream_plot.py
@@ -5,17 +5,16 @@ import time
 import numpy as np
 import pyqtgraph
 import pyqtgraph as pg
-from bec_lib import messages, MessageEndpoints
+from bec_lib import MessageEndpoints, messages
 from bec_lib.redis_connector import RedisConnector
-from qtpy.QtCore import Slot as pyqtSlot
-from qtpy.QtWidgets import QTableWidgetItem
 from pyqtgraph import mkBrush, mkPen
 from pyqtgraph.Qt import QtCore, QtWidgets, uic
 from pyqtgraph.Qt.QtCore import pyqtSignal
-from bec_widgets.utils import Crosshair, Colors
-from bec_widgets.utils.bec_dispatcher import bec_dispatcher
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QTableWidgetItem

-# client = bec_dispatcher.client
+from bec_widgets.utils import Colors, Crosshair
+from bec_widgets.utils.bec_dispatcher import BECDispatcher


 class StreamPlot(QtWidgets.QWidget):
@@ -32,7 +31,7 @@ class StreamPlot(QtWidgets.QWidget):
        """

        # Client and device manager from BEC
-        self.client = bec_dispatcher.client if client is None else client
+        self.client = BECDispatcher().client if client is None else client

        super(StreamPlot, self).__init__()
        # Set style for pyqtgraph plots
@@ -42,7 +41,7 @@ class StreamPlot(QtWidgets.QWidget):
        uic.loadUi(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
@@ -56,7 +55,10 @@ class StreamPlot(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()

        ##########################
@@ -66,6 +68,11 @@ class StreamPlot(QtWidgets.QWidget):
        self.init_curves()
        self.hook_crosshair()

+    def close(self):
+        super().close()
+        self._data_retriever_thread_exit_event.set()
+        self.data_retriever.join()
+
    def init_ui(self):
        """Setup all ui elements"""
        ##########################
@@ -169,8 +176,7 @@ class StreamPlot(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,7 +215,7 @@ class StreamPlot(QtWidgets.QWidget):
            ]
        }
        msg = messages.DeviceMessage(signals=return_dict).dumps()
-        self.producer.set_and_publish("px_stream/gui_event", msg=msg)
+        self.connector.set_and_publish("px_stream/gui_event", msg=msg)
        self.roi_signal.emit(region)

    def init_table(self):
@@ -259,14 +265,14 @@ class StreamPlot(QtWidgets.QWidget):
        # else:
        #     return

-    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 = self.client.producer.lrange(topic=endpoint, start=-1, end=-1)
-            data = [messages.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"):
@@ -290,7 +296,7 @@ class StreamPlot(QtWidgets.QWidget):
    def new_proj(self, content: dict, _metadata: dict):
        proj_nr = content["signals"]["proj_nr"]
        endpoint = f"px_stream/projection_{proj_nr}/metadata"
-        msg_raw = self.client.producer.get(topic=endpoint)
+        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"]
@@ -314,6 +320,7 @@ if __name__ == "__main__":
    print(f"Plotting signals for: {', '.join(value.signals)}")

    # Client from dispatcher
+    bec_dispatcher = BECDispatcher()
    client = bec_dispatcher.client

    app = QtWidgets.QApplication([])
--- a/bec_widgets/qtdesigner_plugins/scan2d_plot_plugin.py
+++ b/bec_widgets/qtdesigner_plugins/scan2d_plot_plugin.py
@@ -1,56 +0,0 @@
-from qtpy.QtDesigner import QPyDesignerCustomWidgetPlugin
-from qtpy.QtGui import QIcon
-
-from bec_widgets.widgets.scan_plot.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"
--- a/bec_widgets/qtdesigner_plugins/scan_plot_plugin.py
+++ b/bec_widgets/qtdesigner_plugins/scan_plot_plugin.py
@@ -1,56 +0,0 @@
-from qtpy.QtDesigner import QPyDesignerCustomWidgetPlugin
-from qtpy.QtGui import QIcon
-
-from bec_widgets.widgets.scan_plot.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"
--- a/bec_widgets/utils/init.py
+++ b/bec_widgets/utils/init.py
@@ -1,4 +1,8 @@
-from .crosshair import Crosshair
-from .colors import Colors
-from .validator_delegate import DoubleValidationDelegate
+from .bec_connector import BECConnector, ConnectionConfig
+from .bec_dispatcher import BECDispatcher
 from .bec_table import BECTable
+from .colors import Colors
+from .crosshair import Crosshair
+from .entry_validator import EntryValidator
+from .rpc_decorator import register_rpc_methods, rpc_public
+from .validator_delegate import DoubleValidationDelegate
--- a/bec_widgets/utils/bec_connector.py
+++ b/bec_widgets/utils/bec_connector.py
@@ -0,0 +1,129 @@
+# pylint: disable = no-name-in-module,missing-module-docstring
+from __future__ import annotations
+
+import time
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field, field_validator
+from qtpy.QtCore import Slot as pyqtSlot
+
+from bec_widgets.utils.bec_dispatcher import 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"]
+
+    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
+
+    @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
--- a/bec_widgets/utils/bec_dispatcher.py
+++ b/bec_widgets/utils/bec_dispatcher.py
@@ -1,151 +1,141 @@
-# TODO last backup
-
-# todo super last refactor
-
 from __future__ import annotations

 import argparse
-import itertools
-import os
+import collections
 from collections.abc import Callable
-from typing import Union
+from typing import TYPE_CHECKING, Union

-from bec_lib import BECClient, messages, ServiceConfig
-from bec_lib.redis_connector import RedisConsumerThreaded
-from qtpy.QtCore import QObject, Signal as pyqtSignal
+import redis
+from bec_lib import BECClient
+from bec_lib.redis_connector import MessageObject, RedisConnector
+from qtpy.QtCore import QObject
+from qtpy.QtCore import Signal as pyqtSignal

-# Adding a new pyqt signal requires 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(dict, dict))) for i in itertools.count()
-)
+if TYPE_CHECKING:
+    from bec_lib.endpoints import EndpointInfo


-class _Connection:
-    """Utility class to keep track of slots connected to a particular redis consumer"""
+class QtThreadSafeCallback(QObject):
+    cb_signal = pyqtSignal(dict, dict)

-    def __init__(self, consumer) -> None:
-        self.consumer: RedisConsumerThreaded = consumer
-        self.slots = set()
-        # keep a reference to a new signal class, so it is not gc'ed
-        self._signal_container = next(_signal_class_factory)()
-        self.signal: pyqtSignal = self._signal_container.signal
-
-
-class _BECDispatcher(QObject):
-    """Utility class to keep track of slots connected to a particular redis consumer"""
-
-    def __init__(self, bec_config=None):
+    def __init__(self, cb):
        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.cb = cb
+        self.cb_signal.connect(self.cb)

-        self.client.initialize(config=ServiceConfig(config_path=bec_config))
-        self._connections = {}
+    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, *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):
+        if self._initialized:
+            return
+
+        self._slots = collections.defaultdict(set)
+        self.client = client
+
+        if self.client is None:
+            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[str, list], single_callback_for_all_topics=False
+        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 (str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
-            single_callback_for_all_topics (bool): If True, use the same callback for all topics, otherwise use
-                separate callbacks.
+            topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
        """
-        if isinstance(topics, str):
-            topics = [topics]
+        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))

-        # Ensure topics_key is a tuple, whether single_callback_for_all_topics is True or False.
-        topics_key = tuple(sorted(topics)) if single_callback_for_all_topics else tuple(topics)
+    def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
+        self.client.connector.unregister(topics, cb=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]

-        if topics_key not in self._connections:
-            self._connections[topics_key] = self._create_connection(topics)
-        connection = self._connections[topics_key]
-        if slot not in connection.slots:
-            connection.signal.connect(slot)
-            connection.slots.add(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 _create_connection(self, topics: list) -> _Connection:
-        """Creates a new connection for given topics."""
-
-        def cb(msg):
-            msg = messages.MessageReader.loads(msg.value)
-            if not isinstance(msg, list):
-                msg = [msg]
-            for msg_i in msg:
-                for connection_key, connection in self._connections.items():
-                    if set(topics).intersection(
-                        connection_key if isinstance(connection_key, tuple) else [connection_key]
-                    ):
-                        connection.signal.emit(msg_i.content, msg_i.metadata)
-
-        consumer = self.client.connector.consumer(topics=topics, cb=cb)
-        consumer.start()
-        return _Connection(consumer)
-
-    def _disconnect_slot_from_topic(self, slot: Callable, topic: str) -> None:
-        """A helper method to disconnect a slot from a specific topic.
-
-        Args:
-            slot (Callable): A slot to be disconnected
-            topic (str): A corresponding topic that can typically be acquired via
-                bec_lib.MessageEndpoints
-        """
-        connection = self._connections.get(topic)
-        if connection and slot in connection.slots:
-            connection.signal.disconnect(slot)
-            connection.slots.remove(slot)
-            if not connection.slots:
-                connection.consumer.shutdown()
-                del self._connections[topic]
-
-    def disconnect_slot(self, slot: Callable, topics: Union[str, list]) -> None:
-        """Disconnect widget's pyqt slot from pub/sub updates on a topic.
-
-        Args:
-            slot (Callable): A slot to be disconnected
-            topics (str | list): A corresponding topic or list of topics that can typically be acquired via
-                bec_lib.MessageEndpoints
-        """
-        if isinstance(topics, str):
-            topics = [topics]
-
-        for key, connection in list(self._connections.items()):
-            if slot in connection.slots:
-                common_topics = set(topics).intersection(key)
-                if common_topics:
-                    remaining_topics = set(key) - set(topics)
-                    # Disconnect slot from common topics
-                    connection.signal.disconnect(slot)
-                    connection.slots.remove(slot)
-                    if not connection.slots:
-                        print(f"{connection.consumer} is shutting down")
-                        connection.consumer.shutdown()
-                        del self._connections[key]
-                    # Reconnect slot to remaining topics if any
-                    if remaining_topics:
-                        self.connect_slot(slot, list(remaining_topics), True)
-
-    def disconnect_all(self):
-        """Disconnect all slots from all topics."""
-        for key, connection in list(self._connections.items()):
-            for slot in list(connection.slots):
-                self._disconnect_slot_from_topic(slot, key)
-
-            if key in self._connections and not connection.slots:
-                connection.consumer.shutdown()
-                del self._connections[key]
-
-
-parser = argparse.ArgumentParser()
-parser.add_argument("--bec-config", default=None)
-args, _ = parser.parse_known_args()
-
-bec_dispatcher = _BECDispatcher(args.bec_config)
+    def disconnect_all(self, *args, **kwargs):
+        self.disconnect_topics(self.client.connector._topics_cb)
--- a/bec_widgets/utils/bec_table.py
+++ b/bec_widgets/utils/bec_table.py
@@ -1,5 +1,5 @@
-from qtpy.QtWidgets import QTableWidget
 from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QTableWidget


 class BECTable(QTableWidget):
--- a/bec_widgets/utils/colors.py
+++ b/bec_widgets/utils/colors.py
@@ -1,6 +1,8 @@
+from typing import Literal
+
 import numpy as np
 import pyqtgraph as pg
-from pyqtgraph import mkColor
+from qtpy.QtGui import QColor


 class Colors:
@@ -10,6 +12,9 @@ class Colors:

        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 = []
@@ -21,30 +26,40 @@ class Colors:
        return angles

    @staticmethod
-    def golden_angle_color(colormap: str, num: int) -> list:
+    def golden_angle_color(
+        colormap: str, num: int, format: Literal["QColor", "HEX", "RGB"] = "QColor"
+    ) -> list:
        """
-        Extract num colors for from the specified colormap following golden angle distribution.
+        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
+            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 with length <num>
+            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.color
+        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 = [
-            mkColor(tuple((cmap_colors[int(ii)] * 255).astype(int))) for ii in color_selection[:num]
-        ]
+        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
--- a/bec_widgets/utils/crosshair.py
+++ b/bec_widgets/utils/crosshair.py
@@ -2,7 +2,8 @@ import numpy as np
 import pyqtgraph as pg

 # from qtpy.QtCore import QObject, pyqtSignal
-from qtpy.QtCore import QObject, Signal as pyqtSignal
+from qtpy.QtCore import QObject
+from qtpy.QtCore import Signal as pyqtSignal


 class Crosshair(QObject):
--- a/bec_widgets/utils/entry_validator.py
+++ b/bec_widgets/utils/entry_validator.py
@@ -0,0 +1,17 @@
+class EntryValidator:
+    def __init__(self, devices):
+        self.devices = devices
+
+    def validate_signal(self, name: str, entry: str = None) -> str:
+        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
--- a/bec_widgets/utils/rpc_decorator.py
+++ b/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
--- a/bec_widgets/utils/validator_delegate.py
+++ b/bec_widgets/utils/validator_delegate.py
@@ -2,7 +2,7 @@
 # from qtpy.QtWidgets import QStyledItemDelegate, QLineEdit

 from qtpy.QtGui import QDoubleValidator
-from qtpy.QtWidgets import QStyledItemDelegate, QLineEdit
+from qtpy.QtWidgets import QLineEdit, QStyledItemDelegate


 class DoubleValidationDelegate(QStyledItemDelegate):
--- a/bec_widgets/utils/widget_io.py
+++ b/bec_widgets/utils/widget_io.py
@@ -3,16 +3,16 @@ from abc import ABC, abstractmethod

 from qtpy.QtWidgets import (
    QApplication,
-    QWidget,
-    QLineEdit,
+    QCheckBox,
    QComboBox,
-    QTableWidget,
-    QSpinBox,
    QDoubleSpinBox,
+    QLabel,
+    QLineEdit,
+    QSpinBox,
+    QTableWidget,
    QTableWidgetItem,
    QVBoxLayout,
-    QCheckBox,
-    QLabel,
+    QWidget,
 )


--- a/bec_widgets/utils/yaml_dialog.py
+++ b/bec_widgets/utils/yaml_dialog.py
@@ -1,6 +1,7 @@
 # pylint: disable=no-name-in-module

 from typing import Union
+
 import yaml
 from qtpy.QtWidgets import QFileDialog

--- a/bec_widgets/validation/monitor_config_validator.py
+++ b/bec_widgets/validation/monitor_config_validator.py
@@ -1,6 +1,6 @@
-from typing import Optional, Union, Literal
+from typing import Literal, Optional, Union

-from pydantic import BaseModel, Field, field_validator, model_validator, ValidationError
+from pydantic import BaseModel, Field, ValidationError, field_validator, model_validator
 from pydantic_core import PydanticCustomError


@@ -92,12 +92,12 @@ class SourceHistoryValidator(BaseModel):
    """History source validator
    Attributes:
        type (str): type of source - history
-        scanID (str): Scan ID for history source.
+        scan_id (str): Scan ID for history source.
        signals (list): Signal for the source.
    """

    type: Literal["history"]
-    scanID: str  # TODO can be validated if it is a valid scanID
+    scan_id: str  # TODO can be validated if it is a valid scan_id
    signals: AxisSignal


@@ -131,12 +131,12 @@ class Source(BaseModel):  # TODO decide if it should stay for general Source val
    General source validation, includes all Optional arguments of all other sources.
    Attributes:
        type (list): type of source (scan_segment, history)
-        scanID (Optional[str]): Scan ID for history source.
+        scan_id (Optional[str]): Scan ID for history source.
        signals (Optional[AxisSignal]): Signal for the source.
    """

    type: Literal["scan_segment", "history", "redis"]
-    scanID: Optional[str] = None
+    scan_id: Optional[str] = None
    signals: Optional[dict] = None


--- a/bec_widgets/widgets/init.py
+++ b/bec_widgets/widgets/init.py
@@ -1,5 +1,13 @@
-from .monitor import BECMonitor, ConfigDialog
-from .motor_map import MotorMap
-from .scan_control import ScanControl
-from .toolbar import ModularToolBar
 from .editor import BECEditor
+from .figure import BECFigure, FigureConfig
+from .monitor import BECMonitor
+from .motor_control import (
+    MotorControlAbsolute,
+    MotorControlRelative,
+    MotorControlSelection,
+    MotorCoordinateTable,
+    MotorThread,
+)
+from .motor_map import MotorMap
+from .plots import BECCurve, BECMotorMap, BECWaveform
+from .scan_control import ScanControl
--- a/bec_widgets/widgets/editor/editor.py
+++ b/bec_widgets/widgets/editor/editor.py
@@ -3,24 +3,16 @@ import subprocess
 import qdarktheme
 from jedi import Script
 from jedi.api import Completion
-
-# pylint: disable=no-name-in-module
-from qtpy.Qsci import QsciScintilla, QsciLexerPython, QsciAPIs
-from qtpy.QtCore import Qt
-from qtpy.QtCore import Signal, QThread
-from qtpy.QtGui import QColor, QFont
-from qtpy.QtWidgets import (
-    QApplication,
-    QFileDialog,
-    QTextEdit,
-    QVBoxLayout,
-    QWidget,
-)
-from qtpy.QtWidgets import QSplitter
 from qtconsole.manager import QtKernelManager
 from qtconsole.rich_jupyter_widget import RichJupyterWidget

-from bec_widgets.widgets import ModularToolBar
+# pylint: disable=no-name-in-module
+from qtpy.Qsci import QsciAPIs, QsciLexerPython, QsciScintilla
+from qtpy.QtCore import Qt, QThread, Signal
+from qtpy.QtGui import QColor, QFont
+from qtpy.QtWidgets import QApplication, QFileDialog, QSplitter, QTextEdit, QVBoxLayout, QWidget
+
+from bec_widgets.widgets.toolbar import ModularToolBar


 class AutoCompleter(QThread):
--- a/bec_widgets/widgets/editor/vscode.py
+++ b/bec_widgets/widgets/editor/vscode.py
@@ -0,0 +1,32 @@
+from qtpy.QtCore import QUrl
+from qtpy.QtWebEngineWidgets import QWebEngineView
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+
+class WebsiteWidget(QWidget):
+    def __init__(self, url):
+        super().__init__()
+        self.editor = QWebEngineView(self)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.editor)
+        self.setLayout(layout)
+        self.editor.setUrl(QUrl(url))
+
+
+class VSCodeEditor(WebsiteWidget):
+    token = "bec"
+    host = "localhost"
+    port = 7000
+
+    def __init__(self):
+        super().__init__(f"http://{self.host}:{self.port}?tkn={self.token}")
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    mainWin = WebsiteWidget("https://scilog.psi.ch")
+    mainWin.show()
+    sys.exit(app.exec())
--- a/bec_widgets/widgets/editor/vscode_server.py
+++ b/bec_widgets/widgets/editor/vscode_server.py
@@ -0,0 +1,59 @@
+"""
+Module to handle the vscode server
+"""
+
+import subprocess
+
+
+class VSCodeServer:
+    """
+    Class to handle the vscode server
+    """
+
+    _instance = None
+
+    def __init__(self, port=7000, token="bec"):
+        self.started = False
+        self._server = None
+        self.port = port
+        self.token = token
+
+    def __new__(cls, *args, forced=False, **kwargs):
+        if cls._instance is None or forced:
+            cls._instance = super(VSCodeServer, cls).__new__(cls)
+        return cls._instance
+
+    def start_server(self):
+        """
+        Start the vscode server in a subprocess
+        """
+        if self.started:
+            return
+        self._server = subprocess.Popen(
+            f"code serve-web --port {self.port} --connection-token={self.token} --accept-server-license-terms",
+            shell=True,
+        )
+        self.started = True
+
+    def wait(self):
+        """
+        Wait for the server to finish
+        """
+        if not self.started:
+            return
+        if not self._server:
+            return
+        self._server.wait()
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Start the vscode server")
+    parser.add_argument("--port", type=int, default=7000, help="Port to start the server")
+    parser.add_argument("--token", type=str, default="bec", help="Token to start the server")
+    args = parser.parse_args()
+
+    server = VSCodeServer(port=args.port, token=args.token)
+    server.start_server()
+    server.wait()
--- a/bec_widgets/widgets/figure/init.py
+++ b/bec_widgets/widgets/figure/init.py
@@ -0,0 +1 @@
+from .figure import BECFigure, FigureConfig
--- a/bec_widgets/widgets/figure/figure.py
+++ b/bec_widgets/widgets/figure/figure.py
@@ -0,0 +1,798 @@
+# pylint: disable = no-name-in-module,missing-module-docstring
+from __future__ import annotations
+
+import itertools
+import os
+from collections import defaultdict
+from typing import Literal, Optional, Type
+
+import numpy as np
+import pyqtgraph as pg
+import qdarktheme
+from pydantic import Field
+from pyqtgraph.Qt import uic
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
+
+from bec_widgets.utils import BECConnector, BECDispatcher, ConnectionConfig
+from bec_widgets.widgets.plots import (
+    BECImageShow,
+    BECMotorMap,
+    BECPlotBase,
+    BECWaveform,
+    Waveform1DConfig,
+    WidgetConfig,
+)
+from bec_widgets.widgets.plots.image import ImageConfig
+from bec_widgets.widgets.plots.motor_map import MotorMapConfig
+
+
+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, WidgetConfig] = 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, WidgetConfig),
+            "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 = [
+        "config_dict",
+        "axes",
+        "widgets",
+        "add_plot",
+        "add_image",
+        "add_motor_map",
+        "plot",
+        "image",
+        "motor_map",
+        "remove",
+        "change_layout",
+        "change_theme",
+        "clear_all",
+    ]
+
+    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 = []
+
+    @property
+    def axes(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
+
+    @axes.setter
+    def axes(self, value: list[BECPlotBase]):
+        self._axes = value
+
+    @property
+    def widgets(self) -> dict:
+        return self._widgets
+
+    @widgets.setter
+    def widgets(self, value: dict):
+        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 = self._generate_unique_widget_id()
+        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
+
+    def 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,
+        **axis_kwargs,
+    ) -> BECWaveform:
+        """
+        Add a 1D waveform plot to the figure. Always access the first waveform widget in the figure.
+        Args:
+            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.
+            x(list | np.ndarray): Custom x data to plot.
+            y(list | np.ndarray): Custom y data to plot.
+            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 = self._find_first_widget_by_class(BECWaveform, can_fail=True)
+        if waveform is not None:
+            if axis_kwargs:
+                waveform.set(**axis_kwargs)
+        else:
+            waveform = self.add_plot(**axis_kwargs)
+
+        # 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 = self._find_first_widget_by_class(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 = self._generate_unique_widget_id()
+        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 = self._find_first_widget_by_class(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 = self._generate_unique_widget_id()
+        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 = self._generate_unique_widget_id()
+        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 _find_first_widget_by_class(
+        self, widget_class: Type[BECPlotBase], can_fail: bool = True
+    ) -> BECPlotBase | None:
+        """
+        Find the first widget of a given class in the figure.
+        Args:
+            widget_class(Type[BECPlotBase]): 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:
+            BECPlotBase: The widget of the given class.
+        """
+        for widget_id, widget in self._widgets.items():
+            if isinstance(widget, widget_class):
+                return widget
+        if can_fail:
+            return None
+        else:
+            raise ValueError(f"No widget of class {widget_class} found.")
+
+    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._get_widget_by_coordinates(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)
+            print(f"Removed widget {widget_id}.")
+        else:
+            raise ValueError(f"Widget with ID '{widget_id}' does not exist.")
+
+    def __getitem__(self, key: tuple | str):
+        if isinstance(key, tuple) and len(key) == 2:
+            return self._get_widget_by_coordinates(*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)"
+            )
+
+    def _get_widget_by_coordinates(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 _generate_unique_widget_id(self):
+        """Generate a unique widget ID."""
+        existing_ids = set(self._widgets.keys())
+        for i in itertools.count(1):
+            widget_id = f"widget_{i}"
+            if widget_id not in existing_ids:
+                return widget_id
+
+    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."""
+        print(f"old grid: {self.grid}")
+        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 self._widgets.values():
+        #     widget.cleanup()
+        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
+        )
--- a/bec_widgets/widgets/monitor/init.py
+++ b/bec_widgets/widgets/monitor/init.py
@@ -1,2 +1 @@
 from .monitor import BECMonitor
-from .config_dialog import ConfigDialog
--- a/bec_widgets/widgets/monitor/config_dialog.py
+++ b/bec_widgets/widgets/monitor/config_dialog.py
@@ -1,18 +1,22 @@
 import os

+from pydantic import ValidationError
 from qtpy import uic
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtWidgets import (
    QApplication,
-    QWidget,
-    QVBoxLayout,
-    QTableWidget,
-    QTabWidget,
-    QTableWidgetItem,
    QLineEdit,
+    QMessageBox,
+    QTableWidget,
+    QTableWidgetItem,
+    QTabWidget,
+    QVBoxLayout,
+    QWidget,
 )

+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 from bec_widgets.utils.yaml_dialog import load_yaml, save_yaml
+from bec_widgets.validation import MonitorConfigValidator

 current_path = os.path.dirname(__file__)
 Ui_Form, BaseClass = uic.loadUiType(os.path.join(current_path, "config_dialog.ui"))
@@ -168,10 +172,25 @@ CONFIG_SCAN_MODE = {
 class ConfigDialog(QWidget, Ui_Form):
    config_updated = pyqtSignal(dict)

-    def __init__(self, default_config=None):
+    def __init__(
+        self,
+        client=None,
+        default_config=None,
+        skip_validation: bool = False,
+    ):
        super(ConfigDialog, self).__init__()
        self.setupUi(self)

+        # Client
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.dev = self.client.device_manager.devices
+
+        # Init validator
+        self.skip_validation = skip_validation
+        if self.skip_validation is False:
+            self.validator = MonitorConfigValidator(self.dev)
+
        # Connect the Ok/Apply/Cancel buttons
        self.pushButton_ok.clicked.connect(self.apply_and_close)
        self.pushButton_apply.clicked.connect(self.apply_config)
@@ -522,8 +541,45 @@ class ConfigDialog(QWidget, Ui_Form):

    def apply_and_close(self):
        new_config = self.apply_config()
-        self.config_updated.emit(new_config)
-        self.close()
+        if self.skip_validation is True:
+            self.config_updated.emit(new_config)
+            self.close()
+        else:
+            try:
+                validated_config = self.validator.validate_monitor_config(new_config)
+                approved_config = validated_config.model_dump()
+                self.config_updated.emit(approved_config)
+                self.close()
+            except ValidationError as e:
+                error_str = str(e)
+                formatted_error_message = ConfigDialog.format_validation_error(error_str)
+
+                # Display the formatted error message in a popup
+                QMessageBox.critical(self, "Configuration Error", formatted_error_message)
+
+    @staticmethod
+    def format_validation_error(error_str: str) -> str:
+        """
+        Format the validation error string to be displayed in a popup.
+        Args:
+            error_str(str): Error string from the validation error.
+        """
+        error_lines = error_str.split("\n")
+        # The first line contains the number of errors.
+        error_header = f"<p><b>{error_lines[0]}</b></p><hr>"
+
+        formatted_error_message = error_header
+        # Skip the first line as it's the header.
+        error_details = error_lines[1:]
+
+        # Iterate through pairs of lines (each error's two lines).
+        for i in range(0, len(error_details), 2):
+            location = error_details[i]
+            message = error_details[i + 1] if i + 1 < len(error_details) else ""
+
+            formatted_error_message += f"<p><b>{location}</b><br>{message}</p><hr>"
+
+        return formatted_error_message


 if __name__ == "__main__":  # pragma: no cover
--- a/bec_widgets/widgets/monitor/monitor.py
+++ b/bec_widgets/widgets/monitor/monitor.py
@@ -11,8 +11,9 @@ from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QApplication, QMessageBox

 from bec_widgets.utils import Colors, Crosshair, yaml_dialog
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 from bec_widgets.validation import MonitorConfigValidator
-from bec_widgets.utils.bec_dispatcher import bec_dispatcher
+from bec_widgets.widgets.monitor.config_dialog import ConfigDialog

 # just for demonstration purposes if script run directly
 CONFIG_SCAN_MODE = {
@@ -33,7 +34,7 @@ CONFIG_SCAN_MODE = {
                        "type": "scan_segment",
                        "signals": {
                            "x": [{"name": "samx", "entry": "samx"}],
-                            "y": [{"name": "gauss_bpm"}],
+                            "y": [{"name": "bpm4i"}],
                        },
                    }
                ],
@@ -47,7 +48,7 @@ CONFIG_SCAN_MODE = {
                        "type": "scan_segment",
                        "signals": {
                            "x": [{"name": "samx", "entry": "samx"}],
-                            "y": [{"name": "gauss_adc1"}],
+                            "y": [{"name": "bpm4i"}],
                        },
                    }
                ],
@@ -59,10 +60,7 @@ CONFIG_SCAN_MODE = {
                "sources": [
                    {
                        "type": "scan_segment",
-                        "signals": {
-                            "x": [{"name": "samy"}],
-                            "y": [{"name": "gauss_adc2"}],
-                        },
+                        "signals": {"x": [{"name": "samy"}], "y": [{"name": "bpm4i"}]},
                    }
                ],
            },
@@ -75,7 +73,7 @@ CONFIG_SCAN_MODE = {
                        "type": "scan_segment",
                        "signals": {
                            "x": [{"name": "samy", "entry": "samy"}],
-                            "y": [{"name": "gauss_adc3"}],
+                            "y": [{"name": "bpm4i"}],
                        },
                    }
                ],
@@ -105,7 +103,7 @@ CONFIG_SCAN_MODE = {
                        "type": "scan_segment",
                        "signals": {
                            "x": [{"name": "samx", "entry": "samx"}],
-                            "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
+                            "y": [{"name": "bpm4i"}, {"name": "bpm4i"}],
                        },
                    }
                ],
@@ -137,7 +135,7 @@ CONFIG_WRONG = {
                },
                {
                    "type": "history",
-                    "scanID": "<scanID>",
+                    "scan_id": "<scan_id>",
                    "signals": {
                        "x": [{"name": "samy"}],
                        "y": [{"name": "bpm4i", "entry": "bpm4i"}],
@@ -170,11 +168,8 @@ CONFIG_WRONG = {
                {
                    "signals": {
                        "x": [{"name": "samx", "entry": "samx"}],
-                        "y": [
-                            {"name": "samx"},
-                            {"name": "samy", "entry": "samx"},
-                        ],
-                    },
+                        "y": [{"name": "samx"}, {"name": "samy", "entry": "samx"}],
+                    }
                }
            ],
        },
@@ -228,7 +223,7 @@ CONFIG_SIMPLE = {
                    "type": "scan_segment",
                    "signals": {
                        "x": [{"name": "samx", "entry": "samx"}],
-                        "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
+                        "y": [{"name": "bpm4i"}, {"name": "bpm4i"}],
                    },
                }
            ],
@@ -282,6 +277,7 @@ class BECMonitor(pg.GraphicsLayoutWidget):

        # Client and device manager from BEC
        self.plot_data = None
+        bec_dispatcher = BECDispatcher()
        self.client = bec_dispatcher.client if client is None else client
        self.dev = self.client.device_manager.devices
        self.queue = self.client.queue
@@ -308,13 +304,13 @@ class BECMonitor(pg.GraphicsLayoutWidget):
        self.enable_crosshair = enable_crosshair

        # Displayed Data
-        self.database = {}
+        self.database = None

        self.crosshairs = None
        self.plots = None
        self.curves_data = None
        self.grid_coordinates = None
-        self.scanID = None
+        self.scan_id = None

        # TODO make colors accessible to users
        self.user_colors = {}  # key: (plot_name, y_name, y_entry), value: color
@@ -351,6 +347,9 @@ class BECMonitor(pg.GraphicsLayoutWidget):
        # Initialize the UI
        self._init_ui(self.plot_settings["num_columns"])

+        if self.scan_id is not None:
+            self.replot_last_scan()
+
    def _init_database(self, plot_data_config: dict, source_type_to_init=None) -> dict:
        """
        Initializes or updates the database for the PlotApp.
@@ -598,9 +597,10 @@ class BECMonitor(pg.GraphicsLayoutWidget):

    def show_config_dialog(self):
        """Show the configuration dialog."""
-        from bec_widgets.widgets import ConfigDialog

-        dialog = ConfigDialog(default_config=self.config)
+        dialog = ConfigDialog(
+            client=self.client, default_config=self.config, skip_validation=self.skip_validation
+        )
        dialog.config_updated.connect(self.on_config_update)
        dialog.show()

@@ -723,11 +723,11 @@ class BECMonitor(pg.GraphicsLayoutWidget):
            msg (dict): Message received with scan data.
            metadata (dict): Metadata of the scan.
        """
-        current_scanID = msg.get("scanID", None)
-        if current_scanID is None:
+        current_scan_id = msg.get("scan_id", None)
+        if current_scan_id is None:
            return

-        if current_scanID != self.scanID:
+        if current_scan_id != self.scan_id:
            if self.scan_types is False:
                self.plot_data = self.plot_data_config
            elif self.scan_types is True:
@@ -747,10 +747,10 @@ class BECMonitor(pg.GraphicsLayoutWidget):
                # Init UI
                self._init_ui(self.plot_settings["num_columns"])

-            self.scanID = current_scanID
-            self.scan_data = self.queue.scan_storage.find_scan_by_ID(self.scanID)
+            self.scan_id = current_scan_id
+            self.scan_data = self.queue.scan_storage.find_scan_by_ID(self.scan_id)
            if not self.scan_data:
-                print(f"No data found for scanID: {self.scanID}")  # TODO better error
+                print(f"No data found for scan_id: {self.scan_id}")  # TODO better error
                return
            self.flush(source_type_to_flush="scan_segment")

@@ -760,7 +760,7 @@ class BECMonitor(pg.GraphicsLayoutWidget):

    def scan_segment_update(self):
        """
-        Update the database with data from scan storage based on the provided scanID.
+        Update the database with data from scan storage based on the provided scan_id.
        """
        scan_data = self.scan_data.data
        for device_name, device_entries in self.database.get("scan_segment", {}).items():
@@ -771,6 +771,13 @@ class BECMonitor(pg.GraphicsLayoutWidget):
                else:
                    print(f"No data found for {device_name} {entry}")

+    def replot_last_scan(self):
+        """
+        Replot the last scan.
+        """
+        self.scan_segment_update()
+        self.update_plot(source_type="scan_segment")
+
    @pyqtSlot(dict)
    def on_data_from_redis(self, msg) -> None:
        """
@@ -824,14 +831,10 @@ if __name__ == "__main__":  # pragma: no cover
    else:
        config = CONFIG_SIMPLE

-    client = bec_dispatcher.client
+    client = BECDispatcher().client
    client.start()
    app = QApplication(sys.argv)
-    monitor = BECMonitor(
-        config=config,
-        gui_id=args.id,
-        skip_validation=False,
-    )
+    monitor = BECMonitor(config=config, gui_id=args.id, skip_validation=False)
    monitor.show()
    # just to test redis data
    # redis_data = {
--- a/bec_widgets/widgets/motor_control/init.py
+++ b/bec_widgets/widgets/motor_control/init.py
@@ -0,0 +1,7 @@
+from .motor_control import (
+    MotorControlAbsolute,
+    MotorControlRelative,
+    MotorControlSelection,
+    MotorCoordinateTable,
+    MotorThread,
+)
--- a/bec_widgets/widgets/motor_control/motor_control.py
+++ b/bec_widgets/widgets/motor_control/motor_control.py
--- a/bec_widgets/widgets/motor_control/motor_control_absolute.ui
+++ b/bec_widgets/widgets/motor_control/motor_control_absolute.ui
@@ -0,0 +1,149 @@
+<?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>285</width>
+    <height>220</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>285</width>
+    <height>220</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>285</width>
+    <height>220</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Move Movement Absolute</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_2">
+   <item>
+    <widget class="QGroupBox" name="motorControl_absolute">
+     <property name="minimumSize">
+      <size>
+       <width>261</width>
+       <height>195</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>261</width>
+       <height>195</height>
+      </size>
+     </property>
+     <property name="title">
+      <string>Move Movement 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="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="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>
+          </property>
+          <property name="alignment">
+           <set>Qt::AlignCenter</set>
+          </property>
+         </widget>
+        </item>
+        <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>
+       </layout>
+      </item>
+      <item>
+       <widget class="QPushButton" name="pushButton_stop">
+        <property name="text">
+         <string>Stop Movement</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
--- a/bec_widgets/widgets/motor_control/motor_control_relative.ui
+++ b/bec_widgets/widgets/motor_control/motor_control_relative.ui
@@ -0,0 +1,298 @@
+<?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>285</width>
+    <height>405</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>285</width>
+    <height>405</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Motor Control Relative</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QGroupBox" name="motorControl">
+     <property name="minimumSize">
+      <size>
+       <width>261</width>
+       <height>394</height>
+      </size>
+     </property>
+     <property name="title">
+      <string>Motor Control Relative</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_5">
+      <item>
+       <widget class="QCheckBox" name="checkBox_enableArrows">
+        <property name="text">
+         <string>Move with arrow keys</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <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>
+          <property name="arrowType">
+           <enum>Qt::UpArrow</enum>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="4">
+         <spacer name="horizontalSpacer_2">
+          <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 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>
+          <property name="arrowType">
+           <enum>Qt::DownArrow</enum>
+          </property>
+         </widget>
+        </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>
+          <property name="arrowType">
+           <enum>Qt::LeftArrow</enum>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="2">
+         <spacer name="verticalSpacer">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>20</width>
+            <height>40</height>
+           </size>
+          </property>
+         </spacer>
+        </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>
+          <property name="arrowType">
+           <enum>Qt::RightArrow</enum>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="0">
+         <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>
+        <item row="4" column="2">
+         <spacer name="verticalSpacer_2">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>20</width>
+            <height>40</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <widget class="QPushButton" name="pushButton_stop">
+        <property name="text">
+         <string>Stop Movement</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
--- a/bec_widgets/widgets/motor_control/motor_control_selection.ui
+++ b/bec_widgets/widgets/motor_control/motor_control_selection.ui
@@ -0,0 +1,69 @@
+<?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>285</width>
+    <height>156</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>285</width>
+    <height>156</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Motor Control Selection</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <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>
+     <layout class="QGridLayout" name="gridLayout_4">
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_5">
+        <property name="text">
+         <string>Motor X</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QComboBox" name="comboBox_motor_x"/>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_8">
+        <property name="text">
+         <string>Motor Y</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0" colspan="2">
+       <widget class="QPushButton" name="pushButton_connecMotors">
+        <property name="text">
+         <string>Connect Motors</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QComboBox" name="comboBox_motor_y"/>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
--- a/bec_widgets/widgets/motor_control/motor_control_table.ui
+++ b/bec_widgets/widgets/motor_control/motor_control_table.ui
@@ -0,0 +1,113 @@
+<?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>676</width>
+    <height>667</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Motor Coordinates Table</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_3">
+     <item>
+      <spacer name="horizontalSpacer_4">
+       <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="QCheckBox" name="checkBox_resize_auto">
+       <property name="text">
+        <string>Resize Auto</string>
+       </property>
+       <property name="checked">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton_editColumns">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
+       <property name="text">
+        <string>Edit Custom Column</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="label">
+       <property name="text">
+        <string>Entries Mode:</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QComboBox" name="comboBox_mode">
+       <property name="enabled">
+        <bool>true</bool>
+       </property>
+       <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="table">
+     <property name="gridStyle">
+      <enum>Qt::SolidLine</enum>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QPushButton" name="pushButton_importCSV">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
+       <property name="text">
+        <string>Import CSV</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pushButton_exportCSV">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
+       <property name="text">
+        <string>Export CSV</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
--- a/bec_widgets/widgets/motor_map/motor_map.py
+++ b/bec_widgets/widgets/motor_map/motor_map.py
@@ -7,14 +7,13 @@ from typing import Any, Union
 import numpy as np
 import pyqtgraph as pg
 from bec_lib import MessageEndpoints
-from qtpy import QtCore
-from qtpy import QtGui
+from qtpy import QtCore, QtGui
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QApplication

+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 from bec_widgets.utils.yaml_dialog import load_yaml
-from bec_widgets.utils.bec_dispatcher import bec_dispatcher

 CONFIG_DEFAULT = {
    "plot_settings": {
@@ -63,6 +62,7 @@ class MotorMap(pg.GraphicsLayoutWidget):
        super().__init__(parent=parent)

        # Import BEC related stuff
+        bec_dispatcher = BECDispatcher()
        self.client = bec_dispatcher.client if client is None else client
        self.dev = self.client.device_manager.devices

@@ -121,6 +121,28 @@ class MotorMap(pg.GraphicsLayoutWidget):
        else:  # TODO implement validator
            print("Do validation")

+    @pyqtSlot(str, str, int)
+    def change_motors(self, motor_x: str, motor_y: str, subplot: int = 0) -> 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.
+            subplot(int): Subplot number.
+        """
+        if subplot >= len(self.plot_data):
+            print(f"Invalid subplot index: {subplot}. Available subplots: {len(self.plot_data)}")
+            return
+
+        # Update the motor names in the plot configuration
+        self.config["motors"][subplot]["signals"]["x"][0]["name"] = motor_x
+        self.config["motors"][subplot]["signals"]["x"][0]["entry"] = motor_x
+        self.config["motors"][subplot]["signals"]["y"][0]["name"] = motor_y
+        self.config["motors"][subplot]["signals"]["y"][0]["entry"] = motor_y
+
+        # reinitialise the config and UI
+        self._init_config()
+
    def _init_config(self):
        """Initiate the configuration."""

@@ -145,6 +167,9 @@ class MotorMap(pg.GraphicsLayoutWidget):
        # Connect motors to slots
        self._connect_motors_to_slots()

+        # Render init position of selected motors
+        self._update_plots()
+
    def _get_global_settings(self):
        """Get global settings from the config."""
        self.plot_settings = self.config.get("plot_settings", {})
@@ -172,6 +197,7 @@ class MotorMap(pg.GraphicsLayoutWidget):
        """Connect motors to slots."""

        # Disconnect all slots before connecting a new ones
+        bec_dispatcher = BECDispatcher()
        bec_dispatcher.disconnect_all()

        # Get list of all unique motors
@@ -191,7 +217,6 @@ class MotorMap(pg.GraphicsLayoutWidget):
        bec_dispatcher.connect_slot(
            self.on_device_readback,
            endpoints,
-            single_callback_for_all_topics=True,
        )

    def _add_limits_to_plot_data(self):
@@ -486,6 +511,32 @@ class MotorMap(pg.GraphicsLayoutWidget):
                self.curves_data[plot_name]["highlight_V"].setPos(current_x)
                self.curves_data[plot_name]["highlight_H"].setPos(current_y)

+    @pyqtSlot(list, str, str)
+    def plot_saved_coordinates(self, coordinates: list, tag: str, color: str):
+        """
+        Plot saved coordinates on the map.
+        Args:
+            coordinates(list): List of coordinates to be plotted.
+            tag(str): Tag for the coordinates for future reference.
+            color(str): Color to plot coordinates in.
+        """
+        for plot_name in self.plots:
+            plot = self.plots[plot_name]
+
+            # Clear previous saved points
+            if tag in self.curves_data[plot_name]:
+                plot.removeItem(self.curves_data[plot_name][tag])
+
+            # Filter coordinates to be shown
+            visible_coords = [coord[:2] for coord in coordinates if coord[2]]
+
+            if visible_coords:
+                saved_points = pg.ScatterPlotItem(
+                    pos=np.array(visible_coords), brush=pg.mkBrush(color)
+                )
+                plot.addItem(saved_points)
+                self.curves_data[plot_name][tag] = saved_points
+
    @pyqtSlot(dict)
    def on_device_readback(self, msg: dict):
        """
@@ -541,7 +592,7 @@ if __name__ == "__main__":  # pragma: no cover
    else:
        config = CONFIG_DEFAULT

-    client = bec_dispatcher.client
+    client = BECDispatcher().client
    client.start()
    app = QApplication(sys.argv)
    motor_map = MotorMap(
--- a/bec_widgets/widgets/plots/init.py
+++ b/bec_widgets/widgets/plots/init.py
@@ -0,0 +1,4 @@
+from .image import BECImageItem, BECImageShow, ImageItemConfig
+from .motor_map import BECMotorMap, MotorMapConfig
+from .plot_base import AxisConfig, BECPlotBase, WidgetConfig
+from .waveform import BECCurve, BECWaveform, Waveform1DConfig
--- a/bec_widgets/widgets/plots/image.py
+++ b/bec_widgets/widgets/plots/image.py
@@ -0,0 +1,923 @@
+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 import MessageEndpoints
+from pydantic import BaseModel, Field, ValidationError
+from qtpy.QtCore import QObject, QThread
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import BECConnector, ConnectionConfig
+
+from .plot_base import BECPlotBase, WidgetConfig
+
+
+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 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 ImageConfig(WidgetConfig):
+    images: dict[str, ImageItemConfig] = Field(
+        {},
+        description="The configuration of the images. The key is the name of the image (source).",
+    )
+
+
+class BECImageItem(BECConnector, pg.ImageItem):
+    USER_ACCESS = [
+        "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[BECImageItem] = 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'")
+
+
+class BECImageShow(BECPlotBase):
+    USER_ACCESS = [
+        "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
+        )
+
+        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_widget_by_id(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 monitor, image_item in images.items():
+                if image_item.gui_id == item_id:
+                    return image_item
+
+    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 | WidgetConfig):
+        """
+        Apply the configuration to the 1D waveform widget.
+        Args:
+            config(dict|WidgetConfig): 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}'."
+            )
+
+        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:
+            print("using threaded version")
+            self._create_thread_worker(device, data)
+        else:
+            print("using NON-threaded version")
+            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 cleanup(self):
+        """
+        Clean up the widget.
+        """
+        print(f"Cleaning up {self.gui_id}")
+        # for monitor in self._images["device_monitor"]:
+        #     self.bec_dispatcher.disconnect_slot(
+        #         self.on_image_update, MessageEndpoints.device_monitor(monitor)
+        #     )
+        # if self.thread is not None and self.thread.isRunning():
+        #     self.thread.quit()
+        #     self.thread.wait()
+
+
+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 = pyqtSignal(str, np.ndarray)
+    stopRequested = pyqtSignal()
+    finished = pyqtSignal()
+
+    def __init__(self, processor):
+        super().__init__()
+        self.processor = processor
+        self._isRunning = False
+        self.stopRequested.connect(self.stop)
+
+    @pyqtSlot(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
--- a/bec_widgets/widgets/plots/motor_map.py
+++ b/bec_widgets/widgets/plots/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 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.plots.plot_base import BECPlotBase, WidgetConfig
+from bec_widgets.widgets.plots.waveform import Signal, SignalData
+
+
+class MotorMapConfig(WidgetConfig):
+    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 _connect_motor_to_slots(self):
+        """Connect motors to slots."""
+        if self.motor_x is not None and self.motor_y is not None:
+            old_endpoints = [
+                MessageEndpoints.device_readback(self.motor_x),
+                MessageEndpoints.device_readback(self.motor_y),
+            ]
+            self.bec_dispatcher.disconnect_slot(self.on_device_readback, old_endpoints)
+
+        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()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    import pyqtgraph as pg
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    glw = pg.GraphicsLayoutWidget()
+    motor_map = BECMotorMap()
+    motor_map.change_motors("samx", "samy")
+    glw.addItem(motor_map)
+    widget = glw
+    widget.show()
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/plots/plot_base.py
+++ b/bec_widgets/widgets/plots/plot_base.py
@@ -0,0 +1,249 @@
+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 WidgetConfig(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[WidgetConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = WidgetConfig(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.figure.remove(widget_id=self.gui_id)
+
+    def cleanup(self):
+        """Cleanup the plot widget."""
--- a/bec_widgets/widgets/plots/waveform.py
+++ b/bec_widgets/widgets/plots/waveform.py
@@ -0,0 +1,798 @@
+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 import MessageEndpoints
+from bec_lib.scan_data import ScanData
+from pydantic import BaseModel, Field, ValidationError
+from pyqtgraph import mkBrush
+from qtpy import QtCore
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import BECConnector, Colors, ConnectionConfig, EntryValidator
+from bec_widgets.widgets.plots.plot_base import BECPlotBase, WidgetConfig
+
+
+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 Waveform1DConfig(WidgetConfig):
+    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 BECCurve(BECConnector, pg.PlotDataItem):
+    USER_ACCESS = [
+        "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,
+        **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.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 = 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
+
+
+class BECWaveform(BECPlotBase):
+    USER_ACCESS = [
+        "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 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
+
+    def apply_config(self, config: dict | WidgetConfig, replot_last_scan: bool = False):
+        """
+        Apply the configuration to the 1D waveform widget.
+        Args:
+            config(dict|WidgetConfig): 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)
+        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())
--- a/bec_widgets/widgets/scan_control/scan_control.py
+++ b/bec_widgets/widgets/scan_control/scan_control.py
@@ -1,26 +1,27 @@
 import msgpack
+from bec_lib import MessageEndpoints
 from qtpy.QtWidgets import (
    QApplication,
-    QWidget,
-    QComboBox,
-    QPushButton,
-    QVBoxLayout,
-    QGroupBox,
-    QLabel,
-    QLineEdit,
-    QDoubleSpinBox,
-    QSpinBox,
    QCheckBox,
+    QComboBox,
+    QDoubleSpinBox,
    QFrame,
-    QHBoxLayout,
-    QLayout,
    QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLayout,
+    QLineEdit,
+    QPushButton,
+    QSpinBox,
    QTableWidget,
    QTableWidgetItem,
-    QHeaderView,
+    QVBoxLayout,
+    QWidget,
 )

-from bec_lib import MessageEndpoints
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 from bec_widgets.utils.widget_io import WidgetIO


@@ -45,7 +46,7 @@ class ScanControl(QWidget):
        super().__init__(parent)

        # Client from BEC + shortcuts to device manager and scans
-        self.client = bec_dispatcher.client if client is None else client
+        self.client = BECDispatcher().client if client is None else client
        self.dev = self.client.device_manager.devices
        self.scans = self.client.scans

@@ -118,8 +119,7 @@ class ScanControl(QWidget):

    def populate_scans(self):
        """Populates the scan selection combo box with available scans"""
-        msg = self.client.producer.get(MessageEndpoints.available_scans())
-        self.available_scans = msgpack.loads(msg)
+        self.available_scans = self.client.producer.get(MessageEndpoints.available_scans()).resource
        if self.allowed_scans is None:
            allowed_scans = self.available_scans.keys()
        else:
@@ -425,10 +425,8 @@ class ScanControl(QWidget):

 # Application example
 if __name__ == "__main__":  # pragma: no cover
-    from bec_widgets.utils.bec_dispatcher import bec_dispatcher
-
    # BECclient global variables
-    client = bec_dispatcher.client
+    client = BECDispatcher().client
    client.start()

    app = QApplication([])
--- a/bec_widgets/widgets/scan_plot/init.py
+++ b/bec_widgets/widgets/scan_plot/init.py
--- a/bec_widgets/widgets/scan_plot/scan2d_plot.py
+++ b/bec_widgets/widgets/scan_plot/scan2d_plot.py
@@ -1,152 +0,0 @@
-from threading import RLock
-
-import numpy as np
-import pyqtgraph as pg
-from bec_lib import MessageEndpoints
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import Property as pyqtProperty, Slot as pyqtSlot
-
-from bec_widgets.utils.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_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
-
-        self._scanID = None
-        self._scanID_lock = RLock()
-
-        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)
-
-    def reset_plots(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):
-        # reset plots on scanID change
-        with self._scanID_lock:
-            scan_id = scan_segment["scanID"]
-            if self._scanID != scan_id:
-                self._scanID = scan_id
-                self.reset_plots(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 qtpy.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())
--- a/bec_widgets/widgets/scan_plot/scan_plot.py
+++ b/bec_widgets/widgets/scan_plot/scan_plot.py
@@ -1,151 +0,0 @@
-import itertools
-from threading import RLock
-
-import pyqtgraph as pg
-from bec_lib import MessageEndpoints
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import Property as pyqtProperty, Slot as pyqtSlot
-
-from bec_widgets.utils.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_slot(self.on_scan_segment, MessageEndpoints.scan_segment())
-
-        self.view = pg.PlotItem()
-        self.setCentralItem(self.view)
-
-        self._scanID = None
-        self._scanID_lock = RLock()
-
-        self._x_channel = ""
-        self._y_channel_list = []
-
-        self.scan_curves = {}
-        self.dap_curves = {}
-
-    def reset_plots(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):
-        # reset plots on scanID change
-        with self._scanID_lock:
-            scan_id = scan_segment["scanID"]
-            if self._scanID != scan_id:
-                self._scanID = scan_id
-                self.reset_plots(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, content, _metadata):
-        data = content["data"]
-        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]
-            chan_removed_ep = MessageEndpoints.processed_data(chan_removed)
-            bec_dispatcher.disconnect_slot(self.redraw_dap, chan_removed_ep)
-
-        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
-                y_chan_ep = MessageEndpoints.processed_data(y_chan)
-                bec_dispatcher.connect_slot(self.redraw_dap, y_chan_ep)
-            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 qtpy.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())
--- a/bec_widgets/widgets/toolbar/toolbar.py
+++ b/bec_widgets/widgets/toolbar/toolbar.py
@@ -1,11 +1,9 @@
 from abc import ABC, abstractmethod

 # pylint: disable=no-name-in-module
-from qtpy.QtCore import QSize
-from qtpy.QtWidgets import QToolBar, QStyle, QApplication
-from qtpy.QtCore import QTimer
+from qtpy.QtCore import QSize, QTimer
 from qtpy.QtGui import QAction
-from qtpy.QtWidgets import QWidget
+from qtpy.QtWidgets import QApplication, QStyle, QToolBar, QWidget


 class ToolBarAction(ABC):
--- a/docs/developer/developer.md
+++ b/docs/developer/developer.md
@@ -1,6 +1,14 @@
 (developer)=
 # Development

+```{toctree}
+---
+maxdepth: 1
+hidden: true
+---
+reference/
+```
+
 To contribute to the development of BEC Widgets, start by setting up the development environment:

 1. **Clone the Repository**: 
@@ -13,4 +21,6 @@ cd bec-widgets
 Installing the package in editable mode allows you to make changes to the code and test them in real-time.
 ```bash
 pip install -e .[dev]
-```
+```
+
+
--- a/docs/developer/reference.md
+++ b/docs/developer/reference.md
@@ -0,0 +1,10 @@
+## API Reference
+
+```{eval-rst}
+.. autosummary::
+   :toctree: _autosummary
+   :template: custom-module-template.rst
+   :recursive:
+
+   bec_widgets
+```
--- a/docs/user/apps/motor_app.md
+++ b/docs/user/apps/motor_app.md
@@ -1,4 +1,34 @@
 (user.apps.motor_app)=
 # Motor Alignment

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

 Before installing BEC Widgets, please ensure the following requirements are met:

-1. **Python Version:** BEC Widgets requires Python version 3.9 or higher. Verify your Python version to ensure compatibility.
+1. **Python Version:** BEC Widgets requires Python version 3.10 or higher. Verify your Python version to ensure compatibility.
 2. **BEC Installation:** BEC Widgets works in conjunction with BEC. While BEC is a dependency and will be installed automatically, you can find more information about BEC and its installation process in the [BEC documentation](https://beamline-experiment-control.readthedocs.io/en/latest/).

 **Standard Installation**
@@ -43,4 +43,4 @@ If you encounter issues during installation, particularly with PyQt, try purging
 pip cache purge
 ```

-This can resolve conflicts or issues with package installations.
+This can resolve conflicts or issues with package installations.
--- a/docs/user/widgets.md
+++ b/docs/user/widgets.md
@@ -1,6 +1,41 @@
 (user.widgets)=
 # Widgets

-Guide to use widgets.
+## Visualization Widgets

-_work in progress_
+BEC Widgets includes a variety of visualization widgets designed to cater to diverse data representation needs in beamline experiments. These widgets enhance the user experience by providing intuitive and interactive data visualizations.
+
+### 1D Waveform Widget
+
+**Purpose:** This widget provides a straightforward visualization of 1D data. It is particularly useful for plotting positioner movements against detector readings, enabling users to observe correlations and patterns in a simple, linear format.
+
+**Key Features:**
+- Real-time plotting of positioner versus detector values.
+- Interactive controls for zooming and panning through the data.
+- Customizable visual elements such as line color and style.
+
+**Example of Use:**
+![Waveform 1D](./widgets/w1D.gif)
+### 2D Scatter Plot
+
+**Purpose:** The 2D scatter plot widget is designed for more complex data visualization. It employs a false color map to represent a third dimension (z-axis), making it an ideal tool for visualizing multidimensional data sets.
+
+**Key Features:**
+
+- 2D scatter plot with color-coded data points based on a third variable (two positioners for x/y vs. one detector for colormap).
+- Interactive false color map for enhanced data interpretation.
+- Tools for selecting and inspecting specific data points.
+
+**Example of Use:**
+![Waveform 1D](./widgets/scatter_2D.gif)
+### Motor Position Map
+
+**Purpose:** A specialized component derived from the Motor Alignment Tool. It's focused on tracking and visualizing the position of motors, crucial for precise alignment and movement tracking during scans.
+
+**Key Features:**
+- Real-time tracking of motor positions.
+- Visual representation of motor trajectories, aiding in alignment tasks.
+- Ability to record and recall specific motor positions for repetitive tasks.
+
+**Example of Use:**
+![Waveform 1D](./widgets/motor.gif)
--- a/docs/user/widgets/motor.gif
+++ b/docs/user/widgets/motor.gif
--- a/docs/user/widgets/scatter_2D.gif
+++ b/docs/user/widgets/scatter_2D.gif
--- a/docs/user/widgets/w1D.gif
+++ b/docs/user/widgets/w1D.gif
--- a/setup.cfg
+++ b/setup.cfg
@@ -15,7 +15,7 @@ classifiers =
 package_dir =
    = .
 packages = find:
-python_requires = >=3.9
+python_requires = >=3.10

 [options.packages.find]
 where = .
--- a/setup.py
+++ b/setup.py
@@ -1,7 +1,7 @@
 # pylint: disable= missing-module-docstring
-from setuptools import setup
+from setuptools import find_packages, setup

-__version__ = "0.37.0"
+__version__ = "0.46.6"

 # Default to PyQt6 if no other Qt binding is installed
 QT_DEPENDENCY = "PyQt6>=6.0"
@@ -30,11 +30,23 @@ if __name__ == "__main__":
            "zmq",
            "h5py",
            "pyqtdarktheme",
+            "black",
        ],
        extras_require={
-            "dev": ["pytest", "pytest-random-order", "coverage", "pytest-qt", "black"],
+            "dev": [
+                "pytest",
+                "pytest-random-order",
+                "pytest-timeout",
+                "coverage",
+                "pytest-qt",
+                "black",
+                "isort",
+            ],
            "pyqt5": ["PyQt5>=5.9"],
            "pyqt6": ["PyQt6>=6.0"],
        },
        version=__version__,
+        packages=find_packages(),
+        include_package_data=True,
+        package_data={"": ["*.ui", "*.yaml"]},
    )
--- a/bec_widgets/examples/oneplot/init.py
+++ b/bec_widgets/examples/oneplot/init.py
--- a/tests/end-2-end/test_bec_figure_rpc.py
+++ b/tests/end-2-end/test_bec_figure_rpc.py
@@ -0,0 +1,181 @@
+import numpy as np
+import pytest
+from bec_lib import MessageEndpoints
+
+from bec_widgets.cli.client import BECFigure, BECImageShow, BECMotorMap, BECWaveform
+from bec_widgets.cli.server import BECWidgetsCLIServer
+from bec_widgets.utils import BECDispatcher
+
+
+@pytest.fixture
+def rpc_server(qtbot, bec_client_lib, threads_check):
+    dispatcher = BECDispatcher(client=bec_client_lib)  # Has to init singleton with fixture client
+    server = BECWidgetsCLIServer(gui_id="id_test")
+    qtbot.addWidget(server.fig)
+    qtbot.waitExposed(server.fig)
+    qtbot.wait(1000)  # 1s long to wait until gui is ready
+    yield server
+    dispatcher.disconnect_all()
+    server.client.shutdown()
+    server.shutdown()
+    dispatcher.reset_singleton()
+
+
+def test_rpc_waveform1d_custom_curve(rpc_server, qtbot):
+    fig = BECFigure(rpc_server.gui_id)
+    fig_server = rpc_server.fig
+
+    ax = fig.add_plot()
+    curve = ax.add_curve_custom([1, 2, 3], [1, 2, 3])
+    curve.set_color("red")
+    curve = ax.curves[0]
+    curve.set_color("blue")
+
+    assert len(fig_server.widgets) == 1
+    assert len(fig_server.widgets["widget_1"].curves) == 1
+
+
+def test_rpc_plotting_shortcuts_init_configs(rpc_server, qtbot):
+    fig = BECFigure(rpc_server.gui_id)
+    fig_server = rpc_server.fig
+
+    plt = fig.plot("samx", "bpm4i")
+    im = fig.image("eiger")
+    motor_map = fig.motor_map("samx", "samy")
+    plt_z = fig.add_plot("samx", "samy", "bpm4i")
+
+    # Checking if classes are correctly initialised
+    assert len(fig_server.widgets) == 4
+    assert plt.__class__.__name__ == "BECWaveform"
+    assert plt.__class__ == BECWaveform
+    assert im.__class__.__name__ == "BECImageShow"
+    assert im.__class__ == BECImageShow
+    assert motor_map.__class__.__name__ == "BECMotorMap"
+    assert motor_map.__class__ == BECMotorMap
+
+    # check if the correct devices are set
+    # plot
+    assert plt.config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
+        "source": "scan_segment",
+        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
+        "y": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
+        "z": None,
+    }
+    # image
+    assert im.config_dict["images"]["eiger"]["monitor"] == "eiger"
+    # motor map
+    assert motor_map.config_dict["signals"] == {
+        "source": "device_readback",
+        "x": {
+            "name": "samx",
+            "entry": "samx",
+            "unit": None,
+            "modifier": None,
+            "limits": [-50.0, 50.0],
+        },
+        "y": {
+            "name": "samy",
+            "entry": "samy",
+            "unit": None,
+            "modifier": None,
+            "limits": [-50.0, 50.0],
+        },
+        "z": None,
+    }
+    # plot with z scatter
+    assert plt_z.config_dict["curves"]["bpm4i-bpm4i"]["signals"] == {
+        "source": "scan_segment",
+        "x": {"name": "samx", "entry": "samx", "unit": None, "modifier": None, "limits": None},
+        "y": {"name": "samy", "entry": "samy", "unit": None, "modifier": None, "limits": None},
+        "z": {"name": "bpm4i", "entry": "bpm4i", "unit": None, "modifier": None, "limits": None},
+    }
+
+
+def test_rpc_waveform_scan(rpc_server, qtbot):
+    fig = BECFigure(rpc_server.gui_id)
+
+    # add 3 different curves to track
+    plt = fig.plot("samx", "bpm4i")
+    fig.plot("samx", "bpm3a")
+    fig.plot("samx", "bpm4d")
+
+    client = rpc_server.client
+    dev = client.device_manager.devices
+    scans = client.scans
+    queue = client.queue
+
+    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
+
+    # wait for scan to finish
+    while not status.status == "COMPLETED":
+        qtbot.wait(200)
+
+    last_scan_data = queue.scan_storage.storage[-1].data
+
+    # get data from curves
+    plt_data = plt.get_all_data()
+
+    # check plotted data
+    assert plt_data["bpm4i-bpm4i"]["x"] == last_scan_data["samx"]["samx"].val
+    assert plt_data["bpm4i-bpm4i"]["y"] == last_scan_data["bpm4i"]["bpm4i"].val
+    assert plt_data["bpm3a-bpm3a"]["x"] == last_scan_data["samx"]["samx"].val
+    assert plt_data["bpm3a-bpm3a"]["y"] == last_scan_data["bpm3a"]["bpm3a"].val
+    assert plt_data["bpm4d-bpm4d"]["x"] == last_scan_data["samx"]["samx"].val
+    assert plt_data["bpm4d-bpm4d"]["y"] == last_scan_data["bpm4d"]["bpm4d"].val
+
+
+def test_rpc_image(rpc_server, qtbot):
+    fig = BECFigure(rpc_server.gui_id)
+
+    im = fig.image("eiger")
+
+    client = rpc_server.client
+    dev = client.device_manager.devices
+    scans = client.scans
+
+    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
+
+    # wait for scan to finish
+    while not status.status == "COMPLETED":
+        qtbot.wait(200)
+
+    last_image_device = client.connector.get_last(MessageEndpoints.device_monitor("eiger"))[
+        "data"
+    ].data
+    qtbot.wait(500)
+    last_image_plot = im.images[0].get_data()
+
+    # check plotted data
+    np.testing.assert_equal(last_image_device, last_image_plot)
+
+
+def test_rpc_motor_map(rpc_server, qtbot):
+    fig = BECFigure(rpc_server.gui_id)
+    fig_server = rpc_server.fig
+
+    motor_map = fig.motor_map("samx", "samy")
+
+    client = rpc_server.client
+    dev = client.device_manager.devices
+    scans = client.scans
+
+    initial_pos_x = dev.samx.read()["samx"]["value"]
+    initial_pos_y = dev.samy.read()["samy"]["value"]
+
+    status = scans.mv(dev.samx, 1, dev.samy, 2, relative=True)
+
+    # wait for scan to finish
+    while not status.status == "COMPLETED":
+        qtbot.wait(200)
+    final_pos_x = dev.samx.read()["samx"]["value"]
+    final_pos_y = dev.samy.read()["samy"]["value"]
+
+    # check plotted data
+    motor_map_data = motor_map.get_data()
+
+    np.testing.assert_equal(
+        [motor_map_data["x"][0], motor_map_data["y"][0]], [initial_pos_x, initial_pos_y]
+    )
+    np.testing.assert_equal(
+        [motor_map_data["x"][-1], motor_map_data["y"][-1]], [final_pos_x, final_pos_y]
+    )
--- a/tests/test_bec_dispatcher.py
+++ b/tests/test_bec_dispatcher.py
@@ -1,249 +0,0 @@
-# pylint: disable=missing-function-docstring
-from unittest.mock import Mock
-
-import pytest
-from bec_lib.messages import ScanMessage
-from bec_lib.connector import MessageObject
-
-# TODO: find a better way to mock singletons
-from bec_widgets.utils.bec_dispatcher import _BECDispatcher
-
-msg = MessageObject(topic="", value=ScanMessage(point_id=0, scanID=0, data={}).dumps())
-
-
-@pytest.fixture(name="bec_dispatcher")
-def _bec_dispatcher():
-    bec_dispatcher = _BECDispatcher()
-    yield bec_dispatcher
-
-
-@pytest.fixture(name="consumer")
-def _consumer(bec_dispatcher):
-    bec_dispatcher.client.connector.consumer = Mock()
-    consumer = bec_dispatcher.client.connector.consumer
-    yield consumer
-
-
-@pytest.mark.filterwarnings("ignore:Failed to connect to redis.")
-def test_connect_one_slot(bec_dispatcher, consumer):
-    slot1 = Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    consumer.assert_called_once()
-    # trigger consumer callback as if a message was published
-    consumer.call_args.kwargs["cb"](msg)
-    slot1.assert_called_once()
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 2
-
-
-def test_connect_identical(bec_dispatcher, consumer):
-    slot1 = Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    consumer.assert_called_once()
-
-    consumer.call_args.kwargs["cb"](msg)
-    slot1.assert_called_once()
-
-
-def test_connect_many_slots_one_topic(bec_dispatcher, consumer):
-    slot1, slot2 = Mock(), Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    consumer.assert_called_once()
-    bec_dispatcher.connect_slot(slot=slot2, topics="topic0")
-    consumer.assert_called_once()
-    # trigger consumer callback as if a message was published
-    consumer.call_args.kwargs["cb"](msg)
-    slot1.assert_called_once()
-    slot2.assert_called_once()
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 2
-    assert slot2.call_count == 2
-
-
-def test_connect_one_slot_many_topics(bec_dispatcher, consumer):
-    slot1 = Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    assert consumer.call_count == 1
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic1")
-    assert consumer.call_count == 2
-    # trigger consumer callback as if a message was published
-    consumer.call_args_list[0].kwargs["cb"](msg)
-    slot1.assert_called_once()
-    consumer.call_args_list[1].kwargs["cb"](msg)
-    assert slot1.call_count == 2
-
-
-def test_disconnect_one_slot_one_topic(bec_dispatcher, consumer):
-    slot1, slot2 = Mock(), Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-
-    # disconnect using a different topic
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic1")
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 1
-
-    # disconnect using a different slot
-    bec_dispatcher.disconnect_slot(slot=slot2, topics="topic0")
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 2
-
-    # disconnect using the right slot and topics
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic0")
-    # reset count to 0 for slot
-    slot1.reset_mock()
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 0
-
-
-def test_disconnect_identical(bec_dispatcher, consumer):
-    slot1 = Mock()
-    # Try to connect slot twice
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-
-    # Test to call the slot once (slot should be not connected twice)
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 1
-
-    # Disconnect the slot
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic0")
-
-    # Test to call the slot once (slot should be not connected anymore), count remains 1
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 1
-
-
-def test_disconnect_many_slots_one_topic(bec_dispatcher, consumer):
-    slot1, slot2, slot3 = Mock(), Mock(), Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    bec_dispatcher.connect_slot(slot=slot2, topics="topic0")
-
-    # disconnect using a different slot
-    bec_dispatcher.disconnect_slot(slot3, topics="topic0")
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 1
-    assert slot2.call_count == 1
-
-    # disconnect using a different topics
-    bec_dispatcher.disconnect_slot(slot1, topics="topic1")
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 2
-    assert slot2.call_count == 2
-
-    # disconnect using the right slot and topics
-    bec_dispatcher.disconnect_slot(slot1, topics="topic0")
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 2
-    assert slot2.call_count == 3
-
-
-def test_disconnect_one_slot_many_topics(bec_dispatcher, consumer):
-    slot1, slot2 = Mock(), Mock()
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic1")
-
-    # disconnect using a different slot
-    bec_dispatcher.disconnect_slot(slot=slot2, topics="topic0")
-    consumer.call_args_list[0].kwargs["cb"](msg)
-    assert slot1.call_count == 1
-    consumer.call_args_list[1].kwargs["cb"](msg)
-    assert slot1.call_count == 2
-
-    # disconnect using a different topics
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic3")
-    consumer.call_args_list[0].kwargs["cb"](msg)
-    assert slot1.call_count == 3
-    consumer.call_args_list[1].kwargs["cb"](msg)
-    assert slot1.call_count == 4
-
-    # disconnect using the right slot and topics
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic0")
-    # Calling disconnected topic0 should not call slot1
-    consumer.call_args_list[0].kwargs["cb"](msg)
-    assert slot1.call_count == 4
-    # Calling topic1 should still call slot1
-    consumer.call_args_list[1].kwargs["cb"](msg)
-    assert slot1.call_count == 5
-
-    # disconnect remaining topic1 from slot1, calling any topic should not increase count
-    bec_dispatcher.disconnect_slot(slot=slot1, topics="topic1")
-    consumer.call_args_list[0].kwargs["cb"](msg)
-    consumer.call_args_list[1].kwargs["cb"](msg)
-    assert slot1.call_count == 5
-
-
-def test_disconnect_all(bec_dispatcher, consumer):
-    # Mock slots to connect
-    slot1, slot2, slot3 = Mock(), Mock(), Mock()
-
-    # Connect slots to different topics
-    bec_dispatcher.connect_slot(slot=slot1, topics="topic0")
-    bec_dispatcher.connect_slot(slot=slot2, topics="topic1")
-    bec_dispatcher.connect_slot(slot=slot3, topics="topic2")
-
-    # Call disconnect_all method
-    bec_dispatcher.disconnect_all()
-
-    # Simulate messages and verify that none of the slots are called
-    consumer.call_args_list[0].kwargs["cb"](msg)
-    consumer.call_args_list[1].kwargs["cb"](msg)
-    consumer.call_args_list[2].kwargs["cb"](msg)
-
-    # Ensure that the slots have not been called
-    assert slot1.call_count == 0
-    assert slot2.call_count == 0
-    assert slot3.call_count == 0
-
-    # Also, check that the consumer for each topic is shutdown
-    assert "topic0" not in bec_dispatcher._connections
-    assert "topic1" not in bec_dispatcher._connections
-    assert "topic2" not in bec_dispatcher._connections
-
-
-def test_connect_one_slot_multiple_topics_single_callback(bec_dispatcher, consumer):
-    slot1 = Mock()
-
-    # Connect the slot to multiple topics using a single callback
-    topics = ["topic1", "topic2"]
-    bec_dispatcher.connect_slot(slot=slot1, topics=topics, single_callback_for_all_topics=True)
-
-    # Verify the initial state
-    assert len(bec_dispatcher._connections) == 1  # One connection for all topics
-    assert len(bec_dispatcher._connections[tuple(sorted(topics))].slots) == 1  # One slot connected
-
-    # Simulate messages being published on each topic
-    for topic in topics:
-        msg_with_topic = MessageObject(
-            topic=topic, value=ScanMessage(point_id=0, scanID=0, data={}).dumps()
-        )
-        consumer.call_args.kwargs["cb"](msg_with_topic)
-
-    # Verify that the slot is called once for each topic
-    assert slot1.call_count == len(topics)
-
-    # Verify that a single consumer is created for all topics
-    consumer.assert_called_once()
-
-
-def test_disconnect_all_with_single_callback_for_multiple_topics(bec_dispatcher, consumer):
-    slot1 = Mock()
-
-    # Connect the slot to multiple topics using a single callback
-    topics = ["topic1", "topic2"]
-    bec_dispatcher.connect_slot(slot=slot1, topics=topics, single_callback_for_all_topics=True)
-
-    # Verify the initial state
-    assert len(bec_dispatcher._connections) == 1  # One connection for all topics
-    assert len(bec_dispatcher._connections[tuple(sorted(topics))].slots) == 1  # One slot connected
-
-    # Call disconnect_all method
-    bec_dispatcher.disconnect_all()
-
-    # Verify that the slot is disconnected
-    assert len(bec_dispatcher._connections) == 0  # All connections are removed
-    assert slot1.call_count == 0  # Slot has not been called
-
-    # Simulate messages and verify that the slot is not called
-    consumer.call_args.kwargs["cb"](msg)
-    assert slot1.call_count == 0  # Slot has not been called
--- a/tests/test_msgs/msg_dict.pkl
+++ b/tests/test_msgs/msg_dict.pkl
--- a/tests/test_plot_app.py
+++ b/tests/test_plot_app.py
@@ -1,488 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, patch
-
-import pyqtgraph as pg
-import pytest
-from qtpy.QtWidgets import QMessageBox
-
-from bec_widgets.examples.plot_app.plot_app import PlotApp, ErrorHandler
-
-
-def setup_plot_app(qtbot, config):
-    """Helper function to set up the PlotApp widget."""
-    client = MagicMock()
-    widget = PlotApp(config=config, client=client)
-    qtbot.addWidget(widget)
-    qtbot.waitExposed(widget)
-    return widget
-
-
-@pytest.fixture
-def error_handler():
-    # TODO so far tested separately, but the error message scenarios can be tested directly in the plot app
-    return ErrorHandler()
-
-
-config_device_mode_all_filled = {
-    "plot_settings": {
-        "background_color": "black",
-        "num_columns": 2,
-        "colormap": "plasma",
-        "scan_types": False,
-    },
-    "plot_data": [
-        {
-            "plot_name": "BPM4i plots vs samx",
-            "x": {
-                "label": "Motor Y",
-                "signals": [{"name": "samx", "entry": "samx"}],
-            },
-            "y": {
-                "label": "bpm4i",
-                "signals": [{"name": "bpm4i", "entry": "bpm4i"}],
-            },
-        },
-        {
-            "plot_name": "Gauss plots vs samx",
-            "x": {
-                "label": "Motor X",
-                "signals": [{"name": "samx", "entry": "samx"}],
-            },
-            "y": {
-                "label": "Gauss",
-                "signals": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-            },
-        },
-    ],
-}
-
-config_device_mode_no_entry = {
-    "plot_settings": {
-        "background_color": "white",
-        "num_columns": 1,
-        "colormap": "plasma",
-        "scan_types": False,
-    },
-    "plot_data": [
-        {
-            "plot_name": "BPM4i plots vs samx",
-            "x": {
-                "label": "Motor Y",
-                "signals": [{"name": "samx"}],  # Entry is missing
-            },
-            "y": {
-                "label": "bpm4i",
-                "signals": [{"name": "bpm4i"}],  # Entry is missing
-            },
-        },
-        {
-            "plot_name": "Gauss plots vs samx",
-            "x": {
-                "label": "Motor X",
-                "signals": [{"name": "samx"}],  # Entry is missing
-            },
-            "y": {
-                "label": "Gauss",
-                "signals": [{"name": "gauss_bpm"}],  # Entry is missing
-            },
-        },
-    ],
-}
-
-config_scan_mode = config = {
-    "plot_settings": {
-        "background_color": "white",
-        "num_columns": 3,
-        "colormap": "plasma",
-        "scan_types": True,
-    },
-    "plot_data": {
-        "grid_scan": [
-            {
-                "plot_name": "Grid plot 1",
-                "x": {"label": "Motor X", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "gauss_adc1", "entry": "gauss_adc1"},
-                    ],
-                },
-            },
-            {
-                "plot_name": "Grid plot 2",
-                "x": {"label": "Motor X", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "gauss_adc1", "entry": "gauss_adc1"},
-                    ],
-                },
-            },
-            {
-                "plot_name": "Grid plot 3",
-                "x": {"label": "Motor Y", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [{"name": "gauss_bpm", "entry": "gauss_bpm"}],
-                },
-            },
-            {
-                "plot_name": "Grid plot 4",
-                "x": {"label": "Motor Y", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [{"name": "gauss_adc3", "entry": "gauss_adc3"}],
-                },
-            },
-        ],
-        "line_scan": [
-            {
-                "plot_name": "BPM plot",
-                "x": {"label": "Motor X", "signals": [{"name": "samx"}]},
-                "y": {
-                    "label": "BPM",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "gauss_adc1", "entry": "gauss_adc1"},
-                        {"name": "gauss_adc2", "entry": "gauss_adc2"},
-                    ],
-                },
-            },
-            {
-                "plot_name": "Multi",
-                "x": {"label": "Motor X", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "Multi",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "samx", "entry": ["samx", "samx_setpoint"]},
-                    ],
-                },
-            },
-            {
-                "plot_name": "Multi",
-                "x": {"label": "Motor X", "signals": [{"name": "samx", "entry": "samx"}]},
-                "y": {
-                    "label": "Multi",
-                    "signals": [
-                        {"name": "gauss_bpm", "entry": "gauss_bpm"},
-                        {"name": "samx", "entry": ["samx", "samx_setpoint"]},
-                    ],
-                },
-            },
-        ],
-    },
-}
-
-config_all_wrong = {
-    "plot_settings": {
-        "background_color": "white",
-        "num_columns": 1,
-        "colormap": "plasma",
-        "scan_types": False,
-    },
-    "plot_data": [
-        {
-            "plot_name": "BPM4i plots vs samx",
-            "x": {
-                "label": "Motor Y",
-                # signals are missing
-            },
-            "y": {
-                "label": "bpm4i",
-                "signals": [{"name": "bpm4i", "entry": "gauss_bpm"}],  # wrong entry
-            },
-        },
-    ],
-}
-
-
-@pytest.mark.parametrize(
-    "config, plot_setting_bg, num_plot ,pg_background",
-    [
-        (config_device_mode_all_filled, "black", 2, "k"),
-        (config_device_mode_no_entry, "white", 2, "w"),
-        (config_scan_mode, "white", 4, "w"),
-    ],
-)
-def test_init_config(qtbot, config, plot_setting_bg, num_plot, pg_background):
-    plot_app = setup_plot_app(qtbot, config)
-    assert plot_app.plot_settings["background_color"] == plot_setting_bg
-    assert len(plot_app.plot_data) == num_plot
-    assert pg.getConfigOption("background") == pg_background
-
-
-@pytest.mark.parametrize(
-    "config, num_columns_input, expected_num_columns, expected_plot_names, expected_coordinates",
-    [
-        (
-            config_device_mode_all_filled,
-            2,
-            2,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (0, 1)],
-        ),
-        (
-            config_device_mode_all_filled,
-            5,
-            2,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (0, 1)],
-        ),  # num_columns greater than number of plots
-        (
-            config_device_mode_no_entry,
-            1,
-            1,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (1, 0)],
-        ),
-        (
-            config_device_mode_no_entry,
-            2,
-            2,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (0, 1)],
-        ),
-        (
-            config_device_mode_no_entry,
-            5,
-            2,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (0, 1)],
-        ),  # num_columns greater than number of plots,
-        (
-            config_scan_mode,
-            2,
-            2,
-            [
-                "Grid plot 1",
-                "Grid plot 2",
-                "Grid plot 3",
-                "Grid plot 4",
-            ],
-            [(0, 0), (0, 1), (1, 0), (1, 1)],
-        ),
-        (
-            config_scan_mode,
-            3,
-            3,
-            [
-                "Grid plot 1",
-                "Grid plot 2",
-                "Grid plot 3",
-                "Grid plot 4",
-            ],
-            [(0, 0), (0, 1), (0, 2), (1, 0)],
-        ),
-        (
-            config_scan_mode,
-            5,
-            4,
-            [
-                "Grid plot 1",
-                "Grid plot 2",
-                "Grid plot 3",
-                "Grid plot 4",
-            ],
-            [(0, 0), (0, 1), (0, 2), (0, 3)],
-        ),  # num_columns greater than number of plots
-    ],
-)
-def test_init_ui(
-    qtbot,
-    config,
-    num_columns_input,
-    expected_num_columns,
-    expected_plot_names,
-    expected_coordinates,
-):
-    plot_app = setup_plot_app(qtbot, config)
-    plot_app.init_ui(num_columns_input)
-
-    # Validate number of columns
-    assert plot_app.plot_settings["num_columns"] == expected_num_columns
-
-    # Validate the plots are created correctly
-    for expected_name in expected_plot_names:
-        assert expected_name in plot_app.plots.keys()
-
-    # Validate the grid_coordinates
-    assert plot_app.grid_coordinates == expected_coordinates
-
-
-def mock_getitem(dev_name):
-    """Helper function to mock the __getitem__ method of the 'dev' object.""" ""
-    mock_instance = MagicMock()
-    if dev_name == "samx":
-        mock_instance._hints = "samx"
-    elif dev_name == "bpm4i":
-        mock_instance._hints = "bpm4i"
-    elif dev_name == "gauss_bpm":
-        mock_instance._hints = "gauss_bpm"
-
-    return mock_instance
-
-
-@pytest.mark.parametrize(
-    "config, msg, metadata, expected_data",
-    [
-        # Case: msg does not have 'scanID'
-        (config_device_mode_all_filled, {"data": {}}, {}, {}),
-        # Case: scan_types is False, msg contains all valid fields, and entry is present in config
-        (
-            config_device_mode_all_filled,
-            {
-                "data": {
-                    "samx": {"samx": {"value": 10}},
-                    "bpm4i": {"bpm4i": {"value": 5}},
-                    "gauss_bpm": {"gauss_bpm": {"value": 7}},
-                },
-                "scanID": 1,
-            },
-            {},
-            {
-                ("samx", "samx", "bpm4i", "bpm4i"): {"x": [10], "y": [5]},
-                ("samx", "samx", "gauss_bpm", "gauss_bpm"): {"x": [10], "y": [7]},
-            },
-        ),
-        # Case: scan_types is False, msg contains all valid fields and entry is missing in config, should use hints
-        (
-            config_device_mode_no_entry,
-            {
-                "data": {
-                    "samx": {"samx": {"value": 10}},
-                    "bpm4i": {"bpm4i": {"value": 5}},
-                    "gauss_bpm": {"gauss_bpm": {"value": 7}},
-                },
-                "scanID": 1,
-            },
-            {},
-            {
-                ("samx", "samx", "bpm4i", "bpm4i"): {"x": [10], "y": [5]},
-                ("samx", "samx", "gauss_bpm", "gauss_bpm"): {"x": [10], "y": [7]},
-            },
-        ),
-    ],
-)
-def test_on_scan_segment(qtbot, config, msg, metadata, expected_data):
-    plot_app = setup_plot_app(qtbot, config)
-
-    # Initialize and run test
-    plot_app.data = {}
-    plot_app.scanID = 0
-
-    # Get hints
-    plot_app.dev.__getitem__.side_effect = mock_getitem
-
-    plot_app.on_scan_segment(msg, metadata)
-    assert plot_app.data == expected_data
-
-
-@pytest.mark.parametrize(
-    "config, msg, metadata, expected_exception_message",
-    [
-        # Case: scan_types is True, but metadata does not contain 'scan_name'
-        (
-            config_scan_mode,
-            {"data": {}, "scanID": 1},
-            {},  # No 'scan_name' in metadata
-            "Scan name not found in metadata. Please check the scan_name in the YAML config or in bec configuration.",
-        ),
-        # Case: scan_types is True, metadata contains non-existing 'scan_name'
-        (
-            config_scan_mode,
-            {"data": {}, "scanID": 1},
-            {"scan_name": "non_existing_scan"},
-            "Scan name non_existing_scan not found in the YAML config. Please check the scan_name in the YAML config "
-            "or in bec configuration.",
-        ),
-    ],
-)
-def test_on_scan_message_error_handling(qtbot, config, msg, metadata, expected_exception_message):
-    plot_app = setup_plot_app(qtbot, config)
-
-    # Initialize
-    plot_app.init_curves = MagicMock()
-    plot_app.data = {}
-    plot_app.scanID = 0
-
-    plot_app.dev.__getitem__.side_effect = mock_getitem
-
-    with pytest.raises(ValueError) as exc_info:
-        plot_app.on_scan_segment(msg, metadata)
-    assert str(exc_info.value) == expected_exception_message
-
-
-####################
-# ErrorHandler tests
-####################
-def test_initialization(error_handler):
-    assert error_handler.errors == []
-    assert error_handler.parent is None
-    assert error_handler.retry_action is None
-
-
-@patch(
-    "bec_widgets.examples.plot_app.plot_app.QMessageBox.critical", return_value=QMessageBox.Retry
-)
-def test_handle_error_retry(mocked_critical, error_handler):
-    retry_action = MagicMock()
-    error_handler.set_retry_action(retry_action)
-    error_handler.handle_error("error message")
-    retry_action.assert_called_once()
-
-
-@patch(
-    "bec_widgets.examples.plot_app.plot_app.QMessageBox.critical", return_value=QMessageBox.Cancel
-)
-def test_handle_error_cancel(mocked_critical, error_handler):
-    retry_action = MagicMock()
-    with pytest.raises(SystemExit) as excinfo:
-        error_handler.handle_error("error message")
-    assert excinfo.value.code == 1
-    retry_action.assert_not_called()
-
-
-@pytest.mark.parametrize(
-    "config, expected_errors",
-    [
-        (config_device_mode_all_filled, []),
-        (config_device_mode_no_entry, []),
-        (config_scan_mode, []),
-        (
-            config_all_wrong,
-            ["Missing 'signals' configuration for x axis in plot 0 - 'BPM4i plots vs samx'"],
-        ),
-    ],
-)
-def test_error_handler(error_handler, config, expected_errors):
-    # Mock QMessageBox
-    error_handler.handle_error = MagicMock()
-
-    # Mock logging
-    with unittest.mock.patch("bec_widgets.examples.plot_app.plot_app.logging") as mocked_logging:
-        error_handler.validate_config_file(config)
-
-        # Assert
-        assert error_handler.errors == expected_errors
-
-        # If there are expected errors, check if handle_error was called
-        if expected_errors:
-            error_handler.handle_error.assert_called_once()
-            mocked_logging.error.assert_called()
-        else:
-            mocked_logging.error.assert_not_called()
-            error_handler.handle_error.assert_not_called()
-
-
-def test_validate_plot_config(error_handler):
-    plot_config = {
-        "x": {"label": "Motor X", "signals": []},  # empty signals list should trigger an error
-        "y": {"label": "Motor Y", "signals": [{"name": "samx", "entry": "samx"}]},
-    }
-    error_handler.validate_plot_config(plot_config, 0)
-    assert error_handler.errors == [
-        "'signals' configuration for x axis in plot 0 must be a non-empty list"
-    ]
--- a/tests/test_scan_plot.py
+++ b/tests/test_scan_plot.py
@@ -1,91 +0,0 @@
-from bec_widgets.widgets.scan_plot import scan_plot
-
-
-def test_scan_plot(qtbot):
-    """Test ScanPlot"""
-    plot = scan_plot.BECScanPlot()
-    qtbot.addWidget(plot)
-    plot.show()
-    qtbot.waitExposed(plot)
-
-    plot.x_channel = "x"
-    plot.y_channel_list = ["y1", "y2"]
-
-    plot.on_scan_segment(
-        {
-            "data": {
-                "x": {"x": {"value": 1}},
-                "y1": {"y1": {"value": 1}},
-                "y2": {"y2": {"value": 3}},
-            },
-            "scanID": "test",
-        },
-        {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]},
-    )
-    plot.on_scan_segment(
-        {
-            "data": {
-                "x": {"x": {"value": 2}},
-                "y1": {"y1": {"value": 2}},
-                "y2": {"y2": {"value": 4}},
-            },
-            "scanID": "test",
-        },
-        {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]},
-    )
-
-    assert all(plot.scan_curves["y1"].getData()[0] == [1, 2])
-    assert all(plot.scan_curves["y2"].getData()[1] == [3, 4])
-
-
-def test_scan_plot_clears_data(qtbot):
-    """Test ScanPlot"""
-    plot = scan_plot.BECScanPlot()
-    qtbot.addWidget(plot)
-    plot.show()
-    qtbot.waitExposed(plot)
-
-    plot.x_channel = "x"
-    plot.y_channel_list = ["y1", "y2"]
-
-    plot.on_scan_segment(
-        {
-            "data": {
-                "x": {"x": {"value": 1}},
-                "y1": {"y1": {"value": 1}},
-                "y2": {"y2": {"value": 3}},
-            },
-            "scanID": "test",
-        },
-        {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]},
-    )
-    plot.reset_plots({}, {})
-    plot.on_scan_segment(
-        {
-            "data": {
-                "x": {"x": {"value": 2}},
-                "y1": {"y1": {"value": 2}},
-                "y2": {"y2": {"value": 4}},
-            },
-            "scanID": "test",
-        },
-        {"scanID": "test", "scan_number": 1, "scan_report_devices": ["x"]},
-    )
-
-    assert all(plot.scan_curves["y1"].getData()[0] == [2])
-    assert all(plot.scan_curves["y2"].getData()[1] == [4])
-
-
-def test_scan_plot_redraws_dap(qtbot):
-    """Test ScanPlot"""
-    plot = scan_plot.BECScanPlot()
-    qtbot.addWidget(plot)
-    plot.show()
-    qtbot.waitExposed(plot)
-
-    plot.y_channel_list = ["dap.y1", "dap.y2"]
-
-    plot.redraw_dap({"data": {"y1": {"x": [1], "y": [1]}, "y2": {"x": [2], "y": [2]}}}, {})
-
-    assert all(plot.dap_curves["y1"].getData()[0] == [1])
-    assert all(plot.dap_curves["y2"].getData()[1] == [2])
--- a/bec_widgets/examples/plot_app/init.py
+++ b/bec_widgets/examples/plot_app/init.py
--- a/tests/unit_tests/client_mocks.py
+++ b/tests/unit_tests/client_mocks.py
@@ -0,0 +1,138 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+from unittest.mock import MagicMock, patch
+
+import fakeredis
+import pytest
+from bec_lib import BECClient, RedisConnector
+from bec_lib.device import Positioner
+from bec_lib.devicemanager import DeviceContainer
+
+
+class FakeDevice:
+    """Fake minimal positioner class for testing."""
+
+    def __init__(self, name, enabled=True):
+        self.name = name
+        self.enabled = enabled
+        self.signals = {self.name: {"value": 1.0}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+
+    def __contains__(self, item):
+        return item == self.name
+
+    @property
+    def _hints(self):
+        return [self.name]
+
+    def set_value(self, fake_value: float = 1.0) -> None:
+        """
+        Setup fake value for device readout
+        Args:
+            fake_value(float): Desired fake value
+        """
+        self.signals[self.name]["value"] = fake_value
+
+    def describe(self) -> dict:
+        """
+        Get the description of the device
+        Returns:
+            dict: Description of the device
+        """
+        return self.description
+
+
+class FakePositioner(FakeDevice):
+    def __init__(self, name, enabled=True, limits=None, read_value=1.0):
+        super().__init__(name, enabled)
+        self.limits = limits if limits is not None else [0, 0]
+        self.read_value = read_value
+
+    def set_read_value(self, value):
+        self.read_value = value
+
+    def read(self):
+        return {self.name: {"value": self.read_value}}
+
+    def set_limits(self, limits):
+        self.limits = limits
+
+    def move(self, value, relative=False):
+        """Simulates moving the device to a new position."""
+        if relative:
+            self.read_value += value
+        else:
+            self.read_value = value
+        # Respect the limits
+        self.read_value = max(min(self.read_value, self.limits[1]), self.limits[0])
+
+    @property
+    def readback(self):
+        return MagicMock(get=MagicMock(return_value=self.read_value))
+
+
+class DMMock:
+    def __init__(self):
+        self.devices = DeviceContainer()
+
+    def add_devives(self, devices: list):
+        for device in devices:
+            self.devices[device.name] = device
+
+
+DEVICES = [
+    FakePositioner("samx", limits=[-10, 10], read_value=2.0),
+    FakePositioner("samy", limits=[-5, 5], read_value=3.0),
+    FakePositioner("aptrx", limits=None, read_value=4.0),
+    FakePositioner("aptry", limits=None, read_value=5.0),
+    FakeDevice("gauss_bpm"),
+    FakeDevice("gauss_adc1"),
+    FakeDevice("gauss_adc2"),
+    FakeDevice("gauss_adc3"),
+    FakeDevice("bpm4i"),
+    FakeDevice("bpm3a"),
+    FakeDevice("bpm3i"),
+]
+
+
+def fake_redis_server(host, port):
+    redis = fakeredis.FakeRedis()
+    return redis
+
+
+@pytest.fixture(scope="function")
+def mocked_client(bec_dispatcher):
+    connector = RedisConnector("localhost:1", redis_cls=fake_redis_server)
+    # Create a MagicMock object
+    client = MagicMock()  # TODO change to real BECClient
+
+    # Shutdown the original client
+    bec_dispatcher.client.shutdown()
+    # Mock the connector attribute
+    bec_dispatcher.client = client
+
+    # Mock the device_manager.devices attribute
+    client.connector = connector
+    client.device_manager = DMMock()
+    client.device_manager.add_devives(DEVICES)
+
+    def mock_mv(*args, relative=False):
+        # Extracting motor and value pairs
+        for i in range(0, len(args), 2):
+            motor = args[i]
+            value = args[i + 1]
+            motor.move(value, relative=relative)
+        return MagicMock(wait=MagicMock())
+
+    client.scans = MagicMock(mv=mock_mv)
+
+    # Ensure isinstance check for Positioner passes
+    original_isinstance = isinstance
+
+    def isinstance_mock(obj, class_info):
+        if class_info == Positioner and isinstance(obj, FakePositioner):
+            return True
+        return original_isinstance(obj, class_info)
+
+    with patch("builtins.isinstance", new=isinstance_mock):
+        yield client
+    connector.shutdown()  # TODO change to real BECClient
--- a/tests/unit_tests/conftest.py
+++ b/tests/unit_tests/conftest.py
@@ -0,0 +1,14 @@
+import pytest
+
+from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
+
+
+@pytest.fixture(autouse=True)
+def bec_dispatcher(threads_check):
+    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
+    yield bec_dispatcher
+    bec_dispatcher.disconnect_all()
+    # clean BEC client
+    bec_dispatcher.client.shutdown()
+    # reinitialize singleton for next test
+    bec_dispatcher_module.BECDispatcher.reset_singleton()
--- a/tests/unit_tests/test_bec_connector.py
+++ b/tests/unit_tests/test_bec_connector.py
@@ -0,0 +1,57 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+import pytest
+
+from bec_widgets.utils import BECConnector, ConnectionConfig
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def bec_connector(mocked_client):
+    connector = BECConnector(client=mocked_client)
+    return connector
+
+
+def test_bec_connector_init(bec_connector):
+    assert bec_connector is not None
+    assert bec_connector.client is not None
+    assert isinstance(bec_connector, BECConnector)
+    assert bec_connector.config.widget_class == "BECConnector"
+
+
+def test_bec_connector_init_with_gui_id(mocked_client):
+    bc = BECConnector(client=mocked_client, gui_id="test_gui_id")
+    assert bc.config.gui_id == "test_gui_id"
+    assert bc.gui_id == "test_gui_id"
+
+
+def test_bec_connector_set_gui_id(bec_connector):
+    bec_connector.set_gui_id("test_gui_id")
+    assert bec_connector.config.gui_id == "test_gui_id"
+
+
+def test_bec_connector_change_config(bec_connector):
+    bec_connector.on_config_update({"gui_id": "test_gui_id"})
+    assert bec_connector.config.gui_id == "test_gui_id"
+
+
+def test_bec_connector_get_obj_by_id(bec_connector):
+    bec_connector.set_gui_id("test_gui_id")
+    assert bec_connector.get_obj_by_id("test_gui_id") == bec_connector
+    assert bec_connector.get_obj_by_id("test_gui_id_2") is None
+
+
+def test_bec_connector_update_client(bec_connector, mocked_client):
+    client_new = mocked_client
+    bec_connector.update_client(client_new)
+    assert bec_connector.client == client_new
+    assert bec_connector.dev is not None
+    assert bec_connector.scans is not None
+    assert bec_connector.queue is not None
+    assert bec_connector.scan_storage is not None
+    assert bec_connector.dap is not None
+
+
+def test_bec_connector_get_config(bec_connector):
+    assert bec_connector.get_config(dict_output=False) == bec_connector.config
+    assert bec_connector.get_config() == bec_connector.config.model_dump()
--- a/tests/unit_tests/test_bec_dispatcher.py
+++ b/tests/unit_tests/test_bec_dispatcher.py
@@ -0,0 +1,59 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+import time
+from unittest import mock
+
+import pytest
+import redis
+from bec_lib.connector import MessageObject
+from bec_lib.messages import ScanMessage
+from bec_lib.redis_connector import RedisConnector
+from bec_lib.serialization import MsgpackSerialization
+
+from bec_widgets.utils.bec_dispatcher import QtRedisConnector
+
+
+@pytest.fixture
+def bec_dispatcher_w_connector(bec_dispatcher, topics_msg_list):
+    def pubsub_msg_generator():
+        for topic, msg in topics_msg_list:
+            yield {"channel": topic.encode(), "pattern": None, "data": msg}
+        while True:
+            time.sleep(0.2)
+            yield StopIteration
+
+    with mock.patch("redis.Redis"):
+        pubsub = redis.Redis().pubsub()
+        messages = pubsub_msg_generator()
+        pubsub.get_message.side_effect = lambda timeout: next(messages)
+        connector = QtRedisConnector("localhost:1")
+        bec_dispatcher.client.connector = connector
+        yield bec_dispatcher
+
+
+dummy_msg = MsgpackSerialization.dumps(ScanMessage(point_id=0, scan_id="0", data={}))
+
+
+@pytest.mark.parametrize(
+    "topics_msg_list",
+    [
+        (
+            ("topic1", dummy_msg),
+            ("topic2", dummy_msg),
+            ("topic3", dummy_msg),
+        )
+    ],
+)
+def test_dispatcher_disconnect_all(bec_dispatcher_w_connector, qtbot):
+    bec_dispatcher = bec_dispatcher_w_connector
+    cb1 = mock.Mock(spec=[])
+    cb2 = mock.Mock(spec=[])
+
+    bec_dispatcher.connect_slot(cb1, "topic1")
+    bec_dispatcher.connect_slot(cb1, "topic2")
+    bec_dispatcher.connect_slot(cb2, "topic2")
+    bec_dispatcher.connect_slot(cb2, "topic3")
+    assert len(bec_dispatcher.client.connector._topics_cb) == 3
+
+    bec_dispatcher.disconnect_all()
+
+    assert len(bec_dispatcher.client.connector._topics_cb) == 0
--- a/tests/unit_tests/test_bec_figure.py
+++ b/tests/unit_tests/test_bec_figure.py
@@ -0,0 +1,244 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
+import os
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+from bec_widgets.widgets import BECFigure, BECMotorMap, BECWaveform
+from bec_widgets.widgets.plots import BECImageShow
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def bec_figure(qtbot, mocked_client):
+    widget = BECFigure(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+def test_bec_figure_init(bec_figure):
+    assert bec_figure is not None
+    assert bec_figure.client is not None
+    assert isinstance(bec_figure, BECFigure)
+    assert bec_figure.config.widget_class == "BECFigure"
+
+
+def test_bec_figure_init_with_config(mocked_client):
+    config = {
+        "widget_class": "BECFigure",
+        "gui_id": "test_gui_id",
+        "theme": "dark",
+    }
+    widget = BECFigure(client=mocked_client, config=config)
+    assert widget.config.gui_id == "test_gui_id"
+    assert widget.config.theme == "dark"
+
+
+def test_bec_figure_add_remove_plot(bec_figure):
+    initial_count = len(bec_figure._widgets)
+
+    # Adding 3 widgets -  2 WaveformBase and 1 PlotBase
+    w0 = bec_figure.add_plot()
+    w1 = bec_figure.add_plot()
+    w2 = bec_figure.add_widget(widget_type="PlotBase")
+
+    # Check if the widgets were added
+    assert len(bec_figure._widgets) == initial_count + 3
+    assert "widget_1" in bec_figure._widgets
+    assert "widget_2" in bec_figure._widgets
+    assert "widget_3" in bec_figure._widgets
+    assert bec_figure._widgets["widget_1"].config.widget_class == "BECWaveform"
+    assert bec_figure._widgets["widget_2"].config.widget_class == "BECWaveform"
+    assert bec_figure._widgets["widget_3"].config.widget_class == "BECPlotBase"
+
+    # Check accessing positions by the grid in figure
+    assert bec_figure[0, 0] == w0
+    assert bec_figure[1, 0] == w1
+    assert bec_figure[2, 0] == w2
+
+    # Removing 1 widget
+    bec_figure.remove(widget_id="widget_1")
+    assert len(bec_figure._widgets) == initial_count + 2
+    assert "widget_1" not in bec_figure._widgets
+    assert "widget_3" in bec_figure._widgets
+    assert bec_figure._widgets["widget_2"].config.widget_class == "BECWaveform"
+
+
+def test_add_different_types_of_widgets(bec_figure):
+    plt = bec_figure.plot("samx", "bpm4i")
+    im = bec_figure.image("eiger")
+    motor_map = bec_figure.motor_map("samx", "samy")
+
+    assert plt.__class__ == BECWaveform
+    assert im.__class__ == BECImageShow
+    assert motor_map.__class__ == BECMotorMap
+
+
+def test_access_widgets_access_errors(bec_figure):
+    bec_figure.add_plot(row=0, col=0)
+
+    # access widget by non-existent coordinates
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure[0, 2]
+        assert "No widget at coordinates (0, 2)" in str(excinfo.value)
+
+    # access widget by non-existent widget_id
+    with pytest.raises(KeyError) as excinfo:
+        bec_figure["non_existent_widget"]
+        assert "Widget with id 'non_existent_widget' not found" in str(excinfo.value)
+
+    # access widget by wrong type
+    with pytest.raises(TypeError) as excinfo:
+        bec_figure[1.2]
+        assert (
+            "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
+            in str(excinfo.value)
+        )
+
+
+def test_add_plot_to_occupied_position(bec_figure):
+    bec_figure.add_plot(row=0, col=0)
+
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure.add_plot(row=0, col=0)
+        assert "Position at row 0 and column 0 is already occupied." in str(excinfo.value)
+
+
+def test_remove_plots(bec_figure):
+    w1 = bec_figure.add_plot(row=0, col=0)
+    w2 = bec_figure.add_plot(row=0, col=1)
+    w3 = bec_figure.add_plot(row=1, col=0)
+    w4 = bec_figure.add_plot(row=1, col=1)
+
+    assert bec_figure[0, 0] == w1
+    assert bec_figure[0, 1] == w2
+    assert bec_figure[1, 0] == w3
+    assert bec_figure[1, 1] == w4
+
+    # remove by coordinates
+    bec_figure[0, 0].remove()
+    assert "widget_1" not in bec_figure._widgets
+
+    # remove by widget_id
+    bec_figure.remove(widget_id="widget_2")
+    assert "widget_2" not in bec_figure._widgets
+
+    # remove by widget object
+    w3.remove()
+    assert "widget_3" not in bec_figure._widgets
+
+    # check the remaining widget 4
+    assert bec_figure[0, 0] == w4
+    assert bec_figure["widget_4"] == w4
+    assert "widget_4" in bec_figure._widgets
+    assert len(bec_figure._widgets) == 1
+
+
+def test_remove_plots_by_coordinates_ints(bec_figure):
+    w1 = bec_figure.add_plot(row=0, col=0)
+    w2 = bec_figure.add_plot(row=0, col=1)
+
+    bec_figure.remove(0, 0)
+    assert "widget_1" not in bec_figure._widgets
+    assert "widget_2" in bec_figure._widgets
+    assert bec_figure[0, 0] == w2
+    assert len(bec_figure._widgets) == 1
+
+
+def test_remove_plots_by_coordinates_tuple(bec_figure):
+    w1 = bec_figure.add_plot(row=0, col=0)
+    w2 = bec_figure.add_plot(row=0, col=1)
+
+    bec_figure.remove(coordinates=(0, 0))
+    assert "widget_1" not in bec_figure._widgets
+    assert "widget_2" in bec_figure._widgets
+    assert bec_figure[0, 0] == w2
+    assert len(bec_figure._widgets) == 1
+
+
+def test_remove_plot_by_id_error(bec_figure):
+    bec_figure.add_plot(row=0, col=0)
+
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure.remove(widget_id="non_existent_widget")
+        assert "Widget with ID 'non_existent_widget' does not exist." in str(excinfo.value)
+
+
+def test_remove_plot_by_coordinates_error(bec_figure):
+    bec_figure.add_plot(row=0, col=0)
+
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure.remove(0, 1)
+        assert "No widget at coordinates (0, 1)" in str(excinfo.value)
+
+
+def test_remove_plot_by_providing_nothing(bec_figure):
+    bec_figure.add_plot(row=0, col=0)
+
+    with pytest.raises(ValueError) as excinfo:
+        bec_figure.remove()
+        assert "Must provide either widget_id or coordinates for removal." in str(excinfo.value)
+
+
+# def test_change_theme(bec_figure): #TODO do no work at python 3.12
+#     bec_figure.change_theme("dark")
+#     assert bec_figure.config.theme == "dark"
+#     assert bec_figure.backgroundBrush().color().name() == "#000000"
+#     bec_figure.change_theme("light")
+#     assert bec_figure.config.theme == "light"
+#     assert bec_figure.backgroundBrush().color().name() == "#ffffff"
+#     bec_figure.change_theme("dark")
+#     assert bec_figure.config.theme == "dark"
+#     assert bec_figure.backgroundBrush().color().name() == "#000000"
+
+
+def test_change_layout(bec_figure):
+    w1 = bec_figure.add_plot(row=0, col=0)
+    w2 = bec_figure.add_plot(row=0, col=1)
+    w3 = bec_figure.add_plot(row=1, col=0)
+    w4 = bec_figure.add_plot(row=1, col=1)
+
+    bec_figure.change_layout(max_columns=1)
+
+    assert np.shape(bec_figure.grid) == (4, 1)
+    assert bec_figure[0, 0] == w1
+    assert bec_figure[1, 0] == w2
+    assert bec_figure[2, 0] == w3
+    assert bec_figure[3, 0] == w4
+
+    bec_figure.change_layout(max_rows=1)
+
+    assert np.shape(bec_figure.grid) == (1, 4)
+    assert bec_figure[0, 0] == w1
+    assert bec_figure[0, 1] == w2
+    assert bec_figure[0, 2] == w3
+    assert bec_figure[0, 3] == w4
+
+
+def test_clear_all(bec_figure):
+    bec_figure.add_plot(row=0, col=0)
+    bec_figure.add_plot(row=0, col=1)
+    bec_figure.add_plot(row=1, col=0)
+    bec_figure.add_plot(row=1, col=1)
+
+    bec_figure.clear_all()
+
+    assert len(bec_figure._widgets) == 0
+    assert np.shape(bec_figure.grid) == (0,)
+
+
+def test_shortcuts(bec_figure):
+    plt = bec_figure.plot("samx", "bpm4i")
+    im = bec_figure.image("eiger")
+    motor_map = bec_figure.motor_map("samx", "samy")
+
+    assert plt.config.widget_class == "BECWaveform"
+    assert plt.__class__ == BECWaveform
+    assert im.config.widget_class == "BECImageShow"
+    assert im.__class__ == BECImageShow
+    assert motor_map.config.widget_class == "BECMotorMap"
+    assert motor_map.__class__ == BECMotorMap
--- a/tests/unit_tests/test_bec_monitor.py
+++ b/tests/unit_tests/test_bec_monitor.py
@@ -1,11 +1,14 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import os
-import yaml
-
-import pytest
 from unittest.mock import MagicMock

+import pytest
+import yaml
+
 from bec_widgets.widgets import BECMonitor

+from .client_mocks import mocked_client
+

 def load_test_config(config_name):
    """Helper function to load config from yaml file."""
@@ -15,71 +18,8 @@ def load_test_config(config_name):
    return config


-class FakeDevice:
-    """Fake minimal positioner class for testing."""
-
-    def __init__(self, name, enabled=True):
-        self.name = name
-        self.enabled = enabled
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name}}
-
-    def __contains__(self, item):
-        return item == self.name
-
-    @property
-    def _hints(self):
-        return [self.name]
-
-    def set_value(self, fake_value: float = 1.0) -> None:
-        """
-        Setup fake value for device readout
-        Args:
-            fake_value(float): Desired fake value
-        """
-        self.signals[self.name]["value"] = fake_value
-
-    def describe(self) -> dict:
-        """
-        Get the description of the device
-        Returns:
-            dict: Description of the device
-        """
-        return self.description
-
-
-def get_mocked_device(device_name: str):
-    """
-    Helper function to mock the devices
-    Args:
-        device_name(str): Name of the device to mock
-    """
-    return FakeDevice(name=device_name, enabled=True)
-
-
@pytest.fixture(scope="function")
-def mocked_client():
-    # Create a dictionary of mocked devices
-    device_names = ["samx", "gauss_bpm", "gauss_adc1", "gauss_adc2", "gauss_adc3", "bpm4i"]
-    mocked_devices = {name: get_mocked_device(name) for name in device_names}
-
-    # Create a MagicMock object
-    client = MagicMock()
-
-    # Mock the device_manager.devices attribute
-    client.device_manager.devices = MagicMock()
-    client.device_manager.devices.__getitem__.side_effect = lambda x: mocked_devices.get(x)
-    client.device_manager.devices.__contains__.side_effect = lambda x: x in mocked_devices
-
-    # Set each device as an attribute of the mock
-    for name, device in mocked_devices.items():
-        setattr(client.device_manager.devices, name, device)
-
-    return client
-
-
-@pytest.fixture(scope="function")
-def monitor(qtbot, mocked_client):
+def monitor(bec_dispatcher, qtbot, mocked_client):
    # client = MagicMock()
    widget = BECMonitor(client=mocked_client)
    qtbot.addWidget(widget)
@@ -125,12 +65,7 @@ def test_on_config_update(monitor, config_initial, config_update):
@pytest.mark.parametrize(
    "config_name, expected_num_columns, expected_plot_names, expected_coordinates",
    [
-        (
-            "config_device",
-            1,
-            ["BPM4i plots vs samx", "Gauss plots vs samx"],
-            [(0, 0), (1, 0)],
-        ),
+        ("config_device", 1, ["BPM4i plots vs samx", "Gauss plots vs samx"], [(0, 0), (1, 0)]),
        (
            "config_scan",
            3,
@@ -185,7 +120,7 @@ msg_1 = {
        "gauss_adc1": {"gauss_adc1": {"value": 8}},
        "gauss_adc2": {"gauss_adc2": {"value": 9}},
    },
-    "scanID": 1,
+    "scan_id": 1,
 }
 metadata_grid = {"scan_name": "grid_scan"}
 metadata_line = {"scan_name": "line_scan"}
@@ -194,7 +129,7 @@ metadata_line = {"scan_name": "line_scan"}
@pytest.mark.parametrize(
    "config_name, msg, metadata, expected_data",
    [
-        # case: msg does not have 'scanID'
+        # case: msg does not have 'scan_id'
        (
            "config_device",
            {"data": {}},
@@ -270,9 +205,6 @@ def test_on_scan_segment(monitor, config_name, msg, metadata, expected_data):
    config = load_test_config(config_name)
    monitor.on_config_update(config)

-    # Get hints
-    monitor.dev.__getitem__.side_effect = mock_getitem
-
    # Mock scan_storage.find_scan_by_ID
    mock_scan_data = MagicMock()
    mock_scan_data.data = {
--- a/tests/unit_tests/test_bec_motor_map.py
+++ b/tests/unit_tests/test_bec_motor_map.py
@@ -0,0 +1,125 @@
+import pytest
+
+from bec_widgets.widgets import BECMotorMap
+from bec_widgets.widgets.plots.motor_map import MotorMapConfig
+from bec_widgets.widgets.plots.waveform import Signal, SignalData
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture(scope="function")
+def bec_motor_map(qtbot, mocked_client):
+    widget = BECMotorMap(client=mocked_client, gui_id="BECMotorMap_test")
+    # qtbot.addWidget(widget)
+    # qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_motor_map_init(bec_motor_map):
+    default_config = MotorMapConfig(widget_class="BECMotorMap", gui_id="BECMotorMap_test")
+
+    assert bec_motor_map.config == default_config
+
+
+def test_motor_map_change_motors(bec_motor_map):
+    bec_motor_map.change_motors("samx", "samy")
+
+    assert bec_motor_map.config.signals.x == SignalData(name="samx", entry="samx", limits=[-10, 10])
+    assert bec_motor_map.config.signals.y == SignalData(name="samy", entry="samy", limits=[-5, 5])
+
+
+def test_motor_map_get_limits(bec_motor_map):
+    expected_limits = {
+        "samx": [-10, 10],
+        "samy": [-5, 5],
+    }
+
+    for motor_name, expected_limit in expected_limits.items():
+        actual_limit = bec_motor_map._get_motor_limit(motor_name)
+        assert actual_limit == expected_limit
+
+
+def test_motor_map_get_init_position(bec_motor_map):
+    bec_motor_map.set_precision(2)
+
+    motor_map_dev = bec_motor_map.client.device_manager.devices
+
+    expected_positions = {
+        ("samx", "samx"): motor_map_dev["samx"].read()["samx"]["value"],
+        ("samy", "samy"): motor_map_dev["samy"].read()["samy"]["value"],
+        ("aptrx", "aptrx"): motor_map_dev["aptrx"].read()["aptrx"]["value"],
+        ("aptry", "aptry"): motor_map_dev["aptry"].read()["aptry"]["value"],
+    }
+
+    for (motor_name, entry), expected_position in expected_positions.items():
+        actual_position = bec_motor_map._get_motor_init_position(motor_name, entry, 2)
+        assert actual_position == expected_position
+
+
+def test_motor_movement_updates_position_and_database(bec_motor_map):
+    motor_map_dev = bec_motor_map.client.device_manager.devices
+
+    init_positions = {
+        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
+        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
+    }
+
+    bec_motor_map.change_motors("samx", "samy")
+
+    assert bec_motor_map.database_buffer["x"] == init_positions["samx"]
+    assert bec_motor_map.database_buffer["y"] == init_positions["samy"]
+
+    # Simulate motor movement for 'samx' only
+    new_position_samx = 4.0
+    bec_motor_map.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
+
+    init_positions["samx"].append(new_position_samx)
+    init_positions["samy"].append(init_positions["samy"][-1])
+    # Verify database update for 'samx'
+    assert bec_motor_map.database_buffer["x"] == init_positions["samx"]
+
+    # Verify 'samy' retains its last known position
+    assert bec_motor_map.database_buffer["y"] == init_positions["samy"]
+
+
+def test_scatter_plot_rendering(bec_motor_map):
+    motor_map_dev = bec_motor_map.client.device_manager.devices
+
+    init_positions = {
+        "samx": [motor_map_dev["samx"].read()["samx"]["value"]],
+        "samy": [motor_map_dev["samy"].read()["samy"]["value"]],
+    }
+
+    bec_motor_map.change_motors("samx", "samy")
+
+    # Simulate motor movement for 'samx' only
+    new_position_samx = 4.0
+    bec_motor_map.on_device_readback({"signals": {"samx": {"value": new_position_samx}}})
+    bec_motor_map._update_plot()
+
+    # Get the scatter plot item
+    scatter_plot_item = bec_motor_map.plot_components["scatter"]
+
+    # Check the scatter plot item properties
+    assert len(scatter_plot_item.data) > 0, "Scatter plot data is empty"
+    x_data = scatter_plot_item.data["x"]
+    y_data = scatter_plot_item.data["y"]
+    assert x_data[-1] == new_position_samx, "Scatter plot X data not updated correctly"
+    assert (
+        y_data[-1] == init_positions["samy"][-1]
+    ), "Scatter plot Y data should retain last known position"
+
+
+def test_plot_visualization_consistency(bec_motor_map):
+    bec_motor_map.change_motors("samx", "samy")
+    # Simulate updating the plot with new data
+    bec_motor_map.on_device_readback({"signals": {"samx": {"value": 5}}})
+    bec_motor_map.on_device_readback({"signals": {"samy": {"value": 9}}})
+    bec_motor_map._update_plot()
+
+    scatter_plot_item = bec_motor_map.plot_components["scatter"]
+
+    # Check if the scatter plot reflects the new data correctly
+    assert (
+        scatter_plot_item.data["x"][-1] == 5 and scatter_plot_item.data["y"][-1] == 9
+    ), "Plot not updated correctly with new data"
--- a/tests/unit_tests/test_client_utils.py
+++ b/tests/unit_tests/test_client_utils.py
@@ -0,0 +1,29 @@
+from unittest import mock
+
+import pytest
+
+from bec_widgets.cli.client import BECFigure
+
+from .client_mocks import FakeDevice
+
+
+@pytest.fixture
+def cli_figure():
+    fig = BECFigure(gui_id="test")
+    with mock.patch.object(fig, "_run_rpc") as mock_rpc_call:
+        with mock.patch.object(fig, "gui_is_alive", return_value=True):
+            yield fig, mock_rpc_call
+
+
+def test_rpc_call_plot(cli_figure):
+    fig, mock_rpc_call = cli_figure
+    fig.plot("samx", "bpm4i")
+    mock_rpc_call.assert_called_with("plot", "samx", "bpm4i")
+
+
+def test_rpc_call_accepts_device_as_input(cli_figure):
+    dev1 = FakeDevice("samx")
+    dev2 = FakeDevice("bpm4i")
+    fig, mock_rpc_call = cli_figure
+    fig.plot(dev1, dev2)
+    mock_rpc_call.assert_called_with("plot", "samx", "bpm4i")
--- a/tests/unit_tests/test_config_dialog.py
+++ b/tests/unit_tests/test_config_dialog.py
@@ -1,10 +1,14 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
 import os
-import yaml
+from unittest.mock import MagicMock

 import pytest
-from qtpy.QtWidgets import QTabWidget, QTableWidgetItem
+import yaml
+from qtpy.QtWidgets import QTableWidgetItem, QTabWidget

-from bec_widgets.widgets import ConfigDialog
+from bec_widgets.widgets.monitor.config_dialog import ConfigDialog
+
+from .client_mocks import mocked_client


 def load_test_config(config_name):
@@ -16,8 +20,9 @@ def load_test_config(config_name):


@pytest.fixture(scope="function")
-def config_dialog(qtbot):
-    widget = ConfigDialog()
+def config_dialog(qtbot, mocked_client):
+    client = mocked_client
+    widget = ConfigDialog(client=client)
    qtbot.addWidget(widget)
    qtbot.waitExposed(widget)
    yield widget
--- a/tests/unit_tests/test_configs/config_device.yaml
+++ b/tests/unit_tests/test_configs/config_device.yaml
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`from .figure import BECFigure, FigureConfig`