2.16.2

Automatically generated by python-semantic-release

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,26 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-## 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.]

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,41 @@
+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/ISSUE_TEMPLATE/documentation_update.md

@@ -1,3 +1,13 @@
+---
+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]

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,8 +1,9 @@
 ---
 name: Feature request
 about: Suggest an idea for this project
-title: ''
-labels: ''
+title: '[FEAT]: '
+type: feature
+label: feature
 assignees: ''
 
 ---

.github/actions/bw_install/action.yml

@@ -0,0 +1,64 @@
+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/pull_request_template.md

@@ -1,19 +1,24 @@
 ## Description
 
-[Provide a brief description of the changes introduced by this merge request.]
+[Provide a brief description of the changes introduced by this pull request.]
 
 ## Related Issues
 
-[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`.]
+[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`.]
 
 ## 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 MR.]
+[Describe any potential side effects or risks of merging this PR.]
 
 ## Screenshots / GIFs (if applicable)
 

.github/scripts/pr_issue_sync/pr_issue_sync.py

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

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

.github/workflows/check_pr.yml

@@ -14,7 +14,7 @@ jobs:
     steps:
       - uses: actions/github-script@v7
         id: script
-        if: github.event_name == 'push'
+        if: github.event_name == 'push' && github.event.ref_type != 'tag'
         with:
           script: |
             const prs = await github.rest.pulls.list({

.github/workflows/ci.yml

@@ -1,5 +1,21 @@
 name: Full CI
-on: [push, pull_request]
+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
@@ -17,6 +33,10 @@ jobs:
     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 }}
 
@@ -24,6 +44,10 @@ jobs:
     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]

.github/workflows/end2end-conda.yml

@@ -12,6 +12,7 @@ jobs:
       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"
@@ -39,10 +40,19 @@ jobs:
           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
-          pip install -e .[dev,pyside6]
-          pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end
+          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

@@ -14,10 +14,15 @@ jobs:
 
       - name: Run black and isort
         run: |
-          pip install black isort
-          pip install -e .[dev]
+          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
 

.github/workflows/pytest-matrix.yml

@@ -1,5 +1,26 @@
 name: Run Pytest with different Python versions
-on: [workflow_call]
+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:
@@ -9,7 +30,7 @@ jobs:
         python-version: ["3.10", "3.11", "3.12"]
 
     env:
-      CHILD_PIPELINE_BRANCH: main  # Set the branch you want for ophyd_devices
+      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 }}
@@ -17,30 +38,20 @@ jobs:
       QT_QPA_PLATFORM: "offscreen"
 
     steps:
-      - uses: actions/checkout@v4
 
-      - name: Set up Python
-        uses: actions/setup-python@v5
+      - name: Checkout BEC Widgets
+        uses: actions/checkout@v4
         with:
-          python-version: ${{ matrix.python-version }}
+          repository: bec-project/bec_widgets
+          ref: ${{ inputs.BEC_WIDGETS_BRANCH }}
 
-      - 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: 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: 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: |

.github/workflows/pytest.yml

@@ -6,6 +6,21 @@ on:
         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
@@ -20,38 +35,23 @@ jobs:
     runs-on: ubuntu-latest
 
     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
+      - name: Checkout BEC Widgets
+        uses: actions/checkout@v4
         with:
-          python-version: '3.11'
+          repository: bec-project/bec_widgets
+          ref: ${{ inputs.BEC_WIDGETS_BRANCH }}
 
-      - 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: 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: 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

.github/workflows/semantic_release.yml

@@ -26,6 +26,9 @@ jobs:
       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
@@ -38,6 +41,13 @@ jobs:
         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: |
@@ -81,60 +91,13 @@ jobs:
 
           printf '%s\n' "Verified upstream branch has not changed, continuing with release..."
 
-      - name: Setup | Install Dependencies
-        run: |
-          pip install build wheel
-
-      - name: Action | Semantic Version Release
+      - name: Semantic Version Release
         id: release
-        # Adjust tag with desired version if applicable.
-        uses: python-semantic-release/python-semantic-release@v9.21.1
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          git_committer_name: "github-actions"
-          git_committer_email: "actions@users.noreply.github.com"
-      - name: Publish | Upload to GitHub Release Assets
-        uses: python-semantic-release/publish-action@v9.21.1
-        if: steps.release.outputs.released == 'true'
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          tag: ${{ steps.release.outputs.tag }}
-
-      - name: Upload | Distribution Artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: distribution-artifacts
-          path: dist
-          if-no-files-found: error
-
-  pypi-publish:
-    # 1. Separate out the deploy step from the publish step to run each step at
-    #    the least amount of token privilege
-    # 2. Also, deployments can fail, and its better to have a separate job if you need to retry
-    #    and it won't require reversing the release.
-    runs-on: ubuntu-latest
-    needs: release
-    if: ${{ needs.release.outputs.released == 'true' }}
-
-    environment:
-      name: pypi
-      url: https://pypi.org/p/bec-widgets
-    permissions:
-      contents: read
-      id-token: write
-
-    steps:
-      - name: Setup | Download Build Artifacts
-        uses: actions/download-artifact@v4
-        id: artifact-download
-        with:
-          name: distribution-artifacts
-          path: dist
-
-      # see https://docs.pypi.org/trusted-publishers/
-      - name: Publish package distributions to PyPI
-        uses: pypa/gh-action-pypi-publish@v1.12.4
-        with:
-          packages-dir: dist
-          print-hash: true
-          verbose: true
+        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

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

@@ -0,0 +1,40 @@
+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,6 +64,9 @@ coverage.xml
 .pytest_cache/
 cover/
 
+# Output from end2end testing
+tests/reference_failures/
+
 # Translations
 *.mo
 *.pot

.gitlab/issue_templates/bug_report_template.md

@@ -1,17 +0,0 @@
-## 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/feature_request_template.md

@@ -1,40 +0,0 @@
-## Feature Summary
-
-[Provide a brief and clear summary of the new feature you are requesting]
-
-## Problem Description
-
-[Explain the problem or need that this feature aims to address. Be specific about the issues or gaps in the current functionality]
-
-## Use Case
-
-[Describe a real-world scenario or use case where this feature would be beneficial. Explain how it would improve the user experience or workflow]
-
-## Proposed Solution
-
-[If you have a specific solution in mind, describe it here. Explain how it would work and how it would address the problem described above]
-
-## Benefits
-
-[Explain the benefits and advantages of implementing this feature. Highlight how it adds value to the product or improves user satisfaction]
-
-## Alternatives Considered
-
-[If you've considered alternative solutions or workarounds, mention them here. Explain why the proposed feature is the preferred option]
-
-## Impact on Existing Functionality
-
-[Discuss how the new feature might impact or interact with existing features. Address any potential conflicts or dependencies]
-
-## Priority
-
-[Assign a priority level to the feature request based on its importance. Use a scale such as Low, Medium, High]
-
-## Attachments
-
-[Include any relevant attachments, such as sketches, diagrams, or references that can help the development team understand your feature request better]
-
-## 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]
-

.readthedocs.yaml

@@ -7,13 +7,13 @@ version: 2
 
 # Set the version of Python and other tools you might need
 build:
-  os: ubuntu-20.04
+  os: ubuntu-22.04
   tools:
-    python: "3.10"
+    python: "3.11"
 
 # 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,5 +21,7 @@ sphinx:
 
 # Optionally declare the Python requirements required to build your docs
 python:
-   install:
-   - requirements: docs/requirements.txt
+  install:
+    - requirements: docs/requirements.txt
+    - method: pip
+      path: .[dev]

bec_widgets/applications/launch_window.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Callable
 
 from bec_lib.logger import bec_logger
 from qtpy.QtCore import Qt, Signal  # type: ignore
-from qtpy.QtGui import QPainter, QPainterPath, QPixmap
+from qtpy.QtGui import QFontMetrics, QPainter, QPainterPath, QPixmap
 from qtpy.QtWidgets import (
     QApplication,
     QComboBox,
@@ -44,6 +44,7 @@ MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
 
 class LaunchTile(RoundedFrame):
+    DEFAULT_SIZE = (250, 300)
     open_signal = Signal()
 
     def __init__(
@@ -54,9 +55,15 @@ 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)
@@ -87,12 +94,26 @@ 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)
@@ -133,6 +154,29 @@ 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
@@ -146,6 +190,8 @@ class LaunchWindow(BECMainWindow):
 
         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)
@@ -196,7 +242,7 @@ class LaunchWindow(BECMainWindow):
         )
 
         # plugin widgets
-        self.available_widgets: dict[str, BECWidget] = get_all_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()
@@ -250,14 +296,34 @@ class LaunchWindow(BECMainWindow):
             main_label=main_label,
             description=description,
             show_selector=show_selector,
+            tile_size=self.TILE_SIZE,
         )
-        tile.setFixedSize(*self.TILE_SIZE)
+        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
 
     def launch(

bec_widgets/cli/client.py

@@ -51,6 +51,9 @@ _Widgets = {
     "RingProgressBar": "RingProgressBar",
     "ScanControl": "ScanControl",
     "ScatterWaveform": "ScatterWaveform",
+    "SignalComboBox": "SignalComboBox",
+    "SignalLabel": "SignalLabel",
+    "SignalLineEdit": "SignalLineEdit",
     "StopButton": "StopButton",
     "TextBox": "TextBox",
     "VSCodeEditor": "VSCodeEditor",
@@ -61,7 +64,7 @@ _Widgets = {
 
 
 try:
-    _plugin_widgets = get_all_plugin_widgets()
+    _plugin_widgets = get_all_plugin_widgets().as_dict()
     plugin_client = get_plugin_client_module()
     Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
 
@@ -504,6 +507,264 @@ 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):
@@ -721,9 +982,22 @@ class DeviceComboBox(RPCBase):
     """Combobox widget for device input with autocomplete for device names."""
 
     @rpc_call
-    def remove(self):
+    def set_device(self, device: "str"):
         """
-        Cleanup the BECConnector
+        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.
         """
 
 
@@ -741,9 +1015,154 @@ class DeviceLineEdit(RPCBase):
     """Line edit widget for device input with autocomplete for device names."""
 
     @rpc_call
-    def remove(self):
+    def set_device(self, device: "str"):
         """
-        Cleanup the BECConnector
+        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.
+        """
+
+
+class EllipticalROI(RPCBase):
+    """Elliptical Region of Interest with centre/width/height tracking and auto-labelling."""
+
+    @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":
+        """
+        Return the ellipse's centre and size.
+
+        Args:
+            typed (bool | None): If True returns dict; otherwise tuple.
+        """
+
+    @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.
         """
 
 
@@ -965,6 +1384,20 @@ class Image(RPCBase):
         Set auto range for the y-axis.
         """
 
+    @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 color_map(self) -> "str":
@@ -981,16 +1414,16 @@ class Image(RPCBase):
 
     @property
     @rpc_call
-    def vrange(self) -> "tuple":
+    def v_range(self) -> "QPointF":
         """
-        Get the vrange of the image.
+        Set the v_range of the main image.
         """
 
-    @vrange.setter
+    @v_range.setter
     @rpc_call
-    def vrange(self) -> "tuple":
+    def v_range(self) -> "QPointF":
         """
-        Get the vrange of the image.
+        Set the v_range of the main image.
         """
 
     @property
@@ -1188,12 +1621,12 @@ class Image(RPCBase):
     @rpc_call
     def image(
         self,
-        monitor: "str | None" = None,
+        monitor: "str | tuple | 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":
+    ) -> "ImageItem | None":
         """
         Set the image source and update the image.
 
@@ -1215,6 +1648,46 @@ class Image(RPCBase):
         Access the main image item.
         """
 
+    @rpc_call
+    def add_roi(
+        self,
+        kind: "Literal['rect', 'circle', 'ellipse']" = "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
@@ -2056,6 +2529,20 @@ 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):
@@ -2318,6 +2805,135 @@ 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."""
 
@@ -2912,6 +3528,20 @@ 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":
@@ -2982,6 +3612,152 @@ 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."""
 
@@ -3312,6 +4088,20 @@ 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]":
@@ -3364,6 +4154,48 @@ 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,

bec_widgets/cli/generate_cli.py

@@ -111,7 +111,7 @@ _Widgets = {
             self.content += """
 
 try:
-    _plugin_widgets = get_all_plugin_widgets()
+    _plugin_widgets = get_all_plugin_widgets().as_dict()
     plugin_client = get_plugin_client_module()
     Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
 

bec_widgets/cli/rpc/rpc_widget_handler.py

@@ -31,10 +31,9 @@ class RPCWidgetHandler:
         Returns:
             None
         """
-        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
-        }
+        self._widget_classes = (
+            get_custom_classes("bec_widgets") + get_all_plugin_widgets()
+        ).as_dict(IGNORE_WIDGETS)
 
     def create_widget(self, widget_type, **kwargs) -> BECWidget:
         """

bec_widgets/cli/server.py

@@ -6,7 +6,6 @@ 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
@@ -38,6 +37,10 @@ class SimpleFileLikeFromLogOutputFunc:
             self._log_func(lines)
         self._buffer = [remaining]
 
+    @property
+    def encoding(self):
+        return "utf-8"
+
     def close(self):
         return
 

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -43,7 +43,7 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     "pg": pg,
                     "wh": wh,
                     "dock": self.dock,
-                    # "im": self.im,
+                    "im": self.im,
                     # "mi": self.mi,
                     # "mm": self.mm,
                     # "lm": self.lm,
@@ -112,13 +112,13 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         # tab_widget.addTab(fifth_tab, "Waveform Next Gen")
         # tab_widget.setCurrentIndex(4)
         #
-        # sixth_tab = QWidget()
-        # sixth_tab_layout = QVBoxLayout(sixth_tab)
-        # 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(5)
+        sixth_tab = QWidget()
+        sixth_tab_layout = QVBoxLayout(sixth_tab)
+        self.im = Image(popups=True)
+        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)

bec_widgets/tests/utils.py

@@ -19,7 +19,7 @@ class FakeDevice(BECDevice):
             "readoutPriority": "baseline",
             "deviceClass": "ophyd.Device",
             "deviceConfig": {},
-            "deviceTags": ["user device"],
+            "deviceTags": {"user device"},
             "enabled": enabled,
             "readOnly": False,
             "name": self.name,
@@ -89,7 +89,7 @@ class FakePositioner(BECPositioner):
             "readoutPriority": "baseline",
             "deviceClass": "ophyd_devices.SimPositioner",
             "deviceConfig": {"delay": 1, "tolerance": 0.01, "update_frequency": 400},
-            "deviceTags": ["user motors"],
+            "deviceTags": {"user motors"},
             "enabled": enabled,
             "readOnly": False,
             "name": self.name,
@@ -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):
-        super().__init__(name, limits, read_value)
+    def __init__(self, name="test", limits=None, read_value=1.0, enabled=True):
+        super().__init__(name, limits=limits, read_value=read_value, enabled=enabled)
 
 
 class Device(FakeDevice):
@@ -200,10 +200,49 @@ class DMMock:
         self.devices = DeviceContainer()
         self.enabled_devices = [device for device in self.devices if device.enabled]
 
-    def add_devives(self, devices: list):
+    def add_devices(self, devices: list):
+        """
+        Add devices to the DeviceContainer.
+
+        Args:
+            devices (list): List of device instances to add.
+        """
         for device in devices:
             self.devices[device.name] = device
 
+    def get_bec_signals(self, signal_class_name: str):
+        """
+        Emulate DeviceManager.get_bec_signals for unit-tests.
+
+        For “AsyncSignal” we list every device whose readout_priority is
+        ReadoutPriority.ASYNC and build a minimal tuple
+        (device_name, signal_name, signal_info_dict) that matches the real
+        API shape used by Waveform._check_async_signal_found.
+        """
+        signals: list[tuple[str, str, dict]] = []
+        if signal_class_name != "AsyncSignal":
+            return signals
+
+        for device in self.devices.values():
+            if getattr(device, "readout_priority", None) == ReadoutPriority.ASYNC:
+                device_name = device.name
+                signal_name = device.name  # primary signal in our mocks
+                signal_info = {
+                    "component_name": signal_name,
+                    "obj_name": signal_name,
+                    "kind_str": "hinted",
+                    "signal_class": signal_class_name,
+                    "metadata": {
+                        "connected": True,
+                        "precision": None,
+                        "read_access": True,
+                        "timestamp": 0.0,
+                        "write_access": True,
+                    },
+                }
+                signals.append((device_name, signal_name, signal_info))
+        return signals
+
 
 DEVICES = [
     FakePositioner("samx", limits=[-10, 10], read_value=2.0),

bec_widgets/utils/bec_dispatcher.py

@@ -163,7 +163,7 @@ class BECDispatcher:
     def connect_slot(
         self,
         slot: Callable,
-        topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]],
+        topics: EndpointInfo | str | list[EndpointInfo] | list[str],
         cb_info: dict | None = None,
         **kwargs,
     ) -> None:
@@ -172,7 +172,7 @@ 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): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
+            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.
         """
         qt_slot = QtThreadSafeCallback(cb=slot, cb_info=cb_info)
@@ -183,13 +183,15 @@ class BECDispatcher:
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
         qt_slot.topics.update(set(topics_str))
 
-    def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
+    def disconnect_slot(
+        self, slot: Callable, topics: EndpointInfo | str | list[EndpointInfo] | list[str]
+    ):
         """
         Disconnect a slot from a topic.
 
         Args:
             slot(Callable): The slot to disconnect
-            topics(Union[str, list]): The topic(s) to disconnect from
+            topics EndpointInfo | str | list[EndpointInfo] | list[str]: A topic or list of topics to unsub from.
         """
         # find the right slot to disconnect from ;
         # slot callbacks are wrapped in QtThreadSafeCallback objects,

bec_widgets/utils/bec_plugin_helper.py

@@ -3,12 +3,17 @@ 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_widgets.utils.bec_widget import BECWidget
+from bec_lib.logger import bec_logger
+
+from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
+
+logger = bec_logger.logger
 
 
 def _submodule_specs(module: ModuleType) -> tuple[ModuleSpec | None, ...]:
@@ -30,7 +35,12 @@ def _loaded_submodules_from_specs(
         assert isinstance(
             submodule.__loader__, SourceFileLoader
         ), "Module found from FileFinder should have SourceFileLoader!"
-        submodule.__loader__.exec_module(submodule)
+        try:
+            submodule.__loader__.exec_module(submodule)
+        except Exception as e:
+            logger.error(
+                f"Error loading plugin {submodule}: \n{''.join(traceback.format_exception(e))}"
+            )
         yield submodule
 
 
@@ -41,27 +51,29 @@ def _submodule_by_name(module: ModuleType, name: str):
     return None
 
 
-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."""
+def _get_widgets_from_module(module: ModuleType) -> BECClassContainer:
+    """Find any BECWidget subclasses in the given module and return them with their info."""
     from bec_widgets.utils.bec_widget import BECWidget  # avoid circular import
 
-    return dict(
-        inspect.getmembers(
-            module,
-            predicate=lambda item: inspect.isclass(item)
-            and issubclass(item, BECWidget)
-            and item is not BECWidget,
-        )
+    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
     )
 
 
-def _all_widgets_from_all_submods(module):
+def _all_widgets_from_all_submods(module) -> BECClassContainer:
     """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.update(_all_widgets_from_all_submods(submod))
+        widgets += _all_widgets_from_all_submods(submod)
     return widgets
 
 
@@ -75,15 +87,16 @@ 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() -> dict[str, "type[BECWidget]"]:
+def get_all_plugin_widgets() -> BECClassContainer:
     """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 {}
+        return BECClassContainer()
 
 
 if __name__ == "__main__":  # pragma: no cover
-    #  print(get_all_plugin_widgets())
+
     client = get_plugin_client_module()
+    print(get_all_plugin_widgets())
     ...

bec_widgets/utils/clickable_label.py

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

bec_widgets/utils/crosshair.py

@@ -34,13 +34,21 @@ class Crosshair(QObject):
     coordinatesChanged2D = Signal(tuple)
     coordinatesClicked2D = Signal(tuple)
 
-    def __init__(self, plot_item: pg.PlotItem, precision: int = 3, parent=None):
+    def __init__(
+        self,
+        plot_item: pg.PlotItem,
+        precision: int | None = None,
+        *,
+        min_precision: int = 2,
+        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, optional): Number of decimal places to round the coordinates to. Defaults to None.
+            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.
             parent (QObject, optional): Parent object for the QObject. Defaults to None.
         """
         super().__init__(parent)
@@ -48,7 +56,9 @@ class Crosshair(QObject):
         self.is_log_x = None
         self.is_derivative = None
         self.plot_item = plot_item
-        self.precision = precision
+        self._precision = precision
+        self._min_precision = max(0, int(min_precision))  # ensure non‑negative
+
         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)
@@ -85,13 +95,64 @@ class Crosshair(QObject):
         self.items = []
         self.marker_moved_1d = {}
         self.marker_clicked_1d = {}
-        self.marker_2d = None
+        self.marker_2d_row = None
+        self.marker_2d_col = 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()
@@ -195,13 +256,23 @@ 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 is not None:
+                if self.marker_2d_row is not None and self.marker_2d_col is not None:
                     continue
-                self.marker_2d = pg.ROI(
-                    [0, 0], size=[1, 1], pen=pg.mkPen("r", width=2), movable=False
+                # 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.skip_auto_range = True
-                self.plot_item.addItem(self.marker_2d)
+                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)
 
     def snap_to_data(
         self, x: float, y: float
@@ -241,8 +312,10 @@ class Crosshair(QObject):
                     y_values[name] = closest_y
                     x_values[name] = closest_x
             elif isinstance(item, pg.ImageItem):  # 2D plot
-                name = item.config.monitor or str(id(item))
+                name = item.objectName() 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))
@@ -311,6 +384,7 @@ 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))
@@ -321,16 +395,19 @@ class Crosshair(QObject):
                     x_snapped_scaled, y_snapped_scaled = self.scale_emitted_coordinates(x, y)
                     coordinate_to_emit = (
                         name,
-                        round(x_snapped_scaled, self.precision),
-                        round(y_snapped_scaled, self.precision),
+                        round(x_snapped_scaled, precision),
+                        round(y_snapped_scaled, precision),
                     )
                     self.coordinatesChanged1D.emit(coordinate_to_emit)
                 elif isinstance(item, pg.ImageItem):
-                    name = item.config.monitor or str(id(item))
+                    name = item.objectName() or str(id(item))
                     x, y = x_snap_values[name], y_snap_values[name]
                     if x is None or y is None:
                         continue
-                    self.marker_2d.setPos([x, y])
+                    # 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])
                     coordinate_to_emit = (name, x, y)
                     self.coordinatesChanged2D.emit(coordinate_to_emit)
                 else:
@@ -364,6 +441,7 @@ 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))
@@ -375,16 +453,19 @@ class Crosshair(QObject):
                     x_snapped_scaled, y_snapped_scaled = self.scale_emitted_coordinates(x, y)
                     coordinate_to_emit = (
                         name,
-                        round(x_snapped_scaled, self.precision),
-                        round(y_snapped_scaled, self.precision),
+                        round(x_snapped_scaled, precision),
+                        round(y_snapped_scaled, precision),
                     )
                     self.coordinatesClicked1D.emit(coordinate_to_emit)
                 elif isinstance(item, pg.ImageItem):
-                    name = item.config.monitor or str(id(item))
+                    name = item.objectName() or str(id(item))
                     x, y = x_snap_values[name], y_snap_values[name]
                     if x is None or y is None:
                         continue
-                    self.marker_2d.setPos([x, y])
+                    # 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])
                     coordinate_to_emit = (name, x, y)
                     self.coordinatesClicked2D.emit(coordinate_to_emit)
                 else:
@@ -424,14 +505,17 @@ class Crosshair(QObject):
         """
         x, y = pos
         x_scaled, y_scaled = self.scale_emitted_coordinates(x, y)
-        text = f"({x_scaled:.{self.precision}g}, {y_scaled:.{self.precision}g})"
+        precision = self._current_precision()
+        text = f"({x_scaled:.{precision}f}, {y_scaled:.{precision}f})"
         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:.{self.precision}g}"
+                text += f"\nIntensity: {intensity:.{precision}f}"
                 break
         # Update coordinate label
         self.coord_label.setText(text)
@@ -450,9 +534,12 @@ class Crosshair(QObject):
         self.clear_markers()
 
     def cleanup(self):
-        if self.marker_2d is not None:
-            self.plot_item.removeItem(self.marker_2d)
-            self.marker_2d = None
+        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
         self.plot_item.removeItem(self.v_line)
         self.plot_item.removeItem(self.h_line)
         self.plot_item.removeItem(self.coord_label)

bec_widgets/utils/expandable_frame.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 from bec_qthemes import material_icon
+from qtpy.QtCore import Signal
 from qtpy.QtWidgets import (
+    QApplication,
     QFrame,
     QHBoxLayout,
     QLabel,
@@ -12,15 +14,20 @@ 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, title: str, parent: QWidget | None = None, expanded: bool = True) -> None:
+    def __init__(
+        self, parent: QWidget | None = None, title: str = "", expanded: bool = True, icon: str = ""
+    ) -> None:
         super().__init__(parent=parent)
         self._expanded = expanded
 
@@ -29,19 +36,33 @@ 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._expansion_button = QToolButton()
-        self._update_icon()
-        self._title = QLabel(f"<b>{title}</b>")
-        self._title_layout.addWidget(self._expansion_button)
-        self._title_layout.addWidget(self._title)
+
+        self._create_title_layout(title, icon)
 
         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 _create_title_layout(self, title: str, icon: str):
+        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.clicked.connect(self.switch_expanded_state)
+        self._title_icon.clicked.connect(self.switch_expanded_state)
+
+        self._title_layout.addStretch(1)
+
+        self._expansion_button = QToolButton()
+        self._update_expansion_icon()
+        self._title_layout.addWidget(self._expansion_button, stretch=1)
 
     def set_layout(self, layout: QLayout) -> None:
         self._contents.setLayout(layout)
@@ -50,7 +71,8 @@ class ExpandableGroupFrame(QFrame):
     @SafeSlot()
     def switch_expanded_state(self):
         self.expanded = not self.expanded  # type: ignore
-        self._update_icon()
+        self._update_expansion_icon()
+        self.expansion_state_changed.emit()
 
     @SafeProperty(bool)
     def expanded(self):  # type: ignore
@@ -61,8 +83,9 @@ class ExpandableGroupFrame(QFrame):
         self._expanded = expanded
         self._contents.setVisible(expanded)
         self.updateGeometry()
+        self.adjustSize()
 
-    def _update_icon(self):
+    def _update_expansion_icon(self):
         self._expansion_button.setIcon(
             material_icon(icon_name=self.EXPANDED_ICON_NAME, size=(10, 10), convert_to_pixmap=False)
             if self.expanded
@@ -70,3 +93,36 @@ 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,76 +1,107 @@
 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, QVBoxLayout, QWidget
+from qtpy.QtWidgets import QApplication, QGridLayout, QLabel, QSizePolicy, QVBoxLayout, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.compact_popup import CompactPopupWidget
-from bec_widgets.utils.forms_from_types.items import FormItemSpec, widget_from_type
+from bec_widgets.utils.error_popups import SafeProperty
+from bec_widgets.utils.forms_from_types import styles
+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 = False
+    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.
-
+            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) or (
-            items is None and form_item_specs is None
-        ):
-            raise ValueError("Must specify one and only one of items and form_item_specs")
+        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)
-                for name, item_type in items  # type: ignore
-            ]
-        )
+        self._items = form_item_specs or [
+            FormItemSpec(name=name, item_type=item_type, pretty_display=pretty_display)
+            for name, item_type in items  # type: ignore
+        ]
+        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
         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.Minimum)
         self._form_grid = QWidget(parent=self._form_grid_container)
+        self._form_grid.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
         self._layout.addWidget(self._form_grid_container)
         self._form_grid_container.setLayout(QVBoxLayout())
         self._form_grid.setLayout(self._new_grid_layout())
 
+        self._widget_types: dict | None = None
+        self._widget_from_type = widget_from_type
+        self._post_init()
+
+    def _post_init(self):
+        """Override this if a subclass should do things after super().__init__ and before populate()"""
         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)
+        gl: QGridLayout = self._form_grid.layout()
+        gl.setRowStretch(gl.rowCount(), 1)
 
     def _add_griditem(self, item: FormItemSpec, row: int):
         grid = self._form_grid.layout()
@@ -78,19 +109,22 @@ class TypedForm(BECWidget, QWidget):
         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 = self._widget_from_type(item, self._widget_types)(parent=self, spec=item)
         widget.valueChanged.connect(self.value_changed)
+        widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
         grid.addWidget(widget, row, 1)
 
-    def _dict_from_grid(self) -> dict[str, str | int | float | Decimal | bool]:
+    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 "_model_field_name"), and the entry widget"""
         grid: QGridLayout = self._form_grid.layout()  # type: ignore
+        for i in range(grid.rowCount() - 1):  # One extra row for stretch
+            yield GridRow(i, grid.itemAtPosition(i, 0).widget(), grid.itemAtPosition(i, 1).widget())
+
+    def _dict_from_grid(self) -> dict[str, DynamicFormItemType]:
         return {
-            grid.itemAtPosition(i, 0)
-            .widget()
-            .property("_model_field_name"): grid.itemAtPosition(i, 1)
-            .widget()
-            .getValue()  # type: ignore # we only add 'DynamicFormItem's here
-            for i in range(grid.rowCount())
+            row.label.property("_model_field_name"): row.widget.getValue()
+            for row in self.enumerate_form_widgets()
         }
 
     def _clear_grid(self):
@@ -103,10 +137,13 @@ class TypedForm(BECWidget, QWidget):
             old_layout.deleteLater()
             self._form_grid.deleteLater()
         self._form_grid = QWidget()
-
+        self._form_grid.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
         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()
@@ -114,23 +151,56 @@ class TypedForm(BECWidget, QWidget):
     def _new_grid_layout(self):
         new_grid = QGridLayout()
         new_grid.setContentsMargins(0, 0, 0, 0)
-        new_grid.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
         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, metadata_model: type[BaseModel] = None, client=None, **kwargs):
+    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:
-            metadata_model (type[BaseModel]): the model class for which to generate a form.
+            data_model (type[BaseModel]): the model class for which to generate a form.
+            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.
+
         """
-        self._md_schema = metadata_model
-        super().__init__(parent=parent, form_item_specs=self._form_item_specs(), client=client)
+        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,
+            **kwargs,
+        )
 
         self._validity = CompactPopupWidget()
         self._validity.compact_view = True  # type: ignore
@@ -143,13 +213,40 @@ class PydanticModelForm(TypedForm):
         self._layout.addWidget(self._validity)
         self.value_changed.connect(self.validate_form)
 
+        self._connect_to_theme_change()
+
+    def set_pretty_display_theme(self, theme: str = "dark"):
+        if self._pretty_display:
+            self.setStyleSheet(styles.pretty_display_theme(theme))
+
+    def _connect_to_theme_change(self):
+        """Connect to the theme change signal."""
+        qapp = QApplication.instance()
+        if hasattr(qapp, "theme_signal"):
+            qapp.theme_signal.theme_updated.connect(self.set_pretty_display_theme)  # type: ignore
+
     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)
+            FormItemSpec(
+                name=name, info=info, item_type=info.annotation, pretty_display=self._pretty_display
+            )
             for name, info in self._md_schema.model_fields.items()
         ]
 

bec_widgets/utils/forms_from_types/items.py

@@ -1,31 +1,44 @@
 from __future__ import annotations
 
+import typing
 from abc import abstractmethod
 from decimal import Decimal
-from types import UnionType
-from typing import Callable, Protocol
+from types import GenericAlias, UnionType
+from typing import Callable, Final, Iterable, Literal, NamedTuple, OrderedDict, get_args
 
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 from pydantic.fields import FieldInfo
-from qtpy.QtCore import Signal  # type: ignore
+from pydantic_core import PydanticUndefined
+from qtpy import QtCore
+from qtpy.QtCore import QSize, Qt, Signal  # type: ignore
+from qtpy.QtGui import QFontMetrics
 from qtpy.QtWidgets import (
     QApplication,
     QButtonGroup,
     QCheckBox,
+    QComboBox,
     QDoubleSpinBox,
     QGridLayout,
     QHBoxLayout,
     QLabel,
     QLayout,
     QLineEdit,
+    QListWidget,
+    QListWidgetItem,
+    QPushButton,
     QRadioButton,
+    QSizePolicy,
     QSpinBox,
     QToolButton,
+    QVBoxLayout,
     QWidget,
 )
 
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.widget_io import WidgetIO
+from bec_widgets.widgets.editors.dict_backed_table import DictBackedTable
 from bec_widgets.widgets.editors.scan_metadata._util import (
     clearable_required,
     field_default,
@@ -34,6 +47,7 @@ from bec_widgets.widgets.editors.scan_metadata._util import (
     field_minlen,
     field_precision,
 )
+from bec_widgets.widgets.utility.toggle.toggle import ToggleSwitch
 
 logger = bec_logger.logger
 
@@ -46,9 +60,36 @@ class FormItemSpec(BaseModel):
     """
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
-    item_type: type | UnionType
+
+    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):
@@ -94,10 +135,20 @@ class ClearableBoolEntry(QWidget):
         self._false.setToolTip(tooltip)
 
 
+DynamicFormItemType = str | int | float | Decimal | bool | dict | list | None
+
+
 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.
+        """
         super().__init__(parent)
         self._spec = spec
         self._layout = QHBoxLayout()
@@ -107,11 +158,17 @@ class DynamicFormItem(QWidget):
         self._desc = self._spec.info.description
         self.setLayout(self._layout)
         self._add_main_widget()
-        if clearable_required(spec.info):
-            self._add_clear_button()
+        assert isinstance(self._main_widget, QWidget), "Please set a widget in _add_main_widget()"  # type: ignore
+        self._main_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
+        self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
+        if not spec.pretty_display:
+            if clearable_required(spec.info):
+                self._add_clear_button()
+        else:
+            self._set_pretty_display()
 
     @abstractmethod
-    def getValue(self): ...
+    def getValue(self) -> DynamicFormItemType: ...
 
     @abstractmethod
     def setValue(self, value): ...
@@ -121,6 +178,11 @@ 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)
+        if button := getattr(self, "_clear_button", None):
+            button.setVisible(False)
+
     def _describe(self, pad=" "):
         return pad + (self._desc if self._desc else "")
 
@@ -138,7 +200,7 @@ class DynamicFormItem(QWidget):
         self.valueChanged.emit()
 
 
-class StrMetadataField(DynamicFormItem):
+class StrFormItem(DynamicFormItem):
     def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
         super().__init__(parent=parent, spec=spec)
         self._main_widget.textChanged.connect(self._value_changed)
@@ -163,11 +225,11 @@ class StrMetadataField(DynamicFormItem):
 
     def setValue(self, value: str):
         if value is None:
-            self._main_widget.setText("")
-        self._main_widget.setText(value)
+            return self._main_widget.setText("")
+        self._main_widget.setText(str(value))
 
 
-class IntMetadataField(DynamicFormItem):
+class IntFormItem(DynamicFormItem):
     def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
         super().__init__(parent=parent, spec=spec)
         self._main_widget.textChanged.connect(self._value_changed)
@@ -196,18 +258,18 @@ class IntMetadataField(DynamicFormItem):
         self._main_widget.setValue(value)
 
 
-class FloatDecimalMetadataField(DynamicFormItem):
+class FloatDecimalFormItem(DynamicFormItem):
     def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
         super().__init__(parent=parent, spec=spec)
         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, int)
+        min_, max_ = field_limits(self._spec.info, float, precision)
         self._main_widget.setMinimum(min_)
         self._main_widget.setMaximum(max_)
-        precision = field_precision(self._spec.info)
         if precision:
             self._main_widget.setDecimals(precision)
         minstr = f"{float(min_):.3f}" if abs(min_) <= 1000 else f"{float(min_):.3e}"
@@ -224,13 +286,13 @@ class FloatDecimalMetadataField(DynamicFormItem):
             return self._default
         return self._main_widget.value()
 
-    def setValue(self, value: float):
+    def setValue(self, value: float | Decimal):
         if value is None:
             self._main_widget.clear()
-        self._main_widget.setValue(value)
+        self._main_widget.setValue(float(value))
 
 
-class BoolMetadataField(DynamicFormItem):
+class BoolFormItem(DynamicFormItem):
     def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
         super().__init__(parent=parent, spec=spec)
         self._main_widget.stateChanged.connect(self._value_changed)
@@ -251,36 +313,300 @@ class BoolMetadataField(DynamicFormItem):
         self._main_widget.setChecked(value)
 
 
-def widget_from_type(annotation: type | UnionType | None) -> type[DynamicFormItem]:
-    if annotation in [str, str | None]:
-        return StrMetadataField
-    if annotation in [int, int | None]:
-        return IntMetadataField
-    if annotation in [float, float | None, Decimal, Decimal | None]:
-        return FloatDecimalMetadataField
-    if annotation in [bool, bool | None]:
-        return BoolMetadataField
-    else:
-        logger.warning(f"Type {annotation} is not (yet) supported in metadata form creation.")
-        return StrMetadataField
+class BoolToggleFormItem(BoolFormItem):
+    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
+        if spec.info.default is PydanticUndefined:
+            spec.info.default = False
+        super().__init__(parent=parent, spec=spec)
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = ToggleSwitch()
+        self._layout.addWidget(self._main_widget)
+        self._main_widget.setToolTip(self._describe(""))
+        if self._default is not None:
+            self._main_widget.setChecked(self._default)
+
+
+class DictFormItem(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)
+        if spec.info.default is not PydanticUndefined:
+            self._main_widget.set_default(spec.info.default)
+
+    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)
+
+
+class _ItemAndWidgetType(NamedTuple):
+    # TODO: this should be generic but not supported in 3.10
+    item: type[int | float | str]
+    widget: type[QWidget]
+    default: int | float | str
+
+
+class ListFormItem(DynamicFormItem):
+    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
+        if spec.info.annotation is list:
+            self._types = _ItemAndWidgetType(str, QLineEdit, "")
+        elif isinstance(spec.info.annotation, GenericAlias):
+            args = set(typing.get_args(spec.info.annotation))
+            if args == {str}:
+                self._types = _ItemAndWidgetType(str, QLineEdit, "")
+            if args == {int}:
+                self._types = _ItemAndWidgetType(int, QSpinBox, 0)
+            if args == {float} or args == {int, float}:
+                self._types = _ItemAndWidgetType(float, QDoubleSpinBox, 0.0)
+        else:
+            self._types = _ItemAndWidgetType(str, QLineEdit, "")
+        super().__init__(parent=parent, spec=spec)
+        self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
+        self._main_widget: QListWidget
+        self._data = []
+        self._min_lines = 2 if spec.pretty_display else 4
+        self._repop(self._data)
+
+    def sizeHint(self):
+        default = super().sizeHint()
+        return QSize(default.width(), QFontMetrics(self.font()).height() * 6)
+
+    def _add_main_widget(self) -> None:
+        self._main_widget = QListWidget()
+        self._layout.addWidget(self._main_widget)
+        self._layout.setAlignment(Qt.AlignmentFlag.AlignTop)
+        self._add_buttons()
+
+    def _add_buttons(self):
+        self._button_holder = QWidget()
+        self._buttons = QVBoxLayout()
+        self._button_holder.setLayout(self._buttons)
+        self._layout.addWidget(self._button_holder)
+        self._add_button = QPushButton("+")
+        self._add_button.setToolTip("add a new row")
+        self._remove_button = QPushButton("-")
+        self._remove_button.setToolTip("delete the focused row (if any)")
+        self._add_button.clicked.connect(self._add_row)
+        self._remove_button.clicked.connect(self._delete_row)
+        self._buttons.addWidget(self._add_button)
+        self._buttons.addWidget(self._remove_button)
+
+    def _set_pretty_display(self):
+        super()._set_pretty_display()
+        self._button_holder.setHidden(True)
+
+    def _repop(self, data):
+        self._main_widget.clear()
+        for val in data:
+            self._add_list_item(val)
+        self.scale_to_data()
+
+    def _add_data_item(self, val=None):
+        val = val or self._types.default
+        self._data.append(val)
+        self._add_list_item(val)
+        self._repop(self._data)
+
+    def _add_list_item(self, val):
+        item = QListWidgetItem(self._main_widget)
+        item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsEditable)
+        item_widget = self._types.widget(parent=self)
+        WidgetIO.set_value(item_widget, val)
+        self._main_widget.setItemWidget(item, item_widget)
+        self._main_widget.addItem(item)
+        WidgetIO.connect_widget_change_signal(item_widget, self._update)
+        return item_widget
+
+    def _update(self, _, value, *args):
+        self._data[self._main_widget.currentRow()] = value
+
+    @SafeSlot()
+    def _add_row(self):
+        self._add_data_item(self._types.default)
+        self._repop(self._data)
+
+    @SafeSlot()
+    def _delete_row(self):
+        if selected := self._main_widget.currentItem():
+            self._main_widget.removeItemWidget(selected)
+            row = self._main_widget.currentRow()
+            self._main_widget.takeItem(row)
+            self._data.pop(row)
+        self._repop(self._data)
+
+    @SafeSlot()
+    def clear(self):
+        self._repop([])
+
+    def getValue(self):
+        return self._data
+
+    def setValue(self, value: Iterable):
+        if set(map(type, value)) | {self._types.item} != {self._types.item}:
+            raise ValueError(f"This widget only accepts items of type {self._types.item}")
+        self._data = list(value)
+        self._repop(self._data)
+
+    def _line_height(self):
+        return QFontMetrics(self._main_widget.font()).height()
+
+    def set_max_height_in_lines(self, lines: int):
+        outer_inc = 1 if self._spec.pretty_display else 3
+        self._main_widget.setFixedHeight(self._line_height() * max(lines, self._min_lines))
+        self._button_holder.setFixedHeight(self._line_height() * (max(lines, self._min_lines) + 1))
+        self.setFixedHeight(self._line_height() * (max(lines, self._min_lines) + outer_inc))
+
+    def scale_to_data(self, *_):
+        self.set_max_height_in_lines(self._main_widget.count() + 1)
+
+
+class SetFormItem(ListFormItem):
+    def _add_main_widget(self) -> None:
+        super()._add_main_widget()
+        self._add_item_field = self._types.widget()
+        self._buttons.addWidget(QLabel("Add new:"))
+        self._buttons.addWidget(self._add_item_field)
+        self.setSizePolicy(QSizePolicy.Policy.MinimumExpanding, QSizePolicy.Policy.Minimum)
+
+    @SafeSlot()
+    def _add_row(self):
+        self._add_data_item(WidgetIO.get_value(self._add_item_field))
+        self._repop(self._data)
+
+    def _update(self, _, value, *args):
+        if value in self._data:
+            return
+        return super()._update(_, value, *args)
+
+    def _add_data_item(self, val=None):
+        val = val or self._types.default
+        if val == self._types.default or val in self._data:
+            return
+        self._data.append(val)
+        self._add_list_item(val)
+
+    def _add_list_item(self, val):
+        item_widget = super()._add_list_item(val)
+        if isinstance(item_widget, QLineEdit):
+            item_widget.setReadOnly(True)
+        return item_widget
+
+    def getValue(self):
+        return set(self._data)
+
+    def setValue(self, value: set):
+        return super().setValue(set(value))
+
+
+class StrLiteralFormItem(DynamicFormItem):
+    def _add_main_widget(self) -> None:
+        self._main_widget = QComboBox()
+        self._options = get_args(self._spec.info.annotation)
+        for opt in self._options:
+            self._main_widget.addItem(opt)
+        self._layout.addWidget(self._main_widget)
+
+    def getValue(self):
+        return self._main_widget.currentText()
+
+    def setValue(self, value: str | None):
+        if value is None:
+            self.clear()
+        for i in range(self._main_widget.count()):
+            if self._main_widget.itemText(i) == value:
+                self._main_widget.setCurrentIndex(i)
+                return
+        raise ValueError(f"Cannot set value: {value}, options are: {self._options}")
+
+    def clear(self):
+        self._main_widget.setCurrentIndex(-1)
+
+
+WidgetTypeRegistry = OrderedDict[str, tuple[Callable[[FormItemSpec], bool], type[DynamicFormItem]]]
+
+DEFAULT_WIDGET_TYPES: Final[WidgetTypeRegistry] = OrderedDict() | {
+    # dict literals are ordered already but TypedForm subclasses may modify coppies of this dict
+    # and delete/insert keys or change the order
+    "literal_str": (
+        lambda spec: type(spec.info.annotation) is type(Literal[""])
+        and set(type(arg) for arg in get_args(spec.info.annotation)) == {str},
+        StrLiteralFormItem,
+    ),
+    "str": (lambda spec: spec.item_type in [str, str | None, None], StrFormItem),
+    "int": (lambda spec: spec.item_type in [int, int | None], IntFormItem),
+    "float_decimal": (
+        lambda spec: spec.item_type in [float, float | None, Decimal, Decimal | None],
+        FloatDecimalFormItem,
+    ),
+    "bool": (lambda spec: spec.item_type in [bool, bool | None], BoolFormItem),
+    "dict": (
+        lambda spec: spec.item_type in [dict, dict | None]
+        or (isinstance(spec.item_type, GenericAlias) and spec.item_type.__origin__ is dict),
+        DictFormItem,
+    ),
+    "list": (
+        lambda spec: spec.item_type in [list, list | None]
+        or (isinstance(spec.item_type, GenericAlias) and spec.item_type.__origin__ is list),
+        ListFormItem,
+    ),
+    "set": (
+        lambda spec: spec.item_type in [set, set | None]
+        or (isinstance(spec.item_type, GenericAlias) and spec.item_type.__origin__ is set),
+        SetFormItem,
+    ),
+}
+
+
+def widget_from_type(
+    spec: FormItemSpec, widget_types: WidgetTypeRegistry | None = None
+) -> type[DynamicFormItem]:
+    widget_types = widget_types or DEFAULT_WIDGET_TYPES
+    for predicate, widget_type in widget_types.values():
+        if predicate(spec):
+            return widget_type
+    logger.warning(
+        f"Type {spec.item_type=} / {spec.info.annotation=} is not (yet) supported in dynamic form creation."
+    )
+    return StrFormItem
 
 
 if __name__ == "__main__":  # pragma: no cover
 
     class TestModel(BaseModel):
+        value0: set = Field(set(["a", "b"]))
         value1: str | None = Field(None)
         value2: bool | None = Field(None)
         value3: bool = Field(True)
         value4: int = Field(123)
         value5: int | None = Field()
+        value6: list[int] = Field()
+        value7: list = Field()
 
     app = QApplication([])
     w = QWidget()
     layout = QGridLayout()
     w.setLayout(layout)
+    items = []
     for i, (field_name, info) in enumerate(TestModel.model_fields.items()):
+        spec = spec = FormItemSpec(item_type=info.annotation, name=field_name, info=info)
         layout.addWidget(QLabel(field_name), i, 0)
-        layout.addWidget(widget_from_type(info.annotation)(info), i, 1)
+        widg = widget_from_type(spec)(spec=spec)
+        items.append(widg)
+        layout.addWidget(widg, i, 1)
+
+    items[6].setValue([1, 2, 3, 4])
+    items[7].setValue(["1", "2", "asdfg", "qwerty"])
 
     w.show()
     app.exec()

bec_widgets/utils/forms_from_types/styles.py

@@ -0,0 +1,21 @@
+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,6 +8,9 @@ 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):
@@ -90,34 +93,20 @@ class DesignerPluginGenerator:
 
         # Check if the widget class calls the super constructor with parent argument
         init_source = inspect.getsource(self.widget.__init__)
-        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)
+        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
         )
+        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 = (
-                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)
-            )
+            super_init_found = SUPER_INIT_REGEX.search(init_source) is not None
 
         # for the new style classes, we only have one super call. We can therefore check if the
         # number of __init__ calls is 2 (the class itself and the super class)
         num_inits = re.findall(r"__init__", init_source)
         if len(num_inits) == 2 and not super_init_found:
-            super_init_found = bool(
-                init_source.find("super().__init__(parent=parent") > 0
-                or init_source.find("super().__init__(parent,") > 0
-                or init_source.find("super().__init__(parent)") > 0
-            )
+            super_init_found = SUPER_INIT_REGEX.search(init_source) is not None
 
         if not cls_init_found and not super_init_found:
             raise ValueError(

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
+from typing import TYPE_CHECKING, Iterable
 
 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
+    obj: type[BECWidget]
     is_connector: bool = False
     is_widget: bool = False
     is_plugin: bool = False
 
 
 class BECClassContainer:
-    def __init__(self):
-        self._collection: list[BECClassInfo] = []
+    def __init__(self, initial: Iterable[BECClassInfo] = []):
+        self._collection: list[BECClassInfo] = list(initial)
 
     def __repr__(self):
         return str(list(cl.name for cl in self.collection))
@@ -106,6 +106,16 @@ 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.
@@ -115,53 +125,44 @@ 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]
 
 
@@ -197,7 +198,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

@@ -195,7 +195,7 @@ class RPCServer:
             return
         self._broadcasted_data = data
 
-        logger.info(f"Broadcasting registry update: {data} for {self.gui_id}")
+        logger.debug(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 PySide6.QtGui import QCloseEvent
+from qtpy.QtGui import QCloseEvent
 from qtpy.QtWidgets import QDialog, QDialogButtonBox, QHBoxLayout, QPushButton, QVBoxLayout, QWidget
 
 from bec_widgets.utils.error_popups import SafeSlot

bec_widgets/utils/toolbar.py

@@ -7,6 +7,7 @@ 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
@@ -31,6 +32,8 @@ 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)
 
@@ -173,6 +176,10 @@ 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)
 

bec_widgets/utils/ui_loader.py

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

bec_widgets/widgets/containers/dock/dock_area.py

@@ -163,8 +163,11 @@ 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", filled=True
+                            icon_name=LogPanel.ICON_NAME,
+                            tooltip="Add LogPanel - Disabled",
+                            filled=True,
                         ),
                     },
                 ),
@@ -230,9 +233,11 @@ class BECDockArea(BECWidget, QWidget):
         self.toolbar.widgets["menu_utils"].widgets["progress_bar"].triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="RingProgressBar")
         )
-        self.toolbar.widgets["menu_utils"].widgets["log_panel"].triggered.connect(
-            lambda: self._create_widget_from_toolbar(widget_name="LogPanel")
-        )
+        # 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")
+        # )
 
         # Icons
         self.toolbar.widgets["attach_all"].action.triggered.connect(self.attach_all)

bec_widgets/widgets/containers/main_window/addons/scroll_label.py

@@ -0,0 +1,110 @@
+from qtpy.QtCore import QTimer
+from qtpy.QtGui import QFontMetrics, QPainter
+from qtpy.QtWidgets import QLabel
+
+
+class ScrollLabel(QLabel):
+    """A QLabel that scrolls its text horizontally across the widget."""
+
+    def __init__(self, parent=None, speed_ms=30, step_px=1, delay_ms=2000):
+        super().__init__(parent=parent)
+        self._offset = 0
+        self._text_width = 0
+
+        # scrolling timer (runs continuously once started)
+        self._timer = QTimer(self)
+        self._timer.setInterval(speed_ms)
+        self._timer.timeout.connect(self._scroll)
+
+        # delay‑before‑scroll timer (single‑shot)
+        self._delay_timer = QTimer(self)
+        self._delay_timer.setSingleShot(True)
+        self._delay_timer.setInterval(delay_ms)
+        self._delay_timer.timeout.connect(self._timer.start)
+
+        self._step_px = step_px
+
+    def setText(self, text):
+        """
+        Overridden to ensure that new text replaces the current one
+        immediately.
+        If the label was already scrolling (or in its delay phase),
+        the next message starts **without** the extra delay.
+        """
+        # Determine whether the widget was already in a scrolling cycle
+        was_scrolling = self._timer.isActive() or self._delay_timer.isActive()
+
+        super().setText(text)
+
+        fm = QFontMetrics(self.font())
+        self._text_width = fm.horizontalAdvance(text)
+        self._offset = 0
+
+        # Skip the delay when we were already scrolling
+        self._update_timer(skip_delay=was_scrolling)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        self._update_timer()
+
+    def _update_timer(self, *, skip_delay: bool = False):
+        """
+        Decide whether to start or stop scrolling.
+
+        If the text is wider than the visible area, start a single‑shot
+        delay timer (2s by default). Scrolling begins only after this
+        delay. Any change (resize or new text) restarts the logic.
+        """
+        needs_scroll = self._text_width > self.width()
+
+        if needs_scroll:
+            # Reset any running timers
+            if self._timer.isActive():
+                self._timer.stop()
+            if self._delay_timer.isActive():
+                self._delay_timer.stop()
+
+            self._offset = 0
+
+            # Start scrolling immediately when we should skip the delay,
+            # otherwise apply the configured delay_ms interval
+            if skip_delay:
+                self._timer.start()
+            else:
+                self._delay_timer.start()
+        else:
+            if self._delay_timer.isActive():
+                self._delay_timer.stop()
+            if self._timer.isActive():
+                self._timer.stop()
+            self.update()
+
+    def _scroll(self):
+        self._offset += self._step_px
+        if self._offset >= self._text_width:
+            self._offset = 0
+        self.update()
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.TextAntialiasing)
+        text = self.text()
+        if not text:
+            return
+        fm = QFontMetrics(self.font())
+        y = (self.height() + fm.ascent() - fm.descent()) // 2
+        if self._text_width <= self.width():
+            painter.drawText(0, y, text)
+        else:
+            x = -self._offset
+            gap = 50  # space between repeating text blocks
+            while x < self.width():
+                painter.drawText(x, y, text)
+                x += self._text_width + gap
+
+    def cleanup(self):
+        """Stop all timers to prevent memory leaks."""
+        if self._timer.isActive():
+            self._timer.stop()
+        if self._delay_timer.isActive():
+            self._delay_timer.stop()

bec_widgets/widgets/containers/main_window/main_window.py

@@ -1,16 +1,17 @@
 import os
 
-from qtpy.QtCore import QSize
+from bec_lib.endpoints import MessageEndpoints
+from qtpy.QtCore import QEvent, QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QActionGroup, QIcon
-from qtpy.QtWidgets import QApplication, QMainWindow, QStyle
+from qtpy.QtWidgets import QApplication, QFrame, QLabel, QMainWindow, QStyle, QVBoxLayout, QWidget
 
 import bec_widgets
 from bec_widgets.utils import UILoader
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import apply_theme
-from bec_widgets.utils.container_utils import WidgetContainerUtils
 from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.widget_io import WidgetHierarchy
+from bec_widgets.widgets.containers.main_window.addons.scroll_label import ScrollLabel
 from bec_widgets.widgets.containers.main_window.addons.web_links import BECWebLinksMixin
 
 MODULE_PATH = os.path.dirname(bec_widgets.__file__)
@@ -36,6 +37,14 @@ class BECMainWindow(BECWidget, QMainWindow):
         self._init_ui()
         self._connect_to_theme_change()
 
+        # Connections to BEC Notifications
+        self.bec_dispatcher.connect_slot(
+            self.display_client_message, MessageEndpoints.client_info()
+        )
+
+    ################################################################################
+    # MainWindow Elements Initialization
+    ################################################################################
     def _init_ui(self):
 
         # Set the icon
@@ -43,40 +52,77 @@ class BECMainWindow(BECWidget, QMainWindow):
 
         # Set Menu and Status bar
         self._setup_menu_bar()
+        self._init_status_bar_widgets()
 
         # BEC Specific UI
         self.display_app_id()
 
+    def _init_status_bar_widgets(self):
+        """
+        Prepare the BEC specific widgets in the status bar.
+        """
+        status_bar = self.statusBar()
+
+        # Left: App‑ID label
+        self._app_id_label = QLabel()
+        self._app_id_label.setAlignment(
+            Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter
+        )
+        status_bar.addWidget(self._app_id_label)
+
+        # Add a separator after the app ID label
+        self._add_separator()
+
+        # Centre: Client‑info label (stretch=1 so it expands)
+        self._client_info_label = ScrollLabel()
+        self._client_info_label.setAlignment(
+            Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter
+        )
+        status_bar.addWidget(self._client_info_label, 1)
+
+        # Timer to automatically clear client messages once they expire
+        self._client_info_expire_timer = QTimer(self)
+        self._client_info_expire_timer.setSingleShot(True)
+        self._client_info_expire_timer.timeout.connect(lambda: self._client_info_label.setText(""))
+
+    def _add_separator(self):
+        """
+        Add a vertically centred separator to the status bar.
+        """
+        status_bar = self.statusBar()
+
+        # The actual line
+        line = QFrame()
+        line.setFrameShape(QFrame.VLine)
+        line.setFrameShadow(QFrame.Sunken)
+        line.setFixedHeight(status_bar.sizeHint().height() - 2)
+
+        # Wrapper to center the line vertically -> work around for QFrame not being able to center itself
+        wrapper = QWidget()
+        vbox = QVBoxLayout(wrapper)
+        vbox.setContentsMargins(0, 0, 0, 0)
+        vbox.addStretch()
+        vbox.addWidget(line, alignment=Qt.AlignHCenter)
+        vbox.addStretch()
+        wrapper.setFixedWidth(line.sizeHint().width())
+
+        status_bar.addWidget(wrapper)
+
     def _init_bec_icon(self):
         icon = self.app.windowIcon()
         if icon.isNull():
-            print("No icon is set, setting default icon")
             icon = QIcon()
             icon.addFile(
                 os.path.join(MODULE_PATH, "assets", "app_icons", "bec_widgets_icon.png"),
                 size=QSize(48, 48),
             )
             self.app.setWindowIcon(icon)
-        else:
-            print("An icon is set")
 
     def load_ui(self, ui_file):
         loader = UILoader(self)
         self.ui = loader.loader(ui_file)
         self.setCentralWidget(self.ui)
 
-    def display_app_id(self):
-        """
-        Display the app ID in the status bar.
-        """
-        if self.bec_dispatcher.cli_server is None:
-            status_message = "Not connected"
-        else:
-            # Get the server ID from the dispatcher
-            server_id = self.bec_dispatcher.cli_server.gui_id
-            status_message = f"App ID: {server_id}"
-        self.statusBar().showMessage(status_message)
-
     def _fetch_theme(self) -> str:
         return self.app.theme.theme
 
@@ -164,14 +210,64 @@ class BECMainWindow(BECWidget, QMainWindow):
         help_menu.addAction(widgets_docs)
         help_menu.addAction(bug_report)
 
+    ################################################################################
+    # Status Bar Addons
+    ################################################################################
+    def display_app_id(self):
+        """
+        Display the app ID in the status bar.
+        """
+        if self.bec_dispatcher.cli_server is None:
+            status_message = "Not connected"
+        else:
+            # Get the server ID from the dispatcher
+            server_id = self.bec_dispatcher.cli_server.gui_id
+            status_message = f"App ID: {server_id}"
+        self._app_id_label.setText(status_message)
+
+    @SafeSlot(dict, dict)
+    def display_client_message(self, msg: dict, meta: dict):
+        """
+        Display a client message in the status bar.
+
+        Args:
+            msg(dict): The message to display, should contain:
+            meta(dict): Metadata about the message, usually empty.
+        """
+        # self._client_info_label.setText("")
+        message = msg.get("message", "")
+        expiration = msg.get("expire", 0)  # 0 → never expire
+        self._client_info_label.setText(message)
+
+        # Restart the expiration timer if necessary
+        if hasattr(self, "_client_info_expire_timer") and self._client_info_expire_timer.isActive():
+            self._client_info_expire_timer.stop()
+        if expiration and expiration > 0:
+            self._client_info_expire_timer.start(int(expiration * 1000))
+
+    ################################################################################
+    # General and Cleanup Methods
+    ################################################################################
     @SafeSlot(str)
     def change_theme(self, theme: str):
+        """
+        Change the theme of the application.
+
+        Args:
+            theme(str): The theme to apply, either "light" or "dark".
+        """
         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()
-        central_widget.deleteLater()
+        if central_widget is not None:
+            central_widget.close()
+            central_widget.deleteLater()
         if not isinstance(central_widget, BECWidget):
             # if the central widget is not a BECWidget, we need to call the cleanup method
             # of all widgets whose parent is the current BECMainWindow
@@ -182,8 +278,22 @@ class BECMainWindow(BECWidget, QMainWindow):
                     child.cleanup()
                     child.close()
                     child.deleteLater()
+
+        if hasattr(self, "_client_info_expire_timer") and self._client_info_expire_timer.isActive():
+            self._client_info_expire_timer.stop()
+        # Status bar widgets cleanup
+        self._client_info_label.cleanup()
         super().cleanup()
 
 
 class UILaunchWindow(BECMainWindow):
     RPC = True
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    main_window = UILaunchWindow()
+    main_window.show()
+    sys.exit(app.exec())

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

@@ -1,10 +1,11 @@
 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, Slot
+from qtpy.QtCore import Property
 
 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
@@ -49,7 +50,7 @@ class DeviceSignalInputBase(BECWidget):
 
         self._device = None
         self.get_bec_shortcuts()
-        self._signal_filter = []
+        self._signal_filter = set()
         self._signals = []
         self._hinted_signals = []
         self._normal_signals = []
@@ -60,7 +61,7 @@ class DeviceSignalInputBase(BECWidget):
 
     ### Qt Slots ###
 
-    @Slot(str)
+    @SafeSlot(str)
     def set_signal(self, signal: str):
         """
         Set the signal.
@@ -76,10 +77,10 @@ class DeviceSignalInputBase(BECWidget):
                 f"Signal {signal} not found for device {self.device} and filtered selection {self.signal_filter}."
             )
 
-    @Slot(str)
+    @SafeSlot(str)
     def set_device(self, device: str | None):
         """
-        Set the device. If device is not valid, device will be set to None which happpens
+        Set the device. If device is not valid, device will be set to None which happens
 
         Args:
             device(str): device name.
@@ -90,8 +91,8 @@ class DeviceSignalInputBase(BECWidget):
             self._device = device
         self.update_signals_from_filters()
 
-    @Slot(dict, dict)
-    @Slot()
+    @SafeSlot(dict, dict)
+    @SafeSlot()
     def update_signals_from_filters(
         self, content: dict | None = None, metadata: dict | None = None
     ):
@@ -112,9 +113,12 @@ class DeviceSignalInputBase(BECWidget):
         # See above convention for Signals and ComputedSignals
         if isinstance(device, Signal):
             self._signals = [self._device]
-            FilterIO.set_selection(widget=self, selection=[self._device])
+            self._hinted_signals = [self._device]
+            self._normal_signals = []
+            self._config_signals = []
+            FilterIO.set_selection(widget=self, selection=self._signals)
             return
-        device_info = device._info["signals"]
+        device_info = device._info.get("signals", {})
 
         def _update(kind: Kind):
             return [
@@ -155,9 +159,9 @@ class DeviceSignalInputBase(BECWidget):
     @include_hinted_signals.setter
     def include_hinted_signals(self, value: bool):
         if value:
-            self._signal_filter.append(Kind.hinted)
+            self._signal_filter.add(Kind.hinted)
         else:
-            self._signal_filter.remove(Kind.hinted)
+            self._signal_filter.discard(Kind.hinted)
         self.update_signals_from_filters()
 
     @Property(bool)
@@ -168,9 +172,9 @@ class DeviceSignalInputBase(BECWidget):
     @include_normal_signals.setter
     def include_normal_signals(self, value: bool):
         if value:
-            self._signal_filter.append(Kind.normal)
+            self._signal_filter.add(Kind.normal)
         else:
-            self._signal_filter.remove(Kind.normal)
+            self._signal_filter.discard(Kind.normal)
         self.update_signals_from_filters()
 
     @Property(bool)
@@ -181,9 +185,9 @@ class DeviceSignalInputBase(BECWidget):
     @include_config_signals.setter
     def include_config_signals(self, value: bool):
         if value:
-            self._signal_filter.append(Kind.config)
+            self._signal_filter.add(Kind.config)
         else:
-            self._signal_filter.remove(Kind.config)
+            self._signal_filter.discard(Kind.config)
         self.update_signals_from_filters()
 
     ### Properties and Methods ###

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

@@ -22,10 +22,14 @@ 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
 
@@ -145,6 +149,25 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
             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,11 +24,15 @@ 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 ReadoutPriority. Check DeviceInputBase for more details.
+        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", "_is_valid_input"]
+
     device_selected = Signal(str)
     device_config_update = Signal()
 
@@ -51,7 +55,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)
@@ -95,6 +99,20 @@ 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.

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

@@ -1,11 +1,13 @@
 from bec_lib.device import Positioner
-from qtpy.QtCore import QSize, Signal, Slot
+from qtpy.QtCore import QSize, Signal
 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,
 )
 
 
@@ -23,8 +25,11 @@ 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)
 
@@ -32,7 +37,7 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
         self,
         parent=None,
         client=None,
-        config: DeviceSignalInputBase = None,
+        config: DeviceSignalInputBaseConfig | None = None,
         gui_id: str | None = None,
         device: str | None = None,
         signal_filter: str | list[str] | None = None,
@@ -62,9 +67,13 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
         if default is not None:
             self.set_signal(default)
 
-    def update_signals_from_filters(self):
+    @SafeSlot()
+    @SafeSlot(dict, dict)
+    def update_signals_from_filters(
+        self, content: dict | None = None, metadata: dict | None = None
+    ):
         """Update the filters for the combobox"""
-        super().update_signals_from_filters()
+        super().update_signals_from_filters(content, metadata)
         # pylint: disable=protected-access
         if FilterIO._find_handler(self) is ComboBoxFilterHandler:
             if len(self._config_signals) > 0:
@@ -81,7 +90,7 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
                 self.insertItem(0, "Hinted Signals")
                 self.model().item(0).setEnabled(False)
 
-    @Slot(str)
+    @SafeSlot(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,9 +24,12 @@ 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__(
@@ -41,7 +44,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)
@@ -65,8 +68,22 @@ class SignalLineEdit(DeviceSignalInputBase, QLineEdit):
             self.set_device(device)
         if default is not None:
             self.set_signal(default)
-        self.textChanged.connect(self.validate_device)
-        self.validate_device(self.text())
+        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 get_current_device(self) -> object:
         """
@@ -131,6 +148,9 @@ 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")
@@ -138,6 +158,12 @@ if __name__ == "__main__":  # pragma: no cover
     widget.setFixedSize(200, 200)
     layout = QVBoxLayout()
     widget.setLayout(layout)
-    layout.addWidget(SignalLineEdit(device="samx"))
+    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)
     widget.show()
     app.exec_()

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -89,6 +89,7 @@ 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()
@@ -165,7 +166,6 @@ class ScanControl(BECWidget, QWidget):
         self.layout.addStretch()
 
     def _add_metadata_form(self):
-        self._metadata_form = ScanMetadata(parent=self)
         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/editors/console/console.py

@@ -1,870 +0,0 @@
-"""
-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

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

bec_widgets/widgets/editors/dict_backed_table.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 from typing import Any
 
+from qtpy import QtWidgets
 from qtpy.QtCore import QAbstractTableModel, QModelIndex, Qt, Signal  # type: ignore
+from qtpy.QtGui import QFontMetrics
 from qtpy.QtWidgets import (
     QApplication,
     QHBoxLayout,
@@ -13,7 +15,9 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
-from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
+
+_NOT_SET = object()
 
 
 class DictBackedTableModel(QAbstractTableModel):
@@ -25,6 +29,7 @@ class DictBackedTableModel(QAbstractTableModel):
             data (list[list[str]]): list of key-value pairs to initialise with"""
         super().__init__()
         self._data: list[list[str]] = data
+        self._default = _NOT_SET
         self._disallowed_keys: list[str] = []
 
     # pylint: disable=missing-function-docstring
@@ -45,8 +50,15 @@ class DictBackedTableModel(QAbstractTableModel):
 
     def data(self, index, role=Qt.ItemDataRole):
         if index.isValid():
-            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
-                return str(self._data[index.row()][index.column()])
+            if role in [
+                Qt.ItemDataRole.DisplayRole,
+                Qt.ItemDataRole.EditRole,
+                Qt.ItemDataRole.ToolTipRole,
+            ]:
+                try:
+                    return str(self._data[index.row()][index.column()])
+                except IndexError:
+                    return None
 
     def setData(self, index, value, role):
         if role == Qt.ItemDataRole.EditRole:
@@ -57,6 +69,12 @@ class DictBackedTableModel(QAbstractTableModel):
             return True
         return False
 
+    def replaceData(self, data: dict):
+        self.delete_rows(list(range(len(self._data))))
+        self.resetInternalData()
+        self._data = [[str(k), str(v)] for k, v in data.items()]
+        self.dataChanged.emit(self.index(0, 0), self.index(len(self._data), 1))
+
     def update_disallowed_keys(self, keys: list[str]):
         """Set the list of keys which may not be used.
 
@@ -66,7 +84,7 @@ class DictBackedTableModel(QAbstractTableModel):
         for i, item in enumerate(self._data):
             if item[0] in self._disallowed_keys:
                 self._data[i][0] = ""
-                self.dataChanged.emit(self.index(i, 0), self.index(i, 0))
+                self.dataChanged.emit(self.index(i, 0), self.index(i, 1))
 
     def _other_keys(self, row: int):
         return [r[0] for r in self._data[:row] + self._data[row + 1 :]]
@@ -95,45 +113,74 @@ class DictBackedTableModel(QAbstractTableModel):
     @SafeSlot()
     def add_row(self):
         self.insertRow(self.rowCount())
+        self.dataChanged.emit(self.index(self.rowCount(), 0), self.index(self.rowCount(), 1), 0)
 
     @SafeSlot(list)
     def delete_rows(self, rows: list[int]):
         # delete from the end so indices stay correct
         for row in sorted(rows, reverse=True):
+            self.dataChanged.emit(self.index(row, 0), self.index(row, 1), 0)
             self.removeRows(row, 1, QModelIndex())
 
+    def set_default(self, value: dict | None):
+        self._default = value
+
     def dump_dict(self):
-        if self._data == [[]]:
+        if self._data in [[], [[]], [["", ""]]]:
+            if self._default is not _NOT_SET:
+                return self._default
             return {}
         return dict(self._data)
 
+    def length(self):
+        return len(self._data)
+
 
 class DictBackedTable(QWidget):
     delete_rows = Signal(list)
-    data_updated = Signal()
+    data_changed = Signal(dict)
 
-    def __init__(self, initial_data: list[list[str]]):
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        initial_data: list[list[str]] = [],
+        autoscale_to_data: bool = True,
+    ):
         """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__()
+        super().__init__(parent)
 
         self._layout = QHBoxLayout()
         self.setLayout(self._layout)
+        self._layout.setContentsMargins(0, 0, 0, 0)
+
         self._table_model = DictBackedTableModel(initial_data)
         self._table_view = QTreeView()
+
         self._table_view.setModel(self._table_model)
+        self._min_lines = 3
+        self.set_height_in_lines(len(initial_data))
         self._table_view.setSizePolicy(
-            QSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
+            QSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
         )
         self._table_view.setAlternatingRowColors(True)
+        self._table_view.setUniformRowHeights(True)
+        self._table_view.setWordWrap(False)
+        self._table_view.header().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        self._table_view.header().setSectionResizeMode(5, QtWidgets.QHeaderView.Stretch)
+        self.autoscale = autoscale_to_data
+        if self.autoscale:
+            self.data_changed.connect(self.scale_to_data)
         self._layout.addWidget(self._table_view)
 
+        self._button_holder = QWidget()
         self._buttons = QVBoxLayout()
-        self._layout.addLayout(self._buttons)
+        self._button_holder.setLayout(self._buttons)
+        self._layout.addWidget(self._button_holder)
         self._add_button = QPushButton("+")
         self._add_button.setToolTip("add a new row")
         self._remove_button = QPushButton("-")
@@ -143,11 +190,21 @@ class DictBackedTable(QWidget):
         self._add_button.clicked.connect(self._table_model.add_row)
         self._remove_button.clicked.connect(self.delete_selected_rows)
         self.delete_rows.connect(self._table_model.delete_rows)
-        self._table_model.dataChanged.connect(self._emit_data_updated)
 
-    def _emit_data_updated(self, *args, **kwargs):
-        """Just to swallow the args"""
-        self.data_updated.emit()
+        self._table_model.dataChanged.connect(lambda *_: self.data_changed.emit(self.dump_dict()))
+
+    def set_default(self, value: dict | None):
+        self._table_model.set_default(value)
+
+    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 | None):
+        self._table_model.replaceData(data or {})
 
     def delete_selected_rows(self):
         """Delete rows which are part of the selection model"""
@@ -167,6 +224,29 @@ class DictBackedTable(QWidget):
             keys (list[str]): list of keys which are forbidden."""
         self._table_model.update_disallowed_keys(keys)
 
+    def set_height_in_lines(self, lines: int):
+        self._table_view.setMaximumHeight(
+            int(QFontMetrics(self._table_view.font()).height() * max(lines + 2, self._min_lines))
+        )
+
+    @SafeSlot()
+    @SafeSlot(dict)
+    def scale_to_data(self, *_):
+        self.set_height_in_lines(self._table_model.length())
+
+    @SafeProperty(bool)
+    def autoscale(self):  # type: ignore
+        return self._autoscale
+
+    @autoscale.setter
+    def autoscale(self, autoscale: bool):
+        self._autoscale = autoscale
+        if self._autoscale:
+            self.scale_to_data()
+            self.data_changed.connect(self.scale_to_data)
+        else:
+            self.data_changed.disconnect(self.scale_to_data)
+
 
 if __name__ == "__main__":  # pragma: no cover
     from bec_widgets.utils.colors import set_theme
@@ -174,6 +254,6 @@ if __name__ == "__main__":  # pragma: no cover
     app = QApplication([])
     set_theme("dark")
 
-    window = DictBackedTable([["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
+    window = DictBackedTable(None, [["key1", "value1"], ["key2", "value2"], ["key3", "value3"]])
     window.show()
     app.exec()

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 inf, nextafter
+from math import copysign, inf, nextafter
 from typing import TYPE_CHECKING, TypeVar, get_args
 
 from annotated_types import Ge, Gt, Le, Lt
@@ -23,16 +23,19 @@ _MAXFLOAT = sys.float_info.max
 T = TypeVar("T", int, float, Decimal)
 
 
-def field_limits(info: FieldInfo, type_: type[T]) -> tuple[T, T]:
+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))
+
     _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
@@ -64,4 +67,6 @@ def field_default(info: FieldInfo):
 
 
 def clearable_required(info: FieldInfo):
-    return type(None) in get_args(info.annotation) or info.is_required()
+    return type(None) in get_args(info.annotation) or (
+        info.is_required() and info.default is PydanticUndefined
+    )

bec_widgets/widgets/editors/scan_metadata/scan_metadata.py

@@ -16,6 +16,9 @@ logger = bec_logger.logger
 
 
 class ScanMetadata(PydanticModelForm):
+
+    RPC = False
+
     def __init__(
         self,
         parent=None,
@@ -36,16 +39,18 @@ class ScanMetadata(PydanticModelForm):
 
         # self.populate() gets called in super().__init__
         # so make sure self._additional_metadata exists
-        self._additional_md_box = ExpandableGroupFrame("Additional metadata", expanded=False)
+        self._additional_md_box = ExpandableGroupFrame(
+            parent, "Additional metadata", expanded=False
+        )
         self._additional_md_box_layout = QHBoxLayout()
         self._additional_md_box.set_layout(self._additional_md_box_layout)
 
-        self._additional_metadata = DictBackedTable(initial_extras or [])
+        self._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_updated.connect(self.validate_form)
+        self._additional_metadata.data_changed.connect(self.validate_form)
 
-        super().__init__(parent=parent, metadata_model=self._md_schema, client=client, **kwargs)
+        super().__init__(parent=parent, data_model=self._md_schema, client=client, **kwargs)
 
         self._layout.addWidget(self._additional_md_box)
         self._additional_md_box_layout.addWidget(self._additional_metadata)
@@ -127,6 +132,7 @@ 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/plots/image/image_item.py

@@ -21,9 +21,6 @@ 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.")
@@ -43,6 +40,7 @@ class ImageItemConfig(ConnectionConfig):  # TODO review config
 
 
 class ImageItem(BECConnector, pg.ImageItem):
+
     RPC = True
     USER_ACCESS = [
         "color_map",
@@ -69,12 +67,13 @@ class ImageItem(BECConnector, pg.ImageItem):
     ]
 
     vRangeChangedManually = Signal(tuple)
+    removed = Signal(str)
 
     def __init__(
         self,
         config: Optional[ImageItemConfig] = None,
         gui_id: Optional[str] = None,
-        parent_image=None,
+        parent_image=None,  # FIXME: rename to parent
         **kwargs,
     ):
         if config is None:
@@ -274,6 +273,8 @@ class ImageItem(BECConnector, pg.ImageItem):
         self.buffer = []
         self.max_len = 0
 
-    def remove(self):
-        self.parent().disconnect_monitor(self.config.monitor)
+    def remove(self, emit: bool = True):
         self.clear()
+        super().remove()
+        if emit:
+            self.removed.emit(self.objectName())

bec_widgets/widgets/plots/image/image_roi_plot.py

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

@@ -0,0 +1,457 @@
+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,
+    EllipticalROI,
+    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")
+        self._draw_actions: dict[str, MaterialIconAction] = {}
+        # --- ROI draw actions (toggleable) ---
+        self.add_rect_action = MaterialIconAction("add_box", "Add Rect ROI", True, self)
+        tb.add_action("Add Rect ROI", self.add_rect_action, self)
+        self._draw_actions["rect"] = self.add_rect_action
+        self.add_circle_action = MaterialIconAction("add_circle", "Add Circle ROI", True, self)
+        tb.add_action("Add Circle ROI", self.add_circle_action, self)
+        self._draw_actions["circle"] = self.add_circle_action
+        # --- Ellipse ROI draw action ---
+        self.add_ellipse_action = MaterialIconAction("vignette", "Add Ellipse ROI", True, self)
+        tb.add_action("Add Ellipse ROI", self.add_ellipse_action, self)
+        self._draw_actions["ellipse"] = self.add_ellipse_action
+
+        for mode, act in self._draw_actions.items():
+            act.action.toggled.connect(lambda on, m=mode: self._on_draw_action_toggled(m, on))
+
+        # 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' | 'ellipse' | None
+        self._roi_start_pos = None  # QPointF in image coords
+        self._temp_roi = None  # live ROI being resized while dragging
+        # 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):
+        # Update toolbar actions so that only the selected mode is checked
+        for m, act in self._draw_actions.items():
+            act.action.blockSignals(True)
+            act.action.setChecked(m == mode)
+            act.action.blockSignals(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 _on_draw_action_toggled(self, mode: str, checked: bool):
+        if checked:
+            # Activate selected mode
+            self._set_roi_draw_mode(mode)
+        else:
+            # If the active mode is being unchecked, clear mode
+            if self._roi_draw_mode == mode:
+                self._set_roi_draw_mode(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,
+                )
+            elif 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,
+                )
+            elif self._roi_draw_mode == "ellipse":
+                self._temp_roi = EllipticalROI(
+                    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])
+            elif 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])
+            elif self._roi_draw_mode == "ellipse":
+                # Safeguard: enforce a minimum ellipse width/height of 2 px
+                min_dim = 2.0
+                w = dx if abs(dx) >= min_dim else math.copysign(min_dim, dx or 1.0)
+                h = dy if abs(dy) >= min_dim else math.copysign(min_dim, dy or 1.0)
+                self._temp_roi.setSize([w, h])
+            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
+from qtpy.QtCore import Qt, QTimer
 from qtpy.QtWidgets import QComboBox, QStyledItemDelegate
 
 from bec_widgets.utils.error_popups import SafeSlot
@@ -35,25 +35,73 @@ 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=True))
+        self.add_action("monitor", WidgetAction(widget=self.device_combo_box, adjust_size=False))
 
         # 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(60)
+        self.dim_combo_box.setFixedWidth(100)
         self.dim_combo_box.setItemDelegate(NoCheckDelegate(self.dim_combo_box))
 
-        self.add_action("dim_combo", WidgetAction(widget=self.dim_combo_box, adjust_size=True))
+        self.add_action("dim_combo", WidgetAction(widget=self.dim_combo_box, adjust_size=False))
 
-        # 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())
+        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)
 
     @SafeSlot()
-    def connect_monitor(self):
+    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.
+        """
         dim = self.dim_combo_box.currentText()
-        self.target_widget.image(monitor=self.device_combo_box.currentText(), monitor_type=dim)
+        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)

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

@@ -11,18 +11,31 @@ 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)
-        self.log = MaterialIconAction(icon_name="log_scale", tooltip="Toggle Log", checkable=True)
+        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.transpose = MaterialIconAction(
-            icon_name="transform", tooltip="Transpose Image", checkable=True
+            icon_name="transform",
+            tooltip="Transpose Image",
+            checkable=True,
+            parent=self.target_widget,
         )
         self.right = MaterialIconAction(
-            icon_name="rotate_right", tooltip="Rotate image clockwise by 90 deg"
+            icon_name="rotate_right",
+            tooltip="Rotate image clockwise by 90 deg",
+            parent=self.target_widget,
         )
         self.left = MaterialIconAction(
-            icon_name="rotate_left", tooltip="Rotate image counterclockwise by 90 deg"
+            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
         )
-        self.reset = MaterialIconAction(icon_name="reset_settings", tooltip="Reset Image Settings")
 
         self.add_action("fft", self.fft)
         self.add_action("log", self.log)

bec_widgets/widgets/plots/multi_waveform/multi_waveform.py

@@ -91,6 +91,8 @@ 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/plot_base.py

@@ -112,8 +112,11 @@ 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)
@@ -473,12 +476,31 @@ 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.
+        The final label shown on the axis = user portion + suffix + [units].
         """
-        return self._user_x_label + self._x_label_suffix
+        units = f" [{self._x_axis_units}]" if self._x_axis_units else ""
+        return self._user_x_label + self._x_label_suffix + units
 
     def _apply_x_label(self):
         """
@@ -521,12 +543,31 @@ 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.
+        The final y label shown on the axis = user portion + suffix + [units].
         """
-        return self._user_y_label + self._y_label_suffix
+        units = f" [{self._y_axis_units}]" if self._y_axis_units else ""
+        return self._user_y_label + self._y_label_suffix + units
 
     def _apply_y_label(self):
         """
@@ -938,7 +979,9 @@ 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, precision=3)
+            self.crosshair = Crosshair(
+                self.plot_item, min_precision=self._minimal_crosshair_precision
+            )
             self.crosshair.crosshairChanged.connect(self.crosshair_position_changed)
             self.crosshair.crosshairClicked.connect(self.crosshair_position_clicked)
             self.crosshair.coordinatesChanged1D.connect(self.crosshair_coordinates_changed)
@@ -966,6 +1009,29 @@ 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/scatter_waveform/scatter_waveform.py

@@ -82,6 +82,8 @@ 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/scatter_waveform/settings/scatter_curve_settings_horizontal.ui

@@ -141,6 +141,14 @@
    <header>bec_color_map_widget</header>
   </customwidget>
  </customwidgets>
+ <tabstops>
+  <tabstop>x_name</tabstop>
+  <tabstop>x_entry</tabstop>
+  <tabstop>y_name</tabstop>
+  <tabstop>y_entry</tabstop>
+  <tabstop>z_name</tabstop>
+  <tabstop>z_entry</tabstop>
+ </tabstops>
  <resources/>
  <connections>
   <connection>

bec_widgets/widgets/plots/setting_menus/axis_settings.py

@@ -60,6 +60,7 @@ 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)
 
@@ -121,6 +122,7 @@ 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)
@@ -144,6 +146,7 @@ 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)

bec_widgets/widgets/plots/setting_menus/axis_settings_horizontal.ui

@@ -14,97 +14,6 @@
             <string>Form</string>
         </property>
         <layout class="QGridLayout" name="gridLayout">
-            <item row="1" column="0">
-                <widget class="QLabel" name="label">
-                    <property name="text">
-                        <string>Inner Axes</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="1" column="1">
-                <widget class="ToggleSwitch" name="inner_axes"/>
-            </item>
-            <item row="1" column="2">
-                <widget class="QLabel" name="label_outer_axes">
-                    <property name="text">
-                        <string>Outer Axes</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="1" column="3">
-                <widget class="ToggleSwitch" name="outer_axes">
-                    <property name="checked" stdset="0">
-                        <bool>false</bool>
-                    </property>
-                </widget>
-            </item>
-            <item row="2" column="0" colspan="2">
-                <widget class="QGroupBox" name="x_axis_box">
-                    <property name="title">
-                        <string>X Axis</string>
-                    </property>
-                    <layout class="QGridLayout" name="gridLayout_4">
-                        <item row="5" column="0">
-                            <widget class="QLabel" name="x_grid_label">
-                                <property name="text">
-                                    <string>Grid</string>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="3" column="2">
-                            <widget class="ToggleSwitch" name="x_log">
-                                <property name="checked" stdset="0">
-                                    <bool>false</bool>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="2" column="0">
-                            <widget class="QLabel" name="x_max_label">
-                                <property name="text">
-                                    <string>Max</string>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="5" column="2">
-                            <widget class="ToggleSwitch" name="x_grid">
-                                <property name="checked" stdset="0">
-                                    <bool>false</bool>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="3" column="0">
-                            <widget class="QLabel" name="x_scale_label">
-                                <property name="text">
-                                    <string>Log</string>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="1" column="0" colspan="2">
-                            <widget class="QLabel" name="x_min_label">
-                                <property name="text">
-                                    <string>Min</string>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="0" column="0">
-                            <widget class="QLabel" name="x_label_label">
-                                <property name="text">
-                                    <string>Label</string>
-                                </property>
-                            </widget>
-                        </item>
-                        <item row="0" column="2">
-                            <widget class="QLineEdit" name="x_label"/>
-                        </item>
-                        <item row="1" column="2">
-                            <widget class="BECSpinBox" name="x_min"/>
-                        </item>
-                        <item row="2" column="2">
-                            <widget class="BECSpinBox" name="x_max"/>
-                        </item>
-                    </layout>
-                </widget>
-            </item>
             <item row="2" column="2" colspan="2">
                 <widget class="QGroupBox" name="y_axis_box">
                     <property name="title">
@@ -179,6 +88,87 @@
                     </layout>
                 </widget>
             </item>
+            <item row="1" column="3">
+                <widget class="ToggleSwitch" name="outer_axes">
+                    <property name="checked" stdset="0">
+                        <bool>false</bool>
+                    </property>
+                </widget>
+            </item>
+            <item row="1" column="0">
+                <widget class="QLabel" name="label">
+                    <property name="text">
+                        <string>Inner Axes</string>
+                    </property>
+                </widget>
+            </item>
+            <item row="2" column="0" colspan="2">
+                <widget class="QGroupBox" name="x_axis_box">
+                    <property name="title">
+                        <string>X Axis</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_4">
+                        <item row="5" column="0">
+                            <widget class="QLabel" name="x_grid_label">
+                                <property name="text">
+                                    <string>Grid</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="2">
+                            <widget class="ToggleSwitch" name="x_log">
+                                <property name="checked" stdset="0">
+                                    <bool>false</bool>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="x_max_label">
+                                <property name="text">
+                                    <string>Max</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="5" column="2">
+                            <widget class="ToggleSwitch" name="x_grid">
+                                <property name="checked" stdset="0">
+                                    <bool>false</bool>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="x_scale_label">
+                                <property name="text">
+                                    <string>Log</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0" colspan="2">
+                            <widget class="QLabel" name="x_min_label">
+                                <property name="text">
+                                    <string>Min</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="0">
+                            <widget class="QLabel" name="x_label_label">
+                                <property name="text">
+                                    <string>Label</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="0" column="2">
+                            <widget class="QLineEdit" name="x_label"/>
+                        </item>
+                        <item row="1" column="2">
+                            <widget class="BECSpinBox" name="x_min"/>
+                        </item>
+                        <item row="2" column="2">
+                            <widget class="BECSpinBox" name="x_max"/>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
             <item row="0" column="0" colspan="4">
                 <layout class="QHBoxLayout" name="horizontalLayout">
                     <item>
@@ -191,8 +181,41 @@
                     <item>
                         <widget class="QLineEdit" name="title"/>
                     </item>
+                    <item>
+                        <widget class="QLabel" name="label_2">
+                            <property name="text">
+                                <string>Precision</string>
+                            </property>
+                        </widget>
+                    </item>
+                    <item>
+                        <widget class="QSpinBox" name="minimal_crosshair_precision">
+                            <property name="toolTip">
+                                <string>Minimal Crosshair Precision</string>
+                            </property>
+                            <property name="alignment">
+                                <set>Qt::AlignmentFlag::AlignCenter</set>
+                            </property>
+                            <property name="maximum">
+                                <number>20</number>
+                            </property>
+                            <property name="value">
+                                <number>3</number>
+                            </property>
+                        </widget>
+                    </item>
                 </layout>
             </item>
+            <item row="1" column="2">
+                <widget class="QLabel" name="label_outer_axes">
+                    <property name="text">
+                        <string>Outer Axes</string>
+                    </property>
+                </widget>
+            </item>
+            <item row="1" column="1">
+                <widget class="ToggleSwitch" name="inner_axes"/>
+            </item>
         </layout>
     </widget>
     <customwidgets>

bec_widgets/widgets/plots/setting_menus/axis_settings_vertical.ui

@@ -6,15 +6,84 @@
             <rect>
                 <x>0</x>
                 <y>0</y>
-                <width>241</width>
-                <height>526</height>
+                <width>250</width>
+                <height>612</height>
             </rect>
         </property>
         <property name="windowTitle">
             <string>Form</string>
         </property>
-        <layout class="QGridLayout" name="gridLayout">
-            <item row="4" column="0" colspan="2">
+        <layout class="QVBoxLayout" name="verticalLayout">
+            <item>
+                <widget class="QGroupBox" name="general_box">
+                    <property name="title">
+                        <string>General</string>
+                    </property>
+                    <layout class="QGridLayout" name="gridLayout_2">
+                        <item row="4" column="0">
+                            <widget class="QLabel" name="label_outer_axes">
+                                <property name="text">
+                                    <string>Outer Axes</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="4" column="1">
+                            <widget class="ToggleSwitch" name="outer_axes">
+                                <property name="checked" stdset="0">
+                                    <bool>false</bool>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="1">
+                            <widget class="QLineEdit" name="title"/>
+                        </item>
+                        <item row="3" column="0">
+                            <widget class="QLabel" name="label">
+                                <property name="text">
+                                    <string>Inner Axes</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="1" column="0">
+                            <widget class="QLabel" name="plot_title_label">
+                                <property name="text">
+                                    <string>Plot Title</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="3" column="1">
+                            <widget class="ToggleSwitch" name="inner_axes"/>
+                        </item>
+                        <item row="2" column="0">
+                            <widget class="QLabel" name="label_2">
+                                <property name="toolTip">
+                                    <string>Minimal Crosshair Precision</string>
+                                </property>
+                                <property name="text">
+                                    <string>Precision</string>
+                                </property>
+                            </widget>
+                        </item>
+                        <item row="2" column="1">
+                            <widget class="QSpinBox" name="minimal_crosshair_precision">
+                                <property name="toolTip">
+                                    <string>Minimal Crosshair Precision</string>
+                                </property>
+                                <property name="alignment">
+                                    <set>Qt::AlignmentFlag::AlignCenter</set>
+                                </property>
+                                <property name="maximum">
+                                    <number>20</number>
+                                </property>
+                                <property name="value">
+                                    <number>3</number>
+                                </property>
+                            </widget>
+                        </item>
+                    </layout>
+                </widget>
+            </item>
+            <item>
                 <widget class="QGroupBox" name="x_axis_box">
                     <property name="title">
                         <string>X Axis</string>
@@ -81,28 +150,7 @@
                     </layout>
                 </widget>
             </item>
-            <item row="0" column="0" colspan="2">
-                <layout class="QHBoxLayout" name="horizontalLayout">
-                    <item>
-                        <widget class="QLabel" name="plot_title_label">
-                            <property name="text">
-                                <string>Plot Title</string>
-                            </property>
-                        </widget>
-                    </item>
-                    <item>
-                        <widget class="QLineEdit" name="title"/>
-                    </item>
-                </layout>
-            </item>
-            <item row="2" column="0">
-                <widget class="QLabel" name="label_outer_axes">
-                    <property name="text">
-                        <string>Outer Axes</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="5" column="0" colspan="2">
+            <item>
                 <widget class="QGroupBox" name="y_axis_box">
                     <property name="title">
                         <string>Y Axis</string>
@@ -169,23 +217,6 @@
                     </layout>
                 </widget>
             </item>
-            <item row="2" column="1">
-                <widget class="ToggleSwitch" name="outer_axes">
-                    <property name="checked" stdset="0">
-                        <bool>false</bool>
-                    </property>
-                </widget>
-            </item>
-            <item row="1" column="0">
-                <widget class="QLabel" name="label">
-                    <property name="text">
-                        <string>Inner Axes</string>
-                    </property>
-                </widget>
-            </item>
-            <item row="1" column="1">
-                <widget class="ToggleSwitch" name="inner_axes"/>
-            </item>
         </layout>
     </widget>
     <customwidgets>

bec_widgets/widgets/plots/toolbar_bundles/mouse_interactions.py

@@ -44,7 +44,7 @@ class MouseInteractionToolbarBundle(ToolbarBundle):
             initial_action="drag_mode",
             tooltip="Mouse Modes",
             checkable=True,
-            parent=self,
+            parent=self.target_widget,
         )
 
         # Add them to the bundle

bec_widgets/widgets/plots/waveform/settings/curve_settings/curve_tree.py

@@ -22,6 +22,7 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
+from bec_widgets import SafeSlot
 from bec_widgets.utils import ConnectionConfig, EntryValidator
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import Colors
@@ -154,7 +155,7 @@ class CurveRow(QTreeWidgetItem):
         """Create columns 3..6: color button, style combo, width spin, symbol spin."""
         # Color in col 3
         self.color_button = ColorButtonNative(color=self.config.color)
-        self.color_button.clicked.connect(lambda: self._select_color(self.color_button))
+        self.color_button.color_changed.connect(self._on_color_changed)
         self.tree.setItemWidget(self, 3, self.color_button)
 
         # Style in col 4
@@ -177,20 +178,16 @@ class CurveRow(QTreeWidgetItem):
         self.symbol_spin.setValue(self.config.symbol_size)
         self.tree.setItemWidget(self, 6, self.symbol_spin)
 
-    def _select_color(self, button):
+    @SafeSlot(str, verify_sender=True)
+    def _on_color_changed(self, new_color: str):
         """
-        Selects a new color using a color dialog and applies it to the specified button. Updates
-        related configuration properties based on the chosen color.
+        Update configuration when the color button emits a change.
 
         Args:
-            button: The button widget whose color is being modified.
+            new_color (str): The new color in hex format.
         """
-        current_color = QColor(button.color())
-        chosen_color = QColorDialog.getColor(current_color, self.tree, "Select Curve Color")
-        if chosen_color.isValid():
-            button.set_color(chosen_color)
-            self.config.color = chosen_color.name()
-            self.config.symbol_color = chosen_color.name()
+        self.config.color = new_color
+        self.config.symbol_color = new_color
 
     def add_dap_row(self):
         """Create a new DAP row as a child. Only valid if source='device'."""

bec_widgets/widgets/plots/waveform/waveform.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from typing import Literal
+from typing import Any, Literal
 
 import lmfit
 import numpy as np
@@ -9,8 +9,19 @@ import pyqtgraph as pg
 from bec_lib import bec_logger, messages
 from bec_lib.endpoints import MessageEndpoints
 from pydantic import Field, ValidationError, field_validator
-from qtpy.QtCore import QTimer, Signal
-from qtpy.QtWidgets import QApplication, QDialog, QHBoxLayout, QMainWindow, QVBoxLayout, QWidget
+from qtpy.QtCore import Qt, QTimer, Signal
+from qtpy.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QDialog,
+    QDialogButtonBox,
+    QDoubleSpinBox,
+    QHBoxLayout,
+    QLabel,
+    QMainWindow,
+    QVBoxLayout,
+    QWidget,
+)
 
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_signal_proxy import BECSignalProxy
@@ -33,6 +44,11 @@ class WaveformConfig(ConnectionConfig):
     color_palette: str | None = Field(
         "plasma", description="The color palette of the figure widget.", validate_default=True
     )
+    max_dataset_size_mb: float = Field(
+        10,
+        description="Maximum dataset size (in MB) permitted when fetching async data from history before prompting the user.",
+        validate_default=True,
+    )
 
     model_config: dict = {"validate_assignment": True}
     _validate_color_palette = field_validator("color_palette")(Colors.validate_color_map)
@@ -86,6 +102,8 @@ class Waveform(PlotBase):
         "y_log.setter",
         "legend_label_size",
         "legend_label_size.setter",
+        "minimal_crosshair_precision",
+        "minimal_crosshair_precision.setter",
         # Waveform Specific RPC Access
         "curves",
         "x_mode",
@@ -94,6 +112,12 @@ class Waveform(PlotBase):
         "x_entry.setter",
         "color_palette",
         "color_palette.setter",
+        "skip_large_dataset_warning",
+        "skip_large_dataset_warning.setter",
+        "skip_large_dataset_check",
+        "skip_large_dataset_check.setter",
+        "max_dataset_size_mb",
+        "max_dataset_size_mb.setter",
         "plot",
         "add_dap_curve",
         "remove_curve",
@@ -139,9 +163,10 @@ class Waveform(PlotBase):
         self._async_curves = []
         self._slice_index = None
         self._dap_curves = []
-        self._mode: Literal["none", "sync", "async", "mixed"] = "none"
+        self._mode = None
 
         # Scan data
+        self._scan_done = True  # means scan is not running
         self.old_scan_id = None
         self.scan_id = None
         self.scan_item = None
@@ -161,6 +186,10 @@ class Waveform(PlotBase):
         self._init_curve_dialog()
         self.curve_settings_dialog = None
 
+        # Large‑dataset guard
+        self._skip_large_dataset_warning = False  # session flag
+        self._skip_large_dataset_check = False  # per-plot flag, to skip the warning for this plot
+
         # Scan status update loop
         self.bec_dispatcher.connect_slot(self.on_scan_status, MessageEndpoints.scan_status())
         self.bec_dispatcher.connect_slot(self.on_scan_progress, MessageEndpoints.scan_progress())
@@ -414,6 +443,8 @@ class Waveform(PlotBase):
         """
         Slot for when the axis settings dialog is closed.
         """
+        self.dap_summary.close()
+        self.dap_summary.deleteLater()
         self.dap_summary_dialog.deleteLater()
         self.dap_summary_dialog = None
         self.toolbar.widgets["fit_params"].action.setChecked(False)
@@ -557,6 +588,59 @@ class Waveform(PlotBase):
         """
         return [item for item in self.plot_item.curves if isinstance(item, Curve)]
 
+    @SafeProperty(bool)
+    def skip_large_dataset_check(self) -> bool:
+        """
+        Whether to skip the large dataset warning when fetching async data.
+        """
+        return self._skip_large_dataset_check
+
+    @skip_large_dataset_check.setter
+    def skip_large_dataset_check(self, value: bool):
+        """
+        Set whether to skip the large dataset warning when fetching async data.
+
+        Args:
+            value(bool): Whether to skip the large dataset warning.
+        """
+        self._skip_large_dataset_check = value
+
+    @SafeProperty(bool)
+    def skip_large_dataset_warning(self) -> bool:
+        """
+        Whether to skip the large dataset warning when fetching async data.
+        """
+        return self._skip_large_dataset_warning
+
+    @skip_large_dataset_warning.setter
+    def skip_large_dataset_warning(self, value: bool):
+        """
+        Set whether to skip the large dataset warning when fetching async data.
+
+        Args:
+            value(bool): Whether to skip the large dataset warning.
+        """
+        self._skip_large_dataset_warning = value
+
+    @SafeProperty(float)
+    def max_dataset_size_mb(self) -> float:
+        """
+        The maximum dataset size (in MB) permitted when fetching async data from history before prompting the user.
+        """
+        return self.config.max_dataset_size_mb
+
+    @max_dataset_size_mb.setter
+    def max_dataset_size_mb(self, value: float):
+        """
+        Set the maximum dataset size (in MB) permitted when fetching async data from history before prompting the user.
+
+        Args:
+            value(float): The maximum dataset size in MB.
+        """
+        if value <= 0:
+            raise ValueError("Maximum dataset size must be greater than 0.")
+        self.config.max_dataset_size_mb = value
+
     ################################################################################
     # High Level methods for API
     ################################################################################
@@ -803,8 +887,6 @@ class Waveform(PlotBase):
         if config.source == "device":
             if self.scan_item is None:
                 self.update_with_scan_history(-1)
-            if curve in self._async_curves:
-                self._setup_async_curve(curve)
             self.async_signal_update.emit()
             self.sync_signal_update.emit()
         if config.source == "dap":
@@ -1052,12 +1134,12 @@ class Waveform(PlotBase):
             meta(dict): The message metadata.
         """
         self.sync_signal_update.emit()
-        status = msg.get("done")
-        if status:
+        self._scan_done = msg.get("done")
+        if self._scan_done:
             QTimer.singleShot(100, self.update_sync_curves)
             QTimer.singleShot(300, self.update_sync_curves)
 
-    def _fetch_scan_data_and_access(self):
+    def _fetch_scan_data_and_access(self) -> tuple[dict, str] | tuple[None, None]:
         """
         Decide whether the widget is in live or historical mode
         and return the appropriate data dict and access key.
@@ -1071,7 +1153,7 @@ class Waveform(PlotBase):
             self.update_with_scan_history(-1)
             if self.scan_item is None:
                 logger.info("No scan executed so far; skipping device curves categorisation.")
-                return "none", "none"
+                return None, None
 
         if hasattr(self.scan_item, "live_data"):
             # Live scan
@@ -1087,7 +1169,7 @@ class Waveform(PlotBase):
         """
         if self.scan_item is None:
             logger.info("No scan executed so far; skipping device curves categorisation.")
-            return "none"
+            return
         data, access_key = self._fetch_scan_data_and_access()
         for curve in self._sync_curves:
             device_name = curve.config.signal.name
@@ -1095,9 +1177,8 @@ class Waveform(PlotBase):
             if access_key == "val":
                 device_data = data.get(device_name, {}).get(device_entry, {}).get(access_key, None)
             else:
-                device_data = (
-                    data.get(device_name, {}).get(device_entry, {}).read().get("value", None)
-                )
+                entry_obj = data.get(device_name, {}).get(device_entry)
+                device_data = entry_obj.read()["value"] if entry_obj else None
             x_data = self._get_x_data(device_name, device_entry)
             if x_data is not None:
                 if len(x_data) == 1:
@@ -1131,9 +1212,12 @@ class Waveform(PlotBase):
             if access_key == "val":  # live access
                 device_data = data.get(device_name, {}).get(device_entry, {}).get(access_key, None)
             else:  # history access
-                device_data = (
-                    data.get(device_name, {}).get(device_entry, {}).read().get("value", None)
-                )
+                dataset_obj = data.get(device_name, {})
+                if self._skip_large_dataset_check is False:
+                    if not self._check_dataset_size_and_confirm(dataset_obj, device_entry):
+                        continue  # user declined to load; skip this curve
+                entry_obj = dataset_obj.get(device_entry, None)
+                device_data = entry_obj.read()["value"] if entry_obj else None
 
             # if shape is 2D cast it into 1D and take the last waveform
             if len(np.shape(device_data)) > 1:
@@ -1162,6 +1246,23 @@ class Waveform(PlotBase):
 
         self.request_dap_update.emit()
 
+    def _check_async_signal_found(self, name: str, signal: str) -> bool:
+        """
+        Check if the async signal is found in the BEC device manager.
+
+        Args:
+            name(str): The name of the async signal.
+            signal(str): The entry of the async signal.
+
+        Returns:
+            bool: True if the async signal is found, False otherwise.
+        """
+        bec_async_signals = self.client.device_manager.get_bec_signals("AsyncSignal")
+        for entry_name, _, entry_data in bec_async_signals:
+            if entry_name == name and entry_data.get("obj_name") == signal:
+                return True
+        return False
+
     def _setup_async_curve(self, curve: Curve):
         """
         Setup async curve.
@@ -1170,20 +1271,40 @@ class Waveform(PlotBase):
             curve(Curve): The curve to set up.
         """
         name = curve.config.signal.name
-        self.bec_dispatcher.disconnect_slot(
-            self.on_async_readback, MessageEndpoints.device_async_readback(self.old_scan_id, name)
-        )
+        signal = curve.config.signal.entry
+        async_signal_found = self._check_async_signal_found(name, signal)
+
         try:
             curve.clear_data()
         except KeyError:
             logger.warning(f"Curve {name} not found in plot item.")
             pass
-        self.bec_dispatcher.connect_slot(
-            self.on_async_readback,
-            MessageEndpoints.device_async_readback(self.scan_id, name),
-            from_start=True,
-            cb_info={"scan_id": self.scan_id},
-        )
+
+        # New endpoint for async signals
+        if async_signal_found:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_async_readback,
+                MessageEndpoints.device_async_signal(self.old_scan_id, name, signal),
+            )
+            self.bec_dispatcher.connect_slot(
+                self.on_async_readback,
+                MessageEndpoints.device_async_signal(self.scan_id, name, signal),
+                from_start=True,
+                cb_info={"scan_id": self.scan_id},
+            )
+
+        # old endpoint
+        else:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_async_readback,
+                MessageEndpoints.device_async_readback(self.old_scan_id, name),
+            )
+            self.bec_dispatcher.connect_slot(
+                self.on_async_readback,
+                MessageEndpoints.device_async_readback(self.scan_id, name),
+                from_start=True,
+                cb_info={"scan_id": self.scan_id},
+            )
         logger.info(f"Setup async curve {name}")
 
     @SafeSlot(dict, dict, verify_sender=True)
@@ -1465,29 +1586,35 @@ class Waveform(PlotBase):
             if access_key == "val":  # live data
                 x_data = data.get(x_name, {}).get(x_entry, {}).get(access_key, [0])
             else:  # history data
-                x_data = data.get(x_name, {}).get(x_entry, {}).read().get("value", [0])
-            new_suffix = f" [custom: {x_name}-{x_entry}]"
+                entry_obj = data.get(x_name, {}).get(x_entry)
+                x_data = entry_obj.read()["value"] if entry_obj else [0]
+            new_suffix = f" (custom: {x_name}-{x_entry})"
 
         # 2 User wants timestamp
         if self.x_axis_mode["name"] == "timestamp":
             if access_key == "val":  # live
-                timestamps = data[device_name][device_entry].timestamps
+                x_data = data.get(device_name, {}).get(device_entry, None)
+                if x_data is None:
+                    return None
+                else:
+                    timestamps = x_data.timestamps
             else:  # history data
-                timestamps = data[device_name][device_entry].read().get("timestamp", [0])
+                entry_obj = data.get(device_name, {}).get(device_entry)
+                timestamps = entry_obj.read()["timestamp"] if entry_obj else [0]
             x_data = timestamps
-            new_suffix = " [timestamp]"
+            new_suffix = " (timestamp)"
 
         # 3 User wants index
         if self.x_axis_mode["name"] == "index":
             x_data = None
-            new_suffix = " [index]"
+            new_suffix = " (index)"
 
         # 4 Best effort automatic mode
         if self.x_axis_mode["name"] is None or self.x_axis_mode["name"] == "auto":
             # 4.1 If there are async curves, use index
             if len(self._async_curves) > 0:
                 x_data = None
-                new_suffix = " [auto: index]"
+                new_suffix = " (auto: index)"
             # 4.2 If there are sync curves, use the first device from the scan report
             else:
                 try:
@@ -1500,8 +1627,9 @@ class Waveform(PlotBase):
                 if access_key == "val":
                     x_data = data.get(x_name, {}).get(x_entry, {}).get(access_key, None)
                 else:
-                    x_data = data.get(x_name, {}).get(x_entry, {}).read().get("value", None)
-                new_suffix = f" [auto: {x_name}-{x_entry}]"
+                    entry_obj = data.get(x_name, {}).get(x_entry)
+                    x_data = entry_obj.read()["value"] if entry_obj else None
+                new_suffix = f" (auto: {x_name}-{x_entry})"
         self._update_x_label_suffix(new_suffix)
         return x_data
 
@@ -1553,7 +1681,7 @@ class Waveform(PlotBase):
             self.update_with_scan_history(-1)
             if self.scan_item is None:
                 logger.info("No scan executed so far; skipping device curves categorisation.")
-                return "none"
+                return None
 
         if hasattr(self.scan_item, "live_data"):
             readout_priority = self.scan_item.status_message.info["readout_priority"]  # live data
@@ -1577,6 +1705,8 @@ class Waveform(PlotBase):
             dev_name = curve.config.signal.name
             if dev_name in readout_priority_async:
                 self._async_curves.append(curve)
+                if hasattr(self.scan_item, "live_data"):
+                    self._setup_async_curve(curve)
                 found_async = True
             elif dev_name in readout_priority_sync:
                 self._sync_curves.append(curve)
@@ -1653,6 +1783,106 @@ class Waveform(PlotBase):
     ################################################################################
     # Utility Methods
     ################################################################################
+
+    # Large dataset handling helpers
+    def _check_dataset_size_and_confirm(self, dataset_obj, device_entry: str) -> bool:
+        """
+        Check the size of the dataset and confirm with the user if it exceeds the limit.
+
+        Args:
+            dataset_obj: The dataset object containing the information.
+            device_entry( str): The specific device entry to check.
+
+        Returns:
+            bool: True if the dataset is within the size limit or user confirmed to load it,
+                  False if the dataset exceeds the size limit and user declined to load it.
+        """
+        try:
+            info = dataset_obj._info
+            mem_bytes = info.get(device_entry, {}).get("value", {}).get("mem_size", 0)
+            # Fallback – grab first entry if lookup failed
+            if mem_bytes == 0 and info:
+                first_key = next(iter(info))
+                mem_bytes = info[first_key]["value"]["mem_size"]
+            size_mb = mem_bytes / (1024 * 1024)
+            print(f"Dataset size: {size_mb:.1f} MB")
+        except Exception as exc:  # noqa: BLE001
+            logger.error(f"Unable to evaluate dataset size: {exc}")
+            return True
+
+        if size_mb <= self.config.max_dataset_size_mb:
+            return True
+        logger.warning(
+            f"Attempt to load large dataset: {size_mb:.1f} MB "
+            f"(limit {self.config.max_dataset_size_mb} MB)"
+        )
+        if self._skip_large_dataset_warning:
+            logger.info("Skipping large dataset warning dialog.")
+            return False
+        return self._confirm_large_dataset(size_mb)
+
+    def _confirm_large_dataset(self, size_mb: float) -> bool:
+        """
+        Confirm with the user whether to load a large dataset with dialog popup.
+        Also allows the user to adjust the maximum dataset size limit and if user
+        wants to see this popup again during session.
+
+        Args:
+            size_mb(float): Size of the dataset in MB.
+
+        Returns:
+            bool: True if the user confirmed to load the dataset, False otherwise.
+        """
+        if self._skip_large_dataset_warning:
+            return True
+
+        dialog = QDialog(self)
+        dialog.setWindowTitle("Large dataset detected")
+        main_dialog_layout = QVBoxLayout(dialog)
+
+        # Limit adjustment widgets
+        limit_adjustment_layout = QHBoxLayout()
+        limit_adjustment_layout.addWidget(QLabel("New limit (MB):"))
+        spin = QDoubleSpinBox()
+        spin.setRange(0.001, 4096)
+        spin.setDecimals(3)
+        spin.setSingleStep(0.01)
+        spin.setValue(self.config.max_dataset_size_mb)
+        spin.valueChanged.connect(lambda value: setattr(self.config, "max_dataset_size_mb", value))
+        limit_adjustment_layout.addWidget(spin)
+
+        # Don't show again checkbox
+        checkbox = QCheckBox("Don't show this again for this session")
+
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.Yes | QDialogButtonBox.No, Qt.Horizontal, dialog
+        )
+        buttons.accepted.connect(dialog.accept)  # Yes
+        buttons.rejected.connect(dialog.reject)  # No
+
+        # widget layout
+        main_dialog_layout.addWidget(
+            QLabel(
+                f"The selected dataset is {size_mb:.1f} MB which exceeds the "
+                f"current limit of {self.config.max_dataset_size_mb} MB.\n"
+            )
+        )
+        main_dialog_layout.addLayout(limit_adjustment_layout)
+        main_dialog_layout.addWidget(checkbox)
+        main_dialog_layout.addWidget(QLabel("Would you like to display dataset anyway?"))
+        main_dialog_layout.addWidget(buttons)
+
+        result = dialog.exec()  # modal; waits for user choice
+
+        # Respect the “don't show again” checkbox for *either* choice
+        if checkbox.isChecked():
+            self._skip_large_dataset_warning = True
+
+        if result == QDialog.Accepted:
+            self.config.max_dataset_size_mb = spin.value()
+            return True
+        return False
+
     def _ensure_str_list(self, entries: list | tuple | np.ndarray):
         """
         Convert a variety of possible inputs (string, bytes, list/tuple/ndarray of either)
@@ -1783,7 +2013,7 @@ class DemoApp(QMainWindow):  # pragma: no cover
         self.setCentralWidget(self.main_widget)
 
         self.waveform_popup = Waveform(popups=True)
-        self.waveform_popup.plot(y_name="monitor_async")
+        self.waveform_popup.plot(y_name="waveform")
 
         self.waveform_side = Waveform(popups=False)
         self.waveform_side.plot(y_name="bpm4i", y_entry="bpm4i", dap="GaussianModel")

bec_widgets/widgets/services/device_browser/device_browser.py

@@ -1,15 +1,22 @@
 import os
 import re
-from typing import Optional
+from functools import partial
 
 from bec_lib.callback_handler import EventType
+from bec_lib.logger import bec_logger
+from bec_lib.messages import ConfigAction
 from pyqtgraph import SignalProxy
-from qtpy.QtCore import Signal, Slot
-from qtpy.QtWidgets import QListWidgetItem, QVBoxLayout, QWidget
+from qtpy.QtCore import QSize, Signal
+from qtpy.QtWidgets import QListWidget, QListWidgetItem, QVBoxLayout, QWidget
 
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.ui_loader import UILoader
 from bec_widgets.widgets.services.device_browser.device_item import DeviceItem
+from bec_widgets.widgets.services.device_browser.util import map_device_type_to_icon
+
+logger = bec_logger.logger
 
 
 class DeviceBrowser(BECWidget, QWidget):
@@ -23,18 +30,18 @@ class DeviceBrowser(BECWidget, QWidget):
 
     def __init__(
         self,
-        parent: Optional[QWidget] = None,
+        parent: QWidget | None = None,
         config=None,
         client=None,
-        gui_id: Optional[str] = None,
+        gui_id: str | None = None,
         **kwargs,
     ) -> None:
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
-
         self.get_bec_shortcuts()
         self.ui = None
         self.ini_ui()
-
+        self.dev_list: QListWidget = self.ui.device_list
+        self.dev_list.setVerticalScrollMode(QListWidget.ScrollMode.ScrollPerPixel)
         self.proxy_device_update = SignalProxy(
             self.ui.filter_input.textChanged, rateLimit=500, slot=self.update_device_list
         )
@@ -43,6 +50,7 @@ class DeviceBrowser(BECWidget, QWidget):
         )
         self.device_update.connect(self.update_device_list)
 
+        self.init_device_list()
         self.update_device_list()
 
     def ini_ui(self) -> None:
@@ -50,14 +58,12 @@ class DeviceBrowser(BECWidget, QWidget):
         Initialize the UI by loading the UI file and setting the layout.
         """
         layout = QVBoxLayout()
-        layout.setContentsMargins(0, 0, 0, 0)
-
         ui_file_path = os.path.join(os.path.dirname(__file__), "device_browser.ui")
         self.ui = UILoader(self).loader(ui_file_path)
         layout.addWidget(self.ui)
         self.setLayout(layout)
 
-    def on_device_update(self, action: str, content: dict) -> None:
+    def on_device_update(self, action: ConfigAction, content: dict) -> None:
         """
         Callback for device update events. Triggers the device_update signal.
 
@@ -68,8 +74,42 @@ class DeviceBrowser(BECWidget, QWidget):
         if action in ["add", "remove", "reload"]:
             self.device_update.emit()
 
-    @Slot()
-    def update_device_list(self) -> None:
+    def init_device_list(self):
+        self.dev_list.clear()
+        self._device_items: dict[str, QListWidgetItem] = {}
+
+        def _updatesize(item: QListWidgetItem, device_item: DeviceItem):
+            device_item.adjustSize()
+            item.setSizeHint(QSize(device_item.width(), device_item.height()))
+            logger.debug(f"Adjusting {item} size to {device_item.width(), device_item.height()}")
+
+        with RPCRegister.delayed_broadcast():
+            for device, device_obj in self.dev.items():
+                item = QListWidgetItem(self.dev_list)
+                device_item = DeviceItem(
+                    parent=self,
+                    device=device,
+                    devices=self.dev,
+                    icon=map_device_type_to_icon(device_obj),
+                )
+                device_item.expansion_state_changed.connect(partial(_updatesize, item, device_item))
+                tooltip = self.dev[device]._config.get("description", "")
+                device_item.setToolTip(tooltip)
+                device_item.broadcast_size_hint.connect(item.setSizeHint)
+                item.setSizeHint(device_item.sizeHint())
+
+                self.dev_list.setItemWidget(item, device_item)
+                self.dev_list.addItem(item)
+                self._device_items[device] = item
+
+    @SafeSlot()
+    def reset_device_list(self) -> None:
+        self.init_device_list()
+        self.update_device_list()
+
+    @SafeSlot()
+    @SafeSlot(str)
+    def update_device_list(self, *_) -> None:
         """
         Update the device list based on the filter input.
         There are two ways to trigger this function:
@@ -80,23 +120,14 @@ class DeviceBrowser(BECWidget, QWidget):
         """
         filter_text = self.ui.filter_input.text()
         try:
-            regex = re.compile(filter_text, re.IGNORECASE)
+            self.regex = re.compile(filter_text, re.IGNORECASE)
         except re.error:
-            regex = None  # Invalid regex, disable filtering
-
-        dev_list = self.ui.device_list
-        dev_list.clear()
+            self.regex = None  # Invalid regex, disable filtering
+            for device in self.dev:
+                self._device_items[device].setHidden(False)
+            return
         for device in self.dev:
-            if regex is None or regex.search(device):
-                item = QListWidgetItem(dev_list)
-                device_item = DeviceItem(device)
-
-                # pylint: disable=protected-access
-                tooltip = self.dev[device]._config.get("description", "")
-                device_item.setToolTip(tooltip)
-                item.setSizeHint(device_item.sizeHint())
-                dev_list.setItemWidget(item, device_item)
-                dev_list.addItem(item)
+            self._device_items[device].setHidden(not self.regex.search(device))
 
 
 if __name__ == "__main__":  # pragma: no cover
@@ -104,10 +135,10 @@ if __name__ == "__main__":  # pragma: no cover
 
     from qtpy.QtWidgets import QApplication
 
-    from bec_widgets.utils.colors import apply_theme
+    from bec_widgets.utils.colors import set_theme
 
     app = QApplication(sys.argv)
-    apply_theme("light")
+    set_theme("light")
     widget = DeviceBrowser()
     widget.show()
     sys.exit(app.exec_())

bec_widgets/widgets/services/device_browser/device_item/device_config_dialog.py

@@ -0,0 +1,254 @@
+from ast import literal_eval
+
+from bec_lib.atlas_models import Device as DeviceConfigModel
+from bec_lib.config_helper import CONF as DEVICE_CONF_KEYS
+from bec_lib.config_helper import ConfigHelper
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QObject, QRunnable, QSize, Qt, QThreadPool, Signal
+from qtpy.QtWidgets import (
+    QApplication,
+    QDialog,
+    QDialogButtonBox,
+    QLabel,
+    QStackedLayout,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.services.device_browser.device_item.device_config_form import (
+    DeviceConfigForm,
+)
+from bec_widgets.widgets.utility.spinner.spinner import SpinnerWidget
+
+logger = bec_logger.logger
+
+
+class _CommSignals(QObject):
+    error = Signal(Exception)
+    done = Signal()
+
+
+class _CommunicateUpdate(QRunnable):
+
+    def __init__(self, config_helper: ConfigHelper, device: str, config: dict) -> None:
+        super().__init__()
+        self.config_helper = config_helper
+        self.device = device
+        self.config = config
+        self.signals = _CommSignals()
+
+    @SafeSlot()
+    def run(self):
+        try:
+            timeout = self.config_helper.suggested_timeout_s(self.config)
+            RID = self.config_helper.send_config_request(
+                action="update", config={self.device: self.config}, wait_for_response=False
+            )
+            logger.info("Waiting for config reply")
+            reply = self.config_helper.wait_for_config_reply(RID, timeout=timeout)
+            self.config_helper.handle_update_reply(reply, RID, timeout)
+            logger.info("Done updating config!")
+        except Exception as e:
+            self.signals.error.emit(e)
+        finally:
+            self.signals.done.emit()
+
+
+class DeviceConfigDialog(BECWidget, QDialog):
+    RPC = False
+    applied = Signal()
+
+    def __init__(
+        self,
+        parent=None,
+        device: str | None = None,
+        config_helper: ConfigHelper | None = None,
+        **kwargs,
+    ):
+        super().__init__(parent=parent, **kwargs)
+        self._config_helper = config_helper or ConfigHelper(
+            self.client.connector, self.client._service_name
+        )
+        self.threadpool = QThreadPool()
+        self._device = device
+        self.setWindowTitle(f"Edit config for: {device}")
+        self._container = QStackedLayout()
+        self._container.setStackingMode(QStackedLayout.StackAll)
+
+        self._layout = QVBoxLayout()
+        user_warning = QLabel(
+            "Warning: edit items here at your own risk - minimal validation is applied to the entered values.\n"
+            "Items in the deviceConfig dictionary should correspond to python literals, e.g. numbers, lists, strings (including quotes), etc."
+        )
+        user_warning.setWordWrap(True)
+        user_warning.setStyleSheet("QLabel { color: red; }")
+        self._layout.addWidget(user_warning)
+        self._add_form()
+        self._add_overlay()
+        self._add_buttons()
+
+        self.setLayout(self._container)
+        self._overlay_widget.setVisible(False)
+
+    def _add_form(self):
+        self._form_widget = QWidget()
+        self._form_widget.setLayout(self._layout)
+        self._form = DeviceConfigForm()
+        self._layout.addWidget(self._form)
+
+        for row in self._form.enumerate_form_widgets():
+            if row.label.property("_model_field_name") in DEVICE_CONF_KEYS.NON_UPDATABLE:
+                row.widget._set_pretty_display()
+
+        self._fetch_config()
+        self._fill_form()
+        self._container.addWidget(self._form_widget)
+
+    def _add_overlay(self):
+        self._overlay_widget = QWidget()
+        self._overlay_widget.setStyleSheet("background-color:rgba(128,128,128,128);")
+        self._overlay_widget.setAutoFillBackground(True)
+        self._overlay_layout = QVBoxLayout()
+        self._overlay_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self._overlay_widget.setLayout(self._overlay_layout)
+
+        self._spinner = SpinnerWidget(parent=self)
+        self._spinner.setMinimumSize(QSize(100, 100))
+        self._overlay_layout.addWidget(self._spinner)
+        self._container.addWidget(self._overlay_widget)
+
+    def _add_buttons(self):
+        button_box = QDialogButtonBox(
+            QDialogButtonBox.Apply | QDialogButtonBox.Ok | QDialogButtonBox.Cancel
+        )
+        button_box.button(QDialogButtonBox.Apply).clicked.connect(self.apply)
+        button_box.accepted.connect(self.accept)
+        button_box.rejected.connect(self.reject)
+        self._layout.addWidget(button_box)
+
+    def _fetch_config(self):
+        self._initial_config = {}
+        if (
+            self.client.device_manager is not None
+            and self._device in self.client.device_manager.devices
+        ):
+            self._initial_config = self.client.device_manager.devices.get(self._device)._config
+
+    def _fill_form(self):
+        self._form.set_data(DeviceConfigModel.model_validate(self._initial_config))
+
+    def updated_config(self):
+        new_config = self._form.get_form_data()
+        diff = {
+            k: v for k, v in new_config.items() if self._initial_config.get(k) != new_config.get(k)
+        }
+        if diff.get("deviceConfig") is not None:
+            # TODO: special cased in some parts of device manager but not others, should
+            # be removed in config update as with below issue
+            diff["deviceConfig"].pop("device_access", None)
+            # TODO: replace when https://github.com/bec-project/bec/issues/528 is resolved
+            diff["deviceConfig"] = {
+                k: literal_eval(str(v)) for k, v in diff["deviceConfig"].items()
+            }
+        return diff
+
+    @SafeSlot()
+    def apply(self):
+        self._process_update_action()
+        self.applied.emit()
+
+    @SafeSlot()
+    def accept(self):
+        self._process_update_action()
+        return super().accept()
+
+    def _process_update_action(self):
+        updated_config = self.updated_config()
+        if (device_name := updated_config.get("name")) == "":
+            logger.warning("Can't create a device with no name!")
+        elif set(updated_config.keys()) & set(DEVICE_CONF_KEYS.NON_UPDATABLE):
+            logger.info(
+                f"Removing old device {self._device} and adding new device {device_name or self._device} with modified config: {updated_config}"
+            )
+        else:
+            self._update_device_config(updated_config)
+
+    def _update_device_config(self, config: dict):
+        if self._device is None:
+            return
+        if config == {}:
+            logger.info("No changes made to device config")
+            return
+        logger.info(f"Sending request to update device config: {config}")
+
+        self._start_waiting_display()
+        communicate_update = _CommunicateUpdate(self._config_helper, self._device, config)
+        communicate_update.signals.error.connect(self.update_error)
+        communicate_update.signals.done.connect(self.update_done)
+        self.threadpool.start(communicate_update)
+
+    @SafeSlot()
+    def update_done(self):
+        self._stop_waiting_display()
+        self._fetch_config()
+        self._fill_form()
+
+    @SafeSlot(Exception, popup_error=True)
+    def update_error(self, e: Exception):
+        raise RuntimeError("Failed to update device configuration") from e
+
+    def _start_waiting_display(self):
+        self._overlay_widget.setVisible(True)
+        self._spinner.start()
+        QApplication.processEvents()
+
+    def _stop_waiting_display(self):
+        self._overlay_widget.setVisible(False)
+        self._spinner.stop()
+        QApplication.processEvents()
+
+
+def main():  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication, QLineEdit, QPushButton, QWidget
+
+    from bec_widgets.utils.colors import set_theme
+
+    dialog = None
+
+    app = QApplication(sys.argv)
+    set_theme("light")
+    widget = QWidget()
+    widget.setLayout(QVBoxLayout())
+
+    device = QLineEdit()
+    widget.layout().addWidget(device)
+
+    def _destroy_dialog(*_):
+        nonlocal dialog
+        dialog = None
+
+    def accept(*args):
+        logger.success(f"submitted device config form {dialog} {args}")
+        _destroy_dialog()
+
+    def _show_dialog(*_):
+        nonlocal dialog
+        if dialog is None:
+            dialog = DeviceConfigDialog(device=device.text())
+            dialog.accepted.connect(accept)
+            dialog.rejected.connect(_destroy_dialog)
+            dialog.open()
+
+    button = QPushButton("Show device dialog")
+    widget.layout().addWidget(button)
+    button.clicked.connect(_show_dialog)
+    widget.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == "__main__":
+    main()

bec_widgets/widgets/services/device_browser/device_item/device_config_form.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from bec_lib.atlas_models import Device as DeviceConfigModel
+from pydantic import BaseModel
+from qtpy.QtWidgets import QApplication
+
+from bec_widgets.utils.colors import get_theme_name
+from bec_widgets.utils.forms_from_types import styles
+from bec_widgets.utils.forms_from_types.forms import PydanticModelForm
+from bec_widgets.utils.forms_from_types.items import (
+    DEFAULT_WIDGET_TYPES,
+    BoolFormItem,
+    BoolToggleFormItem,
+)
+
+
+class DeviceConfigForm(PydanticModelForm):
+    RPC = False
+    PLUGIN = False
+
+    def __init__(self, parent=None, client=None, pretty_display=False, **kwargs):
+        super().__init__(
+            parent=parent,
+            data_model=DeviceConfigModel,
+            pretty_display=pretty_display,
+            client=client,
+            **kwargs,
+        )
+        self._widget_types = DEFAULT_WIDGET_TYPES.copy()
+        self._widget_types["bool"] = (lambda spec: spec.item_type is bool, BoolToggleFormItem)
+        self._widget_types["optional_bool"] = (
+            lambda spec: spec.item_type == bool | None,
+            BoolFormItem,
+        )
+        self._validity.setVisible(False)
+        self._connect_to_theme_change()
+        self.populate()
+
+    def _post_init(self): ...
+
+    def set_pretty_display_theme(self, theme: str | None = None):
+        if theme is None:
+            theme = get_theme_name()
+        self.setStyleSheet(styles.pretty_display_theme(theme))
+
+    def get_form_data(self):
+        """Get the entered metadata as a dict."""
+        return self._md_schema.model_validate(super().get_form_data()).model_dump()
+
+    def _connect_to_theme_change(self):
+        """Connect to the theme change signal."""
+        qapp = QApplication.instance()
+        if hasattr(qapp, "theme_signal"):
+            qapp.theme_signal.theme_updated.connect(self.set_pretty_display_theme)  # type: ignore
+
+    def set_schema(self, schema: type[BaseModel]):
+        raise TypeError("This class doesn't support changing the schema")
+
+    def set_data(self, data: DeviceConfigModel):  # type: ignore # This class locks the type
+        super().set_data(data)

bec_widgets/widgets/services/device_browser/device_item/device_item.py

@@ -2,37 +2,90 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from bec_lib.atlas_models import Device as DeviceConfigModel
+from bec_lib.devicemanager import DeviceContainer
 from bec_lib.logger import bec_logger
-from qtpy.QtCore import QMimeData, Qt
+from bec_qthemes import material_icon
+from qtpy.QtCore import QMimeData, QSize, Qt, Signal
 from qtpy.QtGui import QDrag
-from qtpy.QtWidgets import QApplication, QHBoxLayout, QLabel, QWidget
+from qtpy.QtWidgets import QApplication, QHBoxLayout, QToolButton, QWidget
+
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.expandable_frame import ExpandableGroupFrame
+from bec_widgets.widgets.services.device_browser.device_item.device_config_dialog import (
+    DeviceConfigDialog,
+)
+from bec_widgets.widgets.services.device_browser.device_item.device_config_form import (
+    DeviceConfigForm,
+)
 
 if TYPE_CHECKING:  # pragma: no cover
     from qtpy.QtGui import QMouseEvent
 
+
 logger = bec_logger.logger
 
 
-class DeviceItem(QWidget):
-    def __init__(self, device: str) -> None:
-        super().__init__()
+class DeviceItem(ExpandableGroupFrame):
+    broadcast_size_hint = Signal(QSize)
 
+    RPC = False
+
+    def __init__(self, parent, device: str, devices: DeviceContainer, icon: str = "") -> None:
+        super().__init__(parent, title=device, expanded=False, icon=icon)
+        self.dev = devices
         self._drag_pos = None
-
+        self._expanded_first_time = False
+        self._data = None
         self.device = device
         layout = QHBoxLayout()
-        layout.setContentsMargins(10, 2, 10, 2)
-        self.label = QLabel(device)
-        layout.addWidget(self.label)
-        self.setLayout(layout)
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.set_layout(layout)
 
-        self.setStyleSheet(
-            """
-            border: 1px solid #ddd;
-            border-radius: 5px;
-            padding: 10px;
-        """
+        self.adjustSize()
+
+    def _create_title_layout(self, title: str, icon: str):
+        super()._create_title_layout(title, icon)
+        self.edit_button = QToolButton()
+        self.edit_button.setIcon(
+            material_icon(icon_name="edit", size=(10, 10), convert_to_pixmap=False)
         )
+        self._title_layout.insertWidget(self._title_layout.count() - 1, self.edit_button)
+        self.edit_button.clicked.connect(self._create_edit_dialog)
+
+    def _create_edit_dialog(self):
+        dialog = DeviceConfigDialog(parent=self, device=self.device)
+        dialog.accepted.connect(self._reload_config)
+        dialog.applied.connect(self._reload_config)
+        dialog.open()
+
+    @SafeSlot()
+    def switch_expanded_state(self):
+        if not self.expanded and not self._expanded_first_time:
+            self._expanded_first_time = True
+            self.form = DeviceConfigForm(parent=self, pretty_display=True)
+            self._contents.layout().addWidget(self.form)
+            self._reload_config()
+            self.broadcast_size_hint.emit(self.sizeHint())
+        super().switch_expanded_state()
+        if self._expanded_first_time:
+            self.form.adjustSize()
+            self.updateGeometry()
+            if self._expanded:
+                self.form.set_pretty_display_theme()
+        self.adjustSize()
+        self.broadcast_size_hint.emit(self.sizeHint())
+
+    @SafeSlot(popup_error=True)
+    def _reload_config(self, *_):
+        self.set_display_config(self.dev[self.device]._config)
+
+    def set_display_config(self, config_dict: dict):
+        """Set the displayed information from a device config dict, which must conform to the
+        bec_lib.atlas_models.Device config model."""
+        self._data = DeviceConfigModel.model_validate(config_dict)
+        if self._expanded_first_time:
+            self.form.set_data(self._data)
 
     def mousePressEvent(self, event: QMouseEvent) -> None:
         super().mousePressEvent(event)
@@ -59,10 +112,33 @@ class DeviceItem(QWidget):
 
 if __name__ == "__main__":  # pragma: no cover
     import sys
+    from unittest.mock import MagicMock
 
     from qtpy.QtWidgets import QApplication
 
+    from bec_widgets.widgets.services.device_browser.device_item.device_config_form import (
+        DeviceConfigForm,
+    )
+    from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+
     app = QApplication(sys.argv)
-    widget = DeviceItem("Device")
+    widget = QWidget()
+    layout = QHBoxLayout()
+    widget.setLayout(layout)
+    mock_config = {
+        "name": "Test Device",
+        "enabled": True,
+        "deviceClass": "FakeDeviceClass",
+        "deviceConfig": {"kwarg1": "value1"},
+        "readoutPriority": "baseline",
+        "description": "A device for testing out a widget",
+        "readOnly": True,
+        "softwareTrigger": False,
+        "deviceTags": {"tag1", "tag2", "tag3"},
+        "userParameter": {"some_setting": "some_ value"},
+    }
+    item = DeviceItem(widget, "Device", {"Device": MagicMock(enabled=True, _config=mock_config)})
+    layout.addWidget(DarkModeButton())
+    layout.addWidget(item)
     widget.show()
     sys.exit(app.exec_())

bec_widgets/widgets/services/device_browser/util.py

@@ -0,0 +1,11 @@
+from bec_lib.device import Device
+
+
+def map_device_type_to_icon(device_obj: Device) -> str:
+    """Associate device types with material icon names"""
+    match device_obj._info.get("device_base_class", "").lower():
+        case "positioner":
+            return "precision_manufacturing"
+        case "signal":
+            return "vital_signs"
+    return "deployed_code"

bec_widgets/widgets/utility/logpanel/logpanel.py

@@ -11,12 +11,11 @@ from re import Pattern
 from typing import TYPE_CHECKING, Literal
 
 from bec_lib.client import BECClient
-from bec_lib.connector import ConnectorBase
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import LogLevel, bec_logger
 from bec_lib.messages import LogMessage, StatusMessage
-from PySide6.QtCore import QObject
-from qtpy.QtCore import QDateTime, Qt, Signal
+from pyqtgraph import SignalProxy
+from qtpy.QtCore import QDateTime, QObject, Qt, Signal
 from qtpy.QtGui import QFont
 from qtpy.QtWidgets import (
     QApplication,
@@ -35,6 +34,7 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
+from bec_widgets.utils.bec_connector import BECConnector
 from bec_widgets.utils.colors import get_theme_palette, set_theme
 from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.widgets.editors.text_box.text_box import TextBox
@@ -69,22 +69,22 @@ DEFAULT_LOG_COLORS = {
 }
 
 
-class BecLogsQueue(QObject):
+class BecLogsQueue(BECConnector, QObject):
     """Manages getting logs from BEC Redis and formatting them for display"""
 
+    RPC = False
     new_message = Signal()
 
     def __init__(
         self,
         parent: QObject | None,
-        conn: ConnectorBase,
         maxlen: int = 1000,
         line_formatter: LineFormatter = noop_format,
+        **kwargs,
     ) -> None:
-        super().__init__(parent=parent)
+        super().__init__(parent=parent, **kwargs)
         self._timestamp_start: QDateTime | None = None
         self._timestamp_end: QDateTime | None = None
-        self._conn = conn
         self._max_length = maxlen
         self._data: deque[LogMessage] = deque([], self._max_length)
         self._display_queue: deque[str] = deque([], self._max_length)
@@ -92,20 +92,26 @@ class BecLogsQueue(QObject):
         self._search_query: Pattern | str | None = None
         self._selected_services: set[str] | None = None
         self._set_formatter_and_update_filter(line_formatter)
-        self._conn.register([MessageEndpoints.log()], None, self._process_incoming_log_msg)
+        # instance attribute still accessible after c++ object is deleted, so the callback can be unregistered
+        self.bec_dispatcher.connect_slot(self._process_incoming_log_msg, MessageEndpoints.log())
 
-    def unsub_from_redis(self):
+    def cleanup(self, *_):
         """Stop listening to the Redis log stream"""
-        self._conn.unregister([MessageEndpoints.log()], None, self._process_incoming_log_msg)
+        self.bec_dispatcher.disconnect_slot(
+            self._process_incoming_log_msg, [MessageEndpoints.log()]
+        )
 
-    def _process_incoming_log_msg(self, msg: dict):
+    @SafeSlot(verify_sender=True)
+    def _process_incoming_log_msg(self, msg: dict, _metadata: dict):
         try:
-            _msg: LogMessage = msg["data"]
+            _msg = LogMessage(**msg)
             self._data.append(_msg)
             if self.filter is None or self.filter(_msg):
                 self._display_queue.append(self._line_formatter(_msg))
                 self.new_message.emit()
         except Exception as e:
+            if "Internal C++ object (BecLogsQueue) already deleted." in e.args:
+                return
             logger.warning(f"Error in LogPanel incoming message callback: {e}")
 
     def _set_formatter_and_update_filter(self, line_formatter: LineFormatter = noop_format):
@@ -202,7 +208,7 @@ class BecLogsQueue(QObject):
         """Fetch all available messages from Redis"""
         self._data = deque(
             item["data"]
-            for item in self._conn.xread(
+            for item in self.bec_dispatcher.client.connector.xread(
                 MessageEndpoints.log().endpoint, from_start=True, count=self._max_length
             )
         )
@@ -396,7 +402,6 @@ class LogPanel(TextBox):
     """Displays a log panel"""
 
     ICON_NAME = "terminal"
-    _new_messages = Signal()
     service_list_update = Signal(dict, set)
 
     def __init__(
@@ -407,17 +412,17 @@ class LogPanel(TextBox):
         **kwargs,
     ):
         """Initialize the LogPanel widget."""
-        super().__init__(parent=parent, client=client, **kwargs)
+        super().__init__(parent=parent, client=client, config={"text": ""}, **kwargs)
         self._update_colors()
         self._service_status = service_status or BECServiceStatusMixin(self, client=self.client)  # type: ignore
         self._log_manager = BecLogsQueue(
-            parent,
-            self.client.connector,  # type: ignore
-            line_formatter=partial(simple_color_format, colors=self._colors),
+            parent=self, line_formatter=partial(simple_color_format, colors=self._colors)
+        )
+        self._proxy_update = SignalProxy(
+            self._log_manager.new_message, rateLimit=1, slot=self._on_append
         )
-        self._log_manager.new_message.connect(self._new_messages)
 
-        self.toolbar = LogPanelToolbar(parent=parent)
+        self.toolbar = LogPanelToolbar(parent=self)
         self.toolbar_area = QScrollArea()
         self.toolbar_area.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         self.toolbar_area.setSizeAdjustPolicy(QScrollArea.SizeAdjustPolicy.AdjustToContents)
@@ -431,7 +436,6 @@ class LogPanel(TextBox):
         self.toolbar.search_textbox.returnPressed.connect(self._on_re_update)
         self.toolbar.regex_enabled.checkStateChanged.connect(self._on_re_update)
         self.toolbar.filter_level_dropdown.currentTextChanged.connect(self._set_level_filter)
-        self._new_messages.connect(self._on_append)
 
         self.toolbar.timerange_button.clicked.connect(self._choose_datetime)
         self._service_status.services_update.connect(self._update_service_list)
@@ -483,10 +487,10 @@ class LogPanel(TextBox):
         self.set_html_text(self._log_manager.display_all())
         self._cursor_to_end()
 
-    @SafeSlot()
-    def _on_append(self):
-        self._cursor_to_end()
+    @SafeSlot(verify_sender=True)
+    def _on_append(self, *_):
         self.text_box_text_edit.insertHtml(self._log_manager.format_new())
+        self._cursor_to_end()
 
     @SafeSlot()
     def _on_clear(self):
@@ -529,9 +533,8 @@ class LogPanel(TextBox):
 
     def cleanup(self):
         self._service_status.cleanup()
-        self._log_manager.unsub_from_redis()
-        self._log_manager.new_message.disconnect(self._new_messages)
-        self._new_messages.disconnect(self._on_append)
+        self._log_manager.cleanup()
+        self._log_manager.deleteLater()
         super().cleanup()
 
 

bec_widgets/widgets/utility/signal_label/register_signal_label.py

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

bec_widgets/widgets/utility/signal_label/signal_label.py

@@ -0,0 +1,456 @@
+from __future__ import annotations
+
+import sys
+import traceback
+from typing import TYPE_CHECKING
+
+from bec_lib.device import Device, Signal
+from bec_lib.endpoints import MessageEndpoints
+from bec_qthemes import material_icon
+from qtpy.QtCore import Signal as QSignal
+from qtpy.QtWidgets import (
+    QApplication,
+    QComboBox,
+    QDialog,
+    QDialogButtonBox,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QToolButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.utils.bec_connector import ConnectionConfig
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.colors import get_accent_colors
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
+from bec_widgets.utils.ophyd_kind_util import Kind
+from bec_widgets.widgets.control.device_input.base_classes.device_input_base import (
+    DeviceInputConfig,
+)
+from bec_widgets.widgets.control.device_input.base_classes.device_signal_input_base import (
+    DeviceSignalInputBaseConfig,
+)
+from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
+    DeviceLineEdit,
+)
+from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
+
+if TYPE_CHECKING:
+    from bec_lib.client import BECClient
+
+
+class ChoiceDialog(QDialog):
+    accepted_output = QSignal(str, str)
+
+    CONNECTION_ERROR_STR = "Error: client is not connected!"
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        config: ConnectionConfig | None = None,
+        client: BECClient | None = None,
+        show_hinted: bool = True,
+        show_normal: bool = False,
+        show_config: bool = False,
+    ):
+        if not client or not client.started:
+            self._display_error()
+            return
+        super().__init__(parent=parent)
+        self.setWindowTitle("Choose device and signal...")
+        self._accent_colors = get_accent_colors()
+
+        layout = QHBoxLayout()
+
+        config_dict = config.model_dump() if config is not None else {}
+        self._device_config = DeviceInputConfig.model_validate(config_dict)
+        self._signal_config = DeviceSignalInputBaseConfig.model_validate(config_dict)
+        self._device_field = DeviceLineEdit(
+            config=self._device_config, parent=parent, client=client
+        )
+        self._signal_field = SignalComboBox(
+            config=self._signal_config,
+            device=self._signal_config.device,
+            parent=parent,
+            client=client,
+        )
+        layout.addWidget(self._device_field)
+        layout.addWidget(self._signal_field)
+
+        self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        self.button_box.accepted.connect(self.accept)
+        self.button_box.rejected.connect(self.reject)
+        layout.addWidget(self.button_box)
+
+        self._signal_field.include_hinted_signals = show_hinted
+        self._signal_field.include_normal_signals = show_normal
+        self._signal_field.include_config_signals = show_config
+
+        self.setLayout(layout)
+        self._device_field.textChanged.connect(self._update_device)
+        self._device_field.setText(config.device if config is not None else "")
+
+    def _display_error(self):
+        try:
+            super().__init__()
+        except Exception:
+            ...
+        layout = QHBoxLayout()
+        layout.addWidget(QLabel(self.CONNECTION_ERROR_STR))
+        self.button_box = QDialogButtonBox(QDialogButtonBox.Cancel)
+        self.button_box.accepted.connect(self.reject)
+        layout.addWidget(self.button_box)
+        self.setLayout(layout)
+
+    @SafeSlot(str)
+    def _update_device(self, device: str):
+        if device in self._device_field.dev:
+            self._device_field.set_device(device)
+            self._signal_field.set_device(device)
+            self._device_field.setStyleSheet(
+                f"QLineEdit {{ border-style: solid; border-width: 2px; border-color: {self._accent_colors.success.name() if self._accent_colors else 'green'}}}"
+            )
+            self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
+        else:
+            self._device_field.setStyleSheet(
+                f"QLineEdit {{ border-style: solid; border-width: 2px; border-color: {self._accent_colors.emergency.name() if self._accent_colors else 'red'}}}"
+            )
+            self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
+            self._signal_field.clear()
+
+    def accept(self):
+        self.accepted_output.emit(self._device_field.text(), self._signal_field.currentText())
+        return super().accept()
+
+
+class SignalLabel(BECWidget, QWidget):
+
+    ICON_NAME = "scoreboard"
+    RPC = True
+    PLUGIN = True
+
+    USER_ACCESS = [
+        "custom_label",
+        "custom_units",
+        "custom_label.setter",
+        "custom_units.setter",
+        "decimal_places",
+        "decimal_places.setter",
+        "show_default_units",
+        "show_default_units.setter",
+        "show_select_button",
+        "show_select_button.setter",
+    ]
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        client: BECClient | None = None,
+        device: str | None = None,
+        signal: str | None = None,
+        show_select_button: bool = True,
+        show_default_units: bool = False,
+        custom_label: str = "",
+        custom_units: str = "",
+        **kwargs,
+    ):
+        """Initialize the SignalLabel widget.
+
+        Args:
+            parent (QWidget, optional): The parent widget. Defaults to None.
+            client (BECClient, optional): The BEC client. Defaults to None.
+            device (str, optional): The device name. Defaults to None.
+            signal (str, optional): The signal name. Defaults to None.
+            selection_dialog_config (DeviceSignalInputBaseConfig | dict, optional): Configuration for the signal selection dialog.
+            show_select_button (bool, optional): Whether to show the select button. Defaults to True.
+            show_default_units (bool, optional): Whether to show default units. Defaults to False.
+            custom_label (str, optional): Custom label for the widget. Defaults to "".
+            custom_units (str, optional): Custom units for the widget. Defaults to "".
+        """
+        self._config = DeviceSignalInputBaseConfig(default=signal, device=device)
+        super().__init__(parent=parent, client=client, **kwargs)
+
+        self._device = device
+        self._signal = signal
+
+        self._custom_label: str = custom_label
+        self._custom_units: str = custom_units
+        self._show_default_units: bool = show_default_units
+        self._decimal_places = 3
+
+        self._show_hinted_signals: bool = True
+        self._show_normal_signals: bool = False
+        self._show_config_signals: bool = False
+
+        self._outer_layout = QHBoxLayout()
+        self._layout = QHBoxLayout()
+        self._outer_layout.setContentsMargins(0, 0, 0, 0)
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(self._outer_layout)
+
+        self._label = QGroupBox(custom_label)
+        self._outer_layout.addWidget(self._label)
+        self._update_label()
+        self._label.setLayout(self._layout)
+
+        self._value: str = ""
+        self._display = QLabel()
+        self._layout.addWidget(self._display)
+
+        self._select_button = QToolButton()
+        self._select_button.setIcon(material_icon(icon_name="settings", size=(20, 20)))
+        self._show_select_button: bool = show_select_button
+        self._layout.addWidget(self._select_button)
+        self._display.setMinimumHeight(self._select_button.sizeHint().height())
+        self.show_select_button = self._show_select_button
+
+        self._select_button.clicked.connect(self.show_choice_dialog)
+        self.get_bec_shortcuts()
+
+        self._connected: bool = False
+        self.connect_device()
+
+    def _create_dialog(self):
+        return ChoiceDialog(
+            config=self._config,
+            parent=self,
+            client=self.client,
+            show_config=self.show_config_signals,
+            show_normal=self.show_normal_signals,
+            show_hinted=self.show_hinted_signals,
+        )
+
+    @SafeSlot()
+    def _process_dialog(self, device: str, signal: str):
+        self.disconnect_device()
+        self.device = device
+        self.signal = signal
+        self._update_label()
+        self.connect_device()
+
+    def show_choice_dialog(self):
+        dialog = self._create_dialog()
+        dialog.accepted_output.connect(self._process_dialog)
+        dialog.open()
+        return dialog
+
+    def connect_device(self):
+        """Subscribe to the Redis topic for the device to display"""
+        if not self._connected and self._device and self._device in self.dev:
+            self._connected = True
+            self._readback_endpoint = MessageEndpoints.device_readback(self._device)
+            self.bec_dispatcher.connect_slot(self.on_device_readback, self._readback_endpoint)
+            self._manual_read()
+            self.set_display_value(self._value)
+
+    def disconnect_device(self):
+        """Unsubscribe from the Redis topic for the device to display"""
+        if self._connected:
+            self._connected = False
+            self.bec_dispatcher.disconnect_slot(self.on_device_readback, self._readback_endpoint)
+
+    def _manual_read(self):
+        if self._device is None or not isinstance(
+            (device := self.dev.get(self._device)), Device | Signal
+        ):
+            self._units = ""
+            self._value = "__"
+            return
+        signal: Signal = (
+            getattr(device, self.signal, None) if isinstance(device, Device) else device
+        )
+        if not isinstance(signal, Signal):  # Avoid getting other attributes of device, e.g. methods
+            signal = None
+        if signal is None:
+            self._units = ""
+            self._value = "__"
+            return
+        self._value = signal.get()
+        self._units = signal.get_device_config().get("egu", "")
+
+    @SafeSlot(dict, dict)
+    def on_device_readback(self, msg: dict, metadata: dict) -> None:
+        """
+        Update the display with the new value.
+        """
+        try:
+            signal_to_read = self._patch_hinted_signal()
+            self._value = msg["signals"][signal_to_read]["value"]
+            self.set_display_value(self._value)
+        except Exception as e:
+            self._display.setText("ERROR!")
+            self._display.setToolTip(
+                f"Error processing incoming reading: {msg}, handled with exception: {''.join(traceback.format_exception(e))}"
+            )
+
+    def _patch_hinted_signal(self):
+        if self.dev[self._device]._info["signals"] == {}:
+            return self._signal
+        signal_info = self.dev[self._device]._info["signals"][self._signal]
+        return (
+            signal_info["obj_name"] if signal_info["kind_str"] == Kind.hinted.name else self._signal
+        )
+
+    @SafeProperty(str)
+    def device(self) -> str:
+        """The device from which to select a signal"""
+        return self._device or "Not set!"
+
+    @device.setter
+    def device(self, value: str) -> None:
+        self.disconnect_device()
+        self._device = value
+        self._config.device = value
+        self.connect_device()
+        self._update_label()
+
+    @SafeProperty(str)
+    def signal(self) -> str:
+        """The signal to display"""
+        return self._signal or "Not set!"
+
+    @signal.setter
+    def signal(self, value: str) -> None:
+        self.disconnect_device()
+        self._signal = value
+        self._config.default = value
+        self.connect_device()
+        self._update_label()
+
+    @SafeProperty(bool)
+    def show_select_button(self) -> bool:
+        """Show the button to select the signal to display"""
+        return self._show_select_button
+
+    @show_select_button.setter
+    def show_select_button(self, value: bool) -> None:
+        self._show_select_button = value
+        self._select_button.setVisible(value)
+
+    @SafeProperty(bool)
+    def show_default_units(self) -> bool:
+        """Show default units obtained from the signal alongside it"""
+        return self._show_default_units
+
+    @show_default_units.setter
+    def show_default_units(self, value: bool) -> None:
+        self._show_default_units = value
+        self.set_display_value(self._value)
+
+    @SafeProperty(str)
+    def custom_label(self) -> str:
+        """Use a cusom label rather than the signal name"""
+        return self._custom_label
+
+    @custom_label.setter
+    def custom_label(self, value: str) -> None:
+        self._custom_label = value
+        self._update_label()
+
+    @SafeProperty(str)
+    def custom_units(self) -> str:
+        """Use a custom unit string"""
+        return self._custom_units
+
+    @custom_units.setter
+    def custom_units(self, value: str) -> None:
+        self._custom_units = value
+        self.set_display_value(self._value)
+
+    @SafeProperty(int)
+    def decimal_places(self) -> int:
+        """Format to a given number of decimal_places. Set to 0 to disable."""
+        return self._decimal_places
+
+    @decimal_places.setter
+    def decimal_places(self, value: int) -> None:
+        self._decimal_places = value
+        self._update_label()
+
+    @SafeProperty(bool)
+    def show_hinted_signals(self) -> bool:
+        """In the signal selection menu, show hinted signals"""
+        return self._show_hinted_signals
+
+    @show_hinted_signals.setter
+    def show_hinted_signals(self, value: bool) -> None:
+        self._show_hinted_signals = value
+
+    @SafeProperty(bool)
+    def show_config_signals(self) -> bool:
+        """In the signal selection menu, show config signals"""
+        return self._show_config_signals
+
+    @show_config_signals.setter
+    def show_config_signals(self, value: bool) -> None:
+        self._show_config_signals = value
+
+    @SafeProperty(bool)
+    def show_normal_signals(self) -> bool:
+        """In the signal selection menu, show normal signals"""
+        return self._show_normal_signals
+
+    @show_normal_signals.setter
+    def show_normal_signals(self, value: bool) -> None:
+        self._show_normal_signals = value
+
+    def _format_value(self, value: str):
+        if self._decimal_places == 0:
+            return value
+        try:
+            return f"{float(value):0.{self._decimal_places}f}"
+        except ValueError:
+            return value
+
+    @SafeSlot(str)
+    def set_display_value(self, value: str):
+        """Set the display to a given value, appending the units if specified"""
+        self._display.setText(f"{self._format_value(value)}{self._units_string}")
+        self._display.setToolTip("")
+
+    @property
+    def _units_string(self):
+        if self.custom_units or self._show_default_units:
+            return f" {self.custom_units or self._default_units or ''}"
+        return ""
+
+    @property
+    def _default_units(self) -> str:
+        return self._units
+
+    @property
+    def _default_label(self) -> str:
+        return (
+            str(self._signal) if self._device == self._signal else f"{self._device} {self._signal}"
+        )
+
+    def _update_label(self):
+        self._label.setTitle(
+            self._custom_label if self._custom_label else f"{self._default_label}:"
+        )
+
+
+if __name__ == "__main__":
+
+    app = QApplication(sys.argv)
+    w = QWidget()
+    w.setLayout(QVBoxLayout())
+    w.layout().addWidget(
+        SignalLabel(
+            device="samx",
+            signal="readback",
+            custom_label="custom label:",
+            custom_units=" m/s/s",
+            show_select_button=False,
+        )
+    )
+    w.layout().addWidget(SignalLabel(device="samy", signal="readback", show_default_units=True))
+    l = SignalLabel()
+    l.device = "bpm4i"
+    l.signal = "bpm4i"
+    w.layout().addWidget(l)
+    w.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/utility/signal_label/signal_label.pyproject

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

bec_widgets/widgets/utility/signal_label/signal_label_plugin.py

@@ -1,43 +1,39 @@
 # 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.console.console import BECConsole
+from bec_widgets.widgets.utility.signal_label.signal_label import SignalLabel
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='BECConsole' name='bec_console'>
+    <widget class='SignalLabel' name='signal_label'>
     </widget>
 </ui>
 """
 
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
-
-class BECConsolePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+class SignalLabelPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
         super().__init__()
         self._form_editor = None
 
     def createWidget(self, parent):
-        t = BECConsole(parent)
+        t = SignalLabel(parent)
         return t
 
     def domXml(self):
         return DOM_XML
 
     def group(self):
-        return "BEC Console"
+        return "BEC Utils"
 
     def icon(self):
-        return designer_material_icon(BECConsole.ICON_NAME)
+        return designer_material_icon(SignalLabel.ICON_NAME)
 
     def includeFile(self):
-        return "bec_console"
+        return "signal_label"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -49,10 +45,10 @@ class BECConsolePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return self._form_editor is not None
 
     def name(self):
-        return "BECConsole"
+        return "SignalLabel"
 
     def toolTip(self):
-        return "A terminal-like vt100 widget."
+        return "Display the live value of any signal"
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/utility/toggle/toggle.py

@@ -10,6 +10,7 @@ class ToggleSwitch(QWidget):
     A simple toggle.
     """
 
+    stateChanged = Signal(bool)
     enabled = Signal(bool)
     ICON_NAME = "toggle_on"
     PLUGIN = True
@@ -42,11 +43,19 @@ class ToggleSwitch(QWidget):
 
     @checked.setter
     def checked(self, state):
+        if self._checked != state:
+            self.stateChanged.emit(state)
         self._checked = state
         self.update_colors()
         self.set_thumb_pos_to_state()
         self.enabled.emit(self._checked)
 
+    def setChecked(self, state: bool):
+        self.checked = state
+
+    def isChecked(self):
+        return self.checked
+
     @Property(QPointF)
     def thumb_pos(self):
         return self._thumb_pos

bec_widgets/widgets/utility/visual/color_button_native/color_button_native.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
+from qtpy.QtCore import Signal
 from qtpy.QtGui import QColor
-from qtpy.QtWidgets import QPushButton
+from qtpy.QtWidgets import QColorDialog, QPushButton
 
 from bec_widgets import BECWidget, SafeProperty, SafeSlot
 
@@ -12,6 +15,8 @@ class ColorButtonNative(BECWidget, QPushButton):
     to guarantee good readability.
     """
 
+    color_changed = Signal(str)
+
     RPC = False
     PLUGIN = True
     ICON_NAME = "colors"
@@ -25,9 +30,10 @@ class ColorButtonNative(BECWidget, QPushButton):
         """
         super().__init__(parent=parent, **kwargs)
         self.set_color(color)
+        self.clicked.connect(self._open_color_dialog)
 
     @SafeSlot()
-    def set_color(self, color):
+    def set_color(self, color: str | QColor):
         """Set the button's color and update its appearance.
 
         Args:
@@ -38,6 +44,7 @@ class ColorButtonNative(BECWidget, QPushButton):
         else:
             self._color = color
         self._update_appearance()
+        self.color_changed.emit(self._color)
 
     @SafeProperty("QColor")
     def color(self):
@@ -56,3 +63,11 @@ class ColorButtonNative(BECWidget, QPushButton):
         text_color = "#000000" if brightness > 0.5 else "#FFFFFF"
         self.setStyleSheet(f"background-color: {self._color}; color: {text_color};")
         self.setText(self._color)
+
+    @SafeSlot()
+    def _open_color_dialog(self):
+        """Open a QColorDialog and apply the selected color."""
+        current_color = QColor(self._color)
+        chosen_color = QColorDialog.getColor(current_color, self, "Select Curve Color")
+        if chosen_color.isValid():
+            self.set_color(chosen_color)

docs/developer/widget_development/widget_development.md

@@ -19,13 +19,11 @@ from bec_widgets.utils.bec_widget import BECWidget
 
 class HelloWorldWidget(BECWidget, QWidget):
     def __init__(
-        self, parent: QWidget | None = None, client=None, gui_id: str | None = None
+        self, parent: QWidget | None = None, client=None, gui_id: str | None = None, **kwargs
     ) -> None:
-        # Initialize the BECWidget and QWidget
-        super().__init__(client=client, gui_id=gui_id)
-        QWidget.__init__(self, parent)
+        # Initialize base classes
+        super().__init__(parent=parent, client=client, gui_id=gui_id, **kwargs)
 
-        # Create a label with the text "Hello World"
         self.label = QLabel(self)
         self.label.setText("Hello World")
 

docs/requirements.txt

@@ -7,6 +7,4 @@ sphinx-copybutton
 sphinx-inline-tabs
 myst-parser
 sphinx-design
-PySide6~=6.8.2
-bec-widgets
 tomli

docs/user/widgets/signal_label/signal_label.md

@@ -0,0 +1,102 @@
+(user.widgets.signal_label)=
+
+# Signal Label widget
+
+````{tab} Overview
+
+The [`SignalLabel`](/api_reference/_autosummary/bec_widgets.cli.client.SignalLabel) displays the value of a signal from a device, with optional customization for labels, units, decimal formatting, and signal selection. It is designed for use in BEC (Beamline Experiment Control) GUIs to monitor values which beamline operators might want to keep an eye on, e.g. sample position, flux, hutch state...
+
+## Key Features:
+- Display: Shows the current value of a device signal.
+- Custom Label/Units: Optionally override the default label and units.
+- Decimal Formatting: Control the number of decimal places shown.
+- Signal Selection: (Optional) Button to open a dialog for selecting a device and signal.
+- Live Updates: Subscribes to device updates and refreshes the display automatically.
+
+
+````
+
+````{tab} Examples - python
+
+The `SignalLabel` widget can be used inside another widget to build an overall GUI display. For example, to create a display
+for the sample position like this:
+
+
+```{figure} ./test_screenshot.png
+```
+
+You can simply add three of these signal displays as done here:
+
+```python
+import sys
+
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.widgets.utility.signal_label.signal_label import SignalLabel
+
+
+class SamplePositionWidget(BECWidget, QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self.setLayout(QVBoxLayout())
+        self.samx_readback = SignalLabel(
+            device="samx",
+            signal="readback",
+            custom_label="Sample X:",
+            custom_units="mm",
+            show_select_button=False,
+            show_default_units=False,
+        )
+        self.samy_readback = SignalLabel(
+            device="samy",
+            signal="readback",
+            custom_label="Sample Y:",
+            custom_units="mm",
+            show_select_button=False,
+            show_default_units=False,
+        )
+        self.samz_readback = SignalLabel(
+            device="samz",
+            signal="readback",
+            custom_label="Sample Z:",
+            custom_units="mm",
+            show_select_button=False,
+            show_default_units=False,
+        )
+        self.layout().addWidget(self.samx_readback)
+        self.layout().addWidget(self.samy_readback)
+        self.layout().addWidget(self.samz_readback)
+
+
+if __name__ == "__main__":
+    app = QApplication()
+    w = SamplePositionWidget()
+    w.show()
+    sys.exit(app.exec_())
+
+```
+
+````
+
+````{tab} Examples - BEC desginer
+The various properties can also be set when the SignalLabel widget is added to a UI in BEC designer:
+
+```{figure} ./designer_screenshot.png
+```
+````
+
+````{tab} API
+```{eval-rst} 
+.. include:: /api_reference/_autosummary/bec_widgets.cli.client.TextBox.rst
+```
+````
+
+
+
+
+
+
+
+
+

docs/user/widgets/widgets.md

@@ -175,6 +175,14 @@ Various buttons which manage the control of the BEC Queue.
 Choose individual device from current session.
 ```
 
+```{grid-item-card} Signal Label
+:link: user.widgets.signal_label
+:link-type: ref
+:img-top: ./signal_label/test_screenshot.png
+
+Display the live value of a signal.
+```
+
 ```{grid-item-card} Signal Input Widgets
 :link: user.widgets.signal_input
 :link-type: ref
@@ -289,5 +297,7 @@ lmfit_dialog/lmfit_dialog.md
 dap_combo_box/dap_combo_box.md
 games/games.md
 log_panel/log_panel.md
+signal_label/signal_label.md
+
 
 ```

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "2.3.0"
+version = "2.16.2"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -13,16 +13,15 @@ classifiers = [
     "Topic :: Scientific/Engineering",
 ]
 dependencies = [
-    "bec_ipython_client>=2.21.4, <=4.0", # needed for jupyter console
-    "bec_lib>=3.29, <=4.0",
+    "bec_ipython_client>=3.38, <=4.0", # needed for jupyter console
+    "bec_lib>=3.38, <=4.0",
     "bec_qthemes~=0.7, >=0.7",
-    "black~=25.0",                       # needed for bw-generate-cli
-    "isort~=5.13, >=5.13.2",             # needed for bw-generate-cli
+    "black~=25.0",                     # needed for bw-generate-cli
+    "isort~=5.13, >=5.13.2",           # needed for bw-generate-cli
     "pydantic~=2.0",
     "pyqtgraph~=0.13",
     "PySide6~=6.8.2",
-    "pyte",                              # needed for vt100 console
-    "qtconsole~=5.5, >=5.5.1",           # needed for jupyter console
+    "qtconsole~=5.5, >=5.5.1",         # needed for jupyter console
     "qtpy~=2.4",
 ]
 
@@ -71,7 +70,7 @@ include_trailing_comma = true
 known_first_party = ["bec_widgets"]
 
 [tool.semantic_release]
-build_command = "python -m build"
+build_command = "pip install build wheel && python -m build"
 version_toml = ["pyproject.toml:project.version"]
 
 [tool.semantic_release.commit_author]
@@ -98,7 +97,7 @@ default_bump_level = 0
 [tool.semantic_release.remote]
 name = "origin"
 type = "github"
-ignore_token_for_push = false
+ignore_token_for_push = true
 
 [tool.semantic_release.remote.token]
 env = "GH_TOKEN"

tests/end-2-end/conftest.py

@@ -5,11 +5,20 @@ import random
 import pytest
 
 from bec_widgets.cli.client_utils import BECGuiClient
+from bec_widgets.widgets.control.scan_control import ScanControl
 
 # pylint: disable=unused-argument
 # pylint: disable=redefined-outer-name
 
 
+@pytest.fixture(scope="function")
+def scan_control(qtbot, bec_client_lib):  # , mock_dev):
+    widget = ScanControl(client=bec_client_lib)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
 @pytest.fixture(autouse=True)
 def threads_check_fixture(threads_check):
     """

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -51,7 +51,6 @@ def test_rpc_add_dock_with_plots_e2e(qtbot, bec_client_lib, connected_client_gui
 
     # Waii until docks are registered
     qtbot.waitUntil(check_docks_registered, timeout=5000)
-    qtbot.wait(500)
     assert len(dock.panels) == 3
     assert hasattr(gui.bec, "dock_0")
 

tests/end-2-end/test_rpc_widgets_e2e.py

@@ -145,7 +145,14 @@ def test_available_widgets(qtbot, connected_client_gui_obj):
 
         # Check that the number of top level widgets is still the same. As the cleanup is done by the
         # qt event loop, we need to wait for the qtbot to finish the cleanup
-        qtbot.waitUntil(lambda: len(gui._server_registry) == top_level_widgets_count)
+        try:
+            qtbot.waitUntil(lambda: len(gui._server_registry) == top_level_widgets_count)
+        except Exception as exc:
+            raise RuntimeError(
+                f"Widget {object_name} was not removed properly. The number of top level widgets "
+                f"is {len(gui._server_registry)} instead of {top_level_widgets_count}. The following "
+                f"widgets are still registered: {list(gui._server_registry.keys())}."
+            ) from exc
         # Number of widgets with parent_id == None, should be 2
         widgets = [
             widget