feat: add feedback dialog

.github/workflows/ci.yml

@@ -17,6 +17,10 @@ on:
         required: false
         type: string
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 permissions:
   pull-requests: write
 

bec_widgets/applications/bw_launch.py

@@ -2,15 +2,15 @@ from __future__ import annotations
 
 from bec_lib import bec_logger
 
-from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
 from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
+from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
 
 logger = bec_logger.logger
 
 
 def dock_area(
     object_name: str | None = None, profile: str | None = None, start_empty: bool = False
-) -> AdvancedDockArea:
+) -> BECDockArea:
     """
     Create an advanced dock area using Qt Advanced Docking System.
 
@@ -20,7 +20,7 @@ def dock_area(
         start_empty(bool): If True, start with an empty dock area when loading specified profile.
 
     Returns:
-        AdvancedDockArea: The created advanced dock area.
+        BECDockArea: The created advanced dock area.
 
     Note:
         The "general" profile is mandatory and will always exist. If manually deleted,
@@ -29,7 +29,7 @@ def dock_area(
     # Default to "general" profile when called from CLI without specifying a profile
     effective_profile = profile if profile is not None else "general"
 
-    widget = AdvancedDockArea(
+    widget = BECDockArea(
         object_name=object_name,
         restore_initial_profile=True,
         root_widget=True,
@@ -51,7 +51,7 @@ def auto_update_dock_area(object_name: str | None = None) -> AutoUpdates:
         object_name(str): The name of the dock area.
 
     Returns:
-        AdvancedDockArea: The created dock area.
+        BECDockArea: The created dock area.
     """
     _auto_update = AutoUpdates(object_name=object_name)
     return _auto_update

bec_widgets/applications/launch_window.py

@@ -27,14 +27,12 @@ from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.name_utils import pascal_to_snake
 from bec_widgets.utils.plugin_utils import get_plugin_auto_updates
 from bec_widgets.utils.round_frame import RoundedFrame
+from bec_widgets.utils.screen_utils import apply_window_geometry, centered_geometry_for_app
 from bec_widgets.utils.toolbars.toolbar import ModularToolBar
 from bec_widgets.utils.ui_loader import UILoader
-from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
-from bec_widgets.widgets.containers.advanced_dock_area.profile_utils import (
-    get_last_profile,
-    list_profiles,
-)
 from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
+from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
+from bec_widgets.widgets.containers.dock_area.profile_utils import get_last_profile, list_profiles
 from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow, BECMainWindowNoRPC
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
@@ -78,23 +76,28 @@ class LaunchTile(RoundedFrame):
             circular_pixmap.fill(Qt.transparent)
 
             painter = QPainter(circular_pixmap)
-            painter.setRenderHints(QPainter.Antialiasing, True)
+            painter.setRenderHints(QPainter.RenderHint.Antialiasing, True)
             path = QPainterPath()
             path.addEllipse(0, 0, size, size)
             painter.setClipPath(path)
-            pixmap = pixmap.scaled(size, size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+            pixmap = pixmap.scaled(
+                size,
+                size,
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation,
+            )
             painter.drawPixmap(0, 0, pixmap)
             painter.end()
 
             self.icon_label.setPixmap(circular_pixmap)
-        self.layout.addWidget(self.icon_label, alignment=Qt.AlignCenter)
+        self.layout.addWidget(self.icon_label, alignment=Qt.AlignmentFlag.AlignCenter)
 
         # Top label
         self.top_label = QLabel(top_label.upper())
         font_top = self.top_label.font()
         font_top.setPointSize(10)
         self.top_label.setFont(font_top)
-        self.layout.addWidget(self.top_label, alignment=Qt.AlignCenter)
+        self.layout.addWidget(self.top_label, alignment=Qt.AlignmentFlag.AlignCenter)
 
         # Main label
         self.main_label = QLabel(main_label)
@@ -104,7 +107,7 @@ class LaunchTile(RoundedFrame):
         font_main.setPointSize(14)
         font_main.setBold(True)
         self.main_label.setFont(font_main)
-        self.main_label.setAlignment(Qt.AlignCenter)
+        self.main_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
 
         # Shrink font if the default would wrap on this platform / DPI
         content_width = (
@@ -120,13 +123,13 @@ class LaunchTile(RoundedFrame):
 
         self.layout.addWidget(self.main_label)
 
-        self.spacer_top = QSpacerItem(0, 10, QSizePolicy.Fixed, QSizePolicy.Fixed)
+        self.spacer_top = QSpacerItem(0, 10, QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
         self.layout.addItem(self.spacer_top)
 
         # Description
         self.description_label = QLabel(description)
         self.description_label.setWordWrap(True)
-        self.description_label.setAlignment(Qt.AlignCenter)
+        self.description_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
         self.layout.addWidget(self.description_label)
 
         # Selector
@@ -136,7 +139,9 @@ class LaunchTile(RoundedFrame):
         else:
             self.selector = None
 
-        self.spacer_bottom = QSpacerItem(0, 0, QSizePolicy.Fixed, QSizePolicy.Expanding)
+        self.spacer_bottom = QSpacerItem(
+            0, 0, QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Expanding
+        )
         self.layout.addItem(self.spacer_bottom)
 
         # Action button
@@ -156,7 +161,7 @@ class LaunchTile(RoundedFrame):
         }
         """
         )
-        self.layout.addWidget(self.action_button, alignment=Qt.AlignCenter)
+        self.layout.addWidget(self.action_button, alignment=Qt.AlignmentFlag.AlignCenter)
 
     def _fit_label_to_width(self, label: QLabel, max_width: int, min_pt: int = 10):
         """
@@ -179,12 +184,14 @@ class LaunchTile(RoundedFrame):
         metrics = QFontMetrics(font)
         label.setFont(font)
         label.setWordWrap(False)
-        label.setText(metrics.elidedText(label.text(), Qt.ElideRight, max_width))
+        label.setText(metrics.elidedText(label.text(), Qt.TextElideMode.ElideRight, max_width))
 
 
 class LaunchWindow(BECMainWindow):
     RPC = True
+    PLUGIN = False
     TILE_SIZE = (250, 300)
+    DEFAULT_LAUNCH_SIZE = (800, 600)
     USER_ACCESS = ["show_launcher", "hide_launcher"]
 
     def __init__(
@@ -209,7 +216,7 @@ class LaunchWindow(BECMainWindow):
         self.toolbar = ModularToolBar(parent=self)
         self.addToolBar(Qt.TopToolBarArea, self.toolbar)
         self.spacer = QWidget(self)
-        self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        self.spacer.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
         self.toolbar.addWidget(self.spacer)
         self.toolbar.addWidget(self.dark_mode_button)
 
@@ -318,7 +325,7 @@ class LaunchWindow(BECMainWindow):
         )
         tile.setFixedWidth(self.TILE_SIZE[0])
         tile.setMinimumHeight(self.TILE_SIZE[1])
-        tile.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding)
+        tile.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.MinimumExpanding)
         if action_button:
             tile.action_button.clicked.connect(action_button)
         if show_selector and selector_items:
@@ -428,7 +435,9 @@ class LaunchWindow(BECMainWindow):
         from bec_widgets.applications import bw_launch
 
         with RPCRegister.delayed_broadcast() as rpc_register:
-            existing_dock_areas = rpc_register.get_names_of_rpc_by_class_type(AdvancedDockArea)
+            if geometry is None and launch_script != "custom_ui_file":
+                geometry = self._default_launch_geometry()
+            existing_dock_areas = rpc_register.get_names_of_rpc_by_class_type(BECDockArea)
             if name is not None:
                 WidgetContainerUtils.raise_for_invalid_name(name)
                 # If name already exists, generate a unique one with counter suffix
@@ -451,13 +460,13 @@ class LaunchWindow(BECMainWindow):
 
             if launch_script == "auto_update":
                 auto_update = kwargs.pop("auto_update", None)
-                return self._launch_auto_update(auto_update)
+                return self._launch_auto_update(auto_update, geometry=geometry)
 
             if launch_script == "widget":
                 widget = kwargs.pop("widget", None)
                 if widget is None:
                     raise ValueError("Widget name must be provided.")
-                return self._launch_widget(widget)
+                return self._launch_widget(widget, geometry=geometry)
 
             launch = getattr(bw_launch, launch_script, None)
             if launch is None:
@@ -469,13 +478,13 @@ class LaunchWindow(BECMainWindow):
             logger.info(f"Created new dock area: {name}")
 
             if isinstance(result_widget, BECMainWindow):
-                self._apply_window_geometry(result_widget, geometry)
+                apply_window_geometry(result_widget, geometry)
                 result_widget.show()
             else:
                 window = BECMainWindowNoRPC()
                 window.setCentralWidget(result_widget)
                 window.setWindowTitle(f"BEC - {result_widget.objectName()}")
-                self._apply_window_geometry(window, geometry)
+                apply_window_geometry(window, geometry)
                 window.show()
             return result_widget
 
@@ -511,12 +520,14 @@ class LaunchWindow(BECMainWindow):
             window.setCentralWidget(loaded)
 
         window.setWindowTitle(f"BEC - {filename}")
-        self._apply_window_geometry(window, None)
+        apply_window_geometry(window, None)
         window.show()
         logger.info(f"Launched custom UI: {filename}, type: {type(window).__name__}")
         return window
 
-    def _launch_auto_update(self, auto_update: str) -> AutoUpdates:
+    def _launch_auto_update(
+        self, auto_update: str, geometry: tuple[int, int, int, int] | None = None
+    ) -> AutoUpdates:
         if auto_update in self.available_auto_updates:
             auto_update_cls = self.available_auto_updates[auto_update]
             window = auto_update_cls()
@@ -527,11 +538,13 @@ class LaunchWindow(BECMainWindow):
 
         window.resize(window.minimumSizeHint())
         window.setWindowTitle(f"BEC - {window.objectName()}")
-        self._apply_window_geometry(window, None)
+        apply_window_geometry(window, geometry)
         window.show()
         return window
 
-    def _launch_widget(self, widget: type[BECWidget]) -> QWidget:
+    def _launch_widget(
+        self, widget: type[BECWidget], geometry: tuple[int, int, int, int] | None = None
+    ) -> QWidget:
         name = pascal_to_snake(widget.__name__)
 
         WidgetContainerUtils.raise_for_invalid_name(name)
@@ -544,7 +557,7 @@ class LaunchWindow(BECMainWindow):
         window.setCentralWidget(widget_instance)
         window.resize(window.minimumSizeHint())
         window.setWindowTitle(f"BEC - {widget_instance.objectName()}")
-        self._apply_window_geometry(window, None)
+        apply_window_geometry(window, geometry)
         window.show()
         return window
 
@@ -592,30 +605,9 @@ class LaunchWindow(BECMainWindow):
             raise ValueError(f"Widget {widget} not found in available widgets.")
         return self.launch("widget", widget=self.available_widgets[widget])
 
-    def _apply_window_geometry(
-        self, window: QWidget, geometry: tuple[int, int, int, int] | None
-    ) -> None:
-        """Apply a provided geometry or center the window with an 80% layout."""
-        if geometry is not None:
-            window.setGeometry(*geometry)
-            return
-        default_geometry = self._default_window_geometry(window)
-        if default_geometry is not None:
-            window.setGeometry(*default_geometry)
-        else:
-            window.resize(window.minimumSizeHint())
-
-    @staticmethod
-    def _default_window_geometry(window: QWidget) -> tuple[int, int, int, int] | None:
-        screen = window.screen() or QApplication.primaryScreen()
-        if screen is None:
-            return None
-        available = screen.availableGeometry()
-        width = int(available.width() * 0.8)
-        height = int(available.height() * 0.8)
-        x = available.x() + (available.width() - width) // 2
-        y = available.y() + (available.height() - height) // 2
-        return x, y, width, height
+    def _default_launch_geometry(self) -> tuple[int, int, int, int] | None:
+        width, height = self.DEFAULT_LAUNCH_SIZE
+        return centered_geometry_for_app(width=width, height=height)
 
     @SafeSlot(popup_error=True)
     def _open_custom_ui_file(self):
@@ -706,7 +698,7 @@ class LaunchWindow(BECMainWindow):
         self.hide()
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     import sys
 
     from bec_widgets.utils.colors import apply_theme

bec_widgets/applications/main_app.py

@@ -5,13 +5,20 @@ from bec_widgets.applications.navigation_centre.side_bar import SideBar
 from bec_widgets.applications.navigation_centre.side_bar_components import NavigationItem
 from bec_widgets.applications.views.developer_view.developer_view import DeveloperView
 from bec_widgets.applications.views.device_manager_view.device_manager_view import DeviceManagerView
+from bec_widgets.applications.views.dock_area_view.dock_area_view import DockAreaView
 from bec_widgets.applications.views.view import ViewBase, WaveformViewInline, WaveformViewPopup
 from bec_widgets.utils.colors import apply_theme
-from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
+from bec_widgets.utils.screen_utils import (
+    apply_centered_size,
+    available_screen_geometry,
+    main_app_size_for_screen,
+)
 from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
 
 
 class BECMainApp(BECMainWindow):
+    RPC = False
+    PLUGIN = False
 
     def __init__(
         self,
@@ -45,13 +52,16 @@ class BECMainApp(BECMainWindow):
 
     def _add_views(self):
         self.add_section("BEC Applications", "bec_apps")
-        self.ads = AdvancedDockArea(self, profile_namespace="bec", auto_profile_namespace=False)
-        self.ads.setObjectName("MainWorkspace")
+        self.dock_area = DockAreaView(self)
         self.device_manager = DeviceManagerView(self)
         self.developer_view = DeveloperView(self)
 
         self.add_view(
-            icon="widgets", title="Dock Area", id="dock_area", widget=self.ads, mini_text="Docks"
+            icon="widgets",
+            title="Dock Area",
+            id="dock_area",
+            widget=self.dock_area,
+            mini_text="Docks",
         )
         self.add_view(
             icon="display_settings",
@@ -211,25 +221,12 @@ def main():  # pragma: no cover
     apply_theme("dark")
     w = BECMainApp(show_examples=args.examples)
 
-    screen = app.primaryScreen()
-    screen_geometry = screen.availableGeometry()
-    screen_width = screen_geometry.width()
-    screen_height = screen_geometry.height()
-    # 70% of screen height, keep 16:9 ratio
-    height = int(screen_height * 0.9)
-    width = int(height * (16 / 9))
-
-    # If width exceeds screen width, scale down
-    if width > screen_width * 0.9:
-        width = int(screen_width * 0.9)
-        height = int(width / (16 / 9))
-
-    w.resize(width, height)
-
-    # Center the window on the screen
-    x = screen_geometry.x() + (screen_geometry.width() - width) // 2
-    y = screen_geometry.y() + (screen_geometry.height() - height) // 2
-    w.move(x, y)
+    screen_geometry = available_screen_geometry()
+    if screen_geometry is not None:
+        width, height = main_app_size_for_screen(screen_geometry)
+        apply_centered_size(w, width, height, available=screen_geometry)
+    else:
+        w.resize(w.minimumSizeHint())
 
     w.show()
 

bec_widgets/applications/views/developer_view/developer_widget.py

@@ -13,8 +13,8 @@ from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.toolbars.actions import MaterialIconAction
 from bec_widgets.utils.toolbars.bundles import ToolbarBundle
 from bec_widgets.utils.toolbars.toolbar import ModularToolBar
-from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
-from bec_widgets.widgets.containers.advanced_dock_area.basic_dock_area import DockAreaWidget
+from bec_widgets.widgets.containers.dock_area.basic_dock_area import DockAreaWidget
+from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
 from bec_widgets.widgets.containers.qt_ads import CDockWidget
 from bec_widgets.widgets.editors.monaco.monaco_dock import MonacoDock
 from bec_widgets.widgets.editors.monaco.monaco_widget import MonacoWidget
@@ -79,6 +79,8 @@ def markdown_to_html(md_text: str) -> str:
 
 
 class DeveloperWidget(DockAreaWidget):
+    RPC = False
+    PLUGIN = False
 
     def __init__(self, parent=None, **kwargs):
         super().__init__(parent=parent, variant="compact", **kwargs)
@@ -99,7 +101,7 @@ class DeveloperWidget(DockAreaWidget):
         self.monaco = MonacoDock(self)
         self.monaco.setObjectName("MonacoEditor")
         self.monaco.save_enabled.connect(self._on_save_enabled_update)
-        self.plotting_ads = AdvancedDockArea(
+        self.plotting_ads = BECDockArea(
             self,
             mode="plot",
             default_add_direction="bottom",

bec_widgets/applications/views/device_manager_view/device_manager_display_widget.py

@@ -38,7 +38,7 @@ from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.utils.toolbars.actions import MaterialIconAction
 from bec_widgets.utils.toolbars.bundles import ToolbarBundle
 from bec_widgets.utils.toolbars.toolbar import ModularToolBar
-from bec_widgets.widgets.containers.advanced_dock_area.basic_dock_area import DockAreaWidget
+from bec_widgets.widgets.containers.dock_area.basic_dock_area import DockAreaWidget
 from bec_widgets.widgets.control.device_manager.components import (
     DeviceTable,
     DMConfigView,

bec_widgets/applications/views/dock_area_view/dock_area_view.py

@@ -0,0 +1,24 @@
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.applications.views.view import ViewBase
+from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
+
+
+class DockAreaView(ViewBase):
+    """
+    Modular dock area view for arranging and managing multiple dockable widgets.
+    """
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        content: QWidget | None = None,
+        *,
+        id: str | None = None,
+        title: str | None = None,
+    ):
+        super().__init__(parent=parent, content=content, id=id, title=title)
+        self.dock_area = BECDockArea(
+            self, profile_namespace="bec", auto_profile_namespace=False, object_name="DockArea"
+        )
+        self.set_content(self.dock_area)

bec_widgets/cli/client.py

@@ -56,7 +56,6 @@ _Widgets = {
     "ScatterWaveform": "ScatterWaveform",
     "SignalLabel": "SignalLabel",
     "TextBox": "TextBox",
-    "VSCodeEditor": "VSCodeEditor",
     "Waveform": "Waveform",
     "WebConsole": "WebConsole",
     "WebsiteWidget": "WebsiteWidget",
@@ -91,7 +90,63 @@ except ImportError as e:
     logger.error(f"Failed loading plugins: \n{reduce(add, traceback.format_exception(e))}")
 
 
-class AdvancedDockArea(RPCBase):
+class AutoUpdates(RPCBase):
+    @property
+    @rpc_call
+    def enabled(self) -> "bool":
+        """
+        Get the enabled status of the auto updates.
+        """
+
+    @enabled.setter
+    @rpc_call
+    def enabled(self) -> "bool":
+        """
+        Get the enabled status of the auto updates.
+        """
+
+    @property
+    @rpc_call
+    def selected_device(self) -> "str | None":
+        """
+        Get the selected device from the auto update config.
+
+        Returns:
+            str: The selected device. If no device is selected, None is returned.
+        """
+
+    @selected_device.setter
+    @rpc_call
+    def selected_device(self) -> "str | None":
+        """
+        Get the selected device from the auto update config.
+
+        Returns:
+            str: The selected device. If no device is selected, None is returned.
+        """
+
+
+class AvailableDeviceResources(RPCBase):
+    @rpc_call
+    def remove(self):
+        """
+        Cleanup the BECConnector
+        """
+
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
+        """
+
+
+class BECDockArea(RPCBase):
     @rpc_call
     def new(
         self,
@@ -321,62 +376,6 @@ class AdvancedDockArea(RPCBase):
         """
 
 
-class AutoUpdates(RPCBase):
-    @property
-    @rpc_call
-    def enabled(self) -> "bool":
-        """
-        Get the enabled status of the auto updates.
-        """
-
-    @enabled.setter
-    @rpc_call
-    def enabled(self) -> "bool":
-        """
-        Get the enabled status of the auto updates.
-        """
-
-    @property
-    @rpc_call
-    def selected_device(self) -> "str | None":
-        """
-        Get the selected device from the auto update config.
-
-        Returns:
-            str: The selected device. If no device is selected, None is returned.
-        """
-
-    @selected_device.setter
-    @rpc_call
-    def selected_device(self) -> "str | None":
-        """
-        Get the selected device from the auto update config.
-
-        Returns:
-            str: The selected device. If no device is selected, None is returned.
-        """
-
-
-class AvailableDeviceResources(RPCBase):
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-    @rpc_call
-    def attach(self):
-        """
-        None
-        """
-
-    @rpc_call
-    def detach(self):
-        """
-        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
-        """
-
-
 class BECMainWindow(RPCBase):
     @rpc_call
     def remove(self):
@@ -2502,16 +2501,30 @@ class Image(RPCBase):
 
     @property
     @rpc_call
-    def monitor(self) -> "str":
+    def device_name(self) -> "str":
         """
-        The name of the monitor to use for the image.
+        The name of the device to monitor for image data.
         """
 
-    @monitor.setter
+    @device_name.setter
     @rpc_call
-    def monitor(self) -> "str":
+    def device_name(self) -> "str":
         """
-        The name of the monitor to use for the image.
+        The name of the device to monitor for image data.
+        """
+
+    @property
+    @rpc_call
+    def device_entry(self) -> "str":
+        """
+        The signal/entry name to monitor on the device.
+        """
+
+    @device_entry.setter
+    @rpc_call
+    def device_entry(self) -> "str":
+        """
+        The signal/entry name to monitor on the device.
         """
 
     @rpc_call
@@ -2617,8 +2630,8 @@ class Image(RPCBase):
     @rpc_call
     def image(
         self,
-        monitor: "str | tuple | None" = None,
-        monitor_type: "Literal['auto', '1d', '2d']" = "auto",
+        device_name: "str | None" = None,
+        device_entry: "str | None" = None,
         color_map: "str | None" = None,
         color_bar: "Literal['simple', 'full'] | None" = None,
         vrange: "tuple[int, int] | None" = None,
@@ -2627,14 +2640,14 @@ class Image(RPCBase):
         Set the image source and update the image.
 
         Args:
-            monitor(str|tuple|None): The name of the monitor to use for the image, or a tuple of (device, signal) for preview signals. If None or empty string, the current monitor will be disconnected.
-            monitor_type(str): The type of monitor to use. Options are "1d", "2d", or "auto".
+            device_name(str|None): The name of the device to monitor. If None or empty string, the current monitor will be disconnected.
+            device_entry(str|None): The signal/entry name to monitor on the device.
             color_map(str): The color map to use for the image.
             color_bar(str): The type of color bar to use. Options are "simple" or "full".
             vrange(tuple): The range of values to use for the color map.
 
         Returns:
-            ImageItem: The image object.
+            ImageItem: The image object, or None if connection failed.
         """
 
     @property
@@ -2835,6 +2848,20 @@ class ImageItem(RPCBase):
         """
 
 
+class LaunchWindow(RPCBase):
+    @rpc_call
+    def show_launcher(self):
+        """
+        Show the launcher window.
+        """
+
+    @rpc_call
+    def hide_launcher(self):
+        """
+        Hide the launcher window.
+        """
+
+
 class LogPanel(RPCBase):
     """Displays a log panel"""
 
@@ -5515,12 +5542,6 @@ class TextBox(RPCBase):
         """
 
 
-class VSCodeEditor(RPCBase):
-    """A widget to display the VSCode editor."""
-
-    ...
-
-
 class Waveform(RPCBase):
     """Widget for plotting waveforms."""
 

bec_widgets/cli/generate_cli.py

@@ -291,7 +291,8 @@ def main():
 
     client_path = module_dir / client_subdir / "client.py"
 
-    rpc_classes = get_custom_classes(module_name)
+    packages = ("widgets", "applications") if module_name == "bec_widgets" else ("widgets",)
+    rpc_classes = get_custom_classes(module_name, packages=packages)
     logger.info(f"Obtained classes with RPC objects: {rpc_classes!r}")
 
     generator = ClientGenerator(base=module_name == "bec_widgets")

bec_widgets/cli/rpc/rpc_widget_handler.py

@@ -32,7 +32,8 @@ class RPCWidgetHandler:
             None
         """
         self._widget_classes = (
-            get_custom_classes("bec_widgets") + get_all_plugin_widgets()
+            get_custom_classes("bec_widgets", packages=("widgets", "applications"))
+            + get_all_plugin_widgets()
         ).as_dict(IGNORE_WIDGETS)
 
     def create_widget(self, widget_type, **kwargs) -> BECWidget:

bec_widgets/utils/bec_connector.py

@@ -12,7 +12,7 @@ import shiboken6 as shb
 from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import lazy_import_from
 from pydantic import BaseModel, Field, field_validator
-from qtpy.QtCore import Property, QObject, QRunnable, QThreadPool, QTimer, Signal
+from qtpy.QtCore import Property, QObject, QRunnable, QThreadPool, Signal
 from qtpy.QtWidgets import QApplication
 
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
@@ -23,7 +23,6 @@ from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, s
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_widgets.utils.bec_dispatcher import BECDispatcher
-    from bec_widgets.widgets.containers.dock import BECDock
 else:
     BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
 
@@ -273,6 +272,8 @@ class BECConnector:
         Args:
             name (str): The new object name.
         """
+        # sanitize before setting to avoid issues with Qt object names and RPC namespaces
+        name = sanitize_namespace(name)
         super().setObjectName(name)
         self.object_name = name
         if self.rpc_register.object_is_registered(self):

bec_widgets/utils/bec_login.py

@@ -0,0 +1,91 @@
+"""
+Login dialog for user authentication.
+The Login Widget is styled in a Material Design style and emits
+the entered credentials through a signal for further processing.
+"""
+
+from qtpy.QtCore import Qt, Signal
+from qtpy.QtWidgets import QLabel, QLineEdit, QPushButton, QVBoxLayout, QWidget
+
+
+class BECLogin(QWidget):
+    """Login dialog for user authentication in Material Design style."""
+
+    credentials_entered = Signal(str, str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        # Only displayed if this widget as standalone widget, and not embedded in another widget
+        self.setWindowTitle("Login")
+
+        title = QLabel("Sign in", parent=self)
+        title.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        title.setStyleSheet(
+            """
+            #QLabel
+                {
+                    font-size: 18px;
+                    font-weight: 600;
+                }
+            """
+        )
+
+        self.username = QLineEdit(parent=self)
+        self.username.setPlaceholderText("Username")
+
+        self.password = QLineEdit(parent=self)
+        self.password.setPlaceholderText("Password")
+        self.password.setEchoMode(QLineEdit.EchoMode.Password)
+
+        self.ok_btn = QPushButton("Sign in", parent=self)
+        self.ok_btn.setDefault(True)
+        self.ok_btn.clicked.connect(self._emit_credentials)
+        # If the user presses Enter in the password field, trigger the OK button click
+        self.password.returnPressed.connect(self.ok_btn.click)
+
+        # Build Layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(32, 32, 32, 32)
+        layout.setSpacing(16)
+
+        layout.addWidget(title)
+        layout.addSpacing(8)
+        layout.addWidget(self.username)
+        layout.addWidget(self.password)
+        layout.addSpacing(12)
+        layout.addWidget(self.ok_btn)
+
+        self.username.setFocus()
+
+        self.setStyleSheet(
+            """
+            QLineEdit {
+                padding: 8px;
+            }
+            """
+        )
+
+    def _clear_password(self):
+        """Clear the password field."""
+        self.password.clear()
+
+    def _emit_credentials(self):
+        """Emit credentials and clear the password field."""
+        self.credentials_entered.emit(self.username.text().strip(), self.password.text())
+        self._clear_password()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from bec_qthemes import apply_theme
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    apply_theme("light")
+
+    dialog = BECLogin()
+
+    dialog.credentials_entered.connect(lambda u, p: print(f"Username: {u}, Password: {p}"))
+    dialog.show()
+    sys.exit(app.exec_())

bec_widgets/utils/colors.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+from functools import lru_cache
 from typing import Literal
 
 import numpy as np
@@ -9,6 +10,7 @@ from bec_lib import bec_logger
 from bec_qthemes import apply_theme as apply_theme_global
 from bec_qthemes._theme import AccentColors
 from pydantic_core import PydanticCustomError
+from pyqtgraph.graphicsItems.GradientEditorItem import Gradients
 from qtpy.QtCore import QEvent, QEventLoop
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QApplication
@@ -57,6 +59,96 @@ def apply_theme(theme: Literal["dark", "light"]):
 
 
 class Colors:
+    @staticmethod
+    def list_available_colormaps() -> list[str]:
+        """
+        List colormap names available via the pyqtgraph colormap registry.
+
+        Note: This does not include `GradientEditorItem` presets (used by HistogramLUT menus).
+        """
+
+        def _list(source: str | None = None) -> list[str]:
+            try:
+                return pg.colormap.listMaps() if source is None else pg.colormap.listMaps(source)
+            except Exception:  # pragma: no cover - backend may be missing
+                return []
+
+        return [*_list(None), *_list("matplotlib"), *_list("colorcet")]
+
+    @staticmethod
+    def list_available_gradient_presets() -> list[str]:
+        """
+        List `GradientEditorItem` preset names (HistogramLUT right-click menu entries).
+        """
+        from pyqtgraph.graphicsItems.GradientEditorItem import Gradients
+
+        return list(Gradients.keys())
+
+    @staticmethod
+    def canonical_colormap_name(color_map: str) -> str:
+        """
+        Return an available colormap/preset name if a case-insensitive match exists.
+        """
+        requested = (color_map or "").strip()
+        if not requested:
+            return requested
+
+        registry = Colors.list_available_colormaps()
+        presets = Colors.list_available_gradient_presets()
+        available = set(registry) | set(presets)
+
+        if requested in available:
+            return requested
+
+        # Case-insensitive match.
+        requested_lc = requested.casefold()
+
+        for name in available:
+            if name.casefold() == requested_lc:
+                return name
+
+        return requested
+
+    @staticmethod
+    def get_colormap(color_map: str) -> pg.ColorMap:
+        """
+        Resolve a string into a `pg.ColorMap` using either:
+        - the `pg.colormap` registry (optionally including matplotlib/colorcet backends), or
+        - `GradientEditorItem` presets (HistogramLUT right-click menu).
+        """
+        name = Colors.canonical_colormap_name(color_map)
+        if not name:
+            raise ValueError("Empty colormap name")
+
+        return Colors._get_colormap_cached(name)
+
+    @staticmethod
+    @lru_cache(maxsize=256)
+    def _get_colormap_cached(name: str) -> pg.ColorMap:
+        # 1) Registry/backends
+        try:
+            cmap = pg.colormap.get(name)
+            if cmap is not None:
+                return cmap
+        except Exception:
+            pass
+        for source in ("matplotlib", "colorcet"):
+            try:
+                cmap = pg.colormap.get(name, source=source)
+                if cmap is not None:
+                    return cmap
+            except Exception:
+                continue
+
+        # 2) Presets -> ColorMap
+
+        if name not in Gradients:
+            raise KeyError(f"Colormap '{name}' not found")
+
+        ge = pg.GradientEditorItem()
+        ge.loadPreset(name)
+
+        return ge.colorMap()
 
     @staticmethod
     def golden_ratio(num: int) -> list:
@@ -138,7 +230,7 @@ class Colors:
         if theme_offset < 0 or theme_offset > 1:
             raise ValueError("theme_offset must be between 0 and 1")
 
-        cmap = pg.colormap.get(colormap)
+        cmap = Colors.get_colormap(colormap)
         min_pos, max_pos = Colors.set_theme_offset(theme, theme_offset)
 
         # Generate positions that are evenly spaced within the acceptable range
@@ -186,7 +278,7 @@ class Colors:
             ValueError: If theme_offset is not between 0 and 1.
         """
 
-        cmap = pg.colormap.get(colormap)
+        cmap = Colors.get_colormap(colormap)
         phi = (1 + np.sqrt(5)) / 2  # Golden ratio
         golden_angle_conjugate = 1 - (1 / phi)  # Approximately 0.38196601125
 
@@ -452,21 +544,24 @@ class Colors:
         Raises:
             PydanticCustomError: If colormap is invalid.
         """
-        available_pg_maps = pg.colormap.listMaps()
-        available_mpl_maps = pg.colormap.listMaps("matplotlib")
-        available_mpl_colorcet = pg.colormap.listMaps("colorcet")
-
-        available_colormaps = available_pg_maps + available_mpl_maps + available_mpl_colorcet
-        if color_map not in available_colormaps:
+        normalized = Colors.canonical_colormap_name(color_map)
+        try:
+            Colors.get_colormap(normalized)
+        except Exception as ext:
+            logger.warning(f"Colormap validation error: {ext}")
             if return_error:
+                available_colormaps = sorted(
+                    set(Colors.list_available_colormaps())
+                    | set(Colors.list_available_gradient_presets())
+                )
                 raise PydanticCustomError(
                     "unsupported colormap",
-                    f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose on the following: {available_colormaps}.",
+                    f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose from the following: {available_colormaps}.",
                     {"wrong_value": color_map},
                 )
             else:
                 return False
-        return color_map
+        return normalized
 
     @staticmethod
     def relative_luminance(color: QColor) -> float:

bec_widgets/utils/plugin_utils.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Iterable
 
 from bec_lib.plugin_helper import _get_available_plugins
-from qtpy.QtWidgets import QGraphicsWidget, QWidget
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.utils import BECConnector
 from bec_widgets.utils.bec_widget import BECWidget
@@ -166,18 +166,17 @@ class BECClassContainer:
         return [info.obj for info in self.collection]
 
 
-def get_custom_classes(repo_name: str) -> BECClassContainer:
-    """
-    Get all RPC-enabled classes in the specified repository.
-
-    Args:
-        repo_name(str): The name of the repository.
-
-    Returns:
-        dict: A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
-    """
+def _collect_classes_from_package(repo_name: str, package: str) -> BECClassContainer:
+    """Collect classes from a package subtree (for example ``widgets`` or ``applications``)."""
     collection = BECClassContainer()
-    anchor_module = importlib.import_module(f"{repo_name}.widgets")
+    try:
+        anchor_module = importlib.import_module(f"{repo_name}.{package}")
+    except ModuleNotFoundError as exc:
+        # Some plugin repositories expose only one subtree. Skip gracefully if it does not exist.
+        if exc.name == f"{repo_name}.{package}":
+            return collection
+        raise
+
     directory = os.path.dirname(anchor_module.__file__)
     for root, _, files in sorted(os.walk(directory)):
         for file in files:
@@ -185,13 +184,13 @@ def get_custom_classes(repo_name: str) -> BECClassContainer:
                 continue
 
             path = os.path.join(root, file)
-            subs = os.path.dirname(os.path.relpath(path, directory)).split("/")
-            if len(subs) == 1 and not subs[0]:
+            rel_dir = os.path.dirname(os.path.relpath(path, directory))
+            if rel_dir in ("", "."):
                 module_name = file.split(".")[0]
             else:
-                module_name = ".".join(subs + [file.split(".")[0]])
+                module_name = ".".join(rel_dir.split(os.sep) + [file.split(".")[0]])
 
-            module = importlib.import_module(f"{repo_name}.widgets.{module_name}")
+            module = importlib.import_module(f"{repo_name}.{package}.{module_name}")
 
             for name in dir(module):
                 obj = getattr(module, name)
@@ -203,12 +202,30 @@ def get_custom_classes(repo_name: str) -> BECClassContainer:
                         class_info.is_connector = True
                     if issubclass(obj, QWidget) or issubclass(obj, BECWidget):
                         class_info.is_widget = True
-                    if len(subs) == 1 and (
-                        issubclass(obj, QWidget) or issubclass(obj, QGraphicsWidget)
-                    ):
-                        class_info.is_top_level = True
                     if hasattr(obj, "PLUGIN") and obj.PLUGIN:
                         class_info.is_plugin = True
                     collection.add_class(class_info)
-
+    return collection
+
+
+def get_custom_classes(
+    repo_name: str, packages: tuple[str, ...] | None = None
+) -> BECClassContainer:
+    """
+    Get all relevant classes for RPC/CLI in the specified repository.
+
+    By default, discovery is limited to ``<repo>.widgets`` for backward compatibility.
+    Additional package subtrees (for example ``applications``) can be included explicitly.
+
+    Args:
+        repo_name(str): The name of the repository.
+        packages(tuple[str, ...] | None): Optional tuple of package names to scan. Defaults to ("widgets",) for backward compatibility.
+
+    Returns:
+        BECClassContainer: Container with collected class information.
+    """
+    selected_packages = packages or ("widgets",)
+    collection = BECClassContainer()
+    for package in selected_packages:
+        collection += _collect_classes_from_package(repo_name, package)
     return collection

bec_widgets/utils/screen_utils.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from qtpy.QtWidgets import QApplication, QWidget
+
+if TYPE_CHECKING:  # pragma: no cover
+    from qtpy.QtCore import QRect
+
+
+def available_screen_geometry(*, widget: QWidget | None = None) -> QRect | None:
+    """
+    Get the available geometry of the screen associated with the given widget or application.
+
+    Args:
+        widget(QWidget | None): The widget to get the screen from.
+    Returns:
+        QRect | None: The available geometry of the screen, or None if no screen is found.
+    """
+    screen = widget.screen() if widget is not None else None
+    if screen is None:
+        app = QApplication.instance()
+        screen = app.primaryScreen() if app is not None else None
+    if screen is None:
+        return None
+    return screen.availableGeometry()
+
+
+def centered_geometry(available: "QRect", width: int, height: int) -> tuple[int, int, int, int]:
+    """
+    Calculate centered geometry within the available rectangle.
+
+    Args:
+        available(QRect): The available rectangle to center within.
+        width(int): The desired width.
+        height(int): The desired height.
+
+    Returns:
+        tuple[int, int, int, int]: The (x, y, width, height) of the centered geometry.
+    """
+    x = available.x() + (available.width() - width) // 2
+    y = available.y() + (available.height() - height) // 2
+    return x, y, width, height
+
+
+def centered_geometry_for_app(width: int, height: int) -> tuple[int, int, int, int] | None:
+    available = available_screen_geometry()
+    if available is None:
+        return None
+    return centered_geometry(available, width, height)
+
+
+def scaled_centered_geometry_for_window(
+    window: QWidget, *, width_ratio: float = 0.8, height_ratio: float = 0.8
+) -> tuple[int, int, int, int] | None:
+    available = available_screen_geometry(widget=window)
+    if available is None:
+        return None
+    width = int(available.width() * width_ratio)
+    height = int(available.height() * height_ratio)
+    return centered_geometry(available, width, height)
+
+
+def apply_window_geometry(
+    window: QWidget,
+    geometry: tuple[int, int, int, int] | None,
+    *,
+    width_ratio: float = 0.8,
+    height_ratio: float = 0.8,
+) -> None:
+    if geometry is not None:
+        window.setGeometry(*geometry)
+        return
+    default_geometry = scaled_centered_geometry_for_window(
+        window, width_ratio=width_ratio, height_ratio=height_ratio
+    )
+    if default_geometry is not None:
+        window.setGeometry(*default_geometry)
+    else:
+        window.resize(window.minimumSizeHint())
+
+
+def main_app_size_for_screen(available: "QRect") -> tuple[int, int]:
+    height = int(available.height() * 0.9)
+    width = int(height * (16 / 9))
+    if width > available.width() * 0.9:
+        width = int(available.width() * 0.9)
+        height = int(width / (16 / 9))
+    return width, height
+
+
+def apply_centered_size(
+    window: QWidget, width: int, height: int, *, available: "QRect" | None = None
+) -> None:
+    if available is None:
+        available = available_screen_geometry(widget=window)
+    if available is None:
+        window.resize(width, height)
+        return
+    window.setGeometry(*centered_geometry(available, width, height))

bec_widgets/widgets/containers/auto_update/auto_updates.py

@@ -7,7 +7,7 @@ from bec_lib.logger import bec_logger
 from bec_lib.messages import ScanStatusMessage
 
 from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
+from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea
 from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
 from bec_widgets.widgets.containers.qt_ads import CDockWidget
 
@@ -37,7 +37,7 @@ class AutoUpdates(BECMainWindow):
     ):
         super().__init__(parent=parent, gui_id=gui_id, window_title=window_title, **kwargs)
 
-        self.dock_area = AdvancedDockArea(
+        self.dock_area = BECDockArea(
             parent=self,
             object_name="dock_area",
             enable_profile_management=False,

bec_widgets/widgets/containers/dock_area/dock_area.py

@@ -5,7 +5,7 @@ from typing import Literal, Mapping, Sequence
 
 import slugify
 from bec_lib import bec_logger
-from qtpy.QtCore import QTimer, Signal
+from qtpy.QtCore import Signal
 from qtpy.QtGui import QPixmap
 from qtpy.QtWidgets import (
     QApplication,
@@ -31,8 +31,8 @@ from bec_widgets.utils.toolbars.actions import (
 from bec_widgets.utils.toolbars.bundles import ToolbarBundle
 from bec_widgets.utils.toolbars.toolbar import ModularToolBar
 from bec_widgets.utils.widget_state_manager import WidgetStateManager
-from bec_widgets.widgets.containers.advanced_dock_area.basic_dock_area import DockAreaWidget
-from bec_widgets.widgets.containers.advanced_dock_area.profile_utils import (
+from bec_widgets.widgets.containers.dock_area.basic_dock_area import DockAreaWidget
+from bec_widgets.widgets.containers.dock_area.profile_utils import (
     SETTINGS_KEYS,
     default_profile_candidates,
     delete_profile_files,
@@ -55,14 +55,12 @@ from bec_widgets.widgets.containers.advanced_dock_area.profile_utils import (
     user_profile_candidates,
     write_manifest,
 )
-from bec_widgets.widgets.containers.advanced_dock_area.settings.dialogs import (
+from bec_widgets.widgets.containers.dock_area.settings.dialogs import (
     RestoreProfileDialog,
     SaveProfileDialog,
 )
-from bec_widgets.widgets.containers.advanced_dock_area.settings.workspace_manager import (
-    WorkSpaceManager,
-)
-from bec_widgets.widgets.containers.advanced_dock_area.toolbar_components.workspace_actions import (
+from bec_widgets.widgets.containers.dock_area.settings.workspace_manager import WorkSpaceManager
+from bec_widgets.widgets.containers.dock_area.toolbar_components.workspace_actions import (
     WorkspaceConnection,
     workspace_bundle,
 )
@@ -90,7 +88,7 @@ _PROFILE_NAMESPACE_UNSET = object()
 PROFILE_STATE_KEYS = {key: SETTINGS_KEYS[key] for key in ("geom", "state", "ads_state")}
 
 
-class AdvancedDockArea(DockAreaWidget):
+class BECDockArea(DockAreaWidget):
     RPC = True
     PLUGIN = False
     USER_ACCESS = [
@@ -1163,7 +1161,7 @@ if __name__ == "__main__":  # pragma: no cover
     dispatcher = BECDispatcher(gui_id="ads")
     window = BECMainWindowNoRPC()
 
-    ads = AdvancedDockArea(mode="creator", enable_profile_management=True, root_widget=True)
+    ads = BECDockArea(mode="creator", enable_profile_management=True, root_widget=True)
 
     window.setCentralWidget(ads)
     window.show()

bec_widgets/widgets/containers/dock_area/settings/workspace_manager.py

@@ -28,7 +28,7 @@ from qtpy.QtWidgets import (
 
 from bec_widgets import BECWidget, SafeSlot
 from bec_widgets.utils.colors import get_accent_colors
-from bec_widgets.widgets.containers.advanced_dock_area.profile_utils import (
+from bec_widgets.widgets.containers.dock_area.profile_utils import (
     get_profile_info,
     is_quick_select,
     list_profiles,

bec_widgets/widgets/containers/dock_area/toolbar_components/workspace_actions.py

@@ -10,7 +10,7 @@ from bec_widgets import SafeSlot
 from bec_widgets.utils.toolbars.actions import MaterialIconAction, WidgetAction
 from bec_widgets.utils.toolbars.bundles import ToolbarBundle, ToolbarComponents
 from bec_widgets.utils.toolbars.connections import BundleConnection
-from bec_widgets.widgets.containers.advanced_dock_area.profile_utils import list_quick_profiles
+from bec_widgets.widgets.containers.dock_area.profile_utils import list_quick_profiles
 
 
 class ProfileComboBox(QComboBox):

bec_widgets/widgets/containers/main_window/main_window.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 from typing import TYPE_CHECKING
 
+from bec_lib import messages
 from bec_lib.endpoints import MessageEndpoints
 from qtpy.QtCore import QEvent, QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QActionGroup, QIcon
@@ -31,6 +32,7 @@ from bec_widgets.widgets.containers.main_window.addons.notification_center.notif
 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
+from bec_widgets.widgets.utility.feedback_dialog.feedback_dialog import FeedbackDialog
 
 MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
@@ -342,6 +344,34 @@ class BECMainWindow(BECWidget, QMainWindow):
         help_menu.addAction(widgets_docs)
         help_menu.addAction(bug_report)
 
+        # Add separator before feedback
+        help_menu.addSeparator()
+
+        # Feedback action
+        feedback_icon = QApplication.style().standardIcon(
+            QStyle.StandardPixmap.SP_MessageBoxQuestion
+        )
+        feedback_action = QAction("Feedback", self)
+        feedback_action.setIcon(feedback_icon)
+        feedback_action.triggered.connect(self._show_feedback_dialog)
+        help_menu.addAction(feedback_action)
+
+    def _show_feedback_dialog(self):
+        """Show the feedback dialog and handle the submitted feedback."""
+        dialog = FeedbackDialog(self)
+
+        def on_feedback_submitted(rating: int, comment: str, email: str):
+            rating = max(1, min(rating, 5))  # Ensure rating is between 1 and 5
+            username = os.getlogin()
+
+            message = messages.FeedbackMessage(
+                feedback=comment, rating=rating, contact=email, username=username
+            )
+            self.bec_dispatcher.client.connector.send(MessageEndpoints.submit_feedback(), message)
+
+        dialog.feedback_submitted.connect(on_feedback_submitted)
+        dialog.exec()
+
     ################################################################################
     # Status Bar Addons
     ################################################################################

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

@@ -186,6 +186,11 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
             device = self.itemData(idx)[0]  # type: ignore[assignment]
         return super().validate_device(device)
 
+    @property
+    def is_valid_input(self) -> bool:
+        """Whether the current text represents a valid device selection."""
+        return self._is_valid_input
+
 
 if __name__ == "__main__":  # pragma: no cover
     # pylint: disable=import-outside-toplevel

bec_widgets/widgets/control/device_manager/components/ophyd_validation/ophyd_validation.py

@@ -69,11 +69,12 @@ class DeviceTest(QtCore.QRunnable):
         enable_connect: bool,
         force_connect: bool,
         timeout: float,
+        device_manager_ds: object | None = None,
     ):
         super().__init__()
         self.uuid = device_model.uuid
         test_config = {device_model.device_name: device_model.device_config}
-        self.tester = StaticDeviceTest(config_dict=test_config)
+        self.tester = StaticDeviceTest(config_dict=test_config, device_manager_ds=device_manager_ds)
         self.signals = DeviceTestResult()
         self.device_config = device_model.device_config
         self.enable_connect = enable_connect
@@ -752,11 +753,15 @@ class OphydValidation(BECWidget, QtWidgets.QWidget):
             # Remove widget from list as it's safe to assume it can be loaded.
             self._remove_device_config(widget.device_model.device_config)
             return
+        dm_ds = None
+        if self.client:
+            dm_ds = getattr(self.client, "device_manager", None)
         runnable = DeviceTest(
             device_model=widget.device_model,
             enable_connect=connect,
             force_connect=force_connect,
             timeout=timeout,
+            device_manager_ds=dm_ds,
         )
         widget.validation_scheduled()
         if self.thread_pool_manager:

bec_widgets/widgets/editors/monaco/monaco_dock.py

@@ -9,7 +9,7 @@ from bec_lib.macro_update_handler import has_executable_code
 from qtpy.QtCore import QEvent, QTimer, Signal
 from qtpy.QtWidgets import QFileDialog, QMessageBox, QToolButton, QWidget
 
-from bec_widgets.widgets.containers.advanced_dock_area.basic_dock_area import DockAreaWidget
+from bec_widgets.widgets.containers.dock_area.basic_dock_area import DockAreaWidget
 from bec_widgets.widgets.containers.qt_ads import CDockAreaWidget, CDockWidget
 from bec_widgets.widgets.editors.monaco.monaco_widget import MonacoWidget
 

bec_widgets/widgets/editors/vscode/register_vs_code_editor.py

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

bec_widgets/widgets/editors/vscode/vs_code_editor.pyproject

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

bec_widgets/widgets/editors/vscode/vs_code_editor_plugin.py

@@ -1,57 +0,0 @@
-# Copyright (C) 2022 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-
-from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-from qtpy.QtWidgets import QWidget
-
-from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.editors.vscode.vscode import VSCodeEditor
-
-DOM_XML = """
-<ui language='c++'>
-    <widget class='VSCodeEditor' name='vs_code_editor'>
-    </widget>
-</ui>
-"""
-
-
-class VSCodeEditorPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self._form_editor = None
-
-    def createWidget(self, parent):
-        if parent is None:
-            return QWidget()
-        t = VSCodeEditor(parent)
-        return t
-
-    def domXml(self):
-        return DOM_XML
-
-    def group(self):
-        return "BEC Developer"
-
-    def icon(self):
-        return designer_material_icon(VSCodeEditor.ICON_NAME)
-
-    def includeFile(self):
-        return "vs_code_editor"
-
-    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 "VSCodeEditor"
-
-    def toolTip(self):
-        return ""
-
-    def whatsThis(self):
-        return self.toolTip()

bec_widgets/widgets/editors/vscode/vscode.py

@@ -1,203 +0,0 @@
-import os
-import select
-import shlex
-import signal
-import socket
-import subprocess
-from typing import Literal
-
-from pydantic import BaseModel
-from qtpy.QtCore import Signal, Slot
-
-from bec_widgets.widgets.editors.website.website import WebsiteWidget
-
-
-class VSCodeInstructionMessage(BaseModel):
-    command: Literal["open", "write", "close", "zenMode", "save", "new", "setCursor"]
-    content: str = ""
-
-
-def get_free_port():
-    """
-    Get a free port on the local machine.
-
-    Returns:
-        int: The free port number
-    """
-    sock = socket.socket()
-    sock.bind(("", 0))
-    port = sock.getsockname()[1]
-    sock.close()
-    return port
-
-
-class VSCodeEditor(WebsiteWidget):
-    """
-    A widget to display the VSCode editor.
-    """
-
-    file_saved = Signal(str)
-
-    token = "bec"
-    host = "127.0.0.1"
-
-    PLUGIN = True
-    USER_ACCESS = []
-    ICON_NAME = "developer_mode_tv"
-
-    def __init__(self, parent=None, config=None, client=None, gui_id=None, **kwargs):
-
-        self.process = None
-        self.port = get_free_port()
-        self._url = f"http://{self.host}:{self.port}?tkn={self.token}"
-        super().__init__(parent=parent, config=config, client=client, gui_id=gui_id, **kwargs)
-        self.start_server()
-        self.bec_dispatcher.connect_slot(self.on_vscode_event, f"vscode-events/{self.gui_id}")
-
-    def start_server(self):
-        """
-        Start the server.
-
-        This method starts the server for the VSCode editor in a subprocess.
-        """
-
-        env = os.environ.copy()
-        env["BEC_Widgets_GUIID"] = self.gui_id
-        env["BEC_REDIS_HOST"] = self.client.connector.host
-        cmd = shlex.split(
-            f"code serve-web --port {self.port} --connection-token={self.token} --accept-server-license-terms"
-        )
-        self.process = subprocess.Popen(
-            cmd,
-            text=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.DEVNULL,
-            preexec_fn=os.setsid,
-            env=env,
-        )
-
-        os.set_blocking(self.process.stdout.fileno(), False)
-        while self.process.poll() is None:
-            readylist, _, _ = select.select([self.process.stdout], [], [], 1)
-            if self.process.stdout in readylist:
-                output = self.process.stdout.read(1024)
-                if output and f"available at {self._url}" in output:
-                    break
-        self.set_url(self._url)
-        self.wait_until_loaded()
-
-    @Slot(str)
-    def open_file(self, file_path: str):
-        """
-        Open a file in the VSCode editor.
-
-        Args:
-            file_path: The file path to open
-        """
-        msg = VSCodeInstructionMessage(command="open", content=f"file://{file_path}")
-        self.client.connector.raw_send(f"vscode-instructions/{self.gui_id}", msg.model_dump_json())
-
-    @Slot(dict, dict)
-    def on_vscode_event(self, content, _metadata):
-        """
-        Handle the VSCode event. VSCode events are received as RawMessages.
-
-        Args:
-            content: The content of the event
-            metadata: The metadata of the event
-        """
-
-        # the message also contains the content but I think is fine for now to just emit the file path
-        if not isinstance(content["data"], dict):
-            return
-        if "uri" not in content["data"]:
-            return
-        if not content["data"]["uri"].startswith("file://"):
-            return
-        file_path = content["data"]["uri"].split("file://")[1]
-        self.file_saved.emit(file_path)
-
-    @Slot()
-    def save_file(self):
-        """
-        Save the file in the VSCode editor.
-        """
-        msg = VSCodeInstructionMessage(command="save")
-        self.client.connector.raw_send(f"vscode-instructions/{self.gui_id}", msg.model_dump_json())
-
-    @Slot()
-    def new_file(self):
-        """
-        Create a new file in the VSCode editor.
-        """
-        msg = VSCodeInstructionMessage(command="new")
-        self.client.connector.raw_send(f"vscode-instructions/{self.gui_id}", msg.model_dump_json())
-
-    @Slot()
-    def close_file(self):
-        """
-        Close the file in the VSCode editor.
-        """
-        msg = VSCodeInstructionMessage(command="close")
-        self.client.connector.raw_send(f"vscode-instructions/{self.gui_id}", msg.model_dump_json())
-
-    @Slot(str)
-    def write_file(self, content: str):
-        """
-        Write content to the file in the VSCode editor.
-
-        Args:
-            content: The content to write
-        """
-        msg = VSCodeInstructionMessage(command="write", content=content)
-        self.client.connector.raw_send(f"vscode-instructions/{self.gui_id}", msg.model_dump_json())
-
-    @Slot()
-    def zen_mode(self):
-        """
-        Toggle the Zen mode in the VSCode editor.
-        """
-        msg = VSCodeInstructionMessage(command="zenMode")
-        self.client.connector.raw_send(f"vscode-instructions/{self.gui_id}", msg.model_dump_json())
-
-    @Slot(int, int)
-    def set_cursor(self, line: int, column: int):
-        """
-        Set the cursor in the VSCode editor.
-
-        Args:
-            line: The line number
-            column: The column number
-        """
-        msg = VSCodeInstructionMessage(command="setCursor", content=f"{line},{column}")
-        self.client.connector.raw_send(f"vscode-instructions/{self.gui_id}", msg.model_dump_json())
-
-    def cleanup_vscode(self):
-        """
-        Cleanup the VSCode editor.
-        """
-        if not self.process or self.process.poll() is not None:
-            return
-        os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
-        self.process.wait()
-
-    def cleanup(self):
-        """
-        Cleanup the widget. This method is called from the dock area when the widget is removed.
-        """
-        self.bec_dispatcher.disconnect_slot(self.on_vscode_event, f"vscode-events/{self.gui_id}")
-        self.cleanup_vscode()
-        return super().cleanup()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    widget = VSCodeEditor(gui_id="unknown")
-    widget.show()
-    app.exec_()
-    widget.bec_dispatcher.disconnect_all()
-    widget.client.shutdown()

bec_widgets/widgets/plots/image/image_base.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel, ConfigDict, Field, ValidationError
 from qtpy.QtCore import QPointF, Signal, SignalInstance
 from qtpy.QtWidgets import QDialog, QVBoxLayout
 
+from bec_widgets.utils import Colors
 from bec_widgets.utils.container_utils import WidgetContainerUtils
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.side_panel import SidePanel
@@ -131,8 +132,9 @@ class ImageLayerManager:
         image.setZValue(z_position)
         image.removed.connect(self._remove_destroyed_layer)
 
-        # FIXME: For now, we hard-code the default color map here. In the future, this should be configurable.
-        image.color_map = "plasma"
+        color_map = getattr(getattr(self.parent, "config", None), "color_map", None)
+        if color_map:
+            image.color_map = color_map
 
         self.layers[name] = ImageLayer(name=name, image=image, sync=sync)
         self.plot_item.addItem(image)
@@ -249,6 +251,8 @@ class ImageBase(PlotBase):
     Base class for the Image widget.
     """
 
+    MAX_TICKS_COLORBAR = 10
+
     sync_colorbar_with_autorange = Signal()
     image_updated = Signal()
     layer_added = Signal(str)
@@ -460,18 +464,20 @@ class ImageBase(PlotBase):
                 self.setProperty("autorange", False)
 
             if style == "simple":
-                self._color_bar = pg.ColorBarItem(colorMap=self.config.color_map)
+                cmap = Colors.get_colormap(self.config.color_map)
+                self._color_bar = pg.ColorBarItem(colorMap=cmap)
                 self._color_bar.setImageItem(self.layer_manager["main"].image)
                 self._color_bar.sigLevelsChangeFinished.connect(disable_autorange)
+                self.config.color_bar = "simple"
 
             elif style == "full":
                 self._color_bar = pg.HistogramLUTItem()
                 self._color_bar.setImageItem(self.layer_manager["main"].image)
-                self._color_bar.gradient.loadPreset(self.config.color_map)
+                self.config.color_bar = "full"
+                self._apply_colormap_to_colorbar(self.config.color_map)
                 self._color_bar.sigLevelsChanged.connect(disable_autorange)
 
             self.plot_widget.addItem(self._color_bar, row=0, col=1)
-            self.config.color_bar = style
         else:
             if self._color_bar:
                 self.plot_widget.removeItem(self._color_bar)
@@ -484,6 +490,37 @@ class ImageBase(PlotBase):
         if vrange:  # should be at the end to disable the autorange if defined
             self.v_range = vrange
 
+    def _apply_colormap_to_colorbar(self, color_map: str) -> None:
+        if not self._color_bar:
+            return
+
+        cmap = Colors.get_colormap(color_map)
+
+        if self.config.color_bar == "simple":
+            self._color_bar.setColorMap(cmap)
+            return
+
+        if self.config.color_bar != "full":
+            return
+
+        gradient = getattr(self._color_bar, "gradient", None)
+        if gradient is None:
+            return
+
+        positions = np.linspace(0.0, 1.0, self.MAX_TICKS_COLORBAR)
+        colors = cmap.map(positions, mode="byte")
+
+        colors = np.asarray(colors)
+        if colors.ndim != 2:
+            return
+        if colors.shape[1] == 3:  # add alpha
+            alpha = np.full((colors.shape[0], 1), 255, dtype=colors.dtype)
+            colors = np.concatenate([colors, alpha], axis=1)
+
+        ticks = [(float(p), tuple(int(x) for x in c)) for p, c in zip(positions, colors)]
+        state = {"mode": "rgb", "ticks": ticks}
+        gradient.restoreState(state)
+
     ################################################################################
     # Static rois with roi manager
 
@@ -754,11 +791,11 @@ class ImageBase(PlotBase):
                 layer.image.color_map = value
 
             if self._color_bar:
-                if self.config.color_bar == "simple":
-                    self._color_bar.setColorMap(value)
-                elif self.config.color_bar == "full":
-                    self._color_bar.gradient.loadPreset(value)
-        except ValidationError:
+                self._apply_colormap_to_colorbar(self.config.color_map)
+        except ValidationError as exc:
+            logger.warning(
+                f"Colormap '{value}' is not available; keeping '{self.config.color_map}'. {exc}"
+            )
             return
 
     @SafeProperty("QPointF")

bec_widgets/widgets/plots/image/image_item.py

@@ -119,7 +119,8 @@ class ImageItem(BECConnector, pg.ImageItem):
         """Set a new color map."""
         try:
             self.config.color_map = value
-            self.setColorMap(value)
+            cmap = Colors.get_colormap(self.config.color_map)
+            self.setColorMap(cmap)
         except ValidationError:
             logger.error(f"Invalid colormap '{value}' provided.")
 

bec_widgets/widgets/plots/image/toolbar_components/device_selection.py

@@ -0,0 +1,255 @@
+from qtpy.QtWidgets import QHBoxLayout, QSizePolicy, QWidget
+
+from bec_widgets.utils.toolbars.actions import WidgetAction
+from bec_widgets.utils.toolbars.bundles import ToolbarBundle, ToolbarComponents
+from bec_widgets.utils.toolbars.connections import BundleConnection
+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
+
+
+class DeviceSelection(QWidget):
+    """Device and signal selection widget for image toolbar."""
+
+    def __init__(self, parent=None, client=None):
+        super().__init__(parent=parent)
+
+        self.client = client
+        self.supported_signals = [
+            "PreviewSignal",
+            "AsyncSignal",
+            "AsyncMultiSignal",
+            "DynamicSignal",
+        ]
+
+        # Create device combobox with signal class filter
+        # This will only show devices that have signals matching the supported signal classes
+        self.device_combo_box = DeviceComboBox(
+            parent=self, client=self.client, signal_class_filter=self.supported_signals
+        )
+        self.device_combo_box.setToolTip("Select Device")
+        self.device_combo_box.setEditable(True)
+        # Set expanding size policy so it grows with available space
+        self.device_combo_box.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        self.device_combo_box.lineEdit().setPlaceholderText("Select Device")
+
+        # Configure SignalComboBox to filter by PreviewSignal and supported async signals
+        # Also filter by ndim (1D and 2D only) for Image widget
+        self.signal_combo_box = SignalComboBox(
+            parent=self,
+            client=self.client,
+            signal_class_filter=[
+                "PreviewSignal",
+                "AsyncSignal",
+                "AsyncMultiSignal",
+                "DynamicSignal",
+            ],
+            ndim_filter=[1, 2],  # Only show 1D and 2D signals for Image widget
+            store_signal_config=True,
+            require_device=True,
+        )
+        self.signal_combo_box.setToolTip("Select Signal")
+        self.signal_combo_box.setEditable(True)
+        # Set expanding size policy so it grows with available space
+        self.signal_combo_box.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        self.signal_combo_box.lineEdit().setPlaceholderText("Select Signal")
+
+        # Connect comboboxes together
+        self.device_combo_box.currentTextChanged.connect(self.signal_combo_box.set_device)
+        self.device_combo_box.device_reset.connect(self.signal_combo_box.reset_selection)
+
+        # Simple horizontal layout with stretch to fill space
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(2)
+        layout.addWidget(self.device_combo_box, stretch=1)
+        layout.addWidget(self.signal_combo_box, stretch=1)
+
+    def set_device_and_signal(self, device_name: str | None, device_entry: str | None) -> None:
+        """Set the displayed device and signal without emitting selection signals."""
+        device_name = device_name or ""
+        device_entry = device_entry or ""
+
+        self.device_combo_box.blockSignals(True)
+        self.signal_combo_box.blockSignals(True)
+
+        try:
+            if device_name:
+                # Set device in device_combo_box
+                index = self.device_combo_box.findText(device_name)
+                if index >= 0:
+                    self.device_combo_box.setCurrentIndex(index)
+                else:
+                    # Device not found in list, but still set it
+                    self.device_combo_box.setCurrentText(device_name)
+
+                # Only update signal combobox device filter if it's actually changing
+                # This prevents redundant repopulation which can cause duplicates !!!!
+                current_device = getattr(self.signal_combo_box, "_device", None)
+                if current_device != device_name:
+                    self.signal_combo_box.set_device(device_name)
+
+                # Sync signal combobox selection
+                if device_entry:
+                    # Try to find the signal by component_name (which is what's displayed)
+                    found = False
+                    for i in range(self.signal_combo_box.count()):
+                        text = self.signal_combo_box.itemText(i)
+                        config_data = self.signal_combo_box.itemData(i)
+
+                        # Check if this matches our signal
+                        if config_data:
+                            component_name = config_data.get("component_name", "")
+                            if text == component_name or text == device_entry:
+                                self.signal_combo_box.setCurrentIndex(i)
+                                found = True
+                                break
+
+                    if not found:
+                        # Fallback: try to match the device_entry directly
+                        index = self.signal_combo_box.findText(device_entry)
+                        if index >= 0:
+                            self.signal_combo_box.setCurrentIndex(index)
+            else:
+                # No device set, clear selections
+                self.device_combo_box.setCurrentText("")
+                self.signal_combo_box.reset_selection()
+        finally:
+            # Always unblock signals
+            self.device_combo_box.blockSignals(False)
+            self.signal_combo_box.blockSignals(False)
+
+    def set_connection_status(self, status: str, message: str | None = None) -> None:
+        tooltip = f"Connection status: {status}"
+        if message:
+            tooltip = f"{tooltip}\n{message}"
+        self.device_combo_box.setToolTip(tooltip)
+        self.signal_combo_box.setToolTip(tooltip)
+
+        if not self.device_combo_box.is_valid_input or not self.signal_combo_box.is_valid_input:
+            return
+
+        if status == "error":
+            style = "border: 1px solid orange;"
+        else:
+            style = "border: 1px solid transparent;"
+
+        self.device_combo_box.setStyleSheet(style)
+        self.signal_combo_box.setStyleSheet(style)
+
+    def cleanup(self):
+        """Clean up the widget resources."""
+        self.device_combo_box.close()
+        self.device_combo_box.deleteLater()
+        self.signal_combo_box.close()
+        self.signal_combo_box.deleteLater()
+
+
+def device_selection_bundle(components: ToolbarComponents, client=None) -> ToolbarBundle:
+    """
+    Creates a device selection toolbar bundle for Image widget.
+
+    Includes a resizable splitter after the device selection. All subsequent bundles'
+    actions will appear compactly after the splitter with no gaps.
+
+    Args:
+        components (ToolbarComponents): The components to be added to the bundle.
+        client: The BEC client instance.
+
+    Returns:
+        ToolbarBundle: The device selection toolbar bundle.
+    """
+    device_selection_widget = DeviceSelection(parent=components.toolbar, client=client)
+    components.add_safe(
+        "device_selection", WidgetAction(widget=device_selection_widget, adjust_size=False)
+    )
+
+    bundle = ToolbarBundle("device_selection", components)
+    bundle.add_action("device_selection")
+
+    bundle.add_splitter(
+        name="device_selection_splitter",
+        target_widget=device_selection_widget,
+        min_width=210,
+        max_width=600,
+    )
+
+    return bundle
+
+
+class DeviceSelectionConnection(BundleConnection):
+    """
+    Connection helper for the device selection bundle.
+    """
+
+    def __init__(self, components: ToolbarComponents, target_widget=None):
+        super().__init__(parent=components.toolbar)
+        self.bundle_name = "device_selection"
+        self.components = components
+        self.target_widget = target_widget
+        self._connected = False
+        self.register_property_sync("device_name", self._sync_from_device_name)
+        self.register_property_sync("device_entry", self._sync_from_device_entry)
+        self.register_property_sync("connection_status", self._sync_connection_status)
+        self.register_property_sync("connection_error", self._sync_connection_status)
+
+    def _widget(self) -> DeviceSelection:
+        return self.components.get_action("device_selection").widget
+
+    def connect(self):
+        if self._connected:
+            return
+        widget = self._widget()
+        widget.device_combo_box.device_selected.connect(
+            self.target_widget.on_device_selection_changed
+        )
+        widget.signal_combo_box.device_signal_changed.connect(
+            self.target_widget.on_device_selection_changed
+        )
+        self.connect_property_sync(self.target_widget)
+        self._connected = True
+
+    def disconnect(self):
+        if not self._connected:
+            return
+        widget = self._widget()
+        widget.device_combo_box.device_selected.disconnect(
+            self.target_widget.on_device_selection_changed
+        )
+        widget.signal_combo_box.device_signal_changed.disconnect(
+            self.target_widget.on_device_selection_changed
+        )
+        self.disconnect_property_sync(self.target_widget)
+        self._connected = False
+        widget.cleanup()
+
+    def _sync_from_device_name(self, _):
+        try:
+            widget = self._widget()
+        except Exception:
+            return
+
+        widget.set_device_and_signal(
+            self.target_widget.device_name, self.target_widget.device_entry
+        )
+        self.target_widget._sync_device_entry_from_toolbar()
+
+    def _sync_from_device_entry(self, _):
+        try:
+            widget = self._widget()
+        except Exception:
+            return
+
+        widget.set_device_and_signal(
+            self.target_widget.device_name, self.target_widget.device_entry
+        )
+
+    def _sync_connection_status(self, _):
+        try:
+            widget = self._widget()
+        except Exception:
+            return
+
+        widget.set_connection_status(
+            self.target_widget._config.connection_status,
+            self.target_widget._config.connection_error,
+        )

bec_widgets/widgets/utility/feedback_dialog/feedback_dialog.py

@@ -0,0 +1,294 @@
+from qtpy.QtCore import Qt, Signal
+from qtpy.QtGui import QColor, QFont
+from qtpy.QtWidgets import (
+    QApplication,
+    QDialog,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.utils.error_popups import SafeConnect, SafeSlot
+
+
+class StarRating(QWidget):
+    """
+    A star rating widget that allows users to rate from 1 to 5 stars.
+    """
+
+    rating_changed = Signal(int)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._rating = 0
+        self._hovered_star = 0
+        self._star_buttons = []
+
+        # Get theme colors
+        theme = getattr(QApplication.instance(), "theme", None)
+        if theme:
+            SafeConnect(self, theme.theme_changed, self._update_theme_colors)
+        self._update_theme_colors()
+
+        # Enable mouse tracking to handle hover across the entire widget
+        self.setMouseTracking(True)
+
+        layout = QHBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(5)
+
+        for i in range(5):
+            btn = QPushButton("★")
+            btn.setFixedSize(30, 30)
+            btn.setFlat(True)
+            btn.setCursor(Qt.CursorShape.PointingHandCursor)
+            btn.clicked.connect(lambda checked=False, idx=i + 1: self._set_rating(idx))
+            layout.addWidget(btn)
+            self._star_buttons.append(btn)
+
+        self.setLayout(layout)
+        self._update_display()
+
+    @SafeSlot(str)
+    def _update_theme_colors(self, _theme: str | None = None):
+        """Update colors based on theme."""
+        theme = getattr(QApplication.instance(), "theme", None)
+        colors = theme.colors if theme else {}
+
+        self._inactive_color = colors.get("SEPARATOR", QColor(200, 200, 200))
+        self._active_color = colors.get("ACCENT_WARNING", QColor(255, 193, 7))
+
+        # Update display if already initialized
+        if hasattr(self, "_star_buttons") and self._star_buttons:
+            self._update_display()
+
+    def _set_rating(self, rating: int):
+        """Set the rating and emit the signal."""
+        if self._rating != rating:
+            self._rating = rating
+            self.rating_changed.emit(rating)
+            self._update_display()
+
+    def mouseMoveEvent(self, event):
+        """Handle mouse movement to update hovered star."""
+        # Calculate which star is being hovered based on mouse position
+        x_pos = event.pos().x()
+        star_idx = 0
+
+        # Find which star region we're in (including gaps between stars)
+        for i, btn in enumerate(self._star_buttons):
+            btn_geometry = btn.geometry()
+            # If we're to the right of this button's left edge, this is the current star
+            # (including the gap before the next button)
+            if x_pos >= btn_geometry.left():
+                star_idx = i + 1
+            else:
+                break
+
+        if star_idx != self._hovered_star:
+            self._hovered_star = star_idx
+            self._update_display()
+
+        super().mouseMoveEvent(event)
+
+    def leaveEvent(self, event):
+        """Handle mouse leaving the widget."""
+        self._hovered_star = 0
+        self._update_display()
+        super().leaveEvent(event)
+
+    def _update_display(self):
+        """Update the visual display of stars."""
+        display_rating = self._hovered_star if self._hovered_star > 0 else self._rating
+        inactive_color_name = self._inactive_color.name()
+        active_color_name = self._active_color.name()
+
+        for i, btn in enumerate(self._star_buttons):
+            if i < display_rating:
+                btn.setStyleSheet(
+                    f"""
+                    QPushButton {{
+                        border: none;
+                        background: transparent;
+                        font-size: 24px;
+                        color: {active_color_name};
+                    }}
+                """
+                )
+            else:
+                btn.setStyleSheet(
+                    f"""
+                    QPushButton {{
+                        border: none;
+                        background: transparent;
+                        font-size: 24px;
+                        color: {inactive_color_name};
+                    }}
+                    QPushButton:hover {{
+                        color: {active_color_name};
+                    }}
+                """
+                )
+
+    def rating(self) -> int:
+        """Get the current rating."""
+        return self._rating
+
+    def set_rating(self, rating: int):
+        """Set the rating programmatically."""
+        if 0 <= rating <= 5:
+            self._set_rating(rating)
+
+
+class FeedbackDialog(QDialog):
+    """
+    A feedback dialog widget containing a comment field, star rating, and optional email field.
+
+    Signals:
+        feedbackSubmitted: Emitted when feedback is submitted (rating: int, comment: str, email: str)
+    """
+
+    feedback_submitted = Signal(int, str, str)
+    ICON_NAME = "feedback"
+    PLUGIN = True
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Feedback")
+        self.setModal(True)
+        self.setMinimumWidth(400)
+        self.setMinimumHeight(300)
+
+        self._setup_ui()
+
+    def _setup_ui(self):
+        """Set up the user interface."""
+        layout = QVBoxLayout()
+        layout.setSpacing(15)
+
+        # Title
+        title_label = QLabel("We'd love to hear your feedback!")
+        title_font = QFont()
+        title_font.setPointSize(12)
+        title_font.setBold(True)
+        title_label.setFont(title_font)
+        layout.addWidget(title_label)
+
+        # Star rating section
+        rating_layout = QVBoxLayout()
+        rating_label = QLabel("Rating:")
+        rating_layout.addWidget(rating_label)
+
+        self._star_rating = StarRating()
+        rating_layout.addWidget(self._star_rating)
+        layout.addLayout(rating_layout)
+
+        # Comment section
+        comment_label = QLabel("Comments:")
+        layout.addWidget(comment_label)
+
+        self._comment_field = QTextEdit()
+        self._comment_field.setPlaceholderText("Please share your thoughts...")
+        self._comment_field.setMaximumHeight(150)
+        layout.addWidget(self._comment_field)
+
+        # Email section (optional)
+        email_label = QLabel("Email (optional, for follow-up):")
+        layout.addWidget(email_label)
+
+        self._email_field = QLineEdit()
+        self._email_field.setPlaceholderText("your.email@example.com")
+        layout.addWidget(self._email_field)
+
+        # Buttons
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+
+        self._cancel_button = QPushButton("Cancel")
+        self._cancel_button.clicked.connect(self.reject)
+        button_layout.addWidget(self._cancel_button)
+
+        self._submit_button = QPushButton("Submit")
+        self._submit_button.setDefault(True)
+        self._submit_button.clicked.connect(self._on_submit)
+        button_layout.addWidget(self._submit_button)
+
+        layout.addLayout(button_layout)
+
+        self.setLayout(layout)
+
+    def _on_submit(self):
+        """Handle submit button click."""
+        rating = self._star_rating.rating()
+        comment = self._comment_field.toPlainText().strip()
+        email = self._email_field.text().strip()
+
+        # Emit the feedback signal
+        self.feedback_submitted.emit(rating, comment, email)
+
+        # Accept the dialog
+        self.accept()
+
+    def get_feedback(self) -> tuple[int, str, str]:
+        """
+        Get the current feedback values.
+
+        Returns:
+            tuple: (rating, comment, email)
+        """
+        return (
+            self._star_rating.rating(),
+            self._comment_field.toPlainText().strip(),
+            self._email_field.text().strip(),
+        )
+
+    def set_rating(self, rating: int):
+        """Set the star rating."""
+        self._star_rating.set_rating(rating)
+
+    def set_comment(self, comment: str):
+        """Set the comment text."""
+        self._comment_field.setPlainText(comment)
+
+    def set_email(self, email: str):
+        """Set the email text."""
+        self._email_field.setText(email)
+
+    @staticmethod
+    def show_feedback_dialog(parent=None) -> tuple[int, str, str] | None:
+        """
+        Show the feedback dialog and return the feedback if submitted.
+
+        Args:
+            parent: Parent widget
+
+        Returns:
+            tuple: (rating, comment, email) if submitted, None if cancelled
+        """
+        dialog = FeedbackDialog(parent)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            return dialog.get_feedback()
+        return None
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from bec_widgets.utils.colors import apply_theme
+
+    app = QApplication(sys.argv)
+    apply_theme("dark")
+    dialog = FeedbackDialog()
+
+    def on_feedback(rating, comment, email):
+        print(f"Rating: {rating}")
+        print(f"Comment: {comment}")
+        print(f"Email: {email}")
+
+    dialog.feedback_submitted.connect(on_feedback)
+    dialog.exec()
+    sys.exit(app.exec())

docs/user/widgets/image/image_widget.md

@@ -32,7 +32,7 @@ dock_area = gui.new()
 img_widget = dock_area.new().new(gui.available_widgets.Image)
 
 # Add an ImageWidget to the BECFigure for a 2D detector
-img_widget.image(monitor='eiger', monitor_type='2d')
+img_widget.image(device_name='eiger', device_entry='preview')
 img_widget.title = "Camera Image - Eiger Detector"
 ```
 
@@ -46,7 +46,7 @@ dock_area = gui.new()
 img_widget = dock_area.new().new(gui.available_widgets.Image)
 
 # Add an ImageWidget to the BECFigure for a 2D detector
-img_widget.image(monitor='waveform', monitor_type='1d')
+img_widget.image(device_name='waveform', device_entry='data')
 img_widget.title = "Line Detector Data"
 
 # Optional: Set the color map and value range
@@ -84,7 +84,7 @@ The Image Widget can be configured for different detectors by specifying the cor
 
 ```python
 # For a 2D camera detector
-img_widget = fig.image(monitor='eiger', monitor_type='2d')
+img_widget = fig.image(device_name='eiger', device_entry='preview')
 img_widget.set_title("Eiger Camera Image")
 ```
 
@@ -92,7 +92,7 @@ img_widget.set_title("Eiger Camera Image")
 
 ```python
 # For a 1D line detector
-img_widget = fig.image(monitor='waveform', monitor_type='1d')
+img_widget = fig.image(device_name='waveform', device_entry='data')
 img_widget.set_title("Line Detector Data")
 ```
 

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -59,7 +59,7 @@ def test_rpc_add_dock_with_plots_e2e(qtbot, bec_client_lib, connected_client_gui
 
     mm.map("samx", "samy")
     curve = wf.plot(x_name="samx", y_name="bpm4i")
-    im_item = im.image("eiger")
+    im_item = im.image(device_name="eiger", device_entry="preview")
 
     assert curve.__class__.__name__ == "RPCReference"
     assert curve.__class__ == RPCReference
@@ -122,12 +122,12 @@ def test_rpc_gui_obj(connected_client_gui_obj, qtbot):
     assert gui.windows["bec"] is gui.bec
     mw = gui.bec
     assert mw.__class__.__name__ == "RPCReference"
-    assert gui._ipython_registry[mw._gui_id].__class__.__name__ == "AdvancedDockArea"
+    assert gui._ipython_registry[mw._gui_id].__class__.__name__ == "BECDockArea"
 
     xw = gui.new("X")
     xw.delete_all()
     assert xw.__class__.__name__ == "RPCReference"
-    assert gui._ipython_registry[xw._gui_id].__class__.__name__ == "AdvancedDockArea"
+    assert gui._ipython_registry[xw._gui_id].__class__.__name__ == "BECDockArea"
     assert len(gui.windows) == 2
 
     assert gui._gui_is_alive()

tests/end-2-end/test_plotting_framework_e2e.py

@@ -42,7 +42,7 @@ def test_rpc_plotting_shortcuts_init_configs(qtbot, connected_client_gui_obj):
     c3 = wf.plot(y=[1, 2, 3], x=[1, 2, 3])
     assert c3.object_name == "Curve_0"
 
-    im.image(monitor="eiger")
+    im.image(device_name="eiger", device_entry="preview")
     mm.map(x_name="samx", y_name="samy")
     sw.plot(x_name="samx", y_name="samy", z_name="bpm4a")
     mw.plot(monitor="waveform")
@@ -165,14 +165,14 @@ def test_rpc_image(qtbot, bec_client_lib, connected_client_gui_obj):
     scans = client.scans
 
     im = dock_area.new("Image")
-    im.image(monitor="eiger")
+    im.image(device_name="eiger", device_entry="preview")
 
     status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.05, relative=False)
     status.wait()
 
-    last_image_device = client.connector.get_last(MessageEndpoints.device_monitor_2d("eiger"))[
-        "data"
-    ].data
+    last_image_device = client.connector.get_last(
+        MessageEndpoints.device_preview("eiger", "preview")
+    )["data"].data
     last_image_plot = im.main_image.get_data()
 
     # check plotted data

tests/end-2-end/test_rpc_register_e2e.py

@@ -15,7 +15,7 @@ def test_rpc_reference_objects(connected_client_gui_obj):
     plt.plot(x_name="samx", y_name="bpm4i")
 
     im = dock_area.new("Image")
-    im.image("eiger")
+    im.image(device_name="eiger", device_entry="preview")
     motor_map = dock_area.new("MotorMap")
     motor_map.map("samx", "samy")
     plt_z = dock_area.new("Waveform")
@@ -23,7 +23,8 @@ def test_rpc_reference_objects(connected_client_gui_obj):
 
     assert len(plt_z.curves) == 1
     assert len(plt.curves) == 1
-    assert im.monitor == "eiger"
+    assert im.device_name == "eiger"
+    assert im.device_entry == "preview"
 
     assert isinstance(im.main_image, RPCReference)
     image_item = gui._ipython_registry.get(im.main_image._gui_id, None)

tests/end-2-end/user_interaction/test_user_interaction_e2e.py

@@ -16,6 +16,7 @@ from typing import TYPE_CHECKING
 
 import numpy as np
 import pytest
+from bec_lib.endpoints import MessageEndpoints
 
 from bec_widgets.cli.rpc.rpc_base import RPCBase, RPCReference
 
@@ -233,7 +234,7 @@ def test_widgets_e2e_image(qtbot, connected_client_gui_obj, random_generator_fro
     scans = bec.scans
     dev = bec.device_manager.devices
     # Test rpc calls
-    img = widget.image(dev.eiger)
+    img = widget.image(device_name=dev.eiger.name, device_entry="preview")
     assert img.get_data() is None
     # Run a scan and plot the image
     s = scans.line_scan(dev.samx, -3, 3, steps=50, exp_time=0.01, relative=False)
@@ -247,13 +248,13 @@ def test_widgets_e2e_image(qtbot, connected_client_gui_obj, random_generator_fro
     qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
 
     # Check that last image is equivalent to data in Redis
-    last_img = bec.device_monitor.get_data(
-        dev.eiger, count=1
-    )  # Get last image from Redis monitor 2D endpoint
+    last_img = bec.connector.get_last(MessageEndpoints.device_preview("eiger", "preview"))[
+        "data"
+    ].data
     assert np.allclose(img.get_data(), last_img)
 
     # Now add a device with a preview signal
-    img = widget.image(["eiger", "preview"])
+    img = widget.image(device_name="eiger", device_entry="preview")
     s = scans.line_scan(dev.samx, -3, 3, steps=50, exp_time=0.01, relative=False)
     s.wait()
 

tests/unit_tests/test_bec_connector.py

@@ -39,6 +39,18 @@ def test_bec_connector_set_gui_id(bec_connector):
     assert bec_connector.config.gui_id == "test_gui_id"
 
 
+def test_bec_connector_sanitize_names(mocked_client):
+    class MyWidget(BECConnector, QWidget):
+        def __init__(self, parent=None, client=None, **kwargs):
+            super().__init__(parent=parent, client=client, **kwargs)
+
+    widget = MyWidget(client=mocked_client)
+    widget.setObjectName("Test Name With Spaces")
+    assert widget.objectName() == "Test_Name_With_Spaces"
+    widget.setObjectName("Test@Name#With$Special%Characters!")
+    assert widget.objectName() == "Test_Name_With_Special_Characters_"
+
+
 def test_bec_connector_change_config(bec_connector):
     bec_connector.on_config_update({"gui_id": "test_gui_id"})
     assert bec_connector.config.gui_id == "test_gui_id"

tests/unit_tests/test_client_utils.py

@@ -3,13 +3,13 @@ from unittest import mock
 
 import pytest
 
-from bec_widgets.cli.client import AdvancedDockArea
+from bec_widgets.cli.client import BECDockArea
 from bec_widgets.cli.client_utils import BECGuiClient, _start_plot_process
 
 
 @pytest.fixture
 def cli_dock_area():
-    dock_area = AdvancedDockArea(gui_id="test")
+    dock_area = BECDockArea(gui_id="test")
     with mock.patch.object(dock_area, "_run_rpc") as mock_rpc_call:
         with mock.patch.object(dock_area, "_gui_is_alive", return_value=True):
             yield dock_area, mock_rpc_call

tests/unit_tests/test_color_utils.py

@@ -82,6 +82,45 @@ def test_rgba_to_hex():
     assert Colors.rgba_to_hex(255, 87, 51) == "#FF5733FF"
 
 
+def test_canonical_colormap_name_case_insensitive():
+    available = Colors.list_available_colormaps()
+    presets = Colors.list_available_gradient_presets()
+    if not available and not presets:
+        pytest.skip("No colormaps or presets available to test canonical mapping.")
+
+    name = (available or presets)[0]
+    requested = name.swapcase()
+    assert Colors.canonical_colormap_name(requested) == name
+
+
+def test_validate_color_map_returns_canonical_name():
+    available = Colors.list_available_colormaps()
+    presets = Colors.list_available_gradient_presets()
+    if not available and not presets:
+        pytest.skip("No colormaps or presets available to test validation.")
+
+    name = (available or presets)[0]
+    requested = name.swapcase()
+    assert Colors.validate_color_map(requested) == name
+
+
+def test_get_colormap_uses_gradient_preset_fallback(monkeypatch):
+    presets = Colors.list_available_gradient_presets()
+    if not presets:
+        pytest.skip("No gradient presets available to test fallback.")
+
+    preset = presets[0]
+    Colors._get_colormap_cached.cache_clear()
+
+    def _raise(*args, **kwargs):
+        raise Exception("registry unavailable")
+
+    monkeypatch.setattr(pg.colormap, "get", _raise)
+
+    cmap = Colors._get_colormap_cached(preset)
+    assert isinstance(cmap, pg.ColorMap)
+
+
 @pytest.mark.parametrize("num", [10, 100, 400])
 def test_evenly_spaced_colors(num):
     colors_qcolor = Colors.evenly_spaced_colors(colormap="magma", num=num, format="QColor")

tests/unit_tests/test_dock_area.py

@@ -10,17 +10,14 @@ from qtpy.QtCore import QSettings, Qt, QTimer
 from qtpy.QtGui import QPixmap
 from qtpy.QtWidgets import QDialog, QMessageBox, QWidget
 
-import bec_widgets.widgets.containers.advanced_dock_area.basic_dock_area as basic_dock_module
-import bec_widgets.widgets.containers.advanced_dock_area.profile_utils as profile_utils
-from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import (
-    AdvancedDockArea,
-    SaveProfileDialog,
-)
-from bec_widgets.widgets.containers.advanced_dock_area.basic_dock_area import (
+import bec_widgets.widgets.containers.dock_area.basic_dock_area as basic_dock_module
+import bec_widgets.widgets.containers.dock_area.profile_utils as profile_utils
+from bec_widgets.widgets.containers.dock_area.basic_dock_area import (
     DockAreaWidget,
     DockSettingsDialog,
 )
-from bec_widgets.widgets.containers.advanced_dock_area.profile_utils import (
+from bec_widgets.widgets.containers.dock_area.dock_area import BECDockArea, SaveProfileDialog
+from bec_widgets.widgets.containers.dock_area.profile_utils import (
     SETTINGS_KEYS,
     default_profile_path,
     get_profile_info,
@@ -31,20 +28,17 @@ from bec_widgets.widgets.containers.advanced_dock_area.profile_utils import (
     load_user_profile_screenshot,
     open_default_settings,
     open_user_settings,
-    plugin_profiles_dir,
     read_manifest,
     restore_user_from_default,
     set_quick_select,
     user_profile_path,
     write_manifest,
 )
-from bec_widgets.widgets.containers.advanced_dock_area.settings.dialogs import (
+from bec_widgets.widgets.containers.dock_area.settings.dialogs import (
     PreviewPanel,
     RestoreProfileDialog,
 )
-from bec_widgets.widgets.containers.advanced_dock_area.settings.workspace_manager import (
-    WorkSpaceManager,
-)
+from bec_widgets.widgets.containers.dock_area.settings.workspace_manager import WorkSpaceManager
 
 from .client_mocks import mocked_client
 
@@ -52,7 +46,7 @@ from .client_mocks import mocked_client
 @pytest.fixture
 def advanced_dock_area(qtbot, mocked_client):
     """Create an AdvancedDockArea instance for testing."""
-    widget = AdvancedDockArea(client=mocked_client)
+    widget = BECDockArea(client=mocked_client)
     qtbot.addWidget(widget)
     qtbot.waitExposed(widget)
     yield widget
@@ -152,7 +146,7 @@ def workspace_manager_target():
             """Mock delete_profile that performs actual file deletion."""
             from qtpy.QtWidgets import QMessageBox
 
-            from bec_widgets.widgets.containers.advanced_dock_area.profile_utils import (
+            from bec_widgets.widgets.containers.dock_area.profile_utils import (
                 delete_profile_files,
                 is_profile_read_only,
             )
@@ -190,7 +184,7 @@ def basic_dock_area(qtbot, mocked_client):
 class _NamespaceProfiles:
     """Helper that routes profile file helpers through a namespace."""
 
-    def __init__(self, widget: AdvancedDockArea):
+    def __init__(self, widget: BECDockArea):
         self.namespace = widget.profile_namespace
 
     def open_user(self, name: str):
@@ -215,7 +209,7 @@ class _NamespaceProfiles:
         return is_quick_select(name, namespace=self.namespace)
 
 
-def profile_helper(widget: AdvancedDockArea) -> _NamespaceProfiles:
+def profile_helper(widget: BECDockArea) -> _NamespaceProfiles:
     """Return a helper wired to the widget's profile namespace."""
     return _NamespaceProfiles(widget)
 
@@ -590,7 +584,7 @@ class TestAdvancedDockAreaInit:
 
     def test_init(self, advanced_dock_area):
         assert advanced_dock_area is not None
-        assert isinstance(advanced_dock_area, AdvancedDockArea)
+        assert isinstance(advanced_dock_area, BECDockArea)
         assert advanced_dock_area.mode == "creator"
         assert hasattr(advanced_dock_area, "dock_manager")
         assert hasattr(advanced_dock_area, "toolbar")
@@ -598,8 +592,8 @@ class TestAdvancedDockAreaInit:
         assert hasattr(advanced_dock_area, "state_manager")
 
     def test_rpc_and_plugin_flags(self):
-        assert AdvancedDockArea.RPC is True
-        assert AdvancedDockArea.PLUGIN is False
+        assert BECDockArea.RPC is True
+        assert BECDockArea.PLUGIN is False
 
     def test_user_access_list(self):
         expected_methods = [
@@ -611,7 +605,7 @@ class TestAdvancedDockAreaInit:
             "delete_all",
         ]
         for method in expected_methods:
-            assert method in AdvancedDockArea.USER_ACCESS
+            assert method in BECDockArea.USER_ACCESS
 
 
 class TestDockManagement:
@@ -1421,21 +1415,21 @@ class TestAdvancedDockAreaRestoreAndDialogs:
         pix = QPixmap(8, 8)
         pix.fill(Qt.red)
         monkeypatch.setattr(
-            "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.load_user_profile_screenshot",
+            "bec_widgets.widgets.containers.dock_area.dock_area.load_user_profile_screenshot",
             lambda name, namespace=None: pix,
         )
         monkeypatch.setattr(
-            "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.load_default_profile_screenshot",
+            "bec_widgets.widgets.containers.dock_area.dock_area.load_default_profile_screenshot",
             lambda name, namespace=None: pix,
         )
         monkeypatch.setattr(
-            "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.RestoreProfileDialog.confirm",
+            "bec_widgets.widgets.containers.dock_area.dock_area.RestoreProfileDialog.confirm",
             lambda *args, **kwargs: True,
         )
 
         with (
             patch(
-                "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.restore_user_from_default"
+                "bec_widgets.widgets.containers.dock_area.dock_area.restore_user_from_default"
             ) as mock_restore,
             patch.object(advanced_dock_area, "delete_all") as mock_delete_all,
             patch.object(advanced_dock_area, "load_profile") as mock_load_profile,
@@ -1457,20 +1451,20 @@ class TestAdvancedDockAreaRestoreAndDialogs:
         advanced_dock_area._current_profile_name = profile_name
         advanced_dock_area.isVisible = lambda: False
         monkeypatch.setattr(
-            "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.load_user_profile_screenshot",
+            "bec_widgets.widgets.containers.dock_area.dock_area.load_user_profile_screenshot",
             lambda name: QPixmap(),
         )
         monkeypatch.setattr(
-            "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.load_default_profile_screenshot",
+            "bec_widgets.widgets.containers.dock_area.dock_area.load_default_profile_screenshot",
             lambda name: QPixmap(),
         )
         monkeypatch.setattr(
-            "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.RestoreProfileDialog.confirm",
+            "bec_widgets.widgets.containers.dock_area.dock_area.RestoreProfileDialog.confirm",
             lambda *args, **kwargs: False,
         )
 
         with patch(
-            "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.restore_user_from_default"
+            "bec_widgets.widgets.containers.dock_area.dock_area.restore_user_from_default"
         ) as mock_restore:
             advanced_dock_area.restore_user_profile_from_default()
 
@@ -1479,7 +1473,7 @@ class TestAdvancedDockAreaRestoreAndDialogs:
     def test_restore_user_profile_from_default_no_target(self, advanced_dock_area, monkeypatch):
         advanced_dock_area._current_profile_name = None
         with patch(
-            "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.RestoreProfileDialog.confirm"
+            "bec_widgets.widgets.containers.dock_area.dock_area.RestoreProfileDialog.confirm"
         ) as mock_confirm:
             advanced_dock_area.restore_user_profile_from_default()
         mock_confirm.assert_not_called()
@@ -1723,8 +1717,7 @@ class TestWorkspaceProfileOperations:
                 return False
 
         with patch(
-            "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.SaveProfileDialog",
-            StubDialog,
+            "bec_widgets.widgets.containers.dock_area.dock_area.SaveProfileDialog", StubDialog
         ):
             advanced_dock_area.save_profile(profile_name, show_dialog=True)
 
@@ -1795,8 +1788,7 @@ class TestWorkspaceProfileOperations:
                 return False
 
         with patch(
-            "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.SaveProfileDialog",
-            StubDialog,
+            "bec_widgets.widgets.containers.dock_area.dock_area.SaveProfileDialog", StubDialog
         ):
             advanced_dock_area.save_profile(show_dialog=True)
 
@@ -1859,11 +1851,11 @@ class TestWorkspaceProfileOperations:
 
             with (
                 patch(
-                    "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.QMessageBox.question",
+                    "bec_widgets.widgets.containers.dock_area.dock_area.QMessageBox.question",
                     return_value=QMessageBox.Yes,
                 ) as mock_question,
                 patch(
-                    "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.QMessageBox.information",
+                    "bec_widgets.widgets.containers.dock_area.dock_area.QMessageBox.information",
                     return_value=None,
                 ) as mock_info,
             ):
@@ -1893,7 +1885,7 @@ class TestWorkspaceProfileOperations:
             mock_get_action.return_value.widget = mock_combo
 
             with patch(
-                "bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area.QMessageBox.question"
+                "bec_widgets.widgets.containers.dock_area.dock_area.QMessageBox.question"
             ) as mock_question:
                 mock_question.return_value = QMessageBox.Yes
 

tests/unit_tests/test_feedback_dialog.py

@@ -0,0 +1,262 @@
+import pytest
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QDialog
+
+from bec_widgets.utils.colors import apply_theme
+from bec_widgets.widgets.utility.feedback_dialog.feedback_dialog import FeedbackDialog, StarRating
+
+
+@pytest.fixture
+def star_rating(qtbot):
+    """Create a StarRating widget for testing."""
+    widget = StarRating()
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+@pytest.fixture
+def feedback_dialog(qtbot):
+    """Create a FeedbackDialog for testing."""
+    dialog = FeedbackDialog()
+    qtbot.addWidget(dialog)
+    qtbot.waitExposed(dialog)
+    yield dialog
+    dialog.close()
+
+
+class TestStarRating:
+    """Tests for the StarRating widget."""
+
+    def test_initial_state(self, star_rating):
+        """Test that StarRating initializes with rating 0."""
+        assert star_rating.rating() == 0
+        assert star_rating._hovered_star == 0
+        assert len(star_rating._star_buttons) == 5
+
+    def test_set_rating_via_method(self, star_rating):
+        """Test setting rating programmatically."""
+        star_rating.set_rating(3)
+        assert star_rating.rating() == 3
+
+        star_rating.set_rating(5)
+        assert star_rating.rating() == 5
+
+    def test_set_rating_bounds(self, star_rating):
+        """Test that rating is bounded between 0 and 5."""
+        star_rating.set_rating(0)
+        assert star_rating.rating() == 0
+
+        star_rating.set_rating(5)
+        assert star_rating.rating() == 5
+
+        # Out of bounds should not change rating
+        initial_rating = star_rating.rating()
+        star_rating.set_rating(6)
+        assert star_rating.rating() == initial_rating
+
+        star_rating.set_rating(-1)
+        assert star_rating.rating() == initial_rating
+
+    def test_rating_signal_emission(self, star_rating, qtbot):
+        """Test that rating_changed signal is emitted when rating changes."""
+        with qtbot.waitSignal(star_rating.rating_changed, timeout=1000) as blocker:
+            star_rating.set_rating(4)
+
+        assert blocker.args == [4]
+
+    def test_rating_signal_not_emitted_on_same_value(self, star_rating, qtbot):
+        """Test that signal is not emitted when setting the same rating."""
+        star_rating.set_rating(3)
+
+        # Should not emit signal when setting same value
+        with qtbot.assertNotEmitted(star_rating.rating_changed, wait=100):
+            star_rating.set_rating(3)
+
+    def test_click_star_button(self, star_rating, qtbot):
+        """Test clicking on star buttons."""
+        # Click the third star (index 2)
+        with qtbot.waitSignal(star_rating.rating_changed, timeout=1000):
+            qtbot.mouseClick(star_rating._star_buttons[2], Qt.LeftButton)
+
+        assert star_rating.rating() == 3
+
+        # Click the first star
+        with qtbot.waitSignal(star_rating.rating_changed, timeout=1000):
+            qtbot.mouseClick(star_rating._star_buttons[0], Qt.LeftButton)
+
+        assert star_rating.rating() == 1
+
+    def test_mouse_hover(self, star_rating, qtbot):
+        """Test mouse hover behavior."""
+        # Set initial rating
+        star_rating.set_rating(2)
+        assert star_rating._hovered_star == 0
+
+        # Simulate mouse move over the fourth button
+        btn = star_rating._star_buttons[3]
+        btn_center = btn.geometry().center()
+        event = qtbot.mouseMove(star_rating, pos=btn_center)
+
+        # Note: _hovered_star should be updated by mouseMoveEvent
+        # This is a bit tricky to test directly, so we verify the method exists
+        assert hasattr(star_rating, "mouseMoveEvent")
+        assert hasattr(star_rating, "leaveEvent")
+
+    def test_leave_event(self, star_rating, qtbot):
+        """Test that leaving the widget clears hover state."""
+        star_rating.set_rating(2)
+        star_rating._hovered_star = 4  # Simulate hover
+
+        # Trigger leave event
+        star_rating.leaveEvent(None)
+
+        assert star_rating._hovered_star == 0
+        assert star_rating.rating() == 2  # Rating should remain unchanged
+
+    def test_update_theme_colors(self, star_rating):
+        """Test that theme colors are applied correctly."""
+        assert hasattr(star_rating, "_inactive_color")
+        assert hasattr(star_rating, "_active_color")
+
+        # Colors should be initialized
+        assert star_rating._inactive_color is not None
+        assert star_rating._active_color is not None
+
+    def test_display_update(self, star_rating):
+        """Test that display updates when rating changes."""
+        star_rating.set_rating(3)
+        # If this doesn't raise an exception, the display was updated successfully
+        star_rating._update_display()
+
+
+class TestFeedbackDialog:
+    """Tests for the FeedbackDialog widget."""
+
+    def test_initial_state(self, feedback_dialog):
+        """Test that FeedbackDialog initializes correctly."""
+        assert feedback_dialog.windowTitle() == "Feedback"
+        assert feedback_dialog.isModal() is True
+        assert feedback_dialog._star_rating is not None
+        assert feedback_dialog._comment_field is not None
+        assert feedback_dialog._email_field is not None
+        assert feedback_dialog._submit_button is not None
+        assert feedback_dialog._cancel_button is not None
+
+    def test_get_feedback_initial(self, feedback_dialog):
+        """Test getting feedback from unmodified dialog."""
+        rating, comment, email = feedback_dialog.get_feedback()
+        assert rating == 0
+        assert comment == ""
+        assert email == ""
+
+    def test_set_and_get_rating(self, feedback_dialog):
+        """Test setting and getting rating."""
+        feedback_dialog.set_rating(4)
+        rating, _, _ = feedback_dialog.get_feedback()
+        assert rating == 4
+
+    def test_set_and_get_comment(self, feedback_dialog):
+        """Test setting and getting comment."""
+        test_comment = "This is a test comment"
+        feedback_dialog.set_comment(test_comment)
+        _, comment, _ = feedback_dialog.get_feedback()
+        assert comment == test_comment
+
+    def test_set_and_get_email(self, feedback_dialog):
+        """Test setting and getting email."""
+        test_email = "test@example.com"
+        feedback_dialog.set_email(test_email)
+        _, _, email = feedback_dialog.get_feedback()
+        assert email == test_email
+
+    def test_set_all_feedback(self, feedback_dialog):
+        """Test setting all feedback fields."""
+        feedback_dialog.set_rating(5)
+        feedback_dialog.set_comment("Great widget!")
+        feedback_dialog.set_email("user@example.com")
+
+        rating, comment, email = feedback_dialog.get_feedback()
+        assert rating == 5
+        assert comment == "Great widget!"
+        assert email == "user@example.com"
+
+    def test_submit_button_emits_signal(self, feedback_dialog, qtbot):
+        """Test that clicking submit emits feedback_submitted signal."""
+        feedback_dialog.set_rating(3)
+        feedback_dialog.set_comment("Test feedback")
+        feedback_dialog.set_email("test@test.com")
+
+        with qtbot.waitSignal(feedback_dialog.feedback_submitted, timeout=1000) as blocker:
+            qtbot.mouseClick(feedback_dialog._submit_button, Qt.LeftButton)
+
+        assert blocker.args == [3, "Test feedback", "test@test.com"]
+
+    def test_submit_button_accepts_dialog(self, feedback_dialog, qtbot):
+        """Test that clicking submit accepts the dialog."""
+        feedback_dialog.set_rating(4)
+
+        qtbot.mouseClick(feedback_dialog._submit_button, Qt.LeftButton)
+        qtbot.wait(100)
+
+        # Dialog should be accepted
+        assert feedback_dialog.result() == QDialog.DialogCode.Accepted
+
+    def test_cancel_button_rejects_dialog(self, feedback_dialog, qtbot):
+        """Test that clicking cancel rejects the dialog."""
+        qtbot.mouseClick(feedback_dialog._cancel_button, Qt.LeftButton)
+        qtbot.wait(100)
+
+        # Dialog should be rejected
+        assert feedback_dialog.result() == QDialog.DialogCode.Rejected
+
+    def test_submit_with_empty_fields(self, feedback_dialog, qtbot):
+        """Test submitting with empty fields."""
+        # Don't set any values
+        with qtbot.waitSignal(feedback_dialog.feedback_submitted, timeout=1000) as blocker:
+            qtbot.mouseClick(feedback_dialog._submit_button, Qt.LeftButton)
+
+        # Should emit with empty values
+        assert blocker.args == [0, "", ""]
+
+    def test_submit_strips_whitespace(self, feedback_dialog, qtbot):
+        """Test that whitespace is stripped from comment and email."""
+        feedback_dialog.set_comment("  Test comment  ")
+        feedback_dialog.set_email("  test@example.com  ")
+
+        with qtbot.waitSignal(feedback_dialog.feedback_submitted, timeout=1000) as blocker:
+            qtbot.mouseClick(feedback_dialog._submit_button, Qt.LeftButton)
+
+        rating, comment, email = blocker.args
+        assert comment == "Test comment"
+        assert email == "test@example.com"
+
+    def test_dialog_has_correct_properties(self, feedback_dialog):
+        """Test that dialog has correct class properties."""
+        assert hasattr(FeedbackDialog, "ICON_NAME")
+        assert FeedbackDialog.ICON_NAME == "feedback"
+        assert hasattr(FeedbackDialog, "PLUGIN")
+        assert FeedbackDialog.PLUGIN is True
+
+    def test_comment_field_placeholder(self, feedback_dialog):
+        """Test that comment field has placeholder text."""
+        assert feedback_dialog._comment_field.placeholderText() != ""
+
+    def test_email_field_placeholder(self, feedback_dialog):
+        """Test that email field has placeholder text."""
+        assert feedback_dialog._email_field.placeholderText() != ""
+
+    def test_submit_button_is_default(self, feedback_dialog):
+        """Test that submit button is set as default."""
+        assert feedback_dialog._submit_button.isDefault() is True
+
+    def test_star_rating_embedded_correctly(self, feedback_dialog, qtbot):
+        """Test that StarRating widget is properly embedded."""
+        # Verify we can interact with the embedded star rating
+        feedback_dialog._star_rating.set_rating(5)
+        assert feedback_dialog._star_rating.rating() == 5
+
+        # Verify rating is reflected in feedback
+        rating, _, _ = feedback_dialog.get_feedback()
+        assert rating == 5

tests/unit_tests/test_image_layer.py

@@ -4,7 +4,6 @@ import pyqtgraph as pg
 import pytest
 
 from bec_widgets.widgets.plots.image.image_base import ImageLayerManager
-from bec_widgets.widgets.plots.image.image_item import ImageItem
 
 
 @pytest.fixture()

tests/unit_tests/test_image_view_next_gen.py

@@ -1,6 +1,7 @@
 import numpy as np
 import pyqtgraph as pg
 import pytest
+from bec_lib.endpoints import MessageEndpoints
 from qtpy.QtCore import QPointF
 
 from bec_widgets.widgets.plots.image.image import Image
@@ -12,6 +13,23 @@ from tests.unit_tests.conftest import create_widget
 ##################################################
 
 
+def _set_signal_config(
+    client,
+    device_name: str,
+    signal_name: str,
+    signal_class: str,
+    ndim: int,
+    obj_name: str | None = None,
+):
+    device = client.device_manager.devices[device_name]
+    device._info["signals"][signal_name] = {
+        "obj_name": obj_name or signal_name,
+        "signal_class": signal_class,
+        "component_name": signal_name,
+        "describe": {"signal_info": {"ndim": ndim}},
+    }
+
+
 def test_initialization_defaults(qtbot, mocked_client):
     bec_image_view = create_widget(qtbot, Image, client=mocked_client)
     assert bec_image_view.color_map == "plasma"
@@ -114,32 +132,35 @@ def test_enable_colorbar_with_vrange(qtbot, mocked_client, colorbar_type):
 
 
 ##############################################
-# Preview‑signal update mechanism
+# Device/signal update mechanism
 
 
-def test_image_setup_preview_signal_1d(qtbot, mocked_client, monkeypatch):
+def test_image_setup_preview_signal_1d(qtbot, mocked_client):
     """
-    Ensure that calling .image() with a (device, signal, config) tuple representing
-    a 1‑D PreviewSignal connects using the 1‑D path and updates correctly.
+    Ensure that calling .image() with a 1‑D PreviewSignal connects using the 1‑D path
+    and updates correctly.
     """
     import numpy as np
 
     view = create_widget(qtbot, Image, client=mocked_client)
 
-    signal_config = {
-        "obj_name": "waveform1d_img",
-        "signal_class": "PreviewSignal",
-        "describe": {"signal_info": {"ndim": 1}},
-    }
+    _set_signal_config(
+        mocked_client,
+        "waveform1d",
+        "img",
+        signal_class="PreviewSignal",
+        ndim=1,
+        obj_name="waveform1d_img",
+    )
 
-    # Set the image monitor to the preview signal
-    view.image(monitor=("waveform1d", "img", signal_config))
+    view.image(device_name="waveform1d", device_entry="img")
 
     # Subscriptions should indicate 1‑D preview connection
     sub = view.subscriptions["main"]
     assert sub.source == "device_monitor_1d"
     assert sub.monitor_type == "1d"
-    assert sub.monitor == ("waveform1d", "img", signal_config)
+    assert view.device_name == "waveform1d"
+    assert view.device_entry == "img"
 
     # Simulate a waveform update from the dispatcher
     waveform = np.arange(25, dtype=float)
@@ -148,29 +169,32 @@ def test_image_setup_preview_signal_1d(qtbot, mocked_client, monkeypatch):
     np.testing.assert_array_equal(view.main_image.raw_data[0], waveform)
 
 
-def test_image_setup_preview_signal_2d(qtbot, mocked_client, monkeypatch):
+def test_image_setup_preview_signal_2d(qtbot, mocked_client):
     """
-    Ensure that calling .image() with a (device, signal, config) tuple representing
-    a 2‑D PreviewSignal connects using the 2‑D path and updates correctly.
+    Ensure that calling .image() with a 2‑D PreviewSignal connects using the 2‑D path
+    and updates correctly.
     """
     import numpy as np
 
     view = create_widget(qtbot, Image, client=mocked_client)
 
-    signal_config = {
-        "obj_name": "eiger_img2d",
-        "signal_class": "PreviewSignal",
-        "describe": {"signal_info": {"ndim": 2}},
-    }
+    _set_signal_config(
+        mocked_client,
+        "eiger",
+        "img2d",
+        signal_class="PreviewSignal",
+        ndim=2,
+        obj_name="eiger_img2d",
+    )
 
-    # Set the image monitor to the preview signal
-    view.image(monitor=("eiger", "img2d", signal_config))
+    view.image(device_name="eiger", device_entry="img2d")
 
     # Subscriptions should indicate 2‑D preview connection
     sub = view.subscriptions["main"]
     assert sub.source == "device_monitor_2d"
     assert sub.monitor_type == "2d"
-    assert sub.monitor == ("eiger", "img2d", signal_config)
+    assert view.device_name == "eiger"
+    assert view.device_entry == "img2d"
 
     # Simulate a 2‑D image update
     test_data = np.arange(16, dtype=float).reshape(4, 4)
@@ -178,38 +202,197 @@ def test_image_setup_preview_signal_2d(qtbot, mocked_client, monkeypatch):
     np.testing.assert_array_equal(view.main_image.image, test_data)
 
 
+def test_preview_signals_skip_0d_entries(qtbot, mocked_client, monkeypatch):
+    """
+    Preview/async combobox should omit 0‑D signals.
+    """
+    view = create_widget(qtbot, Image, client=mocked_client)
+
+    def fake_get(signal_class_filter):
+        signal_classes = (
+            signal_class_filter
+            if isinstance(signal_class_filter, (list, tuple, set))
+            else [signal_class_filter]
+        )
+        if "PreviewSignal" in signal_classes:
+            return [
+                (
+                    "eiger",
+                    "sig0d",
+                    {
+                        "obj_name": "sig0d",
+                        "signal_class": "PreviewSignal",
+                        "describe": {"signal_info": {"ndim": 0}},
+                    },
+                ),
+                (
+                    "eiger",
+                    "sig2d",
+                    {
+                        "obj_name": "sig2d",
+                        "signal_class": "PreviewSignal",
+                        "describe": {"signal_info": {"ndim": 2}},
+                    },
+                ),
+            ]
+        return []
+
+    monkeypatch.setattr(view.client.device_manager, "get_bec_signals", fake_get)
+    device_selection = view.toolbar.components.get_action("device_selection").widget
+    device_selection.signal_combo_box.set_device("eiger")
+    device_selection.signal_combo_box.update_signals_from_signal_classes()
+
+    texts = [
+        device_selection.signal_combo_box.itemText(i)
+        for i in range(device_selection.signal_combo_box.count())
+    ]
+    assert "sig0d" not in texts
+    assert "sig2d" in texts
+
+
+def test_image_async_signal_uses_obj_name(qtbot, mocked_client, monkeypatch):
+    """
+    Verify async signals use obj_name for endpoints/payloads and reconnect with scan_id.
+    """
+    view = create_widget(qtbot, Image, client=mocked_client)
+    _set_signal_config(
+        mocked_client, "eiger", "img", signal_class="AsyncSignal", ndim=1, obj_name="async_obj"
+    )
+
+    view.image(device_name="eiger", device_entry="img")
+    assert view.subscriptions["main"].async_signal_name == "async_obj"
+    assert view.async_update is True
+
+    # Prepare scan ids and capture dispatcher calls
+    view.old_scan_id = "old_scan"
+    view.scan_id = "new_scan"
+    connected = []
+    disconnected = []
+    monkeypatch.setattr(
+        view.bec_dispatcher,
+        "connect_slot",
+        lambda slot, endpoint, from_start=False, cb_info=None: connected.append(
+            (slot, endpoint, from_start, cb_info)
+        ),
+    )
+    monkeypatch.setattr(
+        view.bec_dispatcher,
+        "disconnect_slot",
+        lambda slot, endpoint: disconnected.append((slot, endpoint)),
+    )
+
+    view._setup_async_image(view.scan_id)
+
+    expected_new = MessageEndpoints.device_async_signal("new_scan", "eiger", "async_obj")
+    expected_old = MessageEndpoints.device_async_signal("old_scan", "eiger", "async_obj")
+    assert any(ep == expected_new for _, ep, _, _ in connected)
+    assert any(ep == expected_old for _, ep in disconnected)
+
+    # Payload extraction should use obj_name
+    payload = np.array([1, 2, 3])
+    msg = {"signals": {"async_obj": {"value": payload}}}
+    assert np.array_equal(view._get_payload_data(msg), payload)
+
+
+def test_disconnect_clears_async_state(qtbot, mocked_client, monkeypatch):
+    view = create_widget(qtbot, Image, client=mocked_client)
+    _set_signal_config(
+        mocked_client, "eiger", "img", signal_class="AsyncSignal", ndim=2, obj_name="async_obj"
+    )
+
+    view.image(device_name="eiger", device_entry="img")
+    view.scan_id = "scan_x"
+    view.old_scan_id = "scan_y"
+    view.subscriptions["main"].async_signal_name = "async_obj"
+
+    # Avoid touching real dispatcher
+    monkeypatch.setattr(view.bec_dispatcher, "disconnect_slot", lambda *args, **kwargs: None)
+
+    view.disconnect_monitor(device_name="eiger", device_entry="img")
+
+    assert view.subscriptions["main"].async_signal_name is None
+    assert view.async_update is False
+
+
 ##############################################
-# Device monitor endpoint update mechanism
+# Connection guardrails
 
 
-def test_image_setup_image_2d(qtbot, mocked_client):
-    bec_image_view = create_widget(qtbot, Image, client=mocked_client)
-    bec_image_view.image(monitor="eiger", monitor_type="2d")
-    assert bec_image_view.monitor == "eiger"
-    assert bec_image_view.subscriptions["main"].source == "device_monitor_2d"
-    assert bec_image_view.subscriptions["main"].monitor_type == "2d"
-    assert bec_image_view.main_image.raw_data is None
-    assert bec_image_view.main_image.image is None
+def test_image_setup_rejects_unsupported_signal_class(qtbot, mocked_client):
+    view = create_widget(qtbot, Image, client=mocked_client)
+    _set_signal_config(mocked_client, "eiger", "img", signal_class="Signal", ndim=2)
+
+    view.image(device_name="eiger", device_entry="img")
+
+    assert view.subscriptions["main"].source is None
+    assert view.subscriptions["main"].monitor_type is None
+    assert view.async_update is False
 
 
-def test_image_setup_image_1d(qtbot, mocked_client):
-    bec_image_view = create_widget(qtbot, Image, client=mocked_client)
-    bec_image_view.image(monitor="eiger", monitor_type="1d")
-    assert bec_image_view.monitor == "eiger"
-    assert bec_image_view.subscriptions["main"].source == "device_monitor_1d"
-    assert bec_image_view.subscriptions["main"].monitor_type == "1d"
-    assert bec_image_view.main_image.raw_data is None
-    assert bec_image_view.main_image.image is None
+def test_image_disconnects_with_missing_entry(qtbot, mocked_client):
+    view = create_widget(qtbot, Image, client=mocked_client)
+    _set_signal_config(mocked_client, "eiger", "img", signal_class="PreviewSignal", ndim=2)
+
+    view.image(device_name="eiger", device_entry="img")
+    assert view.device_name == "eiger"
+    assert view.device_entry == "img"
+
+    view.image(device_name="eiger", device_entry=None)
+    assert view.device_name == ""
+    assert view.device_entry == ""
 
 
-def test_image_setup_image_auto(qtbot, mocked_client):
-    bec_image_view = create_widget(qtbot, Image, client=mocked_client)
-    bec_image_view.image(monitor="eiger", monitor_type="auto")
-    assert bec_image_view.monitor == "eiger"
-    assert bec_image_view.subscriptions["main"].source == "auto"
-    assert bec_image_view.subscriptions["main"].monitor_type == "auto"
-    assert bec_image_view.main_image.raw_data is None
-    assert bec_image_view.main_image.image is None
+def test_handle_scan_change_clears_buffers_and_resets_crosshair(qtbot, mocked_client, monkeypatch):
+    view = create_widget(qtbot, Image, client=mocked_client)
+    view.scan_id = "scan_1"
+    view.main_image.buffer = [np.array([1.0, 2.0])]
+    view.main_image.max_len = 2
+
+    clear_called = []
+    monkeypatch.setattr(view.main_image, "clear", lambda: clear_called.append(True))
+    reset_called = []
+    if view.crosshair is not None:
+        monkeypatch.setattr(view.crosshair, "reset", lambda: reset_called.append(True))
+
+    view._handle_scan_change("scan_2")
+
+    assert view.old_scan_id == "scan_1"
+    assert view.scan_id == "scan_2"
+    assert clear_called == [True]
+    assert view.main_image.buffer == []
+    assert view.main_image.max_len == 0
+    if view.crosshair is not None:
+        assert reset_called == [True]
+
+
+def test_handle_scan_change_reconnects_async(qtbot, mocked_client, monkeypatch):
+    view = create_widget(qtbot, Image, client=mocked_client)
+    view.scan_id = "scan_1"
+    view.async_update = True
+
+    called = []
+    monkeypatch.setattr(view, "_setup_async_image", lambda scan_id: called.append(scan_id))
+
+    view._handle_scan_change("scan_2")
+
+    assert called == ["scan_2"]
+
+
+def test_handle_scan_change_same_scan_noop(qtbot, mocked_client, monkeypatch):
+    view = create_widget(qtbot, Image, client=mocked_client)
+    view.scan_id = "scan_1"
+    view.main_image.buffer = [np.array([1.0])]
+    view.main_image.max_len = 1
+
+    clear_called = []
+    monkeypatch.setattr(view.main_image, "clear", lambda: clear_called.append(True))
+
+    view._handle_scan_change("scan_1")
+
+    assert view.scan_id == "scan_1"
+    assert clear_called == []
+    assert view.main_image.buffer == [np.array([1.0])]
+    assert view.main_image.max_len == 1
 
 
 def test_image_data_update_2d(qtbot, mocked_client):
@@ -245,8 +428,7 @@ def test_toolbar_actions_presence(qtbot, mocked_client):
     assert bec_image_view.toolbar.components.exists("image_autorange")
     assert bec_image_view.toolbar.components.exists("lock_aspect_ratio")
     assert bec_image_view.toolbar.components.exists("image_processing_fft")
-    assert bec_image_view.toolbar.components.exists("image_device_combo")
-    assert bec_image_view.toolbar.components.exists("image_dim_combo")
+    assert bec_image_view.toolbar.components.exists("device_selection")
 
 
 def test_auto_emit_syncs_image_toolbar_actions(qtbot, mocked_client):
@@ -327,13 +509,40 @@ def test_setting_vrange_with_colorbar(qtbot, mocked_client, colorbar_type):
 ###################################
 
 
-def test_setup_image_from_toolbar(qtbot, mocked_client):
+def test_setup_image_from_toolbar(qtbot, mocked_client, monkeypatch):
     bec_image_view = create_widget(qtbot, Image, client=mocked_client)
 
-    bec_image_view.device_combo_box.setCurrentText("eiger")
-    bec_image_view.dim_combo_box.setCurrentText("2d")
+    _set_signal_config(mocked_client, "eiger", "img", signal_class="PreviewSignal", ndim=2)
+    monkeypatch.setattr(
+        mocked_client.device_manager,
+        "get_bec_signals",
+        lambda signal_class_filter: (
+            [
+                (
+                    "eiger",
+                    "img",
+                    {
+                        "obj_name": "img",
+                        "signal_class": "PreviewSignal",
+                        "describe": {"signal_info": {"ndim": 2}},
+                    },
+                )
+            ]
+            if "PreviewSignal" in (signal_class_filter or [])
+            else []
+        ),
+    )
 
-    assert bec_image_view.monitor == "eiger"
+    device_selection = bec_image_view.toolbar.components.get_action("device_selection").widget
+    device_selection.device_combo_box.update_devices_from_filters()
+    device_selection.device_combo_box.setCurrentText("eiger")
+    device_selection.signal_combo_box.setCurrentText("img")
+
+    bec_image_view.on_device_selection_changed(None)
+    qtbot.wait(200)
+
+    assert bec_image_view.device_name == "eiger"
+    assert bec_image_view.device_entry == "img"
     assert bec_image_view.subscriptions["main"].source == "device_monitor_2d"
     assert bec_image_view.subscriptions["main"].monitor_type == "2d"
     assert bec_image_view.main_image.raw_data is None
@@ -598,90 +807,59 @@ def test_roi_plot_data_from_image(qtbot, mocked_client):
 
 
 ##############################################
-# MonitorSelectionToolbarBundle specific tests
+# Device selection toolbar sync
 ##############################################
 
 
-def test_monitor_selection_reverse_device_items(qtbot, mocked_client):
-    """
-    Verify that _reverse_device_items correctly reverses the order of items in the
-    device combobox while preserving the current selection.
-    """
+def test_device_selection_syncs_from_properties(qtbot, mocked_client, monkeypatch):
     view = create_widget(qtbot, Image, client=mocked_client)
-    combo = view.device_combo_box
-
-    # Replace existing items with a deterministic list
-    combo.clear()
-    combo.addItem("samx", 1)
-    combo.addItem("samy", 2)
-    combo.addItem("samz", 3)
-    combo.setCurrentText("samy")
-
-    # Reverse the items
-    view._reverse_device_items()
-
-    # Order should be reversed and selection preserved
-    assert [combo.itemText(i) for i in range(combo.count())] == ["samz", "samy", "samx"]
-    assert combo.currentText() == "samy"
-
-
-def test_monitor_selection_populate_preview_signals(qtbot, mocked_client, monkeypatch):
-    """
-    Verify that _populate_preview_signals adds preview‑signal devices to the combo‑box
-    with the correct userData.
-    """
-    view = create_widget(qtbot, Image, client=mocked_client)
-
-    # Provide a deterministic fake device_manager with get_bec_signals
-    class _FakeDM:
-        def get_bec_signals(self, _filter):
-            return [
-                ("eiger", "img", {"obj_name": "eiger_img"}),
-                ("async_device", "img2", {"obj_name": "async_device_img2"}),
+    _set_signal_config(mocked_client, "eiger", "img2d", signal_class="PreviewSignal", ndim=2)
+    monkeypatch.setattr(
+        view.client.device_manager,
+        "get_bec_signals",
+        lambda signal_class_filter: (
+            [
+                (
+                    "eiger",
+                    "img2d",
+                    {
+                        "obj_name": "img2d",
+                        "signal_class": "PreviewSignal",
+                        "describe": {"signal_info": {"ndim": 2}},
+                    },
+                )
             ]
+            if "PreviewSignal" in (signal_class_filter or [])
+            else []
+        ),
+    )
 
-    monkeypatch.setattr(view.client, "device_manager", _FakeDM())
+    view.device_name = "eiger"
+    view.device_entry = "img2d"
 
-    initial_count = view.device_combo_box.count()
+    qtbot.wait(200)  # Allow signal processing
 
-    view._populate_preview_signals()
-
-    # Two new entries should have been added
-    assert view.device_combo_box.count() == initial_count + 2
-
-    # The first newly added item should carry tuple userData describing the device/signal
-    data = view.device_combo_box.itemData(initial_count)
-    assert isinstance(data, tuple) and data[0] == "eiger"
+    device_selection = view.toolbar.components.get_action("device_selection").widget
+    qtbot.waitUntil(
+        lambda: device_selection.device_combo_box.currentText() == "eiger"
+        and device_selection.signal_combo_box.currentText() == "img2d",
+        timeout=1000,
+    )
 
 
-def test_monitor_selection_adjust_and_connect(qtbot, mocked_client, monkeypatch):
-    """
-    Verify that _adjust_and_connect performs the full set-up:
-    - fills the combobox with preview signals,
-    - reverses their order,
-    - and resets the currentText to an empty string.
-    """
+def test_device_entry_syncs_from_toolbar(qtbot, mocked_client):
     view = create_widget(qtbot, Image, client=mocked_client)
+    _set_signal_config(mocked_client, "eiger", "img_a", signal_class="PreviewSignal", ndim=2)
+    _set_signal_config(mocked_client, "eiger", "img_b", signal_class="PreviewSignal", ndim=2)
 
-    # Deterministic fake device_manager
-    class _FakeDM:
-        def get_bec_signals(self, _filter):
-            return [("eiger", "img", {"obj_name": "eiger_img"})]
+    view.device_name = "eiger"
+    view.device_entry = "img_a"
 
-    monkeypatch.setattr(view.client, "device_manager", _FakeDM())
+    device_selection = view.toolbar.components.get_action("device_selection").widget
+    device_selection.signal_combo_box.blockSignals(True)
+    device_selection.signal_combo_box.setCurrentText("img_b")
+    device_selection.signal_combo_box.blockSignals(False)
 
-    combo = view.device_combo_box
-    # Start from a clean state
-    combo.clear()
-    combo.addItem("", None)
-    combo.setCurrentText("")
+    view._sync_device_entry_from_toolbar()
 
-    # Execute the method under test
-    view._adjust_and_connect()
-
-    # Expect exactly two items: preview label followed by the empty default
-    assert combo.count() == 2
-    # Because of the reversal, the preview label comes first
-    assert combo.itemText(0) == "eiger_img"
-    # Current selection remains empty
-    assert combo.currentText() == ""
+    assert view.device_entry == "img_b"

tests/unit_tests/test_rpc_widget_handler.py

@@ -9,7 +9,7 @@ def test_rpc_widget_handler():
     handler = RPCWidgetHandler()
     assert "Image" in handler.widget_classes
     assert "RingProgressBar" in handler.widget_classes
-    assert "AdvancedDockArea" in handler.widget_classes
+    assert "BECDockArea" in handler.widget_classes
 
 
 class _TestPluginWidget(BECWidget): ...

tests/unit_tests/test_screen_utils.py

@@ -0,0 +1,38 @@
+from qtpy.QtCore import QRect
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils.screen_utils import (
+    apply_centered_size,
+    centered_geometry,
+    main_app_size_for_screen,
+)
+
+
+def test_centered_geometry_returns_expected_tuple():
+    available = QRect(100, 50, 800, 600)
+    result = centered_geometry(available, 400, 300)
+    assert result == (300, 200, 400, 300)
+
+
+def test_main_app_size_for_screen_respects_16_9_and_screen_caps():
+    available = QRect(0, 0, 1920, 1080)
+    width, height = main_app_size_for_screen(available)
+    assert (width, height) == (1728, 972)
+
+    narrow = QRect(0, 0, 1000, 800)
+    width, height = main_app_size_for_screen(narrow)
+    assert (width, height) == (900, 506)
+
+
+def test_apply_centered_size_uses_provided_geometry(qtbot):
+    widget = QWidget()
+    qtbot.addWidget(widget)
+
+    available = QRect(10, 20, 600, 400)
+    apply_centered_size(widget, 200, 100, available=available)
+
+    geometry = widget.geometry()
+    assert geometry.x() == 210
+    assert geometry.y() == 170
+    assert geometry.width() == 200
+    assert geometry.height() == 100

tests/unit_tests/test_utils_bec_login.py

@@ -0,0 +1,52 @@
+"""Test the BEC Login widget"""
+
+import pytest
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QLineEdit
+
+from bec_widgets.utils.bec_login import BECLogin
+
+
+@pytest.fixture
+def login_dialog(qtbot):
+    """Fixture to create a BECLogin instance."""
+    dialog = BECLogin()
+    qtbot.addWidget(dialog)
+    qtbot.waitExposed(dialog)  # Ensure the dialog is fully shown before running tests
+    return dialog
+
+
+def test_utils_login_dialog_initialization(login_dialog, qtbot):
+    """Test that the BECLogin initializes correctly."""
+    assert login_dialog.windowTitle() == "Login"
+    assert login_dialog.username.placeholderText() == "Username"
+    assert login_dialog.password.placeholderText() == "Password"
+    assert login_dialog.password.echoMode() == QLineEdit.EchoMode.Password
+    assert login_dialog.ok_btn.text() == "Sign in"
+
+    # Initially, this should be empty
+    with qtbot.waitSignal(login_dialog.credentials_entered, timeout=5000) as blocker:
+        qtbot.mouseClick(login_dialog.ok_btn, Qt.MouseButton.LeftButton)
+    assert blocker.args == ["", ""]
+
+
+def test_utils_login_dialog_emit_credentials(login_dialog, qtbot):
+    """Test that the BECLogin emits credentials correctly."""
+    test_username = "testuser "
+    test_password = "testpass"
+
+    login_dialog.username.setText(test_username)
+    login_dialog.password.setText(test_password)
+
+    with qtbot.waitSignal(login_dialog.credentials_entered, timeout=5000) as blocker:
+        qtbot.mouseClick(login_dialog.ok_btn, Qt.MouseButton.LeftButton)
+
+    assert blocker.args == [test_username.strip(), test_password]
+    assert login_dialog.password.text() == ""  # Password should be cleared after emitting
+
+    login_dialog.password.setText(test_password)
+    with qtbot.waitSignal(login_dialog.credentials_entered, timeout=5000) as blocker:
+        qtbot.keyClick(login_dialog.password, Qt.Key.Key_Return)
+
+    assert blocker.args == [test_username.strip(), test_password]
+    assert login_dialog.password.text() == ""  # Password should be cleared after emitting

tests/unit_tests/test_vscode_widget.py

@@ -1,91 +0,0 @@
-import os
-import shlex
-import subprocess
-from unittest import mock
-
-import pytest
-
-from bec_widgets.widgets.editors.vscode.vscode import VSCodeEditor
-
-from .client_mocks import mocked_client
-
-
-@pytest.fixture
-def vscode_widget(qtbot, mocked_client):
-    with mock.patch("bec_widgets.widgets.editors.vscode.vscode.subprocess.Popen") as mock_popen:
-        widget = VSCodeEditor(client=mocked_client)
-        qtbot.addWidget(widget)
-        qtbot.waitExposed(widget)
-        yield widget
-
-
-def test_vscode_widget(qtbot, vscode_widget):
-    assert vscode_widget.process is not None
-    assert vscode_widget._url == f"http://127.0.0.1:{vscode_widget.port}?tkn=bec"
-
-
-def test_start_server(qtbot, mocked_client):
-    with mock.patch("bec_widgets.widgets.editors.vscode.vscode.os.killpg") as mock_killpg:
-        with mock.patch("bec_widgets.widgets.editors.vscode.vscode.os.getpgid") as mock_getpgid:
-            with mock.patch(
-                "bec_widgets.widgets.editors.vscode.vscode.subprocess.Popen"
-            ) as mock_popen:
-                with mock.patch(
-                    "bec_widgets.widgets.editors.vscode.vscode.select.select"
-                ) as mock_select:
-                    with mock.patch(
-                        "bec_widgets.widgets.editors.vscode.vscode.get_free_port"
-                    ) as mock_get_free_port:
-                        mock_get_free_port.return_value = 12345
-                        mock_process = mock.Mock()
-                        mock_process.stdout.fileno.return_value = 1
-                        mock_process.poll.return_value = None
-                        mock_process.stdout.read.return_value = f"available at http://{VSCodeEditor.host}:{12345}?tkn={VSCodeEditor.token}"
-                        mock_popen.return_value = mock_process
-                        mock_select.return_value = [[mock_process.stdout], [], []]
-
-                        widget = VSCodeEditor(client=mocked_client)
-                        widget.close()
-                        widget.deleteLater()
-
-                    assert (
-                        mock.call(
-                            shlex.split(
-                                f"code serve-web --port {widget.port} --connection-token={widget.token} --accept-server-license-terms"
-                            ),
-                            text=True,
-                            stdout=subprocess.PIPE,
-                            stderr=subprocess.DEVNULL,
-                            preexec_fn=os.setsid,
-                            env=mock.ANY,
-                        )
-                        in mock_popen.mock_calls
-                    )
-
-
-@pytest.fixture
-def patched_vscode_process(qtbot, vscode_widget):
-    with mock.patch("bec_widgets.widgets.editors.vscode.vscode.os.killpg") as mock_killpg:
-        mock_killpg.reset_mock()
-        with mock.patch("bec_widgets.widgets.editors.vscode.vscode.os.getpgid") as mock_getpgid:
-            mock_getpgid.return_value = 123
-            vscode_widget.process = mock.Mock()
-            yield vscode_widget, mock_killpg
-
-
-def test_vscode_cleanup(qtbot, patched_vscode_process):
-    vscode_patched, mock_killpg = patched_vscode_process
-    vscode_patched.process.pid = 123
-    vscode_patched.process.poll.return_value = None
-    vscode_patched.cleanup_vscode()
-    mock_killpg.assert_called_once_with(123, 15)
-    vscode_patched.process.wait.assert_called_once()
-
-
-def test_close_event_on_terminated_code(qtbot, patched_vscode_process):
-    vscode_patched, mock_killpg = patched_vscode_process
-    vscode_patched.process.pid = 123
-    vscode_patched.process.poll.return_value = 0
-    vscode_patched.cleanup_vscode()
-    mock_killpg.assert_not_called()
-    vscode_patched.process.wait.assert_not_called()