qplotter 1.6.0__py3-none-any.whl

qplot/windows/_plot_annotation.py

@@ -0,0 +1,186 @@
+"""Database/run provenance drawn in the plot scene, including exports."""
+
+from html import escape
+from pathlib import Path
+
+import pyqtgraph as pg
+from PyQt6 import QtCore, QtGui, QtWidgets
+
+from qplot.configuration.fonts import FONT_SIZE_KEY
+
+SHOW_SOURCE_ANNOTATION_KEY = "user_preference.show_source_annotation"
+
+
+def _run_ranges(run_ids):
+    """Compress sequences of three or more; leave pairs as separate IDs."""
+    runs = sorted(set(run_ids))
+    groups = []
+    start = 0
+    while start < len(runs):
+        end = start
+        while end + 1 < len(runs) and runs[end + 1] == runs[end] + 1:
+            end += 1
+        if end - start >= 2:
+            groups.append(f"{runs[start]}-{runs[end]}")
+        else:
+            groups.extend(str(run) for run in runs[start:end + 1])
+        start = end + 1
+    return ", ".join(groups)
+
+
+def format_plot_sources(sources, *, rich_text=False):
+    """Group (database path, run ID, parameter label) in encounter order."""
+    databases = {}
+    for database, run_id, parameter in sources:
+        parameters = databases.setdefault(database, {})
+        parameters.setdefault(parameter, set()).add(run_id)
+    names = [Path(database).stem for database in databases]
+    lines = []
+    for database, parameters in databases.items():
+        name = Path(database).stem
+        if names.count(name) > 1:
+            name = str(database)
+        groups = "; ".join(
+            f"{_run_ranges(runs)} ({parameter})"
+            for parameter, runs in parameters.items()
+        )
+        lines.append(
+            f"<b>{escape(name)}:</b> {escape(groups)}"
+            if rich_text else f"{name}: {groups}"
+        )
+    return ("<br>" if rich_text else "\n").join(lines)
+
+
+class PlotSourceLabel(pg.GraphicsWidget):
+    """A shaded source strip that wraps to the plot width."""
+
+    def __init__(self):
+        super().__init__()
+        self.item = QtWidgets.QGraphicsTextItem(self)
+        self.item.document().setDocumentMargin(0)
+        self.text = ""
+        self.rich_text = None
+        self.background = QtGui.QColor("white")
+        self._height = 0.0
+        self.setSizePolicy(
+            QtWidgets.QSizePolicy.Policy.Expanding,
+            QtWidgets.QSizePolicy.Policy.Fixed,
+        )
+
+    def set_source_text(self, text, font, color, *, rich_text, background=None):
+        background = QtGui.QColor("white") if background is None else background
+        if (text == self.text and font == self.item.font()
+                and color == self.item.defaultTextColor()
+                and rich_text == self.rich_text and background == self.background):
+            return
+        self.text = text
+        self.rich_text = rich_text
+        self.background = background
+        self.item.setFont(font)
+        self.item.setDefaultTextColor(color)
+        self.item.setHtml(rich_text)
+        self._wrap()
+        self.update()
+
+    def paint(self, painter, option, widget=None):
+        if not self.text:
+            return
+        foreground = self.item.defaultTextColor()
+
+        def tint(amount):
+            return QtGui.QColor.fromRgbF(*(
+                base * (1 - amount) + ink * amount
+                for base, ink in zip(
+                    self.background.getRgbF()[:3], foreground.getRgbF()[:3], strict=True,
+                )
+            ))
+
+        painter.setBrush(tint(0.05))
+        painter.setPen(QtGui.QPen(tint(0.18), 1))
+        painter.drawRect(self.boundingRect().adjusted(0.5, 0.5, -0.5, -4.5))
+
+    def _wrap(self):
+        horizontal, vertical = 8, 5
+        self.item.setPos(horizontal, vertical)
+        self.item.setTextWidth(max(1.0, (self.size().width() or 600.0) - 2 * horizontal))
+        height = self.item.boundingRect().height() + 2 * vertical + 4 if self.text else 0.0
+        if height != self._height:
+            self._height = height
+            self.setMinimumHeight(height)
+            self.setMaximumHeight(height)
+            self.updateGeometry()
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        self._wrap()
+
+    def sizeHint(self, which, constraint=None):
+        width = {
+            QtCore.Qt.SizeHint.MinimumSize: 0,
+            QtCore.Qt.SizeHint.PreferredSize: 300,
+            QtCore.Qt.SizeHint.MaximumSize: 16777215,
+        }.get(which, 0)
+        return QtCore.QSizeF(width, self._height)
+
+
+class PlotAnnotationMixin:
+    def _init_plot_annotation(self):
+        self.source_annotation = PlotSourceLabel()
+        # PlotItem reserves row zero for its title, aligned with the data axes.
+        self.plot.layout.removeItem(self.plot.titleLabel)
+        self.plot.titleLabel.hide()
+        self.plot.layout.setRowMinimumHeight(0, 0)
+        self.plot.layout.setRowMaximumHeight(0, 16777215)
+        self.plot.layout.setRowPreferredHeight(0, -1)
+        self.plot.layout.addItem(self.source_annotation, 0, 1)
+        self._annotation_in_layout = True
+        self.trace_updated.connect(self._update_plot_annotation)
+        self._update_plot_annotation()
+
+    def _set_plot_annotation_visible(self, visible):
+        if visible != self._annotation_in_layout:
+            if visible:
+                self.plot.layout.setRowMinimumHeight(0, 0)
+                self.plot.layout.setRowMaximumHeight(0, 16777215)
+                self.plot.layout.setRowPreferredHeight(0, -1)
+                self.plot.layout.addItem(self.source_annotation, 0, 1)
+            else:
+                self.plot.layout.removeItem(self.source_annotation)
+                self.plot.layout.setRowFixedHeight(0, 0)
+            self._annotation_in_layout = visible
+        self.source_annotation.setVisible(visible)
+
+    def _update_plot_annotation(self):
+        annotation = self.__dict__.get("source_annotation")
+        if annotation is None:
+            return
+        visible = self.config.get(SHOW_SOURCE_ANNOTATION_KEY)
+        self._set_plot_annotation_visible(visible)
+        if not visible:
+            return
+        sources = []
+        if "lines" not in self.__dict__ and self.__dict__.get("line") is not None:
+            sources.append(self)  # A standalone heatmap cut has no trace registry.
+        styles = self.__dict__.get("_trace_styles", {})
+        for key, line in self.__dict__.get("lines", {}).items():
+            if line is None:
+                continue
+            style = styles.get(key)
+            if style is not None and (not style.visible or style.opacity == 0):
+                continue
+            source = self if line is self.__dict__.get("line") else line.from_win
+            sources.append(source)
+        for layer in self.__dict__.get("heatmaps", {}).values():
+            if self._heatmap_is_visible(layer) and self._heatmap_opacity(layer) > 0:
+                sources.append(self if layer is self else layer.from_win)
+        # Keep the primary source first even when appearance rows are reordered.
+        sources.sort(key=lambda source: source is not self)
+        source_info = [source._plot_source_info for source in sources]
+        text = format_plot_sources(source_info)
+        font = QtGui.QFont(QtWidgets.QApplication.font())
+        font.setPointSize(self.config.get(FONT_SIZE_KEY))
+        annotation.set_source_text(
+            text, font, pg.mkColor(self.config.theme.plot_foreground),
+            rich_text=format_plot_sources(source_info, rich_text=True),
+            background=pg.mkColor(self.config.theme.plot_background),
+        )

qplot/windows/_plot_appearance.py

@@ -0,0 +1,283 @@
+"""Shared widgets used by plot-item appearance dialogs."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from PyQt6 import QtCore, QtGui
+from PyQt6 import QtWidgets as qtw
+
+
+class CenteredPreviewDelegate(qtw.QStyledItemDelegate):
+    """Paint an icon in the centre of its cell, optionally limiting its size."""
+
+    def __init__(self, parent=None, *, icon_size: QtCore.QSize | None = None):
+        super().__init__(parent)
+        self.icon_size = icon_size
+
+    def paint(self, painter, option, index):
+        icon = index.data(QtCore.Qt.ItemDataRole.DecorationRole)
+        if not isinstance(icon, QtGui.QIcon) or icon.isNull():
+            super().paint(painter, option, index)
+            return
+
+        styled_option = qtw.QStyleOptionViewItem(option)
+        self.initStyleOption(styled_option, index)
+        styled_option.text = ""
+        styled_option.icon = QtGui.QIcon()
+
+        widget = styled_option.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,
+            styled_option,
+            painter,
+            widget,
+        )
+
+        available = styled_option.rect.size()
+        if self.icon_size is not None:
+            available = available.boundedTo(self.icon_size)
+        icon_size = icon.actualSize(available)
+        icon_rect = QtCore.QRect(QtCore.QPoint(), icon_size)
+        icon_rect.moveCenter(styled_option.rect.center())
+        icon.paint(painter, icon_rect, QtCore.Qt.AlignmentFlag.AlignCenter)
+
+
+class ReorderAppearanceTable(qtw.QTableWidget):
+    """Three-column appearance table with internal multi-row reordering."""
+
+    def __init__(
+        self,
+        dialog: Any,
+        *,
+        mime_type: str,
+    ) -> None:
+        super().__init__(0, 3, dialog)
+        self.dialog = dialog
+        self._reorder_mime_type = mime_type
+        self._dragged_rows: list[int] = []
+        self._drag_origin = QtCore.QModelIndex()
+        self.setMouseTracking(True)
+        self.viewport().setMouseTracking(True)
+        self._drop_indicator = qtw.QWidget(self.viewport())
+        self._drop_indicator.setAttribute(
+            QtCore.Qt.WidgetAttribute.WA_TransparentForMouseEvents
+        )
+        self._drop_indicator.setAttribute(
+            QtCore.Qt.WidgetAttribute.WA_StyledBackground
+        )
+        self._drop_indicator.setFixedHeight(2)
+        self._drop_indicator.setStyleSheet(
+            "background-color: palette(highlight);"
+        )
+        self._drop_indicator.hide()
+
+    def selectRow(self, row: int) -> None:
+        """Select a whole row reliably before the table has been displayed."""
+
+        super().selectRow(row)
+        selection_model = self.selectionModel()
+        model = self.model()
+        if selection_model is None or model is None:
+            return
+        index = model.index(row, 0)
+        if not index.isValid():
+            return
+        selection_model.select(
+            index,
+            QtCore.QItemSelectionModel.SelectionFlag.Select
+            | QtCore.QItemSelectionModel.SelectionFlag.Rows,
+        )
+
+    def mousePressEvent(self, event: QtGui.QMouseEvent) -> None:
+        self._drag_origin = self.indexAt(event.position().toPoint())
+        super().mousePressEvent(event)
+
+    def mouseReleaseEvent(self, event: QtGui.QMouseEvent) -> None:
+        try:
+            super().mouseReleaseEvent(event)
+        finally:
+            self._drag_origin = QtCore.QModelIndex()
+
+    def mouseMoveEvent(self, event: QtGui.QMouseEvent) -> None:
+        self._update_reorder_cursor(event.position().toPoint())
+        super().mouseMoveEvent(event)
+
+    def leaveEvent(self, event: QtCore.QEvent) -> None:
+        self.viewport().unsetCursor()
+        super().leaveEvent(event)
+
+    def dragEnterEvent(self, event: QtGui.QDragEnterEvent) -> None:
+        if self._is_internal_reorder_drag(event):
+            event.acceptProposedAction()
+            return
+        event.ignore()
+
+    def dragMoveEvent(self, event: QtGui.QDragMoveEvent) -> None:
+        if self._is_internal_reorder_drag(event):
+            self._show_drop_indicator(
+                self._drop_insertion_row(event.position().toPoint())
+            )
+            event.acceptProposedAction()
+            return
+        event.ignore()
+
+    def dragLeaveEvent(self, event: QtGui.QDragLeaveEvent) -> None:
+        self._hide_drop_indicator()
+        super().dragLeaveEvent(event)
+
+    def dropEvent(self, event: QtGui.QDropEvent) -> None:
+        self._hide_drop_indicator()
+        if not self._is_internal_reorder_drag(event):
+            event.ignore()
+            return
+
+        source_rows = self._dragged_rows
+        self._dragged_rows = []
+        if not source_rows:
+            event.ignore()
+            return
+
+        self.dialog._move_rows_to_position(
+            source_rows,
+            self._drop_insertion_row(event.position().toPoint()),
+        )
+        event.acceptProposedAction()
+
+    def startDrag(self, supported_actions):
+        del supported_actions
+        index = self._drag_origin
+        if not index.isValid():
+            index = self.currentIndex()
+        if not index.isValid() or index.column() == self.dialog._COL_PREVIEW:
+            return
+
+        source_rows = self.dialog._selected_rows()
+        if not source_rows:
+            return
+
+        mime_data = QtCore.QMimeData()
+        mime_data.setData(self._reorder_mime_type, QtCore.QByteArray())
+        drag = QtGui.QDrag(self)
+        drag.setMimeData(mime_data)
+        self._dragged_rows = source_rows
+        try:
+            drag.exec(QtCore.Qt.DropAction.MoveAction)
+        finally:
+            self._dragged_rows = []
+            self._hide_drop_indicator()
+
+    def _is_internal_reorder_drag(self, event: QtGui.QDropEvent) -> bool:
+        return (
+            event.source() is self
+            and event.mimeData().hasFormat(self._reorder_mime_type)
+        )
+
+    def _drop_insertion_row(self, position: QtCore.QPoint) -> int:
+        index = self.indexAt(position)
+        if not index.isValid():
+            return self.rowCount()
+        if position.y() > self.visualRect(index).center().y():
+            return index.row() + 1
+        return index.row()
+
+    def _update_reorder_cursor(self, position: QtCore.QPoint) -> None:
+        index = self.indexAt(position)
+        if index.isValid() and index.column() != self.dialog._COL_PREVIEW:
+            self.viewport().setCursor(QtCore.Qt.CursorShape.SizeVerCursor)
+            return
+        self.viewport().unsetCursor()
+
+    def _show_drop_indicator(self, destination_row: int) -> None:
+        if not self.rowCount():
+            self._hide_drop_indicator()
+            return
+
+        destination_row = max(0, min(destination_row, self.rowCount()))
+        if destination_row == self.rowCount():
+            index = self.model().index(self.rowCount() - 1, 0)
+            y_position = self.visualRect(index).bottom() + 1
+        else:
+            index = self.model().index(destination_row, 0)
+            y_position = self.visualRect(index).top()
+        self._drop_indicator.setGeometry(
+            0,
+            max(0, y_position - 1),
+            self.viewport().width(),
+            self._drop_indicator.height(),
+        )
+        self._drop_indicator.show()
+        self._drop_indicator.raise_()
+
+    def _hide_drop_indicator(self) -> None:
+        self._drop_indicator.hide()
+
+
+def configure_appearance_table(
+    table: qtw.QTableWidget,
+    dialog: Any,
+    *,
+    object_name: str,
+    item_name: str,
+) -> None:
+    """Apply the common appearance-table layout and interaction policy."""
+
+    table.setObjectName(object_name)
+    table.setHorizontalHeaderLabels(["ID", "Preview", "Measurement"])
+    table.setEditTriggers(qtw.QAbstractItemView.EditTrigger.NoEditTriggers)
+    table.setSelectionBehavior(qtw.QAbstractItemView.SelectionBehavior.SelectRows)
+    table.setSelectionMode(qtw.QAbstractItemView.SelectionMode.ExtendedSelection)
+    table.setAlternatingRowColors(True)
+    table.setShowGrid(False)
+    table.setWordWrap(False)
+    table.setTextElideMode(QtCore.Qt.TextElideMode.ElideRight)
+    table.setIconSize(QtCore.QSize(64, 22))
+    table.setHorizontalScrollBarPolicy(
+        QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff
+    )
+    table.setToolTip(f"Drag a {item_name} up or down to change its order.")
+    table.setDragEnabled(True)
+    table.setAcceptDrops(True)
+    table.viewport().setAcceptDrops(True)
+    table.setDragDropMode(qtw.QAbstractItemView.DragDropMode.DragDrop)
+    table.setDefaultDropAction(QtCore.Qt.DropAction.MoveAction)
+    table.setDropIndicatorShown(False)
+    table.setItemDelegateForColumn(
+        dialog._COL_PREVIEW,
+        CenteredPreviewDelegate(table),
+    )
+
+    horizontal_header = table.horizontalHeader()
+    if horizontal_header is not None:
+        header_font = horizontal_header.font()
+        header_font.setBold(False)
+        horizontal_header.setFont(header_font)
+        for column in range(table.columnCount()):
+            header_item = table.horizontalHeaderItem(column)
+            if header_item is not None:
+                item_font = header_item.font()
+                item_font.setBold(False)
+                header_item.setFont(item_font)
+        horizontal_header.setFixedHeight(24)
+        horizontal_header.setSectionResizeMode(
+            dialog._COL_ID,
+            qtw.QHeaderView.ResizeMode.ResizeToContents,
+        )
+        horizontal_header.setSectionResizeMode(
+            dialog._COL_PREVIEW,
+            qtw.QHeaderView.ResizeMode.ResizeToContents,
+        )
+        horizontal_header.setSectionResizeMode(
+            dialog._COL_MEASUREMENT,
+            qtw.QHeaderView.ResizeMode.Stretch,
+        )
+
+    vertical_header = table.verticalHeader()
+    if vertical_header is not None:
+        vertical_header.setVisible(False)
+        vertical_header.setDefaultSectionSize(28)
+        vertical_header.setMinimumSectionSize(24)