WIP double check sibling logic

bec_widgets/applications/bw_launch.py

@@ -0,0 +1,6 @@
+from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
+
+
+def dock_area(name: str | None = None):
+    _dock_area = BECDockArea(name=name)
+    return _dock_area

bec_widgets/applications/launch_dialog.ui

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+    <class>Form</class>
+    <widget class="QWidget" name="Form">
+        <property name="geometry">
+            <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>400</width>
+                <height>300</height>
+            </rect>
+        </property>
+        <property name="windowTitle">
+            <string>Form</string>
+        </property>
+        <layout class="QGridLayout" name="gridLayout">
+            <item row="0" column="0">
+                <widget class="QPushButton" name="open_dock_area">
+                    <property name="text">
+                        <string>PushButton</string>
+                    </property>
+                </widget>
+            </item>
+            <item row="0" column="1">
+                <widget class="QPushButton" name="pushButton_2">
+                    <property name="text">
+                        <string>PushButton</string>
+                    </property>
+                </widget>
+            </item>
+        </layout>
+    </widget>
+    <resources/>
+    <connections/>
+</ui>

bec_widgets/applications/launch_window.py

@@ -0,0 +1,93 @@
+import os
+
+from qtpy.QtWidgets import QSizePolicy
+
+import bec_widgets
+from bec_lib.logger import bec_logger
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.container_utils import WidgetContainerUtils
+from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
+
+logger = bec_logger.logger
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+
+
+class LaunchWindow(BECMainWindow):
+    def __init__(self, gui_id: str = None, *args, **kwargs):
+        BECMainWindow.__init__(self, gui_id=gui_id, window_title="BEC Launcher", *args, **kwargs)
+
+        self.setObjectName("LaunchWindow")
+
+        self.resize(500, 300)
+        self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+        self.loader = UILoader(self)
+        self._init_ui()
+
+    def _init_ui(self):
+        super()._init_ui()
+        # Load ui file
+        ui_file_path = os.path.join(MODULE_PATH, "applications/launch_dialog.ui")
+        self.load_ui(ui_file_path)
+
+    def load_ui(self, ui_file):
+        self.ui = self.loader.loader(ui_file)
+        self.setCentralWidget(self.ui)
+        self.ui.open_dock_area.setText("Open Dock Area")
+        self.ui.open_dock_area.clicked.connect(lambda: self.launch("dock_area"))
+
+    def launch(
+        self,
+        launch_script: str,
+        name: str | None = None,
+        geometry: tuple[int, int, int, int] | None = None,
+    ) -> "BECDockArea":
+        """Create a new dock area.
+
+        Args:
+            name(str): The name of the dock area.
+            geometry(tuple): The geometry parameters to be passed to the dock area.
+        Returns:
+            BECDockArea: The newly created dock area.
+        """
+        from bec_widgets.applications.bw_launch import dock_area
+
+        with RPCRegister.delayed_broadcast() as rpc_register:
+            existing_dock_areas = rpc_register.get_names_of_rpc_by_class_type(BECDockArea)
+            if name is not None:
+                if name in existing_dock_areas:
+                    raise ValueError(
+                        f"Name {name} must be unique for dock areas, but already exists: {existing_dock_areas}."
+                    )
+            else:
+                name = "dock_area"
+                name = WidgetContainerUtils.generate_unique_name(name, existing_dock_areas)
+            dock_area = dock_area(name)  # BECDockArea(name=name)
+            dock_area.resize(dock_area.minimumSizeHint())
+            # TODO Should we simply use the specified name as title here?
+            dock_area.window().setWindowTitle(f"BEC - {name}")
+            logger.info(f"Created new dock area: {name}")
+            logger.info(f"Existing dock areas: {geometry}")
+            if geometry is not None:
+                dock_area.setGeometry(*geometry)
+
+            # TODO somehow we need to encapsulate this into BECMainWindow and keep dock area as top widget
+            # window = BECMainWindow()
+            # window.setCentralWidget(dock_area)
+            # window.show()
+            # dock_area.parent_id = None
+            dock_area.show()
+            return dock_area
+
+    def custom_ui_launcher(self): ...
+
+    def show_launcher(self):
+        self.show()
+
+    def hide_launcher(self):
+        self.hide()
+
+    def cleanup(self):
+        super().close()

bec_widgets/cli/client.py

@@ -15,17 +15,12 @@ class Widgets(str, enum.Enum):
     Enum for the available widgets.
     """
 
-    AbortButton = "AbortButton"
-    BECColorMapWidget = "BECColorMapWidget"
     BECDockArea = "BECDockArea"
     BECProgressBar = "BECProgressBar"
     BECQueue = "BECQueue"
     BECStatusBox = "BECStatusBox"
     DapComboBox = "DapComboBox"
-    DarkModeButton = "DarkModeButton"
     DeviceBrowser = "DeviceBrowser"
-    DeviceComboBox = "DeviceComboBox"
-    DeviceLineEdit = "DeviceLineEdit"
     Image = "Image"
     LMFitDialog = "LMFitDialog"
     LogPanel = "LogPanel"
@@ -36,39 +31,15 @@ class Widgets(str, enum.Enum):
     PositionerBox = "PositionerBox"
     PositionerBox2D = "PositionerBox2D"
     PositionerControlLine = "PositionerControlLine"
-    ResetButton = "ResetButton"
-    ResumeButton = "ResumeButton"
     RingProgressBar = "RingProgressBar"
     ScanControl = "ScanControl"
     ScatterWaveform = "ScatterWaveform"
-    SignalComboBox = "SignalComboBox"
-    SignalLineEdit = "SignalLineEdit"
-    StopButton = "StopButton"
     TextBox = "TextBox"
     VSCodeEditor = "VSCodeEditor"
     Waveform = "Waveform"
     WebsiteWidget = "WebsiteWidget"
 
 
-class AbortButton(RPCBase):
-    """A button that abort the scan."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
-class BECColorMapWidget(RPCBase):
-    @property
-    @rpc_call
-    def colormap(self):
-        """
-        Get the current colormap name.
-        """
-
-
 class BECDock(RPCBase):
     @property
     @rpc_call
@@ -625,12 +596,11 @@ class DapComboBox(RPCBase):
         """
 
 
-class DarkModeButton(RPCBase):
+class DemoApp(RPCBase):
     @rpc_call
-    def toggle_dark_mode(self) -> "None":
+    def remove(self):
         """
-        Toggle the dark mode state. This will change the theme of the entire
-        application to dark or light mode.
+        Cleanup the BECConnector
         """
 
 
@@ -642,46 +612,6 @@ class DeviceBrowser(RPCBase):
         """
 
 
-class DeviceComboBox(RPCBase):
-    """Combobox widget for device input with autocomplete for device names."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
-class DeviceInputBase(RPCBase):
-    """Mixin base class for device input widgets."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
-class DeviceLineEdit(RPCBase):
-    """Line edit widget for device input with autocomplete for device names."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
-class DeviceSignalInputBase(RPCBase):
-    """Mixin base class for device signal input widgets."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class Image(RPCBase):
     @property
     @rpc_call
@@ -2283,26 +2213,6 @@ class PositionerGroup(RPCBase):
         """
 
 
-class ResetButton(RPCBase):
-    """A button that resets the scan queue."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
-class ResumeButton(RPCBase):
-    """A button that continue scan queue."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class Ring(RPCBase):
     @rpc_call
     def _get_all_rpc(self) -> "dict":
@@ -2953,36 +2863,6 @@ class ScatterWaveform(RPCBase):
         """
 
 
-class SignalComboBox(RPCBase):
-    """Line edit widget for device input with autocomplete for device names."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
-class SignalLineEdit(RPCBase):
-    """Line edit widget for device input with autocomplete for device names."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
-class StopButton(RPCBase):
-    """A button that stops the current scan."""
-
-    @rpc_call
-    def remove(self):
-        """
-        Cleanup the BECConnector
-        """
-
-
 class TextBox(RPCBase):
     """A widget that displays text in plain and HTML format"""
 
@@ -3513,3 +3393,40 @@ class WebsiteWidget(RPCBase):
         """
         Go forward in the history
         """
+
+
+class WindowWithUi(RPCBase):
+    """This is just testing app wiht UI file which could be connected to RPC."""
+
+    @rpc_call
+    def new_dock_area(
+        self, name: str | None = None, geometry: tuple[int, int, int, int] | None = None
+    ) -> "BECDockArea":
+        """
+        Create a new dock area.
+
+        Args:
+            name(str): The name of the dock area.
+            geometry(tuple): The geometry parameters to be passed to the dock area.
+        Returns:
+            BECDockArea: The newly created dock area.
+        """
+
+    @property
+    @rpc_call
+    def all_connections(self) -> list:
+        """
+        None
+        """
+
+    @rpc_call
+    def change_theme(self, theme):
+        """
+        None
+        """
+
+    @rpc_call
+    def hierarchy(self):
+        """
+        None
+        """

bec_widgets/cli/client_utils.py

@@ -10,11 +10,11 @@ import threading
 import time
 from contextlib import contextmanager
 from threading import Lock
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Literal, TypeAlias
 
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
-from bec_lib.utils.import_utils import lazy_import, lazy_import_from
+from bec_lib.utils.import_utils import lazy_import_from
 from rich.console import Console
 from rich.table import Table
 
@@ -28,7 +28,11 @@ else:
 
 logger = bec_logger.logger
 
-IGNORE_WIDGETS = ["BECDockArea", "BECDock"]
+IGNORE_WIDGETS = ["LaunchWindow"]
+
+RegistryState: TypeAlias = dict[
+    Literal["gui_id", "name", "widget_class", "config", "__rpc__"], str | bool | dict
+]
 
 # pylint: disable=redefined-outer-scope
 
@@ -67,7 +71,7 @@ def _get_output(process, logger) -> None:
 
 
 def _start_plot_process(
-    gui_id: str, gui_class: type, gui_class_id: str, config: dict | str, logger=None
+    gui_id: str, gui_class_id: str, config: dict | str, gui_class: str = "launcher", logger=None
 ) -> tuple[subprocess.Popen[str], threading.Thread | None]:
     """
     Start the plot in a new process.
@@ -82,7 +86,7 @@ def _start_plot_process(
         "--id",
         gui_id,
         "--gui_class",
-        gui_class.__name__,
+        gui_class,
         "--gui_class_id",
         gui_class_id,
         "--hide",
@@ -199,21 +203,25 @@ class BECGuiClient(RPCBase):
         self._auto_updates_enabled = True
         self._auto_updates = None
         self._killed = False
-        self._top_level: dict[str, client.BECDockArea] = {}
+        self._top_level: dict[str, RPCReference] = {}
         self._startup_timeout = 0
         self._gui_started_timer = None
         self._gui_started_event = threading.Event()
         self._process = None
         self._process_output_processing_thread = None
-        self._exposed_widgets = []
-        self._server_registry = {}
-        self._ipython_registry = {}
+        self._server_registry: dict[str, RegistryState] = {}
+        self._ipython_registry: dict[str, RPCReference] = {}
         self.available_widgets = AvailableWidgetsNamespace()
 
     ####################
     #### Client API ####
     ####################
 
+    @property
+    def launcher(self) -> RPCBase:
+        """The launcher object."""
+        return RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self, name="launcher")
+
     def connect_to_gui_server(self, gui_id: str) -> None:
         """Connect to a GUI server"""
         # Unregister the old callback
@@ -221,21 +229,25 @@ class BECGuiClient(RPCBase):
             MessageEndpoints.gui_registry_state(self._gui_id), cb=self._handle_registry_update
         )
         self._gui_id = gui_id
-        # Get the registry state
-        msgs = self._client.connector.xread(
-            MessageEndpoints.gui_registry_state(self._gui_id), count=1
-        )
-        if msgs:
-            self._handle_registry_update(msgs[0])
+
+        # reset the namespace
+        self._update_dynamic_namespace({})
+        self._server_registry = {}
+        self._top_level = {}
+        self._ipython_registry = {}
+
         # Register the new callback
         self._client.connector.register(
-            MessageEndpoints.gui_registry_state(self._gui_id), cb=self._handle_registry_update
+            MessageEndpoints.gui_registry_state(self._gui_id),
+            cb=self._handle_registry_update,
+            parent=self,
+            from_start=True,
         )
 
     @property
     def windows(self) -> dict:
         """Dictionary with dock areas in the GUI."""
-        return self._top_level
+        return {widget._name: widget for widget in self._top_level.values()}
 
     @property
     def window_list(self) -> list:
@@ -275,12 +287,12 @@ class BECGuiClient(RPCBase):
             self.start(wait=True)
         if wait:
             with wait_for_server(self):
-                rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
+                rpc_client = RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self)
                 widget = rpc_client._run_rpc(
-                    "new_dock_area", name, geometry
+                    "launch", "dock_area", name, geometry
                 )  # pylint: disable=protected-access
                 return widget
-        rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
+        rpc_client = RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self)
         widget = rpc_client._run_rpc(
             "new_dock_area", name, geometry
         )  # pylint: disable=protected-access
@@ -352,11 +364,13 @@ class BECGuiClient(RPCBase):
         # Wait for 'bec' gui to be registered, this may take some time
         # After 60s timeout. Should this raise an exception on timeout?
         while time.time() < time.time() + timeout:
-            if len(list(self._server_registry.keys())) == 0:
+            if len(list(self._server_registry.keys())) < 2 or not hasattr(
+                self, self._default_dock_name
+            ):
                 time.sleep(0.1)
             else:
                 break
-        self._do_show_all()
+
         self._gui_started_event.set()
 
     def _start_server(self, wait: bool = False) -> None:
@@ -369,7 +383,6 @@ class BECGuiClient(RPCBase):
             self._gui_started_event.clear()
             self._process, self._process_output_processing_thread = _start_plot_process(
                 self._gui_id,
-                self.__class__,
                 gui_class_id=self._default_dock_name,
                 config=self._client._service_config.config,  # pylint: disable=protected-access
                 logger=logger,
@@ -380,7 +393,7 @@ class BECGuiClient(RPCBase):
                     if callable(callback):
                         callback()
                 finally:
-                    threading.current_thread().cancel()
+                    threading.current_thread().cancel()  # type: ignore
 
             self._gui_started_timer = RepeatTimer(
                 0.5, lambda: self._gui_is_alive() and gui_started_callback(self._gui_post_startup)
@@ -390,25 +403,25 @@ class BECGuiClient(RPCBase):
         if wait:
             self._gui_started_event.wait()
 
-    def _dump(self):
-        rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
-        return rpc_client._run_rpc("_dump")
-
     def _start(self, wait: bool = False) -> None:
         self._killed = False
         self._client.connector.register(
-            MessageEndpoints.gui_registry_state(self._gui_id), cb=self._handle_registry_update
+            MessageEndpoints.gui_registry_state(self._gui_id),
+            cb=self._handle_registry_update,
+            parent=self,
         )
         return self._start_server(wait=wait)
 
-    def _handle_registry_update(self, msg: StreamMessage) -> None:
+    @staticmethod
+    def _handle_registry_update(msg: StreamMessage, parent: BECGuiClient) -> None:
         # This was causing a deadlock during shutdown, not sure why.
         # with self._lock:
+        self = parent
         self._server_registry = msg["data"].state
-        self._update_dynamic_namespace()
+        self._update_dynamic_namespace(self._server_registry)
 
     def _do_show_all(self):
-        rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
+        rpc_client = RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self)
         rpc_client._run_rpc("show")  # pylint: disable=protected-access
         for window in self._top_level.values():
             window.show()
@@ -419,112 +432,54 @@ class BECGuiClient(RPCBase):
 
     def _hide_all(self):
         with wait_for_server(self):
-            rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
+            rpc_client = RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self)
             rpc_client._run_rpc("hide")  # pylint: disable=protected-access
             if not self._killed:
                 for window in self._top_level.values():
                     window.hide()
 
-    def _update_dynamic_namespace(self):
-        """Update the dynamic name space"""
-        # Clear the top level
-        self._top_level.clear()
-        # First we update the name space based on the new registry state
-        self._add_registry_to_namespace()
-        # Then we clear the ipython registry from old objects
-        self._cleanup_ipython_registry()
+    def _update_dynamic_namespace(self, server_registry: dict):
+        """
+        Update the dynamic name space with the given server registry.
+        Setting the server registry to an empty dictionary will remove all widgets from the namespace.
 
-    def _cleanup_ipython_registry(self):
-        """Cleanup the ipython registry"""
-        names_in_registry = list(self._ipython_registry.keys())
-        names_in_server_state = list(self._server_registry.keys())
-        remove_ids = list(set(names_in_registry) - set(names_in_server_state))
-        for widget_id in remove_ids:
-            self._ipython_registry.pop(widget_id)
-        self._cleanup_rpc_references_on_rpc_base(remove_ids)
-        # Clear the exposed widgets
-        self._exposed_widgets.clear()  # No longer needed I think
+        Args:
+            server_registry (dict): The server registry
+        """
+        top_level_widgets: dict[str, RPCReference] = {}
+        for gui_id, state in server_registry.items():
+            widget = self._add_widget(state, self)
+            if widget is None:
+                # ignore widgets that are not supported
+                continue
+            # get all top-level widgets. These are widgets that have no parent
+            if not state["config"].get("parent_id"):
+                top_level_widgets[gui_id] = widget
 
-    def _cleanup_rpc_references_on_rpc_base(self, remove_ids: list[str]) -> None:
-        """Cleanup the rpc references on the RPCBase object"""
-        if not remove_ids:
-            return
-        for widget in self._ipython_registry.values():
-            to_delete = []
-            for attr_name, gui_id in widget._rpc_references.items():
-                if gui_id in remove_ids:
-                    to_delete.append(attr_name)
-            for attr_name in to_delete:
-                if hasattr(widget, attr_name):
-                    delattr(widget, attr_name)
-                if attr_name.startswith("elements."):
-                    delattr(widget.elements, attr_name.split(".")[1])
-                widget._rpc_references.pop(attr_name)
+        remove_from_registry = []
+        for gui_id, widget in self._ipython_registry.items():
+            if gui_id not in server_registry:
+                remove_from_registry.append(gui_id)
+            widget._refresh_references()
+        for gui_id in remove_from_registry:
+            self._ipython_registry.pop(gui_id)
 
-    def _set_dynamic_attributes(self, obj: object, name: str, value: Any) -> None:
-        """Add an object to the namespace"""
-        setattr(obj, name, value)
-
-    def _update_rpc_references(self, widget: RPCBase, name: str, gui_id: str) -> None:
-        """Update the RPC references"""
-        widget._rpc_references[name] = gui_id
-
-    def _add_registry_to_namespace(self) -> None:
-        """Add registry to namespace"""
-        # Add dock areas
-        dock_area_states = [
-            state
-            for state in self._server_registry.values()
-            if state["widget_class"] == "BECDockArea"
+        removed_widgets = [
+            widget._name for widget in self._top_level.values() if widget._is_deleted()
         ]
-        for state in dock_area_states:
-            dock_area_ref = self._add_widget(state, self)
-            dock_area = self._ipython_registry.get(dock_area_ref._gui_id)
-            if not hasattr(dock_area, "elements"):
-                self._set_dynamic_attributes(dock_area, "elements", WidgetNameSpace())
-            self._set_dynamic_attributes(self, dock_area.widget_name, dock_area_ref)
-            # Keep track of rpc references on RPCBase object
-            self._update_rpc_references(self, dock_area.widget_name, dock_area_ref._gui_id)
-            # Add dock_area to the top level
-            self._top_level[dock_area_ref.widget_name] = dock_area_ref
-            self._exposed_widgets.append(dock_area_ref._gui_id)
 
-            # Add docks
-            dock_states = [
-                state
-                for state in self._server_registry.values()
-                if state["config"].get("parent_id", "") == dock_area_ref._gui_id
-            ]
-            for state in dock_states:
-                dock_ref = self._add_widget(state, dock_area)
-                dock = self._ipython_registry.get(dock_ref._gui_id)
-                self._set_dynamic_attributes(dock_area, dock_ref.widget_name, dock_ref)
-                # Keep track of rpc references on RPCBase object
-                self._update_rpc_references(dock_area, dock_ref.widget_name, dock_ref._gui_id)
-                # Keep track of exposed docks
-                self._exposed_widgets.append(dock_ref._gui_id)
+        for widget_name in removed_widgets:
+            # the check is not strictly necessary, but better safe
+            # than sorry; who knows what the user has done
+            if hasattr(self, widget_name):
+                delattr(self, widget_name)
 
-                # Add widgets
-                widget_states = [
-                    state
-                    for state in self._server_registry.values()
-                    if state["config"].get("parent_id", "") == dock_ref._gui_id
-                ]
-                for state in widget_states:
-                    widget_ref = self._add_widget(state, dock)
-                    self._set_dynamic_attributes(dock, widget_ref.widget_name, widget_ref)
-                    self._set_dynamic_attributes(
-                        dock_area.elements, widget_ref.widget_name, widget_ref
-                    )
-                    # Keep track of rpc references on RPCBase object
-                    self._update_rpc_references(
-                        dock_area, f"elements.{widget_ref.widget_name}", widget_ref._gui_id
-                    )
-                    self._update_rpc_references(dock, widget_ref.widget_name, widget_ref._gui_id)
-                    # Keep track of exposed widgets
-                    self._exposed_widgets.append(widget_ref._gui_id)
+        for gui_id, widget_ref in top_level_widgets.items():
+            setattr(self, widget_ref._name, widget_ref)
 
-    def _add_widget(self, state: dict, parent: object) -> RPCReference:
+        self._top_level = top_level_widgets
+
+    def _add_widget(self, state: dict, parent: object) -> RPCReference | None:
         """Add a widget to the namespace
 
         Args:
@@ -533,6 +488,8 @@ class BECGuiClient(RPCBase):
         """
         name = state["name"]
         gui_id = state["gui_id"]
+        if state["widget_class"] in IGNORE_WIDGETS:
+            return
         widget_class = getattr(client, state["widget_class"])
         obj = self._ipython_registry.get(gui_id)
         if obj is None:
@@ -544,6 +501,7 @@ class BECGuiClient(RPCBase):
         return obj
 
 
+# FIXME not sure if this is cleanup properly, thread seems hanging
 if __name__ == "__main__":  # pragma: no cover
     from bec_lib.client import BECClient
     from bec_lib.service_config import ServiceConfig

bec_widgets/cli/rpc/rpc_base.py

@@ -15,6 +15,9 @@ import bec_widgets.cli.client as client
 if TYPE_CHECKING:  # pragma: no cover
     from bec_lib import messages
     from bec_lib.connector import MessageObject
+
+    from bec_widgets.cli.client_utils import BECGuiClient
+
 else:
     messages = lazy_import("bec_lib.messages")
     # from bec_lib.connector import MessageObject
@@ -88,10 +91,11 @@ class RPCReference:
     def __init__(self, registry: dict, gui_id: str) -> None:
         self._registry = registry
         self._gui_id = gui_id
+        self._name = self._registry[self._gui_id]._name
 
     @check_for_deleted_widget
     def __getattr__(self, name):
-        if name in ["_registry", "_gui_id"]:
+        if name in ["_registry", "_gui_id", "_is_deleted", "_name"]:
             return super().__getattribute__(name)
         return self._registry[self._gui_id].__getattribute__(name)
 
@@ -114,6 +118,9 @@ class RPCReference:
             return []
         return self._registry[self._gui_id].__dir__()
 
+    def _is_deleted(self) -> bool:
+        return self._gui_id not in self._registry
+
 
 class RPCBase:
     def __init__(
@@ -152,7 +159,7 @@ class RPCBase:
         return self._name
 
     @property
-    def _root(self):
+    def _root(self) -> BECGuiClient:
         """
         Get the root widget. This is the BECFigure widget that holds
         the anchor gui_id.
@@ -163,7 +170,7 @@ class RPCBase:
             parent = parent._parent
         return parent
 
-    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=3, **kwargs) -> Any:
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=300, **kwargs) -> Any:
         """
         Run the RPC call.
 
@@ -236,13 +243,14 @@ class RPCBase:
 
             cls = getattr(client, cls)
             # The namespace of the object will be updated dynamically on the client side
-            # Therefor it is important to check if the object is already in the registry
+            # Therefore it is important to check if the object is already in the registry
             # If yes, we return the reference to the object, otherwise we create a new object
             # pylint: disable=protected-access
             if msg_result["gui_id"] in self._root._ipython_registry:
                 return RPCReference(self._root._ipython_registry, msg_result["gui_id"])
             ret = cls(parent=self, **msg_result)
             self._root._ipython_registry[ret._gui_id] = ret
+            self._refresh_references()
             obj = RPCReference(self._root._ipython_registry, ret._gui_id)
             return obj
             # return ret
@@ -258,3 +266,22 @@ class RPCBase:
         if heart.status == messages.BECStatus.RUNNING:
             return True
         return False
+
+    def _refresh_references(self):
+        """
+        Refresh the references.
+        """
+        with self._root._lock:
+            references = {}
+            for key, val in self._root._server_registry.items():
+                parent_id = val["config"].get("parent_id")
+                if parent_id == self._gui_id:
+                    references[key] = {"gui_id": val["config"]["gui_id"], "name": val["name"]}
+            removed_references = set(self._rpc_references.keys()) - set(references.keys())
+            for key in removed_references:
+                delattr(self, self._rpc_references[key]["name"])
+            self._rpc_references = references
+            for key, val in references.items():
+                setattr(
+                    self, val["name"], RPCReference(self._root._ipython_registry, val["gui_id"])
+                )

bec_widgets/cli/rpc/rpc_register.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import wraps
-from threading import Lock, RLock
+from threading import RLock
 from typing import TYPE_CHECKING, Callable
 from weakref import WeakValueDictionary
 
@@ -77,7 +77,7 @@ class RPCRegister:
         self._rpc_register[rpc.gui_id] = rpc
 
     @broadcast_update
-    def remove_rpc(self, rpc: str):
+    def remove_rpc(self, rpc: BECConnector):
         """
         Remove an RPC object from the register.
 
@@ -113,7 +113,7 @@ class RPCRegister:
         return connections
 
     def get_names_of_rpc_by_class_type(
-        self, cls: BECWidget | BECConnector | BECDock | BECDockArea
+        self, cls: type[BECWidget] | type[BECConnector] | type[BECDock] | type[BECDockArea]
     ) -> list[str]:
         """Get all the names of the widgets.
 
@@ -170,6 +170,7 @@ class RPCRegisterBroadcast:
 
     def __exit__(self, *exc):
         """Exit the context manager"""
+
         self._call_depth -= 1  # Remove nested calls
         if self._call_depth == 0:  # Last one to exit is repsonsible for broadcasting
             self.rpc_register._skip_broadcast = False

bec_widgets/cli/server.py

@@ -1,188 +1,27 @@
 from __future__ import annotations
 
-import functools
+import argparse
 import json
+import os
 import signal
 import sys
-import types
-from contextlib import contextmanager, redirect_stderr, redirect_stdout
-from typing import Union
+from contextlib import redirect_stderr, redirect_stdout
+from typing import cast
 
-from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from bec_lib.service_config import ServiceConfig
-from bec_lib.utils.import_utils import lazy_import
-from qtpy.QtCore import Qt, QTimer
-from redis.exceptions import RedisError
+from qtpy.QtCore import QSize, Qt
+from qtpy.QtGui import QIcon
+from qtpy.QtWidgets import QApplication
 
+import bec_widgets
+from bec_widgets.applications.launch_window import LaunchWindow
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils import BECDispatcher
-from bec_widgets.utils.bec_connector import BECConnector
-from bec_widgets.utils.error_popups import ErrorPopupUtility
-from bec_widgets.widgets.containers.dock import BECDockArea
-from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
-messages = lazy_import("bec_lib.messages")
 logger = bec_logger.logger
 
-
-@contextmanager
-def rpc_exception_hook(err_func):
-    """This context replaces the popup message box for error display with a specific hook"""
-    # get error popup utility singleton
-    popup = ErrorPopupUtility()
-    # save current setting
-    old_exception_hook = popup.custom_exception_hook
-
-    # install err_func, if it is a callable
-    # IMPORTANT, Keep self here, because this method is overwriting the custom_exception_hook
-    # of the ErrorPopupUtility (popup instance) class.
-    def custom_exception_hook(self, exc_type, value, tb, **kwargs):
-        err_func({"error": popup.get_error_message(exc_type, value, tb)})
-
-    popup.custom_exception_hook = types.MethodType(custom_exception_hook, popup)
-
-    try:
-        yield popup
-    finally:
-        # restore state of error popup utility singleton
-        popup.custom_exception_hook = old_exception_hook
-
-
-class BECWidgetsCLIServer:
-
-    def __init__(
-        self,
-        gui_id: str,
-        dispatcher: BECDispatcher = None,
-        client=None,
-        config=None,
-        gui_class: type[BECDockArea] = BECDockArea,
-        gui_class_id: str = "bec",
-    ) -> None:
-        self.status = messages.BECStatus.BUSY
-        self.dispatcher = BECDispatcher(config=config) if dispatcher is None else dispatcher
-        self.client = self.dispatcher.client if client is None else client
-        self.client.start()
-        self.gui_id = gui_id
-        # register broadcast callback
-        self.rpc_register = RPCRegister()
-        self.rpc_register.add_callback(self.broadcast_registry_update)
-
-        self.dispatcher.connect_slot(
-            self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
-        )
-
-        # Setup QTimer for heartbeat
-        self._heartbeat_timer = QTimer()
-        self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
-        self._heartbeat_timer.start(200)
-
-        self.status = messages.BECStatus.RUNNING
-        with RPCRegister.delayed_broadcast():
-            self.gui = gui_class(parent=None, name=gui_class_id, gui_id=gui_class_id)
-        logger.success(f"Server started with gui_id: {self.gui_id}")
-        # Create initial object -> BECFigure or BECDockArea
-
-    def on_rpc_update(self, msg: dict, metadata: dict):
-        request_id = metadata.get("request_id")
-        logger.debug(f"Received RPC instruction: {msg}, metadata: {metadata}")
-        with rpc_exception_hook(functools.partial(self.send_response, request_id, False)):
-            try:
-                obj = self.get_object_from_config(msg["parameter"])
-                method = msg["action"]
-                args = msg["parameter"].get("args", [])
-                kwargs = msg["parameter"].get("kwargs", {})
-                res = self.run_rpc(obj, method, args, kwargs)
-            except Exception as e:
-                logger.error(f"Error while executing RPC instruction: {e}")
-                self.send_response(request_id, False, {"error": str(e)})
-            else:
-                logger.debug(f"RPC instruction executed successfully: {res}")
-                self.send_response(request_id, True, {"result": res})
-
-    def send_response(self, request_id: str, accepted: bool, msg: dict):
-        self.client.connector.set_and_publish(
-            MessageEndpoints.gui_instruction_response(request_id),
-            messages.RequestResponseMessage(accepted=accepted, message=msg),
-            expire=60,
-        )
-
-    def get_object_from_config(self, config: dict):
-        gui_id = config.get("gui_id")
-        obj = self.rpc_register.get_rpc_by_id(gui_id)
-        if obj is None:
-            raise ValueError(f"Object with gui_id {gui_id} not found")
-        return obj
-
-    def run_rpc(self, obj, method, args, kwargs):
-        # Run with rpc registry broadcast, but only once
-        with RPCRegister.delayed_broadcast():
-            logger.debug(f"Running RPC instruction: {method} with args: {args}, kwargs: {kwargs}")
-            method_obj = getattr(obj, method)
-            # check if the method accepts args and kwargs
-            if not callable(method_obj):
-                if not args:
-                    res = method_obj
-                else:
-                    setattr(obj, method, args[0])
-                    res = None
-            else:
-                res = method_obj(*args, **kwargs)
-
-            if isinstance(res, list):
-                res = [self.serialize_object(obj) for obj in res]
-            elif isinstance(res, dict):
-                res = {key: self.serialize_object(val) for key, val in res.items()}
-            else:
-                res = self.serialize_object(res)
-            return res
-
-    def serialize_object(self, obj):
-        if isinstance(obj, BECConnector):
-            config = obj.config.model_dump()
-            config["parent_id"] = obj.parent_id  # add parent_id to config
-            return {
-                "gui_id": obj.gui_id,
-                "name": (
-                    obj._name if hasattr(obj, "_name") else obj.__class__.__name__
-                ),  # pylint: disable=protected-access
-                "widget_class": obj.__class__.__name__,
-                "config": config,
-                "__rpc__": True,
-            }
-        return obj
-
-    def emit_heartbeat(self):
-        logger.trace(f"Emitting heartbeat for {self.gui_id}")
-        try:
-            self.client.connector.set(
-                MessageEndpoints.gui_heartbeat(self.gui_id),
-                messages.StatusMessage(name=self.gui_id, status=self.status, info={}),
-                expire=10,
-            )
-        except RedisError as exc:
-            logger.error(f"Error while emitting heartbeat: {exc}")
-
-    def broadcast_registry_update(self, connections: dict):
-        """
-        Broadcast the updated registry to all clients.
-        """
-
-        # We only need to broadcast the dock areas
-        data = {key: self.serialize_object(val) for key, val in connections.items()}
-        self.client.connector.xadd(
-            MessageEndpoints.gui_registry_state(self.gui_id),
-            msg_dict={"data": messages.GUIRegistryStateMessage(state=data)},
-            max_size=1,  # only single message in stream
-        )
-
-    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
-        self.status = messages.BECStatus.IDLE
-        self._heartbeat_timer.stop()
-        self.emit_heartbeat()
-        logger.info("Succeded in shutting down gui")
-        self.client.shutdown()
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
 
 class SimpleFileLikeFromLogOutputFunc:
@@ -203,40 +42,134 @@ class SimpleFileLikeFromLogOutputFunc:
         return
 
 
-def _start_server(
-    gui_id: str, gui_class: BECDockArea, gui_class_id: str = "bec", config: str | None = None
-):
-    if config:
-        try:
-            config = json.loads(config)
-            service_config = ServiceConfig(config=config)
-        except (json.JSONDecodeError, TypeError):
-            service_config = ServiceConfig(config_path=config)
-    else:
-        # if no config is provided, use the default config
-        service_config = ServiceConfig()
+class GUIServer:
+    """
+    This class is used to start the BEC GUI and is the main entry point for launching BEC Widgets in a subprocess.
+    """
 
-    # bec_logger.configure(
-    #     service_config.redis,
-    #     QtRedisConnector,
-    #     service_name="BECWidgetsCLIServer",
-    #     service_config=service_config.service_config,
-    # )
-    server = BECWidgetsCLIServer(
-        gui_id=gui_id, config=service_config, gui_class=gui_class, gui_class_id=gui_class_id
-    )
-    return server
+    def __init__(self, args):
+        self.config = args.config
+        self.gui_id = args.id
+        self.gui_class = args.gui_class
+        self.gui_class_id = args.gui_class_id
+        self.hide = args.hide
+        self.app: QApplication | None = None
+        self.launcher_window: LaunchWindow | None = None
+        self.dispatcher: BECDispatcher | None = None
+
+    def start(self):
+        """
+        Start the GUI server.
+        """
+        bec_logger.level = bec_logger.LOGLEVEL.INFO
+        if self.hide:
+            # pylint: disable=protected-access
+            bec_logger._stderr_log_level = bec_logger.LOGLEVEL.ERROR
+            bec_logger._update_sinks()
+
+        with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.info)):  # type: ignore
+            with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):  # type: ignore
+                self._run()
+
+    def _get_service_config(self) -> ServiceConfig:
+        if self.config:
+            try:
+                config = json.loads(self.config)
+                service_config = ServiceConfig(config=config)
+            except (json.JSONDecodeError, TypeError):
+                service_config = ServiceConfig(config_path=config)
+        else:
+            # if no config is provided, use the default config
+            service_config = ServiceConfig()
+        return service_config
+
+    def _turn_off_the_lights(self, connections: dict):
+        """
+        If there is only one connection remaining, it is the launcher, so we show it.
+        Once the launcher is closed as the last window, we quit the application.
+        """
+        self.launcher_window = cast(LaunchWindow, self.launcher_window)
+
+        if len(connections) <= 1:
+            self.launcher_window.show()
+            self.launcher_window.activateWindow()
+            self.launcher_window.raise_()
+            if self.app:
+                self.app.setQuitOnLastWindowClosed(True)
+        else:
+            self.launcher_window.hide()
+            if self.app:
+                self.app.setQuitOnLastWindowClosed(False)
+
+    def _run(self):
+        """
+        Run the GUI server.
+        """
+        # TODO decide if attach to app or not
+        self.app = QApplication(sys.argv)
+        self.app.setApplicationName("BEC")
+        self.app.gui_id = self.gui_id  # type: ignore
+        self.setup_bec_icon()
+
+        service_config = self._get_service_config()
+        self.dispatcher = BECDispatcher(config=service_config, gui_id=self.gui_id)
+
+        self.launcher_window = LaunchWindow(gui_id=f"{self.gui_id}:launcher")
+        self.launcher_window.setAttribute(Qt.WA_ShowWithoutActivating)  # type: ignore
+
+        self.app.aboutToQuit.connect(self.shutdown)
+        self.app.setQuitOnLastWindowClosed(False)
+
+        register = RPCRegister()
+        register.callbacks.append(self._turn_off_the_lights)
+        register.broadcast()
+
+        if self.gui_class:
+            # If the server is started with a specific gui class, we launch it.
+            # This will automatically hide the launcher.
+            self.launcher_window.launch(self.gui_class, name=self.gui_class_id)
+
+        def sigint_handler(*args):
+            # display message, for people to let it terminate gracefully
+            print("Caught SIGINT, exiting")
+            # Widgets should be all closed.
+            with RPCRegister.delayed_broadcast():
+                for widget in QApplication.instance().topLevelWidgets():  # type: ignore
+                    widget.close()
+            if self.app:
+                self.app.quit()
+
+        # gui.bec.close()
+        # win.shutdown()
+        signal.signal(signal.SIGINT, sigint_handler)
+        signal.signal(signal.SIGTERM, sigint_handler)
+
+        sys.exit(self.app.exec())
+
+    def setup_bec_icon(self):
+        """
+        Set the BEC icon for the application
+        """
+        icon = QIcon()
+        icon.addFile(
+            os.path.join(MODULE_PATH, "assets", "app_icons", "bec_widgets_icon.png"),
+            size=QSize(48, 48),
+        )
+        self.app.setWindowIcon(icon)
+
+    def shutdown(self):
+        """
+        Shutdown the GUI server.
+        """
+        if self.dispatcher:
+            self.dispatcher.stop_cli_server()
+            self.dispatcher.disconnect_all()
 
 
 def main():
-    import argparse
-    import os
-
-    from qtpy.QtCore import QSize
-    from qtpy.QtGui import QIcon
-    from qtpy.QtWidgets import QApplication
-
-    import bec_widgets
+    """
+    Main entry point for subprocesses that start a GUI server.
+    """
 
     parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
     parser.add_argument("--id", type=str, default="test", help="The id of the server")
@@ -256,69 +189,12 @@ def main():
 
     args = parser.parse_args()
 
-    bec_logger.level = bec_logger.LOGLEVEL.INFO
-    if args.hide:
-        # pylint: disable=protected-access
-        bec_logger._stderr_log_level = bec_logger.LOGLEVEL.ERROR
-        bec_logger._update_sinks()
-
-    if args.gui_class == "BECDockArea":
-        gui_class = BECDockArea
-    else:
-        print(
-            "Please specify a valid gui_class to run. Use -h for help."
-            "\n Starting with default gui_class BECFigure."
-        )
-        gui_class = BECDockArea
-
-    with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.info)):
-        with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):
-            app = QApplication(sys.argv)
-            # set close on last window, only if not under control of client ;
-            # indeed, Qt considers a hidden window a closed window, so if all windows
-            # are hidden by default it exits
-            app.setQuitOnLastWindowClosed(not args.hide)
-            module_path = os.path.dirname(bec_widgets.__file__)
-            icon = QIcon()
-            icon.addFile(
-                os.path.join(module_path, "assets", "app_icons", "bec_widgets_icon.png"),
-                size=QSize(48, 48),
-            )
-            app.setWindowIcon(icon)
-            # store gui id within QApplication object, to make it available to all widgets
-            app.gui_id = args.id
-
-            # args.id = "abff6"
-            server = _start_server(args.id, gui_class, args.gui_class_id, args.config)
-
-            win = BECMainWindow(gui_id=f"{server.gui_id}:window")
-            win.setAttribute(Qt.WA_ShowWithoutActivating)
-            win.setWindowTitle("BEC")
-
-            RPCRegister().add_rpc(win)
-            gui = server.gui
-            win.setCentralWidget(gui)
-            if not args.hide:
-                win.show()
-
-            app.aboutToQuit.connect(server.shutdown)
-
-            def sigint_handler(*args):
-                # display message, for people to let it terminate gracefully
-                print("Caught SIGINT, exiting")
-                # Widgets should be all closed.
-                with RPCRegister.delayed_broadcast():
-                    for widget in QApplication.instance().topLevelWidgets():
-                        widget.close()
-                app.quit()
-
-            # gui.bec.close()
-            # win.shutdown()
-            signal.signal(signal.SIGINT, sigint_handler)
-            signal.signal(signal.SIGTERM, sigint_handler)
-
-            sys.exit(app.exec())
+    server = GUIServer(args)
+    server.start()
 
 
 if __name__ == "__main__":
+    # import sys
+
+    # sys.argv = ["bec_widgets", "--gui_class", "MainWindow"]
     main()

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -34,11 +34,13 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         super().__init__(parent)
 
         self._init_ui()
+        self.app_instance = QApplication.instance()
 
         # console push
         if self.console.inprocess is True:
             self.console.kernel_manager.kernel.shell.push(
                 {
+                    "app": self.app_instance,
                     "np": np,
                     "pg": pg,
                     "wh": wh,
@@ -74,6 +76,9 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         first_tab = QWidget()
         first_tab_layout = QVBoxLayout(first_tab)
         self.dock = BECDockArea(gui_id="dock")
+        wf0 = self.dock.new(widget="Waveform")
+        wf1 = self.dock.new(widget="Waveform")
+        wf0.element_list[0].plot("samx")
         first_tab_layout.addWidget(self.dock)
         tab_widget.addTab(first_tab, "Dock Area")
 

bec_widgets/utils/bec_connector.py

@@ -10,13 +10,14 @@ from typing import TYPE_CHECKING, Optional
 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 QObject, QRunnable, QThreadPool, Signal
+from qtpy.QtCore import QObject, QRunnable, Qt, QThreadPool, Signal
 from qtpy.QtWidgets import QApplication
 
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.utils.container_utils import WidgetContainerUtils
 from bec_widgets.utils.error_popups import ErrorPopupUtility
 from bec_widgets.utils.error_popups import SafeSlot as pyqtSlot
+from bec_widgets.utils.widget_io import WidgetHierarchy
 from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -127,7 +128,17 @@ class BECConnector:
         else:
             if not WidgetContainerUtils.has_name_valid_chars(name):
                 raise ValueError(f"Name {name} contains invalid characters.")
-        self._name = name if name else self.__class__.__name__
+        # TODO Hierarchy can be refreshed upon creation
+        if isinstance(self, QObject):
+            # 1) If no objectName is set, set the initial name
+            if not self.objectName():
+                self.setObjectName(name if name else self.__class__.__name__)
+            self._name = self.objectName()
+
+            # 2) Enforce unique objectName among siblings with the same BECConnector parent
+            self._enforce_unique_sibling_name()
+        else:
+            self._name = name if name else self.__class__.__name__
         self.rpc_register = RPCRegister()
         self.rpc_register.add_rpc(self)
 
@@ -138,6 +149,49 @@ class BECConnector:
         # Store references to running workers so they're not garbage collected prematurely.
         self._workers = []
 
+    def _enforce_unique_sibling_name(self):
+        """
+        Enforce that this BECConnector has a unique objectName among its siblings.
+
+        Sibling logic:
+          - If there's a nearest BECConnector parent, only compare with children of that parent.
+          - If parent is None (i.e., top-level object), compare with all other top-level BECConnectors.
+        """
+        parent_bec = WidgetHierarchy._get_becwidget_ancestor(self)
+
+        if parent_bec:
+            # We have a parent => only compare with siblings under that parent
+            siblings = parent_bec.findChildren(BECConnector, options=Qt.FindDirectChildrenOnly)
+        else:
+            # No parent => treat all top-level BECConnectors as siblings
+            # 1) Gather all BECConnectors from QApplication
+            all_widgets = QApplication.allWidgets()
+            all_bec = [w for w in all_widgets if isinstance(w, BECConnector)]
+            # 2) "Top-level" means closest BECConnector parent is None
+            top_level_bec = [
+                w for w in all_bec if WidgetHierarchy._get_becwidget_ancestor(w) is None
+            ]
+            # 3) We are among these top-level siblings
+            siblings = top_level_bec
+
+        # Collect used names among siblings
+        used_names = {sib.objectName() for sib in siblings if sib is not self}
+
+        base_name = self.objectName()
+        if base_name not in used_names:
+            # Name is already unique among siblings
+            return
+
+        # Need a suffix to avoid collision
+        counter = 0
+        while True:
+            trial_name = f"{base_name}_{counter}"
+            if trial_name not in used_names:
+                self.setObjectName(trial_name)
+                self._name = trial_name
+                break
+            counter += 1
+
     def submit_task(self, fn, *args, on_complete: pyqtSlot = None, **kwargs) -> Worker:
         """
         Submit a task to run in a separate thread. The task will run the specified

bec_widgets/utils/bec_dispatcher.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import collections
+import random
+import string
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Union
 
@@ -17,6 +19,8 @@ logger = bec_logger.logger
 if TYPE_CHECKING:
     from bec_lib.endpoints import EndpointInfo
 
+    from bec_widgets.utils.cli_server import CLIServer
+
 
 class QtThreadSafeCallback(QObject):
     cb_signal = pyqtSignal(dict, dict)
@@ -73,14 +77,24 @@ class BECDispatcher:
 
     _instance = None
     _initialized = False
+    client: BECClient
+    cli_server: CLIServer | None = None
 
-    def __new__(cls, client=None, config: str = None, *args, **kwargs):
+    # TODO add custom gui id for server
+    def __new__(
+        cls,
+        client=None,
+        config: str | ServiceConfig | None = None,
+        gui_id: str = None,
+        *args,
+        **kwargs,
+    ):
         if cls._instance is None:
             cls._instance = super(BECDispatcher, cls).__new__(cls)
             cls._initialized = False
         return cls._instance
 
-    def __init__(self, client=None, config: str | ServiceConfig = None):
+    def __init__(self, client=None, config: str | ServiceConfig | None = None, gui_id: str = None):
         if self._initialized:
             return
 
@@ -108,10 +122,15 @@ class BECDispatcher:
             logger.warning("Could not connect to Redis, skipping start of BECClient.")
 
         logger.success("Initialized BECDispatcher")
+
+        self.start_cli_server(gui_id=gui_id)
         self._initialized = True
 
     @classmethod
     def reset_singleton(cls):
+        """
+        Reset the singleton instance of the BECDispatcher.
+        """
         cls._instance = None
         cls._initialized = False
 
@@ -178,4 +197,49 @@ class BECDispatcher:
             *args: Arbitrary positional arguments
             **kwargs: Arbitrary keyword arguments
         """
+        # pylint: disable=protected-access
         self.disconnect_topics(self.client.connector._topics_cb)
+
+    def start_cli_server(self, gui_id: str | None = None):
+        """
+        Start the CLI server.
+
+        Args:
+            gui_id(str, optional): The GUI ID. Defaults to None. If None, a unique identifier will be generated.
+        """
+        # pylint: disable=import-outside-toplevel
+        from bec_widgets.utils.cli_server import CLIServer
+
+        if gui_id is None:
+            gui_id = self.generate_unique_identifier()
+
+        if not self.client.started:
+            logger.error("Cannot start CLI server without a running client")
+            return
+        self.cli_server = CLIServer(gui_id, dispatcher=self, client=self.client)
+        logger.success(f"Started CLI server with gui_id: {gui_id}")
+
+    def stop_cli_server(self):
+        """
+        Stop the CLI server.
+        """
+        if self.cli_server is None:
+            logger.error("Cannot stop CLI server without starting it first")
+            return
+        self.cli_server.shutdown()
+        self.cli_server = None
+        logger.success("Stopped CLI server")
+
+    @staticmethod
+    def generate_unique_identifier(length: int = 4) -> str:
+        """
+        Generate a unique identifier for the application.
+
+        Args:
+            length: The length of the identifier. Defaults to 4.
+
+        Returns:
+            str: The unique identifier.
+        """
+        allowed_chars = string.ascii_lowercase + string.digits
+        return "".join(random.choices(allowed_chars, k=length))

bec_widgets/utils/bec_widget.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import darkdetect
 from bec_lib.logger import bec_logger
@@ -43,8 +43,8 @@ class BECWidget(BECConnector):
 
         >>> class MyWidget(BECWidget, QWidget):
         >>>     def __init__(self, parent=None, client=None, config=None, gui_id=None):
-        >>>         super().__init__(client=client, config=config, gui_id=gui_id)
-        >>>         QWidget.__init__(self, parent=parent)
+        >>>         QWidget.__init__(self, parent=parent) #Qt class has to be initialized first before BECWidget
+        >>>         BECWidget.__init__(self,client=client, config=config, gui_id=gui_id)
 
 
         Args:
@@ -56,7 +56,6 @@ class BECWidget(BECConnector):
         """
         if not isinstance(self, QWidget):
             raise RuntimeError(f"{repr(self)} is not a subclass of QWidget")
-
         super().__init__(
             client=client,
             config=config,

bec_widgets/utils/cli_server.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import functools
+import traceback
+import types
+from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+from bec_lib.client import BECClient
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from bec_lib.utils.import_utils import lazy_import
+from qtpy.QtCore import QTimer
+from qtpy.QtWidgets import QApplication
+from redis.exceptions import RedisError
+
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.utils.error_popups import ErrorPopupUtility
+from bec_widgets.utils.widget_io import WidgetHierarchy
+from bec_widgets.widgets.plots.plot_base import PlotBase
+
+if TYPE_CHECKING:
+    from bec_lib import messages
+else:
+    messages = lazy_import("bec_lib.messages")
+logger = bec_logger.logger
+
+
+@contextmanager
+def rpc_exception_hook(err_func):
+    """This context replaces the popup message box for error display with a specific hook"""
+    # get error popup utility singleton
+    popup = ErrorPopupUtility()
+    # save current setting
+    old_exception_hook = popup.custom_exception_hook
+
+    # install err_func, if it is a callable
+    # IMPORTANT, Keep self here, because this method is overwriting the custom_exception_hook
+    # of the ErrorPopupUtility (popup instance) class.
+    def custom_exception_hook(self, exc_type, value, tb, **kwargs):
+        err_func({"error": popup.get_error_message(exc_type, value, tb)})
+
+    popup.custom_exception_hook = types.MethodType(custom_exception_hook, popup)
+
+    try:
+        yield popup
+    finally:
+        # restore state of error popup utility singleton
+        popup.custom_exception_hook = old_exception_hook
+
+
+class CLIServer:
+
+    client: BECClient
+
+    def __init__(
+        self,
+        gui_id: str,
+        dispatcher: BECDispatcher | None = None,
+        client: BECClient | None = None,
+        config=None,
+        gui_class_id: str = "bec",
+    ) -> None:
+        self.status = messages.BECStatus.BUSY
+        self.dispatcher = BECDispatcher(config=config) if dispatcher is None else dispatcher
+        self.client = self.dispatcher.client if client is None else client
+        self.client.start()
+        self.gui_id = gui_id
+        # register broadcast callback
+        self.rpc_register = RPCRegister()
+        self.rpc_register.add_callback(self.broadcast_registry_update)
+
+        self.dispatcher.connect_slot(
+            self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
+        )
+
+        # Setup QTimer for heartbeat
+        self._heartbeat_timer = QTimer()
+        self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
+        self._heartbeat_timer.start(200)
+        self._registry_update_callbacks = []
+
+        self.status = messages.BECStatus.RUNNING
+        logger.success(f"Server started with gui_id: {self.gui_id}")
+
+    def on_rpc_update(self, msg: dict, metadata: dict):
+        request_id = metadata.get("request_id")
+        if request_id is None:
+            logger.error("Received RPC instruction without request_id")
+            return
+        logger.debug(f"Received RPC instruction: {msg}, metadata: {metadata}")
+        with rpc_exception_hook(functools.partial(self.send_response, request_id, False)):
+            try:
+                obj = self.get_object_from_config(msg["parameter"])
+                method = msg["action"]
+                args = msg["parameter"].get("args", [])
+                kwargs = msg["parameter"].get("kwargs", {})
+                res = self.run_rpc(obj, method, args, kwargs)
+            except Exception as e:
+                content = traceback.format_exc()
+                logger.error(f"Error while executing RPC instruction: {content}")
+                self.send_response(request_id, False, {"error": content})
+            else:
+                logger.debug(f"RPC instruction executed successfully: {res}")
+                self.send_response(request_id, True, {"result": res})
+
+    def send_response(self, request_id: str, accepted: bool, msg: dict):
+        self.client.connector.set_and_publish(
+            MessageEndpoints.gui_instruction_response(request_id),
+            messages.RequestResponseMessage(accepted=accepted, message=msg),
+            expire=60,
+        )
+
+    def get_object_from_config(self, config: dict):
+        gui_id = config.get("gui_id")
+        obj = self.rpc_register.get_rpc_by_id(gui_id)
+        if obj is None:
+            raise ValueError(f"Object with gui_id {gui_id} not found")
+        return obj
+
+    def run_rpc(self, obj, method, args, kwargs):
+        # Run with rpc registry broadcast, but only once
+        with RPCRegister.delayed_broadcast():
+            logger.debug(f"Running RPC instruction: {method} with args: {args}, kwargs: {kwargs}")
+            method_obj = getattr(obj, method)
+            # check if the method accepts args and kwargs
+            if not callable(method_obj):
+                if not args:
+                    res = method_obj
+                else:
+                    setattr(obj, method, args[0])
+                    res = None
+            else:
+                res = method_obj(*args, **kwargs)
+
+            if isinstance(res, list):
+                res = [self.serialize_object(obj) for obj in res]
+            elif isinstance(res, dict):
+                res = {key: self.serialize_object(val) for key, val in res.items()}
+            else:
+                res = self.serialize_object(res)
+            return res
+
+    def serialize_object(self, obj):
+        if isinstance(obj, BECConnector):
+            # Respect RPC = False
+            if hasattr(obj, "RPC") and obj.RPC is False:
+                return None
+            return self._serialize_bec_connector(obj)
+        return obj
+
+    def emit_heartbeat(self):
+        logger.trace(f"Emitting heartbeat for {self.gui_id}")
+        try:
+            self.client.connector.set(
+                MessageEndpoints.gui_heartbeat(self.gui_id),
+                messages.StatusMessage(name=self.gui_id, status=self.status, info={}),
+                expire=10,
+            )
+        except RedisError as exc:
+            logger.error(f"Error while emitting heartbeat: {exc}")
+
+    # FIXME signature should be changed on all levels, connection dict is no longer needed
+    def broadcast_registry_update(self, _):
+        # 1) Gather ALL BECConnector-based widgets
+        all_qwidgets = QApplication.allWidgets()
+        bec_widgets = set(w for w in all_qwidgets if isinstance(w, BECConnector))
+        bec_widgets = {
+            c for c in bec_widgets if not (hasattr(c, "RPC") and c.RPC is False)
+        }  # FIXME not needed
+
+        # 2) Also gather BECConnector-based data items from PlotBase
+        # TODO do we need to access plot data items in cli in namespace?
+        for w in all_qwidgets:
+            if isinstance(w, PlotBase) and hasattr(w, "plot_item"):
+                if hasattr(w.plot_item, "listDataItems"):
+                    for data_item in w.plot_item.listDataItems():
+                        if isinstance(data_item, BECConnector):
+                            bec_widgets.add(data_item)
+
+        # 3) Convert each BECConnector to a JSON-like dict
+        registry_data = {}
+        for connector in bec_widgets:
+            if not hasattr(connector, "config"):
+                continue
+            serialized = self._serialize_bec_connector(connector)
+            registry_data[serialized["gui_id"]] = serialized
+
+        # 4) Broadcast the final dictionary
+        for callback in self._registry_update_callbacks:
+            callback(registry_data)
+
+        # FIXME this message is bugged and it was even before mine refactor of parent logic
+        # logger.info(f"Broadcasting registry update: {registry_data} for {self.gui_id}")
+        self.client.connector.xadd(
+            MessageEndpoints.gui_registry_state(self.gui_id),
+            msg_dict={"data": messages.GUIRegistryStateMessage(state=registry_data)},
+            max_size=1,
+        )
+
+    def _serialize_bec_connector(self, connector: BECConnector) -> dict:
+        """
+        Create the serialization dict for a single BECConnector,
+        setting 'parent_id' via the real nearest BECConnector parent.
+        """
+
+        parent = WidgetHierarchy._get_becwidget_ancestor(connector)
+        parent_id = parent.gui_id if parent else None
+
+        config_dict = connector.config.model_dump()
+        config_dict["parent_id"] = parent_id
+
+        return {
+            "gui_id": connector.gui_id,
+            "name": connector._name or connector.__class__.__name__,
+            "widget_class": connector.__class__.__name__,
+            "config": config_dict,
+            "__rpc__": True,
+        }
+
+    # Suppose clients register callbacks to receive updates
+    def add_registry_update_callback(self, cb):
+        self._registry_update_callbacks.append(cb)
+
+    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
+        self.status = messages.BECStatus.IDLE
+        self._heartbeat_timer.stop()
+        self.emit_heartbeat()
+        logger.info("Succeded in shutting down CLI server")
+        self.client.shutdown()

bec_widgets/utils/error_popups.py

@@ -177,8 +177,9 @@ class _ErrorPopupUtility(QObject):
         msg.setStandardButtons(QMessageBox.Ok)
         msg.setDetailedText(detailed_text)
         msg.setTextInteractionFlags(Qt.TextSelectableByMouse)
-        msg.setMinimumWidth(600)
-        msg.setMinimumHeight(400)
+        msg.resize(800, 800)
+        # msg.setMinimumWidth(600)
+        # msg.setMinimumHeight(400)
         msg.exec_()
 
     def show_property_error(self, title, message, widget):

bec_widgets/utils/palette_viewer.py

@@ -24,8 +24,8 @@ class PaletteViewer(BECWidget, QWidget):
     ICON_NAME = "palette"
 
     def __init__(self, *args, parent=None, **kwargs):
-        super().__init__(*args, theme_update=True, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, *args, theme_update=True, **kwargs)
         self.setFixedSize(400, 600)
         layout = QVBoxLayout(self)
         dark_mode_button = DarkModeButton(self)

bec_widgets/utils/toolbar.py

@@ -858,7 +858,7 @@ class MainWindow(QMainWindow):  # pragma: no cover
 
         # For theme testing
 
-        self.dark_button = DarkModeButton(toolbar=True)
+        self.dark_button = DarkModeButton(parent=self, toolbar=True)
         dark_mode_action = WidgetAction(label=None, widget=self.dark_button)
         self.toolbar.add_action("dark_mode", dark_mode_action, self)
 

bec_widgets/utils/ui_loader.py

@@ -1,11 +1,14 @@
-import os
+import inspect
 
+from bec_lib.logger import bec_logger
 from qtpy import PYQT6, PYSIDE6, QT_VERSION
 from qtpy.QtCore import QFile, QIODevice
 
 from bec_widgets.utils.generate_designer_plugin import DesignerPluginInfo
 from bec_widgets.utils.plugin_utils import get_custom_classes
 
+logger = bec_logger.logger
+
 if PYSIDE6:
     from PySide6.QtUiTools import QUiLoader
 
@@ -18,10 +21,19 @@ if PYSIDE6:
 
         def createWidget(self, class_name, parent=None, name=""):
             if class_name in self.custom_widgets:
-                widget = self.custom_widgets[class_name](parent)
+
+                # check if the custom widget has a parent_id argument
+                if "parent_id" in inspect.signature(self.custom_widgets[class_name]).parameters:
+                    gui_id = getattr(self.baseinstance, "gui_id", None)
+                    widget = self.custom_widgets[class_name](self.baseinstance, parent_id=gui_id)
+                else:
+                    logger.warning(
+                        f"Custom widget {class_name} does not have a parent_id argument. "
+                    )
+                    widget = self.custom_widgets[class_name](self.baseinstance)
                 widget.setObjectName(name)
                 return widget
-            return super().createWidget(class_name, parent, name)
+            return super().createWidget(class_name, self.baseinstance, name)
 
 
 class UILoader:
@@ -51,7 +63,7 @@ class UILoader:
         Returns:
             QWidget: The loaded widget.
         """
-
+        parent = parent or self.parent
         loader = CustomUiLoader(parent, self.custom_widgets)
         file = QFile(ui_file)
         if not file.open(QIODevice.ReadOnly):

bec_widgets/utils/widget_io.py

@@ -275,39 +275,160 @@ class WidgetHierarchy:
         grab_values: bool = False,
         prefix: str = "",
         exclude_internal_widgets: bool = True,
+        only_bec_widgets: bool = False,
+        show_parent: bool = True,
     ) -> None:
         """
         Print the widget hierarchy to the console.
 
         Args:
-            widget: Widget to print the hierarchy of
+            widget: Widget to print the hierarchy of.
             indent(int, optional): Level of indentation.
             grab_values(bool,optional): Whether to grab the values of the widgets.
-            prefix(stc,optional): Custom string prefix for indentation.
+            prefix(str,optional): Custom string prefix for indentation.
             exclude_internal_widgets(bool,optional): Whether to exclude internal widgets (e.g. QComboBox in PyQt6).
+            only_bec_widgets(bool, optional): Whether to print only widgets that are instances of BECWidget.
+            show_parent(bool, optional): Whether to display which BECWidget is the parent of each discovered BECWidget.
         """
-        widget_info = f"{widget.__class__.__name__} ({widget.objectName()})"
-        if grab_values:
-            value = WidgetIO.get_value(widget, ignore_errors=True)
-            value_str = f" [value: {value}]" if value is not None else ""
-            widget_info += value_str
+        from bec_widgets.utils import BECConnector
+        from bec_widgets.widgets.plots.waveform.waveform import Waveform
 
+        # 1) Filter out widgets that are not BECConnectors (if 'only_bec_widgets' is True)
+        is_bec = isinstance(widget, BECConnector)
+        if only_bec_widgets and not is_bec:
+            return
+
+        # 2) Determine and print the parent's info (closest BECConnector)
+        parent_info = ""
+        if show_parent and is_bec:
+            ancestor = WidgetHierarchy._get_becwidget_ancestor(widget)
+            if ancestor:
+                parent_label = ancestor.objectName() or ancestor.__class__.__name__
+                parent_info = f" parent={parent_label}"
+            else:
+                parent_info = " parent=None"
+
+        widget_info = f"{widget.__class__.__name__} ({widget.objectName()}){parent_info}"
         print(prefix + widget_info)
 
-        children = widget.children()
-        for child in children:
-            if (
-                exclude_internal_widgets
-                and isinstance(widget, QComboBox)
-                and child.__class__.__name__ in ["QFrame", "QBoxLayout", "QListView"]
-            ):
+        # 3) If it's a Waveform, explicitly print the curves
+        if isinstance(widget, Waveform):
+            for curve in widget.curves:
+                curve_prefix = prefix + "  └─ "
+                print(
+                    f"{curve_prefix}{curve.__class__.__name__} ({curve.objectName()}) "
+                    f"parent={widget.objectName()}"
+                )
+
+        # 4) Recursively handle each child if:
+        #    - It's a QWidget
+        #    - It is a BECConnector (or we don't care about filtering)
+        #    - Its closest BECConnector parent is the current widget
+        for child in widget.findChildren(QWidget):
+            if only_bec_widgets and not isinstance(child, BECConnector):
                 continue
-            child_prefix = prefix + "  "
-            arrow = "├─ " if child != children[-1] else "└─ "
+
+            # if WidgetHierarchy._get_becwidget_ancestor(child) == widget:
+            child_prefix = prefix + "  └─ "
             WidgetHierarchy.print_widget_hierarchy(
-                child, indent + 1, grab_values, prefix=child_prefix + arrow
+                child,
+                indent=indent + 1,
+                grab_values=grab_values,
+                prefix=child_prefix,
+                exclude_internal_widgets=exclude_internal_widgets,
+                only_bec_widgets=only_bec_widgets,
+                show_parent=show_parent,
             )
 
+    @staticmethod
+    def print_becconnector_hierarchy_from_app():
+        """
+        Enumerate ALL BECConnector objects in the QApplication.
+        Also detect if a widget is a PlotBase, and add any data items
+        (PlotDataItem-like) that are also BECConnector objects.
+
+        Build a parent->children graph where each child's 'parent'
+        is its closest BECConnector ancestor. Print the entire hierarchy
+        from the root(s).
+
+        The result is a single, consolidated tree for your entire
+        running GUI, including PlotBase data items that are BECConnector.
+        """
+        import sys
+        from collections import defaultdict
+
+        from qtpy.QtWidgets import QApplication
+
+        from bec_widgets.utils import BECConnector
+        from bec_widgets.widgets.plots.plot_base import PlotBase
+
+        # 1) Gather ALL QWidget-based BECConnector objects
+        all_qwidgets = QApplication.allWidgets()
+        bec_widgets = set(w for w in all_qwidgets if isinstance(w, BECConnector))
+
+        # 2) Also gather any BECConnector-based data items from PlotBase widgets
+        for w in all_qwidgets:
+            if isinstance(w, PlotBase) and hasattr(w, "plot_item"):
+                plot_item = w.plot_item
+                if hasattr(plot_item, "listDataItems"):
+                    for data_item in plot_item.listDataItems():
+                        if isinstance(data_item, BECConnector):
+                            bec_widgets.add(data_item)
+
+        # 3) Build a map of (closest BECConnector parent) -> list of children
+        parent_map = defaultdict(list)
+        for w in bec_widgets:
+            parent_bec = WidgetHierarchy._get_becwidget_ancestor(w)
+            parent_map[parent_bec].append(w)
+
+        # 4) Define a recursive printer to show each object's children
+        def print_tree(parent, prefix=""):
+            children = parent_map[parent]
+            for i, child in enumerate(children):
+                connector_class = child.__class__.__name__
+                connector_name = child.objectName() or connector_class
+
+                if parent is None:
+                    parent_label = "None"
+                else:
+                    parent_label = parent.objectName() or parent.__class__.__name__
+
+                line = f"{connector_class} ({connector_name}) parent={parent_label}"
+                # Determine tree-branch symbols
+                is_last = i == len(children) - 1
+                branch_str = "└─ " if is_last else "├─ "
+                print(prefix + branch_str + line)
+
+                # Recurse deeper
+                next_prefix = prefix + ("   " if is_last else "│  ")
+                print_tree(child, prefix=next_prefix)
+
+        # 5) Print top-level items (roots) whose BECConnector parent is None
+        roots = parent_map[None]
+        for r_i, root in enumerate(roots):
+            root_class = root.__class__.__name__
+            root_name = root.objectName() or root_class
+            line = f"{root_class} ({root_name}) parent=None"
+            is_last_root = r_i == len(roots) - 1
+            print(line)
+            # Recurse into its children
+            print_tree(root, prefix="   ")
+
+    @staticmethod
+    def _get_becwidget_ancestor(widget):
+        """
+        Traverse up the parent chain to find the nearest BECConnector.
+        Returns None if none is found.
+        """
+        from bec_widgets.utils import BECConnector
+
+        parent = widget.parent()
+        while parent is not None:
+            if isinstance(parent, BECConnector):
+                return parent
+            parent = parent.parent()
+        return None
+
     @staticmethod
     def export_config_to_dict(
         widget: QWidget,

bec_widgets/widgets/containers/dock/dock.py

@@ -148,11 +148,11 @@ class BECDock(BECWidget, Dock):
             if isinstance(config, dict):
                 config = DockConfig(**config)
             self.config = config
-        super().__init__(
-            client=client, config=config, gui_id=gui_id, name=name, parent_id=parent_id
-        )  # Name was checked and created in BEC Widget
         label = CustomDockLabel(text=name, closable=closable)
         Dock.__init__(self, name=name, label=label, parent=self, **kwargs)
+        BECWidget.__init__(
+            self, client=client, config=config, gui_id=gui_id, name=name, parent_id=parent_id
+        )  # Name was checked and created in BEC Widget
         # Dock.__init__(self, name=name, **kwargs)
 
         self.parent_dock_area = parent_dock_area

bec_widgets/widgets/containers/dock/dock_area.py

@@ -21,6 +21,7 @@ from bec_widgets.utils.toolbar import (
     ModularToolBar,
     SeparatorAction,
 )
+from bec_widgets.utils.widget_io import WidgetHierarchy
 from bec_widgets.widgets.containers.dock.dock import BECDock, DockConfig
 from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
 from bec_widgets.widgets.control.scan_control.scan_control import ScanControl
@@ -82,8 +83,8 @@ class BECDockArea(BECWidget, QWidget):
             if isinstance(config, dict):
                 config = DockAreaConfig(**config)
             self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id, name=name, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, name=name, **kwargs)
         self._parent = parent
         self.layout = QVBoxLayout(self)
         self.layout.setSpacing(5)
@@ -91,8 +92,10 @@ class BECDockArea(BECWidget, QWidget):
 
         self._instructions_visible = True
 
+        self.dark_mode_button = DarkModeButton(parent=self, parent_id=self.gui_id, toolbar=True)
         self.dock_area = DockArea()
         self.toolbar = ModularToolBar(
+            parent=self,
             actions={
                 "menu_plots": ExpandableMenuAction(
                     label="Add Plot ",
@@ -172,7 +175,7 @@ class BECDockArea(BECWidget, QWidget):
         self.spacer = QWidget()
         self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
         self.toolbar.addWidget(self.spacer)
-        self.toolbar.addWidget(DarkModeButton(toolbar=True))
+        self.toolbar.addWidget(self.dark_mode_button)
         self._hook_toolbar()
 
     def minimumSizeHint(self):
@@ -432,6 +435,8 @@ class BECDockArea(BECWidget, QWidget):
         self.delete_all()
         self.toolbar.close()
         self.toolbar.deleteLater()
+        self.dark_mode_button.close()
+        self.dark_mode_button.deleteLater()
         self.dock_area.close()
         self.dock_area.deleteLater()
         super().cleanup()
@@ -496,10 +501,12 @@ if __name__ == "__main__":  # pragma: no cover
     set_theme("auto")
     dock_area = BECDockArea()
     dock_1 = dock_area.new(name="dock_0", widget="Waveform")
+    dock_1.new(widget="Waveform")
     # dock_1 = dock_area.new(name="dock_0", widget="Waveform")
     dock_area.new(widget="Waveform")
     dock_area.show()
     dock_area.setGeometry(100, 100, 800, 600)
+    WidgetHierarchy.print_becconnector_hierarchy_from_app()
     app.topLevelWidgets()
     app.exec_()
     sys.exit(app.exec_())

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

@@ -0,0 +1,15 @@
+import webbrowser
+
+
+class BECWebLinksMixin:
+    @staticmethod
+    def open_bec_docs():
+        webbrowser.open("https://beamline-experiment-control.readthedocs.io/en/latest/")
+
+    @staticmethod
+    def open_bec_widgets_docs():
+        webbrowser.open("https://bec.readthedocs.io/projects/bec-widgets/en/latest/")
+
+    @staticmethod
+    def open_bec_bug_report():
+        webbrowser.open("https://gitlab.psi.ch/groups/bec/-/issues/")

bec_widgets/widgets/containers/main_window/example_app.ui

@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+    <class>Form</class>
+    <widget class="QWidget" name="Form">
+        <property name="geometry">
+            <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>824</width>
+                <height>1320</height>
+            </rect>
+        </property>
+        <property name="windowTitle">
+            <string>Form</string>
+        </property>
+        <layout class="QVBoxLayout" name="verticalLayout_3">
+            <item>
+                <widget class="QTabWidget" name="tabWidget">
+                    <property name="currentIndex">
+                        <number>1</number>
+                    </property>
+                    <widget class="QWidget" name="tab">
+                        <attribute name="title">
+                            <string>Tab 1</string>
+                        </attribute>
+                        <layout class="QVBoxLayout" name="verticalLayout">
+                            <item>
+                                <widget class="Waveform" name="waveform"/>
+                            </item>
+                            <item>
+                                <widget class="Waveform" name="waveform_2"/>
+                            </item>
+                        </layout>
+                    </widget>
+                    <widget class="QWidget" name="tab_2">
+                        <attribute name="title">
+                            <string>Tab 2</string>
+                        </attribute>
+                        <layout class="QVBoxLayout" name="verticalLayout_2">
+                            <item>
+                                <widget class="BECDockArea" name="dock_area"/>
+                            </item>
+                            <item>
+                                <widget class="BECDockArea" name="dock_area_2"/>
+                            </item>
+                        </layout>
+                    </widget>
+                </widget>
+            </item>
+        </layout>
+    </widget>
+    <customwidgets>
+        <customwidget>
+            <class>BECDockArea</class>
+            <extends>QWidget</extends>
+            <header>dock_area</header>
+        </customwidget>
+        <customwidget>
+            <class>Waveform</class>
+            <extends>QWidget</extends>
+            <header>waveform</header>
+        </customwidget>
+    </customwidgets>
+    <resources/>
+    <connections/>
+</ui>

bec_widgets/widgets/containers/main_window/general_app.ui

@@ -0,0 +1,262 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+    <class>MainWindow</class>
+    <widget class="QMainWindow" name="MainWindow">
+        <property name="geometry">
+            <rect>
+                <x>0</x>
+                <y>0</y>
+                <width>1718</width>
+                <height>1139</height>
+            </rect>
+        </property>
+        <property name="windowTitle">
+            <string>MainWindow</string>
+        </property>
+        <property name="tabShape">
+            <enum>QTabWidget::TabShape::Rounded</enum>
+        </property>
+        <widget class="QWidget" name="centralwidget">
+            <layout class="QVBoxLayout" name="verticalLayout_3">
+                <item>
+                    <widget class="QTabWidget" name="central_tab">
+                        <property name="currentIndex">
+                            <number>0</number>
+                        </property>
+                        <widget class="QWidget" name="dock_area_tab">
+                            <attribute name="title">
+                                <string>Dock Area</string>
+                            </attribute>
+                            <layout class="QVBoxLayout" name="verticalLayout">
+                                <property name="leftMargin">
+                                    <number>2</number>
+                                </property>
+                                <property name="topMargin">
+                                    <number>1</number>
+                                </property>
+                                <property name="rightMargin">
+                                    <number>2</number>
+                                </property>
+                                <property name="bottomMargin">
+                                    <number>2</number>
+                                </property>
+                                <item>
+                                    <widget class="BECDockArea" name="dock_area"/>
+                                </item>
+                            </layout>
+                        </widget>
+                        <widget class="QWidget" name="vscode_tab">
+                            <attribute name="icon">
+                                <iconset theme="QIcon::ThemeIcon::Computer"/>
+                            </attribute>
+                            <attribute name="title">
+                                <string>Visual Studio Code</string>
+                            </attribute>
+                            <layout class="QVBoxLayout" name="verticalLayout_2">
+                                <property name="leftMargin">
+                                    <number>2</number>
+                                </property>
+                                <property name="topMargin">
+                                    <number>1</number>
+                                </property>
+                                <property name="rightMargin">
+                                    <number>2</number>
+                                </property>
+                                <property name="bottomMargin">
+                                    <number>2</number>
+                                </property>
+                                <item>
+                                    <widget class="VSCodeEditor" name="vscode"/>
+                                </item>
+                            </layout>
+                        </widget>
+                    </widget>
+                </item>
+            </layout>
+        </widget>
+        <widget class="QMenuBar" name="menubar">
+            <property name="geometry">
+                <rect>
+                    <x>0</x>
+                    <y>0</y>
+                    <width>1718</width>
+                    <height>31</height>
+                </rect>
+            </property>
+            <widget class="QMenu" name="menuHelp">
+                <property name="title">
+                    <string>Help</string>
+                </property>
+                <addaction name="action_BEC_docs"/>
+                <addaction name="action_BEC_widgets_docs"/>
+                <addaction name="action_bug_report"/>
+            </widget>
+            <widget class="QMenu" name="menuTheme">
+                <property name="title">
+                    <string>Theme</string>
+                </property>
+                <addaction name="action_light"/>
+                <addaction name="action_dark"/>
+            </widget>
+            <addaction name="menuTheme"/>
+            <addaction name="menuHelp"/>
+        </widget>
+        <widget class="QStatusBar" name="statusbar"/>
+        <widget class="QDockWidget" name="dock_scan_control">
+            <property name="windowTitle">
+                <string>Scan Control</string>
+            </property>
+            <attribute name="dockWidgetArea">
+                <number>2</number>
+            </attribute>
+            <widget class="QWidget" name="dockWidgetContents_2">
+                <layout class="QVBoxLayout" name="verticalLayout_4">
+                    <item>
+                        <widget class="ScanControl" name="scan_control"/>
+                    </item>
+                </layout>
+            </widget>
+        </widget>
+        <widget class="QDockWidget" name="dock_status_2">
+            <property name="windowTitle">
+                <string>BEC Service Status</string>
+            </property>
+            <attribute name="dockWidgetArea">
+                <number>2</number>
+            </attribute>
+            <widget class="QWidget" name="dockWidgetContents_3">
+                <layout class="QVBoxLayout" name="verticalLayout_5">
+                    <property name="leftMargin">
+                        <number>0</number>
+                    </property>
+                    <property name="topMargin">
+                        <number>0</number>
+                    </property>
+                    <property name="rightMargin">
+                        <number>0</number>
+                    </property>
+                    <property name="bottomMargin">
+                        <number>0</number>
+                    </property>
+                    <item>
+                        <widget class="BECStatusBox" name="bec_status_box_2"/>
+                    </item>
+                </layout>
+            </widget>
+        </widget>
+        <widget class="QDockWidget" name="dock_queue">
+            <property name="windowTitle">
+                <string>Scan Queue</string>
+            </property>
+            <attribute name="dockWidgetArea">
+                <number>2</number>
+            </attribute>
+            <widget class="QWidget" name="dockWidgetContents_4">
+                <layout class="QVBoxLayout" name="verticalLayout_6">
+                    <property name="leftMargin">
+                        <number>0</number>
+                    </property>
+                    <property name="topMargin">
+                        <number>0</number>
+                    </property>
+                    <property name="rightMargin">
+                        <number>0</number>
+                    </property>
+                    <property name="bottomMargin">
+                        <number>0</number>
+                    </property>
+                    <item>
+                        <widget class="BECQueue" name="bec_queue">
+                            <row/>
+                            <column/>
+                            <column/>
+                            <column/>
+                            <item row="0" column="0"/>
+                            <item row="0" column="1"/>
+                            <item row="0" column="2"/>
+                        </widget>
+                    </item>
+                </layout>
+            </widget>
+        </widget>
+        <action name="action_BEC_docs">
+            <property name="icon">
+                <iconset theme="QIcon::ThemeIcon::DialogQuestion"/>
+            </property>
+            <property name="text">
+                <string>BEC Docs</string>
+            </property>
+        </action>
+        <action name="action_BEC_widgets_docs">
+            <property name="icon">
+                <iconset theme="QIcon::ThemeIcon::DialogQuestion"/>
+            </property>
+            <property name="text">
+                <string>BEC Widgets Docs</string>
+            </property>
+        </action>
+        <action name="action_bug_report">
+            <property name="icon">
+                <iconset theme="QIcon::ThemeIcon::DialogError"/>
+            </property>
+            <property name="text">
+                <string>Bug Report</string>
+            </property>
+        </action>
+        <action name="action_light">
+            <property name="checkable">
+                <bool>true</bool>
+            </property>
+            <property name="text">
+                <string>Light</string>
+            </property>
+        </action>
+        <action name="action_dark">
+            <property name="checkable">
+                <bool>true</bool>
+            </property>
+            <property name="text">
+                <string>Dark</string>
+            </property>
+        </action>
+    </widget>
+    <customwidgets>
+        <customwidget>
+            <class>WebsiteWidget</class>
+            <extends>QWebEngineView</extends>
+            <header>website_widget</header>
+        </customwidget>
+        <customwidget>
+            <class>BECQueue</class>
+            <extends>QTableWidget</extends>
+            <header>bec_queue</header>
+        </customwidget>
+        <customwidget>
+            <class>ScanControl</class>
+            <extends>QWidget</extends>
+            <header>scan_control</header>
+        </customwidget>
+        <customwidget>
+            <class>VSCodeEditor</class>
+            <extends>WebsiteWidget</extends>
+            <header>vs_code_editor</header>
+        </customwidget>
+        <customwidget>
+            <class>BECStatusBox</class>
+            <extends>QWidget</extends>
+            <header>bec_status_box</header>
+        </customwidget>
+        <customwidget>
+            <class>BECDockArea</class>
+            <extends>QWidget</extends>
+            <header>dock_area</header>
+        </customwidget>
+        <customwidget>
+            <class>QWebEngineView</class>
+            <extends></extends>
+            <header location="global">QtWebEngineWidgets/QWebEngineView</header>
+        </customwidget>
+    </customwidgets>
+    <resources/>
+    <connections/>
+</ui>

bec_widgets/widgets/containers/main_window/main_window.py

@@ -1,74 +1,171 @@
-from bec_lib.logger import bec_logger
-from qtpy.QtWidgets import QApplication, QMainWindow
+import os
 
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from qtpy.QtCore import QSize
+from qtpy.QtGui import QAction, QActionGroup, QIcon
+from qtpy.QtWidgets import QApplication, QMainWindow, QStyle
+
+import bec_widgets
+from bec_lib.logger import bec_logger
+from bec_widgets.utils import UILoader
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.container_utils import WidgetContainerUtils
-from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.widget_io import WidgetHierarchy
+from bec_widgets.widgets.containers.main_window.addons.web_links import BECWebLinksMixin
 
 logger = bec_logger.logger
 
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+
 
 class BECMainWindow(BECWidget, QMainWindow):
-    def __init__(self, gui_id: str = None, *args, **kwargs):
-        BECWidget.__init__(self, gui_id=gui_id, **kwargs)
+    def __init__(self, gui_id: str = None, client=None, window_title: str = "BEC", *args, **kwargs):
         QMainWindow.__init__(self, *args, **kwargs)
+        BECWidget.__init__(self, gui_id=gui_id, client=client, **kwargs)
 
-    def _dump(self):
-        """Return a dictionary with informations about the application state, for use in tests"""
-        # TODO: ModularToolBar and something else leak top-level widgets (3 or 4 QMenu + 2 QWidget);
-        # so, a filtering based on title is applied here, but the solution is to not have those widgets
-        # as top-level (so for now, a window with no title does not appear in _dump() result)
+        self.app = QApplication.instance()
+        self.setWindowTitle(window_title)
+        self._init_ui()
 
-        # NOTE: the main window itself is excluded, since we want to dump dock areas
-        info = {
-            tlw.gui_id: {
-                "title": tlw.windowTitle(),
-                "visible": tlw.isVisible(),
-                "class": str(type(tlw)),
-            }
-            for tlw in QApplication.instance().topLevelWidgets()
-            if tlw is not self and tlw.windowTitle()
-        }
-        # Add the main window dock area
-        info[self.centralWidget().gui_id] = {
-            "title": self.windowTitle(),
-            "visible": self.isVisible(),
-            "class": str(type(self.centralWidget())),
-        }
-        return info
+    def _init_ui(self):
 
-    def new_dock_area(
-        self, name: str | None = None, geometry: tuple[int, int, int, int] | None = None
-    ) -> BECDockArea:
-        """Create a new dock area.
+        # Set the icon
+        self._init_bec_icon()
 
-        Args:
-            name(str): The name of the dock area.
-            geometry(tuple): The geometry parameters to be passed to the dock area.
-        Returns:
-            BECDockArea: The newly created dock area.
+        # Set Menu and Status bar
+        self._setup_menu_bar()
+
+        # BEC Specific UI
+        self.display_app_id()
+
+    def _init_bec_icon(self):
+        icon = self.app.windowIcon()
+        if icon.isNull():
+            print("No icon is set, setting default icon")
+            icon = QIcon()
+            icon.addFile(
+                os.path.join(MODULE_PATH, "assets", "app_icons", "bec_widgets_icon.png"),
+                size=QSize(48, 48),
+            )
+            self.app.setWindowIcon(icon)
+        else:
+            print("An icon is set")
+
+    def load_ui(self, ui_file):
+        loader = UILoader(self)
+        self.ui = loader.loader(ui_file)
+        self.setCentralWidget(self.ui)
+
+    def display_app_id(self):
+        server_id = self.bec_dispatcher.cli_server.gui_id
+        self.statusBar().showMessage(f"App ID: {server_id}")
+
+    def _fetch_theme(self) -> str:
+        return self.app.theme.theme
+
+    def _setup_menu_bar(self):
         """
-        with RPCRegister.delayed_broadcast() as rpc_register:
-            existing_dock_areas = rpc_register.get_names_of_rpc_by_class_type(BECDockArea)
-            if name is not None:
-                if name in existing_dock_areas:
-                    raise ValueError(
-                        f"Name {name} must be unique for dock areas, but already exists: {existing_dock_areas}."
-                    )
-            else:
-                name = "dock_area"
-                name = WidgetContainerUtils.generate_unique_name(name, existing_dock_areas)
-            dock_area = BECDockArea(name=name)
-            dock_area.resize(dock_area.minimumSizeHint())
-            # TODO Should we simply use the specified name as title here?
-            dock_area.window().setWindowTitle(f"BEC - {name}")
-            logger.info(f"Created new dock area: {name}")
-            logger.info(f"Existing dock areas: {geometry}")
-            if geometry is not None:
-                dock_area.setGeometry(*geometry)
-            dock_area.show()
-            return dock_area
+        Setup the menu bar for the main window.
+        """
+        menu_bar = self.menuBar()
+
+        ########################################
+        # Theme menu
+        theme_menu = menu_bar.addMenu("Theme")
+
+        theme_group = QActionGroup(self)
+        light_theme_action = QAction("Light Theme", self, checkable=True)
+        dark_theme_action = QAction("Dark Theme", self, checkable=True)
+        theme_group.addAction(light_theme_action)
+        theme_group.addAction(dark_theme_action)
+        theme_group.setExclusive(True)
+
+        theme_menu.addAction(light_theme_action)
+        theme_menu.addAction(dark_theme_action)
+
+        # Connect theme actions
+        light_theme_action.triggered.connect(lambda: self.change_theme("light"))
+        dark_theme_action.triggered.connect(lambda: self.change_theme("dark"))
+
+        # Set the default theme
+        theme = self.app.theme.theme
+        if theme == "light":
+            light_theme_action.setChecked(True)
+        elif theme == "dark":
+            dark_theme_action.setChecked(True)
+
+        ########################################
+        # Help menu
+        help_menu = menu_bar.addMenu("Help")
+
+        help_icon = QApplication.style().standardIcon(QStyle.SP_MessageBoxQuestion)
+        bug_icon = QApplication.style().standardIcon(QStyle.SP_MessageBoxInformation)
+
+        bec_docs = QAction("BEC Docs", self)
+        bec_docs.setIcon(help_icon)
+        widgets_docs = QAction("BEC Widgets Docs", self)
+        widgets_docs.setIcon(help_icon)
+        bug_report = QAction("Bug Report", self)
+        bug_report.setIcon(bug_icon)
+
+        bec_docs.triggered.connect(BECWebLinksMixin.open_bec_docs)
+        widgets_docs.triggered.connect(BECWebLinksMixin.open_bec_widgets_docs)
+        bug_report.triggered.connect(BECWebLinksMixin.open_bec_bug_report)
+
+        help_menu.addAction(bec_docs)
+        help_menu.addAction(widgets_docs)
+        help_menu.addAction(bug_report)
+
+    @SafeSlot(str)
+    def change_theme(self, theme: str):
+        apply_theme(theme)
 
     def cleanup(self):
         super().close()
+
+
+class WindowWithUi(BECMainWindow):
+    """
+    This is just testing app wiht UI file which could be connected to RPC.
+
+    """
+
+    USER_ACCESS = ["new_dock_area", "all_connections", "change_theme", "hierarchy"]
+
+    def __init__(self, *args, name: str = None, **kwargs):
+        super().__init__(gui_id="test", *args, **kwargs)
+        if name is None:
+            name = self.__class__.__name__
+        else:
+            if not WidgetContainerUtils.has_name_valid_chars(name):
+                raise ValueError(f"Name {name} contains invalid characters.")
+        self._name = name if name else self.__class__.__name__
+        ui_file_path = os.path.join(os.path.dirname(__file__), "example_app.ui")
+        self.load_ui(ui_file_path)
+
+    def load_ui(self, ui_file):
+        loader = UILoader(self)
+        self.ui = loader.loader(ui_file)
+        self.setCentralWidget(self.ui)
+
+    @property
+    def all_connections(self) -> list:
+        all_connections = self.rpc_register.list_all_connections()
+        all_connections_keys = list(all_connections.keys())
+        return all_connections_keys
+
+    def hierarchy(self):
+        WidgetHierarchy.print_widget_hierarchy(self, only_bec_widgets=True)
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    print(id(app))
+    # app = BECApplication(sys.argv)
+    # print(id(app))
+    main_window = WindowWithUi()
+    main_window.show()
+    sys.exit(app.exec())

bec_widgets/widgets/control/buttons/button_abort/button_abort.py

@@ -10,6 +10,7 @@ class AbortButton(BECWidget, QWidget):
     """A button that abort the scan."""
 
     PLUGIN = True
+    RPC = False
     ICON_NAME = "cancel"
 
     def __init__(
@@ -22,8 +23,8 @@ class AbortButton(BECWidget, QWidget):
         scan_id=None,
         **kwargs,
     ):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
 
         self.get_bec_shortcuts()
 

bec_widgets/widgets/control/buttons/button_reset/button_reset.py

@@ -10,11 +10,12 @@ class ResetButton(BECWidget, QWidget):
     """A button that resets the scan queue."""
 
     PLUGIN = True
+    RPC = False
     ICON_NAME = "restart_alt"
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
 
         self.get_bec_shortcuts()
 

bec_widgets/widgets/control/buttons/button_resume/button_resume.py

@@ -10,11 +10,12 @@ class ResumeButton(BECWidget, QWidget):
     """A button that continue scan queue."""
 
     PLUGIN = True
+    RPC = False
     ICON_NAME = "resume"
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
 
         self.get_bec_shortcuts()
 

bec_widgets/widgets/control/buttons/stop_button/stop_button.py

@@ -10,11 +10,12 @@ class StopButton(BECWidget, QWidget):
     """A button that stops the current scan."""
 
     PLUGIN = True
+    RPC = False
     ICON_NAME = "dangerous"
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
 
         self.get_bec_shortcuts()
 

bec_widgets/widgets/control/device_control/position_indicator/position_indicator.py

@@ -13,8 +13,8 @@ class PositionIndicator(BECWidget, QWidget):
     ICON_NAME = "horizontal_distribute"
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, **kwargs):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
         self.position = 50
         self.min_value = 0
         self.max_value = 100

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

@@ -55,8 +55,8 @@ class PositionerBoxBase(BECWidget, CompactPopupWidget):
             parent: The parent widget.
             device (Positioner): The device to control.
         """
-        super().__init__(**kwargs)
         CompactPopupWidget.__init__(self, parent=parent, layout=QVBoxLayout)
+        BECWidget.__init__(self, **kwargs)
         self._dialog = None
         self.get_bec_shortcuts()
 

bec_widgets/widgets/control/device_control/positioner_group/positioner_group.py

@@ -69,8 +69,8 @@ class PositionerGroup(BECWidget, QWidget):
         Args:
             parent: The parent widget.
         """
-        super().__init__(**kwargs)
         QWidget.__init__(self, parent)
+        BECWidget.__init__(self, **kwargs)
 
         self.get_bec_shortcuts()
 

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

@@ -81,6 +81,7 @@ class DeviceInputBase(BECWidget):
         ReadoutPriority.CONTINUOUS: "readout_continuous",
         ReadoutPriority.ON_REQUEST: "readout_on_request",
     }
+    RPC = False
 
     def __init__(self, client=None, config=None, gui_id: str | None = None, **kwargs):
 

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

@@ -29,6 +29,8 @@ class DeviceSignalInputBase(BECWidget):
     signal object based on the current text of the widget.
     """
 
+    RPC = False
+
     _filter_handler = {
         Kind.hinted: "include_hinted_signals",
         Kind.normal: "include_normal_signals",

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

@@ -47,8 +47,8 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
         arg_name: str | None = None,
         **kwargs,
     ):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QComboBox.__init__(self, parent=parent)
+        DeviceInputBase.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
         if arg_name is not None:
             self.config.arg_name = arg_name
             self.arg_name = arg_name

bec_widgets/widgets/control/device_input/device_line_edit/device_line_edit.py

@@ -53,8 +53,8 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         self._callback_id = None
         self._is_valid_input = False
         self._accent_colors = get_accent_colors()
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QLineEdit.__init__(self, parent=parent)
+        DeviceInputBase.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
         self.completer = QCompleter(self)
         self.setCompleter(self.completer)
 

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

@@ -40,8 +40,8 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
         arg_name: str | None = None,
         **kwargs,
     ):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QComboBox.__init__(self, parent=parent)
+        DeviceSignalInputBase.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
         if arg_name is not None:
             self.config.arg_name = arg_name
             self.arg_name = arg_name

bec_widgets/widgets/control/device_input/signal_line_edit/signal_line_edit.py

@@ -42,8 +42,8 @@ class SignalLineEdit(DeviceSignalInputBase, QLineEdit):
         **kwargs,
     ):
         self._is_valid_input = False
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QLineEdit.__init__(self, parent=parent)
+        DeviceSignalInputBase.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
         self._accent_colors = get_accent_colors()
         self.completer = QCompleter(self)
         self.setCompleter(self.completer)

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -65,8 +65,8 @@ class ScanControl(BECWidget, QWidget):
             config = ScanControlConfig(
                 widget_class=self.__class__.__name__, allowed_scans=allowed_scans
             )
-        super().__init__(client=client, gui_id=gui_id, config=config, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
 
         self._hide_add_remove_buttons = False
 

bec_widgets/widgets/dap/dap_combo_box/dap_combo_box.py

@@ -44,8 +44,8 @@ class DapComboBox(BECWidget, QWidget):
         default_fit: str | None = None,
         **kwargs,
     ):
-        super().__init__(client=client, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, gui_id=gui_id, **kwargs)
         self.layout = QVBoxLayout(self)
         self.fit_model_combobox = QComboBox(self)
         self.layout.addWidget(self.fit_model_combobox)

bec_widgets/widgets/dap/lmfit_dialog/lmfit_dialog.py

@@ -43,10 +43,10 @@ class LMFitDialog(BECWidget, QWidget):
             gui_id (str): GUI ID.
             ui_file (str): The UI file to be loaded.
         """
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
         self.setProperty("skip_settings", True)
-        self.setObjectName("LMFitDialog")
+        # self.setObjectName("LMFitDialog")
         self._ui_file = ui_file
         self.target_widget = target_widget
 

bec_widgets/widgets/editors/scan_metadata/scan_metadata.py

@@ -51,8 +51,8 @@ class ScanMetadata(BECWidget, QWidget):
         initial_extras: list[list[str]] | None = None,
         **kwargs,
     ):
-        super().__init__(client=client, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, **kwargs)
 
         self.set_schema(scan_name)
 

bec_widgets/widgets/editors/text_box/text_box.py

@@ -49,8 +49,9 @@ class TextBox(BECWidget, QWidget):
             if isinstance(config, dict):
                 config = TextBoxConfig(**config)
             self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
+
         self.layout = QVBoxLayout(self)
         self.text_box_text_edit = QTextEdit(parent=self)
         self.layout.addWidget(self.text_box_text_edit)

bec_widgets/widgets/editors/website/website.py

@@ -26,8 +26,8 @@ class WebsiteWidget(BECWidget, QWidget):
     def __init__(
         self, parent=None, url: str = None, config=None, client=None, gui_id=None, **kwargs
     ):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
         layout = QVBoxLayout()
         layout.setContentsMargins(0, 0, 0, 0)
         self.website = QWebEngineView()

bec_widgets/widgets/games/minesweeper.py

@@ -146,8 +146,8 @@ class Minesweeper(BECWidget, QWidget):
     USER_ACCESS = []
 
     def __init__(self, parent=None, *args, **kwargs):
-        super().__init__(*args, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, *args, **kwargs)
 
         self._ui_initialised = False
         self._timer_start_num_seconds = 0

bec_widgets/widgets/plots/image/image.py

@@ -125,8 +125,8 @@ class Image(PlotBase):
         popups: bool = True,
         **kwargs,
     ):
-        self._main_image = ImageItem(parent_image=self)
         self._color_bar = None
+        self._main_image = None
         if config is None:
             config = ImageConfig(widget_class=self.__class__.__name__)
         super().__init__(
@@ -135,8 +135,6 @@ class Image(PlotBase):
 
         # For PropertyManager identification
         self.setObjectName("Image")
-
-        self.plot_item.addItem(self._main_image)
         self.scan_id = None
 
         # Default Color map to magma
@@ -145,6 +143,10 @@ class Image(PlotBase):
     ################################################################################
     # Widget Specific GUI interactions
     ################################################################################
+    def _init_main_image(self):
+        self._main_image = ImageItem(parent_image=self)
+        self.plot_item.addItem(self._main_image)
+
     def _init_toolbar(self):
 
         # add to the first position
@@ -270,7 +272,7 @@ class Image(PlotBase):
             style(Literal["full", "simple"]): The type of colorbar to enable.
             vrange(tuple): The range of values to use for the colorbar.
         """
-        autorange_state = self._main_image.autorange
+        autorange_state = self.main_image.autorange
         if enabled:
             if self._color_bar:
                 if self.config.color_bar == "full":
@@ -280,14 +282,14 @@ class Image(PlotBase):
 
             if style == "simple":
                 self._color_bar = pg.ColorBarItem(colorMap=self.config.color_map)
-                self._color_bar.setImageItem(self._main_image)
+                self._color_bar.setImageItem(self.main_image)
                 self._color_bar.sigLevelsChangeFinished.connect(
                     lambda: self.setProperty("autorange", False)
                 )
 
             elif style == "full":
                 self._color_bar = pg.HistogramLUTItem()
-                self._color_bar.setImageItem(self._main_image)
+                self._color_bar.setImageItem(self.main_image)
                 self._color_bar.gradient.loadPreset(self.config.color_map)
                 self._color_bar.sigLevelsChanged.connect(
                     lambda: self.setProperty("autorange", False)
@@ -374,7 +376,7 @@ class Image(PlotBase):
         """
         try:
             self.config.color_map = value
-            self._main_image.color_map = value
+            self.main_image.color_map = value
 
             if self._color_bar:
                 if self.config.color_bar == "simple":
@@ -390,7 +392,7 @@ class Image(PlotBase):
         """
         Set the v_range of the main image.
         """
-        vmin, vmax = self._main_image.v_range
+        vmin, vmax = self.main_image.v_range
         return QPointF(vmin, vmax)
 
     @v_range.setter
@@ -406,7 +408,7 @@ class Image(PlotBase):
 
         vmin, vmax = value.x(), value.y()
 
-        self._main_image.v_range = (vmin, vmax)
+        self.main_image.v_range = (vmin, vmax)
 
         # propagate to colorbar if exists
         if self._color_bar:
@@ -495,7 +497,7 @@ class Image(PlotBase):
         """
         The name of the monitor to use for the image.
         """
-        return self._main_image.config.monitor
+        return self.main_image.config.monitor
 
     @monitor.setter
     def monitor(self, value: str):
@@ -505,7 +507,7 @@ class Image(PlotBase):
         Args:
             value(str): The name of the monitor to set.
         """
-        if self._main_image.config.monitor == value:
+        if self.main_image.config.monitor == value:
             return
         try:
             self.entry_validator.validate_monitor(value)
@@ -516,6 +518,8 @@ class Image(PlotBase):
     @property
     def main_image(self) -> ImageItem:
         """Access the main image item."""
+        if self._main_image is None:
+            self._init_main_image()
         return self._main_image
 
     ################################################################################
@@ -526,7 +530,7 @@ class Image(PlotBase):
         """
         Whether autorange is enabled.
         """
-        return self._main_image.autorange
+        return self.main_image.autorange
 
     @autorange.setter
     def autorange(self, enabled: bool):
@@ -536,9 +540,9 @@ class Image(PlotBase):
         Args:
             enabled(bool): Whether to enable autorange.
         """
-        self._main_image.autorange = enabled
-        if enabled and self._main_image.raw_data is not None:
-            self._main_image.apply_autorange()
+        self.main_image.autorange = enabled
+        if enabled and self.main_image.raw_data is not None:
+            self.main_image.apply_autorange()
             self._sync_colorbar_levels()
         self._sync_autorange_switch()
 
@@ -552,7 +556,7 @@ class Image(PlotBase):
             - "mean": Use the mean value of the image for autoranging.
 
         """
-        return self._main_image.autorange_mode
+        return self.main_image.autorange_mode
 
     @autorange_mode.setter
     def autorange_mode(self, mode: str):
@@ -565,7 +569,7 @@ class Image(PlotBase):
         # for qt Designer
         if mode not in ["max", "mean"]:
             return
-        self._main_image.autorange_mode = mode
+        self.main_image.autorange_mode = mode
 
         self._sync_autorange_switch()
 
@@ -578,11 +582,11 @@ class Image(PlotBase):
             enabled(bool): Whether to enable autorange.
             mode(str): The autorange mode. Options are "max" or "mean".
         """
-        if self._main_image is not None:
-            self._main_image.autorange = enabled
-            self._main_image.autorange_mode = mode
+        if self.main_image is not None:
+            self.main_image.autorange = enabled
+            self.main_image.autorange_mode = mode
             if enabled:
-                self._main_image.apply_autorange()
+                self.main_image.apply_autorange()
             self._sync_colorbar_levels()
 
     def _sync_autorange_switch(self):
@@ -590,13 +594,13 @@ class Image(PlotBase):
         Synchronize the autorange switch with the current autorange state and mode if changed from outside.
         """
         self.autorange_switch.block_all_signals(True)
-        self.autorange_switch.set_default_action(f"auto_range_{self._main_image.autorange_mode}")
-        self.autorange_switch.set_state_all(self._main_image.autorange)
+        self.autorange_switch.set_default_action(f"auto_range_{self.main_image.autorange_mode}")
+        self.autorange_switch.set_state_all(self.main_image.autorange)
         self.autorange_switch.block_all_signals(False)
 
     def _sync_colorbar_levels(self):
         """Immediately propagate current levels to the active colorbar."""
-        vrange = self._main_image.v_range
+        vrange = self.main_image.v_range
         if self._color_bar:
             self._color_bar.blockSignals(True)
             self.v_range = vrange
@@ -623,7 +627,7 @@ class Image(PlotBase):
         """
         Whether FFT postprocessing is enabled.
         """
-        return self._main_image.fft
+        return self.main_image.fft
 
     @fft.setter
     def fft(self, enable: bool):
@@ -633,14 +637,14 @@ class Image(PlotBase):
         Args:
             enable(bool): Whether to enable FFT postprocessing.
         """
-        self._main_image.fft = enable
+        self.main_image.fft = enable
 
     @SafeProperty(bool)
     def log(self) -> bool:
         """
         Whether logarithmic scaling is applied.
         """
-        return self._main_image.log
+        return self.main_image.log
 
     @log.setter
     def log(self, enable: bool):
@@ -650,14 +654,14 @@ class Image(PlotBase):
         Args:
             enable(bool): Whether to enable logarithmic scaling.
         """
-        self._main_image.log = enable
+        self.main_image.log = enable
 
     @SafeProperty(int)
     def rotation(self) -> int:
         """
         The number of 90° rotations to apply.
         """
-        return self._main_image.rotation
+        return self.main_image.rotation
 
     @rotation.setter
     def rotation(self, value: int):
@@ -667,14 +671,14 @@ class Image(PlotBase):
         Args:
             value(int): The number of 90° rotations to apply.
         """
-        self._main_image.rotation = value
+        self.main_image.rotation = value
 
     @SafeProperty(bool)
     def transpose(self) -> bool:
         """
         Whether the image is transposed.
         """
-        return self._main_image.transpose
+        return self.main_image.transpose
 
     @transpose.setter
     def transpose(self, enable: bool):
@@ -684,7 +688,7 @@ class Image(PlotBase):
         Args:
             enable(bool): Whether to enable transposing the image.
         """
-        self._main_image.transpose = enable
+        self.main_image.transpose = enable
 
     ################################################################################
     # High Level methods for API
@@ -712,27 +716,27 @@ class Image(PlotBase):
             ImageItem: The image object.
         """
 
-        if self._main_image.config.monitor is not None:
-            self.disconnect_monitor(self._main_image.config.monitor)
+        if self.main_image.config.monitor is not None:
+            self.disconnect_monitor(self.main_image.config.monitor)
         self.entry_validator.validate_monitor(monitor)
-        self._main_image.config.monitor = monitor
+        self.main_image.config.monitor = monitor
 
         if monitor_type == "1d":
-            self._main_image.config.source = "device_monitor_1d"
-            self._main_image.config.monitor_type = "1d"
+            self.main_image.config.source = "device_monitor_1d"
+            self.main_image.config.monitor_type = "1d"
         elif monitor_type == "2d":
-            self._main_image.config.source = "device_monitor_2d"
-            self._main_image.config.monitor_type = "2d"
+            self.main_image.config.source = "device_monitor_2d"
+            self.main_image.config.monitor_type = "2d"
         elif monitor_type == "auto":
-            self._main_image.config.source = "auto"
+            self.main_image.config.source = "auto"
             logger.warning(
                 f"Updates for '{monitor}' will be fetch from both 1D and 2D monitor endpoints."
             )
-            self._main_image.config.monitor_type = "auto"
+            self.main_image.config.monitor_type = "auto"
 
         self.set_image_update(monitor=monitor, type=monitor_type)
         if color_map is not None:
-            self._main_image.color_map = color_map
+            self.main_image.color_map = color_map
         if color_bar is not None:
             self.enable_colorbar(True, color_bar)
         if vrange is not None:
@@ -740,20 +744,20 @@ class Image(PlotBase):
 
         self._sync_device_selection()
 
-        return self._main_image
+        return self.main_image
 
     def _sync_device_selection(self):
         """
         Synchronize the device selection with the current monitor.
         """
-        if self._main_image.config.monitor is not None:
+        if self.main_image.config.monitor is not None:
             for combo in (
                 self.selection_bundle.device_combo_box,
                 self.selection_bundle.dim_combo_box,
             ):
                 combo.blockSignals(True)
-            self.selection_bundle.device_combo_box.set_device(self._main_image.config.monitor)
-            self.selection_bundle.dim_combo_box.setCurrentText(self._main_image.config.monitor_type)
+            self.selection_bundle.device_combo_box.set_device(self.main_image.config.monitor)
+            self.selection_bundle.dim_combo_box.setCurrentText(self.main_image.config.monitor_type)
             for combo in (
                 self.selection_bundle.device_combo_box,
                 self.selection_bundle.dim_combo_box,
@@ -793,7 +797,7 @@ class Image(PlotBase):
                 self.on_image_update_2d, MessageEndpoints.device_monitor_2d(monitor)
             )
         print(f"Connected to {monitor} with type {type}")
-        self._main_image.config.monitor = monitor
+        self.main_image.config.monitor = monitor
 
     def disconnect_monitor(self, monitor: str):
         """
@@ -808,7 +812,7 @@ class Image(PlotBase):
         self.bec_dispatcher.disconnect_slot(
             self.on_image_update_2d, MessageEndpoints.device_monitor_2d(monitor)
         )
-        self._main_image.config.monitor = None
+        self.main_image.config.monitor = None
 
     ########################################
     # 1D updates
@@ -829,13 +833,13 @@ class Image(PlotBase):
             return
         if current_scan_id != self.scan_id:
             self.scan_id = current_scan_id
-            self._main_image.clear()
-            self._main_image.buffer = []
-            self._main_image.max_len = 0
-        image_buffer = self.adjust_image_buffer(self._main_image, data)
+            self.main_image.clear()
+            self.main_image.buffer = []
+            self.main_image.max_len = 0
+        image_buffer = self.adjust_image_buffer(self.main_image, data)
         if self._color_bar is not None:
             self._color_bar.blockSignals(True)
-        self._main_image.set_data(image_buffer)
+        self.main_image.set_data(image_buffer)
         if self._color_bar is not None:
             self._color_bar.blockSignals(False)
 
@@ -886,7 +890,7 @@ class Image(PlotBase):
         data = msg["data"]
         if self._color_bar is not None:
             self._color_bar.blockSignals(True)
-        self._main_image.set_data(data)
+        self.main_image.set_data(data)
         if self._color_bar is not None:
             self._color_bar.blockSignals(False)
 
@@ -914,9 +918,9 @@ class Image(PlotBase):
         """
         Disconnect the image update signals and clean up the image.
         """
-        if self._main_image.config.monitor is not None:
-            self.disconnect_monitor(self._main_image.config.monitor)
-            self._main_image.config.monitor = None
+        if self.main_image.config.monitor is not None:
+            self.disconnect_monitor(self.main_image.config.monitor)
+            self.main_image.config.monitor = None
 
         if self._color_bar:
             if self.config.color_bar == "full":

bec_widgets/widgets/plots/image/image_item.py

@@ -72,6 +72,7 @@ class ImageItem(BECConnector, pg.ImageItem):
 
     def __init__(
         self,
+        parent=None,
         config: Optional[ImageItemConfig] = None,
         gui_id: Optional[str] = None,
         parent_image=None,
@@ -82,8 +83,7 @@ class ImageItem(BECConnector, pg.ImageItem):
             self.config = config
         else:
             self.config = config
-        super().__init__(config=config, gui_id=gui_id)
-        pg.ImageItem.__init__(self)
+        pg.ImageItem.__init__(self, parent=parent)
 
         self.parent_image = parent_image
 
@@ -94,6 +94,11 @@ class ImageItem(BECConnector, pg.ImageItem):
         # Image processor will handle any setting of data
         self._image_processor = ImageProcessor(config=self.config.processing)
 
+        BECConnector.__init__(self, config=config, gui_id=gui_id)
+
+    def parent(self):
+        return self.parent_image
+
     def set_data(self, data: np.ndarray):
         self.raw_data = data
         self._process_image()

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

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

bec_widgets/widgets/plots/plot_base.py

@@ -74,11 +74,10 @@ class PlotBase(BECWidget, QWidget):
     ) -> None:
         if config is None:
             config = ConnectionConfig(widget_class=self.__class__.__name__)
-        super().__init__(client=client, gui_id=gui_id, config=config, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, gui_id=gui_id, config=config, **kwargs)
 
         # For PropertyManager identification
-        self.setObjectName("PlotBase")
         self.get_bec_shortcuts()
 
         # Layout Management
@@ -172,6 +171,9 @@ class PlotBase(BECWidget, QWidget):
         # hide some options by default
         self.toolbar.toggle_action_visibility("fps_monitor", False)
 
+        # Get default viewbox state
+        self.mouse_bundle.get_viewbox_mode()
+
     def add_side_menus(self):
         """Adds multiple menus to the side panel."""
         # Setting Axis Widget
@@ -223,6 +225,8 @@ class PlotBase(BECWidget, QWidget):
         """
         Slot for when the axis settings dialog is closed.
         """
+        self.axis_settings_dialog.close()
+        self.axis_settings_dialog.deleteLater()
         self.axis_settings_dialog = None
         self.toolbar.widgets["axis"].action.setChecked(False)
 

bec_widgets/widgets/plots/scatter_waveform/scatter_curve.py

@@ -77,12 +77,14 @@ class ScatterCurve(BECConnector, pg.PlotDataItem):
         else:
             self.config = config
             name = config.label
-        super().__init__(config=config, gui_id=gui_id)
-        pg.PlotDataItem.__init__(self, name=name)
-
+        pg.PlotDataItem.__init__(self, **kwargs, name=name)
         self.parent_item = parent_item
         self.data_z = None  # color scaling needs to be cashed for changing colormap
         self.apply_config()
+        BECConnector.__init__(self, config=config, gui_id=gui_id)
+
+    def parent(self):
+        return self.parent_item
 
     def apply_config(self, config: dict | ScatterCurveConfig | None = None, **kwargs) -> None:
         """

bec_widgets/widgets/plots/scatter_waveform/scatter_waveform.py

@@ -110,9 +110,7 @@ class ScatterWaveform(PlotBase):
         super().__init__(
             parent=parent, config=config, client=client, gui_id=gui_id, popups=popups, **kwargs
         )
-        self._main_curve = ScatterCurve(parent_item=self)
-        # For PropertyManager identification
-        self.setObjectName("ScatterWaveform")
+        self._main_curve = ScatterCurve(parent=self, parent_item=self)
 
         # Specific GUI elements
         self.scatter_dialog = None

bec_widgets/widgets/plots/toolbar_bundles/mouse_interactions.py

@@ -56,9 +56,6 @@ class MouseInteractionToolbarBundle(ToolbarBundle):
         rect.action.toggled.connect(self.enable_mouse_rectangle_mode)
         auto.action.triggered.connect(self.autorange_plot)
 
-        # Give some time to check the state
-        QTimer.singleShot(10, self.get_viewbox_mode)
-
     def get_viewbox_mode(self):
         """
         Returns the current interaction mode of a PyQtGraph ViewBox and sets the corresponding action.

bec_widgets/widgets/plots/waveform/curve.py

@@ -79,6 +79,7 @@ class Curve(BECConnector, pg.PlotDataItem):
 
     def __init__(
         self,
+        parent=None,
         name: str | None = None,
         config: CurveConfig | None = None,
         gui_id: str | None = None,
@@ -90,9 +91,10 @@ class Curve(BECConnector, pg.PlotDataItem):
             self.config = config
         else:
             self.config = config
-        super().__init__(config=config, gui_id=gui_id)
-        pg.PlotDataItem.__init__(self, name=name)
+        pg.PlotDataItem.__init__(self, parent=parent, name=name)
 
+        self.setObjectName(name.replace("-", "_"))
+        self.parent_id = parent_item.config.gui_id
         self.parent_item = parent_item
         self.apply_config()
         self.dap_params = None
@@ -100,6 +102,11 @@ class Curve(BECConnector, pg.PlotDataItem):
         if kwargs:
             self.set(**kwargs)
 
+        BECConnector.__init__(self, config=config, gui_id=gui_id)
+
+    def parent(self):
+        return self.parent_item
+
     def apply_config(self, config: dict | CurveConfig | None = None, **kwargs) -> None:
         """
         Apply the configuration to the curve.

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

@@ -337,8 +337,8 @@ class CurveTree(BECWidget, QWidget):
     ) -> None:
         if config is None:
             config = ConnectionConfig(widget_class=self.__class__.__name__)
-        super().__init__(client=client, gui_id=gui_id, config=config)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, gui_id=gui_id, config=config)
 
         self.waveform = waveform
         if self.waveform and hasattr(self.waveform, "color_palette"):

bec_widgets/widgets/plots/waveform/waveform.py

@@ -10,7 +10,15 @@ from bec_lib import bec_logger, messages
 from bec_lib.endpoints import MessageEndpoints
 from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import QTimer, Signal
-from qtpy.QtWidgets import QDialog, QHBoxLayout, QMainWindow, QVBoxLayout, QWidget
+from qtpy.QtWidgets import (
+    QApplication,
+    QDialog,
+    QHBoxLayout,
+    QMainWindow,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
 
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_signal_proxy import BECSignalProxy
@@ -18,6 +26,7 @@ from bec_widgets.utils.colors import Colors, set_theme
 from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
 from bec_widgets.utils.settings_dialog import SettingsDialog
 from bec_widgets.utils.toolbar import MaterialIconAction
+from bec_widgets.utils.widget_io import WidgetHierarchy
 from bec_widgets.widgets.dap.lmfit_dialog.lmfit_dialog import LMFitDialog
 from bec_widgets.widgets.plots.plot_base import PlotBase
 from bec_widgets.widgets.plots.waveform.curve import Curve, CurveConfig, DeviceSignal
@@ -120,16 +129,23 @@ class Waveform(PlotBase):
         client=None,
         gui_id: str | None = None,
         popups: bool = True,
+        name=None,
         **kwargs,
     ):
         if config is None:
             config = WaveformConfig(widget_class=self.__class__.__name__)
         super().__init__(
-            parent=parent, config=config, client=client, gui_id=gui_id, popups=popups, **kwargs
+            parent=parent,
+            config=config,
+            client=client,
+            gui_id=gui_id,
+            popups=popups,
+            name=name,
+            **kwargs,
         )
 
         # For PropertyManager identification
-        self.setObjectName("Waveform")
+        # self.setObjectName("Waveform")
 
         # Curve data
         self._sync_curves = []
@@ -282,6 +298,8 @@ class Waveform(PlotBase):
         """
         Slot for when the axis settings dialog is closed.
         """
+        self.curve_settings_dialog.close()
+        self.curve_settings_dialog.deleteLater()
         self.curve_settings_dialog = None
         self.toolbar.widgets["curve"].action.setChecked(False)
 
@@ -757,7 +775,8 @@ class Waveform(PlotBase):
         Returns:
             Curve: The newly created curve object, added to the plot.
         """
-        curve = Curve(config=config, name=name, parent_item=self)
+        curve = Curve(parent=self, config=config, name=name, parent_item=self)
+        curve.setParentItem(self.plot_item)
         self.plot_item.addItem(curve)
         self._categorise_device_curves()
         return curve
@@ -1586,7 +1605,7 @@ class DemoApp(QMainWindow):  # pragma: no cover
         super().__init__()
         self.setWindowTitle("Waveform Demo")
         self.resize(800, 600)
-        self.main_widget = QWidget()
+        self.main_widget = QWidget(self)
         self.layout = QHBoxLayout(self.main_widget)
         self.setCentralWidget(self.main_widget)
 
@@ -1597,15 +1616,29 @@ class DemoApp(QMainWindow):  # pragma: no cover
         self.waveform_side.plot(y_name="bpm4i", y_entry="bpm4i", dap="GaussianModel")
         self.waveform_side.plot(y_name="bpm3a", y_entry="bpm3a")
 
+        self.hierarchy_button = QPushButton()
+        self.hierarchy_button.setText("Hierarchy")
+        self.hierarchy_button.clicked.connect(self.hierarchy)
+
         self.layout.addWidget(self.waveform_side)
         self.layout.addWidget(self.waveform_popup)
+        self.layout.addWidget(self.hierarchy_button)
+
+    def hierarchy(self):
+        print("getting app")
+        WidgetHierarchy.print_becconnector_hierarchy_from_app()  # , only_bec_widgets=True)
+        print("Waveform popup")
+        print(self.waveform_popup.objectName())
+        print("Waveform side")
+        print(self.waveform_side.objectName())
 
 
 if __name__ == "__main__":  # pragma: no cover
     import sys
 
-    from qtpy.QtWidgets import QApplication
-
+    # from bec_widgets.utils.bec_qapp import BECApplication
+    #
+    # app = BECApplication(sys.argv)
     app = QApplication(sys.argv)
     set_theme("dark")
     widget = DemoApp()

bec_widgets/widgets/progress/bec_progressbar/bec_progressbar.py

@@ -25,8 +25,8 @@ class BECProgressBar(BECWidget, QWidget):
     ICON_NAME = "page_control"
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, **kwargs):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
 
         accent_colors = get_accent_colors()
 

bec_widgets/widgets/progress/ring_progress_bar/ring_progress_bar.py

@@ -110,8 +110,8 @@ class RingProgressBar(BECWidget, QWidget):
             if isinstance(config, dict):
                 config = RingProgressBarConfig(**config, widget_class=self.__class__.__name__)
             self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
 
         self.get_bec_shortcuts()
         self.entry_validator = EntryValidator(self.dev)

bec_widgets/widgets/services/bec_queue/bec_queue.py

@@ -44,8 +44,8 @@ class BECQueue(BECWidget, CompactPopupWidget):
         refresh_upon_start: bool = True,
         **kwargs,
     ):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         CompactPopupWidget.__init__(self, parent=parent, layout=QVBoxLayout)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
         self.layout.setSpacing(0)
         self.layout.setContentsMargins(0, 0, 0, 0)
 

bec_widgets/widgets/services/bec_status_box/bec_status_box.py

@@ -89,8 +89,8 @@ class BECStatusBox(BECWidget, CompactPopupWidget):
         gui_id: str = None,
         **kwargs,
     ):
-        super().__init__(client=client, gui_id=gui_id, **kwargs)
         CompactPopupWidget.__init__(self, parent=parent, layout=QHBoxLayout)
+        BECWidget.__init__(self, client=client, gui_id=gui_id, **kwargs)
 
         self.box_name = box_name
         self.status_container = defaultdict(lambda: {"info": None, "item": None, "widget": None})

bec_widgets/widgets/services/device_browser/device_browser.py

@@ -25,8 +25,8 @@ class DeviceBrowser(BECWidget, QWidget):
         gui_id: Optional[str] = None,
         **kwargs,
     ) -> None:
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
         QWidget.__init__(self, parent)
+        BECWidget.__init__(self, client=client, config=config, gui_id=gui_id, **kwargs)
 
         self.get_bec_shortcuts()
         self.ui = None

bec_widgets/widgets/utility/logpanel/log_panel_plugin.py

@@ -1,7 +1,5 @@
-# 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.utility.logpanel.logpanel import LogPanel
@@ -17,11 +15,17 @@ DOM_XML = """
 class LogPanelPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
         super().__init__()
+        self._initialized = False
         self._form_editor = None
 
     def createWidget(self, parent):
-        t = LogPanel(parent)
-        return t
+        # 1) Detect if Qt Designer is just enumerating your widget for the palette
+        if parent is None:
+            # Return a minimal stub (or do nothing) so you don’t initialize LogPanel fully
+            return QWidget()
+
+        # 2) Otherwise, create the real widget
+        return LogPanel(parent)
 
     def domXml(self):
         return DOM_XML
@@ -33,16 +37,20 @@ class LogPanelPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return designer_material_icon(LogPanel.ICON_NAME)
 
     def includeFile(self):
+        # Return the Python import path for the actual class
         return "log_panel"
 
     def initialize(self, form_editor):
+        if self._initialized:
+            return
         self._form_editor = form_editor
+        self._initialized = True
 
     def isContainer(self):
         return False
 
     def isInitialized(self):
-        return self._form_editor is not None
+        return self._initialized
 
     def name(self):
         return "LogPanel"

bec_widgets/widgets/utility/spinbox/decimal_spinbox.py

@@ -30,8 +30,8 @@ class BECSpinBox(BECWidget, QDoubleSpinBox):
     ) -> None:
         if config is None:
             config = ConnectionConfig(widget_class=self.__class__.__name__)
-        super().__init__(client=client, gui_id=gui_id, config=config, **kwargs)
         QDoubleSpinBox.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, gui_id=gui_id, config=config, **kwargs)
 
         self.setObjectName("BECSpinBox")
         # Make the widget as compact as possible horizontally.

bec_widgets/widgets/utility/visual/colormap_widget/colormap_widget.py

@@ -11,10 +11,11 @@ class BECColorMapWidget(BECWidget, QWidget):
     ICON_NAME = "palette"
     USER_ACCESS = ["colormap"]
     PLUGIN = True
+    RPC = False
 
     def __init__(self, parent=None, cmap: str = "magma", **kwargs):
-        super().__init__(**kwargs)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, **kwargs)
 
         # Create the ColorMapButton
         self.button = ColorMapButton()

bec_widgets/widgets/utility/visual/dark_mode_button/dark_mode_button.py

@@ -9,10 +9,11 @@ from bec_widgets.utils.colors import set_theme
 
 
 class DarkModeButton(BECWidget, QWidget):
-    USER_ACCESS = ["toggle_dark_mode"]
+    USER_ACCESS = []
 
     ICON_NAME = "dark_mode"
     PLUGIN = True
+    RPC = False
 
     def __init__(
         self,
@@ -22,8 +23,8 @@ class DarkModeButton(BECWidget, QWidget):
         toolbar: bool = False,
         **kwargs,
     ) -> None:
-        super().__init__(client=client, gui_id=gui_id, theme_update=True, **kwargs)
         QWidget.__init__(self, parent)
+        BECWidget.__init__(self, client=client, gui_id=gui_id, theme_update=True, **kwargs)
 
         self._dark_mode_enabled = False
         self.layout = QHBoxLayout(self)

tests/end-2-end/test_bec_dock_rpc_e2e.py

@@ -144,7 +144,7 @@ def test_ring_bar(qtbot, connected_client_gui_obj):
 def test_rpc_gui_obj(connected_client_gui_obj, qtbot):
     gui = connected_client_gui_obj
 
-    assert len(gui.windows) == 1
+    qtbot.waitUntil(lambda: len(gui.windows) == 1, timeout=3000)
     assert gui.windows["bec"] is gui.bec
     mw = gui.bec
     assert mw.__class__.__name__ == "RPCReference"
@@ -155,22 +155,6 @@ def test_rpc_gui_obj(connected_client_gui_obj, qtbot):
     assert gui._ipython_registry[xw._gui_id].__class__.__name__ == "BECDockArea"
     assert len(gui.windows) == 2
 
-    gui_info = gui._dump()
-    mw_info = gui_info[mw._gui_id]
-    assert mw_info["title"] == "BEC"
-    assert mw_info["visible"]
-    xw_info = gui_info[xw._gui_id]
-    assert xw_info["title"] == "BEC - X"
-    assert xw_info["visible"]
-
-    gui.hide()
-    gui_info = gui._dump()  #
-    assert not any(windows["visible"] for windows in gui_info.values())
-
-    gui.show()
-    gui_info = gui._dump()
-    assert all(windows["visible"] for windows in gui_info.values())
-
     assert gui._gui_is_alive()
     gui.kill_server()
     assert not gui._gui_is_alive()
@@ -186,10 +170,8 @@ def test_rpc_gui_obj(connected_client_gui_obj, qtbot):
     qtbot.waitUntil(wait_for_gui_started, timeout=3000)
     # gui.windows should have bec with gui_id 'bec'
     assert len(gui.windows) == 1
-    assert gui.windows["bec"]._gui_id == mw._gui_id
+
     # communication should work, main dock area should have same id and be visible
-    gui_info = gui._dump()
-    assert gui_info[mw._gui_id]["visible"]
 
     yw = gui.new("Y")
     assert len(gui.windows) == 2

tests/end-2-end/test_plotting_framework_e2e.py

@@ -60,18 +60,18 @@ def test_rpc_plotting_shortcuts_init_configs(qtbot, connected_client_gui_obj):
 
     # check if the correct devices are set
     # Curve
-    assert c1._config["signal"] == {
+    assert c1._config_dict["signal"] == {
         "dap": None,
         "name": "bpm4i",
         "entry": "bpm4i",
         "dap_oversample": 1,
     }
-    assert c1._config["source"] == "device"
-    assert c1._config["label"] == "bpm4i-bpm4i"
+    assert c1._config_dict["source"] == "device"
+    assert c1._config_dict["label"] == "bpm4i-bpm4i"
 
-    # Image Item
-    assert im_item._config["monitor"] == "eiger"
-    assert im_item._config["source"] == "auto"
+    # # Image Item
+    # assert im_item._config["monitor"] == "eiger"
+    # assert im_item._config["source"] == "auto"
 
 
 def test_rpc_waveform_scan(qtbot, bec_client_lib, connected_client_gui_obj):

tests/unit_tests/conftest.py

@@ -28,8 +28,10 @@ def qapplication(qtbot, request, testable_qtimer_class):  # pylint: disable=unus
         print("Test failed, skipping cleanup checks")
         return
 
-    testable_qtimer_class.check_all_stopped(qtbot)
+    # qapp = BECApplication()
+    # qapp.shutdown()
 
+    testable_qtimer_class.check_all_stopped(qtbot)
     qapp = QApplication.instance()
     qapp.processEvents()
     if hasattr(qapp, "os_listener") and qapp.os_listener:

tests/unit_tests/test_client_utils.py

@@ -31,7 +31,7 @@ def test_rpc_call_new_dock(cli_dock_area):
 )
 def test_client_utils_start_plot_process(config, call_config):
     with mock.patch("bec_widgets.cli.client_utils.subprocess.Popen") as mock_popen:
-        _start_plot_process("gui_id", BECDockArea, "bec", config)
+        _start_plot_process("gui_id", "bec", config, gui_class="BECDockArea")
         command = [
             "bec-gui-server",
             "--id",
@@ -82,7 +82,6 @@ def test_client_utils_passes_client_config_to_server(bec_dispatcher):
             )  # the started event will not be set, wait=True would block forever
             mock_start_plot.assert_called_once_with(
                 "gui_id",
-                BECGuiClient,
                 gui_class_id="bec",
                 config=mixin._client._service_config.config,
                 logger=mock.ANY,

tests/unit_tests/test_color_utils.py

@@ -133,8 +133,8 @@ class ExamplePlotWidget(BECWidget, QWidget):
     ) -> None:
         if config is None:
             config = ConnectionConfig(widget_class=self.__class__.__name__)
-        super().__init__(client=client, gui_id=gui_id, config=config)
         QWidget.__init__(self, parent=parent)
+        BECWidget.__init__(self, client=client, gui_id=gui_id, config=config)
 
         self.layout = QVBoxLayout(self)
         self.glw = pg.GraphicsLayoutWidget()

tests/unit_tests/test_device_input_base.py

@@ -18,8 +18,8 @@ class DeviceInputWidget(DeviceInputBase, QWidget):
     """Thin wrapper around DeviceInputBase to make it a QWidget"""
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None):
-        super().__init__(client=client, config=config, gui_id=gui_id)
         QWidget.__init__(self, parent=parent)
+        DeviceInputBase.__init__(self, client=client, config=config, gui_id=gui_id)
 
 
 @pytest.fixture

tests/unit_tests/test_device_signal_input.py

@@ -22,8 +22,8 @@ class DeviceInputWidget(DeviceSignalInputBase, QWidget):
     """Thin wrapper around DeviceInputBase to make it a QWidget"""
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None):
-        super().__init__(client=client, config=config, gui_id=gui_id)
         QWidget.__init__(self, parent=parent)
+        DeviceSignalInputBase.__init__(self, client=client, config=config, gui_id=gui_id)
 
 
 @pytest.fixture

tests/unit_tests/test_rpc_server.py

@@ -1,45 +1,56 @@
+import argparse
 from unittest import mock
 
 import pytest
+from bec_lib.service_config import ServiceConfig
 
-from bec_widgets.cli.server import _start_server
-from bec_widgets.widgets.containers.dock import BECDockArea
+from bec_widgets.cli.server import GUIServer
 
 
 @pytest.fixture
-def mocked_cli_server():
-    with mock.patch("bec_widgets.cli.server.BECWidgetsCLIServer") as mock_server:
-        with mock.patch("bec_widgets.cli.server.ServiceConfig") as mock_config:
-            with mock.patch("bec_lib.logger.bec_logger.configure") as mock_logger:
-                yield mock_server, mock_config, mock_logger
+def gui_server():
+    args = argparse.Namespace(
+        config=None, id="gui_id", gui_class="LaunchWindow", gui_class_id="bec", hide=False
+    )
+    return GUIServer(args=args)
 
 
-def test_rpc_server_start_server_without_service_config(mocked_cli_server):
+def test_gui_server_start_server_without_service_config(gui_server):
     """
     Test that the server is started with the correct arguments.
     """
-    mock_server, mock_config, _ = mocked_cli_server
+    assert gui_server.config is None
+    assert gui_server.gui_id == "gui_id"
+    assert gui_server.gui_class == "LaunchWindow"
+    assert gui_server.gui_class_id == "bec"
+    assert gui_server.hide is False
 
-    _start_server("gui_id", BECDockArea, config=None)
-    mock_server.assert_called_once_with(
-        gui_id="gui_id", config=mock_config(), gui_class=BECDockArea, gui_class_id="bec"
-    )
+
+def test_gui_server_get_service_config(gui_server):
+    """
+    Test that the server is started with the correct arguments.
+    """
+    assert gui_server._get_service_config().config is ServiceConfig().config
 
 
 @pytest.mark.parametrize(
-    "config, call_config",
+    "connections, hide",
     [
-        ("/path/to/config.yml", {"config_path": "/path/to/config.yml"}),
-        ({"key": "value"}, {"config": {"key": "value"}}),
+        ({}, False),
+        ({"launcher": mock.MagicMock()}, False),
+        ({"launcher": mock.MagicMock(), "dock_area": mock.MagicMock()}, True),
     ],
 )
-def test_rpc_server_start_server_with_service_config(mocked_cli_server, config, call_config):
-    """
-    Test that the server is started with the correct arguments.
-    """
-    mock_server, mock_config, _ = mocked_cli_server
-    config = mock_config(**call_config)
-    _start_server("gui_id", BECDockArea, config=config)
-    mock_server.assert_called_once_with(
-        gui_id="gui_id", config=config, gui_class=BECDockArea, gui_class_id="bec"
-    )
+def test_gui_server_turns_off_the_lights(gui_server, connections, hide):
+    with mock.patch.object(gui_server, "launcher_window") as mock_launcher_window:
+        with mock.patch.object(gui_server, "app") as mock_app:
+            gui_server._turn_off_the_lights(connections)
+
+            if not hide:
+                mock_launcher_window.show.assert_called_once()
+                mock_launcher_window.activateWindow.assert_called_once()
+                mock_launcher_window.raise_.assert_called_once()
+                mock_app.setQuitOnLastWindowClosed.assert_called_once_with(True)
+            else:
+                mock_launcher_window.hide.assert_called_once()
+                mock_app.setQuitOnLastWindowClosed.assert_called_once_with(False)