WIP drag and drop form widget

.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,64 +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
-
-    - 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/scripts/pr_issue_sync/pr_issue_sync.py

@@ -1,342 +0,0 @@
-import functools
-import os
-from typing import Literal
-
-import requests
-from github import Github
-from pydantic import BaseModel
-
-
-class GHConfig(BaseModel):
-    token: str
-    organization: str
-    repository: str
-    project_number: int
-    graphql_url: str
-    rest_url: str
-    headers: dict
-
-
-class ProjectItemHandler:
-    """
-    A class to handle GitHub project items.
-    """
-
-    def __init__(self, gh_config: GHConfig):
-        self.gh_config = gh_config
-        self.gh = Github(gh_config.token)
-        self.repo = self.gh.get_repo(f"{gh_config.organization}/{gh_config.repository}")
-        self.project_node_id = self.get_project_node_id()
-
-    def set_issue_status(
-        self,
-        status: Literal[
-            "Selected for Development",
-            "Weekly Backlog",
-            "In Development",
-            "Ready For Review",
-            "On Hold",
-            "Done",
-        ],
-        issue_number: int | None = None,
-        issue_node_id: str | None = None,
-    ):
-        """
-        Set the status field of a GitHub issue in the project.
-
-        Args:
-            status (str): The status to set. Must be one of the predefined statuses.
-            issue_number (int, optional): The issue number. If not provided, issue_node_id must be provided.
-            issue_node_id (str, optional): The issue node ID. If not provided, issue_number must be provided.
-        """
-        if not issue_number and not issue_node_id:
-            raise ValueError("Either issue_number or issue_node_id must be provided.")
-        if issue_number and issue_node_id:
-            raise ValueError("Only one of issue_number or issue_node_id must be provided.")
-        if issue_number is not None:
-            issue = self.repo.get_issue(issue_number)
-            issue_id = self.get_issue_info(issue.node_id)[0]["id"]
-        else:
-            issue_id = issue_node_id
-        field_id, option_id = self.get_status_field_id(field_name=status)
-        self.set_field_option(issue_id, field_id, option_id)
-
-    def run_graphql(self, query: str, variables: dict) -> dict:
-        """
-        Execute a GraphQL query against the GitHub API.
-
-        Args:
-            query (str): The GraphQL query to execute.
-            variables (dict): The variables to pass to the query.
-
-        Returns:
-            dict: The response from the GitHub API.
-        """
-        response = requests.post(
-            self.gh_config.graphql_url,
-            json={"query": query, "variables": variables},
-            headers=self.gh_config.headers,
-            timeout=10,
-        )
-        if response.status_code != 200:
-            raise Exception(
-                f"Query failed with status code {response.status_code}: {response.text}"
-            )
-        return response.json()
-
-    def get_project_node_id(self):
-        """
-        Retrieve the project node ID from the GitHub API.
-        """
-        query = """
-      query($owner: String!, $number: Int!) {
-        organization(login: $owner) {
-          projectV2(number: $number) {
-            id
-          }
-        }
-      }
-      """
-        variables = {"owner": self.gh_config.organization, "number": self.gh_config.project_number}
-        resp = self.run_graphql(query, variables)
-        return resp["data"]["organization"]["projectV2"]["id"]
-
-    def get_issue_info(self, issue_node_id: str):
-        """
-        Get the project-related information for a given issue node ID.
-
-        Args:
-            issue_node_id (str): The node ID of the issue. Please note that this is not the issue number and typically starts with "I".
-
-        Returns:
-            list[dict]: A list of project items associated with the issue.
-        """
-        query = """
-        query($issueId: ID!) {
-          node(id: $issueId) {
-            ... on Issue {
-              projectItems(first: 10) {
-                nodes {
-                  project {
-                    id
-                    title
-                  }
-                  id
-                  fieldValues(first: 20) {
-                    nodes {
-                      ... on ProjectV2ItemFieldSingleSelectValue {
-                        name
-                        field {
-                          ... on ProjectV2SingleSelectField {
-                            name
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        """
-        variables = {"issueId": issue_node_id}
-        resp = self.run_graphql(query, variables)
-        return resp["data"]["node"]["projectItems"]["nodes"]
-
-    def get_status_field_id(
-        self,
-        field_name: Literal[
-            "Selected for Development",
-            "Weekly Backlog",
-            "In Development",
-            "Ready For Review",
-            "On Hold",
-            "Done",
-        ],
-    ) -> tuple[str, str]:
-        """
-        Get the status field ID and option ID for the given field name in the project.
-
-        Args:
-            field_name (str): The name of the field to retrieve.
-                Must be one of the predefined statuses.
-
-        Returns:
-            tuple[str, str]: A tuple containing the field ID and option ID.
-        """
-        field_id = None
-        option_id = None
-        project_fields = self.get_project_fields()
-        for field in project_fields:
-            if field["name"] != "Status":
-                continue
-            field_id = field["id"]
-            for option in field["options"]:
-                if option["name"] == field_name:
-                    option_id = option["id"]
-                    break
-        if not field_id or not option_id:
-            raise ValueError(f"Field '{field_name}' not found in project fields.")
-
-        return field_id, option_id
-
-    def set_field_option(self, item_id, field_id, option_id):
-        """
-        Set the option of a project item for a single-select field.
-
-        Args:
-            item_id (str): The ID of the project item to update.
-            field_id (str): The ID of the field to update.
-            option_id (str): The ID of the option to set.
-        """
-
-        mutation = """
-        mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
-          updateProjectV2ItemFieldValue(
-            input: {
-              projectId: $projectId
-              itemId: $itemId
-              fieldId: $fieldId
-              value: { singleSelectOptionId: $optionId }
-            }
-          ) {
-            projectV2Item {
-              id
-            }
-          }
-        }
-        """
-        variables = {
-            "projectId": self.project_node_id,
-            "itemId": item_id,
-            "fieldId": field_id,
-            "optionId": option_id,
-        }
-        return self.run_graphql(mutation, variables)
-
-    @functools.lru_cache(maxsize=1)
-    def get_project_fields(self) -> list[dict]:
-        """
-        Get the available fields in the project.
-        This method caches the result to avoid multiple API calls.
-
-        Returns:
-            list[dict]: A list of fields in the project.
-        """
-
-        query = """
-    query($projectId: ID!) {
-      node(id: $projectId) {
-        ... on ProjectV2 {
-          fields(first: 50) {
-            nodes {
-              ... on ProjectV2SingleSelectField {
-                id
-                name
-                options {
-                  id
-                  name
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    """
-        variables = {"projectId": self.project_node_id}
-        resp = self.run_graphql(query, variables)
-        return list(filter(bool, resp["data"]["node"]["fields"]["nodes"]))
-
-    def get_pull_request_linked_issues(self, pr_number: int) -> list[dict]:
-        """
-        Get the linked issues of a pull request.
-
-        Args:
-            pr_number (int): The pull request number.
-
-        Returns:
-            list[dict]: A list of linked issues.
-        """
-        query = """
-    query($number: Int!, $owner: String!, $repo: String!) {
-      repository(owner: $owner, name: $repo) {
-        pullRequest(number: $number) {
-          id
-          closingIssuesReferences(first: 50) {
-            edges {
-              node {
-                id
-                body
-                number
-                title
-              }
-            }
-          }
-        }
-      }
-    }
-    """
-        variables = {
-            "number": pr_number,
-            "owner": self.gh_config.organization,
-            "repo": self.gh_config.repository,
-        }
-        resp = self.run_graphql(query, variables)
-        edges = resp["data"]["repository"]["pullRequest"]["closingIssuesReferences"]["edges"]
-        return [edge["node"] for edge in edges if edge.get("node")]
-
-
-def main():
-    # GitHub settings
-    token = os.getenv("TOKEN")
-    org = os.getenv("ORG")
-    repo = os.getenv("REPO")
-    project_number = os.getenv("PROJECT_NUMBER")
-    pr_number = os.getenv("PR_NUMBER")
-
-    if not token:
-        raise ValueError("GitHub token is not set. Please set the TOKEN environment variable.")
-    if not org:
-        raise ValueError("GitHub organization is not set. Please set the ORG environment variable.")
-    if not repo:
-        raise ValueError("GitHub repository is not set. Please set the REPO environment variable.")
-    if not project_number:
-        raise ValueError(
-            "GitHub project number is not set. Please set the PROJECT_NUMBER environment variable."
-        )
-    if not pr_number:
-        raise ValueError(
-            "Pull request number is not set. Please set the PR_NUMBER environment variable."
-        )
-
-    project_number = int(project_number)
-    pr_number = int(pr_number)
-
-    gh_config = GHConfig(
-        token=token,
-        organization=org,
-        repository=repo,
-        project_number=project_number,
-        graphql_url="https://api.github.com/graphql",
-        rest_url=f"https://api.github.com/repos/{org}/{repo}/issues",
-        headers={"Authorization": f"Bearer {token}", "Accept": "application/vnd.github+json"},
-    )
-    project_item_handler = ProjectItemHandler(gh_config=gh_config)
-
-    # Get PR info
-    pr = project_item_handler.repo.get_pull(pr_number)
-
-    # Get the linked issues of the pull request
-    linked_issues = project_item_handler.get_pull_request_linked_issues(pr_number=pr_number)
-    print(f"Linked issues: {linked_issues}")
-
-    target_status = "In Development" if pr.draft else "Ready For Review"
-    print(f"Target status: {target_status}")
-    for issue in linked_issues:
-        project_item_handler.set_issue_status(issue_number=issue["number"], status=target_status)
-
-
-if __name__ == "__main__":
-    main()

.github/scripts/pr_issue_sync/requirements.txt

@@ -1,2 +0,0 @@
-pydantic
-pygithub

.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/ci.yml

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

.github/workflows/end2end-conda.yml

@@ -1,48 +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
-      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
-
-      - 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
-          cd ./bec
-          conda create -q -n test-environment python=3.11
-          source ./bin/install_bec_dev.sh -t
-          cd ../
-          pip install -e ./ophyd_devices
-          pip install -e .[dev,pyside6]
-          pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end

.github/workflows/formatter.yml

@@ -1,61 +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 black isort
-          pip install -e .[dev]
-          black --check --diff --color .
-          isort --check --diff ./
-  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.10", "3.11", "3.12"]
-
-    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 --maxfail=2 --junitxml=report.xml --random-order ./tests/unit_tests

.github/workflows/pytest.yml

@@ -1,64 +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 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/sync-issues-pr.yml

@@ -1,40 +0,0 @@
-name: Sync PR to Project
-
-on:
-  pull_request:
-    types: [opened, edited, ready_for_review, converted_to_draft, reopened, synchronize]
-
-jobs:
-  sync-project:
-    runs-on: ubuntu-latest
-
-    permissions:
-      issues: write
-      pull-requests: read
-      contents: read
-
-    env:
-        PROJECT_NUMBER: 3 # BEC Project
-        ORG: 'bec-project'
-        REPO: 'bec_widgets'
-        TOKEN: ${{ secrets.ADD_ISSUE_TO_PROJECT }}
-        PR_NUMBER: ${{ github.event.pull_request.number }}
-
-    steps:
-      - name: Set up python environment
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.11
-
-      - name: Checkout repo
-        uses: actions/checkout@v4
-        with:
-          repository: ${{ github.repository }}
-          ref: ${{ github.event.pull_request.head.ref }}
-
-      - name: Install dependencies
-        run: |
-          pip install -r ./.github/scripts/pr_issue_sync/requirements.txt
-      - name: Sync PR to Project
-        run: |
-          python ./.github/scripts/pr_issue_sync/pr_issue_sync.py

.gitignore

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

.gitlab-ci.yml

@@ -13,7 +13,7 @@ variables:
     value: main
   CHILD_PIPELINE_BRANCH: $CI_DEFAULT_BRANCH
   CHECK_PKG_VERSIONS:
-    description: Whether to run additional tests against min/max/random selection of dependencies. Set to 1 for running.
+    description: Whether to run additional tests against min/max/random selection of dependencies. Set to 1 for running. 
     value: 0
 
 workflow:
@@ -77,7 +77,7 @@ formatter:
   stage: Formatter
   needs: []
   script:
-    - pip install -e ./[dev]
+    - pip install bec_lib[dev]
     - isort --check --diff --line-length=100 --profile=black --multi-line=3 --trailing-comma ./
     - black --check --diff --color --line-length=100 --skip-magic-trailing-comma ./
   rules:
@@ -162,20 +162,6 @@ tests:
       - tests/reference_failures/
     when: always
 
-generate-client-check:
-  stage: test
-  needs: []
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-  script:
-    - *clone-repos
-    - *install-os-packages
-    - *install-repos
-    - pip install -e .[dev,pyside6]
-    - bw-generate-cli --target bec_widgets
-    # if there are changes in the generated files, fail the job
-    - git diff --exit-code
-
 test-matrix:
   parallel:
     matrix:
@@ -203,7 +189,7 @@ test-matrix:
 end-2-end-conda:
   stage: End2End
   needs: []
-  image: continuumio/miniconda3:25.1.1-2
+  image: continuumio/miniconda3
   allow_failure: false
   variables:
     QT_QPA_PLATFORM: "offscreen"
@@ -230,7 +216,7 @@ end-2-end-conda:
     - pip install -e ./ophyd_devices
 
     - pip install -e .[dev,pyside6]
-    - pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end
+    - pytest -v --files-path ./ --start-servers --flush-redis --random-order  ./tests/end-2-end
 
   artifacts:
     when: on_failure
@@ -245,7 +231,7 @@ end-2-end-conda:
     - if: '$CI_PIPELINE_SOURCE == "parent_pipeline"'
     - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"'
     - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
-    - if: "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME =~ /^pre_release.*$/"
+    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME =~ /^pre_release.*$/'
 
 semver:
   stage: Deploy

.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)
 

.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.10"
 
 # 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,16 +1,5 @@
 # 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.10%20%7C%203.11%20%7C%203.12-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)
-
-
 **⚠️ Important Notice:**
 
 🚨 **PyQt6 is no longer supported** due to incompatibilities with Qt Designer. Please use **PySide6** instead. 🚨

bec_widgets/applications/alignment/alignment_1d/alignment_1d.py

@@ -0,0 +1,199 @@
+""" This module contains the GUI for the 1D alignment application.
+It is a preliminary version of the GUI, which will be added to the main branch and steadily updated to be improved.
+"""
+
+import os
+from typing import Optional
+
+from bec_lib.device import Signal as BECSignal
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QSize
+from qtpy.QtGui import QIcon
+from qtpy.QtWidgets import QApplication
+
+import bec_widgets
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.utils.colors import get_accent_colors
+from bec_widgets.utils.error_popups import SafeSlot as Slot
+from bec_widgets.widgets.control.buttons.stop_button.stop_button import StopButton
+from bec_widgets.widgets.control.device_control.positioner_group.positioner_group import (
+    PositionerGroup,
+)
+from bec_widgets.widgets.dap.lmfit_dialog.lmfit_dialog import LMFitDialog
+from bec_widgets.widgets.plots.waveform.waveform_widget import BECWaveformWidget
+from bec_widgets.widgets.progress.bec_progressbar.bec_progressbar import BECProgressBar
+
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+logger = bec_logger.logger
+
+
+# FIXME BECWaveFormWidget is gone, this app will not work until adapted to new Waveform
+class Alignment1D:
+    """Alignment GUI to perform 1D scans"""
+
+    def __init__(self, client=None, gui_id: Optional[str] = None) -> None:
+        """Initialization
+
+        Args:
+            config: Configuration of the application.
+            client: BEC client object.
+            gui_id: GUI ID.
+        """
+        self.bec_dispatcher = BECDispatcher(client=client)
+        self.client = self.bec_dispatcher.client if client is None else client
+        QApplication.instance().aboutToQuit.connect(self.close)
+        self.dev = self.client.device_manager.devices
+
+        self._accent_colors = get_accent_colors()
+        self.ui_file = "alignment_1d.ui"
+        self.ui = None
+        self.progress_bar = None
+        self.waveform = None
+        self.init_ui()
+
+    def init_ui(self):
+        """Initialise the UI from QT Designer file"""
+        current_path = os.path.dirname(__file__)
+        self.ui = UILoader(None).loader(os.path.join(current_path, self.ui_file))
+        # Customize the plotting widget
+        self.waveform = self.ui.findChild(BECWaveformWidget, "bec_waveform_widget")
+        self._customise_bec_waveform_widget()
+        # Setup comboboxes for motor and signal selection
+        # FIXME after changing the filtering in the combobox
+        self._setup_signal_combobox()
+        # Setup motor indicator
+        self._setup_motor_indicator()
+        # Setup progress bar
+        self._setup_progress_bar()
+        # Add actions buttons
+        self._customise_buttons()
+        # Hook scaninfo updates
+        self.bec_dispatcher.connect_slot(self.scan_status_callback, MessageEndpoints.scan_status())
+
+    def show(self):
+        return self.ui.show()
+
+    ##############################
+    ############ SLOTS ###########
+    ##############################
+
+    @Slot(dict, dict)
+    def scan_status_callback(self, content: dict, _) -> None:
+        """This slot allows to enable/disable the UI critical components when a scan is running"""
+        if content["status"] in ["open"]:
+            self.enable_ui(False)
+        elif content["status"] in ["aborted", "halted", "closed"]:
+            self.enable_ui(True)
+
+    @Slot(tuple)
+    def move_to_center(self, move_request: tuple) -> None:
+        """Move the selected motor to the center"""
+        motor = self.ui.device_combobox.currentText()
+        if move_request[0] in ["center", "center1", "center2"]:
+            pos = move_request[1]
+        self.dev.get(motor).move(float(pos), relative=False)
+
+    @Slot()
+    def reset_progress_bar(self) -> None:
+        """Reset the progress bar"""
+        self.progress_bar.set_value(0)
+        self.progress_bar.set_minimum(0)
+
+    @Slot(dict, dict)
+    def update_progress_bar(self, content: dict, _) -> None:
+        """Hook to update the progress bar
+
+        Args:
+            content: Content of the scan progress message.
+            metadata: Metadata of the message.
+        """
+        if content["max_value"] == 0:
+            self.progress_bar.set_value(0)
+            return
+        self.progress_bar.set_maximum(content["max_value"])
+        self.progress_bar.set_value(content["value"])
+
+    @Slot()
+    def clear_queue(self) -> None:
+        """Clear the scan queue"""
+        self.queue.request_queue_reset()
+
+    ##############################
+    ######## END OF SLOTS ########
+    ##############################
+
+    def enable_ui(self, enable: bool) -> None:
+        """Enable or disable the UI components"""
+        # Enable/disable motor and signal selection
+        self.ui.device_combobox_2.setEnabled(enable)
+        # Enable/disable DAP selection
+        self.ui.dap_combo_box.setEnabled(enable)
+        # Enable/disable Scan Button
+        # self.ui.scan_button.setEnabled(enable)
+        # Disable move to buttons in LMFitDialog
+        self.ui.findChild(LMFitDialog).set_actions_enabled(enable)
+
+    def _customise_buttons(self) -> None:
+        """Add action buttons for the Action Control.
+        In addition, we are adding a callback to also clear the queue to the stop button
+        to ensure that upon clicking the button, no scans from another client may be queued
+        which would be confusing without the queue widget.
+        """
+        fit_dialog = self.ui.findChild(LMFitDialog)
+        fit_dialog.active_action_list = ["center", "center1", "center2"]
+        fit_dialog.move_action.connect(self.move_to_center)
+        stop_button = self.ui.findChild(StopButton)
+        stop_button.button.setText("Stop and Clear Queue")
+        stop_button.button.clicked.connect(self.clear_queue)
+
+    def _customise_bec_waveform_widget(self) -> None:
+        """Customise the BEC Waveform Widget, i.e. clear the toolbar"""
+        self.waveform.toolbar.clear()
+
+    def _setup_motor_indicator(self) -> None:
+        """Setup the arrow item"""
+        self.waveform.waveform.tick_item.add_to_plot()
+        positioner_box = self.ui.findChild(PositionerGroup)
+        positioner_box.position_update.connect(self.waveform.waveform.tick_item.set_position)
+        self.waveform.waveform.tick_item.set_position(0)
+
+    def _setup_signal_combobox(self) -> None:
+        """Setup signal selection"""
+        # FIXME after changing the filtering in the combobox
+        signals = [name for name in self.dev if isinstance(self.dev.get(name), BECSignal)]
+        self.ui.device_combobox_2.setCurrentText(signals[0])
+        self.ui.device_combobox_2.set_device_filter("Signal")
+
+    def _setup_progress_bar(self) -> None:
+        """Setup progress bar"""
+        # FIXME once the BECScanProgressBar is implemented
+        self.progress_bar = self.ui.findChild(BECProgressBar, "bec_progress_bar")
+        self.progress_bar.set_value(0)
+        self.ui.bec_waveform_widget.new_scan.connect(self.reset_progress_bar)
+        self.bec_dispatcher.connect_slot(self.update_progress_bar, MessageEndpoints.scan_progress())
+
+    def close(self):
+        logger.info("Disconnecting", repr(self.bec_dispatcher))
+        self.bec_dispatcher.disconnect_all()
+        logger.info("Shutting down BEC Client", repr(self.client))
+        self.client.shutdown()
+
+
+def main():
+    import sys
+
+    app = QApplication(sys.argv)
+    icon = QIcon()
+    icon.addFile(
+        os.path.join(MODULE_PATH, "assets", "app_icons", "alignment_1d.png"), size=QSize(48, 48)
+    )
+    app.setWindowIcon(icon)
+    window = Alignment1D()
+    window.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/applications/alignment/alignment_1d/alignment_1d.ui

@@ -0,0 +1,615 @@
+<?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>1611</width>
+    <height>1019</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Alignment tool</string>
+  </property>
+  <widget class="QWidget" name="widget">
+   <layout class="QVBoxLayout" name="verticalLayout_2">
+    <item>
+     <widget class="QWidget" name="widget" native="true">
+      <property name="sizePolicy">
+       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+        <horstretch>0</horstretch>
+        <verstretch>0</verstretch>
+       </sizepolicy>
+      </property>
+      <layout class="QHBoxLayout" name="horizontalLayout_5">
+       <item>
+        <widget class="DarkModeButton" name="dark_mode_button"/>
+       </item>
+       <item>
+        <spacer name="horizontalSpacer_6">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item>
+        <widget class="BECStatusBox" name="bec_status_box">
+         <property name="compact_view" stdset="0">
+          <bool>true</bool>
+         </property>
+         <property name="label" stdset="0">
+          <string>BEC Servers</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <spacer name="horizontalSpacer_3">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item>
+        <widget class="BECQueue" name="bec_queue">
+         <property name="compact_view" stdset="0">
+          <bool>true</bool>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <spacer name="horizontalSpacer_5">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item>
+        <widget class="QRadioButton" name="radioButton">
+         <property name="enabled">
+          <bool>false</bool>
+         </property>
+         <property name="text">
+          <string>SLS Light On</string>
+         </property>
+         <property name="checkable">
+          <bool>true</bool>
+         </property>
+         <property name="checked">
+          <bool>true</bool>
+         </property>
+         <property name="autoExclusive">
+          <bool>false</bool>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <spacer name="horizontalSpacer_7">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item>
+        <widget class="QRadioButton" name="radioButton_3">
+         <property name="enabled">
+          <bool>false</bool>
+         </property>
+         <property name="text">
+          <string>BEAMLINE Checks</string>
+         </property>
+         <property name="checkable">
+          <bool>true</bool>
+         </property>
+         <property name="checked">
+          <bool>true</bool>
+         </property>
+         <property name="autoExclusive">
+          <bool>false</bool>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <spacer name="horizontalSpacer_4">
+         <property name="orientation">
+          <enum>Qt::Orientation::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item>
+        <widget class="StopButton" name="stop_button">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="minimumSize">
+          <size>
+           <width>200</width>
+           <height>40</height>
+          </size>
+         </property>
+         <property name="maximumSize">
+          <size>
+           <width>200</width>
+           <height>40</height>
+          </size>
+         </property>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+    </item>
+    <item>
+     <widget class="BECProgressBar" name="bec_progress_bar">
+      <property name="minimumSize">
+       <size>
+        <width>0</width>
+        <height>25</height>
+       </size>
+      </property>
+      <property name="maximumSize">
+       <size>
+        <width>16777215</width>
+        <height>25</height>
+       </size>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <widget class="QTabWidget" name="tabWidget">
+      <property name="sizePolicy">
+       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+        <horstretch>0</horstretch>
+        <verstretch>0</verstretch>
+       </sizepolicy>
+      </property>
+      <property name="currentIndex">
+       <number>0</number>
+      </property>
+      <widget class="QWidget" name="ControlTab">
+       <attribute name="title">
+        <string>Alignment Control</string>
+       </attribute>
+       <layout class="QHBoxLayout" name="horizontalLayout_6">
+        <item>
+         <widget class="QWidget" name="widget_4" native="true">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+            <horstretch>1</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <layout class="QVBoxLayout" name="verticalLayout_3">
+           <item>
+            <widget class="ScanControl" name="scan_control">
+             <property name="current_scan" stdset="0">
+              <string>line_scan</string>
+             </property>
+             <property name="hide_arg_box" stdset="0">
+              <bool>false</bool>
+             </property>
+             <property name="hide_scan_selection_combobox" stdset="0">
+              <bool>true</bool>
+             </property>
+             <property name="hide_add_remove_buttons" stdset="0">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="PositionerGroup" name="positioner_group"/>
+           </item>
+           <item>
+            <spacer name="verticalSpacer">
+             <property name="orientation">
+              <enum>Qt::Orientation::Vertical</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>20</width>
+               <height>40</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QWidget" name="widget_3" native="true">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+            <horstretch>4</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <layout class="QVBoxLayout" name="verticalLayout">
+           <item>
+            <widget class="QWidget" name="widget_2" native="true">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <layout class="QHBoxLayout" name="horizontalLayout_3">
+              <item>
+               <widget class="QLabel" name="label_2">
+                <property name="font">
+                 <font/>
+                </property>
+                <property name="text">
+                 <string>Monitor</string>
+                </property>
+               </widget>
+              </item>
+              <item>
+               <widget class="DeviceComboBox" name="device_combobox_2"/>
+              </item>
+              <item>
+               <widget class="QLabel" name="label_3">
+                <property name="font">
+                 <font/>
+                </property>
+                <property name="text">
+                 <string>LMFit Model</string>
+                </property>
+               </widget>
+              </item>
+              <item>
+               <widget class="DapComboBox" name="dap_combo_box"/>
+              </item>
+              <item>
+               <widget class="QLabel" name="label">
+                <property name="text">
+                 <string>Enable ROI</string>
+                </property>
+               </widget>
+              </item>
+              <item>
+               <widget class="ToggleSwitch" name="toggle_switch">
+                <property name="sizePolicy">
+                 <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+                  <horstretch>3</horstretch>
+                  <verstretch>0</verstretch>
+                 </sizepolicy>
+                </property>
+                <property name="toolTip">
+                 <string>Activate linear region select for LMFit</string>
+                </property>
+                <property name="layoutDirection">
+                 <enum>Qt::LayoutDirection::LeftToRight</enum>
+                </property>
+                <property name="checked" stdset="0">
+                 <bool>false</bool>
+                </property>
+               </widget>
+              </item>
+              <item>
+               <spacer name="horizontalSpacer_8">
+                <property name="orientation">
+                 <enum>Qt::Orientation::Horizontal</enum>
+                </property>
+                <property name="sizeHint" stdset="0">
+                 <size>
+                  <width>40</width>
+                  <height>20</height>
+                 </size>
+                </property>
+               </spacer>
+              </item>
+             </layout>
+            </widget>
+           </item>
+           <item>
+            <widget class="BECWaveformWidget" name="bec_waveform_widget">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>1</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>600</width>
+               <height>450</height>
+              </size>
+             </property>
+             <property name="clear_curves_on_plot_update" stdset="0">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="LMFitDialog" name="lm_fit_dialog">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>0</width>
+               <height>190</height>
+              </size>
+             </property>
+             <property name="always_show_latest" stdset="0">
+              <bool>true</bool>
+             </property>
+             <property name="hide_curve_selection" stdset="0">
+              <bool>true</bool>
+             </property>
+             <property name="hide_summary" stdset="0">
+              <bool>true</bool>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+      <widget class="QWidget" name="tab_2">
+       <attribute name="title">
+        <string>Logbook</string>
+       </attribute>
+       <layout class="QHBoxLayout" name="horizontalLayout_4">
+        <property name="leftMargin">
+         <number>2</number>
+        </property>
+        <property name="topMargin">
+         <number>2</number>
+        </property>
+        <property name="rightMargin">
+         <number>2</number>
+        </property>
+        <property name="bottomMargin">
+         <number>2</number>
+        </property>
+        <item>
+         <widget class="WebsiteWidget" name="website_widget">
+          <property name="url" stdset="0">
+           <string>https://scilog.psi.ch/login</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </widget>
+    </item>
+   </layout>
+  </widget>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>DapComboBox</class>
+   <extends>QWidget</extends>
+   <header>dap_combo_box</header>
+  </customwidget>
+  <customwidget>
+   <class>StopButton</class>
+   <extends>QWidget</extends>
+   <header>stop_button</header>
+  </customwidget>
+  <customwidget>
+   <class>WebsiteWidget</class>
+   <extends>QWidget</extends>
+   <header>website_widget</header>
+  </customwidget>
+  <customwidget>
+   <class>BECQueue</class>
+   <extends>QWidget</extends>
+   <header>bec_queue</header>
+  </customwidget>
+  <customwidget>
+   <class>ScanControl</class>
+   <extends>QWidget</extends>
+   <header>scan_control</header>
+  </customwidget>
+  <customwidget>
+   <class>ToggleSwitch</class>
+   <extends>QWidget</extends>
+   <header>toggle_switch</header>
+  </customwidget>
+  <customwidget>
+   <class>BECProgressBar</class>
+   <extends>QWidget</extends>
+   <header>bec_progress_bar</header>
+  </customwidget>
+  <customwidget>
+   <class>DarkModeButton</class>
+   <extends>QWidget</extends>
+   <header>dark_mode_button</header>
+  </customwidget>
+  <customwidget>
+   <class>PositionerGroup</class>
+   <extends>QWidget</extends>
+   <header>positioner_group</header>
+  </customwidget>
+  <customwidget>
+   <class>BECWaveformWidget</class>
+   <extends>QWidget</extends>
+   <header>bec_waveform_widget</header>
+  </customwidget>
+  <customwidget>
+   <class>DeviceComboBox</class>
+   <extends>QComboBox</extends>
+   <header>device_combobox</header>
+  </customwidget>
+  <customwidget>
+   <class>LMFitDialog</class>
+   <extends>QWidget</extends>
+   <header>lm_fit_dialog</header>
+  </customwidget>
+  <customwidget>
+   <class>BECStatusBox</class>
+   <extends>QWidget</extends>
+   <header>bec_status_box</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>toggle_switch</sender>
+   <signal>enabled(bool)</signal>
+   <receiver>bec_waveform_widget</receiver>
+   <slot>toogle_roi_select(bool)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>1042</x>
+     <y>212</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>1416</x>
+     <y>322</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>bec_waveform_widget</sender>
+   <signal>dap_summary_update(QVariantMap,QVariantMap)</signal>
+   <receiver>lm_fit_dialog</receiver>
+   <slot>update_summary_tree(QVariantMap,QVariantMap)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>1099</x>
+     <y>258</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>1157</x>
+     <y>929</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>device_combobox_2</sender>
+   <signal>currentTextChanged(QString)</signal>
+   <receiver>bec_waveform_widget</receiver>
+   <slot>plot(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>577</x>
+     <y>215</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>1416</x>
+     <y>427</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>device_combobox_2</sender>
+   <signal>currentTextChanged(QString)</signal>
+   <receiver>dap_combo_box</receiver>
+   <slot>select_y_axis(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>577</x>
+     <y>215</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>909</x>
+     <y>215</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>dap_combo_box</sender>
+   <signal>new_dap_config(QString,QString,QString)</signal>
+   <receiver>bec_waveform_widget</receiver>
+   <slot>add_dap(QString,QString,QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>909</x>
+     <y>215</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>1416</x>
+     <y>447</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>scan_control</sender>
+   <signal>device_selected(QString)</signal>
+   <receiver>positioner_group</receiver>
+   <slot>set_positioners(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>230</x>
+     <y>306</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>187</x>
+     <y>926</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>scan_control</sender>
+   <signal>device_selected(QString)</signal>
+   <receiver>bec_waveform_widget</receiver>
+   <slot>set_x(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>187</x>
+     <y>356</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>972</x>
+     <y>509</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>scan_control</sender>
+   <signal>device_selected(QString)</signal>
+   <receiver>dap_combo_box</receiver>
+   <slot>select_x_axis(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>187</x>
+     <y>356</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>794</x>
+     <y>202</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

bec_widgets/applications/bec_app.py

@@ -0,0 +1,84 @@
+"""
+Launcher for BEC GUI Applications
+
+Application must be located in bec_widgets/applications ;
+in order for the launcher to find the application, it has to be put in
+a subdirectory with the same name as the main Python module:
+
+/bec_widgets/applications
+    ├── alignment
+    │   └── alignment_1d
+    │       └── alignment_1d.py
+    ├── other_app
+        └── other_app.py
+
+The tree above would contain 2 applications, alignment_1d and other_app.
+
+The Python module for the application must have `if __name__ == "__main__":`
+in order for the launcher to execute it (it is run with `python -m`).
+"""
+
+import argparse
+import os
+import sys
+
+MODULE_PATH = os.path.dirname(__file__)
+
+
+def find_apps(base_dir: str) -> list[str]:
+    matching_modules = []
+
+    for root, dirs, files in os.walk(base_dir):
+        parent_dir = os.path.basename(root)
+
+        for file in files:
+            if file.endswith(".py") and file != "__init__.py":
+                file_name_without_ext = os.path.splitext(file)[0]
+
+                if file_name_without_ext == parent_dir:
+                    rel_path = os.path.relpath(root, base_dir)
+                    module_path = rel_path.replace(os.sep, ".")
+
+                    module_name = f"{module_path}.{file_name_without_ext}"
+                    matching_modules.append((file_name_without_ext, module_name))
+
+    return matching_modules
+
+
+def main():
+    parser = argparse.ArgumentParser(description="BEC application launcher")
+
+    parser.add_argument("-m", "--module", type=str, help="The module to run (string argument).")
+
+    # Add a positional argument for the module, which acts as a fallback if -m is not provided
+    parser.add_argument(
+        "positional_module",
+        nargs="?",  # This makes the positional argument optional
+        help="Positional argument that is treated as module if -m is not specified.",
+    )
+
+    args = parser.parse_args()
+    # If the -m/--module is not provided, fallback to the positional argument
+    module = args.module if args.module else args.positional_module
+
+    if module:
+        for app_name, app_module in find_apps(MODULE_PATH):
+            if module in (app_name, app_module):
+                print("Starting:", app_name)
+                python_executable = sys.executable
+
+                # Replace the current process with the new Python module
+                os.execvp(
+                    python_executable,
+                    [python_executable, "-m", f"bec_widgets.applications.{app_module}"],
+                )
+        print(f"Error: cannot find application {module}")
+
+    # display list of apps
+    print("Available applications:")
+    for app, _ in find_apps(MODULE_PATH):
+        print(f"  - {app}")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/applications/bw_launch.py

@@ -1,11 +1,9 @@
-from __future__ import annotations
-
 from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
 from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
 
 
 def dock_area(object_name: str | None = None) -> BECDockArea:
-    _dock_area = BECDockArea(object_name=object_name, root_widget=True)
+    _dock_area = BECDockArea(object_name=object_name)
     return _dock_area
 
 

bec_widgets/applications/launch_window.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 import os
 import xml.etree.ElementTree as ET
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING
 
 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.QtCore import Qt, Signal
+from qtpy.QtGui import QPainter, QPainterPath, QPixmap
 from qtpy.QtWidgets import (
     QApplication,
     QComboBox,
@@ -21,10 +21,8 @@ from qtpy.QtWidgets import (
 
 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.toolbar import ModularToolBar
@@ -37,14 +35,11 @@ from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import
 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__)
 
 
 class LaunchTile(RoundedFrame):
-    DEFAULT_SIZE = (250, 300)
     open_signal = Signal()
 
     def __init__(
@@ -55,15 +50,9 @@ class LaunchTile(RoundedFrame):
         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)
@@ -94,26 +83,12 @@ class LaunchTile(RoundedFrame):
 
         # 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.setWordWrap(True)
         self.main_label.setAlignment(Qt.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.Fixed, QSizePolicy.Fixed)
@@ -154,29 +129,6 @@ class LaunchTile(RoundedFrame):
         )
         self.layout.addWidget(self.action_button, alignment=Qt.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.ElideRight, max_width))
-
 
 class LaunchWindow(BECMainWindow):
     RPC = True
@@ -189,15 +141,12 @@ class LaunchWindow(BECMainWindow):
         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 = QWidget()
         self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
         self.toolbar.addWidget(self.spacer)
         self.toolbar.addWidget(self.dark_mode_button)
@@ -207,124 +156,53 @@ class LaunchWindow(BECMainWindow):
         self.central_widget.layout = QHBoxLayout(self.central_widget)
         self.setCentralWidget(self.central_widget)
 
-        self.register_tile(
-            name="dock_area",
+        self.tile_dock_area = LaunchTile(
             icon_path=os.path.join(MODULE_PATH, "assets", "app_icons", "bec_widgets_icon.png"),
             top_label="Get started",
             main_label="BEC Dock Area",
             description="Highly flexible and customizable dock area application with modular widgets.",
-            action_button=lambda: self.launch("dock_area"),
-            show_selector=False,
         )
+        self.tile_dock_area.setFixedSize(*self.TILE_SIZE)
 
-        self.available_auto_updates: dict[str, type[AutoUpdates]] = (
-            self._update_available_auto_updates()
-        )
-        self.register_tile(
-            name="auto_update",
+        self.tile_auto_update = LaunchTile(
             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.tile_auto_update.setFixedSize(*self.TILE_SIZE)
 
-        self.register_tile(
-            name="custom_ui_file",
+        self.tile_ui_file = LaunchTile(
             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,
         )
+        self.tile_ui_file.setFixedSize(*self.TILE_SIZE)
 
-        # plugin widgets
-        self.available_widgets: dict[str, BECWidget] = get_all_plugin_widgets()
-        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()),
-            )
+        # Add tiles to the main layout
+        self.central_widget.layout.addWidget(self.tile_dock_area)
+        self.central_widget.layout.addWidget(self.tile_auto_update)
+        self.central_widget.layout.addWidget(self.tile_ui_file)
 
+        # hacky solution no time to waste
+        self.tiles = [self.tile_dock_area, self.tile_auto_update, self.tile_ui_file]
+
+        # Connect signals
+        self.tile_dock_area.action_button.clicked.connect(lambda: self.launch("dock_area"))
+        self.tile_auto_update.action_button.clicked.connect(self._open_auto_update)
+        self.tile_ui_file.action_button.clicked.connect(self._open_custom_ui_file)
         self._update_theme()
 
-        self.register = RPCRegister()
-        self.register.callbacks.append(self._turn_off_the_lights)
-        self.register.broadcast()
-
-    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,
+        # Auto updates
+        self.available_auto_updates: dict[str, type[AutoUpdates]] = (
+            self._update_available_auto_updates()
         )
-        tile.setFixedWidth(self.TILE_SIZE[0])
-        tile.setMinimumHeight(self.TILE_SIZE[1])
-        tile.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.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
+        if self.tile_auto_update.selector is not None:
+            self.tile_auto_update.selector.addItems(
+                list(self.available_auto_updates.keys()) + ["Default"]
+            )
 
     def launch(
         self,
@@ -332,7 +210,7 @@ class LaunchWindow(BECMainWindow):
         name: str | None = None,
         geometry: tuple[int, int, int, int] | None = None,
         **kwargs,
-    ) -> QWidget | None:
+    ) -> QWidget:
         """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.
@@ -353,8 +231,6 @@ class LaunchWindow(BECMainWindow):
                     raise ValueError(
                         f"Name {name} must be unique for dock areas, but already exists: {existing_dock_areas}."
                     )
-                WidgetContainerUtils.raise_for_invalid_name(name)
-
             else:
                 name = "dock_area"
                 name = WidgetContainerUtils.generate_unique_name(name, existing_dock_areas)
@@ -366,20 +242,12 @@ class LaunchWindow(BECMainWindow):
 
             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)
 
-            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)
-
             launch = getattr(bw_launch, launch_script, None)
             if launch is None:
                 raise ValueError(f"Launch script {launch_script} not found.")
@@ -397,7 +265,6 @@ class LaunchWindow(BECMainWindow):
             else:
                 window = BECMainWindow()
                 window.setCentralWidget(result_widget)
-                window.setWindowTitle(f"BEC - {result_widget.objectName()}")
                 window.show()
             return result_widget
 
@@ -407,8 +274,6 @@ class LaunchWindow(BECMainWindow):
             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)
-
         tree = ET.parse(ui_file)
         root = tree.getroot()
         # Check if the top-level widget is a QMainWindow
@@ -446,28 +311,11 @@ class LaunchWindow(BECMainWindow):
         window.show()
         return window
 
-    def _launch_widget(self, widget: type[BECWidget]) -> QWidget:
-        name = pascal_to_snake(widget.__name__)
-
-        WidgetContainerUtils.raise_for_invalid_name(name)
-
-        window = BECMainWindow()
-
-        widget_instance = widget(root_widget=True, object_name=name)
-        assert isinstance(widget_instance, QWidget)
-        QApplication.processEvents()
-
-        window.setCentralWidget(widget_instance)
-        window.resize(window.minimumSizeHint())
-        window.setWindowTitle(f"BEC - {widget_instance.objectName()}")
-        window.show()
-        return window
-
     def apply_theme(self, theme: str):
         """
         Change the theme of the application.
         """
-        for tile in self.tiles.values():
+        for tile in self.tiles:
             tile.apply_theme(theme)
 
         super().apply_theme(theme)
@@ -476,25 +324,14 @@ class LaunchWindow(BECMainWindow):
         """
         Open the auto update window.
         """
-        if self.tiles["auto_update"].selector is None:
+        if self.tile_auto_update.selector is None:
             auto_update = None
         else:
-            auto_update = self.tiles["auto_update"].selector.currentText()
+            auto_update = self.tile_auto_update.selector.currentText()
             if auto_update == "Default":
                 auto_update = None
         return self.launch("auto_update", auto_update=auto_update)
 
-    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])
-
     @SafeSlot(popup_error=True)
     def _open_custom_ui_file(self):
         """
@@ -534,45 +371,6 @@ class LaunchWindow(BECMainWindow):
         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.
-        """
-
-        remaining_connections = [
-            connection for connection in connections.values() if connection.parent_id != self.gui_id
-        ]
-        return len(remaining_connections) <= 1
-
-    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__":
     import sys

bec_widgets/cli/client.py

@@ -6,8 +6,6 @@ from __future__ import annotations
 import enum
 import inspect
 import traceback
-from functools import reduce
-from operator import add
 from typing import Literal, Optional
 
 from bec_lib.logger import bec_logger
@@ -27,37 +25,25 @@ class _WidgetsEnumType(str, enum.Enum):
 
 
 _Widgets = {
-    "AbortButton": "AbortButton",
     "BECDockArea": "BECDockArea",
     "BECProgressBar": "BECProgressBar",
     "BECQueue": "BECQueue",
     "BECStatusBox": "BECStatusBox",
     "DapComboBox": "DapComboBox",
-    "DarkModeButton": "DarkModeButton",
     "DeviceBrowser": "DeviceBrowser",
     "DeviceComboBox": "DeviceComboBox",
     "DeviceLineEdit": "DeviceLineEdit",
     "Image": "Image",
     "LogPanel": "LogPanel",
-    "Minesweeper": "Minesweeper",
     "MotorMap": "MotorMap",
     "MultiWaveform": "MultiWaveform",
     "PositionIndicator": "PositionIndicator",
-    "PositionerBox": "PositionerBox",
-    "PositionerBox2D": "PositionerBox2D",
-    "PositionerControlLine": "PositionerControlLine",
-    "ResetButton": "ResetButton",
-    "ResumeButton": "ResumeButton",
     "RingProgressBar": "RingProgressBar",
     "ScanControl": "ScanControl",
     "ScatterWaveform": "ScatterWaveform",
-    "SignalComboBox": "SignalComboBox",
-    "SignalLineEdit": "SignalLineEdit",
-    "StopButton": "StopButton",
     "TextBox": "TextBox",
     "VSCodeEditor": "VSCodeEditor",
     "Waveform": "Waveform",
-    "WebConsole": "WebConsole",
     "WebsiteWidget": "WebsiteWidget",
 }
 
@@ -90,16 +76,6 @@ except ImportError as e:
     logger.error(f"Failed loading plugins: \n{reduce(add, traceback.format_exception(e))}")
 
 
-class AbortButton(RPCBase):
-    """A button that abort the scan."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class AutoUpdates(RPCBase):
     @property
     @rpc_call
@@ -473,12 +449,6 @@ class BECProgressBar(RPCBase):
         >>> progressbar.label_template = "$value / $percentage %"
         """
 
-    @rpc_call
-    def _get_label(self) -> str:
-        """
-        Return the label text. mostly used for testing rpc.
-        """
-
 
 class BECQueue(RPCBase):
     """Widget to display the BEC queue."""
@@ -493,12 +463,6 @@ class BECQueue(RPCBase):
 class BECStatusBox(RPCBase):
     """An autonomous widget to display the status of BEC services."""
 
-    @rpc_call
-    def get_server_state(self) -> "str":
-        """
-        Get the state ("RUNNING", "BUSY", "IDLE", "ERROR") of the BEC server
-        """
-
     @rpc_call
     def remove(self):
         """
@@ -506,224 +470,6 @@ class BECStatusBox(RPCBase):
         """
 
 
-class BaseROI(RPCBase):
-    """Base class for all Region of Interest (ROI) implementations."""
-
-    @property
-    @rpc_call
-    def label(self) -> "str":
-        """
-        Gets the display name of this ROI.
-
-        Returns:
-            str: The current name of the ROI.
-        """
-
-    @label.setter
-    @rpc_call
-    def label(self) -> "str":
-        """
-        Gets the display name of this ROI.
-
-        Returns:
-            str: The current name of the ROI.
-        """
-
-    @property
-    @rpc_call
-    def line_color(self) -> "str":
-        """
-        Gets the current line color of the ROI.
-
-        Returns:
-            str: The current line color as a string (e.g., hex color code).
-        """
-
-    @line_color.setter
-    @rpc_call
-    def line_color(self) -> "str":
-        """
-        Gets the current line color of the ROI.
-
-        Returns:
-            str: The current line color as a string (e.g., hex color code).
-        """
-
-    @property
-    @rpc_call
-    def line_width(self) -> "int":
-        """
-        Gets the current line width of the ROI.
-
-        Returns:
-            int: The current line width in pixels.
-        """
-
-    @line_width.setter
-    @rpc_call
-    def line_width(self) -> "int":
-        """
-        Gets the current line width of the ROI.
-
-        Returns:
-            int: The current line width in pixels.
-        """
-
-    @rpc_call
-    def get_coordinates(self):
-        """
-        Gets the coordinates that define this ROI's position and shape.
-
-        This is an abstract method that must be implemented by subclasses.
-        Implementations should return either a dictionary with descriptive keys
-        or a tuple of coordinates, depending on the value of self.description.
-
-        Returns:
-            dict or tuple: The coordinates defining the ROI's position and shape.
-
-        Raises:
-            NotImplementedError: This method must be implemented by subclasses.
-        """
-
-    @rpc_call
-    def get_data_from_image(
-        self, image_item: "pg.ImageItem | None" = None, returnMappedCoords: "bool" = False, **kwargs
-    ):
-        """
-        Wrapper around `pyqtgraph.ROI.getArrayRegion`.
-
-        Args:
-            image_item (pg.ImageItem or None): The ImageItem to sample. If None, auto-detects
-                the first `ImageItem` in the same GraphicsScene as this ROI.
-            returnMappedCoords (bool): If True, also returns the coordinate array generated by
-                *getArrayRegion*.
-            **kwargs: Additional keyword arguments passed to *getArrayRegion* or *affineSlice*,
-                such as `axes`, `order`, `shape`, etc.
-
-        Returns:
-            ndarray: Pixel data inside the ROI, or (data, coords) if *returnMappedCoords* is True.
-        """
-
-    @rpc_call
-    def set_position(self, x: "float", y: "float"):
-        """
-        Sets the position of the ROI.
-
-        Args:
-            x (float): The x-coordinate of the new position.
-            y (float): The y-coordinate of the new position.
-        """
-
-
-class CircularROI(RPCBase):
-    """Circular Region of Interest with center/diameter tracking and auto-labeling."""
-
-    @property
-    @rpc_call
-    def label(self) -> "str":
-        """
-        Gets the display name of this ROI.
-
-        Returns:
-            str: The current name of the ROI.
-        """
-
-    @label.setter
-    @rpc_call
-    def label(self) -> "str":
-        """
-        Gets the display name of this ROI.
-
-        Returns:
-            str: The current name of the ROI.
-        """
-
-    @property
-    @rpc_call
-    def line_color(self) -> "str":
-        """
-        Gets the current line color of the ROI.
-
-        Returns:
-            str: The current line color as a string (e.g., hex color code).
-        """
-
-    @line_color.setter
-    @rpc_call
-    def line_color(self) -> "str":
-        """
-        Gets the current line color of the ROI.
-
-        Returns:
-            str: The current line color as a string (e.g., hex color code).
-        """
-
-    @property
-    @rpc_call
-    def line_width(self) -> "int":
-        """
-        Gets the current line width of the ROI.
-
-        Returns:
-            int: The current line width in pixels.
-        """
-
-    @line_width.setter
-    @rpc_call
-    def line_width(self) -> "int":
-        """
-        Gets the current line width of the ROI.
-
-        Returns:
-            int: The current line width in pixels.
-        """
-
-    @rpc_call
-    def get_coordinates(self, typed: "bool | None" = None) -> "dict | tuple":
-        """
-        Calculates and returns the coordinates and size of an object, either as a
-        typed dictionary or as a tuple.
-
-        Args:
-            typed (bool | None): If True, returns coordinates as a dictionary. Defaults
-                to None, which utilizes the object's description value.
-
-        Returns:
-            dict: A dictionary with keys 'center_x', 'center_y', 'diameter', and 'radius'
-                if `typed` is True.
-            tuple: A tuple containing (center_x, center_y, diameter, radius) if `typed` is False.
-        """
-
-    @rpc_call
-    def get_data_from_image(
-        self, image_item: "pg.ImageItem | None" = None, returnMappedCoords: "bool" = False, **kwargs
-    ):
-        """
-        Wrapper around `pyqtgraph.ROI.getArrayRegion`.
-
-        Args:
-            image_item (pg.ImageItem or None): The ImageItem to sample. If None, auto-detects
-                the first `ImageItem` in the same GraphicsScene as this ROI.
-            returnMappedCoords (bool): If True, also returns the coordinate array generated by
-                *getArrayRegion*.
-            **kwargs: Additional keyword arguments passed to *getArrayRegion* or *affineSlice*,
-                such as `axes`, `order`, `shape`, etc.
-
-        Returns:
-            ndarray: Pixel data inside the ROI, or (data, coords) if *returnMappedCoords* is True.
-        """
-
-    @rpc_call
-    def set_position(self, x: "float", y: "float"):
-        """
-        Sets the position of the ROI.
-
-        Args:
-            x (float): The x-coordinate of the new position.
-            y (float): The y-coordinate of the new position.
-        """
-
-
 class Curve(RPCBase):
     @rpc_call
     def remove(self):
@@ -919,14 +665,6 @@ class DapComboBox(RPCBase):
         """
 
 
-class DarkModeButton(RPCBase):
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class DeviceBrowser(RPCBase):
     """DeviceBrowser is a widget that displays all available devices in the current BEC session."""
 
@@ -941,22 +679,9 @@ class DeviceComboBox(RPCBase):
     """Combobox widget for device input with autocomplete for device names."""
 
     @rpc_call
-    def set_device(self, device: "str"):
+    def remove(self):
         """
-        Set the device.
-
-        Args:
-            device (str): Default name.
-        """
-
-    @property
-    @rpc_call
-    def devices(self) -> "list[str]":
-        """
-        Get the list of devices for the applied filters.
-
-        Returns:
-            list[str]: List of devices.
+        Cleanup the BECConnector
         """
 
 
@@ -974,32 +699,9 @@ class DeviceLineEdit(RPCBase):
     """Line edit widget for device input with autocomplete for device names."""
 
     @rpc_call
-    def set_device(self, device: "str"):
+    def remove(self):
         """
-        Set the device.
-
-        Args:
-            device (str): Default name.
-        """
-
-    @property
-    @rpc_call
-    def devices(self) -> "list[str]":
-        """
-        Get the list of devices for the applied filters.
-
-        Returns:
-            list[str]: List of devices.
-        """
-
-    @property
-    @rpc_call
-    def _is_valid_input(self) -> bool:
-        """
-        Check if the current value is a valid device name.
-
-        Returns:
-            bool: True if the current value is a valid device name, False otherwise.
+        Cleanup the BECConnector
         """
 
 
@@ -1221,6 +923,48 @@ class Image(RPCBase):
         Set auto range for the y-axis.
         """
 
+    @property
+    @rpc_call
+    def x_log(self) -> "bool":
+        """
+        Set X-axis to log scale if True, linear if False.
+        """
+
+    @x_log.setter
+    @rpc_call
+    def x_log(self) -> "bool":
+        """
+        Set X-axis to log scale if True, linear if False.
+        """
+
+    @property
+    @rpc_call
+    def y_log(self) -> "bool":
+        """
+        Set Y-axis to log scale if True, linear if False.
+        """
+
+    @y_log.setter
+    @rpc_call
+    def y_log(self) -> "bool":
+        """
+        Set Y-axis to log scale if True, linear if False.
+        """
+
+    @property
+    @rpc_call
+    def legend_label_size(self) -> "int":
+        """
+        The font size of the legend font.
+        """
+
+    @legend_label_size.setter
+    @rpc_call
+    def legend_label_size(self) -> "int":
+        """
+        The font size of the legend font.
+        """
+
     @property
     @rpc_call
     def color_map(self) -> "str":
@@ -1415,16 +1159,16 @@ class Image(RPCBase):
 
     @property
     @rpc_call
-    def num_rotation_90(self) -> "int":
+    def rotation(self) -> "int":
         """
-        The number of 90° rotations to apply counterclockwise.
+        The number of 90° rotations to apply.
         """
 
-    @num_rotation_90.setter
+    @rotation.setter
     @rpc_call
-    def num_rotation_90(self) -> "int":
+    def rotation(self) -> "int":
         """
-        The number of 90° rotations to apply counterclockwise.
+        The number of 90° rotations to apply.
         """
 
     @property
@@ -1471,44 +1215,6 @@ class Image(RPCBase):
         Access the main image item.
         """
 
-    @rpc_call
-    def add_roi(
-        self,
-        kind: "Literal['rect', 'circle']" = "rect",
-        name: "str | None" = None,
-        line_width: "int | None" = 5,
-        pos: "tuple[float, float] | None" = (10, 10),
-        size: "tuple[float, float] | None" = (50, 50),
-        **pg_kwargs,
-    ) -> "RectangularROI | CircularROI":
-        """
-        Add a ROI to the image.
-
-        Args:
-            kind(str): The type of ROI to add. Options are "rect" or "circle".
-            name(str): The name of the ROI.
-            line_width(int): The line width of the ROI.
-            pos(tuple): The position of the ROI.
-            size(tuple): The size of the ROI.
-            **pg_kwargs: Additional arguments for the ROI.
-
-        Returns:
-            RectangularROI | CircularROI: The created ROI object.
-        """
-
-    @rpc_call
-    def remove_roi(self, roi: "int | str"):
-        """
-        Remove an ROI by index or label via the ROIController.
-        """
-
-    @property
-    @rpc_call
-    def rois(self) -> "list[BaseROI]":
-        """
-        Get the list of ROIs.
-        """
-
 
 class ImageItem(RPCBase):
     @property
@@ -1625,14 +1331,14 @@ class ImageItem(RPCBase):
 
     @property
     @rpc_call
-    def num_rotation_90(self) -> "Optional[int]":
+    def rotation(self) -> "Optional[int]":
         """
         Get or set the number of 90° rotations to apply.
         """
 
-    @num_rotation_90.setter
+    @rotation.setter
     @rpc_call
-    def num_rotation_90(self) -> "Optional[int]":
+    def rotation(self) -> "Optional[int]":
         """
         Get or set the number of 90° rotations to apply.
         """
@@ -1682,9 +1388,6 @@ class LogPanel(RPCBase):
         """
 
 
-class Minesweeper(RPCBase): ...
-
-
 class MotorMap(RPCBase):
     """Motor map widget for plotting motor positions in 2D including a trace of the last points."""
 
@@ -2463,7 +2166,7 @@ class MultiWaveform(RPCBase):
         """
 
     @rpc_call
-    def plot(self, monitor: "str", color_palette: "str | None" = "plasma"):
+    def plot(self, monitor: "str", color_palette: "str | None" = "magma"):
         """
         Create a plot for the given monitor.
         Args:
@@ -2493,10 +2196,7 @@ class PositionIndicator(RPCBase):
     @rpc_call
     def set_value(self, position: float):
         """
-        Set the position of the indicator
-
-        Args:
-            position: The new position of the indicator
+        None
         """
 
     @rpc_call
@@ -2516,13 +2216,6 @@ class PositionIndicator(RPCBase):
         Property to determine the orientation of the position indicator
         """
 
-    @vertical.setter
-    @rpc_call
-    def vertical(self):
-        """
-        Property to determine the orientation of the position indicator
-        """
-
     @property
     @rpc_call
     def indicator_width(self):
@@ -2530,13 +2223,6 @@ class PositionIndicator(RPCBase):
         Property to get the width of the indicator
         """
 
-    @indicator_width.setter
-    @rpc_call
-    def indicator_width(self):
-        """
-        Property to get the width of the indicator
-        """
-
     @property
     @rpc_call
     def rounded_corners(self):
@@ -2544,61 +2230,6 @@ class PositionIndicator(RPCBase):
         Property to get the rounded corners of the position indicator
         """
 
-    @rounded_corners.setter
-    @rpc_call
-    def rounded_corners(self):
-        """
-        Property to get the rounded corners of the position indicator
-        """
-
-
-class PositionerBox(RPCBase):
-    """Simple Widget to control a positioner in box form"""
-
-    @rpc_call
-    def set_positioner(self, positioner: "str | Positioner"):
-        """
-        Set the device
-
-        Args:
-            positioner (Positioner | str) : Positioner to set, accepts str or the device
-        """
-
-
-class PositionerBox2D(RPCBase):
-    """Simple Widget to control two positioners in box form"""
-
-    @rpc_call
-    def set_positioner_hor(self, positioner: "str | Positioner"):
-        """
-        Set the device
-
-        Args:
-            positioner (Positioner | str) : Positioner to set, accepts str or the device
-        """
-
-    @rpc_call
-    def set_positioner_ver(self, positioner: "str | Positioner"):
-        """
-        Set the device
-
-        Args:
-            positioner (Positioner | str) : Positioner to set, accepts str or the device
-        """
-
-
-class PositionerControlLine(RPCBase):
-    """A widget that controls a single device."""
-
-    @rpc_call
-    def set_positioner(self, positioner: "str | Positioner"):
-        """
-        Set the device
-
-        Args:
-            positioner (Positioner | str) : Positioner to set, accepts str or the device
-        """
-
 
 class PositionerGroup(RPCBase):
     """Simple Widget to control a positioner in box form"""
@@ -2612,135 +2243,6 @@ class PositionerGroup(RPCBase):
         """
 
 
-class RectangularROI(RPCBase):
-    """Defines a rectangular Region of Interest (ROI) with additional functionality."""
-
-    @property
-    @rpc_call
-    def label(self) -> "str":
-        """
-        Gets the display name of this ROI.
-
-        Returns:
-            str: The current name of the ROI.
-        """
-
-    @label.setter
-    @rpc_call
-    def label(self) -> "str":
-        """
-        Gets the display name of this ROI.
-
-        Returns:
-            str: The current name of the ROI.
-        """
-
-    @property
-    @rpc_call
-    def line_color(self) -> "str":
-        """
-        Gets the current line color of the ROI.
-
-        Returns:
-            str: The current line color as a string (e.g., hex color code).
-        """
-
-    @line_color.setter
-    @rpc_call
-    def line_color(self) -> "str":
-        """
-        Gets the current line color of the ROI.
-
-        Returns:
-            str: The current line color as a string (e.g., hex color code).
-        """
-
-    @property
-    @rpc_call
-    def line_width(self) -> "int":
-        """
-        Gets the current line width of the ROI.
-
-        Returns:
-            int: The current line width in pixels.
-        """
-
-    @line_width.setter
-    @rpc_call
-    def line_width(self) -> "int":
-        """
-        Gets the current line width of the ROI.
-
-        Returns:
-            int: The current line width in pixels.
-        """
-
-    @rpc_call
-    def get_coordinates(self, typed: "bool | None" = None) -> "dict | tuple":
-        """
-        Returns the coordinates of a rectangle's corners. Supports returning them
-        as either a dictionary with descriptive keys or a tuple of coordinates.
-
-        Args:
-            typed (bool | None): If True, returns coordinates as a dictionary with
-                descriptive keys. If False, returns them as a tuple. Defaults to
-                the value of `self.description`.
-
-        Returns:
-            dict | tuple: The rectangle's corner coordinates, where the format
-                depends on the `typed` parameter.
-        """
-
-    @rpc_call
-    def get_data_from_image(
-        self, image_item: "pg.ImageItem | None" = None, returnMappedCoords: "bool" = False, **kwargs
-    ):
-        """
-        Wrapper around `pyqtgraph.ROI.getArrayRegion`.
-
-        Args:
-            image_item (pg.ImageItem or None): The ImageItem to sample. If None, auto-detects
-                the first `ImageItem` in the same GraphicsScene as this ROI.
-            returnMappedCoords (bool): If True, also returns the coordinate array generated by
-                *getArrayRegion*.
-            **kwargs: Additional keyword arguments passed to *getArrayRegion* or *affineSlice*,
-                such as `axes`, `order`, `shape`, etc.
-
-        Returns:
-            ndarray: Pixel data inside the ROI, or (data, coords) if *returnMappedCoords* is True.
-        """
-
-    @rpc_call
-    def set_position(self, x: "float", y: "float"):
-        """
-        Sets the position of the ROI.
-
-        Args:
-            x (float): The x-coordinate of the new position.
-            y (float): The y-coordinate of the new position.
-        """
-
-
-class ResetButton(RPCBase):
-    """A button that resets the scan queue."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
-class ResumeButton(RPCBase):
-    """A button that continue scan queue."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class Ring(RPCBase):
     @rpc_call
     def _get_all_rpc(self) -> "dict":
@@ -2869,9 +2371,9 @@ class RingProgressBar(RPCBase):
 
     @property
     @rpc_call
-    def rings(self) -> "list[Ring]":
+    def rings(self):
         """
-        Returns a list of all rings in the progress bar.
+        None
         """
 
     @rpc_call
@@ -3345,7 +2847,7 @@ class ScatterWaveform(RPCBase):
         x_entry: "None | str" = None,
         y_entry: "None | str" = None,
         z_entry: "None | str" = None,
-        color_map: "str | None" = "plasma",
+        color_map: "str | None" = "magma",
         label: "str | None" = None,
         validate_bec: "bool" = True,
     ) -> "ScatterCurve":
@@ -3385,90 +2887,6 @@ class ScatterWaveform(RPCBase):
         """
 
 
-class SignalComboBox(RPCBase):
-    """Line edit widget for device input with autocomplete for device names."""
-
-    @rpc_call
-    def set_signal(self, signal: str):
-        """
-        Set the signal.
-
-        Args:
-            signal (str): signal name.
-        """
-
-    @rpc_call
-    def set_device(self, device: str | None):
-        """
-        Set the device. If device is not valid, device will be set to None which happens
-
-        Args:
-            device(str): device name.
-        """
-
-    @property
-    @rpc_call
-    def signals(self) -> list[str]:
-        """
-        Get the list of device signals for the applied filters.
-
-        Returns:
-            list[str]: List of device signals.
-        """
-
-
-class SignalLineEdit(RPCBase):
-    """Line edit widget for device input with autocomplete for device names."""
-
-    @property
-    @rpc_call
-    def _is_valid_input(self) -> bool:
-        """
-        Check if the current value is a valid device name.
-
-        Returns:
-            bool: True if the current value is a valid device name, False otherwise.
-        """
-
-    @rpc_call
-    def set_signal(self, signal: str):
-        """
-        Set the signal.
-
-        Args:
-            signal (str): signal name.
-        """
-
-    @rpc_call
-    def set_device(self, device: str | None):
-        """
-        Set the device. If device is not valid, device will be set to None which happens
-
-        Args:
-            device(str): device name.
-        """
-
-    @property
-    @rpc_call
-    def signals(self) -> list[str]:
-        """
-        Get the list of device signals for the applied filters.
-
-        Returns:
-            list[str]: List of device signals.
-        """
-
-
-class StopButton(RPCBase):
-    """A button that stops the current scan."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class TextBox(RPCBase):
     """A widget that displays text in plain and HTML format"""
 
@@ -3813,20 +3231,6 @@ class Waveform(RPCBase):
         None
         """
 
-    @property
-    @rpc_call
-    def x_entry(self) -> "str | None":
-        """
-        The x signal name.
-        """
-
-    @x_entry.setter
-    @rpc_call
-    def x_entry(self) -> "str | None":
-        """
-        The x signal name.
-        """
-
     @property
     @rpc_call
     def color_palette(self) -> "str":
@@ -3979,16 +3383,6 @@ class Waveform(RPCBase):
         """
 
 
-class WebConsole(RPCBase):
-    """A simple widget to display a website"""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class WebsiteWidget(RPCBase):
     """A simple widget to display a website"""
 

bec_widgets/cli/client_utils.py

@@ -20,7 +20,6 @@ from rich.table import Table
 
 import bec_widgets.cli.client as client
 from bec_widgets.cli.rpc.rpc_base import RPCBase, RPCReference
-from bec_widgets.utils.serialization import register_serializer_extension
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_lib.messages import GUIRegistryStateMessage
@@ -32,8 +31,7 @@ logger = bec_logger.logger
 IGNORE_WIDGETS = ["LaunchWindow"]
 
 RegistryState: TypeAlias = dict[
-    Literal["gui_id", "name", "widget_class", "config", "__rpc__", "container_proxy"],
-    str | bool | dict,
+    Literal["gui_id", "name", "widget_class", "config", "__rpc__"], str | bool | dict
 ]
 
 # pylint: disable=redefined-outer-scope
@@ -216,7 +214,6 @@ class BECGuiClient(RPCBase):
         self._server_registry: dict[str, RegistryState] = {}
         self._ipython_registry: dict[str, RPCReference] = {}
         self.available_widgets = AvailableWidgetsNamespace()
-        register_serializer_extension()
 
     ####################
     #### Client API ####
@@ -278,8 +275,6 @@ class BECGuiClient(RPCBase):
         name: str | None = None,
         wait: bool = True,
         geometry: tuple[int, int, int, int] | None = None,
-        launch_script: str = "dock_area",
-        **kwargs,
     ) -> client.BECDockArea:
         """Create a new top-level dock area.
 
@@ -295,11 +290,11 @@ class BECGuiClient(RPCBase):
         if wait:
             with wait_for_server(self):
                 widget = self.launcher._run_rpc(
-                    "launch", launch_script=launch_script, name=name, geometry=geometry, **kwargs
+                    "launch", "dock_area", name, geometry
                 )  # pylint: disable=protected-access
                 return widget
         widget = self.launcher._run_rpc(
-            "launch", launch_script=launch_script, name=name, geometry=geometry, **kwargs
+            "new_dock_area", name, geometry
         )  # pylint: disable=protected-access
         return widget
 

bec_widgets/cli/generate_cli.py

@@ -40,8 +40,6 @@ class ClientGenerator:
             """import enum
 import inspect
 import traceback
-from functools import reduce
-from operator import add
 from typing import Literal, Optional
 """
             if self._base
@@ -223,18 +221,18 @@ class {class_name}(RPCBase):"""
         # 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))
+            formatted_content = black.format_str(full_content, mode=black.FileMode(line_length=100))
         except black.NothingChanged:
             formatted_content = full_content
 
-        config = isort.Config(
+        isort.Config(
             profile="black",
             line_length=100,
             multi_line_output=3,
-            include_trailing_comma=False,
+            include_trailing_comma=True,
             known_first_party=["bec_widgets"],
         )
-        formatted_content = isort.code(formatted_content, config=config)
+        formatted_content = isort.code(formatted_content)
 
         with open(file_name, "w", encoding="utf-8") as file:
             file.write(formatted_content)
@@ -317,7 +315,4 @@ def main():
 
 
 if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    sys.argv = ["bw-generate-cli", "--target", "bec_widgets"]
     main()

bec_widgets/cli/rpc/rpc_base.py

@@ -130,7 +130,6 @@ class RPCBase:
         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 {}
@@ -145,21 +144,21 @@ class RPCBase:
     def __repr__(self):
         type_ = type(self)
         qualname = type_.__qualname__
-        return f"<{qualname} with name: {self.object_name}>"
+        return f"<{qualname} with name: {self.widget_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 widget_name(self):
+        """
+        Get the widget name.
+        """
+        return self.object_name
+
     @property
     def _root(self) -> BECGuiClient:
         """
@@ -172,15 +171,7 @@ class RPCBase:
             parent = parent._parent
         return parent  # type: ignore
 
-    def _run_rpc(
-        self,
-        method,
-        *args,
-        wait_for_rpc_response=True,
-        timeout=5,
-        gui_id: str | None = None,
-        **kwargs,
-    ) -> Any:
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=5, **kwargs) -> Any:
         """
         Run the RPC call.
 
@@ -188,8 +179,6 @@ class RPCBase:
             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:
@@ -198,7 +187,7 @@ class RPCBase:
         request_id = str(uuid.uuid4())
         rpc_msg = messages.GUIInstructionMessage(
             action=method,
-            parameter={"args": args, "kwargs": kwargs, "gui_id": gui_id or self._gui_id},
+            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
             metadata={"request_id": request_id},
         )
         # pylint: disable=protected-access

bec_widgets/cli/server.py

@@ -6,6 +6,7 @@ import os
 import signal
 import sys
 from contextlib import redirect_stderr, redirect_stdout
+from typing import cast
 
 from bec_lib.logger import bec_logger
 from bec_lib.service_config import ServiceConfig
@@ -27,6 +28,7 @@ class SimpleFileLikeFromLogOutputFunc:
     def __init__(self, log_func):
         self._log_func = log_func
         self._buffer = []
+        self.encoding = "utf8"
 
     def write(self, buffer):
         self._buffer.append(buffer)
@@ -37,10 +39,6 @@ class SimpleFileLikeFromLogOutputFunc:
             self._log_func(lines)
         self._buffer = [remaining]
 
-    @property
-    def encoding(self):
-        return "utf-8"
-
     def close(self):
         return
 
@@ -86,6 +84,29 @@ class GUIServer:
             service_config = ServiceConfig()
         return service_config
 
+    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.
+        """
+        self.launcher_window = cast(LaunchWindow, self.launcher_window)
+
+        remaining_connections = [
+            connection
+            for connection in connections.values()
+            if connection.parent_id != self.launcher_window.gui_id
+        ]
+        if len(remaining_connections) <= 1:
+            self.launcher_window.show()
+            self.launcher_window.activateWindow()
+            self.launcher_window.raise_()
+            if self.app:
+                self.app.setQuitOnLastWindowClosed(True)
+        else:
+            self.launcher_window.hide()
+            if self.app:
+                self.app.setQuitOnLastWindowClosed(False)
+
     def _run(self):
         """
         Run the GUI server.
@@ -105,6 +126,10 @@ class GUIServer:
         self.app.aboutToQuit.connect(self.shutdown)
         self.app.setQuitOnLastWindowClosed(False)
 
+        register = RPCRegister()
+        register.callbacks.append(self._turn_off_the_lights)
+        register.broadcast()
+
         if self.gui_class:
             # If the server is started with a specific gui class, we launch it.
             # This will automatically hide the launcher.

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -44,21 +44,21 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     "wh": wh,
                     "dock": self.dock,
                     "im": self.im,
-                    # "mi": self.mi,
-                    # "mm": self.mm,
-                    # "lm": self.lm,
-                    # "btn1": self.btn1,
-                    # "btn2": self.btn2,
-                    # "btn3": self.btn3,
-                    # "btn4": self.btn4,
-                    # "btn5": self.btn5,
-                    # "btn6": self.btn6,
-                    # "pb": self.pb,
-                    # "pi": self.pi,
-                    # "wf": self.wf,
-                    # "scatter": self.scatter,
-                    # "scatter_mi": self.scatter,
-                    # "mwf": self.mwf,
+                    "mi": self.mi,
+                    "mm": self.mm,
+                    "lm": self.lm,
+                    "btn1": self.btn1,
+                    "btn2": self.btn2,
+                    "btn3": self.btn3,
+                    "btn4": self.btn4,
+                    "btn5": self.btn5,
+                    "btn6": self.btn6,
+                    "pb": self.pb,
+                    "pi": self.pi,
+                    "wf": self.wf,
+                    "scatter": self.scatter,
+                    "scatter_mi": self.scatter,
+                    "mwf": self.mwf,
                 }
             )
 
@@ -77,76 +77,76 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         first_tab_layout.addWidget(self.dock)
         tab_widget.addTab(first_tab, "Dock Area")
 
-        # third_tab = QWidget()
-        # third_tab_layout = QVBoxLayout(third_tab)
-        # self.lm = LayoutManagerWidget()
-        # third_tab_layout.addWidget(self.lm)
-        # tab_widget.addTab(third_tab, "Layout Manager Widget")
-        #
-        # fourth_tab = QWidget()
-        # fourth_tab_layout = QVBoxLayout(fourth_tab)
-        # self.pb = PlotBase()
-        # self.pi = self.pb.plot_item
-        # fourth_tab_layout.addWidget(self.pb)
-        # tab_widget.addTab(fourth_tab, "PlotBase")
-        #
-        # tab_widget.setCurrentIndex(3)
-        #
+        third_tab = QWidget()
+        third_tab_layout = QVBoxLayout(third_tab)
+        self.lm = LayoutManagerWidget()
+        third_tab_layout.addWidget(self.lm)
+        tab_widget.addTab(third_tab, "Layout Manager Widget")
+
+        fourth_tab = QWidget()
+        fourth_tab_layout = QVBoxLayout(fourth_tab)
+        self.pb = PlotBase()
+        self.pi = self.pb.plot_item
+        fourth_tab_layout.addWidget(self.pb)
+        tab_widget.addTab(fourth_tab, "PlotBase")
+
+        tab_widget.setCurrentIndex(3)
+
         group_box = QGroupBox("Jupyter Console", splitter)
         group_box_layout = QVBoxLayout(group_box)
         self.console = BECJupyterConsole(inprocess=True)
         group_box_layout.addWidget(self.console)
-        #
-        # # Some buttons for layout testing
-        # self.btn1 = QPushButton("Button 1")
-        # self.btn2 = QPushButton("Button 2")
-        # self.btn3 = QPushButton("Button 3")
-        # self.btn4 = QPushButton("Button 4")
-        # self.btn5 = QPushButton("Button 5")
-        # self.btn6 = QPushButton("Button 6")
-        #
-        # fifth_tab = QWidget()
-        # fifth_tab_layout = QVBoxLayout(fifth_tab)
-        # self.wf = Waveform()
-        # fifth_tab_layout.addWidget(self.wf)
-        # tab_widget.addTab(fifth_tab, "Waveform Next Gen")
-        # tab_widget.setCurrentIndex(4)
-        #
+
+        # Some buttons for layout testing
+        self.btn1 = QPushButton("Button 1")
+        self.btn2 = QPushButton("Button 2")
+        self.btn3 = QPushButton("Button 3")
+        self.btn4 = QPushButton("Button 4")
+        self.btn5 = QPushButton("Button 5")
+        self.btn6 = QPushButton("Button 6")
+
+        fifth_tab = QWidget()
+        fifth_tab_layout = QVBoxLayout(fifth_tab)
+        self.wf = Waveform()
+        fifth_tab_layout.addWidget(self.wf)
+        tab_widget.addTab(fifth_tab, "Waveform Next Gen")
+        tab_widget.setCurrentIndex(4)
+
         sixth_tab = QWidget()
         sixth_tab_layout = QVBoxLayout(sixth_tab)
-        self.im = Image(popups=True)
+        self.im = Image()
         self.mi = self.im.main_image
         sixth_tab_layout.addWidget(self.im)
         tab_widget.addTab(sixth_tab, "Image Next Gen")
-        tab_widget.setCurrentIndex(1)
-        #
-        # seventh_tab = QWidget()
-        # seventh_tab_layout = QVBoxLayout(seventh_tab)
-        # self.scatter = ScatterWaveform()
-        # self.scatter_mi = self.scatter.main_curve
-        # self.scatter.plot("samx", "samy", "bpm4i")
-        # seventh_tab_layout.addWidget(self.scatter)
-        # tab_widget.addTab(seventh_tab, "Scatter Waveform")
-        # tab_widget.setCurrentIndex(6)
-        #
-        # eighth_tab = QWidget()
-        # eighth_tab_layout = QVBoxLayout(eighth_tab)
-        # self.mm = MotorMap()
-        # eighth_tab_layout.addWidget(self.mm)
-        # tab_widget.addTab(eighth_tab, "Motor Map")
-        # tab_widget.setCurrentIndex(7)
-        #
-        # ninth_tab = QWidget()
-        # ninth_tab_layout = QVBoxLayout(ninth_tab)
-        # self.mwf = MultiWaveform()
-        # ninth_tab_layout.addWidget(self.mwf)
-        # tab_widget.addTab(ninth_tab, "MultiWaveform")
-        # tab_widget.setCurrentIndex(8)
-        #
-        # # add stuff to the new Waveform widget
-        # self._init_waveform()
-        #
-        # self.setWindowTitle("Jupyter Console Window")
+        tab_widget.setCurrentIndex(5)
+
+        seventh_tab = QWidget()
+        seventh_tab_layout = QVBoxLayout(seventh_tab)
+        self.scatter = ScatterWaveform()
+        self.scatter_mi = self.scatter.main_curve
+        self.scatter.plot("samx", "samy", "bpm4i")
+        seventh_tab_layout.addWidget(self.scatter)
+        tab_widget.addTab(seventh_tab, "Scatter Waveform")
+        tab_widget.setCurrentIndex(6)
+
+        eighth_tab = QWidget()
+        eighth_tab_layout = QVBoxLayout(eighth_tab)
+        self.mm = MotorMap()
+        eighth_tab_layout.addWidget(self.mm)
+        tab_widget.addTab(eighth_tab, "Motor Map")
+        tab_widget.setCurrentIndex(7)
+
+        ninth_tab = QWidget()
+        ninth_tab_layout = QVBoxLayout(ninth_tab)
+        self.mwf = MultiWaveform()
+        ninth_tab_layout.addWidget(self.mwf)
+        tab_widget.addTab(ninth_tab, "MultiWaveform")
+        tab_widget.setCurrentIndex(8)
+
+        # add stuff to the new Waveform widget
+        self._init_waveform()
+
+        self.setWindowTitle("Jupyter Console Window")
 
     def _init_waveform(self):
         self.wf.plot(y_name="bpm4i", y_entry="bpm4i", dap="GaussianModel")
@@ -174,7 +174,7 @@ if __name__ == "__main__":  # pragma: no cover
     icon = material_icon("terminal", color=(255, 255, 255, 255), filled=True)
     app.setWindowIcon(icon)
 
-    bec_dispatcher = BECDispatcher(gui_id="jupyter_console")
+    bec_dispatcher = BECDispatcher()
     client = bec_dispatcher.client
     client.start()
 

bec_widgets/tests/utils.py

@@ -96,9 +96,9 @@ class FakePositioner(BECPositioner):
         }
         self._info = {
             "signals": {
-                "readback": {"kind_str": "hinted"},  # hinted
-                "setpoint": {"kind_str": "normal"},  # normal
-                "velocity": {"kind_str": "config"},  # config
+                "readback": {"kind_str": "5"},  # hinted
+                "setpoint": {"kind_str": "1"},  # normal
+                "velocity": {"kind_str": "2"},  # config
             }
         }
         self.signals = {
@@ -200,13 +200,7 @@ class DMMock:
         self.devices = DeviceContainer()
         self.enabled_devices = [device for device in self.devices if device.enabled]
 
-    def add_devices(self, devices: list):
-        """
-        Add devices to the DeviceContainer.
-
-        Args:
-            devices (list): List of device instances to add.
-        """
+    def add_devives(self, devices: list):
         for device in devices:
             self.devices[device.name] = device
 

bec_widgets/utils/bec_connector.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 
 import os
 import time
-import traceback
 import uuid
 from datetime import datetime
 from typing import TYPE_CHECKING, Optional
@@ -15,7 +14,8 @@ from qtpy.QtCore import QObject, QRunnable, QThreadPool, QTimer, Signal
 from qtpy.QtWidgets import QApplication
 
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils.error_popups import ErrorPopupUtility, SafeSlot
+from bec_widgets.utils.error_popups import ErrorPopupUtility
+from bec_widgets.utils.error_popups import SafeSlot as pyqtSlot
 from bec_widgets.utils.widget_io import WidgetHierarchy
 from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui
 
@@ -85,21 +85,9 @@ class BECConnector:
         gui_id: str | None = None,
         object_name: str | None = None,
         parent_dock: BECDock | None = None,  # TODO should go away -> issue created #473
-        root_widget: bool = False,
+        parent_id: str | None = None,
         **kwargs,
     ):
-        """
-        BECConnector mixin class to handle BEC client and device manager.
-
-        Args:
-            client(BECClient, optional): The BEC client.
-            config(ConnectionConfig, optional): The connection configuration with specific gui id.
-            gui_id(str, optional): The GUI ID.
-            object_name(str, optional): The object name.
-            parent_dock(BECDock, optional): The parent dock.# TODO should go away -> issue created #473
-            root_widget(bool, optional): If set to True, the parent_id will be always set to None, thus enforcing that the widget is accessible as a root widget of the BECGuiClient object.
-            **kwargs:
-        """
         # Extract object_name from kwargs to not pass it to Qt class
         object_name = object_name or kwargs.pop("objectName", None)
         # Ensure the parent is always the first argument for QObject
@@ -111,9 +99,6 @@ class BECConnector:
             self, QObject
         ), "BECConnector must be used with a QObject or any qt related class."
 
-        # flag to check if the object was destroyed and its cleanup was called
-        self._destroyed = False
-
         # BEC related connections
         self.bec_dispatcher = BECDispatcher(client=client)
         self.client = self.bec_dispatcher.client if client is None else client
@@ -123,7 +108,7 @@ class BECConnector:
         if not self.client in BECConnector.EXIT_HANDLERS:
             # register function to clean connections at exit;
             # the function depends on BECClient, and BECDispatcher
-            @SafeSlot()
+            @pyqtSlot()
             def terminate(client=self.client, dispatcher=self.bec_dispatcher):
                 logger.info("Disconnecting", repr(dispatcher))
                 dispatcher.disconnect_all()
@@ -143,6 +128,7 @@ class BECConnector:
             )
             self.config = ConnectionConfig(widget_class=self.__class__.__name__)
 
+        self.parent_id = parent_id
         # If the gui_id is passed, it should be respected. However, this should be revisted since
         # the gui_id has to be unique, and may no longer be.
         if gui_id:
@@ -161,8 +147,10 @@ class BECConnector:
 
         # 2) Enforce unique objectName among siblings with the same BECConnector parent
         self.setParent(parent)
-        if isinstance(self.parent(), QObject) and hasattr(self, "cleanup"):
-            self.parent().destroyed.connect(self._run_cleanup_on_deleted_parent)
+        if parent_id is None:
+            connector_parent = WidgetHierarchy._get_becwidget_ancestor(self)
+            if connector_parent is not None:
+                self.parent_id = connector_parent.gui_id
 
         # Error popups
         self.error_utility = ErrorPopupUtility()
@@ -171,49 +159,6 @@ class BECConnector:
         # Store references to running workers so they're not garbage collected prematurely.
         self._workers = []
 
-        # If set to True, the parent_id will be always set to None, thus enforcing that the widget is accessible as a root widget of the BECGuiClient object.
-        self.root_widget = root_widget
-
-        QTimer.singleShot(0, self._update_object_name)
-
-    @property
-    def parent_id(self) -> str | None:
-        try:
-            if self.root_widget:
-                return None
-            connector_parent = WidgetHierarchy._get_becwidget_ancestor(self)
-            return connector_parent.gui_id if connector_parent else None
-        except:
-            logger.error(f"Error getting parent_id for {self.__class__.__name__}")
-
-    @SafeSlot()
-    def _run_cleanup_on_deleted_parent(self) -> None:
-        """
-        Run cleanup on the deleted parent.
-        This method is called when the parent is deleted.
-        """
-        if not hasattr(self, "cleanup"):
-            return
-        try:
-            if not self._destroyed:
-                self.cleanup()
-                self._destroyed = True
-        except Exception:
-            content = traceback.format_exc()
-            logger.info(
-                "Failed to run cleanup on deleted parent. "
-                f"This is not necessarily an error as the parent may be deleted before the child and includes already a cleanup. The following exception was raised:\n{content}"
-            )
-
-    def change_object_name(self, name: str) -> None:
-        """
-        Change the object name of the widget. Unregister old name and register the new one.
-
-        Args:
-            name (str): The new object name.
-        """
-        self.rpc_register.remove_rpc(self)
-        self.setObjectName(name.replace("-", "_").replace(" ", "_"))
         QTimer.singleShot(0, self._update_object_name)
 
     def _update_object_name(self) -> None:
@@ -283,7 +228,7 @@ class BECConnector:
         if self.rpc_register.object_is_registered(self):
             self.rpc_register.broadcast()
 
-    def submit_task(self, fn, *args, on_complete: SafeSlot = None, **kwargs) -> Worker:
+    def submit_task(self, fn, *args, on_complete: pyqtSlot = None, **kwargs) -> Worker:
         """
         Submit a task to run in a separate thread. The task will run the specified
         function with the provided arguments and emit the completed signal when done.
@@ -411,7 +356,7 @@ class BECConnector:
             file_path = os.path.join(path, f"{self.__class__.__name__}_config.yaml")
             save_yaml(file_path, self._config_dict)
 
-    # @SafeSlot(str)
+    # @pyqtSlot(str)
     def _set_gui_id(self, gui_id: str) -> None:
         """
         Set the GUI ID for the widget.
@@ -443,7 +388,7 @@ class BECConnector:
         self.client = client
         self.get_bec_shortcuts()
 
-    @SafeSlot(ConnectionConfig)  # TODO can be also dict
+    @pyqtSlot(ConnectionConfig)  # TODO can be also dict
     def on_config_update(self, config: ConnectionConfig | dict) -> None:
         """
         Update the configuration for the widget.

bec_widgets/utils/bec_designer.py

@@ -16,9 +16,9 @@ if PYSIDE6:
     from PySide6.scripts.pyside_tool import (
         _extend_path_var,
         init_virtual_env,
+        qt_tool_wrapper,
         is_pyenv_python,
         is_virtual_env,
-        qt_tool_wrapper,
         ui_tool_binary,
     )
 
@@ -78,7 +78,7 @@ def list_editable_packages() -> set[str]:
     return editable_packages
 
 
-def patch_designer(cmd_args: list[str] = []):  # pragma: no cover
+def patch_designer():  # pragma: no cover
     if not PYSIDE6:
         print("PYSIDE6 is not available in the environment. Cannot patch designer.")
         return
@@ -119,7 +119,7 @@ def patch_designer(cmd_args: list[str] = []):  # pragma: no cover
             editable_packages = list_editable_packages()
             for pckg in editable_packages:
                 _extend_path_var("PYTHONPATH", pckg, True)
-    qt_tool_wrapper(ui_tool_binary("designer"), cmd_args)
+    qt_tool_wrapper(ui_tool_binary("designer"), sys.argv[1:])
 
 
 def find_plugin_paths(base_path: Path):
@@ -147,7 +147,7 @@ def set_plugin_environment_variable(plugin_paths):
 
 
 # Patch the designer function
-def open_designer(cmd_args: list[str] = []):  # pragma: no cover
+def main():  # pragma: no cover
     if not PYSIDE6:
         print("PYSIDE6 is not available in the environment. Exiting...")
         return
@@ -160,11 +160,7 @@ def open_designer(cmd_args: list[str] = []):  # pragma: no cover
 
     set_plugin_environment_variable(plugin_paths)
 
-    patch_designer(cmd_args)
-
-
-def main():
-    open_designer(sys.argv[1:])
+    patch_designer()
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/utils/bec_dispatcher.py

@@ -4,9 +4,8 @@ import collections
 import random
 import string
 from collections.abc import Callable
-from typing import TYPE_CHECKING, DefaultDict, Hashable, Union
+from typing import TYPE_CHECKING, Union
 
-import louie
 import redis
 from bec_lib.client import BECClient
 from bec_lib.logger import bec_logger
@@ -15,52 +14,30 @@ from bec_lib.service_config import ServiceConfig
 from qtpy.QtCore import QObject
 from qtpy.QtCore import Signal as pyqtSignal
 
-from bec_widgets.utils.serialization import register_serializer_extension
-
 logger = bec_logger.logger
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from bec_lib.endpoints import EndpointInfo
 
     from bec_widgets.utils.rpc_server import RPCServer
 
 
 class QtThreadSafeCallback(QObject):
-    """QtThreadSafeCallback is a wrapper around a callback function to make it thread-safe for Qt."""
-
     cb_signal = pyqtSignal(dict, dict)
 
-    def __init__(self, cb: Callable, cb_info: dict | None = None):
-        """
-        Initialize the QtThreadSafeCallback.
-
-        Args:
-            cb (Callable): The callback function to be wrapped.
-            cb_info (dict, optional): Additional information about the callback. Defaults to None.
-        """
+    def __init__(self, cb):
         super().__init__()
-        self.cb_info = cb_info
 
         self.cb = cb
-        self.cb_ref = louie.saferef.safe_ref(cb)
         self.cb_signal.connect(self.cb)
-        self.topics = set()
 
     def __hash__(self):
         # make 2 differents QtThreadSafeCallback to look
         # identical when used as dictionary keys, if the
         # callback is the same
-        return f"{id(self.cb_ref)}{self.cb_info}".__hash__()
-
-    def __eq__(self, other):
-        if not isinstance(other, QtThreadSafeCallback):
-            return False
-        return self.cb_ref == other.cb_ref and self.cb_info == other.cb_info
+        return id(self.cb)
 
     def __call__(self, msg_content, metadata):
-        if self.cb_ref() is None:
-            # callback has been deleted
-            return
         self.cb_signal.emit(msg_content, metadata)
 
 
@@ -107,7 +84,7 @@ class BECDispatcher:
         cls,
         client=None,
         config: str | ServiceConfig | None = None,
-        gui_id: str | None = None,
+        gui_id: str = None,
         *args,
         **kwargs,
     ):
@@ -120,9 +97,7 @@ class BECDispatcher:
         if self._initialized:
             return
 
-        self._registered_slots: DefaultDict[Hashable, QtThreadSafeCallback] = (
-            collections.defaultdict()
-        )
+        self._slots = collections.defaultdict(set)
         self.client = client
 
         if self.client is None:
@@ -145,8 +120,6 @@ class BECDispatcher:
         except redis.exceptions.ConnectionError:
             logger.warning("Could not connect to Redis, skipping start of BECClient.")
 
-        register_serializer_extension()
-
         logger.success("Initialized BECDispatcher")
 
         self.start_cli_server(gui_id=gui_id)
@@ -164,7 +137,6 @@ class BECDispatcher:
         self,
         slot: Callable,
         topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]],
-        cb_info: dict | None = None,
         **kwargs,
     ) -> None:
         """Connect widget's qt slot, so that it is called on new pub/sub topic message.
@@ -173,15 +145,11 @@ class BECDispatcher:
             slot (Callable): A slot method/function that accepts two inputs: content and metadata of
                 the corresponding pub/sub message
             topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
-            cb_info (dict | None): A dictionary containing information about the callback. Defaults to None.
         """
-        qt_slot = QtThreadSafeCallback(cb=slot, cb_info=cb_info)
-        if qt_slot not in self._registered_slots:
-            self._registered_slots[qt_slot] = qt_slot
-        qt_slot = self._registered_slots[qt_slot]
-        self.client.connector.register(topics, cb=qt_slot, **kwargs)
+        slot = QtThreadSafeCallback(slot)
+        self.client.connector.register(topics, cb=slot, **kwargs)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        qt_slot.topics.update(set(topics_str))
+        self._slots[slot].update(set(topics_str))
 
     def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
         """
@@ -194,16 +162,16 @@ class BECDispatcher:
         # find the right slot to disconnect from ;
         # slot callbacks are wrapped in QtThreadSafeCallback objects,
         # but the slot we receive here is the original callable
-        for connected_slot in self._registered_slots.values():
+        for connected_slot in self._slots:
             if connected_slot.cb == slot:
                 break
         else:
             return
         self.client.connector.unregister(topics, cb=connected_slot)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        self._registered_slots[connected_slot].topics.difference_update(set(topics_str))
-        if not self._registered_slots[connected_slot].topics:
-            del self._registered_slots[connected_slot]
+        self._slots[connected_slot].difference_update(set(topics_str))
+        if not self._slots[connected_slot]:
+            del self._slots[connected_slot]
 
     def disconnect_topics(self, topics: Union[str, list]):
         """
@@ -214,16 +182,11 @@ class BECDispatcher:
         """
         self.client.connector.unregister(topics)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-
-        remove_slots = []
-        for connected_slot in self._registered_slots.values():
-            connected_slot.topics.difference_update(set(topics_str))
-
-            if not connected_slot.topics:
-                remove_slots.append(connected_slot)
-
-        for connected_slot in remove_slots:
-            self._registered_slots.pop(connected_slot, None)
+        for slot in list(self._slots.keys()):
+            slot_topics = self._slots[slot]
+            slot_topics.difference_update(set(topics_str))
+            if not slot_topics:
+                del self._slots[slot]
 
     def disconnect_all(self, *args, **kwargs):
         """

bec_widgets/utils/bec_plugin_helper.py

@@ -21,7 +21,7 @@ def _submodule_specs(module: ModuleType) -> tuple[ModuleSpec | None, ...]:
 
 
 def _loaded_submodules_from_specs(
-    submodule_specs: tuple[ModuleSpec | None, ...],
+    submodule_specs: tuple[ModuleSpec | None, ...]
 ) -> Generator[ModuleType, None, None]:
     """Load all submodules from the given specs."""
     for submodule in (

bec_widgets/utils/bec_signal_proxy.py

@@ -1,6 +1,6 @@
-"""This custom class is a thin wrapper around the SignalProxy class to allow signal calls to be blocked.
+""" This custom class is a thin wrapper around the SignalProxy class to allow signal calls to be blocked.
 Unblocking the proxy needs to be done through the slot unblock_proxy. The most likely use case for this class is
-when the callback function is potentially initiating a slower progress, i.e. requesting a data analysis routine to
+when the callback function is potentially initiating a slower progress, i.e. requesting a data analysis routine to 
 analyse data. Requesting a new fit may lead to request piling up and an overall slow done of performance. This proxy
 will allow you to decide by yourself when to unblock and execute the callback again."""
 

bec_widgets/utils/bec_widget.py

@@ -33,6 +33,7 @@ class BECWidget(BECConnector):
         gui_id: str | None = None,
         theme_update: bool = False,
         parent_dock: BECDock | None = None,  # TODO should go away -> issue created #473
+        parent_id: str | None = None,
         **kwargs,
     ):
         """
@@ -54,7 +55,12 @@ class BECWidget(BECConnector):
         """
 
         super().__init__(
-            client=client, config=config, gui_id=gui_id, parent_dock=parent_dock, **kwargs
+            client=client,
+            config=config,
+            gui_id=gui_id,
+            parent_dock=parent_dock,
+            parent_id=parent_id,
+            **kwargs,
         )
         if not isinstance(self, QObject):
             raise RuntimeError(f"{repr(self)} is not a subclass of QWidget")
@@ -106,8 +112,6 @@ class BECWidget(BECConnector):
     def closeEvent(self, event):
         """Wrap the close even to ensure the rpc_register is cleaned up."""
         try:
-            if not self._destroyed:
-                self.cleanup()
-                self._destroyed = True
+            self.cleanup()
         finally:
             super().closeEvent(event)  # pylint: disable=no-member

bec_widgets/utils/colors.py

@@ -11,7 +11,7 @@ from pydantic_core import PydanticCustomError
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QApplication
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from bec_qthemes._main import AccentColors
 
 

bec_widgets/utils/compact_popup.py

@@ -266,5 +266,3 @@ class CompactPopupWidget(QWidget):
         # to ensure proper resources cleanup
         for child in self.container.findChildren(QWidget, options=Qt.FindDirectChildrenOnly):
             child.close()
-
-        super().closeEvent(event)

bec_widgets/utils/container_utils.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-from typing import Any, Type
+import itertools
+from typing import Literal, Type
 
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.cli.client_utils import BECGuiClient
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
 
 
 class WidgetContainerUtils:
@@ -72,36 +73,3 @@ class WidgetContainerUtils:
             return None
         else:
             raise ValueError(f"No widget of class {widget_class} found.")
-
-    @staticmethod
-    def name_is_protected(name: str, container: Any = None) -> bool:
-        """
-        Check if the name is not protected.
-
-        Args:
-            name(str): The name to be checked.
-
-        Returns:
-            bool: True if the name is not protected, False otherwise.
-        """
-        if container is None:
-            container = BECGuiClient
-        gui_client_methods = set(filter(lambda x: not x.startswith("_"), dir(container)))
-        return name in gui_client_methods
-
-    @staticmethod
-    def raise_for_invalid_name(name: str, container: Any = None) -> None:
-        """
-        Check if the name is valid. If not, raise a ValueError.
-
-        Args:
-            name(str): The name to be checked.
-        Raises:
-            ValueError: If the name is not valid.
-        """
-        if not WidgetContainerUtils.has_name_valid_chars(name):
-            raise ValueError(
-                f"Name '{name}' contains invalid characters. Only alphanumeric characters, underscores, and dashes are allowed."
-            )
-        if WidgetContainerUtils.name_is_protected(name, container):
-            raise ValueError(f"Name '{name}' is protected. Please choose another name.")

bec_widgets/utils/crosshair.py

@@ -85,8 +85,7 @@ class Crosshair(QObject):
         self.items = []
         self.marker_moved_1d = {}
         self.marker_clicked_1d = {}
-        self.marker_2d_row = None
-        self.marker_2d_col = None
+        self.marker_2d = None
         self.update_markers()
         self.check_log()
         self.check_derivatives()
@@ -196,23 +195,13 @@ class Crosshair(QObject):
                         marker_clicked_list.append(marker_clicked)
                     self.marker_clicked_1d[name] = marker_clicked_list
             elif isinstance(item, pg.ImageItem):  # 2D plot
-                if self.marker_2d_row is not None and self.marker_2d_col is not None:
+                if self.marker_2d is not None:
                     continue
-                # Create horizontal ROI for row highlighting
-                if item.image is None:
-                    continue
-                self.marker_2d_row = pg.ROI(
-                    [0, 0], size=[item.image.shape[0], 1], pen=pg.mkPen("r", width=2), movable=False
+                self.marker_2d = pg.ROI(
+                    [0, 0], size=[1, 1], pen=pg.mkPen("r", width=2), movable=False
                 )
-                self.marker_2d_row.skip_auto_range = True
-                self.plot_item.addItem(self.marker_2d_row)
-
-                # Create vertical ROI for column highlighting
-                self.marker_2d_col = pg.ROI(
-                    [0, 0], size=[1, item.image.shape[1]], pen=pg.mkPen("r", width=2), movable=False
-                )
-                self.marker_2d_col.skip_auto_range = True
-                self.plot_item.addItem(self.marker_2d_col)
+                self.marker_2d.skip_auto_range = True
+                self.plot_item.addItem(self.marker_2d)
 
     def snap_to_data(
         self, x: float, y: float
@@ -254,8 +243,6 @@ class Crosshair(QObject):
             elif isinstance(item, pg.ImageItem):  # 2D plot
                 name = item.config.monitor or str(id(item))
                 image_2d = item.image
-                if image_2d is None:
-                    continue
                 # Clip the x and y values to the image dimensions to avoid out of bounds errors
                 y_values[name] = int(np.clip(y, 0, image_2d.shape[1] - 1))
                 x_values[name] = int(np.clip(x, 0, image_2d.shape[0] - 1))
@@ -343,10 +330,7 @@ class Crosshair(QObject):
                     x, y = x_snap_values[name], y_snap_values[name]
                     if x is None or y is None:
                         continue
-                    # Set position of horizontal ROI (row)
-                    self.marker_2d_row.setPos([0, y])
-                    # Set position of vertical ROI (column)
-                    self.marker_2d_col.setPos([x, 0])
+                    self.marker_2d.setPos([x, y])
                     coordinate_to_emit = (name, x, y)
                     self.coordinatesChanged2D.emit(coordinate_to_emit)
                 else:
@@ -400,10 +384,7 @@ class Crosshair(QObject):
                     x, y = x_snap_values[name], y_snap_values[name]
                     if x is None or y is None:
                         continue
-                    # Set position of horizontal ROI (row)
-                    self.marker_2d_row.setPos([0, y])
-                    # Set position of vertical ROI (column)
-                    self.marker_2d_col.setPos([x, 0])
+                    self.marker_2d.setPos([x, y])
                     coordinate_to_emit = (name, x, y)
                     self.coordinatesClicked2D.emit(coordinate_to_emit)
                 else:
@@ -447,8 +428,6 @@ class Crosshair(QObject):
         for item in self.items:
             if isinstance(item, pg.ImageItem):
                 image = item.image
-                if image is None:
-                    continue
                 ix = int(np.clip(x, 0, image.shape[0] - 1))
                 iy = int(np.clip(y, 0, image.shape[1] - 1))
                 intensity = image[ix, iy]
@@ -471,12 +450,9 @@ class Crosshair(QObject):
         self.clear_markers()
 
     def cleanup(self):
-        if self.marker_2d_row is not None:
-            self.plot_item.removeItem(self.marker_2d_row)
-            self.marker_2d_row = None
-        if self.marker_2d_col is not None:
-            self.plot_item.removeItem(self.marker_2d_col)
-            self.marker_2d_col = None
+        if self.marker_2d is not None:
+            self.plot_item.removeItem(self.marker_2d)
+            self.marker_2d = None
         self.plot_item.removeItem(self.v_line)
         self.plot_item.removeItem(self.h_line)
         self.plot_item.removeItem(self.coord_label)

bec_widgets/utils/entry_validator.py

@@ -17,23 +17,13 @@ class EntryValidator:
             raise ValueError(f"Device '{name}' not found in current BEC session")
 
         device = self.devices[name]
-
-        # Build list of available signal entries from device._info['signals']
-        signals_dict = getattr(device, "_info", {}).get("signals", {})
-        available_entries = [
-            sig.get("obj_name") for sig in signals_dict.values() if sig.get("obj_name")
-        ]
-
-        # If no signals are found, means device is a signal, use the device name as the entry
-        if not available_entries:
-            available_entries = [name]
+        description = device.describe()
 
         if entry is None or entry == "":
             entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
-        if entry not in available_entries:
+        if entry not in description:
             raise ValueError(
-                f"Entry '{entry}' not found in device '{name}' signals. "
-                f"Available signals: '{available_entries}'"
+                f"Entry '{entry}' not found in device '{name}' signals. Available signals: {description.keys()}"
             )
 
         return entry

bec_widgets/utils/error_popups.py

@@ -96,55 +96,23 @@ def SafeSlot(*slot_args, **slot_kwargs):  # pylint: disable=invalid-name
 
     'popup_error' keyword argument can be passed with boolean value if a dialog should pop up,
     otherwise error display is left to the original exception hook
-    'verify_sender' keyword argument can be passed with boolean value if the sender should be verified
-    before executing the slot. If True, the slot will only execute if the sender is a QObject. This is
-    useful to prevent function calls from already deleted objects.
-    'raise_error' keyword argument can be passed with boolean value if the error should be raised
-    after the error is displayed. This is useful to propagate the error to the caller but should be used
-    with great care to avoid segfaults.
-
-    The keywords above are stored in a container which can be overridden by passing
-    '_override_slot_params' keyword argument with a dictionary containing the keywords to override.
-    This is useful to override the default behavior of the decorator for a specific function call.
-
     """
-    _slot_params = {
-        "popup_error": bool(slot_kwargs.pop("popup_error", False)),
-        "verify_sender": bool(slot_kwargs.pop("verify_sender", False)),
-        "raise_error": bool(slot_kwargs.pop("raise_error", False)),
-    }
+    popup_error = bool(slot_kwargs.pop("popup_error", False))
 
     def error_managed(method):
         @Slot(*slot_args, **slot_kwargs)
         @functools.wraps(method)
         def wrapper(*args, **kwargs):
-
-            _override_slot_params = kwargs.pop("_override_slot_params", {})
-            _slot_params.update(_override_slot_params)
             try:
-                if not _slot_params["verify_sender"] or len(args) == 0:
-                    return method(*args, **kwargs)
-
-                _instance = args[0]
-                if not isinstance(_instance, QObject):
-                    return method(*args, **kwargs)
-                sender = _instance.sender()
-                if sender is None:
-                    logger.info(
-                        f"Sender is None for {method.__module__}.{method.__qualname__}, "
-                        "skipping method call."
-                    )
-                    return
                 return method(*args, **kwargs)
-
             except Exception:
                 slot_name = f"{method.__module__}.{method.__qualname__}"
                 error_msg = traceback.format_exc()
-                if _slot_params["popup_error"]:
-                    ErrorPopupUtility().custom_exception_hook(*sys.exc_info(), popup_error=True)
+                if popup_error:
+                    ErrorPopupUtility().custom_exception_hook(
+                        *sys.exc_info(), popup_error=popup_error
+                    )
                 logger.error(f"SafeSlot error in slot '{slot_name}':\n{error_msg}")
-                if _slot_params["raise_error"]:
-                    raise
 
         return wrapper
 

bec_widgets/utils/expandable_frame.py

@@ -37,7 +37,7 @@ class ExpandableGroupFrame(QFrame):
         self._title_layout.addWidget(self._expansion_button)
         self._title_layout.addWidget(self._title)
 
-        self._contents = QWidget(self)
+        self._contents = QWidget()
         self._layout.addWidget(self._contents)
 
         self._expansion_button.clicked.connect(self.switch_expanded_state)

bec_widgets/utils/forms_from_types/forms.py

@@ -1,182 +0,0 @@
-from __future__ import annotations
-
-from decimal import Decimal
-from types import NoneType
-
-from bec_lib.logger import bec_logger
-from bec_qthemes import material_icon
-from pydantic import BaseModel, ValidationError
-from qtpy.QtCore import Signal  # type: ignore
-from qtpy.QtWidgets import QGridLayout, QLabel, QLayout, QVBoxLayout, QWidget
-
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.compact_popup import CompactPopupWidget
-from bec_widgets.utils.forms_from_types.items import FormItemSpec, widget_from_type
-
-logger = bec_logger.logger
-
-
-class TypedForm(BECWidget, QWidget):
-    PLUGIN = True
-    ICON_NAME = "list_alt"
-
-    value_changed = Signal()
-
-    RPC = False
-
-    def __init__(
-        self,
-        parent=None,
-        items: list[tuple[str, type]] | None = None,
-        form_item_specs: list[FormItemSpec] | None = None,
-        client=None,
-        **kwargs,
-    ):
-        """Widget with a list of form items based on a list of types.
-
-        Args:
-            items (list[tuple[str, type]]): list of tuples of a name for the field and its type.
-                                            Should be a type supported by the logic in items.py
-            form_item_specs (list[FormItemSpec]): list of form item specs, equivalent to items.
-                                                  only one of items or form_item_specs should be
-                                                  supplied.
-
-        """
-        if (items is not None and form_item_specs is not None) or (
-            items is None and form_item_specs is None
-        ):
-            raise ValueError("Must specify one and only one of items and form_item_specs")
-        super().__init__(parent=parent, client=client, **kwargs)
-        self._items = (
-            form_item_specs
-            if form_item_specs is not None
-            else [
-                FormItemSpec(name=name, item_type=item_type)
-                for name, item_type in items  # type: ignore
-            ]
-        )
-        self._layout = QVBoxLayout()
-        self._layout.setContentsMargins(0, 0, 0, 0)
-        self.setLayout(self._layout)
-
-        self._form_grid_container = QWidget(parent=self)
-        self._form_grid = QWidget(parent=self._form_grid_container)
-        self._layout.addWidget(self._form_grid_container)
-        self._form_grid_container.setLayout(QVBoxLayout())
-        self._form_grid.setLayout(self._new_grid_layout())
-
-        self.populate()
-
-    def populate(self):
-        self._clear_grid()
-        for r, item in enumerate(self._items):
-            self._add_griditem(item, r)
-
-    def _add_griditem(self, item: FormItemSpec, row: int):
-        grid = self._form_grid.layout()
-        label = QLabel(item.name)
-        label.setProperty("_model_field_name", item.name)
-        label.setToolTip(item.info.description or item.name)
-        grid.addWidget(label, row, 0)
-        widget = widget_from_type(item.item_type)(parent=self, spec=item)
-        widget.valueChanged.connect(self.value_changed)
-        grid.addWidget(widget, row, 1)
-
-    def _dict_from_grid(self) -> dict[str, str | int | float | Decimal | bool]:
-        grid: QGridLayout = self._form_grid.layout()  # type: ignore
-        return {
-            grid.itemAtPosition(i, 0)
-            .widget()
-            .property("_model_field_name"): grid.itemAtPosition(i, 1)
-            .widget()
-            .getValue()  # type: ignore # we only add 'DynamicFormItem's here
-            for i in range(grid.rowCount())
-        }
-
-    def _clear_grid(self):
-        if (old_layout := self._form_grid.layout()) is not None:
-            while old_layout.count():
-                item = old_layout.takeAt(0)
-                widget = item.widget()
-                if widget is not None:
-                    widget.deleteLater()
-            old_layout.deleteLater()
-            self._form_grid.deleteLater()
-        self._form_grid = QWidget()
-
-        self._form_grid.setLayout(self._new_grid_layout())
-        self._form_grid_container.layout().addWidget(self._form_grid)
-
-        self._form_grid.adjustSize()
-        self._form_grid_container.adjustSize()
-        self.adjustSize()
-
-    def _new_grid_layout(self):
-        new_grid = QGridLayout()
-        new_grid.setContentsMargins(0, 0, 0, 0)
-        new_grid.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
-        return new_grid
-
-
-class PydanticModelForm(TypedForm):
-    metadata_updated = Signal(dict)
-    metadata_cleared = Signal(NoneType)
-
-    def __init__(self, parent=None, metadata_model: type[BaseModel] = None, client=None, **kwargs):
-        """
-        A form generated from a pydantic model.
-
-        Args:
-            metadata_model (type[BaseModel]): the model class for which to generate a form.
-        """
-        self._md_schema = metadata_model
-        super().__init__(parent=parent, form_item_specs=self._form_item_specs(), client=client)
-
-        self._validity = CompactPopupWidget()
-        self._validity.compact_view = True  # type: ignore
-        self._validity.label = "Metadata validity"  # type: ignore
-        self._validity.compact_show_popup.setIcon(
-            material_icon(icon_name="info", size=(10, 10), convert_to_pixmap=False)
-        )
-        self._validity_message = QLabel("Not yet validated")
-        self._validity.addWidget(self._validity_message)
-        self._layout.addWidget(self._validity)
-        self.value_changed.connect(self.validate_form)
-
-    def set_schema(self, schema: type[BaseModel]):
-        self._md_schema = schema
-        self.populate()
-
-    def _form_item_specs(self):
-        return [
-            FormItemSpec(name=name, info=info, item_type=info.annotation)
-            for name, info in self._md_schema.model_fields.items()
-        ]
-
-    def update_items_from_schema(self):
-        self._items = self._form_item_specs()
-
-    def populate(self):
-        self.update_items_from_schema()
-        super().populate()
-
-    def get_form_data(self):
-        """Get the entered metadata as a dict."""
-        return self._dict_from_grid()
-
-    def validate_form(self, *_) -> bool:
-        """validate the currently entered metadata against the pydantic schema.
-        If successful, returns on metadata_emitted and returns true.
-        Otherwise, emits on metadata_cleared and returns false."""
-        try:
-            metadata_dict = self.get_form_data()
-            self._md_schema.model_validate(metadata_dict)
-            self._validity.set_global_state("success")
-            self._validity_message.setText("No errors!")
-            self.metadata_updated.emit(metadata_dict)
-            return True
-        except ValidationError as e:
-            self._validity.set_global_state("emergency")
-            self._validity_message.setText(str(e))
-            self.metadata_cleared.emit(None)
-            return False

bec_widgets/utils/generate_designer_plugin.py

@@ -5,8 +5,6 @@ from typing import NamedTuple
 
 from qtpy.QtCore import QObject
 
-from bec_widgets.utils.name_utils import pascal_to_snake
-
 EXCLUDED_PLUGINS = ["BECConnector", "BECDockArea", "BECDock", "BECFigure"]
 
 
@@ -24,7 +22,7 @@ class DesignerPluginInfo:
     def __init__(self, plugin_class):
         self.plugin_class = plugin_class
         self.plugin_name_pascal = plugin_class.__name__
-        self.plugin_name_snake = pascal_to_snake(self.plugin_name_pascal)
+        self.plugin_name_snake = self.pascal_to_snake(self.plugin_name_pascal)
         self.widget_import = f"from {plugin_class.__module__} import {self.plugin_name_pascal}"
         plugin_module = (
             ".".join(plugin_class.__module__.split(".")[:-1]) + f".{self.plugin_name_snake}_plugin"
@@ -40,6 +38,21 @@ class DesignerPluginInfo:
 
         self.base_path = os.path.dirname(inspect.getfile(plugin_class))
 
+    @staticmethod
+    def pascal_to_snake(name: str) -> str:
+        """
+        Convert PascalCase to snake_case.
+
+        Args:
+            name (str): The name to be converted.
+
+        Returns:
+            str: The converted name.
+        """
+        s1 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+        s2 = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", s1)
+        return s2.lower()
+
 
 class DesignerPluginGenerator:
     def __init__(self, widget: type):
@@ -109,16 +122,6 @@ class DesignerPluginGenerator:
                 or bool(init_source.find("super().__init__(parent)") > 0)
             )
 
-        # for the new style classes, we only have one super call. We can therefore check if the
-        # number of __init__ calls is 2 (the class itself and the super class)
-        num_inits = re.findall(r"__init__", init_source)
-        if len(num_inits) == 2 and not super_init_found:
-            super_init_found = bool(
-                init_source.find("super().__init__(parent=parent") > 0
-                or init_source.find("super().__init__(parent,") > 0
-                or init_source.find("super().__init__(parent)") > 0
-            )
-
         if not cls_init_found and not super_init_found:
             raise ValueError(
                 f"Widget class {self.widget.__name__} must call the super constructor with parent."

bec_widgets/utils/linear_region_selector.py

@@ -1,7 +1,5 @@
-"""Module for a thin wrapper (LinearRegionWrapper) around the LinearRegionItem in pyqtgraph.
-The class is mainly designed for usage with the BECWaveform and 1D plots."""
-
-from __future__ import annotations
+""" Module for a thin wrapper (LinearRegionWrapper) around the LinearRegionItem in pyqtgraph.
+The class is mainly designed for usage with the BECWaveform and 1D plots. """
 
 import pyqtgraph as pg
 from qtpy.QtCore import QObject, Signal, Slot

bec_widgets/utils/name_utils.py

@@ -1,16 +0,0 @@
-import re
-
-
-def pascal_to_snake(name: str) -> str:
-    """
-    Convert PascalCase to snake_case.
-
-    Args:
-        name (str): The name to be converted.
-
-    Returns:
-        str: The converted name.
-    """
-    s1 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
-    s2 = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", s1)
-    return s2.lower()

bec_widgets/utils/rpc_server.py

@@ -18,9 +18,8 @@ from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.utils.error_popups import ErrorPopupUtility
-from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from bec_lib import messages
     from qtpy.QtCore import QObject
 else:
@@ -84,7 +83,6 @@ class RPCServer:
         self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
         self._heartbeat_timer.start(200)
         self._registry_update_callbacks = []
-        self._broadcasted_data = {}
 
         self.status = messages.BECStatus.RUNNING
         logger.success(f"Server started with gui_id: {self.gui_id}")
@@ -191,9 +189,6 @@ class RPCServer:
             if not getattr(val, "RPC", True):
                 continue
             data[key] = self._serialize_bec_connector(val)
-        if self._broadcasted_data == data:
-            return
-        self._broadcasted_data = data
 
         logger.info(f"Broadcasting registry update: {data} for {self.gui_id}")
         self.client.connector.xadd(
@@ -217,15 +212,6 @@ class RPCServer:
         config_dict = connector.config.model_dump()
         config_dict["parent_id"] = getattr(connector, "parent_id", None)
 
-        try:
-            parent = connector.parent()
-            if isinstance(parent, BECMainWindow):
-                container_proxy = parent.gui_id
-            else:
-                container_proxy = None
-        except Exception:
-            container_proxy = None
-
         if wait:
             while not self.rpc_register.object_is_registered(connector):
                 QApplication.processEvents()
@@ -239,7 +225,6 @@ class RPCServer:
             "object_name": connector.object_name or connector.__class__.__name__,
             "widget_class": widget_class,
             "config": config_dict,
-            "container_proxy": container_proxy,
             "__rpc__": True,
         }
 

bec_widgets/utils/serialization.py

@@ -1,44 +0,0 @@
-from bec_lib.serialization import msgpack
-from qtpy.QtCore import QPointF
-
-
-def register_serializer_extension():
-    """
-    Register the serializer extension for the BECConnector.
-    """
-    if not module_is_registered("bec_widgets.utils.serialization"):
-        msgpack.register_object_hook(encode_qpointf, decode_qpointf)
-
-
-def module_is_registered(module_name: str) -> bool:
-    """
-    Check if the module is registered in the encoder.
-
-    Args:
-        module_name (str): The name of the module to check.
-
-    Returns:
-        bool: True if the module is registered, False otherwise.
-    """
-    # pylint: disable=protected-access
-    for enc in msgpack._encoder:
-        if enc[0].__module__ == module_name:
-            return True
-    return False
-
-
-def encode_qpointf(obj):
-    """
-    Encode a QPointF object to a list of floats. As this is mostly used for sending
-    data to the client, it is not necessary to convert it back to a QPointF object.
-    """
-    if isinstance(obj, QPointF):
-        return [obj.x(), obj.y()]
-    return obj
-
-
-def decode_qpointf(obj):
-    """
-    no-op function since QPointF is encoded as a list of floats.
-    """
-    return obj

bec_widgets/utils/side_panel.py

@@ -31,7 +31,6 @@ class SidePanel(QWidget):
         panel_max_width: int = 200,
         animation_duration: int = 200,
         animations_enabled: bool = True,
-        show_toolbar: bool = True,
     ):
         super().__init__(parent=parent)
 
@@ -41,7 +40,6 @@ class SidePanel(QWidget):
         self._panel_max_width = panel_max_width
         self._animation_duration = animation_duration
         self._animations_enabled = animations_enabled
-        self._show_toolbar = show_toolbar
 
         self._panel_width = 0
         self._panel_height = 0
@@ -61,7 +59,7 @@ class SidePanel(QWidget):
             self.main_layout.setContentsMargins(0, 0, 0, 0)
             self.main_layout.setSpacing(0)
 
-            self.toolbar = ModularToolBar(parent=self, target_widget=self, orientation="vertical")
+            self.toolbar = ModularToolBar(target_widget=self, orientation="vertical")
 
             self.container = QWidget()
             self.container.layout = QVBoxLayout(self.container)
@@ -73,14 +71,13 @@ class SidePanel(QWidget):
             self.stack_widget.setMinimumWidth(5)
             self.stack_widget.setMaximumWidth(self._panel_max_width)
 
-            if self._orientation in ("left", "right"):
-                if self._show_toolbar:
-                    self.main_layout.addWidget(self.toolbar)
+            if self._orientation == "left":
+                self.main_layout.addWidget(self.toolbar)
+                self.main_layout.addWidget(self.container)
+            else:
+                self.main_layout.addWidget(self.container)
+                self.main_layout.addWidget(self.toolbar)
 
-                if self._orientation == "left":
-                    self.main_layout.addWidget(self.container)
-                else:
-                    self.main_layout.insertWidget(0, self.container)
             self.container.layout.addWidget(self.stack_widget)
 
             self.menu_anim = QPropertyAnimation(self, b"panel_width")
@@ -92,7 +89,7 @@ class SidePanel(QWidget):
             self.main_layout.setContentsMargins(0, 0, 0, 0)
             self.main_layout.setSpacing(0)
 
-            self.toolbar = ModularToolBar(parent=self, target_widget=self, orientation="horizontal")
+            self.toolbar = ModularToolBar(target_widget=self, orientation="horizontal")
 
             self.container = QWidget()
             self.container.layout = QVBoxLayout(self.container)
@@ -105,13 +102,11 @@ class SidePanel(QWidget):
             self.stack_widget.setMaximumHeight(self._panel_max_width)
 
             if self._orientation == "top":
-                if self._show_toolbar:
-                    self.main_layout.addWidget(self.toolbar)
+                self.main_layout.addWidget(self.toolbar)
                 self.main_layout.addWidget(self.container)
             else:
                 self.main_layout.addWidget(self.container)
-                if self._show_toolbar:
-                    self.main_layout.addWidget(self.toolbar)
+                self.main_layout.addWidget(self.toolbar)
 
             self.container.layout.addWidget(self.stack_widget)
 
@@ -238,24 +233,21 @@ class SidePanel(QWidget):
 
     def add_menu(
         self,
+        action_id: str,
+        icon_name: str,
+        tooltip: str,
         widget: QWidget,
-        action_id: str | None = None,
-        icon_name: str | None = None,
-        tooltip: str | None = None,
         title: str | None = None,
-    ) -> int:
+    ):
         """
         Add a menu to the side panel.
 
         Args:
+            action_id(str): The ID of the action.
+            icon_name(str): The name of the icon.
+            tooltip(str): The tooltip for the action.
             widget(QWidget): The widget to add to the panel.
-            action_id(str | None): The ID of the action. Optional if no toolbar action is needed.
-            icon_name(str | None): The name of the icon. Optional if no toolbar action is needed.
-            tooltip(str | None): The tooltip for the action. Optional if no toolbar action is needed.
-            title(str | None): The title of the panel.
-
-        Returns:
-            int: The index of the added panel, which can be used with show_panel() and switch_to().
+            title(str): The title of the panel.
         """
         # container_widget: top-level container for the stacked page
         container_widget = QWidget()
@@ -286,35 +278,32 @@ class SidePanel(QWidget):
         index = self.stack_widget.count()
         self.stack_widget.addWidget(container_widget)
 
-        # Add an action to the toolbar if action_id, icon_name, and tooltip are provided
-        if action_id is not None and icon_name is not None and tooltip is not None:
-            action = MaterialIconAction(icon_name=icon_name, tooltip=tooltip, checkable=True)
-            self.toolbar.add_action(action_id, action, target_widget=self)
+        # Add an action to the toolbar
+        action = MaterialIconAction(icon_name=icon_name, tooltip=tooltip, checkable=True)
+        self.toolbar.add_action(action_id, action, target_widget=self)
 
-            def on_action_toggled(checked: bool):
-                if self.switching_actions:
-                    return
+        def on_action_toggled(checked: bool):
+            if self.switching_actions:
+                return
 
-                if checked:
-                    if self.current_action and self.current_action != action.action:
-                        self.switching_actions = True
-                        self.current_action.setChecked(False)
-                        self.switching_actions = False
+            if checked:
+                if self.current_action and self.current_action != action.action:
+                    self.switching_actions = True
+                    self.current_action.setChecked(False)
+                    self.switching_actions = False
 
-                    self.current_action = action.action
+                self.current_action = action.action
 
-                    if not self.panel_visible:
-                        self.show_panel(index)
-                    else:
-                        self.switch_to(index)
+                if not self.panel_visible:
+                    self.show_panel(index)
                 else:
-                    if self.current_action == action.action:
-                        self.current_action = None
-                        self.hide_panel()
+                    self.switch_to(index)
+            else:
+                if self.current_action == action.action:
+                    self.current_action = None
+                    self.hide_panel()
 
-            action.action.toggled.connect(on_action_toggled)
-
-        return index
+        action.action.toggled.connect(on_action_toggled)
 
 
 ############################################
@@ -343,56 +332,41 @@ class ExampleApp(QMainWindow):  # pragma: no cover
         self.add_side_menus()
 
     def add_side_menus(self):
-        # Example 1: With action, icon, and tooltip
         widget1 = QWidget()
         layout1 = QVBoxLayout(widget1)
         for i in range(15):
             layout1.addWidget(QLabel(f"Widget 1 label row {i}"))
         self.side_panel.add_menu(
-            widget=widget1,
             action_id="widget1",
             icon_name="counter_1",
             tooltip="Show Widget 1",
+            widget=widget1,
             title="Widget 1 Panel",
         )
 
-        # Example 2: With action, icon, and tooltip
         widget2 = QWidget()
         layout2 = QVBoxLayout(widget2)
         layout2.addWidget(QLabel("Short widget 2 content"))
         self.side_panel.add_menu(
-            widget=widget2,
             action_id="widget2",
             icon_name="counter_2",
             tooltip="Show Widget 2",
+            widget=widget2,
             title="Widget 2 Panel",
         )
 
-        # Example 3: With action, icon, and tooltip
         widget3 = QWidget()
         layout3 = QVBoxLayout(widget3)
         for i in range(10):
             layout3.addWidget(QLabel(f"Line {i} for Widget 3"))
         self.side_panel.add_menu(
-            widget=widget3,
             action_id="widget3",
             icon_name="counter_3",
             tooltip="Show Widget 3",
+            widget=widget3,
             title="Widget 3 Panel",
         )
 
-        # Example 4: Without action, icon, and tooltip (can only be shown programmatically)
-        widget4 = QWidget()
-        layout4 = QVBoxLayout(widget4)
-        layout4.addWidget(QLabel("This panel has no toolbar button"))
-        layout4.addWidget(QLabel("It can only be shown programmatically"))
-        self.hidden_panel_index = self.side_panel.add_menu(widget=widget4, title="Hidden Panel")
-
-        # Example of how to show the hidden panel programmatically after 3 seconds
-        from qtpy.QtCore import QTimer
-
-        QTimer.singleShot(3000, lambda: self.side_panel.show_panel(self.hidden_panel_index))
-
 
 if __name__ == "__main__":  # pragma: no cover
     app = QApplication(sys.argv)

bec_widgets/utils/toolbar.py

@@ -7,7 +7,6 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from typing import Dict, List, Literal, Tuple
 
-from bec_lib.logger import bec_logger
 from bec_qthemes._icon.material_icons import material_icon
 from qtpy.QtCore import QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QColor, QIcon
@@ -32,8 +31,6 @@ from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import
 
 MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
-logger = bec_logger.logger
-
 # Ensure that icons are shown in menus (especially on macOS)
 QApplication.setAttribute(Qt.AA_DontShowIconsInMenus, False)
 
@@ -121,7 +118,7 @@ class IconAction(ToolBarAction):
     def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
         icon = QIcon()
         icon.addFile(self.icon_path, size=QSize(20, 20))
-        self.action = QAction(icon=icon, text=self.tooltip, parent=target)
+        self.action = QAction(icon, self.tooltip, target)
         self.action.setCheckable(self.checkable)
         toolbar.addAction(self.action)
 
@@ -131,7 +128,7 @@ class QtIconAction(ToolBarAction):
         super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
         self.standard_icon = standard_icon
         self.icon = QApplication.style().standardIcon(standard_icon)
-        self.action = QAction(icon=self.icon, text=self.tooltip, parent=parent)
+        self.action = QAction(self.icon, self.tooltip, parent)
         self.action.setCheckable(self.checkable)
 
     def add_to_toolbar(self, toolbar, target):
@@ -176,11 +173,7 @@ class MaterialIconAction(ToolBarAction):
             filled=self.filled,
             color=self.color,
         )
-        if parent is None:
-            logger.warning(
-                "MaterialIconAction was created without a parent. Please consider adding one. Using None as parent may cause issues."
-            )
-        self.action = QAction(icon=self.icon, text=self.tooltip, parent=parent)
+        self.action = QAction(self.icon, self.tooltip, parent=parent)
         self.action.setCheckable(self.checkable)
 
     def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
@@ -219,12 +212,12 @@ class DeviceSelectionAction(ToolBarAction):
         self.device_combobox.currentIndexChanged.connect(lambda: self.set_combobox_style("#ffa700"))
 
     def add_to_toolbar(self, toolbar, target):
-        widget = QWidget(parent=target)
+        widget = QWidget()
         layout = QHBoxLayout(widget)
         layout.setContentsMargins(0, 0, 0, 0)
         layout.setSpacing(0)
         if self.label is not None:
-            label = QLabel(text=f"{self.label}", parent=target)
+            label = QLabel(f"{self.label}")
             layout.addWidget(label)
         if self.device_combobox is not None:
             layout.addWidget(self.device_combobox)
@@ -287,9 +280,7 @@ class SwitchableToolBarAction(ToolBarAction):
         self.main_button.clicked.connect(self._trigger_current_action)
         menu = QMenu(self.main_button)
         for key, action_obj in self.actions.items():
-            menu_action = QAction(
-                icon=action_obj.get_icon(), text=action_obj.tooltip, parent=self.main_button
-            )
+            menu_action = QAction(action_obj.get_icon(), action_obj.tooltip, self.main_button)
             menu_action.setIconVisibleInMenu(True)
             menu_action.setCheckable(self.checkable)
             menu_action.setChecked(key == self.current_key)
@@ -378,13 +369,13 @@ class WidgetAction(ToolBarAction):
             toolbar (QToolBar): The toolbar to add the widget to.
             target (QWidget): The target widget for the action.
         """
-        self.container = QWidget(parent=target)
+        self.container = QWidget()
         layout = QHBoxLayout(self.container)
         layout.setContentsMargins(0, 0, 0, 0)
         layout.setSpacing(0)
 
         if self.label is not None:
-            label_widget = QLabel(text=f"{self.label}", parent=target)
+            label_widget = QLabel(f"{self.label}")
             label_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
             label_widget.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
             layout.addWidget(label_widget)
@@ -446,7 +437,7 @@ class ExpandableMenuAction(ToolBarAction):
         )
         menu = QMenu(button)
         for action_id, action in self.actions.items():
-            sub_action = QAction(text=action.tooltip, parent=target)
+            sub_action = QAction(action.tooltip, target)
             sub_action.setIconVisibleInMenu(True)
             if action.icon_path:
                 icon = QIcon()
@@ -530,7 +521,7 @@ class ModularToolBar(QToolBar):
         orientation: Literal["horizontal", "vertical"] = "horizontal",
         background_color: str = "rgba(0, 0, 0, 0)",
     ):
-        super().__init__(parent=parent)
+        super().__init__(parent)
 
         self.widgets = defaultdict(dict)
         self.background_color = background_color
@@ -709,85 +700,6 @@ class ModularToolBar(QToolBar):
         self.bundles[bundle_id].append(action_id)
         self.update_separators()
 
-    def remove_action(self, action_id: str):
-        """
-        Completely remove a single action from the toolbar.
-
-        The method takes care of both standalone actions and actions that are
-        part of an existing bundle.
-
-        Args:
-            action_id (str): Unique identifier for the action.
-        """
-        if action_id not in self.widgets:
-            raise ValueError(f"Action with ID '{action_id}' does not exist.")
-
-        # Identify potential bundle membership
-        parent_bundle = None
-        for b_id, a_ids in self.bundles.items():
-            if action_id in a_ids:
-                parent_bundle = b_id
-                break
-
-        # 1. Remove the QAction from the QToolBar and delete it
-        tool_action = self.widgets.pop(action_id)
-        if hasattr(tool_action, "action") and tool_action.action is not None:
-            self.removeAction(tool_action.action)
-            tool_action.action.deleteLater()
-
-        # 2. Clean bundle bookkeeping if the action belonged to one
-        if parent_bundle:
-            self.bundles[parent_bundle].remove(action_id)
-            # If the bundle becomes empty, get rid of the bundle entry as well
-            if not self.bundles[parent_bundle]:
-                self.remove_bundle(parent_bundle)
-
-        # 3. Remove from the ordering list
-        self.toolbar_items = [
-            item
-            for item in self.toolbar_items
-            if not (item[0] == "action" and item[1] == action_id)
-        ]
-
-        self.update_separators()
-
-    def remove_bundle(self, bundle_id: str):
-        """
-        Remove an entire bundle (and all of its actions) from the toolbar.
-
-        Args:
-            bundle_id (str): Unique identifier for the bundle.
-        """
-        if bundle_id not in self.bundles:
-            raise ValueError(f"Bundle '{bundle_id}' does not exist.")
-
-        # Remove every action belonging to this bundle
-        for action_id in list(self.bundles[bundle_id]):  # copy the list
-            if action_id in self.widgets:
-                tool_action = self.widgets.pop(action_id)
-                if hasattr(tool_action, "action") and tool_action.action is not None:
-                    self.removeAction(tool_action.action)
-                    tool_action.action.deleteLater()
-
-        # Drop the bundle entry
-        self.bundles.pop(bundle_id, None)
-
-        # Remove bundle entry and its preceding separator (if any) from the ordering list
-        cleaned_items = []
-        skip_next_separator = False
-        for item_type, ident in self.toolbar_items:
-            if item_type == "bundle" and ident == bundle_id:
-                # mark to skip one following separator if present
-                skip_next_separator = True
-                continue
-            if skip_next_separator and item_type == "separator":
-                skip_next_separator = False
-                continue
-            cleaned_items.append((item_type, ident))
-        self.toolbar_items = cleaned_items
-
-        self.update_separators()
-
     def contextMenuEvent(self, event):
         """
         Overrides the context menu event to show toolbar actions with checkboxes and icons.

bec_widgets/utils/ui_loader.py

@@ -2,7 +2,6 @@ from bec_lib.logger import bec_logger
 from qtpy import PYQT6, PYSIDE6
 from qtpy.QtCore import QFile, QIODevice
 
-from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets
 from bec_widgets.utils.generate_designer_plugin import DesignerPluginInfo
 from bec_widgets.utils.plugin_utils import get_custom_classes
 
@@ -35,9 +34,6 @@ class UILoader:
 
         self.custom_widgets = {widget.__name__: widget for widget in widgets}
 
-        plugin_widgets = get_all_plugin_widgets()
-        self.custom_widgets.update(plugin_widgets)
-
         if PYSIDE6:
             self.loader = self.load_ui_pyside6
         elif PYQT6:

bec_widgets/widgets/containers/dock/dock.py

@@ -12,11 +12,10 @@ from bec_widgets.cli.rpc.rpc_widget_handler import widget_handler
 from bec_widgets.utils import ConnectionConfig, GridLayoutManager
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.container_utils import WidgetContainerUtils
-from bec_widgets.utils.error_popups import SafeSlot
 
 logger = bec_logger.logger
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from qtpy.QtWidgets import QWidget
 
     from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
@@ -131,6 +130,7 @@ class BECDock(BECWidget, Dock):
         self,
         parent: QWidget | None = None,
         parent_dock_area: BECDockArea | None = None,
+        parent_id: str | None = None,
         config: DockConfig | None = None,
         name: str | None = None,
         object_name: str | None = None,
@@ -279,7 +279,6 @@ class BECDock(BECWidget, Dock):
             widgets.extend(dock.elements.keys())
         return widgets
 
-    @SafeSlot(popup_error=True)
     def new(
         self,
         widget: BECWidget | str,
@@ -302,9 +301,6 @@ class BECDock(BECWidget, Dock):
             colspan(int): The number of columns the widget should span.
             shift(Literal["down", "up", "left", "right"]): The direction to shift the widgets if the position is occupied.
         """
-        if name is not None:
-            WidgetContainerUtils.raise_for_invalid_name(name, container=self)
-
         if row is None:
             row = self.layout.rowCount()
 
@@ -320,7 +316,11 @@ class BECDock(BECWidget, Dock):
             widget = cast(
                 BECWidget,
                 widget_handler.create_widget(
-                    widget_type=widget, object_name=name, parent_dock=self, parent=self
+                    widget_type=widget,
+                    object_name=name,
+                    parent_dock=self,
+                    parent_id=self.gui_id,
+                    parent=self,
                 ),
             )
         else:
@@ -416,7 +416,6 @@ class BECDock(BECWidget, Dock):
         self.delete_all()
         self.widgets.clear()
         super().cleanup()
-        self.deleteLater()
 
     def close(self):
         """

bec_widgets/widgets/containers/dock/dock_area.py

@@ -14,7 +14,6 @@ from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.utils import ConnectionConfig, WidgetContainerUtils
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.name_utils import pascal_to_snake
 from bec_widgets.utils.toolbar import (
     ExpandableMenuAction,
     MaterialIconAction,
@@ -102,8 +101,8 @@ class BECDockArea(BECWidget, QWidget):
 
         self._instructions_visible = True
 
-        self.dark_mode_button = DarkModeButton(parent=self, toolbar=True)
-        self.dock_area = DockArea(parent=self)
+        self.dark_mode_button = DarkModeButton(parent=self, parent_id=self.gui_id, toolbar=True)
+        self.dock_area = DockArea()
         self.toolbar = ModularToolBar(
             parent=self,
             actions={
@@ -163,11 +162,8 @@ class BECDockArea(BECWidget, QWidget):
                             tooltip="Add Circular ProgressBar",
                             filled=True,
                         ),
-                        # FIXME temporarily disabled  -> issue #644
                         "log_panel": MaterialIconAction(
-                            icon_name=LogPanel.ICON_NAME,
-                            tooltip="Add LogPanel - Disabled",
-                            filled=True,
+                            icon_name=LogPanel.ICON_NAME, tooltip="Add LogPanel", filled=True
                         ),
                     },
                 ),
@@ -185,7 +181,7 @@ class BECDockArea(BECWidget, QWidget):
 
         self.layout.addWidget(self.toolbar)
         self.layout.addWidget(self.dock_area)
-        self.spacer = QWidget(parent=self)
+        self.spacer = QWidget()
         self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
         self.toolbar.addWidget(self.spacer)
         self.toolbar.addWidget(self.dark_mode_button)
@@ -233,11 +229,9 @@ class BECDockArea(BECWidget, QWidget):
         self.toolbar.widgets["menu_utils"].widgets["progress_bar"].triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="RingProgressBar")
         )
-        # FIXME temporarily disabled -> issue #644
-        self.toolbar.widgets["menu_utils"].widgets["log_panel"].setEnabled(False)
-        # self.toolbar.widgets["menu_utils"].widgets["log_panel"].triggered.connect(
-        #     lambda: self._create_widget_from_toolbar(widget_name="LogPanel")
-        # )
+        self.toolbar.widgets["menu_utils"].widgets["log_panel"].triggered.connect(
+            lambda: self._create_widget_from_toolbar(widget_name="LogPanel")
+        )
 
         # Icons
         self.toolbar.widgets["attach_all"].action.triggered.connect(self.attach_all)
@@ -248,8 +242,7 @@ class BECDockArea(BECWidget, QWidget):
     def _create_widget_from_toolbar(self, widget_name: str) -> None:
         # Run with RPC broadcast to namespace of all widgets
         with RPCRegister.delayed_broadcast():
-            name = pascal_to_snake(widget_name)
-            dock_name = WidgetContainerUtils.generate_unique_name(name, self.panels.keys())
+            dock_name = WidgetContainerUtils.generate_unique_name(widget_name, self.panels.keys())
             self.new(name=dock_name, widget=widget_name)
 
     def paintEvent(self, event: QPaintEvent):  # TODO decide if we want any default instructions
@@ -313,8 +306,6 @@ class BECDockArea(BECWidget, QWidget):
         """
         if state is None:
             state = self.config.docks_state
-        if state is None:
-            return
         self.dock_area.restoreState(state, missing=missing, extra=extra)
 
     @SafeSlot()
@@ -371,8 +362,6 @@ class BECDockArea(BECWidget, QWidget):
                     f"Name {name} must be unique for docks, but already exists in DockArea "
                     f"with name: {self.object_name} and id {self.gui_id}."
                 )
-            WidgetContainerUtils.raise_for_invalid_name(name, container=self)
-
         else:  # Name is not provided
             name = WidgetContainerUtils.generate_unique_name(name="dock", list_of_names=dock_names)
 
@@ -381,6 +370,7 @@ class BECDockArea(BECWidget, QWidget):
             name=name,  # this is dock name pyqtgraph property, this is displayed on label
             object_name=name,  # this is a real qt object name passed to BECConnector
             parent_dock_area=self,
+            parent_id=self.gui_id,
             closable=closable,
         )
         dock.config.position = position
@@ -450,8 +440,12 @@ class BECDockArea(BECWidget, QWidget):
         Cleanup the dock area.
         """
         self.delete_all()
+        self.toolbar.close()
+        self.toolbar.deleteLater()
         self.dark_mode_button.close()
         self.dark_mode_button.deleteLater()
+        self.dock_area.close()
+        self.dock_area.deleteLater()
         super().cleanup()
 
     def show(self):

bec_widgets/widgets/containers/layout_manager/layout_manager.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import math
 import sys
 from typing import Dict, Literal, Optional, Set, Tuple, Union
@@ -53,7 +51,7 @@ class LayoutManagerWidget(QWidget):
         self,
         widget: QWidget | str,
         row: int | None = None,
-        col: int | None = None,
+        col: Optional[int] = None,
         rowspan: int = 1,
         colspan: int = 1,
         shift_existing: bool = True,
@@ -138,39 +136,6 @@ class LayoutManagerWidget(QWidget):
         ref_row, ref_col, ref_rowspan, ref_colspan = self.widget_positions[reference_widget]
 
         # Determine new widget position based on the specified relative position
-
-        # If adding to the left or right with shifting, shift the entire column
-        if (
-            position in ("left", "right")
-            and shift_existing
-            and shift_direction in ("left", "right")
-        ):
-            column = ref_col
-            # Collect all rows in this column and sort for safe shifting
-            rows = sorted(
-                {row for (row, col) in self.position_widgets.keys() if col == column},
-                reverse=(shift_direction == "right"),
-            )
-            # Shift each widget in the column
-            for r in rows:
-                self.shift_widgets(direction=shift_direction, start_row=r, start_col=column)
-            # Update reference widget's position after the column shift
-            ref_row, ref_col, ref_rowspan, ref_colspan = self.widget_positions[reference_widget]
-            new_row = ref_row
-            # Compute insertion column based on relative position
-            if position == "left":
-                new_col = ref_col - ref_colspan
-            else:
-                new_col = ref_col + ref_colspan
-            # Add the new widget without triggering another shift
-            return self.add_widget(
-                widget=widget,
-                row=new_row,
-                col=new_col,
-                rowspan=rowspan,
-                colspan=colspan,
-                shift_existing=False,
-            )
         if position == "left":
             new_row = ref_row
             new_col = ref_col - 1

bec_widgets/widgets/control/buttons/button_abort/button_abort.py

@@ -11,7 +11,7 @@ class AbortButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "cancel"
-    RPC = True
+    RPC = False
 
     def __init__(
         self,

bec_widgets/widgets/control/buttons/button_reset/button_reset.py

@@ -11,7 +11,7 @@ class ResetButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "restart_alt"
-    RPC = True
+    RPC = False
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)

bec_widgets/widgets/control/buttons/button_resume/button_resume.py

@@ -11,7 +11,7 @@ class ResumeButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "resume"
-    RPC = True
+    RPC = False
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)

bec_widgets/widgets/control/buttons/stop_button/stop_button.py

@@ -11,7 +11,7 @@ class StopButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "dangerous"
-    RPC = True
+    RPC = False
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
@@ -54,20 +54,9 @@ class StopButton(BECWidget, QWidget):
 if __name__ == "__main__":  # pragma: no cover
     import sys
 
-    from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+    from qtpy.QtWidgets import QApplication
 
-    from bec_widgets.widgets.control.buttons.stop_button.stop_button import StopButton
-
-    class MyGui(QWidget):
-        def __init__(self):
-            super().__init__()
-            self.setLayout(QVBoxLayout())
-            # Create and add the StopButton to the layout
-            self.stop_button = StopButton()
-            self.layout().addWidget(self.stop_button)
-
-    # Example of how this custom GUI might be used:
-    app = QApplication([])
-    my_gui = MyGui()
-    my_gui.show()
+    app = QApplication(sys.argv)
+    w = StopButton()
+    w.show()
     sys.exit(app.exec_())

bec_widgets/widgets/control/device_control/position_indicator/position_indicator.py

@@ -12,16 +12,7 @@ class PositionIndicator(BECWidget, QWidget):
     Display a position within a defined range, e.g. motor limits.
     """
 
-    USER_ACCESS = [
-        "set_value",
-        "set_range",
-        "vertical",
-        "vertical.setter",
-        "indicator_width",
-        "indicator_width.setter",
-        "rounded_corners",
-        "rounded_corners.setter",
-    ]
+    USER_ACCESS = ["set_value", "set_range", "vertical", "indicator_width", "rounded_corners"]
     PLUGIN = True
     ICON_NAME = "horizontal_distribute"
 
@@ -218,12 +209,6 @@ class PositionIndicator(BECWidget, QWidget):
     @Slot(int)
     @Slot(float)
     def set_value(self, position: float):
-        """
-        Set the position of the indicator
-
-        Args:
-            position: The new position of the indicator
-        """
         self.position = position
         self.update()
 

bec_widgets/widgets/control/device_control/positioner_box/positioner_box/positioner_box.py

@@ -31,7 +31,6 @@ class PositionerBox(PositionerBoxBase):
     dimensions = (234, 224)
 
     PLUGIN = True
-    RPC = True
 
     USER_ACCESS = ["set_positioner"]
     device_changed = Signal(str, str)

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_2d/positioner_box_2d.py

@@ -33,7 +33,6 @@ class PositionerBox2D(PositionerBoxBase):
     ui_file = "positioner_box_2d.ui"
 
     PLUGIN = True
-    RPC = True
     USER_ACCESS = ["set_positioner_hor", "set_positioner_ver"]
 
     device_changed_hor = Signal(str, str)

bec_widgets/widgets/control/device_control/positioner_group/positioner_group.py

@@ -1,4 +1,4 @@
-"""Module for a PositionerGroup widget to control a positioner device."""
+""" Module for a PositionerGroup widget to control a positioner device."""
 
 from __future__ import annotations
 

bec_widgets/widgets/control/device_input/base_classes/device_input_base.py

@@ -82,7 +82,7 @@ class DeviceInputBase(BECWidget):
         ReadoutPriority.ON_REQUEST: "readout_on_request",
     }
 
-    def __init__(self, parent=None, client=None, config=None, gui_id: str | None = None, **kwargs):
+    def __init__(self, client=None, config=None, gui_id: str | None = None, **kwargs):
 
         if config is None:
             config = DeviceInputConfig(widget_class=self.__class__.__name__)
@@ -90,9 +90,7 @@ class DeviceInputBase(BECWidget):
             if isinstance(config, dict):
                 config = DeviceInputConfig(**config)
             self.config = config
-        super().__init__(
-            parent=parent, client=client, config=config, gui_id=gui_id, theme_update=True, **kwargs
-        )
+        super().__init__(client=client, config=config, gui_id=gui_id, theme_update=True, **kwargs)
         self.get_bec_shortcuts()
         self._device_filter = []
         self._readout_filter = []
@@ -397,7 +395,7 @@ class DeviceInputBase(BECWidget):
             object: Device object, can be device of type Device, Positioner, Signal or ComputedSignal.
         """
         self.validate_device(device)
-        dev = getattr(self.dev, device, None)
+        dev = getattr(self.dev, device.lower(), None)
         if dev is None:
             raise ValueError(
                 f"Device {device} is not found in the device manager {self.dev} as enabled device."

bec_widgets/widgets/control/device_input/base_classes/device_signal_input_base.py

@@ -36,16 +36,14 @@ class DeviceSignalInputBase(BECWidget):
         Kind.config: "include_config_signals",
     }
 
-    def __init__(
-        self,
-        client=None,
-        config: DeviceSignalInputBaseConfig | dict | None = None,
-        gui_id: str = None,
-        **kwargs,
-    ):
-
-        self.config = self._process_config_input(config)
-        super().__init__(client=client, config=self.config, gui_id=gui_id, **kwargs)
+    def __init__(self, client=None, config=None, gui_id: str = None, **kwargs):
+        if config is None:
+            config = DeviceSignalInputBaseConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = DeviceSignalInputBaseConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
 
         self._device = None
         self.get_bec_shortcuts()
@@ -79,7 +77,7 @@ class DeviceSignalInputBase(BECWidget):
     @Slot(str)
     def set_device(self, device: str | None):
         """
-        Set the device. If device is not valid, device will be set to None which happens
+        Set the device. If device is not valid, device will be set to None which happpens
 
         Args:
             device(str): device name.
@@ -104,7 +102,10 @@ class DeviceSignalInputBase(BECWidget):
         """
         self.config.signal_filter = self.signal_filter
         # pylint: disable=protected-access
-        if not self.validate_device(self._device):
+        self._hinted_signals = []
+        self._normal_signals = []
+        self._config_signals = []
+        if self.validate_device(self._device) is False:
             self._device = None
             self.config.device = self._device
             return
@@ -112,25 +113,30 @@ class DeviceSignalInputBase(BECWidget):
         # See above convention for Signals and ComputedSignals
         if isinstance(device, Signal):
             self._signals = [self._device]
-            self._hinted_signals = [self._device]
-            self._normal_signals = []
-            self._config_signals = []
-            FilterIO.set_selection(widget=self, selection=self._signals)
+            FilterIO.set_selection(widget=self, selection=[self._device])
             return
-        device_info = device._info.get("signals", {})
-
-        def _update(kind: Kind):
-            return [
+        device_info = device._info["signals"]
+        if Kind.hinted in self.signal_filter:
+            hinted_signals = [
                 signal
                 for signal, signal_info in device_info.items()
-                if kind in self.signal_filter
-                and (signal_info.get("kind_str", None) == str(kind.name))
+                if (signal_info.get("kind_str", None) == str(Kind.hinted.value))
             ]
-
-        self._hinted_signals = _update(Kind.hinted)
-        self._normal_signals = _update(Kind.normal)
-        self._config_signals = _update(Kind.config)
-
+            self._hinted_signals = hinted_signals
+        if Kind.normal in self.signal_filter:
+            normal_signals = [
+                signal
+                for signal, signal_info in device_info.items()
+                if (signal_info.get("kind_str", None) == str(Kind.normal.value))
+            ]
+            self._normal_signals = normal_signals
+        if Kind.config in self.signal_filter:
+            config_signals = [
+                signal
+                for signal, signal_info in device_info.items()
+                if (signal_info.get("kind_str", None) == str(Kind.config.value))
+            ]
+            self._config_signals = config_signals
         self._signals = self._hinted_signals + self._normal_signals + self._config_signals
         FilterIO.set_selection(widget=self, selection=self.signals)
 
@@ -244,7 +250,7 @@ class DeviceSignalInputBase(BECWidget):
             object: Device object, can be device of type Device, Positioner, Signal or ComputedSignal.
         """
         self.validate_device(device)
-        dev = getattr(self.dev, device, None)
+        dev = getattr(self.dev, device.lower(), None)
         if dev is None:
             logger.warning(f"Device {device} not found in devicemanager.")
             return None
@@ -273,8 +279,3 @@ class DeviceSignalInputBase(BECWidget):
         if signal in self.signals:
             return True
         return False
-
-    def _process_config_input(self, config: DeviceSignalInputBaseConfig | dict | None):
-        if config is None:
-            return DeviceSignalInputBaseConfig(widget_class=self.__class__.__name__)
-        return DeviceSignalInputBaseConfig.model_validate(config)

bec_widgets/widgets/control/device_input/device_combobox/device_combobox.py

@@ -22,14 +22,10 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
         config: Device input configuration.
         gui_id: GUI ID.
         device_filter: Device filter, name of the device class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
-        readout_priority_filter: Readout priority filter, name of the readout priority class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
-        available_devices: List of available devices, if passed, it sets apply filters to false and device/readout priority filters will not be applied.
         default: Default device name.
         arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
     """
 
-    USER_ACCESS = ["set_device", "devices"]
-
     ICON_NAME = "list_alt"
     PLUGIN = True
 
@@ -144,7 +140,7 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
         """
         if self.validate_device(input_text) is True:
             self._is_valid_input = True
-            self.device_selected.emit(input_text)
+            self.device_selected.emit(input_text.lower())
         else:
             self._is_valid_input = False
         self.update()

bec_widgets/widgets/control/device_input/device_line_edit/device_line_edit.py

@@ -24,15 +24,11 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         client: BEC client object.
         config: Device input configuration.
         gui_id: GUI ID.
-        device_filter: Device filter, name of the device class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
-        readout_priority_filter: Readout priority filter, name of the readout priority class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
-        available_devices: List of available devices, if passed, it sets apply filters to false and device/readout priority filters will not be applied.
+        device_filter: Device filter, name of the device class from BECDeviceFilter and ReadoutPriority. Check DeviceInputBase for more details.
         default: Default device name.
         arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
     """
 
-    USER_ACCESS = ["set_device", "devices", "_is_valid_input"]
-
     device_selected = Signal(str)
     device_config_update = Signal()
 
@@ -55,7 +51,7 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         **kwargs,
     ):
         self._callback_id = None
-        self.__is_valid_input = False
+        self._is_valid_input = False
         self._accent_colors = get_accent_colors()
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
         self.completer = QCompleter(self)
@@ -99,20 +95,6 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         self.textChanged.connect(self.check_validity)
         self.check_validity(self.text())
 
-    @property
-    def _is_valid_input(self) -> bool:
-        """
-        Check if the current value is a valid device name.
-
-        Returns:
-            bool: True if the current value is a valid device name, False otherwise.
-        """
-        return self.__is_valid_input
-
-    @_is_valid_input.setter
-    def _is_valid_input(self, value: bool) -> None:
-        self.__is_valid_input = value
-
     def on_device_update(self, action: str, content: dict) -> None:
         """
         Callback for device update events. Triggers the device_update signal.
@@ -165,7 +147,7 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         """
         if self.validate_device(input_text) is True:
             self._is_valid_input = True
-            self.device_selected.emit(input_text)
+            self.device_selected.emit(input_text.lower())
         else:
             self._is_valid_input = False
         self.update()

bec_widgets/widgets/control/device_input/signal_combobox/signal_combobox.py

@@ -23,11 +23,8 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
         arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
     """
 
-    USER_ACCESS = ["set_signal", "set_device", "signals"]
-
     ICON_NAME = "list_alt"
     PLUGIN = True
-    RPC = True
 
     device_signal_changed = Signal(str)
 

bec_widgets/widgets/control/device_input/signal_line_edit/signal_line_edit.py

@@ -24,12 +24,9 @@ class SignalLineEdit(DeviceSignalInputBase, QLineEdit):
         arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
     """
 
-    USER_ACCESS = ["_is_valid_input", "set_signal", "set_device", "signals"]
-
     device_signal_changed = Signal(str)
 
     PLUGIN = True
-    RPC = True
     ICON_NAME = "vital_signs"
 
     def __init__(
@@ -44,7 +41,7 @@ class SignalLineEdit(DeviceSignalInputBase, QLineEdit):
         arg_name: str | None = None,
         **kwargs,
     ):
-        self.__is_valid_input = False
+        self._is_valid_input = False
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
         self._accent_colors = get_accent_colors()
         self.completer = QCompleter(self)
@@ -68,22 +65,8 @@ class SignalLineEdit(DeviceSignalInputBase, QLineEdit):
             self.set_device(device)
         if default is not None:
             self.set_signal(default)
-        self.textChanged.connect(self.check_validity)
-        self.check_validity(self.text())
-
-    @property
-    def _is_valid_input(self) -> bool:
-        """
-        Check if the current value is a valid device name.
-
-        Returns:
-            bool: True if the current value is a valid device name, False otherwise.
-        """
-        return self.__is_valid_input
-
-    @_is_valid_input.setter
-    def _is_valid_input(self, value: bool) -> None:
-        self.__is_valid_input = value
+        self.textChanged.connect(self.validate_device)
+        self.validate_device(self.text())
 
     def get_current_device(self) -> object:
         """
@@ -148,9 +131,6 @@ if __name__ == "__main__":  # pragma: no cover
     from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
     from bec_widgets.utils.colors import set_theme
-    from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import (
-        DeviceComboBox,
-    )
 
     app = QApplication([])
     set_theme("dark")
@@ -158,12 +138,6 @@ if __name__ == "__main__":  # pragma: no cover
     widget.setFixedSize(200, 200)
     layout = QVBoxLayout()
     widget.setLayout(layout)
-    device_line_edit = DeviceComboBox()
-    device_line_edit.filter_to_positioner = True
-    signal_line_edit = SignalLineEdit()
-    device_line_edit.device_selected.connect(signal_line_edit.set_device)
-
-    layout.addWidget(device_line_edit)
-    layout.addWidget(signal_line_edit)
+    layout.addWidget(SignalLineEdit(device="samx"))
     widget.show()
     app.exec_()

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -64,6 +64,7 @@ class ScanControl(BECWidget, QWidget):
         default_scan: str | None = None,
         **kwargs,
     ):
+
         if config is None:
             config = ScanControlConfig(
                 widget_class=self.__class__.__name__, allowed_scans=allowed_scans
@@ -165,7 +166,7 @@ class ScanControl(BECWidget, QWidget):
         self.layout.addStretch()
 
     def _add_metadata_form(self):
-        self._metadata_form = ScanMetadata(parent=self)
+        self._metadata_form = ScanMetadata()
         self.layout.addWidget(self._metadata_form)
         self._metadata_form.update_with_new_scan(self.comboBox_scan_selection.currentText())
         self.scan_selected.connect(self._metadata_form.update_with_new_scan)

bec_widgets/widgets/control/scan_control/scan_group_box.py

@@ -234,7 +234,7 @@ class ScanGroupBox(QGroupBox):
                 continue
             if default == "_empty":
                 default = None
-            widget = widget_class(parent=self.parent(), arg_name=arg_name, default=default)
+            widget = widget_class(arg_name=arg_name, default=default)
             if isinstance(widget, DeviceLineEdit):
                 widget.set_device_filter(BECDeviceFilter.DEVICE)
                 self.selected_devices[widget] = ""
@@ -274,24 +274,12 @@ class ScanGroupBox(QGroupBox):
         for widget in self.widgets[-len(self.inputs) :]:
             if isinstance(widget, DeviceLineEdit):
                 self.selected_devices[widget] = ""
-            widget.close()
             widget.deleteLater()
         self.widgets = self.widgets[: -len(self.inputs)]
 
         selected_devices_str = " ".join(self.selected_devices.values())
         self.device_selected.emit(selected_devices_str.strip())
 
-    def remove_all_widget_bundles(self):
-        """Remove every widget bundle from the scan control layout."""
-        for widget in list(self.widgets):
-            if isinstance(widget, DeviceLineEdit):
-                self.selected_devices.pop(widget, None)
-            widget.close()
-            widget.deleteLater()
-            self.layout.removeWidget(widget)
-        self.widgets.clear()
-        self.device_selected.emit("")
-
     @Property(bool)
     def hide_add_remove_buttons(self):
         return self._hide_add_remove_buttons
@@ -360,21 +348,10 @@ class ScanGroupBox(QGroupBox):
             self._set_kwarg_parameters(parameters)
 
     def _set_arg_parameters(self, parameters: list):
-        self.remove_all_widget_bundles()
-        if not parameters:
-            return
-
-        inputs_per_bundle = len(self.inputs)
-        if inputs_per_bundle == 0:
-            return
-
-        bundles_needed = -(-len(parameters) // inputs_per_bundle)
-
-        for row in range(1, bundles_needed + 1):
-            self.add_input_widgets(self.inputs, row)
-
-        for i, value in enumerate(parameters):
-            WidgetIO.set_value(self.widgets[i], value)
+        while len(parameters) != len(self.widgets):
+            self.add_widget_bundle()
+        for i, parameter in enumerate(parameters):
+            WidgetIO.set_value(self.widgets[i], parameter)
 
     def _set_kwarg_parameters(self, parameters: dict):
         for widget in self.widgets:

bec_widgets/widgets/dap/dap_combo_box/dap_combo_box.py

@@ -16,7 +16,7 @@ class DapComboBox(BECWidget, QWidget):
     Args:
         parent: Parent widget.
         client: BEC client object.
-        gui_id: GUI ID.
+        gui_id: GUI ID.--
         default: Default device name.
     """
 
@@ -154,7 +154,9 @@ class DapComboBox(BECWidget, QWidget):
     def populate_fit_model_combobox(self):
         """Populate the fit_model_combobox with the devices."""
         # pylint: disable=protected-access
-        self.available_models = [model for model in self.client.dap._available_dap_plugins.keys()]
+        self.available_models = [
+            model for model in self.client.dap._available_dap_plugins.keys()
+        ]
         self.fit_model_combobox.clear()
         self.fit_model_combobox.addItems(self.available_models)
 

bec_widgets/widgets/dap/dap_task_manager/drag_and_drop.py

@@ -0,0 +1,193 @@
+import inspect
+
+from bec_lib.signature_serializer import deserialize_dtype
+from bec_server.data_processing.dap_framework_refactoring.dap_blocks import (
+    BlockWithLotsOfArgs,
+    DAPBlock,
+    GradientBlock,
+    SmoothBlock,
+)
+from pydantic.fields import FieldInfo
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QDoubleSpinBox,
+    QLabel,
+    QLayout,
+    QRadioButton,
+    QScrollArea,
+)
+from qtpy.QtCore import QMimeData, Qt, Signal
+from qtpy.QtGui import QDrag, QPixmap
+from qtpy.QtWidgets import (
+    QApplication,
+    QHBoxLayout,
+    QMainWindow,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.expandable_frame import ExpandableGroupFrame
+from bec_widgets.widgets.editors.scan_metadata._metadata_widgets import widget_from_type
+from bec_widgets.widgets.editors.scan_metadata.scan_metadata import ScanMetadata
+from tests.unit_tests.test_scan_metadata import metadata_widget
+
+
+class DragItem(ExpandableGroupFrame):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setContentsMargins(25, 5, 25, 5)
+        self._layout = QVBoxLayout()
+        self.set_layout(self._layout)
+
+    def mouseMoveEvent(self, e):
+        if e.buttons() == Qt.MouseButton.LeftButton:
+            drag = QDrag(self)
+            mime = QMimeData()
+            drag.setMimeData(mime)
+
+            pixmap = QPixmap(self.size())
+            self.render(pixmap)
+            drag.setPixmap(pixmap)
+
+            drag.exec(Qt.DropAction.MoveAction)
+
+
+class DragWidget(QWidget):
+    """
+    Generic list sorting handler.
+    """
+
+    orderChanged = Signal(list)
+
+    def __init__(self, *args, orientation=Qt.Orientation.Vertical, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setAcceptDrops(True)
+
+        # Store the orientation for drag checks later.
+        self.orientation = orientation
+
+        if self.orientation == Qt.Orientation.Vertical:
+            self.blayout = QVBoxLayout()
+        else:
+            self.blayout = QHBoxLayout()
+
+        self.setLayout(self.blayout)
+
+    def dragEnterEvent(self, e):
+        e.accept()
+
+    def dropEvent(self, e):
+        pos = e.position()
+        widget = e.source()
+        self.blayout.removeWidget(widget)
+
+        for n in range(self.blayout.count()):
+            # Get the widget at each index in turn.
+            w = self.blayout.itemAt(n).widget()
+            if self.orientation == Qt.Orientation.Vertical:
+                # Drag drop vertically.
+                drop_here = pos.y() < w.y() + w.size().height() // 2
+            else:
+                # Drag drop horizontally.
+                drop_here = pos.x() < w.x() + w.size().width() // 2
+
+            if drop_here:
+                break
+
+        else:
+            # We aren't on the left hand/upper side of any widget,
+            # so we're at the end. Increment 1 to insert after.
+            n += 1
+
+        self.blayout.insertWidget(n, widget)
+        self.orderChanged.emit(self.get_item_data())
+
+        e.accept()
+
+    def add_item(self, item):
+        self.blayout.addWidget(item)
+
+    def get_item_data(self):
+        data = []
+        for n in range(self.blayout.count()):
+            # Get the widget at each index in turn.
+            w: "DAPBlockWidget" = self.blayout.itemAt(n).widget()
+            data.append(w._title.text())
+        return data
+
+
+class DAPBlockWidget(BECWidget, DragItem):
+    def __init__(
+        self,
+        parent=None,
+        content: type[DAPBlock] = None,
+        client=None,
+        gui_id: str | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            parent=parent,
+            client=client,
+            gui_id=gui_id,
+            title=content.__name__,
+            **kwargs,
+        )
+        self._content = content
+        self.add_form(self._content)
+
+    def add_form(self, block_type: type[DAPBlock]):
+        run_signature = inspect.signature(block_type.run)
+        self._title.setText(block_type.__name__)
+        layout = self._contents.layout()
+        if layout is None:
+            return
+        self._add_widgets_for_signature(layout, run_signature)
+
+    def _add_widgets_for_signature(self, layout: QLayout, signature: inspect.Signature):
+        for arg_name, arg_spec in signature.parameters.items():
+            annotation: str | type = arg_spec.annotation
+            if isinstance(annotation, str):
+                annotation = deserialize_dtype(annotation) or annotation
+            w = QWidget()
+            w.setLayout(QHBoxLayout())
+            w.layout().addWidget(QLabel(arg_name))
+            w.layout().addWidget(
+                widget_from_type(annotation)(
+                    FieldInfo(
+                        annotation=annotation
+                    )  # FIXME this class should not be initialised directly...
+                )
+            )
+            w.layout().addWidget(QLabel(str(annotation)))
+
+            layout.addWidget(w)
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.drag = DragWidget(orientation=Qt.Orientation.Vertical)
+        for block_type in [SmoothBlock, GradientBlock, BlockWithLotsOfArgs] * 2:
+            item = DAPBlockWidget(content=block_type)
+            self.drag.add_item(item)
+
+        # Print out the changed order.
+        self.drag.orderChanged.connect(print)
+
+        container = QWidget()
+        layout = QVBoxLayout()
+        layout.addStretch(1)
+        layout.addWidget(self.drag)
+        layout.addStretch(1)
+        container.setLayout(layout)
+
+        self.setCentralWidget(container)
+
+
+if __name__ == "__main__":
+    app = QApplication([])
+    w = MainWindow()
+    w.show()
+
+    app.exec()

bec_widgets/widgets/dap/dap_task_manager/task_editor.py

@@ -0,0 +1,6 @@
+"""Panel to compose DAP task runs
+- new ones are added as tabs
+- can be enabled and disabled, continuous and oneoff
+- fill in extra kwargs using thing from MD widget
+- output to topic for the name, which looks like a data topic
+"""

bec_widgets/widgets/editors/console/console.py

@@ -1,5 +1,5 @@
 """
-BECConsole is a Qt widget that runs a Bash shell.
+BECConsole is a Qt widget that runs a Bash shell. 
 
 BECConsole VT100 emulation is powered by Pyte,
 (https://github.com/selectel/pyte).
@@ -56,12 +56,12 @@ control_keys_mapping = {
     QtCore.Qt.Key_G: b"\x07",  # Ctrl-G (Bell)
     QtCore.Qt.Key_H: b"\x08",  # Ctrl-H (Backspace)
     QtCore.Qt.Key_I: b"\x09",  # Ctrl-I (Tab)
-    QtCore.Qt.Key_J: b"\x0a",  # Ctrl-J (Line Feed)
-    QtCore.Qt.Key_K: b"\x0b",  # Ctrl-K (Vertical Tab)
-    QtCore.Qt.Key_L: b"\x0c",  # Ctrl-L (Form Feed)
-    QtCore.Qt.Key_M: b"\x0d",  # Ctrl-M (Carriage Return)
-    QtCore.Qt.Key_N: b"\x0e",  # Ctrl-N
-    QtCore.Qt.Key_O: b"\x0f",  # Ctrl-O
+    QtCore.Qt.Key_J: b"\x0A",  # Ctrl-J (Line Feed)
+    QtCore.Qt.Key_K: b"\x0B",  # Ctrl-K (Vertical Tab)
+    QtCore.Qt.Key_L: b"\x0C",  # Ctrl-L (Form Feed)
+    QtCore.Qt.Key_M: b"\x0D",  # Ctrl-M (Carriage Return)
+    QtCore.Qt.Key_N: b"\x0E",  # Ctrl-N
+    QtCore.Qt.Key_O: b"\x0F",  # Ctrl-O
     QtCore.Qt.Key_P: b"\x10",  # Ctrl-P
     QtCore.Qt.Key_Q: b"\x11",  # Ctrl-Q
     QtCore.Qt.Key_R: b"\x12",  # Ctrl-R
@@ -72,10 +72,10 @@ control_keys_mapping = {
     QtCore.Qt.Key_W: b"\x17",  # Ctrl-W
     QtCore.Qt.Key_X: b"\x18",  # Ctrl-X
     QtCore.Qt.Key_Y: b"\x19",  # Ctrl-Y
-    QtCore.Qt.Key_Z: b"\x1a",  # Ctrl-Z
-    QtCore.Qt.Key_Escape: b"\x1b",  # Ctrl-Escape
-    QtCore.Qt.Key_Backslash: b"\x1c",  # Ctrl-\
-    QtCore.Qt.Key_Underscore: b"\x1f",  # Ctrl-_
+    QtCore.Qt.Key_Z: b"\x1A",  # Ctrl-Z
+    QtCore.Qt.Key_Escape: b"\x1B",  # Ctrl-Escape
+    QtCore.Qt.Key_Backslash: b"\x1C",  # Ctrl-\
+    QtCore.Qt.Key_Underscore: b"\x1F",  # Ctrl-_
 }
 
 normal_keys_mapping = {
@@ -89,7 +89,7 @@ normal_keys_mapping = {
     QtCore.Qt.Key_Left: b"\x02",
     QtCore.Qt.Key_Up: b"\x10",
     QtCore.Qt.Key_Right: b"\x06",
-    QtCore.Qt.Key_Down: b"\x0e",
+    QtCore.Qt.Key_Down: b"\x0E",
     QtCore.Qt.Key_PageUp: b"\x49",
     QtCore.Qt.Key_PageDown: b"\x51",
     QtCore.Qt.Key_F1: b"\x1b\x31",

bec_widgets/widgets/editors/scan_metadata/__init__.py

@@ -0,0 +1,7 @@
+from bec_widgets.widgets.editors.scan_metadata.additional_metadata_table import (
+    AdditionalMetadataTable,
+    AdditionalMetadataTableModel,
+)
+from bec_widgets.widgets.editors.scan_metadata.scan_metadata import ScanMetadata
+
+__all__ = ["ScanMetadata", "AdditionalMetadataTable", "AdditionalMetadataTableModel"]

bec_widgets/widgets/editors/scan_metadata/_metadata_widgets.py

@@ -2,13 +2,11 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from decimal import Decimal
-from types import UnionType
-from typing import Callable, Protocol
+from typing import TYPE_CHECKING, Callable, get_args
 
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
-from pydantic import BaseModel, ConfigDict, Field
-from pydantic.fields import FieldInfo
+from pydantic import BaseModel, Field
 from qtpy.QtCore import Signal  # type: ignore
 from qtpy.QtWidgets import (
     QApplication,
@@ -35,22 +33,12 @@ from bec_widgets.widgets.editors.scan_metadata._util import (
     field_precision,
 )
 
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
+
 logger = bec_logger.logger
 
 
-class FormItemSpec(BaseModel):
-    """
-    The specification for an item in a dynamically generated form. Uses a pydantic FieldInfo
-    to store most annotation info, since one of the main purposes is to store data for
-    forms genrated from pydantic models, but can also be composed from other sources or by hand.
-    """
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-    item_type: type | UnionType
-    name: str
-    info: FieldInfo = FieldInfo()
-
-
 class ClearableBoolEntry(QWidget):
     stateChanged = Signal()
 
@@ -94,20 +82,20 @@ class ClearableBoolEntry(QWidget):
         self._false.setToolTip(tooltip)
 
 
-class DynamicFormItem(QWidget):
+class MetadataWidget(QWidget):
     valueChanged = Signal()
 
-    def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
         super().__init__(parent)
-        self._spec = spec
+        self._info = info
         self._layout = QHBoxLayout()
         self._layout.setContentsMargins(0, 0, 0, 0)
         self._layout.setSizeConstraint(QLayout.SizeConstraint.SetMaximumSize)
-        self._default = field_default(self._spec.info)
-        self._desc = self._spec.info.description
+        self._default = field_default(self._info)
+        self._desc = self._info.description
         self.setLayout(self._layout)
         self._add_main_widget()
-        if clearable_required(spec.info):
+        if clearable_required(info):
             self._add_clear_button()
 
     @abstractmethod
@@ -138,15 +126,15 @@ class DynamicFormItem(QWidget):
         self.valueChanged.emit()
 
 
-class StrMetadataField(DynamicFormItem):
-    def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
-        super().__init__(parent=parent, spec=spec)
+class StrMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
         self._main_widget.textChanged.connect(self._value_changed)
 
     def _add_main_widget(self) -> None:
         self._main_widget = QLineEdit()
         self._layout.addWidget(self._main_widget)
-        min_length, max_length = (field_minlen(self._spec.info), field_maxlen(self._spec.info))
+        min_length, max_length = field_minlen(self._info), field_maxlen(self._info)
         if max_length:
             self._main_widget.setMaxLength(max_length)
         self._main_widget.setToolTip(
@@ -167,15 +155,15 @@ class StrMetadataField(DynamicFormItem):
         self._main_widget.setText(value)
 
 
-class IntMetadataField(DynamicFormItem):
-    def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
-        super().__init__(parent=parent, spec=spec)
+class IntMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
         self._main_widget.textChanged.connect(self._value_changed)
 
     def _add_main_widget(self) -> None:
         self._main_widget = QSpinBox()
         self._layout.addWidget(self._main_widget)
-        min_, max_ = field_limits(self._spec.info, int)
+        min_, max_ = field_limits(self._info, int)
         self._main_widget.setMinimum(min_)
         self._main_widget.setMaximum(max_)
         self._main_widget.setToolTip(f"(range {min_} to {max_}){self._describe()}")
@@ -196,18 +184,18 @@ class IntMetadataField(DynamicFormItem):
         self._main_widget.setValue(value)
 
 
-class FloatDecimalMetadataField(DynamicFormItem):
-    def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
-        super().__init__(parent=parent, spec=spec)
+class FloatDecimalMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
         self._main_widget.textChanged.connect(self._value_changed)
 
     def _add_main_widget(self) -> None:
         self._main_widget = QDoubleSpinBox()
         self._layout.addWidget(self._main_widget)
-        min_, max_ = field_limits(self._spec.info, int)
+        min_, max_ = field_limits(self._info, int)
         self._main_widget.setMinimum(min_)
         self._main_widget.setMaximum(max_)
-        precision = field_precision(self._spec.info)
+        precision = field_precision(self._info)
         if precision:
             self._main_widget.setDecimals(precision)
         minstr = f"{float(min_):.3f}" if abs(min_) <= 1000 else f"{float(min_):.3e}"
@@ -230,13 +218,13 @@ class FloatDecimalMetadataField(DynamicFormItem):
         self._main_widget.setValue(value)
 
 
-class BoolMetadataField(DynamicFormItem):
-    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
-        super().__init__(parent=parent, spec=spec)
+class BoolMetadataField(MetadataWidget):
+    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+        super().__init__(info, parent)
         self._main_widget.stateChanged.connect(self._value_changed)
 
     def _add_main_widget(self) -> None:
-        if clearable_required(self._spec.info):
+        if clearable_required(self._info):
             self._main_widget = ClearableBoolEntry()
         else:
             self._main_widget = QCheckBox()
@@ -251,7 +239,7 @@ class BoolMetadataField(DynamicFormItem):
         self._main_widget.setChecked(value)
 
 
-def widget_from_type(annotation: type | UnionType | None) -> type[DynamicFormItem]:
+def widget_from_type(annotation: type | None) -> Callable[[FieldInfo], MetadataWidget]:
     if annotation in [str, str | None]:
         return StrMetadataField
     if annotation in [int, int | None]:
@@ -261,7 +249,9 @@ def widget_from_type(annotation: type | UnionType | None) -> type[DynamicFormIte
     if annotation in [bool, bool | None]:
         return BoolMetadataField
     else:
-        logger.warning(f"Type {annotation} is not (yet) supported in metadata form creation.")
+        logger.warning(
+            f"Type {annotation} is not (yet) supported in metadata form creation."
+        )
         return StrMetadataField
 
 

bec_widgets/widgets/editors/scan_metadata/_util.py

@@ -9,7 +9,7 @@ from annotated_types import Ge, Gt, Le, Lt
 from bec_lib.logger import bec_logger
 from pydantic_core import PydanticUndefined
 
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from pydantic.fields import FieldInfo
 
 logger = bec_logger.logger

bec_widgets/widgets/editors/scan_metadata/additional_metadata_table.py

@@ -16,20 +16,12 @@ from qtpy.QtWidgets import (
 from bec_widgets.utils.error_popups import SafeSlot
 
 
-class DictBackedTableModel(QAbstractTableModel):
+class AdditionalMetadataTableModel(QAbstractTableModel):
     def __init__(self, data):
-        """A model to go with DictBackedTable, which represents key-value pairs
-        to be displayed in a TreeWidget.
-
-        Args:
-            data (list[list[str]]): list of key-value pairs to initialise with"""
         super().__init__()
         self._data: list[list[str]] = data
         self._disallowed_keys: list[str] = []
 
-    # pylint: disable=missing-function-docstring
-    # see QAbstractTableModel documentation for these methods
-
     def headerData(
         self, section: int, orientation: Qt.Orientation, role: int = Qt.ItemDataRole()
     ) -> Any:
@@ -53,15 +45,10 @@ class DictBackedTableModel(QAbstractTableModel):
             if value in self._disallowed_keys or value in self._other_keys(index.row()):
                 return False
             self._data[index.row()][index.column()] = str(value)
-            self.dataChanged.emit(index, index)
             return True
         return False
 
     def update_disallowed_keys(self, keys: list[str]):
-        """Set the list of keys which may not be used.
-
-        Args:
-            keys (list[str]): list of keys which are forbidden."""
         self._disallowed_keys = keys
         for i, item in enumerate(self._data):
             if item[0] in self._disallowed_keys:
@@ -108,22 +95,16 @@ class DictBackedTableModel(QAbstractTableModel):
         return dict(self._data)
 
 
-class DictBackedTable(QWidget):
+class AdditionalMetadataTable(QWidget):
+
     delete_rows = Signal(list)
-    data_updated = Signal()
 
     def __init__(self, initial_data: list[list[str]]):
-        """Widget which uses a DictBackedTableModel to display an editable table
-        which can be extracted as a dict.
-
-        Args:
-            initial_data (list[list[str]]): list of key-value pairs to initialise with
-        """
         super().__init__()
 
         self._layout = QHBoxLayout()
         self.setLayout(self._layout)
-        self._table_model = DictBackedTableModel(initial_data)
+        self._table_model = AdditionalMetadataTableModel(initial_data)
         self._table_view = QTreeView()
         self._table_view.setModel(self._table_model)
         self._table_view.setSizePolicy(
@@ -143,28 +124,17 @@ class DictBackedTable(QWidget):
         self._add_button.clicked.connect(self._table_model.add_row)
         self._remove_button.clicked.connect(self.delete_selected_rows)
         self.delete_rows.connect(self._table_model.delete_rows)
-        self._table_model.dataChanged.connect(self._emit_data_updated)
-
-    def _emit_data_updated(self, *args, **kwargs):
-        """Just to swallow the args"""
-        self.data_updated.emit()
 
     def delete_selected_rows(self):
-        """Delete rows which are part of the selection model"""
         cells: list[QModelIndex] = self._table_view.selectionModel().selectedIndexes()
         row_indices = list({r.row() for r in cells})
         if row_indices:
             self.delete_rows.emit(row_indices)
 
     def dump_dict(self):
-        """Get the current content of the table as a dict"""
         return self._table_model.dump_dict()
 
     def update_disallowed_keys(self, keys: list[str]):
-        """Set the list of keys which may not be used.
-
-        Args:
-            keys (list[str]): list of keys which are forbidden."""
         self._table_model.update_disallowed_keys(keys)
 
 
@@ -174,6 +144,6 @@ if __name__ == "__main__":  # pragma: no cover
     app = QApplication([])
     set_theme("dark")
 
-    window = DictBackedTable([["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
+    window = AdditionalMetadataTable([["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
     window.show()
     app.exec()

bec_widgets/widgets/editors/scan_metadata/scan_metadata.py

@@ -1,21 +1,52 @@
 from __future__ import annotations
 
 from decimal import Decimal
+from types import NoneType
+from typing import TYPE_CHECKING
 
 from bec_lib.logger import bec_logger
 from bec_lib.metadata_schema import get_metadata_schema_for_scan
-from pydantic import Field
-from qtpy.QtWidgets import QApplication, QComboBox, QHBoxLayout, QVBoxLayout, QWidget
+from bec_qthemes import material_icon
+from pydantic import Field, ValidationError
+from qtpy.QtCore import Signal  # type: ignore
+from qtpy.QtWidgets import (
+    QApplication,
+    QComboBox,
+    QGridLayout,
+    QHBoxLayout,
+    QLabel,
+    QLayout,
+    QVBoxLayout,
+    QWidget,
+)
 
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.compact_popup import CompactPopupWidget
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.expandable_frame import ExpandableGroupFrame
-from bec_widgets.utils.forms_from_types.forms import PydanticModelForm
-from bec_widgets.widgets.editors.dict_backed_table import DictBackedTable
+from bec_widgets.widgets.editors.scan_metadata._metadata_widgets import widget_from_type
+from bec_widgets.widgets.editors.scan_metadata.additional_metadata_table import (
+    AdditionalMetadataTable,
+)
+
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
 
 logger = bec_logger.logger
 
 
-class ScanMetadata(PydanticModelForm):
+class PydanticModelForm(BECWidget, QWidget):
+    """Dynamically generates a form for inclusion of metadata for a scan. Uses the
+    metadata schema registry supplied in the plugin repo to find pydantic models
+    associated with the scan type. Sets limits for numerical values if specified."""
+
+    PLUGIN = True
+    ICON_NAME = "list_alt"
+
+    metadata_updated = Signal(dict)
+    metadata_cleared = Signal(NoneType)
+    RPC = False
+
     def __init__(
         self,
         parent=None,
@@ -24,37 +55,126 @@ class ScanMetadata(PydanticModelForm):
         initial_extras: list[list[str]] | None = None,
         **kwargs,
     ):
-        """Dynamically generates a form for inclusion of metadata for a scan. Uses the
-        metadata schema registry supplied in the plugin repo to find pydantic models
-        associated with the scan type. Sets limits for numerical values if specified.
+        super().__init__(parent=parent, client=client, **kwargs)
 
-        Args:
-            scan_name (str): The scan for which to generate a metadata form
-            Initial_extras (list[list[str]]): Initial data with which to populate the additional
-                                              metadata table - inner lists should be key-value pairs
-        """
+        self.set_schema(scan_name)
 
-        # self.populate() gets called in super().__init__
-        # so make sure self._additional_metadata exists
-        self._additional_md_box = ExpandableGroupFrame("Additional metadata", expanded=False)
+        self._layout = QVBoxLayout()
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(self._layout)
+
+        self._required_md_box = ExpandableGroupFrame("Scan schema metadata")
+        self._layout.addWidget(self._required_md_box)
+        self._required_md_box_layout = QHBoxLayout()
+        self._required_md_box.set_layout(self._required_md_box_layout)
+
+        self._md_grid = QWidget()
+        self._required_md_box_layout.addWidget(self._md_grid)
+        self._grid_container = QVBoxLayout()
+        self._md_grid.setLayout(self._grid_container)
+        self._new_grid_layout()
+        self._grid_container.addLayout(self._md_grid_layout)
+
+        self._additional_md_box = ExpandableGroupFrame(
+            "Additional metadata", expanded=False
+        )
+        self._layout.addWidget(self._additional_md_box)
         self._additional_md_box_layout = QHBoxLayout()
         self._additional_md_box.set_layout(self._additional_md_box_layout)
 
-        self._additional_metadata = DictBackedTable(initial_extras or [])
-        self._scan_name = scan_name or ""
-        self._md_schema = get_metadata_schema_for_scan(self._scan_name)
-        self._additional_metadata.data_updated.connect(self.validate_form)
-
-        super().__init__(parent=parent, metadata_model=self._md_schema, client=client, **kwargs)
-
-        self._layout.addWidget(self._additional_md_box)
+        self._additional_metadata = AdditionalMetadataTable(initial_extras or [])
         self._additional_md_box_layout.addWidget(self._additional_metadata)
 
+        self._validity = CompactPopupWidget()
+        self._validity.compact_view = True  # type: ignore
+        self._validity.label = "Metadata validity"  # type: ignore
+        self._validity.compact_show_popup.setIcon(
+            material_icon(icon_name="info", size=(10, 10), convert_to_pixmap=False)
+        )
+        self._validity_message = QLabel("Not yet validated")
+        self._validity.addWidget(self._validity_message)
+        self._layout.addWidget(self._validity)
+
+        self.populate()
+
     @SafeSlot(str)
     def update_with_new_scan(self, scan_name: str):
-        self.set_schema_from_scan(scan_name)
+        self.set_schema(scan_name)
+        self.populate()
         self.validate_form()
 
+    def validate_form(self, *_) -> bool:
+        """validate the currently entered metadata against the pydantic schema.
+        If successful, returns on metadata_emitted and returns true.
+        Otherwise, emits on metadata_cleared and returns false."""
+        try:
+            metadata_dict = self.get_full_model_dict()
+            self._md_schema.model_validate(metadata_dict)
+            self._validity.set_global_state("success")
+            self._validity_message.setText("No errors!")
+            self.metadata_updated.emit(metadata_dict)
+        except ValidationError as e:
+            self._validity.set_global_state("emergency")
+            self._validity_message.setText(str(e))
+            self.metadata_cleared.emit(None)
+
+    def get_full_model_dict(self):
+        """Get the entered metadata as a dict"""
+        return self._additional_metadata.dump_dict() | self._dict_from_grid()
+
+    def set_schema(self, scan_name: str | None = None):
+        self._scan_name = scan_name or ""
+        self._md_schema = get_metadata_schema_for_scan(self._scan_name)
+
+    def populate(self):
+        self._clear_grid()
+        self._populate()
+
+    def _populate(self):
+        self._additional_metadata.update_disallowed_keys(
+            list(self._md_schema.model_fields.keys())
+        )
+        for i, (field_name, info) in enumerate(self._md_schema.model_fields.items()):
+            self._add_griditem(field_name, info, i)
+
+    def _add_griditem(self, field_name: str, info: FieldInfo, row: int):
+        grid = self._md_grid_layout
+        label = QLabel(info.title or field_name)
+        label.setProperty("_model_field_name", field_name)
+        label.setToolTip(info.description or field_name)
+        grid.addWidget(label, row, 0)
+        widget = widget_from_type(info.annotation)(info)
+        widget.valueChanged.connect(self.validate_form)
+        grid.addWidget(widget, row, 1)
+
+    def _dict_from_grid(self) -> dict[str, str | int | float | Decimal | bool]:
+        grid = self._md_grid_layout
+        return {
+            grid.itemAtPosition(i, 0)
+            .widget()
+            .property("_model_field_name"): grid.itemAtPosition(i, 1)
+            .widget()
+            .getValue()  # type: ignore # we only add 'MetadataWidget's here
+            for i in range(grid.rowCount())
+        }
+
+    def _clear_grid(self):
+        while self._md_grid_layout.count():
+            item = self._md_grid_layout.takeAt(0)
+            widget = item.widget()
+            if widget is not None:
+                widget.deleteLater()
+        self._md_grid_layout.deleteLater()
+        self._new_grid_layout()
+        self._grid_container.addLayout(self._md_grid_layout)
+        self._md_grid.adjustSize()
+        self.adjustSize()
+
+    def _new_grid_layout(self):
+        self._md_grid_layout = QGridLayout()
+        self._md_grid_layout.setContentsMargins(0, 0, 0, 0)
+        self._md_grid_layout.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
+
     @SafeProperty(bool)
     def hide_optional_metadata(self):  # type: ignore
         """Property to hide the optional metadata table."""
@@ -69,25 +189,11 @@ class ScanMetadata(PydanticModelForm):
         """
         self._additional_md_box.setVisible(not hide)
 
-    def get_form_data(self):
-        """Get the entered metadata as a dict"""
-        return self._additional_metadata.dump_dict() | self._dict_from_grid()
 
-    def populate(self):
-        self._additional_metadata.update_disallowed_keys(list(self._md_schema.model_fields.keys()))
-        super().populate()
-
-    def set_schema_from_scan(self, scan_name: str | None):
-        self._scan_name = scan_name or ""
-        self.set_schema(get_metadata_schema_for_scan(self._scan_name))
-        self.populate()
+class ScanMetadata(PydanticModelForm): ...
 
 
 if __name__ == "__main__":  # pragma: no cover
-    # pylint: disable=redefined-outer-name
-    # pylint: disable=protected-access
-    # pylint: disable=disallowed-name
-
     from unittest.mock import patch
 
     from bec_lib.metadata_schema import BasicScanMetadata
@@ -95,15 +201,21 @@ if __name__ == "__main__":  # pragma: no cover
     from bec_widgets.utils.colors import set_theme
 
     class ExampleSchema1(BasicScanMetadata):
-        abc: int = Field(gt=0, lt=2000, description="Heating temperature abc", title="A B C")
-        foo: str = Field(max_length=12, description="Sample database code", default="DEF123")
+        abc: int = Field(
+            gt=0, lt=2000, description="Heating temperature abc", title="A B C"
+        )
+        foo: str = Field(
+            max_length=12, description="Sample database code", default="DEF123"
+        )
         xyz: Decimal = Field(decimal_places=4)
         baz: bool
 
     class ExampleSchema2(BasicScanMetadata):
         checkbox_up_top: bool
         checkbox_again: bool = Field(
-            title="Checkbox Again", description="this one defaults to True", default=True
+            title="Checkbox Again",
+            description="this one defaults to True",
+            default=True,
         )
         different_items: int | None = Field(
             None, description="This is just one different item...", gt=-100, lt=0
@@ -116,7 +228,11 @@ if __name__ == "__main__":  # pragma: no cover
 
     with patch(
         "bec_lib.metadata_schema._get_metadata_schema_registry",
-        lambda: {"scan1": ExampleSchema1, "scan2": ExampleSchema2, "scan3": ExampleSchema3},
+        lambda: {
+            "scan1": ExampleSchema1,
+            "scan2": ExampleSchema2,
+            "scan3": ExampleSchema3,
+        },
     ):
         app = QApplication([])
         w = QWidget()

bec_widgets/widgets/editors/web_console/register_web_console.py

@@ -1,15 +0,0 @@
-def main():  # pragma: no cover
-    from qtpy import PYSIDE6
-
-    if not PYSIDE6:
-        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
-        return
-    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
-
-    from bec_widgets.widgets.editors.web_console.web_console_plugin import WebConsolePlugin
-
-    QPyDesignerCustomWidgetCollection.addCustomWidget(WebConsolePlugin())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/widgets/editors/web_console/web_console.py

@@ -1,230 +0,0 @@
-from __future__ import annotations
-
-import secrets
-import subprocess
-import time
-
-from bec_lib.logger import bec_logger
-from louie.saferef import safe_ref
-from qtpy.QtCore import QUrl, qInstallMessageHandler
-from qtpy.QtWebEngineWidgets import QWebEnginePage, QWebEngineView
-from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
-
-from bec_widgets.utils.bec_widget import BECWidget
-
-logger = bec_logger.logger
-
-
-class WebConsoleRegistry:
-    """
-    A registry for the WebConsole class to manage its instances.
-    """
-
-    def __init__(self):
-        """
-        Initialize the registry.
-        """
-        self._instances = {}
-        self._server_process = None
-        self._server_port = None
-        self._token = secrets.token_hex(16)
-
-    def register(self, instance: WebConsole):
-        """
-        Register an instance of WebConsole.
-        """
-        self._instances[instance.gui_id] = safe_ref(instance)
-        self.cleanup()
-
-        if self._server_process is None:
-            # Start the ttyd server if not already running
-            self.start_ttyd()
-
-    def start_ttyd(self, use_zsh: bool | None = None):
-        """
-        Start the ttyd server
-        ttyd -q -W -t 'theme={"background": "black"}' zsh
-
-        Args:
-            use_zsh (bool): Whether to use zsh or bash. If None, it will try to detect if zsh is available.
-        """
-
-        # First, check if ttyd is installed
-        try:
-            subprocess.run(["ttyd", "--version"], check=True, stdout=subprocess.PIPE)
-        except FileNotFoundError:
-            # pylint: disable=raise-missing-from
-            raise RuntimeError("ttyd is not installed. Please install it first.")
-
-        if use_zsh is None:
-            # Check if we can use zsh
-            try:
-                subprocess.run(["zsh", "--version"], check=True, stdout=subprocess.PIPE)
-                use_zsh = True
-            except FileNotFoundError:
-                use_zsh = False
-
-        command = [
-            "ttyd",
-            "-p",
-            "0",
-            "-W",
-            "-t",
-            'theme={"background": "black"}',
-            "-c",
-            f"user:{self._token}",
-        ]
-        if use_zsh:
-            command.append("zsh")
-        else:
-            command.append("bash")
-
-        # Start the ttyd server
-        self._server_process = subprocess.Popen(
-            command, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-
-        self._wait_for_server_port()
-
-        self._server_process.stdout.close()
-        self._server_process.stderr.close()
-
-    def _wait_for_server_port(self, timeout: float = 10):
-        """
-        Wait for the ttyd server to start and get the port number.
-
-        Args:
-            timeout (float): The timeout in seconds to wait for the server to start.
-        """
-        start_time = time.time()
-        while True:
-            output = self._server_process.stderr.readline()
-            if output == b"" and self._server_process.poll() is not None:
-                break
-            if not output:
-                continue
-
-            output = output.decode("utf-8").strip()
-            if "Listening on" in output:
-                # Extract the port number from the output
-                self._server_port = int(output.split(":")[-1])
-                logger.info(f"ttyd server started on port {self._server_port}")
-                break
-            if time.time() - start_time > timeout:
-                raise TimeoutError(
-                    "Timeout waiting for ttyd server to start. Please check if ttyd is installed and available in your PATH."
-                )
-
-    def cleanup(self):
-        """
-        Clean up the registry by removing any instances that are no longer valid.
-        """
-        for gui_id, weak_ref in list(self._instances.items()):
-            if weak_ref() is None:
-                del self._instances[gui_id]
-
-        if not self._instances and self._server_process:
-            # If no instances are left, terminate the server process
-            self._server_process.terminate()
-            self._server_process = None
-            self._server_port = None
-            logger.info("ttyd server terminated")
-
-    def unregister(self, instance: WebConsole):
-        """
-        Unregister an instance of WebConsole.
-
-        Args:
-            instance (WebConsole): The instance to unregister.
-        """
-        if instance.gui_id in self._instances:
-            del self._instances[instance.gui_id]
-
-        self.cleanup()
-
-
-_web_console_registry = WebConsoleRegistry()
-
-
-def suppress_qt_messages(type_, context, msg):
-    if context.category in ["js", "default"]:
-        return
-    print(msg)
-
-
-qInstallMessageHandler(suppress_qt_messages)
-
-
-class BECWebEnginePage(QWebEnginePage):
-    def javaScriptConsoleMessage(self, level, message, lineNumber, sourceID):
-        logger.info(f"[JS Console] {level.name} at line {lineNumber} in {sourceID}: {message}")
-
-
-class WebConsole(BECWidget, QWidget):
-    """
-    A simple widget to display a website
-    """
-
-    PLUGIN = True
-    ICON_NAME = "terminal"
-
-    def __init__(self, parent=None, config=None, client=None, gui_id=None, **kwargs):
-        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
-        _web_console_registry.register(self)
-        self._token = _web_console_registry._token
-        layout = QVBoxLayout()
-        layout.setContentsMargins(0, 0, 0, 0)
-        self.browser = QWebEngineView(self)
-        self.page = BECWebEnginePage(self)
-        self.page.authenticationRequired.connect(self._authenticate)
-        self.browser.setPage(self.page)
-        layout.addWidget(self.browser)
-        self.setLayout(layout)
-        self.page.setUrl(QUrl(f"http://localhost:{_web_console_registry._server_port}"))
-
-    def write(self, data: str, send_return: bool = True):
-        """
-        Send data to the web page
-        """
-        self.page.runJavaScript(f"window.term.paste('{data}');")
-        if send_return:
-            self.send_return()
-
-    def _authenticate(self, _, auth):
-        """
-        Authenticate the request with the provided username and password.
-        """
-        auth.setUser("user")
-        auth.setPassword(self._token)
-
-    def send_return(self):
-        """
-        Send return to the web page
-        """
-        self.page.runJavaScript(
-            "document.querySelector('textarea.xterm-helper-textarea').dispatchEvent(new KeyboardEvent('keypress', {charCode: 13}))"
-        )
-
-    def send_ctrl_c(self):
-        """
-        Send Ctrl+C to the web page
-        """
-        self.page.runJavaScript(
-            "document.querySelector('textarea.xterm-helper-textarea').dispatchEvent(new KeyboardEvent('keypress', {charCode: 3}))"
-        )
-
-    def cleanup(self):
-        """
-        Clean up the registry by removing any instances that are no longer valid.
-        """
-        _web_console_registry.unregister(self)
-        super().cleanup()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    app = QApplication(sys.argv)
-    widget = WebConsole()
-    widget.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/editors/web_console/web_console.pyproject

@@ -1 +0,0 @@
-{'files': ['web_console.py']}

bec_widgets/widgets/editors/web_console/web_console_plugin.py

@@ -1,54 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-
-from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.editors.web_console.web_console import WebConsole
-
-DOM_XML = """
-<ui language='c++'>
-    <widget class='WebConsole' name='web_console'>
-    </widget>
-</ui>
-"""
-
-
-class WebConsolePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self._form_editor = None
-
-    def createWidget(self, parent):
-        t = WebConsole(parent)
-        return t
-
-    def domXml(self):
-        return DOM_XML
-
-    def group(self):
-        return "BEC Console"
-
-    def icon(self):
-        return designer_material_icon(WebConsole.ICON_NAME)
-
-    def includeFile(self):
-        return "web_console"
-
-    def initialize(self, form_editor):
-        self._form_editor = form_editor
-
-    def isContainer(self):
-        return False
-
-    def isInitialized(self):
-        return self._form_editor is not None
-
-    def name(self):
-        return "WebConsole"
-
-    def toolTip(self):
-        return ""
-
-    def whatsThis(self):
-        return self.toolTip()

bec_widgets/widgets/editors/website/website.py

@@ -117,7 +117,6 @@ class WebsiteWidget(BECWidget, QWidget):
         Cleanup the widget
         """
         self.website.page().deleteLater()
-        super().cleanup()
 
 
 if __name__ == "__main__":

bec_widgets/widgets/games/minesweeper.py

@@ -144,7 +144,7 @@ class Minesweeper(BECWidget, QWidget):
     PLUGIN = True
     ICON_NAME = "videogame_asset"
     USER_ACCESS = []
-    RPC = True
+    RPC = False
 
     def __init__(self, parent=None, *args, **kwargs):
         super().__init__(parent=parent, *args, **kwargs)

bec_widgets/widgets/plots/image/image.py

@@ -8,27 +8,18 @@ from bec_lib import bec_logger
 from bec_lib.endpoints import MessageEndpoints
 from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import QPointF, Signal
-from qtpy.QtWidgets import QDialog, QVBoxLayout, QWidget
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.colors import Colors
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
-from bec_widgets.utils.side_panel import SidePanel
 from bec_widgets.utils.toolbar import MaterialIconAction, SwitchableToolBarAction
 from bec_widgets.widgets.plots.image.image_item import ImageItem
-from bec_widgets.widgets.plots.image.image_roi_plot import ImageROIPlot
-from bec_widgets.widgets.plots.image.setting_widgets.image_roi_tree import ROIPropertyTree
 from bec_widgets.widgets.plots.image.toolbar_bundles.image_selection import (
     MonitorSelectionToolbarBundle,
 )
 from bec_widgets.widgets.plots.image.toolbar_bundles.processing import ImageProcessingToolbarBundle
 from bec_widgets.widgets.plots.plot_base import PlotBase
-from bec_widgets.widgets.plots.roi.image_roi import (
-    BaseROI,
-    CircularROI,
-    RectangularROI,
-    ROIController,
-)
 
 logger = bec_logger.logger
 
@@ -36,7 +27,7 @@ logger = bec_logger.logger
 # noinspection PyDataclass
 class ImageConfig(ConnectionConfig):
     color_map: str = Field(
-        "plasma", description="The colormap  of the figure widget.", validate_default=True
+        "magma", description="The colormap  of the figure widget.", validate_default=True
     )
     color_bar: Literal["full", "simple"] | None = Field(
         None, description="The type of the color bar."
@@ -88,6 +79,12 @@ class Image(PlotBase):
         "auto_range_x.setter",
         "auto_range_y",
         "auto_range_y.setter",
+        "x_log",
+        "x_log.setter",
+        "y_log",
+        "y_log.setter",
+        "legend_label_size",
+        "legend_label_size.setter",
         # ImageView Specific Settings
         "color_map",
         "color_map.setter",
@@ -114,18 +111,14 @@ class Image(PlotBase):
         "fft.setter",
         "log",
         "log.setter",
-        "num_rotation_90",
-        "num_rotation_90.setter",
+        "rotation",
+        "rotation.setter",
         "transpose",
         "transpose.setter",
         "image",
         "main_image",
-        "add_roi",
-        "remove_roi",
-        "rois",
     ]
     sync_colorbar_with_autorange = Signal()
-    image_updated = Signal()
 
     def __init__(
         self,
@@ -141,74 +134,33 @@ class Image(PlotBase):
         self.gui_id = config.gui_id
         self._color_bar = None
         self._main_image = ImageItem()
-        self.roi_controller = ROIController(colormap="viridis")
-        self.x_roi = None
-        self.y_roi = None
         super().__init__(
             parent=parent, config=config, client=client, gui_id=gui_id, popups=popups, **kwargs
         )
-        self._main_image = ImageItem(parent_image=self)
+        self._main_image = ImageItem(parent_image=self, parent_id=self.gui_id)
 
         self.plot_item.addItem(self._main_image)
         self.scan_id = None
 
-        # Default Color map to plasma
-        self.color_map = "plasma"
-
-        # Initialize ROI plots and side panels
-        self._add_roi_plots()
-
-        self.roi_manager_dialog = None
-
-        # Refresh theme for ROI plots
-        self._update_theme()
+        # Default Color map to magma
+        self.color_map = "magma"
 
     ################################################################################
     # Widget Specific GUI interactions
     ################################################################################
-    def apply_theme(self, theme: str):
-        super().apply_theme(theme)
-        if self.x_roi is not None and self.y_roi is not None:
-            self.x_roi.apply_theme(theme)
-            self.y_roi.apply_theme(theme)
-
     def _init_toolbar(self):
 
         # add to the first position
         self.selection_bundle = MonitorSelectionToolbarBundle(
             bundle_id="selection", target_widget=self
         )
-        self.toolbar.add_bundle(bundle=self.selection_bundle, target_widget=self)
+        self.toolbar.add_bundle(self.selection_bundle, self)
 
         super()._init_toolbar()
 
         # Image specific changes to PlotBase toolbar
         self.toolbar.widgets["reset_legend"].action.setVisible(False)
 
-        # ROI Bundle replacement with switchable crosshair
-        self.toolbar.remove_bundle("roi")
-        crosshair = MaterialIconAction(
-            icon_name="point_scan", tooltip="Show Crosshair", checkable=True
-        )
-        crosshair_roi = MaterialIconAction(
-            icon_name="my_location",
-            tooltip="Show Crosshair with ROI plots",
-            checkable=True,
-            parent=self,
-        )
-        crosshair_roi.action.toggled.connect(self.toggle_roi_panels)
-        crosshair.action.toggled.connect(self.toggle_crosshair)
-        switch_crosshair = SwitchableToolBarAction(
-            actions={"crosshair_simple": crosshair, "crosshair_roi": crosshair_roi},
-            initial_action="crosshair_simple",
-            tooltip="Crosshair",
-            checkable=True,
-            parent=self,
-        )
-        self.toolbar.add_action(
-            action_id="switch_crosshair", action=switch_crosshair, target_widget=self
-        )
-
         # Lock aspect ratio button
         self.lock_aspect_ratio_action = MaterialIconAction(
             icon_name="aspect_ratio", tooltip="Lock Aspect Ratio", checkable=True, parent=self
@@ -257,8 +209,11 @@ class Image(PlotBase):
             parent=self,
         )
 
-        self.toolbar.add_action(
-            action_id="autorange_image", action=self.autorange_switch, target_widget=self
+        self.toolbar.add_action_to_bundle(
+            bundle_id="roi",
+            action_id="autorange_image",
+            action=self.autorange_switch,
+            target_widget=self,
         )
 
         self.autorange_mean_action.action.toggled.connect(
@@ -290,8 +245,11 @@ class Image(PlotBase):
             parent=self,
         )
 
-        self.toolbar.add_action(
-            action_id="switch_colorbar", action=self.colorbar_switch, target_widget=self
+        self.toolbar.add_action_to_bundle(
+            bundle_id="roi",
+            action_id="switch_colorbar",
+            action=self.colorbar_switch,
+            target_widget=self,
         )
 
         self.simple_colorbar_action.action.toggled.connect(
@@ -301,55 +259,6 @@ class Image(PlotBase):
             lambda checked: self.enable_colorbar(checked, style="full")
         )
 
-    ########################################
-    # ROI Gui Manager
-    def add_side_menus(self):
-        super().add_side_menus()
-
-        roi_mgr = ROIPropertyTree(parent=self, image_widget=self)
-        self.side_panel.add_menu(
-            action_id="roi_mgr",
-            icon_name="view_list",
-            tooltip="ROI Manager",
-            widget=roi_mgr,
-            title="ROI Manager",
-        )
-
-    def add_popups(self):
-        super().add_popups()  # keep Axis Settings
-
-        roi_action = MaterialIconAction(
-            icon_name="view_list", tooltip="ROI Manager", checkable=True, parent=self
-        )
-        # self.popup_bundle.add_action("roi_mgr", roi_action)
-        self.toolbar.add_action_to_bundle(
-            bundle_id="popup_bundle", action_id="roi_mgr", action=roi_action, target_widget=self
-        )
-        self.toolbar.widgets["roi_mgr"].action.triggered.connect(self.show_roi_manager_popup)
-
-    def show_roi_manager_popup(self):
-        roi_action = self.toolbar.widgets["roi_mgr"].action
-        if self.roi_manager_dialog is None or not self.roi_manager_dialog.isVisible():
-            self.roi_mgr = ROIPropertyTree(parent=self, image_widget=self)
-            self.roi_manager_dialog = QDialog(modal=False)
-            self.roi_manager_dialog.layout = QVBoxLayout(self.roi_manager_dialog)
-            self.roi_manager_dialog.layout.addWidget(self.roi_mgr)
-            self.roi_manager_dialog.finished.connect(self._roi_mgr_closed)
-            self.roi_manager_dialog.show()
-            roi_action.setChecked(True)
-        else:
-            self.roi_manager_dialog.raise_()
-            self.roi_manager_dialog.activateWindow()
-            roi_action.setChecked(True)
-
-    def _roi_mgr_closed(self):
-        self.roi_mgr.close()
-        self.roi_mgr.deleteLater()
-        self.roi_manager_dialog.close()
-        self.roi_manager_dialog.deleteLater()
-        self.roi_manager_dialog = None
-        self.toolbar.widgets["roi_mgr"].action.setChecked(False)
-
     def enable_colorbar(
         self,
         enabled: bool,
@@ -401,177 +310,9 @@ class Image(PlotBase):
         if vrange:  # should be at the end to disable the autorange if defined
             self.v_range = vrange
 
-    ################################################################################
-    # Static rois with roi manager
-
-    def add_roi(
-        self,
-        kind: Literal["rect", "circle"] = "rect",
-        name: str | None = None,
-        line_width: int | None = 5,
-        pos: tuple[float, float] | None = (10, 10),
-        size: tuple[float, float] | None = (50, 50),
-        **pg_kwargs,
-    ) -> RectangularROI | CircularROI:
-        """
-        Add a ROI to the image.
-
-        Args:
-            kind(str): The type of ROI to add. Options are "rect" or "circle".
-            name(str): The name of the ROI.
-            line_width(int): The line width of the ROI.
-            pos(tuple): The position of the ROI.
-            size(tuple): The size of the ROI.
-            **pg_kwargs: Additional arguments for the ROI.
-
-        Returns:
-            RectangularROI | CircularROI: The created ROI object.
-        """
-        if name is None:
-            name = f"ROI_{len(self.roi_controller.rois) + 1}"
-        if kind == "rect":
-            roi = RectangularROI(
-                pos=pos,
-                size=size,
-                parent_image=self,
-                line_width=line_width,
-                label=name,
-                **pg_kwargs,
-            )
-        elif kind == "circle":
-            roi = CircularROI(
-                pos=pos,
-                size=size,
-                parent_image=self,
-                line_width=line_width,
-                label=name,
-                **pg_kwargs,
-            )
-        else:
-            raise ValueError("kind must be 'rect' or 'circle'")
-
-        # Add to plot and controller (controller assigns color)
-        self.plot_item.addItem(roi)
-        self.roi_controller.add_roi(roi)
-        roi.add_scale_handle()
-        return roi
-
-    def remove_roi(self, roi: int | str):
-        """Remove an ROI by index or label via the ROIController."""
-        if isinstance(roi, int):
-            self.roi_controller.remove_roi_by_index(roi)
-        elif isinstance(roi, str):
-            self.roi_controller.remove_roi_by_name(roi)
-        else:
-            raise ValueError("roi must be an int index or str name")
-
-    def _add_roi_plots(self):
-        """
-        Initialize the ROI plots and side panels.
-        """
-        # Create ROI plot widgets
-        self.x_roi = ImageROIPlot(parent=self)
-        self.y_roi = ImageROIPlot(parent=self)
-        self.x_roi.apply_theme("dark")
-        self.y_roi.apply_theme("dark")
-
-        # Set titles for the plots
-        self.x_roi.plot_item.setTitle("X ROI")
-        self.y_roi.plot_item.setTitle("Y ROI")
-
-        # Create side panels
-        self.side_panel_x = SidePanel(
-            parent=self, orientation="bottom", panel_max_width=200, show_toolbar=False
-        )
-        self.side_panel_y = SidePanel(
-            parent=self, orientation="left", panel_max_width=200, show_toolbar=False
-        )
-
-        # Add ROI plots to side panels
-        self.x_panel_index = self.side_panel_x.add_menu(widget=self.x_roi)
-        self.y_panel_index = self.side_panel_y.add_menu(widget=self.y_roi)
-
-        # # Add side panels to the layout
-        self.layout_manager.add_widget_relative(
-            self.side_panel_x, self.round_plot_widget, position="bottom", shift_direction="down"
-        )
-        self.layout_manager.add_widget_relative(
-            self.side_panel_y, self.round_plot_widget, position="left", shift_direction="right"
-        )
-
-    def toggle_roi_panels(self, checked: bool):
-        """
-        Show or hide the ROI panels based on the test action toggle state.
-
-        Args:
-            checked (bool): Whether the test action is checked.
-        """
-        if checked:
-            # Show the ROI panels
-            self.hook_crosshair()
-            self.side_panel_x.show_panel(self.x_panel_index)
-            self.side_panel_y.show_panel(self.y_panel_index)
-            self.crosshair.coordinatesChanged2D.connect(self.update_image_slices)
-            self.image_updated.connect(self.update_image_slices)
-        else:
-            self.unhook_crosshair()
-            # Hide the ROI panels
-            self.side_panel_x.hide_panel()
-            self.side_panel_y.hide_panel()
-            self.image_updated.disconnect(self.update_image_slices)
-
-    @SafeSlot()
-    def update_image_slices(self, coordinates: tuple[int, int, int] = None):
-        """
-        Update the image slices based on the crosshair position.
-
-        Args:
-            coordinates(tuple): The coordinates of the crosshair.
-        """
-        if coordinates is None:
-            # Try to get coordinates from crosshair position (like in crosshair mouse_moved)
-            if (
-                hasattr(self, "crosshair")
-                and hasattr(self.crosshair, "v_line")
-                and hasattr(self.crosshair, "h_line")
-            ):
-                x = int(round(self.crosshair.v_line.value()))
-                y = int(round(self.crosshair.h_line.value()))
-            else:
-                return
-        else:
-            x = coordinates[1]
-            y = coordinates[2]
-        image = self._main_image.image
-        if image is None:
-            return
-        max_row, max_col = image.shape[0] - 1, image.shape[1] - 1
-        row, col = x, y
-        if not (0 <= row <= max_row and 0 <= col <= max_col):
-            return
-        # Horizontal slice
-        h_slice = image[:, col]
-        x_axis = np.arange(h_slice.shape[0])
-        self.x_roi.plot_item.clear()
-        self.x_roi.plot_item.plot(x_axis, h_slice, pen=pg.mkPen(self.x_roi.curve_color, width=3))
-        # Vertical slice
-        v_slice = image[row, :]
-        y_axis = np.arange(v_slice.shape[0])
-        self.y_roi.plot_item.clear()
-        self.y_roi.plot_item.plot(v_slice, y_axis, pen=pg.mkPen(self.y_roi.curve_color, width=3))
-
     ################################################################################
     # Widget Specific Properties
     ################################################################################
-    ################################################################################
-    # Rois
-
-    @property
-    def rois(self) -> list[BaseROI]:
-        """
-        Get the list of ROIs.
-        """
-        return self.roi_controller.rois
 
     ################################################################################
     # Colorbar toggle
@@ -915,21 +656,21 @@ class Image(PlotBase):
         self._main_image.log = enable
 
     @SafeProperty(int)
-    def num_rotation_90(self) -> int:
+    def rotation(self) -> int:
         """
-        The number of 90° rotations to apply counterclockwise.
+        The number of 90° rotations to apply.
         """
-        return self._main_image.num_rotation_90
+        return self._main_image.rotation
 
-    @num_rotation_90.setter
-    def num_rotation_90(self, value: int):
+    @rotation.setter
+    def rotation(self, value: int):
         """
-        Set the number of 90° rotations to apply counterclockwise.
+        Set the number of 90° rotations to apply.
 
         Args:
             value(int): The number of 90° rotations to apply.
         """
-        self._main_image.num_rotation_90 = value
+        self._main_image.rotation = value
 
     @SafeProperty(bool)
     def transpose(self) -> bool:
@@ -1021,19 +762,6 @@ class Image(PlotBase):
                 self.selection_bundle.dim_combo_box,
             ):
                 combo.blockSignals(False)
-        else:
-            for combo in (
-                self.selection_bundle.device_combo_box,
-                self.selection_bundle.dim_combo_box,
-            ):
-                combo.blockSignals(True)
-            self.selection_bundle.device_combo_box.setCurrentText("")
-            self.selection_bundle.dim_combo_box.setCurrentText("auto")
-            for combo in (
-                self.selection_bundle.device_combo_box,
-                self.selection_bundle.dim_combo_box,
-            ):
-                combo.blockSignals(False)
 
     ################################################################################
     # Image Update Methods
@@ -1084,7 +812,6 @@ class Image(PlotBase):
             self.on_image_update_2d, MessageEndpoints.device_monitor_2d(monitor)
         )
         self._main_image.config.monitor = None
-        self._sync_device_selection()
 
     ########################################
     # 1D updates
@@ -1114,7 +841,6 @@ class Image(PlotBase):
         self._main_image.set_data(image_buffer)
         if self._color_bar is not None:
             self._color_bar.blockSignals(False)
-        self.image_updated.emit()
 
     def adjust_image_buffer(self, image: ImageItem, new_data: np.ndarray) -> np.ndarray:
         """
@@ -1166,7 +892,6 @@ class Image(PlotBase):
         self._main_image.set_data(data)
         if self._color_bar is not None:
             self._color_bar.blockSignals(False)
-        self.image_updated.emit()
 
     ################################################################################
     # Clean up
@@ -1192,11 +917,6 @@ class Image(PlotBase):
         """
         Disconnect the image update signals and clean up the image.
         """
-        # Remove all ROIs
-        rois = self.rois
-        for roi in rois:
-            roi.remove()
-
         # Main Image cleanup
         if self._main_image.config.monitor is not None:
             self.disconnect_monitor(self._main_image.config.monitor)
@@ -1213,38 +933,20 @@ class Image(PlotBase):
                 self._color_bar.deleteLater()
             self._color_bar = None
 
-        # Popup cleanup
-        if self.roi_manager_dialog is not None:
-            self.roi_manager_dialog.reject()
-            self.roi_manager_dialog = None
-
         # Toolbar cleanup
         self.toolbar.widgets["monitor"].widget.close()
         self.toolbar.widgets["monitor"].widget.deleteLater()
 
-        # ROI plots cleanup
-        self.x_roi.cleanup_pyqtgraph()
-        self.y_roi.cleanup_pyqtgraph()
-
         super().cleanup()
 
 
 if __name__ == "__main__":  # pragma: no cover
     import sys
 
-    from qtpy.QtWidgets import QApplication, QHBoxLayout
+    from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
-    win = QWidget()
-    win.setWindowTitle("Image Demo")
-    ml = QHBoxLayout(win)
-
-    image_popup = Image(popups=True)
-    image_side_panel = Image(popups=False)
-
-    ml.addWidget(image_popup)
-    ml.addWidget(image_side_panel)
-
-    win.resize(1500, 800)
-    win.show()
+    widget = Image(popups=True)
+    widget.show()
+    widget.resize(1000, 800)
     sys.exit(app.exec_())

bec_widgets/widgets/plots/image/image_item.py

@@ -24,7 +24,7 @@ class ImageItemConfig(ConnectionConfig):  # TODO review config
     monitor: str | None = Field(None, description="The name of the monitor.")
     monitor_type: Literal["1d", "2d", "auto"] = Field("auto", description="The type of monitor.")
     source: str | None = Field(None, description="The source of the curve.")
-    color_map: str | None = Field("plasma", description="The color map of the image.")
+    color_map: str | None = Field("magma", description="The color map of the image.")
     downsample: bool | None = Field(True, description="Whether to downsample the image.")
     opacity: float | None = Field(1.0, description="The opacity of the image.")
     v_range: tuple[float | int, float | int] | None = Field(
@@ -61,8 +61,8 @@ class ImageItem(BECConnector, pg.ImageItem):
         "fft.setter",
         "log",
         "log.setter",
-        "num_rotation_90",
-        "num_rotation_90.setter",
+        "rotation",
+        "rotation.setter",
         "transpose",
         "transpose.setter",
         "get_data",
@@ -86,6 +86,7 @@ class ImageItem(BECConnector, pg.ImageItem):
             self.set_parent(parent_image)
         else:
             self.parent_image = None
+            self.parent_id = None
         super().__init__(config=config, gui_id=gui_id, **kwargs)
 
         self.raw_data = None
@@ -97,6 +98,7 @@ class ImageItem(BECConnector, pg.ImageItem):
 
     def set_parent(self, parent: BECConnector):
         self.parent_image = parent
+        self.parent_id = parent.gui_id
 
     def parent(self):
         return self.parent_image
@@ -239,13 +241,13 @@ class ImageItem(BECConnector, pg.ImageItem):
         self._process_image()
 
     @property
-    def num_rotation_90(self) -> Optional[int]:
+    def rotation(self) -> Optional[int]:
         """Get or set the number of 90° rotations to apply."""
-        return self.config.processing.num_rotation_90
+        return self.config.processing.rotation
 
-    @num_rotation_90.setter
-    def num_rotation_90(self, value: Optional[int]):
-        self.config.processing.num_rotation_90 = value
+    @rotation.setter
+    def rotation(self, value: Optional[int]):
+        self.config.processing.rotation = value
         self._process_image()
 
     @property
@@ -273,7 +275,3 @@ class ImageItem(BECConnector, pg.ImageItem):
         self.raw_data = None
         self.buffer = []
         self.max_len = 0
-
-    def remove(self):
-        self.parent().disconnect_monitor(self.config.monitor)
-        self.clear()

bec_widgets/widgets/plots/image/image_processor.py

@@ -37,7 +37,7 @@ class ProcessingConfig(BaseModel):
     transpose: bool = Field(
         False, description="Whether to transpose the monitor data before displaying."
     )
-    num_rotation_90: int = Field(
+    rotation: int = Field(
         0, description="The rotation angle of the monitor data before displaying."
     )
     stats: ImageStats = Field(
@@ -140,8 +140,8 @@ class ImageProcessor(QObject):
         """Core processing logic without threading overhead."""
         if self.config.fft:
             data = self.FFT(data)
-        if self.config.num_rotation_90 is not None:
-            data = self.rotation(data, self.config.num_rotation_90)
+        if self.config.rotation is not None:
+            data = self.rotation(data, self.config.rotation)
         if self.config.transpose:
             data = self.transpose(data)
         if self.config.log:

bec_widgets/widgets/plots/image/image_roi_plot.py

@@ -1,37 +0,0 @@
-import pyqtgraph as pg
-
-from bec_widgets.utils.round_frame import RoundedFrame
-from bec_widgets.widgets.plots.plot_base import BECViewBox
-
-
-class ImageROIPlot(RoundedFrame):
-    """
-    A widget for displaying an image with a region of interest (ROI) overlay.
-    """
-
-    def __init__(self, parent=None):
-        super().__init__(parent=parent)
-
-        self.content_widget = pg.GraphicsLayoutWidget(self)
-        self.layout.addWidget(self.content_widget)
-        self.plot_item = pg.PlotItem(viewBox=BECViewBox(enableMenu=True))
-        self.content_widget.addItem(self.plot_item)
-        self.curve_color = "w"
-
-        self.apply_plot_widget_style()
-
-    def apply_theme(self, theme: str):
-        if theme == "dark":
-            self.curve_color = "w"
-        else:
-            self.curve_color = "k"
-        for curve in self.plot_item.curves:
-            curve.setPen(pg.mkPen(self.curve_color, width=3))
-        super().apply_theme(theme)
-
-    def cleanup_pyqtgraph(self):
-        """Cleanup pyqtgraph items."""
-        self.plot_item.vb.menu.close()
-        self.plot_item.vb.menu.deleteLater()
-        self.plot_item.ctrlMenu.close()
-        self.plot_item.ctrlMenu.deleteLater()