fix(dock): fix cleanup of dock_label in dock, remove logger.warning

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

.github/workflows/formatter.yml

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

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

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

.github/workflows/pytest-matrix.yml

@@ -1,59 +0,0 @@
-name: Run Pytest with different Python versions
-on: 
-  workflow_call:
-    inputs:
-      pr_number:
-        description: 'Pull request number'
-        required: false
-        type: number
-      BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
-        required: false
-        default: 'main'
-        type: string
-      OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
-        required: false
-        default: 'main'
-        type: string
-      BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
-        required: false
-        default: 'main'
-        type: string
-
-jobs:
-  pytest-matrix:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.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/stale-issues.yml

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

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

@@ -5,7 +5,7 @@ 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,9 +141,6 @@ 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)
@@ -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, type[BECWidget]] = get_all_plugin_widgets().as_dict()
-        if self.available_widgets:
-            plugin_repo_name = next(iter(self.available_widgets.values())).__module__.split(".")[0]
-            plugin_repo_name = plugin_repo_name.removesuffix("_bec").upper()
-            self.register_tile(
-                name="widget",
-                icon_path=os.path.join(
-                    MODULE_PATH, "assets", "app_icons", "widget_launch_tile.png"
-                ),
-                top_label="Get quickly started",
-                main_label=f"Launch a {plugin_repo_name} Widget",
-                description=f"GUI application with one widget from the {plugin_repo_name} repository.",
-                action_button=self._open_widget,
-                show_selector=True,
-                selector_items=list(self.available_widgets.keys()),
-            )
+        # 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,
@@ -353,8 +231,10 @@ 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)
-
+                if not WidgetContainerUtils.has_name_valid_chars(name):
+                    raise ValueError(
+                        f"Name {name} contains invalid characters. Only alphanumeric characters, underscores, and dashes are allowed."
+                    )
             else:
                 name = "dock_area"
                 name = WidgetContainerUtils.generate_unique_name(name, existing_dock_areas)
@@ -374,12 +254,6 @@ class LaunchWindow(BECMainWindow):
                 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 +271,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 +280,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 +317,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 +330,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 +377,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

@@ -7,7 +7,6 @@ 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
@@ -51,20 +50,16 @@ _Widgets = {
     "RingProgressBar": "RingProgressBar",
     "ScanControl": "ScanControl",
     "ScatterWaveform": "ScatterWaveform",
-    "SignalComboBox": "SignalComboBox",
-    "SignalLabel": "SignalLabel",
-    "SignalLineEdit": "SignalLineEdit",
     "StopButton": "StopButton",
     "TextBox": "TextBox",
     "VSCodeEditor": "VSCodeEditor",
     "Waveform": "Waveform",
-    "WebConsole": "WebConsole",
     "WebsiteWidget": "WebsiteWidget",
 }
 
 
 try:
-    _plugin_widgets = get_all_plugin_widgets().as_dict()
+    _plugin_widgets = get_all_plugin_widgets()
     plugin_client = get_plugin_client_module()
     Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
 
@@ -474,12 +469,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."""
@@ -494,12 +483,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):
         """
@@ -507,264 +490,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 movable(self) -> "bool":
-        """
-        Gets whether this ROI is movable.
-
-        Returns:
-            bool: True if the ROI can be moved, False otherwise.
-        """
-
-    @movable.setter
-    @rpc_call
-    def movable(self) -> "bool":
-        """
-        Gets whether this ROI is movable.
-
-        Returns:
-            bool: True if the ROI can be moved, False otherwise.
-        """
-
-    @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 movable(self) -> "bool":
-        """
-        Gets whether this ROI is movable.
-
-        Returns:
-            bool: True if the ROI can be moved, False otherwise.
-        """
-
-    @movable.setter
-    @rpc_call
-    def movable(self) -> "bool":
-        """
-        Gets whether this ROI is movable.
-
-        Returns:
-            bool: True if the ROI can be moved, False otherwise.
-        """
-
-    @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):
@@ -982,22 +707,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
         """
 
 
@@ -1015,32 +727,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
         """
 
 
@@ -1264,16 +953,44 @@ class Image(RPCBase):
 
     @property
     @rpc_call
-    def minimal_crosshair_precision(self) -> "int":
+    def x_log(self) -> "bool":
         """
-        Minimum decimal places for crosshair when dynamic precision is enabled.
+        Set X-axis to log scale if True, linear if False.
         """
 
-    @minimal_crosshair_precision.setter
+    @x_log.setter
     @rpc_call
-    def minimal_crosshair_precision(self) -> "int":
+    def x_log(self) -> "bool":
         """
-        Minimum decimal places for crosshair when dynamic precision is enabled.
+        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
@@ -1292,16 +1009,16 @@ class Image(RPCBase):
 
     @property
     @rpc_call
-    def v_range(self) -> "QPointF":
+    def vrange(self) -> "tuple":
         """
-        Set the v_range of the main image.
+        Get the vrange of the image.
         """
 
-    @v_range.setter
+    @vrange.setter
     @rpc_call
-    def v_range(self) -> "QPointF":
+    def vrange(self) -> "tuple":
         """
-        Set the v_range of the main image.
+        Get the vrange of the image.
         """
 
     @property
@@ -1470,16 +1187,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
@@ -1499,12 +1216,12 @@ class Image(RPCBase):
     @rpc_call
     def image(
         self,
-        monitor: "str | tuple | None" = None,
+        monitor: "str | None" = None,
         monitor_type: "Literal['auto', '1d', '2d']" = "auto",
         color_map: "str | None" = None,
         color_bar: "Literal['simple', 'full'] | None" = None,
         vrange: "tuple[int, int] | None" = None,
-    ) -> "ImageItem | None":
+    ) -> "ImageItem":
         """
         Set the image source and update the image.
 
@@ -1526,46 +1243,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),
-        movable: "bool" = True,
-        **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.
-            movable(bool): Whether the ROI is movable.
-            **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
@@ -1682,14 +1359,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.
         """
@@ -2407,20 +2084,6 @@ class MultiWaveform(RPCBase):
         The font size of the legend font.
         """
 
-    @property
-    @rpc_call
-    def minimal_crosshair_precision(self) -> "int":
-        """
-        Minimum decimal places for crosshair when dynamic precision is enabled.
-        """
-
-    @minimal_crosshair_precision.setter
-    @rpc_call
-    def minimal_crosshair_precision(self) -> "int":
-        """
-        Minimum decimal places for crosshair when dynamic precision is enabled.
-        """
-
     @property
     @rpc_call
     def highlighted_index(self):
@@ -2683,135 +2346,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 movable(self) -> "bool":
-        """
-        Gets whether this ROI is movable.
-
-        Returns:
-            bool: True if the ROI can be moved, False otherwise.
-        """
-
-    @movable.setter
-    @rpc_call
-    def movable(self) -> "bool":
-        """
-        Gets whether this ROI is movable.
-
-        Returns:
-            bool: True if the ROI can be moved, False otherwise.
-        """
-
-    @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."""
 
@@ -3406,20 +2940,6 @@ class ScatterWaveform(RPCBase):
         The font size of the legend font.
         """
 
-    @property
-    @rpc_call
-    def minimal_crosshair_precision(self) -> "int":
-        """
-        Minimum decimal places for crosshair when dynamic precision is enabled.
-        """
-
-    @minimal_crosshair_precision.setter
-    @rpc_call
-    def minimal_crosshair_precision(self) -> "int":
-        """
-        Minimum decimal places for crosshair when dynamic precision is enabled.
-        """
-
     @property
     @rpc_call
     def main_curve(self) -> "ScatterCurve":
@@ -3490,152 +3010,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 SignalLabel(RPCBase):
-    @property
-    @rpc_call
-    def custom_label(self) -> "str":
-        """
-        Use a cusom label rather than the signal name
-        """
-
-    @property
-    @rpc_call
-    def custom_units(self) -> "str":
-        """
-        Use a custom unit string
-        """
-
-    @custom_label.setter
-    @rpc_call
-    def custom_label(self) -> "str":
-        """
-        Use a cusom label rather than the signal name
-        """
-
-    @custom_units.setter
-    @rpc_call
-    def custom_units(self) -> "str":
-        """
-        Use a custom unit string
-        """
-
-    @property
-    @rpc_call
-    def decimal_places(self) -> "int":
-        """
-        Format to a given number of decimal_places. Set to 0 to disable.
-        """
-
-    @decimal_places.setter
-    @rpc_call
-    def decimal_places(self) -> "int":
-        """
-        Format to a given number of decimal_places. Set to 0 to disable.
-        """
-
-    @property
-    @rpc_call
-    def show_default_units(self) -> "bool":
-        """
-        Show default units obtained from the signal alongside it
-        """
-
-    @show_default_units.setter
-    @rpc_call
-    def show_default_units(self) -> "bool":
-        """
-        Show default units obtained from the signal alongside it
-        """
-
-    @property
-    @rpc_call
-    def show_select_button(self) -> "bool":
-        """
-        Show the button to select the signal to display
-        """
-
-    @show_select_button.setter
-    @rpc_call
-    def show_select_button(self) -> "bool":
-        """
-        Show the button to select the signal to display
-        """
-
-
-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."""
 
@@ -3966,20 +3340,6 @@ class Waveform(RPCBase):
         The font size of the legend font.
         """
 
-    @property
-    @rpc_call
-    def minimal_crosshair_precision(self) -> "int":
-        """
-        Minimum decimal places for crosshair when dynamic precision is enabled.
-        """
-
-    @minimal_crosshair_precision.setter
-    @rpc_call
-    def minimal_crosshair_precision(self) -> "int":
-        """
-        Minimum decimal places for crosshair when dynamic precision is enabled.
-        """
-
     @property
     @rpc_call
     def curves(self) -> "list[Curve]":
@@ -4004,20 +3364,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":
@@ -4032,48 +3378,6 @@ class Waveform(RPCBase):
         The color palette of the figure widget.
         """
 
-    @property
-    @rpc_call
-    def skip_large_dataset_warning(self) -> "bool":
-        """
-        Whether to skip the large dataset warning when fetching async data.
-        """
-
-    @skip_large_dataset_warning.setter
-    @rpc_call
-    def skip_large_dataset_warning(self) -> "bool":
-        """
-        Whether to skip the large dataset warning when fetching async data.
-        """
-
-    @property
-    @rpc_call
-    def skip_large_dataset_check(self) -> "bool":
-        """
-        Whether to skip the large dataset warning when fetching async data.
-        """
-
-    @skip_large_dataset_check.setter
-    @rpc_call
-    def skip_large_dataset_check(self) -> "bool":
-        """
-        Whether to skip the large dataset warning when fetching async data.
-        """
-
-    @property
-    @rpc_call
-    def max_dataset_size_mb(self) -> "float":
-        """
-        The maximum dataset size (in MB) permitted when fetching async data from history before prompting the user.
-        """
-
-    @max_dataset_size_mb.setter
-    @rpc_call
-    def max_dataset_size_mb(self) -> "float":
-        """
-        The maximum dataset size (in MB) permitted when fetching async data from history before prompting the user.
-        """
-
     @rpc_call
     def plot(
         self,
@@ -4212,16 +3516,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/generate_cli.py

@@ -41,7 +41,6 @@ class ClientGenerator:
 import inspect
 import traceback
 from functools import reduce
-from operator import add
 from typing import Literal, Optional
 """
             if self._base
@@ -111,7 +110,7 @@ _Widgets = {
             self.content += """
 
 try:
-    _plugin_widgets = get_all_plugin_widgets().as_dict()
+    _plugin_widgets = get_all_plugin_widgets()
     plugin_client = get_plugin_client_module()
     Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
 
@@ -223,18 +222,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)
@@ -319,5 +318,5 @@ def main():
 if __name__ == "__main__":  # pragma: no cover
     import sys
 
-    sys.argv = ["bw-generate-cli", "--target", "bec_widgets"]
+    sys.argv = ["bw-generate-cli", "--target", "csaxs_bec"]
     main()

bec_widgets/cli/rpc/rpc_widget_handler.py

@@ -31,9 +31,10 @@ class RPCWidgetHandler:
         Returns:
             None
         """
-        self._widget_classes = (
-            get_custom_classes("bec_widgets") + get_all_plugin_widgets()
-        ).as_dict(IGNORE_WIDGETS)
+        clss = get_custom_classes("bec_widgets")
+        self._widget_classes = get_all_plugin_widgets() | {
+            cls.__name__: cls for cls in clss.widgets if cls.__name__ not in IGNORE_WIDGETS
+        }
 
     def create_widget(self, widget_type, **kwargs) -> BECWidget:
         """

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
@@ -37,10 +38,6 @@ class SimpleFileLikeFromLogOutputFunc:
             self._log_func(lines)
         self._buffer = [remaining]
 
-    @property
-    def encoding(self):
-        return "utf-8"
-
     def close(self):
         return
 
@@ -86,6 +83,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 +125,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 = {
@@ -184,8 +184,8 @@ class FakePositioner(BECPositioner):
 class Positioner(FakePositioner):
     """just placeholder for testing embedded isinstance check in DeviceCombobox"""
 
-    def __init__(self, name="test", limits=None, read_value=1.0, enabled=True):
-        super().__init__(name, limits=limits, read_value=read_value, enabled=enabled)
+    def __init__(self, name="test", limits=None, read_value=1.0):
+        super().__init__(name, limits, read_value)
 
 
 class Device(FakeDevice):
@@ -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

@@ -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
@@ -143,6 +131,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,6 +150,11 @@ class BECConnector:
 
         # 2) Enforce unique objectName among siblings with the same BECConnector parent
         self.setParent(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
+
         if isinstance(self.parent(), QObject) and hasattr(self, "cleanup"):
             self.parent().destroyed.connect(self._run_cleanup_on_deleted_parent)
 
@@ -171,21 +165,8 @@ 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:
         """
@@ -205,17 +186,6 @@ class BECConnector:
                 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:
         """
         Enforce a unique object name among siblings and register the object for RPC.

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
@@ -26,41 +25,21 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 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 +86,7 @@ class BECDispatcher:
         cls,
         client=None,
         config: str | ServiceConfig | None = None,
-        gui_id: str | None = None,
+        gui_id: str = None,
         *args,
         **kwargs,
     ):
@@ -120,9 +99,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:
@@ -163,8 +140,7 @@ class BECDispatcher:
     def connect_slot(
         self,
         slot: Callable,
-        topics: EndpointInfo | str | list[EndpointInfo] | list[str],
-        cb_info: dict | None = None,
+        topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]],
         **kwargs,
     ) -> None:
         """Connect widget's qt slot, so that it is called on new pub/sub topic message.
@@ -172,40 +148,34 @@ class BECDispatcher:
         Args:
             slot (Callable): A slot method/function that accepts two inputs: content and metadata of
                 the corresponding pub/sub message
-            topics EndpointInfo | str | list[EndpointInfo] | list[str]: 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.
+            topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
         """
-        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: EndpointInfo | str | list[EndpointInfo] | list[str]
-    ):
+    def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
         """
         Disconnect a slot from a topic.
 
         Args:
             slot(Callable): The slot to disconnect
-            topics EndpointInfo | str | list[EndpointInfo] | list[str]: A topic or list of topics to unsub from.
+            topics(Union[str, list]): The topic(s) to disconnect from
         """
         # 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]):
         """
@@ -216,16 +186,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

@@ -3,17 +3,12 @@ from __future__ import annotations
 import importlib.metadata
 import inspect
 import pkgutil
-import traceback
 from importlib import util as importlib_util
 from importlib.machinery import FileFinder, ModuleSpec, SourceFileLoader
 from types import ModuleType
 from typing import Generator
 
-from bec_lib.logger import bec_logger
-
-from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
-
-logger = bec_logger.logger
+from bec_widgets.utils.bec_widget import BECWidget
 
 
 def _submodule_specs(module: ModuleType) -> tuple[ModuleSpec | None, ...]:
@@ -26,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 (
@@ -35,12 +30,7 @@ def _loaded_submodules_from_specs(
         assert isinstance(
             submodule.__loader__, SourceFileLoader
         ), "Module found from FileFinder should have SourceFileLoader!"
-        try:
-            submodule.__loader__.exec_module(submodule)
-        except Exception as e:
-            logger.error(
-                f"Error loading plugin {submodule}: \n{''.join(traceback.format_exception(e))}"
-            )
+        submodule.__loader__.exec_module(submodule)
         yield submodule
 
 
@@ -51,29 +41,27 @@ def _submodule_by_name(module: ModuleType, name: str):
     return None
 
 
-def _get_widgets_from_module(module: ModuleType) -> BECClassContainer:
-    """Find any BECWidget subclasses in the given module and return them with their info."""
+def _get_widgets_from_module(module: ModuleType) -> dict[str, "type[BECWidget]"]:
+    """Find any BECWidget subclasses in the given module and return them with their names."""
     from bec_widgets.utils.bec_widget import BECWidget  # avoid circular import
 
-    classes = inspect.getmembers(
-        module,
-        predicate=lambda item: inspect.isclass(item)
-        and issubclass(item, BECWidget)
-        and item is not BECWidget,
-    )
-    return BECClassContainer(
-        BECClassInfo(name=k, module=module.__name__, file=module.__loader__.get_filename(), obj=v)
-        for k, v in classes
+    return dict(
+        inspect.getmembers(
+            module,
+            predicate=lambda item: inspect.isclass(item)
+            and issubclass(item, BECWidget)
+            and item is not BECWidget,
+        )
     )
 
 
-def _all_widgets_from_all_submods(module) -> BECClassContainer:
+def _all_widgets_from_all_submods(module):
     """Recursively load submodules, find any BECWidgets, and return them all as a flat dict."""
     widgets = _get_widgets_from_module(module)
     if not hasattr(module, "__path__"):
         return widgets
     for submod in _loaded_submodules_from_specs(_submodule_specs(module)):
-        widgets += _all_widgets_from_all_submods(submod)
+        widgets.update(_all_widgets_from_all_submods(submod))
     return widgets
 
 
@@ -87,16 +75,15 @@ def get_plugin_client_module() -> ModuleType | None:
     return _submodule_by_name(plugin, "client") if (plugin := user_widget_plugin()) else None
 
 
-def get_all_plugin_widgets() -> BECClassContainer:
+def get_all_plugin_widgets() -> dict[str, "type[BECWidget]"]:
     """If there is a plugin repository installed, load all widgets from it."""
     if plugin := user_widget_plugin():
         return _all_widgets_from_all_submods(plugin)
     else:
-        return BECClassContainer()
+        return {}
 
 
 if __name__ == "__main__":  # pragma: no cover
-
+    #  print(get_all_plugin_widgets())
     client = get_plugin_client_module()
-    print(get_all_plugin_widgets())
     ...

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

bec_widgets/utils/clickable_label.py

@@ -1,13 +0,0 @@
-from __future__ import annotations
-
-from qtpy.QtCore import Signal
-from qtpy.QtGui import QMouseEvent
-from qtpy.QtWidgets import QLabel
-
-
-class ClickableLabel(QLabel):
-    clicked = Signal()
-
-    def mouseReleaseEvent(self, ev: QMouseEvent) -> None:
-        self.clicked.emit()
-        return super().mouseReleaseEvent(ev)

bec_widgets/utils/colors.py

@@ -15,15 +15,12 @@ if TYPE_CHECKING:  # pragma: no cover
     from bec_qthemes._main import AccentColors
 
 
-def get_theme_name():
-    if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
-        return "dark"
-    else:
-        return QApplication.instance().theme.theme
-
-
 def get_theme_palette():
-    return bec_qthemes.load_palette(get_theme_name())
+    if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
+        theme = "dark"
+    else:
+        theme = QApplication.instance().theme.theme
+    return bec_qthemes.load_palette(theme)
 
 
 def get_accent_colors() -> AccentColors | None:

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

@@ -34,21 +34,13 @@ class Crosshair(QObject):
     coordinatesChanged2D = Signal(tuple)
     coordinatesClicked2D = Signal(tuple)
 
-    def __init__(
-        self,
-        plot_item: pg.PlotItem,
-        precision: int | None = None,
-        *,
-        min_precision: int = 2,
-        parent=None,
-    ):
+    def __init__(self, plot_item: pg.PlotItem, precision: int = 3, parent=None):
         """
         Crosshair for 1D and 2D plots.
 
         Args:
             plot_item (pyqtgraph.PlotItem): The plot item to which the crosshair will be attached.
-            precision (int | None, optional): Fixed number of decimal places to display. If *None*, precision is chosen dynamically from the current view range.
-            min_precision (int, optional): The lower bound (in decimal places) used when dynamic precision is enabled. Defaults to 2.
+            precision (int, optional): Number of decimal places to round the coordinates to. Defaults to None.
             parent (QObject, optional): Parent object for the QObject. Defaults to None.
         """
         super().__init__(parent)
@@ -56,9 +48,7 @@ class Crosshair(QObject):
         self.is_log_x = None
         self.is_derivative = None
         self.plot_item = plot_item
-        self._precision = precision
-        self._min_precision = max(0, int(min_precision))  # ensure non‑negative
-
+        self.precision = precision
         self.v_line = pg.InfiniteLine(angle=90, movable=False)
         self.v_line.skip_auto_range = True
         self.h_line = pg.InfiniteLine(angle=0, movable=False)
@@ -95,64 +85,13 @@ 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()
 
         self._connect_to_theme_change()
 
-    @property
-    def precision(self) -> int | None:
-        """Fixed number of decimals; ``None`` enables dynamic mode."""
-        return self._precision
-
-    @precision.setter
-    def precision(self, value: int | None):
-        """
-        Set the fixed number of decimals to display.
-
-        Args:
-            value(int | None): The number of decimals to display. If `None`, dynamic precision is used based on the view range.
-        """
-        self._precision = value
-
-    @property
-    def min_precision(self) -> int:
-        """Lower bound on decimals when dynamic precision is used."""
-        return self._min_precision
-
-    @min_precision.setter
-    def min_precision(self, value: int):
-        """
-        Set the lower bound on decimals when dynamic precision is used.
-
-        Args:
-            value(int): The minimum number of decimals to display. Must be non-negative.
-        """
-        self._min_precision = max(0, int(value))
-
-    def _current_precision(self) -> int:
-        """
-        Get the current precision based on the view range or fixed precision.
-        """
-        if self._precision is not None:
-            return self._precision
-
-        # Dynamically choose precision from the smaller visible span
-        view_range = self.plot_item.vb.viewRange()
-        x_span = abs(view_range[0][1] - view_range[0][0])
-        y_span = abs(view_range[1][1] - view_range[1][0])
-
-        # Ignore zero spans that can appear during initialisation
-        spans = [s for s in (x_span, y_span) if s > 0]
-        span = min(spans) if spans else 1.0
-
-        exponent = np.floor(np.log10(span))  # order of magnitude
-        decimals = max(0, int(-exponent) + 1)
-        return max(self._min_precision, decimals)
-
     def _connect_to_theme_change(self):
         """Connect to the theme change signal."""
         qapp = QApplication.instance()
@@ -256,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
@@ -312,10 +241,8 @@ class Crosshair(QObject):
                     y_values[name] = closest_y
                     x_values[name] = closest_x
             elif isinstance(item, pg.ImageItem):  # 2D plot
-                name = item.objectName() or str(id(item))
+                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))
@@ -384,7 +311,6 @@ class Crosshair(QObject):
                 # not sure how we got here, but just to be safe...
                 return
 
-            precision = self._current_precision()
             for item in self.items:
                 if isinstance(item, pg.PlotDataItem):
                     name = item.name() or str(id(item))
@@ -395,19 +321,16 @@ class Crosshair(QObject):
                     x_snapped_scaled, y_snapped_scaled = self.scale_emitted_coordinates(x, y)
                     coordinate_to_emit = (
                         name,
-                        round(x_snapped_scaled, precision),
-                        round(y_snapped_scaled, precision),
+                        round(x_snapped_scaled, self.precision),
+                        round(y_snapped_scaled, self.precision),
                     )
                     self.coordinatesChanged1D.emit(coordinate_to_emit)
                 elif isinstance(item, pg.ImageItem):
-                    name = item.objectName() or str(id(item))
+                    name = item.config.monitor or str(id(item))
                     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:
@@ -441,7 +364,6 @@ class Crosshair(QObject):
                 # not sure how we got here, but just to be safe...
                 return
 
-            precision = self._current_precision()
             for item in self.items:
                 if isinstance(item, pg.PlotDataItem):
                     name = item.name() or str(id(item))
@@ -453,19 +375,16 @@ class Crosshair(QObject):
                     x_snapped_scaled, y_snapped_scaled = self.scale_emitted_coordinates(x, y)
                     coordinate_to_emit = (
                         name,
-                        round(x_snapped_scaled, precision),
-                        round(y_snapped_scaled, precision),
+                        round(x_snapped_scaled, self.precision),
+                        round(y_snapped_scaled, self.precision),
                     )
                     self.coordinatesClicked1D.emit(coordinate_to_emit)
                 elif isinstance(item, pg.ImageItem):
-                    name = item.objectName() or str(id(item))
+                    name = item.config.monitor or str(id(item))
                     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:
@@ -505,17 +424,14 @@ class Crosshair(QObject):
         """
         x, y = pos
         x_scaled, y_scaled = self.scale_emitted_coordinates(x, y)
-        precision = self._current_precision()
-        text = f"({x_scaled:.{precision}f}, {y_scaled:.{precision}f})"
+        text = f"({x_scaled:.{self.precision}g}, {y_scaled:.{self.precision}g})"
         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]
-                text += f"\nIntensity: {intensity:.{precision}f}"
+                text += f"\nIntensity: {intensity:.{self.precision}g}"
                 break
         # Update coordinate label
         self.coord_label.setText(text)
@@ -534,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

@@ -1,9 +1,7 @@
 from __future__ import annotations
 
 from bec_qthemes import material_icon
-from qtpy.QtCore import Signal
 from qtpy.QtWidgets import (
-    QApplication,
     QFrame,
     QHBoxLayout,
     QLabel,
@@ -14,20 +12,15 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
-from bec_widgets.utils.clickable_label import ClickableLabel
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 
 
 class ExpandableGroupFrame(QFrame):
 
-    expansion_state_changed = Signal()
-
     EXPANDED_ICON_NAME: str = "collapse_all"
     COLLAPSED_ICON_NAME: str = "expand_all"
 
-    def __init__(
-        self, parent: QWidget | None = None, title: str = "", expanded: bool = True, icon: str = ""
-    ) -> None:
+    def __init__(self, title: str, parent: QWidget | None = None, expanded: bool = True) -> None:
         super().__init__(parent=parent)
         self._expanded = expanded
 
@@ -36,28 +29,19 @@ class ExpandableGroupFrame(QFrame):
         self._layout = QVBoxLayout()
         self._layout.setContentsMargins(0, 0, 0, 0)
         self.setLayout(self._layout)
-
         self._title_layout = QHBoxLayout()
         self._layout.addLayout(self._title_layout)
-
-        self._title = ClickableLabel(f"<b>{title}</b>")
-        self._title_icon = ClickableLabel()
-        self._title_layout.addWidget(self._title_icon)
-        self._title_layout.addWidget(self._title)
-        self.icon_name = icon
-
-        self._title_layout.addStretch(1)
-
         self._expansion_button = QToolButton()
-        self._update_expansion_icon()
-        self._title_layout.addWidget(self._expansion_button, stretch=1)
+        self._update_icon()
+        self._title = QLabel(f"<b>{title}</b>")
+        self._title_layout.addWidget(self._expansion_button)
+        self._title_layout.addWidget(self._title)
 
         self._contents = QWidget(self)
         self._layout.addWidget(self._contents)
 
         self._expansion_button.clicked.connect(self.switch_expanded_state)
         self.expanded = self._expanded  # type: ignore
-        self.expansion_state_changed.emit()
 
     def set_layout(self, layout: QLayout) -> None:
         self._contents.setLayout(layout)
@@ -66,8 +50,7 @@ class ExpandableGroupFrame(QFrame):
     @SafeSlot()
     def switch_expanded_state(self):
         self.expanded = not self.expanded  # type: ignore
-        self._update_expansion_icon()
-        self.expansion_state_changed.emit()
+        self._update_icon()
 
     @SafeProperty(bool)
     def expanded(self):  # type: ignore
@@ -78,9 +61,8 @@ class ExpandableGroupFrame(QFrame):
         self._expanded = expanded
         self._contents.setVisible(expanded)
         self.updateGeometry()
-        self.adjustSize()
 
-    def _update_expansion_icon(self):
+    def _update_icon(self):
         self._expansion_button.setIcon(
             material_icon(icon_name=self.EXPANDED_ICON_NAME, size=(10, 10), convert_to_pixmap=False)
             if self.expanded
@@ -88,36 +70,3 @@ class ExpandableGroupFrame(QFrame):
                 icon_name=self.COLLAPSED_ICON_NAME, size=(10, 10), convert_to_pixmap=False
             )
         )
-
-    @SafeProperty(str)
-    def icon_name(self):  # type: ignore
-        return self._title_icon_name
-
-    @icon_name.setter
-    def icon_name(self, icon_name: str):
-        self._title_icon_name = icon_name
-        self._set_title_icon(self._title_icon_name)
-
-    def _set_title_icon(self, icon_name: str):
-        if icon_name:
-            self._title_icon.setVisible(True)
-            self._title_icon.setPixmap(
-                material_icon(icon_name=icon_name, size=(20, 20), convert_to_pixmap=True)
-            )
-        else:
-            self._title_icon.setVisible(False)
-
-
-# Application example
-if __name__ == "__main__":  # pragma: no cover
-
-    app = QApplication([])
-    frame = ExpandableGroupFrame()
-    layout = QVBoxLayout()
-    frame.set_layout(layout)
-    layout.addWidget(QLabel("test1"))
-    layout.addWidget(QLabel("test2"))
-    layout.addWidget(QLabel("test3"))
-
-    frame.show()
-    app.exec()

bec_widgets/utils/forms_from_types/forms.py

@@ -1,261 +0,0 @@
-from __future__ import annotations
-
-from decimal import Decimal
-from types import NoneType
-from typing import NamedTuple
-
-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, QSizePolicy, 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
-from bec_widgets.utils.forms_from_types.items import (
-    DynamicFormItem,
-    DynamicFormItemType,
-    FormItemSpec,
-    widget_from_type,
-)
-
-logger = bec_logger.logger
-
-
-class GridRow(NamedTuple):
-    i: int
-    label: QLabel
-    widget: DynamicFormItem
-
-
-class TypedForm(BECWidget, QWidget):
-    PLUGIN = True
-    ICON_NAME = "list_alt"
-
-    value_changed = Signal()
-
-    RPC = True
-    USER_ACCESS = ["enabled", "enabled.setter"]
-
-    def __init__(
-        self,
-        parent=None,
-        items: list[tuple[str, type]] | None = None,
-        form_item_specs: list[FormItemSpec] | None = None,
-        enabled: bool = True,
-        pretty_display: bool = False,
-        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.
-            enabled (bool, optional):               whether fields are enabled for editing.
-            pretty_display (bool, optional): Whether to use a pretty display for the widget. Defaults to False. If True, disables the widget, doesn't add a clear button, and adapts the stylesheet for non-editable display.
-        """
-        if items is not None and form_item_specs is not None:
-            logger.error(
-                "Must specify one and only one of items and form_item_specs! Ignoring `items`."
-            )
-            items = None
-        if items is None and form_item_specs is None:
-            logger.error("Must specify one and only one of items and form_item_specs!")
-            items = []
-        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, pretty_display=pretty_display)
-                for name, item_type in items  # type: ignore
-            ]
-        )
-        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
-        self._layout = QVBoxLayout()
-        self._layout.setContentsMargins(0, 0, 0, 0)
-        self.setLayout(self._layout)
-
-        self._enabled: bool = enabled
-
-        self._form_grid_container = QWidget(parent=self)
-        self._form_grid_container.setSizePolicy(
-            QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding
-        )
-        self._form_grid = QWidget(parent=self._form_grid_container)
-        self._form_grid.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
-        self._layout.addWidget(self._form_grid_container)
-        self._form_grid_container.setLayout(QVBoxLayout())
-        self._form_grid.setLayout(self._new_grid_layout())
-
-        self.populate()
-        self.enabled = self._enabled  # type: ignore # QProperty
-
-    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)
-        widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
-        grid.addWidget(widget, row, 1)
-
-    def enumerate_form_widgets(self):
-        """Return a generator over the rows of the form, with the row number, the label widget (to
-        which the field name is attached as a property), and the entry widget"""
-        grid: QGridLayout = self._form_grid.layout()  # type: ignore
-        for i in range(grid.rowCount()):
-            yield GridRow(i, grid.itemAtPosition(i, 0).widget(), grid.itemAtPosition(i, 1).widget())
-
-    def _dict_from_grid(self) -> dict[str, DynamicFormItemType]:
-        return {
-            row.label.property("_model_field_name"): row.widget.getValue()
-            for row in self.enumerate_form_widgets()
-        }
-
-    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.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
-        self._form_grid.setLayout(self._new_grid_layout())
-        self._form_grid_container.layout().addWidget(self._form_grid)
-
-        self.update_size()
-
-    def update_size(self):
-        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)
-        return new_grid
-
-    @property
-    def widget_dict(self):
-        return {
-            row.label.property("_model_field_name"): row.widget
-            for row in self.enumerate_form_widgets()
-        }
-
-    @SafeProperty(bool)
-    def enabled(self):
-        return self._enabled
-
-    @enabled.setter
-    def enabled(self, value: bool):
-        self._enabled = value
-        self.setEnabled(value)
-
-
-class PydanticModelForm(TypedForm):
-    metadata_updated = Signal(dict)
-    metadata_cleared = Signal(NoneType)
-
-    def __init__(
-        self,
-        parent=None,
-        data_model: type[BaseModel] | None = None,
-        enabled: bool = True,
-        pretty_display: bool = False,
-        client=None,
-        **kwargs,
-    ):
-        """
-        A form generated from a pydantic model.
-
-        Args:
-            data_model (type[BaseModel]): the model class for which to generate a form.
-            enabled (bool): whether fields are enabled for editing.
-            pretty_display (bool, optional): Whether to use a pretty display for the widget. Defaults to False. If True, disables the widget, doesn't add a clear button, and adapts the stylesheet for non-editable display.
-
-        """
-        self._pretty_display = pretty_display
-        self._md_schema = data_model
-        super().__init__(
-            parent=parent, form_item_specs=self._form_item_specs(), enabled=enabled, 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 set_data(self, data: BaseModel):
-        """Fill the data for the form.
-
-        Args:
-            data (BaseModel):   the data to enter into the form. Must be the same type as the
-                                currently set schema, raises TypeError otherwise."""
-        if not self._md_schema:
-            raise ValueError("Schema not set - can't set data")
-        if not isinstance(data, self._md_schema):
-            raise TypeError(f"Supplied data {data} not of type {self._md_schema}")
-        for form_item in self.enumerate_form_widgets():
-            form_item.widget.setValue(getattr(data, form_item.label.property("_model_field_name")))
-
-    def _form_item_specs(self):
-        return [
-            FormItemSpec(
-                name=name, info=info, item_type=info.annotation, pretty_display=self._pretty_display
-            )
-            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/forms_from_types/styles.py

@@ -1,21 +0,0 @@
-import bec_qthemes
-
-
-def pretty_display_theme(theme: str = "dark"):
-    palette = bec_qthemes.load_palette(theme)
-    foreground = palette.text().color().name()
-    background = palette.base().color().name()
-    border = palette.shadow().color().name()
-    accent = palette.accent().color().name()
-    return f"""
-QWidget {{color: {foreground}; background-color: {background}}}
-QLabel {{ font-weight: bold; }}
-QLineEdit,QLabel,QTreeView {{ border-style: solid; border-width: 2px; border-color: {border} }}
-QRadioButton {{ color: {foreground}; }}
-QRadioButton::indicator::checked {{ color: {accent}; }}
-QCheckBox {{ color: {accent}; }}
-"""
-
-
-if __name__ == "__main__":
-    print(pretty_display_theme())

bec_widgets/utils/generate_designer_plugin.py

@@ -8,9 +8,6 @@ from qtpy.QtCore import QObject
 from bec_widgets.utils.name_utils import pascal_to_snake
 
 EXCLUDED_PLUGINS = ["BECConnector", "BECDockArea", "BECDock", "BECFigure"]
-_PARENT_ARG_REGEX = r".__init__\(\s*(?:parent\)|parent=parent,?|parent,?)"
-_SELF_PARENT_ARG_REGEX = r".__init__\(\s*self,\s*(?:parent\)|parent=parent,?|parent,?)"
-SUPER_INIT_REGEX = re.compile(r"super\(\)" + _PARENT_ARG_REGEX, re.MULTILINE)
 
 
 class PluginFilenames(NamedTuple):
@@ -93,20 +90,34 @@ class DesignerPluginGenerator:
 
         # Check if the widget class calls the super constructor with parent argument
         init_source = inspect.getsource(self.widget.__init__)
-        class_re = re.compile(base_cls[0].__name__ + _SELF_PARENT_ARG_REGEX, re.MULTILINE)
-        cls_init_found = class_re.search(init_source) is not None
-        super_self_re = re.compile(
-            rf"super\({base_cls[0].__name__}, self\)" + _PARENT_ARG_REGEX, re.MULTILINE
+        cls_init_found = (
+            bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent=parent") > 0)
+            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent)") > 0)
+            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent,") > 0)
+        )
+        super_init_found = (
+            bool(
+                init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent=parent") > 0
+            )
+            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent,") > 0)
+            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent)") > 0)
         )
-        super_init_found = super_self_re.search(init_source) is not None
         if issubclass(self.widget.__bases__[0], QObject) and not super_init_found:
-            super_init_found = SUPER_INIT_REGEX.search(init_source) is not None
+            super_init_found = (
+                bool(init_source.find("super().__init__(parent=parent") > 0)
+                or bool(init_source.find("super().__init__(parent,") > 0)
+                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 = SUPER_INIT_REGEX.search(init_source) is not None
+            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(

bec_widgets/utils/linear_region_selector.py

@@ -1,5 +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."""
+""" 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
 

bec_widgets/utils/plugin_utils.py

@@ -4,7 +4,7 @@ import importlib
 import inspect
 import os
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Iterable
+from typing import TYPE_CHECKING
 
 from bec_lib.plugin_helper import _get_available_plugins
 from qtpy.QtWidgets import QGraphicsWidget, QWidget
@@ -90,15 +90,15 @@ class BECClassInfo:
     name: str
     module: str
     file: str
-    obj: type[BECWidget]
+    obj: type
     is_connector: bool = False
     is_widget: bool = False
     is_plugin: bool = False
 
 
 class BECClassContainer:
-    def __init__(self, initial: Iterable[BECClassInfo] = []):
-        self._collection: list[BECClassInfo] = list(initial)
+    def __init__(self):
+        self._collection: list[BECClassInfo] = []
 
     def __repr__(self):
         return str(list(cl.name for cl in self.collection))
@@ -106,16 +106,6 @@ class BECClassContainer:
     def __iter__(self):
         return self._collection.__iter__()
 
-    def __add__(self, other: BECClassContainer):
-        return BECClassContainer((*self, *(c for c in other if c.name not in self.names)))
-
-    def as_dict(self, ignores: list[str] = []) -> dict[str, type[BECWidget]]:
-        """get a dict of {name: Type} for all the entries in the collection.
-
-        Args:
-            ignores(list[str]): a list of class names to exclude from the dictionary."""
-        return {c.name: c.obj for c in self if c.name not in ignores}
-
     def add_class(self, class_info: BECClassInfo):
         """
         Add a class to the collection.
@@ -125,44 +115,53 @@ class BECClassContainer:
         """
         self.collection.append(class_info)
 
-    @property
-    def names(self):
-        """Return a list of class names"""
-        return [c.name for c in self]
-
     @property
     def collection(self):
-        """Get the collection of classes."""
+        """
+        Get the collection of classes.
+        """
         return self._collection
 
     @property
     def connector_classes(self):
-        """Get all connector classes."""
+        """
+        Get all connector classes.
+        """
         return [info.obj for info in self.collection if info.is_connector]
 
     @property
     def top_level_classes(self):
-        """Get all top-level classes."""
+        """
+        Get all top-level classes.
+        """
         return [info.obj for info in self.collection if info.is_plugin]
 
     @property
     def plugins(self):
-        """Get all plugins. These are all classes that are on the top level and are widgets."""
+        """
+        Get all plugins. These are all classes that are on the top level and are widgets.
+        """
         return [info.obj for info in self.collection if info.is_widget and info.is_plugin]
 
     @property
     def widgets(self):
-        """Get all widgets. These are all classes inheriting from BECWidget."""
+        """
+        Get all widgets. These are all classes inheriting from BECWidget.
+        """
         return [info.obj for info in self.collection if info.is_widget]
 
     @property
     def rpc_top_level_classes(self):
-        """Get all top-level classes that are RPC-enabled. These are all classes that users can choose from."""
+        """
+        Get all top-level classes that are RPC-enabled. These are all classes that users can choose from.
+        """
         return [info.obj for info in self.collection if info.is_plugin and info.is_connector]
 
     @property
     def classes(self):
-        """Get all classes."""
+        """
+        Get all classes.
+        """
         return [info.obj for info in self.collection]
 
 
@@ -198,7 +197,7 @@ def get_custom_classes(repo_name: str) -> BECClassContainer:
                 if not hasattr(obj, "__module__") or obj.__module__ != module.__name__:
                     continue
                 if isinstance(obj, type):
-                    class_info = BECClassInfo(name=name, module=module.__name__, file=path, obj=obj)
+                    class_info = BECClassInfo(name=name, module=module_name, file=path, obj=obj)
                     if issubclass(obj, BECConnector):
                         class_info.is_connector = True
                     if issubclass(obj, BECWidget):

bec_widgets/utils/rpc_server.py

@@ -84,7 +84,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,11 +190,8 @@ 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.debug(f"Broadcasting registry update: {data} for {self.gui_id}")
+        logger.info(f"Broadcasting registry update: {data} for {self.gui_id}")
         self.client.connector.xadd(
             MessageEndpoints.gui_registry_state(self.gui_id),
             msg_dict={"data": messages.GUIRegistryStateMessage(state=data)},

bec_widgets/utils/settings_dialog.py

@@ -1,5 +1,5 @@
 from bec_lib.logger import bec_logger
-from qtpy.QtGui import QCloseEvent
+from PySide6.QtGui import QCloseEvent
 from qtpy.QtWidgets import QDialog, QDialogButtonBox, QHBoxLayout, QPushButton, QVBoxLayout, QWidget
 
 from bec_widgets.utils.error_popups import SafeSlot

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
@@ -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")
@@ -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)
 
@@ -176,10 +173,6 @@ 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.setCheckable(self.checkable)
 
@@ -709,85 +702,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,14 +2,13 @@ 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
 
 logger = bec_logger.logger
 
 if PYSIDE6:
-    from qtpy.QtUiTools import QUiLoader
+    from PySide6.QtUiTools import QUiLoader
 
     class CustomUiLoader(QUiLoader):
         def __init__(self, baseinstance, custom_widgets: dict | None = None):
@@ -31,9 +30,9 @@ class UILoader:
     def __init__(self, parent=None):
         self.parent = parent
 
-        self.custom_widgets = (
-            get_custom_classes("bec_widgets") + get_all_plugin_widgets()
-        ).as_dict()
+        widgets = get_custom_classes("bec_widgets").classes
+
+        self.custom_widgets = {widget.__name__: widget for widget in widgets}
 
         if PYSIDE6:
             self.loader = self.load_ui_pyside6

bec_widgets/widgets/containers/dock/dock.py

@@ -131,6 +131,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,
@@ -303,7 +304,11 @@ class BECDock(BECWidget, Dock):
             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 not WidgetContainerUtils.has_name_valid_chars(name):
+                raise ValueError(
+                    f"Name {name} contains invalid characters. "
+                    f"Only alphanumeric characters and underscores are allowed."
+                )
 
         if row is None:
             row = self.layout.rowCount()
@@ -320,7 +325,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:
@@ -403,11 +412,10 @@ class BECDock(BECWidget, Dock):
         """
         # # FIXME Cleanup might be called twice
         try:
-            logger.info(f"Cleaning up dock {self.name()}")
             self.label.close()
             self.label.deleteLater()
         except Exception as e:
-            logger.error(f"Error while closing dock label: {e}")
+            logger.info(f"Error while closing dock label of dock: {e}")
 
         # Remove the dock from the parent dock area
         if self.parent_dock_area:
@@ -416,7 +424,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

@@ -102,7 +102,7 @@ class BECDockArea(BECWidget, QWidget):
 
         self._instructions_visible = True
 
-        self.dark_mode_button = DarkModeButton(parent=self, toolbar=True)
+        self.dark_mode_button = DarkModeButton(parent=self, parent_id=self.gui_id, toolbar=True)
         self.dock_area = DockArea(parent=self)
         self.toolbar = ModularToolBar(
             parent=self,
@@ -163,11 +163,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
                         ),
                     },
                 ),
@@ -233,11 +230,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)
@@ -313,8 +308,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 +364,11 @@ 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)
-
+            if not WidgetContainerUtils.has_name_valid_chars(name):
+                raise ValueError(
+                    f"Name {name} contains invalid characters. "
+                    f"Only alphanumeric characters and underscores are allowed."
+                )
         else:  # Name is not provided
             name = WidgetContainerUtils.generate_unique_name(name="dock", list_of_names=dock_names)
 
@@ -381,6 +377,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

bec_widgets/widgets/containers/layout_manager/layout_manager.py

@@ -53,7 +53,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 +138,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/containers/main_window/main_window.py

@@ -1,6 +1,6 @@
 import os
 
-from qtpy.QtCore import QEvent, QSize
+from qtpy.QtCore import QSize
 from qtpy.QtGui import QAction, QActionGroup, QIcon
 from qtpy.QtWidgets import QApplication, QMainWindow, QStyle
 
@@ -168,11 +168,6 @@ class BECMainWindow(BECWidget, QMainWindow):
     def change_theme(self, theme: str):
         apply_theme(theme)
 
-    def event(self, event):
-        if event.type() == QEvent.Type.StatusTip:
-            return True
-        return super().event(event)
-
     def cleanup(self):
         central_widget = self.centralWidget()
         central_widget.close()

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

@@ -1,11 +1,10 @@
 from bec_lib.callback_handler import EventType
 from bec_lib.device import Signal
 from bec_lib.logger import bec_logger
-from qtpy.QtCore import Property
+from qtpy.QtCore import Property, Slot
 
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.filter_io import FilterIO
 from bec_widgets.utils.ophyd_kind_util import Kind
 from bec_widgets.utils.widget_io import WidgetIO
@@ -37,20 +36,18 @@ 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()
-        self._signal_filter = set()
+        self._signal_filter = []
         self._signals = []
         self._hinted_signals = []
         self._normal_signals = []
@@ -61,7 +58,7 @@ class DeviceSignalInputBase(BECWidget):
 
     ### Qt Slots ###
 
-    @SafeSlot(str)
+    @Slot(str)
     def set_signal(self, signal: str):
         """
         Set the signal.
@@ -77,10 +74,10 @@ class DeviceSignalInputBase(BECWidget):
                 f"Signal {signal} not found for device {self.device} and filtered selection {self.signal_filter}."
             )
 
-    @SafeSlot(str)
+    @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.
@@ -91,8 +88,8 @@ class DeviceSignalInputBase(BECWidget):
             self._device = device
         self.update_signals_from_filters()
 
-    @SafeSlot(dict, dict)
-    @SafeSlot()
+    @Slot(dict, dict)
+    @Slot()
     def update_signals_from_filters(
         self, content: dict | None = None, metadata: dict | None = None
     ):
@@ -105,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
@@ -113,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)
 
@@ -159,9 +164,9 @@ class DeviceSignalInputBase(BECWidget):
     @include_hinted_signals.setter
     def include_hinted_signals(self, value: bool):
         if value:
-            self._signal_filter.add(Kind.hinted)
+            self._signal_filter.append(Kind.hinted)
         else:
-            self._signal_filter.discard(Kind.hinted)
+            self._signal_filter.remove(Kind.hinted)
         self.update_signals_from_filters()
 
     @Property(bool)
@@ -172,9 +177,9 @@ class DeviceSignalInputBase(BECWidget):
     @include_normal_signals.setter
     def include_normal_signals(self, value: bool):
         if value:
-            self._signal_filter.add(Kind.normal)
+            self._signal_filter.append(Kind.normal)
         else:
-            self._signal_filter.discard(Kind.normal)
+            self._signal_filter.remove(Kind.normal)
         self.update_signals_from_filters()
 
     @Property(bool)
@@ -185,9 +190,9 @@ class DeviceSignalInputBase(BECWidget):
     @include_config_signals.setter
     def include_config_signals(self, value: bool):
         if value:
-            self._signal_filter.add(Kind.config)
+            self._signal_filter.append(Kind.config)
         else:
-            self._signal_filter.discard(Kind.config)
+            self._signal_filter.remove(Kind.config)
         self.update_signals_from_filters()
 
     ### Properties and Methods ###
@@ -245,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
@@ -274,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,30 +140,11 @@ 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()
 
-    def validate_device(self, device: str) -> bool:  # type: ignore[override]
-        """
-        Extend validation so that preview‑signal pseudo‑devices (labels like
-        ``"eiger_preview"``) are accepted as valid choices.
-
-        The validation run only on device not on the preview‑signal.
-
-        Args:
-            device: The text currently entered/selected.
-
-        Returns:
-            True if the device is a genuine BEC device *or* one of the
-            whitelisted preview‑signal entries.
-        """
-        idx = self.findText(device)
-        if idx >= 0 and isinstance(self.itemData(idx), tuple):
-            device = self.itemData(idx)[0]  # type: ignore[assignment]
-        return super().validate_device(device)
-
 
 if __name__ == "__main__":  # pragma: no cover
     # pylint: disable=import-outside-toplevel

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

@@ -1,13 +1,11 @@
 from bec_lib.device import Positioner
-from qtpy.QtCore import QSize, Signal
+from qtpy.QtCore import QSize, Signal, Slot
 from qtpy.QtWidgets import QComboBox, QSizePolicy
 
-from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.filter_io import ComboBoxFilterHandler, FilterIO
 from bec_widgets.utils.ophyd_kind_util import Kind
 from bec_widgets.widgets.control.device_input.base_classes.device_signal_input_base import (
     DeviceSignalInputBase,
-    DeviceSignalInputBaseConfig,
 )
 
 
@@ -25,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)
 
@@ -37,7 +32,7 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
         self,
         parent=None,
         client=None,
-        config: DeviceSignalInputBaseConfig | None = None,
+        config: DeviceSignalInputBase = None,
         gui_id: str | None = None,
         device: str | None = None,
         signal_filter: str | list[str] | None = None,
@@ -67,13 +62,9 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
         if default is not None:
             self.set_signal(default)
 
-    @SafeSlot()
-    @SafeSlot(dict, dict)
-    def update_signals_from_filters(
-        self, content: dict | None = None, metadata: dict | None = None
-    ):
+    def update_signals_from_filters(self):
         """Update the filters for the combobox"""
-        super().update_signals_from_filters(content, metadata)
+        super().update_signals_from_filters()
         # pylint: disable=protected-access
         if FilterIO._find_handler(self) is ComboBoxFilterHandler:
             if len(self._config_signals) > 0:
@@ -90,7 +81,7 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
                 self.insertItem(0, "Hinted Signals")
                 self.model().item(0).setEnabled(False)
 
-    @SafeSlot(str)
+    @Slot(str)
     def on_text_changed(self, text: str):
         """Slot for text changed. If a device is selected and the signal is changed and valid it emits a signal.
         For a positioner, the readback value has to be renamed to the device name.

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
@@ -89,7 +90,6 @@ class ScanControl(BECWidget, QWidget):
         self.config.allowed_scans = allowed_scans
 
         self._scan_metadata: dict | None = None
-        self._metadata_form = ScanMetadata(parent=self)
 
         # Create and set main layout
         self._init_UI()
@@ -166,6 +166,7 @@ class ScanControl(BECWidget, QWidget):
         self.layout.addStretch()
 
     def _add_metadata_form(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

@@ -1,4 +1,4 @@
-"""Module for DapComboBox widget class to select a DAP model from a combobox."""
+""" Module for DapComboBox widget class to select a DAP model from a combobox. """
 
 from bec_lib.logger import bec_logger
 from qtpy.QtCore import Property, Signal, Slot

bec_widgets/widgets/editors/console/console.py

@@ -0,0 +1,870 @@
+"""
+BECConsole is a Qt widget that runs a Bash shell. 
+
+BECConsole VT100 emulation is powered by Pyte,
+(https://github.com/selectel/pyte).
+"""
+
+import collections
+import fcntl
+import html
+import os
+import pty
+import re
+import signal
+import sys
+import time
+
+import pyte
+from pygments.token import Token
+from pyte.screens import History
+from qtpy import QtCore, QtGui, QtWidgets
+from qtpy.QtCore import Property as pyqtProperty
+from qtpy.QtCore import QSize, QSocketNotifier, Qt, QTimer
+from qtpy.QtCore import Signal as pyqtSignal
+from qtpy.QtGui import QClipboard, QColor, QPalette, QTextCursor
+from qtpy.QtWidgets import QApplication, QHBoxLayout, QScrollBar, QSizePolicy
+
+from bec_widgets.utils.error_popups import SafeSlot as Slot
+
+ansi_colors = {
+    "black": "#000000",
+    "red": "#CD0000",
+    "green": "#00CD00",
+    "brown": "#996633",  # Brown, replacing the yellow
+    "blue": "#0000EE",
+    "magenta": "#CD00CD",
+    "cyan": "#00CDCD",
+    "white": "#E5E5E5",
+    "brightblack": "#7F7F7F",
+    "brightred": "#FF0000",
+    "brightgreen": "#00FF00",
+    "brightyellow": "#FFFF00",
+    "brightblue": "#5C5CFF",
+    "brightmagenta": "#FF00FF",
+    "brightcyan": "#00FFFF",
+    "brightwhite": "#FFFFFF",
+}
+
+control_keys_mapping = {
+    QtCore.Qt.Key_A: b"\x01",  # Ctrl-A
+    QtCore.Qt.Key_B: b"\x02",  # Ctrl-B
+    QtCore.Qt.Key_C: b"\x03",  # Ctrl-C
+    QtCore.Qt.Key_D: b"\x04",  # Ctrl-D
+    QtCore.Qt.Key_E: b"\x05",  # Ctrl-E
+    QtCore.Qt.Key_F: b"\x06",  # Ctrl-F
+    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_P: b"\x10",  # Ctrl-P
+    QtCore.Qt.Key_Q: b"\x11",  # Ctrl-Q
+    QtCore.Qt.Key_R: b"\x12",  # Ctrl-R
+    QtCore.Qt.Key_S: b"\x13",  # Ctrl-S
+    QtCore.Qt.Key_T: b"\x14",  # Ctrl-T
+    QtCore.Qt.Key_U: b"\x15",  # Ctrl-U
+    QtCore.Qt.Key_V: b"\x16",  # Ctrl-V
+    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-_
+}
+
+normal_keys_mapping = {
+    QtCore.Qt.Key_Return: b"\n",
+    QtCore.Qt.Key_Space: b" ",
+    QtCore.Qt.Key_Enter: b"\n",
+    QtCore.Qt.Key_Tab: b"\t",
+    QtCore.Qt.Key_Backspace: b"\x08",
+    QtCore.Qt.Key_Home: b"\x47",
+    QtCore.Qt.Key_End: b"\x4f",
+    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_PageUp: b"\x49",
+    QtCore.Qt.Key_PageDown: b"\x51",
+    QtCore.Qt.Key_F1: b"\x1b\x31",
+    QtCore.Qt.Key_F2: b"\x1b\x32",
+    QtCore.Qt.Key_F3: b"\x1b\x33",
+    QtCore.Qt.Key_F4: b"\x1b\x34",
+    QtCore.Qt.Key_F5: b"\x1b\x35",
+    QtCore.Qt.Key_F6: b"\x1b\x36",
+    QtCore.Qt.Key_F7: b"\x1b\x37",
+    QtCore.Qt.Key_F8: b"\x1b\x38",
+    QtCore.Qt.Key_F9: b"\x1b\x39",
+    QtCore.Qt.Key_F10: b"\x1b\x30",
+    QtCore.Qt.Key_F11: b"\x45",
+    QtCore.Qt.Key_F12: b"\x46",
+}
+
+
+def QtKeyToAscii(event):
+    """
+    Convert the Qt key event to the corresponding ASCII sequence for
+    the terminal. This works fine for standard alphanumerical characters, but
+    most other characters require terminal specific control sequences.
+
+    The conversion below works for TERM="linux" terminals.
+    """
+    if sys.platform == "darwin":
+        # special case for MacOS
+        # /!\ Qt maps ControlModifier to CMD
+        # CMD-C, CMD-V for copy/paste
+        # CTRL-C and other modifiers -> key mapping
+        if event.modifiers() == QtCore.Qt.MetaModifier:
+            if event.key() == Qt.Key_Backspace:
+                return control_keys_mapping.get(Qt.Key_W)
+            return control_keys_mapping.get(event.key())
+        elif event.modifiers() == QtCore.Qt.ControlModifier:
+            if event.key() == Qt.Key_C:
+                # copy
+                return "copy"
+            elif event.key() == Qt.Key_V:
+                # paste
+                return "paste"
+            return None
+        else:
+            return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
+    if event.modifiers() == QtCore.Qt.ControlModifier:
+        return control_keys_mapping.get(event.key())
+    else:
+        return normal_keys_mapping.get(event.key(), event.text().encode("utf8"))
+
+
+class Screen(pyte.HistoryScreen):
+    def __init__(self, stdin_fd, cols, rows, historyLength):
+        super().__init__(cols, rows, historyLength, ratio=1 / rows)
+        self._fd = stdin_fd
+
+    def write_process_input(self, data):
+        """Response to CPR request (for example),
+        this can be for other requests
+        """
+        try:
+            os.write(self._fd, data.encode("utf-8"))
+        except (IOError, OSError):
+            pass
+
+    def resize(self, lines, columns):
+        lines = lines or self.lines
+        columns = columns or self.columns
+
+        if lines == self.lines and columns == self.columns:
+            return  # No changes.
+
+        self.dirty.clear()
+        self.dirty.update(range(lines))
+
+        self.save_cursor()
+        if lines < self.lines:
+            if lines <= self.cursor.y:
+                nlines_to_move_up = self.lines - lines
+                for i in range(nlines_to_move_up):
+                    line = self.buffer[i]  # .pop(0)
+                    self.history.top.append(line)
+                self.cursor_position(0, 0)
+                self.delete_lines(nlines_to_move_up)
+                self.restore_cursor()
+                self.cursor.y -= nlines_to_move_up
+        else:
+            self.restore_cursor()
+
+        self.lines, self.columns = lines, columns
+        self.history = History(
+            self.history.top,
+            self.history.bottom,
+            1 / self.lines,
+            self.history.size,
+            self.history.position,
+        )
+        self.set_margins()
+
+
+class Backend(QtCore.QObject):
+    """
+    Poll Bash.
+
+    This class will run as a qsocketnotifier (started in ``_TerminalWidget``) and poll the
+    file descriptor of the Bash terminal.
+    """
+
+    # Signals to communicate with ``_TerminalWidget``.
+    dataReady = pyqtSignal(object)
+    processExited = pyqtSignal()
+
+    def __init__(self, fd, cols, rows):
+        super().__init__()
+
+        # File descriptor that connects to Bash process.
+        self.fd = fd
+
+        # Setup Pyte (hard coded display size for now).
+        self.screen = Screen(self.fd, cols, rows, 10000)
+        self.stream = pyte.ByteStream()
+        self.stream.attach(self.screen)
+
+        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
+        self.notifier.activated.connect(self._fd_readable)
+
+    def _fd_readable(self):
+        """
+        Poll the Bash output, run it through Pyte, and notify
+        """
+        # Read the shell output until the file descriptor is closed.
+        try:
+            out = os.read(self.fd, 2**16)
+        except OSError:
+            self.processExited.emit()
+            self.notifier.setEnabled(False)
+            return
+
+        # Feed output into Pyte's state machine and send the new screen
+        # output to the GUI
+        self.stream.feed(out)
+        self.dataReady.emit(self.screen)
+
+
+class BECConsole(QtWidgets.QWidget):
+    """Container widget for the terminal text area"""
+
+    PLUGIN = True
+    ICON_NAME = "terminal"
+
+    prompt = pyqtSignal(bool)
+
+    def __init__(self, parent=None, cols=132):
+        super().__init__(parent)
+
+        self.term = _TerminalWidget(self, cols, rows=43)
+        self.term.prompt.connect(self.prompt)  # forward signal from term to this widget
+
+        self.scroll_bar = QScrollBar(Qt.Vertical, self)
+        # self.scroll_bar.hide()
+        layout = QHBoxLayout(self)
+        layout.addWidget(self.term)
+        layout.addWidget(self.scroll_bar)
+        layout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)
+
+        pal = QPalette()
+        self.set_bgcolor(pal.window().color())
+        self.set_fgcolor(pal.windowText().color())
+        self.term.set_scroll_bar(self.scroll_bar)
+        self.set_cmd("bec --nogui")
+
+        self._check_designer_timer = QTimer()
+        self._check_designer_timer.timeout.connect(self.check_designer)
+        self._check_designer_timer.start(1000)
+
+    def minimumSizeHint(self):
+        size = self.term.sizeHint()
+        size.setWidth(size.width() + self.scroll_bar.width())
+        return size
+
+    def sizeHint(self):
+        return self.minimumSizeHint()
+
+    def check_designer(self, calls={"n": 0}):
+        calls["n"] += 1
+        if self.term.fd is not None:
+            # already started
+            self._check_designer_timer.stop()
+        elif self.window().windowTitle().endswith("[Preview]"):
+            # assuming Designer preview -> start
+            self._check_designer_timer.stop()
+            self.term.start()
+        elif calls["n"] >= 3:
+            # assuming not in Designer -> stop checking
+            self._check_designer_timer.stop()
+
+    def get_rows(self):
+        return self.term.rows
+
+    def set_rows(self, rows):
+        self.term.rows = rows
+        self.adjustSize()
+        self.updateGeometry()
+
+    def get_cols(self):
+        return self.term.cols
+
+    def set_cols(self, cols):
+        self.term.cols = cols
+        self.adjustSize()
+        self.updateGeometry()
+
+    def get_bgcolor(self):
+        return QColor.fromString(self.term.bg_color)
+
+    def set_bgcolor(self, color):
+        self.term.bg_color = color.name(QColor.HexRgb)
+
+    def get_fgcolor(self):
+        return QColor.fromString(self.term.fg_color)
+
+    def set_fgcolor(self, color):
+        self.term.fg_color = color.name(QColor.HexRgb)
+
+    def get_cmd(self):
+        return self.term._cmd
+
+    def set_cmd(self, cmd):
+        self.term._cmd = cmd
+        if self.term.fd is None:
+            # not started yet
+            self.term.clear()
+            self.term.appendHtml(f"<h2>BEC Console - {repr(cmd)}</h2>")
+
+    def start(self, deactivate_ctrl_d=True):
+        self.term.start(deactivate_ctrl_d=deactivate_ctrl_d)
+
+    def push(self, text, hit_return=False):
+        """Push some text to the terminal"""
+        return self.term.push(text, hit_return=hit_return)
+
+    def execute_command(self, command):
+        self.push(command, hit_return=True)
+
+    def set_prompt_tokens(self, *tokens):
+        """Prepare regexp to identify prompt, based on tokens
+
+        Tokens are returned from get_ipython().prompts.in_prompt_tokens()
+        """
+        regex_parts = []
+        for token_type, token_value in tokens:
+            if token_type == Token.PromptNum:  # Handle dynamic prompt number
+                regex_parts.append(r"[\d\?]+")  # Match one or more digits or '?'
+            else:
+                # Escape other prompt parts (e.g., "In [", "]: ")
+                if not token_value:
+                    regex_parts.append(".+?")  # arbitrary string
+                else:
+                    regex_parts.append(re.escape(token_value))
+
+        # Combine into a single regex
+        prompt_pattern = "".join(regex_parts)
+        self.term._prompt_re = re.compile(prompt_pattern + r"\s*$")
+
+    def terminate(self, timeout=10):
+        self.term.stop(timeout=timeout)
+
+    def send_ctrl_c(self, timeout=None):
+        self.term.send_ctrl_c(timeout)
+
+    cols = pyqtProperty(int, get_cols, set_cols)
+    rows = pyqtProperty(int, get_rows, set_rows)
+    bgcolor = pyqtProperty(QColor, get_bgcolor, set_bgcolor)
+    fgcolor = pyqtProperty(QColor, get_fgcolor, set_fgcolor)
+    cmd = pyqtProperty(str, get_cmd, set_cmd)
+
+
+class _TerminalWidget(QtWidgets.QPlainTextEdit):
+    """
+    Start ``Backend`` process and render Pyte output as text.
+    """
+
+    prompt = pyqtSignal(bool)
+
+    def __init__(self, parent, cols=125, rows=50, **kwargs):
+        # regexp to match prompt
+        self._prompt_re = None
+        # last prompt
+        self._prompt_str = None
+        # process pid
+        self.pid = None
+        # file descriptor to communicate with the subprocess
+        self.fd = None
+        self.backend = None
+        # command to execute
+        self._cmd = ""
+        # should ctrl-d be deactivated ? (prevent Python exit)
+        self._deactivate_ctrl_d = False
+
+        # Default colors
+        pal = QPalette()
+        self._fg_color = pal.text().color().name()
+        self._bg_color = pal.base().color().name()
+
+        # Specify the terminal size in terms of lines and columns.
+        self._rows = rows
+        self._cols = cols
+        self.output = collections.deque()
+
+        super().__init__(parent)
+
+        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Expanding)
+
+        # Disable default scrollbars (we use our own, to be set via .set_scroll_bar())
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.scroll_bar = None
+
+        # Use Monospace fonts and disable line wrapping.
+        self.setFont(QtGui.QFont("Courier", 9))
+        self.setFont(QtGui.QFont("Monospace"))
+        self.setLineWrapMode(QtWidgets.QPlainTextEdit.NoWrap)
+        fmt = QtGui.QFontMetrics(self.font())
+        char_width = fmt.width("w")
+        self.setCursorWidth(char_width)
+
+        self.adjustSize()
+        self.updateGeometry()
+        self.update_stylesheet()
+
+    @property
+    def bg_color(self):
+        return self._bg_color
+
+    @bg_color.setter
+    def bg_color(self, hexcolor):
+        self._bg_color = hexcolor
+        self.update_stylesheet()
+
+    @property
+    def fg_color(self):
+        return self._fg_color
+
+    @fg_color.setter
+    def fg_color(self, hexcolor):
+        self._fg_color = hexcolor
+        self.update_stylesheet()
+
+    def update_stylesheet(self):
+        self.setStyleSheet(
+            f"QPlainTextEdit {{ border: 0; color: {self._fg_color}; background-color: {self._bg_color}; }} "
+        )
+
+    @property
+    def rows(self):
+        return self._rows
+
+    @rows.setter
+    def rows(self, rows: int):
+        if self.backend is None:
+            # not initialized yet, ok to change
+            self._rows = rows
+            self.adjustSize()
+            self.updateGeometry()
+        else:
+            raise RuntimeError("Cannot change rows after console is started.")
+
+    @property
+    def cols(self):
+        return self._cols
+
+    @cols.setter
+    def cols(self, cols: int):
+        if self.fd is None:
+            # not initialized yet, ok to change
+            self._cols = cols
+            self.adjustSize()
+            self.updateGeometry()
+        else:
+            raise RuntimeError("Cannot change cols after console is started.")
+
+    def start(self, deactivate_ctrl_d: bool = False):
+        self._deactivate_ctrl_d = deactivate_ctrl_d
+
+        self.update_term_size()
+
+        # Start the Bash process
+        self.pid, self.fd = self.fork_shell()
+
+        if self.fd:
+            # Create the ``Backend`` object
+            self.backend = Backend(self.fd, self.cols, self.rows)
+            self.backend.dataReady.connect(self.data_ready)
+            self.backend.processExited.connect(self.process_exited)
+        else:
+            self.process_exited()
+
+    def process_exited(self):
+        self.fd = None
+        self.clear()
+        self.appendHtml(f"<br><h2>{repr(self._cmd)} - Process exited.</h2>")
+        self.setReadOnly(True)
+
+    def send_ctrl_c(self, wait_prompt=True, timeout=None):
+        """Send CTRL-C to the process
+
+        If wait_prompt=True (default), wait for a new prompt after CTRL-C
+        If no prompt is displayed after 'timeout' seconds, TimeoutError is raised
+        """
+        os.kill(self.pid, signal.SIGINT)
+        if wait_prompt:
+            timeout_error = False
+            if timeout:
+
+                def set_timeout_error():
+                    nonlocal timeout_error
+                    timeout_error = True
+
+                timeout_timer = QTimer()
+                timeout_timer.singleShot(timeout * 1000, set_timeout_error)
+            while self._prompt_str is None:
+                QApplication.instance().process_events()
+                if timeout_error:
+                    raise TimeoutError(
+                        f"CTRL-C: could not get back to prompt after {timeout} seconds."
+                    )
+
+    def _is_running(self):
+        if os.waitpid(self.pid, os.WNOHANG) == (0, 0):
+            return True
+        return False
+
+    def stop(self, kill=True, timeout=None):
+        """Stop the running process
+
+        SIGTERM is the default signal for terminating processes.
+
+        If kill=True (default), SIGKILL will be sent if the process does not exit after timeout
+        """
+        # try to exit gracefully
+        os.kill(self.pid, signal.SIGTERM)
+
+        # wait until process is truly dead
+        t0 = time.perf_counter()
+        while self._is_running():
+            time.sleep(1)
+            if timeout is not None and time.perf_counter() - t0 > timeout:
+                # still alive after 'timeout' seconds
+                if kill:
+                    # send SIGKILL and make a last check in loop
+                    os.kill(self.pid, signal.SIGKILL)
+                    kill = False
+                else:
+                    # still running after timeout...
+                    raise TimeoutError(
+                        f"Could not terminate process with pid: {self.pid} within timeout"
+                    )
+        self.process_exited()
+
+    def data_ready(self, screen):
+        """Handle new screen: redraw, set scroll bar max and slider, move cursor to its position
+
+        This method is triggered via a signal from ``Backend``.
+        """
+        self.redraw_screen()
+        self.adjust_scroll_bar()
+        self.move_cursor()
+
+    def minimumSizeHint(self):
+        """Return minimum size for current cols and rows"""
+        fmt = QtGui.QFontMetrics(self.font())
+        char_width = fmt.width("w")
+        char_height = fmt.height()
+        width = char_width * self.cols
+        height = char_height * self.rows
+        return QSize(width, height)
+
+    def sizeHint(self):
+        return self.minimumSizeHint()
+
+    def set_scroll_bar(self, scroll_bar):
+        self.scroll_bar = scroll_bar
+        self.scroll_bar.setMinimum(0)
+        self.scroll_bar.valueChanged.connect(self.scroll_value_change)
+
+    def scroll_value_change(self, value, old={"value": -1}):
+        if self.backend is None:
+            return
+        if old["value"] == -1:
+            old["value"] = self.scroll_bar.maximum()
+        if value <= old["value"]:
+            # scroll up
+            # value is number of lines from the start
+            nlines = old["value"] - value
+            # history ratio gives prev_page == 1 line
+            for i in range(nlines):
+                self.backend.screen.prev_page()
+        else:
+            # scroll down
+            nlines = value - old["value"]
+            for i in range(nlines):
+                self.backend.screen.next_page()
+        old["value"] = value
+        self.redraw_screen()
+
+    def adjust_scroll_bar(self):
+        sb = self.scroll_bar
+        sb.valueChanged.disconnect(self.scroll_value_change)
+        tmp = len(self.backend.screen.history.top) + len(self.backend.screen.history.bottom)
+        sb.setMaximum(tmp if tmp > 0 else 0)
+        sb.setSliderPosition(tmp if tmp > 0 else 0)
+        # if tmp > 0:
+        #    # show scrollbar, but delayed - prevent recursion with widget size change
+        #    QTimer.singleShot(0, scrollbar.show)
+        # else:
+        #    QTimer.singleShot(0, scrollbar.hide)
+        sb.valueChanged.connect(self.scroll_value_change)
+
+    def write(self, data):
+        try:
+            os.write(self.fd, data)
+        except (IOError, OSError):
+            self.process_exited()
+
+    @Slot(object)
+    def keyPressEvent(self, event):
+        """
+        Redirect all keystrokes to the terminal process.
+        """
+        if self.fd is None:
+            # not started
+            return
+        # Convert the Qt key to the correct ASCII code.
+        if (
+            self._deactivate_ctrl_d
+            and event.modifiers() == QtCore.Qt.ControlModifier
+            and event.key() == QtCore.Qt.Key_D
+        ):
+            return None
+
+        code = QtKeyToAscii(event)
+        if code == "copy":
+            # MacOS only: CMD-C handling
+            self.copy()
+        elif code == "paste":
+            # MacOS only: CMD-V handling
+            self._push_clipboard()
+        elif code is not None:
+            self.write(code)
+
+    def push(self, text, hit_return=False):
+        """
+        Write 'text' to terminal
+        """
+        self.write(text.encode("utf-8"))
+        if hit_return:
+            self.write(b"\n")
+
+    def contextMenuEvent(self, event):
+        if self.fd is None:
+            return
+        menu = self.createStandardContextMenu()
+        for action in menu.actions():
+            # remove all actions except copy and paste
+            if "opy" in action.text():
+                # redefine text without shortcut
+                # since it probably clashes with control codes (like CTRL-C etc)
+                action.setText("Copy")
+                continue
+            if "aste" in action.text():
+                # redefine text without shortcut
+                action.setText("Paste")
+                # paste -> have to insert with self.push
+                action.triggered.connect(self._push_clipboard)
+                continue
+            menu.removeAction(action)
+        menu.exec_(event.globalPos())
+
+    def _push_clipboard(self):
+        clipboard = QApplication.instance().clipboard()
+        self.push(clipboard.text())
+
+    def move_cursor(self):
+        textCursor = self.textCursor()
+        textCursor.setPosition(0)
+        textCursor.movePosition(
+            QTextCursor.Down, QTextCursor.MoveAnchor, self.backend.screen.cursor.y
+        )
+        textCursor.movePosition(
+            QTextCursor.Right, QTextCursor.MoveAnchor, self.backend.screen.cursor.x
+        )
+        self.setTextCursor(textCursor)
+
+    def mouseReleaseEvent(self, event):
+        if self.fd is None:
+            return
+        if event.button() == Qt.MiddleButton:
+            # push primary selection buffer ("mouse clipboard") to terminal
+            clipboard = QApplication.instance().clipboard()
+            if clipboard.supportsSelection():
+                self.push(clipboard.text(QClipboard.Selection))
+            return None
+        elif event.button() == Qt.LeftButton:
+            # left button click
+            textCursor = self.textCursor()
+            if textCursor.selectedText():
+                # mouse was used to select text -> nothing to do
+                pass
+            else:
+                # a simple 'click', move scrollbar to end
+                self.scroll_bar.setSliderPosition(self.scroll_bar.maximum())
+                self.move_cursor()
+                return None
+        return super().mouseReleaseEvent(event)
+
+    def redraw_screen(self):
+        """
+        Render the screen as formatted text into the widget.
+        """
+        screen = self.backend.screen
+
+        # Clear the widget
+        if screen.dirty:
+            self.clear()
+            while len(self.output) < (max(screen.dirty) + 1):
+                self.output.append("")
+            while len(self.output) > (max(screen.dirty) + 1):
+                self.output.pop()
+
+            # Prepare the HTML output
+            for line_no in screen.dirty:
+                line = text = ""
+                style = old_style = ""
+                old_idx = 0
+                for idx, ch in screen.buffer[line_no].items():
+                    text += " " * (idx - old_idx - 1)
+                    old_idx = idx
+                    style = f"{'background-color:%s;' % ansi_colors.get(ch.bg, ansi_colors['black']) if ch.bg!='default' else ''}{'color:%s;' % ansi_colors.get(ch.fg, ansi_colors['white']) if ch.fg!='default' else ''}{'font-weight:bold;' if ch.bold else ''}{'font-style:italic;' if ch.italics else ''}"
+                    if style != old_style:
+                        if old_style:
+                            line += f"<span style={repr(old_style)}>{html.escape(text, quote=True)}</span>"
+                        else:
+                            line += html.escape(text, quote=True)
+                        text = ""
+                        old_style = style
+                    text += ch.data
+                if style:
+                    line += f"<span style={repr(style)}>{html.escape(text, quote=True)}</span>"
+                else:
+                    line += html.escape(text, quote=True)
+                # do a check at the cursor position:
+                # it is possible x pos > output line length,
+                # for example if last escape codes are "cursor forward" past end of text,
+                # like IPython does for "..." prompt (in a block, like "for" loop or "while" for example)
+                # In this case, cursor is at 12 but last text output is at 8 -> insert spaces
+                if line_no == screen.cursor.y:
+                    llen = len(screen.buffer[line_no])
+                    if llen < screen.cursor.x:
+                        line += " " * (screen.cursor.x - llen)
+                self.output[line_no] = line
+            # fill the text area with HTML contents in one go
+            self.appendHtml(f"<pre>{chr(10).join(self.output)}</pre>")
+
+            if self._prompt_re is not None:
+                text_buf = self.toPlainText()
+                prompt = self._prompt_re.search(text_buf)
+                if prompt is None:
+                    if self._prompt_str:
+                        self.prompt.emit(False)
+                    self._prompt_str = None
+                else:
+                    prompt_str = prompt.string.rstrip()
+                    if prompt_str != self._prompt_str:
+                        self._prompt_str = prompt_str
+                        self.prompt.emit(True)
+
+            # did updates, all clean
+            screen.dirty.clear()
+
+    def update_term_size(self):
+        fmt = QtGui.QFontMetrics(self.font())
+        char_width = fmt.width("w")
+        char_height = fmt.height()
+        self._cols = int(self.width() / char_width)
+        self._rows = int(self.height() / char_height)
+
+    def resizeEvent(self, event):
+        self.update_term_size()
+        if self.fd:
+            self.backend.screen.resize(self._rows, self._cols)
+            self.redraw_screen()
+            self.adjust_scroll_bar()
+            self.move_cursor()
+
+    def wheelEvent(self, event):
+        if not self.fd:
+            return
+        y = event.angleDelta().y()
+        if y > 0:
+            self.backend.screen.prev_page()
+        else:
+            self.backend.screen.next_page()
+        self.redraw_screen()
+
+    def fork_shell(self):
+        """
+        Fork the current process and execute bec in shell.
+        """
+        try:
+            pid, fd = pty.fork()
+        except (IOError, OSError):
+            return False
+        if pid == 0:
+            try:
+                ls = os.environ["LANG"].split(".")
+            except KeyError:
+                ls = []
+            if len(ls) < 2:
+                ls = ["en_US", "UTF-8"]
+            os.putenv("COLUMNS", str(self.cols))
+            os.putenv("LINES", str(self.rows))
+            os.putenv("TERM", "linux")
+            os.putenv("LANG", ls[0] + ".UTF-8")
+            if not self._cmd:
+                self._cmd = os.environ["SHELL"]
+            cmd = self._cmd
+            if isinstance(cmd, str):
+                cmd = cmd.split()
+            try:
+                os.execvp(cmd[0], cmd)
+            except (IOError, OSError):
+                pass
+            os._exit(0)
+        else:
+            # We are in the parent process.
+            # Set file control
+            fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK)
+            return pid, fd
+
+
+if __name__ == "__main__":
+    import os
+    import sys
+
+    from qtpy import QtGui, QtWidgets
+
+    # Create the Qt application and console.
+    app = QtWidgets.QApplication([])
+    mainwin = QtWidgets.QMainWindow()
+    title = "BECConsole"
+    mainwin.setWindowTitle(title)
+
+    console = BECConsole(mainwin)
+    mainwin.setCentralWidget(console)
+
+    def check_prompt(at_prompt):
+        if at_prompt:
+            print("NEW PROMPT")
+        else:
+            print("EXECUTING SOMETHING...")
+
+    console.set_prompt_tokens(
+        (Token.OutPromptNum, "•"),
+        (Token.Prompt, ""),  # will match arbitrary string,
+        (Token.Prompt, " ["),
+        (Token.PromptNum, "3"),
+        (Token.Prompt, "/"),
+        (Token.PromptNum, "1"),
+        (Token.Prompt, "] "),
+        (Token.Prompt, "❯❯"),
+    )
+    console.prompt.connect(check_prompt)
+    console.start()
+
+    # Show widget and launch Qt's event loop.
+    mainwin.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/editors/console/console.pyproject

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

bec_widgets/widgets/editors/console/console_plugin.py

@@ -1,26 +1,30 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+import os
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
 
+import bec_widgets
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.editors.web_console.web_console import WebConsole
+from bec_widgets.widgets.editors.console.console import BECConsole
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='WebConsole' name='web_console'>
+    <widget class='BECConsole' name='bec_console'>
     </widget>
 </ui>
 """
 
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
-class WebConsolePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+
+class BECConsolePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
         super().__init__()
         self._form_editor = None
 
     def createWidget(self, parent):
-        t = WebConsole(parent)
+        t = BECConsole(parent)
         return t
 
     def domXml(self):
@@ -30,10 +34,10 @@ class WebConsolePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return "BEC Console"
 
     def icon(self):
-        return designer_material_icon(WebConsole.ICON_NAME)
+        return designer_material_icon(BECConsole.ICON_NAME)
 
     def includeFile(self):
-        return "web_console"
+        return "bec_console"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -45,10 +49,10 @@ class WebConsolePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return self._form_editor is not None
 
     def name(self):
-        return "WebConsole"
+        return "BECConsole"
 
     def toolTip(self):
-        return ""
+        return "A terminal-like vt100 widget."
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/editors/console/register_console.py

@@ -6,9 +6,9 @@ def main():  # pragma: no cover
         return
     from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
 
-    from bec_widgets.widgets.editors.web_console.web_console_plugin import WebConsolePlugin
+    from bec_widgets.widgets.editors.console.console_plugin import BECConsolePlugin
 
-    QPyDesignerCustomWidgetCollection.addCustomWidget(WebConsolePlugin())
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECConsolePlugin())
 
 
 if __name__ == "__main__":  # pragma: no cover

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 GenericAlias, UnionType
-from typing import Literal
+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, field_validator
-from pydantic.fields import FieldInfo
+from pydantic import BaseModel, Field
 from qtpy.QtCore import Signal  # type: ignore
 from qtpy.QtWidgets import (
     QApplication,
@@ -21,13 +19,11 @@ from qtpy.QtWidgets import (
     QLayout,
     QLineEdit,
     QRadioButton,
-    QSizePolicy,
     QSpinBox,
     QToolButton,
     QWidget,
 )
 
-from bec_widgets.widgets.editors.dict_backed_table import DictBackedTable
 from bec_widgets.widgets.editors.scan_metadata._util import (
     clearable_required,
     field_default,
@@ -37,49 +33,12 @@ from bec_widgets.widgets.editors.scan_metadata._util import (
     field_precision,
 )
 
+if TYPE_CHECKING:  # pragma: no cover
+    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 | GenericAlias
-    name: str
-    info: FieldInfo = FieldInfo()
-    pretty_display: bool = Field(
-        default=False,
-        description="Whether to use a pretty display for the widget. Defaults to False. If True, disables the widget, doesn't add a clear button, and adapts the stylesheet for non-editable display.",
-    )
-
-    @field_validator("item_type", mode="before")
-    @classmethod
-    def _validate_type(cls, v):
-        allowed_primitives = [str, int, float, bool]
-        if isinstance(v, (type, UnionType)):
-            return v
-        if isinstance(v, GenericAlias):
-            if v.__origin__ in [list, dict, set] and all(
-                arg in allowed_primitives for arg in v.__args__
-            ):
-                return v
-            raise ValueError(
-                f"Generics of type {v} are not supported - only lists, dicts and sets of primitive types {allowed_primitives}"
-            )
-        if type(v) is type(Literal[""]):  # _LiteralGenericAlias is not exported from typing
-            arg_types = set(type(arg) for arg in v.__args__)
-            if len(arg_types) != 1:
-                raise ValueError("Mixtures of literal types are not supported!")
-            if (t := arg_types.pop()) in allowed_primitives:
-                return t
-            raise ValueError(f"Literals of type {t} are not supported")
-
-
 class ClearableBoolEntry(QWidget):
     stateChanged = Signal()
 
@@ -123,39 +82,25 @@ class ClearableBoolEntry(QWidget):
         self._false.setToolTip(tooltip)
 
 
-DynamicFormItemType = str | int | float | Decimal | bool | dict
+class MetadataWidget(QWidget):
 
-
-class DynamicFormItem(QWidget):
     valueChanged = Signal()
 
-    def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
-        """
-        Initializes the form item widget.
-
-        Args:
-            parent (QWidget | None, optional): The parent widget. Defaults to None.
-            spec (FormItemSpec): The specification for the form item.
-        """
+    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()
-        self._main_widget: QWidget
-        self._main_widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
-        if not spec.pretty_display:
-            if clearable_required(spec.info):
-                self._add_clear_button()
-        else:
-            self._set_pretty_display()
+        if clearable_required(info):
+            self._add_clear_button()
 
     @abstractmethod
-    def getValue(self) -> DynamicFormItemType: ...
+    def getValue(self): ...
 
     @abstractmethod
     def setValue(self, value): ...
@@ -165,9 +110,6 @@ class DynamicFormItem(QWidget):
         """Add the main data entry widget to self._main_widget and appply any
         constraints from the field info"""
 
-    def _set_pretty_display(self):
-        self.setEnabled(False)
-
     def _describe(self, pad=" "):
         return pad + (self._desc if self._desc else "")
 
@@ -185,15 +127,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(
@@ -211,18 +153,18 @@ class StrMetadataField(DynamicFormItem):
     def setValue(self, value: str):
         if value is None:
             self._main_widget.setText("")
-        self._main_widget.setText(str(value))
+        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()}")
@@ -243,18 +185,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:
-        precision = field_precision(self._spec.info)
         self._main_widget = QDoubleSpinBox()
         self._layout.addWidget(self._main_widget)
-        min_, max_ = field_limits(self._spec.info, float, precision)
+        min_, max_ = field_limits(self._info, int)
         self._main_widget.setMinimum(min_)
         self._main_widget.setMaximum(max_)
+        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}"
@@ -271,19 +213,19 @@ class FloatDecimalMetadataField(DynamicFormItem):
             return self._default
         return self._main_widget.value()
 
-    def setValue(self, value: float | Decimal):
+    def setValue(self, value: float):
         if value is None:
             self._main_widget.clear()
-        self._main_widget.setValue(float(value))
+        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()
@@ -298,28 +240,7 @@ class BoolMetadataField(DynamicFormItem):
         self._main_widget.setChecked(value)
 
 
-class DictMetadataField(DynamicFormItem):
-    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
-        super().__init__(parent=parent, spec=spec)
-        self._main_widget.data_changed.connect(self._value_changed)
-
-    def _set_pretty_display(self):
-        self._main_widget.set_button_visibility(False)
-        super()._set_pretty_display()
-
-    def _add_main_widget(self) -> None:
-        self._main_widget = DictBackedTable(self, [])
-        self._layout.addWidget(self._main_widget)
-        self._main_widget.setToolTip(self._describe(""))
-
-    def getValue(self):
-        return self._main_widget.dump_dict()
-
-    def setValue(self, value):
-        self._main_widget.replace_data(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]:
@@ -328,14 +249,6 @@ def widget_from_type(annotation: type | UnionType | None) -> type[DynamicFormIte
         return FloatDecimalMetadataField
     if annotation in [bool, bool | None]:
         return BoolMetadataField
-    if annotation in [dict, dict | None] or (
-        isinstance(annotation, GenericAlias) and annotation.__origin__ is dict
-    ):
-        return DictMetadataField
-    if annotation in [list, list | None] or (
-        isinstance(annotation, GenericAlias) and annotation.__origin__ is list
-    ):
-        return StrMetadataField
     else:
         logger.warning(f"Type {annotation} is not (yet) supported in metadata form creation.")
         return StrMetadataField

bec_widgets/widgets/editors/scan_metadata/_util.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sys
 from decimal import Decimal
-from math import copysign, inf, nextafter
+from math import inf, nextafter
 from typing import TYPE_CHECKING, TypeVar, get_args
 
 from annotated_types import Ge, Gt, Le, Lt
@@ -23,19 +23,16 @@ _MAXFLOAT = sys.float_info.max
 T = TypeVar("T", int, float, Decimal)
 
 
-def field_limits(info: FieldInfo, type_: type[T], prec: int | None = None) -> tuple[T, T]:
-    def _nextafter(x, y):
-        return nextafter(x, y) if prec is None else x + (10 ** (-prec)) * (copysign(1, y))
-
+def field_limits(info: FieldInfo, type_: type[T]) -> tuple[T, T]:
     _min = _MININT if type_ is int else _MINFLOAT
     _max = _MAXINT if type_ is int else _MAXFLOAT
     for md in info.metadata:
         if isinstance(md, Ge):
             _min = type_(md.ge)  # type: ignore
         if isinstance(md, Gt):
-            _min = type_(md.gt) + 1 if type_ is int else _nextafter(type_(md.gt), inf)  # type: ignore
+            _min = type_(md.gt) + 1 if type_ is int else nextafter(type_(md.gt), inf)  # type: ignore
         if isinstance(md, Lt):
-            _max = type_(md.lt) - 1 if type_ is int else _nextafter(type_(md.lt), -inf)  # type: ignore
+            _max = type_(md.lt) - 1 if type_ is int else nextafter(type_(md.lt), -inf)  # type: ignore
         if isinstance(md, Le):
             _max = type_(md.le)  # type: ignore
     return _min, _max  # type: ignore

bec_widgets/widgets/editors/scan_metadata/additional_metadata_table.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import Any
 
-from qtpy import QtWidgets
 from qtpy.QtCore import QAbstractTableModel, QModelIndex, Qt, Signal  # type: ignore
 from qtpy.QtWidgets import (
     QApplication,
@@ -17,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:
@@ -46,11 +37,7 @@ class DictBackedTableModel(QAbstractTableModel):
 
     def data(self, index, role=Qt.ItemDataRole):
         if index.isValid():
-            if role in [
-                Qt.ItemDataRole.DisplayRole,
-                Qt.ItemDataRole.EditRole,
-                Qt.ItemDataRole.ToolTipRole,
-            ]:
+            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
                 return str(self._data[index.row()][index.column()])
 
     def setData(self, index, value, role):
@@ -58,20 +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 replaceData(self, data: dict):
-        self.resetInternalData()
-        self._data = [[k, v] for k, v in data.items()]
-        self.dataChanged.emit(self.index(0, 0), self.index(len(self._data), 0))
-
     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:
@@ -118,36 +95,26 @@ class DictBackedTableModel(QAbstractTableModel):
         return dict(self._data)
 
 
-class DictBackedTable(QWidget):
+class AdditionalMetadataTable(QWidget):
+
     delete_rows = Signal(list)
-    data_changed = Signal(dict)
 
-    def __init__(self, parent: QWidget | None = None, 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__(parent)
+    def __init__(self, initial_data: list[list[str]]):
+        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(
-            QSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
+            QSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
         )
         self._table_view.setAlternatingRowColors(True)
-        self._table_view.header().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
-        self._table_view.header().setSectionResizeMode(5, QtWidgets.QHeaderView.Stretch)
         self._layout.addWidget(self._table_view)
 
-        self._button_holder = QWidget()
         self._buttons = QVBoxLayout()
-        self._button_holder.setLayout(self._buttons)
-        self._layout.addWidget(self._button_holder)
+        self._layout.addLayout(self._buttons)
         self._add_button = QPushButton("+")
         self._add_button.setToolTip("add a new row")
         self._remove_button = QPushButton("-")
@@ -157,34 +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(lambda *_: self.data_changed.emit(self.dump_dict()))
-
-    def set_button_visibility(self, value: bool):
-        self._button_holder.setVisible(value)
-
-    @SafeSlot()
-    def clear(self):
-        self._table_model.replaceData({})
-
-    def replace_data(self, data: dict):
-        self._table_model.replaceData(data)
 
     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)
 
 
@@ -194,6 +144,6 @@ if __name__ == "__main__":  # pragma: no cover
     app = QApplication([])
     set_theme("dark")
 
-    window = DictBackedTable(None, [["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,22 +1,50 @@
 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:  # pragma: no cover
+    from pydantic.fields import FieldInfo
 
 logger = bec_logger.logger
 
 
-class ScanMetadata(PydanticModelForm):
+class ScanMetadata(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__(
@@ -27,39 +55,118 @@ 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(
-            parent, "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(parent, initial_extras or [])
-        self._scan_name = scan_name or ""
-        self._md_schema = get_metadata_schema_for_scan(self._scan_name)
-        self._additional_metadata.data_changed.connect(self.validate_form)
-
-        super().__init__(parent=parent, data_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."""
@@ -74,25 +181,8 @@ 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()
-
 
 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
@@ -123,6 +213,7 @@ if __name__ == "__main__":  # pragma: no cover
         "bec_lib.metadata_schema._get_metadata_schema_registry",
         lambda: {"scan1": ExampleSchema1, "scan2": ExampleSchema2, "scan3": ExampleSchema3},
     ):
+
         app = QApplication([])
         w = QWidget()
         selection = QComboBox()
@@ -132,7 +223,6 @@ if __name__ == "__main__":  # pragma: no cover
         w.setLayout(layout)
 
         scan_metadata = ScanMetadata(
-            parent=w,
             scan_name="grid_scan",
             initial_extras=[["key1", "value1"], ["key2", "value2"], ["key3", "value3"]],
         )

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/plots/image/image_item.py

@@ -21,6 +21,9 @@ logger = bec_logger.logger
 # noinspection PyDataclass
 class ImageItemConfig(ConnectionConfig):  # TODO review config
     parent_id: str | None = Field(None, description="The parent plot of the image.")
+    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.")
     downsample: bool | None = Field(True, description="Whether to downsample the image.")
     opacity: float | None = Field(1.0, description="The opacity of the image.")
@@ -40,7 +43,6 @@ class ImageItemConfig(ConnectionConfig):  # TODO review config
 
 
 class ImageItem(BECConnector, pg.ImageItem):
-
     RPC = True
     USER_ACCESS = [
         "color_map",
@@ -59,21 +61,20 @@ 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",
     ]
 
     vRangeChangedManually = Signal(tuple)
-    removed = Signal(str)
 
     def __init__(
         self,
         config: Optional[ImageItemConfig] = None,
         gui_id: Optional[str] = None,
-        parent_image=None,  # FIXME: rename to parent
+        parent_image=None,
         **kwargs,
     ):
         if config is None:
@@ -85,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
@@ -96,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
@@ -238,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
@@ -272,9 +275,3 @@ class ImageItem(BECConnector, pg.ImageItem):
         self.raw_data = None
         self.buffer = []
         self.max_len = 0
-
-    def remove(self, emit: bool = True):
-        self.clear()
-        super().remove()
-        if emit:
-            self.removed.emit(self.objectName())

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

bec_widgets/widgets/plots/image/setting_widgets/image_roi_tree.py

@@ -1,437 +0,0 @@
-from __future__ import annotations
-
-import math
-from typing import TYPE_CHECKING
-
-from bec_qthemes import material_icon
-from qtpy.QtCore import QEvent, Qt
-from qtpy.QtGui import QColor
-from qtpy.QtWidgets import (
-    QColorDialog,
-    QHBoxLayout,
-    QHeaderView,
-    QSpinBox,
-    QToolButton,
-    QTreeWidget,
-    QTreeWidgetItem,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets import BECWidget
-from bec_widgets.utils import BECDispatcher, ConnectionConfig
-from bec_widgets.utils.toolbar import MaterialIconAction, ModularToolBar
-from bec_widgets.widgets.plots.roi.image_roi import (
-    BaseROI,
-    CircularROI,
-    RectangularROI,
-    ROIController,
-)
-from bec_widgets.widgets.utility.visual.color_button_native.color_button_native import (
-    ColorButtonNative,
-)
-from bec_widgets.widgets.utility.visual.colormap_widget.colormap_widget import BECColorMapWidget
-
-if TYPE_CHECKING:
-    from bec_widgets.widgets.plots.image.image import Image
-
-
-class ROILockButton(QToolButton):
-    """Keeps its icon and checked state in sync with a single ROI."""
-
-    def __init__(self, roi: BaseROI, parent=None):
-        super().__init__(parent)
-        self.setCheckable(True)
-        self._roi = roi
-        self.clicked.connect(self._toggle)
-        roi.movableChanged.connect(lambda _: self._sync())
-        self._sync()
-
-    def _toggle(self):
-        # checked -> locked -> movable = False
-        self._roi.movable = not self.isChecked()
-
-    def _sync(self):
-        movable = self._roi.movable
-        self.setChecked(not movable)
-        icon = "lock_open_right" if movable else "lock"
-        self.setIcon(material_icon(icon, size=(20, 20), convert_to_pixmap=False))
-
-
-class ROIPropertyTree(BECWidget, QWidget):
-    """
-    Two-column tree:  [ROI]  [Properties]
-
-    - Top-level: ROI name (editable) + color button.
-    - Children: type, line-width (spin box), coordinates (auto-updating).
-
-    Args:
-        image_widget (Image): The main Image widget that displays the ImageItem.
-            Provides ``plot_item`` and owns an ROIController already.
-        controller (ROIController, optional): Optionally pass an external controller.
-            If None, the manager uses ``image_widget.roi_controller``.
-        parent (QWidget, optional): Parent widget. Defaults to None.
-    """
-
-    PLUGIN = False
-    RPC = False
-
-    COL_ACTION, COL_ROI, COL_PROPS = range(3)
-    DELETE_BUTTON_COLOR = "#CC181E"
-
-    def __init__(
-        self,
-        *,
-        parent: QWidget = None,
-        image_widget: Image,
-        controller: ROIController | None = None,
-    ):
-
-        super().__init__(
-            parent=parent, config=ConnectionConfig(widget_class=self.__class__.__name__)
-        )
-
-        if controller is None:
-            # Use the controller already belonging to the Image widget
-            controller = getattr(image_widget, "roi_controller", None)
-            if controller is None:
-                controller = ROIController()
-                image_widget.roi_controller = controller
-
-        self.image_widget = image_widget
-        self.plot = image_widget.plot_item
-        self.controller = controller
-        self.roi_items: dict[BaseROI, QTreeWidgetItem] = {}
-
-        self.layout = QVBoxLayout(self)
-        self._init_toolbar()
-        self._init_tree()
-
-        # connect controller
-        self.controller.roiAdded.connect(self._on_roi_added)
-        self.controller.roiRemoved.connect(self._on_roi_removed)
-        self.controller.cleared.connect(self.tree.clear)
-
-        # initial load
-        for r in self.controller.rois:
-            self._on_roi_added(r)
-
-        self.tree.collapseAll()
-
-    # --------------------------------------------------------------------- UI
-    def _init_toolbar(self):
-        tb = ModularToolBar(self, self, orientation="horizontal")
-        # --- ROI draw actions (toggleable) ---
-        self.add_rect_action = MaterialIconAction("add_box", "Add Rect ROI", True, self)
-        self.add_circle_action = MaterialIconAction("add_circle", "Add Circle ROI", True, self)
-        tb.add_action("Add Rect ROI", self.add_rect_action, self)
-        tb.add_action("Add Circle ROI", self.add_circle_action, self)
-
-        # Expand/Collapse toggle
-        self.expand_toggle = MaterialIconAction(
-            "unfold_more", "Expand/Collapse", checkable=True, parent=self  # icon when collapsed
-        )
-        tb.add_action("Expand/Collapse", self.expand_toggle, self)
-
-        def _exp_toggled(on: bool):
-            if on:
-                # switched to expanded state
-                self.tree.expandAll()
-                new_icon = material_icon("unfold_less", size=(20, 20), convert_to_pixmap=False)
-            else:
-                # collapsed state
-                self.tree.collapseAll()
-                new_icon = material_icon("unfold_more", size=(20, 20), convert_to_pixmap=False)
-            self.expand_toggle.action.setIcon(new_icon)
-
-        self.expand_toggle.action.toggled.connect(_exp_toggled)
-
-        self.expand_toggle.action.setChecked(False)
-
-        # Lock/Unlock all ROIs
-        self.lock_all_action = MaterialIconAction(
-            "lock_open_right", "Lock/Unlock all ROIs", checkable=True, parent=self
-        )
-        tb.add_action("Lock/Unlock all ROIs", self.lock_all_action, self)
-
-        def _lock_all(checked: bool):
-            # checked -> everything locked (movable = False)
-            for r in self.controller.rois:
-                r.movable = not checked
-            new_icon = material_icon(
-                "lock" if checked else "lock_open_right", size=(20, 20), convert_to_pixmap=False
-            )
-            self.lock_all_action.action.setIcon(new_icon)
-
-        self.lock_all_action.action.toggled.connect(_lock_all)
-
-        # colormap widget
-        self.cmap = BECColorMapWidget(cmap=self.controller.colormap)
-        tb.addWidget(QWidget())  # spacer
-        tb.addWidget(self.cmap)
-        self.cmap.colormap_changed_signal.connect(self.controller.set_colormap)
-        self.layout.addWidget(tb)
-        self.controller.paletteChanged.connect(lambda cmap: setattr(self.cmap, "colormap", cmap))
-
-        # ROI drawing state
-        self._roi_draw_mode = None  # 'rect' | 'circle' | None
-        self._roi_start_pos = None  # QPointF in image coords
-        self._temp_roi = None  # live ROI being resized while dragging
-
-        # toggle handlers
-        self.add_rect_action.action.toggled.connect(
-            lambda on: self._set_roi_draw_mode("rect" if on else None)
-        )
-        self.add_circle_action.action.toggled.connect(
-            lambda on: self._set_roi_draw_mode("circle" if on else None)
-        )
-        # capture mouse events on the plot scene
-        self.plot.scene().installEventFilter(self)
-
-    def _init_tree(self):
-        self.tree = QTreeWidget()
-        self.tree.setColumnCount(3)
-        self.tree.setHeaderLabels(["Actions", "ROI", "Properties"])
-        self.tree.header().setSectionResizeMode(self.COL_ACTION, QHeaderView.ResizeToContents)
-        self.tree.headerItem().setText(self.COL_ACTION, "Actions")  # blank header text
-        self.tree.itemChanged.connect(self._on_item_edited)
-        self.layout.addWidget(self.tree)
-
-    ################################################################################
-    # Helper functions
-    ################################################################################
-
-    # --------------------------------------------------------------------- formatting
-    @staticmethod
-    def _format_coord_text(value) -> str:
-        """
-        Consistently format a coordinate value for display.
-        """
-        if isinstance(value, (tuple, list)):
-            return "(" + ", ".join(f"{v:.2f}" for v in value) + ")"
-        if isinstance(value, (int, float)):
-            return f"{value:.2f}"
-        return str(value)
-
-    def _set_roi_draw_mode(self, mode: str | None):
-        # Ensure only the selected action is toggled on
-        if mode == "rect":
-            self.add_rect_action.action.setChecked(True)
-            self.add_circle_action.action.setChecked(False)
-        elif mode == "circle":
-            self.add_rect_action.action.setChecked(False)
-            self.add_circle_action.action.setChecked(True)
-        else:
-            self.add_rect_action.action.setChecked(False)
-            self.add_circle_action.action.setChecked(False)
-        self._roi_draw_mode = mode
-        self._roi_start_pos = None
-        # remove any unfinished temp ROI
-        if self._temp_roi is not None:
-            self.plot.removeItem(self._temp_roi)
-            self._temp_roi = None
-
-    def eventFilter(self, obj, event):
-        if self._roi_draw_mode is None:
-            return super().eventFilter(obj, event)
-        if event.type() == QEvent.GraphicsSceneMousePress and event.button() == Qt.LeftButton:
-            self._roi_start_pos = self.plot.vb.mapSceneToView(event.scenePos())
-            if self._roi_draw_mode == "rect":
-                self._temp_roi = RectangularROI(
-                    pos=[self._roi_start_pos.x(), self._roi_start_pos.y()],
-                    size=[5, 5],
-                    parent_image=self.image_widget,
-                    resize_handles=False,
-                )
-            if self._roi_draw_mode == "circle":
-                self._temp_roi = CircularROI(
-                    pos=[self._roi_start_pos.x() - 2.5, self._roi_start_pos.y() - 2.5],
-                    size=[5, 5],
-                    parent_image=self.image_widget,
-                )
-            self.plot.addItem(self._temp_roi)
-            return True
-        elif event.type() == QEvent.GraphicsSceneMouseMove and self._temp_roi is not None:
-            pos = self.plot.vb.mapSceneToView(event.scenePos())
-            dx = pos.x() - self._roi_start_pos.x()
-            dy = pos.y() - self._roi_start_pos.y()
-
-            if self._roi_draw_mode == "rect":
-                self._temp_roi.setSize([dx, dy])
-            if self._roi_draw_mode == "circle":
-                r = max(
-                    1, math.hypot(dx, dy)
-                )  # radius never smaller than 1 for safety of handle mapping, otherwise SEGFAULT
-                d = 2 * r  # diameter
-                self._temp_roi.setPos(self._roi_start_pos.x() - r, self._roi_start_pos.y() - r)
-                self._temp_roi.setSize([d, d])
-            return True
-        elif (
-            event.type() == QEvent.GraphicsSceneMouseRelease
-            and event.button() == Qt.LeftButton
-            and self._temp_roi is not None
-        ):
-            # finalize ROI
-            final_roi = self._temp_roi
-            self._temp_roi = None
-            self._set_roi_draw_mode(None)
-            # register via controller
-            self.controller.add_roi(final_roi)
-            return True
-        return super().eventFilter(obj, event)
-
-    # --------------------------------------------------------- controller slots
-    def _on_roi_added(self, roi: BaseROI):
-        # check the global setting from the toolbar
-        if self.lock_all_action.action.isChecked():
-            roi.movable = False
-        # parent row with blank action column, name in ROI column
-        parent = QTreeWidgetItem(self.tree, ["", "", ""])
-        parent.setText(self.COL_ROI, roi.label)
-        parent.setFlags(parent.flags() | Qt.ItemIsEditable)
-        # --- actions widget (lock/unlock + delete) ---
-        actions_widget = QWidget()
-        actions_layout = QHBoxLayout(actions_widget)
-        actions_layout.setContentsMargins(0, 0, 0, 0)
-        actions_layout.setSpacing(3)
-
-        # lock / unlock toggle
-        lock_btn = ROILockButton(roi, parent=self)
-        actions_layout.addWidget(lock_btn)
-
-        # delete button
-        del_btn = QToolButton()
-        delete_icon = material_icon(
-            "delete",
-            size=(20, 20),
-            convert_to_pixmap=False,
-            filled=False,
-            color=self.DELETE_BUTTON_COLOR,
-        )
-        del_btn.setIcon(delete_icon)
-        del_btn.clicked.connect(lambda _=None, r=roi: self._delete_roi(r))
-        actions_layout.addWidget(del_btn)
-
-        # install composite widget into the tree
-        self.tree.setItemWidget(parent, self.COL_ACTION, actions_widget)
-        # color button
-        color_btn = ColorButtonNative(parent=self, color=roi.line_color)
-        self.tree.setItemWidget(parent, self.COL_PROPS, color_btn)
-        color_btn.clicked.connect(lambda: self._pick_color(roi, color_btn))
-
-        # child rows (3 columns: action, ROI, properties)
-        QTreeWidgetItem(parent, ["", "Type", roi.__class__.__name__])
-        width_item = QTreeWidgetItem(parent, ["", "Line width", ""])
-        width_spin = QSpinBox()
-        width_spin.setRange(1, 50)
-        width_spin.setValue(roi.line_width)
-        self.tree.setItemWidget(width_item, self.COL_PROPS, width_spin)
-        width_spin.valueChanged.connect(lambda v, r=roi: setattr(r, "line_width", v))
-
-        # --- Step 2: Insert separate coordinate rows (one per value)
-        coord_rows = {}
-        coords = roi.get_coordinates(typed=True)
-
-        for key, value in coords.items():
-            # Human-readable label: “center x” from “center_x”, etc.
-            label = key.replace("_", " ").title()
-            val_text = self._format_coord_text(value)
-            row = QTreeWidgetItem(parent, ["", label, val_text])
-            coord_rows[key] = row
-
-        # keep dict refs
-        self.roi_items[roi] = parent
-
-        # --- Step 3: Update coordinates on ROI movement
-        def _update_coords():
-            c_dict = roi.get_coordinates(typed=True)
-            for k, row in coord_rows.items():
-                if k in c_dict:
-                    val = c_dict[k]
-                    row.setText(self.COL_PROPS, self._format_coord_text(val))
-
-        if isinstance(roi, RectangularROI):
-            roi.edgesChanged.connect(_update_coords)
-        else:
-            roi.centerChanged.connect(_update_coords)
-
-        # sync width edits back to spinbox
-        roi.penChanged.connect(lambda r=roi, sp=width_spin: sp.setValue(r.line_width))
-        roi.nameChanged.connect(lambda n, itm=parent: itm.setText(self.COL_ROI, n))
-
-        # color changes
-        roi.penChanged.connect(lambda r=roi, b=color_btn: b.set_color(r.line_color))
-
-        for c in range(3):
-            self.tree.resizeColumnToContents(c)
-
-    def _toggle_movable(self, roi: BaseROI):
-        """
-        Toggle the `movable` property of the given ROI.
-        """
-        roi.movable = not roi.movable
-
-    def _on_roi_removed(self, roi: BaseROI):
-        item = self.roi_items.pop(roi, None)
-        if item:
-            idx = self.tree.indexOfTopLevelItem(item)
-            self.tree.takeTopLevelItem(idx)
-
-    # ---------------------------------------------------------- event handlers
-    def _pick_color(self, roi: BaseROI, btn: "ColorButtonNative"):
-        clr = QColorDialog.getColor(QColor(roi.line_color), self, "Select ROI Color")
-        if clr.isValid():
-            roi.line_color = clr.name()
-            btn.set_color(clr)
-
-    def _on_item_edited(self, item: QTreeWidgetItem, col: int):
-        if col != self.COL_ROI:
-            return
-        # find which roi
-        for r, it in self.roi_items.items():
-            if it is item:
-                r.label = item.text(self.COL_ROI)
-                break
-
-    def _delete_roi(self, roi):
-        self.controller.remove_roi(roi)
-
-    def cleanup(self):
-        self.cmap.close()
-        self.cmap.deleteLater()
-        super().cleanup()
-
-
-# Demo
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    import numpy as np
-    from qtpy.QtWidgets import QApplication
-
-    from bec_widgets.widgets.plots.image.image import Image
-
-    app = QApplication(sys.argv)
-
-    bec_dispatcher = BECDispatcher(gui_id="roi_tree_demo")
-    client = bec_dispatcher.client
-    client.start()
-
-    image_widget = Image(popups=False)
-    image_widget.main_image.set_data(np.random.normal(size=(200, 200)))
-
-    win = QWidget()
-    win.setWindowTitle("Modular ROI Demo")
-    ml = QHBoxLayout(win)
-
-    # Add the image widget on the left
-    ml.addWidget(image_widget)
-
-    # ROI manager linked to that image
-    mgr = ROIPropertyTree(parent=image_widget, image_widget=image_widget)
-    mgr.setFixedWidth(350)
-    ml.addWidget(mgr)
-
-    win.resize(1500, 600)
-    win.show()
-    sys.exit(app.exec_())

bec_widgets/widgets/plots/image/toolbar_bundles/image_selection.py

@@ -1,5 +1,5 @@
 from bec_lib.device import ReadoutPriority
-from qtpy.QtCore import Qt, QTimer
+from qtpy.QtCore import Qt
 from qtpy.QtWidgets import QComboBox, QStyledItemDelegate
 
 from bec_widgets.utils.error_popups import SafeSlot
@@ -35,73 +35,25 @@ class MonitorSelectionToolbarBundle(ToolbarBundle):
         self.device_combo_box.addItem("", None)
         self.device_combo_box.setCurrentText("")
         self.device_combo_box.setToolTip("Select Device")
-        self.device_combo_box.setFixedWidth(150)
         self.device_combo_box.setItemDelegate(NoCheckDelegate(self.device_combo_box))
 
-        self.add_action("monitor", WidgetAction(widget=self.device_combo_box, adjust_size=False))
+        self.add_action("monitor", WidgetAction(widget=self.device_combo_box, adjust_size=True))
 
         # 2) Dimension combo box
         self.dim_combo_box = QComboBox(parent=self.target_widget)
         self.dim_combo_box.addItems(["auto", "1d", "2d"])
         self.dim_combo_box.setCurrentText("auto")
         self.dim_combo_box.setToolTip("Monitor Dimension")
-        self.dim_combo_box.setFixedWidth(100)
+        self.dim_combo_box.setFixedWidth(60)
         self.dim_combo_box.setItemDelegate(NoCheckDelegate(self.dim_combo_box))
 
-        self.add_action("dim_combo", WidgetAction(widget=self.dim_combo_box, adjust_size=False))
+        self.add_action("dim_combo", WidgetAction(widget=self.dim_combo_box, adjust_size=True))
 
-        self.device_combo_box.currentTextChanged.connect(self.connect_monitor)
-        self.dim_combo_box.currentTextChanged.connect(self.connect_monitor)
-
-        QTimer.singleShot(0, self._adjust_and_connect)
-
-    def _adjust_and_connect(self):
-        """
-        Adjust the size of the device combo box and populate it with preview signals.
-        Has to be done with QTimer.singleShot to ensure the UI is fully initialized, needed for testing.
-        """
-        self._populate_preview_signals()
-        self._reverse_device_items()
-        self.device_combo_box.setCurrentText("")  # set again default to empty string
-
-    def _populate_preview_signals(self) -> None:
-        """
-        Populate the device combo box with preview‑signal devices in the
-        format '<device>_<signal>' and store the tuple(device, signal) in
-        the item's userData for later use.
-        """
-        preview_signals = self.target_widget.client.device_manager.get_bec_signals("PreviewSignal")
-        for device, signal, signal_config in preview_signals:
-            label = signal_config.get("obj_name", f"{device}_{signal}")
-            self.device_combo_box.addItem(label, (device, signal, signal_config))
-
-    def _reverse_device_items(self) -> None:
-        """
-        Reverse the current order of items in the device combo box while
-        keeping their userData and restoring the previous selection.
-        """
-        current_text = self.device_combo_box.currentText()
-        items = [
-            (self.device_combo_box.itemText(i), self.device_combo_box.itemData(i))
-            for i in range(self.device_combo_box.count())
-        ]
-        self.device_combo_box.clear()
-        for text, data in reversed(items):
-            self.device_combo_box.addItem(text, data)
-        if current_text:
-            self.device_combo_box.setCurrentText(current_text)
+        # Connect slots, a device will be connected upon change of any combobox
+        self.device_combo_box.currentTextChanged.connect(lambda: self.connect_monitor())
+        self.dim_combo_box.currentTextChanged.connect(lambda: self.connect_monitor())
 
     @SafeSlot()
-    def connect_monitor(self, *args, **kwargs):
-        """
-        Connect the target widget to the selected monitor based on the current device and dimension.
-
-        If the selected device is a preview-signal device, it will use the tuple (device, signal) as the monitor.
-        """
+    def connect_monitor(self):
         dim = self.dim_combo_box.currentText()
-        data = self.device_combo_box.currentData()
-
-        if isinstance(data, tuple):
-            self.target_widget.image(monitor=data, monitor_type="auto")
-        else:
-            self.target_widget.image(monitor=self.device_combo_box.currentText(), monitor_type=dim)
+        self.target_widget.image(monitor=self.device_combo_box.currentText(), monitor_type=dim)

bec_widgets/widgets/plots/image/toolbar_bundles/processing.py

@@ -11,31 +11,18 @@ class ImageProcessingToolbarBundle(ToolbarBundle):
         super().__init__(bundle_id=bundle_id, actions=[], **kwargs)
         self.target_widget = target_widget
 
-        self.fft = MaterialIconAction(
-            icon_name="fft", tooltip="Toggle FFT", checkable=True, parent=self.target_widget
-        )
-        self.log = MaterialIconAction(
-            icon_name="log_scale", tooltip="Toggle Log", checkable=True, parent=self.target_widget
-        )
+        self.fft = MaterialIconAction(icon_name="fft", tooltip="Toggle FFT", checkable=True)
+        self.log = MaterialIconAction(icon_name="log_scale", tooltip="Toggle Log", checkable=True)
         self.transpose = MaterialIconAction(
-            icon_name="transform",
-            tooltip="Transpose Image",
-            checkable=True,
-            parent=self.target_widget,
+            icon_name="transform", tooltip="Transpose Image", checkable=True
         )
         self.right = MaterialIconAction(
-            icon_name="rotate_right",
-            tooltip="Rotate image clockwise by 90 deg",
-            parent=self.target_widget,
+            icon_name="rotate_right", tooltip="Rotate image clockwise by 90 deg"
         )
         self.left = MaterialIconAction(
-            icon_name="rotate_left",
-            tooltip="Rotate image counterclockwise by 90 deg",
-            parent=self.target_widget,
-        )
-        self.reset = MaterialIconAction(
-            icon_name="reset_settings", tooltip="Reset Image Settings", parent=self.target_widget
+            icon_name="rotate_left", tooltip="Rotate image counterclockwise by 90 deg"
         )
+        self.reset = MaterialIconAction(icon_name="reset_settings", tooltip="Reset Image Settings")
 
         self.add_action("fft", self.fft)
         self.add_action("log", self.log)
@@ -68,24 +55,24 @@ class ImageProcessingToolbarBundle(ToolbarBundle):
 
     @SafeSlot()
     def rotate_right(self):
-        if self.target_widget.num_rotation_90 is None:
+        if self.target_widget.rotation is None:
             return
-        rotation = (self.target_widget.num_rotation_90 - 1) % 4
-        self.target_widget.num_rotation_90 = rotation
+        rotation = (self.target_widget.rotation - 1) % 4
+        self.target_widget.rotation = rotation
 
     @SafeSlot()
     def rotate_left(self):
-        if self.target_widget.num_rotation_90 is None:
+        if self.target_widget.rotation is None:
             return
-        rotation = (self.target_widget.num_rotation_90 + 1) % 4
-        self.target_widget.num_rotation_90 = rotation
+        rotation = (self.target_widget.rotation + 1) % 4
+        self.target_widget.rotation = rotation
 
     @SafeSlot()
     def reset_settings(self):
         self.target_widget.fft = False
         self.target_widget.log = False
         self.target_widget.transpose = False
-        self.target_widget.num_rotation_90 = 0
+        self.target_widget.rotation = 0
 
         self.fft.action.setChecked(False)
         self.log.action.setChecked(False)

bec_widgets/widgets/plots/multi_waveform/multi_waveform.py

@@ -91,8 +91,6 @@ class MultiWaveform(PlotBase):
         "y_log.setter",
         "legend_label_size",
         "legend_label_size.setter",
-        "minimal_crosshair_precision",
-        "minimal_crosshair_precision.setter",
         # MultiWaveform Specific RPC Access
         "highlighted_index",
         "highlighted_index.setter",

bec_widgets/widgets/plots/multi_waveform/toolbar_bundles/monitor_selection.py

@@ -29,7 +29,9 @@ class MultiWaveformSelectionToolbarBundle(ToolbarBundle):
 
         # Monitor Selection
         self.monitor = DeviceComboBox(
-            device_filter=BECDeviceFilter.DEVICE, readout_priority_filter=ReadoutPriority.ASYNC
+            device_filter=BECDeviceFilter.DEVICE,
+            readout_priority_filter=ReadoutPriority.ASYNC,
+            parent_id=self.target_widget.gui_id,
         )
         self.monitor.addItem("", None)
         self.monitor.setCurrentText("")
@@ -38,7 +40,7 @@ class MultiWaveformSelectionToolbarBundle(ToolbarBundle):
         self.add_action("monitor", WidgetAction(widget=self.monitor, adjust_size=False))
 
         # Colormap Selection
-        self.colormap_widget = BECColorMapWidget(cmap="plasma")
+        self.colormap_widget = BECColorMapWidget(cmap="plasma", parent_id=self.target_widget.gui_id)
         self.add_action("color_map", WidgetAction(widget=self.colormap_widget, adjust_size=False))
 
         # Connect slots, a device will be connected upon change of any combobox

bec_widgets/widgets/plots/plot_base.py

@@ -98,7 +98,6 @@ class PlotBase(BECWidget, QWidget):
         self._ui_mode = UIMode.POPUP if popups else UIMode.SIDE
         self.axis_settings_dialog = None
         self.plot_widget = pg.GraphicsLayoutWidget(parent=self)
-        self.plot_widget.ci.setContentsMargins(0, 0, 0, 0)
         self.plot_item = pg.PlotItem(viewBox=BECViewBox(enableMenu=True))
         self.plot_widget.addItem(self.plot_item)
         self.side_panel = SidePanel(self, orientation="left", panel_max_width=280)
@@ -112,11 +111,8 @@ class PlotBase(BECWidget, QWidget):
         self.fps_label = QLabel(alignment=Qt.AlignmentFlag.AlignRight)
         self._user_x_label = ""
         self._x_label_suffix = ""
-        self._x_axis_units = ""
         self._user_y_label = ""
         self._y_label_suffix = ""
-        self._y_axis_units = ""
-        self._minimal_crosshair_precision = 3
 
         # Plot Indicator Items
         self.tick_item = BECTickItem(parent=self, plot_item=self.plot_item)
@@ -476,31 +472,12 @@ class PlotBase(BECWidget, QWidget):
         self._x_label_suffix = suffix
         self._apply_x_label()
 
-    @property
-    def x_label_units(self) -> str:
-        """
-        The units of the x-axis.
-        """
-        return self._x_axis_units
-
-    @x_label_units.setter
-    def x_label_units(self, units: str):
-        """
-        The units of the x-axis.
-
-        Args:
-            units(str): The units to set.
-        """
-        self._x_axis_units = units
-        self._apply_x_label()
-
     @property
     def x_label_combined(self) -> str:
         """
-        The final label shown on the axis = user portion + suffix + [units].
+        The final label shown on the axis = user portion + suffix.
         """
-        units = f" [{self._x_axis_units}]" if self._x_axis_units else ""
-        return self._user_x_label + self._x_label_suffix + units
+        return self._user_x_label + self._x_label_suffix
 
     def _apply_x_label(self):
         """
@@ -543,31 +520,12 @@ class PlotBase(BECWidget, QWidget):
         self._y_label_suffix = suffix
         self._apply_y_label()
 
-    @property
-    def y_label_units(self) -> str:
-        """
-        The units of the y-axis.
-        """
-        return self._y_axis_units
-
-    @y_label_units.setter
-    def y_label_units(self, units: str):
-        """
-        The units of the y-axis.
-
-        Args:
-            units(str): The units to set.
-        """
-        self._y_axis_units = units
-        self._apply_y_label()
-
     @property
     def y_label_combined(self) -> str:
         """
-        The final y label shown on the axis = user portion + suffix + [units].
+        The final y label shown on the axis = user portion + suffix.
         """
-        units = f" [{self._y_axis_units}]" if self._y_axis_units else ""
-        return self._user_y_label + self._y_label_suffix + units
+        return self._user_y_label + self._y_label_suffix
 
     def _apply_y_label(self):
         """
@@ -837,7 +795,6 @@ class PlotBase(BECWidget, QWidget):
         """
         self.plot_item.showAxis("top", value)
         self.plot_item.showAxis("right", value)
-
         self.property_changed.emit("outer_axes", value)
 
     @SafeProperty(bool, doc="Show inner axes of the plot widget.")
@@ -857,7 +814,6 @@ class PlotBase(BECWidget, QWidget):
         """
         self.plot_item.showAxis("bottom", value)
         self.plot_item.showAxis("left", value)
-
         self._apply_x_label()
         self._apply_y_label()
         self.property_changed.emit("inner_axes", value)
@@ -979,9 +935,7 @@ class PlotBase(BECWidget, QWidget):
     def hook_crosshair(self) -> None:
         """Hook the crosshair to all plots."""
         if self.crosshair is None:
-            self.crosshair = Crosshair(
-                self.plot_item, min_precision=self._minimal_crosshair_precision
-            )
+            self.crosshair = Crosshair(self.plot_item, precision=3)
             self.crosshair.crosshairChanged.connect(self.crosshair_position_changed)
             self.crosshair.crosshairClicked.connect(self.crosshair_position_clicked)
             self.crosshair.coordinatesChanged1D.connect(self.crosshair_coordinates_changed)
@@ -1009,29 +963,6 @@ class PlotBase(BECWidget, QWidget):
 
         self.unhook_crosshair()
 
-    @SafeProperty(
-        int, doc="Minimum decimal places for crosshair when dynamic precision is enabled."
-    )
-    def minimal_crosshair_precision(self) -> int:
-        """
-        Minimum decimal places for crosshair when dynamic precision is enabled.
-        """
-        return self._minimal_crosshair_precision
-
-    @minimal_crosshair_precision.setter
-    def minimal_crosshair_precision(self, value: int):
-        """
-        Set the minimum decimal places for crosshair when dynamic precision is enabled.
-
-        Args:
-            value(int): The minimum decimal places to set.
-        """
-        value_int = max(0, int(value))
-        self._minimal_crosshair_precision = value_int
-        if self.crosshair is not None:
-            self.crosshair.min_precision = value_int
-        self.property_changed.emit("minimal_crosshair_precision", value_int)
-
     @SafeSlot()
     def reset(self) -> None:
         """Reset the plot widget."""

bec_widgets/widgets/plots/roi/image_roi.py

@@ -1,964 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import pyqtgraph as pg
-from pyqtgraph import TextItem
-from pyqtgraph import functions as fn
-from pyqtgraph import mkPen
-from qtpy import QtCore
-from qtpy.QtCore import QObject, Signal
-
-from bec_widgets import SafeProperty
-from bec_widgets.utils import BECConnector, ConnectionConfig
-from bec_widgets.utils.colors import Colors
-
-if TYPE_CHECKING:
-    from bec_widgets.widgets.plots.image.image import Image
-
-
-class LabelAdorner:
-    """Manages a TextItem label on top of any ROI, keeping it aligned."""
-
-    def __init__(
-        self,
-        roi: BaseROI,
-        anchor: tuple[int, int] = (0, 1),
-        padding: int = 2,
-        bg_color: str | tuple[int, int, int, int] = (0, 0, 0, 100),
-        text_color: str | tuple[int, int, int, int] = "white",
-    ):
-        """
-        Initializes a label overlay for a given region of interest (ROI), allowing for customization
-        of text placement, padding, background color, and text color. Automatically attaches the label
-        to the ROI and updates its position and content based on ROI changes.
-
-        Args:
-            roi: The region of interest to which the label will be attached.
-            anchor: Tuple specifying the label's anchor relative to the ROI. Default is (0, 1).
-            padding: Integer specifying the padding around the label's text. Default is 2.
-            bg_color: RGBA tuple for the label's background color. Default is (0, 0, 0, 100).
-            text_color: String specifying the color of the label's text. Default is "white".
-        """
-        self.roi = roi
-        self.label = TextItem(anchor=anchor)
-        self.padding = padding
-        self.bg_rgba = bg_color
-        self.text_color = text_color
-        roi.addItem(self.label) if hasattr(roi, "addItem") else self.label.setParentItem(roi)
-        # initial draw
-        self._update_html(roi.label)
-        self._reposition()
-        # reconnect on geometry/name changes
-        roi.sigRegionChanged.connect(self._reposition)
-        if hasattr(roi, "nameChanged"):
-            roi.nameChanged.connect(self._update_html)
-
-    def _update_html(self, text: str):
-        """
-        Updates the HTML content of the label with the given text.
-
-        Creates an HTML div with the configured background color, text color, and padding,
-        then sets this HTML as the content of the label.
-
-        Args:
-            text (str): The text to display in the label.
-        """
-        html = (
-            f'<div style="background: rgba{self.bg_rgba}; '
-            f"font-weight:bold; color:{self.text_color}; "
-            f'padding:{self.padding}px;">{text}</div>'
-        )
-        self.label.setHtml(html)
-
-    def _reposition(self):
-        """
-        Repositions the label to align with the ROI's current position.
-
-        This method is called whenever the ROI's position or size changes.
-        It places the label at the bottom-left corner of the ROI's bounding rectangle.
-        """
-        # put at top-left corner of ROI’s bounding rect
-        size = self.roi.state["size"]
-        height = size[1]
-        self.label.setPos(0, height)
-
-
-class BaseROI(BECConnector):
-    """Base class for all Region of Interest (ROI) implementations.
-
-    This class serves as a mixin that provides common properties and methods for ROIs,
-    including name, line color, and line width properties. It inherits from BECConnector
-    to enable remote procedure call functionality.
-
-    Attributes:
-        RPC (bool): Flag indicating if remote procedure calls are enabled.
-        PLUGIN (bool): Flag indicating if this class is a plugin.
-        nameChanged (Signal): Signal emitted when the ROI name changes.
-        penChanged (Signal): Signal emitted when the ROI pen (color/width) changes.
-        USER_ACCESS (list): List of methods and properties accessible via RPC.
-    """
-
-    RPC = True
-    PLUGIN = False
-
-    nameChanged = Signal(str)
-    penChanged = Signal()
-    movableChanged = Signal(bool)
-    USER_ACCESS = [
-        "label",
-        "label.setter",
-        "movable",
-        "movable.setter",
-        "line_color",
-        "line_color.setter",
-        "line_width",
-        "line_width.setter",
-        "get_coordinates",
-        "get_data_from_image",
-        "set_position",
-    ]
-
-    def __init__(
-        self,
-        *,
-        # BECConnector kwargs
-        config: ConnectionConfig | None = None,
-        gui_id: str | None = None,
-        parent_image: Image | None,
-        # ROI-specific
-        label: str | None = None,
-        line_color: str | None = None,
-        line_width: int = 5,
-        movable: bool = True,
-        # all remaining pg.*ROI kwargs (pos, size, pen, …)
-        **pg_kwargs,
-    ):
-        """Base class for all modular ROIs.
-
-        Args:
-            label (str): Human-readable name shown in ROI Manager and labels.
-            line_color (str | None, optional): Initial pen color. Defaults to None.
-                Controller may override color later.
-            line_width (int, optional): Initial pen width. Defaults to 15.
-                Controller may override width later.
-            config (ConnectionConfig | None, optional): Standard BECConnector argument. Defaults to None.
-            gui_id (str | None, optional): Standard BECConnector argument. Defaults to None.
-            parent_image (BECConnector | None, optional): Standard BECConnector argument. Defaults to None.
-        """
-        if config is None:
-            config = ConnectionConfig(widget_class=self.__class__.__name__)
-        self.config = config
-
-        self.set_parent(parent_image)
-        self.parent_plot_item = parent_image.plot_item
-        object_name = label.replace("-", "_").replace(" ", "_") if label else None
-        super().__init__(
-            object_name=object_name,
-            config=config,
-            gui_id=gui_id,
-            removable=True,
-            invertible=True,
-            movable=movable,
-            **pg_kwargs,
-        )
-
-        self._label = label or "ROI"
-        self._line_color = line_color or "#ffffff"
-        self._line_width = line_width
-        self._description = True
-        self._movable = movable
-        self.setPen(mkPen(self._line_color, width=self._line_width))
-
-        # Reset Handles to avoid inherited handles from pyqtgraph
-        self.remove_scale_handles()  # remove any existing handles from pyqtgraph.RectROI
-        if movable:
-            self.add_scale_handle()  # add custom scale handles
-
-    def set_parent(self, parent: Image):
-        """
-        Sets the parent image for this ROI.
-
-        Args:
-            parent (Image): The parent image object to associate with this ROI.
-        """
-        self.parent_image = parent
-
-    def parent(self):
-        """
-        Gets the parent image associated with this ROI.
-
-        Returns:
-            Image: The parent image object, or None if no parent is set.
-        """
-        return self.parent_image
-
-    @property
-    def movable(self) -> bool:
-        """
-        Gets whether this ROI is movable.
-
-        Returns:
-            bool: True if the ROI can be moved, False otherwise.
-        """
-        return self._movable
-
-    @movable.setter
-    def movable(self, value: bool):
-        """
-        Sets whether this ROI is movable.
-
-        If the new value is different from the current value, this method updates
-        the internal state and emits the penChanged signal.
-
-        Args:
-            value (bool): True to make the ROI movable, False to make it fixed.
-        """
-        if value != self._movable:
-            self._movable = value
-            # All relevant properties from pyqtgraph to block movement
-            self.translatable = value
-            self.rotatable = value
-            self.resizable = value
-            self.removable = value
-            if value:
-                self.add_scale_handle()  # add custom scale handles
-            else:
-                self.remove_scale_handles()  # remove custom scale handles
-            self.movableChanged.emit(value)
-
-    @property
-    def label(self) -> str:
-        """
-        Gets the display name of this ROI.
-
-        Returns:
-            str: The current name of the ROI.
-        """
-        return self._label
-
-    @label.setter
-    def label(self, new: str):
-        """
-        Sets the display name of this ROI.
-
-        If the new name is different from the current name, this method updates
-        the internal name, emits the nameChanged signal, and updates the object name.
-
-        Args:
-            new (str): The new name to set for the ROI.
-        """
-        if new != self._label:
-            self._label = new
-            self.nameChanged.emit(new)
-            self.change_object_name(new)
-
-    @property
-    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).
-        """
-        return self._line_color
-
-    @line_color.setter
-    def line_color(self, value: str):
-        """
-        Sets the line color of the ROI.
-
-        If the new color is different from the current color, this method updates
-        the internal color value, updates the pen while preserving the line width,
-        and emits the penChanged signal.
-
-        Args:
-            value (str): The new color to set for the ROI's outline (e.g., hex color code).
-        """
-        if value != self._line_color:
-            self._line_color = value
-            # update pen but preserve width
-            self.setPen(mkPen(value, width=self._line_width))
-            self.penChanged.emit()
-
-    @property
-    def line_width(self) -> int:
-        """
-        Gets the current line width of the ROI.
-
-        Returns:
-            int: The current line width in pixels.
-        """
-        return self._line_width
-
-    @line_width.setter
-    def line_width(self, value: int):
-        """
-        Sets the line width of the ROI.
-
-        If the new width is different from the current width and is greater than 0,
-        this method updates the internal width value, updates the pen while preserving
-        the line color, and emits the penChanged signal.
-
-        Args:
-            value (int): The new width to set for the ROI's outline in pixels.
-                Must be greater than 0.
-        """
-        if value != self._line_width and value > 0:
-            self._line_width = value
-            self.setPen(mkPen(self._line_color, width=value))
-            self.penChanged.emit()
-
-    @property
-    def description(self) -> bool:
-        """
-        Gets whether ROI coordinates should be emitted with descriptive keys by default.
-
-        Returns:
-            bool: True if coordinates should include descriptive keys, False otherwise.
-        """
-        return self._description
-
-    @description.setter
-    def description(self, value: bool):
-        """
-        Sets whether ROI coordinates should be emitted with descriptive keys by default.
-
-        This affects the default behavior of the get_coordinates method.
-
-        Args:
-            value (bool): True to emit coordinates with descriptive keys, False to emit
-                as a simple tuple of values.
-        """
-        self._description = value
-
-    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.
-        """
-        raise NotImplementedError("Subclasses must implement get_coordinates()")
-
-    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.
-        """
-        if image_item is None:
-            image_item = next(
-                (
-                    it
-                    for it in self.scene().items()
-                    if isinstance(it, pg.ImageItem) and it.image is not None
-                ),
-                None,
-            )
-        if image_item is None:
-            raise RuntimeError("No ImageItem found in the current scene.")
-
-        data = image_item.image  # the raw ndarray held by ImageItem
-        return self.getArrayRegion(
-            data, img=image_item, returnMappedCoords=returnMappedCoords, **kwargs
-        )
-
-    def add_scale_handle(self):
-        """Add scale handles to the ROI."""
-        return
-
-    def remove_scale_handles(self):
-        """Remove all scale handles from the ROI."""
-        handles = self.handles
-        for i in range(len(handles)):
-            try:
-                self.removeHandle(0)
-            except IndexError:
-                continue
-
-    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.
-        """
-        self.setPos(x, y)
-
-    def remove(self):
-        # Delegate to controller first so that GUI managers stay in sync
-        controller = getattr(self.parent_image, "roi_controller", None)
-        if controller and self in controller.rois:
-            controller.remove_roi(self)
-            return  # controller will call back into this method once deregistered
-        self.remove_scale_handles()
-        self.rpc_register.remove_rpc(self)
-        self.parent_image.plot_item.removeItem(self)
-        viewBox = self.parent_plot_item.vb
-        viewBox.update()
-
-
-class RectangularROI(BaseROI, pg.RectROI):
-    """
-    Defines a rectangular Region of Interest (ROI) with additional functionality.
-
-    Provides tools for manipulating and extracting data from rectangular areas on
-    images, includes support for GUI features and event-driven signaling.
-
-    Attributes:
-        edgesChanged (Signal): Signal emitted when the ROI edges change, providing
-            the new ("top_left", "top_right", "bottom_left","bottom_right") coordinates.
-        edgesReleased (Signal): Signal emitted when the ROI edges are released,
-            providing the new ("top_left", "top_right", "bottom_left","bottom_right") coordinates.
-    """
-
-    edgesChanged = Signal(float, float, float, float)
-    edgesReleased = Signal(float, float, float, float)
-
-    def __init__(
-        self,
-        *,
-        # pg.RectROI kwargs
-        pos: tuple[float, float],
-        size: tuple[float, float],
-        pen=None,
-        # BECConnector kwargs
-        config: ConnectionConfig | None = None,
-        gui_id: str | None = None,
-        parent_image: Image | None = None,
-        # ROI specifics
-        label: str | None = None,
-        line_color: str | None = None,
-        line_width: int = 5,
-        movable: bool = True,
-        resize_handles: bool = True,
-        **extra_pg,
-    ):
-        """
-        Initializes an instance with properties for defining a rectangular ROI with handles,
-        configurations, and an auto-aligning label. Also connects a signal for region updates.
-
-        Args:
-            pos: Initial position of the ROI.
-            size: Initial size of the ROI.
-            pen: Defines the border appearance; can be color or style.
-            config: Optional configuration details for the connection.
-            gui_id: Optional identifier for the associated GUI element.
-            parent_image: Optional parent object the ROI is related to.
-            label: Optional label for identification within the context.
-            line_color: Optional color of the ROI outline.
-            line_width: Width of the ROI's outline in pixels.
-            parent_plot_item: The plot item this ROI belongs to.
-            **extra_pg: Additional keyword arguments specific to pg.RectROI.
-        """
-        super().__init__(
-            config=config,
-            gui_id=gui_id,
-            parent_image=parent_image,
-            label=label,
-            line_color=line_color,
-            line_width=line_width,
-            pos=pos,
-            size=size,
-            pen=pen,
-            movable=movable,
-            **extra_pg,
-        )
-
-        self.sigRegionChanged.connect(self._on_region_changed)
-        self.adorner = LabelAdorner(roi=self)
-        self.hoverPen = fn.mkPen(color=(255, 0, 0), width=3, style=QtCore.Qt.DashLine)
-        self.handleHoverPen = fn.mkPen("lime", width=4)
-
-    def _normalized_edges(self) -> tuple[float, float, float, float]:
-        """
-        Return rectangle edges as (left, bottom, right, top) with consistent
-        ordering even when the ROI has been inverted by its scale handles.
-
-        Returns:
-            tuple: A tuple containing the left, bottom, right, and top edges
-                of the ROI rectangle in normalized coordinates.
-        """
-        x0, y0 = self.pos().x(), self.pos().y()
-        w, h = self.state["size"]
-        x_left = min(x0, x0 + w)
-        x_right = max(x0, x0 + w)
-        y_bottom = min(y0, y0 + h)
-        y_top = max(y0, y0 + h)
-        return x_left, y_bottom, x_right, y_top
-
-    def add_scale_handle(self):
-        """
-        Add scale handles at every corner and edge of the ROI.
-
-        Corner handles are anchored to the centre for two-axis scaling.
-        Edge handles are anchored to the midpoint of the opposite edge for single-axis scaling.
-        """
-        centre = [0.5, 0.5]
-
-        # Corner handles – anchored to the centre for two-axis scaling
-        self.addScaleHandle([0, 0], centre)  # top‑left
-        self.addScaleHandle([1, 0], centre)  # top‑right
-        self.addScaleHandle([0, 1], centre)  # bottom‑left
-        self.addScaleHandle([1, 1], centre)  # bottom‑right
-
-        # Edge handles – anchored to the midpoint of the opposite edge
-        self.addScaleHandle([0.5, 0], [0.5, 1])  # top edge
-        self.addScaleHandle([0.5, 1], [0.5, 0])  # bottom edge
-        self.addScaleHandle([0, 0.5], [1, 0.5])  # left edge
-        self.addScaleHandle([1, 0.5], [0, 0.5])  # right edge
-
-    def _on_region_changed(self):
-        """
-        Handles changes to the ROI's region.
-
-        This method is called whenever the ROI's position or size changes.
-        It calculates the new corner coordinates and emits the edgesChanged signal
-        with the updated coordinates.
-        """
-        x_left, y_bottom, x_right, y_top = self._normalized_edges()
-        self.edgesChanged.emit(x_left, y_bottom, x_right, y_top)
-        self.parent_plot_item.vb.update()
-
-    def mouseDragEvent(self, ev):
-        """
-        Handles mouse drag events on the ROI.
-
-        This method extends the parent class implementation to emit the edgesReleased
-        signal when the mouse drag is finished, providing the final coordinates of the ROI.
-
-        Args:
-            ev: The mouse event object containing information about the drag operation.
-        """
-        super().mouseDragEvent(ev)
-        if ev.isFinish():
-            x_left, y_bottom, x_right, y_top = self._normalized_edges()
-            self.edgesReleased.emit(x_left, y_bottom, x_right, y_top)
-
-    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.
-        """
-        if typed is None:
-            typed = self.description
-
-        x_left, y_bottom, x_right, y_top = self._normalized_edges()
-
-        if typed:
-            return {
-                "bottom_left": (x_left, y_bottom),
-                "bottom_right": (x_right, y_bottom),
-                "top_left": (x_left, y_top),
-                "top_right": (x_right, y_top),
-            }
-        return (x_left, y_bottom), (x_right, y_bottom), (x_left, y_top), (x_right, y_top)
-
-    def _lookup_scene_image(self):
-        """
-        Searches for an image in the current scene.
-
-        This helper method iterates through all items in the scene and returns
-        the first pg.ImageItem that has a non-None image property.
-
-        Returns:
-            numpy.ndarray or None: The image from the first found ImageItem,
-            or None if no suitable image is found.
-        """
-        for it in self.scene().items():
-            if isinstance(it, pg.ImageItem) and it.image is not None:
-                return it.image
-        return None
-
-
-class CircularROI(BaseROI, pg.CircleROI):
-    """Circular Region of Interest with center/diameter tracking and auto-labeling.
-
-    This class extends the BaseROI and pg.CircleROI classes to provide a circular ROI
-    that emits signals when its center or diameter changes, and includes an auto-aligning
-    label for visual identification.
-
-    Attributes:
-        centerChanged (Signal): Signal emitted when the ROI center or diameter changes,
-            providing the new (center_x, center_y, diameter) values.
-        centerReleased (Signal): Signal emitted when the ROI is released after dragging,
-            providing the final (center_x, center_y, diameter) values.
-    """
-
-    centerChanged = Signal(float, float, float)
-    centerReleased = Signal(float, float, float)
-
-    def __init__(
-        self,
-        *,
-        pos,
-        size,
-        pen=None,
-        config: ConnectionConfig | None = None,
-        gui_id: str | None = None,
-        parent_image: Image | None = None,
-        label: str | None = None,
-        line_color: str | None = None,
-        line_width: int = 5,
-        movable: bool = True,
-        **extra_pg,
-    ):
-        """
-        Initializes a circular ROI with the specified properties.
-
-        Creates a circular ROI at the given position and with the given size,
-        connects signals for tracking changes, and attaches an auto-aligning label.
-
-        Args:
-            pos: Initial position of the ROI as [x, y].
-            size: Initial size of the ROI as [diameter, diameter].
-            pen: Defines the border appearance; can be color or style.
-            config (ConnectionConfig | None, optional): Configuration for BECConnector. Defaults to None.
-            gui_id (str | None, optional): Identifier for the GUI element. Defaults to None.
-            parent_image (BECConnector | None, optional): Parent image object. Defaults to None.
-            label (str | None, optional): Display name for the ROI. Defaults to None.
-            line_color (str | None, optional): Color of the ROI outline. Defaults to None.
-            line_width (int, optional): Width of the ROI outline in pixels. Defaults to 3.
-            parent_plot_item: The plot item this ROI belongs to.
-            **extra_pg: Additional keyword arguments for pg.CircleROI.
-        """
-        super().__init__(
-            config=config,
-            gui_id=gui_id,
-            parent_image=parent_image,
-            label=label,
-            line_color=line_color,
-            line_width=line_width,
-            pos=pos,
-            size=size,
-            pen=pen,
-            movable=movable,
-            **extra_pg,
-        )
-        self.sigRegionChanged.connect(self._on_region_changed)
-        self._adorner = LabelAdorner(self)
-        self.hoverPen = fn.mkPen(color=(255, 0, 0), width=3, style=QtCore.Qt.DashLine)
-        self.handleHoverPen = fn.mkPen("lime", width=4)
-
-    def add_scale_handle(self):
-        """
-        Adds scale handles to the circular ROI.
-        """
-        self._addHandles()  # wrapper around pg.CircleROI._addHandles
-
-    def _on_region_changed(self):
-        """
-        Handles ROI region change events.
-
-        This method is called whenever the ROI's position or size changes.
-        It calculates the center coordinates and diameter of the circle and
-        emits the centerChanged signal with these values.
-        """
-        d = self.state["size"][0]
-        cx = self.pos().x() + d / 2
-        cy = self.pos().y() + d / 2
-        self.centerChanged.emit(cx, cy, d)
-        viewBox = self.parent_plot_item.getViewBox()
-        viewBox.update()
-
-    def mouseDragEvent(self, ev):
-        """
-        Handles mouse drag events on the ROI.
-
-        This method extends the parent class implementation to emit the centerReleased
-        signal when the mouse drag is finished, providing the final center coordinates
-        and diameter of the circular ROI.
-
-        Args:
-            ev: The mouse event object containing information about the drag operation.
-        """
-        super().mouseDragEvent(ev)
-        if ev.isFinish():
-            d = self.state["size"][0]
-            cx = self.pos().x() + d / 2
-            cy = self.pos().y() + d / 2
-            self.centerReleased.emit(cx, cy, d)
-
-    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.
-        """
-        if typed is None:
-            typed = self.description
-
-        d = abs(self.state["size"][0])
-        cx = self.pos().x() + d / 2
-        cy = self.pos().y() + d / 2
-
-        if typed:
-            return {"center_x": cx, "center_y": cy, "diameter": d, "radius": d / 2}
-        return (cx, cy, d, d / 2)
-
-    def _lookup_scene_image(self) -> pg.ImageItem | None:
-        """
-        Retrieves an image from the scene items if available.
-
-        Iterates over all items in the scene and checks if any of them are of type
-        `pg.ImageItem` and have a non-None image. If such an item is found, its image
-        is returned.
-
-        Returns:
-            pg.ImageItem or None: The first found ImageItem with a non-None image,
-            or None if no suitable image is found.
-        """
-        for it in self.scene().items():
-            if isinstance(it, pg.ImageItem) and it.image is not None:
-                return it.image
-        return None
-
-
-class ROIController(QObject):
-    """Manages a collection of ROIs (Regions of Interest) with palette-assigned colors.
-
-    Handles creating, adding, removing, and managing ROI instances. Supports color assignment
-    from a colormap, and provides utility methods to access and manipulate ROIs.
-
-    Attributes:
-        roiAdded (Signal): Emits the new ROI instance when added.
-        roiRemoved (Signal): Emits the removed ROI instance when deleted.
-        cleared (Signal): Emits when all ROIs are removed.
-        paletteChanged (Signal): Emits the new colormap name when updated.
-        _colormap (str): Name of the colormap used for ROI colors.
-        _rois (list[BaseROI]): Internal list storing currently managed ROIs.
-        _colors (list[str]): Internal list of colors for the ROIs.
-    """
-
-    roiAdded = Signal(object)  # emits the new ROI instance
-    roiRemoved = Signal(object)  # emits the removed ROI instance
-    cleared = Signal()  # emits when all ROIs are removed
-    paletteChanged = Signal(str)  # emits new colormap name
-
-    def __init__(self, colormap="viridis"):
-        """
-        Initializes the ROI controller with the specified colormap.
-
-        Sets up internal data structures for managing ROIs and their colors.
-
-        Args:
-            colormap (str, optional): The name of the colormap to use for ROI colors.
-                Defaults to "viridis".
-        """
-        super().__init__()
-        self._colormap = colormap
-        self._rois: list[BaseROI] = []
-        self._colors: list[str] = []
-        self._rebuild_color_buffer()
-
-    def _rebuild_color_buffer(self):
-        """
-        Regenerates the color buffer for ROIs.
-
-        This internal method creates a new list of colors based on the current colormap
-        and the number of ROIs. It ensures there's always one more color than the number
-        of ROIs to allow for adding a new ROI without regenerating the colors.
-        """
-        n = len(self._rois) + 1
-        self._colors = Colors.golden_angle_color(colormap=self._colormap, num=n, format="HEX")
-
-    def add_roi(self, roi: BaseROI):
-        """
-        Registers an externally created ROI with this controller.
-
-        Adds the ROI to the internal list, assigns it a color from the color buffer,
-        ensures it has an appropriate line width, and emits the roiAdded signal.
-
-        Args:
-            roi (BaseROI): The ROI instance to register. Can be any subclass of BaseROI,
-                such as RectangularROI or CircularROI.
-        """
-        self._rois.append(roi)
-        self._rebuild_color_buffer()
-        idx = len(self._rois) - 1
-        if roi.label == "ROI" or roi.label.startswith("ROI "):
-            roi.label = f"ROI {idx}"
-        color = self._colors[idx]
-        roi.line_color = color
-        # ensure line width default is at least 3 if not previously set
-        if getattr(roi, "line_width", 0) < 1:
-            roi.line_width = 5
-        self.roiAdded.emit(roi)
-
-    def remove_roi(self, roi: BaseROI):
-        """
-        Removes an ROI from this controller.
-
-        If the ROI is found in the internal list, it is removed, the color buffer
-        is regenerated, and the roiRemoved signal is emitted.
-
-        Args:
-            roi (BaseROI): The ROI instance to remove.
-        """
-        if roi in self._rois:
-            self.roiRemoved.emit(roi)
-            self._rois.remove(roi)
-            roi.remove()
-            self._rebuild_color_buffer()
-        else:
-            roi.remove()
-
-    def get_roi(self, index: int) -> BaseROI | None:
-        """
-        Returns the ROI at the specified index.
-
-        Args:
-            index (int): The index of the ROI to retrieve.
-
-        Returns:
-            BaseROI or None: The ROI at the specified index, or None if the index
-                is out of range.
-        """
-        if 0 <= index < len(self._rois):
-            return self._rois[index]
-        return None
-
-    def get_roi_by_name(self, name: str) -> BaseROI | None:
-        """
-        Returns the first ROI with the specified name.
-
-        Args:
-            name (str): The name to search for (case-sensitive).
-
-        Returns:
-            BaseROI or None: The first ROI with a matching name, or None if no
-                matching ROI is found.
-        """
-        for r in self._rois:
-            if r.label == name:
-                return r
-        return None
-
-    def remove_roi_by_index(self, index: int):
-        """
-        Removes the ROI at the specified index.
-
-        Args:
-            index (int): The index of the ROI to remove.
-        """
-        roi = self.get_roi(index)
-        if roi is not None:
-            self.remove_roi(roi)
-
-    def remove_roi_by_name(self, name: str):
-        """
-        Removes the first ROI with the specified name.
-
-        Args:
-            name (str): The name of the ROI to remove (case-sensitive).
-        """
-        roi = self.get_roi_by_name(name)
-        if roi is not None:
-            self.remove_roi(roi)
-
-    def clear(self):
-        """
-        Removes all ROIs from this controller.
-
-        Iterates through all ROIs and removes them one by one, then emits
-        the cleared signal to notify listeners that all ROIs have been removed.
-        """
-        for roi in list(self._rois):
-            self.remove_roi(roi)
-        self.cleared.emit()
-
-    def renormalize_colors(self):
-        """
-        Reassigns palette colors to all ROIs in order.
-
-        Regenerates the color buffer based on the current colormap and number of ROIs,
-        then assigns each ROI a color from the buffer in the order they were added.
-        This is useful after changing the colormap or when ROIs need to be visually
-        distinguished from each other.
-        """
-        self._rebuild_color_buffer()
-        for idx, roi in enumerate(self._rois):
-            roi.line_color = self._colors[idx]
-
-    @SafeProperty(str)
-    def colormap(self):
-        """
-        Gets the name of the colormap used for ROI colors.
-
-        Returns:
-            str: The name of the colormap.
-        """
-        return self._colormap
-
-    @colormap.setter
-    def colormap(self, cmap: str):
-        """
-        Sets the colormap used for ROI colors.
-
-        Updates the internal colormap name and reassigns colors to all ROIs
-        based on the new colormap.
-
-        Args:
-            cmap (str): The name of the colormap to use (e.g., "viridis", "plasma").
-        """
-
-        self.set_colormap(cmap)
-
-    def set_colormap(self, cmap: str):
-        Colors.validate_color_map(cmap)
-        self._colormap = cmap
-        self.paletteChanged.emit(cmap)
-        self.renormalize_colors()
-
-    @property
-    def rois(self) -> list[BaseROI]:
-        """
-        Gets a copy of the list of ROIs managed by this controller.
-
-        Returns a new list containing all the ROIs currently managed by this controller.
-        The list is a copy, so modifying it won't affect the controller's internal list.
-
-        Returns:
-            list[BaseROI]: A list of all ROIs currently managed by this controller.
-        """
-        return list(self._rois)
-
-    def cleanup(self):
-        for roi in self._rois:
-            self.remove_roi(roi)

bec_widgets/widgets/plots/scatter_waveform/scatter_curve.py

@@ -78,6 +78,7 @@ class ScatterCurve(BECConnector, pg.PlotDataItem):
             self.config = config
             name = config.label
         self.parent_item = parent_item
+        self.parent_id = self.parent_item.gui_id
         object_name = name.replace("-", "_").replace(" ", "_") if name else None
         super().__init__(name=name, object_name=object_name, config=config, gui_id=gui_id, **kwargs)
 

bec_widgets/widgets/plots/scatter_waveform/scatter_waveform.py

@@ -82,8 +82,6 @@ class ScatterWaveform(PlotBase):
         "y_log.setter",
         "legend_label_size",
         "legend_label_size.setter",
-        "minimal_crosshair_precision",
-        "minimal_crosshair_precision.setter",
         # Scatter Waveform Specific RPC Access
         "main_curve",
         "color_map",

bec_widgets/widgets/plots/setting_menus/axis_settings.py

@@ -60,7 +60,6 @@ class AxisSettings(SettingWidget):
             self.ui.y_grid,
             self.ui.inner_axes,
             self.ui.outer_axes,
-            self.ui.minimal_crosshair_precision,
         ]:
             WidgetIO.connect_widget_change_signal(widget, self.set_property)
 
@@ -122,7 +121,6 @@ class AxisSettings(SettingWidget):
             self.ui.y_max,
             self.ui.y_log,
             self.ui.y_grid,
-            self.ui.minimal_crosshair_precision,
         ]:
             property_name = widget.objectName()
             value = getattr(self.target_widget, property_name)
@@ -146,7 +144,6 @@ class AxisSettings(SettingWidget):
             self.ui.y_grid,
             self.ui.outer_axes,
             self.ui.inner_axes,
-            self.ui.minimal_crosshair_precision,
         ]:
             property_name = widget.objectName()
             value = WidgetIO.get_value(widget)