docs(waveform): plotting ruleset

2.21.2
Automatically generated by python-semantic-release
2026-04-09 18:20:55 +02:00 · 2025-07-02 23:03:01 +02:00 · 2025-06-30 11:53:00 +00:00 · 2025-06-30 13:52:19 +02:00 · 2025-06-29 11:52:14 +02:00 · 2025-06-29 09:49:32 +00:00
70 changed files with 4271 additions and 494 deletions
--- a/.github/workflows/formatter.yml
+++ b/.github/workflows/formatter.yml
@@ -21,7 +21,7 @@ jobs:
          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"'
+        run: '! grep -re "from PySide6\." bec_widgets/ tests/ | grep  -v -e "PySide6.QtDesigner" -e "PySide6.scripts"'

  Pylint:
    runs-on: ubuntu-latest
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,335 @@
 # CHANGELOG


+## v2.21.2 (2025-06-30)
+
+### Bug Fixes
+
+- **waveform**: Fix waveform categorisation for aborted scans
+  ([`09c5a44`](https://github.com/bec-project/bec_widgets/commit/09c5a443aac675f02fa1e38179deb9863af152e2))
+
+### Testing
+
+- Assert config for equality, not identity
+  ([`3f5ab14`](https://github.com/bec-project/bec_widgets/commit/3f5ab142a3cb5446261c4faebdc7b13f10ef4a80))
+
+
+## v2.21.1 (2025-06-29)
+
+### Bug Fixes
+
+- **sbb monitor**: Add missing pyproject file
+  ([`371bc48`](https://github.com/bec-project/bec_widgets/commit/371bc485d060404433082c9e3e00780961ce6ae3))
+
+
+## v2.21.0 (2025-06-28)
+
+### Features
+
+- **sbb monitor**: Add sbb monitor widget
+  ([`3d59c25`](https://github.com/bec-project/bec_widgets/commit/3d59c25aa93590a62ab4d31a4ab08589402bf407))
+
+
+## v2.20.1 (2025-06-28)
+
+### Bug Fixes
+
+- **signal input base**: Unregister callback to avoid accessing deleted qt objects
+  ([`7ba8863`](https://github.com/bec-project/bec_widgets/commit/7ba8863d6a0c21f772e4ef8a5d4180c2a7ab49cb))
+
+
+## v2.20.0 (2025-06-26)
+
+### Bug Fixes
+
+- **curve_settings**: Larger minimalWidth for the x device combobox selection
+  ([`48a0e58`](https://github.com/bec-project/bec_widgets/commit/48a0e5831feccd30f24218821bbc9d73f8c47933))
+
+### Features
+
+- **waveform**: Move x axis selection to a combobox
+  ([`d10328c`](https://github.com/bec-project/bec_widgets/commit/d10328cb5c775a9b7b40ed4e9f2889e63eb039ff))
+
+### Refactoring
+
+- **curve settings**: Move signal logic to SignalCombobox
+  ([`e841468`](https://github.com/bec-project/bec_widgets/commit/e84146889210165de1c4e63eb20b39f30cc5c623))
+
+### Testing
+
+- **curve settings**: Add curve tree elements to the dialog test
+  ([`1e9dd4c`](https://github.com/bec-project/bec_widgets/commit/1e9dd4cd2561d37bdda1cd86b511295c259b2831))
+
+
+## v2.19.4 (2025-06-26)
+
+### Bug Fixes
+
+- **curve tree**: Remove manual interception of the close event; call parent cleanup
+  ([`bc3085a`](https://github.com/bec-project/bec_widgets/commit/bc3085ab8cb6688da358df4a7c07fc213a99f2df))
+
+- **waveform**: Curve tree elements must clean up signal combobox
+  ([`9cba696`](https://github.com/bec-project/bec_widgets/commit/9cba696afd3300a76678dfdc4226604696cc3696))
+
+
+## v2.19.3 (2025-06-25)
+
+### Bug Fixes
+
+- **scan_control**: Safeguard against empty history; reversed history to fetch the newest scan
+  ([`29a26b1`](https://github.com/bec-project/bec_widgets/commit/29a26b19f9ab829b0d877c3233613a0936db0a12))
+
+
+## v2.19.2 (2025-06-23)
+
+### Bug Fixes
+
+- **scan_control**: Scan parameters fetched from the scan_history, fix #707
+  ([`4456297`](https://github.com/bec-project/bec_widgets/commit/4456297beb940b147882f96caee6fb19aaf93c73))
+
+### Build System
+
+- Bec_lib 3.44 required
+  ([`9f3dcc3`](https://github.com/bec-project/bec_widgets/commit/9f3dcc3ab30a2c238ffffa8d594735ccaf6f1ca4))
+
+### Refactoring
+
+- **scan_control**: Request_last_executed_scan_parameters logic adjusted
+  ([`57f75bd`](https://github.com/bec-project/bec_widgets/commit/57f75bd4d506ca4d8dc982f3051d0d4c29b0d41c))
+
+
+## v2.19.1 (2025-06-23)
+
+### Bug Fixes
+
+- **launch_window**: Number of remaining connections extended to 4
+  ([`7484f51`](https://github.com/bec-project/bec_widgets/commit/7484f5160c8c6d632fd27996035ff6c0dda2e657))
+
+
+## v2.19.0 (2025-06-23)
+
+### Bug Fixes
+
+- **ci**: Extend check for pyside import to tests
+  ([`d5a40da`](https://github.com/bec-project/bec_widgets/commit/d5a40dabc74753acad05e3eb6b121499fc1e03d7))
+
+### Features
+
+- (#494) add signal display to device browser
+  ([`f3da6e9`](https://github.com/bec-project/bec_widgets/commit/f3da6e959e0416827ee5d02e34e6ad0ecfc8e5e7))
+
+- (#494) add tabbed layout for device item
+  ([`3378051`](https://github.com/bec-project/bec_widgets/commit/337805125098c3e028a17b74ef6d9ae4b9ba3d6d))
+
+- (#494) display device signals
+  ([`3a10341`](https://github.com/bec-project/bec_widgets/commit/3a103410e7448256a56b59bb3276fee056ec42a0))
+
+
+## v2.18.0 (2025-06-22)
+
+### Bug Fixes
+
+- Make settings dialog resizable
+  ([`5a564a5`](https://github.com/bec-project/bec_widgets/commit/5a564a5f3f3229e6407ea52a59d3e63319dc214a))
+
+- **curve settings**: Add initial size hint
+  ([`a9708f6`](https://github.com/bec-project/bec_widgets/commit/a9708f6d8f15c42b142488da1e392a8f3179932a))
+
+### Features
+
+- **curve settings**: Add combobox selection for device and signal
+  ([`eea5f7e`](https://github.com/bec-project/bec_widgets/commit/eea5f7ebbd2b477b3ed19c7efcc76390dd391f26))
+
+- **device combobox**: Emit reset event if validation fails
+  ([`4c2c0c5`](https://github.com/bec-project/bec_widgets/commit/4c2c0c5525d593d8ec7fd554336cb11adbe32de2))
+
+- **FilterIO**: Add support for item data
+  ([`8e8acd6`](https://github.com/bec-project/bec_widgets/commit/8e8acd672c0deb8dcd928886fb574452ac956de7))
+
+- **signal combobox**: Add reset_selection slot
+  ([`b51de1a`](https://github.com/bec-project/bec_widgets/commit/b51de1a00e4b17c44cab23e5097391c6fa8ea0e2))
+
+### Refactoring
+
+- **device input**: Refactor to SafeProperty and SafeSlot
+  ([`6e2f2ce`](https://github.com/bec-project/bec_widgets/commit/6e2f2cea91ba3af33e9891532506f4b0b65b90c8))
+
+
+## v2.17.0 (2025-06-22)
+
+### Bug Fixes
+
+- **bec_progressbar**: Layout and sizing adjustments
+  ([`b02c870`](https://github.com/bec-project/bec_widgets/commit/b02c870dbfecb4bc6921ec4c915dac0e67beb9b4))
+
+- **launch_window**: Number of remaining connections increase to 2 to include the ScanProgressBar
+  ([`3bbb8da`](https://github.com/bec-project/bec_widgets/commit/3bbb8daa24348613f62bde667a446d37dcec8fb0))
+
+- **main_window**: Labels and sizing of scan progress adopted
+  ([`aca6efb`](https://github.com/bec-project/bec_widgets/commit/aca6efb567528eb3c68521a59b4f9903a5616c6f))
+
+- **scan_progressbar**: Cleanup adjusted
+  ([`e8ae972`](https://github.com/bec-project/bec_widgets/commit/e8ae9725fa86b7db52a147ca5a2acc62fa2ccf43))
+
+- **scan_progressbar**: Mapping of bec progress states to the progressbar enums
+  ([`88b42e4`](https://github.com/bec-project/bec_widgets/commit/88b42e49e30a0aa0edc2de4d970408f4be5bde6b))
+
+### Build System
+
+- Update min dependency of bec to 3.42.4
+  ([`a4274ff`](https://github.com/bec-project/bec_widgets/commit/a4274ff8cd9f3e73a61b2eaf902c172c028d21b0))
+
+### Features
+
+- **main_window**: Added scan progress bar to BECMainWindow status bar
+  ([`497e394`](https://github.com/bec-project/bec_widgets/commit/497e394deb5cfe36c8fc4f769fef26f109fd1c1f))
+
+- **main_window**: Timer to show hide scan progress when it is relevant only
+  ([`9ff1706`](https://github.com/bec-project/bec_widgets/commit/9ff170660edd9e03f99eccee60b5e20fc1cf5a8d))
+
+- **progressbar**: Added padding as designer property
+  ([`a451625`](https://github.com/bec-project/bec_widgets/commit/a451625a5ab804ca8259f9c9f83c4f9ebbea4a5b))
+
+- **progressbar**: State setting and dynamic corner radius
+  ([`d3a9e09`](https://github.com/bec-project/bec_widgets/commit/d3a9e0903a263d735ecab3a2ad9319c9d5e86092))
+
+- **scan_progressbar**: Added oneline design for compact applications
+  ([`d5ca7b8`](https://github.com/bec-project/bec_widgets/commit/d5ca7b84337cf60aa66f961d357ae66994f53c7a))
+
+- **scan_progressbar**: Added progressbar with hooks to scan progress and device progress
+  ([`c4b8538`](https://github.com/bec-project/bec_widgets/commit/c4b85381a41e4742567680864668ee83d498b1d1))
+
+### Refactoring
+
+- **progressbar**: Change slot / property to safeslot / safeproperty
+  ([`92d0ffe`](https://github.com/bec-project/bec_widgets/commit/92d0ffee65babc718fafd60131d0a4f291e5ca2b))
+
+### Testing
+
+- **scan progress**: Add test for queue update logic
+  ([`b2a46e2`](https://github.com/bec-project/bec_widgets/commit/b2a46e284d45e97dd9853d1a3c8e95de7e530267))
+
+- **scan_progress**: Tests extended
+  ([`6c04eac`](https://github.com/bec-project/bec_widgets/commit/6c04eac18c887526b333f58fc1118c3b4029abd8))
+
+
+## v2.16.2 (2025-06-20)
+
+### Bug Fixes
+
+- **waveform**: Asyncsignal are handled with the same update mechanism as async readback
+  ([`a3ffcef`](https://github.com/bec-project/bec_widgets/commit/a3ffcefe8085fa1a88d679f8ef6adfdff786492e))
+
+### Testing
+
+- **utils**: Dmmock can fetch get_bec_signals method
+  ([`3146d98`](https://github.com/bec-project/bec_widgets/commit/3146d98c572ff2bb8ab77f71b75d9612e364ffe0))
+
+
+## v2.16.1 (2025-06-20)
+
+### Bug Fixes
+
+- **scatter**: Fix tab order
+  ([`235aabf`](https://github.com/bec-project/bec_widgets/commit/235aabf307ef0c01a51a5cd8be4eb53915ed360c))
+
+
+## v2.16.0 (2025-06-17)
+
+### Bug Fixes
+
+- Adjust height of list widget
+  ([`11131ef`](https://github.com/bec-project/bec_widgets/commit/11131ef14c7e8714a4eaf70256da9e5835d60810))
+
+- Make website test robust
+  ([`4d8c07c`](https://github.com/bec-project/bec_widgets/commit/4d8c07cdd142bab4c0d8224c43e66517a02da7c1))
+
+- Parse config on submission and reload after
+  ([`5e4c129`](https://github.com/bec-project/bec_widgets/commit/5e4c129af6ae6644e4bb94f4129c6770fd26542d))
+
+- Pass on kwargs from PydanticModelForm
+  ([`a55f561`](https://github.com/bec-project/bec_widgets/commit/a55f561971a9ce2295cd835cd5cb6ce436d6c693))
+
+- Put waiting in thread
+  ([`1a350c3`](https://github.com/bec-project/bec_widgets/commit/1a350c3b16da0d990afd53d14934040e5e063177))
+
+- Reset dict table properly
+  ([`5623547`](https://github.com/bec-project/bec_widgets/commit/5623547e926b86eeb5e2164fa6ec9e36b99b8f63))
+
+- Scale dict widget height
+  ([`dea2568`](https://github.com/bec-project/bec_widgets/commit/dea2568de370450ca871fe7bf3573eec9acf8122))
+
+- Tidy up form widget formatting
+  ([`8f4c8e4`](https://github.com/bec-project/bec_widgets/commit/8f4c8e45b3d4a15c67e36cd52d475c3117eca1d3))
+
+### Features
+
+- Add a widget to edit lists in forms
+  ([`7fc85ba`](https://github.com/bec-project/bec_widgets/commit/7fc85bac7fff8555b73d28eefe9a538540d574b9))
+
+- Add set form item
+  ([`be73349`](https://github.com/bec-project/bec_widgets/commit/be73349c706582c144813f70dbc477372057de86))
+
+- Allow editing device config from browser
+  ([`886964b`](https://github.com/bec-project/bec_widgets/commit/886964bb54d2f3923fb6baf198652bb05cf28eb2))
+
+- Generate combobox for literal str
+  ([`138d4ca`](https://github.com/bec-project/bec_widgets/commit/138d4cabbd50e3c86ab18e9cdc25bbb5cdabc511))
+
+### Performance Improvements
+
+- Replace wait with waitUntil
+  ([`d626caa`](https://github.com/bec-project/bec_widgets/commit/d626caae3dc71683134cc47073bc131eba4820f5))
+
+### Refactoring
+
+- Move device config form to module
+  ([`9ce31c9`](https://github.com/bec-project/bec_widgets/commit/9ce31c9833ae38721b2246cdcac50f1154fba99d))
+
+- Rename field widgets
+  ([`b0d03c0`](https://github.com/bec-project/bec_widgets/commit/b0d03c0648cd365143dfed27d4755d6f5b9c7a45))
+
+### Testing
+
+- Add tests for config dialog
+  ([`a9613a0`](https://github.com/bec-project/bec_widgets/commit/a9613a07b0cd9cd9455fd996d124c77218c9388f))
+
+
+## v2.15.1 (2025-06-16)
+
+### Bug Fixes
+
+- **main_window**: Added expiration timer for scroll label for ClientInfoMessage
+  ([`187bf49`](https://github.com/bec-project/bec_widgets/commit/187bf493a5b18299a10939901b9ed7e308435092))
+
+- **scroll_label**: Updating label during scrolling is done imminently, regardless scrolling
+  ([`1612933`](https://github.com/bec-project/bec_widgets/commit/1612933dd9689f2bf480ad81811c051201a9ff70))
+
+
+## v2.15.0 (2025-06-15)
+
+### Bug Fixes
+
+- **main_window**: Central widget cleanup check to not remove None
+  ([`644be62`](https://github.com/bec-project/bec_widgets/commit/644be621f20cf09037da763f6217df9d1e4642bc))
+
+### Features
+
+- **main_window**: Main window can display the messages from the send_client_info as a scrolling
+  horizontal text; closes #700
+  ([`0dec78a`](https://github.com/bec-project/bec_widgets/commit/0dec78afbaddbef98d20949d3a0ba4e0dc8529df))
+
+### Refactoring
+
+- **main_window**: App id is displayed as QLabel instead of message
+  ([`57b9a57`](https://github.com/bec-project/bec_widgets/commit/57b9a57a631f267a8cb3622bf73035ffb15510e6))
+
+### Testing
+
+- **main_window**: Becmainwindow tests extended
+  ([`30acc4c`](https://github.com/bec-project/bec_widgets/commit/30acc4c236bfbfed19f56512b264a52b4359e6c1))
+
+
 ## v2.14.0 (2025-06-13)

 ### Features
--- a/bec_widgets/applications/launch_window.py
+++ b/bec_widgets/applications/launch_window.py
@@ -542,7 +542,7 @@ class LaunchWindow(BECMainWindow):
        remaining_connections = [
            connection for connection in connections.values() if connection.parent_id != self.gui_id
        ]
-        return len(remaining_connections) <= 1
+        return len(remaining_connections) <= 4

    def _turn_off_the_lights(self, connections: dict):
        """
--- a/bec_widgets/cli/client.py
+++ b/bec_widgets/cli/client.py
@@ -49,6 +49,7 @@ _Widgets = {
    "ResetButton": "ResetButton",
    "ResumeButton": "ResumeButton",
    "RingProgressBar": "RingProgressBar",
+    "SBBMonitor": "SBBMonitor",
    "ScanControl": "ScanControl",
    "ScatterWaveform": "ScatterWaveform",
    "SignalComboBox": "SignalComboBox",
@@ -474,6 +475,20 @@ class BECProgressBar(RPCBase):
        >>> progressbar.label_template = "$value / $percentage %"
        """

+    @property
+    @rpc_call
+    def state(self):
+        """
+        None
+        """
+
+    @state.setter
+    @rpc_call
+    def state(self):
+        """
+        None
+        """
+
    @rpc_call
    def _get_label(self) -> str:
        """
@@ -3235,6 +3250,12 @@ class RingProgressBar(RPCBase):
        """


+class SBBMonitor(RPCBase):
+    """A widget to display the SBB monitor website."""
+
+    ...
+
+
 class ScanControl(RPCBase):
    """Widget to submit new scans to the queue."""

@@ -3245,6 +3266,16 @@ class ScanControl(RPCBase):
        """


+class ScanProgressBar(RPCBase):
+    """Widget to display a progress bar that is hooked up to the scan progress of a scan."""
+
+    @rpc_call
+    def remove(self):
+        """
+        Cleanup the BECConnector
+        """
+
+
 class ScatterCurve(RPCBase):
    """Scatter curve item for the scatter waveform widget."""

--- a/bec_widgets/tests/utils.py
+++ b/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,16 +89,28 @@ 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,
        }
        self._info = {
            "signals": {
-                "readback": {"kind_str": "hinted"},  # hinted
-                "setpoint": {"kind_str": "normal"},  # normal
-                "velocity": {"kind_str": "config"},  # config
+                "readback": {
+                    "kind_str": "hinted",
+                    "component_name": "readback",
+                    "obj_name": self.name,
+                },  # hinted
+                "setpoint": {
+                    "kind_str": "normal",
+                    "component_name": "setpoint",
+                    "obj_name": f"{self.name}_setpoint",
+                },  # normal
+                "velocity": {
+                    "kind_str": "config",
+                    "component_name": "velocity",
+                    "obj_name": f"{self.name}_velocity",
+                },  # config
            }
        }
        self.signals = {
@@ -210,6 +222,39 @@ class DMMock:
        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),
--- a/bec_widgets/utils/expandable_frame.py
+++ b/bec_widgets/utils/expandable_frame.py
@@ -37,6 +37,16 @@ class ExpandableGroupFrame(QFrame):
        self._layout.setContentsMargins(0, 0, 0, 0)
        self.setLayout(self._layout)

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

@@ -45,6 +55,8 @@ class ExpandableGroupFrame(QFrame):
        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)

@@ -52,13 +64,6 @@ class ExpandableGroupFrame(QFrame):
        self._update_expansion_icon()
        self._title_layout.addWidget(self._expansion_button, stretch=1)

-        self._contents = QWidget(self)
-        self._layout.addWidget(self._contents)
-
-        self._expansion_button.clicked.connect(self.switch_expanded_state)
-        self.expanded = self._expanded  # type: ignore
-        self.expansion_state_changed.emit()
-
    def set_layout(self, layout: QLayout) -> None:
        self._contents.setLayout(layout)
        self._contents.layout().setContentsMargins(0, 0, 0, 0)  # type: ignore
--- a/bec_widgets/utils/filter_io.py
+++ b/bec_widgets/utils/filter_io.py
@@ -8,6 +8,8 @@ from bec_lib.logger import bec_logger
 from qtpy.QtCore import QStringListModel
 from qtpy.QtWidgets import QComboBox, QCompleter, QLineEdit

+from bec_widgets.utils.ophyd_kind_util import Kind
+
 logger = bec_logger.logger


@@ -15,11 +17,13 @@ class WidgetFilterHandler(ABC):
    """Abstract base class for widget filter handlers"""

    @abstractmethod
-    def set_selection(self, widget, selection: list) -> None:
+    def set_selection(self, widget, selection: list[str | tuple]) -> None:
        """Set the filtered_selection for the widget

        Args:
-            selection (list): Filtered selection of items
+            widget: Widget instance
+            selection (list[str | tuple]): Filtered selection of items.
+                If tuple, it contains (text, data) pairs.
        """

    @abstractmethod
@@ -34,17 +38,37 @@ class WidgetFilterHandler(ABC):
            bool: True if the input text is in the filtered selection
        """

+    @abstractmethod
+    def update_with_kind(
+        self, kind: Kind, signal_filter: set, device_info: dict, device_name: str
+    ) -> list[str | tuple]:
+        """Update the selection based on the kind of signal.
+
+        Args:
+            kind (Kind): The kind of signal to filter.
+            signal_filter (set): Set of signal kinds to filter.
+            device_info (dict): Dictionary containing device information.
+            device_name (str): Name of the device.
+
+        Returns:
+            list[str | tuple]: A list of filtered signals based on the kind.
+        """
+        # This method should be implemented in subclasses or extended as needed
+

 class LineEditFilterHandler(WidgetFilterHandler):
    """Handler for QLineEdit widget"""

-    def set_selection(self, widget: QLineEdit, selection: list) -> None:
+    def set_selection(self, widget: QLineEdit, selection: list[str | tuple]) -> None:
        """Set the selection for the widget to the completer model

        Args:
            widget (QLineEdit): The QLineEdit widget
-            selection (list): Filtered selection of items
+            selection (list[str | tuple]): Filtered selection of items. If tuple, it contains (text, data) pairs.
        """
+        if isinstance(selection, tuple):
+            # If selection is a tuple, it contains (text, data) pairs
+            selection = [text for text, _ in selection]
        if not isinstance(widget.completer, QCompleter):
            completer = QCompleter(widget)
            widget.setCompleter(completer)
@@ -64,19 +88,47 @@ class LineEditFilterHandler(WidgetFilterHandler):
        model_data = [model.data(model.index(i)) for i in range(model.rowCount())]
        return text in model_data

+    def update_with_kind(
+        self, kind: Kind, signal_filter: set, device_info: dict, device_name: str
+    ) -> list[str | tuple]:
+        """Update the selection based on the kind of signal.
+
+        Args:
+            kind (Kind): The kind of signal to filter.
+            signal_filter (set): Set of signal kinds to filter.
+            device_info (dict): Dictionary containing device information.
+            device_name (str): Name of the device.
+
+        Returns:
+            list[str | tuple]: A list of filtered signals based on the kind.
+        """
+
+        return [
+            signal
+            for signal, signal_info in device_info.items()
+            if kind in signal_filter and (signal_info.get("kind_str", None) == str(kind.name))
+        ]
+

 class ComboBoxFilterHandler(WidgetFilterHandler):
    """Handler for QComboBox widget"""

-    def set_selection(self, widget: QComboBox, selection: list) -> None:
+    def set_selection(self, widget: QComboBox, selection: list[str | tuple]) -> None:
        """Set the selection for the widget to the completer model

        Args:
            widget (QComboBox): The QComboBox widget
-            selection (list): Filtered selection of items
+            selection (list[str | tuple]): Filtered selection of items. If tuple, it contains (text, data) pairs.
        """
        widget.clear()
-        widget.addItems(selection)
+        if len(selection) == 0:
+            return
+        for element in selection:
+            if isinstance(element, str):
+                widget.addItem(element)
+            elif isinstance(element, tuple):
+                # If element is a tuple, it contains (text, data) pairs
+                widget.addItem(*element)

    def check_input(self, widget: QComboBox, text: str) -> bool:
        """Check if the input text is in the filtered selection
@@ -90,6 +142,40 @@ class ComboBoxFilterHandler(WidgetFilterHandler):
        """
        return text in [widget.itemText(i) for i in range(widget.count())]

+    def update_with_kind(
+        self, kind: Kind, signal_filter: set, device_info: dict, device_name: str
+    ) -> list[str | tuple]:
+        """Update the selection based on the kind of signal.
+
+        Args:
+            kind (Kind): The kind of signal to filter.
+            signal_filter (set): Set of signal kinds to filter.
+            device_info (dict): Dictionary containing device information.
+            device_name (str): Name of the device.
+
+        Returns:
+            list[str | tuple]: A list of filtered signals based on the kind.
+        """
+        out = []
+        for signal, signal_info in device_info.items():
+            if kind not in signal_filter or (signal_info.get("kind_str", None) != str(kind.name)):
+                continue
+            obj_name = signal_info.get("obj_name", "")
+            component_name = signal_info.get("component_name", "")
+            signal_wo_device = obj_name.removeprefix(f"{device_name}_")
+            if not signal_wo_device:
+                signal_wo_device = obj_name
+
+            if signal_wo_device != signal and component_name.replace(".", "_") != signal_wo_device:
+                # If the object name is not the same as the signal name, we use the object name
+                # to display in the combobox.
+                out.append((f"{signal_wo_device} ({signal})", signal_info))
+            else:
+                # If the object name is the same as the signal name, we do not change it.
+                out.append((signal, signal_info))
+
+        return out
+

 class FilterIO:
    """Public interface to set filters for input widgets.
@@ -99,13 +185,14 @@ class FilterIO:
    _handlers = {QLineEdit: LineEditFilterHandler, QComboBox: ComboBoxFilterHandler}

    @staticmethod
-    def set_selection(widget, selection: list, ignore_errors=True):
+    def set_selection(widget, selection: list[str | tuple], ignore_errors=True):
        """
        Retrieve value from the widget instance.

        Args:
            widget: Widget instance.
-            selection(list): List of filtered selection items.
+            selection (list[str | tuple]): Filtered selection of items.
+                If tuple, it contains (text, data) pairs.
            ignore_errors(bool, optional): Whether to ignore if no handler is found.
        """
        handler_class = FilterIO._find_handler(widget)
@@ -139,6 +226,35 @@ class FilterIO:
            )
        return None

+    @staticmethod
+    def update_with_kind(
+        widget, kind: Kind, signal_filter: set, device_info: dict, device_name: str
+    ) -> list[str | tuple]:
+        """
+        Update the selection based on the kind of signal.
+
+        Args:
+            widget: Widget instance.
+            kind (Kind): The kind of signal to filter.
+            signal_filter (set): Set of signal kinds to filter.
+            device_info (dict): Dictionary containing device information.
+            device_name (str): Name of the device.
+
+        Returns:
+            list[str | tuple]: A list of filtered signals based on the kind.
+        """
+        handler_class = FilterIO._find_handler(widget)
+        if handler_class:
+            return handler_class().update_with_kind(
+                kind=kind,
+                signal_filter=signal_filter,
+                device_info=device_info,
+                device_name=device_name,
+            )
+        raise ValueError(
+            f"No matching handler for widget type: {type(widget)} in handler list {FilterIO._handlers}"
+        )
+
    @staticmethod
    def _find_handler(widget):
        """
--- a/bec_widgets/utils/forms_from_types/forms.py
+++ b/bec_widgets/utils/forms_from_types/forms.py
@@ -1,6 +1,5 @@
 from __future__ import annotations

-from decimal import Decimal
 from types import NoneType
 from typing import NamedTuple

@@ -8,11 +7,12 @@ from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
 from pydantic import BaseModel, ValidationError
 from qtpy.QtCore import Signal  # type: ignore
-from qtpy.QtWidgets import QGridLayout, QLabel, QLayout, QSizePolicy, QVBoxLayout, QWidget
+from 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.error_popups import SafeProperty
+from bec_widgets.utils.forms_from_types import styles
 from bec_widgets.utils.forms_from_types.items import (
    DynamicFormItem,
    DynamicFormItemType,
@@ -68,15 +68,11 @@ class TypedForm(BECWidget, QWidget):
            logger.error("Must specify one and only one of items and form_item_specs!")
            items = []
        super().__init__(parent=parent, client=client, **kwargs)
-        self._items = (
-            form_item_specs
-            if form_item_specs is not None
-            else [
-                FormItemSpec(name=name, item_type=item_type, pretty_display=pretty_display)
-                for name, item_type in items  # type: ignore
-            ]
-        )
-        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
+        self._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)
@@ -84,15 +80,19 @@ class TypedForm(BECWidget, QWidget):
        self._enabled: bool = enabled

        self._form_grid_container = QWidget(parent=self)
-        self._form_grid_container.setSizePolicy(
-            QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding
-        )
+        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.MinimumExpanding)
+        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

@@ -100,6 +100,8 @@ class TypedForm(BECWidget, QWidget):
        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()
@@ -107,16 +109,16 @@ 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.MinimumExpanding)
+        widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
        grid.addWidget(widget, row, 1)

    def enumerate_form_widgets(self):
        """Return a generator over the rows of the form, with the row number, the label widget (to
-        which the field name is attached as a property), and the entry widget"""
+        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()):
+        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]:
@@ -135,7 +137,7 @@ class TypedForm(BECWidget, QWidget):
            old_layout.deleteLater()
            self._form_grid.deleteLater()
        self._form_grid = QWidget()
-        self._form_grid.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
+        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)

@@ -186,14 +188,18 @@ class PydanticModelForm(TypedForm):

        Args:
            data_model (type[BaseModel]): the model class for which to generate a form.
-            enabled (bool): whether fields are enabled for editing.
+            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._pretty_display = pretty_display
        self._md_schema = data_model
        super().__init__(
-            parent=parent, form_item_specs=self._form_item_specs(), enabled=enabled, client=client
+            parent=parent,
+            form_item_specs=self._form_item_specs(),
+            enabled=enabled,
+            client=client,
+            **kwargs,
        )

        self._validity = CompactPopupWidget()
@@ -207,6 +213,18 @@ 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()
--- a/bec_widgets/utils/forms_from_types/items.py
+++ b/bec_widgets/utils/forms_from_types/items.py
@@ -1,32 +1,43 @@
 from __future__ import annotations

+import typing
 from abc import abstractmethod
 from decimal import Decimal
 from types import GenericAlias, UnionType
-from typing import Literal
+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, 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,
@@ -36,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

@@ -123,7 +135,7 @@ class ClearableBoolEntry(QWidget):
        self._false.setToolTip(tooltip)


-DynamicFormItemType = str | int | float | Decimal | bool | dict
+DynamicFormItemType = str | int | float | Decimal | bool | dict | list | None


 class DynamicFormItem(QWidget):
@@ -146,8 +158,9 @@ class DynamicFormItem(QWidget):
        self._desc = self._spec.info.description
        self.setLayout(self._layout)
        self._add_main_widget()
-        self._main_widget: QWidget
-        self._main_widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
+        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()
@@ -167,6 +180,8 @@ class DynamicFormItem(QWidget):

    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 "")
@@ -185,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)
@@ -210,11 +225,11 @@ class StrMetadataField(DynamicFormItem):

    def setValue(self, value: str):
        if value is None:
-            self._main_widget.setText("")
+            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)
@@ -243,7 +258,7 @@ 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)
@@ -277,7 +292,7 @@ class FloatDecimalMetadataField(DynamicFormItem):
        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)
@@ -298,10 +313,26 @@ class BoolMetadataField(DynamicFormItem):
        self._main_widget.setChecked(value)


-class DictMetadataField(DynamicFormItem):
+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)
@@ -319,44 +350,263 @@ class DictMetadataField(DynamicFormItem):
        self._main_widget.replace_data(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
-    if annotation in [dict, dict | None] or (
-        isinstance(annotation, GenericAlias) and annotation.__origin__ is dict
-    ):
-        return DictMetadataField
-    if annotation in [list, list | None] or (
-        isinstance(annotation, GenericAlias) and annotation.__origin__ is list
-    ):
-        return StrMetadataField
-    else:
-        logger.warning(f"Type {annotation} is not (yet) supported in metadata form creation.")
-        return StrMetadataField
+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()
--- a/bec_widgets/widgets/containers/dock/dock_area.py
+++ b/bec_widgets/widgets/containers/dock/dock_area.py
@@ -169,6 +169,9 @@ class BECDockArea(BECWidget, QWidget):
                            tooltip="Add LogPanel - Disabled",
                            filled=True,
                        ),
+                        "sbb_monitor": MaterialIconAction(
+                            icon_name="train", tooltip="Add SBB Monitor", filled=True
+                        ),
                    },
                ),
                "separator_2": SeparatorAction(),
@@ -238,6 +241,9 @@ class BECDockArea(BECWidget, QWidget):
        # self.toolbar.widgets["menu_utils"].widgets["log_panel"].triggered.connect(
        #     lambda: self._create_widget_from_toolbar(widget_name="LogPanel")
        # )
+        self.toolbar.widgets["menu_utils"].widgets["sbb_monitor"].triggered.connect(
+            lambda: self._create_widget_from_toolbar(widget_name="SBBMonitor")
+        )

        # Icons
        self.toolbar.widgets["attach_all"].action.triggered.connect(self.attach_all)
--- a/bec_widgets/widgets/containers/main_window/addons/hover_widget.py
+++ b/bec_widgets/widgets/containers/main_window/addons/hover_widget.py
@@ -0,0 +1,115 @@
+import sys
+
+from qtpy.QtCore import QPoint, Qt
+from qtpy.QtWidgets import QApplication, QHBoxLayout, QLabel, QProgressBar, QVBoxLayout, QWidget
+
+
+class WidgetTooltip(QWidget):
+    """Frameless, always-on-top window that behaves like a tooltip."""
+
+    def __init__(self, content: QWidget) -> None:
+        super().__init__(None, Qt.ToolTip | Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)
+        self.setAttribute(Qt.WA_ShowWithoutActivating)
+        self.setMouseTracking(True)
+        self.content = content
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(6, 6, 6, 6)
+        layout.addWidget(self.content)
+        self.adjustSize()
+
+    def leaveEvent(self, _event) -> None:
+        self.hide()
+
+    def show_above(self, global_pos: QPoint, offset: int = 8) -> None:
+        self.adjustSize()
+        screen = QApplication.screenAt(global_pos) or QApplication.primaryScreen()
+        screen_geo = screen.availableGeometry()
+        geom = self.geometry()
+
+        x = global_pos.x() - geom.width() // 2
+        y = global_pos.y() - geom.height() - offset
+
+        x = max(screen_geo.left(), min(x, screen_geo.right() - geom.width()))
+        y = max(screen_geo.top(), min(y, screen_geo.bottom() - geom.height()))
+
+        self.move(x, y)
+        self.show()
+
+
+class HoverWidget(QWidget):
+
+    def __init__(self, parent: QWidget | None = None, *, simple: QWidget, full: QWidget):
+        super().__init__(parent)
+        self._simple = simple
+        self._full = full
+        self._full.setVisible(False)
+        self._tooltip = None
+
+        lay = QVBoxLayout(self)
+        lay.setContentsMargins(0, 0, 0, 0)
+        lay.addWidget(simple)
+
+    def enterEvent(self, event):
+        # suppress empty-label tooltips for labels
+        if isinstance(self._full, QLabel) and not self._full.text():
+            return
+
+        if self._tooltip is None:  # first time only
+            self._tooltip = WidgetTooltip(self._full)
+            self._full.setVisible(True)
+
+        centre = self.mapToGlobal(self.rect().center())
+        self._tooltip.show_above(centre)
+        super().enterEvent(event)
+
+    def leaveEvent(self, event):
+        if self._tooltip and self._tooltip.isVisible():
+            self._tooltip.hide()
+        super().leaveEvent(event)
+
+    def close(self):
+        if self._tooltip:
+            self._tooltip.close()
+            self._tooltip.deleteLater()
+            self._tooltip = None
+        super().close()
+
+
+################################################################################
+# Demo
+# Just a simple example to show how the HoverWidget can be used to display
+# a tooltip with a full widget inside (two different widgets are used
+# for the simple and full versions).
+################################################################################
+
+
+class DemoSimpleWidget(QLabel):  # pragma: no cover
+    """A simple widget to be used as a trigger for the tooltip."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setText("Hover me for a preview!")
+
+
+class DemoFullWidget(QProgressBar):  # pragma: no cover
+    """A full widget to be shown in the tooltip."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setRange(0, 100)
+        self.setValue(75)
+        self.setFixedWidth(320)
+        self.setFixedHeight(30)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app = QApplication(sys.argv)
+
+    window = QWidget()
+    window.layout = QHBoxLayout(window)
+    hover_widget = HoverWidget(simple=DemoSimpleWidget(), full=DemoFullWidget())
+    window.layout.addWidget(hover_widget)
+    window.show()
+
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/containers/main_window/addons/scroll_label.py
+++ b/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()
--- a/bec_widgets/widgets/containers/main_window/main_window.py
+++ b/bec_widgets/widgets/containers/main_window/main_window.py
@@ -1,17 +1,31 @@
+from __future__ import annotations
+
 import os

-from qtpy.QtCore import QEvent, QSize
+from bec_lib.endpoints import MessageEndpoints
+from qtpy.QtCore import QEasingCurve, QEvent, QPropertyAnimation, QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QActionGroup, QIcon
-from qtpy.QtWidgets import QApplication, QMainWindow, QStyle
+from qtpy.QtWidgets import (
+    QApplication,
+    QFrame,
+    QHBoxLayout,
+    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.hover_widget import HoverWidget
+from bec_widgets.widgets.containers.main_window.addons.scroll_label import ScrollLabel
 from bec_widgets.widgets.containers.main_window.addons.web_links import BECWebLinksMixin
+from bec_widgets.widgets.progress.scan_progressbar.scan_progressbar import ScanProgressBar

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

@@ -19,6 +33,8 @@ MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 class BECMainWindow(BECWidget, QMainWindow):
    RPC = False
    PLUGIN = False
+    SCAN_PROGRESS_WIDTH = 100  # px
+    STATUS_BAR_WIDGETS_EXPIRE_TIME = 60_000  # milliseconds

    def __init__(
        self,
@@ -32,10 +48,19 @@ class BECMainWindow(BECWidget, QMainWindow):
        super().__init__(parent=parent, gui_id=gui_id, **kwargs)

        self.app = QApplication.instance()
+        self.status_bar = self.statusBar()
        self.setWindowTitle(window_title)
        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 +68,189 @@ 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.
+        """
+
+        # Left: App‑ID label
+        self._app_id_label = QLabel()
+        self._app_id_label.setAlignment(
+            Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter
+        )
+        self.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._add_client_info_label()
+
+        # Add scan_progress bar with display logic
+        self._add_scan_progress_bar()
+
+    ################################################################################
+    # Client message status bar widget helpers
+
+    def _add_client_info_label(self):
+        """
+        Add a client info label to the status bar.
+        This label will display messages from the BEC dispatcher.
+        """
+
+        # Scroll label for client info in Status Bar
+        self._client_info_label = ScrollLabel(self)
+        self._client_info_label.setAlignment(
+            Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter
+        )
+        # Full label used in the hover widget
+        self._client_info_label_full = QLabel(self)
+        self._client_info_label_full.setAlignment(
+            Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter
+        )
+        # Hover widget to show the full client info label
+        self._client_info_hover = HoverWidget(
+            self, simple=self._client_info_label, full=self._client_info_label_full
+        )
+        self.status_bar.addWidget(self._client_info_hover, 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(""))
+        self._client_info_expire_timer.timeout.connect(
+            lambda: self._client_info_label_full.setText("")
+        )
+
+    ################################################################################
+    # Progress‑bar helpers
+    def _add_scan_progress_bar(self):
+
+        # Setting HoverWidget for the scan progress bar - minimal and full version
+        self._scan_progress_bar_simple = ScanProgressBar(self, one_line_design=True)
+        self._scan_progress_bar_simple.show_elapsed_time = False
+        self._scan_progress_bar_simple.show_remaining_time = False
+        self._scan_progress_bar_simple.show_source_label = False
+        self._scan_progress_bar_simple.progressbar.label_template = ""
+        self._scan_progress_bar_simple.progressbar.setFixedHeight(8)
+        self._scan_progress_bar_simple.progressbar.setFixedWidth(80)
+        self._scan_progress_bar_full = ScanProgressBar(self)
+        self._scan_progress_hover = HoverWidget(
+            self, simple=self._scan_progress_bar_simple, full=self._scan_progress_bar_full
+        )
+
+        # Bundle the progress bar with a separator
+        separator = self._add_separator(separate_object=True)
+        self._scan_progress_bar_with_separator = QWidget()
+        self._scan_progress_bar_with_separator.layout = QHBoxLayout(
+            self._scan_progress_bar_with_separator
+        )
+        self._scan_progress_bar_with_separator.layout.setContentsMargins(0, 0, 0, 0)
+        self._scan_progress_bar_with_separator.layout.setSpacing(0)
+        self._scan_progress_bar_with_separator.layout.addWidget(separator)
+        self._scan_progress_bar_with_separator.layout.addWidget(self._scan_progress_hover)
+
+        # Set Size
+        self._scan_progress_bar_target_width = self.SCAN_PROGRESS_WIDTH
+        self._scan_progress_bar_with_separator.setMaximumWidth(self._scan_progress_bar_target_width)
+
+        self.status_bar.addWidget(self._scan_progress_bar_with_separator)
+
+        # Visibility logic
+        self._scan_progress_bar_with_separator.hide()
+        self._scan_progress_bar_with_separator.setMaximumWidth(0)
+
+        # Timer for hiding logic
+        self._scan_progress_hide_timer = QTimer(self)
+        self._scan_progress_hide_timer.setSingleShot(True)
+        self._scan_progress_hide_timer.setInterval(self.STATUS_BAR_WIDGETS_EXPIRE_TIME)
+        self._scan_progress_hide_timer.timeout.connect(self._animate_hide_scan_progress_bar)
+
+        # Show / hide behaviour
+        self._scan_progress_bar_simple.progress_started.connect(self._show_scan_progress_bar)
+        self._scan_progress_bar_simple.progress_finished.connect(self._delay_hide_scan_progress_bar)
+
+    def _show_scan_progress_bar(self):
+        if self._scan_progress_hide_timer.isActive():
+            self._scan_progress_hide_timer.stop()
+        if self._scan_progress_bar_with_separator.isVisible():
+            return
+
+        # Make visible and reset width
+        self._scan_progress_bar_with_separator.show()
+        self._scan_progress_bar_with_separator.setMaximumWidth(0)
+
+        self._show_container_anim = QPropertyAnimation(
+            self._scan_progress_bar_with_separator, b"maximumWidth", self
+        )
+        self._show_container_anim.setDuration(300)
+        self._show_container_anim.setStartValue(0)
+        self._show_container_anim.setEndValue(self._scan_progress_bar_target_width)
+        self._show_container_anim.setEasingCurve(QEasingCurve.OutCubic)
+        self._show_container_anim.start()
+
+    def _delay_hide_scan_progress_bar(self):
+        """Start the countdown to hide the scan progress bar."""
+        if hasattr(self, "_scan_progress_hide_timer"):
+            self._scan_progress_hide_timer.start()
+
+    def _animate_hide_scan_progress_bar(self):
+        """Shrink container to the right, then hide."""
+        self._hide_container_anim = QPropertyAnimation(
+            self._scan_progress_bar_with_separator, b"maximumWidth", self
+        )
+        self._hide_container_anim.setDuration(300)
+        self._hide_container_anim.setStartValue(self._scan_progress_bar_with_separator.width())
+        self._hide_container_anim.setEndValue(0)
+        self._hide_container_anim.setEasingCurve(QEasingCurve.InCubic)
+        self._hide_container_anim.finished.connect(self._scan_progress_bar_with_separator.hide)
+        self._hide_container_anim.start()
+
+    def _add_separator(self, separate_object: bool = False) -> QWidget | None:
+        """
+        Add a vertically centred separator to the status bar or just return it as a separate object.
+        """
+        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())
+
+        if separate_object:
+            return wrapper
+        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,8 +338,52 @@ 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.
+        """
+        message = msg.get("message", "")
+        expiration = msg.get("expire", 0)  # 0 → never expire
+        self._client_info_label.setText(message)
+        self._client_info_label_full.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):
@@ -175,8 +393,9 @@ class BECMainWindow(BECWidget, QMainWindow):

    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
@@ -187,8 +406,39 @@ class BECMainWindow(BECWidget, QMainWindow):
                    child.cleanup()
                    child.close()
                    child.deleteLater()
+
+        # Timer cleanup
+        if hasattr(self, "_client_info_expire_timer") and self._client_info_expire_timer.isActive():
+            self._client_info_expire_timer.stop()
+        if hasattr(self, "_scan_progress_hide_timer") and self._scan_progress_hide_timer.isActive():
+            self._scan_progress_hide_timer.stop()
+
+        ########################################
+        # Status bar widgets cleanup
+
+        # Client info label cleanup
+        self._client_info_label.cleanup()
+        self._client_info_hover.close()
+        self._client_info_hover.deleteLater()
+        # Scan progress bar cleanup
+        self._scan_progress_bar_simple.close()
+        self._scan_progress_bar_simple.deleteLater()
+        self._scan_progress_bar_full.close()
+        self._scan_progress_bar_full.deleteLater()
+        self._scan_progress_hover.close()
+        self._scan_progress_hover.deleteLater()
        super().cleanup()


 class UILaunchWindow(BECMainWindow):
    RPC = True
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    main_window = UILaunchWindow()
+    main_window.show()
+    main_window.resize(800, 600)
+    sys.exit(app.exec())
--- a/bec_widgets/widgets/control/device_input/base_classes/device_input_base.py
+++ b/bec_widgets/widgets/control/device_input/base_classes/device_input_base.py
@@ -6,10 +6,10 @@ from bec_lib.device import ComputedSignal, Device, Positioner, ReadoutPriority
 from bec_lib.device import Signal as BECSignal
 from bec_lib.logger import bec_logger
 from pydantic import field_validator
-from qtpy.QtCore import Property, Signal, Slot

 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.filter_io import FilterIO
 from bec_widgets.utils.widget_io import WidgetIO

@@ -100,7 +100,7 @@ class DeviceInputBase(BECWidget):

    ### QtSlots ###

-    @Slot(str)
+    @SafeSlot(str)
    def set_device(self, device: str):
        """
        Set the device.
@@ -114,7 +114,7 @@ class DeviceInputBase(BECWidget):
        else:
            logger.warning(f"Device {device} is not in the filtered selection.")

-    @Slot()
+    @SafeSlot()
    def update_devices_from_filters(self):
        """Update the devices based on the current filter selection
        in self.device_filter and self.readout_filter. If apply_filter is False,
@@ -133,7 +133,7 @@ class DeviceInputBase(BECWidget):
        self.devices = [device.name for device in devs]
        self.set_device(current_device)

-    @Slot(list)
+    @SafeSlot(list)
    def set_available_devices(self, devices: list[str]):
        """
        Set the devices. If a device in the list is not valid, it will not be considered.
@@ -146,7 +146,7 @@ class DeviceInputBase(BECWidget):

    ### QtProperties ###

-    @Property(
+    @SafeProperty(
        "QStringList",
        doc="List of devices. If updated, it will disable the apply filters property.",
    )
@@ -165,7 +165,7 @@ class DeviceInputBase(BECWidget):
        self.config.devices = value
        FilterIO.set_selection(widget=self, selection=value)

-    @Property(str)
+    @SafeProperty(str)
    def default(self):
        """Get the default device name. If set through this property, it will update only if the device is within the filtered selection."""
        return self.config.default
@@ -177,7 +177,7 @@ class DeviceInputBase(BECWidget):
        self.config.default = value
        WidgetIO.set_value(widget=self, value=value)

-    @Property(bool)
+    @SafeProperty(bool)
    def apply_filter(self):
        """Apply the filters on the devices."""
        return self.config.apply_filter
@@ -187,7 +187,7 @@ class DeviceInputBase(BECWidget):
        self.config.apply_filter = value
        self.update_devices_from_filters()

-    @Property(bool)
+    @SafeProperty(bool)
    def filter_to_device(self):
        """Include devices in filters."""
        return BECDeviceFilter.DEVICE in self.device_filter
@@ -200,7 +200,7 @@ class DeviceInputBase(BECWidget):
            self._device_filter.remove(BECDeviceFilter.DEVICE)
        self.update_devices_from_filters()

-    @Property(bool)
+    @SafeProperty(bool)
    def filter_to_positioner(self):
        """Include devices of type Positioner in filters."""
        return BECDeviceFilter.POSITIONER in self.device_filter
@@ -213,7 +213,7 @@ class DeviceInputBase(BECWidget):
            self._device_filter.remove(BECDeviceFilter.POSITIONER)
        self.update_devices_from_filters()

-    @Property(bool)
+    @SafeProperty(bool)
    def filter_to_signal(self):
        """Include devices of type Signal in filters."""
        return BECDeviceFilter.SIGNAL in self.device_filter
@@ -226,7 +226,7 @@ class DeviceInputBase(BECWidget):
            self._device_filter.remove(BECDeviceFilter.SIGNAL)
        self.update_devices_from_filters()

-    @Property(bool)
+    @SafeProperty(bool)
    def filter_to_computed_signal(self):
        """Include devices of type ComputedSignal in filters."""
        return BECDeviceFilter.COMPUTED_SIGNAL in self.device_filter
@@ -239,7 +239,7 @@ class DeviceInputBase(BECWidget):
            self._device_filter.remove(BECDeviceFilter.COMPUTED_SIGNAL)
        self.update_devices_from_filters()

-    @Property(bool)
+    @SafeProperty(bool)
    def readout_monitored(self):
        """Include devices with readout priority Monitored in filters."""
        return ReadoutPriority.MONITORED in self.readout_filter
@@ -252,7 +252,7 @@ class DeviceInputBase(BECWidget):
            self._readout_filter.remove(ReadoutPriority.MONITORED)
        self.update_devices_from_filters()

-    @Property(bool)
+    @SafeProperty(bool)
    def readout_baseline(self):
        """Include devices with readout priority Baseline in filters."""
        return ReadoutPriority.BASELINE in self.readout_filter
@@ -265,7 +265,7 @@ class DeviceInputBase(BECWidget):
            self._readout_filter.remove(ReadoutPriority.BASELINE)
        self.update_devices_from_filters()

-    @Property(bool)
+    @SafeProperty(bool)
    def readout_async(self):
        """Include devices with readout priority Async in filters."""
        return ReadoutPriority.ASYNC in self.readout_filter
@@ -278,7 +278,7 @@ class DeviceInputBase(BECWidget):
            self._readout_filter.remove(ReadoutPriority.ASYNC)
        self.update_devices_from_filters()

-    @Property(bool)
+    @SafeProperty(bool)
    def readout_continuous(self):
        """Include devices with readout priority continuous in filters."""
        return ReadoutPriority.CONTINUOUS in self.readout_filter
@@ -291,7 +291,7 @@ class DeviceInputBase(BECWidget):
            self._readout_filter.remove(ReadoutPriority.CONTINUOUS)
        self.update_devices_from_filters()

-    @Property(bool)
+    @SafeProperty(bool)
    def readout_on_request(self):
        """Include devices with readout priority OnRequest in filters."""
        return ReadoutPriority.ON_REQUEST in self.readout_filter
--- a/bec_widgets/widgets/control/device_input/base_classes/device_signal_input_base.py
+++ b/bec_widgets/widgets/control/device_input/base_classes/device_signal_input_base.py
@@ -6,7 +6,7 @@ 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.filter_io import FilterIO, LineEditFilterHandler
 from bec_widgets.utils.ophyd_kind_util import Kind
 from bec_widgets.utils.widget_io import WidgetIO

@@ -55,7 +55,7 @@ class DeviceSignalInputBase(BECWidget):
        self._hinted_signals = []
        self._normal_signals = []
        self._config_signals = []
-        self.bec_dispatcher.client.callbacks.register(
+        self._device_update_register = self.bec_dispatcher.client.callbacks.register(
            EventType.DEVICE_UPDATE, self.update_signals_from_filters
        )

@@ -108,25 +108,32 @@ class DeviceSignalInputBase(BECWidget):
        if not self.validate_device(self._device):
            self._device = None
            self.config.device = self._device
-            return
-        device = self.get_device_object(self._device)
-        # See above convention for Signals and ComputedSignals
-        if isinstance(device, Signal):
-            self._signals = [self._device]
-            self._hinted_signals = [self._device]
+            self._signals = []
+            self._hinted_signals = []
            self._normal_signals = []
            self._config_signals = []
            FilterIO.set_selection(widget=self, selection=self._signals)
            return
+        device = self.get_device_object(self._device)
        device_info = device._info.get("signals", {})

+        # See above convention for Signals and ComputedSignals
+        if isinstance(device, Signal):
+            self._signals = [(self._device, {})]
+            self._hinted_signals = [(self._device, {})]
+            self._normal_signals = []
+            self._config_signals = []
+            FilterIO.set_selection(widget=self, selection=self._signals)
+            return
+
        def _update(kind: Kind):
-            return [
-                signal
-                for signal, signal_info in device_info.items()
-                if kind in self.signal_filter
-                and (signal_info.get("kind_str", None) == str(kind.name))
-            ]
+            return FilterIO.update_with_kind(
+                widget=self,
+                kind=kind,
+                signal_filter=self.signal_filter,
+                device_info=device_info,
+                device_name=self._device,
+            )

        self._hinted_signals = _update(Kind.hinted)
        self._normal_signals = _update(Kind.normal)
@@ -271,11 +278,21 @@ class DeviceSignalInputBase(BECWidget):
        Args:
            signal(str): Signal to validate.
        """
-        if signal in self.signals:
-            return True
+        for entry in self.signals:
+            if isinstance(entry, tuple):
+                entry = entry[0]
+            if entry == signal:
+                return True
        return False

    def _process_config_input(self, config: DeviceSignalInputBaseConfig | dict | None):
        if config is None:
            return DeviceSignalInputBaseConfig(widget_class=self.__class__.__name__)
        return DeviceSignalInputBaseConfig.model_validate(config)
+
+    def cleanup(self):
+        """
+        Cleanup the widget.
+        """
+        self.bec_dispatcher.client.callbacks.remove(self._device_update_register)
+        super().cleanup()
--- a/bec_widgets/widgets/control/device_input/device_combobox/device_combobox.py
+++ b/bec_widgets/widgets/control/device_input/device_combobox/device_combobox.py
@@ -34,6 +34,7 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
    PLUGIN = True

    device_selected = Signal(str)
+    device_reset = Signal()
    device_config_update = Signal()

    def __init__(
@@ -147,6 +148,7 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
            self.device_selected.emit(input_text)
        else:
            self._is_valid_input = False
+            self.device_reset.emit()
        self.update()

    def validate_device(self, device: str) -> bool:  # type: ignore[override]
--- a/bec_widgets/widgets/control/device_input/signal_combobox/signal_combobox.py
+++ b/bec_widgets/widgets/control/device_input/signal_combobox/signal_combobox.py
@@ -90,6 +90,44 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
                self.insertItem(0, "Hinted Signals")
                self.model().item(0).setEnabled(False)

+    def set_to_obj_name(self, obj_name: str) -> bool:
+        """
+        Set the combobox to the object name of the signal.
+
+        Args:
+            obj_name (str): Object name of the signal.
+
+        Returns:
+            bool: True if the object name was found and set, False otherwise.
+        """
+        for i in range(self.count()):
+            signal_data = self.itemData(i)
+            if signal_data and signal_data.get("obj_name") == obj_name:
+                self.setCurrentIndex(i)
+                return True
+        return False
+
+    def set_to_first_enabled(self) -> bool:
+        """
+        Set the combobox to the first enabled item.
+
+        Returns:
+            bool: True if an enabled item was found and set, False otherwise.
+        """
+        for i in range(self.count()):
+            if self.model().item(i).isEnabled():
+                self.setCurrentIndex(i)
+                return True
+        return False
+
+    @SafeSlot()
+    def reset_selection(self):
+        """Reset the selection of the combobox."""
+        self.clear()
+        self.setItemText(0, "Select a device")
+        self.update_signals_from_filters()
+        self.device_signal_changed.emit("")
+
    @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.
@@ -102,11 +140,7 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
            return
        if self.validate_signal(text) is False:
            return
-        if text == "readback" and isinstance(self.get_device_object(self.device), Positioner):
-            device_signal = self.device
-        else:
-            device_signal = f"{self.device}_{text}"
-        self.device_signal_changed.emit(device_signal)
+        self.device_signal_changed.emit(text)


 if __name__ == "__main__":  # pragma: no cover
--- a/bec_widgets/widgets/control/scan_control/scan_control.py
+++ b/bec_widgets/widgets/control/scan_control/scan_control.py
@@ -203,35 +203,40 @@ class ScanControl(BECWidget, QWidget):
        """
        Requests the last executed scan parameters from BEC and restores them to the scan control widget.
        """
-        enabled = self.toggle.checked
-        current_scan = self.comboBox_scan_selection.currentText()
-        if enabled:
-            history = self.client.connector.lrange(MessageEndpoints.scan_queue_history(), 0, -1)
+        self.last_scan_found = False
+        if not self.toggle.checked:
+            return

-            for scan in history:
-                scan_name = scan.content["info"]["request_blocks"][-1]["msg"].content["scan_type"]
-                if scan_name == current_scan:
-                    args_dict = scan.content["info"]["request_blocks"][-1]["msg"].content[
-                        "parameter"
-                    ]["args"]
-                    args_list = []
-                    for key, value in args_dict.items():
-                        args_list.append(key)
-                        args_list.extend(value)
-                    if len(args_list) > 1 and self.arg_box is not None:
-                        self.arg_box.set_parameters(args_list)
-                    kwargs = scan.content["info"]["request_blocks"][-1]["msg"].content["parameter"][
-                        "kwargs"
-                    ]
-                    if kwargs and self.kwarg_boxes:
-                        for box in self.kwarg_boxes:
-                            box.set_parameters(kwargs)
-                    self.last_scan_found = True
-                    break
-                else:
-                    self.last_scan_found = False
-        else:
-            self.last_scan_found = False
+        current_scan = self.comboBox_scan_selection.currentText()
+        history = (
+            self.client.connector.xread(
+                MessageEndpoints.scan_history(), from_start=True, user_id=self.object_name
+            )
+            or []
+        )
+
+        for scan in reversed(history):
+            scan_data = scan.get("data")
+            if not scan_data:
+                continue
+
+            if scan_data.scan_name != current_scan:
+                continue
+
+            ri = getattr(scan_data, "request_inputs", {}) or {}
+            args_list = ri.get("arg_bundle", [])
+            if args_list and self.arg_box:
+                self.arg_box.set_parameters(args_list)
+
+            inputs = ri.get("inputs", {})
+            kwargs = ri.get("kwargs", {})
+            merged = {**inputs, **kwargs}
+            if merged and self.kwarg_boxes:
+                for box in self.kwarg_boxes:
+                    box.set_parameters(merged)
+
+            self.last_scan_found = True
+            break

    @SafeProperty(str)
    def current_scan(self):
--- a/bec_widgets/widgets/editors/dict_backed_table.py
+++ b/bec_widgets/widgets/editors/dict_backed_table.py
@@ -4,6 +4,7 @@ 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,
@@ -14,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):
@@ -26,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
@@ -51,7 +55,10 @@ class DictBackedTableModel(QAbstractTableModel):
                Qt.ItemDataRole.EditRole,
                Qt.ItemDataRole.ToolTipRole,
            ]:
-                return str(self._data[index.row()][index.column()])
+                try:
+                    return str(self._data[index.row()][index.column()])
+                except IndexError:
+                    return None

    def setData(self, index, value, role):
        if role == Qt.ItemDataRole.EditRole:
@@ -63,9 +70,10 @@ class DictBackedTableModel(QAbstractTableModel):
        return False

    def replaceData(self, data: dict):
+        self.delete_rows(list(range(len(self._data))))
        self.resetInternalData()
-        self._data = [[k, v] for k, v in data.items()]
-        self.dataChanged.emit(self.index(0, 0), self.index(len(self._data), 0))
+        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.
@@ -76,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 :]]
@@ -105,24 +113,39 @@ 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_changed = Signal(dict)

-    def __init__(self, parent: QWidget | None = None, 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.

@@ -133,15 +156,25 @@ class DictBackedTable(QWidget):

        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.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()
@@ -157,8 +190,12 @@ class DictBackedTable(QWidget):
        self._add_button.clicked.connect(self._table_model.add_row)
        self._remove_button.clicked.connect(self.delete_selected_rows)
        self.delete_rows.connect(self._table_model.delete_rows)
+
        self._table_model.dataChanged.connect(lambda *_: self.data_changed.emit(self.dump_dict()))

+    def set_default(self, value: dict | None):
+        self._table_model.set_default(value)
+
    def set_button_visibility(self, value: bool):
        self._button_holder.setVisible(value)

@@ -166,8 +203,8 @@ class DictBackedTable(QWidget):
    def clear(self):
        self._table_model.replaceData({})

-    def replace_data(self, data: dict):
-        self._table_model.replaceData(data)
+    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"""
@@ -187,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
--- a/bec_widgets/widgets/editors/sbb_monitor/init.py
+++ b/bec_widgets/widgets/editors/sbb_monitor/init.py
--- a/bec_widgets/widgets/editors/sbb_monitor/register_sbb_monitor.py
+++ b/bec_widgets/widgets/editors/sbb_monitor/register_sbb_monitor.py
@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.editors.sbb_monitor.sbb_monitor_plugin import SBBMonitorPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(SBBMonitorPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/widgets/editors/sbb_monitor/sbb_monitor.py
+++ b/bec_widgets/widgets/editors/sbb_monitor/sbb_monitor.py
@@ -0,0 +1,15 @@
+from bec_widgets.widgets.editors.website.website import WebsiteWidget
+
+
+class SBBMonitor(WebsiteWidget):
+    """
+    A widget to display the SBB monitor website.
+    """
+
+    PLUGIN = True
+    ICON_NAME = "train"
+    USER_ACCESS = []
+
+    def __init__(self, parent=None, **kwargs):
+        url = "https://free.oevplus.ch/monitor/?viewType=splitView&layout=1&showClock=true&showPerron=true&stationGroup1Title=Villigen%2C%20PSI%20West&stationGroup2Title=Siggenthal-Würenlingen&station_1_id=85%3A3592&station_1_name=Villigen%2C%20PSI%20West&station_1_quantity=5&station_1_group=1&station_2_id=85%3A3502&station_2_name=Siggenthal-Würenlingen&station_2_quantity=5&station_2_group=2"
+        super().__init__(parent=parent, url=url, **kwargs)
--- a/bec_widgets/widgets/editors/sbb_monitor/sbb_monitor.pyproject
+++ b/bec_widgets/widgets/editors/sbb_monitor/sbb_monitor.pyproject
@@ -0,0 +1 @@
+{'files': ['sbb_monitor.py']}
--- a/bec_widgets/widgets/editors/sbb_monitor/sbb_monitor_plugin.py
+++ b/bec_widgets/widgets/editors/sbb_monitor/sbb_monitor_plugin.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.editors.sbb_monitor.sbb_monitor import SBBMonitor
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='SBBMonitor' name='sbb_monitor'>
+    </widget>
+</ui>
+"""
+
+
+class SBBMonitorPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = SBBMonitor(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return ""
+
+    def icon(self):
+        return designer_material_icon(SBBMonitor.ICON_NAME)
+
+    def includeFile(self):
+        return "sbb_monitor"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "SBBMonitor"
+
+    def toolTip(self):
+        return ""
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/widgets/editors/scan_metadata/_util.py
+++ b/bec_widgets/widgets/editors/scan_metadata/_util.py
@@ -67,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
+    )
--- a/bec_widgets/widgets/plots/scatter_waveform/settings/scatter_curve_settings_horizontal.ui
+++ b/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>
--- a/bec_widgets/widgets/plots/waveform/settings/curve_settings/curve_setting.py
+++ b/bec_widgets/widgets/plots/waveform/settings/curve_settings/curve_setting.py
@@ -2,12 +2,12 @@ from __future__ import annotations

 from typing import TYPE_CHECKING

+from qtpy.QtCore import QSize, Qt
 from qtpy.QtWidgets import (
    QComboBox,
    QGroupBox,
    QHBoxLayout,
    QLabel,
-    QLineEdit,
    QSizePolicy,
    QVBoxLayout,
    QWidget,
@@ -15,9 +15,8 @@ from qtpy.QtWidgets import (

 from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.settings_dialog import SettingWidget
-from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
-    DeviceLineEdit,
-)
+from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
+from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
 from bec_widgets.widgets.plots.waveform.settings.curve_settings.curve_tree import CurveTree

 if TYPE_CHECKING:  # pragma: no cover
@@ -29,13 +28,18 @@ class CurveSetting(SettingWidget):
        super().__init__(parent=parent, *args, **kwargs)
        self.setProperty("skip_settings", True)
        self.target_widget = target_widget
+        self._x_settings_connected = False

        self.layout = QVBoxLayout(self)

        self._init_x_box()
        self._init_y_box()

-        self.setFixedWidth(580)  # TODO height is still debate
+    def sizeHint(self) -> QSize:
+        """
+        Returns the size hint for the settings widget.
+        """
+        return QSize(800, 500)

    def _init_x_box(self):
        self.x_axis_box = QGroupBox("X Axis")
@@ -46,15 +50,23 @@ class CurveSetting(SettingWidget):
        self.mode_combo_label = QLabel("Mode")
        self.mode_combo = QComboBox()
        self.mode_combo.addItems(["auto", "index", "timestamp", "device"])
+        self.mode_combo.setMinimumWidth(120)

        self.spacer = QWidget()
        self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)

        self.device_x_label = QLabel("Device")
-        self.device_x = DeviceLineEdit(parent=self)
+        self.device_x = DeviceComboBox(parent=self)
+        self.device_x.insertItem(0, "")
+        self.device_x.setEditable(True)
+        self.device_x.setMinimumWidth(180)

        self.signal_x_label = QLabel("Signal")
-        self.signal_x = QLineEdit()
+        self.signal_x = SignalComboBox(parent=self)
+        self.signal_x.include_config_signals = False
+        self.signal_x.insertItem(0, "")
+        self.signal_x.setEditable(True)
+        self.signal_x.setMinimumWidth(180)

        self._get_x_mode_from_waveform()
        self.switch_x_device_selection()
@@ -80,11 +92,32 @@ class CurveSetting(SettingWidget):

    def switch_x_device_selection(self):
        if self.mode_combo.currentText() == "device":
+            self._x_settings_connected = True
+            self.device_x.currentTextChanged.connect(self.signal_x.set_device)
+            self.device_x.device_reset.connect(self.signal_x.reset_selection)
+
            self.device_x.setEnabled(True)
-            self.device_x.setText(self.target_widget.x_axis_mode["name"])
-            self.signal_x.setText(self.target_widget.x_axis_mode["entry"])
+            self.signal_x.setEnabled(True)
+            item = self.device_x.findText(self.target_widget.x_axis_mode["name"])
+            self.device_x.setCurrentIndex(item if item != -1 else 0)
+            signal_x = self.target_widget.x_axis_mode.get("entry", "")
+            if signal_x:
+                self.signal_x.set_to_obj_name(signal_x)
+            else:
+                # If no match is found, set to the first enabled item
+                if not self.signal_x.set_to_first_enabled():
+                    # If no enabled item is found, set to the first item
+                    self.signal_x.setCurrentIndex(0)
        else:
            self.device_x.setEnabled(False)
+            self.signal_x.setEnabled(False)
+            self.device_x.setCurrentIndex(0)
+            self.signal_x.setCurrentIndex(0)
+
+            if self._x_settings_connected:
+                self._x_settings_connected = False
+                self.device_x.currentTextChanged.disconnect(self.signal_x.set_device)
+                self.device_x.device_reset.disconnect(self.signal_x.reset_selection)

    def _init_y_box(self):
        self.y_axis_box = QGroupBox("Y Axis")
@@ -97,16 +130,17 @@ class CurveSetting(SettingWidget):

        self.layout.addWidget(self.y_axis_box)

-    @SafeSlot()
+    @SafeSlot(popup_error=True)
    def accept_changes(self):
        """
        Accepts the changes made in the settings widget and applies them to the target widget.
        """
        if self.mode_combo.currentText() == "device":
-            self.target_widget.x_mode = self.device_x.text()
-            signal_x = self.signal_x.text()
+            self.target_widget.x_mode = self.device_x.currentText()
+            signal_x = self.signal_x.currentText()
+            signal_data = self.signal_x.itemData(self.signal_x.currentIndex())
            if signal_x != "":
-                self.target_widget.x_entry = signal_x
+                self.target_widget.x_entry = signal_data.get("obj_name", signal_x)
        else:
            self.target_widget.x_mode = self.mode_combo.currentText()
        self.curve_manager.send_curve_json()
@@ -121,5 +155,7 @@ class CurveSetting(SettingWidget):
        """Cleanup the widget."""
        self.device_x.close()
        self.device_x.deleteLater()
+        self.signal_x.close()
+        self.signal_x.deleteLater()
        self.curve_manager.close()
        self.curve_manager.deleteLater()
--- a/bec_widgets/widgets/plots/waveform/settings/curve_settings/curve_tree.py
+++ b/bec_widgets/widgets/plots/waveform/settings/curve_settings/curve_tree.py
@@ -5,13 +5,12 @@ from typing import TYPE_CHECKING

 from bec_lib.logger import bec_logger
 from bec_qthemes._icon.material_icons import material_icon
-from qtpy.QtGui import QColor
+from qtpy.QtCore import Qt
 from qtpy.QtWidgets import (
-    QColorDialog,
    QComboBox,
    QHBoxLayout,
+    QHeaderView,
    QLabel,
-    QLineEdit,
    QPushButton,
    QSizePolicy,
    QSpinBox,
@@ -27,9 +26,8 @@ from bec_widgets.utils import ConnectionConfig, EntryValidator
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import Colors
 from bec_widgets.utils.toolbar import MaterialIconAction, ModularToolBar
-from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
-    DeviceLineEdit,
-)
+from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
+from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
 from bec_widgets.widgets.dap.dap_combo_box.dap_combo_box import DapComboBox
 from bec_widgets.widgets.plots.waveform.curve import CurveConfig, DeviceSignal
 from bec_widgets.widgets.utility.visual.color_button_native.color_button_native import (
@@ -125,11 +123,30 @@ class CurveRow(QTreeWidgetItem):
        """Create columns 1 and 2. For device rows, we have device/entry edits; for dap rows, label/model combo."""
        if self.source == "device":
            # Device row: columns 1..2 are device line edits
-            self.device_edit = DeviceLineEdit(parent=self.tree)
-            self.entry_edit = QLineEdit(parent=self.tree)  # TODO in future will be signal line edit
+            self.device_edit = DeviceComboBox(parent=self.tree)
+            self.device_edit.insertItem(0, "")
+            self.device_edit.setEditable(True)
+            self.entry_edit = SignalComboBox(parent=self.tree)
+            self.entry_edit.include_config_signals = False
+            self.entry_edit.insertItem(0, "")
+            self.entry_edit.setEditable(True)
+            self.device_edit.currentTextChanged.connect(self.entry_edit.set_device)
+            self.device_edit.device_reset.connect(self.entry_edit.reset_selection)
            if self.config.signal:
-                self.device_edit.setText(self.config.signal.name or "")
-                self.entry_edit.setText(self.config.signal.entry or "")
+                device_index = self.device_edit.findText(self.config.signal.name or "")
+                if device_index >= 0:
+                    self.device_edit.setCurrentIndex(device_index)
+                    # Force the entry_edit to update based on the device name
+                    self.device_edit.currentTextChanged.emit(self.device_edit.currentText())
+                else:
+                    # If the device name is not found, set the first enabled item
+                    self.device_edit.setCurrentIndex(0)
+
+                if not self.entry_edit.set_to_obj_name(self.config.signal.entry):
+                    # If the entry is not found, try to set it to the first enabled item
+                    if not self.entry_edit.set_to_first_enabled():
+                        # If no enabled item is found, set to the first item
+                        self.entry_edit.setCurrentIndex(0)

            self.tree.setItemWidget(self, 1, self.device_edit)
            self.tree.setItemWidget(self, 2, self.entry_edit)
@@ -236,6 +253,11 @@ class CurveRow(QTreeWidgetItem):
            self.device_edit.deleteLater()
            self.device_edit = None

+        if getattr(self, "entry_edit", None) is not None:
+            self.entry_edit.close()
+            self.entry_edit.deleteLater()
+            self.entry_edit = None
+
        if getattr(self, "dap_combo", None) is not None:
            self.dap_combo.close()
            self.dap_combo.deleteLater()
@@ -268,13 +290,22 @@ class CurveRow(QTreeWidgetItem):
            # Gather device name/entry
            device_name = ""
            device_entry = ""
+
+            ## TODO: Move this to itemData
            if hasattr(self, "device_edit"):
-                device_name = self.device_edit.text()
+                device_name = self.device_edit.currentText()
            if hasattr(self, "entry_edit"):
-                device_entry = self.entry_validator.validate_signal(
-                    name=device_name, entry=self.entry_edit.text()
-                )
-                self.entry_edit.setText(device_entry)
+                device_entry = self.entry_edit.currentText()
+                index = self.entry_edit.findText(device_entry)
+                if index > -1:
+                    device_entry_info = self.entry_edit.itemData(index)
+                    if device_entry_info:
+                        device_entry = device_entry_info.get("obj_name", device_entry)
+                else:
+                    device_entry = self.entry_validator.validate_signal(
+                        name=device_name, entry=device_entry
+                    )
+
            self.config.signal = DeviceSignal(name=device_name, entry=device_entry)
            self.config.source = "device"
            self.config.label = f"{device_name}-{device_entry}"
@@ -390,13 +421,20 @@ class CurveTree(BECWidget, QWidget):
        self.tree = QTreeWidget()
        self.tree.setColumnCount(7)
        self.tree.setHeaderLabels(["Actions", "Name", "Entry", "Color", "Style", "Width", "Symbol"])
+
+        header = self.tree.header()
+        for idx in range(self.tree.columnCount()):
+            if idx in (1, 2):  # Device name and entry should stretch
+                header.setSectionResizeMode(idx, QHeaderView.Stretch)
+            else:
+                header.setSectionResizeMode(idx, QHeaderView.Fixed)
+        header.setStretchLastSection(False)
        self.tree.setColumnWidth(0, 90)
-        self.tree.setColumnWidth(1, 100)
-        self.tree.setColumnWidth(2, 100)
        self.tree.setColumnWidth(3, 70)
        self.tree.setColumnWidth(4, 80)
-        self.tree.setColumnWidth(5, 40)
-        self.tree.setColumnWidth(6, 40)
+        self.tree.setColumnWidth(5, 50)
+        self.tree.setColumnWidth(6, 50)
+
        self.layout.addWidget(self.tree)

    def _init_color_buffer(self, size: int):
@@ -532,7 +570,4 @@ class CurveTree(BECWidget, QWidget):
        all_items = list(self.all_items)
        for item in all_items:
            item.remove_self()
-
-    def closeEvent(self, event):
-        self.cleanup()
-        return super().closeEvent(event)
+        super().cleanup()
--- a/bec_widgets/widgets/plots/waveform/waveform.py
+++ b/bec_widgets/widgets/plots/waveform/waveform.py
@@ -330,7 +330,6 @@ class Waveform(PlotBase):
            self.curve_settings_dialog = SettingsDialog(
                self, settings_widget=curve_setting, window_title="Curve Settings", modal=False
            )
-            self.curve_settings_dialog.setFixedWidth(580)
            # When the dialog is closed, update the toolbar icon and clear the reference
            self.curve_settings_dialog.finished.connect(self._curve_settings_closed)
            self.curve_settings_dialog.show()
@@ -1246,6 +1245,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.
@@ -1254,20 +1270,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)
@@ -1647,9 +1683,14 @@ class Waveform(PlotBase):
                return None

        if hasattr(self.scan_item, "live_data"):
-            readout_priority = self.scan_item.status_message.info["readout_priority"]  # live data
+            readout_priority = self.scan_item.status_message.info.get(
+                "readout_priority"
+            )  # live data
        else:
-            readout_priority = self.scan_item.metadata["bec"]["readout_priority"]  # history
+            readout_priority = self.scan_item.metadata["bec"].get("readout_priority")  # history
+
+        if readout_priority is None:
+            return None

        # Reset sync/async curve lists
        self._async_curves.clear()
--- a/bec_widgets/widgets/progress/bec_progressbar/bec_progressbar.py
+++ b/bec_widgets/widgets/progress/bec_progressbar/bec_progressbar.py
@@ -1,12 +1,46 @@
 import sys
+from enum import Enum
 from string import Template

-from qtpy.QtCore import Property, QEasingCurve, QPropertyAnimation, QRectF, Qt, QTimer, Slot
+from qtpy.QtCore import QEasingCurve, QPropertyAnimation, QRectF, Qt, QTimer
 from qtpy.QtGui import QColor, QPainter, QPainterPath
+
+
+class ProgressState(Enum):
+    NORMAL = "normal"
+    PAUSED = "paused"
+    INTERRUPTED = "interrupted"
+    COMPLETED = "completed"
+
+    @classmethod
+    def from_bec_status(cls, status: str) -> "ProgressState":
+        """
+        Map a BEC status string (open, paused, aborted, halted, closed)
+        to the corresponding ProgressState.
+        Any unknown status falls back to NORMAL.
+        """
+        mapping = {
+            "open": cls.NORMAL,
+            "paused": cls.PAUSED,
+            "aborted": cls.INTERRUPTED,
+            "halted": cls.PAUSED,
+            "closed": cls.COMPLETED,
+        }
+        return mapping.get(status.lower(), cls.NORMAL)
+
+
+PROGRESS_STATE_COLORS = {
+    ProgressState.NORMAL: QColor("#2979ff"),  # blue  – normal progress
+    ProgressState.PAUSED: QColor("#ffca28"),  # orange/amber – paused
+    ProgressState.INTERRUPTED: QColor("#ff5252"),  # red – interrupted
+    ProgressState.COMPLETED: QColor("#00e676"),  # green – finished
+}
+
 from qtpy.QtWidgets import QApplication, QLabel, QVBoxLayout, QWidget

 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


 class BECProgressBar(BECWidget, QWidget):
@@ -21,6 +55,8 @@ class BECProgressBar(BECWidget, QWidget):
        "set_minimum",
        "label_template",
        "label_template.setter",
+        "state",
+        "state.setter",
        "_get_label",
    ]
    ICON_NAME = "page_control"
@@ -48,27 +84,38 @@ class BECProgressBar(BECWidget, QWidget):

        self._completed_color = accent_colors.success
        self._border_color = QColor(50, 50, 50)
+        # Corner‑rounding: base radius in pixels (auto‑reduced if bar is small)
+        self._corner_radius = 10
+
+        # Progress‑bar state handling
+        self._state = ProgressState.NORMAL
+        self._state_colors = dict(PROGRESS_STATE_COLORS)

        # layout settings
+        self._padding_left_right = 10
        self._value_animation = QPropertyAnimation(self, b"_progressbar_value")
        self._value_animation.setDuration(200)
        self._value_animation.setEasingCurve(QEasingCurve.Type.OutCubic)

        # label on top of the progress bar
        self.center_label = QLabel(self)
-        self.center_label.setAlignment(Qt.AlignCenter)
+        self.center_label.setAlignment(Qt.AlignHCenter)
        self.center_label.setStyleSheet("color: white;")
        self.center_label.setMinimumSize(0, 0)

        layout = QVBoxLayout(self)
-        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setContentsMargins(10, 0, 10, 0)
        layout.setSpacing(0)
        layout.addWidget(self.center_label)
+        layout.setAlignment(self.center_label, Qt.AlignCenter)
        self.setLayout(layout)

        self.update()
+        self._adjust_label_width()

-    @Property(str, doc="The template for the center label. Use $value, $maximum, and $percentage.")
+    @SafeProperty(
+        str, doc="The template for the center label. Use $value, $maximum, and $percentage."
+    )
    def label_template(self):
        """
        The template for the center label. Use $value, $maximum, and $percentage to insert the values.
@@ -83,10 +130,11 @@ class BECProgressBar(BECWidget, QWidget):
    @label_template.setter
    def label_template(self, template):
        self._label_template = template
+        self._adjust_label_width()
        self.set_value(self._user_value)
        self.update()

-    @Property(float, designable=False)
+    @SafeProperty(float, designable=False)
    def _progressbar_value(self):
        """
        The current value of the progress bar.
@@ -106,8 +154,20 @@ class BECProgressBar(BECWidget, QWidget):
            percentage=int((self.map_value(self._user_value) / self._maximum) * 100),
        )

-    @Slot(float)
-    @Slot(int)
+    def _adjust_label_width(self):
+        """
+        Reserve enough horizontal space for the center label so the widget
+        doesn't resize as the text grows during progress.
+        """
+        template = Template(self._label_template)
+        sample_text = template.safe_substitute(
+            value=self._user_maximum, maximum=self._user_maximum, percentage=100
+        )
+        width = self.center_label.fontMetrics().horizontalAdvance(sample_text)
+        self.center_label.setFixedWidth(width)
+
+    @SafeSlot(float)
+    @SafeSlot(int)
    def set_value(self, value):
        """
        Set the value of the progress bar.
@@ -122,35 +182,88 @@ class BECProgressBar(BECWidget, QWidget):
        self._target_value = self.map_value(value)
        self._user_value = value
        self.center_label.setText(self._update_template())
+        # Update state automatically unless paused or interrupted
+        if self._state not in (ProgressState.PAUSED, ProgressState.INTERRUPTED):
+            self._state = (
+                ProgressState.COMPLETED
+                if self._user_value >= self._user_maximum
+                else ProgressState.NORMAL
+            )
        self.animate_progress()

+    @SafeProperty(object, doc="Current visual state of the progress bar.")
+    def state(self):
+        return self._state
+
+    @state.setter
+    def state(self, state):
+        """
+        Set the visual state of the progress bar.
+
+        Args:
+            state(ProgressState | str): The state to set. Can be one of the
+        """
+        if isinstance(state, str):
+            state = ProgressState(state.lower())
+        if not isinstance(state, ProgressState):
+            raise ValueError("state must be a ProgressState or its value")
+        self._state = state
+        self.update()
+
+    @SafeProperty(float, doc="Base corner radius in pixels (auto‑scaled down on small bars).")
+    def corner_radius(self) -> float:
+        return self._corner_radius
+
+    @corner_radius.setter
+    def corner_radius(self, radius: float):
+        self._corner_radius = max(0.0, radius)
+        self.update()
+
+    @SafeProperty(float)
+    def padding_left_right(self) -> float:
+        return self._padding_left_right
+
+    @padding_left_right.setter
+    def padding_left_right(self, padding: float):
+        self._padding_left_right = padding
+        self.update()
+
    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
-        rect = self.rect().adjusted(10, 0, -10, -1)
+        rect = self.rect().adjusted(self._padding_left_right, 0, -self._padding_left_right, -1)
+
+        # Corner radius adapts to widget height so it never exceeds half the bar’s thickness
+        radius = min(self._corner_radius, rect.height() / 2)

        # Draw background
        painter.setBrush(self._background_color)
        painter.setPen(Qt.NoPen)
-        painter.drawRoundedRect(rect, 10, 10)  # Rounded corners
+        painter.drawRoundedRect(rect, radius, radius)  # Rounded corners

        # Draw border
        painter.setBrush(Qt.NoBrush)
        painter.setPen(self._border_color)
-        painter.drawRoundedRect(rect, 10, 10)
+        painter.drawRoundedRect(rect, radius, radius)

-        # Determine progress color based on completion
-        if self._value >= self._maximum:
-            current_color = self._completed_color
+        # Determine progress colour based on current state
+        if self._state == ProgressState.PAUSED:
+            current_color = self._state_colors[ProgressState.PAUSED]
+        elif self._state == ProgressState.INTERRUPTED:
+            current_color = self._state_colors[ProgressState.INTERRUPTED]
+        elif self._state == ProgressState.COMPLETED or self._value >= self._maximum:
+            current_color = self._state_colors[ProgressState.COMPLETED]
        else:
-            current_color = self._progress_color
+            current_color = self._state_colors[ProgressState.NORMAL]

        # Set clipping region to preserve the background's rounded corners
        progress_rect = rect.adjusted(
            0, 0, int(-rect.width() + (self._value / self._maximum) * rect.width()), 0
        )
        clip_path = QPainterPath()
-        clip_path.addRoundedRect(QRectF(rect), 10, 10)  # Clip to the background's rounded corners
+        clip_path.addRoundedRect(
+            QRectF(rect), radius, radius
+        )  # Clip to the background's rounded corners
        painter.setClipPath(clip_path)

        # Draw progress bar
@@ -168,7 +281,7 @@ class BECProgressBar(BECWidget, QWidget):
        self._value_animation.setEndValue(self._target_value)
        self._value_animation.start()

-    @Property(float)
+    @SafeProperty(float)
    def maximum(self):
        """
        The maximum value of the progress bar.
@@ -182,7 +295,7 @@ class BECProgressBar(BECWidget, QWidget):
        """
        self.set_maximum(maximum)

-    @Property(float)
+    @SafeProperty(float)
    def minimum(self):
        """
        The minimum value of the progress bar.
@@ -193,7 +306,7 @@ class BECProgressBar(BECWidget, QWidget):
    def minimum(self, minimum: float):
        self.set_minimum(minimum)

-    @Property(float)
+    @SafeProperty(float)
    def initial_value(self):
        """
        The initial value of the progress bar.
@@ -204,7 +317,7 @@ class BECProgressBar(BECWidget, QWidget):
    def initial_value(self, value: float):
        self.set_value(value)

-    @Slot(float)
+    @SafeSlot(float)
    def set_maximum(self, maximum: float):
        """
        Set the maximum value of the progress bar.
@@ -213,10 +326,11 @@ class BECProgressBar(BECWidget, QWidget):
            maximum (float): The maximum value.
        """
        self._user_maximum = maximum
+        self._adjust_label_width()
        self.set_value(self._user_value)  # Update the value to fit the new range
        self.update()

-    @Slot(float)
+    @SafeSlot(float)
    def set_minimum(self, minimum: float):
        """
        Set the minimum value of the progress bar.
--- a/bec_widgets/widgets/progress/scan_progressbar/init.py
+++ b/bec_widgets/widgets/progress/scan_progressbar/init.py
--- a/bec_widgets/widgets/progress/scan_progressbar/register_scan_progress_bar.py
+++ b/bec_widgets/widgets/progress/scan_progressbar/register_scan_progress_bar.py
@@ -0,0 +1,17 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.progress.scan_progressbar.scan_progress_bar_plugin import (
+        ScanProgressBarPlugin,
+    )
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(ScanProgressBarPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()
--- a/bec_widgets/widgets/progress/scan_progressbar/scan_progress_bar.pyproject
+++ b/bec_widgets/widgets/progress/scan_progressbar/scan_progress_bar.pyproject
@@ -0,0 +1 @@
+{'files': ['scan_progressbar.py']}
--- a/bec_widgets/widgets/progress/scan_progressbar/scan_progress_bar_plugin.py
+++ b/bec_widgets/widgets/progress/scan_progressbar/scan_progress_bar_plugin.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.progress.scan_progressbar.scan_progressbar import ScanProgressBar
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='ScanProgressBar' name='scan_progress_bar'>
+    </widget>
+</ui>
+"""
+
+
+class ScanProgressBarPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = ScanProgressBar(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Utils"
+
+    def icon(self):
+        return designer_material_icon(ScanProgressBar.ICON_NAME)
+
+    def includeFile(self):
+        return "scan_progress_bar"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "ScanProgressBar"
+
+    def toolTip(self):
+        return "A progress bar that is hooked up to the scan progress of a scan."
+
+    def whatsThis(self):
+        return self.toolTip()
--- a/bec_widgets/widgets/progress/scan_progressbar/scan_progressbar.py
+++ b/bec_widgets/widgets/progress/scan_progressbar/scan_progressbar.py
@@ -0,0 +1,320 @@
+from __future__ import annotations
+
+import enum
+import os
+import time
+from typing import Literal
+
+import numpy as np
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QObject, QTimer, Signal
+from qtpy.QtWidgets import QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
+from bec_widgets.utils.ui_loader import UILoader
+from bec_widgets.widgets.progress.bec_progressbar.bec_progressbar import ProgressState
+
+logger = bec_logger.logger
+
+
+class ProgressSource(enum.Enum):
+    """
+    Enum to define the source of the progress.
+    """
+
+    SCAN_PROGRESS = "scan_progress"
+    DEVICE_PROGRESS = "device_progress"
+
+
+class ProgressTask(QObject):
+    """
+    Class to store progress information.
+    Inspired by https://github.com/Textualize/rich/blob/master/rich/progress.py
+    """
+
+    def __init__(self, parent: QWidget, value: float = 0, max_value: float = 0, done: bool = False):
+        super().__init__(parent=parent)
+        self.start_time = time.time()
+        self.done = done
+        self.value = value
+        self.max_value = max_value
+        self._elapsed_time = 0
+
+        self.timer = QTimer(self)
+        self.timer.timeout.connect(self.update_elapsed_time)
+        self.timer.start(100)  # update the elapsed time every 100 ms
+
+    def update(self, value: float, max_value: float, done: bool = False):
+        """
+        Update the progress.
+        """
+        self.max_value = max_value
+        self.done = done
+        self.value = value
+        if done:
+            self.timer.stop()
+
+    def update_elapsed_time(self):
+        """
+        Update the time estimates. This is called every 100 ms by a QTimer.
+        """
+        self._elapsed_time += 0.1
+
+    @property
+    def percentage(self) -> float:
+        """float: Get progress of task as a percentage. If a None total was set, returns 0"""
+        if not self.max_value:
+            return 0.0
+        completed = (self.value / self.max_value) * 100.0
+        completed = min(100.0, max(0.0, completed))
+        return completed
+
+    @property
+    def speed(self) -> float:
+        """Get the estimated speed in steps per second."""
+        if self._elapsed_time == 0:
+            return 0.0
+
+        return self.value / self._elapsed_time
+
+    @property
+    def frequency(self) -> float:
+        """Get the estimated frequency in steps per second."""
+        if self.speed == 0:
+            return 0.0
+        return 1 / self.speed
+
+    @property
+    def time_elapsed(self) -> str:
+        # format the elapsed time to a string in the format HH:MM:SS
+        return self._format_time(int(self._elapsed_time))
+
+    @property
+    def remaining(self) -> float:
+        """Get the estimated remaining steps."""
+        if self.done:
+            return 0.0
+        remaining = self.max_value - self.value
+        return remaining
+
+    @property
+    def time_remaining(self) -> str:
+        """
+        Get the estimated remaining time in the format HH:MM:SS.
+        """
+        if self.done or not self.speed or not self.remaining:
+            return self._format_time(0)
+        estimate = int(np.round(self.remaining / self.speed))
+
+        return self._format_time(estimate)
+
+    def _format_time(self, seconds: float) -> str:
+        """
+        Format the time in seconds to a string in the format HH:MM:SS.
+        """
+        return f"{seconds // 3600:02}:{(seconds // 60) % 60:02}:{seconds % 60:02}"
+
+
+class ScanProgressBar(BECWidget, QWidget):
+    """
+    Widget to display a progress bar that is hooked up to the scan progress of a scan.
+    If you want to manually set the progress, it is recommended to use the BECProgressbar or QProgressbar directly.
+    """
+
+    ICON_NAME = "timelapse"
+    progress_started = Signal()
+    progress_finished = Signal()
+
+    def __init__(self, parent=None, client=None, config=None, gui_id=None, one_line_design=False):
+        super().__init__(parent=parent, client=client, config=config, gui_id=gui_id)
+
+        self.get_bec_shortcuts()
+        ui_file = os.path.join(
+            os.path.dirname(__file__),
+            "scan_progressbar_one_line.ui" if one_line_design else "scan_progressbar.ui",
+        )
+        self.ui = UILoader(self).loader(ui_file)
+        self.layout = QVBoxLayout(self)
+        self.layout.setSpacing(0)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.layout.addWidget(self.ui)
+        self.setLayout(self.layout)
+        self.progressbar = self.ui.progressbar
+
+        self.connect_to_queue()
+        self._progress_source = None
+        self.task = None
+        self.scan_number = None
+        self.progress_started.connect(lambda: print("Scan progress started"))
+
+    def connect_to_queue(self):
+        """
+        Connect to the queue status signal.
+        """
+        self.bec_dispatcher.connect_slot(self.on_queue_update, MessageEndpoints.scan_queue_status())
+
+    def set_progress_source(self, source: ProgressSource, device=None):
+        """
+        Set the source of the progress.
+        """
+        if self._progress_source == source:
+            self.update_source_label(source, device=device)
+            return
+        if self._progress_source is not None:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_progress_update,
+                (
+                    MessageEndpoints.scan_progress()
+                    if self._progress_source == ProgressSource.SCAN_PROGRESS
+                    else MessageEndpoints.device_progress(device=device)
+                ),
+            )
+        self._progress_source = source
+        self.bec_dispatcher.connect_slot(
+            self.on_progress_update,
+            (
+                MessageEndpoints.scan_progress()
+                if source == ProgressSource.SCAN_PROGRESS
+                else MessageEndpoints.device_progress(device=device)
+            ),
+        )
+        self.update_source_label(source, device=device)
+        # self.progress_started.emit()
+
+    def update_source_label(self, source: ProgressSource, device=None):
+        scan_text = f"Scan {self.scan_number}" if self.scan_number is not None else "Scan"
+        text = scan_text if source == ProgressSource.SCAN_PROGRESS else f"Device {device}"
+        logger.info(f"Set progress source to {text}")
+        self.ui.source_label.setText(text)
+
+    @SafeSlot(dict, dict)
+    def on_progress_update(self, msg_content: dict, metadata: dict):
+        """
+        Update the progress bar based on the progress message.
+        """
+        value = msg_content["value"]
+        max_value = msg_content.get("max_value", 100)
+        done = msg_content.get("done", False)
+        status: Literal["open", "paused", "aborted", "halted", "closed"] = metadata.get(
+            "status", "open"
+        )
+
+        if self.task is None:
+            return
+        self.task.update(value, max_value, done)
+
+        self.update_labels()
+
+        self.progressbar.set_maximum(self.task.max_value)
+        self.progressbar.state = ProgressState.from_bec_status(status)
+        self.progressbar.set_value(self.task.value)
+
+        if done:
+            self.task = None
+            self.progress_finished.emit()
+            return
+
+    @SafeProperty(bool)
+    def show_elapsed_time(self):
+        return self.ui.elapsed_time_label.isVisible()
+
+    @show_elapsed_time.setter
+    def show_elapsed_time(self, value):
+        self.ui.elapsed_time_label.setVisible(value)
+        if hasattr(self.ui, "dash"):
+            self.ui.dash.setVisible(value)
+
+    @SafeProperty(bool)
+    def show_remaining_time(self):
+        return self.ui.remaining_time_label.isVisible()
+
+    @show_remaining_time.setter
+    def show_remaining_time(self, value):
+        self.ui.remaining_time_label.setVisible(value)
+        if hasattr(self.ui, "dash"):
+            self.ui.dash.setVisible(value)
+
+    @SafeProperty(bool)
+    def show_source_label(self):
+        return self.ui.source_label.isVisible()
+
+    @show_source_label.setter
+    def show_source_label(self, value):
+        self.ui.source_label.setVisible(value)
+
+    def update_labels(self):
+        """
+        Update the labels based on the progress task.
+        """
+        if self.task is None:
+            return
+
+        self.ui.elapsed_time_label.setText(self.task.time_elapsed)
+        self.ui.remaining_time_label.setText(self.task.time_remaining)
+
+    @SafeSlot(dict, dict, verify_sender=True)
+    def on_queue_update(self, msg_content, metadata):
+        """
+        Update the progress bar based on the queue status.
+        """
+        if not "queue" in msg_content:
+            return
+        primary_queue_info = msg_content["queue"].get("primary", {}).get("info", [])
+        if len(primary_queue_info) == 0:
+            return
+        scan_info = primary_queue_info[0]
+        if scan_info is None:
+            return
+        if scan_info.get("status").lower() == "running" and self.task is None:
+            self.task = ProgressTask(parent=self)
+            self.progress_started.emit()
+
+        active_request_block = scan_info.get("active_request_block", {})
+        if active_request_block is None:
+            return
+
+        self.scan_number = active_request_block.get("scan_number")
+        report_instructions = active_request_block.get("report_instructions", [])
+        if not report_instructions:
+            return
+
+        # for now, let's just use the first instruction
+        instruction = report_instructions[0]
+
+        if "scan_progress" in instruction:
+            self.set_progress_source(ProgressSource.SCAN_PROGRESS)
+        elif "device_progress" in instruction:
+            device = instruction["device_progress"][0]
+            self.set_progress_source(ProgressSource.DEVICE_PROGRESS, device=device)
+
+    def cleanup(self):
+        if self.task is not None:
+            self.task.timer.stop()
+            self.close()
+            self.deleteLater()
+        if self._progress_source is not None:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_progress_update,
+                (
+                    MessageEndpoints.scan_progress()
+                    if self._progress_source == ProgressSource.SCAN_PROGRESS
+                    else MessageEndpoints.device_progress(device=self._progress_source.value)
+                ),
+            )
+        self.progressbar.close()
+        self.progressbar.deleteLater()
+        super().cleanup()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from qtpy.QtWidgets import QApplication
+
+    bec_logger.disabled_modules = ["bec_lib"]
+    app = QApplication([])
+
+    widget = ScanProgressBar()
+    widget.show()
+
+    app.exec_()
--- a/bec_widgets/widgets/progress/scan_progressbar/scan_progressbar.ui
+++ b/bec_widgets/widgets/progress/scan_progressbar/scan_progressbar.ui
@@ -0,0 +1,141 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>211</width>
+    <height>60</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>0</width>
+    <height>60</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>16777215</width>
+    <height>16777215</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <property name="spacing">
+    <number>1</number>
+   </property>
+   <property name="leftMargin">
+    <number>2</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>2</number>
+   </property>
+   <property name="bottomMargin">
+    <number>0</number>
+   </property>
+   <item>
+    <layout class="QHBoxLayout" name="source_layout">
+     <item>
+      <widget class="QLabel" name="source_label">
+       <property name="maximumSize">
+        <size>
+         <width>16777215</width>
+         <height>20</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>Scan</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="source_spacer">
+       <property name="orientation">
+        <enum>Qt::Orientation::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>10</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="BECProgressBar" name="progressbar">
+     <property name="padding_left_right" stdset="0">
+      <double>2.000000000000000</double>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="timer_layout">
+     <item>
+      <widget class="QLabel" name="remaining_time_label">
+       <property name="maximumSize">
+        <size>
+         <width>16777215</width>
+         <height>20</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>0:00:00</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="timer_spacer">
+       <property name="orientation">
+        <enum>Qt::Orientation::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>0</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QLabel" name="elapsed_time_label">
+       <property name="maximumSize">
+        <size>
+         <width>16777215</width>
+         <height>20</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>0:00:00</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>BECProgressBar</class>
+   <extends>QWidget</extends>
+   <header>bec_progress_bar</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
--- a/bec_widgets/widgets/progress/scan_progressbar/scan_progressbar_one_line.ui
+++ b/bec_widgets/widgets/progress/scan_progressbar/scan_progressbar_one_line.ui
@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>328</width>
+    <height>24</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>0</width>
+    <height>24</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>16777215</width>
+    <height>24</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QHBoxLayout" name="horizontalLayout_2" stretch="0,1,0">
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>2</number>
+   </property>
+   <property name="rightMargin">
+    <number>2</number>
+   </property>
+   <property name="bottomMargin">
+    <number>2</number>
+   </property>
+   <item>
+    <widget class="QLabel" name="source_label">
+     <property name="maximumSize">
+      <size>
+       <width>16777215</width>
+       <height>20</height>
+      </size>
+     </property>
+     <property name="text">
+      <string>Scan</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="BECProgressBar" name="progressbar">
+     <property name="minimumSize">
+      <size>
+       <width>30</width>
+       <height>0</height>
+      </size>
+     </property>
+     <property name="padding_left_right" stdset="0">
+      <double>5.000000000000000</double>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QLabel" name="remaining_time_label">
+       <property name="maximumSize">
+        <size>
+         <width>16777215</width>
+         <height>20</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>0:00:00</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="dash">
+       <property name="text">
+        <string>-</string>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignmentFlag::AlignCenter</set>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="elapsed_time_label">
+       <property name="maximumSize">
+        <size>
+         <width>16777215</width>
+         <height>20</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>0:00:00</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>BECProgressBar</class>
+   <extends>QWidget</extends>
+   <header>bec_progress_bar</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
--- a/bec_widgets/widgets/services/device_browser/device_browser.py
+++ b/bec_widgets/widgets/services/device_browser/device_browser.py
@@ -87,14 +87,13 @@ class DeviceBrowser(BECWidget, QWidget):
            for device, device_obj in self.dev.items():
                item = QListWidgetItem(self.dev_list)
                device_item = DeviceItem(
-                    parent=self, device=device, icon=map_device_type_to_icon(device_obj)
+                    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))
-
-                device_config = self.dev[device]._config  # pylint: disable=protected-access
-                device_item.set_display_config(device_config)
-                tooltip = device_config.get("description", "")
+                tooltip = self.dev[device]._config.get("description", "")
                device_item.setToolTip(tooltip)
                device_item.broadcast_size_hint.connect(item.setSizeHint)
                item.setSizeHint(device_item.sizeHint())
--- a/bec_widgets/widgets/services/device_browser/device_item/device_config_dialog.py
+++ b/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()
--- a/bec_widgets/widgets/services/device_browser/device_item/device_config_form.py
+++ b/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)
--- a/bec_widgets/widgets/services/device_browser/device_item/device_item.py
+++ b/bec_widgets/widgets/services/device_browser/device_item/device_item.py
@@ -3,79 +3,89 @@ 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 bec_qthemes import material_icon
 from qtpy.QtCore import QMimeData, QSize, Qt, Signal
 from qtpy.QtGui import QDrag
-from qtpy.QtWidgets import QApplication, QHBoxLayout, QWidget
+from qtpy.QtWidgets import QApplication, QHBoxLayout, QTabWidget, QToolButton, QVBoxLayout, QWidget

-from bec_widgets.utils.colors import get_theme_name
 from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.expandable_frame import ExpandableGroupFrame
-from bec_widgets.utils.forms_from_types import styles
-from bec_widgets.utils.forms_from_types.forms import PydanticModelForm
-from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
+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,
+)
+from bec_widgets.widgets.services.device_browser.device_item.device_signal_display import (
+    SignalDisplay,
+)

 if TYPE_CHECKING:  # pragma: no cover
    from qtpy.QtGui import QMouseEvent

+
 logger = bec_logger.logger


-class DeviceItemForm(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._validity.setVisible(False)
-        self._connect_to_theme_change()
-
-    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 _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
-
-
 class DeviceItem(ExpandableGroupFrame):
    broadcast_size_hint = Signal(QSize)

    RPC = False

-    def __init__(self, parent, device: str, icon: str = "") -> None:
+    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(0, 0, 0, 0)
-        self.set_layout(layout)

+        self._layout = QHBoxLayout()
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._tab_widget = QTabWidget(tabShape=QTabWidget.TabShape.Rounded)
+        self._tab_widget.setDocumentMode(True)
+        self._layout.addWidget(self._tab_widget)
+
+        self.set_layout(self._layout)
+
+        self._form_page = QWidget()
+        self._form_page_layout = QVBoxLayout()
+        self._form_page.setLayout(self._form_page_layout)
+
+        self._signal_page = QWidget()
+        self._signal_page_layout = QVBoxLayout()
+        self._signal_page.setLayout(self._signal_page_layout)
+
+        self._tab_widget.addTab(self._form_page, "Configuration")
+        self._tab_widget.addTab(self._signal_page, "Signals")
        self.adjustSize()
-        self._title.clicked.connect(self.switch_expanded_state)
-        self._title_icon.clicked.connect(self.switch_expanded_state)
+
+    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 = DeviceItemForm(parent=self, pretty_display=True)
-            self._contents.layout().addWidget(self.form)
-            if self._data:
-                self.form.set_data(self._data)
+            self.form = DeviceConfigForm(parent=self, pretty_display=True)
+            self._form_page_layout.addWidget(self.form)
+            self.signals = SignalDisplay(parent=self, device=self.device)
+            self._signal_page_layout.addWidget(self.signals)
+            self._reload_config()
            self.broadcast_size_hint.emit(self.sizeHint())
        super().switch_expanded_state()
        if self._expanded_first_time:
@@ -86,6 +96,10 @@ class DeviceItem(ExpandableGroupFrame):
        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."""
@@ -118,29 +132,33 @@ class DeviceItem(ExpandableGroupFrame):

 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 = QWidget()
    layout = QHBoxLayout()
    widget.setLayout(layout)
-    item = DeviceItem("Device")
+    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)
-    item.set_display_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"},
-        }
-    )
    widget.show()
    sys.exit(app.exec_())
--- a/bec_widgets/widgets/services/device_browser/device_item/device_signal_display.py
+++ b/bec_widgets/widgets/services/device_browser/device_item/device_signal_display.py
@@ -0,0 +1,102 @@
+from bec_qthemes import material_icon
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QHBoxLayout, QLabel, QToolButton, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_connector import ConnectionConfig
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
+from bec_widgets.widgets.containers.dock.dock import BECDock
+from bec_widgets.widgets.utility.signal_label.signal_label import SignalLabel
+
+
+class SignalDisplay(BECWidget, QWidget):
+    RPC = False
+
+    def __init__(
+        self,
+        client=None,
+        device: str = "",
+        config: ConnectionConfig = None,
+        gui_id: str | None = None,
+        theme_update: bool = False,
+        parent_dock: BECDock | None = None,
+        **kwargs,
+    ):
+        """A widget to display all the signals from a given device, and allow getting
+        a fresh reading."""
+        super().__init__(client, config, gui_id, theme_update, parent_dock, **kwargs)
+        self.get_bec_shortcuts()
+        self._layout = QVBoxLayout()
+        self.setLayout(self._layout)
+        self._content = QWidget()
+        self._layout.addWidget(self._content)
+        self._device = device
+        self.device = device
+
+    @SafeSlot()
+    def _refresh(self):
+        if self.device in self.dev:
+            self.dev.get(self.device).read(cached=False)
+            self.dev.get(self.device).read_configuration(cached=False)
+
+    def _add_refresh_button(self):
+        button_holder = QWidget()
+        button_holder.setLayout(QHBoxLayout())
+        button_holder.layout().setAlignment(Qt.AlignmentFlag.AlignRight)
+        button_holder.layout().setContentsMargins(0, 0, 0, 0)
+        refresh_button = QToolButton()
+        refresh_button.setIcon(
+            material_icon(icon_name="refresh", size=(20, 20), convert_to_pixmap=False)
+        )
+        refresh_button.clicked.connect(self._refresh)
+        button_holder.layout().addWidget(refresh_button)
+        self._content_layout.addWidget(button_holder)
+
+    def _populate(self):
+        self._content.deleteLater()
+        self._content = QWidget()
+        self._layout.addWidget(self._content)
+        self._content_layout = QVBoxLayout()
+        self._content_layout.setContentsMargins(0, 0, 0, 0)
+        self._content.setLayout(self._content_layout)
+
+        self._add_refresh_button()
+
+        if self._device in self.dev:
+            for sig in self.dev[self.device]._info.get("signals", {}).keys():
+                self._content_layout.addWidget(
+                    SignalLabel(
+                        device=self._device,
+                        signal=sig,
+                        show_select_button=False,
+                        show_default_units=True,
+                    )
+                )
+            self._content_layout.addStretch(1)
+        else:
+            self._content_layout.addWidget(
+                QLabel(f"Device {self.device} not found in device manager!")
+            )
+
+    @SafeProperty(str)
+    def device(self):
+        return self._device
+
+    @device.setter
+    def device(self, value: str):
+        self._device = value
+        self._populate()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    from bec_widgets.utils.colors import set_theme
+
+    app = QApplication(sys.argv)
+    set_theme("light")
+    widget = SignalDisplay(device="samx")
+    widget.show()
+    sys.exit(app.exec_())
--- a/bec_widgets/widgets/utility/signal_label/signal_label.py
+++ b/bec_widgets/widgets/utility/signal_label/signal_label.py
@@ -16,7 +16,6 @@ from qtpy.QtWidgets import (
    QGroupBox,
    QHBoxLayout,
    QLabel,
-    QLineEdit,
    QToolButton,
    QVBoxLayout,
    QWidget,
@@ -180,6 +179,7 @@ class SignalLabel(BECWidget, QWidget):
        self._custom_units: str = custom_units
        self._show_default_units: bool = show_default_units
        self._decimal_places = 3
+        self._dtype = None

        self._show_hinted_signals: bool = True
        self._show_normal_signals: bool = False
@@ -241,8 +241,10 @@ class SignalLabel(BECWidget, QWidget):
        """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._read_endpoint = MessageEndpoints.device_read(self._device)
+            self._read_config_endpoint = MessageEndpoints.device_read_configuration(self._device)
+            self.bec_dispatcher.connect_slot(self.on_device_readback, self._read_endpoint)
+            self.bec_dispatcher.connect_slot(self.on_device_readback, self._read_config_endpoint)
            self._manual_read()
            self.set_display_value(self._value)

@@ -250,7 +252,8 @@ class SignalLabel(BECWidget, QWidget):
        """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)
+            self.bec_dispatcher.disconnect_slot(self.on_device_readback, self._read_endpoint)
+            self.bec_dispatcher.disconnect_slot(self.on_device_readback, self._read_config_endpoint)

    def _manual_read(self):
        if self._device is None or not isinstance(
@@ -259,8 +262,13 @@ class SignalLabel(BECWidget, QWidget):
            self._units = ""
            self._value = "__"
            return
-        signal: Signal = (
-            getattr(device, self.signal, None) if isinstance(device, Device) else device
+        signal, info = (
+            (
+                getattr(device, self.signal, None),
+                device._info.get("signals", {}).get(self._signal, {}).get("describe", {}),
+            )
+            if isinstance(device, Device)
+            else (device, device.describe().get(self._device))
        )
        if not isinstance(signal, Signal):  # Avoid getting other attributes of device, e.g. methods
            signal = None
@@ -269,7 +277,8 @@ class SignalLabel(BECWidget, QWidget):
            self._value = "__"
            return
        self._value = signal.get()
-        self._units = signal.get_device_config().get("egu", "")
+        self._units = info.get("egu", "")
+        self._dtype = info.get("dtype", "float")

    @SafeSlot(dict, dict)
    def on_device_readback(self, msg: dict, metadata: dict) -> None:
@@ -278,8 +287,10 @@ class SignalLabel(BECWidget, QWidget):
        """
        try:
            signal_to_read = self._patch_hinted_signal()
-            self._value = msg["signals"][signal_to_read]["value"]
-            self.set_display_value(self._value)
+            _value = msg["signals"].get(signal_to_read, {}).get("value")
+            if _value is not None:
+                self._value = _value
+                self.set_display_value(self._value)
        except Exception as e:
            self._display.setText("ERROR!")
            self._display.setToolTip(
@@ -401,7 +412,10 @@ class SignalLabel(BECWidget, QWidget):
        if self._decimal_places == 0:
            return value
        try:
-            return f"{float(value):0.{self._decimal_places}f}"
+            if self._dtype in ("integer", "float"):
+                return f"{float(value):0.{self._decimal_places}f}"
+            else:
+                return str(value)
        except ValueError:
            return value

--- a/bec_widgets/widgets/utility/toggle/toggle.py
+++ b/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
--- a/docs/user/widgets/waveform/waveform_ruleset.md
+++ b/docs/user/widgets/waveform/waveform_ruleset.md
@@ -0,0 +1,94 @@
+# Waveform Widget Plotting Ruleset
+
+The Waveform widget allows plotting data from scans generated within the BEC framework. Each scan produces a **scan item
+**, which includes measurement data from various devices, as well as additional metadata (e.g., devices driving the
+scan, such as `motor_x`, `motor_y`, etc.).
+
+The rules described below define how data from different devices and scans can be plotted together, depending on the
+selected `x_mode`.
+
+---
+
+## Types of Curves
+
+- **Live Curves**
+    - Continuously updated from the currently running scan.
+    - Dynamically adapt based on live data.
+
+- **History Curves**
+    - Static curves representing data from a specific completed scan (e.g., scan 110).
+    - Displayed only if compatible with the currently selected x-axis device.
+
+---
+
+## General Compatibility Rules
+
+- Data from devices within **the same scan item** can always be plotted against each other, provided they have the same
+  number of data points.
+    - Example: plotting `detector_1` against `detector_2` from scan 110 to check signal correlation is valid.
+
+- Data from **different scan items** cannot be plotted against each other.
+    - Example: plotting x-data from `motor_x` in scan 110 against y-data from `detector_1` in scan 111 is not allowed.
+
+---
+
+## Specific Rules for Each `x_mode`
+
+### 1. `x_mode='auto'` (default)
+
+- Automatically determines the device for x-axis scaling from the currently running (live) scan.
+- The primary device used for scaling is the first device listed in the current scan's `scan_report_devices` (usually a
+  positioner in the case of step scans).
+- **Live Curves**:
+    - Always plotted against the selected x-axis device from the current scan.
+- **History Curves**:
+    - Each history curve is linked to a specific scan item with scan ID.
+    - Waveform widget checks compatibility with the currently selected x-axis device from the live scan.
+    - If the selected x-axis device data exists in the history curve’s original scan item, the curve is displayed.
+    - If the selected x-axis device data does not exist in the original scan item, the history curve remains **hidden**
+      until a compatible device is selected again.
+
+_Example Scenario_:
+
+- The live scan currently uses `motor_x` as the x-axis device. Any history curve will only be displayed if its original
+  scan item contains data for `motor_x`. If not, the history curve is hidden.
+
+---
+
+### 2. `x_mode='timestamp'`
+
+- X-axis scaling is based on timestamps from each data point.
+- All curves, both live and history, are always compatible, as timestamps provide a universal and absolute reference for
+  the x-axis.
+- Curves from different scan items can appear simultaneously, regardless of the devices measured.
+
+---
+
+### 3. `x_mode='index'`
+
+- X-axis scaling uses data point indices (0, 1, 2, ..., N-1).
+- Allows plotting multiple curves of varying lengths in the same view.
+- All curves are always compatible, as indices represent relative positions, independent of device or timestamp, it is
+  up to the user to interpret the x-axis.
+
+---
+
+### 4. `x_mode='device'`
+
+- User explicitly selects a device to scale the x-axis.
+- The chosen device must exist in each curve’s respective scan item.
+- **Live Curves**:
+    - Continuously displayed if the selected device data is being measured in the current scan.
+- **History Curves**:
+    - Displayed only if the selected device exists in the scan item from which the history curve originates.
+    - Remain **hidden** if the selected device is not present in the original scan item, reappearing only when a
+      compatible device is chosen again.
+
+---
+
+## Key Technical Points
+
+- Each curve stores its own independent x and y data sets (as it is defined by `pg.PlotDataItem`, allowing simultaneous
+  plotting of multiple curves with different data lengths.
+- Compatibility checks ensure that plotting meaningful comparisons is always possible, avoiding combinations of
+  unrelated or non-compatible datasets.
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"

 [project]
 name = "bec_widgets"
-version = "2.14.0"
+version = "2.21.2"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -13,15 +13,15 @@ classifiers = [
    "Topic :: Scientific/Engineering",
 ]
 dependencies = [
-    "bec_ipython_client>=3.38, <=4.0", # needed for jupyter console
-    "bec_lib>=3.38, <=4.0",
+    "bec_ipython_client>=3.42.4, <=4.0", # needed for jupyter console
+    "bec_lib>=3.44, <=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",
-    "qtconsole~=5.5, >=5.5.1",         # needed for jupyter console
+    "qtconsole~=5.5, >=5.5.1",           # needed for jupyter console
    "qtpy~=2.4",
 ]

--- a/tests/end-2-end/test_bec_dock_rpc_e2e.py
+++ b/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")

--- a/tests/end-2-end/test_rpc_widgets_e2e.py
+++ b/tests/end-2-end/test_rpc_widgets_e2e.py
@@ -79,7 +79,7 @@ def test_available_widgets(qtbot, connected_client_gui_obj):
    gui = connected_client_gui_obj
    dock_area = gui.bec
    # Number of top level widgets, should be 4
-    top_level_widgets_count = 4
+    top_level_widgets_count = 12
    assert len(gui._server_registry) == top_level_widgets_count
    # Number of widgets with parent_id == None, should be 2
    widgets = [
--- a/tests/end-2-end/test_with_plugins_e2e.py
+++ b/tests/end-2-end/test_with_plugins_e2e.py
@@ -69,7 +69,7 @@ def test_scan_metadata_for_custom_scan(
    def do_test():
        # Set the metadata
        grid: QGridLayout = scan_control._metadata_form._form_grid.layout()
-        for i in range(grid.rowCount()):  # type: ignore
+        for i in range(grid.rowCount() - 1):  # type: ignore
            field_name = grid.itemAtPosition(i, 0).widget().property("_model_field_name")
            if (value_to_set := md.pop(field_name, None)) is not None:
                grid.itemAtPosition(i, 1).widget().setValue(value_to_set)
--- a/tests/end-2-end/user_interaction/test_user_interaction_e2e.py
+++ b/tests/end-2-end/user_interaction/test_user_interaction_e2e.py
@@ -12,12 +12,11 @@ may not be created immediately after the rpc call is made.
 from __future__ import annotations

 import random
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING

 import numpy as np
 import pytest

-from bec_widgets.cli.client import BECDockArea
 from bec_widgets.cli.rpc.rpc_base import RPCBase, RPCReference

 PYTEST_TIMEOUT = 50
@@ -321,20 +320,20 @@ def test_widgets_e2e_signal_combobox(qtbot, connected_client_gui_obj, random_gen
    gui = connected_client_gui_obj
    bec = gui._client
    # Create dock_area, dock, widget
-    dock, widget = create_widget(qtbot, gui, gui.available_widgets.SignalComboBox)
-    dock: client.BECDock
+    _, widget = create_widget(qtbot, gui, gui.available_widgets.SignalComboBox)
    widget: client.SignalComboBox

    widget.set_device("samx")
+    info = bec.device_manager.devices.samx._info["signals"]
    assert widget.signals == [
-        "readback",
-        "setpoint",
-        "motor_is_moving",
-        "velocity",
-        "acceleration",
-        "tolerance",
+        ["samx (readback)", info.get("readback")],
+        ["setpoint", info.get("setpoint")],
+        ["motor_is_moving", info.get("motor_is_moving")],
+        ["velocity", info.get("velocity")],
+        ["acceleration", info.get("acceleration")],
+        ["tolerance", info.get("tolerance")],
    ]
-    widget.set_signal("readback")
+    widget.set_signal("samx (readback)")

    # Test removing the widget, or leaving it open for the next test
    maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
--- a/tests/unit_tests/test_axis_settings.py
+++ b/tests/unit_tests/test_axis_settings.py
@@ -168,11 +168,16 @@ def test_accept_changes(axis_settings_fixture, qtbot):
    axis_settings.ui.x_grid.checked = True

    axis_settings.accept_changes()
-    qtbot.wait(200)
-
-    assert plot_base.title == "New Title"
-    assert plot_base.x_min == 10
-    assert plot_base.x_max == 20
-    assert plot_base.x_label == "New X Label"
-    assert plot_base.x_log is True
-    assert plot_base.x_grid is True
+    qtbot.waitUntil(
+        lambda: all(
+            [
+                plot_base.title == "New Title",
+                plot_base.x_min == 10,
+                plot_base.x_max == 20,
+                plot_base.x_label == "New X Label",
+                plot_base.x_log is True,
+                plot_base.x_grid is True,
+            ]
+        ),
+        timeout=200,
+    )
--- a/tests/unit_tests/test_bec_dock.py
+++ b/tests/unit_tests/test_bec_dock.py
@@ -47,24 +47,21 @@ def test_bec_dock_area_add_remove_dock(bec_dock_area, qtbot):
    # Remove docks
    d0_name = d0.name()
    bec_dock_area.delete(d0_name)
-    qtbot.wait(200)
    d1.remove()
-    qtbot.wait(200)

-    assert len(bec_dock_area.dock_area.docks) == initial_count + 1
+    qtbot.waitUntil(lambda: len(bec_dock_area.dock_area.docks) == initial_count + 1, timeout=200)
    assert d0.name() not in dict(bec_dock_area.dock_area.docks)
    assert d1.name() not in dict(bec_dock_area.dock_area.docks)
    assert d2.name() in dict(bec_dock_area.dock_area.docks)


 def test_close_docks(bec_dock_area, qtbot):
-    d0 = bec_dock_area.new(name="dock_0")
-    d1 = bec_dock_area.new(name="dock_1")
-    d2 = bec_dock_area.new(name="dock_2")
+    _ = bec_dock_area.new(name="dock_0")
+    _ = bec_dock_area.new(name="dock_1")
+    _ = bec_dock_area.new(name="dock_2")

    bec_dock_area.delete_all()
-    qtbot.wait(200)
-    assert len(bec_dock_area.dock_area.docks) == 0
+    qtbot.waitUntil(lambda: len(bec_dock_area.dock_area.docks) == 0)


 def test_undock_and_dock_docks(bec_dock_area, qtbot):
--- a/tests/unit_tests/test_bec_progressbar.py
+++ b/tests/unit_tests/test_bec_progressbar.py
@@ -1,7 +1,10 @@
 import numpy as np
 import pytest

-from bec_widgets.widgets.progress.bec_progressbar.bec_progressbar import BECProgressBar
+from bec_widgets.widgets.progress.bec_progressbar.bec_progressbar import (
+    BECProgressBar,
+    ProgressState,
+)


@pytest.fixture
@@ -33,3 +36,23 @@ def test_progressbar_label(progressbar):
    progressbar.label_template = "Test: $value"
    progressbar.set_value(50)
    assert progressbar.center_label.text() == "Test: 50"
+
+
+def test_progress_state_from_bec_status():
+    """ProgressState.from_bec_status() maps BEC literals correctly."""
+    mapping = {
+        "open": ProgressState.NORMAL,
+        "paused": ProgressState.PAUSED,
+        "aborted": ProgressState.INTERRUPTED,
+        "halted": ProgressState.PAUSED,
+        "closed": ProgressState.COMPLETED,
+        "UNKNOWN": ProgressState.NORMAL,  # fallback
+    }
+    for text, expected in mapping.items():
+        assert ProgressState.from_bec_status(text) is expected
+
+
+def test_progressbar_state_setter(progressbar):
+    """Setting .state reflects internally."""
+    progressbar.state = ProgressState.PAUSED
+    assert progressbar.state is ProgressState.PAUSED
--- a/tests/unit_tests/test_curve_settings.py
+++ b/tests/unit_tests/test_curve_settings.py
@@ -93,7 +93,7 @@ def test_curve_setting_switch_device_mode(curve_setting_fixture, qtbot):
    assert curve_setting.device_x.isEnabled()

    # This line edit should reflect the waveform.x_axis_mode["name"], or be blank if none
-    assert curve_setting.device_x.text() == wf.x_axis_mode["name"]
+    assert curve_setting.device_x.currentText() == ""


 def test_curve_setting_refresh(curve_setting_fixture, qtbot):
@@ -127,8 +127,8 @@ def test_change_device_from_target_widget(curve_setting_fixture, qtbot):

    assert curve_setting.mode_combo.currentText() == "device"
    assert curve_setting.device_x.isEnabled()
-    assert curve_setting.device_x.text() == wf.x_axis_mode["name"]
-    assert curve_setting.signal_x.text() == wf.x_axis_mode["entry"]
+    assert curve_setting.device_x.currentText() == wf.x_axis_mode["name"]
+    assert curve_setting.signal_x.currentText() == f"{wf.x_axis_mode['entry']} (readback)"


 ##################################################
--- a/tests/unit_tests/test_device_browser.py
+++ b/tests/unit_tests/test_device_browser.py
@@ -3,9 +3,12 @@ from unittest import mock

 import pytest
 from qtpy.QtCore import QPoint, Qt
+from qtpy.QtWidgets import QTabWidget

 from bec_widgets.widgets.services.device_browser.device_browser import DeviceBrowser
-from bec_widgets.widgets.services.device_browser.device_item.device_item import DeviceItemForm
+from bec_widgets.widgets.services.device_browser.device_item.device_config_form import (
+    DeviceConfigForm,
+)

 from .client_mocks import mocked_client

@@ -24,6 +27,7 @@ if TYPE_CHECKING:  # pragma: no cover
@pytest.fixture
 def device_browser(qtbot, mocked_client):
    dev_browser = DeviceBrowser(client=mocked_client)
+    dev_browser.dev["samx"].read_configuration = mock.MagicMock()
    qtbot.addWidget(dev_browser)
    qtbot.waitExposed(dev_browser)
    yield dev_browser
@@ -83,11 +87,16 @@ def test_device_item_expansion(device_browser, qtbot):
    device_item: QListWidgetItem = device_browser.ui.device_list.itemAt(0, 0)
    widget: DeviceItem = device_browser.ui.device_list.itemWidget(device_item)
    qtbot.mouseClick(widget._expansion_button, Qt.MouseButton.LeftButton)
-    form = widget._contents.layout().itemAt(0).widget()
-    qtbot.waitUntil(lambda: isinstance(form, DeviceItemForm), timeout=500)
+    tab_widget: QTabWidget = widget._contents.layout().itemAt(0).widget()
+    qtbot.waitUntil(lambda: tab_widget.widget(0) is not None, timeout=100)
+    qtbot.waitUntil(
+        lambda: isinstance(tab_widget.widget(0).layout().itemAt(0).widget(), DeviceConfigForm),
+        timeout=100,
+    )
+    form = tab_widget.widget(0).layout().itemAt(0).widget()
    assert widget.expanded
    assert (name_field := form.widget_dict.get("name")) is not None
-    assert name_field.getValue() == "samx"
+    qtbot.waitUntil(lambda: name_field.getValue() == "samx", timeout=500)
    qtbot.mouseClick(widget._expansion_button, Qt.MouseButton.LeftButton)
    assert not widget.expanded

--- a/tests/unit_tests/test_device_config_form_dialog.py
+++ b/tests/unit_tests/test_device_config_form_dialog.py
@@ -0,0 +1,98 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from bec_lib.atlas_models import Device as DeviceConfigModel
+
+from bec_widgets.widgets.services.device_browser.device_item.device_config_dialog import (
+    DeviceConfigDialog,
+)
+
+_BASIC_CONFIG = {
+    "name": "test_device",
+    "enabled": True,
+    "deviceClass": "TestDevice",
+    "readoutPriority": "monitored",
+}
+
+
+@pytest.fixture
+def dialog(qtbot):
+    """Fixture to create a DeviceConfigDialog instance."""
+    mock_device = MagicMock(_config=DeviceConfigModel.model_validate(_BASIC_CONFIG).model_dump())
+    mock_client = MagicMock()
+    mock_client.device_manager.devices = {"test_device": mock_device}
+    dialog = DeviceConfigDialog(device="test_device", config_helper=MagicMock(), client=mock_client)
+    qtbot.addWidget(dialog)
+    return dialog
+
+
+def test_initialization(dialog):
+    assert dialog._device == "test_device"
+    assert dialog._container.count() == 2
+
+
+def test_fill_form(dialog):
+    with patch.object(dialog._form, "set_data") as mock_set_data:
+        dialog._fill_form()
+        mock_set_data.assert_called_once_with(DeviceConfigModel.model_validate(_BASIC_CONFIG))
+
+
+def test_updated_config(dialog):
+    """Test that updated_config returns the correct changes."""
+    dialog._initial_config = {"key1": "value1", "key2": "value2"}
+    with patch.object(
+        dialog._form, "get_form_data", return_value={"key1": "value1", "key2": "new_value"}
+    ):
+        updated = dialog.updated_config()
+        assert updated == {"key2": "new_value"}
+
+
+def test_apply(dialog):
+    with patch.object(dialog, "_process_update_action") as mock_process_update:
+        dialog.apply()
+        mock_process_update.assert_called_once()
+
+
+def test_accept(dialog):
+    with (
+        patch.object(dialog, "_process_update_action") as mock_process_update,
+        patch("qtpy.QtWidgets.QDialog.accept") as mock_parent_accept,
+    ):
+        dialog.accept()
+        mock_process_update.assert_called_once()
+        mock_parent_accept.assert_called_once()
+
+
+def test_waiting_display(dialog, qtbot):
+    with (
+        patch.object(dialog._spinner, "start") as mock_spinner_start,
+        patch.object(dialog._spinner, "stop") as mock_spinner_stop,
+    ):
+        dialog.show()
+        dialog._start_waiting_display()
+        qtbot.waitUntil(dialog._overlay_widget.isVisible, timeout=100)
+        mock_spinner_start.assert_called_once()
+        mock_spinner_stop.assert_not_called()
+        dialog._stop_waiting_display()
+        qtbot.waitUntil(lambda: not dialog._overlay_widget.isVisible(), timeout=100)
+        mock_spinner_stop.assert_called_once()
+
+
+def test_update_cycle(dialog, qtbot):
+    update = {"enabled": False, "readoutPriority": "baseline", "deviceTags": {"tag"}}
+
+    def _mock_send(action="update", config=None, wait_for_response=True, timeout_s=None):
+        dialog.client.device_manager.devices["test_device"]._config = config["test_device"]  # type: ignore
+
+    dialog._config_helper.send_config_request = MagicMock(side_effect=_mock_send)
+    for item in dialog._form.enumerate_form_widgets():
+        if (val := update.get(item.label.property("_model_field_name"))) is not None:
+            item.widget.setValue(val)
+
+    assert dialog.updated_config() == update
+    dialog.apply()
+    qtbot.waitUntil(lambda: dialog._config_helper.send_config_request.call_count == 1, timeout=100)
+
+    dialog._config_helper.send_config_request.assert_called_with(
+        action="update", config={"test_device": update}, wait_for_response=False
+    )
--- a/tests/unit_tests/test_device_signal_input.py
+++ b/tests/unit_tests/test_device_signal_input.py
@@ -94,18 +94,6 @@ def test_device_signal_qproperties(device_signal_base):
    assert device_signal_base._signal_filter == {Kind.config, Kind.normal}


-def test_device_signal_set_device(device_signal_base):
-    """Test if the set_device method works correctly"""
-    device_signal_base.include_hinted_signals = True
-    device_signal_base.set_device("samx")
-    assert device_signal_base.device == "samx"
-    assert device_signal_base.signals == ["readback"]
-    device_signal_base.include_normal_signals = True
-    assert device_signal_base.signals == ["readback", "setpoint"]
-    device_signal_base.include_config_signals = True
-    assert device_signal_base.signals == ["readback", "setpoint", "velocity"]
-
-
 def test_signal_combobox(qtbot, device_signal_combobox):
    """Test the signal_combobox"""
    container = []
@@ -120,17 +108,25 @@ def test_signal_combobox(qtbot, device_signal_combobox):
    device_signal_combobox.include_config_signals = True
    assert device_signal_combobox.signals == []
    device_signal_combobox.set_device("samx")
-    assert device_signal_combobox.signals == ["readback", "setpoint", "velocity"]
+    samx = device_signal_combobox.dev.samx
+    assert device_signal_combobox.signals == [
+        ("samx (readback)", samx._info["signals"].get("readback")),
+        ("setpoint", samx._info["signals"].get("setpoint")),
+        ("velocity", samx._info["signals"].get("velocity")),
+    ]
    qtbot.wait(100)
-    assert container == ["samx"]
+    assert container == ["samx (readback)"]
    # Set the type of class from the FakeDevice to Signal
-    fake_signal = FakeSignal(name="fake_signal")
+    fake_signal = FakeSignal(name="fake_signal", info={"device_info": {"signals": {}}})
    device_signal_combobox.client.device_manager.add_devices([fake_signal])
    device_signal_combobox.set_device("fake_signal")
-    assert device_signal_combobox.signals == ["fake_signal"]
+    fake_signal = device_signal_combobox.dev.fake_signal
+    assert device_signal_combobox.signals == [
+        ("fake_signal", fake_signal._info["signals"].get("fake_signal", {}))
+    ]
    assert device_signal_combobox._config_signals == []
    assert device_signal_combobox._normal_signals == []
-    assert device_signal_combobox._hinted_signals == ["fake_signal"]
+    assert device_signal_combobox._hinted_signals == [("fake_signal", {})]


 def test_signal_lineedit(device_signal_line_edit):
@@ -148,3 +144,12 @@ def test_signal_lineedit(device_signal_line_edit):
    assert device_signal_line_edit._is_valid_input is True
    device_signal_line_edit.setText("invalid")
    assert device_signal_line_edit._is_valid_input is False
+
+
+def test_device_signal_input_base_cleanup(qtbot, mocked_client):
+
+    widget = DeviceInputWidget(client=mocked_client)
+    widget.close()
+    widget.deleteLater()
+
+    mocked_client.callbacks.remove.assert_called_once_with(widget._device_update_register)
--- a/tests/unit_tests/test_generated_form_form.py
+++ b/tests/unit_tests/test_generated_form_form.py
@@ -3,12 +3,8 @@ from decimal import Decimal
 import pytest
 from pydantic import BaseModel, Field

-from bec_widgets.utils.forms_from_types.forms import PydanticModelForm
-from bec_widgets.utils.forms_from_types.items import (
-    FloatDecimalMetadataField,
-    IntMetadataField,
-    StrMetadataField,
-)
+from bec_widgets.utils.forms_from_types.forms import PydanticModelForm, TypedForm
+from bec_widgets.utils.forms_from_types.items import FloatDecimalFormItem, IntFormItem, StrFormItem

 # pylint: disable=no-member
 # pylint: disable=missing-function-docstring
@@ -58,9 +54,9 @@ def model_widget(qtbot):


 def test_widget_dict(model_widget: PydanticModelForm):
-    assert isinstance(model_widget.widget_dict["str_optional"], StrMetadataField)
-    assert isinstance(model_widget.widget_dict["float_nodefault"], FloatDecimalMetadataField)
-    assert isinstance(model_widget.widget_dict["int_default"], IntMetadataField)
+    assert isinstance(model_widget.widget_dict["str_optional"], StrFormItem)
+    assert isinstance(model_widget.widget_dict["float_nodefault"], FloatDecimalFormItem)
+    assert isinstance(model_widget.widget_dict["int_default"], IntFormItem)


 def test_widget_set_data(model_widget: PydanticModelForm):
--- a/tests/unit_tests/test_generated_form_items.py
+++ b/tests/unit_tests/test_generated_form_items.py
@@ -1,11 +1,12 @@
 import sys
-from typing import Literal
+from typing import Any, Literal, get_args

 import pytest
 from pydantic import ValidationError
 from pydantic.fields import FieldInfo

-from bec_widgets.utils.forms_from_types.items import FormItemSpec
+from bec_widgets.utils.forms_from_types.items import FormItemSpec, ListFormItem
+from bec_widgets.utils.widget_io import WidgetIO


@pytest.mark.skipif(sys.version_info < (3, 11), reason="Generic types don't support this in 3.10")
@@ -58,3 +59,65 @@ def test_form_item_spec(input, validity):
    else:
        with pytest.raises(ValidationError):
            FormItemSpec.model_validate(input)
+
+
+@pytest.fixture(
+    params=[
+        {"type": list[int], "value": [1, 2, 3], "extra": 79},
+        {"type": list[str], "value": ["a", "b", "c"], "extra": "string"},
+        {"type": list[float], "value": [0.1, 0.2, 0.3], "extra": 79.0},
+    ]
+)
+def list_field_and_values(request, qtbot):
+    itype, vals, extra = (
+        request.param.get("type"),
+        request.param.get("value"),
+        request.param.get("extra"),
+    )
+    spec = FormItemSpec(item_type=itype, name="test_list", info=FieldInfo(annotation=itype))
+    (widget := ListFormItem(parent=None, spec=spec)).setValue(vals)
+    qtbot.addWidget(widget)
+    yield widget, vals, extra, get_args(itype)[0]
+
+
+def test_list_metadata_field(list_field_and_values: tuple[ListFormItem, list, Any, type]):
+    list_field, vals, extra, _ = list_field_and_values
+    assert list_field.getValue() == vals
+    assert list_field._main_widget.count() == 3
+
+    list_field._add_button.click()
+    assert len(list_field.getValue()) == 4
+    assert list_field._main_widget.count() == 4
+
+    list_field._main_widget.setCurrentRow(-1)
+    list_field._remove_button.click()
+    assert len(list_field.getValue()) == 4
+    assert list_field._main_widget.count() == 4
+
+    list_field._main_widget.setCurrentRow(2)
+    list_field._remove_button.click()
+    assert list_field.getValue() == vals[:2] + [list_field._types.default]
+    assert list_field._main_widget.count() == 3
+
+    list_field._main_widget.setCurrentRow(1)
+    WidgetIO.set_value(list_field._main_widget.itemWidget(list_field._main_widget.item(1)), extra)
+    assert list_field._main_widget.count() == 3
+    assert list_field.getValue() == [vals[0], extra, list_field._types.default]
+
+    list_field._add_data_item(extra)
+    assert list_field._main_widget.count() == 4
+    assert list_field.getValue() == [vals[0], extra, list_field._types.default, extra]
+
+
+def test_list_field_value_acceptance(list_field_and_values: tuple[ListFormItem, list, Any, type]):
+    class _WrongType(object): ...
+
+    list_field, _, _, t = list_field_and_values
+    list_field.setValue([])
+    assert list_field._main_widget.count() == 0
+    list_field.setValue([t(), t(), t()])
+    assert list_field._main_widget.count() == 3
+    with pytest.raises(ValueError) as e:
+        list_field.setValue([_WrongType()])
+    assert list_field._main_widget.count() == 3
+    assert e.match(f"This widget only accepts items of type {t}")
--- a/tests/unit_tests/test_image_roi_tree.py
+++ b/tests/unit_tests/test_image_roi_tree.py
@@ -120,11 +120,11 @@ def test_roi_name_edit(roi_tree, image_widget, qtbot):
    roi_tree.tree.editItem(item, roi_tree.COL_ROI)
    qtbot.keyClicks(roi_tree.tree.viewport().focusWidget(), "new_name")
    qtbot.keyClick(roi_tree.tree.viewport().focusWidget(), Qt.Key_Return)
-    qtbot.wait(200)
-
    # Check the ROI name was updated
-    assert roi.label == "new_name"
-    assert item.text(roi_tree.COL_ROI) == "new_name"
+    qtbot.waitUntil(
+        lambda: all([roi.label == "new_name", item.text(roi_tree.COL_ROI) == "new_name"]),
+        timeout=200,
+    )


 def test_roi_width_edit(roi_tree, image_widget, qtbot):
@@ -138,9 +138,8 @@ def test_roi_width_edit(roi_tree, image_widget, qtbot):

    # Change the width
    width_spin.setValue(25)
-    qtbot.wait(200)
    # Check the ROI width was updated
-    assert roi.line_width == 25
+    qtbot.waitUntil(lambda: roi.line_width == 25, timeout=200)


 def test_delete_roi_button(roi_tree, image_widget, qtbot):
@@ -153,11 +152,12 @@ def test_delete_roi_button(roi_tree, image_widget, qtbot):

    del_btn = layout.itemAt(1).widget()
    del_btn.click()
-    qtbot.wait(200)

    # Verify ROI was removed
-    assert roi not in roi_tree.roi_items
-    assert roi not in image_widget.roi_controller.rois
+    qtbot.waitUntil(
+        lambda: all([roi not in roi_tree.roi_items, roi not in image_widget.roi_controller.rois]),
+        timeout=200,
+    )


 def test_roi_color_change_from_roi(roi_tree, image_widget):
--- a/tests/unit_tests/test_image_view_next_gen.py
+++ b/tests/unit_tests/test_image_view_next_gen.py
@@ -508,19 +508,31 @@ def test_crosshair_roi_panels_visibility(qtbot, mocked_client):

    # Enable ROI crosshair
    switch.actions["crosshair_roi"].action.trigger()
-    qtbot.wait(500)

    # Panels must be visible
-    assert bec_image_view.side_panel_x.panel_height > 0
-    assert bec_image_view.side_panel_y.panel_width > 0
+    qtbot.waitUntil(
+        lambda: all(
+            [
+                bec_image_view.side_panel_x.panel_height > 0,
+                bec_image_view.side_panel_y.panel_width > 0,
+            ]
+        ),
+        timeout=500,
+    )

    # Disable ROI crosshair
    switch.actions["crosshair_roi"].action.trigger()
-    qtbot.wait(500)

    # Panels hidden again
-    assert bec_image_view.side_panel_x.panel_height == 0
-    assert bec_image_view.side_panel_y.panel_width == 0
+    qtbot.waitUntil(
+        lambda: all(
+            [
+                bec_image_view.side_panel_x.panel_height == 0,
+                bec_image_view.side_panel_y.panel_width == 0,
+            ]
+        ),
+        timeout=500,
+    )


 def test_roi_plot_data_from_image(qtbot, mocked_client):
--- a/tests/unit_tests/test_launch_window.py
+++ b/tests/unit_tests/test_launch_window.py
@@ -102,7 +102,34 @@ def test_launch_window_launch_plugin_auto_update(bec_launch_window):
    [
        ({}, False),
        ({"launcher": mock.MagicMock()}, False),
-        ({"launcher": mock.MagicMock(), "dock_area": mock.MagicMock()}, True),
+        ({"launcher": mock.MagicMock(), "dock_area": mock.MagicMock()}, False),
+        (
+            {
+                "launcher": mock.MagicMock(),
+                "dock_area": mock.MagicMock(),
+                "scan_progress": mock.MagicMock(),
+            },
+            False,
+        ),
+        (
+            {
+                "launcher": mock.MagicMock(),
+                "dock_area": mock.MagicMock(),
+                "scan_progress_simple": mock.MagicMock(),
+                "scan_progress_full": mock.MagicMock(),
+            },
+            False,
+        ),
+        (
+            {
+                "launcher": mock.MagicMock(),
+                "dock_area": mock.MagicMock(),
+                "scan_progress_simple": mock.MagicMock(),
+                "scan_progress_full": mock.MagicMock(),
+                "hover_widget": mock.MagicMock(),
+            },
+            True,
+        ),
    ],
 )
 def test_gui_server_turns_off_the_lights(bec_launch_window, connections, hide):
@@ -132,7 +159,34 @@ def test_gui_server_turns_off_the_lights(bec_launch_window, connections, hide):
    [
        ({}, True),
        ({"launcher": mock.MagicMock()}, True),
-        ({"launcher": mock.MagicMock(), "dock_area": mock.MagicMock()}, False),
+        ({"launcher": mock.MagicMock(), "dock_area": mock.MagicMock()}, True),
+        (
+            {
+                "launcher": mock.MagicMock(),
+                "dock_area": mock.MagicMock(),
+                "scan_progress": mock.MagicMock(),
+            },
+            True,
+        ),
+        (
+            {
+                "launcher": mock.MagicMock(),
+                "dock_area": mock.MagicMock(),
+                "scan_progress_simple": mock.MagicMock(),
+                "scan_progress_full": mock.MagicMock(),
+            },
+            True,
+        ),
+        (
+            {
+                "launcher": mock.MagicMock(),
+                "dock_area": mock.MagicMock(),
+                "scan_progress_simple": mock.MagicMock(),
+                "scan_progress_full": mock.MagicMock(),
+                "hover_widget": mock.MagicMock(),
+            },
+            False,
+        ),
    ],
 )
 def test_launch_window_closes(bec_launch_window, connections, close_called):
--- a/tests/unit_tests/test_main_widnow.py
+++ b/tests/unit_tests/test_main_widnow.py
@@ -0,0 +1,293 @@
+import webbrowser
+
+import pytest
+from qtpy.QtCore import QEvent, QPoint, QPointF
+from qtpy.QtGui import QEnterEvent
+from qtpy.QtWidgets import QApplication, QFrame, QLabel
+
+from bec_widgets.widgets.containers.main_window.addons.hover_widget import (
+    HoverWidget,
+    WidgetTooltip,
+)
+from bec_widgets.widgets.containers.main_window.addons.scroll_label import ScrollLabel
+from bec_widgets.widgets.containers.main_window.addons.web_links import BECWebLinksMixin
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
+
+from .client_mocks import mocked_client
+from .conftest import create_widget
+
+
+@pytest.fixture
+def bec_main_window(qtbot, mocked_client):
+    widget = BECMainWindow(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+#################################################################
+# Tests for BECMainWindow Initialization and Functionality
+#################################################################
+
+
+def test_bec_main_window_initialization(bec_main_window):
+    assert isinstance(bec_main_window, BECMainWindow)
+    assert bec_main_window.windowTitle() == "BEC"
+    assert bec_main_window.app is not None
+    assert bec_main_window.statusBar() is not None
+    assert bec_main_window._app_id_label is not None
+
+
+def test_bec_main_window_display_client_message(qtbot, bec_main_window):
+    """
+    Verify that display_client_message updates the client‑info label.
+    """
+    test_msg = "Client connected successfully"
+    bec_main_window.display_client_message({"message": test_msg}, {})
+    qtbot.wait(200)
+    assert bec_main_window._client_info_label.text() == test_msg
+
+
+def test_status_bar_has_separator(bec_main_window):
+    """Ensure the status bar contains at least one vertical separator."""
+    status_bar = bec_main_window.statusBar()
+    separators = [w for w in status_bar.findChildren(QFrame) if w.frameShape() == QFrame.VLine]
+    assert separators, "Expected at least one QFrame separator in the status bar."
+
+
+#################################################################
+# Tests for BECMainWindow Addons
+#################################################################
+
+#################################################################
+# Tests for ScrollLabel behaviour
+
+
+def test_scroll_label_does_not_scroll_when_text_fits(qtbot):
+    """Label with short text should not activate scrolling timer."""
+    lbl = create_widget(qtbot, ScrollLabel)  # shorten delay for test speed
+    qtbot.addWidget(lbl)
+    lbl.resize(200, 20)
+    lbl.setText("Short text")
+    # Process events to allow timer logic to run
+    qtbot.wait(200)
+    assert not lbl._timer.isActive()
+    assert not lbl._delay_timer.isActive()
+
+
+def test_scroll_label_starts_scrolling(qtbot):
+    """Label with long text should start _delay_timer; later _timer becomes active."""
+    lbl = create_widget(qtbot, ScrollLabel, delay_ms=100)
+    lbl.resize(150, 20)
+    long_text = "This is a very long piece of text that should definitely overflow the label width"
+    lbl.setText(long_text)
+    # Immediately after setText, only delay‑timer should be active
+    assert lbl._delay_timer.isActive()
+    assert not lbl._timer.isActive()
+    # Wait until scrolling timer becomes active
+    qtbot.waitUntil(lambda: lbl._timer.isActive(), timeout=2000)
+    assert lbl._timer.isActive()
+
+
+def test_scroll_label_scroll_method(qtbot):
+    """Directly exercise _scroll to ensure offset advances and paintEvent is invoked."""
+    lbl = create_widget(qtbot, ScrollLabel, step_px=5)  # shorten delay for test speed
+    qtbot.addWidget(lbl)
+    lbl.resize(120, 20)
+    lbl.setText("x" * 200)  # long text to guarantee overflow
+    qtbot.wait(200)  # let timers configure themselves
+
+    # Capture current offset and force a manual scroll tick
+    old_offset = lbl._offset
+    lbl._scroll()
+    assert lbl._offset == old_offset + 5
+
+
+def test_scroll_label_paint_event(qtbot):
+    """
+    Grab the widget as a pixmap; this calls paintEvent under the hood
+    and ensures no exceptions occur during rendering.
+    """
+    lbl = create_widget(qtbot, ScrollLabel)  # shorten delay for test speed
+    qtbot.addWidget(lbl)
+    lbl.resize(180, 20)
+    lbl.setText("Rendering check")
+    lbl.show()
+    qtbot.wait(200)  # allow Qt to schedule a paint
+    pixmap = lbl.grab()
+    assert not pixmap.isNull()
+
+
+def test_display_client_message_with_expiration(qtbot, bec_main_window):
+    """
+    A message with a finite 'expire' value should disappear once the timer
+    fires.
+    """
+    test_msg = "This message should vanish fast"
+    expire_sec = 0.2
+
+    bec_main_window.display_client_message({"message": test_msg, "expire": expire_sec}, {})
+
+    assert bec_main_window._client_info_expire_timer.isActive()
+    assert bec_main_window._client_info_label.text() == test_msg
+
+    qtbot.waitUntil(lambda: not bec_main_window._client_info_expire_timer.isActive(), timeout=1000)
+
+    assert bec_main_window._client_info_label.text() == ""
+
+
+def test_display_client_message_no_expiration(qtbot, bec_main_window):
+    """
+    A message with 'expire' == 0 must persist and never start the timer.
+    """
+    test_msg = "Persistent status message"
+
+    bec_main_window.display_client_message({"message": test_msg, "expire": 0}, {})
+
+    assert not bec_main_window._client_info_expire_timer.isActive()
+    assert bec_main_window._client_info_label.text() == test_msg
+
+    qtbot.wait(500)
+    assert bec_main_window._client_info_label.text() == test_msg
+
+
+def test_display_client_message_overwrite_resets_timer(qtbot, bec_main_window):
+    """
+    Sending a second message while the expiration timer is active should
+    overwrite the first and stop the timer if the second one is persistent.
+    """
+    first_msg = "First (temporary)"
+    second_msg = "Second (persistent)"
+
+    bec_main_window.display_client_message({"message": first_msg, "expire": 0.3}, {})
+    qtbot.wait(200)
+    assert bec_main_window._client_info_expire_timer.isActive()
+
+    bec_main_window.display_client_message({"message": second_msg, "expire": 0}, {})
+
+    assert not bec_main_window._client_info_expire_timer.isActive()
+    assert bec_main_window._client_info_label.text() == second_msg
+
+    qtbot.wait(400)
+    assert bec_main_window._client_info_label.text() == second_msg
+
+
+#################################################################
+# Tests for BECWebLinksMixin (webbrowser opening)
+
+
+def test_bec_weblinks(monkeypatch):
+    opened_urls = []
+
+    def fake_open(url):
+        opened_urls.append(url)
+
+    monkeypatch.setattr(webbrowser, "open", fake_open)
+
+    BECWebLinksMixin.open_bec_docs()
+    BECWebLinksMixin.open_bec_widgets_docs()
+    BECWebLinksMixin.open_bec_bug_report()
+
+    assert opened_urls == [
+        "https://beamline-experiment-control.readthedocs.io/en/latest/",
+        "https://bec.readthedocs.io/projects/bec-widgets/en/latest/",
+        "https://gitlab.psi.ch/groups/bec/-/issues/",
+    ]
+
+
+#################################################################
+# Tests for scan‑progress bar animations
+
+
+def test_scan_progress_bar_show_animation(qtbot, bec_main_window):
+    """
+    _show_scan_progress_bar should animate the container's maximumWidth
+    from 0 to the configured target width.
+    """
+    container = bec_main_window._scan_progress_bar_with_separator
+
+    # Pre‑condition: collapsed
+    assert container.maximumWidth() == 0
+
+    bec_main_window._show_scan_progress_bar()
+
+    target = bec_main_window._scan_progress_bar_target_width
+    qtbot.waitUntil(lambda: container.maximumWidth() == target, timeout=2000)
+
+    assert container.maximumWidth() == target
+
+
+def test_scan_progress_bar_hide_animation(qtbot, bec_main_window):
+    """
+    _animate_hide_scan_progress_bar should collapse the container back to 0 width.
+    """
+    container = bec_main_window._scan_progress_bar_with_separator
+
+    # First expand it
+    bec_main_window._show_scan_progress_bar()
+    target = bec_main_window._scan_progress_bar_target_width
+    qtbot.waitUntil(lambda: container.maximumWidth() == target, timeout=2000)
+
+    # Trigger hide animation
+    bec_main_window._animate_hide_scan_progress_bar()
+
+    qtbot.waitUntil(lambda: container.maximumWidth() == 0, timeout=2000)
+
+    assert container.maximumWidth() == 0
+
+
+#################################################################
+# Tests for hover widget and tooltip behaviour
+
+
+def test_hover_widget_tooltip(qtbot):
+    """
+    After a HoverWidget is closed, its WidgetTooltip must be gone.
+    """
+    simple = QLabel("Hover me")
+    full = QLabel("Full details")
+    hover = create_widget(qtbot, HoverWidget, simple=simple, full=full)
+
+    assert hover._simple is simple
+    assert hover._full is full
+    assert hover._tooltip is None
+
+
+def test_widget_tooltip_show_and_hide(qtbot):
+    """
+    WidgetTooltip should appear when show_above is called and hide on Leave.
+    """
+    full_lbl = QLabel("Standalone tooltip content")
+    tooltip = create_widget(qtbot, WidgetTooltip, content=full_lbl)
+
+    # Show above an arbitrary point
+    pos = QPoint(200, 200)
+    tooltip.show_above(pos)
+    assert tooltip.isVisible()
+
+    # Send a synthetic Leave event
+    QApplication.sendEvent(tooltip, QEvent(QEvent.Leave))
+    qtbot.waitUntil(lambda: not tooltip.isVisible(), timeout=500)
+    assert not tooltip.isVisible()
+
+
+def test_hover_widget_mouse_events(qtbot):
+    """
+    Verify that HoverWidget responds correctly to Enter, MouseMove, and Leave
+    events, keeping the tooltip visible only while the pointer is inside.
+    """
+    simple = QLabel("Hover‑target")
+    full = QLabel("Full‑view")
+    hover = create_widget(qtbot, HoverWidget, simple=simple, full=full)
+
+    local = QPointF(hover.rect().center())  # inside widget
+    scene = QPointF(hover.mapTo(hover.window(), local.toPoint()))
+    global_ = QPointF(hover.mapToGlobal(local.toPoint()))
+
+    enter_event = QEnterEvent(local, scene, global_)
+    hover.enterEvent(event=enter_event)
+    qtbot.wait(200)
+
+    assert hover._tooltip is not None
+    assert hover._tooltip.isVisible()
+    assert hover._tooltip.content is full
--- a/tests/unit_tests/test_rpc_server.py
+++ b/tests/unit_tests/test_rpc_server.py
@@ -29,4 +29,4 @@ def test_gui_server_get_service_config(gui_server):
    """
    Test that the server is started with the correct arguments.
    """
-    assert gui_server._get_service_config().config is ServiceConfig().config
+    assert gui_server._get_service_config().config == ServiceConfig().config
--- a/tests/unit_tests/test_scan_control.py
+++ b/tests/unit_tests/test_scan_control.py
@@ -4,10 +4,10 @@ from unittest.mock import MagicMock, patch

 import pytest
 from bec_lib.endpoints import MessageEndpoints
-from bec_lib.messages import AvailableResourceMessage, ScanQueueHistoryMessage, ScanQueueMessage
+from bec_lib.messages import AvailableResourceMessage, ScanHistoryMessage
 from qtpy.QtCore import QModelIndex, Qt

-from bec_widgets.utils.forms_from_types.items import StrMetadataField
+from bec_widgets.utils.forms_from_types.items import StrFormItem
 from bec_widgets.utils.widget_io import WidgetIO
 from bec_widgets.widgets.control.scan_control import ScanControl

@@ -221,82 +221,36 @@ available_scans_message = AvailableResourceMessage(
    }
 )

-scan_history = ScanQueueHistoryMessage(
+scan_history = ScanHistoryMessage(
    metadata={},
-    status="COMPLETED",
-    queue_id="94d7cb39-aa70-4060-92de-addcfb64e3c0",
-    info={
-        "queue_id": "94d7cb39-aa70-4060-92de-addcfb64e3c0",
-        "scan_id": ["bc2aa11f-24f6-44d6-8717-95e97fb43015"],
-        "is_scan": [True],
-        "request_blocks": [
-            {
-                "msg": ScanQueueMessage(
-                    metadata={
-                        "file_suffix": None,
-                        "file_directory": None,
-                        "user_metadata": {},
-                        "RID": "99321ef7-00ac-4e0c-9120-ce689bd88a4d",
-                    },
-                    scan_type="line_scan",
-                    parameter={
-                        "args": {"samx": [0.0, 2.0]},
-                        "kwargs": {
-                            "steps": 10,
-                            "relative": False,
-                            "exp_time": 2.0,
-                            "burst_at_each_point": 1,
-                            "system_config": {"file_suffix": None, "file_directory": None},
-                        },
-                    },
-                    queue="primary",
-                ),
-                "RID": "99321ef7-00ac-4e0c-9120-ce689bd88a4d",
-                "scan_motors": ["samx"],
-                "readout_priority": {
-                    "monitored": ["samx"],
-                    "baseline": [],
-                    "on_request": [],
-                    "async": [],
-                },
-                "is_scan": True,
-                "scan_number": 176,
-                "scan_id": "bc2aa11f-24f6-44d6-8717-95e97fb43015",
-                "metadata": {
-                    "file_suffix": None,
-                    "file_directory": None,
-                    "user_metadata": {},
-                    "RID": "99321ef7-00ac-4e0c-9120-ce689bd88a4d",
-                },
-                "content": {
-                    "scan_type": "line_scan",
-                    "parameter": {
-                        "args": {"samx": [0.0, 2.0]},
-                        "kwargs": {
-                            "steps": 10,
-                            "relative": False,
-                            "exp_time": 2.0,
-                            "burst_at_each_point": 1,
-                            "system_config": {"file_suffix": None, "file_directory": None},
-                        },
-                    },
-                    "queue": "primary",
-                },
-                "report_instructions": [{"scan_progress": 10}],
-            }
-        ],
-        "scan_number": [176],
-        "status": "COMPLETED",
-        "active_request_block": None,
+    scan_id="79cbef20-9ebe-45bb-a44c-f518be27a25c",
+    scan_number=1,
+    dataset_number=1,
+    file_path="/somepath/scan_1.h5",
+    exit_status="closed",
+    start_time=1750618470.936856,
+    end_time=1750618473.668227,
+    scan_name="line_scan",
+    num_points=100,
+    request_inputs={
+        "arg_bundle": ["samx", 0.0, 2.0],
+        "inputs": {},
+        "kwargs": {
+            "steps": 10,
+            "exp_time": 2,
+            "relative": False,
+            "system_config": {"file_suffix": None, "file_directory": None},
+        },
    },
-    queue="primary",
 )


@pytest.fixture(scope="function")
 def scan_control(qtbot, mocked_client):  # , mock_dev):
    mocked_client.connector.set(MessageEndpoints.available_scans(), available_scans_message)
-    mocked_client.connector.lpush(MessageEndpoints.scan_queue_history(), scan_history)
+    mocked_client.connector.xadd(
+        topic=MessageEndpoints.scan_history(), msg_dict={"data": scan_history}
+    )
    widget = ScanControl(client=mocked_client)
    qtbot.addWidget(widget)
    qtbot.waitExposed(widget)
@@ -570,7 +524,7 @@ def test_scan_metadata_is_connected(scan_control):
    scan_control.comboBox_scan_selection.setCurrentText("grid_scan")
    assert scan_control._metadata_form._scan_name == "grid_scan"
    sample_name = scan_control._metadata_form._form_grid.layout().itemAtPosition(0, 1).widget()
-    assert isinstance(sample_name, StrMetadataField)
+    assert isinstance(sample_name, StrFormItem)
    sample_name._main_widget.setText("Test Sample")

    scan_control._metadata_form._additional_metadata._table_model._data = TEST_TABLE_ENTRY
--- a/tests/unit_tests/test_scan_metadata.py
+++ b/tests/unit_tests/test_scan_metadata.py
@@ -8,12 +8,12 @@ from pydantic.types import Json
 from qtpy.QtCore import QItemSelectionModel, QPoint, Qt

 from bec_widgets.utils.forms_from_types.items import (
-    BoolMetadataField,
-    DictMetadataField,
+    BoolFormItem,
+    DictFormItem,
    DynamicFormItem,
-    FloatDecimalMetadataField,
-    IntMetadataField,
-    StrMetadataField,
+    FloatDecimalFormItem,
+    IntFormItem,
+    StrFormItem,
 )
 from bec_widgets.widgets.editors.dict_backed_table import DictBackedTable
 from bec_widgets.widgets.editors.scan_metadata.scan_metadata import ScanMetadata
@@ -42,7 +42,7 @@ class ExampleSchema(BasicScanMetadata):

 TEST_DICT = {
    "sample_name": "test name",
-    "str_optional": "None",
+    "str_optional": None,
    "str_required": "something",
    "bool_optional": None,
    "bool_required_default": True,
@@ -125,18 +125,18 @@ def test_griditems_are_correct_class(
    metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
 ):
    _, components = metadata_widget
-    assert isinstance(components["sample_name"], StrMetadataField)
-    assert isinstance(components["str_optional"], StrMetadataField)
-    assert isinstance(components["str_required"], StrMetadataField)
-    assert isinstance(components["bool_optional"], BoolMetadataField)
-    assert isinstance(components["bool_required_default"], BoolMetadataField)
-    assert isinstance(components["bool_required_nodefault"], BoolMetadataField)
-    assert isinstance(components["int_default"], IntMetadataField)
-    assert isinstance(components["int_nodefault_optional"], IntMetadataField)
-    assert isinstance(components["float_nodefault"], FloatDecimalMetadataField)
-    assert isinstance(components["decimal_dp_limits_nodefault"], FloatDecimalMetadataField)
-    assert isinstance(components["dict_default"], DictMetadataField)
-    assert isinstance(components["unsupported_class"], StrMetadataField)
+    assert isinstance(components["sample_name"], StrFormItem)
+    assert isinstance(components["str_optional"], StrFormItem)
+    assert isinstance(components["str_required"], StrFormItem)
+    assert isinstance(components["bool_optional"], BoolFormItem)
+    assert isinstance(components["bool_required_default"], BoolFormItem)
+    assert isinstance(components["bool_required_nodefault"], BoolFormItem)
+    assert isinstance(components["int_default"], IntFormItem)
+    assert isinstance(components["int_nodefault_optional"], IntFormItem)
+    assert isinstance(components["float_nodefault"], FloatDecimalFormItem)
+    assert isinstance(components["decimal_dp_limits_nodefault"], FloatDecimalFormItem)
+    assert isinstance(components["dict_default"], DictFormItem)
+    assert isinstance(components["unsupported_class"], StrFormItem)


 def test_grid_to_dict(metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]]):
--- a/tests/unit_tests/test_scan_progress_bar.py
+++ b/tests/unit_tests/test_scan_progress_bar.py
@@ -0,0 +1,336 @@
+from unittest import mock
+
+import numpy as np
+import pytest
+from bec_lib import messages
+
+from bec_widgets.widgets.progress.bec_progressbar.bec_progressbar import (
+    BECProgressBar,
+    ProgressState,
+)
+from bec_widgets.widgets.progress.scan_progressbar.scan_progressbar import (
+    ProgressSource,
+    ProgressTask,
+    ScanProgressBar,
+)
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def scan_progressbar(qtbot, mocked_client):
+    widget = ScanProgressBar(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+
+
+def test_progress_task_basic():
+    """percentage, remaining, and formatted time helpers behave as expected."""
+    task = ProgressTask(parent=None, value=50, max_value=100, done=False)
+    task.timer.stop()  # we don’t want the timer ticking in tests
+    task._elapsed_time = 10  # simulate 10 s elapsed
+
+    # 50 / 100  ⇒ 50 %
+    assert task.percentage == 50
+
+    # speed  =  value / elapsed  = 5 steps / s
+    assert np.isclose(task.speed, 5)
+
+    # remaining steps = 50 ; time_remaining ≈ 10 s
+    assert task.remaining == 50
+    assert task.time_remaining == "00:00:10"
+
+    # time_elapsed formatting
+    assert task.time_elapsed == "00:00:10"
+
+
+def test_scan_progressbar_initialization(scan_progressbar):
+    assert isinstance(scan_progressbar, ScanProgressBar)
+    assert isinstance(scan_progressbar.progressbar, BECProgressBar)
+
+
+def test_update_labels_content(scan_progressbar):
+    """update_labels() reflects ProgressTask time strings on the UI."""
+    # fabricate a task with known timings
+    task = ProgressTask(parent=scan_progressbar, value=30, max_value=100, done=False)
+    task.timer.stop()
+    task._elapsed_time = 50
+    scan_progressbar.task = task
+
+    scan_progressbar.update_labels()
+
+    assert scan_progressbar.ui.elapsed_time_label.text() == "00:00:50"
+    assert scan_progressbar.ui.remaining_time_label.text() == "00:01:57"
+
+
+def test_on_progress_update(qtbot, scan_progressbar):
+    """
+    on_progress_update() should forward new values to the embedded
+    BECProgressBar and keep ProgressTask in sync.
+    """
+    task = ProgressTask(parent=scan_progressbar, value=0, max_value=100, done=False)
+    task.timer.stop()
+    scan_progressbar.task = task
+
+    msg = {"value": 20, "max_value": 100, "done": False}
+    scan_progressbar.on_progress_update(msg, metadata={"status": "open"})
+
+    qtbot.wait(200)
+    bar = scan_progressbar.progressbar
+    assert bar._user_value == 20
+    assert bar._user_maximum == 100
+    # state reflects BEC status
+    assert bar.state is ProgressState.NORMAL
+
+
+@pytest.mark.parametrize(
+    "status, value, max_val, expected_state",
+    [
+        ("open", 10, 100, ProgressState.NORMAL),
+        ("paused", 25, 100, ProgressState.PAUSED),
+        ("aborted", 30, 100, ProgressState.INTERRUPTED),
+        ("halted", 40, 100, ProgressState.PAUSED),
+        ("closed", 100, 100, ProgressState.COMPLETED),
+    ],
+)
+def test_state_mapping_during_updates(
+    qtbot, scan_progressbar, status, value, max_val, expected_state
+):
+    """ScanProgressBar should translate BEC status → ProgressState consistently."""
+    task = ProgressTask(parent=scan_progressbar, value=0, max_value=max_val, done=False)
+    task.timer.stop()
+    scan_progressbar.task = task
+
+    scan_progressbar.on_progress_update(
+        {"value": value, "max_value": max_val, "done": status == "closed"},
+        metadata={"status": status},
+    )
+
+    assert scan_progressbar.progressbar.state is expected_state
+
+
+def test_source_label_updates(scan_progressbar):
+    """update_source_label() renders correct text for both progress sources."""
+    # device progress
+    scan_progressbar.update_source_label(ProgressSource.DEVICE_PROGRESS, device="motor")
+    assert scan_progressbar.ui.source_label.text() == "Device motor"
+
+    # scan progress (needs a scan_number for deterministic text)
+    scan_progressbar.scan_number = 5
+    scan_progressbar.update_source_label(ProgressSource.SCAN_PROGRESS)
+    assert scan_progressbar.ui.source_label.text() == "Scan 5"
+
+
+def test_set_progress_source_connections(scan_progressbar, monkeypatch):
+    """ """
+    from bec_lib.endpoints import MessageEndpoints
+
+    connect_calls = []
+    disconnect_calls = []
+
+    def fake_connect(slot, endpoint):
+        connect_calls.append(endpoint)
+
+    def fake_disconnect(slot, endpoint):
+        disconnect_calls.append(endpoint)
+
+    # Patch dispatcher methods
+    monkeypatch.setattr(scan_progressbar.bec_dispatcher, "connect_slot", fake_connect)
+    monkeypatch.setattr(scan_progressbar.bec_dispatcher, "disconnect_slot", fake_disconnect)
+
+    # switch to SCAN_PROGRESS
+    scan_progressbar.scan_number = 7
+    scan_progressbar.set_progress_source(ProgressSource.SCAN_PROGRESS)
+
+    assert scan_progressbar._progress_source == ProgressSource.SCAN_PROGRESS
+    assert scan_progressbar.ui.source_label.text() == "Scan 7"
+    assert connect_calls[-1] == MessageEndpoints.scan_progress()
+    assert disconnect_calls == []
+
+    # switch to DEVICE_PROGRESS
+    device = "motor"
+    scan_progressbar.set_progress_source(ProgressSource.DEVICE_PROGRESS, device=device)
+
+    assert scan_progressbar._progress_source == ProgressSource.DEVICE_PROGRESS
+    assert scan_progressbar.ui.source_label.text() == f"Device {device}"
+    assert connect_calls[-1] == MessageEndpoints.device_progress(device=device)
+    assert disconnect_calls == [MessageEndpoints.scan_progress()]
+
+    # calling again with the SAME source should not add new connect calls
+    prev_connect_count = len(connect_calls)
+    scan_progressbar.set_progress_source(ProgressSource.DEVICE_PROGRESS, device=device)
+    assert len(connect_calls) == prev_connect_count, "No extra connect made for same source"
+
+
+def test_progressbar_queue_update(scan_progressbar):
+    """
+    Test that an empty queue update does not change the progress source.
+    """
+    msg = messages.ScanQueueStatusMessage(queue={"primary": {"info": [], "status": "RUNNING"}})
+    with mock.patch.object(scan_progressbar, "set_progress_source") as mock_set_source:
+        scan_progressbar.on_queue_update(
+            msg.content, msg.metadata, _override_slot_params={"verify_sender": False}
+        )
+        mock_set_source.assert_not_called()
+
+
+def test_progressbar_queue_update_with_scan(scan_progressbar):
+    """
+    Test that a queue update with a scan changes the progress source to SCAN_PROGRESS.
+    """
+    msg = messages.ScanQueueStatusMessage(
+        metadata={},
+        queue={
+            "primary": {
+                "info": [
+                    {
+                        "queue_id": "40831e2c-fbd1-4432-8072-ad168a7ad964",
+                        "scan_id": ["e3f50794-852c-4bb1-965e-41c585ab0aa9"],
+                        "status": "RUNNING",
+                        "active_request_block": {
+                            "msg": messages.ScanQueueMessage(
+                                metadata={
+                                    "file_suffix": None,
+                                    "file_directory": None,
+                                    "user_metadata": {"sample_name": ""},
+                                    "RID": "94949c6e-d5f2-4f01-837e-a5d36257dd5d",
+                                },
+                                scan_type="line_scan",
+                                parameter={
+                                    "args": {"samx": [-10.0, 10.0]},
+                                    "kwargs": {
+                                        "steps": 20,
+                                        "relative": False,
+                                        "exp_time": 0.1,
+                                        "burst_at_each_point": 1,
+                                        "system_config": {
+                                            "file_suffix": None,
+                                            "file_directory": None,
+                                        },
+                                    },
+                                },
+                                queue="primary",
+                            ),
+                            "scan_number": 1,
+                            "report_instructions": [{"scan_progress": 20}],
+                        },
+                    }
+                ],
+                "status": "RUNNING",
+            }
+        },
+    )
+
+    with mock.patch.object(scan_progressbar, "set_progress_source") as mock_set_source:
+        scan_progressbar.on_queue_update(
+            msg.content, msg.metadata, _override_slot_params={"verify_sender": False}
+        )
+        mock_set_source.assert_called_once_with(ProgressSource.SCAN_PROGRESS)
+
+
+def test_progressbar_queue_update_with_device(scan_progressbar):
+    """
+    Test that a queue update with a device changes the progress source to DEVICE_PROGRESS.
+    """
+    msg = messages.ScanQueueStatusMessage(
+        metadata={},
+        queue={
+            "primary": {
+                "info": [
+                    {
+                        "queue_id": "40831e2c-fbd1-4432-8072-ad168a7ad964",
+                        "scan_id": ["e3f50794-852c-4bb1-965e-41c585ab0aa9"],
+                        "status": "RUNNING",
+                        "active_request_block": {
+                            "msg": messages.ScanQueueMessage(
+                                metadata={
+                                    "file_suffix": None,
+                                    "file_directory": None,
+                                    "user_metadata": {"sample_name": ""},
+                                    "RID": "94949c6e-d5f2-4f01-837e-a5d36257dd5d",
+                                },
+                                scan_type="line_scan",
+                                parameter={
+                                    "args": {"samx": [-10.0, 10.0]},
+                                    "kwargs": {
+                                        "steps": 20,
+                                        "relative": False,
+                                        "exp_time": 0.1,
+                                        "burst_at_each_point": 1,
+                                        "system_config": {
+                                            "file_suffix": None,
+                                            "file_directory": None,
+                                        },
+                                    },
+                                },
+                                queue="primary",
+                            ),
+                            "scan_number": 1,
+                            "report_instructions": [{"device_progress": ["samx"]}],
+                        },
+                    }
+                ],
+                "status": "RUNNING",
+            }
+        },
+    )
+
+    with mock.patch.object(scan_progressbar, "set_progress_source") as mock_set_source:
+        scan_progressbar.on_queue_update(
+            msg.content, msg.metadata, _override_slot_params={"verify_sender": False}
+        )
+        mock_set_source.assert_called_once_with(ProgressSource.DEVICE_PROGRESS, device="samx")
+
+
+def test_progressbar_queue_update_with_no_scan_or_device(scan_progressbar):
+    """
+    Test that a queue update with neither scan nor device does not change the progress source.
+    """
+    msg = messages.ScanQueueStatusMessage(
+        metadata={},
+        queue={
+            "primary": {
+                "info": [
+                    {
+                        "queue_id": "40831e2c-fbd1-4432-8072-ad168a7ad964",
+                        "scan_id": ["e3f50794-852c-4bb1-965e-41c585ab0aa9"],
+                        "status": "RUNNING",
+                        "active_request_block": {
+                            "msg": messages.ScanQueueMessage(
+                                metadata={
+                                    "file_suffix": None,
+                                    "file_directory": None,
+                                    "user_metadata": {"sample_name": ""},
+                                    "RID": "94949c6e-d5f2-4f01-837e-a5d36257dd5d",
+                                },
+                                scan_type="line_scan",
+                                parameter={
+                                    "args": {"samx": [-10.0, 10.0]},
+                                    "kwargs": {
+                                        "steps": 20,
+                                        "relative": False,
+                                        "exp_time": 0.1,
+                                        "burst_at_each_point": 1,
+                                        "system_config": {
+                                            "file_suffix": None,
+                                            "file_directory": None,
+                                        },
+                                    },
+                                },
+                                queue="primary",
+                            ),
+                            "scan_number": 1,
+                        },
+                    }
+                ],
+                "status": "RUNNING",
+            }
+        },
+    )
+
+    with mock.patch.object(scan_progressbar, "set_progress_source") as mock_set_source:
+        scan_progressbar.on_queue_update(
+            msg.content, msg.metadata, _override_slot_params={"verify_sender": False}
+        )
+        mock_set_source.assert_not_called()
--- a/tests/unit_tests/test_signal_label.py
+++ b/tests/unit_tests/test_signal_label.py
@@ -121,11 +121,13 @@ def test_custom_label(signal_label: SignalLabel, qtbot):

 def test_units_in_display(signal_label: SignalLabel, qtbot):
    signal_label._value = "1.8"
+    signal_label._dtype = "float"
    signal_label.custom_units = "Mfurlong μfortnight⁻¹"
    assert signal_label._display.text() == "1.800 Mfurlong μfortnight⁻¹"


 def test_decimal_places(signal_label: SignalLabel, qtbot):
+    signal_label._dtype = "float"
    signal_label.decimal_places = 2
    signal_label.set_display_value("123.456")
    assert signal_label._display.text() == "123.46 m/s"
@@ -226,6 +228,7 @@ def test_handle_readback(signal_label: SignalLabel, qtbot):
    signal_label.device = "samx"
    signal_label.signal = "readback"
    signal_label.custom_units = "μm"
+    signal_label._dtype = "float"
    signal_label.on_device_readback({"random": {"stuff": "in", "corrupted": "reading"}}, {})
    assert signal_label._display.text() == "ERROR!"
    assert "Error processing incoming reading" in signal_label._display.toolTip()
--- a/tests/unit_tests/test_waveform_next_gen.py
+++ b/tests/unit_tests/test_waveform_next_gen.py
@@ -806,6 +806,13 @@ def test_show_curve_settings_popup(qtbot, mocked_client):
    assert wf.curve_settings_dialog.isVisible()
    assert curve_action.isChecked()

+    # add a new row to the curve tree
+    wf.curve_settings_dialog.widget.curve_manager.toolbar.widgets["add"].action.trigger()
+    wf.curve_settings_dialog.widget.curve_manager.toolbar.widgets["add"].action.trigger()
+    qtbot.wait(100)
+    # Check that the new row is added
+    assert wf.curve_settings_dialog.widget.curve_manager.tree.model().rowCount() == 2
+
    wf.curve_settings_dialog.close()
    assert wf.curve_settings_dialog is None
    assert not curve_action.isChecked(), "Should be unchecked after closing dialog"
--- a/tests/unit_tests/test_website_widget.py
+++ b/tests/unit_tests/test_website_widget.py
@@ -23,4 +23,7 @@ def test_website_widget_set_url(website_widget):

    website_widget.set_url("https://google.com")
    website_widget.wait_until_loaded()
-    assert website_widget.get_url() == "https://www.google.com/"
+    # in case we get https://www.google.com/sorry/index?continue=https://google.com/&q=...
+    # because of rate limiting or ddos protections etc
+    # e.g. https://github.com/bec-project/bec_widgets/actions/runs/15675153971/job/44172519713?pr=686
+    assert website_widget.get_url().startswith("https://www.google.com/")
Author	SHA1	Message	Date
wyzula-jan	2f1526182b	docs(waveform): plotting ruleset	2025-07-02 23:03:01 +02:00
semantic-release	f10140e0f3	2.21.2 Automatically generated by python-semantic-release	2025-06-30 11:53:00 +00:00
wakonig_k	09c5a443aa	fix(waveform): fix waveform categorisation for aborted scans	2025-06-30 13:52:19 +02:00
wakonig_k	3f5ab142a3	test: assert config for equality, not identity	2025-06-29 11:52:14 +02:00
semantic-release	422d06d141	2.21.1 Automatically generated by python-semantic-release	2025-06-29 09:49:32 +00:00
wakonig_k	371bc485d0	fix(sbb monitor): add missing pyproject file	2025-06-29 11:48:47 +02:00
semantic-release	70970ecf00	2.21.0 Automatically generated by python-semantic-release	2025-06-28 17:36:16 +00:00
wakonig_k	3d59c25aa9	feat(sbb monitor): add sbb monitor widget	2025-06-28 19:35:36 +02:00
semantic-release	70a06c5fd1	2.20.1 Automatically generated by python-semantic-release	2025-06-28 14:23:36 +00:00
wakonig_k	7ba8863d6a	fix(signal input base): unregister callback to avoid accessing deleted qt objects	2025-06-28 16:22:55 +02:00
semantic-release	00ea8bb6c6	2.20.0 Automatically generated by python-semantic-release	2025-06-26 13:03:28 +00:00
wakonig_k	e841468892	refactor(curve settings): move signal logic to SignalCombobox	2025-06-26 15:02:31 +02:00
wyzula-jan	48a0e5831f	fix(curve_settings): larger minimalWidth for the x device combobox selection	2025-06-26 15:02:31 +02:00
wakonig_k	1e9dd4cd25	test(curve settings): add curve tree elements to the dialog test	2025-06-26 15:02:31 +02:00
wakonig_k	d10328cb5c	feat(waveform): move x axis selection to a combobox	2025-06-26 15:02:31 +02:00
semantic-release	6b248e93f5	2.19.4 Automatically generated by python-semantic-release	2025-06-26 07:13:15 +00:00
wakonig_k	bc3085ab8c	fix(curve tree): remove manual interception of the close event; call parent cleanup	2025-06-26 09:12:35 +02:00
wakonig_k	9cba696afd	fix(waveform): curve tree elements must clean up signal combobox	2025-06-26 09:12:35 +02:00
semantic-release	881b7a7e9d	2.19.3 Automatically generated by python-semantic-release	2025-06-25 14:53:56 +00:00
wyzula-jan	29a26b19f9	fix(scan_control): safeguard against empty history; reversed history to fetch the newest scan	2025-06-25 16:53:10 +02:00
semantic-release	cba4d47f76	2.19.2 Automatically generated by python-semantic-release	2025-06-23 14:18:46 +00:00
wyzula-jan	9f3dcc3ab3	build: bec_lib 3.44 required	2025-06-23 16:17:59 +02:00
wyzula-jan	57f75bd4d5	refactor(scan_control): request_last_executed_scan_parameters logic adjusted	2025-06-23 16:17:59 +02:00
wyzula-jan	4456297beb	fix(scan_control): scan parameters fetched from the scan_history, fix #707	2025-06-23 16:17:59 +02:00
semantic-release	ae26b43fb1	2.19.1 Automatically generated by python-semantic-release	2025-06-23 14:07:09 +00:00
wyzula-jan	7484f5160c	fix(launch_window): number of remaining connections extended to 4	2025-06-23 16:06:27 +02:00
wyzula-jan	6421050116	feat(hover_widget) widget enables to display different widget upon hover; applied to scan progress and client info message in status bar of BECMainWindow	2025-06-23 16:06:27 +02:00
semantic-release	5a137d1219	2.19.0 Automatically generated by python-semantic-release	2025-06-23 12:54:48 +00:00
David Perl	d5a40dabc7	fix(ci): extend check for pyside import to tests	2025-06-23 14:54:06 +02:00
David Perl	f3da6e959e	feat: (#494 ) add signal display to device browser	2025-06-23 14:54:06 +02:00
David Perl	3a103410e7	feat: (#494 ) display device signals	2025-06-23 14:54:06 +02:00
David Perl	3378051250	feat: (#494 ) add tabbed layout for device item	2025-06-23 14:54:06 +02:00
semantic-release	77db658f3d	2.18.0 Automatically generated by python-semantic-release	2025-06-22 17:40:06 +00:00
wakonig_k	6e2f2cea91	refactor(device input): refactor to SafeProperty and SafeSlot	2025-06-22 19:39:19 +02:00
wakonig_k	eea5f7ebbd	feat(curve settings): add combobox selection for device and signal	2025-06-22 19:39:19 +02:00
wakonig_k	a9708f6d8f	fix(curve settings): add initial size hint	2025-06-22 19:39:19 +02:00
wakonig_k	b51de1a00e	feat(signal combobox): add reset_selection slot	2025-06-22 19:39:19 +02:00
wakonig_k	8e8acd672c	feat(FilterIO): add support for item data	2025-06-22 19:39:19 +02:00
wakonig_k	4c2c0c5525	feat(device combobox): emit reset event if validation fails	2025-06-22 19:39:19 +02:00
wakonig_k	5a564a5f3f	fix: make settings dialog resizable	2025-06-22 19:39:19 +02:00
semantic-release	43ad207aa8	2.17.0 Automatically generated by python-semantic-release	2025-06-22 13:33:32 +00:00
wakonig_k	a4274ff8cd	build: update min dependency of bec to 3.42.4	2025-06-22 15:32:45 +02:00
wakonig_k	b2a46e284d	test(scan progress): add test for queue update logic	2025-06-22 15:32:45 +02:00
wyzula-jan	9ff170660e	feat(main_window): timer to show hide scan progress when it is relevant only	2025-06-22 15:32:45 +02:00
wyzula-jan	6c04eac18c	test(scan_progress): tests extended	2025-06-22 15:32:45 +02:00
wyzula-jan	aca6efb567	fix(main_window): labels and sizing of scan progress adopted	2025-06-22 15:32:45 +02:00
wyzula-jan	88b42e49e3	fix(scan_progressbar): mapping of bec progress states to the progressbar enums	2025-06-22 15:32:45 +02:00
wyzula-jan	d3a9e0903a	feat(progressbar): state setting and dynamic corner radius	2025-06-22 15:32:45 +02:00
wyzula-jan	3bbb8daa24	fix(launch_window): number of remaining connections increase to 2 to include the ScanProgressBar	2025-06-22 15:32:45 +02:00
wyzula-jan	e8ae9725fa	fix(scan_progressbar): cleanup adjusted	2025-06-22 15:32:45 +02:00
wakonig_k	497e394deb	feat(main_window): added scan progress bar to BECMainWindow status bar	2025-06-22 15:32:45 +02:00
wyzula-jan	d5ca7b8433	feat(scan_progressbar): added oneline design for compact applications	2025-06-22 15:32:45 +02:00
wyzula-jan	b02c870dbf	fix(bec_progressbar): layout and sizing adjustments	2025-06-22 15:32:45 +02:00
wakonig_k	92d0ffee65	refactor(progressbar): change slot / property to safeslot / safeproperty	2025-06-22 15:32:45 +02:00
wakonig_k	c4b85381a4	feat(scan_progressbar): added progressbar with hooks to scan progress and device progress	2025-06-22 15:32:45 +02:00
wakonig_k	a451625a5a	feat(progressbar): added padding as designer property	2025-06-22 15:32:45 +02:00
semantic-release	54dd0a9913	2.16.2 Automatically generated by python-semantic-release	2025-06-20 12:26:07 +00:00
wyzula-jan	3146d98c57	test(utils): DMMock can fetch get_bec_signals method	2025-06-20 14:25:27 +02:00
wyzula-jan	a3ffcefe80	fix(waveform): AsyncSignal are handled with the same update mechanism as async readback	2025-06-20 14:25:27 +02:00
semantic-release	1a7052073d	2.16.1 Automatically generated by python-semantic-release	2025-06-20 06:40:07 +00:00
wakonig_k	235aabf307	fix(scatter): fix tab order	2025-06-20 08:39:28 +02:00
semantic-release	c1cb69b0e8	2.16.0 Automatically generated by python-semantic-release	2025-06-17 14:33:15 +00:00
David Perl	11131ef14c	fix: adjust height of list widget	2025-06-17 15:32:24 +01:00
David Perl	5e4c129af6	fix: parse config on submission and reload after	2025-06-17 15:32:24 +01:00
David Perl	4d8c07cdd1	fix: make website test robust	2025-06-17 15:32:24 +01:00
David Perl	8f4c8e45b3	fix: tidy up form widget formatting	2025-06-17 15:32:24 +01:00
David Perl	5623547e92	fix: reset dict table properly	2025-06-17 15:32:24 +01:00
David Perl	be73349c70	feat: add set form item	2025-06-17 15:32:24 +01:00
David Perl	1a350c3b16	fix: put waiting in thread	2025-06-17 15:32:24 +01:00
David Perl	138d4cabbd	feat: generate combobox for literal str	2025-06-17 15:32:24 +01:00
David Perl	b0d03c0648	refactor: rename field widgets	2025-06-17 15:32:24 +01:00
David Perl	a9613a07b0	test: add tests for config dialog	2025-06-17 15:32:24 +01:00
David Perl	886964bb54	feat: allow editing device config from browser	2025-06-17 15:32:24 +01:00
David Perl	7fc85bac7f	feat: add a widget to edit lists in forms	2025-06-17 15:32:24 +01:00
David Perl	d626caae3d	perf: replace wait with waitUntil	2025-06-17 15:32:24 +01:00
David Perl	dea2568de3	fix: scale dict widget height	2025-06-17 15:32:24 +01:00
David Perl	a55f561971	fix: pass on kwargs from PydanticModelForm	2025-06-17 15:32:24 +01:00
David Perl	9ce31c9833	refactor: move device config form to module	2025-06-17 15:32:24 +01:00
semantic-release	95ce98c622	2.15.1 Automatically generated by python-semantic-release	2025-06-16 15:19:40 +00:00
wyzula-jan	187bf493a5	fix(main_window): added expiration timer for scroll label for ClientInfoMessage	2025-06-16 17:18:52 +02:00
wyzula-jan	1612933dd9	fix(scroll_label): updating label during scrolling is done imminently, regardless scrolling	2025-06-16 17:18:52 +02:00
semantic-release	8c3d6334f6	2.15.0 Automatically generated by python-semantic-release	2025-06-15 10:39:36 +00:00
wyzula-jan	30acc4c236	test(main_window): BECMainWindow tests extended	2025-06-15 12:38:56 +02:00
wyzula-jan	0dec78afba	feat(main_window): main window can display the messages from the send_client_info as a scrolling horizontal text; closes #700	2025-06-15 12:38:56 +02:00
wyzula-jan	57b9a57a63	refactor(main_window): app id is displayed as QLabel instead of message	2025-06-15 12:38:56 +02:00
wyzula-jan	644be621f2	fix(main_window): central widget cleanup check to not remove None	2025-06-15 12:38:56 +02:00