docs: add tutorial on how to add StartScan Button

docs: refactor developer section, add widget tutorial
ci: add job optional dependency check
2026-04-10 02:30:54 +02:00 · 2024-06-14 14:30:40 +02:00 · 2024-06-14 14:24:38 +02:00 · 2024-06-14 11:47:42 +02:00 · 2024-06-14 08:14:22 +00:00 · 2024-06-13 15:14:30 +02:00
56 changed files with 3021 additions and 1443 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -22,6 +22,13 @@ workflow:

 include:
  - template: Security/Secret-Detection.gitlab-ci.yml
+  - project: "bec/awi_utils"
+    file: "/templates/check-packages-job.yml"
+    inputs:
+      stage: test
+      path: "."
+      pytest_args: "-v --random-order tests/"
+      exclude_packages: ""

 # different stages in the pipeline
 stages:
@@ -31,8 +38,22 @@ stages:
  - End2End
  - Deploy

+.install-qt-webengine-deps: &install-qt-webengine-deps
+  - apt-get -y install libnss3 libxdamage1 libasound2 libatomic1 libxcursor1
+  - export QTWEBENGINE_DISABLE_SANDBOX=1
+
+.clone-repos: &clone-repos
+  - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+  - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+  - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+
+.install-os-packages: &install-os-packages
+  - apt-get update
+  - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+  - *install-qt-webengine-deps
+
 before_script:
-  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then 
+  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then
    echo -e "\033[35;1m Using branch $CHILD_PIPELINE_BRANCH of BEC Widgets \033[0;m";
    test -d bec_widgets || git clone --branch $CHILD_PIPELINE_BRANCH https://gitlab.psi.ch/bec/bec_widgets.git; cd bec_widgets;
    fi
@@ -75,18 +96,21 @@ pylint-check:
    - apt-get update
    - apt-get install -y bc
  script:
+    - git fetch origin $CI_MERGE_REQUEST_TARGET_BRANCH_NAME
    # Identify changed Python files
    - if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then
-        TARGET_BRANCH_COMMIT_SHA=$(git rev-parse $CI_MERGE_REQUEST_TARGET_BRANCH_NAME);
-        CHANGED_FILES=$(git diff --name-only $SOURCE_BRANCH_COMMIT_SHA $TARGET_BRANCH_COMMIT_SHA | grep '\.py$' || true);
+      TARGET_BRANCH_COMMIT_SHA=$(git rev-parse origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME);
+      CHANGED_FILES=$(git diff --name-only $TARGET_BRANCH_COMMIT_SHA HEAD | grep '\.py$' || true);
      else
-        CHANGED_FILES=$(git diff --name-only $CI_COMMIT_BEFORE_SHA $CI_COMMIT_SHA | grep '\.py$' || true);
+      CHANGED_FILES=$(git diff --name-only $CI_COMMIT_BEFORE_SHA $CI_COMMIT_SHA | grep '\.py$' || true);
      fi
    - if [ -z "$CHANGED_FILES" ]; then echo "No Python files changed."; exit 0; fi

+    - echo "Changed Python files:"
+      - $CHANGED_FILES
    # Run pylint only on changed files
    - mkdir ./pylint
-    - pylint $CHANGED_FILES --output-format=text . | tee ./pylint/pylint_changed_files.log || pylint-exit $?
+    - pylint $CHANGED_FILES --output-format=text | tee ./pylint/pylint_changed_files.log || pylint-exit $?
    - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint_changed_files.log)
    - echo "Pylint score is $PYLINT_SCORE"

@@ -103,14 +127,12 @@ tests:
  stage: test
  needs: []
  variables:
-      QT_QPA_PLATFORM: "offscreen"
+    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
+    - *clone-repos
+    - *install-os-packages
    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e ./bec/bec_ipython_client
    - pip install -e .[dev,pyqt6]
    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
    - coverage report
@@ -123,123 +145,31 @@ tests:
        coverage_format: cobertura
        path: coverage.xml

-tests-3.10-pyside6:
-  extends: "tests"
-  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.10
-  script:
-    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-    - apt-get update
-    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-    - pip install -e ./bec/bec_lib[dev]
-    - pip install -e .[dev,pyside6]
-    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
-  allow_failure: true
+test-matrix:
+  parallel:
+    matrix:
+      - PYTHON_VERSION:
+          - "3.10"
+          - "3.11"
+          - "3.12"
+        QT_PCKG:
+          - "pyside6"
+          - "pyqt5"
+          - "pyqt6"

-tests-3.12-pyside6:
-  extends: "tests"
  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.12
+  needs: []
+  variables:
+    QT_QPA_PLATFORM: "offscreen"
+    PYTHON_VERSION: ""
+    QT_PCKG: ""
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:$PYTHON_VERSION
  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
+    - *clone-repos
+    - *install-os-packages
    - pip install -e ./bec/bec_lib[dev]
-    - pip install -e .[dev,pyside6]
-    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
-  allow_failure: true
-
-tests-3.10-pyqt5:
-  extends: "tests"
-  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.10
-  script:
-    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-    - apt-get update
-    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-    - pip install -e ./bec/bec_lib[dev]
-    - pip install -e .[dev,pyqt5]
-    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
-  allow_failure: true
-
-tests-3.11-pyqt5:
-  extends: "tests"
-  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
-  script:
-    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-    - apt-get update
-    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-    - pip install -e ./bec/bec_lib[dev]
-    - pip install -e .[dev,pyqt5]
-    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
-  allow_failure: true
-
-tests-3.12-pyqt5:
-  extends: "tests"
-  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.12
-  script:
-    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-    - apt-get update
-    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-    - pip install -e ./bec/bec_lib[dev]
-    - pip install -e .[dev,pyqt5]
-    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
-  allow_failure: true
-
-tests-3.10-pyqt6:
-  extends: "tests"
-  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.10
-  script:
-    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-    - apt-get update
-    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-    - pip install -e ./bec/bec_lib[dev]
-    - pip install -e .[dev,pyqt6]
-    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
-  allow_failure: true
-
-tests-3.11-pyqt6:
-  extends: "tests"
-  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.11
-  script:
-    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-    - apt-get update
-    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-    - pip install -e ./bec/bec_lib[dev]
-    - pip install -e .[dev,pyqt6]
-    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
-  allow_failure: true
-
-tests-3.12-pyqt6:
-  extends: "tests"
-  stage: AdditionalTests
-  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:3.12
-  script:
-    - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-    - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-    - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-    - apt-get update
-    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
-    - pip install -e ./bec/bec_lib[dev]
-    - pip install -e .[dev,pyqt6]
+    - pip install -e ./bec/bec_ipython_client
+    - pip install -e .[dev,$QT_PCKG]
    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
  allow_failure: true

@@ -251,8 +181,8 @@ end-2-end-conda:
  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
+    - *clone-repos
+    - *install-os-packages
    - conda config --prepend channels conda-forge
    - conda config --set channel_priority strict
    - conda config --set always_yes yes --set changeps1 no
@@ -261,10 +191,6 @@ end-2-end-conda:
    - 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

@@ -307,7 +233,7 @@ semver:
    - pip install python-semantic-release==9.* wheel build twine
    - export GL_TOKEN=$CI_UPDATES
    - semantic-release -vv version
-    
+
    # check if any artifacts were created
    - if [ ! -d dist ]; then echo No release will be made; exit 0; fi
    - twine upload dist/* -u __token__ -p $CI_PYPI_TOKEN --skip-existing
@@ -323,7 +249,7 @@ pages:
  variables:
    TARGET_BRANCH: $CI_COMMIT_REF_NAME
  rules:
-    - if: '$CI_COMMIT_TAG != null'
+    - if: "$CI_COMMIT_TAG != null"
      variables:
        TARGET_BRANCH: $CI_COMMIT_TAG
    - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,160 +2,175 @@



-## v0.57.4 (2024-06-06)
+## v0.63.2 (2024-06-14)

 ### Fix

-* fix(docks): set_title do update dock internal _name now ([`15cbc21`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/15cbc21e5bb3cf85f5822d44a2b3665b5aa2f346))
+* fix: do not import &#34;server&#34; in client, prevents from having trouble with QApplication creation order

-* fix(docks): docks widget_list adn dockarea panels return values fixed ([`ffae5ee`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ffae5ee54e6b43da660131092452adff195ba4fb))
+Like with QtWebEngine ([`6f96498`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6f96498de66358b89f3a2035627eed2e02dde5a1))
+
+### Unknown
+
+* Reapply &#34;feat: implement non-polling, interruptible waiting of gui instruction response with timeout&#34;
+
+This reverts commit fe04dd80e59a0e74f7fdea603e0642707ecc7c2a. ([`836b6e6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/836b6e64f694916d6b6f909dedf11a4a6d2c86a4))


-## v0.57.3 (2024-06-06)
+## v0.63.1 (2024-06-13)
+
+### Fix
+
+* fix: just terminate the remote process in close() instead of communicating
+
+The proper finalization sequence will be executed by the remote process
+on SIGTERM ([`9263f8e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9263f8ef5c17ae7a007a1a564baf787b39061756))
+
+
+## v0.63.0 (2024-06-13)

 ### Documentation

-* docs(bar): docs updated ([`4be0d14`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4be0d14b7445c2322c2aef86257db168a841265c))
+* docs: add documentation ([`bc709c4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/bc709c4184c985d4e721f9ea7d1b3dad5e9153a7))

-* docs: fixed syntax of add_widget ([`a951ebf`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a951ebf1be6c086d094aa8abef5e0dfd1b3b8558))
+### Feature

-* docs: added auto update; closes #206 ([`32da803`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/32da803df9f7259842c43e85ba9a0ce29a266d06))
-
-* docs: cleanup ([`07d60cf`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/07d60cf7355d2edadb3c5ef8b86607d74b360455))
-
-### Fix
-
-* fix(ring): automatic updates are disabled uf user specify updates manually with .set_update; &#39;scan_progres&#39; do not reset number of rings ([`e883dba`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e883dbad814dbcc0a19c341041c6d836e58a5918))
-
-* fix(ring): enable_auto_updates(True) do not reset properties of already setup bars ([`a2abad3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a2abad344f4c0039516eb60a825afb6822c5b19a))
-
-* fix(ring): set_min_max accepts floats ([`d44b1cf`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d44b1cf8b107cf02deedd9154b77d01c7f9ed05d))
-
-* fix(ring): set_update changed to Literals, no need to specify endpoint manually ([`c5b6499`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c5b6499e41eb1495bf260436ca3e1b036182c360))
-
-
-## v0.57.2 (2024-06-06)
-
-### Fix
-
-* fix(test/e2e): autoupdate e2e rewritten ([`e1af5ca`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e1af5ca60f0616835f9f41d84412f29dc298c644))
-
-* fix(test/e2e): spiral_progress_bar e2e tests rewritten to use config_dict ([`7fb31fc`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7fb31fc4d762ff4ca839971b3092a084186f81b8))
-
-* fix(test/e2e): dockarea and dock e2e tests changed to check asserts against config_dict ([`5c6ba65`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/5c6ba65469863ea1e6fc5abdc742650e20eba9b9))
-
-* fix: rpc_server_dock fixture now spawns the server process ([`cd9fc46`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/cd9fc46ff8a947242c8c28adcd73d7de60b11c44))
-
-* fix: accept scalars or numpy arrays of 1 element ([`2a88e17`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2a88e17b23436c55d25b7d3449e4af3a7689661c))
+* feat: add textbox widget ([`d9d4e3c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d9d4e3c9bf73ab2a5629c2867b50fc91e69489ec))

 ### Refactor

-* refactor: move _get_output and _start_plot_process at the module level ([`69f4371`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/69f4371007c66aee6b7521a6803054025adf8c92))
+* refactor: add pydantic config, add change_theme ([`6b8432f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6b8432f5b20a71175a3537b5f6832b76e3b67d73))
+
+### Test
+
+* test: add test for text box ([`b49462a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b49462abeb186e56bac79d2ef0b0add1ef28a1a5))
+
+### Unknown
+
+* Revert &#34;feat: implement non-polling, interruptible waiting of gui instruction response with timeout&#34;
+
+This reverts commit abc6caa2d0b6141dfbe1f3d025f78ae14deddcb3 ([`fe04dd8`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fe04dd80e59a0e74f7fdea603e0642707ecc7c2a))


-## v0.57.1 (2024-06-06)
-
-### Documentation
-
-* docs: docs refactored from add_widget_bec to add_widget ([`c3f4845`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c3f4845b4f95005ff737fed5542600b0b9a9cc2b))
-
-### Fix
-
-* fix: tests references to add_widget_bec refactored ([`f51b25f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f51b25f0af4ab8b0a75ee48a40bfbb079c16e9d1))
-
-* fix(dock): add_widget and add_widget_bec consolidated ([`8ae323f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8ae323f5c3c0d9d0f202d31d5e8374a272a26be2))
-
-
-## v0.57.0 (2024-06-05)
-
-### Documentation
-
-* docs: extend user documentation for BEC Widgets ([`4160f3d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4160f3d6d7ec1122785b5e3fdfc4afe67a95e9a1))
+## v0.62.0 (2024-06-12)

 ### Feature

-* feat(widgets/console): BECJupyterConsole added ([`8c03034`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/8c03034acf6b3ed1e346ebf1b785d41068513cc5))
+* feat: implement non-polling, interruptible waiting of gui instruction response with timeout ([`abc6caa`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/abc6caa2d0b6141dfbe1f3d025f78ae14deddcb3))
+
+### Unknown
+
+* doc: add documentation about creating custom GUI applications embedding BEC Widgets ([`17a0068`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/17a00687579f5efab1990cd83862ec0e78198633))


-## v0.56.3 (2024-06-05)
-
-### Ci
-
-* ci: increased verbosity for e2e tests ([`4af1abe`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4af1abe4e15b62d2f7e70bf987a1a7d8694ef4d5))
-
-### Fix
-
-* fix: fixed support for auto updates ([`131f49d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/131f49da8ea65af4d44b50e81c1acfc29cd92093))
-
-
-## v0.56.2 (2024-06-05)
-
-### Documentation
-
-* docs: restructured docs layout ([`3c9181d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3c9181d93d68faa4efb3b91c486ca9ca935975a0))
-
-### Fix
-
-* fix(bar): ring saves current value in config ([`9648e3e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9648e3ea96a4109be6be694d855151ed6d3ad661))
-
-* fix(dock): dock saves configs of all children widgets ([`4be756a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/4be756a8676421c3a3451458995232407295df84))
-
-* fix(dock_area): save/restore state is saved in config ([`46face0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/46face0ee59122f04cb383da685a6658beeeb389))
-
-* fix(figure): added correct types of configs to subplot widgets ([`6f3b1ea`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6f3b1ea985c18929b9bab54239eeb600f03b274a))
-
-
-## v0.56.1 (2024-06-04)
-
-### Fix
-
-* fix(spiral_progress_bar/rings): config min/max values added check for floats ([`9d615c9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9d615c915c8f7cc2ea8f1dc17993b98fe462c682))
-
-* fix(spiral_progress_bar): Endpoint is always stored as a string in the RingConnection Config ([`d253991`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d2539918b296559e1d684344e179775a2423daa9))
-
-
-## v0.56.0 (2024-05-29)
-
-### Build
-
-* build: added pyside6 as dependency ([`db301b1`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/db301b1be27bba76c8bb21fbff93cb4902b592a5))
-
-### Ci
-
-* ci: added tests for pyside6, pyqt6 and pyqt5, default test and e2e is python 3.11 and pyqt6 ([`855be35`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/855be3551a1372bcbebba6f8930903f99202bbca))
-
-### Documentation
-
-* docs(examples): example apps section deleted ([`ad208a5`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ad208a5ef8495c45a8b83a4850ba9a1041b42717))
+## v0.61.0 (2024-06-12)

 ### Feature

-* feat(utils/ui_loader): universal ui loader for pyside/pyqt ([`0fea8d6`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/0fea8d606574fa99dda3b117da5d5209c251f694))
-
-### Fix
-
-* fix(examples): outdated examples removed (mca_plot.py, stream_plot.py, motor_example.py) ([`ddc9510`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ddc9510c2ba8dadf291809eeb5b135a105259492))
-
-* fix: compatibility adjustment to .ui loading and tests for PySide6 ([`07b99d9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/07b99d91a57a645cddd76294f48d78773e4c9ea5))
-
-
-## v0.55.0 (2024-05-24)
-
-### Feature
-
-* feat(widgets/progressbar): SpiralProgressBar added with rpc interface ([`76bd0d3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/76bd0d339ac9ae9e8a3baa0d0d4e951ec1d09670))
-
-
-## v0.54.0 (2024-05-24)
-
-### Build
-
-* build: added pyqt6 as sphinx build dependency ([`a47a8ec`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a47a8ec413934cf7fce8d5b7a5913371d4b3b4a5))
-
-### Feature
-
-* feat(figure): changes to support direct plot functionality ([`fc4d0f3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fc4d0f3bb2a7c2fca9c326d86eb68b305bcd548b))
+* feat(widgets/stop_button): General stop button added ([`61ba08d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/61ba08d0b8df9f48f5c54c7c2b4e6d395206e7e6))

 ### Refactor

-* refactor(reconstruction): repository structure is changed to separate assets needed for each widget ([`3455c60`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3455c602361d3b5cc3ff9190f9d2870474becf8a))
+* refactor: improve labe of auto_update script ([`40b5688`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/40b568815893cd41af3531bb2e647ca1e2e315f4))
+
+
+## v0.60.0 (2024-06-08)
+
+### Ci
+
+* ci: added git fetch for target branch ([`fc4f4f8`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/fc4f4f81ad1be99cf5112f2188a46c5bed2679ee))
+
+* ci: fixed pylint-check ([`6b1d582`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6b1d5827d6599f06a3acd316060a8d25f0686d54))
+
+* ci: cleanup ([`11173b9`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/11173b9c0a7dc4b36e35962042e5b86407da49f1))
+
+### Feature
+
+* feat: added isort to bw-generate-cli ([`f0391f5`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f0391f59c9eb0a51b693fccfe2e399e869d35dda))
+
+* feat: added entry point for bw-generate-cli ([`1c7f491`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1c7f4912ce5998e666276969bf4af8656d619a91))
+
+* feat(cli): auto-discover rpc-enabled widgets ([`df1be10`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/df1be10057a5e85a3f35bef1c1b27366b6727276))
+
+### Fix
+
+* fix: removed BECConnector from rpc client interface ([`6428e38`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6428e38ab94c15a2c904e75cc6404bb6d0394e04))
+
+* fix: added bec_ipython_client as dependency; needed for jupyter widget ([`006a089`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/006a0894b85cba3b2773737ed6fe3e92c81cdee0))
+
+* fix(BECFigure): removed duplicated user access for plot ([`954c576`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/954c576131f7deac669ddf9f51eeb1d41b6f92b7))
+
+* fix(bec_connector): field validator should be a classmethod ([`867720a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/867720a897b6713bd0df9af71ffdd11a6a380f7d))
+
+### Refactor
+
+* refactor: minor cleanup ([`3adf6cf`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/3adf6cfd586355c8b8ce7fdc9722f868e22287c5))
+
+* refactor: disabled pylint for auto-gen client ([`b15816c`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/b15816ca9fd3e4ae87cca5fcfe029b4dfca570ca))
+
+* refactor(isort): added bec_widgets as known first party package ([`9c5a471`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9c5a471234ed2928e4527b079436db2a807c5f6f))
+
+* refactor(dock): parent_dock_area changed to orig_area (native for pyqtgraph) ([`2b40602`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2b40602bdc593ece0447ec926c2100414bd5cf67))
+
+### Test
+
+* test: added missing pylint statement to header ([`f662985`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/f6629852ebc2b4ee239fa560cc310a5ae2627cf7))
+
+
+## v0.59.1 (2024-06-07)
+
+### Fix
+
+* fix(curve): set_color_map_z typo fixed in user access ([`e7838b0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/e7838b0f2fc23b0a232ed7d68fbd7f3493a91b9e))
+
+
+## v0.59.0 (2024-06-07)
+
+### Build
+
+* build: added webengine dependency ([`d56c549`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d56c5493cd28f379d04a79d90b01c73b0760da1b))
+
+### Ci
+
+* ci: merged additional tests to parallel matrix job ([`178fe4d`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/178fe4d2da3a959f7cd90e7ea0f47314dc1ef4ed))
+
+* ci: added webengine dependencies ([`2d79ef8`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2d79ef8fe5e52c61f4a78782770377cd6b41958b))
+
+### Documentation
+
+* docs: added website docs ([`cf6e5a4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/cf6e5a40fc8320e9898a446a5bf14b77e94ef013))
+
+### Feature
+
+* feat(widget): added simple website widget with rpc ([`64abd67`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/64abd67b9b416bff9c89880b248d6e8639aa1e70))
+
+
+## v0.58.1 (2024-06-07)
+
+### Fix
+
+* fix(dock): new dock can be detached upon creation ([`02a2608`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/02a26086c4540127a11c235cba30afc4fd712007))
+
+
+## v0.58.0 (2024-06-07)
+
+### Feature
+
+* feat(utils.colors): general color validators ([`3094632`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/30946321348abc349fb4003dc39d0232dc19606c))
+
+### Fix
+
+* fix: bar colormap dynamic setting ([`67fd5e8`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/67fd5e8581f60fe64027ac57f1f12cefa4d28343))
+
+* fix: formatting isort ([`bf699ec`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/bf699ec1fbe2aacd31854e84fb0438c336840fcf))
+
+* fix(curve): 2D scatter updated if color_map_z is changed ([`6985ff0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6985ff0fcef9791b53198206ec8cbccd1d65ef99))
+
+* fix(curve): color_map_z setting works ([`33f7be4`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/33f7be42c512402dab3fdd9781a8234e3ec5f4ba))
+
+### Test
+
+* test(color): validation tests added ([`c0ddece`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/c0ddeceeeabacbf33019a8f24b18821926dc17ac))
+
+
+## v0.57.7 (2024-06-07)
--- a/bec_widgets/cli/init.py
+++ b/bec_widgets/cli/init.py
@@ -1 +1 @@
-from .client import BECDockArea, BECFigure
+from .client import *
--- a/bec_widgets/cli/auto_updates.py
+++ b/bec_widgets/cli/auto_updates.py
@@ -15,6 +15,7 @@ class ScanInfo(BaseModel):
    scan_report_devices: list
    monitored_devices: list
    status: str
+    model_config: dict = {"validate_assignment": True}


 class AutoUpdates:
@@ -117,7 +118,7 @@ class AutoUpdates:
        if not dev_y:
            return
        fig.clear_all()
-        plt = fig.plot(x_name=dev_x, y_name=dev_y)
+        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)

    def simple_grid_scan(self, info: ScanInfo) -> None:
@@ -131,7 +132,9 @@ class AutoUpdates:
        dev_y = info.scan_report_devices[1]
        dev_z = self.get_selected_device(info.monitored_devices, self.gui.selected_device)
        fig.clear_all()
-        plt = fig.plot(x_name=dev_x, y_name=dev_y, z_name=dev_z, label=f"Scan {info.scan_number}")
+        plt = fig.plot(
+            x_name=dev_x, y_name=dev_y, z_name=dev_z, label=f"Scan {info.scan_number} - {dev_z}"
+        )
        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)

    def best_effort(self, info: ScanInfo) -> None:
@@ -146,5 +149,5 @@ class AutoUpdates:
        if not dev_y:
            return
        fig.clear_all()
-        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number}")
+        plt = fig.plot(x_name=dev_x, y_name=dev_y, label=f"Scan {info.scan_number} - {dev_y}")
        plt.set(title=f"Scan {info.scan_number}", x_label=dev_x, y_label=dev_y)
--- 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
@@ -14,7 +14,7 @@ from typing import TYPE_CHECKING

 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.utils.import_utils import isinstance_based_on_class_name, lazy_import, lazy_import_from
-from qtpy.QtCore import QCoreApplication
+from qtpy.QtCore import QEventLoop, QSocketNotifier, QTimer

 import bec_widgets.cli.client as client
 from bec_widgets.cli.auto_updates import AutoUpdates
@@ -24,6 +24,8 @@ if TYPE_CHECKING:

    from bec_widgets.cli.client import BECDockArea, BECFigure

+from bec_lib.serialization import MsgpackSerialization
+
 messages = lazy_import("bec_lib.messages")
 # from bec_lib.connector import MessageObject
 MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
@@ -84,13 +86,8 @@ def _start_plot_process(gui_id, gui_class, config) -> None:
    Start the plot in a new process.
    """
    # 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,
+        "bec-gui-server",
        "--id",
        gui_id,
        "--config",
@@ -98,7 +95,11 @@ def _start_plot_process(gui_id, gui_class, config) -> None:
        "--gui_class",
        gui_class.__name__,
    ]
-    process = subprocess.Popen(command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    env_dict = os.environ.copy()
+    env_dict["PYTHONUNBUFFERED"] = "1"
+    process = subprocess.Popen(
+        command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env_dict
+    )
    process_output_processing_thread = threading.Thread(target=_get_output, args=(process,))
    process_output_processing_thread.start()
    return process, process_output_processing_thread
@@ -174,16 +175,11 @@ class BECGuiClientMixin:
        """
        Close the figure.
        """
-        if self._process is None:
-            return
-        if self.gui_is_alive():
-            self._run_rpc("close", (), wait_for_rpc_response=True)
-        else:
-            self._run_rpc("close", (), wait_for_rpc_response=False)
-        self._process.terminate()
-        self._process_output_processing_thread.join()
-        self._process = None
        self._client.shutdown()
+        if self._process:
+            self._process.terminate()
+            self._process_output_processing_thread.join()
+            self._process = None

    def print_log(self) -> None:
        """
@@ -205,6 +201,48 @@ class RPCResponseTimeoutError(Exception):
        )


+class QtRedisMessageWaiter:
+    def __init__(self, redis_connector, message_to_wait):
+        self.ev_loop = QEventLoop()
+        self.response = None
+        self.connector = redis_connector
+        self.message_to_wait = message_to_wait
+        self.pubsub = redis_connector._redis_conn.pubsub()
+        self.pubsub.subscribe(self.message_to_wait.endpoint)
+        fd = self.pubsub.connection._sock.fileno()
+        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
+        self.notifier.activated.connect(self._pubsub_readable)
+
+    def _msg_received(self, msg_obj):
+        self.response = msg_obj.value
+        self.ev_loop.quit()
+
+    def wait(self, timeout=1):
+        timer = QTimer()
+        timer.singleShot(timeout * 1000, self.ev_loop.quit)
+        self.ev_loop.exec_()
+        timer.stop()
+        self.notifier.setEnabled(False)
+        self.pubsub.close()
+        return self.response
+
+    def _pubsub_readable(self, fd):
+        while True:
+            msg = self.pubsub.get_message()
+            if msg:
+                if msg["type"] == "subscribe":
+                    # get_message buffers, so we may already have the answer
+                    # let's check...
+                    continue
+                else:
+                    break
+            else:
+                return
+        channel = msg["channel"].decode()
+        msg = MessageObject(topic=channel, value=MsgpackSerialization.loads(msg["data"]))
+        self.connector._execute_callback(self._msg_received, msg, {})
+
+
 class RPCBase:
    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
        self._client = BECDispatcher().client
@@ -231,7 +269,7 @@ class RPCBase:
            parent = parent._parent
        return parent

-    def _run_rpc(self, method, *args, wait_for_rpc_response=True, **kwargs):
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=3, **kwargs):
        """
        Run the RPC call.

@@ -253,16 +291,24 @@ class RPCBase:

        # pylint: disable=protected-access
        receiver = self._root._gui_id
+        if wait_for_rpc_response:
+            redis_msg = QtRedisMessageWaiter(
+                self._client.connector, MessageEndpoints.gui_instruction_response(request_id)
+            )
+
        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)

-        if 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)
+        if wait_for_rpc_response:
+            response = redis_msg.wait(timeout)
+
+            if response is None:
+                raise RPCResponseTimeoutError(request_id, timeout)
+
+            # get class name
+            if not response.accepted:
+                raise ValueError(response.message["error"])
+            msg_result = response.message.get("result")
+            return self._create_widget_from_msg_result(msg_result)

    def _create_widget_from_msg_result(self, msg_result):
        if msg_result is None:
@@ -285,30 +331,6 @@ class RPCBase:
            return cls(parent=self, **msg_result)
        return msg_result

-    def _wait_for_response(self, request_id: str, timeout: int = 5):
-        """
-        Wait for the response from the server.
-
-        Args:
-            request_id(str): The request ID.
-            timeout(int): The timeout in seconds.
-
-        Returns:
-            The response from the server.
-        """
-        start_time = time.time()
-        response = None
-
-        while response is None and self.gui_is_alive() and (time.time() - start_time) < timeout:
-            response = self._client.connector.get(
-                MessageEndpoints.gui_instruction_response(request_id)
-            )
-            QCoreApplication.processEvents()  # keep UI responsive (and execute signals/slots)
-        if response is None and (time.time() - start_time) >= timeout:
-            raise RPCResponseTimeoutError(request_id, timeout)
-
-        return response
-
    def gui_is_alive(self):
        """
        Check if the GUI is alive.
--- a/bec_widgets/cli/generate_cli.py
+++ b/bec_widgets/cli/generate_cli.py
@@ -1,10 +1,18 @@
 # pylint: disable=missing-module-docstring
 from __future__ import annotations

+import argparse
+import importlib
 import inspect
+import os
 import sys
+from typing import Literal

 import black
+import isort
+from qtpy.QtWidgets import QGraphicsWidget, QWidget
+
+from bec_widgets.utils import BECConnector

 if sys.version_info >= (3, 11):
    from typing import get_overloads
@@ -14,30 +22,52 @@ else:
        "If you want to use the real function 'typing.get_overloads()', please use Python 3.11 or later."
    )

-    def get_overloads(obj):
-        # Dummy function for Python versions before 3.11
+    def get_overloads(_obj):
+        """
+        Dummy function for Python versions before 3.11.
+        """
        return []


 class ClientGenerator:
    def __init__(self):
        self.header = """# This file was automatically generated by generate_cli.py\n
-from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECGuiClientMixin
-from typing import Literal, Optional, overload"""
+import enum
+from typing import Literal, Optional, overload
+
+from bec_widgets.cli.client_utils import RPCBase, rpc_call, BECGuiClientMixin
+
+# pylint: skip-file"""

        self.content = ""

-    def generate_client(self, published_classes: list):
+    def generate_client(
+        self, published_classes: dict[Literal["connector_classes", "top_level_classes"], list[type]]
+    ):
        """
        Generate the client for the published classes.

        Args:
-            published_classes(list): The list of published classes (e.g. [BECWaveform1D, BECFigure]).
+            published_classes(dict): A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
        """
-        for cls in published_classes:
+        self.write_client_enum(published_classes["top_level_classes"])
+        for cls in published_classes["connector_classes"]:
            self.content += "\n\n"
            self.generate_content_for_class(cls)

+    def write_client_enum(self, published_classes: list[type]):
+        """
+        Write the client enum to the content.
+        """
+        self.content += """
+class Widgets(str, enum.Enum):
+    \"\"\"
+    Enum for the available widgets.
+    \"\"\"
+    """
+        for cls in published_classes:
+            self.content += f'{cls.__name__} = "{cls.__name__}"\n    '
+
    def generate_content_for_class(self, cls):
        """
        Generate the content for the class.
@@ -47,11 +77,6 @@ from typing import Literal, Optional, overload"""
        """

        class_name = cls.__name__
-        module = cls.__module__
-
-        # Generate the header
-        #         self.header += f"""
-        # from {module} import {class_name}"""

        # Generate the content
        if cls.__name__ == "BECDockArea":
@@ -101,39 +126,85 @@ class {class_name}(RPCBase):"""
        except black.NothingChanged:
            formatted_content = full_content

+        isort.Config(
+            profile="black",
+            line_length=100,
+            multi_line_output=3,
+            include_trailing_comma=True,
+            known_first_party=["bec_widgets"],
+        )
+        formatted_content = isort.code(formatted_content)
+
        with open(file_name, "w", encoding="utf-8") as file:
            file.write(formatted_content)

+    @staticmethod
+    def get_rpc_classes(
+        repo_name: str,
+    ) -> dict[Literal["connector_classes", "top_level_classes"], list[type]]:
+        """
+        Get all RPC-enabled classes in the specified repository.
+
+        Args:
+            repo_name(str): The name of the repository.
+
+        Returns:
+            dict: A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
+        """
+        connector_classes = []
+        top_level_classes = []
+        anchor_module = importlib.import_module(f"{repo_name}.widgets")
+        directory = os.path.dirname(anchor_module.__file__)
+        for root, _, files in sorted(os.walk(directory)):
+            for file in files:
+                if not file.endswith(".py") or file.startswith("__"):
+                    continue
+
+                path = os.path.join(root, file)
+                subs = os.path.dirname(os.path.relpath(path, directory)).split("/")
+                if len(subs) == 1 and not subs[0]:
+                    module_name = file.split(".")[0]
+                else:
+                    module_name = ".".join(subs + [file.split(".")[0]])
+
+                module = importlib.import_module(f"{repo_name}.widgets.{module_name}")
+
+                for name in dir(module):
+                    obj = getattr(module, name)
+                    if not hasattr(obj, "__module__") or obj.__module__ != module.__name__:
+                        continue
+                    if isinstance(obj, type) and issubclass(obj, BECConnector):
+                        connector_classes.append(obj)
+                        if len(subs) == 1 and (
+                            issubclass(obj, QWidget) or issubclass(obj, QGraphicsWidget)
+                        ):
+                            top_level_classes.append(obj)
+
+        return {"connector_classes": connector_classes, "top_level_classes": top_level_classes}
+
+
+def main():
+    """
+    Main entry point for the script, controlled by command line arguments.
+    """
+
+    parser = argparse.ArgumentParser(description="Auto-generate the client for RPC widgets")
+    parser.add_argument("--core", action="store_true", help="Whether to generate the core client")
+
+    args = parser.parse_args()
+
+    if args.core:
+        current_path = os.path.dirname(__file__)
+        client_path = os.path.join(current_path, "client.py")
+
+        rpc_classes = ClientGenerator.get_rpc_classes("bec_widgets")
+        rpc_classes["connector_classes"].sort(key=lambda x: x.__name__)
+
+        generator = ClientGenerator()
+        generator.generate_client(rpc_classes)
+        generator.write(client_path)
+

 if __name__ == "__main__":  # pragma: no cover
-    import os
-
-    from bec_widgets.utils import BECConnector
-    from bec_widgets.widgets import BECDock, BECDockArea, BECFigure, SpiralProgressBar
-    from bec_widgets.widgets.figure.plots.image.image import BECImageShow
-    from bec_widgets.widgets.figure.plots.image.image_item import BECImageItem
-    from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap
-    from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase
-    from bec_widgets.widgets.figure.plots.waveform.waveform import BECWaveform
-    from bec_widgets.widgets.figure.plots.waveform.waveform_curve import BECCurve
-    from bec_widgets.widgets.spiral_progress_bar.ring import Ring
-
-    current_path = os.path.dirname(__file__)
-    client_path = os.path.join(current_path, "client.py")
-    clss = [
-        BECPlotBase,
-        BECWaveform,
-        BECFigure,
-        BECCurve,
-        BECImageShow,
-        BECConnector,
-        BECImageItem,
-        BECMotorMap,
-        BECDock,
-        BECDockArea,
-        SpiralProgressBar,
-        Ring,
-    ]
-    generator = ClientGenerator()
-    generator.generate_client(clss)
-    generator.write(client_path)
+    sys.argv = ["generate_cli.py", "--core"]
+    main()
--- a/bec_widgets/cli/rpc_wigdet_handler.py
+++ b/bec_widgets/cli/rpc_wigdet_handler.py
@@ -1,12 +1,19 @@
 from bec_widgets.utils import BECConnector
 from bec_widgets.widgets.figure import BECFigure
 from bec_widgets.widgets.spiral_progress_bar.spiral_progress_bar import SpiralProgressBar
+from bec_widgets.widgets.text_box.text_box import TextBox
+from bec_widgets.widgets.website.website import WebsiteWidget


 class RPCWidgetHandler:
    """Handler class for creating widgets from RPC messages."""

-    widget_classes = {"BECFigure": BECFigure, "SpiralProgressBar": SpiralProgressBar}
+    widget_classes = {
+        "BECFigure": BECFigure,
+        "SpiralProgressBar": SpiralProgressBar,
+        "Website": WebsiteWidget,
+        "TextBox": TextBox,
+    }

    @staticmethod
    def create_widget(widget_type, **kwargs) -> BECConnector:
--- a/bec_widgets/cli/server.py
+++ b/bec_widgets/cli/server.py
@@ -114,7 +114,7 @@ class BECWidgetsCLIServer:
        self.client.shutdown()


-if __name__ == "__main__":  # pragma: no cover
+def main():
    import argparse
    import os
    import sys
@@ -166,3 +166,7 @@ if __name__ == "__main__":  # pragma: no cover

    app.aboutToQuit.connect(server.shutdown)
    sys.exit(app.exec())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/examples/jupyter_console/jupyter_console_window.py
+++ b/bec_widgets/examples/jupyter_console/jupyter_console_window.py
@@ -86,9 +86,10 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
        self.console_layout.addWidget(self.console)

    def _init_figure(self):
-        self.figure.plot(x_name="samx", y_name="bpm4d")
+        self.figure.plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="cividis")
        self.figure.motor_map("samx", "samy")
        self.figure.image("eiger", color_map="viridis", vrange=(0, 100))
+        self.figure.add_plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="magma")

        self.figure.change_layout(2, 2)

@@ -97,14 +98,14 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
        self.w3 = self.figure[1, 0]

        # curves for w1
-        self.w1.add_curve_scan("samx", "samy", "bpm4i", pen_style="dash")
-        self.w1.add_curve_scan("samx", "samy", "bpm3a", pen_style="dash")
        self.c1 = self.w1.get_config()

    def _init_dock(self):

        self.d0 = self.dock.add_dock(name="dock_0")
        self.fig0 = self.d0.add_widget("BECFigure")
+        data = np.random.rand(10, 2)
+        self.fig0.plot(data, label="2d Data")
        self.fig0.image("eiger", vrange=(0, 100))

        self.d1 = self.dock.add_dock(name="dock_1", position="right")
@@ -114,7 +115,6 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:

        self.d2 = self.dock.add_dock(name="dock_2", position="bottom")
        self.fig2 = self.d2.add_widget("BECFigure", row=0, col=0)
-        self.fig2.motor_map(x_name="samx", y_name="samy")
        self.fig2.plot(x_name="samx", y_name="bpm4i")
        self.bar = self.d2.add_widget("SpiralProgressBar", row=0, col=1)
        self.bar.set_diameter(200)
@@ -136,17 +136,18 @@ if __name__ == "__main__":  # pragma: no cover

    module_path = os.path.dirname(bec_widgets.__file__)

+    app = QApplication(sys.argv)
+    app.setApplicationName("Jupyter Console")
+    app.setApplicationDisplayName("Jupyter Console")
+    qdarktheme.setup_theme("auto")
+    icon = QIcon()
+    icon.addFile(os.path.join(module_path, "assets", "terminal_icon.png"), size=QSize(48, 48))
+    app.setWindowIcon(icon)
+
    bec_dispatcher = BECDispatcher()
    client = bec_dispatcher.client
    client.start()

-    app = QApplication(sys.argv)
-    app.setApplicationName("Jupyter Console")
-    app.setApplicationDisplayName("Jupyter Console")
-    # qdarktheme.setup_theme("auto")
-    icon = QIcon()
-    icon.addFile(os.path.join(module_path, "assets", "terminal_icon.png"), size=QSize(48, 48))
-    app.setWindowIcon(icon)
    win = JupyterConsoleWindow()
    win.show()

--- a/bec_widgets/utils/bec_connector.py
+++ b/bec_widgets/utils/bec_connector.py
@@ -20,8 +20,10 @@ class ConnectionConfig(BaseModel):
    gui_id: Optional[str] = Field(
        default=None, validate_default=True, description="The GUI ID of the widget."
    )
+    model_config: dict = {"validate_assignment": True}

    @field_validator("gui_id")
+    @classmethod
    def generate_gui_id(cls, v, values):
        """Generate a GUI ID if none is provided."""
        if v is None:
--- a/bec_widgets/utils/bec_dispatcher.py
+++ b/bec_widgets/utils/bec_dispatcher.py
@@ -9,7 +9,7 @@ import redis
 from bec_lib.client import BECClient
 from bec_lib.redis_connector import MessageObject, RedisConnector
 from bec_lib.service_config import ServiceConfig
-from qtpy.QtCore import QObject
+from qtpy.QtCore import QCoreApplication, QObject
 from qtpy.QtCore import Signal as pyqtSignal

 if TYPE_CHECKING:
@@ -71,6 +71,7 @@ class BECDispatcher:

    _instance = None
    _initialized = False
+    qapp = None

    def __new__(cls, client=None, config: str = None, *args, **kwargs):
        if cls._instance is None:
@@ -82,6 +83,9 @@ class BECDispatcher:
        if self._initialized:
            return

+        if not QCoreApplication.instance():
+            BECDispatcher.qapp = QCoreApplication([])
+
        self._slots = collections.defaultdict(set)
        self.client = client

--- a/bec_widgets/utils/colors.py
+++ b/bec_widgets/utils/colors.py
@@ -1,11 +1,14 @@
+import re
 from typing import Literal

 import numpy as np
 import pyqtgraph as pg
+from pydantic_core import PydanticCustomError
 from qtpy.QtGui import QColor


 class Colors:
+
    @staticmethod
    def golden_ratio(num: int) -> list:
        """Calculate the golden ratio for a given number of angles.
@@ -63,3 +66,211 @@ class Colors:
            else:
                raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
        return colors
+
+    @staticmethod
+    def validate_color(color: tuple | str) -> tuple | str:
+        """
+        Validate the color input if it is HEX or RGBA compatible. Can be used in any pydantic model as a field validator.
+
+        Args:
+            color(tuple|str): The color to be validated. Can be a tuple of RGBA values or a HEX string.
+
+        Returns:
+            tuple|str: The validated color.
+        """
+        CSS_COLOR_NAMES = {
+            "aliceblue",
+            "antiquewhite",
+            "aqua",
+            "aquamarine",
+            "azure",
+            "beige",
+            "bisque",
+            "black",
+            "blanchedalmond",
+            "blue",
+            "blueviolet",
+            "brown",
+            "burlywood",
+            "cadetblue",
+            "chartreuse",
+            "chocolate",
+            "coral",
+            "cornflowerblue",
+            "cornsilk",
+            "crimson",
+            "cyan",
+            "darkblue",
+            "darkcyan",
+            "darkgoldenrod",
+            "darkgray",
+            "darkgreen",
+            "darkgrey",
+            "darkkhaki",
+            "darkmagenta",
+            "darkolivegreen",
+            "darkorange",
+            "darkorchid",
+            "darkred",
+            "darksalmon",
+            "darkseagreen",
+            "darkslateblue",
+            "darkslategray",
+            "darkslategrey",
+            "darkturquoise",
+            "darkviolet",
+            "deeppink",
+            "deepskyblue",
+            "dimgray",
+            "dimgrey",
+            "dodgerblue",
+            "firebrick",
+            "floralwhite",
+            "forestgreen",
+            "fuchsia",
+            "gainsboro",
+            "ghostwhite",
+            "gold",
+            "goldenrod",
+            "gray",
+            "green",
+            "greenyellow",
+            "grey",
+            "honeydew",
+            "hotpink",
+            "indianred",
+            "indigo",
+            "ivory",
+            "khaki",
+            "lavender",
+            "lavenderblush",
+            "lawngreen",
+            "lemonchiffon",
+            "lightblue",
+            "lightcoral",
+            "lightcyan",
+            "lightgoldenrodyellow",
+            "lightgray",
+            "lightgreen",
+            "lightgrey",
+            "lightpink",
+            "lightsalmon",
+            "lightseagreen",
+            "lightskyblue",
+            "lightslategray",
+            "lightslategrey",
+            "lightsteelblue",
+            "lightyellow",
+            "lime",
+            "limegreen",
+            "linen",
+            "magenta",
+            "maroon",
+            "mediumaquamarine",
+            "mediumblue",
+            "mediumorchid",
+            "mediumpurple",
+            "mediumseagreen",
+            "mediumslateblue",
+            "mediumspringgreen",
+            "mediumturquoise",
+            "mediumvioletred",
+            "midnightblue",
+            "mintcream",
+            "mistyrose",
+            "moccasin",
+            "navajowhite",
+            "navy",
+            "oldlace",
+            "olive",
+            "olivedrab",
+            "orange",
+            "orangered",
+            "orchid",
+            "palegoldenrod",
+            "palegreen",
+            "paleturquoise",
+            "palevioletred",
+            "papayawhip",
+            "peachpuff",
+            "peru",
+            "pink",
+            "plum",
+            "powderblue",
+            "purple",
+            "red",
+            "rosybrown",
+            "royalblue",
+            "saddlebrown",
+            "salmon",
+            "sandybrown",
+            "seagreen",
+            "seashell",
+            "sienna",
+            "silver",
+            "skyblue",
+            "slateblue",
+            "slategray",
+            "slategrey",
+            "snow",
+            "springgreen",
+            "steelblue",
+            "tan",
+            "teal",
+            "thistle",
+            "tomato",
+            "turquoise",
+            "violet",
+            "wheat",
+            "white",
+            "whitesmoke",
+            "yellow",
+            "yellowgreen",
+        }
+        if isinstance(color, str):
+            hex_pattern = re.compile(r"^#(?:[0-9a-fA-F]{3}){1,2}$")
+            if hex_pattern.match(color):
+                return color
+            elif color.lower() in CSS_COLOR_NAMES:
+                return color
+            else:
+                raise PydanticCustomError(
+                    "unsupported color",
+                    "The color must be a valid HEX string or CSS Color.",
+                    {"wrong_value": color},
+                )
+        elif isinstance(color, tuple):
+            if len(color) != 4:
+                raise PydanticCustomError(
+                    "unsupported color",
+                    "The color must be a tuple of 4 elements (R, G, B, A).",
+                    {"wrong_value": color},
+                )
+            for value in color:
+                if not 0 <= value <= 255:
+                    raise PydanticCustomError(
+                        "unsupported color",
+                        f"The color values must be between 0 and 255 in RGBA format (R,G,B,A)",
+                        {"wrong_value": color},
+                    )
+            return color
+
+    @staticmethod
+    def validate_color_map(color_map: str) -> str:
+        """
+        Validate the colormap input if it is supported by pyqtgraph. Can be used in any pydantic model as a field validator. If validation fails it prints all available colormaps from pyqtgraph instance.
+
+        Args:
+            color_map(str): The colormap to be validated.
+
+        Returns:
+            str: The validated colormap.
+        """
+        available_colormaps = pg.colormap.listMaps()
+        if color_map not in available_colormaps:
+            raise PydanticCustomError(
+                "unsupported colormap",
+                f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose on the following: {available_colormaps}.",
+                {"wrong_value": color_map},
+            )
+        return color_map
--- a/bec_widgets/widgets/init.py
+++ b/bec_widgets/widgets/init.py
@@ -1,3 +1,4 @@
+from .buttons import StopButton
 from .dock import BECDock, BECDockArea
 from .figure import BECFigure, FigureConfig
 from .scan_control import ScanControl
--- a/bec_widgets/widgets/buttons/init.py
+++ b/bec_widgets/widgets/buttons/init.py
@@ -0,0 +1 @@
+from .stop_button.stop_button import StopButton
--- a/bec_widgets/widgets/buttons/stop_button/init.py
+++ b/bec_widgets/widgets/buttons/stop_button/init.py
--- a/bec_widgets/widgets/buttons/stop_button/stop_button.py
+++ b/bec_widgets/widgets/buttons/stop_button/stop_button.py
@@ -0,0 +1,32 @@
+from qtpy.QtWidgets import QPushButton
+
+from bec_widgets.utils import BECConnector
+
+
+class StopButton(BECConnector, QPushButton):
+    """A button that stops the current scan."""
+
+    def __init__(self, parent=None, client=None, config=None, gui_id=None):
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QPushButton.__init__(self, parent=parent)
+
+        self.get_bec_shortcuts()
+        self.setText("Stop")
+        self.setStyleSheet("background-color:  #cc181e; color: white")
+        self.clicked.connect(self.stop_scan)
+
+    def stop_scan(self):
+        """Stop the scan."""
+        self.queue.request_scan_abortion()
+        self.queue.request_queue_reset()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = StopButton()
+    widget.show()
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/dock/dock.py
+++ b/bec_widgets/widgets/dock/dock.py
@@ -63,8 +63,6 @@ class BECDock(BECConnector, Dock):
        super().__init__(client=client, config=config, gui_id=gui_id)
        Dock.__init__(self, name=name, **kwargs)

-        self.parent_dock_area = parent_dock_area
-
        # Layout Manager
        self.layout_manager = GridLayoutManager(self.layout)

@@ -73,8 +71,8 @@ class BECDock(BECConnector, Dock):
        old_area = source.area
        self.setOrientation("horizontal", force=True)
        super().dropEvent(event)
-        if old_area in self.parent_dock_area.tempAreas and old_area != self.parent_dock_area:
-            self.parent_dock_area.removeTempArea(old_area)
+        if old_area in self.orig_area.tempAreas and old_area != self.orig_area:
+            self.orig_area.removeTempArea(old_area)

    def float(self):
        """
@@ -129,7 +127,7 @@ class BECDock(BECConnector, Dock):
        Args:
            title(str): The title of the dock.
        """
-        self.parent_dock_area.docks[title] = self.parent_dock_area.docks.pop(self.name())
+        self.orig_area.docks[title] = self.orig_area.docks.pop(self.name())
        self.setTitle(title)
        self._name = title

@@ -153,38 +151,6 @@ class BECDock(BECConnector, Dock):
        """
        return list(RPCWidgetHandler.widget_classes.keys())

-    # def add_widget_bec(
-    #     self,
-    #     widget_type: str,
-    #     row=None,
-    #     col=0,
-    #     rowspan=1,
-    #     colspan=1,
-    #     shift: Literal["down", "up", "left", "right"] = "down",
-    # ):
-    #     """
-    #     Add a widget to the dock.
-    #
-    #     Args:
-    #         widget_type(str): The widget to add. Only BEC RPC widgets from RPCWidgetHandler are allowed.
-    #         row(int): The row to add the widget to. If None, the widget will be added to the next available row.
-    #         col(int): The column to add the widget to.
-    #         rowspan(int): The number of rows the widget should span.
-    #         colspan(int): The number of columns the widget should span.
-    #         shift(Literal["down", "up", "left", "right"]): The direction to shift the widgets if the position is occupied.
-    #     """
-    #     if row is None:
-    #         row = self.layout.rowCount()
-    #
-    #     if self.layout_manager.is_position_occupied(row, col):
-    #         self.layout_manager.shift_widgets(shift, start_row=row)
-    #
-    #     widget = RPCWidgetHandler.create_widget(widget_type)
-    #     self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
-    #     self.config.widgets[widget.gui_id] = widget.config
-    #
-    #     return widget
-
    def add_widget(
        self,
        widget: BECConnector | str,
@@ -238,7 +204,7 @@ class BECDock(BECConnector, Dock):
        """
        Attach the dock to the parent dock area.
        """
-        self.parent_dock_area.removeTempArea(self.area)
+        self.orig_area.removeTempArea(self.area)

    def detach(self):
        """
@@ -263,7 +229,7 @@ class BECDock(BECConnector, Dock):
        Remove the dock from the parent dock area.
        """
        # self.cleanup()
-        self.parent_dock_area.remove_dock(self.name())
+        self.orig_area.remove_dock(self.name())

    def cleanup(self):
        """
--- a/bec_widgets/widgets/dock/dock_area.py
+++ b/bec_widgets/widgets/dock/dock_area.py
@@ -137,6 +137,7 @@ class BECDockArea(BECConnector, DockArea):
        position: Literal["bottom", "top", "left", "right", "above", "below"] = None,
        relative_to: BECDock | None = None,
        closable: bool = False,
+        floating: bool = False,
        prefix: str = "dock",
        widget: str | QWidget | None = None,
        row: int = None,
@@ -152,6 +153,7 @@ class BECDockArea(BECConnector, DockArea):
            position(Literal["bottom", "top", "left", "right", "above", "below"]): The position of the dock.
            relative_to(BECDock): The dock to which the new dock should be added relative to.
            closable(bool): Whether the dock is closable.
+            floating(bool): Whether the dock is detached after creating.
            prefix(str): The prefix for the dock name if no name is provided.
            widget(str|QWidget|None): The widget to be added to the dock. While using RPC, only BEC RPC widgets from RPCWidgetHandler are allowed.
            row(int): The row of the added widget.
@@ -192,6 +194,8 @@ class BECDockArea(BECConnector, DockArea):
        if self._instructions_visible:
            self._instructions_visible = False
            self.update()
+        if floating:
+            dock.detach()
        return dock

    def detach_dock(self, dock_name: str) -> BECDock:
--- a/bec_widgets/widgets/figure/figure.py
+++ b/bec_widgets/widgets/figure/figure.py
@@ -184,8 +184,9 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        """
        self._widgets = value

-    def add_plot(
+    def _init_waveform(
        self,
+        waveform,
        x_name: str = None,
        y_name: str = None,
        z_name: str = None,
@@ -198,33 +199,45 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        color_map_z: Optional[str] = "plasma",
        label: Optional[str] = None,
        validate: bool = True,
-        row: int = None,
-        col: int = None,
-        config=None,
-        **axis_kwargs,
-    ) -> BECWaveform:
+    ):
        """
-        Add a Waveform1D plot to the figure at the specified position.
+        Configure the waveform based on the provided parameters.

        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.
+            waveform (BECWaveform): The waveform to configure.
+            x (list | np.ndarray): Custom x data to plot.
+            y (list | np.ndarray): Custom y data to plot.
+            x_name (str): The name of the device for the x-axis.
+            y_name (str): The name of the device for the y-axis.
+            z_name (str): The name of the device for the z-axis.
+            x_entry (str): The name of the entry for the x-axis.
+            y_entry (str): The name of the entry for the y-axis.
+            z_entry (str): The name of the entry for the z-axis.
+            color (str): The color of the curve.
+            color_map_z (str): The color map to use for the z-axis.
+            label (str): The label of the curve.
+            validate (bool): If True, validate the device names and entries.
        """
-        widget_id = str(uuid.uuid4())
-        waveform = self.add_widget(
-            widget_type="Waveform1D",
-            widget_id=widget_id,
-            row=row,
-            col=col,
-            config=config,
-            **axis_kwargs,
-        )
-
-        # TODO remove repetition from .plot method
-
+        if x is not None and y is None:
+            if isinstance(x, np.ndarray):
+                if x.ndim == 1:
+                    y = np.arange(x.size)
+                    waveform.add_curve_custom(x=np.arange(x.size), y=x, color=color, label=label)
+                    return waveform
+                if x.ndim == 2:
+                    waveform.add_curve_custom(x=x[:, 0], y=x[:, 1], color=color, label=label)
+                    return waveform
+            elif isinstance(x, list):
+                y = np.arange(len(x))
+                waveform.add_curve_custom(x=np.arange(len(x)), y=x, color=color, label=label)
+                return waveform
+            else:
+                raise ValueError(
+                    "Invalid input. Provide either device names (x_name, y_name) or custom data."
+                )
+        if x is not None and y is not None:
+            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
+            return waveform
        # User wants to add scan curve -> 1D Waveform
        if x_name is not None and y_name is not None and z_name is None and x is None and y is None:
            waveform.add_curve_scan(
@@ -262,6 +275,73 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):

        return waveform

+    def add_plot(
+        self,
+        x: list | np.ndarray = None,
+        y: list | np.ndarray = None,
+        x_name: str = None,
+        y_name: str = None,
+        z_name: str = None,
+        x_entry: str = None,
+        y_entry: str = None,
+        z_entry: str = None,
+        color: Optional[str] = None,
+        color_map_z: Optional[str] = "plasma",
+        label: Optional[str] = None,
+        validate: bool = True,
+        row: int = None,
+        col: int = None,
+        config=None,
+        **axis_kwargs,
+    ) -> BECWaveform:
+        """
+        Add a Waveform1D plot to the figure at the specified position.
+
+        Args:
+            x(list | np.ndarray): Custom x data to plot.
+            y(list | np.ndarray): Custom y data to plot.
+            x_name(str): The name of the device for the x-axis.
+            y_name(str): The name of the device for the y-axis.
+            z_name(str): The name of the device for the z-axis.
+            x_entry(str): The name of the entry for the x-axis.
+            y_entry(str): The name of the entry for the y-axis.
+            z_entry(str): The name of the entry for the z-axis.
+            color(str): The color of the curve.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str): The label of the curve.
+            validate(bool): If True, validate the device names and entries.
+            row(int): The row coordinate of the widget in the figure. If not provided, the next empty row will be used.
+            col(int): The column coordinate of the widget in the figure. If not provided, the next empty column will be used.
+            config(dict): Additional configuration for the widget.
+            **axis_kwargs(dict): Additional axis properties to set on the widget after creation.
+        """
+        widget_id = str(uuid.uuid4())
+        waveform = self.add_widget(
+            widget_type="Waveform1D",
+            widget_id=widget_id,
+            row=row,
+            col=col,
+            config=config,
+            **axis_kwargs,
+        )
+
+        waveform = self._init_waveform(
+            waveform=waveform,
+            x=x,
+            y=y,
+            x_name=x_name,
+            y_name=y_name,
+            z_name=z_name,
+            x_entry=x_entry,
+            y_entry=y_entry,
+            z_entry=z_entry,
+            color=color,
+            color_map_z=color_map_z,
+            label=label,
+            validate=validate,
+        )
+        return waveform
+
    @typechecked
    def plot(
        self,
@@ -309,70 +389,61 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        else:
            waveform = self.add_plot(**axis_kwargs)

-        if x is not None and y is None:
-            if isinstance(x, np.ndarray):
-                if x.ndim == 1:
-                    y = np.arange(x.size)
-                    waveform.add_curve_custom(x=np.arange(x.size), y=x, color=color, label=label)
-                    return waveform
-                if x.ndim == 2:
-                    waveform.add_curve_custom(x=x[:, 0], y=x[:, 1], color=color, label=label)
-                    return waveform
-            elif isinstance(x, list):
-                y = np.arange(len(x))
-                waveform.add_curve_custom(x=np.arange(len(x)), y=x, color=color, label=label)
-                return waveform
-            else:
-                raise ValueError(
-                    "Invalid input. Provide either device names (x_name, y_name) or custom data."
-                )
-        if x is not None and y is not None:
-            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
-            return waveform
-
-        # User wants to add scan curve -> 1D Waveform
-        if x_name is not None and y_name is not None and z_name is None and x is None and y is None:
-            waveform.add_curve_scan(
-                x_name=x_name,
-                y_name=y_name,
-                x_entry=x_entry,
-                y_entry=y_entry,
-                color=color,
-                color_map_z="plasma",
-                label=label,
-                validate=validate,
-            )
-        # User wants to add scan curve -> 2D Waveform Scatter
-        elif (
-            x_name is not None
-            and y_name is not None
-            and z_name is not None
-            and x is None
-            and y is None
-        ):
-            waveform.add_curve_scan(
-                x_name=x_name,
-                y_name=y_name,
-                z_name=z_name,
-                x_entry=x_entry,
-                y_entry=y_entry,
-                z_entry=z_entry,
-                color=color,
-                color_map_z=color_map_z,
-                label=label,
-                validate=validate,
-            )
-        # User wants to add custom curve
-        elif (
-            x is not None and y is not None and x_name is None and y_name is None and z_name is None
-        ):
-            waveform.add_curve_custom(x=x, y=y, color=color, label=label)
-        else:
-            raise ValueError(
-                "Invalid input. Provide either device names (x_name, y_name) or custom data."
-            )
+        waveform = self._init_waveform(
+            waveform=waveform,
+            x=x,
+            y=y,
+            x_name=x_name,
+            y_name=y_name,
+            z_name=z_name,
+            x_entry=x_entry,
+            y_entry=y_entry,
+            z_entry=z_entry,
+            color=color,
+            color_map_z=color_map_z,
+            label=label,
+            validate=validate,
+        )
+        # TODO remove repetition from .plot method
        return waveform

+    def _init_image(
+        self,
+        image,
+        monitor: str = None,
+        color_bar: Literal["simple", "full"] = "full",
+        color_map: str = "magma",
+        data: np.ndarray = None,
+        vrange: tuple[float, float] = None,
+    ) -> BECImageShow:
+        """
+        Configure the image based on the provided parameters.
+
+        Args:
+            image (BECImageShow): The image to configure.
+            monitor (str): The name of the monitor to display.
+            color_bar (Literal["simple","full"]): The type of color bar to display.
+            color_map (str): The color map to use for the image.
+            data (np.ndarray): Custom data to display.
+        """
+        if monitor is not None and data is None:
+            image.add_monitor_image(
+                monitor=monitor, color_map=color_map, vrange=vrange, color_bar=color_bar
+            )
+        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 image(
        self,
        monitor: str = None,
@@ -405,23 +476,14 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
        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.")
+        image = self._init_image(
+            image=image,
+            monitor=monitor,
+            color_bar=color_bar,
+            color_map=color_map,
+            data=data,
+            vrange=vrange,
+        )
        return image

    def add_image(
@@ -472,22 +534,14 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
            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)
-
+        image = self._init_image(
+            image=image,
+            monitor=monitor,
+            color_bar=color_bar,
+            color_map=color_map,
+            data=data,
+            vrange=vrange,
+        )
        return image

    def motor_map(self, motor_x: str = None, motor_y: str = None, **axis_kwargs) -> BECMotorMap:
--- a/bec_widgets/widgets/figure/plots/image/image.py
+++ b/bec_widgets/widgets/figure/plots/image/image.py
@@ -53,7 +53,6 @@ class BECImageShow(BECPlotBase):
        "set_y_lim",
        "set_grid",
        "lock_aspect_ratio",
-        "plot",
        "remove",
        "images",
    ]
--- a/bec_widgets/widgets/figure/plots/image/image_processor.py
+++ b/bec_widgets/widgets/figure/plots/image/image_processor.py
@@ -19,6 +19,7 @@ class ProcessingConfig(BaseModel):
    rotation: Optional[int] = Field(
        None, description="The rotation angle of the monitor data before displaying."
    )
+    model_config: dict = {"validate_assignment": True}


 class ImageProcessor:
--- a/bec_widgets/widgets/figure/plots/plot_base.py
+++ b/bec_widgets/widgets/figure/plots/plot_base.py
@@ -20,6 +20,7 @@ class AxisConfig(BaseModel):
    y_lim: Optional[tuple] = Field(None, description="The limits of the y-axis.")
    x_grid: bool = Field(False, description="Show grid on the x-axis.")
    y_grid: bool = Field(False, description="Show grid on the y-axis.")
+    model_config: dict = {"validate_assignment": True}


 class SubplotConfig(ConnectionConfig):
@@ -48,7 +49,6 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
        "set_y_lim",
        "set_grid",
        "lock_aspect_ratio",
-        "plot",
        "remove",
    ]

@@ -237,19 +237,6 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
        """
        self.plot_item.setAspectLocked(lock)

-    def plot(self, data_x: list | np.ndarray, data_y: list | np.ndarray, **kwargs):
-        """
-        Plot custom data on the plot widget. These data are not saved in config.
-
-        Args:
-            data_x(list|np.ndarray): x-axis data
-            data_y(list|np.ndarray): y-axis data
-            **kwargs: Keyword arguments for the plot.
-        """
-        # TODO very basic so far, add more options
-        # TODO decide name of the method
-        self.plot_item.plot(data_x, data_y, **kwargs)
-
    def remove(self):
        """Remove the plot widget from the figure."""
        if self.figure is not None:
--- a/bec_widgets/widgets/figure/plots/waveform/waveform.py
+++ b/bec_widgets/widgets/figure/plots/waveform/waveform.py
@@ -35,8 +35,7 @@ class BECWaveform(BECPlotBase):
    USER_ACCESS = [
        "rpc_id",
        "config_dict",
-        "add_curve_scan",
-        "add_curve_custom",
+        "plot",
        "remove_curve",
        "scan_history",
        "curves",
@@ -54,7 +53,6 @@ class BECWaveform(BECPlotBase):
        "set_y_lim",
        "set_grid",
        "lock_aspect_ratio",
-        "plot",
        "remove",
    ]
    scan_signal_update = pyqtSignal()
@@ -200,6 +198,57 @@ class BECWaveform(BECPlotBase):
        else:
            raise ValueError("Identifier must be either an integer (index) or a string (curve_id).")

+    def plot(
+        self,
+        x: list | np.ndarray | None = None,
+        y: list | np.ndarray | None = None,
+        x_name: str | None = None,
+        y_name: str | None = None,
+        z_name: str | None = None,
+        x_entry: str | None = None,
+        y_entry: str | None = None,
+        z_entry: str | None = None,
+        color: str | None = None,
+        color_map_z: str | None = "plasma",
+        label: str | None = None,
+        validate: bool = True,
+    ) -> BECCurve:
+        """
+        Plot a curve to the plot widget.
+        Args:
+            x(list | np.ndarray): Custom x data to plot.
+            y(list | np.ndarray): Custom y data to plot.
+            x_name(str): The name of the device for the x-axis.
+            y_name(str): The name of the device for the y-axis.
+            z_name(str): The name of the device for the z-axis.
+            x_entry(str): The name of the entry for the x-axis.
+            y_entry(str): The name of the entry for the y-axis.
+            z_entry(str): The name of the entry for the z-axis.
+            color(str): The color of the curve.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str): The label of the curve.
+            validate(bool): If True, validate the device names and entries.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+
+        if x is not None and y is not None:
+            return self.add_curve_custom(x=x, y=y, label=label, color=color)
+        else:
+            return self.add_curve_scan(
+                x_name=x_name,
+                y_name=y_name,
+                z_name=z_name,
+                x_entry=x_entry,
+                y_entry=y_entry,
+                z_entry=z_entry,
+                color=color,
+                color_map_z=color_map_z,
+                label=label,
+                validate_bec=validate,
+            )
+
    def add_curve_custom(
        self,
        x: list | np.ndarray,
@@ -252,33 +301,6 @@ class BECWaveform(BECPlotBase):
        )
        return curve

-    def _add_curve_object(
-        self,
-        name: str,
-        source: str,
-        config: CurveConfig,
-        data: tuple[list | np.ndarray, list | np.ndarray] = None,
-    ) -> BECCurve:
-        """
-        Add a curve object to the plot widget.
-
-        Args:
-            name(str): ID of the curve.
-            source(str): Source of the curve.
-            config(CurveConfig): Configuration of the curve.
-            data(tuple[list|np.ndarray,list|np.ndarray], optional): Data (x,y) to be plotted. Defaults to None.
-
-        Returns:
-            BECCurve: The curve object.
-        """
-        curve = BECCurve(config=config, name=name, parent_item=self.plot_item)
-        self._curves_data[source][name] = curve
-        self.plot_item.addItem(curve)
-        self.config.curves[name] = curve.config
-        if data is not None:
-            curve.setData(data[0], data[1])
-        return curve
-
    def add_curve_scan(
        self,
        x_name: str,
@@ -341,7 +363,7 @@ class BECWaveform(BECPlotBase):
            parent_id=self.gui_id,
            label=label,
            color=color,
-            color_map=color_map_z,
+            color_map_z=color_map_z,
            source=curve_source,
            signals=Signal(
                source=curve_source,
@@ -354,6 +376,33 @@ class BECWaveform(BECPlotBase):
        curve = self._add_curve_object(name=label, source=curve_source, config=curve_config)
        return curve

+    def _add_curve_object(
+        self,
+        name: str,
+        source: str,
+        config: CurveConfig,
+        data: tuple[list | np.ndarray, list | np.ndarray] = None,
+    ) -> BECCurve:
+        """
+        Add a curve object to the plot widget.
+
+        Args:
+            name(str): ID of the curve.
+            source(str): Source of the curve.
+            config(CurveConfig): Configuration of the curve.
+            data(tuple[list|np.ndarray,list|np.ndarray], optional): Data (x,y) to be plotted. Defaults to None.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+        curve = BECCurve(config=config, name=name, parent_item=self)
+        self._curves_data[source][name] = curve
+        self.plot_item.addItem(curve)
+        self.config.curves[name] = curve.config
+        if data is not None:
+            curve.setData(data[0], data[1])
+        return curve
+
    def _validate_signal_entries(
        self,
        x_name: str,
@@ -514,7 +563,7 @@ class BECWaveform(BECPlotBase):
                if curve.config.signals.z:
                    data_z = data[z_name][z_entry].val
                    color_z = self._make_z_gradient(
-                        data_z, curve.config.colormap
+                        data_z, curve.config.color_map_z
                    )  # TODO decide how to implement custom gradient
            except TypeError:
                continue
--- a/bec_widgets/widgets/figure/plots/waveform/waveform_curve.py
+++ b/bec_widgets/widgets/figure/plots/waveform/waveform_curve.py
@@ -1,12 +1,16 @@
 from __future__ import annotations

-from typing import Any, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal, Optional

 import pyqtgraph as pg
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
+from pydantic_core import PydanticCustomError
 from qtpy import QtCore

-from bec_widgets.utils import BECConnector, ConnectionConfig
+from bec_widgets.utils import BECConnector, Colors, ConnectionConfig
+
+if TYPE_CHECKING:
+    from bec_widgets.widgets.figure.plots.waveform import BECWaveform1D


 class SignalData(BaseModel):
@@ -17,6 +21,7 @@ class SignalData(BaseModel):
    unit: Optional[str] = None  # todo implement later
    modifier: Optional[str] = None  # todo implement later
    limits: Optional[list[float]] = None  # todo implement later
+    model_config: dict = {"validate_assignment": True}


 class Signal(BaseModel):
@@ -26,14 +31,17 @@ class Signal(BaseModel):
    x: SignalData  # TODO maybe add metadata for config gui later
    y: SignalData
    z: Optional[SignalData] = None
+    model_config: dict = {"validate_assignment": True}


 class CurveConfig(ConnectionConfig):
    parent_id: Optional[str] = Field(None, description="The parent plot of the curve.")
    label: Optional[str] = Field(None, description="The label of the curve.")
-    color: Optional[Any] = Field(None, description="The color of the curve.")
+    color: Optional[str | tuple] = 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_color: Optional[str | tuple] = 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(
@@ -41,7 +49,15 @@ class CurveConfig(ConnectionConfig):
    )
    source: Optional[str] = Field(None, description="The source of the curve.")
    signals: Optional[Signal] = Field(None, description="The signal of the curve.")
-    colormap: Optional[str] = Field("plasma", description="The colormap of the curves z gradient.")
+    color_map_z: Optional[str] = Field(
+        "plasma", description="The colormap of the curves z gradient.", validate_default=True
+    )
+
+    model_config: dict = {"validate_assignment": True}
+
+    _validate_color_map_z = field_validator("color_map_z")(Colors.validate_color_map)
+    _validate_color = field_validator("color")(Colors.validate_color)
+    _validate_symbol_color = field_validator("symbol_color")(Colors.validate_color)


 class BECCurve(BECConnector, pg.PlotDataItem):
@@ -52,7 +68,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
        "set",
        "set_data",
        "set_color",
-        "set_colormap",
+        "set_color_map_z",
        "set_symbol",
        "set_symbol_color",
        "set_symbol_size",
@@ -66,7 +82,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
        name: Optional[str] = None,
        config: Optional[CurveConfig] = None,
        gui_id: Optional[str] = None,
-        parent_item: Optional[pg.PlotItem] = None,
+        parent_item: Optional[BECWaveform1D] = None,
        **kwargs,
    ):
        if config is None:
@@ -128,7 +144,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
        # Mapping of keywords to setter methods
        method_map = {
            "color": self.set_color,
-            "colormap": self.set_colormap,
+            "color_map_z": self.set_color_map_z,
            "symbol": self.set_symbol,
            "symbol_color": self.set_symbol_color,
            "symbol_size": self.set_symbol_size,
@@ -203,14 +219,16 @@ class BECCurve(BECConnector, pg.PlotDataItem):
        self.config.pen_style = pen_style
        self.apply_config()

-    def set_colormap(self, colormap: str):
+    def set_color_map_z(self, colormap: str):
        """
        Set the colormap for the scatter plot z gradient.

        Args:
            colormap(str): Colormap for the scatter plot.
        """
-        self.config.colormap = colormap
+        self.config.color_map_z = colormap
+        self.apply_config()
+        self.parent_item.scan_history(-1)

    def get_data(self) -> tuple[np.ndarray, np.ndarray]:
        """
--- a/bec_widgets/widgets/spiral_progress_bar/ring.py
+++ b/bec_widgets/widgets/spiral_progress_bar/ring.py
@@ -13,6 +13,7 @@ from bec_widgets.utils import BECConnector, ConnectionConfig
 class RingConnections(BaseModel):
    slot: Literal["on_scan_progress", "on_device_readback"] = None
    endpoint: EndpointInfo | str = None
+    model_config: dict = {"validate_assignment": True}

    @field_validator("endpoint")
    def validate_endpoint(cls, v, values):
@@ -114,32 +115,75 @@ class Ring(BECConnector):
            self.set_connections(self.config.connections.slot, self.config.connections.endpoint)

    def set_value(self, value: int | float):
+        """
+        Set the value for the ring widget
+
+        Args:
+            value(int | float): Value for the ring widget
+        """
        self.config.value = round(
            float(max(self.config.min_value, min(self.config.max_value, value))),
            self.config.precision,
        )

    def set_color(self, color: str | tuple):
+        """
+        Set the color for the ring widget
+
+        Args:
+            color(str | tuple): Color for the ring widget. Can be HEX code or tuple (R, G, B, A).
+        """
        self.config.color = color
        self.color = self.convert_color(color)

    def set_background(self, color: str | tuple):
+        """
+        Set the background color for the ring widget
+
+        Args:
+            color(str | tuple): Background color for the ring widget. Can be HEX code or tuple (R, G, B, A).
+        """
        self.config.background_color = color
        self.color = self.convert_color(color)

    def set_line_width(self, width: int):
+        """
+        Set the line width for the ring widget
+
+        Args:
+            width(int): Line width for the ring widget
+        """
        self.config.line_width = width

    def set_min_max_values(self, min_value: int | float, max_value: int | float):
+        """
+        Set the min and max values for the ring widget.
+
+        Args:
+            min_value(int | float): Minimum value for the ring widget
+            max_value(int | float): Maximum value for the ring widget
+        """
        self.config.min_value = min_value
        self.config.max_value = max_value

    def set_start_angle(self, start_angle: int):
+        """
+        Set the start angle for the ring widget
+
+        Args:
+            start_angle(int): Start angle for the ring widget in degrees
+        """
        self.config.start_position = start_angle
        self.start_position = start_angle * 16

    @staticmethod
    def convert_color(color):
+        """
+        Convert the color to QColor
+
+        Args:
+            color(str | tuple): Color for the ring widget. Can be HEX code or tuple (R, G, B, A).
+        """
        converted_color = None
        if isinstance(color, str):
            converted_color = QtGui.QColor(color)
@@ -149,7 +193,11 @@ class Ring(BECConnector):

    def set_update(self, mode: Literal["manual", "scan", "device"], device: str = None):
        """
-        Set the update mode for the ring widget
+        Set the update mode for the ring widget.
+        Modes:
+        - "manual": Manual update mode, the value is set by the user.
+        - "scan": Update mode for the scan progress. The value is updated by the current scan progress.
+        - "device": Update mode for the device readback. The value is updated by the device readback. Take into account that user has to set the device name and limits.

        Args:
            mode(str): Update mode for the ring widget. Can be "manual", "scan" or "device"
@@ -169,6 +217,13 @@ class Ring(BECConnector):
        self.parent_progress_widget.enable_auto_updates(False)

    def set_connections(self, slot: str, endpoint: str | EndpointInfo):
+        """
+        Set the connections for the ring widget
+
+        Args:
+            slot(str): Slot for the ring widget update. Can be "on_scan_progress" or "on_device_readback".
+            endpoint(str | EndpointInfo): Endpoint for the ring widget update. Endpoint has to match the slot type.
+        """
        if self.config.connections.endpoint == endpoint and self.config.connections.slot == slot:
            return
        else:
@@ -179,12 +234,22 @@ class Ring(BECConnector):
            self.bec_dispatcher.connect_slot(getattr(self, slot), endpoint)

    def reset_connection(self):
+        """
+        Reset the connections for the ring widget. Disconnect the current slot and endpoint.
+        """
        self.bec_dispatcher.disconnect_slot(
            self.config.connections.slot, self.config.connections.endpoint
        )
        self.config.connections = RingConnections()

    def on_scan_progress(self, msg, meta):
+        """
+        Update the ring widget with the scan progress.
+
+        Args:
+            msg(dict): Message with the scan progress
+            meta(dict): Metadata for the message
+        """
        current_RID = meta.get("RID", None)
        if current_RID != self.RID:
            self.set_min_max_values(0, msg.get("max_value", 100))
@@ -192,6 +257,13 @@ class Ring(BECConnector):
        self.parent_progress_widget.update()

    def on_device_readback(self, msg, meta):
+        """
+        Update the ring widget with the device readback.
+
+        Args:
+            msg(dict): Message with the device readback
+            meta(dict): Metadata for the message
+        """
        if isinstance(self.config.connections.endpoint, EndpointInfo):
            endpoint = self.config.connections.endpoint.endpoint
        else:
--- a/bec_widgets/widgets/spiral_progress_bar/spiral_progress_bar.py
+++ b/bec_widgets/widgets/spiral_progress_bar/spiral_progress_bar.py
@@ -15,7 +15,9 @@ from bec_widgets.widgets.spiral_progress_bar.ring import Ring, RingConfig


 class SpiralProgressBarConfig(ConnectionConfig):
-    color_map: str | None = Field("magma", description="Color scheme for the progress bars.")
+    color_map: Optional[str] = Field(
+        "magma", description="Color scheme for the progress bars.", validate_default=True
+    )
    min_number_of_bars: int | None = Field(
        1, description="Minimum number of progress bars to display."
    )
@@ -59,16 +61,7 @@ class SpiralProgressBarConfig(ConnectionConfig):
                )
        return v

-    @field_validator("color_map")
-    def validate_color_map(cls, v, values):
-        if v is not None and v != "":
-            if v not in pg.colormap.listMaps():
-                raise PydanticCustomError(
-                    "unsupported colormap",
-                    f"Colormap '{v}' not found in the current installation of pyqtgraph",
-                    {"wrong_value": v},
-                )
-        return v
+    _validate_colormap = field_validator("color_map")(Colors.validate_color_map)


 class SpiralProgressBar(BECConnector, QWidget):
@@ -368,7 +361,6 @@ class SpiralProgressBar(BECConnector, QWidget):
            colors = self._adjust_list_to_bars(colors)
            for ring, color in zip(self._rings, colors):
                ring.set_color(color)
-            self.config.color_map = None
        self.update()

    def set_line_widths(self, widths: int | list[int], bar_index: int = None):
@@ -464,6 +456,13 @@ class SpiralProgressBar(BECConnector, QWidget):

    @Slot(dict, dict)
    def on_scan_queue_status(self, msg, meta):
+        """
+        Slot to handle scan queue status messages. Decides what update to perform based on the scan queue status.
+
+        Args:
+            msg(dict): Message from the BEC.
+            meta(dict): Metadata from the BEC.
+        """
        primary_queue = msg.get("queue").get("primary")
        info = primary_queue.get("info", None)

@@ -490,6 +489,12 @@ class SpiralProgressBar(BECConnector, QWidget):
                    #     print("hook device_progress")

    def _hook_scan_progress(self, ring_index: int = None):
+        """
+        Hook the scan progress to the progress bars.
+
+        Args:
+            ring_index(int): Index of the progress bar to hook the scan progress to.
+        """
        if ring_index is not None:
            ring = self._find_ring_by_index(ring_index)
        else:
@@ -501,6 +506,15 @@ class SpiralProgressBar(BECConnector, QWidget):
            ring.set_connections("on_scan_progress", MessageEndpoints.scan_progress())

    def _hook_readback(self, bar_index: int, device: str, min: float | int, max: float | int):
+        """
+        Hook the readback values to the progress bars.
+
+        Args:
+            bar_index(int): Index of the progress bar to hook the readback values to.
+            device(str): Device to readback values from.
+            min(float|int): Minimum value for the progress bar.
+            max(float|int): Maximum value for the progress bar.
+        """
        ring = self._find_ring_by_index(bar_index)
        ring.set_min_max_values(min, max)
        endpoint = MessageEndpoints.device_readback(device)
--- a/bec_widgets/widgets/text_box/init.py
+++ b/bec_widgets/widgets/text_box/init.py
--- a/bec_widgets/widgets/text_box/text_box.py
+++ b/bec_widgets/widgets/text_box/text_box.py
@@ -0,0 +1,127 @@
+import re
+
+from pydantic import Field, field_validator
+from qtpy.QtWidgets import QTextEdit
+
+from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
+from bec_widgets.utils.colors import Colors
+
+
+class TextBoxConfig(ConnectionConfig):
+
+    theme: str = Field("dark", description="The theme of the figure widget.")
+    font_color: str = Field("#FFF", description="The font color of the text")
+    background_color: str = Field("#000", description="The background color of the widget.")
+    font_size: int = Field(16, description="The font size of the text in the widget.")
+    text: str = Field("", description="The text to display in the widget.")
+
+    @classmethod
+    @field_validator("theme")
+    def validate_theme(cls, v):
+        """Validate the theme of the figure widget."""
+        if v not in ["dark", "light"]:
+            raise ValueError("Theme must be either 'dark' or 'light'")
+        return v
+
+    _validate_font_color = field_validator("font_color")(Colors.validate_color)
+    _validate_background_color = field_validator("background_color")(Colors.validate_color)
+
+
+class TextBox(BECConnector, QTextEdit):
+
+    USER_ACCESS = ["set_color", "set_text", "set_font_size"]
+
+    def __init__(self, text: str = "", parent=None, client=None, config=None, gui_id=None):
+        if config is None:
+            config = TextBoxConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = TextBoxConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QTextEdit.__init__(self, parent=parent)
+
+        self.config = config
+        self.setReadOnly(True)
+        self.setGeometry(self.rect())
+        self.set_color(self.config.background_color, self.config.font_color)
+        if not text:
+            text = "<h1>Welcome to the BEC Widget TextBox</h1><p>A widget that allows user to display text in plain and HTML format.</p><p>This is an example of displaying HTML text.</p>"
+        self.set_text(text)
+
+    def change_theme(self) -> None:
+        """
+        Change the theme of the figure widget.
+        """
+        if self.config.theme == "dark":
+            theme = "light"
+            font_color = "#000"
+            background_color = "#FFF"
+        else:
+            theme = "dark"
+            font_color = "#FFF"
+            background_color = "#000"
+        self.config.theme = theme
+        self.set_color(background_color, font_color)
+
+    def set_color(self, background_color: str, font_color: str) -> None:
+        """Set the background color of the widget.
+
+        Args:
+            background_color (str): The color to set the background in HEX.
+            font_color (str): The color to set the font in HEX.
+
+        """
+        self.config.background_color = background_color
+        self.config.font_color = font_color
+        self._update_stylesheet()
+
+    def set_font_size(self, size: int) -> None:
+        """Set the font size of the text in the widget.
+
+        Args:
+            size (int): The font size to set.
+        """
+        self.config.font_size = size
+        self._update_stylesheet()
+
+    def _update_stylesheet(self):
+        """Update the stylesheet of the widget."""
+        self.setStyleSheet(
+            f"background-color: {self.config.background_color}; color: {self.config.font_color}; font-size: {self.config.font_size}px"
+        )
+
+    def set_text(self, text: str) -> None:
+        """Set the text of the widget.
+
+        Args:
+            text (str): The text to set.
+        """
+        if self.is_html(text):
+            self.setHtml(text)
+        else:
+            self.setPlainText(text)
+        self.config.text = text
+
+    def is_html(self, text: str) -> bool:
+        """Check if the text contains HTML tags.
+
+        Args:
+            text (str): The text to check.
+
+        Returns:
+            bool: True if the text contains HTML tags, False otherwise.
+        """
+        return bool(re.search(r"<[a-zA-Z/][^>]*>", text))
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+
+    widget = TextBox()
+    widget.show()
+    sys.exit(app.exec())
--- a/bec_widgets/widgets/website/init.py
+++ b/bec_widgets/widgets/website/init.py
--- a/bec_widgets/widgets/website/website.py
+++ b/bec_widgets/widgets/website/website.py
@@ -0,0 +1,65 @@
+from qtpy.QtCore import QUrl
+from qtpy.QtWebEngineWidgets import QWebEngineView
+from qtpy.QtWidgets import QApplication
+
+from bec_widgets.utils import BECConnector
+
+
+class WebsiteWidget(BECConnector, QWebEngineView):
+    """
+    A simple widget to display a website
+    """
+
+    USER_ACCESS = ["set_url", "get_url", "reload", "back", "forward"]
+
+    def __init__(self, url: str = None, parent=None, config=None, client=None, gui_id=None):
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QWebEngineView.__init__(self, parent=parent)
+        self.set_url(url)
+
+    def set_url(self, url: str) -> None:
+        """
+        Set the url of the website widget
+
+        Args:
+            url (str): The url to set
+        """
+        if not url:
+            return
+        self.setUrl(QUrl(url))
+
+    def get_url(self) -> str:
+        """
+        Get the current url of the website widget
+
+        Returns:
+            str: The current url
+        """
+        return self.url().toString()
+
+    def reload(self):
+        """
+        Reload the website
+        """
+        QWebEngineView.reload(self)
+
+    def back(self):
+        """
+        Go back in the history
+        """
+        QWebEngineView.back(self)
+
+    def forward(self):
+        """
+        Go forward in the history
+        """
+        QWebEngineView.forward(self)
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    mainWin = WebsiteWidget("https://scilog.psi.ch")
+    mainWin.show()
+    sys.exit(app.exec())
--- a/docs/developer/developer.md
+++ b/docs/developer/developer.md
@@ -1,18 +1,46 @@
 (developer)=
-# Development
+# Developer 

-To contribute to the development of BEC Widgets, start by setting up the development environment:
+Welcome to the BEC Widgets developer guide! This section is intended for developers who want to contribute to the development of BEC Widgets.

-1. **Clone the Repository**: 
-```bash
-git clone https://gitlab.psi.ch/bec/bec_widgets
-cd bec_widgets
-```
-2. **Install in Editable Mode**:
+```{toctree}
+---
+maxdepth: 2
+hidden: true
+---

-Installing the package in editable mode allows you to make changes to the code and test them in real-time.
-```bash
-pip install -e .[dev,pyqt6]
+getting_started/getting_started.md
+widgets/widgets.md
+api_reference/api_reference.md
 ```


+***
+
+````{grid} 2
+:gutter: 5
+
+```{grid-item-card}
+:link: user.getting_started
+:link-type: ref
+:img-top: /assets/rocket_launch_48dp.svg
+:text-align: center
+
+## Getting Started
+
+Learn how to install BEC Widgets and get started with the framework.
+```
+
+```{grid-item-card}
+:link: user.widgets
+:link-type: ref
+:img-top: /assets/apps_48dp.svg
+:text-align: center
+
+## Widgets
+
+Learn about the building blocks of larger applications: widgets.
+```
+````
+
+
--- a/docs/developer/getting_started/development.md
+++ b/docs/developer/getting_started/development.md
@@ -0,0 +1,27 @@
+(developer.development)=
+# Development
+
+If you like to contribute to the development of BEC Widgets, you can follow the steps below to set up your development environment.
+BEC Widgets works in conjunction with [BEC](https://bec.readthedocs.io/en/latest/). 
+Therefore, we recommend that you install BEC first following the [developer instructions](https://bec.readthedocs.io/en/latest/developer/getting_started/install_developer_env.html) and include BEC Widgets. 
+
+If you already have a BEC environment set up, you can install BEC Widgets in editable mode into your BEC Python environment.
+
+**Prerequisites**
+1. **Python Version:** BEC Widgets requires Python version 3.10 or higher. Verify your Python version to ensure compatibility.
+2. **BEC Installation:** BEC Widgets works in conjunction with BEC. While BEC is a dependency and will be installed automatically, you can find more information about BEC and its installation process in the [BEC documentation](https://beamline-experiment-control.readthedocs.io/en/latest/).
+
+**Clone the Repository**: 
+```bash
+git clone https://gitlab.psi.ch/bec/bec_widgets
+cd bec_widgets
+```
+**Install in Editable Mode**:
+
+Please install the package in editable mode into your BEC Python environemnt. 
+```bash
+pip install -e '.[dev,pyqt6]'
+```
+This installs the package together with [PyQT6](https://www.riverbankcomputing.com/static/Docs/PyQt6/introduction.html). 
+
+
--- a/docs/developer/getting_started/getting_started.md
+++ b/docs/developer/getting_started/getting_started.md
@@ -0,0 +1,12 @@
+(developer.getting_started)=
+# Getting Started
+This section provides valuable information for developers who want to contribute to the development of BEC Widgets. The guide will help you set up the development environment, understand the modular development concept of BEC Widgets, and contribute to the project.
+
+```{toctree}
+---
+maxdepth: 2
+hidden: false
+---
+
+development/
+```
--- a/docs/developer/widgets/how_to_develop_a_widget.md
+++ b/docs/developer/widgets/how_to_develop_a_widget.md
@@ -0,0 +1,353 @@
+(developer.widgets.how_to_develop_a_widget)=
+# How to Develop a Widget
+This section provides a step-by-step guide on how to develop a new widget for BEC Widgets. We will develop a simple widget that allows you to press a button and specify a user-defined action. The general widget will be based on a [QPushButton](https://doc.qt.io/qt-6/qpushbutton.html) which we will extend to be capable of communicating with BEC through the interface provided by BEC Widgets.
+
+## Button to start a scan
+Developing a new widget in BEC Widgets is straightforward. Let's create a widget that allows a user to press a button and execute a `line_scan` in BEC. The proper location to create a new widget is either in the `bec_widgets/widgets` directory, or the beamline plugin widget direction, i.e. `csaxs_bec/bec_widgets`, depending on where your development takes place. 
+
+### Step 1: Create a new widget class
+
+We first create a simple class that inherits from the `QPushButton` class.
+The following code snippet demonstrates how to create a new widget:
+
+``` python
+from qtpy.QtWidgets import QPushButton
+
+class StartScanButton(QPushButton):
+    def __init__(self, parent=None):
+        QPushButton.__init__(self, parent=parent)
+        # Connect the button to the on_click method
+        self.clicked.connect(self.on_click)
+
+    def on_click(self):
+        pass
+```
+So far we have created the button, but we have not yet put any logic to the `on_click` event of the button.
+Adding the functionality to be able to execute a scans will be tackled in the next step.
+
+````{note} 
+To make the button work as a standalone application, you can simply add the following lines at the end.
+``` python
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = StartScanButton()
+    widget.show()
+    sys.exit(app.exec_())
+```
+````
+
+
+### Step 2: Connect with BEC, implement *on_click* functionality
+To be able to start a scan, we need to communicate with BEC. This can be facilitated easily by inheriting additionally from [`BECConnector`](../../api_reference/_autosummary/bec_widgets.utils.bec_connector.BECConnector). 
+With the *BECConnector*, we will also have to pass the *client* ([BECClient](https://bec.readthedocs.io/en/latest/api_reference/_autosummary/bec_lib.client.BECClient.html)) and the *gui_id* (str) to init function of both, our *StartScanButton* widget and the `super().__init__(client=client, gui_id=gui_id)` call.
+In the init of *BECConnector*, the client will be initialised and stored in `self.client`, which gives us access to the available scan objects via `self.client.scans`.
+
+``` python
+from qtpy.QtWidgets import QPushButton
+from bec_widgets.utils import BECConnector
+
+class StartScanButton(BECConnector, QPushButton):
+    def __init__(self, parent=None, client:=None, gui_id=None):
+        super().__init__(client=client, gui_id=gui_id)
+        QPushButton.__init__(self, parent=parent)
+
+        # Set a default scan command, args and kwargs
+        self.scan_name = "line_scan"
+        self.scan_args = (dev.samx, -5, 5)
+        self.scan_kwargs = {"steps": 50, "exp_time": 0.1, "relative": True}
+        # Set the text of the button to display the current scan name
+        self.set_button_text()
+        # Connect the button to the on_click method
+        self.clicked.connect(self.on_click)
+
+    def set_button_text(self):
+        """Set the text of the button"""
+        self.setText(f"Start {self.scan_name}")
+
+    def run_command(self):
+        """Run the scan command."""
+        # Get the scan command from the scans library
+        scan_command = getattr(self.client.scans, self.scan_name)
+        # Run the scan command
+        scan_report = scan_command(*self.scan_args, **self.scan_kwargs)
+        # Wait for the scan to finish
+        scan_report.wait()
+
+    def on_click(self):
+        """Start a line scan"""
+        self.run_command()
+```
+
+```{note}
+For the args and kwargs of the scan command, we are using the same syntax as in the client: `dev.samx` is not a string but the same object as in the client.
+```
+In the *run_command* method, we retrieve the scan object from the client by its name, and execute the method with all *args* and *kwargs* that we have set.
+The current implementation of *run_command* is a blocking call due to `scan_report.wait()`,  which is not ideal for a GUI application since it freezes the GUI. We will adress this in the next step.
+
+### Step 3: Improving the widget interactivity
+To not freeze the GUI, we need to run the scan command in a separate thread. We can either use [QThreads](https://doc.qt.io/qtforpython-6/PySide6/QtCore/QThread.html) or the Python [threading module](https://docs.python.org/3/library/threading.html#thread-objects). In this example, we will use the Python threading module. In addition, we add a method `update_style` to change the style of the button to indicate to the user that the scan is running. We also extend the cleanup procedure of `BECConnector` to ensure that the thread is stopped when the widget is closed. This is good practice to avoid having threads running in the background when the widget is closed. 
+
+``` python
+
+def update_style(self, mode: Literal["ready", "running"]):
+    """Update the style of the button based on the mode.
+
+    Args:
+        mode (Literal["ready", "running"): The mode of the button.
+    """
+    if mode == "ready":
+        self.setStyleSheet(
+            "background-color: #4CAF50; color: white; font-size: 16px; padding: 10px 24px;"
+        )
+    elif mode == "running":
+        self.setStyleSheet(
+            "background-color: #808080; color: white; font-size: 16px; padding: 10px 24px;"
+        )
+
+def run_command(self):
+    """Run the scan command."""
+    # Switch the style of the button
+    self.update_style("running")
+    # Disable the buttom while the scan is running
+    self.setEnabled(False)
+    # Get the scan command from the scans library
+    scan_command = getattr(self.scans, self.scan_name)
+    # Run the scan command
+    scan_report = scan_command(*self.scan_args, **self.scan_kwargs)
+    # Wait for the scan to finish
+    scan_report.wait()
+    # Reactivate the button
+    self.setEnabled(True)
+    # Switch the style of the button back to ready
+    self.update_style("ready")
+
+def on_click(self):
+    """Start a line scan"""
+    thread = threading.Thread(target=self.run_command)
+    thread.start()
+
+def cleanup(self):
+    """Cleanup the widget"""
+    # stop thread
+    # stop the thread or if this is implemented via QThread, ensure stopping of QThread.
+    # Ideally, the BECConnector should take care of this automatically.
+    # Important to call super().cleanup() to ensure that the cleanup of the BECConnector is also called
+    super().cleanup()
+```
+We now added started the scan in a separate thread, which allows the GUI to remain responsive. We also added a method to change the style of the button to indicate to the user that the scan is running. The cleanup method ensures that the thread is stopped when the widget is closed. In a last step, we know like to make the scan command configurable.
+
+### Step 4: Make the scan command configurable
+In order to make the scan comman configurable, we implement a method `set_scan_command` which allows the user to set the scan command, arguments and keyword arguments.
+This method should also become available through the RPC interface of BEC Widgets, so we add the class attribute `USER_ACCESS` which is a list of strings with functions that should become available for the CLI. 
+
+``` python
+    def set_scan_command(
+        self, scan_name: str, args: tuple, kwargs: dict
+    ): 
+        """Set the scan command to run.
+
+        Args:
+            scan_name (str): The name of the scan command.
+            args (tuple): The arguments for the scan command.
+            kwargs (dict): The keyword arguments for the scan command.
+        """
+        # check if scan_command starts with scans.
+        if not getattr(self.client.scans, scan_name):
+            raise ValueError(
+                f"The scan type must be implemented in the scan library of BEC, received {scan_name}"
+            )
+        self.scan_name = scan_name
+        self.scan_args = args
+        self.scan_kwargs = kwargs
+        self.set_button_text()
+```
+
+### Step 5: Generate client interface for RPC 
+We have now prepared the widget which is fully functional as a standalone widget. But we also want to make it available to the BEC command-line-interface (CLI), for which we prepared the **USER_ACCESS** class attribute.
+The communication between the BEC IPythonClient and the widget is done vie the RPC interface of BEC Widgets. 
+For this, we need to run the `bec_widgets.cli.generate_cli` script to generate the CLI interface.
+
+``` bash
+python bec_widgets.cli.generate_cli --core
+# alternatively use the entry point from BEC Widgets
+bw-generate-cli
+```
+
+This will generate a new client with all relevant methods in [`bec_widgets.cli.client.py`](../../api_reference/_autosummary/bec_widgets.bec_widgets.cli.client.rst). 
+The last step is to make the RPCWidgetHandler class aware of the widget, which means to add the name of the widget to the widgets list in the [`RPCWidgetHandler`](../../api_reference/_autosummary/bec_widgets.bec_widgets.cli.rpc_widget_handler.RPCWidgetHandler.rst) class. 
+
+````{dropdown} View code: RPCWidgetHandler class
+:icon: code-square
+:animate: fade-in-slide-down
+
+```{literalinclude} ../../../bec_widgets/cli/rpc_widget_handler.py
+:language: python
+:pyobject: RPCWidgetHandler
+```
+````
+
+With this, we have a fully functional widget that allows the user to start a scan with a button. The scan command, arguments and keyword arguments can be set by the user. 
+The full code is shown once again below:
+
+````{dropdown} View code: Full code of the StartScanButton widget
+:icon: code-square
+:animate: fade-in-slide-down
+
+``` 
+import threading
+from typing import Literal
+
+from qtpy.QtWidgets import QPushButton
+
+from bec_widgets.utils import BECConnector
+
+
+class StartScanButton(BECConnector, QPushButton):
+    """A button to start a line scan.
+
+    Args:
+        parent: The parent widget.
+        client (BECClient): The BEC client.
+        gui_id (str): The unique ID of the widget.
+    """
+
+    USER_ACCESS = ["set_scan_command"]
+
+    def __init__(self, parent=None, client=None, gui_id=None):
+        super().__init__(client=client, gui_id=gui_id)
+        QPushButton.__init__(self, parent=parent)
+
+        # Set the scan command to None
+        self.scan_command = None
+        # Set default scan command
+        self.scan_name = "line_scan"
+        self.scan_args = (dev.samx, -5, 5)
+        self.scan_kwargs = {"steps": 50, "exp_time": 0.1, "relative": True}
+        # Set the text of the button
+        self.set_button_text()
+        # Set the style of the button
+        self.update_style("ready")
+        # Connect the button to the on_click method
+        self.clicked.connect(self.on_click)
+
+    def update_style(self, mode: Literal["ready", "running"]):
+        """Update the style of the button based on the mode.
+
+        Args:
+            mode (Literal["ready", "running"): The mode of the button.
+        """
+        if mode == "ready":
+            self.setStyleSheet(
+                "background-color: #4CAF50; color: white; font-size: 16px; padding: 10px 24px;"
+            )
+        elif mode == "running":
+            self.setStyleSheet(
+                "background-color: #808080; color: white; font-size: 16px; padding: 10px 24px;"
+            )
+
+    def set_button_text(self):
+        """Set the text of the button."""
+        self.setText(f"Start {self.scan_name}")
+
+    def set_scan_command(self, scan_name: str, args: tuple, kwargs: dict):
+        """Set the scan command to run.
+
+        Args:
+            scan_name (str): The name of the scan command.
+            args (tuple): The arguments for the scan command.
+            kwargs (dict): The keyword arguments for the scan command.
+        """
+        # check if scan_command starts with scans.
+        if not getattr(self.client.scans, scan_name):
+            raise ValueError(
+                f"The scan type must be implemented in the scan library of BEC, received {scan_name}"
+            )
+        self.scan_name = scan_name
+        self.scan_args = args
+        self.scan_kwargs = kwargs
+        self.set_button_text()
+
+    def run_command(self):
+        """Run the scan command."""
+        # Switch the style of the button
+        self.update_style("running")
+        # Disable the buttom while the scan is running
+        self.setEnabled(False)
+        # Get the scan command from the scans library
+        scan_command = getattr(self.scans, self.scan_name)
+        # Run the scan command
+        scan_report = scan_command(*self.scan_args, **self.scan_kwargs)
+        # Wait for the scan to finish
+        scan_report.wait()
+        # Reactivate the button
+        self.setEnabled(True)
+        # Switch the style of the button back to ready
+        self.update_style("ready")
+
+    def on_click(self):
+        """Start a line scan"""
+        thread = threading.Thread(target=self.run_command)
+        thread.start()
+
+    def cleanup(self):
+        """Cleanup the widget"""
+        # stop thread
+        # stop the thread or if this is implemented via QThread, ensure stopping of QThread.
+        # Ideally, the BECConnector should take care of this automatically.
+        # Important to call super().cleanup() to ensure that the cleanup of the BECConnector is also called
+        super().cleanup()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = StartScanButton()
+    widget.show()
+    sys.exit(app.exec_())
+
+
+```
+````
+
+### Step 6: Write a test for the widget
+We highly recommend writing tests for the widget to ensure that they work as expected. This allows to run the tests automatically in a CI/CD pipeline and to ensure that the widget works as expected not only now but als in the future.
+The following code snippet shows an example to test the set_scan_command from the `StartScanButton` widget.
+``` python 
+import pytest
+
+from bec_widgets.widgets.start_scan_button import StartScanButton
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def test_scan_button(qtbot, mocked_client):
+    widget = StartScanButton(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+def test_set_scan_command(test_scan_button):
+    """Test the set_scan_command function."""
+    test_scan_button.set_scan_command(
+        scan_name="grid_scan",
+        args=(dev.samx, -5, 5, 10, dev.samy, -5, 5, 20),
+        kwargs={"exp_time": 0.1, "relative": True},
+    )
+    # Check first if all parameter have been properly set
+    assert test_scan_button.scan_name == "grid_scan"
+    assert test_scan_button.scan_args == (dev.samx, -5, 5, 10, dev.samy, -5, 5, 20)
+    assert test_scan_button.scan_kwargs == {"exp_time": 0.1, "relative": True}
+    # Next, we check if the displayed text of the button has been updated
+    # We use the .text() method from the QPushButton class to retrieve the text displayed
+    assert test_scan_button.text() == "Start grid_scan"
+```
--- a/docs/developer/widgets/widgets.md
+++ b/docs/developer/widgets/widgets.md
@@ -0,0 +1,12 @@
+(developer.widgets)=
+# Widgets
+This section provides an introduction to the building blocks of BEC Widgets: widgets. Widgets are the basic components of the graphical user interface (GUI) and are used to create larger applications. We will cover key topics such as how to develop new widgets or how to customise existing widgets. For details on the already available widgets and their usage, please refer to user section about [widgets](#user.widgets)
+
+```{toctree}
+---
+maxdepth: 2
+hidden: false
+---
+
+how_to_develop_a_widget/
+```
--- a/docs/user/customisation.md
+++ b/docs/user/customisation.md
@@ -1,8 +1,118 @@
 (user.customisation)=
 # Customisation

-BEC Widgets are designed to be used with QtDesigner to quicly design GUI.
+## Leveraging BEC Widgets in custom GUI applications

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

 ## Example of promoting widgets in Qt Designer

--- a/docs/user/getting_started/BECDockArea.png
+++ b/docs/user/getting_started/BECDockArea.png
--- a/docs/user/getting_started/installation.md
+++ b/docs/user/getting_started/installation.md
@@ -9,7 +9,7 @@ Before installing BEC Widgets, please ensure the following requirements are met:

 **Standard Installation**

-To install BEC Widgets using the pip package manager, execute the following command in your terminal for getting the default PyQT6 version in your python environment:
+To install BEC Widgets using the pip package manager, execute the following command in your terminal for getting the default PyQT6 version into your python environment for BEC:


 ```bash
--- a/docs/user/getting_started/quick_start.md
+++ b/docs/user/getting_started/quick_start.md
@@ -5,6 +5,10 @@ In order to use BEC Widgets as a plotting tool for BEC, it needs to be [installe
 ## BECDockArea
 The `bec.gui` object is your entry point to BEC Widgets. It is a [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) instance that can be composed of multiple [`BECDock`](/api_reference/_autosummary/bec_widgets.cli.client.BECDock)s that can be attached / detached to the main area. These docks allow users to freely arrange and customize the widgets they add to the gui, providing a flexible and customizable interface to visualize data. 

+**Schema of the BECDockArea**
+
+![BECDockArea.png](BECDockArea.png)
+
 ## Widgets
 Widgets are the building blocks of the BEC Widgets framework. They are the visual components that allow users to interact with the data and control the behavior of the application. Each dock can contain multiple widgets, albeit we recommend for most use cases a single widget per dock. BEC Widgets provides a set of core widgets (cf. [widgets](#user.widgets)). More widgets can be added by the users, and we invite you to explore the [developer documentation](developer.widgets) to learn how to create custom widgets.
 For the introduction given here, we will focus on the `BECFigure` widget, as it is the most commonly used widget for visualizing data from BEC. The same access pattern can be used for all other widgets.
--- a/docs/user/widgets/BECFigure.png
+++ b/docs/user/widgets/BECFigure.png
--- a/docs/user/widgets/bec_figure.md
+++ b/docs/user/widgets/bec_figure.md
@@ -3,6 +3,10 @@
 [`BECFigure`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure) is a widget that provides a graphical user interface for creating and managing plots. It is a versatile tool that allows users to create a wide range of plots, from simple 1D waveforms to complex 2D scatter plots. BECFigure is designed to be user-friendly and interactive, enabling users to customize plots and visualize data in real-time.
 In the following, we describe 4 different type of widgets thaat are available in BECFigure. 

+**Schema of the BECFigure**
+
+![BECFigure.png](BECFigure.png)
+
 (user.widgets.waveform_1d)=
 ## [1D Waveform Widget](/api_reference/_autosummary/bec_widgets.cli.client.BECWaveform)

@@ -22,7 +26,7 @@ The following code snipped demonstrates how to create a 1D waveform plot using B
 # adds a new dock, a new BECFigure and a BECWaveForm to the dock
 plt = gui.add_dock().add_widget('BECFigure').plot('samx', 'bpm4i')
 # add a second curve to the same plot 
-plt.add_curve_scan('samx', 'bpm3i')
+plt.plot(x_name='samx', y_name='bpm3i')
 plt.set_title("Gauss plots vs. samx")
 plt.set_x_label("Motor X")
 plt.set_y_label("Gauss Signal (A.U.")
@@ -53,7 +57,7 @@ dev.bpm3i.sim.select_sim_model("StepModel")
 The following code snipped demonstrates how to create a 2D scatter plot using BEC Widgets within BEC.
 ```python
 # adds a new dock, a new BECFigure and a BECWaveForm to the dock
-plt = gui.add_dock().add_widget('BECFigure').add_plot('samx', 'samy', 'bpm4i')
+plt = gui.add_dock().add_widget('BECFigure').add_plot(x_name='samx', y_name='samy', z_name='bpm4i')
 ```

 (user.widgets.motor_map)=
--- a/docs/user/widgets/buttons.md
+++ b/docs/user/widgets/buttons.md
@@ -0,0 +1,38 @@
+(user.widgets.buttons)=
+
+# Buttons Widgets
+
+This section consolidates various custom buttons used within the BEC GUIs, facilitating the integration of these
+controls into different layouts.
+
+## Stop Button
+
+**Purpose:**
+
+The `Stop Button` provides a user interface control to immediately halt the execution of the current operation in the
+BEC Client. It is designed for easy integration into any BEC GUI layout.
+
+**Key Features:**
+
+- **Immediate Termination:** Halts the execution of the current script or process.
+- **Queue Management:** Clears any pending operations in the scan queue, ensuring the system is ready for new tasks.
+
+**Code example:**
+
+Integrating the `StopButton` into a BEC GUI layout is straightforward. The following example demonstrates how to embed
+a `StopButton` within a GUI layout:
+
+```python
+from qtpy.QtWidgets import QWidget, QVBoxLayout
+from bec_widgets.widgets import StopButton
+
+
+class MyGui(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setLayout(QVBoxLayout(self))  # Initialize the layout for the widget
+
+        # Create and add the StopButton to the layout
+        self.stop_button = StopButton()
+        self.layout().addWidget(self.stop_button)
+```
--- a/docs/user/widgets/text_box.md
+++ b/docs/user/widgets/text_box.md
@@ -0,0 +1,33 @@
+(user.widgets.text_box)=
+# [Text Box Widget](/api_reference/_autosummary/bec_widgets.cli.client.TextBox)
+**Purpose:**
+
+The Text Box Widget is a widget that allows you to display text within the BEC GUI. The widget can be used to display plain text or HTML text.
+
+**Key Features:**
+
+- set the text to display.
+- automatically detects if the text is plain text or HTML text.
+- set background color and font color.
+
+**Code example:**
+
+The following code snipped demonstrates how to create a `TextBox` widget using BEC Widgets within BEC.
+```python
+text_box = gui.add_dock().add_widget("TextBox")
+# set the text to display
+text_box.set_text("Hello, World!")
+# set the background color and font color
+text_box.set_color(backgroud_color="#FFF", font_color="#000")
+# set the text to display as HTML
+text_box.set_text("<h1>Welcome to BEC Widgets</h1><p>This is an example of displaying <strong>HTML</strong> text.</p>")
+```
+
+
+
+
+
+
+
+
+
--- a/docs/user/widgets/website.md
+++ b/docs/user/widgets/website.md
@@ -0,0 +1,21 @@
+(user.widgets.website)=
+# [Website Widget](/api_reference/_autosummary/bec_widgets.cli.client.WebsiteWidget)
+**Purpose:**
+
+The Website Widget is a widget that allows you to display a website within the BEC GUI. The widget can be used to display any website. 
+
+**Key Features:**
+
+- set the URL of the website to display.
+- reload the website.
+- navigate back and forward in the website history.
+
+**Code example:**
+
+The following code snipped demonstrates how to create a `WebsiteWidget` using BEC Widgets within BEC.
+```python
+# adds a new dock with a website widget
+web = gui.add_dock().add_widget("Website")
+# set the URL of the website to display
+web.set_url("https://bec.readthedocs.io/en/latest/")
+```
--- a/docs/user/widgets/widgets.md
+++ b/docs/user/widgets/widgets.md
@@ -10,6 +10,9 @@ hidden: false

 bec_figure/
 spiral_progress_bar/
+website/
+buttons/
+text_box/
 ```


--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"

 [project]
 name = "bec_widgets"
-version = "0.57.4"
+version = "0.63.2"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -19,10 +19,12 @@ dependencies = [
    "qtpy",
    "pyqtgraph",
    "bec_lib",
+    "bec_ipython_client", # needed for jupyter widget
    "zmq",
    "h5py",
    "pyqtdarktheme",
-    "black",
+    "black",              # needed for bw-generate-cli
+    "isort",              # needed for bw-generate-cli
 ]


@@ -34,17 +36,20 @@ dev = [
    "pytest-xvfb",
    "coverage",
    "pytest-qt",
-    "isort",
    "fakeredis",
 ]
-pyqt5 = ["PyQt5>=5.9"]
-pyqt6 = ["PyQt6>=6.7"]
+pyqt5 = ["PyQt5>=5.9", "PyQtWebEngine>=5.9"]
+pyqt6 = ["PyQt6>=6.7", "PyQt6-WebEngine>=6.7"]
 pyside6 = ["PySide6>=6.7"]

 [project.urls]
 "Bug Tracker" = "https://gitlab.psi.ch/bec/bec_widgets/issues"
 Homepage = "https://gitlab.psi.ch/bec/bec_widgets"

+[project.scripts]
+bw-generate-cli = "bec_widgets.cli.generate_cli:main"
+bec-gui-server = "bec_widgets.cli.server:main"
+
 [tool.hatch.build.targets.wheel]
 include = ["*"]

@@ -57,6 +62,7 @@ profile = "black"
 line_length = 100
 multi_line_output = 3
 include_trailing_comma = true
+known_first_party = ["bec_widgets"]

 [tool.semantic_release]
 build_command = "python -m build"
--- a/tests/end-2-end/test_bec_dock_rpc_e2e.py
+++ b/tests/end-2-end/test_bec_dock_rpc_e2e.py
@@ -253,8 +253,14 @@ def test_auto_update(bec_client_lib, rpc_server_dock):
    plt_data = widgets[0].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[f"Scan {status.scan.scan_number} - bpm4i"]["x"]
+        == last_scan_data["samx"]["samx"].val
+    )
+    assert (
+        plt_data[f"Scan {status.scan.scan_number} - bpm4i"]["y"]
+        == last_scan_data["bpm4i"]["bpm4i"].val
+    )

    status = scans.grid_scan(
        dev.samx, -10, 10, 5, dev.samy, -5, 5, 5, exp_time=0.05, relative=False
@@ -268,5 +274,11 @@ def test_auto_update(bec_client_lib, rpc_server_dock):
    last_scan_data = queue.scan_storage.storage[-1].data

    # check plotted data
-    assert plt_data[f"Scan {status.scan.scan_number}"]["x"] == last_scan_data["samx"]["samx"].val
-    assert plt_data[f"Scan {status.scan.scan_number}"]["y"] == last_scan_data["samy"]["samy"].val
+    assert (
+        plt_data[f"Scan {status.scan.scan_number} - {dock.selected_device}"]["x"]
+        == last_scan_data["samx"]["samx"].val
+    )
+    assert (
+        plt_data[f"Scan {status.scan.scan_number} - {dock.selected_device}"]["y"]
+        == last_scan_data["samy"]["samy"].val
+    )
--- a/tests/end-2-end/test_bec_figure_rpc_e2e.py
+++ b/tests/end-2-end/test_bec_figure_rpc_e2e.py
@@ -9,7 +9,7 @@ def test_rpc_waveform1d_custom_curve(rpc_server_figure):
    fig = BECFigure(rpc_server_figure)

    ax = fig.add_plot()
-    curve = ax.add_curve_custom([1, 2, 3], [1, 2, 3])
+    curve = ax.plot(x=[1, 2, 3], y=[1, 2, 3])
    curve.set_color("red")
    curve = ax.curves[0]
    curve.set_color("blue")
@@ -24,7 +24,7 @@ def test_rpc_plotting_shortcuts_init_configs(rpc_server_figure, qtbot):
    plt = fig.plot(x_name="samx", y_name="bpm4i")
    im = fig.image("eiger")
    motor_map = fig.motor_map("samx", "samy")
-    plt_z = fig.add_plot("samx", "samy", "bpm4i")
+    plt_z = fig.add_plot(x_name="samx", y_name="samy", z_name="bpm4i")

    # Checking if classes are correctly initialised
    assert len(fig.widgets) == 4
--- a/tests/end-2-end/test_rpc_register_e2e.py
+++ b/tests/end-2-end/test_rpc_register_e2e.py
@@ -9,7 +9,7 @@ def test_rpc_register_list_connections(rpc_server_figure):
    plt = fig.plot(x_name="samx", y_name="bpm4i")
    im = fig.image("eiger")
    motor_map = fig.motor_map("samx", "samy")
-    plt_z = fig.add_plot("samx", "samy", "bpm4i")
+    plt_z = fig.add_plot(x_name="samx", y_name="samy", z_name="bpm4i")

    # keep only class names from objects, since objects on server and client are different
    # so the best we can do is to compare types (rpc register is unit-tested elsewhere)
--- a/tests/unit_tests/test_color_validation.py
+++ b/tests/unit_tests/test_color_validation.py
@@ -0,0 +1,60 @@
+import pytest
+from pydantic import ValidationError
+
+from bec_widgets.utils import Colors
+from bec_widgets.widgets.figure.plots.waveform.waveform_curve import CurveConfig
+
+
+def test_color_validation_CSS():
+    # Test valid color
+    color = Colors.validate_color("teal")
+    assert color == "teal"
+
+    # Test invalid color
+    with pytest.raises(ValidationError) as excinfo:
+        CurveConfig(color="invalid_color")
+
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == ("unsupported color")
+    assert "The color must be a valid HEX string or CSS Color." in str(excinfo.value)
+
+
+def test_color_validation_hex():
+    # Test valid color
+    color = Colors.validate_color("#ff0000")
+    assert color == "#ff0000"
+
+    # Test invalid color
+    with pytest.raises(ValidationError) as excinfo:
+        CurveConfig(color="#ff00000")
+
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == ("unsupported color")
+    assert "The color must be a valid HEX string or CSS Color." in str(excinfo.value)
+
+
+def test_color_validation_RGBA():
+    # Test valid color
+    color = Colors.validate_color((255, 0, 0, 255))
+    assert color == (255, 0, 0, 255)
+
+    # Test invalid color
+    with pytest.raises(ValidationError) as excinfo:
+        CurveConfig(color=(255, 0, 0))
+
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == ("unsupported color")
+    assert "The color must be a tuple of 4 elements (R, G, B, A)." in str(excinfo.value)
+
+    with pytest.raises(ValidationError) as excinfo:
+        CurveConfig(color=(255, 0, 0, 355))
+
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == ("unsupported color")
+    assert "The color values must be between 0 and 255 in RGBA format (R,G,B,A)" in str(
+        excinfo.value
+    )
--- a/tests/unit_tests/test_generate_cli_client.py
+++ b/tests/unit_tests/test_generate_cli_client.py
@@ -1,10 +1,12 @@
 from textwrap import dedent

 import black
-import pytest
+import isort

 from bec_widgets.cli.generate_cli import ClientGenerator

+# pylint: disable=missing-function-docstring
+

 # Mock classes to test the generator
 class MockBECWaveform1D:
@@ -24,25 +26,39 @@ class MockBECFigure:

    def add_plot(self, plot_id: str):
        """Add a plot to the figure."""
-        pass

    def remove_plot(self, plot_id: str):
        """Remove a plot from the figure."""
-        pass


 def test_client_generator_with_black_formatting():
    generator = ClientGenerator()
-    generator.generate_client([MockBECWaveform1D, MockBECFigure])
+    rpc_classes = {
+        "connector_classes": [MockBECWaveform1D, MockBECFigure],
+        "top_level_classes": [MockBECFigure],
+    }
+    generator.generate_client(rpc_classes)

    # Format the expected output with black to ensure it matches the generator output
    expected_output = dedent(
        '''\
        # This file was automatically generated by generate_cli.py

-        from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECGuiClientMixin
+        import enum
        from typing import Literal, Optional, overload

+        from bec_widgets.cli.client_utils import BECGuiClientMixin, RPCBase, rpc_call
+
+        # pylint: skip-file
+
+        class Widgets(str, enum.Enum):
+            """
+            Enum for the available widgets.
+            """
+
+            MockBECFigure = "MockBECFigure"
+
+
        class MockBECWaveform1D(RPCBase):
            @rpc_call
            def set_frequency(self, frequency: float) -> list:
@@ -78,4 +94,20 @@ def test_client_generator_with_black_formatting():
        generator.header + "\n" + generator.content, mode=black.FileMode(line_length=100)
    )

+    generated_output_formatted = isort.code(generated_output_formatted)
+
    assert expected_output_formatted == generated_output_formatted
+
+
+def test_client_generator_classes():
+    generator = ClientGenerator()
+    out = generator.get_rpc_classes("bec_widgets")
+    assert list(out.keys()) == ["connector_classes", "top_level_classes"]
+    connector_cls_names = [cls.__name__ for cls in out["connector_classes"]]
+    top_level_cls_names = [cls.__name__ for cls in out["top_level_classes"]]
+
+    assert "BECFigure" in connector_cls_names
+    assert "BECWaveform" in connector_cls_names
+    assert "BECDockArea" in top_level_cls_names
+    assert "BECFigure" in top_level_cls_names
+    assert "BECWaveform" not in top_level_cls_names
--- a/tests/unit_tests/test_stop_button.py
+++ b/tests/unit_tests/test_stop_button.py
@@ -0,0 +1,25 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
+
+import pytest
+
+from bec_widgets.widgets import StopButton
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def stop_button(qtbot, mocked_client):
+    widget = StopButton(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+def test_stop_button(stop_button):
+    assert stop_button.text() == "Stop"
+    assert stop_button.styleSheet() == "background-color:  #cc181e; color: white"
+    stop_button.click()
+    assert stop_button.queue.request_scan_abortion.called
+    assert stop_button.queue.request_queue_reset.called
+    stop_button.close()
--- a/tests/unit_tests/test_text_box_widget.py
+++ b/tests/unit_tests/test_text_box_widget.py
@@ -0,0 +1,55 @@
+import re
+from unittest import mock
+
+import pytest
+
+from bec_widgets.widgets.text_box.text_box import TextBox
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def text_box_widget(qtbot, mocked_client):
+    widget = TextBox(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+def test_textbox_widget(text_box_widget):
+    """Test the TextBox widget."""
+    text = "Hello World!"
+    text_box_widget.set_text(text)
+    assert text_box_widget.toPlainText() == text
+
+    text_box_widget.set_color("#FFDDC1", "#123456")
+    text_box_widget.set_font_size(20)
+    assert (
+        text_box_widget.styleSheet() == "background-color: #FFDDC1; color: #123456; font-size: 20px"
+    )
+    text_box_widget.set_color("white", "blue")
+    text_box_widget.set_font_size(14)
+    assert text_box_widget.styleSheet() == "background-color: white; color: blue; font-size: 14px"
+    text = "<h1>Welcome to PyQt6</h1><p>This is an example of displaying <strong>HTML</strong> text.</p>"
+    with mock.patch.object(text_box_widget, "setHtml") as mocked_set_html:
+        text_box_widget.set_text(text)
+        assert mocked_set_html.call_count == 1
+        assert mocked_set_html.call_args == mock.call(text)
+
+
+def test_textbox_change_theme(text_box_widget):
+    """Test change theme functionaility"""
+    # Default is dark theme
+    text_box_widget.change_theme()
+    assert text_box_widget.config.theme == "light"
+    assert (
+        text_box_widget.styleSheet()
+        == f"background-color: #FFF; color: #000; font-size: {text_box_widget.config.font_size}px"
+    )
+    text_box_widget.change_theme()
+    assert text_box_widget.config.theme == "dark"
+    assert (
+        text_box_widget.styleSheet()
+        == f"background-color: #000; color: #FFF; font-size: {text_box_widget.config.font_size}px"
+    )
--- a/tests/unit_tests/test_waveform1d.py
+++ b/tests/unit_tests/test_waveform1d.py
@@ -73,7 +73,7 @@ def test_create_waveform1D_by_config(bec_figure):
                "parent_id": "widget_1",
                "label": "bpm4i-bpm4i",
                "color": "#cc4778",
-                "colormap": "plasma",
+                "color_map_z": "plasma",
                "symbol": "o",
                "symbol_color": None,
                "symbol_size": 5,
@@ -105,7 +105,7 @@ def test_create_waveform1D_by_config(bec_figure):
                "parent_id": "widget_1",
                "label": "curve-custom",
                "color": "blue",
-                "colormap": "plasma",
+                "color_map_z": "plasma",
                "symbol": "o",
                "symbol_color": None,
                "symbol_size": 5,
@@ -360,7 +360,7 @@ def test_curve_add_by_config(bec_figure):
        "parent_id": "widget_1",
        "label": "bpm4i-bpm4i",
        "color": "#cc4778",
-        "colormap": "plasma",
+        "color_map_z": "plasma",
        "symbol": "o",
        "symbol_color": None,
        "symbol_size": 5,
--- a/tests/unit_tests/test_website_widget.py
+++ b/tests/unit_tests/test_website_widget.py
@@ -0,0 +1,27 @@
+import pytest
+from qtpy.QtCore import QUrl
+
+from bec_widgets.widgets.website.website import WebsiteWidget
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def website_widget(qtbot, mocked_client):
+    widget = WebsiteWidget(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.page().deleteLater()
+    qtbot.wait(1000)
+
+
+def test_website_widget_set_url(website_widget):
+    website_widget.set_url("https://scilog.psi.ch")
+    assert website_widget.url() == QUrl("https://scilog.psi.ch")
+
+    website_widget.set_url(None)
+    assert website_widget.url() == QUrl("https://scilog.psi.ch")
+
+    website_widget.set_url("https://google.com")
+    assert website_widget.get_url() == "https://google.com"
Author	SHA1	Message	Date
appel_c	bdbc2b903d	docs: add tutorial on how to add StartScan Button	2024-06-14 14:30:40 +02:00
appel_c	2a36d9364f	docs: refactor developer section, add widget tutorial	2024-06-14 14:24:38 +02:00
appel_c	27426ce7a5	ci: add job optional dependency check	2024-06-14 11:47:42 +02:00
semantic-release	69adadd6d7	0.63.2 Automatically generated by python-semantic-release	2024-06-14 08:14:22 +00:00
Mathias Guijarro	6f96498de6	fix: do not import "server" in client, prevents from having trouble with QApplication creation order Like with QtWebEngine	2024-06-13 15:14:30 +02:00
Mathias Guijarro	836b6e64f6	Reapply "feat: implement non-polling, interruptible waiting of gui instruction response with timeout" This reverts commit `fe04dd80e5`.	2024-06-13 15:14:30 +02:00
semantic-release	fab7dd7eec	0.63.1 Automatically generated by python-semantic-release	2024-06-13 13:12:54 +00:00
Mathias Guijarro	9263f8ef5c	fix: just terminate the remote process in close() instead of communicating The proper finalization sequence will be executed by the remote process on SIGTERM	2024-06-13 14:56:21 +02:00
semantic-release	658728efef	0.63.0 Automatically generated by python-semantic-release	2024-06-13 12:47:57 +00:00
appel_c	6b8432f5b2	refactor: add pydantic config, add change_theme	2024-06-13 14:08:22 +02:00
appel_c	bc709c4184	docs: add documentation	2024-06-13 08:14:50 +02:00
appel_c	b49462abeb	test: add test for text box	2024-06-13 08:14:50 +02:00
appel_c	d9d4e3c9bf	feat: add textbox widget	2024-06-13 08:08:46 +02:00
wyzula_j	fe04dd80e5	Revert "feat: implement non-polling, interruptible waiting of gui instruction response with timeout" This reverts commit `abc6caa2d0`	2024-06-12 17:19:08 +02:00
semantic-release	718950cf0d	0.62.0 Automatically generated by python-semantic-release	2024-06-12 10:01:48 +00:00
Mathias Guijarro	17a0068757	doc: add documentation about creating custom GUI applications embedding BEC Widgets	2024-06-12 11:54:47 +02:00
Mathias Guijarro	abc6caa2d0	feat: implement non-polling, interruptible waiting of gui instruction response with timeout	2024-06-12 11:43:08 +02:00
semantic-release	99fb82561b	0.61.0 Automatically generated by python-semantic-release	2024-06-12 06:27:41 +00:00
wyzula-jan	61ba08d0b8	feat(widgets/stop_button): General stop button added	2024-06-12 01:11:06 +02:00
appel_c	40b5688158	refactor: improve labe of auto_update script	2024-06-10 08:27:32 +02:00
semantic-release	0a4e253cbd	0.60.0 Automatically generated by python-semantic-release	2024-06-08 17:35:57 +00:00
wakonig_k	6428e38ab9	fix: removed BECConnector from rpc client interface	2024-06-08 19:05:57 +02:00
wakonig_k	fc4f4f81ad	ci: added git fetch for target branch	2024-06-08 19:05:57 +02:00
wakonig_k	f6629852eb	test: added missing pylint statement to header	2024-06-08 19:05:57 +02:00
wakonig_k	3adf6cfd58	refactor: minor cleanup	2024-06-08 19:05:57 +02:00
wakonig_k	b15816ca9f	refactor: disabled pylint for auto-gen client	2024-06-08 19:05:57 +02:00
wakonig_k	6b1d5827d6	ci: fixed pylint-check	2024-06-08 19:05:57 +02:00
wakonig_k	f0391f59c9	feat: added isort to bw-generate-cli	2024-06-08 19:05:57 +02:00
wakonig_k	006a0894b8	fix: added bec_ipython_client as dependency; needed for jupyter widget	2024-06-08 19:05:57 +02:00
wakonig_k	9c5a471234	refactor(isort): added bec_widgets as known first party package	2024-06-08 19:05:57 +02:00
wakonig_k	1c7f4912ce	feat: added entry point for bw-generate-cli	2024-06-08 19:05:57 +02:00
wakonig_k	df1be10057	feat(cli): auto-discover rpc-enabled widgets	2024-06-08 19:05:57 +02:00
wakonig_k	954c576131	fix(BECFigure): removed duplicated user access for plot	2024-06-08 19:05:57 +02:00
wakonig_k	867720a897	fix(bec_connector): field validator should be a classmethod	2024-06-08 19:05:57 +02:00
wyzula-jan	2b40602bdc	refactor(dock): parent_dock_area changed to orig_area (native for pyqtgraph)	2024-06-08 16:00:45 +02:00
wakonig_k	11173b9c0a	ci: cleanup	2024-06-08 08:54:08 +02:00
semantic-release	52d46e77db	0.59.1 Automatically generated by python-semantic-release	2024-06-07 23:24:10 +00:00
wyzula-jan	e7838b0f2f	fix(curve): set_color_map_z typo fixed in user access	2024-06-08 01:17:13 +02:00
semantic-release	2ae3810cf6	0.59.0 Automatically generated by python-semantic-release	2024-06-07 20:47:10 +00:00
wakonig_k	178fe4d2da	ci: merged additional tests to parallel matrix job	2024-06-07 22:37:24 +02:00
wakonig_k	2d79ef8fe5	ci: added webengine dependencies	2024-06-07 22:37:24 +02:00
wakonig_k	d56c5493cd	build: added webengine dependency	2024-06-07 22:37:24 +02:00
wakonig_k	cf6e5a40fc	docs: added website docs	2024-06-07 22:37:24 +02:00
wakonig_k	64abd67b9b	feat(widget): added simple website widget with rpc	2024-06-07 22:37:24 +02:00
semantic-release	c19e856800	0.58.1 Automatically generated by python-semantic-release	2024-06-07 19:39:16 +00:00
wyzula-jan	02a26086c4	fix(dock): new dock can be detached upon creation	2024-06-07 21:32:38 +02:00
semantic-release	35f880bc2f	0.58.0 Automatically generated by python-semantic-release	2024-06-07 19:25:17 +00:00
wyzula-jan	c0ddeceeea	test(color): validation tests added	2024-06-07 19:16:58 +02:00
wyzula-jan	67fd5e8581	fix: bar colormap dynamic setting	2024-06-07 18:52:37 +02:00
wyzula-jan	bf699ec1fb	fix: formatting isort	2024-06-07 18:40:42 +02:00
wyzula-jan	3094632134	feat(utils.colors): general color validators	2024-06-07 18:34:57 +02:00
wyzula-jan	6985ff0fce	fix(curve): 2D scatter updated if color_map_z is changed	2024-06-07 16:28:51 +02:00
wyzula-jan	33f7be42c5	fix(curve): color_map_z setting works	2024-06-07 16:28:51 +02:00
semantic-release	36fac70361	0.57.7 Automatically generated by python-semantic-release	2024-06-07 14:15:17 +00:00
appel_c	ca5e8d2fbb	fix: add model_config to pydantic models to allow runtime checks after creation	2024-06-07 15:44:09 +02:00
wyzula-jan	828067f486	docs: added schema of BECDockArea and BECFigure	2024-06-06 20:14:47 +02:00
semantic-release	e5f4c0b952	0.57.6 Automatically generated by python-semantic-release	2024-06-06 18:05:05 +00:00
wyzula-jan	edb1775967	fix(bar): docstrings extended	2024-06-06 18:39:47 +02:00
semantic-release	d0d6908a74	0.57.5 Automatically generated by python-semantic-release	2024-06-06 16:01:55 +00:00
wyzula-jan	c037b87675	docs(figure): docs adjusted to be compatible with new signature	2024-06-06 17:54:41 +02:00
wyzula-jan	52bc322b2b	refactor(figure): logic for .add_image and .image consolidated; logic for .add_plot and .plot consolidated	2024-06-06 17:54:41 +02:00
wyzula-jan	8479caf53a	fix(waveform): added .plot method with the same signature as BECFigure.plot	2024-06-06 17:54:41 +02:00
wyzula-jan	82e2c898d2	fix(plot_base): .plot removed from plot_base.py, because there is no use case for it	2024-06-06 17:54:41 +02:00
				`@@ -0,0 +1 @@`
				`from .stop_button.stop_button import StopButton`