gitpane 1.0.0__py3-none-any.whl

gitpane/ui/history_rewrite/preview.py

@@ -0,0 +1,565 @@
+"""Present the consequences of a prepared history removal proposal."""
+
+from __future__ import annotations
+
+import os
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QMargins, QModelIndex, QSize, Qt, Signal
+from PySide6.QtGui import QFont, QPalette
+from PySide6.QtWidgets import QAbstractItemView, QApplication, QDialog, QHBoxLayout, QHeaderView, QLabel, QPlainTextEdit, QPushButton, QScrollArea, QSplitter, QStyle, QStyleOptionViewItem, QTableView, QVBoxLayout, QWidget
+
+from gitpane.config import ICON_SIDE, LOCAL_PREFIX, SHORT_OID_LENGTH, SPACING_MD, SPACING_SM, fit_window, history_row_height
+from gitpane.history_rewrite.value import RewriteStatus, RewriteTargetKind
+from gitpane.ui.history_rewrite.details import DetailsText, HistoryRewriteDetails, commit_details
+from gitpane.ui.history_rewrite.preview_model import BranchColumn, BranchPreviewModel, CommitColumn, CommitPreviewModel, ModelText, StatusDelegate, author_date, safe_text, status_color
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.look.theme_palette import desktop_prefers_high_contrast
+from gitpane.ui.widget.dialog_layout import apply_form_metrics, install_banded_layout
+from gitpane.ui.widget.long_text import WrappingLabel
+from gitpane.ui.widget.result_label import ResultLabel
+from gitpane.ui.widget.standard_icon_label import StandardIconLabel
+from gitpane.ui.window_control.dialog_modality import open_window_modal
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QObject
+    from PySide6.QtGui import QCloseEvent, QKeyEvent
+
+    from gitpane.history_rewrite.value import RewritePreparation, RewriteRefusal, RewriteTarget
+
+PREVIEW_WIDTH, PREVIEW_HEIGHT = 960, 720
+PREVIEW_MINIMUM_WIDTH, PREVIEW_MINIMUM_HEIGHT = 640, 480
+INITIAL_BRANCH_ROW_COUNT = 4
+MINIMUM_WARNING_LINE_COUNT = 4
+TARGET_LINE_COUNT = 3
+MESSAGE_MINIMUM_CHARACTERS = 24
+AUTHOR_MINIMUM_CHARACTERS = 16
+PREVIEW_BRANCH_MINIMUM_CHARACTERS = 20
+BRANCH_TABLE_STRETCH, COMMIT_TABLE_STRETCH = 1, 3
+
+
+class PreviewState(Enum):
+    """Identify which actions are meaningful for the current proposal."""
+
+    PREPARING = "preparing"
+    READY = "ready"
+    EMPTY = "empty"
+    ERROR = "error"
+    STALE = "stale"
+    STOPPING = "stopping"
+    EXECUTING = "executing"
+    CLOSED = "closed"
+
+
+class PreviewText(Enum):
+    """Name the preview regions and its explicit action states."""
+
+    TITLE = "Remove from history — Preview"
+    TARGET = "Selected path"
+    FILE = "File: {path}"
+    FOLDER = "Folder and all files below it: {path}"
+    REPOSITORY = "Repository: {repository}"
+    BRANCH = "Current branch: {branch}"
+    PREPARING = "Preparing preview… No changes have been made to this repository."
+    STOPPING = "Stopping preview…"
+    EMPTY = "No history changes found"
+    EMPTY_BODY = "{path} has no history changes to remove from the affected local branches. Choose Abort and select another path."
+    ERROR = "Could not build the preview: {cause}. No changes have been made to this repository. Resolve the problem, then choose Recompute preview."
+    INCOMPLETE = "The preview could not be completed: {cause}. Confirm is unavailable. Inspect the diagnostic and resolve the limit before recomputing; no history was changed."
+    MISSING_METADATA = "Required branch or commit metadata is incomplete or unreadable"
+    DIFFERENT_TARGET = "The proposal belongs to another selected path"
+    STALE = "Preview is out of date"
+    STALE_BODY = "The repository changed after this preview was built. Choose Recompute preview to review the current branches and commits before confirming."
+    BRANCHES = "Affected local branches"
+    ONE_BRANCH = "1 local branch will move."
+    MANY_BRANCHES = "{count} local branches will move."
+    COMMITS = "Affected commit changes"
+    ONE_MODIFIED = "1 modified commit"
+    MANY_MODIFIED = "{count} modified commits"
+    ONE_DELETED = "1 deleted commit"
+    MANY_DELETED = "{count} deleted commits"
+    MODIFIED_LEGEND = "— Modified commit, kept in history."
+    DELETED_LEGEND = "— Commit deleted because removing the path makes it empty."
+    DESCENDANTS = "Descendants may also receive new commit hashes even when their own changes do not involve this path. They are not listed here."
+    WARNINGS = "Before you confirm"
+    CONFIRM = "Confirm"
+    ABORT = "Abort"
+    RECOMPUTE = "Recompute preview"
+    EXECUTING = "Checking repository…"
+    PUBLICATION = "Publication information uses remote references from the last fetch. No fetch was performed; the server may have changed since then."
+    PUBLISHED = "Published history will differ from these local branches. Coordinate with other users before updating remote branches. GitPane will not push these changes."
+    ONE_SIGNATURE = "1 affected signed commit will lose its signature, including rewritten commits not listed above. Confirm accepts this loss."
+    MANY_SIGNATURES = "{count} affected signed commits will lose their signatures, including rewritten commits not listed above. Confirm accepts this loss."
+    NO_SIGNATURE = "No affected signed commits were found."
+    ABSENT = "This path is absent from the current branch version. Historical versions will be removed; no file will be recreated on disk."
+    DISK_INDEX = ("Current files on disk, including unstaged changes, will be kept exactly as they are. The target will be removed from the index. "
+                  "Other staged changes will be kept. No ignore rule will be added.")
+    FINAL = ("Confirm removes {path} from the history of every local branch listed above. Other local branches, tags and remote references will not move. "
+             "Review the consequences below before confirming.")
+    RETAINED = ("This is not a global purge. Other references, reflogs, clones and servers may retain the old data. "
+                "Revoke or rotate compromised credentials; removing a path does not make them safe again.")
+    SUBMODULE = "This repository is a submodule"
+    SUBMODULE_PARENT = ("Parent repositories record exact submodule commit hashes. They will still point to the old commits, not their rewritten replacements. "
+                       "If an old commit remains available, it can still expose the removed file. "
+                       "If it is no longer available locally or retrievable, restoring that parent version may fail.")
+    SUBMODULE_CONSUMERS = ("Other repositories using these commits may also be affected. GitPane cannot identify every consumer. "
+                          "Repair could require rewriting those repositories' histories, branches and tags, then their own parents. GitPane will not update any parent repository.")
+    SUBMODULE_ACCEPT = "Confirm accepts that some old parent versions may no longer be restorable."
+    KNOWN_PARENT = "Known parent repository: {repository}"
+    REFUSAL_PATH = "Path: {path}"
+    REFUSAL_COMMIT = "Commit: {commit}"
+    REFUSAL_BRANCH = "Branch: {branch}"
+
+
+class HistoryRewritePreview(QDialog):
+    """Expose a proposal through typed signals without performing repository work."""
+
+    confirm_requested = Signal(object)
+    abort_requested = Signal()
+    recompute_requested = Signal()
+
+    def __init__(self, target: RewriteTarget, branch: str, repository_dir: str, parent: QWidget | None = None, *, active_submodule: bool = False, parent_repository_dir: str = "") -> None:
+        """Start visibly preparing with Abort as the only default action."""
+        super().__init__(parent)
+        self.target = target
+        self.active_branch = branch if branch.startswith(LOCAL_PREFIX) else LOCAL_PREFIX + branch
+        self.repository_dir = repository_dir
+        self.active_submodule = active_submodule
+        self.parent_repository_dir = parent_repository_dir
+        self.preparation: RewritePreparation | None = None
+        self.details_dialog: HistoryRewriteDetails | None = None
+        self.state = PreviewState.PREPARING
+        self.setWindowTitle(PreviewText.TITLE.value)
+        self.resize(PREVIEW_WIDTH, PREVIEW_HEIGHT)
+        self.setWindowFlag(Qt.WindowType.WindowContextHelpButtonHint, False)
+        body = QVBoxLayout()
+        body.setSpacing(SPACING_SM)
+        self.target_text = QPlainTextEdit()
+        self.target_text.setReadOnly(True)
+        self.target_text.setAccessibleName(PreviewText.TARGET.value)
+        self._show_target()
+        body.addWidget(self.target_text)
+        self.status_label = ResultLabel(PreviewText.PREPARING.value)
+        self.status_scroll = QScrollArea()
+        self.status_scroll.setWidgetResizable(True)
+        self.status_scroll.setWidget(self.status_label)
+        self.status_scroll.setFrameShape(QScrollArea.Shape.NoFrame)
+        body.addWidget(self.status_scroll)
+        self.branch_model = BranchPreviewModel()
+        self.commit_model = CommitPreviewModel()
+        self.branch_table = self._table(PreviewText.BRANCHES)
+        self.commit_table = self._table(PreviewText.COMMITS)
+        self.branch_table.setModel(self.branch_model)
+        self.commit_table.setModel(self.commit_model)
+        self.status_delegate = StatusDelegate(self.commit_table)
+        self.commit_table.setItemDelegateForColumn(CommitColumn.STATUS.index, self.status_delegate)
+        self.commit_table.viewport().installEventFilter(self)
+        self.branch_count_label = self._label("")
+        self.commit_count_label = self._label("")
+        self.table_splitter = QSplitter(Qt.Orientation.Vertical)
+        self.table_splitter.addWidget(self._table_section(PreviewText.BRANCHES, self.branch_count_label, self.branch_table))
+        self.table_splitter.addWidget(self._table_section(PreviewText.COMMITS, self.commit_count_label, self.commit_table))
+        branch_section_index, commit_section_index = 0, 1
+        self.table_splitter.setStretchFactor(branch_section_index, BRANCH_TABLE_STRETCH)
+        self.table_splitter.setStretchFactor(commit_section_index, COMMIT_TABLE_STRETCH)
+        self.table_splitter.setChildrenCollapsible(False)
+        self.table_splitter.setHandleWidth(SPACING_MD)
+        body.addWidget(self.table_splitter, 1)
+        legend = QHBoxLayout()
+        legend.setSpacing(SPACING_SM)
+        self.legend_marker_by_status: dict[RewriteStatus, QLabel] = {}
+        for status, caption in ((RewriteStatus.MODIFIED, PreviewText.MODIFIED_LEGEND), (RewriteStatus.DELETED, PreviewText.DELETED_LEGEND)):
+            marker = QLabel(status.value)
+            marker.setTextFormat(Qt.TextFormat.PlainText)
+            marker.setBackgroundRole(QPalette.ColorRole.Base)
+            marker.setForegroundRole(QPalette.ColorRole.Text)
+            marker.setAutoFillBackground(True)
+            marker_font = QFont()
+            marker_font.setBold(status == RewriteStatus.DELETED)
+            marker.setFont(marker_font)
+            self.legend_marker_by_status[status] = marker
+            legend.addWidget(marker, 0, Qt.AlignmentFlag.AlignTop)
+            legend.addWidget(self._label(caption.value), 1, Qt.AlignmentFlag.AlignTop)
+        body.addLayout(legend)
+        body.addWidget(self._label(PreviewText.DESCENDANTS.value))
+        body.addSpacing(SPACING_MD - body.spacing())
+        warning_heading = QHBoxLayout()
+        self.warning_icon = StandardIconLabel(QSize(ICON_SIDE, ICON_SIDE), QStyle.StandardPixmap.SP_MessageBoxWarning)
+        warning_heading.addWidget(self.warning_icon, 0, Qt.AlignmentFlag.AlignVCenter)
+        warning_heading.addWidget(self._heading(PreviewText.WARNINGS), 1)
+        body.addLayout(warning_heading)
+        self.warning_scroll = QScrollArea()
+        self.warning_scroll.setWidgetResizable(True)
+        self.warning_scroll.setAccessibleName(PreviewText.WARNINGS.value)
+        self.warning_scroll.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+        self.warning_scroll.installEventFilter(self)
+        self.warning_label = self._label("")
+        self.warning_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse | Qt.TextInteractionFlag.TextSelectableByKeyboard)
+        self.warning_scroll.setWidget(self.warning_label)
+        body.addWidget(self.warning_scroll, 1)
+        self.confirm_button = QPushButton(PreviewText.CONFIRM.value)
+        self.abort_button = QPushButton(PreviewText.ABORT.value)
+        self.recompute_button = QPushButton(PreviewText.RECOMPUTE.value)
+        for button in (self.confirm_button, self.abort_button, self.recompute_button):
+            button.setAutoDefault(False)
+        self.button_band = install_banded_layout(self, body, [self.confirm_button, self.abort_button],
+                                                body_margins=QMargins(SPACING_MD, SPACING_MD, SPACING_MD, SPACING_MD), leading_buttons=[self.recompute_button])
+        self.abort_button.setDefault(True)
+        self.confirm_button.clicked.connect(self._confirm)
+        self.abort_button.clicked.connect(self.reject)
+        self.recompute_button.clicked.connect(self._recompute)
+        self.branch_table.doubleClicked.connect(self._branch_details)
+        self.commit_table.doubleClicked.connect(self._commit_details)
+        self._set_state(PreviewState.PREPARING)
+        self.apply_metrics()
+        self.table_splitter.setSizes([INITIAL_BRANCH_ROW_COUNT * history_row_height(self.fontMetrics().height()),
+                                     INITIAL_BRANCH_ROW_COUNT * history_row_height(self.fontMetrics().height()) * COMMIT_TABLE_STRETCH])
+        follow_theme(self, self._refresh_theme)
+        self._refresh_theme()
+        previous = self.target_text
+        for widget in (self.branch_table, self.commit_table, self.warning_scroll, self.warning_label, self.recompute_button, self.confirm_button, self.abort_button):
+            QWidget.setTabOrder(previous, widget)
+            previous = widget
+        fit_window(self, PREVIEW_MINIMUM_WIDTH, PREVIEW_MINIMUM_HEIGHT)
+
+    def _label(self, text: str) -> WrappingLabel:
+        """Keep repository text selectable without Qt markup detection."""
+        label = WrappingLabel(text)
+        label.setTextFormat(Qt.TextFormat.PlainText)
+        label.setWordWrap(True)
+        label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+        return label
+
+    def _table(self, caption: PreviewText) -> QTableView:
+        """Use native scrolling and selection without editors or per-cell widgets."""
+        table = QTableView()
+        table.setAccessibleName(caption.value)
+        table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        table.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        table.setSortingEnabled(False)
+        table.setWordWrap(False)
+        table.setTextElideMode(Qt.TextElideMode.ElideRight)
+        table.setShowGrid(False)
+        table.verticalHeader().hide()
+        table.horizontalHeader().setSectionsClickable(False)
+        table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Interactive)
+        table.installEventFilter(self)
+        return table
+
+    def _table_section(self, title: PreviewText, count: WrappingLabel, table: QTableView) -> QWidget:
+        """Keep headings outside the table viewport as its rows scroll."""
+        section = QWidget()
+        layout = QVBoxLayout(section)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(SPACING_SM)
+        layout.addWidget(self._heading(title))
+        layout.addWidget(count)
+        layout.addWidget(table, 1)
+        return section
+
+    def _heading(self, title: PreviewText) -> WrappingLabel:
+        """Emphasize section titles while inheriting the native family and size."""
+        label = self._label(title.value)
+        font = QFont()
+        font.setBold(True)
+        label.setFont(font)
+        return label
+
+    def _hash_column_width(self, table: QTableView, column_index: int) -> int:
+        """Reserve a full short hash plus native cell padding and header space."""
+        option = QStyleOptionViewItem()
+        table.initViewItemOption(option)
+        widest_digit = max("0123456789abcdef", key=lambda digit: option.fontMetrics.horizontalAdvance(digit * SHORT_OID_LENGTH))
+        option.text = widest_digit * SHORT_OID_LENGTH
+        if table == self.branch_table and column_index == BranchColumn.NEW_TIP.index:
+            option.text += f" — {ModelText.TIP_DELETED.value}"
+        option.features |= QStyleOptionViewItem.ViewItemFeature.HasDisplay
+        cell_width = table.style().sizeFromContents(QStyle.ContentsType.CT_ItemViewItem, option, QSize(), table).width()
+        return max(cell_width, table.horizontalHeader().sectionSizeHint(column_index))
+
+    def apply_metrics(self) -> None:
+        """Size columns from the current native font without scanning every row."""
+        metrics = self.fontMetrics()
+        row_height = history_row_height(metrics.height())
+        self.target_text.setMaximumHeight(row_height * TARGET_LINE_COUNT)
+        self.status_scroll.setMaximumHeight(row_height * TARGET_LINE_COUNT)
+        self.warning_scroll.setMinimumHeight(metrics.lineSpacing() * MINIMUM_WARNING_LINE_COUNT + SPACING_MD)
+        for table in (self.branch_table, self.commit_table):
+            table.verticalHeader().setDefaultSectionSize(row_height)
+            table.verticalHeader().setMinimumSectionSize(row_height)
+            table.horizontalHeader().setMinimumSectionSize(SPACING_MD)
+        for column in CommitColumn:
+            sample = column.value
+            if column == CommitColumn.COMMIT:
+                self.commit_table.setColumnWidth(column.index, self._hash_column_width(self.commit_table, column.index))
+                continue
+            elif column == CommitColumn.MESSAGE:
+                sample = "M" * MESSAGE_MINIMUM_CHARACTERS
+            elif column == CommitColumn.AUTHOR:
+                sample = "M" * AUTHOR_MINIMUM_CHARACTERS
+            elif column == CommitColumn.DATE:
+                sample = "2000-12-31 23:59 +1200"
+            self.commit_table.setColumnWidth(column.index, metrics.horizontalAdvance(sample) + SPACING_MD)
+        for column in BranchColumn:
+            if column in (BranchColumn.CURRENT_TIP, BranchColumn.NEW_TIP):
+                self.branch_table.setColumnWidth(column.index, self._hash_column_width(self.branch_table, column.index))
+                continue
+            sample = "M" * PREVIEW_BRANCH_MINIMUM_CHARACTERS
+            self.branch_table.setColumnWidth(column.index, metrics.horizontalAdvance(sample) + SPACING_MD)
+        apply_form_metrics(self)
+        self._fit_message_column()
+
+    def _fit_message_column(self) -> None:
+        """Give the subject remaining viewport space while preserving its readable minimum."""
+        minimum = self.fontMetrics().horizontalAdvance("M" * MESSAGE_MINIMUM_CHARACTERS) + SPACING_MD
+        other_width = 0
+        for column in CommitColumn:
+            if column != CommitColumn.MESSAGE:
+                other_width += self.commit_table.columnWidth(column.index)
+        width = max(minimum, self.commit_table.viewport().width() - other_width)
+        if self.commit_table.columnWidth(CommitColumn.MESSAGE.index) != width:
+            self.commit_table.setColumnWidth(CommitColumn.MESSAGE.index, width)
+
+    def _refresh_theme(self) -> None:
+        """Follow native contrast preference without replacing the prepared models."""
+        self.status_delegate.high_contrast = desktop_prefers_high_contrast(QApplication.instance())
+        self.status_delegate.refresh_theme()
+        for status, marker in self.legend_marker_by_status.items():
+            palette = self.commit_table.palette()
+            for group in (QPalette.ColorGroup.Active, QPalette.ColorGroup.Inactive, QPalette.ColorGroup.Disabled):
+                palette.setCurrentColorGroup(group)
+                palette.setColor(group, QPalette.ColorRole.Text, status_color(status, palette, high_contrast=self.status_delegate.high_contrast))
+            marker.setPalette(palette)
+        self.commit_table.viewport().update()
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Recalculate text metrics only when fonts or styles change."""
+        super().changeEvent(event)
+        if event.type() in (QEvent.Type.FontChange, QEvent.Type.StyleChange) and hasattr(self, "button_band"):
+            self.apply_metrics()
+            self._refresh_theme()
+
+    def _set_state(self, state: PreviewState) -> None:
+        """Derive available actions from one explicit lifecycle state."""
+        self.state = state
+        self.status_scroll.setVisible(state != PreviewState.READY)
+        self.confirm_button.setEnabled(state == PreviewState.READY)
+        self.abort_button.setEnabled(state not in (PreviewState.STOPPING, PreviewState.EXECUTING, PreviewState.CLOSED))
+        self.recompute_button.setVisible(state in (PreviewState.ERROR, PreviewState.STALE))
+
+    def set_preparation(self, preparation: RewritePreparation) -> None:
+        """Show the complete result, refusing partial or unreadable proposals."""
+        if self.state in (PreviewState.STOPPING, PreviewState.EXECUTING, PreviewState.CLOSED):
+            return
+        self.preparation = preparation
+        if preparation.capture.head_ref:
+            self.active_branch = preparation.capture.head_ref
+            self._show_target()
+        old_branch_model, old_commit_model = self.branch_model, self.commit_model
+        self.branch_model = BranchPreviewModel(preparation.branches, preparation.capture.head_ref)
+        self.commit_model = CommitPreviewModel(preparation.rows)
+        self.branch_table.setModel(self.branch_model)
+        self.commit_table.setModel(self.commit_model)
+        old_branch_model.deleteLater()
+        old_commit_model.deleteLater()
+        self._update_counts()
+        self._update_warning(preparation)
+        if preparation.target != self.target:
+            self.set_error(PreviewText.DIFFERENT_TARGET.value)
+            return
+        if not preparation.complete or not preparation.capture.complete or preparation.refusal:
+            self.set_error(preparation.refusal or PreviewText.MISSING_METADATA.value)
+            return
+        if not preparation.rows and not preparation.branches:
+            self._set_state(PreviewState.EMPTY)
+            self.status_label.setText(PreviewText.EMPTY.value + "\n" + PreviewText.EMPTY_BODY.value.format(path=safe_text(self.target.path)))
+            return
+        try:
+            self._validate_metadata(preparation)
+        except (ValueError, OSError, OverflowError) as error:
+            self.set_error(str(error), incomplete=True)
+            return
+        self._set_state(PreviewState.READY)
+        self.status_label.setText("")
+
+    def _show_target(self) -> None:
+        """Keep the branch heading consistent with the newly computed proposal."""
+        scope = PreviewText.FOLDER if self.target.kind == RewriteTargetKind.FOLDER else PreviewText.FILE
+        self.target_text.setPlainText("\n".join((scope.value.format(path=safe_text(self.target.path)),
+                                               PreviewText.REPOSITORY.value.format(repository=safe_text(self.repository_dir)),
+                                               PreviewText.BRANCH.value.format(branch=safe_text(self.active_branch.removeprefix(LOCAL_PREFIX))))))
+
+    def _validate_metadata(self, preparation: RewritePreparation) -> None:
+        """Reject missing required metadata while keeping an actually empty message valid."""
+        if not preparation.rows or not preparation.branches:
+            raise ValueError(PreviewText.MISSING_METADATA.value)
+        message_size = None
+        if preparation.message_filename:
+            with open(preparation.message_filename, "rb") as stream:
+                message_size = os.fstat(stream.fileno()).st_size
+        for row in preparation.rows:
+            if not row.author or not row.oid:
+                raise ValueError(PreviewText.MISSING_METADATA.value)
+            author_date(row.date)
+            if row.message_offset is not None and (message_size is None or row.message_offset < 0 or row.message_length < 0 or row.message_offset + row.message_length > message_size):
+                raise ValueError(DetailsText.INCOMPLETE.value)
+        for branch in preparation.branches:
+            if not branch.name or not branch.old_oid or not branch.new_oid:
+                raise ValueError(PreviewText.MISSING_METADATA.value)
+
+    def _update_counts(self) -> None:
+        """Count only displayed contributions while retaining every affected branch."""
+        branch_count = len(self.branch_model.branches)
+        self.branch_count_label.setText((PreviewText.ONE_BRANCH if branch_count == 1 else PreviewText.MANY_BRANCHES).value.format(count=branch_count))
+        modified_count = sum(row.status == RewriteStatus.MODIFIED for row in self.commit_model.rows)
+        deleted_count = len(self.commit_model.rows) - modified_count
+        modified = (PreviewText.ONE_MODIFIED if modified_count == 1 else PreviewText.MANY_MODIFIED).value.format(count=modified_count)
+        deleted = (PreviewText.ONE_DELETED if deleted_count == 1 else PreviewText.MANY_DELETED).value.format(count=deleted_count)
+        self.commit_count_label.setText(modified + "; " + deleted)
+
+    def _update_warning(self, preparation: RewritePreparation) -> None:
+        """Explain all consequences using complete domain counts and already known context."""
+        paragraphs = [PreviewText.FINAL.value.format(path=safe_text(self.target.path)), PreviewText.PUBLICATION.value, PreviewText.PUBLISHED.value]
+        if preparation.signed_count == 0:
+            paragraphs.append(PreviewText.NO_SIGNATURE.value)
+        else:
+            caption = PreviewText.ONE_SIGNATURE if preparation.signed_count == 1 else PreviewText.MANY_SIGNATURES
+            paragraphs.append(caption.value.format(count=preparation.signed_count))
+        if preparation.current_absent:
+            paragraphs.append(PreviewText.ABSENT.value)
+        paragraphs.append(PreviewText.DISK_INDEX.value)
+        if self.active_submodule:
+            paragraphs.extend((PreviewText.SUBMODULE.value, PreviewText.SUBMODULE_PARENT.value, PreviewText.SUBMODULE_CONSUMERS.value, PreviewText.SUBMODULE_ACCEPT.value))
+            if self.parent_repository_dir:
+                paragraphs.append(PreviewText.KNOWN_PARENT.value.format(repository=safe_text(self.parent_repository_dir)))
+        paragraphs.append(PreviewText.RETAINED.value)
+        self.warning_label.setText("\n\n".join(paragraphs))
+
+    def set_refusal(self, refusal: RewriteRefusal) -> None:
+        """Show every supplied refusal witness without guessing a new repository state."""
+        paragraphs = [refusal.detail]
+        if refusal.path is not None:
+            paragraphs.append(PreviewText.REFUSAL_PATH.value.format(path=refusal.path.decode("utf-8", "surrogateescape")))
+        if refusal.commit_oid:
+            paragraphs.append(PreviewText.REFUSAL_COMMIT.value.format(commit=refusal.commit_oid))
+        if refusal.branch:
+            paragraphs.append(PreviewText.REFUSAL_BRANCH.value.format(branch=refusal.branch))
+        self.set_error("\n".join(paragraphs))
+
+    def set_error(self, cause: str, *, incomplete: bool = False) -> None:
+        """Keep an actionable preparation failure visible with Confirm unavailable."""
+        if self.state in (PreviewState.STOPPING, PreviewState.CLOSED):
+            return
+        self._set_state(PreviewState.ERROR)
+        self.status_label.show_warning((PreviewText.INCOMPLETE if incomplete else PreviewText.ERROR).value.format(cause=safe_text(cause, multiline=True)))
+
+    def mark_stale(self, cause: str = "") -> None:
+        """Revoke consent as soon as the controller observes changed repository facts."""
+        if self.state in (PreviewState.STOPPING, PreviewState.CLOSED):
+            return
+        self._set_state(PreviewState.STALE)
+        self.status_label.setText(PreviewText.STALE.value + "\n" + PreviewText.STALE_BODY.value + ("\n" + safe_text(cause, multiline=True) if cause else ""))
+
+    def finish_publication(self) -> None:
+        """Close an executed proposal without reporting a harmless preview cancellation."""
+        self._set_state(PreviewState.CLOSED)
+        super().accept()
+
+    def _recompute(self) -> None:
+        """Request one fresh calculation without carrying forward prior approval."""
+        if self.state not in (PreviewState.ERROR, PreviewState.STALE):
+            return
+        self._set_state(PreviewState.PREPARING)
+        self.status_label.setText(PreviewText.PREPARING.value)
+        self.recompute_requested.emit()
+
+    def _confirm(self) -> None:
+        """Disable repeated submission before handing the typed proposal to the controller."""
+        if self.state != PreviewState.READY or self.preparation is None:
+            return
+        self._set_state(PreviewState.EXECUTING)
+        self.status_label.setText(PreviewText.EXECUTING.value)
+        self.confirm_requested.emit(self.preparation)
+
+    def reject(self) -> None:
+        """Ask the controller to stop private work before closing this preview."""
+        if self.state in (PreviewState.STOPPING, PreviewState.EXECUTING, PreviewState.CLOSED):
+            return
+        self._set_state(PreviewState.STOPPING)
+        self.status_label.setText(PreviewText.STOPPING.value)
+        self.abort_requested.emit()
+
+    def finish_abort(self) -> None:
+        """Close only after the controller confirms that private work has stopped."""
+        self._set_state(PreviewState.CLOSED)
+        super().reject()
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        """Make title-bar closure follow the same drain requirement as Abort."""
+        if self.state == PreviewState.CLOSED:
+            super().closeEvent(event)
+            return
+        event.ignore()
+        self.reject()
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        """Require explicit button focus for Enter instead of activating a hidden default."""
+        if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
+            focused = self.focusWidget()
+            if focused in (self.confirm_button, self.abort_button, self.recompute_button):
+                focused.click()
+            event.accept()
+            return
+        super().keyPressEvent(event)
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Offer complete keyboard reading without treating navigation as consent."""
+        if event.type() == QEvent.Type.Resize and hasattr(self, "commit_table") and watched == self.commit_table.viewport():
+            self._fit_message_column()
+        # QScrollArea handles arrows and page keys but leaves Home/End unhandled.
+        if event.type() == QEvent.Type.KeyPress and watched == self.warning_scroll and event.key() in (Qt.Key.Key_Home, Qt.Key.Key_End):
+            scrollbar = self.warning_scroll.verticalScrollBar()
+            scrollbar.setValue(scrollbar.minimum() if event.key() == Qt.Key.Key_Home else scrollbar.maximum())
+            event.accept()
+            return True
+        if event.type() == QEvent.Type.KeyPress and event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
+            if watched == self.branch_table:
+                self._branch_details(self.branch_table.currentIndex())
+            elif watched == self.commit_table:
+                self._commit_details(self.commit_table.currentIndex())
+            else:
+                return super().eventFilter(watched, event)
+            return True
+        return super().eventFilter(watched, event)
+
+    def _branch_details(self, index: QModelIndex) -> None:
+        """Open full branch identities without querying the repository."""
+        if index.isValid():
+            self._show_details(self.branch_model.details(index.row()))
+
+    def _commit_details(self, index: QModelIndex) -> None:
+        """Load only the chosen message and refuse confirmation if its spool was lost."""
+        if not index.isValid() or self.preparation is None:
+            return
+        try:
+            text = commit_details(self.commit_model.rows[index.row()], self.preparation.message_filename)
+        except (ValueError, OSError, OverflowError) as error:
+            self.set_error(str(error), incomplete=True)
+            text = safe_text(str(error))
+        self._show_details(text)
+
+    def _show_details(self, text: str) -> None:
+        """Retain one modal child until it closes."""
+        self.details_dialog = HistoryRewriteDetails(text, self)
+        self.details_dialog.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+        self.details_dialog.finished.connect(self._detail_closed)
+        self.details_dialog.show_modal()
+
+    def _detail_closed(self, _result: int) -> None:
+        self.details_dialog = None
+
+    def show_modal(self) -> None:
+        """Show through the native-window policy without beginning any Git work."""
+        open_window_modal(self)