fix(test): add a temporary test

.git_hooks/pre-commit

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

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,41 +0,0 @@
-name: Bug report
-description: File a bug report.
-title: "[BUG]: "
-labels: ["bug"]
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Bug report:
-  - type: textarea
-    id: description
-    attributes:
-      label: Provide a brief description of the bug.
-  - type: textarea
-    id: expected
-    attributes:
-      label: Describe what you expected to happen and what actually happened.
-  - type: textarea
-    id: reproduction
-    attributes:
-      label: Outline the steps that lead to the bug's occurrence. Be specific and provide a clear sequence of actions.
-  - type: input
-    id: version
-    attributes:
-      label: bec_widgets version
-      description: which version of BEC widgets was running?
-  - type: input
-    id: bec-version
-    attributes:
-      label: bec core version
-      description: which version of BEC core was running?
-  - type: textarea
-    id: extra
-    attributes:
-      label: Any extra info / data? e.g. log output...
-  - type: input
-    id: issues
-    attributes:
-      label: Related issues
-      description: please tag any related issues

.github/actions/bw_install/action.yml

@@ -1,65 +0,0 @@
-name: "BEC Widgets Install"
-description: "Install BEC Widgets and related os dependencies"
-inputs:
-  BEC_WIDGETS_BRANCH: # id of input
-    required: false
-    default: "main"
-    description: "Branch of BEC Widgets to install"
-  BEC_CORE_BRANCH: # id of input
-    required: false
-    default: "main"
-    description: "Branch of BEC Core to install"
-  OPHYD_DEVICES_BRANCH: # id of input
-    required: false
-    default: "main"
-    description: "Branch of Ophyd Devices to install"
-  PYTHON_VERSION: # id of input
-    required: false
-    default: "3.11"
-    description: "Python version to use"
-
-runs:
-  using: "composite"
-  steps:
-    - name: Setup Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ inputs.PYTHON_VERSION }}
-
-    - name: Checkout BEC Core
-      uses: actions/checkout@v4
-      with:
-        repository: bec-project/bec
-        ref: ${{ inputs.BEC_CORE_BRANCH }}
-        path: ./bec
-
-    - name: Checkout Ophyd Devices
-      uses: actions/checkout@v4
-      with:
-        repository: bec-project/ophyd_devices
-        ref: ${{ inputs.OPHYD_DEVICES_BRANCH }}
-        path: ./ophyd_devices
-
-    - name: Checkout BEC Widgets
-      uses: actions/checkout@v4
-      with:
-        repository: bec-project/bec_widgets
-        ref: ${{ inputs.BEC_WIDGETS_BRANCH }}
-        path: ./bec_widgets
-
-    - name: Install dependencies
-      shell: bash
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y libgl1 libegl1 x11-utils libxkbcommon-x11-0 libdbus-1-3 xvfb
-        sudo apt-get -y install libnss3 libxdamage1 libasound2t64 libatomic1 libxcursor1
-        sudo apt-get -y install ttyd
-
-    - name: Install Python dependencies
-      shell: bash
-      run: |
-        pip install uv
-        uv pip install --system -e ./ophyd_devices
-        uv pip install --system -e ./bec/bec_lib[dev]
-        uv pip install --system -e ./bec/bec_ipython_client
-        uv pip install --system -e ./bec_widgets[dev,pyside6]

.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "pip"
-    directory: "/"
-    schedule:
-      interval: "weekly"

.github/workflows/check_pr.yml

@@ -1,28 +0,0 @@
-name: Check PR status for branch
-on:
-  workflow_call:
-    outputs:
-      branch-pr:
-        description: The PR number if the branch is in one
-        value: ${{ jobs.pr.outputs.branch-pr }}
-
-jobs:
-  pr:
-    runs-on: "ubuntu-latest"
-    outputs:
-      branch-pr: ${{ steps.script.outputs.result }}
-    steps:
-      - uses: actions/github-script@v7
-        id: script
-        if: github.event_name == 'push' && github.event.ref_type != 'tag'
-        with:
-          script: |
-            const prs = await github.rest.pulls.list({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              head: context.repo.owner + ':${{ github.ref_name }}'
-            })
-            if (prs.data.length) {
-              console.log(`::notice ::Skipping CI on branch push as it is already run in PR #${prs.data[0]["number"]}`)
-              return prs.data[0]["number"]
-            }

.github/workflows/child_repos.yml

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

.github/workflows/ci.yml

@@ -1,84 +0,0 @@
-name: Full CI
-on: 
-  push:
-  pull_request:
-  workflow_dispatch:
-    inputs:
-      BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
-        required: false
-        type: string
-      BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
-        required: false
-        type: string
-      OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
-        required: false
-        type: string
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  pull-requests: write
-
-jobs:
-  check_pr_status:
-    uses: ./.github/workflows/check_pr.yml
-
-  formatter:
-    needs: check_pr_status
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/formatter.yml
-
-  unit-test:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/pytest.yml
-    with:
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref }}
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main' }}
-    secrets:
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-
-  unit-test-matrix:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/pytest-matrix.yml
-    with:
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha}}
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main' }}
-
-  generate-cli-test:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/generate-cli-check.yml
-
-  end2end-test:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/end2end-conda.yml
-
-  child-repos:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/child_repos.yml
-    with:
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main'}} 
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
-  
-  plugin_repos:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: bec-project/bec/.github/workflows/plugin_repos.yml@main
-    with:
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
-
-    secrets:
-      GH_READ_TOKEN: ${{ secrets.GH_READ_TOKEN }}

.github/workflows/end2end-conda.yml

@@ -1,59 +0,0 @@
-name: Run Pytest with Coverage
-on: [workflow_call]
-
-jobs:
-  pytest:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        shell: bash -el {0}
-
-    env:
-      CHILD_PIPELINE_BRANCH: main # Set the branch you want for ophyd_devices
-      BEC_CORE_BRANCH: main # Set the branch you want for bec
-      OPHYD_DEVICES_BRANCH: main # Set the branch you want for ophyd_devices
-      PLUGIN_REPO_BRANCH: main # Set the branch you want for the plugin repo
-      PROJECT_PATH: ${{ github.repository }}
-      QTWEBENGINE_DISABLE_SANDBOX: 1
-      QT_QPA_PLATFORM: "offscreen"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Conda
-        uses: conda-incubator/setup-miniconda@v3
-        with:
-          auto-update-conda: true
-          auto-activate-base: true
-          python-version: "3.11"
-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgl1 libegl1 x11-utils libxkbcommon-x11-0 libdbus-1-3 xvfb
-          sudo apt-get -y install libnss3 libxdamage1 libasound2t64 libatomic1 libxcursor1
-          sudo apt-get -y install ttyd
-
-      - name: Conda install and run pytest
-        run: |
-          echo -e "\033[35;1m Using branch $BEC_CORE_BRANCH of BEC CORE \033[0;m";
-          git clone --branch $BEC_CORE_BRANCH https://github.com/bec-project/bec.git
-          echo -e "\033[35;1m Using branch $OPHYD_DEVICES_BRANCH of OPHYD_DEVICES \033[0;m";
-          git clone --branch $OPHYD_DEVICES_BRANCH https://github.com/bec-project/ophyd_devices.git
-          export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-          echo -e "\033[35;1m Using branch $PLUGIN_REPO_BRANCH of bec_testing_plugin \033[0;m";
-          git clone --branch $PLUGIN_REPO_BRANCH https://github.com/bec-project/bec_testing_plugin.git
-          cd ./bec
-          conda create -q -n test-environment python=3.11
-          source ./bin/install_bec_dev.sh -t
-          cd ../
-          pip install -e ./ophyd_devices -e .[dev,pyside6] -e ./bec_testing_plugin
-          pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end
-
-      - name: Upload logs if job fails
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: pytest-logs
-          path: ./logs/*.log
-          retention-days: 7

.github/workflows/formatter.yml

@@ -1,66 +0,0 @@
-name: Formatter and Pylint jobs
-on: [workflow_call]
-jobs:
-
-  Formatter:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.13' 
-
-      - name: Run black and isort
-        run: |
-          pip install uv
-          uv pip install --system black isort
-          uv pip install --system -e .[dev]
-          black --check --diff --color .
-          isort --check --diff ./
-      
-      - name: Check for disallowed imports from PySide
-        run: '! grep -re "from PySide6\." bec_widgets/ tests/ | grep  -v -e "PySide6.QtDesigner" -e "PySide6.scripts"'
-
-  Pylint:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.13'
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install pylint pylint-exit anybadge
-
-      - name: Run Pylint
-        run: |
-          mkdir -p ./pylint
-          set +e
-          pylint ./${{ github.event.repository.name }} --output-format=text > ./pylint/pylint.log
-          pylint-exit $?
-          set -e
-
-      - name: Extract Pylint Score
-        id: score
-        run: |
-          SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint.log)
-          echo "score=$SCORE" >> $GITHUB_OUTPUT
-
-      - name: Create Badge
-        run: |
-          anybadge --label=Pylint --file=./pylint/pylint.svg --value="${{ steps.score.outputs.score }}" 2=red 4=orange 8=yellow 10=green
-
-      - name: Upload Artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: pylint-artifacts
-          path: |
-            # ./pylint/pylint.log # not sure why this isn't working
-            ./pylint/pylint.svg

.github/workflows/generate-cli-check.yml

@@ -1,49 +0,0 @@
-name: Run bw-generate-cli
-on: [workflow_call]
-
-jobs:
-  pytest:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        shell: bash -el {0}
-
-    env:
-      CHILD_PIPELINE_BRANCH: main  # Set the branch you want for ophyd_devices
-      BEC_CORE_BRANCH: main        # Set the branch you want for bec
-      OPHYD_DEVICES_BRANCH: main   # Set the branch you want for ophyd_devices
-      PROJECT_PATH: ${{ github.repository }}
-      QTWEBENGINE_DISABLE_SANDBOX: 1
-      QT_QPA_PLATFORM: "offscreen"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install os dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgl1 libegl1 x11-utils libxkbcommon-x11-0 libdbus-1-3 xvfb
-          sudo apt-get -y install libnss3 libxdamage1 libasound2t64 libatomic1 libxcursor1
-
-      - name: Clone and install dependencies
-        run: |
-            echo -e "\033[35;1m Using branch $BEC_CORE_BRANCH of BEC CORE \033[0;m";
-            git clone --branch $BEC_CORE_BRANCH https://github.com/bec-project/bec.git
-            echo -e "\033[35;1m Using branch $OPHYD_DEVICES_BRANCH of OPHYD_DEVICES \033[0;m";
-            git clone --branch $OPHYD_DEVICES_BRANCH https://github.com/bec-project/ophyd_devices.git
-            export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-            pip install -e ./ophyd_devices
-            pip install -e ./bec/bec_lib[dev]
-            pip install -e ./bec/bec_ipython_client
-            pip install -e .[dev,pyside6]
-
-      - name: Run bw-generate-cli
-        run: |
-            bw-generate-cli --target bec_widgets 
-            git diff --exit-code
-            

.github/workflows/pytest-matrix.yml

@@ -1,59 +0,0 @@
-name: Run Pytest with different Python versions
-on: 
-  workflow_call:
-    inputs:
-      pr_number:
-        description: 'Pull request number'
-        required: false
-        type: number
-      BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
-        required: false
-        default: 'main'
-        type: string
-      OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
-        required: false
-        default: 'main'
-        type: string
-      BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
-        required: false
-        default: 'main'
-        type: string
-
-jobs:
-  pytest-matrix:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.11", "3.12", "3.13"]
-
-    env:
-      BEC_WIDGETS_BRANCH: main  # Set the branch you want for bec_widgets
-      BEC_CORE_BRANCH: main        # Set the branch you want for bec
-      OPHYD_DEVICES_BRANCH: main   # Set the branch you want for ophyd_devices
-      PROJECT_PATH: ${{ github.repository }}
-      QTWEBENGINE_DISABLE_SANDBOX: 1
-      QT_QPA_PLATFORM: "offscreen"
-
-    steps:
-
-      - name: Checkout BEC Widgets
-        uses: actions/checkout@v4
-        with:
-          repository: bec-project/bec_widgets
-          ref: ${{ inputs.BEC_WIDGETS_BRANCH }}
-
-      - name: Install BEC Widgets and dependencies
-        uses: ./.github/actions/bw_install
-        with:
-          BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH }}
-          BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH }}
-          OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH }}
-          PYTHON_VERSION: ${{ matrix.python-version }}
-
-      - name: Run Pytest
-        run: |
-          pip install pytest pytest-random-order
-          pytest -v --junitxml=report.xml --random-order ./tests/unit_tests

.github/workflows/pytest.yml

@@ -1,72 +0,0 @@
-name: Run Pytest with Coverage
-on: 
-  workflow_call:
-    inputs:
-      pr_number:
-        description: 'Pull request number'
-        required: false
-        type: number
-      BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
-        required: false
-        default: 'main'
-        type: string
-      OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
-        required: false
-        default: 'main'
-        type: string
-      BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
-        required: false
-        default: 'main'
-        type: string
-    secrets:
-      CODECOV_TOKEN:
-        required: true
-
-
-
-permissions:
-  pull-requests: write
-
-jobs:
-  pytest:
-    runs-on: ubuntu-latest
-
-    env:
-      QTWEBENGINE_DISABLE_SANDBOX: 1
-      QT_QPA_PLATFORM: "offscreen"
-
-    steps:
-      - name: Checkout BEC Widgets
-        uses: actions/checkout@v4
-        with:
-          repository: bec-project/bec_widgets
-          ref: ${{ inputs.BEC_WIDGETS_BRANCH }}
-
-      - name: Install BEC Widgets and dependencies
-        uses: ./.github/actions/bw_install
-        with:
-          BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH }}
-          BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH }}
-          OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH }}
-          PYTHON_VERSION: 3.11
-
-      - name: Run Pytest with Coverage
-        id: coverage
-        run: pytest --random-order --cov=bec_widgets --cov-config=pyproject.toml --cov-branch --cov-report=xml --no-cov-on-fail tests/unit_tests/
-
-      - name: Upload test artifacts
-        uses: actions/upload-artifact@v4
-        if: failure()
-        with:
-          name: image-references
-          path: bec_widgets/tests/reference_failures/
-          if-no-files-found: ignore
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          slug: bec-project/bec_widgets

.github/workflows/semantic_release.yml

@@ -1,103 +0,0 @@
-name: Continuous Delivery
-
-on:
-  push:
-    branches:
-      - main
-
-# default: least privileged permissions across all jobs
-permissions:
-  contents: read
-
-
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    concurrency:
-      group: ${{ github.workflow }}-release-${{ github.ref_name }}
-      cancel-in-progress: false
-
-    env:
-      CHILD_PIPELINE_BRANCH: main  # Set the branch you want for ophyd_devices
-      BEC_CORE_BRANCH: main        # Set the branch you want for bec
-      OPHYD_DEVICES_BRANCH: main   # Set the branch you want for ophyd_devices
-      PROJECT_PATH: ${{ github.repository }}
-      QTWEBENGINE_DISABLE_SANDBOX: 1
-      QT_QPA_PLATFORM: "offscreen"
-
-    permissions:
-      contents: write
-
-    steps:
-      # Note: We checkout the repository at the branch that triggered the workflow
-      # with the entire history to ensure to match PSR's release branch detection
-      # and history evaluation.
-      # However, we forcefully reset the branch to the workflow sha because it is
-      # possible that the branch was updated while the workflow was running. This
-      # prevents accidentally releasing un-evaluated changes.
-      - name: Setup | Checkout Repository on Release Branch
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.ref_name }}
-          fetch-depth: 0
-          ssh-key: ${{ secrets.CI_DEPLOY_SSH_KEY }}
-          ssh-known-hosts: ${{ secrets.CI_DEPLOY_SSH_KNOWN_HOSTS }}
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-
-      - name: Setup | Force release branch to be at workflow sha
-        run: |
-          git reset --hard ${{ github.sha }}
-      - name: Evaluate | Verify upstream has NOT changed
-        # Last chance to abort before causing an error as another PR/push was applied to
-        # the upstream branch while this workflow was running. This is important
-        # because we are committing a version change (--commit). You may omit this step
-        # if you have 'commit: false' in your configuration.
-        #
-        # You may consider moving this to a repo script and call it from this step instead
-        # of writing it in-line.
-        shell: bash
-        run: |
-          set +o pipefail
-
-          UPSTREAM_BRANCH_NAME="$(git status -sb | head -n 1 | cut -d' ' -f2 | grep -E '\.{3}' | cut -d'.' -f4)"
-          printf '%s\n' "Upstream branch name: $UPSTREAM_BRANCH_NAME"
-
-          set -o pipefail
-
-          if [ -z "$UPSTREAM_BRANCH_NAME" ]; then
-              printf >&2 '%s\n' "::error::Unable to determine upstream branch name!"
-              exit 1
-          fi
-
-          git fetch "${UPSTREAM_BRANCH_NAME%%/*}"
-
-          if ! UPSTREAM_SHA="$(git rev-parse "$UPSTREAM_BRANCH_NAME")"; then
-              printf >&2 '%s\n' "::error::Unable to determine upstream branch sha!"
-              exit 1
-          fi
-
-          HEAD_SHA="$(git rev-parse HEAD)"
-
-          if [ "$HEAD_SHA" != "$UPSTREAM_SHA" ]; then
-              printf >&2 '%s\n' "[HEAD SHA] $HEAD_SHA != $UPSTREAM_SHA [UPSTREAM SHA]"
-              printf >&2 '%s\n' "::error::Upstream has changed, aborting release..."
-              exit 1
-          fi
-
-          printf '%s\n' "Verified upstream branch has not changed, continuing with release..."
-
-      - name: Semantic Version Release
-        id: release
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          pip install python-semantic-release==9.* wheel build twine
-          semantic-release -vv version
-          if [ ! -d dist ]; then echo No release will be made; exit 0; fi
-          twine upload dist/* -u __token__ -p ${{ secrets.CI_PYPI_TOKEN }} --skip-existing
-          semantic-release publish

.github/workflows/stale-issues.yml

@@ -1,19 +0,0 @@
-name: 'Close stale issues and PRs'
-on:
-  schedule:
-    - cron: '00 10 * * *'
-  workflow_dispatch:
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-    steps:
-      - uses: actions/stale@v9
-        with:
-          stale-issue-message: 'This issue is stale because it has been open 120 days with no activity. Remove stale label or comment or this will be closed in 14 days.'
-          stale-pr-message: 'This PR is stale because it has been open 120 days with no activity. Remove stale label or comment or this will be closed in 14 days.'
-          days-before-stale: 120
-          days-before-close: 14

.github/workflows/sync-issues-pr.yml

@@ -1,35 +0,0 @@
-name: Sync PR to Project
-
-on:
-  pull_request:
-    types:
-      [
-        opened,
-        assigned,
-        unassigned,
-        edited,
-        ready_for_review,
-        converted_to_draft,
-        reopened,
-        synchronize,
-        closed,
-      ]
-
-jobs:
-  sync-project:
-    runs-on: ubuntu-latest
-
-    permissions:
-      issues: write
-      pull-requests: read
-      contents: read
-
-    steps:
-      - name: Sync PR to Project
-        uses: bec-project/action-issue-sync-pr@v1
-        with:
-          token: ${{ secrets.ADD_ISSUE_TO_PROJECT }}
-          org: ${{ github.repository_owner }}
-          repo: ${{ github.event.repository.name }}
-          project-number: 3
-          pr-number: ${{ github.event.pull_request.number }}

.gitignore

@@ -64,9 +64,6 @@ coverage.xml
 .pytest_cache/
 cover/
 
-# Output from end2end testing
-tests/reference_failures/
-
 # Translations
 *.mo
 *.pot

.gitlab-ci.yml

@@ -0,0 +1,163 @@
+# This file is a template, and might need editing before it works on your project.
+# Official language image. Look for the different tagged releases at:
+# https://hub.docker.com/r/library/python/tags/
+image: $CI_DOCKER_REGISTRY/python:3.9
+#commands to run in the Docker container before starting each job.
+variables:
+  DOCKER_TLS_CERTDIR: ""
+
+include:
+  - template: Security/Secret-Detection.gitlab-ci.yml
+
+
+# different stages in the pipeline
+stages:
+  - Formatter
+  - test
+  - AdditionalTests
+  - Deploy
+
+formatter:
+  stage: Formatter
+  needs: []
+  script:
+    - pip install black
+    - black --check --diff --color --line-length=100 ./
+pylint:
+  stage: Formatter
+  needs: []
+  before_script:
+    - pip install pylint pylint-exit anybadge
+    - pip install -e .[dev]
+  script:
+    - mkdir ./pylint
+    - pylint ./bec_widgets --output-format=text --output=./pylint/pylint.log | tee ./pylint/pylint.log || pylint-exit $?
+    - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint.log)
+    - anybadge --label=Pylint --file=pylint/pylint.svg --value=$PYLINT_SCORE 2=red 4=orange 8=yellow 10=green
+    - echo "Pylint score is $PYLINT_SCORE"
+  artifacts:
+    paths:
+      - ./pylint/
+    expire_in: 1 week
+
+pylint-check:
+  stage: Formatter
+  needs: []
+  allow_failure: true
+  before_script:
+    - pip install pylint pylint-exit anybadge
+    - apt-get update
+    - apt-get install -y bc
+  script:
+    # Identify changed Python files
+    - if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then
+        TARGET_BRANCH_COMMIT_SHA=$(git rev-parse $CI_MERGE_REQUEST_TARGET_BRANCH_NAME);
+        CHANGED_FILES=$(git diff --name-only $SOURCE_BRANCH_COMMIT_SHA $TARGET_BRANCH_COMMIT_SHA | grep '\.py$' || true);
+      else
+        CHANGED_FILES=$(git diff --name-only $CI_COMMIT_BEFORE_SHA $CI_COMMIT_SHA | grep '\.py$' || true);
+      fi
+    - if [ -z "$CHANGED_FILES" ]; then echo "No Python files changed."; exit 0; fi
+
+    # Run pylint only on changed files
+    - mkdir ./pylint
+    - pylint $CHANGED_FILES --output-format=text . | tee ./pylint/pylint_changed_files.log || pylint-exit $?
+    - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint_changed_files.log)
+    - echo "Pylint score is $PYLINT_SCORE"
+
+    # Fail the job if the pylint score is below 9
+    - if [ "$(echo "$PYLINT_SCORE < 9" | bc)" -eq 1 ]; then echo "Your pylint score is below the acceptable threshold (9)."; exit 1; fi
+  artifacts:
+    paths:
+      - ./pylint/
+    expire_in: 1 week
+
+tests:
+  stage: test
+  needs: []
+  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
+    - pip install .[dev]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests
+    - coverage report
+    - coverage xml
+  coverage: '/(?i)total.*? (100(?:\.0+)?\%|[1-9]?\d(?:\.\d+)?\%)$/'
+  artifacts:
+    reports:
+      junit: report.xml
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage.xml
+
+#tests-3.9-pyqt5: #todo enable when we decide what qt distributions we want to support
+#  extends: "tests"
+#  stage: AdditionalTests
+#  image: $CI_DOCKER_REGISTRY/python:3.9
+#  script:
+#    - apt-get update
+#    - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+#    - pip install .[dev,pyqt5]
+#    - pytest -v --random-order ./tests
+
+tests-3.10:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DOCKER_REGISTRY/python:3.10
+  allow_failure: true
+
+
+tests-3.11:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DOCKER_REGISTRY/python:3.11
+  allow_failure: true
+
+tests-3.12:
+  extends: "tests"
+  stage: AdditionalTests
+  image: $CI_DOCKER_REGISTRY/python:3.12
+  allow_failure: true
+
+
+semver:
+  stage: Deploy
+  needs: ["tests"]
+  script:
+    - git config --global user.name "ci_update_bot"
+    - git config --global user.email "ci_update_bot@bec.ch"
+    - git checkout "$CI_COMMIT_REF_NAME"
+    - git reset --hard origin/"$CI_COMMIT_REF_NAME"
+
+    # delete all local tags
+    - git tag -l | xargs git tag -d
+    - git fetch --tags
+    - git tag
+
+    # build
+    - pip install python-semantic-release==7.* wheel
+    - export GL_TOKEN=$CI_UPDATES
+    - export REPOSITORY_USERNAME=__token__
+    - export REPOSITORY_PASSWORD=$CI_PYPI_TOKEN
+    - >
+      semantic-release publish -v DEBUG 
+      -D version_variable=./setup.py:__version__  
+      -D hvcs=gitlab 
+
+  allow_failure: false
+  rules:
+    - if: '$CI_COMMIT_REF_NAME == "master"'
+
+pages:
+  stage: Deploy
+  needs: ["semver"]
+  variables:
+    TARGET_BRANCH: $CI_COMMIT_REF_NAME
+  rules:
+    - if: '$CI_COMMIT_TAG != null'
+      variables:
+        TARGET_BRANCH: $CI_COMMIT_TAG
+    - if: '$CI_COMMIT_REF_NAME == "master"'
+  script:
+    - curl -X POST -d "branches=$CI_COMMIT_REF_NAME" -d "token=$RTD_TOKEN" https://readthedocs.org/api/v2/webhook/bec-widgets/253243/

.gitlab/issue_templates/bug_report_template.md

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

.gitlab/issue_templates/documentation_update_template.md

@@ -1,13 +1,3 @@
----
-name: Documentation update request
-about: Suggest an update to the docs
-title: '[DOCS]: '
-type: documentation
-label: documentation
-assignees: ''
-
----
-
 ## Documentation Section
 
 [Specify the section or page of the documentation that needs updating]

.gitlab/issue_templates/feature_request_template.md

@@ -1,13 +1,3 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: '[FEAT]: '
-type: feature
-label: feature
-assignees: ''
-
----
-
 ## Feature Summary
 
 [Provide a brief and clear summary of the new feature you are requesting]
@@ -47,3 +37,4 @@ assignees: ''
 ## Additional Information
 
 [Provide any additional information that might be relevant to the feature request, such as user feedback, market trends, or similar features in other products]
+

.gitlab/merge_request_templates/default.md

@@ -1,24 +1,19 @@
 ## Description
 
-[Provide a brief description of the changes introduced by this pull request.]
+[Provide a brief description of the changes introduced by this merge request.]
 
 ## Related Issues
 
-[Cite any related issues or feature requests that are addressed or resolved by this pull request. Link the associated issue, for example, with `fixes #123` or `closes #123`.]
+[Cite any related issues or feature requests that are addressed or resolved by this merge request. Use the gitlab syntax for linking issues, for example, `fixes #123` or `closes #123`.]
 
 ## Type of Change
 
 - Change 1
 - Change 2
 
-## How to test
-
-- Run unit tests
-- Open [widget] in designer and play around with the properties
-
 ## Potential side effects
 
-[Describe any potential side effects or risks of merging this PR.]
+[Describe any potential side effects or risks of merging this MR.]
 
 ## Screenshots / GIFs (if applicable)
 

.pylintrc

@@ -3,7 +3,7 @@
 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may
 # run arbitrary code.
-extension-pkg-allow-list=PyQt6, PySide6, pyqtgraph
+extension-pkg-allow-list=PyQt5, pyqtgraph
 
 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may
@@ -52,7 +52,7 @@ persistent=yes
 
 # Minimum Python version to use for version dependent checks. Will default to
 # the version used to run pylint.
-py-version=3.11
+py-version=3.9
 
 # When enabled, pylint would attempt to guess common misconfiguration and emit
 # user-friendly hints instead of false-positive error messages.

.readthedocs.yaml

@@ -7,13 +7,13 @@ version: 2
 
 # Set the version of Python and other tools you might need
 build:
-  os: ubuntu-22.04
+  os: ubuntu-20.04
   tools:
-    python: "3.11"
+    python: "3.9"
 
 # Build documentation in the docs/ directory with Sphinx
 sphinx:
-  configuration: docs/conf.py
+   configuration: docs/conf.py
 
 # If using Sphinx, optionally build your docs in additional formats such as PDF
 # formats:
@@ -21,7 +21,5 @@ sphinx:
 
 # Optionally declare the Python requirements required to build your docs
 python:
-  install:
-    - requirements: docs/requirements.txt
-    - method: pip
-      path: .[dev]
+   install:
+   - requirements: docs/requirements.txt

LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2025, Paul Scherrer Institute
+Copyright (c) 2023, bec
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

README.md

@@ -1,200 +1,73 @@
-![banner_opti](https://github.com/user-attachments/assets/44e483be-3f0d-4eb0-bd98-613157456b81)
-
 # BEC Widgets
 
-[![CI](https://github.com/bec-project/bec_widgets/actions/workflows/ci.yml/badge.svg)](https://github.com/bec-project/bec_widgets/actions/workflows/ci.yml)
-[![badge](https://img.shields.io/pypi/v/bec-widgets)](https://pypi.org/project/bec-widgets/)
-[![License](https://img.shields.io/github/license/bec-project/bec_widgets)](./LICENSE)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-[![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue?logo=python&logoColor=white)](https://www.python.org)
-[![PySide6](https://img.shields.io/badge/PySide6-blue?logo=qt&logoColor=white)](https://doc.qt.io/qtforpython/)
-[![Conventional Commits](https://img.shields.io/badge/conventional%20commits-1.0.0-yellow?logo=conventionalcommits&logoColor=white)](https://conventionalcommits.org)
-[![codecov](https://codecov.io/gh/bec-project/bec_widgets/graph/badge.svg?token=0Z9IQRJKMY)](https://codecov.io/gh/bec-project/bec_widgets)
-
-A modular PySide6(Qt6) toolkit for [BEC (Beamline Experiment Control)](https://github.com/bec-project/bec). Create
-high-performance, dockable GUIs to move devices, run scans, and stream live or disk data—powered by Redis and a modular
-plugin system.
-
-## Highlights
-
-- **No-code first** — For ~90% of day-to-day workflows, you can compose, operate, and save workspaces **without writing
-  a single line of code**. Just launch, drag widgets, and do your experiment.
-- **Flexible layout composition** — Build complex experiment GUIs in seconds with the `BECDockArea`: drag‑dock, tab,
-  split, and export profiles/workspaces for reuse.
-- **CLI / scripting** — Control your beamline experiment from the command line a robust RPC layer using
-  `BECIPythonClient`.
-- **Designer integration** — Use Qt Designer plugins to drop BEC widgets next to any Qt control, then launch the `.ui`
-  with the custom BEC loader for a zero‑glue workflow.
-- **Operational integration** — Widgets stay in sync with your running BEC/Redis as the single source of truth:
-  Subscribe to events from BEC and create dynamically updating UIs. BECWidgets also grants you easy access the
-  acquisition history.
-- **Extensible by design** — Build new widgets with minimal boilerplate using `BECWidget` and `BECDispatcher` for BEC data and
-  messaging. Use the generator command to scaffold RPC interfaces and Designer plugin stubs; beamline plugins can extend
-  or override behavior as needed.
-
-## Table of Contents
-
-- [Installation](#installation)
-- [Features](#features)
-    - [1. Dock area interface: build GUIs in seconds](#1-dock-area-interface-build-guis-in-seconds)
-    - [2. Qt Designer plugins + BEC Launcher (no glue)](#2-qt-designer-plugins--bec-launcher-no-glue)
-    - [3. Robust RPC from CLI & remote scripting](#3-robust-rpc-from-cli--remote-scripting)
-    - [4. Rapid development (extensible by design)](#4-rapid-development-extensible-by-design)
-- [Widget Library](#widget-library)
-- [Documentation](#documentation)
-- [License](#license)
-
+BEC Widgets is a GUI framework designed for interaction with [BEC (Beamline Experiment Control)](https://gitlab.psi.ch/bec/bec).
 ## Installation
 
-Use any of the following setups:
-
-### Stable release
-
 Use the package manager [pip](https://pip.pypa.io/en/stable/) to install BEC Widgets:
 
 ```bash
-pip install bec_widgets
+pip install bec-widgets
 ```
 
-### From source (recommended for development)
-
 For development purposes, you can clone the repository and install the package locally in editable mode:
 
 ```bash
-git clone https://github.com/bec-project/bec_widgets.git
-cd bec_widgets
+git clone https://gitlab.psi.ch/bec/bec-widgets
+cd bec-widgets
 pip install -e .[dev]
 ```
 
-## Features
+BEC Widgets currently supports both PyQt5 and PyQt6. By default, PyQt6 is installed.
 
-### 1. Dock area interface: build GUIs in seconds
+To select a specific Python Qt distribution, install the package with an additional tag:
 
-The fastest way to explore BEC Widgets. Launch the BEC IPython client with simply `bec` in terminal and the **BECDockArea** opens as the default UI:
-drag widgets, dock/tab/split panes, and explore. Everything is live—widgets auto-connect to BEC/Redis, so you can
-operate immediately and refine later with RPC or Designer if needed.
-
-![dock_area_example](https://github.com/user-attachments/assets/219a2806-19a8-4a07-9734-b7b554850833)
-
-### 2. Qt Designer plugins + BEC Launcher (no glue)
-
-All BEC Widgets ship as **Qt Designer plugins** with our custom Qt Designer launchable by `bec-designer`. Design your UI
-visually in Designer, save a `.ui`, then launch it with
-the **BEC Launcher**—no glue code. Widgets auto‑connect to BEC/Redis on startup, so your UI is operational immediately.
-
-![designer_opti](https://github.com/user-attachments/assets/fed4843c-1cce-438a-b41f-6636fa5e1545)
-
-### 3. Robust RPC from CLI & remote scripting
-
-Operate and automate BEC Widgets directly from the `BECIPythonClient`. Create or attach to GUIs, address any sub-widget
-via a simple hierarchical API with tab-completion, and script event-driven behavior that reacts to BEC (scan lifecycle,
-active devices, topics)—so your UI can be heavily automated.
-
-- Create & control GUIs: launch, load profiles, open/close panels, tweak properties—all from the shell.
-- Hierarchical addressing: navigate widgets and sub-widgets with discoverable paths and tab-completion.
-- Event scripting: subscribe to BEC events (e.g., scan start/finish, device readiness, topic updates) and trigger
-  actions,switch profiles, open diagnostic views, or start specific scans.
-- Remote & headless: run automation on analysis nodes or from notebooks without a local GUI process.
-- Plays with no-code: Use the Dock Area / BEC Designer to set up the layout and add automation with RPC when needed.
-
-![rpc_opti](https://github.com/user-attachments/assets/666be7fb-9a0d-44c2-8d44-2f9d1dae4497)
-
-### 4. Rapid development (extensible by design)
-
-Build new widgets fast: Inherit from `BECWidget`, list your RPC methods in `USER_ACCESS`, and use `bec_dispatcher` to
-bind endpoints. Then run `bw-generate-cli --target <your-plugin-repo>`. This generates the RPC CLI bindings and a Qt
-Designer plugin that are immediately usable with your BEC setup. Widgets
-come online with live BEC/Redis wiring out of the box. 
-
-<details>
-<summary> View code: Example Widget </summary>
-
-```python
-    from typing import Literal
-
-from qtpy.QtWidgets import QWidget, QLabel, QPushButton, QHBoxLayout, QVBoxLayout, QApplication
-from qtpy.QtCore import Slot
-
-from bec_lib.endpoints import MessageEndpoints
-from bec_widgets import BECWidget, SafeSlot
-
-
-class SimpleMotorWidget(BECWidget, QWidget):
-    USER_ACCESS = ["move"]
-
-    def __init__(self, parent=None, motor_name="samx", step=5.0, **kwargs):
-        super().__init__(parent=parent, **kwargs)
-        self.motor_name = motor_name
-        self.step = float(step)
-
-        self.get_bec_shortcuts()
-
-        self.value_label = QLabel(f"{self.motor_name}: —")
-        self.btn_left = QPushButton("◀︎ -5")
-        self.btn_right = QPushButton("+5 ▶︎")
-
-        row = QHBoxLayout()
-        row.addWidget(self.btn_left)
-        row.addWidget(self.btn_right)
-
-        col = QVBoxLayout(self)
-        col.addWidget(self.value_label)
-        col.addLayout(row)
-
-        self.btn_left.clicked.connect(lambda: self.move("left", self.step))
-        self.btn_right.clicked.connect(lambda: self.move("right", self.step))
-
-        self.bec_dispatcher.connect_slot(self.on_readback, MessageEndpoints.device_readback(self.motor_name))
-
-    @SafeSlot(dict, dict)
-    def on_readback(self, data: dict, meta: dict):
-        current_value = data.get("signals").get(self.motor_name).get('value')
-        self.value_label.setText(f"{self.motor_name}: {current_value:.3f}")
-
-    @Slot(str, float)
-    def move(self, direction: Literal["left", "right"] = "left", step: float = 5.0):
-        if direction == "left":
-            self.dev[self.motor_name].move(-step, relative=True)
-        else:
-            self.dev[self.motor_name].move(step, relative=True)
-
-
-if __name__ == "__main__":
-    import sys
-
-    app = QApplication(sys.argv)
-    w = SimpleMotorWidget(motor_name="samx", step=5.0)
-    w.setWindowTitle("MotorJogWidget")
-    w.resize(280, 90)
-    w.show()
-    sys.exit(app.exec_())
+```bash
+pip install bec-widgets[pyqt6]
 ```
+or 
 
-</details>
-
-## Widget Library
-
-A large and growing catalog—plug, configure, run:
-
-### Plotting
-
-Waveform, MultiWaveform, and Image/Heatmap widgets deliver responsive plots with crosshairs and ROIs for live and
-history data.
-
-<img width="1108" height="838" alt="plotting_hr" src="https://github.com/user-attachments/assets/f50462a5-178d-44d4-aee5-d378c74b107b" />
-
-### Scan orchestration and motion control.
-
-Start and stop scans, track progress, reuse parameter presets, and browse history from a focused control surface.
-Positioner boxes and tweak controls handle precise moves, homing, and calibration for day‑to‑day alignment.
-
-<img width="1496" height="1388" alt="control" src="https://github.com/user-attachments/assets/d4fb2e2e-04f9-4621-8087-790680797620" />
-
+```bash
+pip install bec-widgets[pyqt5]
+```
 ## Documentation
 
-Documentation of BEC Widgets can be found [here](https://bec-widgets.readthedocs.io/en/latest/). The documentation of
-the BEC can be found [here](https://bec.readthedocs.io/en/latest/).
+Documentation of BEC Widgets can be found [here](https://bec-widgets.readthedocs.io/en/latest/). The documentation of the BEC can be found [here](https://beamline-experiment-control.readthedocs.io/en/latest/).
+
+## Contributing
+
+All commits should use the Angular commit scheme:
+
+> #### <a name="commit-header"></a>Angular Commit Message Header
+> 
+> ```
+> <type>(<scope>): <short summary>
+>   │       │             │
+>   │       │             └─⫸ Summary in present tense. Not capitalized. No period at the end.
+>   │       │
+>   │       └─⫸ Commit Scope: animations|bazel|benchpress|common|compiler|compiler-cli|core|
+>   │                          elements|forms|http|language-service|localize|platform-browser|
+>   │                          platform-browser-dynamic|platform-server|router|service-worker|
+>   │                          upgrade|zone.js|packaging|changelog|docs-infra|migrations|ngcc|ve|
+>   │                          devtools
+>   │
+>   └─⫸ Commit Type: build|ci|docs|feat|fix|perf|refactor|test
+> ```
+> 
+> The `<type>` and `<summary>` fields are mandatory, the `(<scope>)` field is optional.
+
+> ##### Type
+> 
+> Must be one of the following:
+> 
+> * **build**: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
+> * **ci**: Changes to our CI configuration files and scripts (examples: CircleCi, SauceLabs)
+> * **docs**: Documentation only changes
+> * **feat**: A new feature
+> * **fix**: A bug fix
+> * **perf**: A code change that improves performance
+> * **refactor**: A code change that neither fixes a bug nor adds a feature
+> * **test**: Adding missing tests or correcting existing tests
 
 ## License
 
-[BSD-3-Clause](https://choosealicense.com/licenses/bsd-3-clause/)
+[BSD-3-Clause](https://choosealicense.com/licenses/bsd-3-clause/)

THIRD-PARTY-LICENCES

@@ -1,28 +0,0 @@
-While BEC Widgets is shipped with BSD-3-Clause license, it includes third-party components with different licenses. Below is a list of these components along with their respective licenses.
-
-Core Dependencies:
-- BEC: BSD-3-Clause License, see [here](https://github.com/bec-project/bec/blob/main/LICENSE)
-- black: MIT License, see [here](https://github.com/psf/black/blob/main/LICENSE)
-- isort: MIT License, see [here](https://github.com/PyCQA/isort/blob/main/LICENSE)
-- pydantic: MIT License, see [here](https://github.com/pydantic/pydantic/blob/main/LICENSE)
-- pyqtgraph: MIT License, see [here](https://github.com/pyqtgraph/pyqtgraph/blob/master/LICENSE.txt)
-- PySide6: LGPLv3 License, see [here](https://doc.qt.io/qtforpython/licenses.html)
-- qtconsole: BSD-3-Clause License, see [here](https://github.com/spyder-ide/qtconsole/blob/main/LICENSE)
-- qtpy: MIT License, see [here](https://github.com/spyder-ide/qtpy/blob/master/LICENSE.txt)
-- qtmonaco: BSD-3-Clause License, see [here](https://github.com/bec-project/qtmonaco/blob/main/LICENSE)
-- thefuzz: MIT License, see [here](https://github.com/seatgeek/thefuzz/blob/master/LICENSE.txt)
-
-
-Additional Dependencies (Testing/Development):
-- coverage: Apache License 2.0, see [here](https://github.com/coveragepy/coveragepy/blob/main/LICENSE.txt)
-- fakeredis: BSD-3-Clause License, see [here](https://github.com/cunla/fakeredis-py/blob/master/LICENSE)
-- pytest-bec-e2e: BSD-3-Clause License, see [here](https://github.com/bec-project/bec/blob/main/LICENSE)
-- pytest-qt: MIT License, see [here](https://github.com/pytest-dev/pytest-qt/blob/master/LICENSE)
-- pytest-random-order: MIT License, see [here](https://github.com/pytest-dev/pytest-random-order/blob/main/LICENSE)
-- pytest-timeout: MIT License, see [here](https://github.com/pytest-dev/pytest-timeout/blob/main/LICENSE)
-- pytest-xvfb: MIT License, see [here](https://github.com/The-Compiler/pytest-xvfb/blob/master/LICENSE)
-- pytest: MIT License, see [here](https://github.com/pytest-dev/pytest/blob/main/LICENSE)
-- pytest-cov: MIT License, see [here](https://github.com/pytest-dev/pytest-cov/blob/main/LICENSE)
-- watchdog: Apache License 2.0, see [here](https://github.com/gorakhargosh/watchdog/blob/master/LICENSE)
-- pre_commit: MIT License, see [here](https://github.com/pre-commit/pre-commit/blob/main/LICENSE)
-

bec_widgets/__init__.py

@@ -1,19 +0,0 @@
-import os
-import sys
-
-import bec_widgets.widgets.containers.qt_ads as QtAds
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
-
-if sys.platform.startswith("linux"):
-    qt_platform = os.environ.get("QT_QPA_PLATFORM", "")
-    if qt_platform != "offscreen":
-        os.environ["QT_QPA_PLATFORM"] = "xcb"
-
-# Default QtAds configuration
-QtAds.CDockManager.setConfigFlag(QtAds.CDockManager.eConfigFlag.FocusHighlighting, True)
-QtAds.CDockManager.setConfigFlag(
-    QtAds.CDockManager.eConfigFlag.RetainTabSizeWhenCloseButtonHidden, True
-)
-
-__all__ = ["BECWidget", "SafeSlot", "SafeProperty"]

bec_widgets/applications/bw_launch.py

@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal
-
-from bec_lib import bec_logger
-
-from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
-from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
-
-logger = bec_logger.logger
-
-
-def dock_area(
-    object_name: str | None = None, startup_profile: str | Literal["restore", "skip"] | None = None
-) -> BECDockArea:
-    """
-    Create an advanced dock area using Qt Advanced Docking System.
-
-    Args:
-        object_name(str): The name of the advanced dock area.
-        startup_profile(str | Literal["restore", "skip"] | None): Startup mode for
-            the workspace:
-              - None: start empty
-              - "restore": restore last used profile
-              - "skip": do not initialize profile state
-              - "<name>": load specific profile
-
-    Returns:
-        BECDockArea: The created advanced dock area.
-
-    """
-
-    widget = BECDockArea(
-        object_name=object_name,
-        root_widget=True,
-        profile_namespace="bec",
-        startup_profile=startup_profile,
-    )
-    logger.info(f"Created advanced dock area with startup_profile: {startup_profile}")
-    return widget
-
-
-def auto_update_dock_area(object_name: str | None = None) -> AutoUpdates:
-    """
-    Create a dock area with auto update enabled.
-
-    Args:
-        object_name(str): The name of the dock area.
-
-    Returns:
-        BECDockArea: The created dock area.
-    """
-    _auto_update = AutoUpdates(object_name=object_name)
-    return _auto_update

bec_widgets/applications/launch_window.py

@@ -1,716 +0,0 @@
-from __future__ import annotations
-
-import os
-import xml.etree.ElementTree as ET
-from typing import TYPE_CHECKING, Callable
-
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import Qt, Signal  # type: ignore
-from qtpy.QtGui import QFontMetrics, QPainter, QPainterPath, QPixmap
-from qtpy.QtWidgets import (
-    QApplication,
-    QComboBox,
-    QFileDialog,
-    QHBoxLayout,
-    QLabel,
-    QPushButton,
-    QSizePolicy,
-    QSpacerItem,
-    QWidget,
-)
-
-import bec_widgets
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets
-from bec_widgets.utils.container_utils import WidgetContainerUtils
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.name_utils import pascal_to_snake
-from bec_widgets.utils.plugin_utils import get_plugin_auto_updates
-from bec_widgets.utils.round_frame import RoundedFrame
-from bec_widgets.utils.screen_utils import apply_window_geometry, centered_geometry_for_app
-from bec_widgets.utils.toolbars.toolbar import ModularToolBar
-from bec_widgets.utils.ui_loader import UILoader
-from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
-from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
-from bec_widgets.widgets.containers.dock_area.profile_utils import get_last_profile, list_profiles
-from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow, BECMainWindowNoRPC
-from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
-
-if TYPE_CHECKING:  # pragma: no cover
-    from qtpy.QtCore import QObject
-
-    from bec_widgets.utils.bec_widget import BECWidget
-
-logger = bec_logger.logger
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
-START_EMPTY_PROFILE_OPTION = "Start Empty (No Profile)"
-
-
-class LaunchTile(RoundedFrame):
-    DEFAULT_SIZE = (250, 300)
-    open_signal = Signal()
-
-    def __init__(
-        self,
-        parent: QObject | None = None,
-        icon_path: str | None = None,
-        top_label: str | None = None,
-        main_label: str | None = None,
-        description: str | None = None,
-        show_selector: bool = False,
-        tile_size: tuple[int, int] | None = None,
-    ):
-        super().__init__(parent=parent, orientation="vertical")
-
-        # Provide a per‑instance TILE_SIZE so the class can compute layout
-        if tile_size is None:
-            tile_size = self.DEFAULT_SIZE
-        self.tile_size = tile_size
-
-        self.icon_label = QLabel(parent=self)
-        self.icon_label.setFixedSize(100, 100)
-        self.icon_label.setScaledContents(True)
-        pixmap = QPixmap(icon_path)
-        if not pixmap.isNull():
-            size = 100
-            circular_pixmap = QPixmap(size, size)
-            circular_pixmap.fill(Qt.transparent)
-
-            painter = QPainter(circular_pixmap)
-            painter.setRenderHints(QPainter.RenderHint.Antialiasing, True)
-            path = QPainterPath()
-            path.addEllipse(0, 0, size, size)
-            painter.setClipPath(path)
-            pixmap = pixmap.scaled(
-                size,
-                size,
-                Qt.AspectRatioMode.KeepAspectRatio,
-                Qt.TransformationMode.SmoothTransformation,
-            )
-            painter.drawPixmap(0, 0, pixmap)
-            painter.end()
-
-            self.icon_label.setPixmap(circular_pixmap)
-        self.layout.addWidget(self.icon_label, alignment=Qt.AlignmentFlag.AlignCenter)
-
-        # Top label
-        self.top_label = QLabel(top_label.upper())
-        font_top = self.top_label.font()
-        font_top.setPointSize(10)
-        self.top_label.setFont(font_top)
-        self.layout.addWidget(self.top_label, alignment=Qt.AlignmentFlag.AlignCenter)
-
-        # Main label
-        self.main_label = QLabel(main_label)
-
-        # Desired default appearance
-        font_main = self.main_label.font()
-        font_main.setPointSize(14)
-        font_main.setBold(True)
-        self.main_label.setFont(font_main)
-        self.main_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-
-        # Shrink font if the default would wrap on this platform / DPI
-        content_width = (
-            self.tile_size[0]
-            - self.layout.contentsMargins().left()
-            - self.layout.contentsMargins().right()
-        )
-        self._fit_label_to_width(self.main_label, content_width)
-
-        # Give every tile the same reserved height for the title so the
-        # description labels start at an identical y‑offset.
-        self.main_label.setFixedHeight(QFontMetrics(self.main_label.font()).height() + 2)
-
-        self.layout.addWidget(self.main_label)
-
-        self.spacer_top = QSpacerItem(0, 10, QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
-        self.layout.addItem(self.spacer_top)
-
-        # Description
-        self.description_label = QLabel(description)
-        self.description_label.setWordWrap(True)
-        self.description_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        self.layout.addWidget(self.description_label)
-
-        # Selector
-        if show_selector:
-            self.selector = QComboBox(self)
-            self.layout.addWidget(self.selector)
-        else:
-            self.selector = None
-
-        self.spacer_bottom = QSpacerItem(
-            0, 0, QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Expanding
-        )
-        self.layout.addItem(self.spacer_bottom)
-
-        # Action button
-        self.action_button = QPushButton("Open")
-        self.action_button.setStyleSheet("""
-        QPushButton {
-            background-color: #007AFF;
-            border: none;
-            padding: 8px 16px;
-            color: white;
-            border-radius: 6px;
-            font-weight: bold;
-        }
-        QPushButton:hover {
-            background-color: #005BB5;
-        }
-        """)
-        self.layout.addWidget(self.action_button, alignment=Qt.AlignmentFlag.AlignCenter)
-
-    def _fit_label_to_width(self, label: QLabel, max_width: int, min_pt: int = 10):
-        """
-        Fit the label text to the specified maximum width by adjusting the font size.
-
-        Args:
-            label(QLabel): The label to adjust.
-            max_width(int): The maximum width the label can occupy.
-            min_pt(int): The minimum font point size to use.
-        """
-        font = label.font()
-        for pt in range(font.pointSize(), min_pt - 1, -1):
-            font.setPointSize(pt)
-            metrics = QFontMetrics(font)
-            if metrics.horizontalAdvance(label.text()) <= max_width:
-                label.setFont(font)
-                label.setWordWrap(False)
-                return
-        # If nothing fits, fall back to eliding
-        metrics = QFontMetrics(font)
-        label.setFont(font)
-        label.setWordWrap(False)
-        label.setText(metrics.elidedText(label.text(), Qt.TextElideMode.ElideRight, max_width))
-
-
-class LaunchWindow(BECMainWindow):
-    RPC = True
-    PLUGIN = False
-    TILE_SIZE = (250, 300)
-    DEFAULT_LAUNCH_SIZE = (800, 600)
-    USER_ACCESS = ["show_launcher", "hide_launcher"]
-
-    def __init__(
-        self,
-        parent=None,
-        gui_id: str = None,
-        window_title="BEC Launcher",
-        launch_gui_class: str = None,
-        launch_gui_id: str = None,
-        *args,
-        **kwargs,
-    ):
-        super().__init__(parent=parent, gui_id=gui_id, window_title=window_title, **kwargs)
-
-        self.app = QApplication.instance()
-        self.tiles: dict[str, LaunchTile] = {}
-        # Track the smallest main‑label font size chosen so far
-        self._min_main_label_pt: int | None = None
-
-        # Toolbar
-        self.dark_mode_button = DarkModeButton(parent=self, toolbar=True)
-        self.toolbar = ModularToolBar(parent=self)
-        self.addToolBar(Qt.TopToolBarArea, self.toolbar)
-        self.spacer = QWidget(self)
-        self.spacer.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
-        self.toolbar.addWidget(self.spacer)
-        self.toolbar.addWidget(self.dark_mode_button)
-
-        # Main Widget
-        self.central_widget = QWidget(self)
-        self.central_widget.layout = QHBoxLayout(self.central_widget)
-        self.setCentralWidget(self.central_widget)
-
-        self.register_tile(
-            name="dock_area",
-            icon_path=os.path.join(MODULE_PATH, "assets", "app_icons", "bec_widgets_icon.png"),
-            top_label="Get started",
-            main_label="BEC Advanced Dock Area",
-            description="Flexible application for managing modular widgets and user profiles.",
-            action_button=self._open_dock_area,
-            show_selector=True,
-            selector_items=list_profiles("bec"),
-        )
-        self._refresh_dock_area_profiles(preserve_selection=False)
-
-        self.available_auto_updates: dict[str, type[AutoUpdates]] = (
-            self._update_available_auto_updates()
-        )
-        self.register_tile(
-            name="auto_update",
-            icon_path=os.path.join(MODULE_PATH, "assets", "app_icons", "auto_update.png"),
-            top_label="Get automated",
-            main_label="BEC Auto Update Dock Area",
-            description="Dock area with auto update functionality for BEC widgets plotting.",
-            action_button=self._open_auto_update,
-            show_selector=True,
-            selector_items=list(self.available_auto_updates.keys()) + ["Default"],
-        )
-
-        self.register_tile(
-            name="custom_ui_file",
-            icon_path=os.path.join(MODULE_PATH, "assets", "app_icons", "ui_loader_tile.png"),
-            top_label="Get customized",
-            main_label="Launch Custom UI File",
-            description="GUI application with custom UI file.",
-            action_button=self._open_custom_ui_file,
-            show_selector=False,
-        )
-
-        # plugin widgets
-        self.available_widgets: dict[str, type[BECWidget]] = get_all_plugin_widgets().as_dict()
-        if self.available_widgets:
-            plugin_repo_name = next(iter(self.available_widgets.values())).__module__.split(".")[0]
-            plugin_repo_name = plugin_repo_name.removesuffix("_bec").upper()
-            self.register_tile(
-                name="widget",
-                icon_path=os.path.join(
-                    MODULE_PATH, "assets", "app_icons", "widget_launch_tile.png"
-                ),
-                top_label="Get quickly started",
-                main_label=f"Launch a {plugin_repo_name} Widget",
-                description=f"GUI application with one widget from the {plugin_repo_name} repository.",
-                action_button=self._open_widget,
-                show_selector=True,
-                selector_items=list(self.available_widgets.keys()),
-            )
-
-        self._update_theme()
-
-        self.register = RPCRegister()
-        self.register.callbacks.append(self._turn_off_the_lights)
-        self.register.broadcast()
-
-        if launch_gui_class and launch_gui_id:
-            # If a specific gui class is provided, launch it and hide the launcher
-            self.launch(launch_gui_class, name=launch_gui_id)
-            self.hide()
-
-    def register_tile(
-        self,
-        name: str,
-        icon_path: str | None = None,
-        top_label: str | None = None,
-        main_label: str | None = None,
-        description: str | None = None,
-        action_button: Callable | None = None,
-        show_selector: bool = False,
-        selector_items: list[str] | None = None,
-    ):
-        """
-        Register a tile in the launcher window.
-
-        Args:
-            name(str): The name of the tile.
-            icon_path(str): The path to the icon.
-            top_label(str): The top label of the tile.
-            main_label(str): The main label of the tile.
-            description(str): The description of the tile.
-            action_button(callable): The action to be performed when the button is clicked.
-            show_selector(bool): Whether to show a selector or not.
-            selector_items(list[str]): The items to be shown in the selector.
-        """
-
-        tile = LaunchTile(
-            icon_path=icon_path,
-            top_label=top_label,
-            main_label=main_label,
-            description=description,
-            show_selector=show_selector,
-            tile_size=self.TILE_SIZE,
-        )
-        tile.setFixedWidth(self.TILE_SIZE[0])
-        tile.setMinimumHeight(self.TILE_SIZE[1])
-        tile.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.MinimumExpanding)
-        if action_button:
-            tile.action_button.clicked.connect(action_button)
-        if show_selector and selector_items:
-            tile.selector.addItems(selector_items)
-        self.central_widget.layout.addWidget(tile)
-
-        # keep all tiles' main labels at a unified point size
-        current_pt = tile.main_label.font().pointSize()
-        if self._min_main_label_pt is None or current_pt < self._min_main_label_pt:
-            # New global minimum – shrink every existing tile to this size
-            self._min_main_label_pt = current_pt
-            for t in self.tiles.values():
-                f = t.main_label.font()
-                f.setPointSize(self._min_main_label_pt)
-                t.main_label.setFont(f)
-                t.main_label.setFixedHeight(QFontMetrics(f).height() + 2)
-        elif current_pt > self._min_main_label_pt:
-            # Tile is larger than global minimum – shrink it to match
-            f = tile.main_label.font()
-            f.setPointSize(self._min_main_label_pt)
-            tile.main_label.setFont(f)
-            tile.main_label.setFixedHeight(QFontMetrics(f).height() + 2)
-
-        self.tiles[name] = tile
-
-    def _refresh_dock_area_profiles(self, preserve_selection: bool = True) -> None:
-        """
-        Refresh the dock-area profile selector, optionally preserving the selection.
-        Defaults to Start Empty when no valid selection can be preserved.
-
-        Args:
-            preserve_selection(bool): Whether to preserve the current selection or not.
-        """
-        tile = self.tiles.get("dock_area")
-        if tile is None or tile.selector is None:
-            return
-
-        selector = tile.selector
-        selected_text = (
-            selector.currentText().strip() if preserve_selection and selector.count() > 0 else ""
-        )
-
-        profiles = list_profiles("bec")
-        selector_items = [START_EMPTY_PROFILE_OPTION, *profiles]
-        selector.blockSignals(True)
-        selector.clear()
-        for profile in selector_items:
-            selector.addItem(profile)
-
-        if selected_text:
-            # Try to preserve the current selection
-            idx = selector.findText(selected_text, Qt.MatchFlag.MatchExactly)
-            if idx >= 0:
-                selector.setCurrentIndex(idx)
-            else:
-                # Selection no longer exists, fall back to default startup selection.
-                self._set_selector_to_default_profile(selector, profiles)
-        else:
-            # No selection to preserve, use default startup selection.
-            self._set_selector_to_default_profile(selector, profiles)
-        selector.blockSignals(False)
-
-    def _set_selector_to_default_profile(self, selector: QComboBox, profiles: list[str]) -> None:
-        """
-        Set the selector default.
-
-        Preference order:
-            1) Start Empty option (if available)
-            2) Last used profile
-            3) First available profile
-
-        Args:
-            selector(QComboBox): The combobox to set.
-            profiles(list[str]): List of available profiles.
-        """
-        start_empty_idx = selector.findText(START_EMPTY_PROFILE_OPTION, Qt.MatchFlag.MatchExactly)
-        if start_empty_idx >= 0:
-            selector.setCurrentIndex(start_empty_idx)
-            return
-
-        # Try to get last used profile
-        last_profile = get_last_profile(namespace="bec")
-        if last_profile and last_profile in profiles:
-            idx = selector.findText(last_profile, Qt.MatchFlag.MatchExactly)
-            if idx >= 0:
-                selector.setCurrentIndex(idx)
-                return
-
-        # If nothing else, select first item
-        if selector.count() > 0:
-            selector.setCurrentIndex(0)
-
-    def launch(
-        self,
-        launch_script: str,
-        name: str | None = None,
-        geometry: tuple[int, int, int, int] | None = None,
-        **kwargs,
-    ) -> QWidget | None:
-        """Launch the specified script. If the launch script creates a QWidget, it will be
-        embedded in a BECMainWindow. If the launch script creates a BECMainWindow, it will be shown
-        as a separate window.
-
-        Args:
-            launch_script(str): The name of the script to be launched.
-            name(str): The name of the dock area.
-            geometry(tuple): The geometry parameters to be passed to the dock area.
-        Returns:
-            QWidget: The created dock area.
-        """
-        from bec_widgets.applications import bw_launch
-
-        with RPCRegister.delayed_broadcast() as rpc_register:
-            if geometry is None and launch_script != "custom_ui_file":
-                geometry = self._default_launch_geometry()
-            existing_dock_areas = rpc_register.get_names_of_rpc_by_class_type(BECDockArea)
-            if name is not None:
-                WidgetContainerUtils.raise_for_invalid_name(name)
-                # If name already exists, generate a unique one with counter suffix
-                if name in existing_dock_areas:
-                    name = WidgetContainerUtils.generate_unique_name(name, existing_dock_areas)
-            else:
-                name = "dock_area"
-                name = WidgetContainerUtils.generate_unique_name(name, existing_dock_areas)
-
-            if launch_script is None:
-                launch_script = "dock_area"
-            if not isinstance(launch_script, str):
-                raise ValueError(f"Launch script must be a string, but got {type(launch_script)}.")
-
-            if launch_script == "custom_ui_file":
-                ui_file = kwargs.pop("ui_file", None)
-                if not ui_file:
-                    return None
-                return self._launch_custom_ui_file(ui_file)
-
-            if launch_script == "auto_update":
-                auto_update = kwargs.pop("auto_update", None)
-                return self._launch_auto_update(auto_update, geometry=geometry)
-
-            if launch_script == "widget":
-                widget = kwargs.pop("widget", None)
-                if widget is None:
-                    raise ValueError("Widget name must be provided.")
-                return self._launch_widget(widget, geometry=geometry)
-
-            launch = getattr(bw_launch, launch_script, None)
-            if launch is None:
-                raise ValueError(f"Launch script {launch_script} not found.")
-
-            result_widget = launch(name, **kwargs)
-            # TODO Should we simply use the specified name as title here?
-            result_widget.window().setWindowTitle(f"BEC - {name}")
-            logger.info(f"Created new dock area: {name}")
-
-            if isinstance(result_widget, BECMainWindow):
-                apply_window_geometry(result_widget, geometry)
-                result_widget.show()
-            else:
-                window = BECMainWindowNoRPC()
-                window.setCentralWidget(result_widget)
-                window.setWindowTitle(f"BEC - {result_widget.objectName()}")
-                apply_window_geometry(window, geometry)
-                window.show()
-            return result_widget
-
-    def _launch_custom_ui_file(self, ui_file: str | None) -> BECMainWindow:
-        """
-        Load a custom .ui file. If the top-level widget is a MainWindow subclass,
-        instantiate it directly; otherwise, embed it in a UILaunchWindow.
-        """
-        if ui_file is None:
-            raise ValueError("UI file must be provided for custom UI file launch.")
-        filename = os.path.basename(ui_file).split(".")[0]
-
-        WidgetContainerUtils.raise_for_invalid_name(filename)
-
-        # Parse the UI to detect top-level widget class
-        tree = ET.parse(ui_file)
-        root = tree.getroot()
-        # Check if the top-level widget is a QMainWindow
-        widget = root.find("widget")
-        if widget is None:
-            raise ValueError("No widget found in the UI file.")
-
-        # Load the UI into a widget
-        loader = UILoader(None)
-        loaded = loader.loader(ui_file)
-
-        # Display the UI in a BECMainWindow
-        if isinstance(loaded, BECMainWindow):
-            window = loaded
-            window.object_name = filename
-        else:
-            window = BECMainWindow(object_name=filename)
-            window.setCentralWidget(loaded)
-
-        window.setWindowTitle(f"BEC - {filename}")
-        apply_window_geometry(window, None)
-        window.show()
-        logger.info(f"Launched custom UI: {filename}, type: {type(window).__name__}")
-        return window
-
-    def _launch_auto_update(
-        self, auto_update: str, geometry: tuple[int, int, int, int] | None = None
-    ) -> AutoUpdates:
-        if auto_update in self.available_auto_updates:
-            auto_update_cls = self.available_auto_updates[auto_update]
-            window = auto_update_cls()
-        else:
-
-            auto_update = "auto_updates"
-            window = AutoUpdates()
-
-        window.resize(window.minimumSizeHint())
-        window.setWindowTitle(f"BEC - {window.objectName()}")
-        apply_window_geometry(window, geometry)
-        window.show()
-        return window
-
-    def _launch_widget(
-        self, widget: type[BECWidget], geometry: tuple[int, int, int, int] | None = None
-    ) -> QWidget:
-        name = pascal_to_snake(widget.__name__)
-
-        WidgetContainerUtils.raise_for_invalid_name(name)
-
-        window = BECMainWindowNoRPC()
-
-        widget_instance = widget(root_widget=True, object_name=name)
-        assert isinstance(widget_instance, QWidget)
-
-        window.setCentralWidget(widget_instance)
-        window.resize(window.minimumSizeHint())
-        window.setWindowTitle(f"BEC - {widget_instance.objectName()}")
-        apply_window_geometry(window, geometry)
-        window.show()
-        return window
-
-    def apply_theme(self, theme: str):
-        """
-        Change the theme of the application.
-        """
-        for tile in self.tiles.values():
-            tile.apply_theme(theme)
-
-        super().apply_theme(theme)
-
-    def _open_auto_update(self):
-        """
-        Open the auto update window.
-        """
-        if self.tiles["auto_update"].selector is None:
-            auto_update = None
-        else:
-            auto_update = self.tiles["auto_update"].selector.currentText()
-            if auto_update == "Default":
-                auto_update = None
-        return self.launch("auto_update", auto_update=auto_update)
-
-    def _open_dock_area(self):
-        """
-        Open Advanced Dock Area using the selected profile.
-        """
-        tile = self.tiles.get("dock_area")
-        if tile is None or tile.selector is None:
-            startup_profile = None
-        else:
-            selection = tile.selector.currentText().strip()
-            if selection == START_EMPTY_PROFILE_OPTION:
-                startup_profile = None
-            else:
-                startup_profile = selection if selection else None
-        return self.launch("dock_area", startup_profile=startup_profile)
-
-    def _open_widget(self):
-        """
-        Open a widget from the available widgets.
-        """
-        if self.tiles["widget"].selector is None:
-            return
-        widget = self.tiles["widget"].selector.currentText()
-        if widget not in self.available_widgets:
-            raise ValueError(f"Widget {widget} not found in available widgets.")
-        return self.launch("widget", widget=self.available_widgets[widget])
-
-    def _default_launch_geometry(self) -> tuple[int, int, int, int] | None:
-        width, height = self.DEFAULT_LAUNCH_SIZE
-        return centered_geometry_for_app(width=width, height=height)
-
-    @SafeSlot(popup_error=True)
-    def _open_custom_ui_file(self):
-        """
-        Open a file dialog to select a custom UI file and launch it.
-        """
-        ui_file, _ = QFileDialog.getOpenFileName(
-            self, "Select UI File", "", "UI Files (*.ui);;All Files (*)"
-        )
-        self.launch("custom_ui_file", ui_file=ui_file)
-
-    @staticmethod
-    def _update_available_auto_updates() -> dict[str, type[AutoUpdates]]:
-        """
-        Load all available auto updates from the plugin repository.
-        """
-        try:
-            auto_updates = get_plugin_auto_updates()
-            logger.info(f"Available auto updates: {auto_updates.keys()}")
-        except Exception as exc:
-            logger.error(f"Failed to load auto updates: {exc}")
-            return {}
-        return auto_updates
-
-    def show_launcher(self):
-        """
-        Show the launcher window.
-        """
-        self.show()
-
-    def hide_launcher(self):
-        """
-        Hide the launcher window.
-        """
-        self.hide()
-
-    def showEvent(self, event):
-        self._refresh_dock_area_profiles()
-        super().showEvent(event)
-        self.setFixedSize(self.size())
-
-    def _launcher_is_last_widget(self, connections: dict) -> bool:
-        """
-        Check if the launcher is the last widget in the application.
-        """
-
-        # get all parents of connections
-        for connection in connections.values():
-            try:
-                parent = connection.parent()
-                if parent is None and connection.objectName() != self.objectName():
-                    logger.info(
-                        f"Found non-launcher connection without parent: {connection.objectName()}"
-                    )
-                    return False
-            except Exception as e:
-                logger.error(f"Error getting parent of connection: {e}")
-                return False
-        return True
-
-    def _turn_off_the_lights(self, connections: dict):
-        """
-        If there is only one connection remaining, it is the launcher, so we show it.
-        Once the launcher is closed as the last window, we quit the application.
-        """
-        if self._launcher_is_last_widget(connections):
-            self.show()
-            self.activateWindow()
-            self.raise_()
-            if self.app:
-                self.app.setQuitOnLastWindowClosed(True)  # type: ignore
-            return
-
-        self.hide()
-        if self.app:
-            self.app.setQuitOnLastWindowClosed(False)  # type: ignore
-
-    def closeEvent(self, event):
-        """
-        Close the launcher window.
-        """
-        connections = self.register.list_all_connections()
-        if self._launcher_is_last_widget(connections):
-            event.accept()
-            return
-
-        event.ignore()
-        self.hide()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from bec_widgets.utils.colors import apply_theme
-
-    app = QApplication(sys.argv)
-    apply_theme("dark")
-    launcher = LaunchWindow()
-    launcher.show()
-    sys.exit(app.exec())

bec_widgets/applications/main_app.py

@@ -1,397 +0,0 @@
-from bec_qthemes import material_icon
-from qtpy.QtGui import QAction  # type: ignore
-from qtpy.QtWidgets import QApplication, QHBoxLayout, QStackedWidget, QWidget
-
-from bec_widgets.applications.navigation_centre.reveal_animator import ANIMATION_DURATION
-from bec_widgets.applications.navigation_centre.side_bar import SideBar
-from bec_widgets.applications.navigation_centre.side_bar_components import NavigationItem
-from bec_widgets.applications.views.developer_view.developer_view import DeveloperView
-from bec_widgets.applications.views.device_manager_view.device_manager_view import DeviceManagerView
-from bec_widgets.applications.views.dock_area_view.dock_area_view import DockAreaView
-from bec_widgets.applications.views.view import ViewBase, WaveformViewInline, WaveformViewPopup
-from bec_widgets.utils.colors import apply_theme
-from bec_widgets.utils.guided_tour import GuidedTour
-from bec_widgets.utils.name_utils import sanitize_namespace
-from bec_widgets.utils.screen_utils import (
-    apply_centered_size,
-    available_screen_geometry,
-    main_app_size_for_screen,
-)
-from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
-
-
-class BECMainApp(BECMainWindow):
-    RPC = False
-    PLUGIN = False
-
-    def __init__(
-        self,
-        parent=None,
-        *args,
-        anim_duration: int = ANIMATION_DURATION,
-        show_examples: bool = False,
-        **kwargs,
-    ):
-        super().__init__(parent=parent, *args, **kwargs)
-        self._show_examples = bool(show_examples)
-
-        # --- Compose central UI (sidebar + stack)
-        self.sidebar = SideBar(parent=self, anim_duration=anim_duration)
-        self.stack = QStackedWidget(self)
-
-        container = QWidget(self)
-        layout = QHBoxLayout(container)
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.setSpacing(0)
-        layout.addWidget(self.sidebar, 0)
-        layout.addWidget(self.stack, 1)
-        self.setCentralWidget(container)
-
-        # Mapping for view switching
-        self._view_index: dict[str, int] = {}
-        self._current_view_id: str | None = None
-        self.sidebar.view_selected.connect(self._on_view_selected)
-
-        self._add_views()
-
-        # Initialize guided tour
-        self.guided_tour = GuidedTour(self)
-        self._setup_guided_tour()
-
-    def _add_views(self):
-        self.add_section("BEC Applications", "bec_apps")
-        self.dock_area = DockAreaView(self)
-        self.device_manager = DeviceManagerView(self)
-        # self.developer_view = DeveloperView(self) #TODO temporary disable until the bugs with BECShell are resolved
-        self.add_view(icon="widgets", title="Dock Area", widget=self.dock_area, mini_text="Docks")
-        self.add_view(
-            icon="display_settings",
-            title="Device Manager",
-            widget=self.device_manager,
-            mini_text="DM",
-        )
-        # TODO temporary disable until the bugs with BECShell are resolved
-        # self.add_view(
-        #     icon="code_blocks",
-        #     title="IDE",
-        #     widget=self.developer_view,
-        #     mini_text="IDE",
-        #     exclusive=True,
-        # )
-
-        if self._show_examples:
-            self.add_section("Examples", "examples")
-            waveform_view_popup = WaveformViewPopup(
-                parent=self, view_id="waveform_view_popup", title="Waveform Plot"
-            )
-            waveform_view_stack = WaveformViewInline(
-                parent=self, view_id="waveform_view_stack", title="Waveform Plot"
-            )
-
-            self.add_view(
-                icon="show_chart",
-                title="Waveform With Popup",
-                widget=waveform_view_popup,
-                mini_text="Popup",
-            )
-            self.add_view(
-                icon="show_chart",
-                title="Waveform InLine Stack",
-                widget=waveform_view_stack,
-                mini_text="Stack",
-            )
-
-        self.set_current("dock_area")
-        self.sidebar.add_dark_mode_item()
-
-        # Add guided tour to Help menu
-        self._add_guided_tour_to_menu()
-
-    # --- Public API ------------------------------------------------------
-    def add_section(self, title: str, id: str, position: int | None = None):
-        return self.sidebar.add_section(title, id, position)
-
-    def add_separator(self):
-        return self.sidebar.add_separator()
-
-    def add_dark_mode_item(self, id: str = "dark_mode", position: int | None = None):
-        return self.sidebar.add_dark_mode_item(id=id, position=position)
-
-    def add_view(
-        self,
-        *,
-        icon: str,
-        title: str,
-        view_id: str | None = None,
-        widget: QWidget,
-        mini_text: str | None = None,
-        position: int | None = None,
-        from_top: bool = True,
-        toggleable: bool = True,
-        exclusive: bool = True,
-    ) -> NavigationItem:
-        """
-        Register a view in the stack and create a matching nav item in the sidebar.
-
-        Args:
-            icon(str): Icon name for the nav item.
-            title(str): Title for the nav item.
-            view_id(str, optional): Unique ID for the view/item. If omitted, uses mini_text;
-                if mini_text is also omitted, uses title.
-            widget(QWidget): The widget to add to the stack.
-            mini_text(str, optional): Short text for the nav item when sidebar is collapsed.
-            position(int, optional): Position to insert the nav item.
-            from_top(bool, optional): Whether to count position from the top or bottom.
-            toggleable(bool, optional): Whether the nav item is toggleable.
-            exclusive(bool, optional): Whether the nav item is exclusive.
-
-        Returns:
-            NavigationItem: The created navigation item.
-
-
-        """
-        resolved_id = sanitize_namespace(view_id or mini_text or title)
-        item = self.sidebar.add_item(
-            icon=icon,
-            title=title,
-            id=resolved_id,
-            mini_text=mini_text,
-            position=position,
-            from_top=from_top,
-            toggleable=toggleable,
-            exclusive=exclusive,
-        )
-        # Wrap plain widgets into a ViewBase so enter/exit hooks are available
-        if isinstance(widget, ViewBase):
-            view_widget = widget
-            view_widget.view_id = resolved_id
-            view_widget.view_title = title
-        else:
-            view_widget = ViewBase(content=widget, parent=self, view_id=resolved_id, title=title)
-
-        view_widget.change_object_name(resolved_id)
-
-        idx = self.stack.addWidget(view_widget)
-        self._view_index[resolved_id] = idx
-        return item
-
-    def set_current(self, id: str) -> None:
-        if id in self._view_index:
-            self.sidebar.activate_item(id)
-
-    # Internal: route sidebar selection to the stack
-    def _on_view_selected(self, vid: str) -> None:
-        # Determine current view
-        current_index = self.stack.currentIndex()
-        current_view = (
-            self.stack.widget(current_index) if 0 <= current_index < self.stack.count() else None
-        )
-
-        # Ask current view whether we may leave
-        if current_view is not None and hasattr(current_view, "on_exit"):
-            may_leave = current_view.on_exit()
-            if may_leave is False:
-                # Veto: restore previous highlight without re-emitting selection
-                if self._current_view_id is not None:
-                    self.sidebar.activate_item(self._current_view_id, emit_signal=False)
-                return
-
-        # Proceed with switch
-        idx = self._view_index.get(vid)
-        if idx is None or not (0 <= idx < self.stack.count()):
-            return
-        self.stack.setCurrentIndex(idx)
-        new_view = self.stack.widget(idx)
-        self._current_view_id = vid
-        if hasattr(new_view, "on_enter"):
-            new_view.on_enter()
-
-    def _setup_guided_tour(self):
-        """
-        Setup the guided tour for the main application.
-        Registers key UI components and delegates to views for their internal components.
-        """
-        tour_steps = []
-
-        # --- General Layout Components ---
-
-        # Register the sidebar toggle button
-        toggle_step = self.guided_tour.register_widget(
-            widget=self.sidebar.toggle,
-            title="Sidebar Toggle",
-            text="Click this button to expand or collapse the sidebar. When expanded, you can see full navigation item titles and section names.",
-        )
-        tour_steps.append(toggle_step)
-
-        # Register the sidebar icons
-        sidebar_dock_area = self.sidebar.components.get("dock_area")
-        if sidebar_dock_area:
-            dock_step = self.guided_tour.register_widget(
-                widget=sidebar_dock_area,
-                title="Dock Area View",
-                text="Click here to access the Dock Area view, where you can manage and arrange your dockable panels.",
-            )
-            tour_steps.append(dock_step)
-
-        sidebar_device_manager = self.sidebar.components.get("device_manager")
-        if sidebar_device_manager:
-            device_manager_step = self.guided_tour.register_widget(
-                widget=sidebar_device_manager,
-                title="Device Manager View",
-                text="Click here to open the Device Manager view, where you can view and manage device configs.",
-            )
-            tour_steps.append(device_manager_step)
-
-        sidebar_developer_view = self.sidebar.components.get("developer_view")
-        if sidebar_developer_view:
-            developer_view_step = self.guided_tour.register_widget(
-                widget=sidebar_developer_view,
-                title="Developer View",
-                text="Click here to access the Developer view to write scripts and makros.",
-            )
-            tour_steps.append(developer_view_step)
-
-        # Register the dark mode toggle
-        dark_mode_item = self.sidebar.components.get("dark_mode")
-        if dark_mode_item:
-            dark_mode_step = self.guided_tour.register_widget(
-                widget=dark_mode_item,
-                title="Theme Toggle",
-                text="Switch between light and dark themes. The theme preference is saved and will be applied when you restart the application.",
-            )
-            tour_steps.append(dark_mode_step)
-
-        # Register the client info label
-        if hasattr(self, "_client_info_hover"):
-            client_info_step = self.guided_tour.register_widget(
-                widget=self._client_info_hover,
-                title="Client Status",
-                text="Displays status messages and information from the BEC Server.",
-            )
-            tour_steps.append(client_info_step)
-
-        # Register the scan progress bar if available
-        if hasattr(self, "_scan_progress_hover"):
-            progress_step = self.guided_tour.register_widget(
-                widget=self._scan_progress_hover,
-                title="Scan Progress",
-                text="Monitor the progress of ongoing scans. Hover over the progress bar to see detailed information including elapsed time and estimated completion.",
-            )
-            tour_steps.append(progress_step)
-
-        # Register the notification indicator in the status bar
-        if hasattr(self, "notification_indicator"):
-            notif_step = self.guided_tour.register_widget(
-                widget=self.notification_indicator,
-                title="Notification Center",
-                text="View system notifications, errors, and status updates. Click to filter notifications by type or expand to see all details.",
-            )
-            tour_steps.append(notif_step)
-
-        # --- View-Specific Components ---
-
-        # Register all views that can extend the tour
-        for view_id, view_index in self._view_index.items():
-            view_widget = self.stack.widget(view_index)
-            if not view_widget or not hasattr(view_widget, "register_tour_steps"):
-                continue
-
-            # Get the view's tour steps
-            view_tour = view_widget.register_tour_steps(self.guided_tour, self)
-            if view_tour is None:
-                if hasattr(view_widget.content, "register_tour_steps"):
-                    view_tour = view_widget.content.register_tour_steps(self.guided_tour, self)
-                if view_tour is None:
-                    continue
-
-            # Get the corresponding sidebar navigation item
-            nav_item = self.sidebar.components.get(view_id)
-            if not nav_item:
-                continue
-
-            # Use the view's title for the navigation button
-            nav_step = self.guided_tour.register_widget(
-                widget=nav_item,
-                title=view_tour.view_title,
-                text=f"Let's explore the features of the {view_tour.view_title}.",
-            )
-            tour_steps.append(nav_step)
-            tour_steps.extend(view_tour.step_ids)
-
-        # Create the tour with all registered steps
-        if tour_steps:
-            self.guided_tour.create_tour(tour_steps)
-
-    def start_guided_tour(self):
-        """
-        Public method to start the guided tour.
-        This can be called programmatically or connected to a menu/button action.
-        """
-        self.guided_tour.start_tour()
-
-    def _add_guided_tour_to_menu(self):
-        """
-        Add a 'Guided Tour' action to the Help menu.
-        """
-
-        # Find the Help menu
-        menu_bar = self.menuBar()
-        help_menu = None
-        for action in menu_bar.actions():
-            if action.text() == "Help":
-                help_menu = action.menu()
-                break
-
-        if help_menu:
-            # Add separator before the tour action
-            help_menu.addSeparator()
-
-            # Create and add the guided tour action
-            tour_action = QAction("Start Guided Tour", self)
-            tour_action.setIcon(material_icon("help"))
-            tour_action.triggered.connect(self.start_guided_tour)
-            tour_action.setShortcut("F1")  # Add keyboard shortcut
-            help_menu.addAction(tour_action)
-
-    def cleanup(self):
-        for view_id, idx in self._view_index.items():
-            view = self.stack.widget(idx)
-            view.close()
-            view.deleteLater()
-        super().cleanup()
-
-
-def main():  # pragma: no cover
-    """
-    Main function to run the BEC main application, exposed as a script entry point through
-    pyproject.toml.
-    """
-    # pylint: disable=import-outside-toplevel
-    import argparse
-    import sys
-
-    parser = argparse.ArgumentParser(description="BEC Main Application")
-    parser.add_argument(
-        "--examples", action="store_true", help="Show the Examples section with waveform demo views"
-    )
-    # Let Qt consume the remaining args
-    args, qt_args = parser.parse_known_args(sys.argv[1:])
-
-    app = QApplication([sys.argv[0], *qt_args])
-    apply_theme("dark")
-    w = BECMainApp(show_examples=args.examples)
-
-    screen_geometry = available_screen_geometry()
-    if screen_geometry is not None:
-        width, height = main_app_size_for_screen(screen_geometry)
-        apply_centered_size(w, width, height, available=screen_geometry)
-    else:
-        w.resize(w.minimumSizeHint())
-
-    w.show()
-
-    sys.exit(app.exec())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/applications/navigation_centre/reveal_animator.py

@@ -1,114 +0,0 @@
-from __future__ import annotations
-
-from qtpy.QtCore import QEasingCurve, QParallelAnimationGroup, QPropertyAnimation
-from qtpy.QtWidgets import QGraphicsOpacityEffect, QWidget
-
-ANIMATION_DURATION = 500  # ms
-
-
-class RevealAnimator:
-    """Animate reveal/hide for a single widget using opacity + max W/H.
-
-    This keeps the widget always visible to avoid jitter from setVisible().
-    Collapsed state: opacity=0, maxW=0, maxH=0.
-    Expanded state: opacity=1, maxW=sizeHint.width(), maxH=sizeHint.height().
-    """
-
-    def __init__(
-        self,
-        widget: QWidget,
-        duration: int = ANIMATION_DURATION,
-        easing: QEasingCurve.Type = QEasingCurve.InOutCubic,
-        initially_revealed: bool = False,
-        *,
-        animate_opacity: bool = True,
-        animate_width: bool = True,
-        animate_height: bool = True,
-    ):
-        self.widget = widget
-        self.animate_opacity = animate_opacity
-        self.animate_width = animate_width
-        self.animate_height = animate_height
-        # Opacity effect
-        self.fx = QGraphicsOpacityEffect(widget)
-        widget.setGraphicsEffect(self.fx)
-        # Animations
-        self.opacity_anim = (
-            QPropertyAnimation(self.fx, b"opacity") if self.animate_opacity else None
-        )
-        self.width_anim = (
-            QPropertyAnimation(widget, b"maximumWidth") if self.animate_width else None
-        )
-        self.height_anim = (
-            QPropertyAnimation(widget, b"maximumHeight") if self.animate_height else None
-        )
-        for anim in (self.opacity_anim, self.width_anim, self.height_anim):
-            if anim is not None:
-                anim.setDuration(duration)
-                anim.setEasingCurve(easing)
-        # Initialize to requested state
-        self.set_immediate(initially_revealed)
-
-    def _natural_sizes(self) -> tuple[int, int]:
-        sh = self.widget.sizeHint()
-        w = max(sh.width(), 1)
-        h = max(sh.height(), 1)
-        return w, h
-
-    def set_immediate(self, revealed: bool):
-        """
-        Immediately set the widget to the target revealed/collapsed state.
-
-        Args:
-            revealed(bool): True to reveal, False to collapse.
-        """
-        w, h = self._natural_sizes()
-        if self.animate_opacity:
-            self.fx.setOpacity(1.0 if revealed else 0.0)
-        if self.animate_width:
-            self.widget.setMaximumWidth(w if revealed else 0)
-        if self.animate_height:
-            self.widget.setMaximumHeight(h if revealed else 0)
-
-    def setup(self, reveal: bool):
-        """
-        Prepare animations to transition to the target revealed/collapsed state.
-
-        Args:
-            reveal(bool): True to reveal, False to collapse.
-        """
-        # Prepare animations from current state to target
-        target_w, target_h = self._natural_sizes()
-        if self.opacity_anim is not None:
-            self.opacity_anim.setStartValue(self.fx.opacity())
-            self.opacity_anim.setEndValue(1.0 if reveal else 0.0)
-        if self.width_anim is not None:
-            self.width_anim.setStartValue(self.widget.maximumWidth())
-            self.width_anim.setEndValue(target_w if reveal else 0)
-        if self.height_anim is not None:
-            self.height_anim.setStartValue(self.widget.maximumHeight())
-            self.height_anim.setEndValue(target_h if reveal else 0)
-
-    def add_to_group(self, group: QParallelAnimationGroup):
-        """
-        Add the prepared animations to the given animation group.
-
-        Args:
-            group(QParallelAnimationGroup): The animation group to add to.
-        """
-        if self.opacity_anim is not None:
-            group.addAnimation(self.opacity_anim)
-        if self.width_anim is not None:
-            group.addAnimation(self.width_anim)
-        if self.height_anim is not None:
-            group.addAnimation(self.height_anim)
-
-    def animations(self):
-        """
-        Get a list of all animations (non-None) for adding to a group.
-        """
-        return [
-            anim
-            for anim in (self.opacity_anim, self.height_anim, self.width_anim)
-            if anim is not None
-        ]

bec_widgets/applications/navigation_centre/side_bar.py

@@ -1,357 +0,0 @@
-from __future__ import annotations
-
-from bec_qthemes import material_icon
-from qtpy import QtWidgets
-from qtpy.QtCore import QEasingCurve, QParallelAnimationGroup, QPropertyAnimation, Qt, Signal
-from qtpy.QtWidgets import (
-    QGraphicsOpacityEffect,
-    QHBoxLayout,
-    QLabel,
-    QScrollArea,
-    QToolButton,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets import SafeProperty, SafeSlot
-from bec_widgets.applications.navigation_centre.reveal_animator import ANIMATION_DURATION
-from bec_widgets.applications.navigation_centre.side_bar_components import (
-    DarkModeNavItem,
-    NavigationItem,
-    SectionHeader,
-    SideBarSeparator,
-)
-
-
-class SideBar(QScrollArea):
-    view_selected = Signal(str)
-    toggled = Signal(bool)
-
-    def __init__(
-        self,
-        parent=None,
-        title: str = "Control Panel",
-        collapsed_width: int = 56,
-        expanded_width: int = 250,
-        anim_duration: int = ANIMATION_DURATION,
-    ):
-        super().__init__(parent=parent)
-        self.setObjectName("SideBar")
-
-        # private attributes
-        self._is_expanded = False
-        self._collapsed_width = collapsed_width
-        self._expanded_width = expanded_width
-        self._anim_duration = anim_duration
-
-        # containers
-        self.components = {}
-        self._item_opts: dict[str, dict] = {}
-
-        # Scroll area properties
-        self.setWidgetResizable(True)
-        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-        self.setFrameShape(QtWidgets.QFrame.NoFrame)
-        self.setFixedWidth(self._collapsed_width)
-
-        # Content widget holding buttons for switching views
-        self.content = QWidget(self)
-        self.content_layout = QVBoxLayout(self.content)
-        self.content_layout.setContentsMargins(0, 0, 0, 0)
-        self.content_layout.setSpacing(4)
-        self.setWidget(self.content)
-
-        # Track active navigation item
-        self._active_id = None
-
-        # Top row with title and toggle button
-        self.toggle_row = QWidget(self)
-        self.toggle_row_layout = QHBoxLayout(self.toggle_row)
-
-        self.title_label = QLabel(title, self)
-        self.title_label.setObjectName("TopTitle")
-        self.title_label.setStyleSheet("font-weight: 600;")
-        self.title_fx = QGraphicsOpacityEffect(self.title_label)
-        self.title_label.setGraphicsEffect(self.title_fx)
-        self.title_fx.setOpacity(0.0)
-        self.title_label.setVisible(False)  # TODO dirty trick to avoid layout shift
-
-        self.toggle = QToolButton(self)
-        self.toggle.setCheckable(False)
-        self.toggle.setIcon(material_icon("keyboard_arrow_right", convert_to_pixmap=False))
-        self.toggle.clicked.connect(self.on_expand)
-
-        self.toggle_row_layout.addWidget(self.title_label, 1, Qt.AlignLeft | Qt.AlignVCenter)
-        self.toggle_row_layout.addWidget(self.toggle, 1, Qt.AlignHCenter | Qt.AlignVCenter)
-
-        # To push the content up always
-        self._bottom_spacer = QtWidgets.QSpacerItem(
-            0, 0, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding
-        )
-
-        # Add core widgets to layout
-        self.content_layout.addWidget(self.toggle_row)
-        self.content_layout.addItem(self._bottom_spacer)
-
-        # Animations
-        self.width_anim = QPropertyAnimation(self, b"bar_width")
-        self.width_anim.setDuration(self._anim_duration)
-        self.width_anim.setEasingCurve(QEasingCurve.InOutCubic)
-
-        self.title_anim = QPropertyAnimation(self.title_fx, b"opacity")
-        self.title_anim.setDuration(self._anim_duration)
-        self.title_anim.setEasingCurve(QEasingCurve.InOutCubic)
-
-        self.group = QParallelAnimationGroup(self)
-        self.group.addAnimation(self.width_anim)
-        self.group.addAnimation(self.title_anim)
-        self.group.finished.connect(self._on_anim_finished)
-
-        app = QtWidgets.QApplication.instance()
-        if app is not None and hasattr(app, "theme") and hasattr(app.theme, "theme_changed"):
-            app.theme.theme_changed.connect(self._on_theme_changed)
-
-    @SafeProperty(int)
-    def bar_width(self) -> int:
-        """
-        Get the current width of the side bar.
-
-        Returns:
-            int: The current width of the side bar.
-        """
-        return self.width()
-
-    @bar_width.setter
-    def bar_width(self, width: int):
-        """
-        Set the width of the side bar.
-
-        Args:
-            width(int): The new width of the side bar.
-        """
-        self.setFixedWidth(width)
-
-    @SafeProperty(bool)
-    def is_expanded(self) -> bool:
-        """
-        Check if the side bar is expanded.
-
-        Returns:
-            bool: True if the side bar is expanded, False otherwise.
-        """
-        return self._is_expanded
-
-    @SafeSlot()
-    @SafeSlot(bool)
-    def on_expand(self):
-        """
-        Toggle the expansion state of the side bar.
-        """
-        self._is_expanded = not self._is_expanded
-        self.toggle.setIcon(
-            material_icon(
-                "keyboard_arrow_left" if self._is_expanded else "keyboard_arrow_right",
-                convert_to_pixmap=False,
-            )
-        )
-
-        if self._is_expanded:
-            self.toggle_row_layout.setAlignment(self.toggle, Qt.AlignRight | Qt.AlignVCenter)
-
-        self.group.stop()
-        # Setting limits for animations of the side bar
-        self.width_anim.setStartValue(self.width())
-        self.width_anim.setEndValue(
-            self._expanded_width if self._is_expanded else self._collapsed_width
-        )
-        self.title_anim.setStartValue(self.title_fx.opacity())
-        self.title_anim.setEndValue(1.0 if self._is_expanded else 0.0)
-
-        # Setting limits for animations of the components
-        for comp in self.components.values():
-            if hasattr(comp, "setup_animations"):
-                comp.setup_animations(self._is_expanded)
-
-        self.group.start()
-        if self._is_expanded:
-            # TODO do not like this trick, but it is what it is for now
-            self.title_label.setVisible(self._is_expanded)
-            for comp in self.components.values():
-                if hasattr(comp, "set_visible"):
-                    comp.set_visible(self._is_expanded)
-        self.toggled.emit(self._is_expanded)
-
-    @SafeSlot()
-    def _on_anim_finished(self):
-        if not self._is_expanded:
-            self.toggle_row_layout.setAlignment(self.toggle, Qt.AlignHCenter | Qt.AlignVCenter)
-            # TODO do not like this trick, but it is what it is for now
-            self.title_label.setVisible(self._is_expanded)
-            for comp in self.components.values():
-                if hasattr(comp, "set_visible"):
-                    comp.set_visible(self._is_expanded)
-
-    @SafeSlot(str)
-    def _on_theme_changed(self, theme_name: str):
-        # Refresh toggle arrow icon so it picks up the new theme
-        self.toggle.setIcon(
-            material_icon(
-                "keyboard_arrow_left" if self._is_expanded else "keyboard_arrow_right",
-                convert_to_pixmap=False,
-            )
-        )
-        # Refresh each component that supports it
-        for comp in self.components.values():
-            if hasattr(comp, "refresh_theme"):
-                comp.refresh_theme()
-            else:
-                comp.style().unpolish(comp)
-                comp.style().polish(comp)
-                comp.update()
-        self.style().unpolish(self)
-        self.style().polish(self)
-        self.update()
-
-    def add_section(self, title: str, id: str, position: int | None = None) -> SectionHeader:
-        """
-        Add a section header to the side bar.
-
-        Args:
-            title(str): The title of the section.
-            id(str): Unique ID for the section.
-            position(int, optional): Position to insert the section header.
-
-        Returns:
-            SectionHeader: The created section header.
-
-        """
-        header = SectionHeader(self, title, anim_duration=self._anim_duration)
-        position = position if position is not None else self.content_layout.count() - 1
-        self.content_layout.insertWidget(position, header)
-        for anim in header.animations:
-            self.group.addAnimation(anim)
-        self.components[id] = header
-        return header
-
-    def add_separator(
-        self, *, from_top: bool = True, position: int | None = None
-    ) -> SideBarSeparator:
-        """
-        Add a separator line to the side bar. Separators are treated like regular
-        items; you can place multiple separators anywhere using `from_top` and `position`.
-        """
-        line = SideBarSeparator(self)
-        line.setStyleSheet("margin:12px;")
-        self._insert_nav_item(line, from_top=from_top, position=position)
-        return line
-
-    def add_item(
-        self,
-        icon: str,
-        title: str,
-        id: str,
-        mini_text: str | None = None,
-        position: int | None = None,
-        *,
-        from_top: bool = True,
-        toggleable: bool = True,
-        exclusive: bool = True,
-    ) -> NavigationItem:
-        """
-        Add a navigation item to the side bar.
-
-        Args:
-            icon(str): Icon name for the nav item.
-            title(str): Title for the nav item.
-            id(str): Unique ID for the nav item.
-            mini_text(str, optional): Short text for the nav item when sidebar is collapsed.
-            position(int, optional): Position to insert the nav item.
-            from_top(bool, optional): Whether to count position from the top or bottom.
-            toggleable(bool, optional): Whether the nav item is toggleable.
-            exclusive(bool, optional): Whether the nav item is exclusive.
-
-        Returns:
-            NavigationItem: The created navigation item.
-        """
-        item = NavigationItem(
-            parent=self,
-            title=title,
-            icon_name=icon,
-            mini_text=mini_text,
-            toggleable=toggleable,
-            exclusive=exclusive,
-            anim_duration=self._anim_duration,
-        )
-        self._insert_nav_item(item, from_top=from_top, position=position)
-        for anim in item.build_animations():
-            self.group.addAnimation(anim)
-        self.components[id] = item
-        # Connect activation to activation logic, passing id unchanged
-        item.activated.connect(lambda id=id: self.activate_item(id))
-        return item
-
-    def activate_item(self, target_id: str, *, emit_signal: bool = True):
-        target = self.components.get(target_id)
-        if target is None:
-            return
-        # Non-toggleable acts like an action: do not change any toggled states
-        if hasattr(target, "toggleable") and not target.toggleable:
-            self._active_id = target_id
-            if emit_signal:
-                self.view_selected.emit(target_id)
-            return
-
-        is_exclusive = getattr(target, "exclusive", True)
-        if is_exclusive:
-            # Radio-like behavior among exclusive items only
-            for comp_id, comp in self.components.items():
-                if not isinstance(comp, NavigationItem):
-                    continue
-                if comp is target:
-                    comp.set_active(True)
-                else:
-                    # Only untoggle other items that are also exclusive
-                    if getattr(comp, "exclusive", True):
-                        comp.set_active(False)
-                    # Leave non-exclusive items as they are
-        else:
-            # Non-exclusive toggles independently
-            target.set_active(not target.is_active())
-
-        self._active_id = target_id
-        if emit_signal:
-            self.view_selected.emit(target_id)
-
-    def add_dark_mode_item(
-        self, id: str = "dark_mode", position: int | None = None
-    ) -> DarkModeNavItem:
-        """
-        Add a dark mode toggle item to the side bar.
-
-        Args:
-            id(str): Unique ID for the dark mode item.
-            position(int, optional): Position to insert the dark mode item.
-
-        Returns:
-            DarkModeNavItem: The created dark mode navigation item.
-        """
-        item = DarkModeNavItem(parent=self, id=id, anim_duration=self._anim_duration)
-        # compute bottom insertion point (same semantics as from_top=False)
-        self._insert_nav_item(item, from_top=False, position=position)
-        for anim in item.build_animations():
-            self.group.addAnimation(anim)
-        self.components[id] = item
-        item.activated.connect(lambda id=id: self.activate_item(id))
-        return item
-
-    def _insert_nav_item(
-        self, item: QWidget, *, from_top: bool = True, position: int | None = None
-    ):
-        if from_top:
-            base_index = self.content_layout.indexOf(self._bottom_spacer)
-            pos = base_index if position is None else min(base_index, position)
-        else:
-            base = self.content_layout.indexOf(self._bottom_spacer) + 1
-            pos = base if position is None else base + max(0, position)
-        self.content_layout.insertWidget(pos, item)

bec_widgets/applications/navigation_centre/side_bar_components.py

@@ -1,370 +0,0 @@
-from __future__ import annotations
-
-from bec_qthemes import material_icon
-from qtpy import QtCore
-from qtpy.QtCore import QEasingCurve, QPropertyAnimation, Qt
-from qtpy.QtWidgets import (
-    QApplication,
-    QFrame,
-    QHBoxLayout,
-    QLabel,
-    QSizePolicy,
-    QToolButton,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets import SafeProperty
-from bec_widgets.applications.navigation_centre.reveal_animator import (
-    ANIMATION_DURATION,
-    RevealAnimator,
-)
-
-
-def get_on_primary():
-    app = QApplication.instance()
-    if app is not None and hasattr(app, "theme"):
-        return app.theme.color("ON_PRIMARY")
-    return "#FFFFFF"
-
-
-def get_fg():
-    app = QApplication.instance()
-    if app is not None and hasattr(app, "theme"):
-        return app.theme.color("FG")
-    return "#FFFFFF"
-
-
-class SideBarSeparator(QFrame):
-    """A horizontal line separator for use in SideBar."""
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.setObjectName("SideBarSeparator")
-        self.setFrameShape(QFrame.NoFrame)
-        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
-        self.setFixedHeight(2)
-        self.setProperty("variant", "separator")
-
-
-class SectionHeader(QWidget):
-    """A section header with a label and a horizontal line below."""
-
-    def __init__(self, parent=None, text: str = None, anim_duration: int = ANIMATION_DURATION):
-        super().__init__(parent)
-        self.setObjectName("SectionHeader")
-
-        self.lbl = QLabel(text, self)
-        self.lbl.setObjectName("SectionHeaderLabel")
-        self.lbl.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
-        self._reveal = RevealAnimator(self.lbl, duration=anim_duration, initially_revealed=False)
-
-        self.line = SideBarSeparator(self)
-
-        lay = QVBoxLayout(self)
-        # keep your margins/spacing preferences here if needed
-        lay.setContentsMargins(12, 0, 12, 0)
-        lay.setSpacing(6)
-        lay.addWidget(self.lbl)
-        lay.addWidget(self.line)
-
-        self.animations = self.build_animations()
-
-    def build_animations(self) -> list[QPropertyAnimation]:
-        """
-        Build and return animations for expanding/collapsing the sidebar.
-
-        Returns:
-            list[QPropertyAnimation]: List of animations.
-        """
-        return self._reveal.animations()
-
-    def setup_animations(self, expanded: bool):
-        """
-        Setup animations for expanding/collapsing the sidebar.
-
-        Args:
-            expanded(bool): True if the sidebar is expanded, False if collapsed.
-        """
-        self._reveal.setup(expanded)
-
-
-class NavigationItem(QWidget):
-    """A nav tile with an icon + labels and an optional expandable body.
-    Provides animations for collapsed/expanded sidebar states via
-    build_animations()/setup_animations(), similar to SectionHeader.
-    """
-
-    activated = QtCore.Signal()
-
-    def __init__(
-        self,
-        parent=None,
-        *,
-        title: str,
-        icon_name: str,
-        mini_text: str | None = None,
-        toggleable: bool = True,
-        exclusive: bool = True,
-        anim_duration: int = ANIMATION_DURATION,
-    ):
-        super().__init__(parent=parent)
-        self.setObjectName("NavigationItem")
-
-        # Private attributes
-        self._title = title
-        self._icon_name = icon_name
-        self._mini_text = mini_text or title
-        self._toggleable = toggleable
-        self._toggled = False
-        self._exclusive = exclusive
-
-        # Main Icon
-        self.icon_btn = QToolButton(self)
-        self.icon_btn.setIcon(material_icon(self._icon_name, filled=False, convert_to_pixmap=False))
-        self.icon_btn.setAutoRaise(True)
-        self._icon_size_collapsed = QtCore.QSize(20, 20)
-        self._icon_size_expanded = QtCore.QSize(26, 26)
-        self.icon_btn.setIconSize(self._icon_size_collapsed)
-        # Remove QToolButton hover/pressed background/outline
-        self.icon_btn.setStyleSheet("""
-            QToolButton:hover { background: transparent; border: none; }
-            QToolButton:pressed { background: transparent; border: none; }
-            """)
-
-        # Mini label below icon
-        self.mini_lbl = QLabel(self._mini_text, self)
-        self.mini_lbl.setObjectName("NavMiniLabel")
-        self.mini_lbl.setAlignment(Qt.AlignCenter)
-        self.mini_lbl.setStyleSheet("font-size: 10px;")
-        self.reveal_mini_lbl = RevealAnimator(
-            widget=self.mini_lbl,
-            initially_revealed=True,
-            animate_width=False,
-            duration=anim_duration,
-        )
-
-        # Container for icon + mini label
-        self.mini_icon = QWidget(self)
-        mini_lay = QVBoxLayout(self.mini_icon)
-        mini_lay.setContentsMargins(0, 2, 0, 2)
-        mini_lay.setSpacing(2)
-        mini_lay.addWidget(self.icon_btn, 0, Qt.AlignCenter)
-        mini_lay.addWidget(self.mini_lbl, 0, Qt.AlignCenter)
-
-        # Title label
-        self.title_lbl = QLabel(self._title, self)
-        self.title_lbl.setObjectName("NavTitleLabel")
-        self.title_lbl.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
-        self.title_lbl.setStyleSheet("font-size: 13px;")
-        self.reveal_title_lbl = RevealAnimator(
-            widget=self.title_lbl,
-            initially_revealed=False,
-            animate_height=False,
-            duration=anim_duration,
-        )
-        self.title_lbl.setVisible(False)  # TODO dirty trick to avoid layout shift
-
-        lay = QHBoxLayout(self)
-        lay.setContentsMargins(12, 2, 12, 2)
-        lay.setSpacing(6)
-        lay.addWidget(self.mini_icon, 0, Qt.AlignHCenter | Qt.AlignTop)
-        lay.addWidget(self.title_lbl, 1, Qt.AlignLeft | Qt.AlignVCenter)
-
-        self.icon_size_anim = QPropertyAnimation(self.icon_btn, b"iconSize")
-        self.icon_size_anim.setDuration(anim_duration)
-        self.icon_size_anim.setEasingCurve(QEasingCurve.InOutCubic)
-
-        # Connect icon button to emit activation
-        self.icon_btn.clicked.connect(self._emit_activated)
-        self.setMouseTracking(True)
-        self.setAttribute(Qt.WA_StyledBackground, True)
-
-    def is_active(self) -> bool:
-        """Return whether the item is currently active/selected."""
-        return self.property("toggled") is True
-
-    def build_animations(self) -> list[QPropertyAnimation]:
-        """
-        Build and return animations for expanding/collapsing the sidebar.
-
-        Returns:
-            list[QPropertyAnimation]: List of animations.
-        """
-        return (
-            self.reveal_title_lbl.animations()
-            + self.reveal_mini_lbl.animations()
-            + [self.icon_size_anim]
-        )
-
-    def setup_animations(self, expanded: bool):
-        """
-        Setup animations for expanding/collapsing the sidebar.
-
-        Args:
-            expanded(bool): True if the sidebar is expanded, False if collapsed.
-        """
-        self.reveal_mini_lbl.setup(not expanded)
-        self.reveal_title_lbl.setup(expanded)
-        self.icon_size_anim.setStartValue(self.icon_btn.iconSize())
-        self.icon_size_anim.setEndValue(
-            self._icon_size_expanded if expanded else self._icon_size_collapsed
-        )
-
-    def set_visible(self, visible: bool):
-        """Set visibility of the title label."""
-        self.title_lbl.setVisible(visible)
-
-    def _emit_activated(self):
-        self.activated.emit()
-
-    def set_active(self, active: bool):
-        """
-        Set the active/selected state of the item.
-
-        Args:
-            active(bool): True to set active, False to deactivate.
-        """
-        self.setProperty("toggled", active)
-        self.toggled = active
-        # ensure style refresh
-        self.style().unpolish(self)
-        self.style().polish(self)
-        self.update()
-
-    def mousePressEvent(self, event):
-        self.activated.emit()
-        super().mousePressEvent(event)
-
-    @SafeProperty(bool)
-    def toggleable(self) -> bool:
-        """
-        Whether the item is toggleable (like a button) or not (like an action).
-
-        Returns:
-            bool: True if toggleable, False otherwise.
-        """
-        return self._toggleable
-
-    @toggleable.setter
-    def toggleable(self, value: bool):
-        """
-        Set whether the item is toggleable (like a button) or not (like an action).
-        Args:
-            value(bool): True to make toggleable, False otherwise.
-        """
-        self._toggleable = bool(value)
-
-    @SafeProperty(bool)
-    def toggled(self) -> bool:
-        """
-        Whether the item is currently toggled/selected.
-
-        Returns:
-            bool: True if toggled, False otherwise.
-        """
-        return self._toggled
-
-    @toggled.setter
-    def toggled(self, value: bool):
-        """
-        Set whether the item is currently toggled/selected.
-
-        Args:
-            value(bool): True to set toggled, False to untoggle.
-        """
-        self._toggled = value
-        if value:
-            new_icon = material_icon(
-                self._icon_name, filled=True, color=get_on_primary(), convert_to_pixmap=False
-            )
-        else:
-            new_icon = material_icon(
-                self._icon_name, filled=False, color=get_fg(), convert_to_pixmap=False
-            )
-        self.icon_btn.setIcon(new_icon)
-        # Re-polish so QSS applies correct colors to icon/labels
-        for w in (self, self.icon_btn, self.title_lbl, self.mini_lbl):
-            w.style().unpolish(w)
-            w.style().polish(w)
-            w.update()
-
-    @SafeProperty(bool)
-    def exclusive(self) -> bool:
-        """
-        Whether the item is exclusive in its toggle group.
-
-        Returns:
-            bool: True if exclusive, False otherwise.
-        """
-        return self._exclusive
-
-    @exclusive.setter
-    def exclusive(self, value: bool):
-        """
-        Set whether the item is exclusive in its toggle group.
-
-        Args:
-            value(bool): True to make exclusive, False otherwise.
-        """
-        self._exclusive = bool(value)
-
-    def refresh_theme(self):
-        # Recompute icon/label colors according to current theme and state
-        # Trigger the toggled setter to rebuild the icon with the correct color
-        self.toggled = self._toggled
-        # Ensure QSS-driven text/icon colors refresh
-        for w in (self, self.icon_btn, self.title_lbl, self.mini_lbl):
-            w.style().unpolish(w)
-            w.style().polish(w)
-            w.update()
-
-
-class DarkModeNavItem(NavigationItem):
-    """Bottom action item that toggles app theme and updates its icon/text."""
-
-    def __init__(
-        self, parent=None, *, id: str = "dark_mode", anim_duration: int = ANIMATION_DURATION
-    ):
-        super().__init__(
-            parent=parent,
-            title="Dark mode",
-            icon_name="dark_mode",
-            mini_text="Dark",
-            toggleable=False,  # action-like, no selection highlight changes
-            exclusive=False,
-            anim_duration=anim_duration,
-        )
-        self._id = id
-        self._sync_from_qapp_theme()
-        self.activated.connect(self.toggle_theme)
-
-    def _qapp_dark_enabled(self) -> bool:
-        qapp = QApplication.instance()
-        return bool(getattr(getattr(qapp, "theme", None), "theme", None) == "dark")
-
-    def _sync_from_qapp_theme(self):
-        is_dark = self._qapp_dark_enabled()
-        # Update labels
-        self.title_lbl.setText("Light mode" if is_dark else "Dark mode")
-        self.mini_lbl.setText("Light" if is_dark else "Dark")
-        # Update icon
-        self.icon_btn.setIcon(
-            material_icon("light_mode" if is_dark else "dark_mode", convert_to_pixmap=False)
-        )
-
-    def refresh_theme(self):
-        self._sync_from_qapp_theme()
-        for w in (self, self.icon_btn, self.title_lbl, self.mini_lbl):
-            w.style().unpolish(w)
-            w.style().polish(w)
-            w.update()
-
-    def toggle_theme(self):
-        """Toggle application theme and update icon/text."""
-        from bec_widgets.utils.colors import apply_theme
-
-        is_dark = self._qapp_dark_enabled()
-
-        apply_theme("light" if is_dark else "dark")
-        self._sync_from_qapp_theme()

bec_widgets/applications/views/developer_view/developer_view.py

@@ -1,140 +0,0 @@
-from qtpy.QtWidgets import QWidget
-
-from bec_widgets.applications.views.developer_view.developer_widget import DeveloperWidget
-from bec_widgets.applications.views.view import ViewBase, ViewTourSteps
-
-
-class DeveloperView(ViewBase):
-    """
-    A view for users to write scripts and macros and execute them within the application.
-    """
-
-    def __init__(
-        self,
-        parent: QWidget | None = None,
-        content: QWidget | None = None,
-        *,
-        view_id: str | None = None,
-        title: str | None = None,
-        **kwargs,
-    ):
-        super().__init__(parent=parent, content=content, view_id=view_id, title=title, **kwargs)
-        self.developer_widget = DeveloperWidget(parent=self)
-        self.set_content(self.developer_widget)
-
-    def register_tour_steps(self, guided_tour, main_app) -> ViewTourSteps | None:
-        """Register Developer View components with the guided tour.
-
-        Args:
-            guided_tour: The GuidedTour instance to register with.
-            main_app: The main application instance (for accessing set_current).
-
-        Returns:
-            ViewTourSteps | None: Model containing view title and step IDs.
-        """
-        step_ids = []
-        dev_widget = self.developer_widget
-
-        # IDE Toolbar
-        def get_ide_toolbar():
-            main_app.set_current("developer_view")
-            return (dev_widget.toolbar, None)
-
-        step_id = guided_tour.register_widget(
-            widget=get_ide_toolbar,
-            title="IDE Toolbar",
-            text="Quick access to save files, execute scripts, and configure IDE settings. Use the toolbar to manage your code and execution.",
-        )
-        step_ids.append(step_id)
-
-        # IDE Explorer
-        def get_ide_explorer():
-            main_app.set_current("developer_view")
-            return (dev_widget.explorer_dock.widget(), None)
-
-        step_id = guided_tour.register_widget(
-            widget=get_ide_explorer,
-            title="File Explorer",
-            text="Browse and manage your macro files. Create new files, open existing ones, and organize your scripts.",
-        )
-        step_ids.append(step_id)
-
-        # IDE Editor
-        def get_ide_editor():
-            main_app.set_current("developer_view")
-            return (dev_widget.monaco_dock.widget(), None)
-
-        step_id = guided_tour.register_widget(
-            widget=get_ide_editor,
-            title="Code Editor",
-            text="Write and edit Python code with syntax highlighting, auto-completion, and signature help. Monaco editor provides a modern coding experience.",
-        )
-        step_ids.append(step_id)
-
-        # IDE Console
-        def get_ide_console():
-            main_app.set_current("developer_view")
-            return (dev_widget.console_dock.widget(), None)
-
-        step_id = guided_tour.register_widget(
-            widget=get_ide_console,
-            title="BEC Shell Console",
-            text="Interactive Python console with BEC integration. Execute commands, test code snippets, and interact with the BEC system in real-time.",
-        )
-        step_ids.append(step_id)
-
-        # IDE Plotting Area
-        def get_ide_plotting():
-            main_app.set_current("developer_view")
-            return (dev_widget.plotting_ads, None)
-
-        step_id = guided_tour.register_widget(
-            widget=get_ide_plotting,
-            title="Plotting Area",
-            text="View plots and visualizations generated by your scripts. Arrange multiple plots in a flexible layout.",
-        )
-        step_ids.append(step_id)
-
-        return ViewTourSteps(view_title="Developer View", step_ids=step_ids)
-
-
-if __name__ == "__main__":
-    import sys
-
-    from bec_qthemes import apply_theme
-    from qtpy.QtWidgets import QApplication
-
-    from bec_widgets.applications.main_app import BECMainApp
-
-    app = QApplication(sys.argv)
-    apply_theme("dark")
-
-    _app = BECMainApp()
-    screen = app.primaryScreen()
-    screen_geometry = screen.availableGeometry()
-    screen_width = screen_geometry.width()
-    screen_height = screen_geometry.height()
-    # 70% of screen height, keep 16:9 ratio
-    height = int(screen_height * 0.9)
-    width = int(height * (16 / 9))
-
-    # If width exceeds screen width, scale down
-    if width > screen_width * 0.9:
-        width = int(screen_width * 0.9)
-        height = int(width / (16 / 9))
-
-    _app.resize(width, height)
-    developer_view = DeveloperView()
-    _app.add_view(
-        icon="code_blocks",
-        title="IDE",
-        widget=developer_view,
-        view_id="developer_view",
-        exclusive=True,
-    )
-    _app.show()
-    # developer_view.show()
-    # developer_view.setWindowTitle("Developer View")
-    # developer_view.resize(1920, 1080)
-    # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime
-    sys.exit(app.exec_())

bec_widgets/applications/views/developer_view/developer_widget.py

@@ -1,432 +0,0 @@
-from __future__ import annotations
-
-import re
-
-import markdown
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.script_executor import upload_script
-from bec_qthemes import material_icon
-from qtpy.QtGui import QKeySequence, QShortcut
-from qtpy.QtWidgets import QTextEdit
-
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.toolbars.actions import MaterialIconAction
-from bec_widgets.utils.toolbars.bundles import ToolbarBundle
-from bec_widgets.utils.toolbars.toolbar import ModularToolBar
-from bec_widgets.widgets.containers.dock_area.basic_dock_area import DockAreaWidget
-from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
-from bec_widgets.widgets.containers.qt_ads import CDockWidget
-from bec_widgets.widgets.editors.monaco.monaco_dock import MonacoDock
-from bec_widgets.widgets.editors.monaco.monaco_widget import MonacoWidget
-from bec_widgets.widgets.editors.web_console.web_console import BECShell, WebConsole
-from bec_widgets.widgets.utility.ide_explorer.ide_explorer import IDEExplorer
-
-
-def markdown_to_html(md_text: str) -> str:
-    """Convert Markdown with syntax highlighting to HTML (Qt-compatible)."""
-
-    # Preprocess: convert consecutive >>> lines to Python code blocks
-    def replace_python_examples(match):
-        indent = match.group(1)
-        examples = match.group(2)
-        # Remove >>> prefix and clean up the code
-        lines = []
-        for line in examples.strip().split("\n"):
-            line = line.strip()
-            if line.startswith(">>> "):
-                lines.append(line[4:])  # Remove '>>> '
-            elif line.startswith(">>>"):
-                lines.append(line[3:])  # Remove '>>>'
-        code = "\n".join(lines)
-
-        return f"{indent}```python\n{indent}{code}\n{indent}```"
-
-    # Match one or more consecutive >>> lines (with same indentation)
-    pattern = r"^(\s*)((?:>>> .+(?:\n|$))+)"
-    md_text = re.sub(pattern, replace_python_examples, md_text, flags=re.MULTILINE)
-
-    extensions = ["fenced_code", "codehilite", "tables", "sane_lists"]
-    html = markdown.markdown(
-        md_text,
-        extensions=extensions,
-        extension_configs={
-            "codehilite": {"linenums": False, "guess_lang": False, "noclasses": True}
-        },
-        output_format="html",
-    )
-
-    # Remove hardcoded background colors that conflict with themes
-    html = re.sub(r'style="background: #[^"]*"', 'style="background: transparent"', html)
-    html = re.sub(r"background: #[^;]*;", "", html)
-
-    # Add CSS to force code blocks to wrap
-    css = """
-    <style>
-    pre, code {
-        white-space: pre-wrap !important;
-        word-wrap: break-word !important;
-        overflow-wrap: break-word !important;
-    }
-    .codehilite pre {
-        white-space: pre-wrap !important;
-        word-wrap: break-word !important;
-        overflow-wrap: break-word !important;
-    }
-    </style>
-    """
-
-    return css + html
-
-
-class DeveloperWidget(DockAreaWidget):
-    RPC = False
-    PLUGIN = False
-
-    def __init__(self, parent=None, **kwargs):
-        super().__init__(parent=parent, variant="compact", **kwargs)
-
-        # Promote toolbar above the dock manager provided by the base class
-        self.toolbar = ModularToolBar(self)
-        self.init_developer_toolbar()
-        self._root_layout.insertWidget(0, self.toolbar)
-
-        # Initialize the widgets
-        self.explorer = IDEExplorer(self)
-        self.explorer.setObjectName("Explorer")
-
-        self.console = BECShell(self, rpc_exposed=False)
-        self.console.setObjectName("BEC Shell")
-        self.terminal = WebConsole(self, rpc_exposed=False)
-        self.terminal.setObjectName("Terminal")
-        self.monaco = MonacoDock(self, rpc_exposed=False, rpc_passthrough_children=False)
-        self.monaco.setObjectName("MonacoEditor")
-        self.monaco.save_enabled.connect(self._on_save_enabled_update)
-        self.plotting_ads = BECDockArea(
-            self,
-            mode="plot",
-            default_add_direction="bottom",
-            profile_namespace="developer_plotting",
-            auto_profile_namespace=False,
-            enable_profile_management=False,
-            variant="compact",
-        )
-        self.plotting_ads.setObjectName("PlottingArea")
-        self.signature_help = QTextEdit(self)
-        self.signature_help.setObjectName("Signature Help")
-        self.signature_help.setAcceptRichText(True)
-        self.signature_help.setReadOnly(True)
-        self.signature_help.setLineWrapMode(QTextEdit.LineWrapMode.WidgetWidth)
-        opt = self.signature_help.document().defaultTextOption()
-        opt.setWrapMode(opt.WrapMode.WrapAnywhere)
-        self.signature_help.document().setDefaultTextOption(opt)
-        self.monaco.signature_help.connect(
-            lambda text: self.signature_help.setHtml(markdown_to_html(text))
-        )
-        self._current_script_id: str | None = None
-        self.script_editor_tab = None
-
-        self._initialize_layout()
-
-        # Connect editor signals
-        self.explorer.file_open_requested.connect(self._open_new_file)
-        self.monaco.macro_file_updated.connect(self.explorer.refresh_macro_file)
-        self.monaco.focused_editor.connect(self._on_focused_editor_changed)
-
-        self.toolbar.show_bundles(["save", "execution", "settings"])
-
-    def _initialize_layout(self) -> None:
-        """Create the default dock arrangement for the developer workspace."""
-
-        # Monaco editor as the central dock
-        self.monaco_dock = self.new(
-            self.monaco,
-            closable=False,
-            floatable=False,
-            movable=False,
-            return_dock=True,
-            show_title_bar=False,
-            show_settings_action=False,
-            title_buttons={"float": False, "close": False, "menu": False},
-            # promote_central=True,
-        )
-
-        # Explorer on the left without a title bar
-        self.explorer_dock = self.new(
-            self.explorer,
-            where="left",
-            closable=False,
-            floatable=False,
-            movable=False,
-            return_dock=True,
-            show_title_bar=False,
-        )
-
-        # Console and terminal tabbed along the bottom
-        self.console_dock = self.new(
-            self.console,
-            relative_to=self.monaco_dock,
-            where="bottom",
-            closable=False,
-            floatable=False,
-            movable=False,
-            return_dock=True,
-            title_buttons={"float": True, "close": False},
-        )
-        self.terminal_dock = self.new(
-            self.terminal,
-            closable=False,
-            floatable=False,
-            movable=False,
-            tab_with=self.console_dock,
-            return_dock=True,
-            title_buttons={"float": False, "close": False},
-        )
-
-        # Plotting area on the right with signature help tabbed alongside
-        self.plotting_ads_dock = self.new(
-            self.plotting_ads,
-            where="right",
-            closable=False,
-            floatable=False,
-            movable=False,
-            return_dock=True,
-            title_buttons={"float": True},
-        )
-        self.signature_dock = self.new(
-            self.signature_help,
-            closable=False,
-            floatable=False,
-            movable=False,
-            tab_with=self.plotting_ads_dock,
-            return_dock=True,
-            title_buttons={"float": False, "close": False},
-        )
-
-        self.set_layout_ratios(horizontal=[2, 5, 3], vertical=[7, 3])
-
-    def init_developer_toolbar(self):
-        """Initialize the developer toolbar with necessary actions and widgets."""
-        save_button = MaterialIconAction(
-            icon_name="save", tooltip="Save", label_text="Save", filled=True, parent=self
-        )
-        save_button.action.triggered.connect(self.on_save)
-        self.toolbar.components.add_safe("save", save_button)
-
-        save_as_button = MaterialIconAction(
-            icon_name="save_as", tooltip="Save As", label_text="Save As", parent=self
-        )
-        self.toolbar.components.add_safe("save_as", save_as_button)
-        save_as_button.action.triggered.connect(self.on_save_as)
-
-        save_bundle = ToolbarBundle("save", self.toolbar.components)
-        save_bundle.add_action("save")
-        save_bundle.add_action("save_as")
-        self.toolbar.add_bundle(save_bundle)
-
-        run_action = MaterialIconAction(
-            icon_name="play_arrow",
-            tooltip="Run current file",
-            label_text="Run",
-            filled=True,
-            parent=self,
-        )
-        run_action.action.triggered.connect(self.on_execute)
-        self.toolbar.components.add_safe("run", run_action)
-
-        stop_action = MaterialIconAction(
-            icon_name="stop",
-            tooltip="Stop current execution",
-            label_text="Stop",
-            filled=True,
-            parent=self,
-        )
-        stop_action.action.triggered.connect(self.on_stop)
-        self.toolbar.components.add_safe("stop", stop_action)
-
-        execution_bundle = ToolbarBundle("execution", self.toolbar.components)
-        execution_bundle.add_action("run")
-        execution_bundle.add_action("stop")
-        self.toolbar.add_bundle(execution_bundle)
-
-        vim_action = MaterialIconAction(
-            icon_name="vim",
-            tooltip="Toggle Vim Mode",
-            label_text="Vim",
-            filled=True,
-            parent=self,
-            checkable=True,
-        )
-        self.toolbar.components.add_safe("vim", vim_action)
-        vim_action.action.triggered.connect(self.on_vim_triggered)
-
-        settings_bundle = ToolbarBundle("settings", self.toolbar.components)
-        settings_bundle.add_action("vim")
-        self.toolbar.add_bundle(settings_bundle)
-
-        save_shortcut = QShortcut(QKeySequence("Ctrl+S"), self)
-        save_shortcut.activated.connect(self.on_save)
-        save_as_shortcut = QShortcut(QKeySequence("Ctrl+Shift+S"), self)
-        save_as_shortcut.activated.connect(self.on_save_as)
-
-    def _open_new_file(self, file_name: str, scope: str):
-        self.monaco.open_file(file_name, scope)
-
-        # Set read-only mode for shared files
-        if "shared" in scope:
-            self.monaco.set_file_readonly(file_name, True)
-
-        # Add appropriate icon based on file type
-        if "script" in scope:
-            # Use script icon for script files
-            icon = material_icon("script", size=(24, 24))
-            self.monaco.set_file_icon(file_name, icon)
-        elif "macro" in scope:
-            # Use function icon for macro files
-            icon = material_icon("function", size=(24, 24))
-            self.monaco.set_file_icon(file_name, icon)
-
-    @SafeSlot()
-    def on_save(self):
-        """Save the currently focused file in the Monaco editor."""
-        self.monaco.save_file()
-
-    @SafeSlot()
-    def on_save_as(self):
-        """Save the currently focused file in the Monaco editor with a 'Save As' dialog."""
-        self.monaco.save_file(force_save_as=True)
-
-    @SafeSlot()
-    def on_vim_triggered(self):
-        """Toggle Vim mode in the Monaco editor."""
-        self.monaco.set_vim_mode(self.toolbar.components.get_action("vim").action.isChecked())
-
-    @SafeSlot(bool)
-    def _on_save_enabled_update(self, enabled: bool):
-        self.toolbar.components.get_action("save").action.setEnabled(enabled)
-        self.toolbar.components.get_action("save_as").action.setEnabled(enabled)
-
-    @SafeSlot()
-    def on_execute(self):
-        """Upload and run the currently focused script in the Monaco editor."""
-        self.script_editor_tab = self.monaco.last_focused_editor
-        if not self.script_editor_tab:
-            return
-        widget = self.script_editor_tab.widget()
-        if not isinstance(widget, MonacoWidget):
-            return
-        if widget.modified:
-            # Save the file before execution if there are unsaved changes
-            self.monaco.save_file()
-            if widget.modified:
-                # If still modified, user likely cancelled save dialog
-                return
-        self.current_script_id = upload_script(self.client.connector, widget.get_text())
-        self.console.write(f'bec._run_script("{self.current_script_id}")')
-        print(f"Uploaded script with ID: {self.current_script_id}")
-
-    @SafeSlot()
-    def on_stop(self):
-        """Stop the execution of the currently running script"""
-        if not self.current_script_id:
-            return
-        self.console.send_ctrl_c()
-
-    @property
-    def current_script_id(self):
-        """Get the ID of the currently running script."""
-        return self._current_script_id
-
-    @current_script_id.setter
-    def current_script_id(self, value: str | None):
-        """
-        Set the ID of the currently running script.
-
-        Args:
-            value (str | None): The script ID to set.
-        Raises:
-            ValueError: If the provided value is not a string or None.
-        """
-        if value is not None and not isinstance(value, str):
-            raise ValueError("Script ID must be a string.")
-        old_script_id = self._current_script_id
-        self._current_script_id = value
-        self._update_subscription(value, old_script_id)
-
-    def _update_subscription(self, new_script_id: str | None, old_script_id: str | None):
-        if old_script_id is not None:
-            self.bec_dispatcher.disconnect_slot(
-                self.on_script_execution_info, MessageEndpoints.script_execution_info(old_script_id)
-            )
-        if new_script_id is not None:
-            self.bec_dispatcher.connect_slot(
-                self.on_script_execution_info, MessageEndpoints.script_execution_info(new_script_id)
-            )
-
-    @SafeSlot(CDockWidget)
-    def _on_focused_editor_changed(self, tab_widget: CDockWidget):
-        """
-        Disable the run / stop buttons if the focused editor is a macro file.
-        Args:
-            tab_widget: The currently focused tab widget in the Monaco editor.
-        """
-        if not isinstance(tab_widget, CDockWidget):
-            return
-        widget = tab_widget.widget()
-        if not isinstance(widget, MonacoWidget):
-            return
-        file_scope = widget.metadata.get("scope", "")
-        run_action = self.toolbar.components.get_action("run")
-        stop_action = self.toolbar.components.get_action("stop")
-        if "macro" in file_scope:
-            run_action.action.setEnabled(False)
-            stop_action.action.setEnabled(False)
-        else:
-            run_action.action.setEnabled(True)
-            stop_action.action.setEnabled(True)
-
-    @SafeSlot(dict, dict)
-    def on_script_execution_info(self, content: dict, metadata: dict):
-        """
-        Handle script execution info messages to update the editor highlights.
-        Args:
-            content (dict): The content of the message containing execution info.
-            metadata (dict): Additional metadata for the message.
-        """
-        print(f"Script execution info: {content}")
-        current_lines = content.get("current_lines")
-        if self.script_editor_tab is None:
-            return
-        widget = self.script_editor_tab.widget()
-        if not isinstance(widget, MonacoWidget):
-            return
-        if not current_lines:
-            widget.clear_highlighted_lines()
-            return
-        line_number = current_lines[0]
-        widget.clear_highlighted_lines()
-        widget.set_highlighted_lines(line_number, line_number)
-
-    def cleanup(self):
-        """Clean up resources used by the developer widget."""
-        self.delete_all()
-        return super().cleanup()
-
-
-if __name__ == "__main__":
-    import sys
-
-    from bec_qthemes import apply_theme
-    from qtpy.QtWidgets import QApplication
-
-    from bec_widgets.applications.main_app import BECMainApp
-
-    app = QApplication(sys.argv)
-    apply_theme("dark")
-
-    _app = BECMainApp()
-    _app.show()
-    # developer_view.show()
-    # developer_view.setWindowTitle("Developer View")
-    # developer_view.resize(1920, 1080)
-    # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime
-    sys.exit(app.exec_())

bec_widgets/applications/views/device_manager_view/device_manager_dialogs/__init__.py

@@ -1,2 +0,0 @@
-from .config_choice_dialog import ConfigChoiceDialog
-from .device_form_dialog import DeviceFormDialog

bec_widgets/applications/views/device_manager_view/device_manager_dialogs/config_choice_dialog.py

@@ -1,49 +0,0 @@
-"""Dialog to choose config loading method: replace, add or cancel."""
-
-from enum import IntEnum
-
-from qtpy.QtWidgets import QDialog, QDialogButtonBox, QLabel, QSizePolicy, QVBoxLayout
-
-
-class ConfigChoiceDialog(QDialog):
-    class Result(IntEnum):
-        CANCEL = QDialog.Rejected
-        ADD = 2
-        REPLACE = 3
-
-    def __init__(
-        self,
-        parent=None,
-        custom_label: str = "Do you want to replace the current config or add to it?",
-    ):
-        super().__init__(parent)
-        self.setWindowTitle("Load Config")
-
-        layout = QVBoxLayout(self)
-
-        label = QLabel(custom_label)
-        label.setWordWrap(True)
-        layout.addWidget(label)
-
-        # Use QDialogButtonBox for native layout
-        self.button_box = QDialogButtonBox(self)
-        self.cancel_btn = self.button_box.addButton(
-            "Cancel", QDialogButtonBox.ButtonRole.ActionRole  # RejectRole will be next to Accept...
-        )
-        self.replace_btn = self.button_box.addButton(
-            "Replace", QDialogButtonBox.ButtonRole.AcceptRole
-        )
-        self.add_btn = self.button_box.addButton("Add", QDialogButtonBox.ButtonRole.AcceptRole)
-
-        layout.addWidget(self.button_box)
-
-        for btn in [self.replace_btn, self.add_btn, self.cancel_btn]:
-            btn.setMinimumWidth(80)
-            btn.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
-
-        # Connections using native done(int)
-        self.replace_btn.clicked.connect(lambda: self.done(self.Result.REPLACE))
-        self.add_btn.clicked.connect(lambda: self.done(self.Result.ADD))
-        self.cancel_btn.clicked.connect(lambda: self.done(self.Result.CANCEL))
-
-        self.replace_btn.setFocus()

bec_widgets/applications/views/device_manager_view/device_manager_dialogs/device_form_dialog.py

@@ -1,447 +0,0 @@
-"""Dialogs for device configuration forms and ophyd testing."""
-
-from typing import Any, Iterable, Tuple
-
-from bec_lib.atlas_models import Device as DeviceModel
-from bec_lib.logger import bec_logger
-from ophyd_devices.interfaces.device_config_templates.ophyd_templates import OPHYD_DEVICE_TEMPLATES
-from qtpy import QtCore, QtWidgets
-
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.widgets.control.device_manager.components import OphydValidation
-from bec_widgets.widgets.control.device_manager.components.device_config_template.device_config_template import (
-    DeviceConfigTemplate,
-)
-from bec_widgets.widgets.control.device_manager.components.device_config_template.template_items import (
-    validate_name,
-)
-from bec_widgets.widgets.control.device_manager.components.ophyd_validation import (
-    ConfigStatus,
-    ConnectionStatus,
-    format_error_to_md,
-)
-
-DEFAULT_DEVICE = "CustomDevice"
-_ValidationResultIter = Iterable[Tuple[dict[str, Any], ConfigStatus, ConnectionStatus, str]]
-
-
-logger = bec_logger.logger
-
-
-class DeviceManagerOphydValidationDialog(QtWidgets.QDialog):
-    """Popup dialog to test Ophyd device configurations interactively."""
-
-    def __init__(self, parent=None, config: dict | None = None):  # type: ignore
-        super().__init__(parent)
-        self.setWindowTitle("Device Manager Ophyd Test")
-        self._config_status = ConfigStatus.UNKNOWN.value
-        self._connection_status = ConnectionStatus.UNKNOWN.value
-        self._validated_config: dict = {}
-        self._validation_msg: str = ""
-
-        layout = QtWidgets.QVBoxLayout(self)
-
-        # Core test widget
-        self.device_manager_ophyd_test = OphydValidation()
-        layout.addWidget(self.device_manager_ophyd_test)
-
-        # Log/Markdown box for messages
-        self.text_box = QtWidgets.QTextEdit()
-        self.text_box.setReadOnly(True)
-        layout.addWidget(self.text_box)
-
-        # Load and apply configuration
-        config = config or {}
-        device_name = config.get("name", None)
-        if device_name:
-            self.device_manager_ophyd_test.add_device_to_keep_visible_after_validation(device_name)
-
-        # Dialog Buttons: equal size, stacked horizontally
-        button_box = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.StandardButton.Close)
-        for button in button_box.buttons():
-            button.setSizePolicy(
-                QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed
-            )
-            button.clicked.connect(self.accept)
-        # button_box.setCenterButtons(False)
-        layout.addWidget(button_box)
-        self.device_manager_ophyd_test.validation_completed.connect(self._on_device_validated)
-        self._resize_dialog()
-        self.finished.connect(self._finished)
-
-        # Add and test device config
-        self.device_manager_ophyd_test.change_device_configs([config], added=True, connect=True)
-
-    def _resize_dialog(self):
-        """Resize the dialog based on the screen size."""
-        app: QtCore.QCoreApplication = QtWidgets.QApplication.instance()
-        screen = app.primaryScreen()
-        screen_geometry = screen.availableGeometry()
-        screen_width = screen_geometry.width()
-        screen_height = screen_geometry.height()
-        # 70% of screen height, keep 4:3 ratio
-        height = int(screen_height * 0.7)
-        width = int(height * (4 / 3))
-
-        # If width exceeds screen width, scale down
-        if width > screen_width * 0.9:
-            width = int(screen_width * 0.9)
-            height = int(width / (4 / 3))
-
-        self.resize(width, height)
-
-    def _on_device_validated(
-        self, device_config: dict, config_status: int, connection_status: int, validation_msg: str
-    ):
-        device_name = device_config.get("name", "")
-        self._config_status = config_status
-        self._connection_status = connection_status
-        self._validated_config = device_config
-        self._validation_msg = validation_msg
-        self.text_box.setMarkdown(format_error_to_md(device_name, validation_msg))
-
-    @SafeSlot(int)
-    def _finished(self, state: int):
-        self.device_manager_ophyd_test.close()
-        self.device_manager_ophyd_test.deleteLater()
-
-    @property
-    def validation_result(self) -> tuple[dict, int, int, str]:
-        """
-        Return the result of the validation as a tuple of
-
-        Returns:
-            result (Tuple[dict, int, int]): A tuple containing:
-                                            validated_config (dict): The validated device configuration.
-                                            config_status (int): The configuration status.
-                                            connection_status (int): The connection status.
-
-        """
-        return (
-            self._validated_config,
-            self._config_status,
-            self._connection_status,
-            self._validation_msg,
-        )
-
-
-class DeviceFormDialog(QtWidgets.QDialog):
-
-    # Signal emitted when device configuration is accepted, only
-    # emitted when the user clicks the "Add Device" button
-    # The integer values indicate if the device config was
-    # validated: config_status, connection_status
-    accepted_data = QtCore.Signal(dict, int, int, str, str)
-
-    def __init__(self, parent=None, add_btn_text: str = "Add Device"):  # type: ignore
-        super().__init__(parent)
-        # Track old device name if config is edited
-        self._old_device_name: str = ""
-
-        # Config validation result
-        self._validation_result: tuple[dict, int, int, str] = (
-            {},
-            ConfigStatus.UNKNOWN.value,
-            ConnectionStatus.UNKNOWN.value,
-            "",
-        )
-        # Group to variants mapping
-        self._group_variants: dict[str, list[str]] = {
-            group: [variant for variant in variants.keys()]
-            for group, variants in OPHYD_DEVICE_TEMPLATES.items()
-        }
-
-        self._control_widgets: dict[str, QtWidgets.QWidget] = {}
-
-        # Setup layout
-        self.setWindowTitle("Device Config Dialog")
-        layout = QtWidgets.QVBoxLayout(self)
-
-        # Control panel
-        self._control_box = self.create_control_panel()
-        layout.addWidget(self._control_box)
-
-        # Device config template display
-        self._device_config_template = DeviceConfigTemplate(parent=self)
-        self._frame = QtWidgets.QFrame()
-        self._frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
-        self._frame.setFrameShadow(QtWidgets.QFrame.Raised)
-        frame_layout = QtWidgets.QVBoxLayout(self._frame)
-        frame_layout.addWidget(self._device_config_template)
-        layout.addWidget(self._frame)
-
-        # Custom buttons
-        self.add_btn = QtWidgets.QPushButton(add_btn_text)
-        self.test_connection_btn = QtWidgets.QPushButton("Test Connection")
-        self.cancel_btn = QtWidgets.QPushButton("Cancel")
-        self.reset_btn = QtWidgets.QPushButton("Reset Form")
-
-        btn_box = QtWidgets.QDialogButtonBox(self)
-        btn_box.addButton(self.cancel_btn, QtWidgets.QDialogButtonBox.ButtonRole.RejectRole)
-        btn_box.addButton(self.reset_btn, QtWidgets.QDialogButtonBox.ButtonRole.ActionRole)
-        btn_box.addButton(
-            self.test_connection_btn, QtWidgets.QDialogButtonBox.ButtonRole.ActionRole
-        )
-        btn_box.addButton(self.add_btn, QtWidgets.QDialogButtonBox.ButtonRole.AcceptRole)
-        for btn in btn_box.buttons():
-            btn.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
-        layout.addWidget(btn_box)
-
-        frame_layout.addWidget(btn_box)
-
-        # Connect signals to explicit slots
-        self.add_btn.clicked.connect(self._add_config)
-        self.test_connection_btn.clicked.connect(self._test_connection)
-        self.reset_btn.clicked.connect(self._reset_config)
-        self.cancel_btn.clicked.connect(self._reject_config)
-
-        # layout.addWidget(self._device_config_template)
-        self.update_variant_combo(self._control_widgets["group_combo"].currentText())
-        self.finished.connect(self._finished)
-
-        # Wait dialog when adding config
-        self._wait_dialog: QtWidgets.QProgressDialog | None = None
-
-    @SafeSlot(int)
-    def _finished(self, state: int):
-        for widget in self._control_widgets.values():
-            widget.close()
-            widget.deleteLater()
-        if self._wait_dialog is not None:
-            self._wait_dialog.close()
-            self._wait_dialog.deleteLater()
-
-    @property
-    def config_validation_result(self) -> tuple[dict, int, int, str]:
-        """Return the result of the last configuration validation."""
-        return self._validation_result
-
-    @config_validation_result.setter
-    def config_validation_result(self, result: tuple[dict, int, int, str]):
-        self._validation_result = result
-
-    def set_device_config(self, device_config: dict):
-        """Set the device configuration in the template form."""
-        # Figure out which group and variant this config belongs to
-        device_class = device_config.get("deviceClass", None)
-        for group, variants in OPHYD_DEVICE_TEMPLATES.items():
-            for variant, template_info in variants.items():
-                if template_info.get("deviceClass", None) == device_class:
-                    # Found the matching group and variant
-                    self._control_widgets["group_combo"].setCurrentText(group)
-                    self.update_variant_combo(group)
-                    self._control_widgets["variant_combo"].setCurrentText(variant)
-                    self._device_config_template.set_config_fields(device_config)
-                    return
-        # If no match found, set to default
-        self._control_widgets["group_combo"].setCurrentText(DEFAULT_DEVICE)
-        self.update_variant_combo(DEFAULT_DEVICE)
-        self._device_config_template.set_config_fields(device_config)
-        self._old_device_name = device_config.get("name", "")
-
-    def sizeHint(self) -> QtCore.QSize:
-        return QtCore.QSize(1600, 1000)
-
-    def create_control_panel(self) -> QtWidgets.QGroupBox:
-        self._control_box = QtWidgets.QGroupBox("Choose a Device Group")
-        layout = QtWidgets.QGridLayout(self._control_box)
-
-        group_label = QtWidgets.QLabel("Device Group:")
-        layout.addWidget(group_label, 0, 0)
-
-        group_combo = QtWidgets.QComboBox()
-        group_combo.addItems(self._group_variants.keys())
-        self._control_widgets["group_combo"] = group_combo
-        layout.addWidget(group_combo, 1, 0)
-
-        variant_label = QtWidgets.QLabel("Variants:")
-        layout.addWidget(variant_label, 0, 1)
-
-        variant_combo = QtWidgets.QComboBox()
-        self._control_widgets["variant_combo"] = variant_combo
-        layout.addWidget(variant_combo, 1, 1)
-
-        group_combo.currentTextChanged.connect(self.update_variant_combo)
-        variant_combo.currentTextChanged.connect(self.update_device_config_template)
-
-        return self._control_box
-
-    def update_variant_combo(self, group_name: str):
-        variant_combo = self._control_widgets["variant_combo"]
-        variant_combo.clear()
-        variant_combo.addItems(self._group_variants.get(group_name, []))
-        if variant_combo.count() <= 1:
-            variant_combo.setEnabled(False)
-        else:
-            variant_combo.setEnabled(True)
-
-    def update_device_config_template(self, variant_name: str):
-        group_name = self._control_widgets["group_combo"].currentText()
-        template_info = OPHYD_DEVICE_TEMPLATES.get(group_name, {}).get(variant_name, {})
-        if template_info:
-            self._device_config_template.change_template(template_info)
-        else:
-            self._device_config_template.change_template(
-                OPHYD_DEVICE_TEMPLATES[DEFAULT_DEVICE][DEFAULT_DEVICE]
-            )
-
-    def _create_validation_dialog(self) -> QtWidgets.QProgressDialog:
-        """
-        Create and show a validation progress dialog while validating the device configuration.
-        The dialog will be modal and prevent user interaction until validation is complete.
-        """
-        wait_dialog = QtWidgets.QProgressDialog(
-            "Validating config... please wait", None, 0, 0, parent=self
-        )
-        wait_dialog.setWindowModality(QtCore.Qt.WindowModality.ApplicationModal)
-        wait_dialog.setCancelButton(None)
-        wait_dialog.setMinimumDuration(0)
-        return wait_dialog
-
-    def _create_and_run_ophyd_validation(self, config: dict[str, Any]) -> OphydValidation:
-        """Run ophyd validation test on the current device configuration."""
-        ophyd_validation = OphydValidation(parent=self)
-        ophyd_validation.validation_completed.connect(self._handle_validation_result)
-        ophyd_validation.multiple_validations_completed.connect(
-            self._handle_devices_already_in_session_results
-        )
-
-        # NOTE Use singleShot here to ensure that the signal is emitted after all other scheduled
-        # tasks in the event loop are processed. This avoids potential deadlocks. In particular,
-        # this is relevant for the _wait_dialog exec which opens a modal dialog during validation
-        # and therefore must not have the signal emitted immediately in the same event loop iteration.
-        # Otherwise, the callback may be scheduled before the dialog is shown resulting in a deadlock.
-        QtCore.QTimer.singleShot(
-            0, lambda: ophyd_validation.change_device_configs([config], True, False)
-        )
-        return ophyd_validation
-
-    @SafeSlot(list)
-    def _handle_devices_already_in_session_results(
-        self, validation_results: _ValidationResultIter
-    ) -> None:
-        """Handle completion if device is already in session."""
-        if len(validation_results) != 1:
-            logger.error(
-                "Expected a single device validation result, but got multiple. Using first result."
-            )
-        result = validation_results[0] if len(validation_results) > 0 else None
-        if result is None:
-            logger.error(
-                f"Received validation results: {validation_results} of unexpected length 0. Returning."
-            )
-            return
-        device_config, config_status, connection_status, validation_msg = result
-        self._handle_validation_result(
-            device_config, config_status, connection_status, validation_msg
-        )
-
-    @SafeSlot(dict, int, int, str)
-    def _handle_validation_result(
-        self, device_config: dict, config_status: int, connection_status: int, validation_msg: str
-    ):
-        """Handle completion of validation."""
-        try:
-            if (
-                DeviceModel.model_validate(device_config)
-                == DeviceModel.model_validate(self._validation_result[0])
-                and connection_status == ConnectionStatus.UNKNOWN.value
-            ):
-                # Config unchanged, we can reuse previous connection status. Only do this if the new
-                # connection status is UNKNOWN as the current validation should not test the connection.
-                connection_status = self._validation_result[2]
-                validation_msg = self._validation_result[3]
-        except Exception:
-            logger.debug(
-                f"Device config validation changed for config: {device_config} compared to previous validation. Using status from recent validation."
-            )
-        self._validation_result = (device_config, config_status, connection_status, validation_msg)
-        if self._wait_dialog is not None:
-            self._wait_dialog.accept()
-            self._wait_dialog.close()
-            self._wait_dialog.deleteLater()
-            self._wait_dialog = None
-
-    def _add_config(self):
-        """
-        Adding a config will always run a validation check of the config without a connection test.
-        We will check if tests have already run, and reuse the information in case they also tested the connection to the device.
-        """
-        config = self._device_config_template.get_config_fields()
-
-        # I. First we validate that the device name is valid, as this may create issues within the OphydValidation widget.
-        # Validate device name first. If invalid, this should immediately block adding the device.
-        if not validate_name(config.get("name", "")):
-            msg_box = self._create_warning_message_box(
-                "Invalid Device Name",
-                f"Device is invalid, cannot be empty or contain spaces. Please provide a valid name. {config.get('name', '')!r}",
-            )
-            msg_box.exec()
-            return
-
-        # II. Next we will run the validation check of the config without connection test.
-        # We will show a wait dialog while this is happening, and compare the results with the last known validation results.
-        # If the config is unchanged, we will use the connection status results from the last validation.
-        self._wait_dialog = self._create_validation_dialog()
-        ophyd_validation: OphydValidation | None = None
-        try:
-            ophyd_validation = self._create_and_run_ophyd_validation(config)
-
-            # NOTE If dialog was already closed, this means that a validation callback was already received
-            # which closed the dialog. In this case, we skip exec to avoid deadlock. With the singleShot above,
-            # this should not happen, but we keep the check for safety.
-            if self._wait_dialog is not None:
-                self._wait_dialog.exec()  # This will block until the validation is complete
-
-            config, config_status, connection_status, validation_msg = self._validation_result
-
-            if config_status == ConfigStatus.INVALID.value:
-                msg_box = self._create_warning_message_box(
-                    "Invalid Device Configuration",
-                    f"Device configuration is invalid. Last known validation message:\n\nErrors:\n{self._validation_result[3]}",
-                )
-                msg_box.exec()
-                return
-
-            self.accepted_data.emit(
-                config, config_status, connection_status, validation_msg, self._old_device_name
-            )
-            self.accept()
-        finally:
-            if ophyd_validation is not None:
-                ophyd_validation.close()
-                ophyd_validation.deleteLater()
-
-    def _create_warning_message_box(self, title: str, text: str) -> QtWidgets.QMessageBox:
-        msg_box = QtWidgets.QMessageBox(self)
-        msg_box.setIcon(QtWidgets.QMessageBox.Warning)
-        msg_box.setWindowTitle(title)
-        msg_box.setText(text)
-        return msg_box
-
-    def _test_connection(self):
-        config = self._device_config_template.get_config_fields()
-        dialog = DeviceManagerOphydValidationDialog(self, config=config)
-        result = dialog.exec()
-        if result in (QtWidgets.QDialog.Accepted, QtWidgets.QDialog.Rejected):
-            self.config_validation_result = dialog.validation_result
-
-    def _reset_config(self):
-        self._device_config_template.reset_to_defaults()
-
-    def _reject_config(self):
-        self.reject()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from bec_qthemes import apply_theme
-
-    app = QtWidgets.QApplication(sys.argv)
-    apply_theme("light")
-
-    dialog = DeviceFormDialog()
-    dialog.resize(1200, 800)
-    dialog.show()
-    sys.exit(app.exec())

bec_widgets/applications/views/device_manager_view/device_manager_dialogs/upload_redis_dialog.py

@@ -1,691 +0,0 @@
-"""Module for the upload redis dialog in the device manager view."""
-
-from __future__ import annotations
-
-from enum import IntEnum
-from functools import partial
-from typing import TYPE_CHECKING, Any, List, Tuple
-
-from bec_lib.logger import bec_logger
-from bec_qthemes import apply_theme, material_icon
-from qtpy import QtCore, QtGui, QtWidgets
-
-from bec_widgets.utils.colors import get_accent_colors
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.widgets.control.device_manager.components.ophyd_validation import (
-    ConfigStatus,
-    ConnectionStatus,
-    get_validation_icons,
-)
-
-if TYPE_CHECKING:
-    from bec_widgets.utils.colors import AccentColor
-    from bec_widgets.widgets.control.device_manager.components.device_table.device_table import (
-        _ValidationResultIter,
-    )
-
-logger = bec_logger.logger
-
-
-class DeviceStatusItem(QtWidgets.QWidget):
-    """Individual device status item widget for the validation display."""
-
-    def __init__(
-        self, device_config: dict, config_status: int, connection_status: int, parent=None
-    ):
-        super().__init__(parent)
-        self.device_name = device_config.get("name", "")
-        self.device_config: dict = device_config
-        self.config_status = ConfigStatus(config_status)
-        self.connection_status = ConnectionStatus(connection_status)
-        self._transparent_button_style = "background-color: transparent; border: none;"
-
-        # Get validation icons
-        self.colors = get_accent_colors()
-        self._icon_size = (20, 20)
-        self.icons = get_validation_icons(self.colors, self._icon_size)
-
-        self._setup_ui()
-        self._update_display()
-
-    def _setup_ui(self):
-        """Setup the UI for the device status item."""
-        layout = QtWidgets.QHBoxLayout(self)
-        layout.setContentsMargins(8, 4, 8, 4)
-        layout.setSpacing(8)
-
-        # Device name label
-        self.name_label = QtWidgets.QLabel(self.device_name)
-        self.name_label.setMinimumWidth(150)
-        layout.addWidget(self.name_label)
-        layout.addStretch()
-
-        # Config status icon
-        self.config_icon_label = self._create_status_icon_label(self._icon_size)
-        layout.addWidget(self.config_icon_label)
-
-        # Connection status icon
-        self.connection_icon_label = self._create_status_icon_label(self._icon_size)
-        layout.addWidget(self.connection_icon_label)
-
-    def _create_status_icon_label(self, icon_size: tuple[int, int]) -> QtWidgets.QPushButton:
-        button = QtWidgets.QPushButton()
-        button.setFlat(True)
-        button.setEnabled(False)
-        button.setStyleSheet(self._transparent_button_style)
-        button.setFixedSize(icon_size[0], icon_size[1])
-        return button
-
-    def _update_display(self):
-        """Update the visual display based on current status."""
-        # Update config status
-        config_icon = self.icons["config_status"].get(self.config_status.value)
-        if config_icon:
-            self.config_icon_label.setIcon(config_icon)
-
-        # Update connection status
-        connection_icon = self.icons["connection_status"].get(self.connection_status.value)
-        if connection_icon:
-            self.connection_icon_label.setIcon(connection_icon)
-
-    def update_status(self, config_status: int, connection_status: int):
-        """Update the status and refresh display."""
-        self.config_status = ConfigStatus(config_status)
-        self.connection_status = ConnectionStatus(connection_status)
-        self._update_display()
-
-
-class SortTableItem(QtWidgets.QTableWidgetItem):
-    """Custom TableWidgetItem with hidden __column_data attribute for sorting."""
-
-    def __lt__(self, other: QtWidgets.QTableWidgetItem) -> bool:
-        """Override less-than operator for sorting."""
-        if not isinstance(other, QtWidgets.QTableWidgetItem):
-            return NotImplemented
-        self_data = self.data(QtCore.Qt.ItemDataRole.UserRole)
-        other_data = other.data(QtCore.Qt.ItemDataRole.UserRole)
-        if self_data is not None and other_data is not None:
-            self_data: DeviceStatusItem
-            other_data: DeviceStatusItem
-            if self_data.config_status != other_data.config_status:
-                return self_data.config_status < other_data.config_status
-            else:
-                return self_data.connection_status < other_data.connection_status
-        return super().__lt__(other)
-
-    def __gt__(self, other: QtWidgets.QTableWidgetItem) -> bool:
-        """Override less-than operator for sorting."""
-        if not isinstance(other, QtWidgets.QTableWidgetItem):
-            return NotImplemented
-        self_data = self.data(QtCore.Qt.ItemDataRole.UserRole)
-        other_data = other.data(QtCore.Qt.ItemDataRole.UserRole)
-        if self_data is not None and other_data is not None:
-            self_data: DeviceStatusItem
-            other_data: DeviceStatusItem
-            if self_data.config_status != other_data.config_status:
-                return self_data.config_status > other_data.config_status
-            else:
-                return self_data.connection_status > other_data.connection_status
-        return super().__gt__(other)
-
-
-class ValidationSection(QtWidgets.QGroupBox):
-    """Section widget for displaying validation results."""
-
-    def __init__(self, title: str, parent=None):
-        super().__init__(title, parent=parent)
-        self._setup_ui()
-        # self.device_items: Dict[str, DeviceStatusItem] = {}
-
-    def _setup_ui(self):
-        """Setup the UI for the validation section."""
-        layout = QtWidgets.QVBoxLayout(self)
-
-        # Status summary label
-        summary_layout = QtWidgets.QHBoxLayout()
-        self.summary_icon = QtWidgets.QLabel()
-        self.summary_icon.setFixedSize(24, 24)
-        self.summary_label = QtWidgets.QLabel()
-        self.summary_label.setWordWrap(True)
-        summary_layout.addWidget(self.summary_icon)
-        summary_layout.addWidget(self.summary_label)
-        layout.addLayout(summary_layout)
-
-        # Scroll area for device items
-        self.table = QtWidgets.QTableWidget()
-        self.table.setColumnCount(1)
-        self.table.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Stretch)
-        self.table.horizontalHeader().hide()
-        self.table.verticalHeader().hide()
-        self.table.setShowGrid(False)  # r
-        self.table.sortItems(0, QtCore.Qt.SortOrder.AscendingOrder)
-        layout.addWidget(self.table)
-        QtCore.QTimer.singleShot(0, self.adjustSize)
-
-    def add_device(self, device_config: dict, config_status: int, connection_status: int):
-        """
-        Add a device to the validation section.
-
-        Args:
-            device_config (dict): The device configuration dictionary.
-            config_status (int): The configuration status.
-            connection_status (int): The connection status.
-        """
-        self.table.setSortingEnabled(False)
-        device_name = device_config.get("name", "")
-        row = self._find_row_by_name(device_name)
-        if row is not None:
-            widget: DeviceStatusItem = self.table.cellWidget(row, 0)
-            widget.update_status(config_status, connection_status)
-        else:
-            row_position = self.table.rowCount()
-            self.table.insertRow(row_position)
-            sort_item = SortTableItem(device_name)
-            sort_item.setText("")
-            self.table.setItem(row_position, 0, sort_item)
-            device_item = DeviceStatusItem(device_config, config_status, connection_status)
-            sort_item.setData(QtCore.Qt.ItemDataRole.UserRole, device_item)
-            self.table.setCellWidget(row_position, 0, device_item)
-        self.table.resizeRowsToContents()
-        self.table.setSortingEnabled(True)
-
-    def _find_row_by_name(self, device_name: str) -> int | None:
-        """
-        Find a row by device name.
-
-        Args:
-            name (str): The name of the device to find.
-        Returns:
-            int | None: The row index if found, else None.
-        """
-        for row in range(self.table.rowCount()):
-            item: SortTableItem = self.table.item(row, 0)
-            widget: DeviceStatusItem = self.table.cellWidget(row, 0)
-            if widget.device_name == device_name:
-                return row
-        return None
-
-    def remove_device(self, device_name: str):
-        """Remove a device from the table by name."""
-        self.table.setSortingEnabled(False)
-        row = self._find_row_by_name(device_name)
-        if row is not None:
-            self.table.removeRow(row)
-        self.table.setSortingEnabled(True)
-
-    def clear_devices(self):
-        """Clear all device items."""
-        self.table.setSortingEnabled(False)
-        while self.table.rowCount() > 0:
-            self.table.removeRow(0)
-        self.table.setSortingEnabled(True)
-
-    def update_summary(self, text: str, icon: QtGui.QPixmap = None):
-        """Update the summary label."""
-        self.summary_label.setText(text)
-        if icon:
-            self.summary_icon.setPixmap(icon)
-
-
-class UploadRedisDialog(QtWidgets.QDialog):
-    """
-    Dialog for uploading device configurations to BEC server with validation checks.
-    """
-
-    class UploadAction(IntEnum):
-        """Enum for upload actions."""
-
-        CANCEL = QtWidgets.QDialog.DialogCode.Rejected
-        OK = QtWidgets.QDialog.DialogCode.Accepted
-        CONNECTION_TEST_REQUESTED = 999
-
-    # Request ophyd validation for all untested device connections
-    # list of device configs, added: bool, connect: bool
-    request_ophyd_validation = QtCore.Signal(list, bool, bool)
-
-    def __init__(self, parent, device_configs: dict[str, Tuple[dict, int, int]] | None = None):
-        super().__init__(parent=parent)
-
-        self.device_configs: dict[str, Tuple[dict, int, int]] = device_configs or {}
-        self._transparent_button_style = "background-color: transparent; border: none;"
-
-        self.colors = get_accent_colors()
-        self.icons = get_validation_icons(self.colors, (20, 20))
-        material_icon_partial = partial(material_icon, size=(24, 24), filled=True)
-        self._label_icons = {
-            "success": material_icon_partial("check_circle", color=self.colors.success),
-            "warning": material_icon_partial("warning", color=self.colors.warning),
-            "error": material_icon_partial("error", color=self.colors.emergency),
-            "reload": material_icon_partial("refresh", color=self.colors.default),
-            "upload": material_icon_partial("cloud_upload", color=self.colors.default),
-        }
-
-        # Track validation states
-        self.has_invalid_configs: int = 0
-        self.has_untested_connections: int = 0
-        self.has_cannot_connect: int = 0
-
-        self._setup_ui()
-        self._update_ui()
-
-    def set_device_config(self, device_configs: dict[str, Tuple[dict, int, int]]):
-        """
-        Update the device configuration in the dialog.
-
-        Args:
-            device_configs (dict[str, Tuple[dict, int, int]]): New device configurations with structure
-                                        {device_name: (config_dict, config_status, connection_status)}.
-        """
-        self.config_section.clear_devices()
-        self.device_configs = device_configs
-        self._update_ui()
-
-    def _setup_ui(self):
-        """Setup the main UI for the dialog."""
-        self.setWindowTitle("Upload Configuration to BEC Server")
-        self.setModal(True)  # Blocks interaction with other parts of the app
-
-        layout = QtWidgets.QVBoxLayout(self)
-        layout.setSpacing(16)
-
-        # Header
-        header_label = QtWidgets.QLabel("Review Configuration Before Upload")
-        header_label.setStyleSheet("font-size: 16px; font-weight: bold; margin-bottom: 8px;")
-        layout.addWidget(header_label)
-
-        # Description
-        desc_label = QtWidgets.QLabel(
-            "Please review the configuration and connection status of all devices before uploading to BEC Server."
-        )
-        desc_label.setWordWrap(True)
-        desc_label.setStyleSheet("color: #666; margin-bottom: 16px;")
-        layout.addWidget(desc_label)
-
-        # Config validation section
-        sections_layout = QtWidgets.QHBoxLayout()
-        self.config_section = ValidationSection("Configuration Validation")
-        sections_layout.addWidget(self.config_section)
-        layout.addLayout(sections_layout)
-
-        # Action buttons section
-        self._setup_action_buttons(layout)
-
-        # Dialog buttons
-        self._setup_dialog_buttons(layout)
-        self.adjustSize()
-
-    def _setup_action_buttons(self, parent_layout: QtWidgets.QLayout):
-        """Setup the action buttons section."""
-        action_group = QtWidgets.QGroupBox("Actions")
-        action_layout = QtWidgets.QVBoxLayout(action_group)
-
-        # Validate connections button
-        button_layout = QtWidgets.QHBoxLayout()
-        self.validate_connections_btn = QtWidgets.QPushButton("Validate All Connections")
-        self.validate_connections_btn.setIcon(self._label_icons["reload"])
-        self.validate_connections_btn.clicked.connect(self._validate_connections)
-        button_layout.addWidget(self.validate_connections_btn)
-        button_layout.addStretch()
-        button_layout.addSpacing(16)
-        action_layout.addLayout(button_layout)
-
-        # Status indicator
-        status_layout = QtWidgets.QHBoxLayout()
-        self.status_icon = QtWidgets.QPushButton()
-        self.status_icon.setFlat(True)
-        self.status_icon.setEnabled(False)
-        self.status_icon.setStyleSheet(self._transparent_button_style)
-        self.status_icon.setFixedSize(24, 24)
-        self.status_label = QtWidgets.QLabel()
-        self.status_label.setWordWrap(True)
-        status_layout.addWidget(self.status_icon)
-        status_layout.addWidget(self.status_label)
-        action_layout.addLayout(status_layout)
-
-        parent_layout.addWidget(action_group)
-
-    def _setup_dialog_buttons(self, parent_layout: QtWidgets.QLayout):
-        """Setup the dialog buttons."""
-        button_layout = QtWidgets.QHBoxLayout()
-
-        # Cancel button
-        self.cancel_btn = QtWidgets.QPushButton("Cancel")
-        self.cancel_btn.clicked.connect(self.reject)
-        button_layout.addWidget(self.cancel_btn)
-
-        button_layout.addStretch()
-
-        # Upload button
-        self.upload_btn = QtWidgets.QPushButton("Upload to BEC Server")
-        self.upload_btn.setIcon(self._label_icons["upload"])
-        self.upload_btn.clicked.connect(self._handle_upload)
-        button_layout.addWidget(self.upload_btn)
-
-        parent_layout.addLayout(button_layout)
-
-    def _populate_device_data(self):
-        """Populate the dialog with device configuration data."""
-        if not self.device_configs:
-            return
-
-        self.has_invalid_configs = 0
-        self.has_untested_connections = 0
-        self.has_cannot_connect = 0
-
-        for device_name, (config, config_status, connection_status) in self.device_configs.items():
-            # Add to appropriate sections
-            self.config_section.add_device(config, config_status, connection_status)
-
-            # Track statistics
-            if config_status == ConfigStatus.INVALID.value:
-                self.has_invalid_configs += 1
-            if connection_status == ConnectionStatus.UNKNOWN.value:
-                self.has_untested_connections += 1
-            if connection_status == ConnectionStatus.CANNOT_CONNECT.value:
-                self.has_cannot_connect += 1
-
-        # Update section summaries
-        num_devices = len(self.device_configs)
-
-        # Config validation summary
-        if self.has_invalid_configs > 0:
-            icon = self._label_icons["error"]
-            text = f"{self.has_invalid_configs} of {num_devices} device configurations are invalid."
-        else:
-            icon = self._label_icons["success"]
-            text = f"All {num_devices} device configurations are valid."
-        if self.has_untested_connections > 0:
-            icon = self._label_icons["warning"]
-            text += f"{self.has_untested_connections} device connections are not tested."
-        if self.has_cannot_connect > 0:
-            icon = self._label_icons["warning"]
-            text += f"{self.has_cannot_connect} device connections cannot be established."
-        self.config_section.update_summary(text, icon)
-
-    def _update_ui(self):
-        """Update UI state based on validation results."""
-        # Update first the device data
-        self._populate_device_data()
-
-        # Invalid configuration have highest priority, upload disabled
-        if self.has_invalid_configs:
-            self.status_icon.setIcon(self._label_icons["error"])
-            self.status_label.setText(
-                "\n".join(
-                    [
-                        f"{self.has_invalid_configs} device configurations are invalid.",
-                        "Please fix configuration errors before uploading.",
-                    ]
-                )
-            )
-            self.upload_btn.setEnabled(False)
-            self.validate_connections_btn.setEnabled(False)
-            self.validate_connections_btn.setText("Invalid Configurations")
-
-        # Next priority: connections that cannot be established, error but upload is enabled
-        elif self.has_cannot_connect:
-            self.status_icon.setIcon(self._label_icons["warning"])
-            self.status_label.setText(
-                "\n".join(
-                    [
-                        f"{self.has_cannot_connect} connections cannot be established.",
-                        "Please fix connection issues before uploading.",
-                    ]
-                )
-            )
-            self.upload_btn.setEnabled(True)
-            self.validate_connections_btn.setEnabled(True)
-            self.validate_connections_btn.setText(
-                f"Validate {self.has_untested_connections + self.has_cannot_connect} Connections"
-            )
-
-        # Next priority: untested connections, warning but upload is enabled
-        elif self.has_untested_connections:
-            self.status_icon.setIcon(self._label_icons["warning"])
-            self.status_label.setText(
-                "\n".join(
-                    [
-                        f"{self.has_untested_connections} connections have not been tested.",
-                        "Consider validating connections before uploading.",
-                    ]
-                )
-            )
-            self.upload_btn.setEnabled(True)
-            self.validate_connections_btn.setEnabled(True)
-            self.validate_connections_btn.setText(
-                f"Validate {self.has_untested_connections + self.has_cannot_connect} Connections"
-            )
-
-        # All good, upload enabled
-        else:
-            self.status_icon.setIcon(self._label_icons["success"])
-            self.status_label.setText(
-                "\n".join(
-                    [
-                        "All device configurations are valid.",
-                        "All connections have been successfully tested.",
-                    ]
-                )
-            )
-            self.upload_btn.setEnabled(True)
-            self.validate_connections_btn.setEnabled(False)
-            self.validate_connections_btn.setText("All Connections Validated")
-
-    @SafeSlot()
-    def _validate_connections(self):
-        """Request validation of all untested connections. This will close the dialog."""
-        testable_devices: List[dict] = []
-        for _, (config, _, connection_status) in self.device_configs.items():
-            if connection_status == ConnectionStatus.UNKNOWN.value:
-                testable_devices.append(config)
-            elif connection_status == ConnectionStatus.CANNOT_CONNECT.value:
-                testable_devices.append(config)
-
-        if len(testable_devices) > 0:
-            self.request_ophyd_validation.emit(testable_devices, True, True)
-            self.done(self.UploadAction.CONNECTION_TEST_REQUESTED)
-
-    @SafeSlot()
-    def _handle_upload(self):
-        """Handle the upload button click with appropriate confirmations."""
-        # First priority: invalid configurations, block upload
-        if self.has_invalid_configs:
-            detailed_text = (
-                f"There is {self.has_invalid_configs} device with an invalid configuration."
-                if self.has_invalid_configs == 1
-                else f"There are {self.has_invalid_configs} devices with invalid configurations."
-            )
-            text = " ".join(
-                [detailed_text, "Invalid configuration can not be uploaded to the BEC Server."]
-            )
-            QtWidgets.QMessageBox.critical(self, "Device Configurations Invalid", text)
-            self.done(self.UploadAction.CANCEL)
-            return
-
-        # Next priority: connections that cannot be established, show warning, but allow to proceed
-        if self.has_cannot_connect:
-            detailed_text = (
-                f"There is {self.has_cannot_connect} device that cannot connect"
-                if self.has_cannot_connect == 1
-                else f"There are {self.has_cannot_connect} devices that cannot connect."
-            )
-            text = " ".join(
-                [
-                    detailed_text,
-                    "These devices may not be reachable and disabled BEC upon loading the config.",
-                    "Consider validating these connections before proceeding.\n\n",
-                    "Continue anyway?",
-                ]
-            )
-            reply = QtWidgets.QMessageBox.critical(
-                self,
-                "Devices cannot Connect",
-                text,
-                QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
-                QtWidgets.QMessageBox.No,
-            )
-            if reply == QtWidgets.QMessageBox.No:
-                return
-
-        # If some connections are untested, warn the user
-        if self.has_untested_connections:
-            detailed_text = (
-                f"There is {self.has_untested_connections} device with untested connections."
-                if self.has_untested_connections == 1
-                else f"There are {self.has_untested_connections} devices with untested connections."
-            )
-            text = " ".join(
-                [
-                    detailed_text,
-                    "Uploading without validating connections may result in devices that cannot be reached when the configuration is applied.",
-                ]
-            )
-            reply = QtWidgets.QMessageBox.question(
-                self,
-                "Untested Connections",
-                text,
-                QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
-                QtWidgets.QMessageBox.No,
-            )
-            if reply == QtWidgets.QMessageBox.No:
-                return
-
-        # Final confirmation
-        text = " ".join(
-            ["You are about to upload the device configurations to BEC Server.", "Please confirm."]
-        )
-        reply = QtWidgets.QMessageBox.question(
-            self,
-            "Upload to BEC Server",
-            text,
-            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
-            QtWidgets.QMessageBox.Yes,
-        )
-        if reply == QtWidgets.QMessageBox.Yes:
-            self.done(self.UploadAction.OK)
-        else:
-            self.done(self.UploadAction.CANCEL)
-
-    @SafeSlot(dict, int, int, str)
-    def _update_from_ophyd_device_tests(
-        self,
-        device_config: dict,
-        config_status: int,
-        connection_status: int,
-        validation_message: str = "",
-    ):
-        """
-        Update device status from ophyd device tests. This has to be with a connection_status that was updated.
-
-        """
-        if connection_status == ConnectionStatus.UNKNOWN.value:
-            return
-        self.update_device_status(device_config, config_status, connection_status)
-
-    @SafeSlot(list)
-    def _multiple_updates_from_ophyd_device_tests(self, validation_results: _ValidationResultIter):
-        """
-        Callback slot for receiving multiple validation result updates from the ophyd test widget.
-
-        Args:
-            validation_results (list): List of tuples containing (device_config, config_status, connection_status, validation_msg).
-        """
-        for cfg, cfg_status, conn_status, val_msg in validation_results:
-            self.update_device_status(cfg, cfg_status, conn_status)
-        self._update_ui()
-
-    @SafeSlot(dict, int, int)
-    def update_device_status(self, device_config: dict, config_status: int, connection_status: int):
-        """Update the status of a specific device."""
-        # Update device config status
-        self._update_device_configs(device_config, config_status, connection_status, "")
-        # Recalculate summaries and UI state
-        self._update_ui()
-
-    def _update_device_configs(
-        self,
-        device_config: dict[str, Any],
-        config_status: int,
-        connection_status: int,
-        validation_msg: str,
-    ):
-        device_name = device_config.get("name", "")
-        old_config, _, _ = self.device_configs.get(device_name, (None, None, None))
-        if old_config is not None:
-            self.device_configs[device_name] = (device_config, config_status, connection_status)
-        else:
-            # If device not found, add it
-            self.config_section.add_device(device_config, config_status, connection_status)
-
-
-def main():  # pragma: no cover
-    """Test the upload redis dialog."""
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-
-    # Sample device configurations for testing
-    sample_configs = [
-        (
-            {"name": "motor_x", "deviceClass": "EpicsMotor"},
-            ConfigStatus.VALID.value,
-            ConnectionStatus.CONNECTED.value,
-        ),
-        (
-            {"name": "detector_1", "deviceClass": "EpicsSignal"},
-            ConfigStatus.VALID.value,
-            ConnectionStatus.CONNECTED.value,
-        ),
-        (
-            {"name": "detector_2", "deviceClass": "EpicsSignal"},
-            ConfigStatus.VALID.value,
-            ConnectionStatus.UNKNOWN.value,
-        ),
-        (
-            {"name": "motor_y", "deviceClass": "EpicsMotor"},
-            ConfigStatus.VALID.value,
-            ConnectionStatus.CONNECTED.value,
-        ),
-        (
-            {"name": "motor_z", "deviceClass": "EpicsMotor"},
-            ConfigStatus.VALID.value,
-            ConnectionStatus.CONNECTED.value,
-        ),
-        (
-            {"name": "motor_x1", "deviceClass": "EpicsMotor"},
-            ConfigStatus.VALID.value,
-            ConnectionStatus.CONNECTED.value,
-        ),
-        (
-            {"name": "detector_11", "deviceClass": "EpicsSignal"},
-            ConfigStatus.VALID.value,
-            ConnectionStatus.CANNOT_CONNECT.value,
-        ),
-        (
-            {"name": "detector_21", "deviceClass": "EpicsSignal"},
-            ConfigStatus.INVALID.value,
-            ConnectionStatus.UNKNOWN.value,
-        ),
-        (
-            {"name": "motor_y1", "deviceClass": "EpicsMotor"},
-            ConfigStatus.VALID.value,
-            ConnectionStatus.CANNOT_CONNECT.value,
-        ),
-        (
-            {"name": "motor_z1", "deviceClass": "EpicsMotor"},
-            ConfigStatus.VALID.value,
-            ConnectionStatus.CONNECTED.value,
-        ),
-    ]
-    configs = {cfg[0]["name"]: cfg for cfg in sample_configs}
-    apply_theme("dark")
-    dialog = UploadRedisDialog(parent=None, device_configs=configs)
-    dialog.show()
-
-    sys.exit(app.exec_())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/applications/views/device_manager_view/device_manager_display_widget.py

@@ -1,864 +0,0 @@
-from __future__ import annotations
-
-import os
-from functools import partial
-from typing import TYPE_CHECKING, List, Literal, get_args
-
-import yaml
-from bec_lib import config_helper
-from bec_lib.bec_yaml_loader import yaml_load
-from bec_lib.callback_handler import EventType
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.file_utils import DeviceConfigWriter
-from bec_lib.logger import bec_logger
-from bec_lib.messages import ConfigAction, ScanStatusMessage
-from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path
-from bec_qthemes import apply_theme, material_icon
-from qtpy.QtCore import QMetaObject, Qt, QThreadPool, Signal
-from qtpy.QtGui import QColor
-from qtpy.QtWidgets import (
-    QApplication,
-    QFileDialog,
-    QMessageBox,
-    QPushButton,
-    QTextEdit,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.applications.views.device_manager_view.device_manager_dialogs import (
-    ConfigChoiceDialog,
-    DeviceFormDialog,
-)
-from bec_widgets.applications.views.device_manager_view.device_manager_dialogs.upload_redis_dialog import (
-    UploadRedisDialog,
-)
-from bec_widgets.utils.colors import get_accent_colors
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.toolbars.actions import MaterialIconAction
-from bec_widgets.utils.toolbars.bundles import ToolbarBundle
-from bec_widgets.utils.toolbars.toolbar import ModularToolBar
-from bec_widgets.widgets.containers.dock_area.basic_dock_area import DockAreaWidget
-from bec_widgets.widgets.control.device_manager.components import (
-    DeviceTable,
-    DMConfigView,
-    DocstringView,
-    OphydValidation,
-)
-from bec_widgets.widgets.control.device_manager.components._util import SharedSelectionSignal
-from bec_widgets.widgets.control.device_manager.components.ophyd_validation.ophyd_validation_utils import (
-    ConfigStatus,
-    ConnectionStatus,
-)
-from bec_widgets.widgets.progress.device_initialization_progress_bar.device_initialization_progress_bar import (
-    DeviceInitializationProgressBar,
-)
-from bec_widgets.widgets.services.device_browser.device_item.config_communicator import (
-    CommunicateConfigAction,
-)
-from bec_widgets.widgets.utility.spinner.spinner import SpinnerWidget
-
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_lib.client import BECClient
-
-logger = bec_logger.logger
-
-_yes_no_question = partial(
-    QMessageBox.question,
-    buttons=QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
-    defaultButton=QMessageBox.StandardButton.No,
-)
-
-
-class CustomBusyWidget(QWidget):
-    """Custom busy widget to show during device config upload."""
-
-    cancel_requested = Signal()
-
-    def __init__(self, parent=None, client: BECClient | None = None):
-        super().__init__(parent=parent)
-
-        # Widgets
-        self.progress = QWidget(parent=self)
-        self.progress_layout = QVBoxLayout(self.progress)
-        self.progress_layout.setContentsMargins(6, 6, 6, 6)
-        self.progress_inner = DeviceInitializationProgressBar(parent=self.progress, client=client)
-        self.progress_layout.addWidget(self.progress_inner)
-        self.progress.setMinimumWidth(320)
-
-        # Spinner
-        self.spinner = SpinnerWidget(parent=self)
-        scale = self._ui_scale()
-        spinner_size = int(scale * 0.12) if scale else 1
-        spinner_size = max(32, min(spinner_size, 96))
-        self.spinner.setFixedSize(spinner_size, spinner_size)
-
-        # Cancel button
-        self.cancel_button = QPushButton("Cancel Upload", parent=self)
-        self.cancel_button.setIcon(material_icon("cancel"))
-        self.cancel_button.clicked.connect(self.cancel_requested.emit)
-        button_height = int(spinner_size * 0.9)
-        button_height = max(36, min(button_height, 72))
-        aspect_ratio = 3.8  # width / height, visually stable for text buttons
-        button_width = int(button_height * aspect_ratio)
-        self.cancel_button.setFixedSize(button_width, button_height)
-        color = get_accent_colors()
-        self.cancel_button.setStyleSheet(f"""
-            QPushButton {{
-                background-color: {color.emergency.name()};
-                color: white;
-                font-weight: 600;
-                border-radius: 6px;
-            }}
-            """)
-
-        # Layout
-        content_layout = QVBoxLayout(self)
-        content_layout.setContentsMargins(24, 24, 24, 24)
-        content_layout.setSpacing(16)
-        content_layout.addStretch()
-        content_layout.addWidget(self.spinner, 0, Qt.AlignmentFlag.AlignHCenter)
-        content_layout.addWidget(self.progress, 0, Qt.AlignmentFlag.AlignHCenter)
-        content_layout.addStretch()
-        content_layout.addWidget(self.cancel_button, 0, Qt.AlignmentFlag.AlignHCenter)
-
-        if hasattr(color, "_colors"):
-            bg_color = color._colors.get("BG", None)
-        if bg_color is None:  # Fallback if missing
-            bg_color = QColor(50, 50, 50, 255)
-        self.setStyleSheet(f"""
-            background-color: {bg_color.name()};
-            border-radius: 12px;
-            """)
-
-    def _ui_scale(self) -> int:
-        parent = self.parent()
-        if not parent:
-            return 0
-        return min(parent.width(), parent.height())
-
-    def showEvent(self, event):
-        """Show event to start the spinner."""
-        super().showEvent(event)
-        self.spinner.start()
-
-    def hideEvent(self, event):
-        """Hide event to stop the spinner."""
-        super().hideEvent(event)
-        self.spinner.stop()
-
-
-class DeviceManagerDisplayWidget(DockAreaWidget):
-    """Device Manager main display widget. This contains all sub-widgets and the toolbar."""
-
-    RPC = False
-
-    request_ophyd_validation = Signal(list, bool, bool)
-
-    def __init__(self, parent=None, *args, **kwargs):
-        super().__init__(parent=parent, variant="compact", *args, **kwargs)
-
-        # State variable for config upload
-        self._config_upload_active: bool = False
-        self._config_in_sync: bool = False
-        scan_status = self.bec_dispatcher.client.connector.get(MessageEndpoints.scan_status())
-        initial_status = scan_status.status if scan_status is not None else "closed"
-        self._scan_is_running: bool = initial_status in ["open", "paused"]
-
-        # Push to Redis dialog
-        self._upload_redis_dialog: UploadRedisDialog | None = None
-        self._dialog_validation_connection: QMetaObject.Connection | None = None
-
-        # NOTE: We need here a seperate config helper instance to avoid conflicts with
-        # other communications to REDIS as uploading a config through a CommunicationConfigAction
-        # will block if we use the config_helper from self.client.config._config_helper
-        self._config_helper = config_helper.ConfigHelper(self.client.connector)
-        self._shared_selection = SharedSelectionSignal()
-
-        # Device Table View widget
-        self.device_table_view = DeviceTable(self)
-
-        # Device Config View widget
-        self.dm_config_view = DMConfigView(self)
-
-        # Docstring View
-        self.dm_docs_view = DocstringView(self)
-
-        # Ophyd Test view
-        self.ophyd_widget_view = QWidget(self)
-        layout = QVBoxLayout(self.ophyd_widget_view)
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.setSpacing(4)
-        self.ophyd_test_view = OphydValidation(self, hide_legend=False)
-        layout.addWidget(self.ophyd_test_view)
-
-        # Validation Results view
-        self.validation_results = QTextEdit(self)
-        self.validation_results.setReadOnly(True)
-        self.validation_results.setPlaceholderText("Validation results will appear here...")
-        layout.addWidget(self.validation_results)
-        self.ophyd_test_view.item_clicked.connect(self._ophyd_test_item_clicked_cb)
-
-        for signal, slots in [
-            (
-                self.device_table_view.selected_devices,
-                (self.dm_config_view.on_select_config, self.dm_docs_view.on_select_config),
-            ),
-            (
-                self.ophyd_test_view.validation_completed,
-                (self.device_table_view.update_device_validation,),
-            ),
-            (
-                self.ophyd_test_view.multiple_validations_completed,
-                (self.device_table_view.update_multiple_device_validations,),
-            ),
-            (self.request_ophyd_validation, (self.ophyd_test_view.change_device_configs,)),
-            (
-                self.device_table_view.device_configs_changed,
-                (self.ophyd_test_view.device_table_config_changed,),
-            ),
-            (
-                self.device_table_view.device_config_in_sync_with_redis,
-                (self._update_config_in_sync,),
-            ),
-            (self.device_table_view.device_row_dbl_clicked, (self._edit_device_action,)),
-        ]:
-            for slot in slots:
-                signal.connect(slot)
-
-        self._scan_status_callback_id = self.bec_dispatcher.client.callbacks.register(
-            EventType.SCAN_STATUS, self._update_scan_running
-        )
-
-        # Add toolbar
-        self._add_toolbar()
-
-        # Build dock layout using shared helpers
-        self._build_docks()
-
-    def cleanup(self):
-        self.bec_dispatcher.client.callbacks.remove(self._scan_status_callback_id)
-        super().cleanup()
-
-    def closeEvent(self, event):
-        """If config upload is active when application is exiting, cancel it."""
-        logger.info("Application is quitting, checking for active config upload...")
-        if self._config_upload_active:
-            logger.info("Application is quitting, cancelling active config upload...")
-            self._config_helper.send_config_request(
-                action="cancel", config=None, wait_for_response=True, timeout_s=10
-            )
-            logger.info("Config upload cancelled.")
-        super().closeEvent(event)
-
-    ##############################
-    ### Custom set busy widget ###
-    ##############################
-
-    def create_busy_state_widget(self) -> QWidget:
-        """Create a custom busy state widget for uploading device configurations."""
-        widget = CustomBusyWidget(parent=self, client=self.client)
-        widget.cancel_requested.connect(self._cancel_device_config_upload)
-        return widget
-
-    def _set_busy_wrapper(self, enabled: bool):
-        """Thin wrapper around set_busy to flip the state variable."""
-        self._busy_overlay.set_opacity(0.92)
-        self._config_upload_active = enabled
-        self.set_busy(enabled=enabled)
-
-    ##############################
-    ### Toolbar and Dock setup ###
-    ##############################
-
-    def _add_toolbar(self):
-        self.toolbar = ModularToolBar(self)
-
-        # Add IO actions
-        self._add_io_actions()
-        self._add_table_actions()
-        self.toolbar.show_bundles(["IO", "Table"])
-        self._root_layout.insertWidget(0, self.toolbar)
-
-    def _build_docks(self) -> None:
-        # Central device table
-        self.device_table_view_dock = self.new(
-            self.device_table_view,
-            return_dock=True,
-            closable=False,
-            floatable=False,
-            movable=False,
-            show_title_bar=False,
-        )
-
-        # Bottom area: docstrings
-        self.dm_docs_view_dock = self.new(
-            self.dm_docs_view,
-            where="bottom",
-            relative_to=self.device_table_view_dock,
-            return_dock=True,
-            closable=False,
-            floatable=False,
-            movable=False,
-            show_title_bar=False,
-        )
-        # Config view left of docstrings
-        self.dm_config_view_dock = self.new(
-            self.dm_config_view,
-            where="left",
-            relative_to=self.dm_docs_view_dock,
-            return_dock=True,
-            closable=False,
-            floatable=False,
-            movable=False,
-            show_title_bar=False,
-        )
-
-        # Right area: ophyd test + validation
-        self.ophyd_test_dock_view = self.new(
-            self.ophyd_widget_view,
-            where="right",
-            relative_to=self.device_table_view_dock,
-            return_dock=True,
-            closable=False,
-            floatable=False,
-            movable=False,
-            show_title_bar=False,
-        )
-
-        self.set_layout_ratios(splitter_overrides={0: [7, 3], 1: [3, 7]})
-
-    def _add_io_actions(self):
-        # Create IO bundle
-        io_bundle = ToolbarBundle("IO", self.toolbar.components)
-
-        # Load from disk
-        load = MaterialIconAction(
-            text_position="under",
-            icon_name="file_open",
-            parent=self,
-            tooltip="Load configuration file from disk",
-            label_text="Load Config",
-        )
-        self.toolbar.components.add_safe("load", load)
-        load.action.triggered.connect(self._load_file_action)
-        io_bundle.add_action("load")
-
-        # Add safe to disk
-        save_to_disk = MaterialIconAction(
-            text_position="under",
-            icon_name="file_save",
-            parent=self,
-            tooltip="Save config to disk",
-            label_text="Save Config",
-        )
-        self.toolbar.components.add_safe("save_to_disk", save_to_disk)
-        save_to_disk.action.triggered.connect(self._save_to_disk_action)
-        io_bundle.add_action("save_to_disk")
-
-        # Add flush config in redis
-        flush_redis = MaterialIconAction(
-            text_position="under",
-            icon_name="delete_sweep",
-            parent=self,
-            tooltip="Flush current config in BEC Server",
-            label_text="Flush loaded Config",
-        )
-        flush_redis.action.triggered.connect(self._flush_redis_action)
-        self.toolbar.components.add_safe("flush_redis", flush_redis)
-        io_bundle.add_action("flush_redis")
-
-        # Add load config from redis
-        load_redis = MaterialIconAction(
-            text_position="under",
-            icon_name="cached",
-            parent=self,
-            tooltip="Load current config from BEC Server",
-            label_text="Get loaded Config",
-        )
-        load_redis.action.triggered.connect(self._load_redis_action)
-        self.toolbar.components.add_safe("load_redis", load_redis)
-        io_bundle.add_action("load_redis")
-
-        # Update config action
-        update_config_redis = MaterialIconAction(
-            text_position="under",
-            icon_name="cloud_upload",
-            parent=self,
-            tooltip="Update current config in BEC Server",
-            label_text="Update Config",
-        )
-        update_config_redis.action.setEnabled(False)
-
-        update_config_redis.action.triggered.connect(self._update_redis_action)
-        self.toolbar.components.add_safe("update_config_redis", update_config_redis)
-        io_bundle.add_action("update_config_redis")
-
-        # Add load config from plugin dir
-        self.toolbar.add_bundle(io_bundle)
-
-    # Table actions
-    def _add_table_actions(self) -> None:
-        table_bundle = ToolbarBundle("Table", self.toolbar.components)
-
-        # Reset composed view
-        reset_composed = MaterialIconAction(
-            text_position="under",
-            icon_name="delete_sweep",
-            parent=self,
-            tooltip="Reset current composed config view",
-            label_text="Reset Config View",
-        )
-        reset_composed.action.triggered.connect(self._reset_composed_view)
-        self.toolbar.components.add_safe("reset_composed", reset_composed)
-        table_bundle.add_action("reset_composed")
-
-        # Add device
-        add_device = MaterialIconAction(
-            text_position="under",
-            icon_name="add",
-            parent=self,
-            tooltip="Add new device",
-            label_text="Add Device",
-        )
-        add_device.action.triggered.connect(self._add_device_action)
-        self.toolbar.components.add_safe("add_device", add_device)
-        table_bundle.add_action("add_device")
-
-        # Remove device
-        remove_device = MaterialIconAction(
-            text_position="under",
-            icon_name="remove",
-            parent=self,
-            tooltip="Remove device",
-            label_text="Remove Device",
-        )
-        remove_device.action.triggered.connect(self._remove_device_action)
-        self.toolbar.components.add_safe("remove_device", remove_device)
-        table_bundle.add_action("remove_device")
-
-        # Rerun validation
-        rerun_validation = MaterialIconAction(
-            text_position="under",
-            icon_name="checklist",
-            parent=self,
-            tooltip="Run device validation with 'connect' on selected devices",
-            label_text="Validate Connection",
-        )
-        rerun_validation.action.triggered.connect(self._run_validate_connection)
-        self.toolbar.components.add_safe("rerun_validation", rerun_validation)
-        table_bundle.add_action("rerun_validation")
-
-        # Add load config from plugin dir
-        self.toolbar.add_bundle(table_bundle)
-
-    ######################################
-    ### Update button state management ###
-    ######################################
-
-    @SafeSlot(dict, dict)
-    def _update_scan_running(self, scan_info: dict, _: dict):
-        """disable editing when scans are running and enable editing when they are finished"""
-        msg = ScanStatusMessage.model_validate(scan_info)
-        self._scan_is_running = msg.status in ["open", "paused"]
-        self._update_config_enabled_button()
-
-    def _update_config_in_sync(self, in_sync: bool):
-        self._config_in_sync = in_sync
-        self._update_config_enabled_button()
-
-    def _update_config_enabled_button(self):
-        action = self.toolbar.components.get_action("update_config_redis")
-        enabled = not self._config_in_sync and not self._scan_is_running
-        action.action.setEnabled(enabled)
-        if enabled:  # button is enabled
-            action.action.setToolTip("Push current config to BEC Server")
-        elif self._scan_is_running:
-            action.action.setToolTip("Scan is currently running, config updates disabled.")
-        else:
-            action.action.setToolTip("Current config is in sync with BEC Server, updates disabled.")
-
-    #######################
-    ### Action Handlers ###
-    #######################
-
-    @SafeSlot()
-    @SafeSlot(bool)
-    def _run_validate_connection(self, connect: bool = True):
-        """Action for the 'rerun_validation' action to rerun validation on selected devices."""
-        configs = list(self.device_table_view.get_selected_device_configs())
-        if not configs:
-            configs = self.device_table_view.get_device_config()
-        # Adjust the state of the icons in the device table view
-        self.device_table_view.update_multiple_device_validations(
-            [
-                (cfg, ConfigStatus.UNKNOWN.value, ConnectionStatus.UNKNOWN.value, "")
-                for cfg in configs
-            ]
-        )
-        self.request_ophyd_validation.emit(configs, True, connect)
-
-    @SafeSlot()
-    def _load_file_action(self):
-        """Action for the 'load' action to load a config from disk for the io_bundle of the toolbar."""
-        config_path = self._get_config_base_path()
-
-        # Implement the file loading logic here
-        start_dir = os.path.abspath(config_path)
-        file_path = self._get_file_path(start_dir, "open_file")
-        if file_path:
-            self._load_config_from_file(file_path)
-
-    def _get_config_base_path(self) -> str:
-        """Get the base path for device configurations."""
-        try:
-            plugin_path = plugin_repo_path()
-            plugin_name = plugin_package_name()
-            config_path = os.path.join(plugin_path, plugin_name, "device_configs")
-        except ValueError:
-            # Get the recovery config path as fallback
-            config_path = self._get_recovery_config_path()
-            logger.warning(
-                f"No plugin repository installed, fallback to recovery config path: {config_path}"
-            )
-        return config_path
-
-    def _get_file_path(self, start_dir: str, mode: Literal["open_file", "save_file"]) -> str:
-        ALLOWED_EXTS = [".yaml", ".yml"]
-        filter_str = "YAML files (*.yaml *.yml);;All Files (*)"
-        initial_filter = "YAML files (*.yaml *.yml);;"
-        if mode == "open_file":
-            file_path, _ = QFileDialog.getOpenFileName(
-                self,
-                caption="Select Config File",
-                dir=start_dir,
-                filter=filter_str,
-                selectedFilter=initial_filter,
-            )
-        else:
-            file_path, _ = QFileDialog.getSaveFileName(
-                self,
-                caption="Save Config File",
-                dir=start_dir,
-                filter=filter_str,
-                selectedFilter=initial_filter,
-            )
-        if not file_path:
-            return ""
-        _, ext = os.path.splitext(file_path)
-        if ext.lower() not in ALLOWED_EXTS:
-            file_path += ".yaml"
-        return file_path
-
-    def _load_config_from_file(self, file_path: str):
-        """
-        Load device config from a given file path and update the device table view.
-
-        Args:
-            file_path (str): Path to the configuration file.
-        """
-        try:
-            config = [{"name": k, **v} for k, v in yaml_load(file_path).items()]
-        except Exception as e:
-            logger.error(f"Failed to load config from file {file_path}. Error: {e}")
-            return
-        self._open_config_choice_dialog(config)
-
-    def _open_config_choice_dialog(self, config: List[dict]):
-        """
-        Open a dialog to choose whether to replace or add the loaded config.
-
-        Args:
-            config (List[dict]): List of device configurations loaded from the file.
-        """
-        if len(self.device_table_view.get_device_config()) == 0:
-            # If no config is composed yet, load directly
-            self.device_table_view.set_device_config(config)
-            return
-        dialog = ConfigChoiceDialog(self)
-        result = dialog.exec()
-        if result == ConfigChoiceDialog.Result.REPLACE:
-            self.device_table_view.set_device_config(config)
-        elif result == ConfigChoiceDialog.Result.ADD:
-            self.device_table_view.add_device_configs(config)
-
-    @SafeSlot()
-    def _flush_redis_action(self):
-        """Action to flush the current config in Redis."""
-        if self.client.device_manager is None:
-            logger.error("No device manager connected, cannot load config from BEC Server.")
-            return
-        if len(self.client.device_manager.devices) == 0:
-            logger.info("No devices in BEC Server, nothing to flush.")
-            QMessageBox.information(
-                self, "No Devices", "There is currently no config loaded on the BEC Server."
-            )
-            return
-        reply = _yes_no_question(
-            self,
-            "Flush BEC Server Config",
-            "Do you really want to flush the current config in BEC Server?",
-        )
-        if reply == QMessageBox.StandardButton.Yes:
-            self.client.config.reset_config()
-            logger.info("Successfully flushed configuration in BEC Server.")
-            # Check if config is in sync, enable load redis button
-            self.device_table_view.device_config_in_sync_with_redis.emit(
-                self.device_table_view._is_config_in_sync_with_redis()
-            )
-            validation_results = self.device_table_view.get_validation_results()
-            for config, config_status, connnection_status in validation_results.values():
-                if connnection_status == ConnectionStatus.CONNECTED.value:
-                    self.device_table_view.update_device_validation(
-                        config, config_status, ConnectionStatus.CAN_CONNECT, ""
-                    )
-
-    @SafeSlot()
-    def _load_redis_action(self):
-        """Action for the 'load_redis' action to load the current config from Redis for the io_bundle of the toolbar."""
-        if self.client.device_manager is None:
-            logger.error("No device manager connected, cannot load config from BEC Server.")
-            return
-        if not self.device_table_view.get_device_config():
-            # If no config is composed yet, load directly
-            self.device_table_view.set_device_config(
-                self.client.device_manager._get_redis_device_config()
-            )
-            return
-        reply = _yes_no_question(
-            self,
-            "Load currently active config in BEC Server",
-            "Do you really want to discard the current config and reload?",
-        )
-        if reply == QMessageBox.StandardButton.Yes:
-            self.device_table_view.set_device_config(
-                self.client.device_manager._get_redis_device_config()
-            )
-
-    @SafeSlot()
-    def _update_redis_action(self) -> None | QMessageBox.StandardButton:
-        """Action to push the current composition to Redis using the upload dialog."""
-        # Check if validations are still running
-        if self.ophyd_test_view.running_ophyd_tests is True:
-            return QMessageBox.warning(
-                self, "Validation in Progress", "Please wait for the validation to finish."
-            )
-
-        # Get all device configurations with their validation status
-        validation_results = self.device_table_view.get_validation_results()
-        # Create and show upload dialog
-        self._upload_redis_dialog = UploadRedisDialog(
-            parent=self, device_configs=validation_results
-        )
-        self._upload_redis_dialog.request_ophyd_validation.connect(
-            self.request_ophyd_validation.emit
-        )
-
-        # Show dialog
-        reply = self._upload_redis_dialog.exec_()
-
-        if reply == UploadRedisDialog.UploadAction.OK:
-            self._push_composition_to_redis(action="set")
-        elif reply == UploadRedisDialog.UploadAction.CANCEL:
-            self.ophyd_test_view.cancel_all_validations()
-        elif reply == UploadRedisDialog.UploadAction.CONNECTION_TEST_REQUESTED:
-            return QMessageBox.information(
-                self, "Connection Test Requested", "Running connection test on untested devices."
-            )
-
-    def _push_composition_to_redis(self, action: ConfigAction):
-        """Push the current device composition to Redis."""
-        if action not in get_args(ConfigAction):
-            logger.error(f"Invalid config action: {action} for uploading to BEC Server.")
-            return
-        config = {cfg.pop("name"): cfg for cfg in self.device_table_view.get_device_config()}
-        threadpool = QThreadPool.globalInstance()
-        comm = CommunicateConfigAction(self._config_helper, None, config, action)
-        comm.signals.done.connect(self._handle_push_complete_to_communicator)
-        comm.signals.error.connect(self._handle_exception_from_communicator)
-        threadpool.start(comm)
-        self._set_busy_wrapper(enabled=True)
-
-    def _cancel_device_config_upload(self):
-        """Cancel the device configuration upload process."""
-        threadpool = QThreadPool.globalInstance()
-        comm = CommunicateConfigAction(self._config_helper, None, {}, "cancel")
-        # Cancelling will raise an exception in the communicator, so we connect to the failure handler
-        comm.signals.error.connect(self._handle_cancel_config_upload_failed)
-        threadpool.start(comm)
-
-    def _handle_cancel_config_upload_failed(self, exception: Exception):
-        """Handle failure to cancel the config upload."""
-        self._set_busy_wrapper(enabled=False)
-
-        validation_results = self.device_table_view.get_validation_results()
-        devices_to_update = []
-        for config, config_status, connection_status in validation_results.values():
-            devices_to_update.append(
-                (config, config_status, ConnectionStatus.UNKNOWN.value, "Upload Cancelled")
-            )
-        # Rerun validation of all devices after cancellation
-        self.device_table_view.update_multiple_device_validations(devices_to_update)
-        self.ophyd_test_view.change_device_configs(
-            [cfg for cfg, _, _, _ in devices_to_update], added=True, skip_validation=False
-        )
-        # Config is in sync with BEC, so we update the state
-        self.device_table_view.device_config_in_sync_with_redis.emit(False)
-
-    def _handle_push_complete_to_communicator(self):
-        """Handle completion of the config push to Redis."""
-        self._set_busy_wrapper(enabled=False)
-
-    def _handle_exception_from_communicator(self, exception: Exception):
-        """Handle exceptions from the config communicator."""
-        QMessageBox.critical(
-            self,
-            "Error Uploading Config",
-            f"An error occurred while uploading the configuration to BEC Server:\n{str(exception)}",
-        )
-        self._set_busy_wrapper(enabled=False)
-
-    @SafeSlot()
-    def _save_to_disk_action(self):
-        """Action for the 'save_to_disk' action to save the current config to disk."""
-        # Check if plugin repo is installed...
-        try:
-            config_path = self._get_recovery_config_path()
-        except ValueError:
-            # Get the recovery config path as fallback
-            config_path = os.path.abspath(os.path.expanduser("~"))
-            logger.warning(f"Failed to find recovery config path, fallback to: {config_path}")
-
-        # Implement the file loading logic here
-        file_path = self._get_file_path(config_path, "save_file")
-        if file_path:
-            config = {cfg.pop("name"): cfg for cfg in self.device_table_view.get_device_config()}
-            if os.path.exists(file_path):
-                reply = _yes_no_question(
-                    self,
-                    "Overwrite File",
-                    f"The file '{file_path}' already exists. Do you want to overwrite it?",
-                )
-                if reply != QMessageBox.StandardButton.Yes:
-                    return
-            with open(file_path, "w") as file:
-                file.write(yaml.dump(config))
-
-    # Table actions
-    @SafeSlot()
-    def _reset_composed_view(self):
-        """Action for the 'reset_composed_view' action to reset the composed view."""
-        reply = _yes_no_question(
-            self,
-            "Clear View",
-            "You are about to clear the current composed config view, please confirm...",
-        )
-        if reply == QMessageBox.StandardButton.Yes:
-            self.device_table_view.clear_device_configs()
-
-    @SafeSlot(dict)
-    def _edit_device_action(self, device_config: dict):
-        """Action to edit a selected device configuration."""
-        dialog = DeviceFormDialog(parent=self, add_btn_text="Apply Changes")
-        dialog.accepted_data.connect(self._update_device_to_table_from_dialog)
-        dialog.set_device_config(device_config)
-        dialog.open()
-
-    @SafeSlot()
-    def _add_device_action(self):
-        """Action for the 'add_device' action to add a new device."""
-        dialog = DeviceFormDialog(parent=self, add_btn_text="Add Device")
-        dialog.accepted_data.connect(self._add_to_table_from_dialog)
-        dialog.open()
-
-    @SafeSlot(dict, int, int, str, str)
-    def _update_device_to_table_from_dialog(
-        self,
-        data: dict,
-        config_status: int,
-        connection_status: int,
-        msg: str,
-        old_device_name: str = "",
-    ):
-        if old_device_name and old_device_name != data.get("name", ""):
-            self.device_table_view.remove_device(old_device_name)
-        self._add_to_table_from_dialog(data, config_status, connection_status, msg, old_device_name)
-
-    @SafeSlot(dict, int, int, str, str)
-    def _add_to_table_from_dialog(
-        self,
-        data: dict,
-        config_status: int,
-        connection_status: int,
-        msg: str,
-        old_device_name: str = "",
-    ):
-        if connection_status == ConnectionStatus.UNKNOWN.value:
-            self.device_table_view.update_device_configs([data], skip_validation=False)
-        else:  # Connection status was tested in dialog
-            # If device is connected, we remove it from the ophyd validation view
-            self.device_table_view.update_device_configs([data], skip_validation=True)
-            # Update validation status in device table view and ophyd validation view
-            self.ophyd_test_view._on_device_test_completed(
-                data, config_status, connection_status, msg
-            )
-
-    @SafeSlot()
-    def _remove_device_action(self):
-        """Action for the 'remove_device' action to remove a device."""
-        configs = self.device_table_view.get_selected_device_configs()
-        if not configs:
-            QMessageBox.warning(
-                self, "No devices selected", "Please select devices from the table to remove."
-            )
-            return
-        if self.device_table_view._remove_configs_dialog([cfg["name"] for cfg in configs]):
-            self.device_table_view.remove_device_configs(configs)
-
-    @SafeSlot(dict, int, int, str, str)
-    def _ophyd_test_item_clicked_cb(
-        self, device_config: dict, config_status: int, connection_status: int, msg: str, md_msg: str
-    ) -> None:
-        self.validation_results.setMarkdown(md_msg)
-
-    def _get_recovery_config_path(self) -> str:
-        """Get the recovery config path from the log_writer config."""
-        # pylint: disable=protected-access
-        log_writer_config = self.client._service_config.config.get("log_writer", {})
-        writer = DeviceConfigWriter(service_config=log_writer_config)
-        return os.path.abspath(os.path.expanduser(writer.get_recovery_directory()))
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
-
-    app = QApplication(sys.argv)
-    w = QWidget()
-    l = QVBoxLayout()
-    w.setLayout(l)
-    apply_theme("dark")
-    button = DarkModeButton()
-    l.addWidget(button)
-    device_manager_view = DeviceManagerDisplayWidget()
-    l.addWidget(device_manager_view)
-    w.show()
-    w.setWindowTitle("Device Manager View")
-    screen = app.primaryScreen()
-    screen_geometry = screen.availableGeometry()
-    screen_width = screen_geometry.width()
-    screen_height = screen_geometry.height()
-    # 70% of screen height, keep 16:9 ratio
-    height = int(screen_height * 0.9)
-    width = int(height * (16 / 9))
-
-    # If width exceeds screen width, scale down
-    if width > screen_width * 0.9:
-        width = int(screen_width * 0.9)
-        height = int(width / (16 / 9))
-
-    w.resize(width, height)
-    sys.exit(app.exec_())

bec_widgets/applications/views/device_manager_view/device_manager_view.py

@@ -1,188 +0,0 @@
-"""Module for Device Manager View."""
-
-from qtpy.QtCore import QRect
-from qtpy.QtWidgets import QWidget
-
-from bec_widgets.applications.views.device_manager_view.device_manager_widget import (
-    DeviceManagerWidget,
-)
-from bec_widgets.applications.views.view import ViewBase, ViewTourSteps
-from bec_widgets.utils.error_popups import SafeSlot
-
-
-class DeviceManagerView(ViewBase):
-    """
-    A view for users to manage devices within the application.
-    """
-
-    def __init__(
-        self,
-        parent: QWidget | None = None,
-        content: QWidget | None = None,
-        *,
-        view_id: str | None = None,
-        title: str | None = None,
-        **kwargs,
-    ):
-        super().__init__(
-            parent=parent,
-            content=content,
-            view_id=view_id,
-            title=title,
-            rpc_passthrough_children=False,
-            **kwargs,
-        )
-        self.device_manager_widget = DeviceManagerWidget(
-            parent=self, rpc_exposed=False, rpc_passthrough_children=False
-        )
-        self.set_content(self.device_manager_widget)
-
-    @SafeSlot()
-    def on_enter(self) -> None:
-        """Called after the view becomes current/visible.
-
-        Default implementation does nothing. Override in subclasses.
-        """
-        self.device_manager_widget.on_enter()
-
-    def register_tour_steps(self, guided_tour, main_app) -> ViewTourSteps | None:
-        """Register Device Manager components with the guided tour.
-
-        Args:
-            guided_tour: The GuidedTour instance to register with.
-            main_app: The main application instance (for accessing set_current).
-
-        Returns:
-            ViewTourSteps | None: Model containing view title and step IDs.
-        """
-        step_ids = []
-        dm_widget = self.device_manager_widget
-
-        # The device_manager_widget is not yet initialized, so we will register
-        # tour steps for its uninitialized state.
-
-        # Register Load Current Config button
-        def get_load_current():
-            main_app.set_current("device_manager")
-            if dm_widget._initialized is True:
-                return (None, None)
-            return (dm_widget.button_load_current_config, None)
-
-        step_id = guided_tour.register_widget(
-            widget=get_load_current,
-            title="Load Current Config",
-            text="Load the current device configuration from the BEC server.",
-        )
-        step_ids.append(step_id)
-
-        # Register Load Config From File button
-        def get_load_file():
-            main_app.set_current("device_manager")
-            if dm_widget._initialized is True:
-                return (None, None)
-            return (dm_widget.button_load_config_from_file, None)
-
-        step_id = guided_tour.register_widget(
-            widget=get_load_file,
-            title="Load Config From File",
-            text="Load a device configuration from a YAML file on disk.",
-        )
-        step_ids.append(step_id)
-
-        ## Register steps for the initialized state
-        # Register main device table
-        def get_device_table():
-            main_app.set_current("device_manager")
-            if dm_widget._initialized is False:
-                return (None, None)
-            return (dm_widget.device_manager_display.device_table_view, None)
-
-        step_id = guided_tour.register_widget(
-            widget=get_device_table,
-            title="Device Table",
-            text="This table displays the config that is prepared to be uploaded to the BEC server. It allows users to review and modify device config settings, and also validate them before uploading to the BEC server.",
-        )
-        step_ids.append(step_id)
-
-        col_text_mapping = {
-            0: "Shows if a device configuration is valid. Automatically validated when adding a new device.",
-            1: "Shows if a device is connectable. Validated on demand.",
-            2: "Device name, unique across all devices within a config.",
-            3: "Device class used to initialize the device on the BEC server.",
-            4: "Defines how BEC treats readings of the device during scans. The options are 'monitored', 'baseline', 'async', 'continuous' or 'on_demand'.",
-            5: "Defines how BEC reacts if a device readback fails. Options are 'raise', 'retry', or 'buffer'.",
-            6: "User-defined tags associated with the device.",
-            7: "A brief description of the device.",
-            8: "Device is enabled when the configuration is loaded.",
-            9: "Device is set to read-only.",
-            10: "This flag allows to configure if the 'trigger' method of the device is called during scans.",
-        }
-
-        # We have at least one device registered
-        def get_device_table_row(column: int):
-            main_app.set_current("device_manager")
-            if dm_widget._initialized is False:
-                return (None, None)
-            table = dm_widget.device_manager_display.device_table_view.table
-            header = table.horizontalHeader()
-            x = header.sectionViewportPosition(column)
-            table.horizontalScrollBar().setValue(x)
-            # Recompute after scrolling
-            x = header.sectionViewportPosition(column)
-            w = header.sectionSize(column)
-            h = header.height()
-            rect = QRect(x, 0, w, h)
-            top_left = header.viewport().mapTo(main_app, rect.topLeft())
-
-            return (QRect(top_left, rect.size()), col_text_mapping.get(column, ""))
-
-        for col, text in col_text_mapping.items():
-            step_id = guided_tour.register_widget(
-                widget=lambda col=col: get_device_table_row(col),
-                title=f"{dm_widget.device_manager_display.device_table_view.table.horizontalHeaderItem(col).text()}",
-                text=text,
-            )
-            step_ids.append(step_id)
-
-        if not step_ids:
-            return None
-
-        return ViewTourSteps(view_title="Device Manager", step_ids=step_ids)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from bec_qthemes import apply_theme
-    from qtpy.QtWidgets import QApplication
-
-    from bec_widgets.applications.main_app import BECMainApp
-
-    app = QApplication(sys.argv)
-    apply_theme("dark")
-
-    _app = BECMainApp()
-    screen = app.primaryScreen()
-    screen_geometry = screen.availableGeometry()
-    screen_width = screen_geometry.width()
-    screen_height = screen_geometry.height()
-    # 70% of screen height, keep 16:9 ratio
-    height = int(screen_height * 0.9)
-    width = int(height * (16 / 9))
-
-    # If width exceeds screen width, scale down
-    if width > screen_width * 0.9:
-        width = int(screen_width * 0.9)
-        height = int(width / (16 / 9))
-
-    _app.resize(width, height)
-    device_manager_view = DeviceManagerView()
-    _app.add_view(
-        icon="display_settings",
-        title="Device Manager",
-        view_id="device_manager",
-        widget=device_manager_view.device_manager_widget,
-        mini_text="DM",
-    )
-    _app.show()
-    sys.exit(app.exec_())

bec_widgets/applications/views/device_manager_view/device_manager_widget.py

@@ -1,112 +0,0 @@
-"""Top Level wrapper for device_manager widget"""
-
-from __future__ import annotations
-
-import os
-
-from bec_lib.bec_yaml_loader import yaml_load
-from bec_lib.logger import bec_logger
-from bec_qthemes import material_icon
-from qtpy import QtCore, QtWidgets
-
-from bec_widgets.applications.views.device_manager_view.device_manager_display_widget import (
-    DeviceManagerDisplayWidget,
-)
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.error_popups import SafeSlot
-
-logger = bec_logger.logger
-
-
-class DeviceManagerWidget(BECWidget, QtWidgets.QWidget):
-
-    RPC = False
-
-    def __init__(self, parent=None, client=None, **kwargs):
-        super().__init__(parent=parent, client=client, **kwargs)
-        self.stacked_layout = QtWidgets.QStackedLayout()
-        self.stacked_layout.setContentsMargins(0, 0, 0, 0)
-        self.stacked_layout.setSpacing(0)
-        self.stacked_layout.setStackingMode(QtWidgets.QStackedLayout.StackAll)
-        self.setLayout(self.stacked_layout)
-
-        # Add device manager view
-        self.device_manager_display = DeviceManagerDisplayWidget(parent=self, client=self.client)
-        self.stacked_layout.addWidget(self.device_manager_display)
-
-        # Add overlay widget
-        self._overlay_widget = QtWidgets.QWidget(self)
-        self._customize_overlay()
-        self.stacked_layout.addWidget(self._overlay_widget)
-        self._initialized = False
-
-    def on_enter(self) -> None:
-        """Called after the widget becomes visible."""
-        if self._initialized is False:
-            self.stacked_layout.setCurrentWidget(self._overlay_widget)
-
-    def _customize_overlay(self):
-        self._overlay_widget.setAutoFillBackground(True)
-        self._overlay_layout = QtWidgets.QVBoxLayout()
-        self._overlay_layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
-        self._overlay_widget.setLayout(self._overlay_layout)
-        self._overlay_widget.setSizePolicy(
-            QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Expanding
-        )
-        # Load current config
-        self.button_load_current_config = QtWidgets.QPushButton("Load Current Config")
-        icon = material_icon(icon_name="database", size=(24, 24), convert_to_pixmap=False)
-        self.button_load_current_config.setIcon(icon)
-        self._overlay_layout.addWidget(self.button_load_current_config)
-        self.button_load_current_config.clicked.connect(self._load_config_clicked)
-        # Load config from disk
-        self.button_load_config_from_file = QtWidgets.QPushButton("Load Config From File")
-        icon = material_icon(icon_name="folder", size=(24, 24), convert_to_pixmap=False)
-        self.button_load_config_from_file.setIcon(icon)
-        self._overlay_layout.addWidget(self.button_load_config_from_file)
-        self.button_load_config_from_file.clicked.connect(self._load_config_from_file_clicked)
-        self._overlay_widget.setVisible(True)
-
-    def _load_config_from_file_clicked(self):
-        """Handle click on 'Load Config From File' button."""
-        self.device_manager_display._load_file_action()
-        self._initialized = True  # Set initialized to True after first load
-        self.stacked_layout.setCurrentWidget(self.device_manager_display)
-
-    @SafeSlot()
-    def _load_config_clicked(self):
-        """Handle click on 'Load Current Config' button."""
-        config = self.client.device_manager._get_redis_device_config()
-        self.device_manager_display.device_table_view.set_device_config(config)
-        self._initialized = True  # Set initialized to True after first load
-        self.stacked_layout.setCurrentWidget(self.device_manager_display)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    from bec_widgets.utils.colors import apply_theme
-
-    apply_theme("light")
-
-    widget = QtWidgets.QWidget()
-    layout = QtWidgets.QVBoxLayout(widget)
-    widget.setLayout(layout)
-    layout.setContentsMargins(0, 0, 0, 0)
-    layout.setSpacing(0)
-    device_manager = DeviceManagerWidget()
-    # config = device_manager.client.device_manager._get_redis_device_config()
-    # device_manager.device_table_view.set_device_config(config)
-    layout.addWidget(device_manager)
-    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
-
-    dark_mode_button = DarkModeButton()
-    layout.addWidget(dark_mode_button)
-    widget.show()
-    device_manager.setWindowTitle("Device Manager View")
-    device_manager.resize(1600, 1200)
-    # developer_view.set_stretch(horizontal=[1, 3, 2], vertical=[5, 5]) #can be set during runtime
-    sys.exit(app.exec_())

bec_widgets/applications/views/dock_area_view/dock_area_view.py

@@ -1,31 +0,0 @@
-from qtpy.QtWidgets import QWidget
-
-from bec_widgets.applications.views.view import ViewBase
-from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
-
-
-class DockAreaView(ViewBase):
-    """
-    Modular dock area view for arranging and managing multiple dockable widgets.
-    """
-
-    RPC_CONTENT_CLASS = BECDockArea
-
-    def __init__(
-        self,
-        parent: QWidget | None = None,
-        content: QWidget | None = None,
-        *,
-        view_id: str | None = None,
-        title: str | None = None,
-        **kwargs,
-    ):
-        super().__init__(parent=parent, content=content, view_id=view_id, title=title, **kwargs)
-        self.dock_area = BECDockArea(
-            self,
-            profile_namespace="bec",
-            auto_profile_namespace=False,
-            object_name="DockArea",
-            rpc_exposed=False,
-        )
-        self.set_content(self.dock_area)

bec_widgets/applications/views/view.py

@@ -1,320 +0,0 @@
-from __future__ import annotations
-
-from typing import List
-
-from pydantic import BaseModel
-from qtpy.QtCore import QEventLoop
-from qtpy.QtWidgets import (
-    QDialog,
-    QDialogButtonBox,
-    QFormLayout,
-    QHBoxLayout,
-    QLabel,
-    QMessageBox,
-    QPushButton,
-    QStackedLayout,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets import BECWidget
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
-from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
-from bec_widgets.widgets.plots.waveform.waveform import Waveform
-
-
-class ViewTourSteps(BaseModel):
-    """Model representing tour steps for a view.
-
-    Attributes:
-        view_title: The human-readable title of the view.
-        step_ids: List of registered step IDs in the order they should appear.
-    """
-
-    view_title: str
-    step_ids: List[str]
-
-
-class ViewBase(BECWidget, QWidget):
-    """Wrapper for a content widget used inside the main app's stacked view.
-
-    Subclasses can implement `on_enter` and `on_exit` to run custom logic when the view becomes visible or is about to be hidden.
-
-    Args:
-        content (QWidget): The actual view widget to display.
-        parent (QWidget | None): Parent widget.
-        view_id (str | None): Optional view view_id, useful for debugging or introspection.
-        title (str | None): Optional human-readable title.
-    """
-
-    RPC = True
-    PLUGIN = False
-    USER_ACCESS = ["activate"]
-    RPC_CONTENT_CLASS: type[QWidget] | None = None
-    RPC_CONTENT_ATTR = "content"
-
-    def __init__(
-        self,
-        parent: QWidget | None = None,
-        content: QWidget | None = None,
-        *,
-        view_id: str | None = None,
-        title: str | None = None,
-        **kwargs,
-    ):
-        super().__init__(parent=parent, **kwargs)
-        self.content: QWidget | None = None
-        self.view_id = view_id
-        self.view_title = title
-
-        lay = QVBoxLayout(self)
-        lay.setContentsMargins(0, 0, 0, 0)
-        lay.setSpacing(0)
-
-        if content is not None:
-            self.set_content(content)
-
-    def set_content(self, content: QWidget) -> None:
-        """Replace the current content widget with a new one."""
-        if self.content is not None:
-            self.content.setParent(None)
-        self.content = content
-        self.layout().addWidget(content)
-
-    @SafeSlot()
-    def on_enter(self) -> None:
-        """Called after the view becomes current/visible.
-
-        Default implementation does nothing. Override in subclasses.
-        """
-        pass
-
-    @SafeSlot()
-    def on_exit(self) -> bool:
-        """Called before the view is switched away/hidden.
-
-        Return True to allow switching, or False to veto.
-        Default implementation allows switching.
-        """
-        return True
-
-    @SafeSlot()
-    def activate(self) -> None:
-        """Switch the parent application to this view."""
-        if not self.view_id:
-            raise ValueError("Cannot switch view without a view_id.")
-
-        parent = self.parent()
-        while parent is not None:
-            if hasattr(parent, "set_current"):
-                parent.set_current(self.view_id)
-                return
-            parent = parent.parent()
-        raise RuntimeError("Could not find a parent application with set_current().")
-
-    def cleanup(self):
-        if self.content is not None:
-            self.content.close()
-            self.content.deleteLater()
-        super().cleanup()
-
-    def register_tour_steps(self, guided_tour, main_app) -> ViewTourSteps | None:
-        """Register this view's components with the guided tour.
-
-        Args:
-            guided_tour: The GuidedTour instance to register with.
-            main_app: The main application instance (for accessing set_current).
-
-        Returns:
-            ViewTourSteps | None: A model containing the view title and step IDs,
-                or None if this view has no tour steps.
-
-        Override this method in subclasses to register view-specific components.
-        """
-        return None
-
-
-####################################################################################################
-# Example views for demonstration/testing purposes
-####################################################################################################
-
-
-# --- Popup UI version ---
-class WaveformViewPopup(ViewBase):  # pragma: no cover
-    def __init__(self, parent=None, *args, **kwargs):
-        super().__init__(parent=parent, *args, **kwargs)
-
-        self.waveform = Waveform(parent=self)
-        self.set_content(self.waveform)
-
-    @SafeSlot()
-    def on_enter(self) -> None:
-        dialog = QDialog(self)
-        dialog.setWindowTitle("Configure Waveform View")
-
-        label = QLabel("Select device and signal for the waveform plot:", parent=dialog)
-
-        # same as in the CurveRow used in waveform
-        self.device_edit = DeviceComboBox(parent=self)
-        self.device_edit.insertItem(0, "")
-        self.device_edit.setEditable(True)
-        self.device_edit.setCurrentIndex(0)
-        self.signal_edit = SignalComboBox(parent=self)
-        self.signal_edit.include_config_signals = False
-        self.signal_edit.insertItem(0, "")
-        self.signal_edit.setEditable(True)
-        self.device_edit.currentTextChanged.connect(self.signal_edit.set_device)
-        self.device_edit.device_reset.connect(self.signal_edit.reset_selection)
-
-        form = QFormLayout()
-        form.addRow(label)
-        form.addRow("Device", self.device_edit)
-        form.addRow("Signal", self.signal_edit)
-
-        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, parent=dialog)
-        buttons.accepted.connect(dialog.accept)
-        buttons.rejected.connect(dialog.reject)
-
-        v = QVBoxLayout(dialog)
-        v.addLayout(form)
-        v.addWidget(buttons)
-
-        if dialog.exec_() == QDialog.Accepted:
-            self.waveform.plot(
-                device_y=self.device_edit.currentText(), signal_y=self.signal_edit.currentText()
-            )
-
-    @SafeSlot()
-    def on_exit(self) -> bool:
-        ans = QMessageBox.question(
-            self,
-            "Switch and clear?",
-            "Do you want to switch views and clear the plot?",
-            QMessageBox.Yes | QMessageBox.No,
-            QMessageBox.No,
-        )
-        if ans == QMessageBox.Yes:
-            self.waveform.clear_all()
-            return True
-        return False
-
-
-# --- Inline stacked UI version ---
-class WaveformViewInline(ViewBase):  # pragma: no cover
-    def __init__(self, parent=None, *args, **kwargs):
-        super().__init__(parent=parent, *args, **kwargs)
-
-        # Root layout for this view uses a stacked layout
-        self.stack = QStackedLayout()
-        container = QWidget(self)
-        container.setLayout(self.stack)
-        self.set_content(container)
-
-        # --- Page 0: Settings page (inline form)
-        self.settings_page = QWidget()
-        sp_layout = QVBoxLayout(self.settings_page)
-        sp_layout.setContentsMargins(16, 16, 16, 16)
-        sp_layout.setSpacing(12)
-
-        title = QLabel("Select device and signal for the waveform plot:", parent=self.settings_page)
-        self.device_edit = DeviceComboBox(parent=self.settings_page)
-        self.device_edit.insertItem(0, "")
-        self.device_edit.setEditable(True)
-        self.device_edit.setCurrentIndex(0)
-
-        self.entry_edit = SignalComboBox(parent=self.settings_page)
-        self.entry_edit.include_config_signals = False
-        self.entry_edit.insertItem(0, "")
-        self.entry_edit.setEditable(True)
-        self.device_edit.currentTextChanged.connect(self.entry_edit.set_device)
-        self.device_edit.device_reset.connect(self.entry_edit.reset_selection)
-
-        form = QFormLayout()
-        form.addRow(title)
-        form.addRow("Device", self.device_edit)
-        form.addRow("Signal", self.entry_edit)
-
-        btn_row = QHBoxLayout()
-        ok_btn = QPushButton("OK", parent=self.settings_page)
-        cancel_btn = QPushButton("Cancel", parent=self.settings_page)
-        btn_row.addStretch(1)
-        btn_row.addWidget(cancel_btn)
-        btn_row.addWidget(ok_btn)
-
-        sp_layout.addLayout(form)
-        sp_layout.addLayout(btn_row)
-
-        # --- Page 1: Waveform page
-        self.waveform_page = QWidget()
-        wf_layout = QVBoxLayout(self.waveform_page)
-        wf_layout.setContentsMargins(0, 0, 0, 0)
-        self.waveform = Waveform(parent=self.waveform_page)
-        wf_layout.addWidget(self.waveform)
-
-        # --- Page 2: Exit confirmation page (inline)
-        self.confirm_page = QWidget()
-        cp_layout = QVBoxLayout(self.confirm_page)
-        cp_layout.setContentsMargins(16, 16, 16, 16)
-        cp_layout.setSpacing(12)
-        qlabel = QLabel("Do you want to switch views and clear the plot?", parent=self.confirm_page)
-        cp_buttons = QHBoxLayout()
-        no_btn = QPushButton("No", parent=self.confirm_page)
-        yes_btn = QPushButton("Yes", parent=self.confirm_page)
-        cp_buttons.addStretch(1)
-        cp_buttons.addWidget(no_btn)
-        cp_buttons.addWidget(yes_btn)
-        cp_layout.addWidget(qlabel)
-        cp_layout.addLayout(cp_buttons)
-
-        # Add pages to the stack
-        self.stack.addWidget(self.settings_page)  # index 0
-        self.stack.addWidget(self.waveform_page)  # index 1
-        self.stack.addWidget(self.confirm_page)  # index 2
-
-        # Wire settings buttons
-        ok_btn.clicked.connect(self._apply_settings_and_show_waveform)
-        cancel_btn.clicked.connect(self._show_waveform_without_changes)
-
-        # Prepare result holder for the inline confirmation
-        self._exit_choice_yes = None
-        yes_btn.clicked.connect(lambda: self._exit_reply(True))
-        no_btn.clicked.connect(lambda: self._exit_reply(False))
-
-    @SafeSlot()
-    def on_enter(self) -> None:
-        # Always start on the settings page when entering
-        self.stack.setCurrentIndex(0)
-
-    @SafeSlot()
-    def on_exit(self) -> bool:
-        # Show inline confirmation page and synchronously wait for a choice
-        # -> trick to make the choice blocking, however popup would be cleaner solution
-        self._exit_choice_yes = None
-        self.stack.setCurrentIndex(2)
-        loop = QEventLoop()
-        self._exit_loop = loop
-        loop.exec_()
-
-        if self._exit_choice_yes:
-            self.waveform.clear_all()
-            return True
-        # Revert to waveform view if user cancelled switching
-        self.stack.setCurrentIndex(1)
-        return False
-
-    def _apply_settings_and_show_waveform(self):
-        dev = self.device_edit.currentText()
-        sig = self.entry_edit.currentText()
-        if dev and sig:
-            self.waveform.plot(device_y=dev, signal_y=sig)
-        self.stack.setCurrentIndex(1)
-
-    def _show_waveform_without_changes(self):
-        # Just show waveform page without plotting
-        self.stack.setCurrentIndex(1)
-
-    def _exit_reply(self, yes: bool):
-        self._exit_choice_yes = bool(yes)
-        if hasattr(self, "_exit_loop") and self._exit_loop.isRunning():
-            self._exit_loop.quit()

bec_widgets/cli/client_utils.py

@@ -1,665 +1,175 @@
-"""Client utilities for the BEC GUI."""
-
-from __future__ import annotations
-
-import json
-import os
+import importlib
 import select
 import subprocess
-import threading
-import time
-from contextlib import contextmanager
-from threading import Lock
-from typing import TYPE_CHECKING, Literal, TypeAlias, cast
+import uuid
 
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.logger import bec_logger
-from bec_lib.utils.import_utils import lazy_import, lazy_import_from
-from rich.console import Console
-from rich.table import Table
+from functools import wraps
 
-from bec_widgets.cli.rpc.rpc_base import RPCBase, RPCReference
-from bec_widgets.utils.serialization import register_serializer_extension
+from qtpy.QtCore import QCoreApplication
 
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_lib.messages import GUIRegistryStateMessage
-
-    import bec_widgets.cli.client as client
-else:
-    GUIRegistryStateMessage = lazy_import_from("bec_lib.messages", "GUIRegistryStateMessage")
-    client = lazy_import("bec_widgets.cli.client")
+import bec_widgets.cli.client as client
+from bec_lib import MessageEndpoints, messages
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 
-logger = bec_logger.logger
-
-IGNORE_WIDGETS = ["LaunchWindow"]
-
-RegistryState: TypeAlias = dict[
-    Literal["gui_id", "name", "widget_class", "config", "__rpc__", "container_proxy"],
-    str | bool | dict,
-]
-
-# pylint: disable=redefined-outer-scope
-
-
-def _filter_output(output: str) -> str:
+def rpc_call(func):
     """
-    Filter out the output from the process.
+    A decorator for calling a function on the server.
+
+    Args:
+        func: The function to call.
+
+    Returns:
+        The result of the function call.
     """
-    if "IMKClient" in output:
-        # only relevant on macOS
-        # see https://discussions.apple.com/thread/255761734?sortBy=rank
-        return ""
-    return output
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        return self._run_rpc(func.__name__, *args, **kwargs)
+
+    return wrapper
 
 
-def _get_output(process, logger) -> None:
-    log_func = {process.stdout: logger.debug, process.stderr: logger.info}
-    stream_buffer = {process.stdout: [], process.stderr: []}
-    try:
-        os.set_blocking(process.stdout.fileno(), False)
-        os.set_blocking(process.stderr.fileno(), False)
-        while process.poll() is None:
-            readylist, _, _ = select.select([process.stdout, process.stderr], [], [], 1)
-            for stream in (process.stdout, process.stderr):
-                buf = stream_buffer[stream]
-                if stream in readylist:
-                    buf.append(stream.read(4096))
-                output, _, remaining = "".join(buf).rpartition("\n")
-                output = _filter_output(output)
-                if output:
-                    log_func[stream](output)
-                    buf.clear()
-                    buf.append(remaining)
-    except Exception as e:
-        logger.error(f"Error reading process output: {str(e)}")
-
-
-def _start_plot_process(
-    gui_id: str,
-    gui_class_id: str,
-    config: dict | str,
-    gui_class: str = "dock_area",
-    logger=None,  # FIXME change gui_class back to "launcher" later
-) -> tuple[subprocess.Popen[str], threading.Thread | None]:
-    """
-    Start the plot in a new process.
-
-    Logger must be a logger object with "debug" and "error" functions,
-    or it can be left to "None" as default. None means output from the
-    process will not be captured.
-    """
-    # pylint: disable=subprocess-run-check
-    command = [
-        "bec-gui-server",
-        "--id",
-        gui_id,
-        "--gui_class",
-        gui_class,
-        "--gui_class_id",
-        gui_class_id,
-        "--hide",
-    ]
-    if config:
-        if isinstance(config, dict):
-            config = json.dumps(config)
-        command.extend(["--config", str(config)])
-
-    env_dict = os.environ.copy()
-    env_dict["PYTHONUNBUFFERED"] = "1"
-
-    if logger is None:
-        stdout_redirect = subprocess.DEVNULL
-        stderr_redirect = subprocess.DEVNULL
-    else:
-        stdout_redirect = subprocess.PIPE
-        stderr_redirect = subprocess.PIPE
-
-    process = subprocess.Popen(
-        command,
-        text=True,
-        start_new_session=True,
-        stdout=stdout_redirect,
-        stderr=stderr_redirect,
-        env=env_dict,
-    )
-    if logger is None:
-        process_output_processing_thread = None
-    else:
-        process_output_processing_thread = threading.Thread(
-            target=_get_output, args=(process, logger)
-        )
-        process_output_processing_thread.start()
-    return process, process_output_processing_thread
-
-
-class RepeatTimer(threading.Timer):
-    """RepeatTimer class."""
-
-    def run(self):
-        while not self.finished.wait(self.interval):
-            self.function(*self.args, **self.kwargs)
-
-
-# pylint: disable=protected-access
-@contextmanager
-def wait_for_server(client: BECGuiClient):
-    """Context manager to wait for the server to start."""
-    timeout = client._startup_timeout
-    if not timeout:
-        if client._gui_is_alive():
-            # there is hope, let's wait a bit
-            timeout = 1
-        else:
-            raise RuntimeError("GUI is not alive")
-    try:
-        if client._gui_started_event.wait(timeout=timeout):
-            if client._gui_started_timer is not None:
-                # cancel the timer, we are done
-                client._gui_started_timer.cancel()
-                client._gui_started_timer.join()
-        else:
-            raise TimeoutError("Could not connect to GUI server")
-    finally:
-        # after initial waiting period, do not wait so much any more
-        # (only relevant if GUI didn't start)
-        client._startup_timeout = 0
-    yield
-
-
-class WidgetNameSpace:
-    def __repr__(self):
-        console = Console()
-        table = Table(title="Available widgets for BEC CLI usage")
-        table.add_column("Widget Name", justify="left", style="magenta")
-        table.add_column("Description", justify="left")
-        for attr, value in self.__dict__.items():
-            docs = value.__doc__
-            docs = docs if docs else "No description available"
-            table.add_row(attr, docs)
-        console.print(table)
-        return ""
-
-
-class AvailableWidgetsNamespace:
-    """Namespace for available widgets in the BEC GUI."""
-
-    def __init__(self):
-        for widget in client.Widgets:
-            name = widget.value
-            if name in IGNORE_WIDGETS:
-                continue
-            setattr(self, name, name)
-
-    def __repr__(self):
-        console = Console()
-        table = Table(title="Available widgets for BEC CLI usage")
-        table.add_column("Widget Name", justify="left", style="magenta")
-        table.add_column("Description", justify="left")
-        for attr_name, _ in self.__dict__.items():
-            docs = getattr(client, attr_name).__doc__
-            docs = docs if docs else "No description available"
-            table.add_row(attr_name, docs if len(docs.strip()) > 0 else "No description available")
-        console.print(table)
-        return ""
-
-
-class BECGuiClient(RPCBase):
-    """BEC GUI client class. Container for GUI applications within Python."""
-
+class BECFigureClientMixin:
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
-        self._lock = Lock()
-        self._anchor_widget = "launcher"
-        self._killed = False
-        self._top_level: dict[str, RPCReference] = {}
-        self._startup_timeout = 0
-        self._gui_started_timer = None
-        self._gui_started_event = threading.Event()
         self._process = None
-        self._process_output_processing_thread = None
-        self._server_registry: dict[str, RegistryState] = {}
-        self._ipython_registry: dict[str, RPCReference] = {}
-        self.available_widgets = AvailableWidgetsNamespace()
-        register_serializer_extension()
 
-    ####################
-    #### Client API ####
-    ####################
+    def show(self) -> None:
+        """
+        Show the figure.
+        """
+        if self._process is None or self._process.poll() is not None:
+            self._start_plot_process()
 
-    @property
-    def launcher(self) -> RPCBase:
-        """The launcher object."""
-        return RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self, object_name="launcher")
+    def close(self) -> None:
+        """
+        Close the figure.
+        """
+        if self._process is None:
+            return
+        self._run_rpc("close", (), wait_for_rpc_response=False)
+        self._process.kill()
+        self._process = None
 
-    def connect_to_gui_server(self, gui_id: str) -> None:
-        """Connect to a GUI server"""
-        # Unregister the old callback
-        self._client.connector.unregister(
-            MessageEndpoints.gui_registry_state(self._gui_id), cb=self._handle_registry_update
-        )
-        self._gui_id = gui_id
+    def _start_plot_process(self) -> 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__
 
-        # reset the namespace
-        self._update_dynamic_namespace({})
-        self._server_registry = {}
-        self._top_level = {}
-        self._ipython_registry = {}
-
-        # Register the new callback
-        self._client.connector.register(
-            MessageEndpoints.gui_registry_state(self._gui_id),
-            cb=self._handle_registry_update,
-            parent=self,
-            from_start=True,
+        command = f"python {monitor_path} --id {self._gui_id}"
+        self._process = subprocess.Popen(
+            command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
         )
 
-    @property
-    def windows(self) -> dict:
-        """Dictionary with dock areas in the GUI."""
-        return {widget.object_name: widget for widget in self._top_level.values()}
+    def print_log(self) -> None:
+        """
+        Print the log of the plot process.
+        """
+        if self._process is None:
+            return
+        print(self._get_stderr_output())
+
+    def _get_stderr_output(self) -> str:
+        stderr_output = []
+        while self._process.poll() is not None:
+            readylist, _, _ = select.select([self._process.stderr], [], [], 0.1)
+            if not readylist:
+                break
+            line = self._process.stderr.readline()
+            if not line:
+                break
+            stderr_output.append(line.decode("utf-8"))
+        return "".join(stderr_output)
+
+    def __del__(self) -> None:
+        self.close()
+
+
+class RPCBase:
+    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
+        self._client = BECDispatcher().client
+        self._config = config if config is not None else {}
+        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())
+        self._parent = parent
+        super().__init__()
+        print(f"RPCBase: {self._gui_id}")
 
     @property
-    def window_list(self) -> list:
-        """List with dock areas in the GUI."""
-        return list(self._top_level.values())
-
-    def start(self, wait: bool = False) -> None:
-        """Start the GUI server."""
-        logger.warning("Using <gui>.start() is deprecated, use <gui>.show() instead.")
-        return self._start(wait=wait)
-
-    def show(self, wait=True) -> None:
+    def _root(self):
         """
-        Show the GUI window.
-        If the GUI server is not running, it will be started.
+        Get the root widget. This is the BECFigure widget that holds
+        the anchor gui_id.
+        """
+        parent = self
+        # pylint: disable=protected-access
+        while parent._parent is not None:
+            parent = parent._parent
+        return parent
+
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, **kwargs):
+        """
+        Run the RPC call.
 
         Args:
-            wait(bool): Whether to wait for the server to start. Defaults to True.
-        """
-        if self._check_if_server_is_alive():
-            return self._show_all()
-        return self._start(wait=wait)
-
-    def hide(self):
-        """Hide the GUI window."""
-        return self._hide_all()
-
-    def raise_window(self, wait: bool = True) -> None:
-        """
-        Bring GUI windows to the front.
-        If the GUI server is not running, it will be started.
-
-        Args:
-            wait(bool): Whether to wait for the server to start. Defaults to True.
-        """
-        if self._check_if_server_is_alive():
-            return self._raise_all()
-        return self._start(wait=wait)
-
-    def change_theme(self, theme: Literal["light", "dark"] | None = None) -> None:
-        """
-        Apply a GUI theme or toggle between dark and light.
-
-        Args:
-            theme(Literal["light", "dark"] | None): Theme to apply. If None, the current
-                theme is fetched from the GUI and toggled.
-        """
-        if not self._check_if_server_is_alive():
-            self._start(wait=True)
-
-        with wait_for_server(self):
-            if theme is None:
-                current_theme = self.launcher._run_rpc("fetch_theme")
-                next_theme = "light" if current_theme == "dark" else "dark"
-            else:
-                next_theme = theme
-            self.launcher._run_rpc("change_theme", theme=next_theme)
-
-    def new(
-        self,
-        name: str | None = None,
-        wait: bool = True,
-        geometry: tuple[int, int, int, int] | None = None,
-        launch_script: str = "dock_area",
-        startup_profile: str | Literal["restore", "skip"] | None = None,
-        **kwargs,
-    ) -> client.AdvancedDockArea:
-        """Create a new top-level dock area.
-
-        Args:
-            name(str, optional): The name of the dock area. Defaults to None.
-            wait(bool, optional): Whether to wait for the server to start. Defaults to True.
-            geometry(tuple[int, int, int, int] | None): The geometry of the dock area (pos_x, pos_y, w, h).
-            launch_script(str): The launch script to use. Defaults to "dock_area".
-            startup_profile(str | Literal["restore", "skip"] | None): Startup mode for
-                the dock area:
-                  - None: start in transient empty workspace
-                  - "restore": restore last-used profile
-                  - "skip": skip profile initialization
-                  - "<name>": load the named profile
-            **kwargs: Additional keyword arguments passed to the dock area.
+            method: The method to call.
+            args: The arguments to pass to the method.
+            wait_for_rpc_response: Whether to wait for the RPC response.
+            kwargs: The keyword arguments to pass to the method.
 
         Returns:
-            client.AdvancedDockArea: The new dock area.
-
-        Examples:
-            >>> gui.new()  # Start with an empty unsaved workspace
-            >>> gui.new(startup_profile="restore")  # Restore last profile
-            >>> gui.new(startup_profile="my_profile")  # Load explicit profile
+            The result of the RPC call.
         """
-        if "profile" in kwargs or "start_empty" in kwargs:
-            raise TypeError(
-                "gui.new() no longer accepts 'profile' or 'start_empty'. Use 'startup_profile' instead."
-            )
-
-        if not self._check_if_server_is_alive():
-            self.start(wait=True)
-        if wait:
-            with wait_for_server(self):
-                return self._new_impl(
-                    name=name,
-                    geometry=geometry,
-                    launch_script=launch_script,
-                    startup_profile=startup_profile,
-                    **kwargs,
-                )
-        return self._new_impl(
-            name=name,
-            geometry=geometry,
-            launch_script=launch_script,
-            startup_profile=startup_profile,
-            **kwargs,
+        request_id = str(uuid.uuid4())
+        rpc_msg = messages.GUIInstructionMessage(
+            action=method,
+            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
+            metadata={"request_id": request_id},
         )
+        print(f"RPCBase: {rpc_msg}")
+        # pylint: disable=protected-access
+        receiver = self._root._gui_id
+        self._client.connector.send(MessageEndpoints.gui_instructions(receiver), rpc_msg)
 
-    def _new_impl(
-        self,
-        *,
-        name: str | None,
-        geometry: tuple[int, int, int, int] | None,
-        launch_script: str,
-        startup_profile: str | Literal["restore", "skip"] | None,
-        **kwargs,
-    ):
-        if launch_script == "dock_area":
-            try:
-                return self.launcher._run_rpc(
-                    "system.launch_dock_area",
-                    name=name,
-                    geometry=geometry,
-                    startup_profile=startup_profile,
-                    **kwargs,
-                )
-            except ValueError as exc:
-                error = str(exc)
-                if (
-                    "Unknown system RPC method: system.launch_dock_area" not in error
-                    and "has no attribute 'system.launch_dock_area'" not in error
-                ):
-                    raise
-                logger.debug("Server does not support system.launch_dock_area; using launcher RPC")
+        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)
 
-        return self.launcher._run_rpc(
-            "launch",
-            launch_script=launch_script,
-            name=name,
-            geometry=geometry,
-            startup_profile=startup_profile,
-            **kwargs,
-        )  # pylint: disable=protected-access
+    def _create_widget_from_msg_result(self, msg_result):
+        if msg_result is None:
+            return None
+        if isinstance(msg_result, list):
+            return [self._create_widget_from_msg_result(res) for res in msg_result]
+        if isinstance(msg_result, dict):
+            if "__rpc__" not in msg_result:
+                return msg_result
+            cls = msg_result.pop("widget_class", None)
+            msg_result.pop("__rpc__", None)
 
-    def delete(self, name: str) -> None:
-        """Delete a dock area and its parent window.
+            if not cls:
+                return msg_result
 
-        Args:
-            name(str): The name of the dock area.
+            cls = getattr(client, cls)
+            print(msg_result)
+            return cls(parent=self, **msg_result)
+        return msg_result
+
+    def _wait_for_response(self, request_id):
         """
-        widget = self.windows.get(name)
-        if widget is None:
-            raise ValueError(f"Dock area {name} not found.")
-
-        # Get the container_proxy (parent window) gui_id from the server registry
-        obj = self._server_registry.get(widget._gui_id)
-        if obj is None:
-            raise ValueError(f"Widget {name} not found in registry.")
-
-        container_gui_id = obj.get("container_proxy")
-        if container_gui_id:
-            # Close the container window which will also clean up the dock area
-            widget._run_rpc("close", gui_id=container_gui_id)  # pylint: disable=protected-access
-        else:
-            # Fallback: just close the dock area directly
-            widget._run_rpc("close")  # pylint: disable=protected-access
-
-    def delete_all(self) -> None:
-        """Delete all dock areas."""
-        for widget_name in self.windows:
-            self.delete(widget_name)
-
-    def kill_server(self) -> None:
-        """Kill the GUI server."""
-        # Unregister the registry state
-        self._killed = True
-
-        if self._gui_started_timer is not None:
-            self._gui_started_timer.cancel()
-            self._gui_started_timer.join()
-
-        if self._process is None:
-            return
-
-        if self._process:
-            logger.success("Stopping GUI...")
-            self._process.terminate()
-            if self._process_output_processing_thread:
-                self._process_output_processing_thread.join()
-            self._process.wait()
-            self._process = None
-
-        # Unregister the registry state
-        self._client.connector.unregister(
-            MessageEndpoints.gui_registry_state(self._gui_id), cb=self._handle_registry_update
-        )
-        # Remove all reference from top level
-        self._top_level.clear()
-        self._server_registry.clear()
-
-    def close(self):
-        """Deprecated. Use kill_server() instead."""
-        # FIXME, deprecated in favor of kill, will be removed in the future
-        self.kill_server()
-
-    #########################
-    #### Private methods ####
-    #########################
-
-    def _check_if_server_is_alive(self):
-        """Checks if the process is alive"""
-        if self._process is None:
-            return False
-        if self._process.poll() is not None:
-            return False
-        return True
-
-    def _gui_post_startup(self):
-        timeout = 60
-        # Wait for 'bec' gui to be registered, this may take some time
-        # After 60s timeout. Should this raise an exception on timeout?
-        start = time.monotonic()
-        while time.monotonic() < start + timeout:
-            if len(list(self._server_registry.keys())) < 2 or not hasattr(
-                self, self._anchor_widget
-            ):
-                time.sleep(0.1)
-            else:
-                break
-
-        self._gui_started_event.set()
-
-    def _start_server(self, wait: bool = False) -> None:
+        Wait for the response from the server.
         """
-        Start the GUI server, and execute callback when it is launched
-        """
-        if self._gui_is_alive():
-            self._gui_started_event.set()
-            return
-        if self._process is None or self._process.poll() is not None:
-            logger.success("GUI starting...")
-            self._startup_timeout = 5
-            self._gui_started_event.clear()
-            self._process, self._process_output_processing_thread = _start_plot_process(
-                self._gui_id,
-                gui_class_id="bec",
-                config=self._client._service_config.config,  # pylint: disable=protected-access
-                logger=logger,
+        response = None
+        while response is None:
+            response = self._client.connector.get(
+                MessageEndpoints.gui_instruction_response(request_id)
             )
-
-            def gui_started_callback(callback):
-                try:
-                    if callable(callback):
-                        callback()
-                finally:
-                    threading.current_thread().cancel()  # type: ignore
-
-            self._gui_started_timer = RepeatTimer(
-                0.5, lambda: self._gui_is_alive() and gui_started_callback(self._gui_post_startup)
-            )
-            self._gui_started_timer.start()
-
-        if wait:
-            self._gui_started_event.wait()
-
-    def _start(self, wait: bool = False) -> None:
-        self._killed = False
-        self._client.connector.register(
-            MessageEndpoints.gui_registry_state(self._gui_id),
-            cb=self._handle_registry_update,
-            parent=self,
-        )
-        return self._start_server(wait=wait)
-
-    @staticmethod
-    def _handle_registry_update(
-        msg: dict[str, GUIRegistryStateMessage], parent: BECGuiClient
-    ) -> None:
-        # This was causing a deadlock during shutdown, not sure why.
-        # with self._lock:
-        self = parent
-        self._server_registry = cast(dict[str, RegistryState], msg["data"].state)
-        self._update_dynamic_namespace(self._server_registry)
-
-    def _do_show_all(self):
-        if self.launcher and len(self._top_level) == 0:
-            self.launcher._run_rpc("show")  # pylint: disable=protected-access
-        for window in self._top_level.values():
-            window.show()
-
-    def _show_all(self):
-        with wait_for_server(self):
-            return self._do_show_all()
-
-    def _hide_all(self):
-        with wait_for_server(self):
-            if self._killed:
-                return
-            self.launcher._run_rpc("hide")
-            for window in self._top_level.values():
-                window.hide()
-
-    def _do_raise_all(self):
-        """Bring GUI windows to the front."""
-        if self.launcher and len(self._top_level) == 0:
-            self.launcher._run_rpc("raise")  # pylint: disable=protected-access
-        for window in self._top_level.values():
-            window._run_rpc("raise")  # type: ignore[attr-defined]
-
-    def _raise_all(self):
-        with wait_for_server(self):
-            if self._killed:
-                return
-            return self._do_raise_all()
-
-    def _update_dynamic_namespace(self, server_registry: dict):
-        """
-        Update the dynamic name space with the given server registry.
-        Setting the server registry to an empty dictionary will remove all widgets from the namespace.
-
-        Args:
-            server_registry (dict): The server registry
-        """
-        top_level_widgets: dict[str, RPCReference] = {}
-        for gui_id, state in server_registry.items():
-            widget = self._add_widget(state, self)
-            if widget is None:
-                # ignore widgets that are not supported
-                continue
-            # get all top-level widgets. These are widgets that have no parent
-            if not state["config"].get("parent_id"):
-                top_level_widgets[gui_id] = widget
-
-        remove_from_registry = []
-        for gui_id, widget in self._ipython_registry.items():
-            if gui_id not in server_registry:
-                remove_from_registry.append(gui_id)
-        for gui_id in remove_from_registry:
-            self._ipython_registry.pop(gui_id)
-
-        removed_widgets = [
-            widget.object_name for widget in self._top_level.values() if widget._is_deleted()
-        ]
-
-        for widget_name in removed_widgets:
-            # the check is not strictly necessary, but better safe
-            # than sorry; who knows what the user has done
-            if hasattr(self, widget_name):
-                delattr(self, widget_name)
-
-        for gui_id, widget_ref in top_level_widgets.items():
-            setattr(self, widget_ref.object_name, widget_ref)
-
-        self._top_level = top_level_widgets
-
-        for widget in self._ipython_registry.values():
-            widget._refresh_references()
-
-    def _add_widget(self, state: dict, parent: object) -> RPCReference | None:
-        """Add a widget to the namespace
-
-        Args:
-            state (dict): The state of the widget from the _server_registry.
-            parent (object): The parent object.
-        """
-        object_name = state["object_name"]
-        gui_id = state["gui_id"]
-        if state["widget_class"] in IGNORE_WIDGETS:
-            return
-        widget_class = getattr(client, state["widget_class"], None)
-        if widget_class is None:
-            return
-        obj = self._ipython_registry.get(gui_id)
-        if obj is None:
-            widget = widget_class(gui_id=gui_id, object_name=object_name, parent=parent)
-            self._ipython_registry[gui_id] = widget
-        else:
-            widget = obj
-        obj = RPCReference(registry=self._ipython_registry, gui_id=gui_id)
-        return obj
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from bec_lib.client import BECClient
-    from bec_lib.service_config import ServiceConfig
-
-    try:
-        config = ServiceConfig()
-        bec_client = BECClient(config)
-        bec_client.start()
-
-        # Test the client_utils.py module
-        gui = BECGuiClient()
-
-        gui.show(wait=True)
-        gui.new().new(widget="Waveform")
-        time.sleep(10)
-    finally:
-        gui.kill_server()
+            QCoreApplication.processEvents()  # keep UI responsive (and execute signals/slots)
+        return response

bec_widgets/cli/generate_cli.py

@@ -1,202 +1,59 @@
-# pylint: disable=missing-module-docstring
-from __future__ import annotations
-
-import argparse
-import importlib
 import inspect
-import os
-import sys
-from pathlib import Path
-
-import black
-import isort
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import Property as QtProperty
-
-from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator, plugin_filenames
-from bec_widgets.utils.plugin_utils import BECClassContainer, get_custom_classes
-
-logger = bec_logger.logger
-
-if sys.version_info >= (3, 11):
-    from typing import get_overloads
-else:
-    print(
-        "Python version is less than 3.11, using dummy function for get_overloads. "
-        "If you want to use the real function 'typing.get_overloads()', please use Python 3.11 or later."
-    )
-
-    def get_overloads(_obj):
-        """
-        Dummy function for Python versions before 3.11.
-        """
-        return []
+import typing
 
 
 class ClientGenerator:
-    def __init__(self, base=False):
-        self._base = base
-        base_imports = (
-            """import enum
-import inspect
-import traceback
-from functools import reduce
-from operator import add
-from typing import Literal, Optional
-"""
-            if self._base
-            else "\n"
-        )
-        self.header = f"""# This file was automatically generated by generate_cli.py
-# type: ignore \n
-from __future__ import annotations
-{base_imports}
-from bec_lib.logger import bec_logger
-
-from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
-{"from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets, get_plugin_client_module" if self._base else ""}
-
-logger = bec_logger.logger
-
-# pylint: skip-file"""
+    def __init__(self):
+        self.header = """# This file was automatically generated by generate_cli.py\n
+from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECFigureClientMixin
+from typing import Literal, Optional, overload"""
 
         self.content = ""
 
-    def generate_client(self, class_container: BECClassContainer):
+    def generate_client(self, published_classes: list):
         """
-        Generate the client for the published classes, skipping any classes
-        that have `RPC = False`.
+        Generate the client for the published classes.
 
         Args:
-            class_container: The class container with the classes to generate the client for.
+            published_classes(list): The list of published classes (e.g. [BECWaveform1D, BECFigure]).
         """
-        # Filter out classes that explicitly have RPC=False
-        rpc_top_level_classes = [
-            cls for cls in class_container.rpc_top_level_classes if getattr(cls, "RPC", True)
-        ]
-        rpc_top_level_classes.sort(key=lambda x: x.__name__)
-
-        connector_classes = [
-            cls for cls in class_container.connector_classes if getattr(cls, "RPC", True)
-        ]
-        connector_classes.sort(key=lambda x: x.__name__)
-
-        self.write_client_enum(rpc_top_level_classes)
-        for cls in connector_classes:
-            logger.debug(f"generating RPC client class for {cls.__name__}")
+        for cls in published_classes:
             self.content += "\n\n"
             self.generate_content_for_class(cls)
 
-    def write_client_enum(self, published_classes: list[type]):
-        """
-        Write the client enum to the content.
-        """
-        if self._base:
-            self.content += """
-class _WidgetsEnumType(str, enum.Enum):
-    \"\"\" Enum for the available widgets, to be generated programatically  \"\"\"
-    ...
-    """
-
-        self.content += """
-
-_Widgets = {
-    """
-        for cls in published_classes:
-            self.content += f'"{cls.__name__}": "{cls.__name__}",\n    '
-
-        self.content += """}
-"""
-        if self._base:
-            self.content += """
-
-try:
-    _plugin_widgets = get_all_plugin_widgets().as_dict()
-    plugin_client = get_plugin_client_module()
-    Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
-
-    if (_overlap := _Widgets.keys() & _plugin_widgets.keys()) != set():
-        for _widget in _overlap:
-            logger.warning(f"Detected duplicate widget {_widget} in plugin repo file: {inspect.getfile(_plugin_widgets[_widget])} !")
-    for plugin_name, plugin_class in inspect.getmembers(plugin_client, inspect.isclass):
-        if issubclass(plugin_class, RPCBase) and plugin_class is not RPCBase:
-            if plugin_name in globals():
-                conflicting_file = (
-                    inspect.getfile(_plugin_widgets[plugin_name])
-                    if plugin_name in _plugin_widgets
-                    else f"{plugin_client}"
-                )
-                logger.warning(
-                    f"Plugin widget {plugin_name} from {conflicting_file} conflicts with a built-in class!"
-                )
-                continue
-            if plugin_name not in _overlap:
-                globals()[plugin_name] = plugin_class
-except ImportError as e:
-    logger.error(f"Failed loading plugins: \\n{reduce(add, traceback.format_exception(e))}")
-"""
-
     def generate_content_for_class(self, cls):
         """
         Generate the content for the class.
-
         Args:
             cls: The class for which to generate the content.
         """
 
         class_name = cls.__name__
+        module = cls.__module__
 
-        if class_name == "BECDockArea":
+        # Generate the header
+        #         self.header += f"""
+        # from {module} import {class_name}"""
+
+        # Generate the content
+        if cls.__name__ == "BECFigure":
             self.content += f"""
-class {class_name}(RPCBase):"""
+class {class_name}(RPCBase, BECFigureClientMixin):"""
         else:
             self.content += f"""
 class {class_name}(RPCBase):"""
-
-        if cls.__doc__:
-            # We only want the first line of the docstring
-            # But skip the first line if it's a blank line
-            first_line = cls.__doc__.split("\n")[0]
-            if first_line:
-                class_docs = first_line
-            else:
-                class_docs = cls.__doc__.split("\n")[1]
-            self.content += f"""
-    \"\"\"{class_docs}\"\"\"
-    """
-        user_access_entries = self._get_user_access_entries(cls)
-        if not user_access_entries:
-            self.content += """...
-    """
-
-        for method_entry in user_access_entries:
-            method, obj, is_property_setter = self._resolve_method_object(cls, method_entry)
-            if obj is None:
-                raise AttributeError(
-                    f"Method {method} not found in class {cls.__name__}. "
-                    f"Please check the USER_ACCESS list."
-                )
-            if hasattr(obj, "__rpc_timeout__"):
-                timeout = {"value": obj.__rpc_timeout__}
-            else:
-                timeout = {}
-            if isinstance(obj, (property, QtProperty)):
-                # for the cli, we can map qt properties to regular properties
-                if is_property_setter:
-                    self.content += f"""
-    @{method}.setter
-    @rpc_call"""
-                else:
-                    self.content += """
+        for method in cls.USER_ACCESS:
+            obj = getattr(cls, method)
+            if isinstance(obj, property):
+                self.content += """
     @property
     @rpc_call"""
-
                 sig = str(inspect.signature(obj.fget))
                 doc = inspect.getdoc(obj.fget)
             else:
                 sig = str(inspect.signature(obj))
                 doc = inspect.getdoc(obj)
-                overloads = get_overloads(obj)
+                overloads = typing.get_overloads(obj)
                 for overload in overloads:
                     sig_overload = str(inspect.signature(overload))
                     self.content += f"""
@@ -204,160 +61,36 @@ class {class_name}(RPCBase):"""
     def {method}{str(sig_overload)}: ...
     """
 
-                self.content += f"""
-    {self._rpc_call(timeout)}"""
+                self.content += """
+    @rpc_call"""
             self.content += f"""
     def {method}{str(sig)}:
         \"\"\"
 {doc}
         \"\"\""""
 
-    @staticmethod
-    def _get_user_access_entries(cls) -> list[str]:
-        entries = list(getattr(cls, "USER_ACCESS", []))
-        content_cls = getattr(cls, "RPC_CONTENT_CLASS", None)
-        if content_cls is not None:
-            entries.extend(getattr(content_cls, "USER_ACCESS", []))
-        return list(dict.fromkeys(entries))
-
-    @staticmethod
-    def _resolve_method_object(cls, method_entry: str):
-        method_name = method_entry
-        is_property_setter = False
-
-        if method_entry.endswith(".setter"):
-            is_property_setter = True
-            method_name = method_entry.split(".setter")[0]
-
-        candidate_classes = [cls]
-        content_cls = getattr(cls, "RPC_CONTENT_CLASS", None)
-        if content_cls is not None:
-            candidate_classes.append(content_cls)
-
-        for candidate_cls in candidate_classes:
-            obj = getattr(candidate_cls, method_name, None)
-            if obj is not None:
-                return method_name, obj, is_property_setter
-        return method_name, None, is_property_setter
-
-    def _rpc_call(self, timeout_info: dict[str, float | None]):
-        """
-        Decorator to mark a method as an RPC call.
-        This is used to generate the client code for the method.
-        """
-        if not timeout_info:
-            return "@rpc_call"
-        timeout = timeout_info.get("value", None)
-        return f"""
-    @rpc_timeout({timeout})
-    @rpc_call"""
-
     def write(self, file_name: str):
         """
-        Write the content to a file, automatically formatted with black.
+        Write the content to a file.
 
         Args:
             file_name(str): The name of the file to write to.
         """
-        # Combine header and content, then format with black
-        full_content = self.header + "\n" + self.content
-        try:
-            formatted_content = black.format_str(full_content, mode=black.Mode(line_length=100))
-        except black.NothingChanged:
-            formatted_content = full_content
-
-        config = isort.Config(
-            profile="black",
-            line_length=100,
-            multi_line_output=3,
-            include_trailing_comma=False,
-            known_first_party=["bec_widgets"],
-        )
-        formatted_content = isort.code(formatted_content, config=config)
-
         with open(file_name, "w", encoding="utf-8") as file:
-            file.write(formatted_content)
+            file.write(self.header)
+            file.write(self.content)
 
 
-def main():
-    """
-    Main entry point for the script, controlled by command line arguments.
-    """
+if __name__ == "__main__":
+    import os
 
-    parser = argparse.ArgumentParser(description="Auto-generate the client for RPC widgets")
-    parser.add_argument(
-        "--target",
-        action="store",
-        type=str,
-        help="Which package to generate plugin files for. Should be installed in the local environment (example: my_plugin_repo)",
-    )
+    from bec_widgets.widgets.figure import BECFigure
+    from bec_widgets.widgets.plots import BECPlotBase, BECWaveform1D  # ,BECCurve
+    from bec_widgets.widgets.plots.waveform1d import BECCurve
 
-    args = parser.parse_args()
-    if args.target is None:
-        logger.error(
-            "You must provide a target - for safety, the default of running this on bec_widgets core has been removed. To generate the client for bec_widgets, run `bw-generate-cli --target bec_widgets`"
-        )
-        return
-
-    logger.info(f"BEC Widget code generation tool started with args: {args}")
-
-    client_subdir = "cli" if args.target == "bec_widgets" else "widgets"
-    module_name = "bec_widgets" if args.target == "bec_widgets" else f"{args.target}.bec_widgets"
-
-    try:
-        module = importlib.import_module(module_name)
-        assert module.__file__ is not None
-        module_file = Path(module.__file__)
-        module_dir = module_file.parent if module_file.is_file() else module_file
-    except Exception as e:
-        logger.error(f"Failed to load module {module_name} for code generation: {e}")
-        return
-
-    client_path = module_dir / client_subdir / "client.py"
-
-    packages = ("widgets", "applications") if module_name == "bec_widgets" else ("widgets",)
-    rpc_classes = get_custom_classes(module_name, packages=packages)
-    logger.info(f"Obtained classes with RPC objects: {rpc_classes!r}")
-
-    generator = ClientGenerator(base=module_name == "bec_widgets")
-    logger.info(f"Generating client file at {client_path}")
-    generator.generate_client(rpc_classes)
-    generator.write(str(client_path))
-
-    if module_name != "bec_widgets":
-        non_overwrite_classes = list(clsinfo.name for clsinfo in get_custom_classes("bec_widgets"))
-        logger.info(
-            f"Not writing plugins which would conflict with builtin classes: {non_overwrite_classes}"
-        )
-    else:
-        non_overwrite_classes = []
-
-    for cls in rpc_classes.plugins:
-        logger.info(f"Writing bec-designer plugin files for {cls.__name__}...")
-
-        if cls.__name__ in non_overwrite_classes:
-            logger.error(
-                f"Not writing plugin files for {cls.__name__} because a built-in widget with that name exists"
-            )
-
-        plugin = DesignerPluginGenerator(cls)
-        if not hasattr(plugin, "info"):
-            continue
-
-        def _exists(file: str):
-            return os.path.exists(os.path.join(plugin.info.base_path, file))
-
-        if any(_exists(file) for file in plugin_filenames(plugin.info.plugin_name_snake)):
-            logger.debug(
-                f"Skipping generation of extra plugin files for {plugin.info.plugin_name_snake} - at least one file out of 'plugin.py', 'pyproject', and 'register_{plugin.info.plugin_name_snake}.py' already exists."
-            )
-            continue
-
-        plugin.run()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    sys.argv = ["bw-generate-cli", "--target", "bec_widgets"]
-    main()
+    current_path = os.path.dirname(__file__)
+    client_path = os.path.join(current_path, "client.py")
+    clss = [BECPlotBase, BECWaveform1D, BECFigure, BECCurve]
+    generator = ClientGenerator()
+    generator.generate_client(clss)
+    generator.write(client_path)

bec_widgets/cli/rpc/rpc_base.py

@@ -1,354 +0,0 @@
-from __future__ import annotations
-
-import inspect
-import threading
-import uuid
-from functools import wraps
-from typing import TYPE_CHECKING, Any, cast
-
-from bec_lib.client import BECClient
-from bec_lib.device import DeviceBaseWithConfig
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.utils.import_utils import lazy_import, lazy_import_from
-
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_lib import messages
-    from bec_lib.connector import MessageObject
-
-    import bec_widgets.cli.client as client
-    from bec_widgets.cli.client_utils import BECGuiClient
-else:
-    client = lazy_import("bec_widgets.cli.client")  # avoid circular import
-    messages = lazy_import("bec_lib.messages")
-    MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
-
-# pylint: disable=protected-access
-
-
-def _name_arg(arg):
-    if isinstance(arg, DeviceBaseWithConfig):
-        # if dev.<device> is passed to GUI, it passes full_name
-        if hasattr(arg, "full_name"):
-            return arg.full_name
-    elif hasattr(arg, "name"):
-        return arg.name
-    return arg
-
-
-def _transform_args_kwargs(args, kwargs) -> tuple[tuple, dict]:
-    return tuple(_name_arg(arg) for arg in args), {k: _name_arg(v) for k, v in kwargs.items()}
-
-
-def rpc_timeout(timeout):
-    """
-    A decorator to set a timeout for an RPC call.
-
-    Args:
-        timeout: The timeout in seconds.
-
-    Returns:
-        The decorated function.
-    """
-
-    def decorator(func):
-        @wraps(func)
-        def wrapper(self, *args, **kwargs):
-            if "timeout" not in kwargs:
-                kwargs["timeout"] = timeout
-            return func(self, *args, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
-def rpc_call(func):
-    """
-    A decorator for calling a function on the server.
-
-    Args:
-        func: The function to call.
-
-    Returns:
-        The result of the function call.
-    """
-
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        # we could rely on a strict type check here, but this is more flexible
-        # moreover, it would anyway crash for objects...
-        caller_frame = inspect.currentframe().f_back  # type: ignore
-        while caller_frame:
-            if "jedi" in caller_frame.f_globals:
-                # Jedi module is present, likely tab completion
-                # Do not run the RPC call
-                return None  # func(*args, **kwargs)
-            caller_frame = caller_frame.f_back
-
-        args, kwargs = _transform_args_kwargs(args, kwargs)
-        if not self._root._gui_is_alive():
-            raise RuntimeError("GUI is not alive")
-        return self._run_rpc(func.__name__, *args, **kwargs)
-
-    return wrapper
-
-
-class RPCResponseTimeoutError(Exception):
-    """Exception raised when an RPC response is not received within the expected time."""
-
-    def __init__(self, request_id, timeout):
-        super().__init__(
-            f"RPC response not received within {timeout} seconds for request ID {request_id}"
-        )
-
-
-class DeletedWidgetError(Exception): ...
-
-
-def check_for_deleted_widget(func):
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        if self._gui_id not in self._registry:
-            raise DeletedWidgetError(f"Widget with gui_id {self._gui_id} has been deleted")
-        return func(self, *args, **kwargs)
-
-    return wrapper
-
-
-class RPCReference:
-    def __init__(self, registry: dict, gui_id: str) -> None:
-        self._registry = registry
-        self._gui_id = gui_id
-        self.object_name = self._registry[self._gui_id].object_name
-
-    @check_for_deleted_widget
-    def __getattr__(self, name):
-        if name in ["_registry", "_gui_id", "_is_deleted", "object_name"]:
-            return super().__getattribute__(name)
-        return self._registry[self._gui_id].__getattribute__(name)
-
-    def __setattr__(self, name, value):
-        if name in ["_registry", "_gui_id", "_is_deleted", "object_name"]:
-            return super().__setattr__(name, value)
-        if self._gui_id not in self._registry:
-            raise DeletedWidgetError(f"Widget with gui_id {self._gui_id} has been deleted")
-        self._registry[self._gui_id].__setattr__(name, value)
-
-    def __repr__(self):
-        if self._gui_id not in self._registry:
-            return f"<Deleted widget with gui_id {self._gui_id}>"
-        return self._registry[self._gui_id].__repr__()
-
-    def __str__(self):
-        if self._gui_id not in self._registry:
-            return f"<Deleted widget with gui_id {self._gui_id}>"
-        return self._registry[self._gui_id].__str__()
-
-    def __dir__(self):
-        if self._gui_id not in self._registry:
-            return []
-        return self._registry[self._gui_id].__dir__()
-
-    def _is_deleted(self) -> bool:
-        return self._gui_id not in self._registry
-
-
-class RPCBase:
-    def __init__(
-        self,
-        gui_id: str | None = None,
-        config: dict | None = None,
-        object_name: str | None = None,
-        parent=None,
-        **kwargs,
-    ) -> None:
-        self._client = BECClient()  # BECClient is a singleton; here, we simply get the instance
-        self._config = config if config is not None else {}
-        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())[:5]
-        self.object_name = object_name if object_name is not None else str(uuid.uuid4())[:5]
-        self._parent = parent
-        self._msg_wait_event = threading.Event()
-        self._rpc_response = None
-        super().__init__()
-        self._rpc_references: dict[str, str] = {}
-
-    def __repr__(self):
-        type_ = type(self)
-        qualname = type_.__qualname__
-        return f"<{qualname} with name: {self.object_name}>"
-
-    def remove(self):
-        """
-        Remove the widget.
-        """
-        obj = self._root._server_registry.get(self._gui_id)
-        if obj is None:
-            raise ValueError(f"Widget {self._gui_id} not found.")
-        if proxy := obj.get("container_proxy"):
-            assert isinstance(proxy, str)
-            self._run_rpc("remove", gui_id=proxy)
-            return
-        self._run_rpc("remove")
-
-    @property
-    def _root(self) -> BECGuiClient:
-        """
-        Get the root widget. This is the BECFigure widget that holds
-        the anchor gui_id.
-        """
-        parent = self
-        # pylint: disable=protected-access
-        while parent._parent is not None:
-            parent = parent._parent
-        return parent  # type: ignore
-
-    def raise_window(self):
-        """Bring this widget (or its container) to the front."""
-        # Use explicit call to ensure action name is 'raise' (not 'raise_')
-        return self._run_rpc("raise")
-
-    def _run_rpc(
-        self,
-        method,
-        *args,
-        wait_for_rpc_response=True,
-        timeout=5,
-        gui_id: str | None = None,
-        **kwargs,
-    ) -> Any:
-        """
-        Run the RPC call.
-
-        Args:
-            method: The method to call.
-            args: The arguments to pass to the method.
-            wait_for_rpc_response: Whether to wait for the RPC response.
-            timeout: The timeout for the RPC response.
-            gui_id: The GUI ID to use for the RPC call. If None, the default GUI ID is used.
-            kwargs: The keyword arguments to pass to the method.
-
-        Returns:
-            The result of the RPC call.
-        """
-        if method in ["show", "hide", "raise"] and gui_id is None:
-            obj = self._root._server_registry.get(self._gui_id)
-            if obj is None:
-                raise ValueError(f"Widget {self._gui_id} not found.")
-            gui_id = obj.get("container_proxy")  # type: ignore
-
-        request_id = str(uuid.uuid4())
-        rpc_msg = messages.GUIInstructionMessage(
-            action=method,
-            parameter={"args": args, "kwargs": kwargs, "gui_id": gui_id or self._gui_id},
-            metadata={"request_id": request_id},
-        )
-        # pylint: disable=protected-access
-        receiver = self._root._gui_id
-        if wait_for_rpc_response:
-            self._rpc_response = None
-            self._msg_wait_event.clear()
-            self._client.connector.register(
-                MessageEndpoints.gui_instruction_response(request_id),
-                cb=self._on_rpc_response,
-                parent=self,
-            )
-
-        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
-
-        if wait_for_rpc_response:
-            try:
-                finished = self._msg_wait_event.wait(timeout)
-                if not finished:
-                    raise RPCResponseTimeoutError(request_id, timeout)
-            finally:
-                self._msg_wait_event.clear()
-                self._client.connector.unregister(
-                    MessageEndpoints.gui_instruction_response(request_id), cb=self._on_rpc_response
-                )
-
-            # we can assume that the response is a RequestResponseMessage, updated by
-            # the _on_rpc_response method
-            assert isinstance(self._rpc_response, messages.RequestResponseMessage)
-
-            if not self._rpc_response.accepted:
-                raise ValueError(self._rpc_response.message["error"])
-            msg_result = self._rpc_response.message.get("result")
-            self._rpc_response = None
-            return self._create_widget_from_msg_result(msg_result)
-
-    @staticmethod
-    def _on_rpc_response(msg_obj: MessageObject, parent: RPCBase) -> None:
-        msg = cast(messages.RequestResponseMessage, msg_obj.value)
-        parent._rpc_response = msg
-        parent._msg_wait_event.set()
-
-    def _create_widget_from_msg_result(self, msg_result):
-        if msg_result is None:
-            return None
-        if isinstance(msg_result, list):
-            return [self._create_widget_from_msg_result(res) for res in msg_result]
-        if isinstance(msg_result, dict):
-            if "__rpc__" not in msg_result:
-                return {
-                    key: self._create_widget_from_msg_result(val) for key, val in msg_result.items()
-                }
-            rpc_enabled = msg_result.get("__rpc__", True)
-            if rpc_enabled is False:
-                return None
-
-            msg_result = dict(msg_result)
-            cls = msg_result.pop("widget_class", None)
-            msg_result.pop("__rpc__", None)
-
-            if not cls:
-                return msg_result
-
-            cls = getattr(client, cls)
-            # The namespace of the object will be updated dynamically on the client side
-            # Therefore it is important to check if the object is already in the registry
-            # If yes, we return the reference to the object, otherwise we create a new object
-            # pylint: disable=protected-access
-            if msg_result["gui_id"] in self._root._ipython_registry:
-                return RPCReference(self._root._ipython_registry, msg_result["gui_id"])
-            ret = cls(parent=self, **msg_result)
-            self._root._ipython_registry[ret._gui_id] = ret
-            self._refresh_references()
-            obj = RPCReference(self._root._ipython_registry, ret._gui_id)
-            return obj
-            # return ret
-        return msg_result
-
-    def _gui_is_alive(self):
-        """
-        Check if the GUI is alive.
-        """
-        heart = self._client.connector.get(MessageEndpoints.gui_heartbeat(self._root._gui_id))
-        if heart is None:
-            return False
-        if heart.status == messages.BECStatus.RUNNING:
-            return True
-        return False
-
-    def _refresh_references(self):
-        """
-        Refresh the references.
-        """
-        with self._root._lock:
-            references = {}
-            for key, val in self._root._server_registry.items():
-                parent_id = val["config"].get("parent_id")
-                if parent_id == self._gui_id:
-                    references[key] = {
-                        "gui_id": val["config"]["gui_id"],
-                        "object_name": val["object_name"],
-                    }
-            removed_references = set(self._rpc_references.keys()) - set(references.keys())
-            for key in removed_references:
-                delattr(self, self._rpc_references[key]["object_name"])
-            self._rpc_references = references
-            for key, val in references.items():
-                setattr(
-                    self,
-                    val["object_name"],
-                    RPCReference(self._root._ipython_registry, val["gui_id"]),
-                )

bec_widgets/cli/rpc/rpc_register.py

@@ -1,196 +0,0 @@
-from __future__ import annotations
-
-from functools import wraps
-from threading import RLock
-from typing import TYPE_CHECKING, Callable
-from weakref import WeakValueDictionary
-
-import shiboken6 as shb
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import QObject
-
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_widgets.utils.bec_connector import BECConnector
-    from bec_widgets.utils.bec_widget import BECWidget
-
-logger = bec_logger.logger
-
-
-def broadcast_update(func):
-    """
-    Decorator to broadcast updates to the RPCRegister whenever a new RPC object is added or removed.
-    If class attribute _skip_broadcast is set to True, the broadcast will be skipped
-    """
-
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        result = func(self, *args, **kwargs)
-        self.broadcast()
-        return result
-
-    return wrapper
-
-
-class RPCRegister:
-    """
-    A singleton class that keeps track of all the RPC objects registered in the system for CLI usage.
-    """
-
-    _instance = None
-    _initialized = False
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super(RPCRegister, cls).__new__(cls)
-            cls._initialized = False
-        return cls._instance
-
-    def __init__(self):
-        if self._initialized:
-            return
-        self._rpc_register = WeakValueDictionary()
-        self._broadcast_on_hold = RPCRegisterBroadcast(self)
-        self._lock = RLock()
-        self._skip_broadcast = False
-        self._initialized = True
-        self.callbacks = []
-
-    @classmethod
-    def delayed_broadcast(cls):
-        """
-        Delay the broadcast of the update to all the callbacks.
-        """
-        register = cls()
-        return register._broadcast_on_hold
-
-    @broadcast_update
-    def add_rpc(self, rpc: BECConnector):
-        """
-        Add an RPC object to the register.
-
-        Args:
-            rpc(QObject): The RPC object to be added to the register.
-        """
-        if not hasattr(rpc, "gui_id"):
-            raise ValueError("RPC object must have a 'gui_id' attribute.")
-        self._rpc_register[rpc.gui_id] = rpc
-
-    @broadcast_update
-    def remove_rpc(self, rpc: BECConnector):
-        """
-        Remove an RPC object from the register.
-
-        Args:
-            rpc(str): The RPC object to be removed from the register.
-        """
-        if not hasattr(rpc, "gui_id"):
-            raise ValueError(f"RPC object {rpc} must have a 'gui_id' attribute.")
-        self._rpc_register.pop(rpc.gui_id, None)
-
-    def get_rpc_by_id(self, gui_id: str) -> QObject | None:
-        """
-        Get an RPC object by its ID.
-
-        Args:
-            gui_id(str): The ID of the RPC object to be retrieved.
-
-        Returns:
-            QObject | None: The RPC object with the given ID or None
-        """
-        rpc_object = self._rpc_register.get(gui_id, None)
-        return rpc_object
-
-    def list_all_connections(self) -> dict:
-        """
-        List all the registered RPC objects.
-
-        Returns:
-            dict: A dictionary containing all the registered RPC objects.
-        """
-        with self._lock:
-            connections = {}
-            for gui_id, obj in self._rpc_register.items():
-                try:
-                    if not shb.isValid(obj):
-                        continue
-                    connections[gui_id] = obj
-                except Exception as e:
-                    logger.warning(f"Error checking validity of object {gui_id}: {e}")
-                    continue
-        return connections
-
-    def get_names_of_rpc_by_class_type(
-        self, cls: type[BECWidget] | type[BECConnector]
-    ) -> list[str]:
-        """Get all the names of the widgets.
-
-        Args:
-            cls(BECWidget | BECConnector): The class of the RPC object to be retrieved.
-        """
-        # This retrieves any rpc objects that are subclass of BECWidget,
-        # i.e. curve and image items are excluded
-        widgets = [rpc for rpc in self._rpc_register.values() if isinstance(rpc, cls)]
-        return [widget.object_name for widget in widgets]
-
-    def broadcast(self):
-        """
-        Broadcast the update to all the callbacks.
-        """
-
-        if self._skip_broadcast:
-            return
-        connections = self.list_all_connections()
-        for callback in self.callbacks:
-            callback(connections)
-
-    def object_is_registered(self, obj: BECConnector) -> bool:
-        """
-        Check if an object is registered in the RPC register.
-
-        Args:
-            obj(QObject): The object to check.
-
-        Returns:
-            bool: True if the object is registered, False otherwise.
-        """
-        return obj.gui_id in self._rpc_register
-
-    def add_callback(self, callback: Callable[[dict], None]):
-        """
-        Add a callback that will be called whenever the registry is updated.
-
-        Args:
-            callback(Callable[[dict], None]): The callback to be added. It should accept a dictionary of all the
-            registered RPC objects as an argument.
-        """
-        self.callbacks.append(callback)
-
-    @classmethod
-    def reset_singleton(cls):
-        """
-        Reset the singleton instance.
-        """
-        cls._instance = None
-        cls._initialized = False
-
-
-class RPCRegisterBroadcast:
-    """Context manager for RPCRegister broadcast."""
-
-    def __init__(self, rpc_register: RPCRegister) -> None:
-        self.rpc_register = rpc_register
-        self._call_depth = 0
-
-    def __enter__(self):
-        """Enter the context manager"""
-        self._call_depth += 1  # Needed for nested calls
-        self.rpc_register._skip_broadcast = True
-        return self.rpc_register
-
-    def __exit__(self, *exc):
-        """Exit the context manager"""
-
-        self._call_depth -= 1  # Remove nested calls
-        if self._call_depth == 0:  # The Last one to exit is responsible for broadcasting
-            self.rpc_register._skip_broadcast = False
-        self.rpc_register.broadcast()

bec_widgets/cli/rpc/rpc_widget_handler.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from bec_widgets.cli.client_utils import IGNORE_WIDGETS
-from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.plugin_utils import get_custom_classes
-
-
-class RPCWidgetHandler:
-    """Handler class for creating widgets from RPC messages."""
-
-    def __init__(self):
-        self._widget_classes = None
-
-    @property
-    def widget_classes(self) -> dict[str, type[BECWidget]]:
-        """
-        Get the available widget classes.
-
-        Returns:
-            dict: The available widget classes.
-        """
-        if self._widget_classes is None:
-            self.update_available_widgets()
-        return self._widget_classes  # type: ignore
-
-    def update_available_widgets(self):
-        """
-        Update the available widgets.
-
-        Returns:
-            None
-        """
-        self._widget_classes = (
-            get_custom_classes("bec_widgets", packages=("widgets", "applications"))
-            + get_all_plugin_widgets()
-        ).as_dict(IGNORE_WIDGETS)
-
-    def create_widget(self, widget_type, **kwargs) -> BECWidget:
-        """
-        Create a widget from an RPC message.
-
-        Args:
-            widget_type(str): The type of the widget.
-            name (str): The name of the widget.
-            **kwargs: The keyword arguments for the widget.
-
-        Returns:
-            widget(BECWidget): The created widget.
-        """
-        widget_class = self.widget_classes.get(widget_type)  # type: ignore
-        if widget_class:
-            return widget_class(**kwargs)
-        raise ValueError(f"Unknown widget type: {widget_type}")
-
-
-widget_handler = RPCWidgetHandler()

bec_widgets/cli/server.py

@@ -1,195 +1,110 @@
-from __future__ import annotations
+import inspect
 
-import argparse
-import json
-import os
-import signal
-import sys
-from contextlib import redirect_stderr, redirect_stdout
+from bec_lib import MessageEndpoints, messages
 
-import darkdetect
-import shiboken6
-from bec_lib.logger import bec_logger
-from bec_lib.service_config import ServiceConfig
-from bec_qthemes import apply_theme
-from qtmonaco.pylsp_provider import pylsp_server
-from qtpy.QtCore import QSize, Qt
-from qtpy.QtGui import QIcon
-from qtpy.QtWidgets import QApplication
-
-import bec_widgets
-from bec_widgets.applications.launch_window import LaunchWindow
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-
-logger = bec_logger.logger
-
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.widgets.figure import BECFigure
+from bec_widgets.widgets.plots import BECCurve, BECWaveform1D
 
 
-class SimpleFileLikeFromLogOutputFunc:
-    def __init__(self, log_func):
-        self._log_func = log_func
-        self._buffer = []
+class BECWidgetsCLIServer:
+    WIDGETS = [BECWaveform1D, BECFigure, BECCurve]
 
-    def write(self, buffer):
-        self._buffer.append(buffer)
+    def __init__(self, gui_id: str = None, dispatcher: BECDispatcher = None) -> None:
+        self.dispatcher = BECDispatcher() if dispatcher is None else dispatcher
+        self.client = self.dispatcher.client
+        self.client.start()
+        self.gui_id = gui_id
+        self.fig = BECFigure(gui_id=self.gui_id)
+        print(f"Server started with gui_id {self.gui_id}")
 
-    def flush(self):
-        lines, _, remaining = "".join(self._buffer).rpartition("\n")
-        if lines:
-            self._log_func(lines)
-        self._buffer = [remaining]
-
-    @property
-    def encoding(self):
-        return "utf-8"
-
-    def close(self):
-        return
-
-
-class GUIServer:
-    """
-    This class is used to start the BEC GUI and is the main entry point for launching BEC Widgets in a subprocess.
-    """
-
-    def __init__(self, args):
-        self.config = args.config
-        self.gui_id = args.id
-        self.gui_class = args.gui_class
-        self.gui_class_id = args.gui_class_id
-        self.hide = args.hide
-        self.app: QApplication | None = None
-        self.launcher_window: LaunchWindow | None = None
-        self.dispatcher: BECDispatcher | None = None
+        self.dispatcher.connect_slot(
+            self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
+        )
 
     def start(self):
-        """
-        Start the GUI server.
-        """
-        bec_logger.level = bec_logger.LOGLEVEL.INFO
-        if self.hide:
-            # pylint: disable=protected-access
-            bec_logger._stderr_log_level = bec_logger.LOGLEVEL.ERROR
-            bec_logger._update_sinks()
+        """Start the figure window."""
+        self.fig.start()
 
-        with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.info)):  # type: ignore
-            with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):  # type: ignore
-                self._run()
-
-    def _get_service_config(self) -> ServiceConfig:
-        if self.config:
-            try:
-                config = json.loads(self.config)
-                service_config = ServiceConfig(config=config)
-            except (json.JSONDecodeError, TypeError):
-                service_config = ServiceConfig(config_path=config)
+    def on_rpc_update(self, msg: dict, metadata: dict):
+        request_id = metadata.get("request_id")
+        try:
+            method = msg["action"]
+            args = msg["parameter"].get("args", [])
+            kwargs = msg["parameter"].get("kwargs", {})
+            obj = self.get_object_from_config(msg["parameter"])
+            res = self.run_rpc(obj, method, args, kwargs)
+        except Exception as e:
+            print(e)
+            self.send_response(request_id, False, {"error": str(e)})
         else:
-            # if no config is provided, use the default config
-            service_config = ServiceConfig()
-        return service_config
+            self.send_response(request_id, True, {"result": res})
 
-    def _run(self):
-        """
-        Run the GUI server.
-        """
-        logger.info("Starting GUIServer", repr(self))
-        self.app = QApplication(sys.argv)
-        if darkdetect.isDark():
-            apply_theme("dark")
-        else:
-            apply_theme("light")
-
-        self.app.setApplicationName("BEC")
-        self.app.gui_id = self.gui_id  # type: ignore
-        self.app.gui_server = self  # type: ignore # make server accessible from QApplication for getattr in widgets
-        self.setup_bec_icon()
-
-        service_config = self._get_service_config()
-        self.dispatcher = BECDispatcher(config=service_config, gui_id=self.gui_id)
-
-        if self.gui_class:
-            self.launcher_window = LaunchWindow(
-                gui_id=f"{self.gui_id}:launcher",
-                launch_gui_class=self.gui_class,
-                launch_gui_id=self.gui_class_id,
-            )
-        else:
-            self.launcher_window = LaunchWindow(gui_id=f"{self.gui_id}:launcher")
-        self.launcher_window.setAttribute(Qt.WA_ShowWithoutActivating)  # type: ignore
-
-        self.app.aboutToQuit.connect(self.shutdown)
-        self.app.setQuitOnLastWindowClosed(True)
-
-        def sigint_handler(*args):
-            # display message, for people to let it terminate gracefully
-            print("Caught SIGINT, exiting")
-            # Widgets should be all closed.
-            with RPCRegister.delayed_broadcast():
-                for widget in QApplication.instance().topLevelWidgets():  # type: ignore
-                    widget.close()
-            self.shutdown()
-
-        signal.signal(signal.SIGINT, sigint_handler)
-        signal.signal(signal.SIGTERM, sigint_handler)
-
-        sys.exit(self.app.exec())
-
-    def setup_bec_icon(self):
-        """
-        Set the BEC icon for the application
-        """
-        if self.app is None:
-            return
-        icon = QIcon()
-        icon.addFile(
-            os.path.join(MODULE_PATH, "assets", "app_icons", "bec_widgets_icon.png"),
-            size=QSize(48, 48),
+    def send_response(self, request_id: str, accepted: bool, msg: dict):
+        self.client.connector.set(
+            MessageEndpoints.gui_instruction_response(request_id),
+            messages.RequestResponseMessage(accepted=accepted, message=msg),
+            expire=60,
         )
-        self.app.setWindowIcon(icon)
 
-    def shutdown(self):
-        logger.info("Shutdown GUIServer", repr(self))
-        if self.launcher_window and shiboken6.isValid(self.launcher_window):
-            self.launcher_window.close()
-            self.launcher_window.deleteLater()
-        if pylsp_server.is_running():
-            pylsp_server.stop()
-        if self.dispatcher:
-            self.dispatcher.stop_cli_server()
-            self.dispatcher.disconnect_all()
+    def get_object_from_config(self, config: dict):
+        gui_id = config.get("gui_id")
+        # check if the object is the figure
+        if gui_id == self.fig.gui_id:
+            return self.fig
+        # check if the object is a widget
+        if gui_id in self.fig.widgets:
+            obj = self.fig.widgets[config["gui_id"]]
+            return obj
+        if self.fig.widgets:
+            for widget in self.fig.widgets.values():
+                item = widget.find_widget_by_id(gui_id)
+                if item:
+                    return item
+                raise NotImplementedError(
+                    f"gui_id lookup for widget of type {widget.__class__.__name__} not implemented"
+                )
 
+        raise ValueError(f"Object with gui_id {gui_id} not found")
 
-def main():
-    """
-    Main entry point for subprocesses that start a GUI server.
-    """
+    def run_rpc(self, obj, method, args, kwargs):
+        method_obj = getattr(obj, method)
+        # check if the method accepts args and kwargs
+        if not callable(method_obj):
+            res = method_obj
+        else:
+            sig = inspect.signature(method_obj)
+            if sig.parameters:
+                res = method_obj(*args, **kwargs)
+            else:
+                res = method_obj()
 
-    parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
-    parser.add_argument("--id", type=str, default="test", help="The id of the server")
-    parser.add_argument(
-        "--gui_class",
-        type=str,
-        help="Name of the gui class to be rendered. Possible values: \n- BECFigure\n- BECDockArea",
-    )
-    parser.add_argument(
-        "--gui_class_id",
-        type=str,
-        default="bec",
-        help="The id of the gui class that is added to the QApplication",
-    )
-    parser.add_argument("--config", type=str, help="Config file or config string.")
-    parser.add_argument("--hide", action="store_true", help="Hide on startup")
+        if isinstance(res, list):
+            res = [self.serialize_object(obj) for obj in res]
+        else:
+            res = self.serialize_object(res)
+        return res
 
-    args = parser.parse_args()
-
-    server = GUIServer(args)
-    server.start()
+    def serialize_object(self, obj):
+        if isinstance(obj, BECConnector):
+            return {
+                "gui_id": obj.gui_id,
+                "widget_class": obj.__class__.__name__,
+                "config": obj.config.model_dump(),
+                "__rpc__": True,
+            }
+        return obj
 
 
 if __name__ == "__main__":
-    # import sys
+    import argparse
 
-    # sys.argv = ["bec_widgets", "--gui_class", "MainWindow"]
-    main()
+    parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
+    parser.add_argument("--id", type=str, help="The id of the server")
+
+    args = parser.parse_args()
+
+    server = BECWidgetsCLIServer(gui_id=args.id)
+    # server = BECWidgetsCLIServer(gui_id="test")
+    server.start()

bec_widgets/examples/__init__.py

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

bec_widgets/examples/crosshair_example/crosshair_example.py

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

bec_widgets/examples/eiger_plot/eiger_plot.py

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

bec_widgets/examples/eiger_plot/eiger_plot.ui

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

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -1,405 +0,0 @@
-from __future__ import annotations
-
-import ast
-import importlib
-import os
-from typing import Any, Dict
-
-import numpy as np
-import pyqtgraph as pg
-from bec_qthemes import material_icon
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import (
-    QApplication,
-    QComboBox,
-    QFrame,
-    QGridLayout,
-    QGroupBox,
-    QHBoxLayout,
-    QLabel,
-    QLineEdit,
-    QPushButton,
-    QSplitter,
-    QTabWidget,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.cli.rpc.rpc_widget_handler import widget_handler
-from bec_widgets.utils.colors import apply_theme
-from bec_widgets.utils.widget_io import WidgetHierarchy as wh
-from bec_widgets.widgets.editors.jupyter_console.jupyter_console import BECJupyterConsole
-
-
-class JupyterConsoleWindow(QWidget):  # pragma: no cover:
-    """A widget that contains a Jupyter console linked to BEC Widgets with full API access.
-
-    Features:
-    - Add widgets dynamically from the UI (top-right panel) or from the console via `jc.add_widget(...)`.
-    - Add BEC widgets by registered type via a combo box or `jc.add_widget_by_type(...)`.
-    - Each added widget appears as a new tab in the left tab widget and is exposed in the console under the chosen shortcut.
-    - Hardcoded example tabs removed; two examples are added programmatically at startup in the __main__ block.
-    """
-
-    def __init__(self, parent=None, *args, **kwargs):
-        super().__init__(parent, *args, **kwargs)
-
-        self._widgets_by_name: Dict[str, QWidget] = {}
-        self._init_ui()
-
-        # expose helper API and basics in the inprocess console
-        if self.console.inprocess is True:
-            # A thin API wrapper so users have a stable, minimal surface in the console
-            class _ConsoleAPI:
-                def __init__(self, win: "JupyterConsoleWindow"):
-                    self._win = win
-
-                def add_widget(self, widget: QWidget, shortcut: str, title: str | None = None):
-                    """Add an existing QWidget as a new tab and expose it in the console under `shortcut`."""
-                    return self._win.add_widget(widget, shortcut, title=title)
-
-                def add_widget_by_class_path(
-                    self,
-                    class_path: str,
-                    shortcut: str,
-                    kwargs: dict | None = None,
-                    title: str | None = None,
-                ):
-                    """Import a QWidget class from `class_path`, instantiate it, and add it."""
-                    return self._win.add_widget_by_class_path(
-                        class_path, shortcut, kwargs=kwargs, title=title
-                    )
-
-                def add_widget_by_type(
-                    self,
-                    widget_type: str,
-                    shortcut: str,
-                    kwargs: dict | None = None,
-                    title: str | None = None,
-                ):
-                    """Instantiate a registered BEC widget by type string and add it."""
-                    return self._win.add_widget_by_type(
-                        widget_type, shortcut, kwargs=kwargs, title=title
-                    )
-
-                def list_widgets(self):
-                    return list(self._win._widgets_by_name.keys())
-
-                def get_widget(self, shortcut: str) -> QWidget | None:
-                    return self._win._widgets_by_name.get(shortcut)
-
-                def available_widgets(self):
-                    return list(widget_handler.widget_classes.keys())
-
-            self.jc = _ConsoleAPI(self)
-            self._push_to_console({"jc": self.jc, "np": np, "pg": pg, "wh": wh})
-
-    def _init_ui(self):
-        self.layout = QHBoxLayout(self)
-
-        # Horizontal splitter: left = widgets tabs, right = console + add-widget panel
-        splitter = QSplitter(self)
-        self.layout.addWidget(splitter)
-
-        # Left: tabs that will host dynamically added widgets
-        self.tab_widget = QTabWidget(splitter)
-
-        # Right: console area with an add-widget mini panel on top
-        right_panel = QGroupBox("Jupyter Console", splitter)
-        right_layout = QVBoxLayout(right_panel)
-        right_layout.setContentsMargins(6, 12, 6, 6)
-
-        # Add-widget mini panel
-        add_panel = QFrame(right_panel)
-        shape = QFrame.Shape.StyledPanel  # PySide6 style enums
-        add_panel.setFrameShape(shape)
-        add_grid = QGridLayout(add_panel)
-        add_grid.setContentsMargins(8, 8, 8, 8)
-        add_grid.setHorizontalSpacing(8)
-        add_grid.setVerticalSpacing(6)
-
-        instr = QLabel(
-            "Add a widget by class path or choose a registered BEC widget type,"
-            " and expose it in the console under a shortcut.\n"
-            "Example class path: bec_widgets.widgets.plots.waveform.waveform.Waveform"
-        )
-        instr.setWordWrap(True)
-        add_grid.addWidget(instr, 0, 0, 1, 2)
-
-        # Registered widget selector
-        reg_label = QLabel("Registered")
-        reg_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
-        self.registry_combo = QComboBox(add_panel)
-        self.registry_combo.setEditable(False)
-        self.refresh_btn = QPushButton("Refresh")
-        reg_row = QHBoxLayout()
-        reg_row.addWidget(self.registry_combo)
-        reg_row.addWidget(self.refresh_btn)
-        add_grid.addWidget(reg_label, 1, 0)
-        add_grid.addLayout(reg_row, 1, 1)
-
-        # Class path entry
-        class_label = QLabel("Class")
-        class_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
-        self.class_path_edit = QLineEdit(add_panel)
-        self.class_path_edit.setPlaceholderText("Fully-qualified class path (e.g. pkg.mod.Class)")
-        add_grid.addWidget(class_label, 2, 0)
-        add_grid.addWidget(self.class_path_edit, 2, 1)
-
-        # Shortcut
-        shortcut_label = QLabel("Shortcut")
-        shortcut_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
-        self.shortcut_edit = QLineEdit(add_panel)
-        self.shortcut_edit.setPlaceholderText("Shortcut in console (variable name)")
-        add_grid.addWidget(shortcut_label, 3, 0)
-        add_grid.addWidget(self.shortcut_edit, 3, 1)
-
-        # Kwargs
-        kwargs_label = QLabel("Kwargs")
-        kwargs_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
-        self.kwargs_edit = QLineEdit(add_panel)
-        self.kwargs_edit.setPlaceholderText(
-            'Optional kwargs as dict literal, e.g. {"popups": True}'
-        )
-        add_grid.addWidget(kwargs_label, 4, 0)
-        add_grid.addWidget(self.kwargs_edit, 4, 1)
-
-        # Title
-        title_label = QLabel("Title")
-        title_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
-        self.title_edit = QLineEdit(add_panel)
-        self.title_edit.setPlaceholderText("Optional tab title (defaults to Shortcut or Class)")
-        add_grid.addWidget(title_label, 5, 0)
-        add_grid.addWidget(self.title_edit, 5, 1)
-
-        # Buttons
-        btn_row = QHBoxLayout()
-        self.add_btn = QPushButton("Add by class path")
-        self.add_btn.clicked.connect(self._on_add_widget_clicked)
-        self.add_reg_btn = QPushButton("Add registered")
-        self.add_reg_btn.clicked.connect(self._on_add_registered_clicked)
-        btn_row.addStretch(1)
-        btn_row.addWidget(self.add_reg_btn)
-        btn_row.addWidget(self.add_btn)
-        add_grid.addLayout(btn_row, 6, 0, 1, 2)
-
-        # Make the second column expand
-        add_grid.setColumnStretch(0, 0)
-        add_grid.setColumnStretch(1, 1)
-
-        # Console widget
-        self.console = BECJupyterConsole(inprocess=True)
-
-        # Vertical splitter between add panel and console
-        right_splitter = QSplitter(Qt.Vertical, right_panel)
-        right_splitter.addWidget(add_panel)
-        right_splitter.addWidget(self.console)
-        right_splitter.setStretchFactor(0, 0)
-        right_splitter.setStretchFactor(1, 1)
-        right_splitter.setSizes([300, 600])
-
-        # Put splitter into the right group box
-        right_layout.addWidget(right_splitter)
-
-        # Populate registry on startup
-        self._populate_registry_widgets()
-
-    def _populate_registry_widgets(self):
-        try:
-            widget_handler.update_available_widgets()
-            items = sorted(widget_handler.widget_classes.keys())
-        except Exception as exc:
-            print(f"Failed to load registered widgets: {exc}")
-            items = []
-        self.registry_combo.clear()
-        self.registry_combo.addItems(items)
-
-    def _on_add_widget_clicked(self):
-        class_path = self.class_path_edit.text().strip()
-        shortcut = self.shortcut_edit.text().strip()
-        kwargs_text = self.kwargs_edit.text().strip()
-        title = self.title_edit.text().strip() or None
-
-        if not class_path or not shortcut:
-            print("Please provide both class path and shortcut.")
-            return
-
-        kwargs: dict | None = None
-        if kwargs_text:
-            try:
-                parsed = ast.literal_eval(kwargs_text)
-                if isinstance(parsed, dict):
-                    kwargs = parsed
-                else:
-                    print("Kwargs must be a Python dict literal, ignoring input.")
-            except Exception as exc:
-                print(f"Failed to parse kwargs: {exc}")
-
-        try:
-            widget = self._instantiate_from_class_path(class_path, kwargs=kwargs)
-        except Exception as exc:
-            print(f"Failed to instantiate {class_path}: {exc}")
-            return
-
-        try:
-            self.add_widget(widget, shortcut, title=title)
-        except Exception as exc:
-            print(f"Failed to add widget: {exc}")
-            return
-
-        # focus the newly added tab
-        idx = self.tab_widget.count() - 1
-        if idx >= 0:
-            self.tab_widget.setCurrentIndex(idx)
-
-    def _on_add_registered_clicked(self):
-        widget_type = self.registry_combo.currentText().strip()
-        shortcut = self.shortcut_edit.text().strip()
-        kwargs_text = self.kwargs_edit.text().strip()
-        title = self.title_edit.text().strip() or None
-
-        if not widget_type or not shortcut:
-            print("Please select a registered widget and provide a shortcut.")
-            return
-
-        kwargs: dict | None = None
-        if kwargs_text:
-            try:
-                parsed = ast.literal_eval(kwargs_text)
-                if isinstance(parsed, dict):
-                    kwargs = parsed
-                else:
-                    print("Kwargs must be a Python dict literal, ignoring input.")
-            except Exception as exc:
-                print(f"Failed to parse kwargs: {exc}")
-
-        try:
-            self.add_widget_by_type(widget_type, shortcut, kwargs=kwargs, title=title)
-        except Exception as exc:
-            print(f"Failed to add registered widget: {exc}")
-            return
-
-        # focus the newly added tab
-        idx = self.tab_widget.count() - 1
-        if idx >= 0:
-            self.tab_widget.setCurrentIndex(idx)
-
-    def _instantiate_from_class_path(self, class_path: str, kwargs: dict | None = None) -> QWidget:
-        module_path, _, class_name = class_path.rpartition(".")
-        if not module_path or not class_name:
-            raise ValueError("class_path must be of the form 'package.module.Class'")
-        module = importlib.import_module(module_path)
-        cls = getattr(module, class_name)
-        if kwargs is None:
-            obj = cls()
-        else:
-            obj = cls(**kwargs)
-        if not isinstance(obj, QWidget):
-            raise TypeError(f"Instantiated object from {class_path} is not a QWidget: {type(obj)}")
-        return obj
-
-    def add_widget(self, widget: QWidget, shortcut: str, title: str | None = None) -> QWidget:
-        """Add a QWidget as a new tab and expose it in the Jupyter console.
-
-        - widget: a QWidget instance to host in a new tab
-        - shortcut: variable name used in the console to access it
-        - title: optional tab title (defaults to shortcut or class name)
-        """
-        if not isinstance(widget, QWidget):
-            raise TypeError("widget must be a QWidget instance")
-        if not shortcut or not shortcut.isidentifier():
-            raise ValueError("shortcut must be a valid Python identifier")
-        if shortcut in self._widgets_by_name:
-            raise ValueError(f"A widget with shortcut '{shortcut}' already exists")
-        if self.console.inprocess is not True:
-            raise RuntimeError("Adding widgets and exposing them requires inprocess console")
-
-        tab_title = title or shortcut or widget.__class__.__name__
-        self.tab_widget.addTab(widget, tab_title)
-        self._widgets_by_name[shortcut] = widget
-
-        # Expose in console under the given shortcut
-        self._push_to_console({shortcut: widget})
-        return widget
-
-    def add_widget_by_class_path(
-        self, class_path: str, shortcut: str, kwargs: dict | None = None, title: str | None = None
-    ) -> QWidget:
-        widget = self._instantiate_from_class_path(class_path, kwargs=kwargs)
-        return self.add_widget(widget, shortcut, title=title)
-
-    def add_widget_by_type(
-        self, widget_type: str, shortcut: str, kwargs: dict | None = None, title: str | None = None
-    ) -> QWidget:
-        """Instantiate a registered BEC widget by its type string and add it as a tab.
-
-        If kwargs does not contain `object_name`, it will default to the provided shortcut.
-        """
-        # Ensure registry is loaded
-        widget_handler.update_available_widgets()
-        cls = widget_handler.widget_classes.get(widget_type)
-        if cls is None:
-            raise ValueError(f"Unknown registered widget type: {widget_type}")
-
-        if kwargs is None:
-            kwargs = {"object_name": shortcut}
-        else:
-            kwargs = dict(kwargs)
-            kwargs.setdefault("object_name", shortcut)
-
-        # Instantiate and add
-        widget = cls(**kwargs)
-        if not isinstance(widget, QWidget):
-            raise TypeError(
-                f"Instantiated object for type '{widget_type}' is not a QWidget: {type(widget)}"
-            )
-        return self.add_widget(widget, shortcut, title=title)
-
-    def _push_to_console(self, mapping: Dict[str, Any]):
-        """Push Python objects into the inprocess kernel user namespace."""
-        if self.console.inprocess is True:
-            self.console.kernel_manager.kernel.shell.push(mapping)
-        else:
-            raise RuntimeError("Can only push variables when using inprocess kernel")
-
-    def closeEvent(self, event):
-        """Override to handle things when main window is closed."""
-
-        # Ensure the embedded kernel and BEC client are shut down before window teardown
-        self.console.shutdown_kernel()
-        self.console.close()
-
-        super().closeEvent(event)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    import bec_widgets
-
-    module_path = os.path.dirname(bec_widgets.__file__)
-
-    app = QApplication(sys.argv)
-    apply_theme("dark")
-    app.setApplicationName("Jupyter Console")
-    app.setApplicationDisplayName("Jupyter Console")
-    icon = material_icon("terminal", color=(255, 255, 255, 255), filled=True)
-    app.setWindowIcon(icon)
-
-    win = JupyterConsoleWindow()
-
-    # Examples: add two widgets programmatically to demonstrate usage
-    try:
-        win.add_widget_by_type("Waveform", shortcut="wf")
-    except Exception as exc:
-        print(f"Example add failed (Waveform by type): {exc}")
-
-    try:
-        win.add_widget_by_type("Image", shortcut="im", kwargs={"popups": True})
-    except Exception as exc:
-        print(f"Example add failed (Image by type): {exc}")
-
-    win.show()
-    win.resize(1500, 800)
-
-    sys.exit(app.exec_())

bec_widgets/examples/mca_readout/mca_plot.py

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

bec_widgets/examples/mca_readout/mca_sim.py

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

bec_widgets/examples/modular_app/modular.ui

@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1433</width>
+    <height>689</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <layout class="QGridLayout" name="gridLayout">
+    <item row="1" column="2">
+     <widget class="QLabel" name="label_3">
+      <property name="text">
+       <string>Plot  Config 2</string>
+      </property>
+     </widget>
+    </item>
+    <item row="3" column="0" colspan="2">
+     <widget class="BECMonitor" name="plot_1"/>
+    </item>
+    <item row="1" column="3">
+     <widget class="QPushButton" name="pushButton_setting_2">
+      <property name="text">
+       <string>Setting Plot 2</string>
+      </property>
+     </widget>
+    </item>
+    <item row="3" column="2" colspan="2">
+     <widget class="BECMonitor" name="plot_2"/>
+    </item>
+    <item row="1" column="4">
+     <widget class="QLabel" name="label_2">
+      <property name="text">
+       <string>Plot Scan Types = True</string>
+      </property>
+     </widget>
+    </item>
+    <item row="1" column="1">
+     <widget class="QPushButton" name="pushButton_setting_1">
+      <property name="text">
+       <string>Setting Plot 1</string>
+      </property>
+     </widget>
+    </item>
+    <item row="1" column="0">
+     <widget class="QLabel" name="label">
+      <property name="text">
+       <string>Plot Config 1</string>
+      </property>
+     </widget>
+    </item>
+    <item row="1" column="5">
+     <widget class="QPushButton" name="pushButton_setting_3">
+      <property name="text">
+       <string>Setting Plot 3</string>
+      </property>
+     </widget>
+    </item>
+    <item row="3" column="4" colspan="2">
+     <widget class="BECMonitor" name="plot_3"/>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>1433</width>
+     <height>37</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>BECMonitor</class>
+   <extends>QGraphicsView</extends>
+   <header location="global">bec_widgets.widgets.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/examples/modular_app/modular_app.py

@@ -0,0 +1,200 @@
+import os
+
+from qtpy import uic
+from qtpy.QtWidgets import QMainWindow, QApplication
+
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.widgets import BECMonitor
+
+# some default configs for demonstration purposes
+CONFIG_SIMPLE = {
+    "plot_settings": {
+        "background_color": "black",
+        "num_columns": 2,
+        "colormap": "plasma",
+        "scan_types": False,
+    },
+    "plot_data": [
+        {
+            "plot_name": "BPM4i plots vs samx",
+            "x_label": "Motor X",
+            "y_label": "bpm4i",
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {
+                        "x": [{"name": "samx"}],
+                        "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                    },
+                },
+                # {
+                #     "type": "history",
+                #     "signals": {
+                #         "x": [{"name": "samx"}],
+                #         "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                #     },
+                # },
+                # {
+                #     "type": "dap",
+                #     'worker':'some_worker',
+                #     "signals": {
+                #         "x": [{"name": "samx"}],
+                #         "y": [{"name": "bpm4i", "entry": "bpm4i"}],
+                #     },
+                # },
+            ],
+        },
+        {
+            "plot_name": "Gauss plots vs samx",
+            "x_label": "Motor X",
+            "y_label": "Gauss",
+            "sources": [
+                {
+                    "type": "scan_segment",
+                    "signals": {
+                        "x": [{"name": "samx", "entry": "samx"}],
+                        "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
+                    },
+                }
+            ],
+        },
+    ],
+}
+
+
+CONFIG_SCAN_MODE = {
+    "plot_settings": {
+        "background_color": "white",
+        "num_columns": 3,
+        "colormap": "plasma",
+        "scan_types": True,
+    },
+    "plot_data": {
+        "grid_scan": [
+            {
+                "plot_name": "Grid plot 1",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_bpm"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 2",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_adc1"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 3",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samy"}],
+                            "y": [{"name": "gauss_adc2"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Grid plot 4",
+                "x_label": "Motor X",
+                "y_label": "BPM",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samy", "entry": "samy"}],
+                            "y": [{"name": "gauss_adc3"}],
+                        },
+                    }
+                ],
+            },
+        ],
+        "line_scan": [
+            {
+                "plot_name": "BPM plots vs samx",
+                "x_label": "Motor X",
+                "y_label": "Gauss",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "bpm4i"}],
+                        },
+                    }
+                ],
+            },
+            {
+                "plot_name": "Gauss plots vs samx",
+                "x_label": "Motor X",
+                "y_label": "Gauss",
+                "sources": [
+                    {
+                        "type": "scan_segment",
+                        "signals": {
+                            "x": [{"name": "samx", "entry": "samx"}],
+                            "y": [{"name": "gauss_bpm"}, {"name": "gauss_adc1"}],
+                        },
+                    }
+                ],
+            },
+        ],
+    },
+}
+
+
+class ModularApp(QMainWindow):
+    def __init__(self, client=None, parent=None):
+        super(ModularApp, self).__init__(parent)
+
+        # Client and device manager from BEC
+        self.client = BECDispatcher().client if client is None else client
+
+        # Loading UI
+        current_path = os.path.dirname(__file__)
+        uic.loadUi(os.path.join(current_path, "modular.ui"), self)
+
+        self._init_plots()
+
+    def _init_plots(self):
+        """Initialize plots and connect the buttons to the config dialogs"""
+        plots = [self.plot_1, self.plot_2, self.plot_3]
+        configs = [CONFIG_SIMPLE, CONFIG_SCAN_MODE, CONFIG_SCAN_MODE]
+        buttons = [self.pushButton_setting_1, self.pushButton_setting_2, self.pushButton_setting_3]
+
+        # hook plots, configs and buttons together
+        for plot, config, button in zip(plots, configs, buttons):
+            plot.on_config_update(config)
+            button.clicked.connect(plot.show_config_dialog)
+
+
+if __name__ == "__main__":
+    # BECclient global variables
+    client = BECDispatcher().client
+    client.start()
+
+    app = QApplication([])
+    modularApp = ModularApp(client=client)
+
+    window = modularApp
+    window.show()
+    app.exec()

bec_widgets/examples/motor_movement/__init__.py

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

bec_widgets/examples/motor_movement/config_example.yaml

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

bec_widgets/examples/motor_movement/csax_bec_config.yaml

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

bec_widgets/examples/motor_movement/csaxs_config.yaml

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

bec_widgets/examples/motor_movement/motor_control_compilations.py

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

bec_widgets/examples/motor_movement/motor_controller.ui

@@ -0,0 +1,926 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1561</width>
+    <height>748</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>1409</width>
+    <height>748</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Motor Controller</string>
+  </property>
+  <layout class="QHBoxLayout" name="horizontalLayout" stretch="8,5,8">
+   <item>
+    <widget class="GraphicsLayoutWidget" name="glw">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QFrame" name="Controls">
+     <property name="minimumSize">
+      <size>
+       <width>221</width>
+       <height>471</height>
+      </size>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_6" stretch="1,1,1,0,1">
+      <property name="spacing">
+       <number>1</number>
+      </property>
+      <property name="sizeConstraint">
+       <enum>QLayout::SetMinimumSize</enum>
+      </property>
+      <item>
+       <widget class="QGroupBox" name="motorSelection">
+        <property name="minimumSize">
+         <size>
+          <width>261</width>
+          <height>145</height>
+         </size>
+        </property>
+        <property name="title">
+         <string>Motor Selection</string>
+        </property>
+        <layout class="QGridLayout" name="gridLayout_4">
+         <item row="2" column="0">
+          <widget class="QLabel" name="label_8">
+           <property name="text">
+            <string>Motor Y</string>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="1">
+          <widget class="QComboBox" name="comboBox_motor_x"/>
+         </item>
+         <item row="2" column="1">
+          <widget class="QComboBox" name="comboBox_motor_y"/>
+         </item>
+         <item row="1" column="0">
+          <widget class="QLabel" name="label_5">
+           <property name="text">
+            <string>Motor X</string>
+           </property>
+          </widget>
+         </item>
+         <item row="3" column="0" colspan="2">
+          <widget class="QPushButton" name="pushButton_connecMotors">
+           <property name="text">
+            <string>Connect Motors</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
+      <item>
+       <spacer name="verticalSpacer_3">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::Minimum</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>18</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item>
+       <widget class="QGroupBox" name="motorControl">
+        <property name="minimumSize">
+         <size>
+          <width>261</width>
+          <height>339</height>
+         </size>
+        </property>
+        <property name="title">
+         <string>Motor Relative</string>
+        </property>
+        <layout class="QVBoxLayout" name="verticalLayout_5">
+         <item>
+          <widget class="QCheckBox" name="checkBox_enableArrows">
+           <property name="text">
+            <string>Move with arrow keys</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QCheckBox" name="checkBox_same_xy">
+           <property name="text">
+            <string>Step [X] = Step [Y]</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <layout class="QGridLayout" name="step_grid">
+           <item row="2" column="0">
+            <widget class="QLabel" name="label_step_y">
+             <property name="minimumSize">
+              <size>
+               <width>111</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Step [Y]</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_2">
+             <property name="minimumSize">
+              <size>
+               <width>111</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Decimal</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="1">
+            <widget class="QDoubleSpinBox" name="spinBox_step_x">
+             <property name="minimumSize">
+              <size>
+               <width>110</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>0.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>99.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+             <property name="value">
+              <double>1.000000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label_step_x">
+             <property name="minimumSize">
+              <size>
+               <width>111</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Step [X]</string>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="1">
+            <widget class="QDoubleSpinBox" name="spinBox_step_y">
+             <property name="minimumSize">
+              <size>
+               <width>110</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>0.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>99.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+             <property name="value">
+              <double>1.000000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1">
+            <widget class="QSpinBox" name="spinBox_precision">
+             <property name="minimumSize">
+              <size>
+               <width>110</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="maximum">
+              <number>8</number>
+             </property>
+             <property name="value">
+              <number>2</number>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QGridLayout" name="direction_grid">
+           <property name="sizeConstraint">
+            <enum>QLayout::SetDefaultConstraint</enum>
+           </property>
+           <item row="1" column="2" alignment="Qt::AlignHCenter|Qt::AlignVCenter">
+            <widget class="QToolButton" name="toolButton_up">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>...</string>
+             </property>
+             <property name="arrowType">
+              <enum>Qt::UpArrow</enum>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="4">
+            <spacer name="horizontalSpacer_2">
+             <property name="orientation">
+              <enum>Qt::Horizontal</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>40</width>
+               <height>20</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+           <item row="3" column="2" alignment="Qt::AlignHCenter|Qt::AlignVCenter">
+            <widget class="QToolButton" name="toolButton_down">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>...</string>
+             </property>
+             <property name="arrowType">
+              <enum>Qt::DownArrow</enum>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="1">
+            <widget class="QToolButton" name="toolButton_left">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>...</string>
+             </property>
+             <property name="arrowType">
+              <enum>Qt::LeftArrow</enum>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="2">
+            <spacer name="verticalSpacer">
+             <property name="orientation">
+              <enum>Qt::Vertical</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>20</width>
+               <height>40</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+           <item row="2" column="3">
+            <widget class="QToolButton" name="toolButton_right">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>...</string>
+             </property>
+             <property name="arrowType">
+              <enum>Qt::RightArrow</enum>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="0">
+            <spacer name="horizontalSpacer">
+             <property name="orientation">
+              <enum>Qt::Horizontal</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>40</width>
+               <height>20</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+           <item row="4" column="2">
+            <spacer name="verticalSpacer_2">
+             <property name="orientation">
+              <enum>Qt::Vertical</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>20</width>
+               <height>40</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+          </layout>
+         </item>
+        </layout>
+       </widget>
+      </item>
+      <item>
+       <spacer name="verticalSpacer_4">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::Minimum</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>18</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item>
+       <widget class="QGroupBox" name="motorControl_absolute">
+        <property name="minimumSize">
+         <size>
+          <width>261</width>
+          <height>195</height>
+         </size>
+        </property>
+        <property name="title">
+         <string>Move Absolute</string>
+        </property>
+        <layout class="QVBoxLayout" name="verticalLayout">
+         <item>
+          <widget class="QCheckBox" name="checkBox_save_with_go">
+           <property name="text">
+            <string>Save position with Go</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <layout class="QGridLayout" name="gridLayout_3">
+           <item row="1" column="1">
+            <widget class="QDoubleSpinBox" name="spinBox_absolute_y">
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>-500.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>500.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QDoubleSpinBox" name="spinBox_absolute_x">
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>-500.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>500.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1">
+            <widget class="QLabel" name="label_7">
+             <property name="text">
+              <string>Y</string>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_6">
+             <property name="text">
+              <string>X</string>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QHBoxLayout" name="horizontalLayout_2">
+           <item>
+            <widget class="QPushButton" name="pushButton_save">
+             <property name="text">
+              <string>Save</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QPushButton" name="pushButton_set">
+             <property name="text">
+              <string>Set</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QPushButton" name="pushButton_go_absolute">
+             <property name="text">
+              <string>Go</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <widget class="QPushButton" name="pushButton_stop">
+           <property name="text">
+            <string>Stop Movement</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QTabWidget" name="tabWidget_tables">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="currentIndex">
+      <number>0</number>
+     </property>
+     <widget class="QWidget" name="tab_coordinates">
+      <attribute name="title">
+       <string>Coordinates</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_3">
+       <item>
+        <layout class="QHBoxLayout" name="horizontalLayout_3">
+         <item>
+          <spacer name="horizontalSpacer_3">
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>40</width>
+             <height>20</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QLabel" name="label">
+           <property name="text">
+            <string>Entries Mode:</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QComboBox" name="comboBox_mode">
+           <item>
+            <property name="text">
+             <string>Individual</string>
+            </property>
+           </item>
+           <item>
+            <property name="text">
+             <string>Start/Stop</string>
+            </property>
+           </item>
+          </widget>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <widget class="QTableWidget" name="tableWidget_coordinates">
+         <property name="selectionMode">
+          <enum>QAbstractItemView::MultiSelection</enum>
+         </property>
+         <property name="selectionBehavior">
+          <enum>QAbstractItemView::SelectRows</enum>
+         </property>
+         <column>
+          <property name="text">
+           <string>Show</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>Move</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>Tag</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>X</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>Y</string>
+          </property>
+         </column>
+        </widget>
+       </item>
+       <item>
+        <layout class="QGridLayout" name="gridLayout">
+         <item row="1" column="1">
+          <widget class="QPushButton" name="pushButton_resize_table">
+           <property name="text">
+            <string>Resize Table</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="1">
+          <widget class="QCheckBox" name="checkBox_resize_auto">
+           <property name="text">
+            <string>Resize Auto</string>
+           </property>
+           <property name="checked">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="0">
+          <widget class="QPushButton" name="pushButton_importCSV">
+           <property name="text">
+            <string>Import CSV</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="0">
+          <widget class="QPushButton" name="pushButton_exportCSV">
+           <property name="text">
+            <string>Export CSV</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="0">
+          <widget class="QPushButton" name="pushButton_help">
+           <property name="text">
+            <string>Help</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="1">
+          <widget class="QPushButton" name="pushButton_duplicate">
+           <property name="text">
+            <string>Duplicate Last Entry</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab_settings">
+      <attribute name="title">
+       <string>Settings</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_4">
+       <item>
+        <widget class="QGroupBox" name="motorLimits">
+         <property name="enabled">
+          <bool>false</bool>
+         </property>
+         <property name="title">
+          <string>Motor Limits</string>
+         </property>
+         <layout class="QGridLayout" name="gridLayout_2">
+          <item row="2" column="1">
+           <widget class="QPushButton" name="pushButton_updateLimits">
+            <property name="text">
+             <string>Update</string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="1">
+           <widget class="QLabel" name="label_Y_max">
+            <property name="text">
+             <string>+ Y</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="4" column="1">
+           <widget class="QLabel" name="label_Y_min">
+            <property name="text">
+             <string>- Y</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0">
+           <widget class="QLabel" name="label_X_min">
+            <property name="text">
+             <string>- X</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="2">
+           <widget class="QLabel" name="label_X_max">
+            <property name="text">
+             <string>+ X</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1">
+           <widget class="QDoubleSpinBox" name="spinBox_y_max">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="1">
+           <widget class="QDoubleSpinBox" name="spinBox_y_min">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QDoubleSpinBox" name="spinBox_x_min">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="2">
+           <widget class="QDoubleSpinBox" name="spinBox_x_max">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="groupBox_2">
+         <property name="title">
+          <string>Plotting Options</string>
+         </property>
+         <layout class="QGridLayout" name="gridLayout_5">
+          <item row="0" column="1" colspan="2">
+           <widget class="QSpinBox" name="spinBox_max_points">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <number>100</number>
+            </property>
+            <property name="maximum">
+             <number>10000</number>
+            </property>
+            <property name="singleStep">
+             <number>100</number>
+            </property>
+            <property name="value">
+             <number>5000</number>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="0">
+           <widget class="QLabel" name="label_15">
+            <property name="text">
+             <string>Max Points</string>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="1" colspan="2">
+           <widget class="QSpinBox" name="spinBox_scatter_size">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <number>1</number>
+            </property>
+            <property name="maximum">
+             <number>15</number>
+            </property>
+            <property name="value">
+             <number>5</number>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QLabel" name="label_11">
+            <property name="text">
+             <string>Scatter Size</string>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="0" colspan="3">
+           <widget class="QPushButton" name="pushButton_update_config">
+            <property name="text">
+             <string>Update Settings</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1" colspan="2">
+           <widget class="QSpinBox" name="spinBox_num_dim_points">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <number>10</number>
+            </property>
+            <property name="maximum">
+             <number>1000</number>
+            </property>
+            <property name="singleStep">
+             <number>10</number>
+            </property>
+            <property name="value">
+             <number>100</number>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0">
+           <widget class="QLabel" name="label_16">
+            <property name="text">
+             <string>N dim</string>
+            </property>
+           </widget>
+          </item>
+          <item row="4" column="0" colspan="3">
+           <widget class="QPushButton" name="pushButton_enableGUI">
+            <property name="text">
+             <string>Enable Control GUI</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab_queue">
+      <attribute name="title">
+       <string>Queue</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_2">
+       <item>
+        <widget class="QLabel" name="label_3">
+         <property name="text">
+          <string>Work in progress</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QPushButton" name="pushButton_5">
+         <property name="enabled">
+          <bool>false</bool>
+         </property>
+         <property name="text">
+          <string>Reset Queue</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QTableWidget" name="tableWidget_2">
+         <property name="enabled">
+          <bool>false</bool>
+         </property>
+         <column>
+          <property name="text">
+           <string>queueID</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>scanID</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>is_scan</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>type</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>scan_number</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>IQ status</string>
+          </property>
+         </column>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>GraphicsLayoutWidget</class>
+   <extends>QGraphicsView</extends>
+   <header>pyqtgraph.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/examples/oneplot/config_gaussworker.yaml

@@ -0,0 +1,3 @@
+x_value: "samx"
+y_values: ["gauss_bpm", "gauss_adc1", "gauss_adc2"]
+dap_worker: "gaussian_fit_worker_3"

bec_widgets/examples/oneplot/config_noworker.yaml

@@ -0,0 +1,3 @@
+x_value: "samx"
+y_values: ["gauss_bpm", "gauss_adc1", "gauss_adc2"]
+dap_worker: None

bec_widgets/examples/oneplot/oneplot.py

@@ -0,0 +1,271 @@
+import os
+
+import numpy as np
+import qtpy.QtWidgets
+import pyqtgraph as pg
+from bec_lib import MessageEndpoints
+from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
+from qtpy.QtWidgets import QApplication, QTableWidgetItem, QWidget
+from pyqtgraph import mkBrush, mkColor, mkPen
+from pyqtgraph.Qt import QtCore, uic
+
+from bec_widgets.utils import Crosshair, ctrl_c
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+
+# TODO implement:
+#   - implement scanID database for visualizing previous scans
+#   - multiple signals for different monitors
+#   - change how dap is handled in bec_dispatcher to handle more workers
+
+
+class PlotApp(QWidget):
+    """
+    Main class for the PlotApp used to plot two signals from the BEC.
+
+    Attributes:
+        update_signal (pyqtSignal): Signal to trigger plot updates.
+        update_dap_signal (pyqtSignal): Signal to trigger DAP updates.
+
+    Args:
+        x_value (str): The x device/signal for plotting.
+        y_values (list of str): List of y device/signals for plotting.
+        dap_worker (str, optional): DAP process to specify. Set to None to disable.
+        parent (QWidget, optional): Parent widget.
+    """
+
+    update_signal = pyqtSignal()
+    update_dap_signal = pyqtSignal()
+
+    def __init__(self, x_value, y_values, dap_worker=None, parent=None):
+        super(PlotApp, self).__init__(parent)
+        current_path = os.path.dirname(__file__)
+        uic.loadUi(os.path.join(current_path, "oneplot.ui"), self)
+
+        self.x_value = x_value
+        self.y_values = y_values
+        self.dap_worker = dap_worker
+
+        self.scanID = None
+        self.data_x = []
+        self.data_y = []
+
+        self.dap_x = np.array([])
+        self.dap_y = np.array([])
+
+        self.fit = None
+
+        self.init_ui()
+        self.init_curves()
+        self.hook_crosshair()
+
+        self.proxy_update_plot = pg.SignalProxy(
+            self.update_signal, rateLimit=25, slot=self.update_plot
+        )
+        self.proxy_update_fit = pg.SignalProxy(
+            self.update_dap_signal, rateLimit=25, slot=self.update_fit_table
+        )
+
+    def init_ui(self) -> None:
+        """Initialize the UI components."""
+        self.plot = pg.PlotItem()
+        self.glw.addItem(self.plot)
+        self.plot.setLabel("bottom", self.x_value)
+        self.plot.setLabel("left", ", ".join(self.y_values))
+        self.plot.addLegend()
+
+    def init_curves(self) -> None:
+        """Initialize curve data and properties."""
+        self.plot.clear()
+
+        self.curves_data = []
+        self.curves_dap = []
+
+        colors_y_values = PlotApp.golden_angle_color(colormap="CET-R2", num=len(self.y_values))
+        # colors_y_daps = PlotApp.golden_angle_color(
+        #     colormap="CET-I2", num=len(self.dap_worker)
+        # )  # TODO adapt for multiple dap_workers
+
+        # Initialize curves for y_values
+        for ii, (signal, color) in enumerate(zip(self.y_values, colors_y_values)):
+            pen_curve = mkPen(color=color, width=2, style=QtCore.Qt.DashLine)
+            brush_curve = mkBrush(color=color)
+            curve_data = pg.PlotDataItem(
+                symbolSize=5,
+                symbolBrush=brush_curve,
+                pen=pen_curve,
+                skipFiniteCheck=True,
+                name=f"{signal}",
+            )
+            self.curves_data.append(curve_data)
+            self.plot.addItem(curve_data)
+
+        # Initialize curves for DAP if dap_worker is not None
+        if self.dap_worker is not None:
+            # for ii, (monitor, color) in enumerate(zip(self.dap_worker, colors_y_daps)):#TODO adapt for multiple dap_workers
+            pen_dap = mkPen(color="#3b5998", width=2, style=QtCore.Qt.DashLine)
+            curve_dap = pg.PlotDataItem(
+                pen=pen_dap, skipFiniteCheck=True, symbolSize=5, name=f"{self.dap_worker}"
+            )
+            self.curves_dap.append(curve_dap)
+            self.plot.addItem(curve_dap)
+
+        self.tableWidget_crosshair.setRowCount(len(self.y_values))
+        self.tableWidget_crosshair.setVerticalHeaderLabels(self.y_values)
+        self.hook_crosshair()
+
+    def hook_crosshair(self) -> None:
+        """Attach the crosshair to the plot."""
+        self.crosshair_1d = Crosshair(self.plot, precision=3)
+        self.crosshair_1d.coordinatesChanged1D.connect(
+            lambda x, y: self.update_table(self.tableWidget_crosshair, x, y, column=0)
+        )
+        self.crosshair_1d.coordinatesClicked1D.connect(
+            lambda x, y: self.update_table(self.tableWidget_crosshair, x, y, column=1)
+        )
+
+    def update_table(
+        self, table_widget: qtpy.QtWidgets.QTableWidget, x: float, y_values: list, column: int
+    ) -> None:
+        for i, y in enumerate(y_values):
+            table_widget.setItem(i, column, QTableWidgetItem(f"({x}, {y})"))
+            table_widget.resizeColumnsToContents()
+
+    def update_plot(self) -> None:
+        """Update the plot data."""
+        for ii, curve in enumerate(self.curves_data):
+            curve.setData(self.data_x, self.data_y[ii])
+
+        if self.dap_worker is not None:
+            # for ii, curve in enumerate(self.curves_dap): #TODO adapt for multiple dap_workers
+            #     curve.setData(self.dap_x, self.dap_y[ii])
+            self.curves_dap[0].setData(self.dap_x, self.dap_y)
+
+    def update_fit_table(self):
+        """Update the table for fit data."""
+
+        self.tableWidget_fit.setData(self.fit)
+
+    @pyqtSlot(dict, dict)
+    def on_dap_update(self, msg: dict, metadata: dict) -> None:
+        """
+        Update DAP  related data.
+
+        Args:
+            msg (dict): Message received with data.
+            metadata (dict): Metadata of the DAP.
+        """
+
+        # TODO adapt for multiple dap_workers
+        self.dap_x = msg[self.dap_worker]["x"]
+        self.dap_y = msg[self.dap_worker]["y"]
+
+        self.fit = metadata["fit_parameters"]
+
+        self.update_dap_signal.emit()
+
+    @pyqtSlot(dict, dict)
+    def on_scan_segment(self, msg: dict, metadata: dict):
+        """
+        Handle new scan segments.
+
+        Args:
+            msg (dict): Message received with scan data.
+            metadata (dict): Metadata of the scan.
+        """
+        current_scanID = msg["scanID"]
+
+        if current_scanID != self.scanID:
+            self.scanID = current_scanID
+            self.data_x = []
+            self.data_y = [[] for _ in self.y_values]
+            self.init_curves()
+
+        dev_x = self.x_value
+        data_x = msg["data"][dev_x][dev[dev_x]._hints[0]]["value"]
+        self.data_x.append(data_x)
+
+        for ii, dev_y in enumerate(self.y_values):
+            data_y = msg["data"][dev_y][dev[dev_y]._hints[0]]["value"]
+            self.data_y[ii].append(data_y)
+
+        self.update_signal.emit()
+
+    @staticmethod
+    def golden_ratio(num: int) -> list:
+        """Calculate the golden ratio for a given number of angles.
+
+        Args:
+            num (int): Number of angles
+        """
+        phi = 2 * np.pi * ((1 + np.sqrt(5)) / 2)
+        angles = []
+        for ii in range(num):
+            x = np.cos(ii * phi)
+            y = np.sin(ii * phi)
+            angle = np.arctan2(y, x)
+            angles.append(angle)
+        return angles
+
+    @staticmethod
+    def golden_angle_color(colormap: str, num: int) -> list:
+        """
+        Extract num colors for from the specified colormap following golden angle distribution.
+
+        Args:
+            colormap (str): Name of the colormap
+            num (int): Number of requested colors
+
+        Returns:
+            list: List of colors with length <num>
+
+        Raises:
+            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
+        """
+
+        cmap = pg.colormap.get(colormap)
+        cmap_colors = cmap.color
+        if num > len(cmap_colors):
+            raise ValueError(
+                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
+            )
+        angles = PlotApp.golden_ratio(len(cmap_colors))
+        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
+        colors = [
+            mkColor(tuple((cmap_colors[int(ii)] * 255).astype(int))) for ii in color_selection[:num]
+        ]
+        return colors
+
+
+if __name__ == "__main__":
+    import yaml
+
+    with open("config_noworker.yaml", "r") as file:
+        config = yaml.safe_load(file)
+
+    x_value = config["x_value"]
+    y_values = config["y_values"]
+    dap_worker = config["dap_worker"]
+
+    dap_worker = None if dap_worker == "None" else dap_worker
+
+    # BECclient global variables
+    bec_dispatcher = BECDispatcher()
+    client = bec_dispatcher.client
+    client.start()
+
+    dev = client.device_manager.devices
+    scans = client.scans
+    queue = client.queue
+
+    app = QApplication([])
+    plotApp = PlotApp(x_value=x_value, y_values=y_values, dap_worker=dap_worker)
+
+    # Connecting signals from bec_dispatcher
+    bec_dispatcher.connect_slot(plotApp.on_dap_update, MessageEndpoints.processed_data(dap_worker))
+    bec_dispatcher.connect_slot(plotApp.on_scan_segment, MessageEndpoints.scan_segment())
+    ctrl_c.setup(app)
+
+    window = plotApp
+    window.show()
+    app.exec()

bec_widgets/examples/oneplot/oneplot.ui

@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>547</width>
+    <height>653</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout" stretch="1,2">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout" stretch="2,1">
+     <item>
+      <widget class="QGroupBox" name="groupBox">
+       <property name="title">
+        <string>Cursor</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout">
+        <item row="0" column="0">
+         <widget class="QTableWidget" name="tableWidget_crosshair">
+          <column>
+           <property name="text">
+            <string>Moved</string>
+           </property>
+          </column>
+          <column>
+           <property name="text">
+            <string>Clicked</string>
+           </property>
+          </column>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="groupBox_2">
+       <property name="title">
+        <string>Fit</string>
+       </property>
+       <layout class="QGridLayout" name="gridLayout_2">
+        <item row="0" column="0">
+         <widget class="TableWidget" name="tableWidget_fit"/>
+        </item>
+       </layout>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="GraphicsLayoutWidget" name="glw"/>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>GraphicsLayoutWidget</class>
+   <extends>QGraphicsView</extends>
+   <header>pyqtgraph.h</header>
+  </customwidget>
+  <customwidget>
+   <class>TableWidget</class>
+   <extends>QTableWidget</extends>
+   <header>pyqtgraph.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/examples/plot_app/config_example.yaml

@@ -0,0 +1,130 @@
+plot_settings:
+  background_color: "black"
+  num_columns: 2
+  colormap: "plasma"
+  scan_types: False # True to show scan types
+
+# example to use without scan_type -> only one general configuration
+plot_data:
+  - plot_name: "BPM4i plots vs samy"
+    x:
+      label: 'Motor Y'
+      signals:
+        - name: "samy"
+#          entry: "samy" # here I also forgot to specify entry
+    y:
+      label: 'bpm4i'
+      signals:
+        - name: "bpm4i"
+          entry: "bpm4i"
+          # I will not specify entry, because I want to take hint from gauss_adc2
+  - plot_name: "BPM4i plots vs samx"
+    x:
+      label: 'Motor Y'
+      signals:
+        - name: "samy"
+#          entry: "samy" # here I also forgot to specify entry
+    y:
+      label: 'bpm4i'
+      signals:
+        - name: "bpm4i"
+          entry: "bpm4i"
+          # I will not specify entry, because I want to take hint from gauss_adc2
+  - plot_name: "MCS Channel 4 (Cyberstar) vs samx"
+    x:
+      label: 'Motor X'
+      signals:
+        - name: "samx"
+          entry: "samx"
+    y:
+      label: 'mcs4 cyberstar'
+      signals:
+        - name: "mcs"
+          entry: "mca4"
+  - plot_name: "MCS Channel 4 (Cyberstar) vs samy"
+    x:
+      label: 'Motor X'
+      signals:
+        - name: "samy"
+          entry: "samy"
+    y:
+      label: 'mcs4 cyberstar'
+      signals:
+        - name: "mcs"
+          entry: "mca4"
+
+
+
+# example to use with scan_type -> different configuration for different scan types
+#plot_data:
+#  line_scan:
+#    - plot_name: "BPM plot"
+#      x:
+#        label: 'Motor X'
+#        signals:
+#          - name: "samx"
+#  #          entry: "samx"
+#      y:
+#        label: 'BPM'
+#        signals:
+#          - name: "gauss_bpm"
+#            entry: "gauss_bpm"
+#          - name: "gauss_adc1"
+#            entry: "gauss_adc1"
+#          - name: "gauss_adc2"
+#            entry: "gauss_adc2"
+#
+#    - plot_name: "Multi"
+#      x:
+#        label: 'Motor X'
+#        signals:
+#          - name: "samx"
+#            entry: "samx"
+#      y:
+#        label: 'Multi'
+#        signals:
+#          - name: "gauss_bpm"
+#            entry: "gauss_bpm"
+#          - name: "samx"
+#            entry: ["samx", "samx_setpoint"]
+#
+#  grid_scan:
+#    - plot_name: "Grid plot 1"
+#      x:
+#        label: 'Motor X'
+#        signals:
+#          - name: "samx"
+#            entry: "samx"
+#      y:
+#        label: 'BPM'
+#        signals:
+#          - name: "gauss_bpm"
+#            entry: "gauss_bpm"
+#          - name: "gauss_adc1"
+#            entry: "gauss_adc1"
+#    - plot_name: "Grid plot 2"
+#      x:
+#        label: 'Motor X'
+#        signals:
+#          - name: "samx"
+#            entry: "samx"
+#      y:
+#        label: 'BPM'
+#        signals:
+#          - name: "gauss_bpm"
+#            entry: "gauss_bpm"
+#          - name: "gauss_adc1"
+#            entry: "gauss_adc1"
+#
+#    - plot_name: "Grid plot 3"
+#      x:
+#        label: 'Motor Y'
+#        signals:
+#          - name: "samy"
+#            entry: "samy"
+#      y:
+#        label: 'BPM'
+#        signals:
+#          - name: "gauss_bpm"
+#            entry: "gauss_bpm"
+

bec_widgets/examples/plot_app/config_scans_example.yaml

@@ -0,0 +1,91 @@
+plot_settings:
+  background_color: "black"
+  num_columns: 2
+  colormap: "plasma"
+  scan_types: True # True to show scan types
+
+# example to use with scan_type -> different configuration for different scan types
+plot_data:
+  line_scan:
+    - plot_name: "BPM plot"
+      x:
+        label: 'Motor X'
+        signals:
+          - name: "samx"
+  #          entry: "samx"
+      y:
+        label: 'BPM'
+        signals:
+          - name: "gauss_bpm"
+            entry: "gauss_bpm"
+          - name: "gauss_adc1"
+            entry: "gauss_adc1"
+          - name: "gauss_adc2"
+            entry: "gauss_adc2"
+
+    - plot_name: "Multi"
+      x:
+        label: 'Motor X'
+        signals:
+          - name: "samx"
+            entry: "samx"
+      y:
+        label: 'Multi'
+        signals:
+          - name: "gauss_bpm"
+            entry: "gauss_bpm"
+          - name: "samx"
+            entry: ["samx", "samx_setpoint"]
+
+  grid_scan:
+    - plot_name: "Grid plot 1"
+      x:
+        label: 'Motor X'
+        signals:
+          - name: "samx"
+            entry: "samx"
+      y:
+        label: 'BPM'
+        signals:
+          - name: "gauss_bpm"
+            entry: "gauss_bpm"
+          - name: "gauss_adc1"
+            entry: "gauss_adc1"
+    - plot_name: "Grid plot 2"
+      x:
+        label: 'Motor X'
+        signals:
+          - name: "samx"
+            entry: "samx"
+      y:
+        label: 'BPM'
+        signals:
+          - name: "gauss_bpm"
+            entry: "gauss_bpm"
+          - name: "gauss_adc1"
+            entry: "gauss_adc1"
+
+    - plot_name: "Grid plot 3"
+      x:
+        label: 'Motor Y'
+        signals:
+          - name: "samy"
+            entry: "samy"
+      y:
+        label: 'BPM'
+        signals:
+          - name: "gauss_bpm"
+            entry: "gauss_bpm"
+
+    - plot_name: "Grid plot 4"
+      x:
+        label: 'Motor Y'
+        signals:
+          - name: "samy"
+            entry: "samy"
+      y:
+        label: 'BPM'
+        signals:
+          - name: "gauss_adc3"
+            entry: "gauss_adc3"
+

bec_widgets/examples/plot_app/plot_app.py

@@ -0,0 +1,730 @@
+import logging
+import os
+
+# import traceback
+
+import pyqtgraph
+import pyqtgraph as pg
+
+from qtpy.QtCore import Signal as pyqtSignal, Slot as pyqtSlot
+
+from qtpy.QtWidgets import (
+    QApplication,
+    QWidget,
+    QTableWidgetItem,
+    QTableWidget,
+    QFileDialog,
+    QMessageBox,
+)
+from pyqtgraph import ColorButton
+from pyqtgraph import mkBrush, mkPen
+from pyqtgraph.Qt import QtCore, uic
+from pyqtgraph.Qt import QtWidgets
+
+from bec_lib import MessageEndpoints
+from bec_widgets.utils import Crosshair, Colors
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+
+
+# TODO implement:
+#   - implement scanID database for visualizing previous scans
+
+
+class PlotApp(QWidget):
+    """
+    Main class for PlotApp, designed to plot multiple signals in a grid layout
+    based on a flexible YAML configuration.
+
+    Attributes:
+        update_signal (pyqtSignal): Signal to trigger plot updates.
+        plot_data (list of dict): List of dictionaries containing plot configurations.
+                                  Each dictionary specifies x and y signals, including their
+                                  name and entry, for a particular plot.
+
+    Args:
+        config (dict): Configuration dictionary containing all settings for the plotting app.
+                      It should include the following keys:
+                      - 'plot_settings': Dictionary containing global plot settings.
+                      - 'plot_data': List of dictionaries specifying the signals to plot.
+        parent (QWidget, optional): Parent widget.
+
+    Example:
+        General Plot Configuration:
+        {
+            'plot_settings': {'background_color': 'black', 'num_columns': 2, 'colormap': 'plasma', 'scan_types': False},
+            'plot_data': [
+                {
+                    'plot_name': 'Plot A',
+                    'x': {'label': 'X-axis', 'signals': [{'name': 'device_x', 'entry': 'entry_x'}]},
+                    'y': {'label': 'Y-axis', 'signals': [{'name': 'device_y', 'entry': 'entry_y'}]}
+                }
+            ]
+        }
+
+        Different Scans Mode Configuration:
+        {
+            'plot_settings': {'background_color': 'black', 'num_columns': 2, 'colormap': 'plasma', 'scan_types': True},
+            'plot_data': {
+                'scan_type_1': [
+                    {
+                        'plot_name': 'Plot 1',
+                        'x': {'label': 'X-axis', 'signals': [{'name': 'device_x1', 'entry': 'entry_x1'}]},
+                        'y': {'label': 'Y-axis', 'signals': [{'name': 'device_y1', 'entry': 'entry_y1'}]}
+                    }
+                ],
+                'scan_type_2': [
+                    {
+                        'plot_name': 'Plot 2',
+                        'x': {'label': 'X-axis', 'signals': [{'name': 'device_x2', 'entry': 'entry_x2'}]},
+                        'y': {'label': 'Y-axis', 'signals': [{'name': 'device_y2', 'entry': 'entry_y2'}]}
+                    }
+                ]
+            }
+        }
+    """
+
+    update_signal = pyqtSignal()
+    update_dap_signal = pyqtSignal()
+
+    def __init__(self, config: dict, client=None, parent=None):
+        super(PlotApp, self).__init__(parent)
+
+        # Error handler
+        self.error_handler = ErrorHandler(parent=self)
+
+        # Client and device manager from BEC
+        self.client = BECDispatcher().client if client is None else client
+        self.dev = self.client.device_manager.devices
+
+        # Loading UI
+        current_path = os.path.dirname(__file__)
+        uic.loadUi(os.path.join(current_path, "plot_app.ui"), self)
+
+        self.data = {}
+
+        self.crosshairs = None
+        self.plots = None
+        self.curves_data = None
+        self.grid_coordinates = None
+        self.scanID = None
+
+        self.user_colors = {}  # key: (plot_name, y_name, y_entry), value: color
+
+        # Default config
+        self.config = config
+
+        # Validate the configuration before proceeding
+        self.load_config(self.config)
+
+        # Default splitter size
+        self.splitter.setSizes([400, 100])
+
+        # Buttons
+        self.pushButton_save.clicked.connect(self.save_settings_to_yaml)
+        self.pushButton_load.clicked.connect(self.load_settings_from_yaml)
+
+        # Connect the update signal to the update plot method
+        self.proxy_update_plot = pg.SignalProxy(
+            self.update_signal, rateLimit=25, slot=self.update_plot
+        )
+
+        # Change layout of plots when the number of columns is changed in GUI
+        self.spinBox_N_columns.valueChanged.connect(lambda x: self.init_ui(x))
+
+    def load_config(self, config: dict) -> None:
+        """
+        Load and validate the configuration, retrying until a valid configuration is provided or the user cancels.
+        Args:
+            config (dict): Configuration dictionary form .yaml file.
+
+        Returns:
+            None
+        """
+        valid_config = False
+        self.error_handler.set_retry_action(self.load_settings_from_yaml)
+        while not valid_config:
+            if config is None:
+                self.config = (
+                    self.load_settings_from_yaml()
+                )  # Load config if it hasn't been loaded yet
+            try:  # Validate loaded config file
+                self.error_handler.validate_config_file(config)
+                valid_config = True
+            except ValueError as e:
+                self.config = None  # Reset config_to_test to force reloading configuration
+                self.config = self.error_handler.handle_error(str(e))
+        if valid_config is True:  # Initialize config if validation succeeds
+            self.init_config(self.config)
+
+    def init_config(self, config: dict) -> None:
+        """
+        Initializes or update the configuration settings for the PlotApp.
+
+        Args:
+            config (dict): Dictionary containing plot settings and data configurations.
+        """
+
+        # YAML config
+        self.plot_settings = config.get("plot_settings", {})
+        self.plot_data_config = config.get("plot_data", {})
+        self.scan_types = self.plot_settings.get("scan_types", False)
+
+        if self.scan_types is False:  # Device tracking mode
+            self.plot_data = self.plot_data_config  # TODO logic has to be improved
+        else:  # setup first line scan as default, then changed with different scan type
+            self.plot_data = self.plot_data_config[list(self.plot_data_config.keys())[0]]
+
+        # Setting global plot settings
+        self.init_plot_background(self.plot_settings["background_color"])
+
+        # Initialize the UI
+        self.init_ui(self.plot_settings["num_columns"])
+        self.spinBox_N_columns.setValue(
+            self.plot_settings["num_columns"]
+        )  # TODO has to be checked if it will not setup more columns than plots
+        self.spinBox_N_columns.setMaximum(len(self.plot_data))
+
+    def init_plot_background(self, background_color: str) -> None:
+        """
+        Initialize plot settings based on the background color.
+
+        Args:
+            background_color (str): The background color ('white' or 'black').
+
+        This method sets the background and foreground colors for pyqtgraph.
+        If the background is dark ('black'), the foreground will be set to 'white',
+        and vice versa.
+        """
+        if background_color.lower() == "black":
+            pg.setConfigOption("background", "k")
+            pg.setConfigOption("foreground", "w")
+        elif background_color.lower() == "white":
+            pg.setConfigOption("background", "w")
+            pg.setConfigOption("foreground", "k")
+        else:
+            raise ValueError(
+                f"Invalid background color {background_color}. Allowed values are 'white' or 'black'."
+            )
+
+        # TODO simplify -> find way how to setup also foreground color
+        # if background_color.lower() not in ["black", "white"]:
+        #     raise ValueError(
+        #         f"Invalid background color {background_color}. Allowed values are 'white' or 'black'."
+        #     )
+        # self.glw.setBackground(background_color.lower())
+
+    def init_ui(self, num_columns: int = 3) -> None:
+        """
+        Initialize the UI components, create plots and store their grid positions.
+
+        Args:
+            num_columns (int): Number of columns to wrap the layout.
+
+        This method initializes a dictionary `self.plots` to store the plot objects
+        along with their corresponding x and y signal names. It dynamically arranges
+        the plots in a grid layout based on the given number of columns and dynamically
+        stretches the last plots to fit the remaining space.
+        """
+        self.glw.clear()
+        self.plots = {}
+        self.grid_coordinates = []
+
+        num_plots = len(self.plot_data)
+
+        # Check if num_columns exceeds the number of plots
+        if num_columns >= num_plots:
+            num_columns = num_plots
+            self.plot_settings["num_columns"] = num_columns  # Update the settings
+            print(
+                f"Warning: num_columns in the YAML file was greater than the number of plots. Resetting num_columns to number of plots:{num_columns}."
+            )
+        else:
+            self.plot_settings["num_columns"] = num_columns  # Update the settings
+
+        num_rows = num_plots // num_columns
+        last_row_cols = num_plots % num_columns
+        remaining_space = num_columns - last_row_cols
+
+        for i, plot_config in enumerate(self.plot_data):
+            row, col = i // num_columns, i % num_columns
+            colspan = 1
+
+            if row == num_rows and remaining_space > 0:
+                if last_row_cols == 1:
+                    colspan = num_columns
+                else:
+                    colspan = remaining_space // last_row_cols + 1
+                    remaining_space -= colspan - 1
+                    last_row_cols -= 1
+
+            plot_name = plot_config.get("plot_name", "")
+            x_label = plot_config["x"].get("label", "")
+            y_label = plot_config["y"].get("label", "")
+
+            plot = self.glw.addPlot(row=row, col=col, colspan=colspan, title=plot_name)
+            plot.setLabel("bottom", x_label)
+            plot.setLabel("left", y_label)
+            plot.addLegend()
+
+            self.plots[plot_name] = plot
+            self.grid_coordinates.append((row, col))
+
+        self.init_curves()
+
+    def init_curves(self) -> None:
+        """
+        Initialize curve data and properties, and update table row labels.
+
+        This method initializes a nested dictionary `self.curves_data` to store
+        the curve objects for each x and y signal pair. It also updates the row labels
+        in `self.tableWidget_crosshair` to include the grid position for each y-value.
+        """
+        self.curves_data = {}
+        row_labels = []
+
+        for idx, plot_config in enumerate(self.plot_data):
+            plot_name = plot_config.get("plot_name", "")
+            plot = self.plots[plot_name]
+            plot.clear()
+
+            y_configs = plot_config["y"]["signals"]
+            colors_ys = Colors.golden_angle_color(
+                colormap=self.plot_settings["colormap"], num=len(y_configs)
+            )
+
+            curve_list = []
+            for i, (y_config, color) in enumerate(zip(y_configs, colors_ys)):
+                # print(y_config)
+                y_name = y_config["name"]
+                y_entries = y_config.get("entry", [y_name])
+
+                if not isinstance(y_entries, list):
+                    y_entries = [y_entries]
+
+                for y_entry in y_entries:
+                    user_color = self.user_colors.get((plot_name, y_name, y_entry), None)
+                    color_to_use = user_color if user_color else color
+
+                    pen_curve = mkPen(color=color_to_use, width=2, style=QtCore.Qt.DashLine)
+                    brush_curve = mkBrush(color=color_to_use)
+
+                    curve_data = pg.PlotDataItem(
+                        symbolSize=5,
+                        symbolBrush=brush_curve,
+                        pen=pen_curve,
+                        skipFiniteCheck=True,
+                        name=f"{y_name} ({y_entry})",
+                    )
+
+                    curve_list.append((y_name, y_entry, curve_data))
+                    plot.addItem(curve_data)
+                    row_labels.append(f"{y_name} ({y_entry}) - {plot_name}")
+
+                    # Create a ColorButton and set its color
+                    color_btn = ColorButton()
+                    color_btn.setColor(color_to_use)
+                    color_btn.sigColorChanged.connect(
+                        lambda btn=color_btn, plot=plot_name, yname=y_name, yentry=y_entry, curve=curve_data: self.change_curve_color(
+                            btn, plot, yname, yentry, curve
+                        )
+                    )
+
+                    # Add the ColorButton as a QWidget to the table
+                    color_widget = QtWidgets.QWidget()
+                    layout = QtWidgets.QHBoxLayout()
+                    layout.addWidget(color_btn)
+                    layout.setContentsMargins(0, 0, 0, 0)
+                    color_widget.setLayout(layout)
+
+                    row = len(row_labels) - 1  # The row index in the table
+                    self.tableWidget_crosshair.setCellWidget(row, 2, color_widget)
+
+            self.curves_data[plot_name] = curve_list
+
+        self.tableWidget_crosshair.setRowCount(len(row_labels))
+        self.tableWidget_crosshair.setVerticalHeaderLabels(row_labels)
+        self.hook_crosshair()
+
+    def change_curve_color(
+        self,
+        btn: pyqtgraph.ColorButton,
+        plot_name: str,
+        y_name: str,
+        y_entry: str,
+        curve: pyqtgraph.PlotDataItem,
+    ) -> None:
+        """
+        Change the color of a curve and update the corresponding ColorButton.
+
+        Args:
+            btn (ColorButton): The ColorButton that was clicked.
+            plot_name (str): The name of the plot where the curve belongs.
+            y_name (str): The name of the y signal.
+            y_entry (str): The entry of the y signal.
+            curve (PlotDataItem): The curve to be changed.
+        """
+        color = btn.color()
+        pen_curve = mkPen(color=color, width=2, style=QtCore.Qt.DashLine)
+        brush_curve = mkBrush(color=color)
+        curve.setPen(pen_curve)
+        curve.setSymbolBrush(brush_curve)
+        self.user_colors[(plot_name, y_name, y_entry)] = color
+
+    def hook_crosshair(self) -> None:
+        """Attach crosshairs to each plot and connect them to the update_table method."""
+        self.crosshairs = {}
+        for plot_name, plot in self.plots.items():
+            crosshair = Crosshair(plot, precision=3)
+            crosshair.coordinatesChanged1D.connect(
+                lambda x, y, plot=plot: self.update_table(
+                    self.tableWidget_crosshair, x, y, column=0, plot=plot
+                )
+            )
+            crosshair.coordinatesClicked1D.connect(
+                lambda x, y, plot=plot: self.update_table(
+                    self.tableWidget_crosshair, x, y, column=1, plot=plot
+                )
+            )
+            self.crosshairs[plot_name] = crosshair
+
+    def update_table(
+        self, table_widget: QTableWidget, x: float, y_values: list, column: int, plot: pg.PlotItem
+    ) -> None:
+        """
+        Update the table with coordinates based on cursor movements and clicks.
+
+        Args:
+            table_widget (QTableWidget): The table to be updated.
+            x (float): The x-coordinate from the plot.
+            y_values (list): The y-coordinates from the plot.
+            column (int): The column in the table to be updated.
+            plot (PlotItem): The plot from which the coordinates are taken.
+
+        This method calculates the correct row in the table for each y-value
+        and updates the cell at (row, column) with the new x and y coordinates.
+        """
+        plot_name = [name for name, value in self.plots.items() if value == plot][0]
+
+        starting_row = 0
+        for plot_config in self.plot_data:
+            if plot_config.get("plot_name", "") == plot_name:
+                break
+            for y_config in plot_config.get("y", {}).get("signals", []):
+                y_entries = y_config.get("entry", [y_config.get("name", "")])
+                if not isinstance(y_entries, list):
+                    y_entries = [y_entries]
+                starting_row += len(y_entries)
+
+        for i, y in enumerate(y_values):
+            row = starting_row + i
+            table_widget.setItem(row, column, QTableWidgetItem(f"({x}, {y})"))
+            table_widget.resizeColumnsToContents()
+
+    def update_plot(self) -> None:
+        """Update the plot data based on the stored data dictionary."""
+        for plot_name, curve_list in self.curves_data.items():
+            for y_name, y_entry, curve in curve_list:
+                x_config = next(
+                    (pc["x"] for pc in self.plot_data if pc.get("plot_name") == plot_name), {}
+                )
+                x_signal_config = x_config["signals"][0]
+                x_name = x_signal_config.get("name", "")
+                x_entry = x_signal_config.get("entry", x_name)
+
+                key = (x_name, x_entry, y_name, y_entry)
+                data_x = self.data.get(key, {}).get("x", [])
+                data_y = self.data.get(key, {}).get("y", [])
+
+                curve.setData(data_x, data_y)
+
+    @pyqtSlot(dict, dict)
+    def on_scan_segment(
+        self, msg, metadata
+    ) -> None:  # TODO the logic should be separated from GUI operation
+        """
+        Handle new scan segments and saves data to a dictionary. Linked through bec_dispatcher.
+
+        Args:
+            msg (dict): Message received with scan data.
+            metadata (dict): Metadata of the scan.
+        """
+
+        current_scanID = msg.get("scanID", None)
+        if current_scanID is None:
+            return
+
+        if current_scanID != self.scanID:
+            if self.scan_types is False:
+                self.plot_data = self.plot_data_config
+            elif self.scan_types is True:
+                currentName = metadata.get("scan_name")
+                if currentName is None:
+                    raise ValueError(
+                        f"Scan name not found in metadata. Please check the scan_name in the YAML config or in bec "
+                        f"configuration."
+                    )
+                self.plot_data = self.plot_data_config.get(currentName, [])
+                if self.plot_data == []:
+                    raise ValueError(
+                        f"Scan name {currentName} not found in the YAML config. Please check the scan_name in the "
+                        f"YAML config or in bec configuration."
+                    )
+
+                # Init UI
+                self.init_ui(self.plot_settings["num_columns"])
+                self.spinBox_N_columns.setValue(
+                    self.plot_settings["num_columns"]
+                )  # TODO has to be checked if it will not setup more columns than plots
+                self.spinBox_N_columns.setMaximum(len(self.plot_data))
+
+            self.scanID = current_scanID
+            self.data = {}
+            self.init_curves()
+
+        for plot_config in self.plot_data:
+            plot_name = plot_config.get("plot_name", "Unnamed Plot")
+            x_config = plot_config["x"]
+            x_signal_config = x_config["signals"][0]  # Assuming there's at least one signal for x
+
+            x_name = x_signal_config.get("name", "")
+            if not x_name:
+                raise ValueError(f"Name for x signal must be specified in plot: {plot_name}.")
+
+            x_entry_list = x_signal_config.get("entry", [])
+            if not x_entry_list:
+                x_entry_list = (
+                    self.dev[x_name]._hints if hasattr(self.dev[x_name], "_hints") else [x_name]
+                )
+
+            if not isinstance(x_entry_list, list):
+                x_entry_list = [x_entry_list]
+
+            y_configs = plot_config["y"]["signals"]
+
+            for x_entry in x_entry_list:
+                for y_config in y_configs:
+                    y_name = y_config.get("name", "")
+                    if not y_name:
+                        raise ValueError(
+                            f"Name for y signal must be specified in plot: {plot_name}."
+                        )
+
+                    y_entry_list = y_config.get("entry", [])
+                    if not y_entry_list:
+                        y_entry_list = (
+                            self.dev[y_name]._hints
+                            if hasattr(self.dev[y_name], "_hints")
+                            else [y_name]
+                        )
+
+                    if not isinstance(y_entry_list, list):
+                        y_entry_list = [y_entry_list]
+
+                    for y_entry in y_entry_list:
+                        key = (x_name, x_entry, y_name, y_entry)
+
+                        data_x = msg["data"].get(x_name, {}).get(x_entry, {}).get("value", None)
+                        data_y = msg["data"].get(y_name, {}).get(y_entry, {}).get("value", None)
+
+                        if data_x is None:
+                            raise ValueError(
+                                f"Incorrect entry '{x_entry}' specified for x in plot: {plot_name}, x name: {x_name}"
+                            )
+
+                        if data_y is None:
+                            if hasattr(self.dev[y_name], "_hints"):
+                                raise ValueError(
+                                    f"Incorrect entry '{y_entry}' specified for y in plot: {plot_name}, y name: {y_name}"
+                                )
+                            else:
+                                raise ValueError(
+                                    f"No hints available for y in plot: {plot_name}, and name '{y_name}' did not work as entry"
+                                )
+
+                        if data_x is not None:
+                            self.data.setdefault(key, {}).setdefault("x", []).append(data_x)
+
+                        if data_y is not None:
+                            self.data.setdefault(key, {}).setdefault("y", []).append(data_y)
+
+        self.update_signal.emit()
+
+    def save_settings_to_yaml(self):
+        """Save the current settings to a .yaml file using a file dialog."""
+        options = QFileDialog.Options()
+        options |= QFileDialog.DontUseNativeDialog
+        file_path, _ = QFileDialog.getSaveFileName(
+            self, "Save Settings", "", "YAML Files (*.yaml);;All Files (*)", options=options
+        )
+
+        if file_path:
+            try:
+                if not file_path.endswith(".yaml"):
+                    file_path += ".yaml"
+
+                with open(file_path, "w") as file:
+                    yaml.dump(
+                        {"plot_settings": self.plot_settings, "plot_data": self.plot_data_config},
+                        file,
+                    )
+                print(f"Settings saved to {file_path}")
+            except Exception as e:
+                print(f"An error occurred while saving the settings to {file_path}: {e}")
+
+    def load_settings_from_yaml(self) -> dict:  # TODO can be replace by the utils function
+        """Load settings from a .yaml file using a file dialog and update the current settings."""
+        options = QFileDialog.Options()
+        options |= QFileDialog.DontUseNativeDialog
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Load Settings", "", "YAML Files (*.yaml);;All Files (*)", options=options
+        )
+
+        if file_path:
+            try:
+                with open(file_path, "r") as file:
+                    self.config = yaml.safe_load(file)
+                    self.load_config(self.config)  # validate new config
+                return config
+            except FileNotFoundError:
+                print(f"The file {file_path} was not found.")
+            except Exception as e:
+                print(f"An error occurred while loading the settings from {file_path}: {e}")
+                return None  # Return None on exception to indicate failure
+
+
+class ErrorHandler:
+    def __init__(self, parent=None):
+        self.parent = parent
+        self.errors = []
+        self.retry_action = None
+        logging.basicConfig(level=logging.ERROR)  # Configure logging
+
+    def set_retry_action(self, action):
+        self.retry_action = action  # Store a reference to the retry action
+
+    def handle_error(self, error_message: str):
+        # logging.error(f"{error_message}\n{traceback.format_exc()}") #TODO decide if useful
+
+        choice = QMessageBox.critical(
+            self.parent,
+            "Error",
+            f"{error_message}\n\nWould you like to retry?",
+            QMessageBox.Retry | QMessageBox.Cancel,
+        )
+        if choice == QMessageBox.Retry and self.retry_action is not None:
+            return self.retry_action()
+        else:
+            exit(1)  # Exit the program if the user selects Cancel or if no retry_action is provided
+
+    def validate_config_file(self, config: dict) -> None:
+        """
+        Validate the configuration dictionary.
+        Args:
+            config (dict): Configuration dictionary form .yaml file.
+
+        Returns:
+            None
+        """
+        self.errors = []
+
+        # Validate common keys
+        required_top_level_keys = ["plot_settings", "plot_data"]
+        for key in required_top_level_keys:
+            if key not in config:
+                self.errors.append(f"Missing required key: {key}")
+
+        # Only continue if no errors so far
+        if not self.errors:
+            # Determine the configuration mode (device or scan)
+            plot_settings = config.get("plot_settings", {})
+            scan_types = plot_settings.get("scan_types", False)
+
+            plot_data = config.get("plot_data", [])
+
+            if scan_types:
+                # Validate scan mode configuration
+                for scan_type, plots in plot_data.items():
+                    for i, plot_config in enumerate(plots):
+                        self.validate_plot_config(plot_config, i)
+            else:
+                # Validate device mode configuration
+                for i, plot_config in enumerate(plot_data):
+                    self.validate_plot_config(plot_config, i)
+
+        if self.errors != []:
+            self.handle_error("\n".join(self.errors))
+
+    def validate_plot_config(self, plot_config: dict, i: int):
+        """
+        Validate individual plot configuration.
+        Args:
+            plot_config (dict): Individual plot configuration.
+            i (int): Index of the plot configuration.
+
+        Returns:
+            None
+        """
+        for axis in ["x", "y"]:
+            axis_config = plot_config.get(axis)
+            plot_name = plot_config.get("plot_name", "")
+            if axis_config is None:
+                error_msg = f"Missing '{axis}' configuration in plot {i} - {plot_name}"
+                logging.error(error_msg)  # Log the error
+                self.errors.append(error_msg)
+
+            signals_config = axis_config.get("signals")
+            if signals_config is None:
+                error_msg = (
+                    f"Missing 'signals' configuration for {axis} axis in plot {i} - '{plot_name}'"
+                )
+                logging.error(error_msg)  # Log the error
+                self.errors.append(error_msg)
+            elif not isinstance(signals_config, list) or len(signals_config) == 0:
+                error_msg = (
+                    f"'signals' configuration for {axis} axis in plot {i} must be a non-empty list"
+                )
+                logging.error(error_msg)  # Log the error
+                self.errors.append(error_msg)
+            # TODO add condition for name and entry
+
+
+if __name__ == "__main__":
+    import yaml
+    import argparse
+
+    # from bec_widgets import ctrl_c
+    parser = argparse.ArgumentParser(description="Plotting App")
+    parser.add_argument(
+        "--config",
+        "-c",
+        help="Path to the .yaml configuration file",
+        default="config_example.yaml",
+    )
+    args = parser.parse_args()
+
+    try:
+        with open(args.config, "r") as file:
+            config = yaml.safe_load(file)
+
+    except FileNotFoundError:
+        print(f"The file {args.config} was not found.")
+        exit(1)
+    except Exception as e:
+        print(f"An error occurred while loading the config file: {e}")
+        exit(1)
+
+    # BECclient global variables
+    bec_dispatcher = BECDispatcher()
+    client = bec_dispatcher.client
+    client.start()
+
+    app = QApplication([])
+    plotApp = PlotApp(config=config, client=client)
+
+    # Connecting signals from bec_dispatcher
+    bec_dispatcher.connect_slot(plotApp.on_scan_segment, MessageEndpoints.scan_segment())
+    # ctrl_c.setup(app)
+
+    window = plotApp
+    window.show()
+    app.exec()

bec_widgets/examples/plot_app/plot_app.ui

@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MultiWindow</class>
+ <widget class="QWidget" name="MultiWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1248</width>
+    <height>564</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MultiWindow</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QSplitter" name="splitter">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <widget class="GraphicsLayoutWidget" name="glw"/>
+     <widget class="QWidget" name="">
+      <layout class="QGridLayout" name="gridLayout_2">
+       <item row="1" column="0">
+        <spacer name="horizontalSpacer">
+         <property name="orientation">
+          <enum>Qt::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="2" column="0" colspan="3">
+        <widget class="QGroupBox" name="groupBox">
+         <property name="title">
+          <string>Cursor</string>
+         </property>
+         <layout class="QGridLayout" name="gridLayout">
+          <item row="0" column="0">
+           <widget class="QTableWidget" name="tableWidget_crosshair">
+            <column>
+             <property name="text">
+              <string>Moved</string>
+             </property>
+            </column>
+            <column>
+             <property name="text">
+              <string>Clicked</string>
+             </property>
+            </column>
+            <column>
+             <property name="text">
+              <string>Color</string>
+             </property>
+            </column>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item row="1" column="1">
+        <widget class="QLabel" name="label">
+         <property name="text">
+          <string>Number of Columns:</string>
+         </property>
+        </widget>
+       </item>
+       <item row="1" column="2">
+        <widget class="QSpinBox" name="spinBox_N_columns">
+         <property name="minimum">
+          <number>1</number>
+         </property>
+         <property name="maximum">
+          <number>10</number>
+         </property>
+         <property name="value">
+          <number>3</number>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="1">
+        <widget class="QPushButton" name="pushButton_load">
+         <property name="text">
+          <string>Load Config</string>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="2">
+        <widget class="QPushButton" name="pushButton_save">
+         <property name="text">
+          <string>Save Config</string>
+         </property>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>GraphicsLayoutWidget</class>
+   <extends>QGraphicsView</extends>
+   <header>pyqtgraph.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/examples/plugin_example_pyside/main.py

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

bec_widgets/examples/plugin_example_pyside/registertictactoe.py

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

bec_widgets/examples/plugin_example_pyside/taskmenuextension.pyproject

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

bec_widgets/examples/plugin_example_pyside/tictactoe.py

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

bec_widgets/examples/plugin_example_pyside/tictactoeplugin.py

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

bec_widgets/examples/plugin_example_pyside/tictactoetaskmenu.py

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

bec_widgets/examples/stream_plot/line_plot.ui

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

bec_widgets/examples/stream_plot/stream_plot.py

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

bec_widgets/qtdesigner_plugins/scan2d_plot_plugin.py

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

bec_widgets/qtdesigner_plugins/scan_plot_plugin.py

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