2.33.3

Automatically generated by python-semantic-release

CHANGELOG.md

@@ -1,6 +1,108 @@
 # CHANGELOG
 
 
+## v2.33.3 (2025-07-31)
+
+### Bug Fixes
+
+- **scan-history-view**: Account for async loading of scan history
+  ([`6df1d0c`](https://github.com/bec-project/bec_widgets/commit/6df1d0c31fb58c25b01e95e2247277ff2dd5d00e))
+
+### Refactoring
+
+- Improve scan history performance on loading full scan lists
+  ([`a5adf3a`](https://github.com/bec-project/bec_widgets/commit/a5adf3a97d9ff05cef833445c1e6cd8f35a9a2fa))
+
+- Make ids a set, cleanup
+  ([`c1f62ad`](https://github.com/bec-project/bec_widgets/commit/c1f62ad6cb00d9b392a8e0b6247f5260dfb37256))
+
+- Use client callback for scan history reload
+  ([`d22a331`](https://github.com/bec-project/bec_widgets/commit/d22a3317baeccfcc4e074dcef4e3912301d210c5))
+
+- **scan-history**: Add spinner for loading time of history
+  ([`50c84a7`](https://github.com/bec-project/bec_widgets/commit/50c84a766a2b021768fb2c0e8ee00b8e5f058ba7))
+
+- **scan-history**: Fix insert logic; cleanup
+  ([`946752a`](https://github.com/bec-project/bec_widgets/commit/946752a4b05804c2f59cb5c21e4c1d11709a7d44))
+
+
+## v2.33.2 (2025-07-31)
+
+### Bug Fixes
+
+- Delete choice dialog on close
+  ([`23413cf`](https://github.com/bec-project/bec_widgets/commit/23413cffabe721e35bb5bb726ec34d74dc4ffe05))
+
+- Display short lists in SignalDisplay
+  ([`4bbb8fa`](https://github.com/bec-project/bec_widgets/commit/4bbb8fa519e8a90eebfcfa34e157493c9baa7880))
+
+- Don't warn on empty DeviceEdit init
+  ([`f18eeb9`](https://github.com/bec-project/bec_widgets/commit/f18eeb9c5dccbd9348b6ee6d1477a8b7925d40fc))
+
+- Remove config, directly set device+signal
+  ([`32ce8e2`](https://github.com/bec-project/bec_widgets/commit/32ce8e2818ceacda87e48399e3ed4df0cabb2335))
+
+
+## v2.33.1 (2025-07-31)
+
+### Bug Fixes
+
+- **cli**: Ensure guis are not started twice
+  ([`cd81e7f`](https://github.com/bec-project/bec_widgets/commit/cd81e7f9ba40be23f6b930d250f743276720b277))
+
+
+## v2.33.0 (2025-07-29)
+
+### Bug Fixes
+
+- **monaco**: Forward text changed signal
+  ([`a51ef04`](https://github.com/bec-project/bec_widgets/commit/a51ef04cdf0ac8abdb7008d78b13c75b86ce9e06))
+
+### Build System
+
+- Update bec and qtmonaco min dependencies
+  ([`5f925ba`](https://github.com/bec-project/bec_widgets/commit/5f925ba4e3840219e4473d6346ece6746076f718))
+
+### Features
+
+- **monaco**: Add insert, delete and lsp header
+  ([`fc68d2c`](https://github.com/bec-project/bec_widgets/commit/fc68d2cf2d6b161d8e3b9fc9daf6185d9197deba))
+
+- **monaco**: Add vim mode
+  ([`627b49b`](https://github.com/bec-project/bec_widgets/commit/627b49b33a30e45b2bfecb57f090eecfa31af09d))
+
+- **web console**: Add set_readonly method
+  ([`c2e1642`](https://github.com/bec-project/bec_widgets/commit/c2e16429c91de7cc0e672ba36224e9031c1c4234))
+
+- **web console**: Add signal to indicate when the js backend is initialized
+  ([`2b9fe6c`](https://github.com/bec-project/bec_widgets/commit/2b9fe6c9590c8d18b7542307273176e118828681))
+
+### Testing
+
+- **web console**: Add tests for the web console
+  ([`40f4bce`](https://github.com/bec-project/bec_widgets/commit/40f4bce2854bcf333ce261229bd1703b80ced538))
+
+
+## v2.32.0 (2025-07-29)
+
+### Features
+
+- **dock area**: Add screenshot toolbar action
+  ([`fd5af01`](https://github.com/bec-project/bec_widgets/commit/fd5af0184279400ca6d8e5d2042f31be88d180f3))
+
+- **rpc_timeout**: Add decorator to override the rpc timeout
+  ([`8a214c8`](https://github.com/bec-project/bec_widgets/commit/8a214c897899d0d94d5f262591a001c127d1b155))
+
+
+## v2.31.3 (2025-07-29)
+
+### Bug Fixes
+
+- **waveform**: Fallback mechanism for auto mode to use index if scan_report_devices are not
+  available
+  ([`6bf84ae`](https://github.com/bec-project/bec_widgets/commit/6bf84aea2508ff01fe201c045ec055684da88593))
+
+
 ## v2.31.2 (2025-07-29)
 
 ### Bug Fixes

bec_widgets/cli/client.py

@@ -12,7 +12,7 @@ from typing import Literal, Optional
 
 from bec_lib.logger import bec_logger
 
-from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
+from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
 from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets, get_plugin_client_module
 
 logger = bec_logger.logger
@@ -414,6 +414,13 @@ class BECDockArea(RPCBase):
             dict: The state of the dock area.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @rpc_call
     def restore_state(
         self, state: "dict" = None, missing: "Literal['ignore', 'error']" = "ignore", extra="bottom"
@@ -1426,6 +1433,13 @@ class Heatmap(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def color_map(self) -> "str":
@@ -1964,6 +1978,13 @@ class Image(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def color_map(self) -> "str":
@@ -2448,6 +2469,26 @@ class MonacoWidget(RPCBase):
         Get the current text from the Monaco editor.
         """
 
+    @rpc_call
+    def insert_text(self, text: str, line: int | None = None, column: int | None = None) -> None:
+        """
+        Insert text at the current cursor position or at a specified line and column.
+
+        Args:
+            text (str): The text to insert.
+            line (int, optional): The line number (1-based) to insert the text at. Defaults to None.
+            column (int, optional): The column number (1-based) to insert the text at. Defaults to None.
+        """
+
+    @rpc_call
+    def delete_line(self, line: int | None = None) -> None:
+        """
+        Delete a line in the Monaco editor.
+
+        Args:
+            line (int, optional): The line number (1-based) to delete. If None, the current line will be deleted.
+        """
+
     @rpc_call
     def set_language(self, language: str) -> None:
         """
@@ -2521,6 +2562,34 @@ class MonacoWidget(RPCBase):
             enabled (bool): If True, the minimap will be enabled; otherwise, it will be disabled.
         """
 
+    @rpc_call
+    def set_vim_mode_enabled(self, enabled: bool) -> None:
+        """
+        Enable or disable Vim mode in the Monaco editor.
+
+        Args:
+            enabled (bool): If True, Vim mode will be enabled; otherwise, it will be disabled.
+        """
+
+    @rpc_call
+    def set_lsp_header(self, header: str) -> None:
+        """
+        Set the LSP (Language Server Protocol) header for the Monaco editor.
+        The header is used to provide context for language servers but is not displayed in the editor.
+
+        Args:
+            header (str): The LSP header to set.
+        """
+
+    @rpc_call
+    def get_lsp_header(self) -> str:
+        """
+        Get the current LSP header set in the Monaco editor.
+
+        Returns:
+            str: The LSP header.
+        """
+
 
 class MotorMap(RPCBase):
     """Motor map widget for plotting motor positions in 2D including a trace of the last points."""
@@ -2796,6 +2865,13 @@ class MotorMap(RPCBase):
         The font size of the legend font.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def color(self) -> "tuple":
@@ -3201,6 +3277,13 @@ class MultiWaveform(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def highlighted_index(self):
@@ -3415,6 +3498,13 @@ class PositionerBox(RPCBase):
             positioner (Positioner | str) : Positioner to set, accepts str or the device
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class PositionerBox2D(RPCBase):
     """Simple Widget to control two positioners in box form"""
@@ -3437,6 +3527,13 @@ class PositionerBox2D(RPCBase):
             positioner (Positioner | str) : Positioner to set, accepts str or the device
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class PositionerControlLine(RPCBase):
     """A widget that controls a single device."""
@@ -3450,6 +3547,13 @@ class PositionerControlLine(RPCBase):
             positioner (Positioner | str) : Positioner to set, accepts str or the device
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class PositionerGroup(RPCBase):
     """Simple Widget to control a positioner in box form"""
@@ -3908,6 +4012,13 @@ class ScanControl(RPCBase):
         Cleanup the BECConnector
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
 
 class ScanProgressBar(RPCBase):
     """Widget to display a progress bar that is hooked up to the scan progress of a scan."""
@@ -4216,6 +4327,13 @@ class ScatterWaveform(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def main_curve(self) -> "ScatterCurve":
@@ -4445,6 +4563,20 @@ class SignalLabel(RPCBase):
         Displays the full data from array signals if set to True.
         """
 
+    @property
+    @rpc_call
+    def max_list_display_len(self) -> "int":
+        """
+        For small lists, the max length to display
+        """
+
+    @max_list_display_len.setter
+    @rpc_call
+    def max_list_display_len(self) -> "int":
+        """
+        For small lists, the max length to display
+        """
+
 
 class SignalLineEdit(RPCBase):
     """Line edit widget for device input with autocomplete for device names."""
@@ -4833,6 +4965,13 @@ class Waveform(RPCBase):
         Minimum decimal places for crosshair when dynamic precision is enabled.
         """
 
+    @rpc_timeout(None)
+    @rpc_call
+    def screenshot(self, file_name: "str | None" = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+
     @property
     @rpc_call
     def curves(self) -> "list[Curve]":

bec_widgets/cli/client_utils.py

@@ -151,8 +151,10 @@ def wait_for_server(client: BECGuiClient):
             raise RuntimeError("GUI is not alive")
     try:
         if client._gui_started_event.wait(timeout=timeout):
-            client._gui_started_timer.cancel()
-            client._gui_started_timer.join()
+            if client._gui_started_timer is not None:
+                # cancel the timer, we are done
+                client._gui_started_timer.cancel()
+                client._gui_started_timer.join()
         else:
             raise TimeoutError("Could not connect to GUI server")
     finally:
@@ -261,13 +263,20 @@ class BECGuiClient(RPCBase):
 
     def start(self, wait: bool = False) -> None:
         """Start the GUI server."""
+        logger.warning("Using <gui>.start() is deprecated, use <gui>.show() instead.")
         return self._start(wait=wait)
 
-    def show(self):
-        """Show the GUI window."""
+    def show(self, wait=True) -> None:
+        """
+        Show the GUI window.
+        If the GUI server is not running, it will be started.
+
+        Args:
+            wait(bool): Whether to wait for the server to start. Defaults to True.
+        """
         if self._check_if_server_is_alive():
             return self._show_all()
-        return self.start(wait=True)
+        return self._start(wait=wait)
 
     def hide(self):
         """Hide the GUI window."""
@@ -382,6 +391,9 @@ class BECGuiClient(RPCBase):
         """
         Start the GUI server, and execute callback when it is launched
         """
+        if self._gui_is_alive():
+            self._gui_started_event.set()
+            return
         if self._process is None or self._process.poll() is not None:
             logger.success("GUI starting...")
             self._startup_timeout = 5
@@ -524,7 +536,7 @@ if __name__ == "__main__":  # pragma: no cover
         # Test the client_utils.py module
         gui = BECGuiClient()
 
-        gui.start(wait=True)
+        gui.show(wait=True)
         gui.new().new(widget="Waveform")
         time.sleep(10)
     finally:

bec_widgets/cli/generate_cli.py

@@ -53,7 +53,7 @@ from __future__ import annotations
 {base_imports}
 from bec_lib.logger import bec_logger
 
-from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
+from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
 {"from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets, get_plugin_client_module" if self._base else ""}
 
 logger = bec_logger.logger
@@ -180,7 +180,10 @@ class {class_name}(RPCBase):"""
                     f"Method {method} not found in class {cls.__name__}. "
                     f"Please check the USER_ACCESS list."
                 )
-
+            if hasattr(obj, "__rpc_timeout__"):
+                timeout = {"value": obj.__rpc_timeout__}
+            else:
+                timeout = {}
             if isinstance(obj, (property, QtProperty)):
                 # for the cli, we can map qt properties to regular properties
                 if is_property_setter:
@@ -205,14 +208,26 @@ class {class_name}(RPCBase):"""
     def {method}{str(sig_overload)}: ...
     """
 
-                self.content += """
-    @rpc_call"""
+                self.content += f"""
+    {self._rpc_call(timeout)}"""
             self.content += f"""
     def {method}{str(sig)}:
         \"\"\"
 {doc}
         \"\"\""""
 
+    def _rpc_call(self, timeout_info: dict[str, float | None]):
+        """
+        Decorator to mark a method as an RPC call.
+        This is used to generate the client code for the method.
+        """
+        if not timeout_info:
+            return "@rpc_call"
+        timeout = timeout_info.get("value", None)
+        return f"""
+    @rpc_timeout({timeout})
+    @rpc_call"""
+
     def write(self, file_name: str):
         """
         Write the content to a file, automatically formatted with black.

bec_widgets/cli/rpc/rpc_base.py

@@ -39,6 +39,29 @@ def _transform_args_kwargs(args, kwargs) -> tuple[tuple, dict]:
     return tuple(_name_arg(arg) for arg in args), {k: _name_arg(v) for k, v in kwargs.items()}
 
 
+def rpc_timeout(timeout):
+    """
+    A decorator to set a timeout for an RPC call.
+
+    Args:
+        timeout: The timeout in seconds.
+
+    Returns:
+        The decorated function.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            if "timeout" not in kwargs:
+                kwargs["timeout"] = timeout
+            return func(self, *args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
 def rpc_call(func):
     """
     A decorator for calling a function on the server.

bec_widgets/utils/bec_widget.py

@@ -1,16 +1,19 @@
 from __future__ import annotations
 
+from datetime import datetime
 from typing import TYPE_CHECKING
 
 import darkdetect
 import shiboken6
 from bec_lib.logger import bec_logger
-from qtpy.QtCore import QObject, Slot
-from qtpy.QtWidgets import QApplication
+from qtpy.QtCore import QObject
+from qtpy.QtWidgets import QApplication, QFileDialog, QWidget
 
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
 from bec_widgets.utils.colors import set_theme
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.rpc_decorator import rpc_timeout
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_widgets.widgets.containers.dock import BECDock
@@ -88,7 +91,7 @@ class BECWidget(BECConnector):
                 theme = "dark"
         self.apply_theme(theme)
 
-    @Slot(str)
+    @SafeSlot(str)
     def apply_theme(self, theme: str):
         """
         Apply the theme to the widget.
@@ -97,6 +100,30 @@ class BECWidget(BECConnector):
             theme(str, optional): The theme to be applied.
         """
 
+    @SafeSlot()
+    @SafeSlot(str)
+    @rpc_timeout(None)
+    def screenshot(self, file_name: str | None = None):
+        """
+        Take a screenshot of the dock area and save it to a file.
+        """
+        if not isinstance(self, QWidget):
+            logger.error("Cannot take screenshot of non-QWidget instance")
+            return
+
+        screenshot = self.grab()
+        if file_name is None:
+            file_name, _ = QFileDialog.getSaveFileName(
+                self,
+                "Save Screenshot",
+                f"bec_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png",
+                "PNG Files (*.png);;JPEG Files (*.jpg *.jpeg);;All Files (*)",
+            )
+        if not file_name:
+            return
+        screenshot.save(file_name)
+        logger.info(f"Screenshot saved to {file_name}")
+
     def cleanup(self):
         """Cleanup the widget."""
         with RPCRegister.delayed_broadcast():

bec_widgets/utils/rpc_decorator.py

@@ -13,3 +13,17 @@ def register_rpc_methods(cls):
         if getattr(method, "rpc_public", False):
             cls.USER_ACCESS.add(name)
     return cls
+
+
+def rpc_timeout(timeout: float | None):
+    """
+    Decorator to set a timeout for RPC methods.
+    The actual implementation of timeout handling is within the cli module. This decorator
+    is solely to inform the generate-cli command about the timeout value.
+    """
+
+    def decorator(func):
+        func.__rpc_timeout__ = timeout  # Store the timeout value in the function
+        return func
+
+    return decorator

bec_widgets/widgets/containers/dock/dock_area.py

@@ -71,6 +71,7 @@ class BECDockArea(BECWidget, QWidget):
         "detach_dock",
         "attach_all",
         "save_state",
+        "screenshot",
         "restore_state",
     ]
 
@@ -267,11 +268,16 @@ class BECDockArea(BECWidget, QWidget):
             "restore_state",
             MaterialIconAction(icon_name="frame_reload", tooltip="Restore Dock State", parent=self),
         )
+        self.toolbar.components.add_safe(
+            "screenshot",
+            MaterialIconAction(icon_name="photo_camera", tooltip="Take Screenshot", parent=self),
+        )
 
         bundle = ToolbarBundle("dock_actions", self.toolbar.components)
         bundle.add_action("attach_all")
         bundle.add_action("save_state")
         bundle.add_action("restore_state")
+        bundle.add_action("screenshot")
         self.toolbar.add_bundle(bundle)
 
     def _hook_toolbar(self):
@@ -333,6 +339,7 @@ class BECDockArea(BECWidget, QWidget):
         self.toolbar.components.get_action("restore_state").action.triggered.connect(
             self.restore_state
         )
+        self.toolbar.components.get_action("screenshot").action.triggered.connect(self.screenshot)
 
     @SafeSlot()
     def _create_widget_from_toolbar(self, widget_name: str) -> None:

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

@@ -33,7 +33,7 @@ class PositionerBox(PositionerBoxBase):
     PLUGIN = True
     RPC = True
 
-    USER_ACCESS = ["set_positioner"]
+    USER_ACCESS = ["set_positioner", "screenshot"]
     device_changed = Signal(str, str)
     # Signal emitted to inform listeners about a position update
     position_update = Signal(float)

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

@@ -34,7 +34,7 @@ class PositionerBox2D(PositionerBoxBase):
 
     PLUGIN = True
     RPC = True
-    USER_ACCESS = ["set_positioner_hor", "set_positioner_ver"]
+    USER_ACCESS = ["set_positioner_hor", "set_positioner_ver", "screenshot"]
 
     device_changed_hor = Signal(str, str)
     device_changed_ver = Signal(str, str)

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

@@ -112,7 +112,9 @@ class DeviceInputBase(BECWidget):
             WidgetIO.set_value(widget=self, value=device)
             self.config.default = device
         else:
-            logger.warning(f"Device {device} is not in the filtered selection.")
+            logger.warning(
+                f"Device {device} is not in the filtered selection of {self}: {self.devices}."
+            )
 
     @SafeSlot()
     def update_devices_from_filters(self):
@@ -131,7 +133,8 @@ class DeviceInputBase(BECWidget):
         # Filter based on readout priority
         devs = [dev for dev in devs if self._check_readout_filter(dev)]
         self.devices = [device.name for device in devs]
-        self.set_device(current_device)
+        if current_device != "":
+            self.set_device(current_device)
 
     @SafeSlot(list)
     def set_available_devices(self, devices: list[str]):

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -45,6 +45,7 @@ class ScanControl(BECWidget, QWidget):
     Widget to submit new scans to the queue.
     """
 
+    USER_ACCESS = ["remove", "screenshot"]
     PLUGIN = True
     ICON_NAME = "tune"
     ARG_BOX_POSITION: int = 2

bec_widgets/widgets/editors/monaco/monaco_widget.py

@@ -1,6 +1,7 @@
 from typing import Literal
 
 import qtmonaco
+from qtpy.QtCore import Signal
 from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
@@ -12,11 +13,14 @@ class MonacoWidget(BECWidget, QWidget):
     A simple Monaco editor widget
     """
 
+    text_changed = Signal(str)
     PLUGIN = True
     ICON_NAME = "code"
     USER_ACCESS = [
         "set_text",
         "get_text",
+        "insert_text",
+        "delete_line",
         "set_language",
         "get_language",
         "set_theme",
@@ -25,6 +29,9 @@ class MonacoWidget(BECWidget, QWidget):
         "set_cursor",
         "current_cursor",
         "set_minimap_enabled",
+        "set_vim_mode_enabled",
+        "set_lsp_header",
+        "get_lsp_header",
     ]
 
     def __init__(self, parent=None, config=None, client=None, gui_id=None, **kwargs):
@@ -36,6 +43,7 @@ class MonacoWidget(BECWidget, QWidget):
         self.editor = qtmonaco.Monaco(self)
         layout.addWidget(self.editor)
         self.setLayout(layout)
+        self.editor.text_changed.connect(self.text_changed.emit)
         self.editor.initialized.connect(self.apply_theme)
 
     def apply_theme(self, theme: str | None = None) -> None:
@@ -65,6 +73,26 @@ class MonacoWidget(BECWidget, QWidget):
         """
         return self.editor.get_text()
 
+    def insert_text(self, text: str, line: int | None = None, column: int | None = None) -> None:
+        """
+        Insert text at the current cursor position or at a specified line and column.
+
+        Args:
+            text (str): The text to insert.
+            line (int, optional): The line number (1-based) to insert the text at. Defaults to None.
+            column (int, optional): The column number (1-based) to insert the text at. Defaults to None.
+        """
+        self.editor.insert_text(text, line, column)
+
+    def delete_line(self, line: int | None = None) -> None:
+        """
+        Delete a line in the Monaco editor.
+
+        Args:
+            line (int, optional): The line number (1-based) to delete. If None, the current line will be deleted.
+        """
+        self.editor.delete_line(line)
+
     def set_cursor(
         self,
         line: int,
@@ -154,6 +182,34 @@ class MonacoWidget(BECWidget, QWidget):
         """
         self.editor.clear_highlighted_lines()
 
+    def set_vim_mode_enabled(self, enabled: bool) -> None:
+        """
+        Enable or disable Vim mode in the Monaco editor.
+
+        Args:
+            enabled (bool): If True, Vim mode will be enabled; otherwise, it will be disabled.
+        """
+        self.editor.set_vim_mode_enabled(enabled)
+
+    def set_lsp_header(self, header: str) -> None:
+        """
+        Set the LSP (Language Server Protocol) header for the Monaco editor.
+        The header is used to provide context for language servers but is not displayed in the editor.
+
+        Args:
+            header (str): The LSP header to set.
+        """
+        self.editor.set_lsp_header(header)
+
+    def get_lsp_header(self) -> str:
+        """
+        Get the current LSP header set in the Monaco editor.
+
+        Returns:
+            str: The LSP header.
+        """
+        return self.editor.get_lsp_header()
+
 
 if __name__ == "__main__":  # pragma: no cover
     qapp = QApplication([])

bec_widgets/widgets/editors/web_console/web_console.py

@@ -6,11 +6,12 @@ import time
 
 from bec_lib.logger import bec_logger
 from louie.saferef import safe_ref
-from qtpy.QtCore import QUrl, qInstallMessageHandler
+from qtpy.QtCore import QTimer, QUrl, Signal, qInstallMessageHandler
 from qtpy.QtWebEngineWidgets import QWebEnginePage, QWebEngineView
 from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeProperty
 
 logger = bec_logger.logger
 
@@ -165,11 +166,16 @@ class WebConsole(BECWidget, QWidget):
     A simple widget to display a website
     """
 
+    _js_callback = Signal(bool)
+    initialized = Signal()
+
     PLUGIN = True
     ICON_NAME = "terminal"
 
     def __init__(self, parent=None, config=None, client=None, gui_id=None, **kwargs):
         super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
+        self._startup_cmd = "bec --nogui"
+        self._is_initialized = False
         _web_console_registry.register(self)
         self._token = _web_console_registry._token
         layout = QVBoxLayout()
@@ -181,6 +187,48 @@ class WebConsole(BECWidget, QWidget):
         layout.addWidget(self.browser)
         self.setLayout(layout)
         self.page.setUrl(QUrl(f"http://localhost:{_web_console_registry._server_port}"))
+        self._startup_timer = QTimer()
+        self._startup_timer.setInterval(500)
+        self._startup_timer.timeout.connect(self._check_page_ready)
+        self._startup_timer.start()
+        self._js_callback.connect(self._on_js_callback)
+
+    def _check_page_ready(self):
+        """
+        Check if the page is ready and stop the timer if it is.
+        """
+        if self.page.isLoading():
+            return
+
+        self.page.runJavaScript("window.term !== undefined", self._js_callback.emit)
+
+    def _on_js_callback(self, ready: bool):
+        """
+        Callback for when the JavaScript is ready.
+        """
+        if not ready:
+            return
+        self._is_initialized = True
+        self._startup_timer.stop()
+        if self._startup_cmd:
+            self.write(self._startup_cmd)
+        self.initialized.emit()
+
+    @SafeProperty(str)
+    def startup_cmd(self):
+        """
+        Get the startup command for the web console.
+        """
+        return self._startup_cmd
+
+    @startup_cmd.setter
+    def startup_cmd(self, cmd: str):
+        """
+        Set the startup command for the web console.
+        """
+        if not isinstance(cmd, str):
+            raise ValueError("Startup command must be a string.")
+        self._startup_cmd = cmd
 
     def write(self, data: str, send_return: bool = True):
         """
@@ -213,10 +261,19 @@ class WebConsole(BECWidget, QWidget):
             "document.querySelector('textarea.xterm-helper-textarea').dispatchEvent(new KeyboardEvent('keypress', {charCode: 3}))"
         )
 
+    def set_readonly(self, readonly: bool):
+        """
+        Set the web console to read-only mode.
+        """
+        if not isinstance(readonly, bool):
+            raise ValueError("Readonly must be a boolean.")
+        self.setEnabled(not readonly)
+
     def cleanup(self):
         """
         Clean up the registry by removing any instances that are no longer valid.
         """
+        self._startup_timer.stop()
         _web_console_registry.unregister(self)
         super().cleanup()
 

bec_widgets/widgets/plots/heatmap/heatmap.py

@@ -115,6 +115,7 @@ class Heatmap(ImageBase):
         "auto_range_y.setter",
         "minimal_crosshair_precision",
         "minimal_crosshair_precision.setter",
+        "screenshot",
         # ImageView Specific Settings
         "color_map",
         "color_map.setter",

bec_widgets/widgets/plots/image/image.py

@@ -91,6 +91,7 @@ class Image(ImageBase):
         "auto_range_y.setter",
         "minimal_crosshair_precision",
         "minimal_crosshair_precision.setter",
+        "screenshot",
         # ImageView Specific Settings
         "color_map",
         "color_map.setter",

bec_widgets/widgets/plots/motor_map/motor_map.py

@@ -128,6 +128,7 @@ class MotorMap(PlotBase):
         "y_log.setter",
         "legend_label_size",
         "legend_label_size.setter",
+        "screenshot",
         # motor_map specific
         "color",
         "color.setter",

bec_widgets/widgets/plots/multi_waveform/multi_waveform.py

@@ -96,6 +96,7 @@ class MultiWaveform(PlotBase):
         "legend_label_size.setter",
         "minimal_crosshair_precision",
         "minimal_crosshair_precision.setter",
+        "screenshot",
         # MultiWaveform Specific RPC Access
         "highlighted_index",
         "highlighted_index.setter",

bec_widgets/widgets/plots/scatter_waveform/scatter_waveform.py

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

bec_widgets/widgets/plots/waveform/waveform.py

@@ -105,6 +105,7 @@ class Waveform(PlotBase):
         "legend_label_size.setter",
         "minimal_crosshair_precision",
         "minimal_crosshair_precision.setter",
+        "screenshot",
         # Waveform Specific RPC Access
         "curves",
         "x_mode",
@@ -1634,18 +1635,25 @@ class Waveform(PlotBase):
             # 4.2 If there are sync curves, use the first device from the scan report
             else:
                 try:
-                    x_name = self._ensure_str_list(
+                    scan_report_devices = self._ensure_str_list(
                         self.scan_item.metadata["bec"]["scan_report_devices"]
-                    )[0]
-                except:
-                    x_name = self.scan_item.status_message.info["scan_report_devices"][0]
-                x_entry = self.entry_validator.validate_signal(x_name, None)
-                if access_key == "val":
-                    x_data = data.get(x_name, {}).get(x_entry, {}).get(access_key, None)
+                    )
+                except Exception:
+                    scan_report_devices = self.scan_item.status_message.info.get(
+                        "scan_report_devices", []
+                    )
+                if not scan_report_devices:
+                    x_data = None
+                    new_suffix = " (auto: index)"
                 else:
-                    entry_obj = data.get(x_name, {}).get(x_entry)
-                    x_data = entry_obj.read()["value"] if entry_obj else None
-                new_suffix = f" (auto: {x_name}-{x_entry})"
+                    x_name = scan_report_devices[0]
+                    x_entry = self.entry_validator.validate_signal(x_name, None)
+                    if access_key == "val":
+                        x_data = data.get(x_name, {}).get(x_entry, {}).get(access_key, None)
+                    else:
+                        entry_obj = data.get(x_name, {}).get(x_entry)
+                        x_data = entry_obj.read()["value"] if entry_obj else None
+                    new_suffix = f" (auto: {x_name}-{x_entry})"
         self._update_x_label_suffix(new_suffix)
         return x_data
 

bec_widgets/widgets/services/scan_history_browser/components/scan_history_view.py

@@ -5,11 +5,13 @@ from typing import TYPE_CHECKING
 from bec_lib.callback_handler import EventType
 from bec_lib.logger import bec_logger
 from bec_lib.messages import ScanHistoryMessage
+from bec_qthemes import material_icon
 from qtpy import QtCore, QtGui, QtWidgets
 
 from bec_widgets.utils.bec_widget import BECWidget, ConnectionConfig
 from bec_widgets.utils.colors import get_accent_colors
 from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.utility.spinner.spinner import SpinnerWidget
 
 if TYPE_CHECKING:
     from bec_lib.client import BECClient
@@ -25,22 +27,38 @@ class BECHistoryManager(QtCore.QObject):
 
     # ScanHistoryMessage.model_dump() (dict)
     scan_history_updated = QtCore.Signal(dict)
+    scan_history_refreshed = QtCore.Signal(list)
 
     def __init__(self, parent, client: BECClient):
         super().__init__(parent)
+        self._load_attempt = 0
         self.client = client
-        self._cb_id = self.client.callbacks.register(
-            event_type=EventType.SCAN_HISTORY_UPDATE, callback=self._on_scan_history_update
+        self._cb_id: dict[str, int] = {}
+        self._cb_id["update_scan_history"] = self.client.callbacks.register(
+            EventType.SCAN_HISTORY_UPDATE, self._on_scan_history_update
+        )
+        self._cb_id["scan_history_loaded"] = self.client.callbacks.register(
+            EventType.SCAN_HISTORY_LOADED, self._on_scan_history_reloaded
         )
 
     def refresh_scan_history(self) -> None:
         """Refresh the scan history from the client."""
+        all_messages = []
+        # pylint: disable=protected-access
         for scan_id in self.client.history._scan_ids:  # pylint: disable=protected-access
             history_msg = self.client.history._scan_data.get(scan_id, None)
             if history_msg is None:
                 logger.info(f"Scan history message for scan_id {scan_id} not found.")
                 continue
-            self.scan_history_updated.emit(history_msg.model_dump())
+            all_messages.append(history_msg.model_dump())
+        self.scan_history_refreshed.emit(all_messages)
+
+    def _on_scan_history_reloaded(self, history_msgs: list[ScanHistoryMessage]) -> None:
+        """Handle scan history reloaded event from the client."""
+        if not history_msgs:
+            logger.warning("Scan history reloaded with no messages.")
+            return
+        self.scan_history_refreshed.emit([msg.model_dump() for msg in history_msgs])
 
     def _on_scan_history_update(self, history_msg: ScanHistoryMessage) -> None:
         """Handle scan history updates from the client."""
@@ -48,8 +66,10 @@ class BECHistoryManager(QtCore.QObject):
 
     def cleanup(self) -> None:
         """Clean up the manager by disconnecting callbacks."""
-        self.client.callbacks.remove(self._cb_id)
+        for cb_id in self._cb_id.values():
+            self.client.callbacks.remove(cb_id)
         self.scan_history_updated.disconnect()
+        self.scan_history_refreshed.disconnect()
 
 
 class ScanHistoryView(BECWidget, QtWidgets.QTreeWidget):
@@ -80,15 +100,10 @@ class ScanHistoryView(BECWidget, QtWidgets.QTreeWidget):
             theme_update=theme_update,
             **kwargs,
         )
-        colors = get_accent_colors()
-        self.status_colors = {
-            "closed": colors.success,
-            "halted": colors.warning,
-            "aborted": colors.emergency,
-        }
-        # self.status_colors = {"closed": "#00e676", "halted": "#ffca28", "aborted": "#ff5252"}
+        self.status_icons = self._create_status_icons()
         self.column_header = ["Scan Nr", "Scan Name", "Status"]
         self.scan_history: list[ScanHistoryMessage] = []  # newest at index 0
+        self.scan_history_ids: set[str] = set()  # scan IDs of the scan history
         self.max_length = max_length  # Maximum number of scan history entries to keep
         self.bec_scan_history_manager = BECHistoryManager(parent=self, client=self.client)
         self._set_policies()
@@ -97,6 +112,12 @@ class ScanHistoryView(BECWidget, QtWidgets.QTreeWidget):
         header = self.header()
         header.setToolTip(f"Last {self.max_length} scans in history.")
         self.bec_scan_history_manager.scan_history_updated.connect(self.update_history)
+        self.bec_scan_history_manager.scan_history_refreshed.connect(self.update_full_history)
+        self._container = QtWidgets.QStackedLayout()
+        self._container.setStackingMode(QtWidgets.QStackedLayout.StackAll)
+        self.setLayout(self._container)
+        self._add_overlay()
+        self._start_waiting_display()
         self.refresh()
 
     def _set_policies(self):
@@ -117,16 +138,52 @@ class ScanHistoryView(BECWidget, QtWidgets.QTreeWidget):
         for column in range(1, self.columnCount()):
             header.setSectionResizeMode(column, QtWidgets.QHeaderView.ResizeMode.Stretch)
 
+    def _create_status_icons(self) -> dict[str, QtGui.QIcon]:
+        """Create status icons for the scan history."""
+        colors = get_accent_colors()
+        return {
+            "closed": material_icon(
+                icon_name="fiber_manual_record", filled=True, color=colors.success
+            ),
+            "halted": material_icon(
+                icon_name="fiber_manual_record", filled=True, color=colors.warning
+            ),
+            "aborted": material_icon(
+                icon_name="fiber_manual_record", filled=True, color=colors.emergency
+            ),
+            "unknown": material_icon(
+                icon_name="fiber_manual_record", filled=True, color=QtGui.QColor("#b0bec5")
+            ),
+        }
+
     def apply_theme(self, theme: str | None = None):
         """Apply the theme to the widget."""
-        colors = get_accent_colors()
-        self.status_colors = {
-            "closed": colors.success,
-            "halted": colors.warning,
-            "aborted": colors.emergency,
-        }
+        self.status_icons = self._create_status_icons()
         self.repaint()
 
+    def _add_overlay(self):
+        self._overlay_widget = QtWidgets.QWidget()
+        self._overlay_widget.setStyleSheet("background-color: rgba(240, 240, 240, 180);")
+        self._overlay_widget.setAutoFillBackground(True)
+        self._overlay_layout = QtWidgets.QVBoxLayout()
+        self._overlay_layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        self._overlay_widget.setLayout(self._overlay_layout)
+
+        self._spinner = SpinnerWidget(parent=self)
+        self._spinner.setFixedSize(QtCore.QSize(32, 32))
+        self._overlay_layout.addWidget(self._spinner)
+        self._container.addWidget(self._overlay_widget)
+
+    def _start_waiting_display(self):
+        self._overlay_widget.setVisible(True)
+        self._spinner.start()
+        QtWidgets.QApplication.processEvents()
+
+    def _stop_waiting_display(self):
+        self._overlay_widget.setVisible(False)
+        self._spinner.stop()
+        QtWidgets.QApplication.processEvents()
+
     def _current_item_changed(
         self, current: QtWidgets.QTreeWidgetItem, previous: QtWidgets.QTreeWidgetItem
     ):
@@ -145,9 +202,14 @@ class ScanHistoryView(BECWidget, QtWidgets.QTreeWidget):
     @SafeSlot()
     def refresh(self):
         """Refresh the scan history view."""
-        while len(self.scan_history) > 0:
-            self.remove_scan(index=0)
-        self.bec_scan_history_manager.refresh_scan_history()
+        # pylint: disable=protected-access
+        if self.client.history._scan_history_loaded_event.is_set():
+            while len(self.scan_history) > 0:
+                self.remove_scan(index=0)
+            self.bec_scan_history_manager.refresh_scan_history()
+            return
+        else:
+            logger.info("Scan history not loaded yet, waiting for it to be loaded.")
 
     @SafeSlot(dict)
     def update_history(self, msg_dump: dict):
@@ -156,6 +218,20 @@ class ScanHistoryView(BECWidget, QtWidgets.QTreeWidget):
         self.add_scan(msg)
         self.ensure_history_max_length()
 
+    @SafeSlot(list)
+    def update_full_history(self, all_messages: list[dict]):
+        """Update the scan history with a full list of scan data."""
+        messages = []
+        for msg_dump in all_messages:
+            msg = ScanHistoryMessage(**msg_dump)
+            messages.append(msg)
+            if len(messages) >= self.max_length:
+                messages.pop(0)
+        messages.sort(key=lambda m: m.scan_number, reverse=False)
+        self.add_scans(messages)
+        self.ensure_history_max_length()
+        self._stop_waiting_display()
+
     def ensure_history_max_length(self) -> None:
         """
         Method to ensure the scan history does not exceed the maximum length.
@@ -172,6 +248,34 @@ class ScanHistoryView(BECWidget, QtWidgets.QTreeWidget):
         """
         Add a scan entry to the tree widget.
 
+        Args:
+            msg (ScanHistoryMessage): The scan history message containing scan details.
+        """
+        self._add_scan_to_scan_history(msg)
+        tree_item = self._setup_tree_item(msg)
+        self.insertTopLevelItem(0, tree_item)
+
+    def _setup_tree_item(self, msg: ScanHistoryMessage) -> QtWidgets.QTreeWidgetItem:
+        """Setup a tree item for the scan history message.
+
+        Args:
+            msg (ScanHistoryMessage): The scan history message containing scan details.
+
+        Returns:
+            QtWidgets.QTreeWidgetItem: The tree item representing the scan history message.
+        """
+        tree_item = QtWidgets.QTreeWidgetItem([str(msg.scan_number), msg.scan_name, ""])
+        icon = self.status_icons.get(msg.exit_status, self.status_icons["unknown"])
+        tree_item.setIcon(2, icon)
+        tree_item.setExpanded(False)
+        for col in range(tree_item.columnCount()):
+            tree_item.setToolTip(col, f"Status: {msg.exit_status}")
+        return tree_item
+
+    def _add_scan_to_scan_history(self, msg: ScanHistoryMessage):
+        """
+        Add a scan message to the internal scan history list and update the tree widget.
+
         Args:
             msg (ScanHistoryMessage): The scan history message containing scan details.
         """
@@ -180,25 +284,25 @@ class ScanHistoryView(BECWidget, QtWidgets.QTreeWidget):
                 f"Old scan history entry fo scan {msg.scan_id} without stored_data_info, skipping."
             )
             return
-        if msg in self.scan_history:
+        if msg.scan_id in self.scan_history_ids:
             logger.info(f"Scan {msg.scan_id} already in history, skipping.")
             return
         self.scan_history.insert(0, msg)
-        tree_item = QtWidgets.QTreeWidgetItem([str(msg.scan_number), msg.scan_name, ""])
-        color = QtGui.QColor(self.status_colors.get(msg.exit_status, "#b0bec5"))
-        pix = QtGui.QPixmap(10, 10)
-        pix.fill(QtCore.Qt.transparent)
-        with QtGui.QPainter(pix) as p:
-            p.setRenderHint(QtGui.QPainter.Antialiasing)
-            p.setPen(QtCore.Qt.NoPen)
-            p.setBrush(color)
-            p.drawEllipse(0, 0, 10, 10)
-        tree_item.setIcon(2, QtGui.QIcon(pix))
-        tree_item.setForeground(2, QtGui.QBrush(color))
-        for col in range(tree_item.columnCount()):
-            tree_item.setToolTip(col, f"Status: {msg.exit_status}")
-        self.insertTopLevelItem(0, tree_item)
-        tree_item.setExpanded(False)
+        self.scan_history_ids.add(msg.scan_id)
+
+    def add_scans(self, messages: list[ScanHistoryMessage]):
+        """
+        Add multiple scan entries to the tree widget.
+
+        Args:
+            messages (list[ScanHistoryMessage]): List of scan history messages containing scan details.
+        """
+        tree_items = []
+        for msg in messages:
+            self._add_scan_to_scan_history(msg)
+            tree_items.append(self._setup_tree_item(msg))
+        # Insert for insertTopLevelItems needs to reversed to keep order of scan_history list
+        self.insertTopLevelItems(0, tree_items[::-1])
 
     def remove_scan(self, index: int):
         """
@@ -212,6 +316,7 @@ class ScanHistoryView(BECWidget, QtWidgets.QTreeWidget):
             index = len(self.scan_history) + index
         try:
             msg = self.scan_history.pop(index)
+            self.scan_history_ids.remove(msg.scan_id)
             self.no_scan_selected.emit()
         except IndexError:
             logger.warning(f"Invalid index {index} for removing scan entry from history.")

bec_widgets/widgets/utility/signal_label/signal_label.py

@@ -2,11 +2,13 @@ from __future__ import annotations
 
 import sys
 import traceback
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Sequence
 
+import numpy as np
 from bec_lib.device import Device, Signal
 from bec_lib.endpoints import MessageEndpoints
 from bec_qthemes import material_icon
+from qtpy.QtCore import Qt
 from qtpy.QtCore import Signal as QSignal
 from qtpy.QtWidgets import (
     QApplication,
@@ -20,17 +22,10 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
-from bec_widgets.utils.bec_connector import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import get_accent_colors
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.ophyd_kind_util import Kind
-from bec_widgets.widgets.control.device_input.base_classes.device_input_base import (
-    DeviceInputConfig,
-)
-from bec_widgets.widgets.control.device_input.base_classes.device_signal_input_base import (
-    DeviceSignalInputBaseConfig,
-)
 from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
     DeviceLineEdit,
 )
@@ -48,8 +43,9 @@ class ChoiceDialog(QDialog):
     def __init__(
         self,
         parent: QWidget | None = None,
-        config: ConnectionConfig | None = None,
         client: BECClient | None = None,
+        device: str | None = None,
+        signal: str | None = None,
         show_hinted: bool = True,
         show_normal: bool = False,
         show_config: bool = False,
@@ -63,18 +59,8 @@ class ChoiceDialog(QDialog):
 
         layout = QHBoxLayout()
 
-        config_dict = config.model_dump() if config is not None else {}
-        self._device_config = DeviceInputConfig.model_validate(config_dict)
-        self._signal_config = DeviceSignalInputBaseConfig.model_validate(config_dict)
-        self._device_field = DeviceLineEdit(
-            config=self._device_config, parent=parent, client=client
-        )
-        self._signal_field = SignalComboBox(
-            config=self._signal_config,
-            device=self._signal_config.device,
-            parent=parent,
-            client=client,
-        )
+        self._device_field = DeviceLineEdit(parent=parent, client=client)
+        self._signal_field = SignalComboBox(parent=parent, client=client)
         layout.addWidget(self._device_field)
         layout.addWidget(self._signal_field)
 
@@ -89,7 +75,10 @@ class ChoiceDialog(QDialog):
 
         self.setLayout(layout)
         self._device_field.textChanged.connect(self._update_device)
-        self._device_field.setText(config.device if config is not None else "")
+        if device:
+            self._device_field.set_device(device)
+        if signal and signal in set(s[0] for s in self._signal_field.signals):
+            self._signal_field.set_signal(signal)
 
     def _display_error(self):
         try:
@@ -123,11 +112,19 @@ class ChoiceDialog(QDialog):
         self.accepted_output.emit(
             self._device_field.text(), self._signal_field.selected_signal_comp_name
         )
+        self.cleanup()
         return super().accept()
 
+    def reject(self):
+        self.cleanup()
+        return super().reject()
+
+    def cleanup(self):
+        self._device_field.close()
+        self._signal_field.close()
+
 
 class SignalLabel(BECWidget, QWidget):
-
     ICON_NAME = "scoreboard"
     RPC = True
     PLUGIN = True
@@ -151,6 +148,8 @@ class SignalLabel(BECWidget, QWidget):
         "show_config_signals.setter",
         "display_array_data",
         "display_array_data.setter",
+        "max_list_display_len",
+        "max_list_display_len.setter",
     ]
 
     def __init__(
@@ -178,7 +177,6 @@ class SignalLabel(BECWidget, QWidget):
             custom_label (str, optional): Custom label for the widget. Defaults to "".
             custom_units (str, optional): Custom units for the widget. Defaults to "".
         """
-        self._config = DeviceSignalInputBaseConfig(default=signal, device=device)
         super().__init__(parent=parent, client=client, **kwargs)
 
         self._device = device
@@ -189,6 +187,7 @@ class SignalLabel(BECWidget, QWidget):
         self._show_default_units: bool = show_default_units
         self._decimal_places = 3
         self._dtype = None
+        self._max_list_display_len = 5
 
         self._show_hinted_signals: bool = True
         self._show_normal_signals: bool = True
@@ -227,9 +226,10 @@ class SignalLabel(BECWidget, QWidget):
 
     def _create_dialog(self):
         return ChoiceDialog(
-            config=self._config,
             parent=self,
             client=self.client,
+            device=self.device,
+            signal=self._signal_key,
             show_config=self.show_config_signals,
             show_normal=self.show_normal_signals,
             show_hinted=self.show_hinted_signals,
@@ -280,7 +280,7 @@ class SignalLabel(BECWidget, QWidget):
             return
         self._value = value
         self._units = self._signal_info.get("egu", "")
-        self._dtype = self._signal_info.get("dtype", "float")
+        self._dtype = self._signal_info.get("dtype")
 
     @SafeSlot(dict, dict)
     def on_device_readback(self, msg: dict, metadata: dict) -> None:
@@ -305,11 +305,13 @@ class SignalLabel(BECWidget, QWidget):
             except KeyError:
                 return "", {}
             if signal_info["kind_str"] == Kind.hinted.name:
-                return signal_info["obj_name"], signal_info
+                return signal_info["obj_name"], signal_info.get("describe", {})
             else:
-                return f"{self._device}_{self._signal}", signal_info
+                return f"{self._device}_{self._signal}", signal_info.get("describe", {})
         elif isinstance(self._device_obj, Signal):
-            return self._device, self._device_obj._info["describe_configuration"]
+            info = self._device_obj._info["describe_configuration"][self._device]
+            info["egu"] = self._device_obj._info["describe_configuration"].get("egu")
+            return (self._device, info)
         return "", {}
 
     @SafeProperty(str)
@@ -322,7 +324,6 @@ class SignalLabel(BECWidget, QWidget):
         self.disconnect_device()
         self._device = value
         self._device_obj = self.dev.get(self._device)
-        self._config.device = value
         self.connect_device()
         self._update_label()
 
@@ -335,7 +336,6 @@ class SignalLabel(BECWidget, QWidget):
     def signal(self, value: str) -> None:
         self.disconnect_device()
         self._signal = value
-        self._config.default = value
         self.connect_device()
         self._update_label()
 
@@ -369,6 +369,16 @@ class SignalLabel(BECWidget, QWidget):
         self._custom_label = value
         self._update_label()
 
+    @SafeProperty(str)
+    def max_list_display_len(self) -> int:
+        """For small lists, the max length to display"""
+        return self._max_list_display_len
+
+    @max_list_display_len.setter
+    def max_list_display_len(self, value: int) -> None:
+        self._max_list_display_len = value
+        self.set_display_value(self._value)
+
     @SafeProperty(str)
     def custom_units(self) -> str:
         """Use a custom unit string"""
@@ -429,6 +439,11 @@ class SignalLabel(BECWidget, QWidget):
     def _format_value(self, value: Any):
         if self._dtype == "array" and not self.display_array_data:
             return "ARRAY DATA"
+        if not isinstance(value, str) and isinstance(value, (Sequence, np.ndarray)):
+            if len(value) < self._max_list_display_len:
+                return str(value)
+            else:
+                return "ARRAY DATA"
         if self._decimal_places == 0:
             return value
         try:
@@ -468,7 +483,6 @@ class SignalLabel(BECWidget, QWidget):
 
 
 if __name__ == "__main__":
-
     app = QApplication(sys.argv)
     w = QWidget()
     w.setLayout(QVBoxLayout())

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "2.31.2"
+version = "2.33.3"
 description = "BEC Widgets"
 requires-python = ">=3.10"
 classifiers = [
@@ -13,17 +13,17 @@ classifiers = [
     "Topic :: Scientific/Engineering",
 ]
 dependencies = [
-    "bec_ipython_client>=3.42.4, <=4.0", # needed for jupyter console
-    "bec_lib>=3.44, <=4.0",
+    "bec_ipython_client~=3.52", # needed for jupyter console
+    "bec_lib~=3.52",
     "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",
-    "qtmonaco>=0.2.3",
+    "qtmonaco~=0.5",
 ]
 
 

tests/unit_tests/test_bec_dock.py

@@ -1,5 +1,7 @@
 # pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
 
+from unittest import mock
+
 import pytest
 from bec_lib.endpoints import MessageEndpoints
 
@@ -170,3 +172,62 @@ def test_toolbar_add_utils_progress_bar(bec_dock_area):
         bec_dock_area.panels["ring_progress_bar_0"].widgets[0].config.widget_class
         == "RingProgressBar"
     )
+
+
+def test_toolbar_screenshot_action(bec_dock_area, tmpdir):
+    """Test the screenshot functionality from the toolbar."""
+    # Create a test screenshot file path in tmpdir
+    screenshot_path = tmpdir.join("test_screenshot.png")
+
+    # Mock the QFileDialog.getSaveFileName to return a test filename
+    with mock.patch("bec_widgets.utils.bec_widget.QFileDialog.getSaveFileName") as mock_dialog:
+        mock_dialog.return_value = (str(screenshot_path), "PNG Files (*.png)")
+
+        # Mock the screenshot.save method
+        with mock.patch.object(bec_dock_area, "grab") as mock_grab:
+            mock_screenshot = mock.MagicMock()
+            mock_grab.return_value = mock_screenshot
+
+            # Trigger the screenshot action
+            bec_dock_area.toolbar.components.get_action("screenshot").action.trigger()
+
+            # Verify the dialog was called with correct parameters
+            mock_dialog.assert_called_once()
+            call_args = mock_dialog.call_args[0]
+            assert call_args[0] == bec_dock_area  # parent widget
+            assert call_args[1] == "Save Screenshot"  # dialog title
+            assert call_args[2].startswith("bec_")  # filename starts with bec_
+            assert call_args[2].endswith(".png")  # filename ends with .png
+            assert (
+                call_args[3] == "PNG Files (*.png);;JPEG Files (*.jpg *.jpeg);;All Files (*)"
+            )  # file filter
+
+            # Verify grab was called
+            mock_grab.assert_called_once()
+
+            # Verify save was called with the filename
+            mock_screenshot.save.assert_called_once_with(str(screenshot_path))
+
+
+def test_toolbar_screenshot_action_cancelled(bec_dock_area):
+    """Test the screenshot functionality when user cancels the dialog."""
+    # Mock the QFileDialog.getSaveFileName to return empty filename (cancelled)
+    with mock.patch("bec_widgets.utils.bec_widget.QFileDialog.getSaveFileName") as mock_dialog:
+        mock_dialog.return_value = ("", "")
+
+        # Mock the screenshot.save method
+        with mock.patch.object(bec_dock_area, "grab") as mock_grab:
+            mock_screenshot = mock.MagicMock()
+            mock_grab.return_value = mock_screenshot
+
+            # Trigger the screenshot action
+            bec_dock_area.toolbar.components.get_action("screenshot").action.trigger()
+
+            # Verify the dialog was called
+            mock_dialog.assert_called_once()
+
+            # Verify grab was called (screenshot is taken before dialog)
+            mock_grab.assert_called_once()
+
+            # Verify save was NOT called since dialog was cancelled
+            mock_screenshot.save.assert_not_called()

tests/unit_tests/test_client_utils.py

@@ -67,7 +67,7 @@ def test_client_utils_passes_client_config_to_server(bec_dispatcher):
         mixin._client = bec_dispatcher.client
         mixin._gui_id = "gui_id"
         mixin._gui_is_alive = mock.MagicMock()
-        mixin._gui_is_alive.side_effect = [True]
+        mixin._gui_is_alive.side_effect = [False, False, True]
 
         try:
             yield mixin

tests/unit_tests/test_generate_cli_client.py

@@ -79,7 +79,7 @@ def test_client_generator_with_black_formatting():
 
         from bec_lib.logger import bec_logger
 
-        from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
+        from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
         from bec_widgets.utils.bec_plugin_helper import (get_all_plugin_widgets,
                                                         get_plugin_client_module)
 

tests/unit_tests/test_scan_history_browser.py

@@ -287,6 +287,23 @@ def test_scan_history_view_refresh(qtbot, scan_history_view, scan_history_msg, s
         assert scan_history_view.topLevelItemCount() == 0
 
 
+def test_scan_history_update_full_history(
+    qtbot, scan_history_view, scan_history_msg, scan_history_msg_2
+):
+    """Test the update_full_history method of ScanHistoryView."""
+    # Wait spinner should be visible
+    scan_history_view.update_full_history(
+        [scan_history_msg.model_dump(), scan_history_msg_2.model_dump()]
+    )
+    assert len(scan_history_view.scan_history) == 2
+    assert scan_history_view.topLevelItemCount() == 2
+    assert scan_history_view.scan_history[0] == scan_history_msg_2  # new first item
+    assert scan_history_view.scan_history[1] == scan_history_msg  # old second item
+    # Wait spinner should be hidden
+    assert scan_history_view._overlay_widget.isVisible() is False
+    assert scan_history_view._spinner.isVisible() is False
+
+
 def test_scan_history_browser(qtbot, scan_history_browser, scan_history_msg, scan_history_msg_2):
     """Test the initialization of ScanHistoryBrowser."""
     assert isinstance(scan_history_browser.scan_history_view, ScanHistoryView)
@@ -298,14 +315,14 @@ def test_scan_history_browser(qtbot, scan_history_browser, scan_history_msg, sca
     scan_history_browser.scan_history_view.update_history(scan_history_msg_2.model_dump())
 
     assert len(scan_history_browser.scan_history_view.scan_history) == 2
+    assert scan_history_browser.scan_history_view.topLevelItemCount() == 2
     # Click on first scan item history to select it
-    qtbot.mouseClick(
-        scan_history_browser.scan_history_view.viewport(),
-        QtCore.Qt.LeftButton,
-        pos=scan_history_browser.scan_history_view.visualItemRect(
-            scan_history_browser.scan_history_view.topLevelItem(0)
-        ).center(),
-    )
+    # TODO #771 ; Multiple clicks to the QTreeView item fail, but only in the CI, not locally.
+    # Simulate a mouse click without qtbot.mouseClick as this is unstable and currently fails in CI
+    item = scan_history_browser.scan_history_view.topLevelItem(0)
+    scan_history_browser.scan_history_view.setCurrentItem(item)
+    scan_history_browser.scan_history_view.itemClicked.emit(item, 0)
+
     assert scan_history_browser.scan_history_view.currentIndex().row() == 0
 
     # Both metadata and device viewers should be updated with the first scan
@@ -320,29 +337,6 @@ def test_scan_history_browser(qtbot, scan_history_browser, scan_history_msg, sca
         timeout=2000,
     )
 
-    # TODO #771 ; Multiple clicks to the QTreeView item fail, but only in the CI, not locally.
-    # Click on second scan item history to select it
-    # qtbot.mouseClick(
-    #     scan_history_browser.scan_history_view.viewport(),
-    #     QtCore.Qt.LeftButton,
-    #     pos=scan_history_browser.scan_history_view.visualItemRect(
-    #         scan_history_browser.scan_history_view.topLevelItem(1)
-    #     ).center(),
-    # )
-    # assert scan_history_browser.scan_history_view.currentIndex().row() == 1
-
-    # # Both metadata and device viewers should be updated with the first scan
-    # qtbot.waitUntil(
-    #     lambda: scan_history_browser.scan_history_metadata_viewer.scan_history_msg
-    #     == scan_history_msg,
-    #     timeout=2000,
-    # )
-    # qtbot.waitUntil(
-    #     lambda: scan_history_browser.scan_history_device_viewer.scan_history_msg
-    #     == scan_history_msg,
-    #     timeout=2000,
-    # )
-
     callback_args = []
 
     def plotting_callback(device_name, signal_name, msg):

tests/unit_tests/test_signal_label.py

@@ -215,9 +215,7 @@ def test_set_existing_device_and_signal(signal_label: SignalLabel, qtbot):
     signal_label.device = "samx"
     signal_label.signal = "readback"
     assert signal_label._device == "samx"
-    assert signal_label._config.device == "samx"
     assert signal_label._signal == "readback"
-    assert signal_label._config.default == "readback"
 
 
 def test_set_nonexisting_device_and_signal(signal_label: SignalLabel, qtbot):
@@ -225,12 +223,10 @@ def test_set_nonexisting_device_and_signal(signal_label: SignalLabel, qtbot):
     signal_label.device = "samq"
     signal_label.signal = "readfront"
     assert signal_label._device == "samq"
-    assert signal_label._config.device == "samq"
     signal_label._manual_read()
     signal_label.set_display_value(signal_label._value)
     assert signal_label._display.text() == "__"
     assert signal_label._signal == "readfront"
-    assert signal_label._config.default == "readfront"
     signal_label._manual_read()
     signal_label.set_display_value(signal_label._value)
     assert signal_label._display.text() == "__"
@@ -256,3 +252,12 @@ def test_handle_readback(signal_label: SignalLabel, qtbot):
     )
     assert signal_label._display.text() == "0.993 μm"
     assert signal_label._display.toolTip() == ""
+
+
+def test_handle_lists(signal_label: SignalLabel, qtbot):
+    signal_label.custom_units = ""
+    signal_label.set_display_value([1, 2, 3, 4])
+    assert signal_label._display.text() == "[1, 2, 3, 4]"
+    signal_label.max_list_display_len = 2
+    signal_label.set_display_value([1, 2, 3, 4])
+    assert signal_label._display.text() == "ARRAY DATA"

tests/unit_tests/test_web_console.py

@@ -88,3 +88,60 @@ def test_web_console_registry_wait_for_server_port_timeout():
     with mock.patch.object(_web_console_registry, "_server_process") as mock_subprocess:
         with pytest.raises(TimeoutError):
             _web_console_registry._wait_for_server_port(timeout=0.1)
+
+
+def test_web_console_startup_command_execution(console_widget, qtbot):
+    """Test that the startup command is triggered after successful initialization."""
+    # Set a custom startup command
+    console_widget.startup_cmd = "test startup command"
+
+    assert console_widget.startup_cmd == "test startup command"
+
+    # Generator to simulate JS initialization sequence
+    def js_readiness_sequence():
+        yield False  # First call: not ready yet
+        while True:
+            yield True  # Any subsequent calls: ready
+
+    readiness_gen = js_readiness_sequence()
+
+    def mock_run_js(script, callback=None):
+        # Check if this is the initialization check call
+        if "window.term !== undefined" in script and callback:
+            ready = next(readiness_gen)
+            callback(ready)
+        else:
+            # For other JavaScript calls (like paste), just call the callback
+            if callback:
+                callback(True)
+
+    with mock.patch.object(
+        console_widget.page, "runJavaScript", side_effect=mock_run_js
+    ) as mock_run_js_method:
+        # Reset initialization state and start the timer
+        console_widget._is_initialized = False
+        console_widget._startup_timer.start()
+
+        # Wait for the initialization to complete
+        qtbot.waitUntil(lambda: console_widget._is_initialized, timeout=3000)
+
+        # Verify that the startup command was executed
+        startup_calls = [
+            call
+            for call in mock_run_js_method.call_args_list
+            if "test startup command" in str(call)
+        ]
+        assert len(startup_calls) > 0, "Startup command should have been executed"
+
+        # Verify the initialized signal was emitted
+        assert console_widget._is_initialized is True
+        assert not console_widget._startup_timer.isActive()
+
+
+def test_web_console_set_readonly(console_widget):
+    # Test the set_readonly method
+    console_widget.set_readonly(True)
+    assert not console_widget.isEnabled()
+
+    console_widget.set_readonly(False)
+    assert console_widget.isEnabled()