qplotter 1.6.0__py3-none-any.whl

qplot/windows/_widgets/run_list_items.py

@@ -0,0 +1,488 @@
+from PyQt6 import QtCore, QtGui
+from PyQt6 import QtWidgets as qtw
+
+from ._run_formatting import one_dimensional_duplicate_point_count, run_tooltip_text
+from .preview import (
+    DraggablePreviewImageLabel,
+    PreviewImageLabel,
+    preview_placeholder_dimensions,
+    unsupported_preview_label,
+)
+
+MEASUREMENT_PREVIEW_SIZE = 22
+MEASUREMENT_PREVIEW_SPACING = 3
+MEASUREMENT_PREVIEW_GENERATING_COLORS = (
+    "#e9f4ff",
+    "#edf7f1",
+    "#fff4e3",
+    "#f4efff",
+    "#eef7f8",
+    "#f8eff4",
+    )
+MEASUREMENT_PREVIEW_GENERATING_BORDERS = (
+    "#bdd8f2",
+    "#c5dfcc",
+    "#ead3aa",
+    "#d4c8ee",
+    "#bfdadd",
+    "#e0c3d1",
+    )
+
+
+class RunPreviewCell(qtw.QWidget):
+    plotRequested = QtCore.pyqtSignal(str, str)
+    exportRequested = QtCore.pyqtSignal(str, str)
+
+    def __init__(self, guid, count, parent=None, icon_size=MEASUREMENT_PREVIEW_SIZE):
+        super().__init__(parent)
+        self.guid = guid
+        self.placeholder_count = max(0, int(count or 0))
+        self.icon_size = int(icon_size)
+        self._generating = False
+        self._has_rendered_previews = False
+        self._placeholder_dimensions = []
+        self._placeholder_parameters = []
+        self._previews = []
+        self._pending_display = None
+
+        self.content_layout = qtw.QHBoxLayout()
+        self.content_layout.setContentsMargins(2, 0, 2, 0)
+        self.content_layout.setSpacing(MEASUREMENT_PREVIEW_SPACING)
+        self.content_layout.setAlignment(
+            QtCore.Qt.AlignmentFlag.AlignLeft
+            | QtCore.Qt.AlignmentFlag.AlignVCenter
+            )
+        self.setLayout(self.content_layout)
+        self.setFixedHeight(self.icon_size + 6)
+        self.show_placeholders()
+
+
+    def show_placeholders(self, count=None, generating=None):
+        if self._defer_display_during_drag(("placeholders", count, generating)):
+            return
+        selected_parameter = self._clear_layout()
+        self._has_rendered_previews = False
+        self._previews = []
+        if generating is not None:
+            self._generating = bool(generating)
+        placeholder_count = self.placeholder_count if count is None else max(0, int(count))
+        for index in range(placeholder_count):
+            self.content_layout.addWidget(
+                self._placeholder_label(index, generating=self._generating)
+                )
+        self.content_layout.addStretch()
+        self._restore_selection(selected_parameter)
+
+
+    def show_previews(self, previews):
+        previews = list(previews or [])
+        if self._defer_display_during_drag(("previews", previews)):
+            return
+        self._generating = False
+        selected_parameter = self._clear_layout()
+        self._previews = list(previews or [])
+
+        preview_count = 0
+        parameters = self._placeholder_parameters
+        if parameters:
+            previews_by_parameter: dict[str, list[dict]] = {}
+            for preview in self._previews:
+                if not self._preview_is_displayable(preview):
+                    continue
+                parameter = preview.get("parameter", "")
+                previews_by_parameter.setdefault(parameter, []).append(preview)
+
+            slot_count = max(self.placeholder_count, len(parameters))
+            for index in range(slot_count):
+                preview = None
+                if index < len(parameters):
+                    matches = previews_by_parameter.get(parameters[index]) or []
+                    if matches:
+                        preview = matches.pop(0)
+                if preview is None:
+                    self.content_layout.addWidget(self._placeholder_label(index))
+                else:
+                    self._add_preview_label(preview)
+                    preview_count += 1
+        else:
+            for preview in self._previews:
+                if not self._preview_is_displayable(preview):
+                    continue
+                self._add_preview_label(preview)
+                preview_count += 1
+            for index in range(preview_count, self.placeholder_count):
+                self.content_layout.addWidget(self._placeholder_label(index))
+        self.content_layout.addStretch()
+        self._has_rendered_previews = preview_count > 0
+        self._restore_selection(selected_parameter)
+
+
+    @staticmethod
+    def _preview_is_displayable(preview):
+        return bool(preview.get("unsupported") or preview.get("image") is not None)
+
+
+    def _add_preview_label(self, preview):
+        if preview.get("unsupported"):
+            label = unsupported_preview_label(
+                preview,
+                self.icon_size,
+                "measurementPreviewUnsupported",
+                )
+            self.content_layout.addWidget(label)
+            return
+
+        label = DraggablePreviewImageLabel(
+            self.guid,
+            preview.get("parameter", ""),
+            preview.get("axes") or [],
+            )
+        label.setObjectName("measurementPreviewImage")
+        label.setFixedSize(self.icon_size, self.icon_size)
+        label.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        label.setToolTip(preview.get("title", ""))
+        label.set_preview_accessibility(preview.get("title"))
+        label.setPixmap(
+            QtGui.QPixmap.fromImage(preview["image"]).scaled(
+                self.icon_size,
+                self.icon_size,
+                QtCore.Qt.AspectRatioMode.KeepAspectRatio,
+                QtCore.Qt.TransformationMode.SmoothTransformation,
+                )
+            )
+        label.plotRequested.connect(self._emit_plot_requested)
+        label.exportRequested.connect(self._emit_export_requested)
+        label.dragFinished.connect(self._apply_pending_display)
+        self.content_layout.addWidget(label)
+
+
+    def set_generating(self, generating):
+        generating = bool(generating)
+        if generating:
+            if self._generating:
+                return
+            if self._has_rendered_previews:
+                self._generating = True
+                return
+            self.show_placeholders(generating=True)
+            return
+
+        self._generating = False
+        for label in self.findChildren(qtw.QLabel, "measurementPreviewPlaceholder"):
+            label.setStyleSheet("")
+            label.setToolTip("")
+
+
+    def update_placeholder_metadata(self, metadata):
+        dimensions = preview_placeholder_dimensions(metadata)
+        parameters = list(metadata.get("measure_parameters") or [])
+        if (dimensions != self._placeholder_dimensions
+                or parameters != self._placeholder_parameters):
+            self._placeholder_dimensions = dimensions
+            self._placeholder_parameters = parameters
+            if self._has_rendered_previews:
+                self.show_previews(self._previews)
+            else:
+                self.show_placeholders()
+
+
+    def _placeholder_label(self, index=0, generating=False):
+        parameters = self._placeholder_parameters
+        parameter = parameters[index] if index < len(parameters) else ""
+        label = DraggablePreviewImageLabel(self.guid, parameter, axes_pending=True)
+        label.dragFinished.connect(self._apply_pending_display)
+        label.plotRequested.connect(self._emit_plot_requested)
+        label.exportRequested.connect(self._emit_export_requested)
+        dimensions = self._placeholder_dimensions
+        dimension = dimensions[index] if index < len(dimensions) else None
+        label.setText(f"{dimension}D" if dimension else "")
+        label.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
+        font = label.font()
+        font.setPointSize(8)
+        label.setFont(font)
+        label.setObjectName("measurementPreviewPlaceholder")
+        label.setFixedSize(self.icon_size, self.icon_size)
+        label.setFrameShape(qtw.QFrame.Shape.Box)
+        label.setFrameShadow(qtw.QFrame.Shadow.Plain)
+        label.setLineWidth(1)
+        if generating:
+            color, border = self._generating_placeholder_colors(index)
+            label.setStyleSheet(
+                "QLabel#measurementPreviewPlaceholder {"
+                f"background-color: {color};"
+                f"border: 1px solid {border};"
+                "}"
+                )
+            label.setToolTip("Generating preview")
+        return label
+
+
+    def _defer_display_during_drag(self, display):
+        # QDrag runs a nested event loop. Preview publication in that loop
+        # must not replace/delete its source until the user has dropped it.
+        if any(label.drag_active for label in self.findChildren(DraggablePreviewImageLabel)):
+            self._pending_display = display
+            return True
+        return False
+
+
+    def _apply_pending_display(self):
+        display = self._pending_display
+        self._pending_display = None
+        if display is None:
+            return
+        if display[0] == "previews":
+            self.show_previews(display[1])
+        else:
+            self.show_placeholders(count=display[1], generating=display[2])
+
+
+    def _generating_placeholder_colors(self, index):
+        seed = sum(ord(char) for char in str(self.guid or ""))
+        palette_index = (seed + int(index or 0)) % len(MEASUREMENT_PREVIEW_GENERATING_COLORS)
+        return (
+            MEASUREMENT_PREVIEW_GENERATING_COLORS[palette_index],
+            MEASUREMENT_PREVIEW_GENERATING_BORDERS[palette_index],
+            )
+
+
+    def _emit_plot_requested(self, parameter):
+        self.plotRequested.emit(self.guid, parameter)
+
+
+    def _emit_export_requested(self, parameter):
+        self.exportRequested.emit(self.guid, parameter)
+
+
+    def _clear_layout(self):
+        selected_parameter = next(
+            (label.parameter for label in self.findChildren(PreviewImageLabel)
+             if label._selected),
+            None,
+            )
+        while self.content_layout.count():
+            item = self.content_layout.takeAt(0)
+            if item is None:
+                continue
+            widget = item.widget()
+            if widget is not None:
+                widget.setParent(None)
+                widget.deleteLater()
+        return selected_parameter
+
+
+    def _restore_selection(self, parameter):
+        if parameter:
+            for label in self.findChildren(PreviewImageLabel):
+                if label.parameter == parameter:
+                    label.set_selected(True)
+                    break
+
+
+class EqualsAlignedDelegate(qtw.QStyledItemDelegate):
+    """
+    Paints setpoint counts with equals signs aligned.
+    """
+
+    right_text_alignment = (
+        QtCore.Qt.AlignmentFlag.AlignLeft
+        | QtCore.Qt.AlignmentFlag.AlignVCenter
+        )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._right_width_cache = {}
+
+
+    def invalidate_width_cache(self):
+        self._right_width_cache.clear()
+
+    def paint(self, painter, option, index):
+        text = index.data(QtCore.Qt.ItemDataRole.DisplayRole)
+        if text is None or text == "":
+            super().paint(painter, option, index)
+            return
+
+        opt = qtw.QStyleOptionViewItem(option)
+        self.initStyleOption(opt, index)
+        text = str(text)
+        sections = self._display_sections(text)
+        if sections is None:
+            super().paint(painter, option, index)
+            return
+        left, right = sections
+
+        opt.text = ""
+
+        widget = opt.widget
+        style = widget.style() if widget else qtw.QApplication.style()
+        if style is None:
+            super().paint(painter, option, index)
+            return
+        style.drawControl(qtw.QStyle.ControlElement.CE_ItemViewItem, opt, painter, widget)
+
+        text_rect = style.subElementRect(
+            qtw.QStyle.SubElement.SE_ItemViewItemText,
+            opt,
+            widget
+            ).adjusted(2, 0, -2, 0)
+        metrics = opt.fontMetrics
+        equals_text = " = "
+        equals_width = metrics.horizontalAdvance(equals_text)
+        max_right_width = self._max_right_width(index, metrics)
+        if right is None and max_right_width <= 0:
+            painter.save()
+            painter.setFont(opt.font)
+            painter.setPen(self._text_color(opt))
+            painter.drawText(
+                text_rect,
+                QtCore.Qt.AlignmentFlag.AlignRight
+                | QtCore.Qt.AlignmentFlag.AlignVCenter,
+                metrics.elidedText(left, QtCore.Qt.TextElideMode.ElideLeft, text_rect.width())
+                )
+            painter.restore()
+            return
+
+        equals_left = max(
+            text_rect.left(),
+            text_rect.right() - max_right_width - equals_width
+            )
+
+        left_rect = QtCore.QRect(
+            text_rect.left(),
+            text_rect.top(),
+            max(0, equals_left - text_rect.left()),
+            text_rect.height()
+            )
+        equals_rect = QtCore.QRect(
+            equals_left,
+            text_rect.top(),
+            equals_width,
+            text_rect.height()
+            )
+        right_rect = QtCore.QRect(
+            equals_left + equals_width,
+            text_rect.top(),
+            max(0, text_rect.right() - equals_left - equals_width + 1),
+            text_rect.height()
+            )
+
+        painter.save()
+        painter.setFont(opt.font)
+        painter.setPen(self._text_color(opt))
+        painter.drawText(
+            left_rect,
+            QtCore.Qt.AlignmentFlag.AlignRight | QtCore.Qt.AlignmentFlag.AlignVCenter,
+            metrics.elidedText(left, QtCore.Qt.TextElideMode.ElideLeft, left_rect.width())
+            )
+        if right is not None:
+            painter.drawText(equals_rect, QtCore.Qt.AlignmentFlag.AlignCenter, equals_text)
+            self._draw_right_text(painter, right_rect, right, metrics)
+        painter.restore()
+
+
+    def _display_sections(self, text):
+        if " = " in text:
+            return str(text).split(" = ", 1)
+        if self._is_count_text(text):
+            return str(text), None
+        return None
+
+
+    def _is_count_text(self, text):
+        try:
+            int(str(text).replace(",", ""))
+        except (TypeError, ValueError):
+            return False
+        return True
+
+
+    def _draw_right_text(self, painter, right_rect, right, metrics):
+        painter.drawText(
+            right_rect,
+            self.right_text_alignment,
+            metrics.elidedText(right, QtCore.Qt.TextElideMode.ElideRight, right_rect.width())
+            )
+
+
+    def _max_right_width(self, index, metrics):
+        view = self.parent()
+        if not isinstance(view, qtw.QTreeWidget):
+            return 0
+
+        column = index.column()
+        cached = self._right_width_cache.get(column)
+        if cached is not None:
+            return cached
+
+        max_width = 0
+        for row in range(view.topLevelItemCount()):
+            item = view.topLevelItem(row)
+            if item is None:
+                continue
+
+            sections = self._display_sections(item.text(column))
+            if sections is None:
+                continue
+
+            _, right = sections
+            if right is None:
+                right = one_dimensional_duplicate_point_count(
+                    getattr(item, "run_metadata", {})
+                    )
+            if right is None:
+                continue
+
+            max_width = max(max_width, metrics.horizontalAdvance(right))
+        self._right_width_cache[column] = max_width
+        return max_width
+
+
+    def _text_color(self, option):
+        return option.palette.color(QtGui.QPalette.ColorRole.Text)
+
+
+class SortableTreeWidgetItem(qtw.QTreeWidgetItem):
+    """
+    QTreeWidgetItem with an overridden comparator that sorts numerical values
+    as numbers instead of sorting them alphabetically.
+    """
+    def __init__(self, strings):
+        super().__init__(strings)
+        self.run_metadata = {}
+        self._guid = ""
+
+    def __lt__(self, other: qtw.QTreeWidgetItem) -> bool:
+        tree = self.treeWidget()
+        if tree is None:
+            return super().__lt__(other)
+
+        col = tree.sortColumn()
+        value1 = self.data(col, QtCore.Qt.ItemDataRole.UserRole)
+        value2 = other.data(col, QtCore.Qt.ItemDataRole.UserRole)
+        if value1 is not None and value2 is not None:
+            try:
+                return float(value1) < float(value2)
+            except (TypeError, ValueError):
+                pass
+
+        text1 = self.text(col)
+        text2 = other.text(col)
+        try:
+            return float(text1) < float(text2)
+        except ValueError:
+            return text1 < text2
+
+    @property
+    def guid(self):
+        return self._guid
+
+
+    def set_guid(self, guid):
+        self._guid = guid
+
+
+    def update_tooltip(self):
+        tooltip = run_tooltip_text(self.run_metadata)
+        for col in range(self.columnCount()):
+            self.setToolTip(col, tooltip)

qplot/windows/_widgets/toolbar.py

@@ -0,0 +1,111 @@
+from typing import Any
+
+from PyQt6 import QtCore
+from PyQt6 import QtWidgets as qtw
+
+_NO_ALIGNMENT = QtCore.Qt.AlignmentFlag(0)
+
+
+class QDock_context(qtw.QDockWidget):
+    """
+    A custom QDockWidget designed to emulate a side QToolbar.
+    
+    """
+    def __init__(self, *args, **kargs):
+        super().__init__(*args, **kargs)
+        
+        self.setTitleBarWidget(qtw.QWidget(self))
+        
+        self.event_filter = contextMenuFilter(self, self.parent())
+        self.installEventFilter(self.event_filter)
+        
+        core_widget = qtw.QFrame()
+        self.setWidget(core_widget)
+        
+        self.content_layout = self.VBox_context(self.event_filter, core_widget)
+        
+    
+    ### Overwrite add functions to add to main layout
+    def addLayout(self, *args: Any, **kargs: Any) -> "QDock_context.HBox_context":
+        layout = self.HBox_context(self.event_filter, *args, **kargs)
+        self.content_layout.addLayout(layout)
+        return layout
+        
+    def addWidget(self, *args: Any, **kargs: Any) -> None:
+        self.content_layout.addWidget(*args, **kargs)
+    
+    ### SUB CLASS LAYOUT TO CARRY CONTEXT MENU THROUGH ###
+    class VBox_context(qtw.QVBoxLayout):
+        def __init__(self, event_filter, *args, **kargs):
+            super().__init__(*args, **kargs)
+            self.event_filter = event_filter
+            
+        def addWidget(
+                self,
+                widget: qtw.QWidget | None,
+                stretch: int = 0,
+                alignment: QtCore.Qt.AlignmentFlag = _NO_ALIGNMENT,
+                ) -> None:
+            if widget is not None:
+                widget.installEventFilter(self.event_filter)
+            for child in self.findChildren(qtw.QWidget):
+                child.installEventFilter(self.event_filter)
+
+            super().addWidget(widget, stretch, alignment)
+            
+    class HBox_context(qtw.QHBoxLayout):
+        def __init__(self, event_filter, *args, **kargs):
+            super().__init__(*args, **kargs)
+            self.event_filter = event_filter
+            
+        def addWidget(
+                self,
+                widget: qtw.QWidget | None,
+                stretch: int = 0,
+                alignment: QtCore.Qt.AlignmentFlag = _NO_ALIGNMENT,
+                ) -> None:
+            if widget is not None:
+                widget.installEventFilter(self.event_filter)
+            for child in self.findChildren(qtw.QWidget):
+                child.installEventFilter(self.event_filter)
+            
+            super().addWidget(widget, stretch, alignment)
+            
+                
+class contextMenuFilter(QtCore.QObject):
+    """Filter to show toggle menu from any widget inside the dock."""
+    def __init__(self, parent, main_window):
+        super().__init__(parent)
+        self.main_window = main_window
+
+    def eventFilter(self, obj, event):
+        """
+        Event handler for right-clicking on a QDock_context
+        Produces a context menu for toggling display of toolbars and dockwidgets
+
+        Parameters
+        ----------
+        obj :
+            Unused by required slot.
+        event : PyQt6.QtCore.QEvent.Type.ContextMenu
+            
+        Returns
+        -------
+        bool
+            Whether to show context menu.
+
+        """
+        if event.type() == QtCore.QEvent.Type.ContextMenu:
+            menu = qtw.QMenu(self.main_window)
+
+            # Find toolbar and dock widgets to add to context menu
+            for toolbar in self.main_window.findChildren(qtw.QToolBar):
+                menu.addAction(toolbar.toggleViewAction())
+
+            for dock in self.main_window.findChildren(qtw.QDockWidget):
+                menu.addAction(dock.toggleViewAction())
+
+            # Display context menu
+            menu.exec(event.globalPos())
+            return True
+        return False