bec-widgets 1.25.1__py3-none-any.whl → 2.0.1__py3-none-any.whl

bec_widgets/widgets/containers/dock/dock_area.py

@@ -3,36 +3,43 @@ from __future__ import annotations
 from typing import Literal, Optional
 from weakref import WeakValueDictionary
 
-from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
 from pydantic import Field
 from pyqtgraph.dockarea.DockArea import DockArea
 from qtpy.QtCore import QSize, Qt
 from qtpy.QtGui import QPainter, QPaintEvent
 from qtpy.QtWidgets import QApplication, QSizePolicy, QVBoxLayout, QWidget
 
-from bec_widgets.qt_utils.error_popups import SafeSlot
-from bec_widgets.qt_utils.toolbar import (
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.utils import ConnectionConfig, WidgetContainerUtils
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.name_utils import pascal_to_snake
+from bec_widgets.utils.toolbar import (
     ExpandableMenuAction,
     MaterialIconAction,
     ModularToolBar,
     SeparatorAction,
 )
-from bec_widgets.utils import ConnectionConfig, WidgetContainerUtils
-from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.widget_io import WidgetHierarchy
 from bec_widgets.widgets.containers.dock.dock import BECDock, DockConfig
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
 from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
 from bec_widgets.widgets.control.scan_control.scan_control import ScanControl
 from bec_widgets.widgets.editors.vscode.vscode import VSCodeEditor
-from bec_widgets.widgets.plots.image.image_widget import BECImageWidget
-from bec_widgets.widgets.plots.motor_map.motor_map_widget import BECMotorMapWidget
-from bec_widgets.widgets.plots.multi_waveform.multi_waveform_widget import BECMultiWaveformWidget
-from bec_widgets.widgets.plots.waveform.waveform_widget import BECWaveformWidget
+from bec_widgets.widgets.plots.image.image import Image
+from bec_widgets.widgets.plots.motor_map.motor_map import MotorMap
+from bec_widgets.widgets.plots.multi_waveform.multi_waveform import MultiWaveform
+from bec_widgets.widgets.plots.scatter_waveform.scatter_waveform import ScatterWaveform
+from bec_widgets.widgets.plots.waveform.waveform import Waveform
 from bec_widgets.widgets.progress.ring_progress_bar.ring_progress_bar import RingProgressBar
 from bec_widgets.widgets.services.bec_queue.bec_queue import BECQueue
 from bec_widgets.widgets.services.bec_status_box.bec_status_box import BECStatusBox
 from bec_widgets.widgets.utility.logpanel.logpanel import LogPanel
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
+logger = bec_logger.logger
+
 
 class DockAreaConfig(ConnectionConfig):
     docks: dict[str, DockConfig] = Field({}, description="The docks in the dock area.")
@@ -42,23 +49,27 @@ class DockAreaConfig(ConnectionConfig):
 
 
 class BECDockArea(BECWidget, QWidget):
+    """
+    Container for other widgets. Widgets can be added to the dock area and arranged in a grid layout.
+    """
+
     PLUGIN = True
     USER_ACCESS = [
+        "_rpc_id",
         "_config_dict",
-        "selected_device",
-        "panels",
-        "save_state",
-        "remove_dock",
-        "restore_state",
-        "add_dock",
-        "clear_all",
-        "detach_dock",
-        "attach_all",
         "_get_all_rpc",
-        "temp_areas",
+        "new",
         "show",
         "hide",
+        "panels",
+        "panel_list",
         "delete",
+        "delete_all",
+        "remove",
+        "detach_dock",
+        "attach_all",
+        "save_state",
+        "restore_state",
     ]
 
     def __init__(
@@ -67,6 +78,8 @@ class BECDockArea(BECWidget, QWidget):
         config: DockAreaConfig | None = None,
         client=None,
         gui_id: str = None,
+        object_name: str = None,
+        **kwargs,
     ) -> None:
         if config is None:
             config = DockAreaConfig(widget_class=self.__class__.__name__)
@@ -74,37 +87,47 @@ class BECDockArea(BECWidget, QWidget):
             if isinstance(config, dict):
                 config = DockAreaConfig(**config)
             self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(
+            parent=parent,
+            object_name=object_name,
+            client=client,
+            gui_id=gui_id,
+            config=config,
+            **kwargs,
+        )
+        self._parent = parent  # TODO probably not needed
         self.layout = QVBoxLayout(self)
         self.layout.setSpacing(5)
         self.layout.setContentsMargins(0, 0, 0, 0)
 
         self._instructions_visible = True
 
-        self.dock_area = DockArea()
+        self.dark_mode_button = DarkModeButton(parent=self, toolbar=True)
+        self.dock_area = DockArea(parent=self)
         self.toolbar = ModularToolBar(
+            parent=self,
             actions={
                 "menu_plots": ExpandableMenuAction(
                     label="Add Plot ",
                     actions={
                         "waveform": MaterialIconAction(
-                            icon_name=BECWaveformWidget.ICON_NAME,
-                            tooltip="Add Waveform",
+                            icon_name=Waveform.ICON_NAME, tooltip="Add Waveform", filled=True
+                        ),
+                        "scatter_waveform": MaterialIconAction(
+                            icon_name=ScatterWaveform.ICON_NAME,
+                            tooltip="Add Scatter Waveform",
                             filled=True,
                         ),
                         "multi_waveform": MaterialIconAction(
-                            icon_name=BECMultiWaveformWidget.ICON_NAME,
+                            icon_name=MultiWaveform.ICON_NAME,
                             tooltip="Add Multi Waveform",
                             filled=True,
                         ),
                         "image": MaterialIconAction(
-                            icon_name=BECImageWidget.ICON_NAME, tooltip="Add Image", filled=True
+                            icon_name=Image.ICON_NAME, tooltip="Add Image", filled=True
                         ),
                         "motor_map": MaterialIconAction(
-                            icon_name=BECMotorMapWidget.ICON_NAME,
-                            tooltip="Add Motor Map",
-                            filled=True,
+                            icon_name=MotorMap.ICON_NAME, tooltip="Add Motor Map", filled=True
                         ),
                     },
                 ),
@@ -159,10 +182,10 @@ class BECDockArea(BECWidget, QWidget):
 
         self.layout.addWidget(self.toolbar)
         self.layout.addWidget(self.dock_area)
-        self.spacer = QWidget()
+        self.spacer = QWidget(parent=self)
         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):
@@ -171,41 +194,44 @@ class BECDockArea(BECWidget, QWidget):
     def _hook_toolbar(self):
         # Menu Plot
         self.toolbar.widgets["menu_plots"].widgets["waveform"].triggered.connect(
-            lambda: self.add_dock(widget="BECWaveformWidget", prefix="waveform")
+            lambda: self._create_widget_from_toolbar(widget_name="Waveform")
+        )
+        self.toolbar.widgets["menu_plots"].widgets["scatter_waveform"].triggered.connect(
+            lambda: self._create_widget_from_toolbar(widget_name="ScatterWaveform")
         )
         self.toolbar.widgets["menu_plots"].widgets["multi_waveform"].triggered.connect(
-            lambda: self.add_dock(widget="BECMultiWaveformWidget", prefix="multi_waveform")
+            lambda: self._create_widget_from_toolbar(widget_name="MultiWaveform")
         )
         self.toolbar.widgets["menu_plots"].widgets["image"].triggered.connect(
-            lambda: self.add_dock(widget="BECImageWidget", prefix="image")
+            lambda: self._create_widget_from_toolbar(widget_name="Image")
         )
         self.toolbar.widgets["menu_plots"].widgets["motor_map"].triggered.connect(
-            lambda: self.add_dock(widget="BECMotorMapWidget", prefix="motor_map")
+            lambda: self._create_widget_from_toolbar(widget_name="MotorMap")
         )
 
         # Menu Devices
         self.toolbar.widgets["menu_devices"].widgets["scan_control"].triggered.connect(
-            lambda: self.add_dock(widget="ScanControl", prefix="scan_control")
+            lambda: self._create_widget_from_toolbar(widget_name="ScanControl")
         )
         self.toolbar.widgets["menu_devices"].widgets["positioner_box"].triggered.connect(
-            lambda: self.add_dock(widget="PositionerBox", prefix="positioner_box")
+            lambda: self._create_widget_from_toolbar(widget_name="PositionerBox")
         )
 
         # Menu Utils
         self.toolbar.widgets["menu_utils"].widgets["queue"].triggered.connect(
-            lambda: self.add_dock(widget="BECQueue", prefix="queue")
+            lambda: self._create_widget_from_toolbar(widget_name="BECQueue")
         )
         self.toolbar.widgets["menu_utils"].widgets["status"].triggered.connect(
-            lambda: self.add_dock(widget="BECStatusBox", prefix="status")
+            lambda: self._create_widget_from_toolbar(widget_name="BECStatusBox")
         )
         self.toolbar.widgets["menu_utils"].widgets["vs_code"].triggered.connect(
-            lambda: self.add_dock(widget="VSCodeEditor", prefix="vs_code")
+            lambda: self._create_widget_from_toolbar(widget_name="VSCodeEditor")
         )
         self.toolbar.widgets["menu_utils"].widgets["progress_bar"].triggered.connect(
-            lambda: self.add_dock(widget="RingProgressBar", prefix="progress_bar")
+            lambda: self._create_widget_from_toolbar(widget_name="RingProgressBar")
         )
         self.toolbar.widgets["menu_utils"].widgets["log_panel"].triggered.connect(
-            lambda: self.add_dock(widget="LogPanel", prefix="log_panel")
+            lambda: self._create_widget_from_toolbar(widget_name="LogPanel")
         )
 
         # Icons
@@ -213,6 +239,14 @@ class BECDockArea(BECWidget, QWidget):
         self.toolbar.widgets["save_state"].action.triggered.connect(self.save_state)
         self.toolbar.widgets["restore_state"].action.triggered.connect(self.restore_state)
 
+    @SafeSlot()
+    def _create_widget_from_toolbar(self, widget_name: str) -> None:
+        # Run with RPC broadcast to namespace of all widgets
+        with RPCRegister.delayed_broadcast():
+            name = pascal_to_snake(widget_name)
+            dock_name = WidgetContainerUtils.generate_unique_name(name, self.panels.keys())
+            self.new(name=dock_name, widget=widget_name)
+
     def paintEvent(self, event: QPaintEvent):  # TODO decide if we want any default instructions
         super().paintEvent(event)
         if self._instructions_visible:
@@ -220,20 +254,9 @@ class BECDockArea(BECWidget, QWidget):
             painter.drawText(
                 self.rect(),
                 Qt.AlignCenter,
-                "Add docks using 'add_dock' method from CLI\n or \n Add widget docks using the toolbar",
+                "Add docks using 'new' method from CLI\n or \n Add widget docks using the toolbar",
             )
 
-    @property
-    def selected_device(self) -> str:
-        gui_id = QApplication.instance().gui_id
-        auto_update_config = self.client.connector.get(
-            MessageEndpoints.gui_auto_update_config(gui_id)
-        )
-        try:
-            return auto_update_config.selected_device
-        except AttributeError:
-            return None
-
     @property
     def panels(self) -> dict[str, BECDock]:
         """
@@ -245,7 +268,17 @@ class BECDockArea(BECWidget, QWidget):
 
     @panels.setter
     def panels(self, value: dict[str, BECDock]):
-        self.dock_area.docks = WeakValueDictionary(value)
+        self.dock_area.docks = WeakValueDictionary(value)  # This can not work can it?
+
+    @property
+    def panel_list(self) -> list[BECDock]:
+        """
+        Get the docks in the dock area.
+
+        Returns:
+            list: The docks in the dock area.
+        """
+        return list(self.dock_area.docks.values())
 
     @property
     def temp_areas(self) -> list:
@@ -275,6 +308,8 @@ class BECDockArea(BECWidget, QWidget):
         """
         if state is None:
             state = self.config.docks_state
+        if state is None:
+            return
         self.dock_area.restoreState(state, missing=missing, extra=extra)
 
     @SafeSlot()
@@ -289,36 +324,17 @@ class BECDockArea(BECWidget, QWidget):
         self.config.docks_state = last_state
         return last_state
 
-    def remove_dock(self, name: str):
-        """
-        Remove a dock by name and ensure it is properly closed and cleaned up.
-
-        Args:
-            name(str): The name of the dock to remove.
-        """
-        dock = self.dock_area.docks.pop(name, None)
-        self.config.docks.pop(name, None)
-        if dock:
-            dock.close()
-            dock.deleteLater()
-            if len(self.dock_area.docks) <= 1:
-                for dock in self.dock_area.docks.values():
-                    dock.hide_title_bar()
-
-        else:
-            raise ValueError(f"Dock with name {name} does not exist.")
-
     @SafeSlot(popup_error=True)
-    def add_dock(
+    def new(
         self,
-        name: str = None,
-        position: Literal["bottom", "top", "left", "right", "above", "below"] = None,
+        name: str | None = None,
+        widget: str | QWidget | None = None,
+        widget_name: str | None = None,
+        position: Literal["bottom", "top", "left", "right", "above", "below"] = "bottom",
         relative_to: BECDock | None = None,
         closable: bool = True,
         floating: bool = False,
-        prefix: str = "dock",
-        widget: str | QWidget | None = None,
-        row: int = None,
+        row: int | None = None,
         col: int = 0,
         rowspan: int = 1,
         colspan: int = 1,
@@ -328,12 +344,11 @@ class BECDockArea(BECWidget, QWidget):
 
         Args:
             name(str): The name of the dock to be displayed and for further references. Has to be unique.
+            widget(str|QWidget|None): The widget to be added to the dock. While using RPC, only BEC RPC widgets from RPCWidgetHandler are allowed.
             position(Literal["bottom", "top", "left", "right", "above", "below"]): The position of the dock.
             relative_to(BECDock): The dock to which the new dock should be added relative to.
             closable(bool): Whether the dock is closable.
             floating(bool): Whether the dock is detached after creating.
-            prefix(str): The prefix for the dock name if no name is provided.
-            widget(str|QWidget|None): The widget to be added to the dock. While using RPC, only BEC RPC widgets from RPCWidgetHandler are allowed.
             row(int): The row of the added widget.
             col(int): The column of the added widget.
             rowspan(int): The rowspan of the added widget.
@@ -342,21 +357,33 @@ class BECDockArea(BECWidget, QWidget):
         Returns:
             BECDock: The created dock.
         """
-        if name is None:
-            name = WidgetContainerUtils.generate_unique_widget_id(
-                container=self.dock_area.docks, prefix=prefix
-            )
-
-        if name in set(self.dock_area.docks.keys()):
-            raise ValueError(f"Dock with name {name} already exists.")
-
-        if position is None:
-            position = "bottom"
-
-        dock = BECDock(name=name, parent_dock_area=self, closable=closable)
+        dock_names = [
+            dock.object_name for dock in self.panel_list
+        ]  # pylint: disable=protected-access
+        if name is not None:  # Name is provided
+            if name in dock_names:
+                raise ValueError(
+                    f"Name {name} must be unique for docks, but already exists in DockArea "
+                    f"with name: {self.object_name} and id {self.gui_id}."
+                )
+            if not WidgetContainerUtils.has_name_valid_chars(name):
+                raise ValueError(
+                    f"Name {name} contains invalid characters. "
+                    f"Only alphanumeric characters and underscores are allowed."
+                )
+        else:  # Name is not provided
+            name = WidgetContainerUtils.generate_unique_name(name="dock", list_of_names=dock_names)
+
+        dock = BECDock(
+            parent=self,
+            name=name,  # this is dock name pyqtgraph property, this is displayed on label
+            object_name=name,  # this is a real qt object name passed to BECConnector
+            parent_dock_area=self,
+            closable=closable,
+        )
         dock.config.position = position
-        self.config.docks[name] = dock.config
-
+        self.config.docks[dock.name()] = dock.config
+        # The dock.name is equal to the name passed to BECDock
         self.dock_area.addDock(dock=dock, position=position, relativeTo=relative_to)
 
         if len(self.dock_area.docks) <= 1:
@@ -365,10 +392,11 @@ class BECDockArea(BECWidget, QWidget):
             for dock in self.dock_area.docks.values():
                 dock.show_title_bar()
 
-        if widget is not None and isinstance(widget, str):
-            dock.add_widget(widget=widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
-        elif widget is not None and isinstance(widget, QWidget):
-            dock.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
+        if widget is not None:
+            # Check if widget name exists.
+            dock.new(
+                widget=widget, name=widget_name, row=row, col=col, rowspan=rowspan, colspan=colspan
+            )
         if (
             self._instructions_visible
         ):  # TODO still decide how initial instructions should be handled
@@ -406,49 +434,24 @@ class BECDockArea(BECWidget, QWidget):
         Remove a temporary area from the dock area.
         This is a patched method of pyqtgraph's removeTempArea
         """
+        if area not in self.dock_area.tempAreas:
+            # FIXME add some context for the logging, I am not sure which object is passed.
+            # It looks like a pyqtgraph.DockArea
+            logger.info(f"Attempted to remove dock_area, but was not floating.")
+            return
         self.dock_area.tempAreas.remove(area)
         area.window().close()
         area.window().deleteLater()
 
-    def clear_all(self):
-        """
-        Close all docks and remove all temp areas.
-        """
-        self.attach_all()
-        for dock in dict(self.dock_area.docks).values():
-            dock.remove()
-        self.dock_area.docks.clear()
-
     def cleanup(self):
         """
         Cleanup the dock area.
         """
-        self.clear_all()
-        self.toolbar.close()
-        self.toolbar.deleteLater()
-        self.dock_area.close()
-        self.dock_area.deleteLater()
+        self.delete_all()
+        self.dark_mode_button.close()
+        self.dark_mode_button.deleteLater()
         super().cleanup()
 
-    def closeEvent(self, event):
-        if self.parent() is None:
-            # we are at top-level (independent window)
-            if self.isVisible():
-                # we are visible => user clicked on [X]
-                # (when closeEvent is called from shutdown procedure,
-                # everything is hidden first)
-                # so, let's ignore "close", and do hide instead
-                event.ignore()
-                self.setVisible(False)
-
-    def close(self):
-        """
-        Close the dock area and cleanup.
-        Has to be implemented to overwrite pyqtgraph event accept in Container close.
-        """
-        self.cleanup()
-        super().close()
-
     def show(self):
         """Show all windows including floating docks."""
         super().show()
@@ -467,18 +470,65 @@ class BECDockArea(BECWidget, QWidget):
                 continue
             docks.window().hide()
 
-    def delete(self):
-        self.hide()
-        self.deleteLater()
+    def delete_all(self) -> None:
+        """
+        Delete all docks.
+        """
+        self.attach_all()
+        for dock_name in self.panels.keys():
+            self.delete(dock_name)
+
+    def delete(self, dock_name: str):
+        """
+        Delete a dock by name.
+
+        Args:
+            dock_name(str): The name of the dock to delete.
+        """
+        dock = self.dock_area.docks.pop(dock_name, None)
+        self.config.docks.pop(dock_name, None)
+        if dock:
+            dock.close()
+            dock.deleteLater()
+            if len(self.dock_area.docks) <= 1:
+                for dock in self.dock_area.docks.values():
+                    dock.hide_title_bar()
+        else:
+            raise ValueError(f"Dock with name {dock_name} does not exist.")
+        # self._broadcast_update()
+
+    def remove(self) -> None:
+        """
+        Remove the dock area. If the dock area is embedded in a BECMainWindow and
+        is set as the central widget, the main window will be closed.
+        """
+        parent = self.parent()
+        if isinstance(parent, BECMainWindow):
+            central_widget = parent.centralWidget()
+            if central_widget is self:
+                # Closing the parent will also close the dock area
+                parent.close()
+                return
+
+        self.close()
+
 
+if __name__ == "__main__":  # pragma: no cover
 
-if __name__ == "__main__":
-    from qtpy.QtWidgets import QApplication
+    import sys
 
     from bec_widgets.utils.colors import set_theme
 
     app = QApplication([])
     set_theme("auto")
     dock_area = BECDockArea()
+    dock_1 = dock_area.new(name="dock_0", widget="DarkModeButton")
+    dock_1.new(widget="DarkModeButton")
+    # dock_1 = dock_area.new(name="dock_0", widget="Waveform")
+    dock_area.new(widget="DarkModeButton")
     dock_area.show()
+    dock_area.setGeometry(100, 100, 800, 600)
+    app.topLevelWidgets()
+    WidgetHierarchy.print_becconnector_hierarchy_from_app()
     app.exec_()
+    sys.exit(app.exec_())

bec_widgets/widgets/containers/layout_manager/layout_manager.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import math
 import sys
 from typing import Dict, Literal, Optional, Set, Tuple, Union
@@ -34,7 +36,6 @@ class LayoutManagerWidget(QWidget):
 
     def __init__(self, parent=None, auto_reindex=True):
         super().__init__(parent)
-        self.setObjectName("LayoutManagerWidget")
         self.layout = QGridLayout(self)
         self.auto_reindex = auto_reindex
 

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/")