gitpane 1.0.0__py3-none-any.whl

gitpane/ui/reader/file_action.py

@@ -0,0 +1,138 @@
+"""Share typed historical-file intentions across the two repository file lists."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QMenu
+
+from gitpane.history.repository_value import FilePanel, RevisionEntry
+from gitpane.ui.emoji.file_action_icon import file_action_icon
+from gitpane.worktree.file_action_target import FileActionTargetKind
+from gitpane.worktree.file_menu_action import FileAction
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.worktree.file_action_target import FileActionSelection, FileRestoreTarget
+
+
+class FileActionMenu(QMenu):
+    """Validate captured selection again before emitting a shared file intention."""
+
+    history_requested = Signal(object)
+    compare_requested = Signal(object)
+    filename_requested = Signal(object)
+    absolute_filename_requested = Signal(object)
+    folder_requested = Signal(object)
+    text_editor_requested = Signal(object)
+    save_requested = Signal(object)
+    restore_requested = Signal(object, object)
+    remove_history_requested = Signal(object)
+
+    def __init__(self, selection: FileActionSelection, validate: Callable[[FileActionSelection], bool], parent: QWidget,
+                 restore_targets: list[FileRestoreTarget] | None = None, text_editor_reason: Callable[[FileActionSelection], str] | None = None,
+                 remove_history_reason: Callable[[FileActionSelection], str] | None = None) -> None:
+        """Share validated file actions and offer external comparison for a Diff entry.
+
+        The text editor reason comes from the file action controller, which knows the preferences and the disk; a non-empty
+        reason greys the entry and shows why.
+        """
+        super().__init__(parent)
+        self.selection = selection
+        self.validate = validate
+        self.remove_history_reason = remove_history_reason
+        self.history_removal_requested = False
+        if selection.kind == FileActionTargetKind.FOLDER:
+            self.restore_menu = None
+            self.addAction(file_action_icon(FileAction.COPY_BASENAME, self), FileAction.COPY_BASENAME.label, lambda: self.request(self.filename_requested))
+            self.addAction(file_action_icon(FileAction.COPY_ABSOLUTE, self), FileAction.COPY_ABSOLUTE.label, lambda: self.request(self.absolute_filename_requested))
+            self._add_history_removal()
+            return
+        self.restore_menu = self.addMenu(FileAction.RESET_TO.label) if restore_targets is not None else None
+        self.set_restore_targets(restore_targets or [])
+        self.addAction(file_action_icon(FileAction.DISPLAY_HISTORY, self), FileAction.DISPLAY_HISTORY.label, lambda: self.request(self.history_requested))
+        if selection.panel_kind == FilePanel.DIFF:
+            self.addAction(file_action_icon(FileAction.COMPARE, self), FileAction.COMPARE.label, lambda: self.request(self.compare_requested))
+        self.addAction(file_action_icon(FileAction.FOLDER, self), FileAction.FOLDER.label, lambda: self.request(self.folder_requested))
+        text_editor_action = self.addAction(file_action_icon(FileAction.TEXT_EDITOR, self), FileAction.TEXT_EDITOR.label, lambda: self.request(self.text_editor_requested))
+        text_editor_unavailable = text_editor_reason(selection) if text_editor_reason is not None else ""
+        if text_editor_unavailable:
+            text_editor_action.setEnabled(False)
+            text_editor_action.setToolTip(text_editor_unavailable)
+            self.setToolTipsVisible(True)
+        self.addAction(file_action_icon(FileAction.COPY_BASENAME, self), FileAction.COPY_BASENAME.label, lambda: self.request(self.filename_requested))
+        self.addAction(file_action_icon(FileAction.COPY_ABSOLUTE, self), FileAction.COPY_ABSOLUTE.label, lambda: self.request(self.absolute_filename_requested))
+        action = self.addAction(file_action_icon(FileAction.SAVE_AS, self), FileAction.SAVE_AS.label, lambda: self.request(self.save_requested))
+        entry = selection.entry
+        mode = (entry.new_mode if entry.new_blob_oid else entry.old_mode) if isinstance(entry, RevisionEntry) else entry.mode
+        if mode == "160000":
+            action.setEnabled(False)
+            action.setToolTip("A submodule points to a commit, not a file blob.")
+            self.setToolTipsVisible(True)
+        self._add_history_removal()
+
+    def _add_history_removal(self) -> None:
+        """Keep the history mutation last, with a reason when the repository is unavailable."""
+        self.addSeparator()
+        self.remove_history_action = self.addAction(file_action_icon(FileAction.REMOVE_FROM_HISTORY, self), FileAction.REMOVE_FROM_HISTORY.label, self.request_remove_history)
+        reason = self.remove_history_reason(self.selection) if self.remove_history_reason is not None else ""
+        self.remove_history_action.setEnabled(not reason)
+        self.remove_history_action.setToolTip(reason)
+        self.setToolTipsVisible(True)
+        for action in self.actions():
+            action.setIconVisibleInMenu(True)
+
+    def request(self, signal: Signal) -> None:
+        """Ignore commands from menus whose owning selection has been invalidated."""
+        if self.validate(self.selection):
+            signal.emit(self.selection)
+
+    def request_remove_history(self) -> None:
+        """Recheck availability at activation and emit at most one removal per menu."""
+        if self.history_removal_requested or not self.validate(self.selection):
+            return
+        reason = self.remove_history_reason(self.selection) if self.remove_history_reason is not None else ""
+        if reason:
+            self.remove_history_action.setEnabled(False)
+            self.remove_history_action.setToolTip(reason)
+            return
+        self.history_removal_requested = True
+        self.remove_history_action.setEnabled(False)
+        self.request(self.remove_history_requested)
+
+    def set_restore_targets(self, targets: list[FileRestoreTarget]) -> None:
+        """Update parent metadata in place so an open menu retains its actions and order."""
+        if self.restore_menu is None:
+            return
+        icon = file_action_icon(FileAction.RESET_TO, self.restore_menu)
+        icon_size = next(iter(icon.availableSizes()))
+        normal_pixmap_key = icon.pixmap(icon_size).cacheKey()
+        menu_action = self.restore_menu.menuAction()
+        if menu_action.icon().pixmap(icon_size).cacheKey() != normal_pixmap_key:
+            menu_action.setIcon(icon)
+        menu_action.setIconVisibleInMenu(True)
+        actions = self.restore_menu.actions()
+        if len(actions) != len(targets):
+            self.restore_menu.clear()
+            for target in targets:
+                action = self.restore_menu.addAction(target.label)
+                action.triggered.connect(lambda checked=False, action=action: self.request_restore(action.data()))
+            actions = self.restore_menu.actions()
+        for action, target in zip(actions, targets, strict=True):
+            if action.icon().pixmap(icon_size).cacheKey() != normal_pixmap_key:
+                action.setIcon(icon)
+            action.setIconVisibleInMenu(True)
+            action.setText(target.label.replace("&", "&&"))
+            action.setData(target)
+            action.setToolTip(target.unavailable or target.message)
+            action.setEnabled(not target.unavailable)
+        self.restore_menu.setToolTipsVisible(True)
+
+    def request_restore(self, target: FileRestoreTarget) -> None:
+        """Emit the selected source only while its captured file selection remains current."""
+        if not target.unavailable and self.validate(self.selection):
+            self.restore_requested.emit(self.selection, target)

gitpane/ui/reader/file_tree_panel.py

@@ -0,0 +1,235 @@
+"""Browse historical Git paths beside a literal, searchable content reader."""
+
+from __future__ import annotations
+
+from time import monotonic
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QSize, Qt, QTimer, Signal
+from PySide6.QtGui import QFontDatabase, QTextCursor
+from PySide6.QtWidgets import QPlainTextEdit, QSplitter, QStyle, QTreeWidget, QTreeWidgetItem, QTreeWidgetItemIterator, QVBoxLayout, QWidget
+
+from gitpane.config import DIFF_FILE_STRETCH, DIFF_TEXT_STRETCH, FILE_PARSE_BUDGET_MS, FILE_TEXT_BATCH_CHARS, LAYOUT_SPACING
+from gitpane.ui.reader.commit_message import CommitMessage
+from gitpane.ui.reader.reader_toolbar import ReaderToolbar
+from gitpane.ui.reader.revision_tree import FOLDER_PATH_ROLE
+from gitpane.ui.reader.source_view import SourceFileView
+
+if TYPE_CHECKING:
+    from gitpane.history.repository_value import BlobContent, FilePanel, TreeEntry
+
+
+class FileTreePanel(QWidget):
+    """Keep revision objects and their original identity beside read-only text."""
+
+    selection_requested = Signal(object)
+    retry_requested = Signal(object)
+
+    def __init__(self) -> None:
+        """Build a compact tree and reuse the literal reader's local search controls."""
+        super().__init__()
+        self.entries: list[TreeEntry] = []
+        self.item_by_entry: dict[TreeEntry, QTreeWidgetItem] = {}
+        self.selected_entry: TreeEntry | None = None
+        self.content: BlobContent | None = None
+        self.render_generation = 0
+        self.tree_generation = 0
+        self.action_generation = 0
+        self.retry_kind: FilePanel | None = None
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(LAYOUT_SPACING)
+        self.reader_toolbar = ReaderToolbar("Find in historical file")
+        self.status_label = self.reader_toolbar.status_label
+        self.status_label.setText("Select a commit")
+        self.retry_button = self.reader_toolbar.retry_button
+        self.retry_button.clicked.connect(lambda: self.retry_requested.emit(self.retry_kind))
+        self.file_tree = QTreeWidget()
+        self.file_tree.setHeaderHidden(True)
+        self.file_tree.setUniformRowHeights(True)
+        self.file_tree.setAccessibleName("Revision files")
+        self.reader = CommitMessage(SourceFileView())
+        self.reader.find_edit.setPlaceholderText("Find in this file")
+        self.reader.find_edit.setAccessibleName("Find in historical file")
+        self.text_edit = self.reader.text_edit
+        self.text_edit.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
+        self.text_edit.setAccessibleName("Historical file content")
+        self.text_edit.setFont(QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont))
+        self.reader_toolbar.find_button.clicked.connect(self.open_search)
+        self.reader_container = QWidget()
+        reader_layout = QVBoxLayout(self.reader_container)
+        reader_layout.setContentsMargins(0, 0, 0, 0)
+        reader_layout.setSpacing(LAYOUT_SPACING)
+        reader_layout.addWidget(self.reader_toolbar)
+        reader_layout.addWidget(self.reader, 1)
+        self.splitter = QSplitter(Qt.Orientation.Horizontal)
+        self.splitter.setChildrenCollapsible(False)
+        self.splitter.addWidget(self.file_tree)
+        self.splitter.addWidget(self.reader_container)
+        file_index, text_index = 0, 1
+        self.splitter.setStretchFactor(file_index, DIFF_FILE_STRETCH)
+        self.splitter.setStretchFactor(text_index, DIFF_TEXT_STRETCH)
+        layout.addWidget(self.splitter, 1)
+        self.file_tree.currentItemChanged.connect(self._select_item)
+        self.file_tree.currentItemChanged.connect(self._invalidate_action)
+        self.refresh_metrics()
+
+    def refresh_metrics(self) -> None:
+        """Scale native file and folder symbols with the tree's current font."""
+        side = max(self.file_tree.fontMetrics().height(), self.style().pixelMetric(QStyle.PixelMetric.PM_SmallIconSize))
+        self.file_tree.setIconSize(QSize(side, side))
+        self.file_icon = self.style().standardIcon(QStyle.StandardPixmap.SP_FileIcon)
+        self.folder_icon = self.style().standardIcon(QStyle.StandardPixmap.SP_DirIcon)
+        iterator = QTreeWidgetItemIterator(self.file_tree)
+        while iterator.value() is not None:
+            item = iterator.value()
+            item.setIcon(0, self.file_icon if item.data(0, Qt.ItemDataRole.UserRole) is not None else self.folder_icon)
+            iterator += 1
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Follow system font, palette and style changes without rebuilding file identities."""
+        super().changeEvent(event)
+        if event.type() in (QEvent.Type.FontChange, QEvent.Type.ApplicationFontChange, QEvent.Type.PaletteChange, QEvent.Type.StyleChange) and hasattr(self, "file_tree"):
+            self.refresh_metrics()
+
+    def _invalidate_action(self) -> None:
+        self.action_generation += 1
+
+    def clear_selection(self, message: str = "Select a commit") -> None:
+        """Remove old paths and text immediately when the commit changes."""
+        self.reader_toolbar.finish_loading()
+        self.selected_entry = None
+        self.retry_button.hide()
+        self.retry_kind = None
+        self.action_generation += 1
+        self.render_generation += 1
+        self.tree_generation += 1
+        self.content = None
+        self.entries.clear()
+        self.item_by_entry.clear()
+        self.file_tree.clear()
+        self.text_edit.clear()
+        self.status_label.setText(message)
+        self.status_label.setVisible(bool(message))
+
+    def show_tree(self, entries: list[TreeEntry]) -> None:
+        """Build explicitly sorted folders without using displayed names as identity."""
+        self.clear_selection("Select a file" if entries else "Empty tree")
+        self.entries = list(entries)
+        item_by_path: dict[bytes, QTreeWidgetItem] = {}
+        pending = iter(sorted(entries, key=lambda entry: entry.path))
+        generation = self.tree_generation
+
+        def append_entries() -> None:
+            """Limit Qt row creation per turn and stop a superseded tree projection."""
+            if generation != self.tree_generation:
+                return
+            # PySide does not invalidate this native root when its tree is deleted; the recursive callback must not capture its wrapper.
+            root = self.file_tree.invisibleRootItem()
+            deadline = monotonic() + FILE_PARSE_BUDGET_MS / 1000
+            while monotonic() < deadline:
+                entry = next(pending, None)
+                if entry is None:
+                    for parent in (root, *item_by_path.values()):
+                        children = parent.takeChildren()
+                        children.sort(key=lambda item: (item.data(0, Qt.ItemDataRole.UserRole) is not None, item.text(0).casefold(), item.text(0)))
+                        parent.addChildren(children)
+                    return
+                components = entry.path.split(b"/")
+                basename = components.pop()
+                parent = root
+                directory_parts = []
+                for component in components:
+                    directory_parts.append(component)
+                    path = b"/".join(directory_parts)
+                    item = item_by_path.get(path)
+                    if item is None:
+                        item = QTreeWidgetItem([component.decode("utf-8", "replace")])
+                        item.setData(0, FOLDER_PATH_ROLE, path)
+                        item.setToolTip(0, path.decode("utf-8", "replace"))
+                        item.setIcon(0, self.folder_icon)
+                        parent.addChild(item)
+                        item_by_path[path] = item
+                    parent = item
+                item = QTreeWidgetItem([basename.decode("utf-8", "replace")])
+                item.setIcon(0, self.file_icon)
+                item.setToolTip(0, entry.path.decode("utf-8", "replace"))
+                item.setData(0, Qt.ItemDataRole.UserRole, entry)
+                parent.addChild(item)
+                self.item_by_entry[entry] = item
+            QTimer.singleShot(0, append_entries)
+
+        append_entries()
+
+    def show_blob(self, content: BlobContent) -> None:
+        """Present the display representation while retaining exact bytes separately."""
+        self.reader_toolbar.finish_loading()
+        self.retry_button.hide()
+        self.retry_kind = None
+        self.render_generation += 1
+        generation = self.render_generation
+        self.content = content
+        self.text_edit.clear()
+        self.text_edit.set_filename(self.selected_entry.path.decode("utf-8", "replace") if self.selected_entry is not None else "")
+        diagnostic = content.diagnostic
+        if self.selected_entry is not None and self.selected_entry.mode == "120000":
+            diagnostic = "Symbolic link — historical target" + (f"; {diagnostic}" if diagnostic else "")
+        self.status_label.setText(diagnostic)
+        self.status_label.setVisible(bool(diagnostic))
+        offset = 0
+
+        def append_text() -> None:
+            """Yield during document insertion and abandon any superseded render."""
+            nonlocal offset
+            if generation != self.render_generation:
+                return
+            deadline = monotonic() + FILE_PARSE_BUDGET_MS / 1000
+            while offset < len(content.display_text) and monotonic() < deadline:
+                end = offset + FILE_TEXT_BATCH_CHARS
+                if content.display_text[end - 1:end + 1] == "\r\n":
+                    end += 1
+                self.text_edit.append_source_text(content.display_text[offset:end])
+                offset = end
+            if offset < len(content.display_text):
+                QTimer.singleShot(0, append_text)
+                return
+            self.text_edit.moveCursor(QTextCursor.MoveOperation.Start)
+            self.text_edit.refresh_syntax()
+
+        append_text()
+
+    def show_submodule(self, oid: str) -> None:
+        """Describe a gitlink without trying to resolve its object in the parent repository."""
+        self.show_error("Submodule commit")
+        self.text_edit.setPlainText(oid)
+
+    def show_error(self, cause: str, retry_kind: FilePanel | None = None) -> None:
+        """Clear misleading text and keep an unavailable object diagnostic visible."""
+        self.reader_toolbar.finish_loading()
+        self.retry_kind = retry_kind
+        self.retry_button.setVisible(retry_kind is not None)
+        self.content = None
+        self.render_generation += 1
+        self.text_edit.clear()
+        self.status_label.setText(cause)
+        self.status_label.show()
+
+    def begin_loading(self) -> None:
+        """Discard old file text immediately while keeping fast reads visually quiet."""
+        self.content = None
+        self.render_generation += 1
+        self.text_edit.clear()
+        self.retry_kind = None
+        self.reader_toolbar.start_loading("Loading file…")
+
+    def open_search(self) -> None:
+        """Focus search in the displayed historical file."""
+        self.reader.open_search()
+
+    def _select_item(self, item: QTreeWidgetItem | None, previous: QTreeWidgetItem | None) -> None:
+        """Emit the original object value, never a path reconstructed from labels."""
+        if item is None:
+            return
+        entry = item.data(0, Qt.ItemDataRole.UserRole)
+        if entry is not None:
+            self.selection_requested.emit(entry)

gitpane/ui/reader/reader_toolbar.py

@@ -0,0 +1,56 @@
+"""Keep the file actions of a text reader above it, with a loading notice only for slow reads."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtWidgets import QHBoxLayout, QLabel, QPushButton, QSizePolicy, QWidget
+
+from gitpane.config import FIND_SHORTCUT, LAYOUT_SPACING
+from gitpane.ui.widget.shortcut_text import with_shortcut
+
+READER_LOADING_DELAY_MS = 200
+
+
+class ReaderToolbar(QWidget):
+    """Reserve one stable control row, showing progress only for slower reads."""
+
+    def __init__(self, search_description: str) -> None:
+        """Place contextual feedback before right-aligned reader commands."""
+        super().__init__()
+        self.controls = QHBoxLayout(self)
+        self.controls.setContentsMargins(0, 0, 0, 0)
+        self.controls.setSpacing(LAYOUT_SPACING)
+        self.status_label = QLabel()
+        self.status_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.status_label.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+        self.controls.addWidget(self.status_label, 1)
+        self.controls.addStretch(1)
+        self.retry_button = QPushButton("Retry reading")
+        self.retry_button.hide()
+        self.controls.addWidget(self.retry_button)
+        self.find_button = QPushButton("Find")
+        self.find_button.setAccessibleName(search_description)
+        self.find_button.setToolTip(with_shortcut(search_description, FIND_SHORTCUT))
+        self.controls.addWidget(self.find_button)
+        self.loading_message = ""
+        self.loading_timer = QTimer(self)
+        self.loading_timer.setSingleShot(True)
+        self.loading_timer.setInterval(READER_LOADING_DELAY_MS)
+        self.loading_timer.timeout.connect(self._show_loading)
+
+    def start_loading(self, message: str) -> None:
+        """Delay transient progress without moving the reader or showing stale errors."""
+        self.finish_loading()
+        self.status_label.clear()
+        self.retry_button.hide()
+        self.loading_message = message
+        self.loading_timer.start()
+
+    def finish_loading(self) -> None:
+        """Cancel progress publication when a result or a newer selection takes over."""
+        self.loading_timer.stop()
+        self.loading_message = ""
+
+    def _show_loading(self) -> None:
+        self.status_label.setText(self.loading_message)
+        self.status_label.show()

gitpane/ui/reader/revision_tree.py

@@ -0,0 +1,80 @@
+"""Display compact revision paths in a tree drawn with native disclosure controls over dotted guides."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QPalette, QPen
+from PySide6.QtWidgets import QTreeWidget
+
+from gitpane.ui.look.theme_color import is_dark_palette
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QModelIndex, QRect
+    from PySide6.QtGui import QPainter
+    from PySide6.QtWidgets import QTreeWidgetItem
+
+BRANCH_DISCLOSURE_GAP = 5
+FOLDER_PATH_ROLE = Qt.ItemDataRole.UserRole + 1
+
+
+class RevisionTree(QTreeWidget):
+    """Keep file-to-folder relationships visible across native platform themes."""
+
+    def drawBranches(self, painter: QPainter, rectangle: QRect, index: QModelIndex) -> None:
+        """Draw dotted ancestor guides while retaining Qt's expand and collapse arrows.
+
+        A light theme draws them in the palette's mid tone. A dark one draws them in the view's text color: the dark mid
+        tone is barely darker or lighter than the dark background of a view, and the guides would not show.
+        """
+        palette = self.palette()
+        guide_role = QPalette.ColorRole.Text if is_dark_palette(palette) else QPalette.ColorRole.Mid
+        painter.save()
+        painter.setPen(QPen(palette.color(guide_role), 1, Qt.PenStyle.DotLine))
+        indentation = self.indentation()
+        center_x = rectangle.right() - indentation // 2
+        center_y = rectangle.center().y()
+        gap = BRANCH_DISCLOSURE_GAP if self.model().hasChildren(index) else 0
+        painter.drawLine(center_x + gap, center_y, rectangle.right(), center_y)
+        if index.row() > 0 or index.parent().isValid():
+            painter.drawLine(center_x, rectangle.top(), center_x, center_y - gap)
+        if index.row() + 1 < self.model().rowCount(index.parent()):
+            painter.drawLine(center_x, center_y + gap, center_x, rectangle.bottom())
+        ancestor = index.parent()
+        while ancestor.isValid():
+            center_x -= indentation
+            if ancestor.row() + 1 < self.model().rowCount(ancestor.parent()):
+                painter.drawLine(center_x, rectangle.top(), center_x, rectangle.bottom())
+            ancestor = ancestor.parent()
+        painter.restore()
+        super().drawBranches(painter, rectangle, index)
+
+
+def compact_directory_tree(group: QTreeWidgetItem) -> None:
+    """Join single-directory chains with slashes while leaving their last folder separate."""
+    first_child_index = 0
+    pending_items = group.takeChildren()
+    group.addChildren(pending_items)
+    while pending_items:
+        item = pending_items.pop()
+        if item.data(first_child_index, Qt.ItemDataRole.UserRole) is not None:
+            continue
+        while item.childCount() == 1:
+            child = item.child(first_child_index)
+            if child.data(first_child_index, Qt.ItemDataRole.UserRole) is not None:
+                break
+            has_directory = False
+            for child_index in range(child.childCount()):
+                if child.child(child_index).data(first_child_index, Qt.ItemDataRole.UserRole) is None:
+                    has_directory = True
+                    break
+            if not has_directory:
+                break
+            child = item.takeChild(first_child_index)
+            item.setText(first_child_index, item.text(first_child_index) + "/" + child.text(first_child_index))
+            item.setToolTip(first_child_index, child.toolTip(first_child_index))
+            item.setData(first_child_index, FOLDER_PATH_ROLE, child.data(first_child_index, FOLDER_PATH_ROLE))
+            item.addChildren(child.takeChildren())
+        for child_index in range(item.childCount()):
+            pending_items.append(item.child(child_index))

gitpane/ui/reader/search_result.py

@@ -0,0 +1,165 @@
+"""Show the wildcard matches of a reader, counted then highlighted, without rescanning unchanged text."""
+
+from __future__ import annotations
+
+from bisect import bisect_left
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QObject
+from PySide6.QtGui import QColor, QPalette, QTextCursor
+from PySide6.QtWidgets import QApplication, QLabel, QTextEdit
+
+from gitpane.history.revision_file import utf16_length
+from gitpane.text.text_query import TextQuery
+from gitpane.ui.reader.source_text import SourceTextEdit
+
+if TYPE_CHECKING:
+    from PySide6.QtGui import QTextDocument
+
+SEARCH_MATCH_BACKGROUND = "#fff176"
+SEARCH_MATCH_FOREGROUND = "#202020"
+
+
+# The class whose palette the commit graph and the other lists paint their selected rows with. Under macOS it holds the
+# accent blue (#0640c6 in dark), where text controls get a muted text selection blue (#314f78); elsewhere no class
+# palette exists and Qt answers the application palette, the one text controls already use.
+LIST_SELECTION_PALETTE_CLASS = "QAbstractItemView"
+SELECTION_ROLES = (QPalette.ColorRole.Highlight, QPalette.ColorRole.HighlightedText)
+SELECTION_GROUPS = (QPalette.ColorGroup.Active, QPalette.ColorGroup.Inactive)
+
+
+def use_list_selection_colors(text_edit: QTextEdit | SourceTextEdit) -> bool:
+    """Paint a reader's selection, the current match, like a selected row of the commit graph, focused or not; answer whether the palette had to change.
+
+    Starts from the reader's own palette, which pins only the colors set here, so a later light/dark switch still
+    reaches its other colors. A palette that already has them is left alone, so no palette change is raised for nothing.
+    """
+    list_palette = QApplication.palette(LIST_SELECTION_PALETTE_CLASS)
+    palette = text_edit.palette()
+    changed = False
+    for role in SELECTION_ROLES:
+        list_color = list_palette.color(QPalette.ColorGroup.Active, role)
+        for group in SELECTION_GROUPS:
+            if palette.color(group, role) == list_color and palette.isBrushSet(group, role):
+                continue
+            palette.setColor(group, role, list_color)
+            changed = True
+    if changed:
+        text_edit.setPalette(palette)
+    return changed
+
+
+class ActiveSelectionKeeper(QObject):
+    """Keep a searched reader's selection, the current match, in the selected-row blue of the lists, also after a light/dark switch.
+
+    The focus stays in the find field while the user goes from match to match, so the reader would paint its selection
+    with the colors of an inactive widget, grey in a dark Fusion theme, over the current match; and the text selection
+    blue of macOS is too dull next to the yellow of the other matches. The reader takes the selection colors of the
+    lists for both groups, and takes them again each time its palette changes.
+    """
+
+    def __init__(self, text_edit: QTextEdit | SourceTextEdit) -> None:
+        """Belong to the reader and follow its palette notices."""
+        super().__init__(text_edit)
+        use_list_selection_colors(text_edit)
+        text_edit.installEventFilter(self)
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Set the selection colors again when the reader's palette changes.
+
+        When they had to change, setting them raised a palette notice of its own, already delivered with the final
+        colors; this older notice is stopped so the reader does not lay its look twice.
+        """
+        if event.type() != QEvent.Type.PaletteChange:
+            return False
+        return use_list_selection_colors(watched)
+
+
+class SearchResultLabel(QLabel):
+    """Share match totals and yellow highlights between commit, diff and file readers."""
+
+    def __init__(self) -> None:
+        """Invalidate the count whenever its query or document content changes."""
+        super().__init__()
+        self.document: QTextDocument | None = None
+        self.revision = -1
+        self.query = ""
+        self.match_count = 0
+        self.match_ranges: list[tuple[int, int]] = []
+        self.match_selections: list[QTextEdit.ExtraSelection] = []
+
+    def show_result(self, text_edit: QTextEdit | SourceTextEdit, query: str) -> None:
+        """Count local matches without letting wildcard gaps span whitespace or line breaks."""
+        if not query:
+            self.query = ""
+            self.match_count = 0
+            self.match_ranges.clear()
+            self.match_selections.clear()
+            self.clear()
+            return
+        document = text_edit.document()
+        revision = document.revision()
+        if self.document is not document or self.revision != revision or self.query != query:
+            self.document = document
+            self.revision = revision
+            self.query = query
+            self.match_ranges.clear()
+            self.match_selections.clear()
+            if isinstance(text_edit, SourceTextEdit):
+                self.match_ranges.extend(text_edit.find_match_range(query, wildcard=True, wildcard_whitespace=False))
+            else:
+                text = text_edit.toPlainText()
+                previous = 0
+                position = 0
+                for begin, end in TextQuery(query).find_match(text, wildcard_whitespace=False):
+                    position += utf16_length(text[previous:begin])
+                    self.match_ranges.append((position, position + utf16_length(text[begin:end])))
+                    previous = begin
+            self.match_count = len(self.match_ranges)
+        if not self.match_count:
+            self.setText("No matches")
+            return
+        noun = "match" if self.match_count == 1 else "matches"
+        self.setText(f"{self.match_count} {noun} found")
+
+    def find_match(self, text_edit: QTextEdit | SourceTextEdit, query: str, start: int, backward: bool = False) -> QTextCursor:
+        """Navigate the same cached spans used by the total and yellow highlights."""
+        self.show_result(text_edit, query)
+        index = bisect_left(self.match_ranges, (start,))
+        if backward:
+            index -= 1
+            if index >= 0:
+                _begin, end = self.match_ranges[index]
+                if end > start:
+                    index -= 1
+        if not 0 <= index < len(self.match_ranges):
+            return QTextCursor()
+        begin, end = self.match_ranges[index]
+        cursor = QTextCursor(text_edit.document())
+        cursor.setPosition(begin)
+        cursor.setPosition(end, QTextCursor.MoveMode.KeepAnchor)
+        return cursor
+
+    def highlight_selections(self, text_edit: QTextEdit | SourceTextEdit, query: str, current: QTextCursor | None = None) -> list[QTextEdit.ExtraSelection]:
+        """Mark all matches in yellow and keep the active result in the native selection color."""
+        if not query:
+            return []
+        self.show_result(text_edit, query)
+        if not self.match_selections:
+            for begin, end in self.match_ranges:
+                selection = QTextEdit.ExtraSelection()
+                selection.cursor = QTextCursor(text_edit.document())
+                selection.cursor.setPosition(begin)
+                selection.cursor.setPosition(end, QTextCursor.MoveMode.KeepAnchor)
+                selection.format.setBackground(QColor(SEARCH_MATCH_BACKGROUND))
+                selection.format.setForeground(QColor(SEARCH_MATCH_FOREGROUND))
+                self.match_selections.append(selection)
+        selections = list(self.match_selections)
+        if current is not None and current.hasSelection():
+            selection = QTextEdit.ExtraSelection()
+            selection.cursor = QTextCursor(current)
+            palette = text_edit.palette()
+            selection.format.setBackground(palette.color(QPalette.ColorGroup.Active, QPalette.ColorRole.Highlight))
+            selection.format.setForeground(palette.color(QPalette.ColorGroup.Active, QPalette.ColorRole.HighlightedText))
+            selections.append(selection)
+        return selections