bec-widgets 0.117.1__py3-none-any.whl → 0.119.0__py3-none-any.whl

bec_widgets/widgets/positioner_group/positioner_group.py

@@ -0,0 +1,170 @@
+""" Module for a PositionerGroup widget to control a positioner device."""
+
+from __future__ import annotations
+
+from bec_lib.device import Positioner
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import Property, QSize, Signal, Slot
+from qtpy.QtWidgets import QGridLayout, QGroupBox, QSizePolicy, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.widgets.positioner_box.positioner_box import PositionerBox
+
+logger = bec_logger.logger
+
+
+class PositionerGroupBox(QGroupBox):
+
+    position_update = Signal(float)
+
+    def __init__(self, parent, dev_name):
+        super().__init__(parent)
+
+        self.device_name = dev_name
+
+        QVBoxLayout(self)
+        self.layout().setContentsMargins(0, 0, 0, 0)
+        self.layout().setSpacing(0)
+        self.widget = PositionerBox(self, dev_name)
+        self.widget.compact_view = True
+        self.widget.expand_popup = False
+        self.layout().addWidget(self.widget)
+        self.widget.position_update.connect(self._on_position_update)
+        self.widget.expand.connect(self._on_expand)
+        self.setTitle(self.device_name)
+        self.widget.init_device()  # force readback
+
+    def _on_expand(self, expand):
+        if expand:
+            self.setTitle("")
+            self.setFlat(True)
+        else:
+            self.setTitle(self.device_name)
+            self.setFlat(False)
+
+    def _on_position_update(self, pos: float):
+        self.position_update.emit(pos)
+        self.widget.label = f"%.{self.widget.dev[self.widget.device].precision}f" % pos
+
+    def close(self):
+        self.widget.close()
+        super().close()
+
+
+class PositionerGroup(BECWidget, QWidget):
+    """Simple Widget to control a positioner in box form"""
+
+    ICON_NAME = "grid_view"
+    USER_ACCESS = ["set_positioners"]
+
+    # Signal emitted to inform listeners about a position update of the first positioner
+    position_update = Signal(float)
+    # Signal emitted to inform listeners about (positioner, pos) updates
+    device_position_update = Signal(str, float)
+
+    def __init__(self, parent=None, **kwargs):
+        """Initialize the widget.
+
+        Args:
+            parent: The parent widget.
+        """
+        super().__init__(**kwargs)
+        QWidget.__init__(self, parent)
+
+        self.get_bec_shortcuts()
+
+        QGridLayout(self)
+        self.layout().setContentsMargins(0, 0, 0, 0)
+
+        self._device_widgets = {}
+        self._grid_ncols = 2
+
+    def minimumSizeHint(self):
+        return QSize(300, 30)
+
+    @Slot(str)
+    def set_positioners(self, device_names: str):
+        """Redraw grid with positioners from device_names string
+
+        Device names must be separated by space
+        """
+        devs = device_names.split()
+        for dev_name in devs:
+            if not self._check_device_is_valid(dev_name):
+                raise ValueError(f"{dev_name} is not a valid Positioner")
+        for i, existing_widget in enumerate(self._device_widgets.values()):
+            self.layout().removeWidget(existing_widget)
+            existing_widget.position_update.disconnect(self._on_position_update)
+            if i == 0:
+                existing_widget.position_update.disconnect(self.position_update)
+        for i, dev_name in enumerate(devs):
+            widget = self._device_widgets.get(dev_name)
+            if widget is None:
+                widget = PositionerGroupBox(self, dev_name)
+                self._device_widgets[dev_name] = widget
+                widget.position_update.connect(self._on_position_update)
+                if i == 0:
+                    # only emit 'position_update' for the first positioner in grid
+                    widget.position_update.connect(self.position_update)
+            self.layout().addWidget(widget, i // self._grid_ncols, i % self._grid_ncols)
+        to_remove = set(self._device_widgets) - set(devs)
+        for dev_name in to_remove:
+            self._device_widgets[dev_name].close()
+            del self._device_widgets[dev_name]
+
+    def _check_device_is_valid(self, device: str):
+        """Check if the device is a positioner
+
+        Args:
+            device (str): The device name
+        """
+        if device not in self.dev:
+            logger.info(f"Device {device} not found in the device list")
+            return False
+        if not isinstance(self.dev[device], Positioner):
+            logger.info(f"Device {device} is not a positioner")
+            return False
+        return True
+
+    def _on_position_update(self, pos: float):
+        widget = self.sender()
+        self.device_position_update.emit(widget.title(), pos)
+
+    @Property(str)
+    def devices_list(self):
+        """Device names string separated by space"""
+        return " ".join(self._device_widgets)
+
+    @devices_list.setter
+    def devices_list(self, device_names: str):
+        """Set devices list from device names string separated by space"""
+        devs = device_names.split()
+        for dev_name in devs:
+            if not self._check_device_is_valid(dev_name):
+                return
+        self.set_positioners(device_names)
+
+    @Property(int)
+    def grid_max_cols(self):
+        """Max number of columns for widgets grid"""
+        return self._grid_ncols
+
+    @grid_max_cols.setter
+    def grid_max_cols(self, ncols: int):
+        """Set max number of columns for widgets grid"""
+        self._grid_ncols = ncols
+        self.set_positioners(self.devices_list)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from qtpy.QtWidgets import QApplication  # pylint: disable=ungrouped-imports
+
+    app = QApplication(sys.argv)
+    widget = PositionerGroup()
+    widget.grid_max_cols = 3
+    widget.set_positioners("samx samy samz")
+
+    widget.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/positioner_group/positioner_group.pyproject

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

bec_widgets/widgets/positioner_group/positioner_group_plugin.py

@@ -0,0 +1,57 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import os
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.positioner_group.positioner_group import PositionerGroup
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='PositionerGroup' name='positioner_group'>
+    </widget>
+</ui>
+"""
+MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+
+
+class PositionerGroupPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = PositionerGroup(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "Device Control"
+
+    def icon(self):
+        return designer_material_icon(PositionerGroup.ICON_NAME)
+
+    def includeFile(self):
+        return "positioner_group"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "PositionerGroup"
+
+    def toolTip(self):
+        return "Container Widget to control positioners in compact form, in a grid"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/positioner_group/register_positioner_group.py

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

bec_widgets/widgets/scan_control/scan_control.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from types import SimpleNamespace
 from typing import Optional
 
 from bec_lib.endpoints import MessageEndpoints
@@ -7,11 +8,11 @@ from qtpy.QtCore import Property, Signal, Slot
 from qtpy.QtWidgets import (
     QApplication,
     QComboBox,
-    QGroupBox,
     QHBoxLayout,
     QLabel,
     QPushButton,
     QSizePolicy,
+    QSpacerItem,
     QVBoxLayout,
     QWidget,
 )
@@ -19,6 +20,7 @@ from qtpy.QtWidgets import (
 from bec_widgets.qt_utils.error_popups import SafeSlot
 from bec_widgets.utils import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.colors import get_accent_colors
 from bec_widgets.widgets.scan_control.scan_group_box import ScanGroupBox
 from bec_widgets.widgets.stop_button.stop_button import StopButton
 from bec_widgets.widgets.toggle.toggle import ToggleSwitch
@@ -42,6 +44,7 @@ class ScanControl(BECWidget, QWidget):
 
     scan_started = Signal()
     scan_selected = Signal(str)
+    device_selected = Signal(str)
     scan_axis = Signal(str, float, float)
 
     def __init__(
@@ -61,6 +64,8 @@ class ScanControl(BECWidget, QWidget):
         super().__init__(client=client, gui_id=gui_id, config=config)
         QWidget.__init__(self, parent=parent)
 
+        self._hide_add_remove_buttons = False
+
         # Client from BEC + shortcuts to device manager and scans
         self.get_bec_shortcuts()
 
@@ -84,12 +89,54 @@ class ScanControl(BECWidget, QWidget):
         """
         Initializes the UI of the scan control widget. Create the top box for scan selection and populate scans to main combobox.
         """
-
-        # Scan selection group box
-        self.scan_selection_group = self.create_scan_selection_group()
+        palette = get_accent_colors()
+        if palette is None:
+            palette = SimpleNamespace(
+                default=QColor("blue"),
+                success=QColor("green"),
+                warning=QColor("orange"),
+                emergency=QColor("red"),
+            )
+        # Scan selection box
+        self.scan_selection_group = QWidget(self)
+        QVBoxLayout(self.scan_selection_group)
+        scan_selection_layout = QHBoxLayout()
+        self.comboBox_scan_selection_label = QLabel("Scan:", self.scan_selection_group)
+        self.comboBox_scan_selection = QComboBox(self.scan_selection_group)
+        scan_selection_layout.addWidget(self.comboBox_scan_selection_label, 0)
+        scan_selection_layout.addWidget(self.comboBox_scan_selection, 1)
+        self.scan_selection_group.layout().addLayout(scan_selection_layout)
+
+        # Label to reload the last scan parameters within scan selection group box
+        self.toggle_layout = QHBoxLayout()
+        self.toggle_layout.addSpacerItem(
+            QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Fixed)
+        )
+        self.last_scan_label = QLabel("Restore last scan parameters", self.scan_selection_group)
+        self.toggle = ToggleSwitch(parent=self.scan_selection_group, checked=False)
+        self.toggle.enabled.connect(self.request_last_executed_scan_parameters)
+        self.toggle_layout.addWidget(self.last_scan_label)
+        self.toggle_layout.addWidget(self.toggle)
+        self.scan_selection_group.layout().addLayout(self.toggle_layout)
         self.scan_selection_group.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
         self.layout.addWidget(self.scan_selection_group)
 
+        # Scan control (Run/Stop) buttons
+        self.scan_control_group = QWidget(self)
+        self.scan_control_group.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+        self.button_layout = QHBoxLayout(self.scan_control_group)
+        self.button_run_scan = QPushButton("Start", self.scan_control_group)
+        self.button_run_scan.setStyleSheet(
+            f"background-color: {palette.success.name()}; color: white"
+        )
+        self.button_stop_scan = StopButton(parent=self.scan_control_group)
+        self.button_stop_scan.setStyleSheet(
+            f"background-color: {palette.emergency.name()}; color: white"
+        )
+        self.button_layout.addWidget(self.button_run_scan)
+        self.button_layout.addWidget(self.button_stop_scan)
+        self.layout.addWidget(self.scan_control_group)
+
         # Default scan from config
         if self.config.default_scan is not None:
             self.comboBox_scan_selection.setCurrentText(self.config.default_scan)
@@ -99,67 +146,11 @@ class ScanControl(BECWidget, QWidget):
         self.comboBox_scan_selection.currentIndexChanged.connect(self.on_scan_selection_changed)
         self.button_run_scan.clicked.connect(self.run_scan)
 
-        # Add bundle button
-        self.button_add_bundle = QPushButton("Add Bundle")
-        self.button_add_bundle.setVisible(False)
-        # Remove bundle button
-        self.button_remove_bundle = QPushButton("Remove Bundle")
-        self.button_remove_bundle.setVisible(False)
-
-        bundle_layout = QHBoxLayout()
-        bundle_layout.addWidget(self.button_add_bundle)
-        bundle_layout.addWidget(self.button_remove_bundle)
-        self.layout.addLayout(bundle_layout)
-
-        self.button_add_bundle.clicked.connect(self.add_arg_bundle)
-        self.button_remove_bundle.clicked.connect(self.remove_arg_bundle)
-
         self.scan_selected.connect(self.scan_select)
 
         # Initialize scan selection
         self.populate_scans()
 
-    def create_scan_selection_group(self) -> QGroupBox:
-        """
-        Creates the scan selection group box with combobox to select the scan and start/stop button.
-
-        Returns:
-            QGroupBox: Group box containing the scan selection widgets.
-        """
-
-        scan_selection_group = QGroupBox("Scan Selection", self)
-        self.scan_selection_layout = QVBoxLayout(scan_selection_group)
-        self.comboBox_scan_selection = QComboBox(scan_selection_group)
-
-        # Buttons
-        self.button_layout = QHBoxLayout()
-        ## Run button
-        self.button_run_scan = QPushButton("Start", scan_selection_group)
-        self.button_run_scan.setStyleSheet("background-color:  #559900; color: white")
-        ## Stop button
-        self.button_stop_scan = StopButton(parent=scan_selection_group)
-        ## Add buttons to layout
-        self.button_layout.addWidget(self.button_run_scan)
-        self.button_layout.addWidget(self.button_stop_scan)
-
-        # Label to reload the last scan parameters
-        self.toggle_layout = QHBoxLayout()
-        ## Label
-        self.last_scan_label = QLabel("Restore last scan parameters", scan_selection_group)
-        ## Switch toggle button
-        self.toggle = ToggleSwitch(parent=scan_selection_group, checked=False)
-        self.toggle.enabled.connect(self.request_last_executed_scan_parameters)
-        ## Add label and switch to layout
-        self.toggle_layout.addWidget(self.last_scan_label)
-        self.toggle_layout.addWidget(self.toggle)
-
-        # Add widgets to layout
-        self.scan_selection_layout.addWidget(self.comboBox_scan_selection)
-        self.scan_selection_layout.addLayout(self.button_layout)
-        self.scan_selection_layout.addLayout(self.toggle_layout)
-
-        return scan_selection_group
-
     def populate_scans(self):
         """Populates the scan selection combo box with available scans from BEC session."""
         self.available_scans = self.client.connector.get(
@@ -282,29 +273,6 @@ class ScanControl(BECWidget, QWidget):
             for box in self.kwarg_boxes:
                 box.setVisible(not hide)
 
-    @Property(bool)
-    def hide_scan_remember_toggle(self):
-        """Property to hide the scan remember toggle."""
-        return not self.toggle.isVisible()
-
-    @hide_scan_remember_toggle.setter
-    def hide_scan_remember_toggle(self, hide: bool):
-        """Setter for the hide_scan_remember_toggle property.
-
-        Args:
-            hide(bool): Hide or show the scan remember toggle.
-        """
-        self.show_scan_remember_toggle(not hide)
-
-    @Slot(bool)
-    def show_scan_remember_toggle(self, show: bool):
-        """Shows or hides the scan control buttons."""
-        self.toggle.setVisible(show)
-        self.last_scan_label.setVisible(show)
-
-        show_group = show or self.button_run_scan.isVisible()
-        self.scan_selection_group.setVisible(show_group)
-
     @Property(bool)
     def hide_scan_control_buttons(self):
         """Property to hide the scan control buttons."""
@@ -322,11 +290,7 @@ class ScanControl(BECWidget, QWidget):
     @Slot(bool)
     def show_scan_control_buttons(self, show: bool):
         """Shows or hides the scan control buttons."""
-        self.button_run_scan.setVisible(show)
-        self.button_stop_scan.setVisible(show)
-
-        show_group = show or self.button_run_scan.isVisible()
-        self.scan_selection_group.setVisible(show_group)
+        self.scan_control_group.setVisible(show)
 
     @Property(bool)
     def hide_scan_selection_combobox(self):
@@ -345,10 +309,7 @@ class ScanControl(BECWidget, QWidget):
     @Slot(bool)
     def show_scan_selection_combobox(self, show: bool):
         """Shows or hides the scan selection combobox."""
-        self.comboBox_scan_selection.setVisible(show)
-
-        show_group = show or self.button_run_scan.isVisible()
-        self.scan_selection_group.setVisible(show_group)
+        self.scan_selection_group.setVisible(show)
 
     @Slot(str)
     def scan_select(self, scan_name: str):
@@ -365,11 +326,7 @@ class ScanControl(BECWidget, QWidget):
         self.arg_group = gui_config.get("arg_group", None)
         self.kwarg_groups = gui_config.get("kwarg_groups", None)
 
-        show_bundle_buttons = bool(self.arg_group["arg_inputs"])
-
-        self._show_bundle_buttons(show_bundle_buttons)
-
-        if show_bundle_buttons:
+        if bool(self.arg_group["arg_inputs"]):
             self.add_arg_group(self.arg_group)
         if len(self.kwarg_groups) > 0:
             self.add_kwargs_boxes(self.kwarg_groups)
@@ -377,28 +334,21 @@ class ScanControl(BECWidget, QWidget):
         self.update()
         self.adjustSize()
 
-    def _show_bundle_buttons(self, show: bool):
-        """Shows or hides the bundle buttons based on the show argument.
-
-        Args:
-            show(bool): Show or hide the bundle buttons.
-        """
-        self.button_add_bundle.setVisible(show)
-        self.button_remove_bundle.setVisible(show)
-
     @Property(bool)
-    def hide_bundle_buttons(self):
-        """Property to hide the bundle buttons."""
-        return not self.button_add_bundle.isVisible()
+    def hide_add_remove_buttons(self):
+        """Property to hide the add_remove buttons."""
+        return self._hide_add_remove_buttons
 
-    @hide_bundle_buttons.setter
-    def hide_bundle_buttons(self, hide: bool):
-        """Setter for the hide_bundle_buttons property.
+    @hide_add_remove_buttons.setter
+    def hide_add_remove_buttons(self, hide: bool):
+        """Setter for the hide_add_remove_buttons property.
 
         Args:
-            hide(bool): Hide or show the bundle buttons.
+            hide(bool): Hide or show the add_remove buttons.
         """
-        self._show_bundle_buttons(not hide)
+        self._hide_add_remove_buttons = hide
+        if self.arg_box is not None:
+            self.arg_box.hide_add_remove_buttons = hide
 
     def add_kwargs_boxes(self, groups: list):
         """
@@ -420,18 +370,20 @@ class ScanControl(BECWidget, QWidget):
         Args:
         """
         self.arg_box = ScanGroupBox(box_type="args", config=group)
+        self.arg_box.device_selected.connect(self.emit_device_selected)
         self.arg_box.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+        self.arg_box.hide_add_remove_buttons = self._hide_add_remove_buttons
         self.layout.addWidget(self.arg_box)
 
-    @Slot()
-    def add_arg_bundle(self):
-        """Adds a new argument bundle to the scan control layout."""
-        self.arg_box.add_widget_bundle()
+    @Slot(str)
+    def emit_device_selected(self, dev_names):
+        """
+        Emit the signal to inform about selected device(s)
 
-    @Slot()
-    def remove_arg_bundle(self):
-        """Removes the last argument bundle from the scan control layout."""
-        self.arg_box.remove_widget_bundle()
+        "dev_names" is a string separated by space, in case of multiple devices
+        """
+        self._selected_devices = dev_names
+        self.device_selected.emit(dev_names)
 
     def reset_layout(self):
         """Clears the scan control layout from GuiGroups and ArgGroups boxes."""