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

bec_widgets/qt_utils/compact_popup.py

@@ -1,7 +1,8 @@
+import time
 from types import SimpleNamespace
 
 from bec_qthemes import material_icon
-from qtpy.QtCore import Property, Qt
+from qtpy.QtCore import Property, Qt, Signal
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import (
     QDialog,
@@ -9,6 +10,7 @@ from qtpy.QtWidgets import (
     QLabel,
     QPushButton,
     QSizePolicy,
+    QSpacerItem,
     QVBoxLayout,
     QWidget,
 )
@@ -98,6 +100,7 @@ class PopupDialog(QDialog):
     def closeEvent(self, event):
         self.content_widget.setVisible(False)
         self.content_widget.setParent(self.parent)
+        self.done(True)
 
 
 class CompactPopupWidget(QWidget):
@@ -107,29 +110,35 @@ class CompactPopupWidget(QWidget):
     In the compact form, a LED-like indicator shows a status indicator.
     """
 
+    expand = Signal(bool)
+
     def __init__(self, parent=None, layout=QVBoxLayout):
         super().__init__(parent)
 
         self._popup_window = None
+        self._expand_popup = True
 
         QVBoxLayout(self)
-        self.compact_view = QWidget(self)
-        self.compact_view.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-        QHBoxLayout(self.compact_view)
-        self.compact_view.layout().setSpacing(0)
-        self.compact_view.layout().setContentsMargins(0, 0, 0, 0)
-        self.compact_label = QLabel(self.compact_view)
-        self.compact_status = LedLabel(self.compact_view)
-        self.compact_show_popup = QPushButton(self.compact_view)
+        self.compact_view_widget = QWidget(self)
+        self.compact_view_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        QHBoxLayout(self.compact_view_widget)
+        self.compact_view_widget.layout().setSpacing(0)
+        self.compact_view_widget.layout().setContentsMargins(0, 0, 0, 0)
+        self.compact_view_widget.layout().addSpacerItem(
+            QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Fixed)
+        )
+        self.compact_label = QLabel(self.compact_view_widget)
+        self.compact_status = LedLabel(self.compact_view_widget)
+        self.compact_show_popup = QPushButton(self.compact_view_widget)
         self.compact_show_popup.setFlat(True)
         self.compact_show_popup.setIcon(
-            material_icon(icon_name="pan_zoom", size=(10, 10), convert_to_pixmap=False)
+            material_icon(icon_name="expand_content", size=(10, 10), convert_to_pixmap=False)
         )
-        self.compact_view.layout().addWidget(self.compact_label)
-        self.compact_view.layout().addWidget(self.compact_status)
-        self.compact_view.layout().addWidget(self.compact_show_popup)
-        self.compact_view.setVisible(False)
-        self.layout().addWidget(self.compact_view)
+        self.compact_view_widget.layout().addWidget(self.compact_label)
+        self.compact_view_widget.layout().addWidget(self.compact_status)
+        self.compact_view_widget.layout().addWidget(self.compact_show_popup)
+        self.compact_view_widget.setVisible(False)
+        self.layout().addWidget(self.compact_view_widget)
         self.container = QWidget(self)
         self.layout().addWidget(self.container)
         self.container.setVisible(True)
@@ -148,8 +157,36 @@ class CompactPopupWidget(QWidget):
 
     def show_popup(self):
         """Display the contained widgets in a popup dialog"""
-        self._popup_window = PopupDialog(self.container)
-        self._popup_window.show()
+        if self._expand_popup:
+            # show popup
+            self._popup_window = PopupDialog(self.container)
+            self._popup_window.show()
+            self._popup_window.finished.connect(lambda: self.expand.emit(False))
+            self.expand.emit(True)
+        else:
+            if self.compact_view:
+                # expand in place
+                self.compact_view = False
+                self.compact_view_widget.setVisible(True)
+                self.compact_label.setVisible(False)
+                self.compact_status.setVisible(False)
+                self.compact_show_popup.setIcon(
+                    material_icon(
+                        icon_name="collapse_content", size=(10, 10), convert_to_pixmap=False
+                    )
+                )
+                self.expand.emit(True)
+            else:
+                # back to compact form
+                self.compact_label.setVisible(True)
+                self.compact_status.setVisible(True)
+                self.compact_show_popup.setIcon(
+                    material_icon(
+                        icon_name="expand_content", size=(10, 10), convert_to_pixmap=False
+                    )
+                )
+                self.compact_view = True
+                self.expand.emit(False)
 
     def setSizePolicy(self, size_policy1, size_policy2=None):
         # setting size policy on the compact popup widget will set
@@ -172,11 +209,11 @@ class CompactPopupWidget(QWidget):
         self.container.layout().addWidget(widget)
 
     @Property(bool)
-    def compact(self):
-        return self.compact_view.isVisible()
+    def compact_view(self):
+        return self.compact_label.isVisible()
 
-    @compact.setter
-    def compact(self, set_compact: bool):
+    @compact_view.setter
+    def compact_view(self, set_compact: bool):
         """Sets the compact form
 
         If set_compact is True, the compact view is displayed ; otherwise,
@@ -184,11 +221,11 @@ class CompactPopupWidget(QWidget):
         the container widget or the compact view widget.
         """
         if set_compact:
-            self.compact_view.setVisible(True)
+            self.compact_view_widget.setVisible(True)
             self.container.setVisible(False)
             QWidget.setSizePolicy(self, QSizePolicy.Fixed, QSizePolicy.Fixed)
         else:
-            self.compact_view.setVisible(False)
+            self.compact_view_widget.setVisible(False)
             self.container.setVisible(True)
             QWidget.setSizePolicy(self, self.container.sizePolicy())
         if self.parentWidget():
@@ -215,6 +252,14 @@ class CompactPopupWidget(QWidget):
         self.compact_label.setToolTip(tooltip)
         self.compact_status.setToolTip(tooltip)
 
+    @Property(bool)
+    def expand_popup(self):
+        return self._expand_popup
+
+    @expand_popup.setter
+    def expand_popup(self, popup: bool):
+        self._expand_popup = popup
+
     def closeEvent(self, event):
         # Called by Qt, on closing - since the children widgets can be
         # BECWidgets, it is good to explicitely call 'close' on them,

bec_widgets/widgets/device_line_edit/device_line_edit.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from qtpy.QtCore import QSize
+from qtpy.QtCore import QSize, Signal, Slot
 from qtpy.QtWidgets import QCompleter, QLineEdit, QSizePolicy
 
 from bec_widgets.utils.bec_widget import BECWidget
@@ -24,6 +24,8 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
     """
 
+    device_selected = Signal(str)
+
     ICON_NAME = "edit_note"
 
     def __init__(
@@ -54,6 +56,18 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
         self.setMinimumSize(QSize(100, 0))
 
+        self.editingFinished.connect(self.emit_device_selected)
+
+    @Slot()
+    def emit_device_selected(self):
+        """
+        Editing finished, let's see which device is selected and emit signal
+        """
+        device_name = self.text().lower()
+        device_obj = getattr(self.dev, device_name, None)
+        if device_obj is not None:
+            self.device_selected.emit(device_name)
+
     def set_device_filter(self, device_filter: str | list[str]):
         """
         Set the device filter.

bec_widgets/widgets/positioner_box/positioner_box.py

@@ -14,6 +14,7 @@ from qtpy.QtCore import Property, Signal, Slot
 from qtpy.QtGui import QDoubleValidator
 from qtpy.QtWidgets import QDialog, QDoubleSpinBox, QPushButton, QVBoxLayout, QWidget
 
+from bec_widgets.qt_utils.compact_popup import CompactPopupWidget
 from bec_widgets.utils import UILoader
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import get_accent_colors, set_theme
@@ -24,7 +25,7 @@ logger = bec_logger.logger
 MODULE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 
 
-class PositionerBox(BECWidget, QWidget):
+class PositionerBox(BECWidget, CompactPopupWidget):
     """Simple Widget to control a positioner in box form"""
 
     ui_file = "positioner_box.ui"
@@ -44,7 +45,7 @@ class PositionerBox(BECWidget, QWidget):
             device (Positioner): The device to control.
         """
         super().__init__(**kwargs)
-        QWidget.__init__(self, parent=parent)
+        CompactPopupWidget.__init__(self, parent=parent, layout=QVBoxLayout)
         self.get_bec_shortcuts()
         self._device = ""
         self._limits = None
@@ -63,8 +64,7 @@ class PositionerBox(BECWidget, QWidget):
         current_path = os.path.dirname(__file__)
         self.ui = UILoader(self).loader(os.path.join(current_path, self.ui_file))
 
-        self.layout = QVBoxLayout(self)
-        self.layout.addWidget(self.ui)
+        self.addWidget(self.ui)
         self.layout.setSpacing(0)
         self.layout.setContentsMargins(0, 0, 0, 0)
 
@@ -135,8 +135,12 @@ class PositionerBox(BECWidget, QWidget):
         """Setter, checks if device is a string"""
         if not value or not isinstance(value, str):
             return
+        if not self._check_device_is_valid(value):
+            return
         old_device = self._device
         self._device = value
+        if not self.label:
+            self.label = value
         self.device_changed.emit(old_device, value)
 
     @Property(bool)
@@ -241,9 +245,11 @@ class PositionerBox(BECWidget, QWidget):
             if is_moving:
                 self.ui.spinner_widget.start()
                 self.ui.spinner_widget.setToolTip("Device is moving")
+                self.set_global_state("warning")
             else:
                 self.ui.spinner_widget.stop()
                 self.ui.spinner_widget.setToolTip("Device is idle")
+                self.set_global_state("success")
 
         if readback_val is not None:
             self.ui.readback.setText(f"{readback_val:.{precision}f}")

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()