gitpane 1.0.0__py3-none-any.whl

gitpane/ui/reader/diff_panel.py

@@ -0,0 +1,626 @@
+"""Browse historical changes in a compact, integrated reading panel."""
+
+from __future__ import annotations
+
+from math import sqrt
+from typing import TYPE_CHECKING
+
+from pygments.lexers import get_lexer_for_filename
+from pygments.styles import get_style_by_name
+from pygments.util import ClassNotFound
+from PySide6.QtCore import QEvent, QPointF, QRect, QRectF, QSize, Qt, Signal
+from PySide6.QtGui import QColor, QFontDatabase, QIcon, QKeySequence, QPainter, QPainterPath, QPalette, QPen, QPixmap, QShortcut, QSyntaxHighlighter, QTextCharFormat, QTextCursor, QTextFormat
+from PySide6.QtWidgets import QApplication, QCheckBox, QHBoxLayout, QLineEdit, QPlainTextEdit, QPushButton, QSplitter, QStyle, QTextEdit, QTreeWidgetItem, QTreeWidgetItemIterator, QVBoxLayout, QWidget
+
+from gitpane.config import (
+    DARK_BACKGROUND_LIGHTNESS_LIMIT,
+    DIFF_FILE_STRETCH,
+    DIFF_ICON_PADDING_RATIO,
+    DIFF_ICON_RENAME_BADGE_AREA_RATIO,
+    DIFF_ICON_STROKE_RATIO,
+    DIFF_NUMBER_COLUMN_COUNT,
+    DIFF_SYNTAX_LIMIT_CHARS,
+    DIFF_TEXT_STRETCH,
+    LAYOUT_SPACING,
+    SharedText,
+)
+from gitpane.history.repository_value import FileStatus
+from gitpane.history.revision_file import DiffDocument, DiffLineKind, decode_blob_display, parse_unified_diff, utf16_length
+from gitpane.ui.look.icon_density import physical_icon_side
+from gitpane.ui.look.theme_color import line_number_gutter_color
+from gitpane.ui.reader.reader_toolbar import ReaderToolbar
+from gitpane.ui.reader.revision_tree import FOLDER_PATH_ROLE, RevisionTree, compact_directory_tree
+from gitpane.ui.reader.search_result import ActiveSelectionKeeper, SearchResultLabel
+from gitpane.ui.reader.source_text import SourceTextEdit
+from gitpane.ui.reader.syntax_span import SyntaxLine, syntax_spans
+from gitpane.ui.widget.system_shortcut import FIND_NEXT_ACTION, FIND_PREVIOUS_ACTION, find_shortcuts
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtGui import QPaintEvent, QResizeEvent
+
+    from gitpane.history.repository_value import ComparisonGroup, RevisionEntry
+
+# Line backgrounds and changed-fragment accents of a diff, by line kind, in the light and in the dark theme. A kind
+# missing from a table keeps the view's own background.
+DIFF_BACKGROUND_BY_KIND: dict[DiffLineKind, str] = {DiffLineKind.ADDED: "#d4f8d4", DiffLineKind.REMOVED: "#ffd7d7", DiffLineKind.HUNK: "#e4eef5"}
+DIFF_DARK_BACKGROUND_BY_KIND: dict[DiffLineKind, str] = {DiffLineKind.ADDED: "#183b28", DiffLineKind.REMOVED: "#4b2528", DiffLineKind.HUNK: "#253442"}
+DIFF_FRAGMENT_BY_KIND: dict[DiffLineKind, str] = {DiffLineKind.ADDED: "#8ee59a", DiffLineKind.REMOVED: "#f4a0a0"}
+DIFF_DARK_FRAGMENT_BY_KIND: dict[DiffLineKind, str] = {DiffLineKind.ADDED: "#286540", DiffLineKind.REMOVED: "#793a43"}
+# Colour of the change symbol drawn for a file, by its status; any other status draws the modified-file symbol.
+DIFF_ICON_COLOR_BY_STATUS: dict[FileStatus, str] = {FileStatus.ADDED: "#23963b", FileStatus.DELETED: "#c73939", FileStatus.MODIFIED: "#ba8614", FileStatus.RENAMED: "#e87500"}
+
+
+class DiffHighlighter(QSyntaxHighlighter):
+    """Layer syntax foregrounds and replacement accents over line backgrounds."""
+
+    def __init__(self, view: DiffView) -> None:
+        """Bind formatting to a reader while keeping its patch unchanged."""
+        super().__init__(view.document())
+        self.view = view
+        self.lexer = None
+        self.token_spans_by_line_index: dict[int, SyntaxLine] = {}
+
+    def highlightBlock(self, text: str) -> None:
+        """Use UTF-16 offsets for syntax and intraline fragments, including emoji."""
+        block = self.currentBlock()
+        line_index = self.view.logical_line_index(block.position())
+        if line_index >= len(self.view.diff_document.lines):
+            return
+        line = self.view.diff_document.lines[line_index]
+        line_position = self.view.line_positions[line_index]
+        block_offset = block.position() - line_position
+        background = self.view.background_by_kind.get(line.kind)
+        if background is not None:
+            base_format = QTextCharFormat()
+            base_format.setBackground(QColor(background))
+            self.setFormat(0, utf16_length(text), base_format)
+        if self.lexer is not None and line.kind in (DiffLineKind.ADDED, DiffLineKind.REMOVED, DiffLineKind.CONTEXT) and len(line.text) <= DIFF_SYNTAX_LIMIT_CHARS:
+            prefix_length = 1
+            if line_index not in self.token_spans_by_line_index:
+                self.token_spans_by_line_index[line_index] = syntax_spans(line.text, self.lexer, self.view.syntax_style, prefix_length)
+            for start, length, syntax_format in self.token_spans_by_line_index[line_index].block_spans(block_offset, utf16_length(text)):
+                token_format = self.format(start)
+                token_format.merge(syntax_format)
+                self.setFormat(start, length, token_format)
+        for start, end in line.changed_spans:
+            fragment_start = max(0, utf16_length(line.text[:start]) - block_offset)
+            fragment_end = min(utf16_length(text), utf16_length(line.text[:end]) - block_offset)
+            for position in range(fragment_start, fragment_end):
+                fragment_format = self.format(position)
+                fragment_format.setBackground(QColor(self.view.fragment_by_kind[line.kind]))
+                self.setFormat(position, 1, fragment_format)
+
+
+class DiffNumberMargin(QWidget):
+    """Paint old and new line numbers outside the selectable text document."""
+
+    def __init__(self, view: DiffView) -> None:
+        """Share scrolling and native font metrics with the reader."""
+        super().__init__(view)
+        self.view = view
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        """Render only the visible blocks so long patches do not require full repaint."""
+        painter = QPainter(self)
+        painter.fillRect(event.rect(), line_number_gutter_color(self.palette()))
+        painter.setFont(self.view.font())
+        block = self.view.firstVisibleBlock()
+        column_width = self.width() // DIFF_NUMBER_COLUMN_COUNT
+        while block.isValid():
+            top = round(self.view.blockBoundingGeometry(block).translated(self.view.contentOffset()).top())
+            height = round(self.view.blockBoundingRect(block).height())
+            if top > event.rect().bottom():
+                break
+            line_index = self.view.logical_line_index(block.position())
+            if block.isVisible() and line_index < len(self.view.diff_document.lines):
+                line = self.view.diff_document.lines[line_index]
+                background = self.view.background_by_kind.get(line.kind)
+                if background is not None:
+                    painter.fillRect(0, top, self.width(), height, QColor(background))
+                painter.setPen(self.palette().color(QPalette.ColorRole.Text))
+                for column_index, number in enumerate((line.old_number, line.new_number)):
+                    if number is not None and block.position() == self.view.line_positions[line_index]:
+                        painter.drawText(column_index * column_width, top, column_width - LAYOUT_SPACING, height, Qt.AlignmentFlag.AlignRight, str(number))
+            block = block.next()
+
+
+class DiffView(SourceTextEdit):
+    """Read and search a unified patch with independent numbering and syntax."""
+
+    def __init__(self) -> None:
+        """Build reusable local search and a margin without adding repository dependencies."""
+        super().__init__()
+        self.dark_theme: bool | None = None
+        self.largest_line_number = 1
+        self.diff_document = DiffDocument()
+        self.saved_selection: tuple[str, str, int, int | None, int | None] | None = None
+        self.setReadOnly(True)
+        self.setUndoRedoEnabled(False)
+        self.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
+        self.setFont(QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont))
+        self.setAccessibleName("Unified diff")
+        self.selection_keeper = ActiveSelectionKeeper(self)
+        self.number_margin = DiffNumberMargin(self)
+        self.highlighter = DiffHighlighter(self)
+        self.search_bar = QWidget(self)
+        search_layout = QHBoxLayout(self.search_bar)
+        search_layout.setContentsMargins(0, 0, 0, 0)
+        self.find_edit = QLineEdit()
+        self.find_edit.setPlaceholderText("Find in diff")
+        self.find_edit.setAccessibleName("Find in diff")
+        self.find_edit.setToolTip(SharedText.TEXT_SEARCH_HELP.value)
+        self.result_label = SearchResultLabel()
+        self.previous_button = QPushButton("Previous")
+        self.next_button = QPushButton("Next")
+        self.close_button = QPushButton("Close")
+        search_layout.addWidget(self.find_edit, 1)
+        search_layout.addWidget(self.result_label)
+        for button in (self.previous_button, self.next_button, self.close_button):
+            search_layout.addWidget(button)
+        self.search_bar.hide()
+        self.find_edit.textChanged.connect(self._restart_search)
+        self.find_edit.returnPressed.connect(self.find_next)
+        self.previous_button.clicked.connect(self.find_previous)
+        self.next_button.clicked.connect(self.find_next)
+        self.close_button.clicked.connect(self.close_search)
+        self.shortcuts: list[QShortcut] = []
+        callback_by_action = {FIND_NEXT_ACTION: self.find_next, FIND_PREVIOUS_ACTION: self.find_previous}
+        key_callbacks: list[tuple[str, Callable[[], None]]] = []
+        for key, action in find_shortcuts():
+            key_callbacks.append((key, callback_by_action[action]))
+        key_callbacks.append(("Escape", self.close_search))
+        for key, callback in key_callbacks:
+            shortcut = QShortcut(QKeySequence(key), self)
+            shortcut.setContext(Qt.ShortcutContext.WidgetWithChildrenShortcut)
+            shortcut.activated.connect(callback)
+            self.shortcuts.append(shortcut)
+        self.updateRequest.connect(self._update_margin)
+        self.refresh_metrics()
+
+    def show_patch(self, patch: bytes, basename: str = "", *, comparison_labels: tuple[str, str] | None = None) -> None:
+        """Parse Git text and choose a lexer without interpreting markup or file paths."""
+        self._remember_selection()
+        content = decode_blob_display("", patch)
+        display_text = content.display_text
+        if comparison_labels is not None:
+            old_label, new_label = comparison_labels
+            label_by_prefix = {"diff --git ": f"diff --git {old_label} -> {new_label}", "--- ": "--- " + old_label, "+++ ": "+++ " + new_label}
+            texts = []
+            in_header = True
+            for text in display_text.splitlines(keepends=True):
+                if text.startswith("@@"):
+                    in_header = False
+                if in_header:
+                    for prefix, label in label_by_prefix.items():
+                        if text.startswith(prefix):
+                            # Only metadata changes: raw patch offsets and every changed line stay intact.
+                            text = label + ("\n" if text.endswith("\n") else "")
+                            break
+                texts.append(text)
+            display_text = "".join(texts)
+        if content.diagnostic:
+            display_text = content.diagnostic + "\n" + display_text
+        self.diff_document = parse_unified_diff(display_text)
+        self._remember_largest_line_number()
+        self.highlighter.token_spans_by_line_index.clear()
+        try:
+            self.highlighter.lexer = get_lexer_for_filename(basename)
+        except ClassNotFound:
+            self.highlighter.lexer = None
+        texts = []
+        for line in self.diff_document.lines:
+            texts.append(line.text)
+        # One coloring pass is enough: the highlighter formats every block that setPlainText inserts, and the parsed
+        # patch, the line positions, the theme colors and the lexer are all in place before the text goes in.
+        # Colors only depend on the theme, which refresh_metrics follows, so placing the margins is all that is left;
+        # the search restart below rebuilds the line decorations.
+        self.setPlainText("\n".join(texts))
+        self._place_margins()
+        self.moveCursor(QTextCursor.MoveOperation.Start)
+        self._restart_search()
+        if self.saved_selection is not None:
+            selected_text, block_text, offset, old_number, new_number = self.saved_selection
+            block_match = self.find_source(block_text, 0)
+            for line_index, line in enumerate(self.diff_document.lines):
+                if line.text == block_text and (line.old_number, line.new_number) == (old_number, new_number):
+                    block_match = QTextCursor(self.document())
+                    block_match.setPosition(self.line_positions[line_index])
+                    break
+            if not block_match.isNull():
+                cursor = QTextCursor(self.document())
+                source_position = self.source_position(block_match.selectionStart()) + offset
+                position = self.document_position(source_position)
+                end = self.document_position(source_position + utf16_length(selected_text))
+                if end >= self.document().characterCount():
+                    self.saved_selection = None
+                    return
+                cursor.setPosition(position)
+                cursor.setPosition(end, QTextCursor.MoveMode.KeepAnchor)
+                if self.selected_source_text(cursor) == selected_text:
+                    self.setTextCursor(cursor)
+                    self.ensureCursorVisible()
+                    self._decorate(cursor)
+            self.saved_selection = None
+
+    def clear(self, preserve_selection: bool = False) -> None:
+        """Discard stale numbering and highlighting along with the visible patch."""
+        if preserve_selection:
+            self._remember_selection()
+        else:
+            self.saved_selection = None
+        self.diff_document = DiffDocument()
+        self._remember_largest_line_number()
+        self.highlighter.token_spans_by_line_index.clear()
+        super().clear()
+        self.setExtraSelections([])
+        self.refresh_metrics()
+
+    def _remember_selection(self) -> None:
+        """Retain the selected text and containing line across a context reload."""
+        cursor = self.textCursor()
+        if cursor.hasSelection():
+            start = QTextCursor(cursor)
+            start.setPosition(cursor.selectionStart())
+            line_index = self.logical_line_index(start.position())
+            if line_index >= len(self.diff_document.lines):
+                return
+            line = self.diff_document.lines[line_index]
+            offset = self.source_position(start.position()) - self.source_position(self.line_positions[line_index])
+            self.saved_selection = (self.selected_source_text(cursor), line.text, offset, line.old_number, line.new_number)
+
+    def refresh_metrics(self) -> None:
+        """Follow native fonts and palettes for line numbers, search and highlights.
+
+        Recoloring the whole patch is the expensive part, so it only happens when the light/dark theme really
+        changed; a font change, a window shown again or the search bar opening only moves the margins and rebuilds
+        the line decorations.
+        """
+        self.search_bar.setFont(QApplication.font())
+        dark = self.palette().color(QPalette.ColorRole.Base).lightnessF() < DARK_BACKGROUND_LIGHTNESS_LIMIT
+        theme_changed = dark != self.dark_theme
+        self.dark_theme = dark
+        self.background_by_kind = DIFF_DARK_BACKGROUND_BY_KIND if dark else DIFF_BACKGROUND_BY_KIND
+        self.fragment_by_kind = DIFF_DARK_FRAGMENT_BY_KIND if dark else DIFF_FRAGMENT_BY_KIND
+        syntax_style = get_style_by_name("native" if dark else "default")
+        if getattr(self, "syntax_style", None) != syntax_style:
+            self.highlighter.token_spans_by_line_index.clear()
+        self.syntax_style = syntax_style
+        self._place_margins()
+        if theme_changed:
+            self.highlighter.rehighlight()
+        self._decorate()
+
+    def _remember_largest_line_number(self) -> None:
+        """Compute once per patch the widest old or new line number, which sizes the number margin."""
+        largest_number = 1
+        for line in self.diff_document.lines:
+            largest_number = max(largest_number, line.old_number or 0, line.new_number or 0)
+        self.largest_line_number = largest_number
+
+    def _place_margins(self) -> None:
+        """Size and place the number margin and the search bar around the text, without touching any color."""
+        column_width = self.fontMetrics().horizontalAdvance(str(self.largest_line_number)) + LAYOUT_SPACING * 2
+        margin_width = column_width * DIFF_NUMBER_COLUMN_COUNT
+        search_height = 0 if self.search_bar.isHidden() else self.search_bar.sizeHint().height()
+        self.setViewportMargins(margin_width, search_height, 0, 0)
+        rectangle = self.contentsRect()
+        self.search_bar.setGeometry(rectangle.left(), rectangle.top(), rectangle.width(), search_height)
+        self.number_margin.setGeometry(rectangle.left(), self.viewport().geometry().top(), margin_width, self.viewport().height())
+        self.number_margin.update()
+
+    def resizeEvent(self, event: QResizeEvent) -> None:
+        """Keep the two margins aligned when the surrounding splitter moves; colors do not depend on the size."""
+        super().resizeEvent(event)
+        self._place_margins()
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Refresh colors and logical geometry after font or palette changes."""
+        super().changeEvent(event)
+        if event.type() in (QEvent.Type.FontChange, QEvent.Type.ApplicationFontChange, QEvent.Type.PaletteChange) and hasattr(self, "search_bar"):
+            self.refresh_metrics()
+
+    def open_search(self) -> None:
+        """Focus the local query without modifying the history filter."""
+        self.search_bar.show()
+        self.result_label.show_result(self, self.find_edit.text())
+        self.refresh_metrics()
+        self.find_edit.setFocus(Qt.FocusReason.ShortcutFocusReason)
+        self.find_edit.selectAll()
+
+    def close_search(self) -> None:
+        """Hide the query while retaining all syntax and change decoration."""
+        self.search_bar.hide()
+        self.refresh_metrics()
+        self.setFocus(Qt.FocusReason.ShortcutFocusReason)
+
+    def find_next(self) -> None:
+        """Select the next Unicode match, wrapping at the end."""
+        self._find(False)
+
+    def find_previous(self) -> None:
+        """Select the previous Unicode match, wrapping at the start."""
+        self._find(True)
+
+    def _restart_search(self) -> None:
+        """Discard obsolete search selection after the patch or query changes."""
+        cursor = self.textCursor()
+        cursor.clearSelection()
+        self.setTextCursor(cursor)
+        self.result_label.clear()
+        self._decorate()
+        self._find(False, restart=True)
+
+    def _find(self, backward: bool, restart: bool = False) -> None:
+        """Use document offsets so surrogate pairs never shift matches or accents."""
+        query = self.find_edit.text()
+        if not query or self.search_bar.isHidden():
+            return
+        self.result_label.show_result(self, query)
+        cursor = self.textCursor()
+        start = cursor.selectionStart() if backward else cursor.selectionEnd()
+        if restart:
+            start = 0
+        match = self.result_label.find_match(self, query, start, backward)
+        if match.isNull():
+            start = self.document().characterCount() - 1 if backward else 0
+            match = self.result_label.find_match(self, query, start, backward)
+        if match.isNull():
+            return
+        self.setTextCursor(match)
+        self.ensureCursorVisible()
+        self._decorate(match)
+
+    def _decorate(self, match: QTextCursor | None = None) -> None:
+        """Keep full-width change backgrounds when search selections come and go."""
+        selections = []
+        block = self.document().begin()
+        while block.isValid():
+            line_index = self.logical_line_index(block.position())
+            if line_index >= len(self.diff_document.lines):
+                break
+            line = self.diff_document.lines[line_index]
+            background = self.background_by_kind.get(line.kind)
+            if background is None:
+                block = block.next()
+                continue
+            selection = QTextEdit.ExtraSelection()
+            selection.cursor = QTextCursor(block)
+            selection.format.setBackground(QColor(background))
+            selection.format.setProperty(QTextFormat.Property.FullWidthSelection, True)
+            selections.append(selection)
+            if block.position() != self.line_positions[line_index]:
+                block = block.next()
+                continue
+            source_position = self.source_position(block.position())
+            for start, end in line.changed_spans:
+                fragment = QTextEdit.ExtraSelection()
+                fragment.cursor = QTextCursor(self.document())
+                fragment.cursor.setPosition(self.document_position(source_position + utf16_length(line.text[:start])))
+                fragment.cursor.setPosition(self.document_position(source_position + utf16_length(line.text[:end])), QTextCursor.MoveMode.KeepAnchor)
+                fragment.format.setBackground(QColor(self.fragment_by_kind[line.kind]))
+                selections.append(fragment)
+            block = block.next()
+        if not self.search_bar.isHidden():
+            selections.extend(self.result_label.highlight_selections(self, self.find_edit.text(), match))
+        self.setExtraSelections(selections)
+
+    def _update_margin(self, rectangle: QRect, distance: int) -> None:
+        self.number_margin.update()
+
+
+def status_icon(status: FileStatus, side: int, density: float) -> QIcon:
+    """Draw change symbols with an orange R over the modified-file icon for renames."""
+    physical_side = physical_icon_side(side, density)
+    pixmap = QPixmap(physical_side, physical_side)
+    pixmap.setDevicePixelRatio(density)
+    pixmap.fill(Qt.GlobalColor.transparent)
+    painter = QPainter(pixmap)
+    painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+    painter.setPen(QPen(QColor(DIFF_ICON_COLOR_BY_STATUS.get(status, DIFF_ICON_COLOR_BY_STATUS[FileStatus.MODIFIED])), side * DIFF_ICON_STROKE_RATIO))
+    padding = side * DIFF_ICON_PADDING_RATIO
+    center = side / 2
+    if status in (FileStatus.ADDED, FileStatus.DELETED):
+        painter.drawLine(QPointF(padding, center), QPointF(side - padding, center))
+        if status == FileStatus.ADDED:
+            painter.drawLine(QPointF(center, padding), QPointF(center, side - padding))
+    else:
+        paper_padding = padding / 2
+        painter.setPen(QPen(QColor("#a0a0a0"), side * DIFF_ICON_STROKE_RATIO / 2))
+        painter.setBrush(QColor("#fffef4"))
+        painter.drawRect(QRectF(paper_padding, paper_padding, side - padding, side - padding))
+        pencil_stroke_ratio = 0.15
+        painter.setPen(QPen(QColor(DIFF_ICON_COLOR_BY_STATUS[FileStatus.MODIFIED]), side * pencil_stroke_ratio))
+        painter.drawLine(QPointF(padding, side - padding), QPointF(side - padding, padding))
+        if status == FileStatus.RENAMED:
+            badge_side = side * sqrt(DIFF_ICON_RENAME_BADGE_AREA_RATIO)
+            badge_font = painter.font()
+            badge_font.setBold(True)
+            badge_font.setPixelSize(side)
+            badge_path = QPainterPath()
+            badge_path.addText(QPointF(), badge_font, FileStatus.RENAMED.value)
+            bounds = badge_path.boundingRect()
+            scale = min(badge_side / bounds.width(), badge_side / bounds.height())
+            painter.translate(side - bounds.width() * scale, side - bounds.height() * scale)
+            painter.scale(scale, scale)
+            painter.translate(-bounds.left(), -bounds.top())
+            painter.setPen(Qt.PenStyle.NoPen)
+            painter.setBrush(QColor(DIFF_ICON_COLOR_BY_STATUS[FileStatus.RENAMED]))
+            painter.drawPath(badge_path)
+    painter.end()
+    return QIcon(pixmap)
+
+
+class DiffPanel(QWidget):
+    """Emit file selections and display only the comparison supplied by the history read controller."""
+
+    entry_selected = Signal(object)
+    retry_requested = Signal()
+    full_context_requested = Signal(bool)
+
+    def __init__(self) -> None:
+        """Keep file navigation beside a selectable, read-only patch."""
+        super().__init__()
+        self.entries: list[RevisionEntry] = []
+        self.item_by_entry: dict[RevisionEntry, QTreeWidgetItem] = {}
+        self.selected_entry: RevisionEntry | None = None
+        self.action_generation = 0
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(LAYOUT_SPACING)
+        self.reader_toolbar = ReaderToolbar("Find in diff")
+        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(self.retry_requested.emit)
+        self.full_context_checkbox = QCheckBox("Show entire file")
+        self.full_context_checkbox.setEnabled(False)
+        self.full_context_checkbox.toggled.connect(self.full_context_requested.emit)
+        find_button_index = self.reader_toolbar.controls.count() - 1
+        self.reader_toolbar.controls.insertWidget(find_button_index, self.full_context_checkbox)
+        self.splitter = QSplitter(Qt.Orientation.Horizontal)
+        self.splitter.setChildrenCollapsible(False)
+        self.file_tree = RevisionTree()
+        self.file_tree.setHeaderHidden(True)
+        self.file_tree.setUniformRowHeights(True)
+        self.file_tree.setAccessibleName("Changed files")
+        self.diff_view = DiffView()
+        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.diff_view, 1)
+        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 _invalidate_action(self) -> None:
+        self.action_generation += 1
+
+    def refresh_metrics(self) -> None:
+        """Scale file symbols with the tree font and current device density."""
+        side = self.file_tree.fontMetrics().height()
+        self.file_tree.setIconSize(QSize(side, side))
+        self.file_tree.setIndentation(side + LAYOUT_SPACING)
+        for entry, item in self.item_by_entry.items():
+            item.setIcon(0, status_icon(entry.status, side, self.devicePixelRatioF()))
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Update symbols after a system font or palette change."""
+        super().changeEvent(event)
+        if event.type() in (QEvent.Type.FontChange, QEvent.Type.PaletteChange) and hasattr(self, "file_tree"):
+            self.refresh_metrics()
+
+    def clear_selection(self, message: str = "Select a commit") -> None:
+        """Clear stale files immediately when a commit changes."""
+        self.reader_toolbar.finish_loading()
+        self.action_generation += 1
+        self.entries.clear()
+        self.item_by_entry.clear()
+        self.selected_entry = None
+        self.full_context_checkbox.setEnabled(False)
+        self.file_tree.clear()
+        self.diff_view.clear()
+        self.status_label.setText(message)
+        self.status_label.setVisible(bool(message))
+        self.retry_button.hide()
+
+    def show_changes(self, groups: list[ComparisonGroup]) -> None:
+        """Keep the original comparison attached to every displayed file."""
+        self.clear_selection("No changed files")
+        for group in groups:
+            description = "Initial commit" if group.parent_oid is None else f"Diff with {group.parent_short_oid} {group.parent_subject}"
+            file_label = "file" if group.file_count == 1 else "files"
+            group_item = QTreeWidgetItem([f"{group.file_count} {file_label} — {description}"])
+            group_item.setToolTip(0, description)
+            group_item.setIcon(0, self.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogDetailedView))
+            self.file_tree.addTopLevelItem(group_item)
+            directory_item_by_path: dict[bytes, QTreeWidgetItem] = {}
+            for entry in sorted(group.entries, key=lambda change: change.new_path or change.old_path or b""):
+                self.entries.append(entry)
+                path = entry.new_path or entry.old_path or b""
+                directories = path.split(b"/")
+                basename = directories.pop()
+                parent_item = group_item
+                directory_path = b""
+                for directory in directories:
+                    directory_path += directory + b"/"
+                    directory_item = directory_item_by_path.get(directory_path)
+                    if directory_item is None:
+                        directory_item = QTreeWidgetItem([directory.decode("utf-8", "replace")])
+                        directory_item.setData(0, FOLDER_PATH_ROLE, directory_path.removesuffix(b"/"))
+                        directory_item.setToolTip(0, directory_path.decode("utf-8", "replace"))
+                        directory_item.setIcon(0, self.style().standardIcon(QStyle.StandardPixmap.SP_DirIcon))
+                        parent_item.addChild(directory_item)
+                        directory_item_by_path[directory_path] = directory_item
+                    parent_item = directory_item
+                label = basename.decode("utf-8", "replace")
+                tooltip = path.decode("utf-8", "replace")
+                if entry.status == FileStatus.RENAMED and entry.old_path is not None:
+                    old_basename = entry.old_path.rsplit(b"/", maxsplit=1).pop().decode("utf-8", "replace")
+                    label += f" ({old_basename})"
+                    tooltip += "\nRenamed from " + entry.old_path.decode("utf-8", "replace")
+                item = QTreeWidgetItem([label])
+                item.setToolTip(0, tooltip)
+                item.setData(0, Qt.ItemDataRole.UserRole, entry)
+                parent_item.addChild(item)
+                self.item_by_entry[entry] = item
+            for directory_item in (*directory_item_by_path.values(), group_item):
+                children = directory_item.takeChildren()
+                children.sort(key=lambda child: (child.data(0, Qt.ItemDataRole.UserRole) is not None, child.text(0).casefold(), child.text(0)))
+                directory_item.addChildren(children)
+            compact_directory_tree(group_item)
+        self.file_tree.expandAll()
+        self.refresh_metrics()
+        if self.entries:
+            self.status_label.setText("Select a file to view its diff")
+
+    def first_entry(self) -> RevisionEntry | None:
+        """Choose the first visible file after folder grouping and sorting."""
+        iterator = QTreeWidgetItemIterator(self.file_tree)
+        while item := iterator.value():
+            entry = item.data(0, Qt.ItemDataRole.UserRole)
+            if entry is not None:
+                return entry
+            iterator += 1
+        return None
+
+    def show_patch(self, entry: RevisionEntry, patch: bytes) -> None:
+        """Display Git's patch as literal text without executing repository content."""
+        self.reader_toolbar.finish_loading()
+        self.selected_entry = entry
+        self.full_context_checkbox.setEnabled(True)
+        self.diff_view.show_patch(patch, (entry.new_path or entry.old_path or b"").decode("utf-8", "replace"))
+        self.status_label.setText("" if patch else "No content changes")
+        self.status_label.setVisible(not patch)
+        self.retry_button.hide()
+
+    def show_error(self, cause: str) -> None:
+        """Keep a failed read explicit and allow a fresh request."""
+        self.reader_toolbar.finish_loading()
+        self.diff_view.clear()
+        self.status_label.setText(cause)
+        self.status_label.show()
+        self.retry_button.show()
+
+    def _select_item(self, item: QTreeWidgetItem | None, previous: QTreeWidgetItem | None) -> None:
+        """Request the complete entry identity when a file row becomes current."""
+        if item is None:
+            return
+        entry = item.data(0, Qt.ItemDataRole.UserRole)
+        if entry is not None:
+            self.entry_selected.emit(entry)
+
+    def open_search(self) -> None:
+        """Reveal local search and identify the reader receiving the window command."""
+        self.diff_view.open_search()
+        self.diff_view.setAccessibleDescription("Search applies to the displayed comparison")