gitpane 1.0.0__py3-none-any.whl

gitpane/ui/staging/staging_window.py

@@ -0,0 +1,745 @@
+"""Present two local change lists beside the reusable unified diff reader."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QAbstractAnimation, QCoreApplication, QEasingCurve, QEvent, QSignalBlocker, Qt, QVariantAnimation, Signal
+from PySide6.QtGui import QAction, QFontDatabase, QKeySequence, QShortcut, QTextCursor
+from PySide6.QtWidgets import QAbstractItemView, QCheckBox, QHBoxLayout, QLabel, QLineEdit, QListWidget, QListWidgetItem, QPlainTextEdit, QPushButton, QSizePolicy, QSplitter, QVBoxLayout, QWidget
+
+from gitpane.config import (
+    EMOJI_GRID_ANIMATION_MS,
+    EMOJI_KEYBOARD_TITLE,
+    FIND_SHORTCUT,
+    ICON_SIDE,
+    LAYOUT_SPACING,
+    SPACING_MD,
+    STAGE_SHORTCUT,
+    STAGING_HEIGHT,
+    STAGING_MESSAGE_PROPORTION_KEY,
+    STAGING_MIN_HEIGHT,
+    STAGING_MIN_WIDTH,
+    STAGING_PROPORTION_BY_KEY,
+    STAGING_WIDTH,
+    SharedText,
+    control_height,
+    fit_window,
+)
+from gitpane.operation.repository_operation import OperationAction
+from gitpane.ui.console.error_dialog import ErrorDialog
+from gitpane.ui.emoji.emoji_font import emoji_capable_font
+from gitpane.ui.emoji.emoji_grid import EmojiGrid
+from gitpane.ui.look.action_icon import action_icon
+from gitpane.ui.reader.diff_panel import DiffView, status_icon
+from gitpane.ui.reader.reader_toolbar import ReaderToolbar
+from gitpane.ui.staging.staging_action import FileResetMenu, StagingActionMenu
+from gitpane.ui.widget.commit_date_text import format_commit_date
+from gitpane.ui.widget.result_label import LineLimitedResultLabel, ResultTone
+from gitpane.ui.widget.unavailable_reason import unavailable_reason_text
+from gitpane.ui.window_control.dialog_modality import open_window_modal
+from gitpane.worktree.worktree_snapshot import SUBMODULE_DIRTY_DESCRIPTION, SUBMODULE_NO_COMMIT_CHANGE, StagingSide
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtCore import QRect
+    from PySide6.QtGui import QCloseEvent
+
+    from gitpane.history.repository_value import RepositoryContext
+    from gitpane.operation.diagnostic import PreparedDiagnostic
+    from gitpane.submodule.submodule_discovery import SubmoduleDifference, SubmoduleSummary
+    from gitpane.worktree.worktree_snapshot import LocalEntry, WorktreeSnapshot
+
+
+# Order of the panes of the message splitter: the diff, the emoji keyboard (hidden until asked for), then the commit message.
+DIFF_PANE_INDEX, EMOJI_PANE_INDEX, MESSAGE_PANE_INDEX = 0, 1, 2
+EMOJI_KEYBOARD_TOOLTIP = "Show or hide the emoji keyboard"
+# Once open, the keyboard keeps at least one row of symbols when the user drags a handle.
+EMOJI_GRID_MINIMUM_ROW_COUNT = 1
+# Lines the status bar shows before it cuts a long result with an ellipsis; Show details holds the whole text.
+STATUS_VISIBLE_LINE_COUNT = 3
+
+
+class StagingText(Enum):
+    """Name the local preparation messages used across view updates."""
+
+    WAITING_TO_CLOSE = "Waiting for the current write to finish. Your message is preserved."
+
+
+def difference_lines(differences: tuple[SubmoduleDifference, ...]) -> list[str]:
+    """Render literal Git status and rename paths without allowing filenames to create extra rows."""
+    lines = []
+    for difference in differences:
+        path = difference.path.decode("utf-8", "replace").replace("\r", "\\r").replace("\n", "\\n").replace("\t", "\\t")
+        if difference.old_path is not None:
+            path = difference.old_path.decode("utf-8", "replace").replace("\r", "\\r").replace("\n", "\\n").replace("\t", "\\t") + " → " + path
+        lines.append(difference.status + " " + path)
+    return lines
+
+
+def commit_summary_lines(summary: SubmoduleSummary) -> tuple[list[str], str]:
+    """Describe changes between the selected immutable commits separately from local child files."""
+    lines = []
+    now = datetime.now().astimezone()
+    source_availability, target_availability = ((summary.reference.committed_availability, summary.reference.indexed_availability) if summary.side == StagingSide.STAGED
+                                                else (summary.reference.indexed_availability, summary.reference.checkout_availability))
+    for label, commit, availability in (("From", summary.source, source_availability), ("To", summary.target, target_availability)):
+        lines.append(f"{label}: {commit.oid or 'Unavailable'}")
+        if commit.oid is None:
+            lines.append(availability)
+        lines.append(format_commit_date(commit.timestamp, now) if commit.timestamp is not None else "Unavailable")
+        lines.append(commit.subject if commit.subject is not None else f"Commit details are unavailable for {commit.oid or 'Unavailable'}.")
+        lines.append("")
+    lines.extend(("Type: " + summary.relation, ""))
+    added, removed = summary.added_count, summary.removed_count
+    suffix = ""
+    if summary.relation == "Fast Forward" and added is not None and removed == 0:
+        lines.append(f"Commits: {added} added")
+        suffix = f" (+{added})"
+    elif summary.relation == "Rewind" and removed is not None and added == 0:
+        lines.append(f"Commits: {removed} removed")
+        suffix = f" (-{removed})"
+    else:
+        lines.append(f"Commits: {added if added is not None else 'Unavailable'} added, {removed if removed is not None else 'Unavailable'} removed")
+    for label, commits, count in (("Added", summary.added_commits, added), ("Removed", summary.removed_commits, removed)):
+        for commit in commits:
+            date = format_commit_date(commit.timestamp, now) if commit.timestamp is not None else "Unavailable"
+            lines.append(f"{label}: {commit.oid} {date} {commit.subject}")
+        if count is not None and count > len(commits):
+            lines.append(f"{label}: showing {len(commits)} of {count} commits.")
+    lines.extend(("", "Differences:"))
+    if summary.differences is None:
+        lines.append("Differences could not be read. Review the details and refresh the repository.")
+    elif not summary.differences:
+        lines.append("No differences between these commits.")
+    else:
+        lines.extend(difference_lines(summary.differences))
+    if summary.differences_truncated:
+        lines.append("More differences are available. The displayed list is limited.")
+    if summary.relation == "Unchanged":
+        lines.extend(("", "The submodule commit has not changed."))
+    return lines, suffix
+
+
+class StagingWindow(QWidget):
+    """Emit captured file intentions while leaving index changes to injected services."""
+
+    closed = Signal()
+    refresh_requested = Signal()
+    stage_requested = Signal(object)
+    unstage_requested = Signal(object)
+    entry_selected = Signal(object)
+    selection_cleared = Signal()
+    commit_requested = Signal()
+    commit_push_requested = Signal()
+    amend_changed = Signal(bool)
+    preference_requested = Signal(object)
+
+    def __init__(self, context: RepositoryContext) -> None:
+        """Build the approved list/diff/message layout with only functional commands."""
+        super().__init__()
+        self.context = context
+        self.setWindowTitle("Prepare changes — " + context.repository_dir)
+        self.resize(STAGING_WIDTH, STAGING_HEIGHT)
+        self.snapshot: WorktreeSnapshot | None = None
+        self.diagnostic: PreparedDiagnostic | None = None
+        self.busy = False
+        self.close_requested = False
+        self.amend_ready = False
+        # A merge waits for its commit: it may be concluded with nothing staged, by keeping HEAD's side of every file.
+        self.merge_in_progress = False
+        self.reason_by_action: dict[OperationAction, str] = {}
+        # Set by the staging controller, which reads the preferences and the disk; the window only shows the reason it returns.
+        self.text_editor_reason: Callable[[LocalEntry], str] | None = None
+        layout = QVBoxLayout(self)
+        self.repository_identity = QLineEdit(context.repository_dir)
+        self.repository_identity.setObjectName("repository_identity")
+        self.repository_identity.setReadOnly(True)
+        self.repository_identity.setAccessibleName("Repository path")
+        layout.addWidget(self.repository_identity)
+        toolbar = QHBoxLayout()
+        self.filter_edit = QLineEdit()
+        self.filter_edit.setPlaceholderText("Filter files")
+        self.filter_edit.setAccessibleName("Filter files")
+        self.refresh_button = QPushButton("Refresh")
+        self.refresh_button.clicked.connect(self.refresh_requested)
+        toolbar.addWidget(self.filter_edit, 1)
+        toolbar.addWidget(self.refresh_button)
+        layout.addLayout(toolbar)
+        self.splitter = QSplitter(Qt.Orientation.Horizontal)
+        layout.addWidget(self.splitter, 1)
+        lists = QWidget()
+        list_layout = QVBoxLayout(lists)
+        list_layout.setContentsMargins(0, 0, 0, 0)
+        self.list_splitter = QSplitter(Qt.Orientation.Vertical)
+        list_layout.addWidget(self.list_splitter, 1)
+        unstaged = QWidget()
+        unstaged_layout = QVBoxLayout(unstaged)
+        unstaged_layout.setContentsMargins(0, 0, 0, 0)
+        unstaged_layout.addWidget(QLabel("Unstaged"))
+        self.unstaged_list = QListWidget()
+        self.unstaged_list.setAccessibleName("Unstaged files")
+        unstaged_layout.addWidget(self.unstaged_list, 1)
+        self.unstaged_empty_label = QLabel()
+        self.unstaged_empty_label.setWordWrap(True)
+        unstaged_layout.addWidget(self.unstaged_empty_label)
+        controls = QHBoxLayout()
+        self.stage_button = QPushButton("Stage selected")
+        self.stage_shortcut = QShortcut(QKeySequence(STAGE_SHORTCUT), self.unstaged_list)
+        self.stage_shortcut.setContext(Qt.ShortcutContext.WidgetShortcut)
+        self.stage_shortcut.activated.connect(self.stage_button.click)
+        self.stage_button.clicked.connect(lambda: self.stage_requested.emit(self.selected_entries(self.unstaged_list)))
+        self.unstage_button = QPushButton("Unstage selected")
+        self.unstage_button.clicked.connect(lambda: self.unstage_requested.emit(self.selected_entries(self.staged_list)))
+        controls.addWidget(self.stage_button)
+        controls.addWidget(self.unstage_button)
+        unstaged_layout.addLayout(controls)
+        self.list_splitter.addWidget(unstaged)
+        staged = QWidget()
+        staged_layout = QVBoxLayout(staged)
+        staged_layout.setContentsMargins(0, 0, 0, 0)
+        staged_layout.addWidget(QLabel("Staged"))
+        self.staged_list = QListWidget()
+        self.staged_list.setAccessibleName("Staged files")
+        staged_layout.addWidget(self.staged_list, 1)
+        self.staged_empty_label = QLabel()
+        self.staged_empty_label.setWordWrap(True)
+        staged_layout.addWidget(self.staged_empty_label)
+        self.list_splitter.addWidget(staged)
+        self.splitter.addWidget(lists)
+        reader = QWidget()
+        reader_layout = QVBoxLayout(reader)
+        reader_layout.setContentsMargins(0, 0, 0, 0)
+        self.reader_toolbar = ReaderToolbar("Find in diff")
+        self.diff_view = DiffView()
+        self.line_menu = StagingActionMenu(self.diff_view, lambda: self.snapshot is not None and self.snapshot.fresh and not self.busy)
+        self.reader_toolbar.find_button.clicked.connect(self.diff_view.open_search)
+        self.message_splitter = QSplitter(Qt.Orientation.Vertical)
+        reader_layout.addWidget(self.message_splitter)
+        preview = QWidget()
+        preview_layout = QVBoxLayout(preview)
+        preview_layout.setContentsMargins(0, 0, 0, 0)
+        preview_layout.addWidget(self.reader_toolbar)
+        preview_layout.addWidget(self.diff_view, 1)
+        self.summary_view = QPlainTextEdit()
+        self.summary_view.setReadOnly(True)
+        self.summary_view.setAccessibleName("Submodule changes")
+        self.summary_view.hide()
+        preview_layout.addWidget(self.summary_view, 1)
+        self.message_splitter.addWidget(preview)
+        self.diff_pane = preview
+        self.diff_pane_vertical_policy = preview.sizePolicy().verticalPolicy()
+        self.emoji_pane = QWidget()
+        emoji_pane_layout = QVBoxLayout(self.emoji_pane)
+        emoji_pane_layout.setContentsMargins(0, 0, 0, 0)
+        # An ignored vertical policy lets the pane go down to a height of 0, so the keyboard can open from nothing.
+        self.emoji_pane.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Ignored)
+        self.emoji_pane.hide()
+        self.message_splitter.addWidget(self.emoji_pane)
+        self.emoji_grid: EmojiGrid | None = None
+        # Owned by the window so it is deleted with it; each frame moves height between the diff and the keyboard only.
+        self.emoji_animation = QVariantAnimation(self)
+        self.emoji_animation.setDuration(EMOJI_GRID_ANIMATION_MS)
+        self.emoji_animation.setEasingCurve(QEasingCurve.Type.OutCubic)
+        self.emoji_animation.valueChanged.connect(self._step_emoji_grid)
+        self.emoji_animation.finished.connect(self._emoji_animation_finished)
+        message = QWidget()
+        message_layout = QVBoxLayout(message)
+        message_layout.setContentsMargins(0, 0, 0, 0)
+        message_title_layout = QHBoxLayout()
+        message_title_layout.addWidget(QLabel("Commit message"))
+        message_title_layout.addSpacing(SPACING_MD)
+        self.emoji_button = QPushButton(EMOJI_KEYBOARD_TITLE)
+        self.emoji_button.setCheckable(True)
+        self.emoji_button.setToolTip(EMOJI_KEYBOARD_TOOLTIP)
+        self.emoji_button.setAccessibleName(EMOJI_KEYBOARD_TITLE)
+        self.emoji_button.toggled.connect(self.set_emoji_keyboard_open)
+        message_title_layout.addWidget(self.emoji_button)
+        message_title_layout.addStretch(1)
+        message_layout.addLayout(message_title_layout)
+        self.message_edit = QPlainTextEdit()
+        # Only the families are set, so the message keeps following the font size of the window.
+        self.message_edit.setFont(emoji_capable_font())
+        self.message_edit.setTabChangesFocus(True)
+        self.message_edit.setAccessibleName("Commit message")
+        self.message_find_edit = QLineEdit()
+        self.message_find_edit.setPlaceholderText("Find in message")
+        self.message_find_edit.setAccessibleName("Find in message")
+        self.message_find_edit.hide()
+        self.message_find_shortcut = QShortcut(QKeySequence(FIND_SHORTCUT), self.message_edit)
+        self.message_find_shortcut.setContext(Qt.ShortcutContext.WidgetShortcut)
+        self.message_find_shortcut.activated.connect(self.find_message)
+        self.message_find_edit.textChanged.connect(self._find_message_text)
+        message_layout.addWidget(self.message_find_edit)
+        message_layout.addWidget(self.message_edit, 1)
+        self.amend_checkbox = QCheckBox("Amend commit")
+        self.amend_checkbox.toggled.connect(self.amend_changed)
+        message_layout.addWidget(self.amend_checkbox)
+        self.commit_button = QPushButton("Commit")
+        self.commit_button.clicked.connect(self.commit_requested)
+        self.commit_button.setAccessibleDescription("Commit the prepared index in " + context.repository_dir)
+        self.stage_button.setAccessibleDescription("Stage selected references and files in " + context.repository_dir)
+        self.unstage_button.setAccessibleDescription("Unstage selected entries in " + context.repository_dir)
+        self.commit_push_button = QPushButton("Commit && push")
+        self.commit_push_button.setAccessibleName("Commit & push")
+        self.commit_push_button.clicked.connect(self.commit_push_requested)
+        self.message_edit.textChanged.connect(self._availability)
+        commit_actions = QHBoxLayout()
+        commit_actions.addWidget(self.commit_button)
+        commit_actions.addWidget(self.commit_push_button)
+        self.commit_reason_label = QLabel()
+        self.commit_reason_label.setWordWrap(True)
+        self.commit_reason_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.commit_reason_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse | Qt.TextInteractionFlag.TextSelectableByKeyboard)
+        self.commit_reason_label.hide()
+        commit_actions.addWidget(self.commit_reason_label, 1)
+        message_layout.addLayout(commit_actions)
+        self.message_splitter.addWidget(message)
+        self.splitter.addWidget(reader)
+        self.status_label = LineLimitedResultLabel("Reading changes…", STATUS_VISIBLE_LINE_COUNT)
+        self.status_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse | Qt.TextInteractionFlag.TextSelectableByKeyboard)
+        status_layout = QHBoxLayout()
+        status_layout.addWidget(self.status_label, 1)
+        self.detail_button = QPushButton(SharedText.RESULT_DETAILS.value)
+        self.detail_button.clicked.connect(self.show_diagnostic)
+        self.detail_button.hide()
+        status_layout.addWidget(self.detail_button)
+        layout.addLayout(status_layout)
+        for file_list in (self.unstaged_list, self.staged_list):
+            file_list.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+            file_list.itemSelectionChanged.connect(lambda file_list=file_list: self._selection_changed(file_list))
+        self.filter_edit.textChanged.connect(self._filter)
+        self.file_menu = FileResetMenu(self)
+        close_action = QAction("Close", self)
+        close_action.setShortcut("Ctrl+W")
+        close_action.triggered.connect(self.close)
+        self.addAction(close_action)
+        self.splitter_by_key = dict(zip(STAGING_PROPORTION_BY_KEY, (self.splitter, self.list_splitter, self.message_splitter), strict=True))
+        for key, splitter in self.splitter_by_key.items():
+            splitter.setChildrenCollapsible(False)
+            splitter.setHandleWidth(LAYOUT_SPACING)
+            splitter.splitterMoved.connect(lambda position, index, key=key: self.preference_requested.emit({key: self.persisted_proportion(key)}))
+        self.refresh_metrics()
+        self.apply_preference(STAGING_PROPORTION_BY_KEY)
+
+    def apply_preference(self, value_by_key: dict[str, object]) -> None:
+        """Apply synchronized pane weights, with readable defaults for malformed storage.
+
+        While the keyboard slides, the message splitter is left to the animation, which already decides its final sizes.
+        """
+        for key, splitter in self.splitter_by_key.items():
+            if key not in value_by_key:
+                continue
+            if splitter is self.message_splitter and self.emoji_animation.state() == QAbstractAnimation.State.Running:
+                continue
+            sizes = value_by_key[key]
+            default = STAGING_PROPORTION_BY_KEY[key]
+            if not isinstance(sizes, (list, tuple)) or len(sizes) != len(default) or any(type(size) is not int or size <= 0 for size in sizes):
+                sizes = default
+            # The window that saved a proportion gets it back; rescaling it again would shift the panes by a few pixels.
+            if list(sizes) == self.persisted_proportion(key):
+                continue
+            extent = splitter.width() if splitter.orientation() == Qt.Orientation.Horizontal else splitter.height()
+            weights: list[int] = []
+            for size in sizes:
+                weights.append(max(1, round(extent * size / sum(sizes))))
+            if splitter is self.message_splitter:
+                weights = self._message_pane_weights(weights)
+            with QSignalBlocker(splitter):
+                splitter.setSizes(weights)
+                splitter.setChildrenCollapsible(False)
+
+    def persisted_proportion(self, key: str) -> list[int]:
+        """Return a splitter's proportion as it is saved.
+
+        The message splitter has three panes, but its preference keeps two sizes: the upper part (diff, emoji keyboard and
+        the keyboard's handle together) and the message, so opening or closing the keyboard never changes the saved proportion.
+        """
+        sizes = self.splitter_by_key[key].sizes()
+        if key != STAGING_MESSAGE_PROPORTION_KEY:
+            return sizes
+        return [sizes[DIFF_PANE_INDEX] + sizes[EMOJI_PANE_INDEX] + self._emoji_handle_height(), sizes[MESSAGE_PANE_INDEX]]
+
+    def _emoji_handle_height(self) -> int:
+        """Return the height taken by the handle above the keyboard, which the splitter only shows while the keyboard is shown."""
+        return 0 if self.emoji_pane.isHidden() else self.message_splitter.handleWidth()
+
+    def _message_pane_weights(self, weights: list[int]) -> list[int]:
+        """Turn a saved two-size proportion into the three message splitter panes, keeping the open keyboard's height.
+
+        The open keyboard may take the whole upper part, since the diff can shrink to nothing while it is open.
+        """
+        upper_weight, message_weight = weights
+        diff_weight = max(1, upper_weight - self._emoji_handle_height())
+        emoji_height = 0 if self.emoji_pane.isHidden() else self.emoji_pane.height()
+        emoji_height = min(emoji_height, diff_weight)
+        return [diff_weight - emoji_height, emoji_height, message_weight]
+
+    def set_emoji_keyboard_open(self, visible: bool) -> None:
+        """Open or close the emoji keyboard pane of this window, sliding it between the diff and the message.
+
+        The keyboard takes its height from the diff only and gives it back when closed; the message keeps its height.
+        It opens tall enough to show every symbol, and may hide the whole diff for that: while writing with symbols the
+        user does not need the diff. A click during the slide starts again from the current height, and the button's
+        state decides where it ends.
+        """
+        self.emoji_animation.stop()
+        sizes = self.message_splitter.sizes()
+        upper_height = sizes[DIFF_PANE_INDEX] + sizes[EMOJI_PANE_INDEX]
+        current_height = 0 if self.emoji_pane.isHidden() else sizes[EMOJI_PANE_INDEX]
+        # The one-row minimum set after opening would stop the keyboard from sliding down to nothing.
+        self.emoji_pane.setMinimumHeight(0)
+        if not visible:
+            self._animate_emoji_grid(current_height, 0)
+            return
+        self._ensure_emoji_grid()
+        self._set_diff_shrinkable(True)
+        if self.emoji_pane.isHidden():
+            # Showing the pane also shows its handle; its width is taken from the diff so the message does not shrink.
+            upper_height -= self.message_splitter.handleWidth()
+            with QSignalBlocker(self.message_splitter):
+                self._set_emoji_pane_shown(True)
+                self.message_splitter.setSizes([upper_height, 0, sizes[MESSAGE_PANE_INDEX]])
+        self._animate_emoji_grid(current_height, self._emoji_grid_target_height(upper_height))
+
+    def _animate_emoji_grid(self, start_height: int, end_height: int) -> None:
+        """Start the slide of the keyboard between two heights."""
+        # Changing the values of an idle animation reports a value at its old position; that frame is not a real step.
+        with QSignalBlocker(self.emoji_animation):
+            self.emoji_animation.setStartValue(start_height)
+            self.emoji_animation.setEndValue(end_height)
+        self.emoji_animation.start()
+
+    def _step_emoji_grid(self, grid_height: int) -> None:
+        """Apply one frame of the slide: the diff absorbs the change, the message keeps its height, nothing is saved."""
+        sizes = self.message_splitter.sizes()
+        upper_height = sizes[DIFF_PANE_INDEX] + sizes[EMOJI_PANE_INDEX]
+        with QSignalBlocker(self.message_splitter):
+            self.message_splitter.setSizes([upper_height - grid_height, grid_height, sizes[MESSAGE_PANE_INDEX]])
+
+    def _emoji_animation_finished(self) -> None:
+        """Settle the keyboard once it has slid: keep at least one row when open, hide it and give its space to the diff when closed.
+
+        Hiding a pane alone would share its space between the diff and the message, so the sizes are set explicitly.
+        """
+        sizes = self.message_splitter.sizes()
+        if self.emoji_button.isChecked():
+            self.emoji_pane.setMinimumHeight(min(self.emoji_grid.row_height(EMOJI_GRID_MINIMUM_ROW_COUNT), sizes[EMOJI_PANE_INDEX]))
+            return
+        # Hiding the pane also hides its handle, whose width goes back to the diff.
+        upper_height = sizes[DIFF_PANE_INDEX] + sizes[EMOJI_PANE_INDEX] + self.message_splitter.handleWidth()
+        with QSignalBlocker(self.message_splitter):
+            self._set_emoji_pane_shown(False)
+            self._set_diff_shrinkable(False)
+            self.message_splitter.setSizes([upper_height, 0, sizes[MESSAGE_PANE_INDEX]])
+
+    def _set_emoji_pane_shown(self, shown: bool) -> None:
+        """Show or hide the keyboard pane together with its handle, so the sizes set right after count the right handles."""
+        self.emoji_pane.setVisible(shown)
+        # Workaround: the splitter shows or hides the pane's handle only when it handles the layout request that the
+        # visibility change posts. Sizes set before that count the old handles and are spread again later, which moved
+        # the diff and the message by the handle's width; handling the request now keeps the sizes exact.
+        QCoreApplication.sendPostedEvents(self.message_splitter, QEvent.Type.LayoutRequest)
+
+    def _set_diff_shrinkable(self, shrinkable: bool) -> None:
+        """Let the diff shrink to nothing while the keyboard is open, and give it back its normal minimum height once closed.
+
+        An ignored vertical size policy is what lets a splitter pane go below the minimum height of its content.
+        """
+        policy = self.diff_pane.sizePolicy()
+        policy.setVerticalPolicy(QSizePolicy.Policy.Ignored if shrinkable else self.diff_pane_vertical_policy)
+        self.diff_pane.setSizePolicy(policy)
+
+    def _ensure_emoji_grid(self) -> EmojiGrid:
+        """Build the grid on first use only, so opening the staging window never pays for its buttons."""
+        if self.emoji_grid is not None:
+            return self.emoji_grid
+        self.emoji_grid = EmojiGrid()
+        # The scroll area itself takes no Tab stop: Tab goes straight to the symbols, and the scroll bar stays a mouse control.
+        self.emoji_grid.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+        self.emoji_grid.setEnabled(not self.busy)
+        self.emoji_pane.layout().addWidget(self.emoji_grid)
+        self.emoji_grid.chosen.connect(lambda text, button: self.insert_emoji(text))
+        # The buttons are created after every other control, so without this Tab would reach them last. They are slotted in
+        # right after the submodule summary, the last control above the keyboard in the layout (Tab skips it while it is
+        # hidden), and right before the keyboard button, which already follows it: every other control keeps its place.
+        previous_widget: QWidget = self.summary_view
+        for widget in (*self.emoji_grid.buttons, self.emoji_button):
+            QWidget.setTabOrder(previous_widget, widget)
+            previous_widget = widget
+        return self.emoji_grid
+
+    def _emoji_grid_target_height(self, upper_height: int) -> int:
+        """Return the opening height of the keyboard: what its real layout needs to show every symbol at the current width, at most the whole upper part."""
+        wanted_height = self.emoji_grid.content_height_for_width(self.message_splitter.contentsRect().width())
+        return max(0, min(wanted_height, upper_height))
+
+    def insert_emoji(self, text: str) -> None:
+        """Insert a symbol where the user would have typed it.
+
+        A selection is replaced, one Undo removes exactly the symbol, and focus returns to the message with the cursor
+        just after it. The cursor interface ignores read-only mode, so a read-only message is left untouched here.
+        """
+        if self.message_edit.isReadOnly():
+            return
+        cursor = self.message_edit.textCursor()
+        cursor.beginEditBlock()
+        cursor.insertText(text)
+        cursor.endEditBlock()
+        self.message_edit.setTextCursor(cursor)
+        self.message_edit.setFocus(Qt.FocusReason.OtherFocusReason)
+
+    def load_message(self, text: str) -> None:
+        """Replace the displayed draft and leave the cursor at its end, where a symbol chosen before any click goes."""
+        self.message_edit.setPlainText(text)
+        self.message_edit.moveCursor(QTextCursor.MoveOperation.End)
+
+    def refresh_metrics(self, available: QRect | None = None) -> None:
+        """Fit the new window using native system metrics and existing screen rules."""
+        summary_font = QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont)
+        summary_font.setPointSizeF(self.font().pointSizeF())
+        self.summary_view.setFont(summary_font)
+        fit_window(self, STAGING_MIN_WIDTH, STAGING_MIN_HEIGHT, available)
+        for button, symbol in ((self.refresh_button, "refresh"), (self.stage_button, "stage"), (self.unstage_button, "unstage")):
+            button.setIcon(action_icon(symbol, self.devicePixelRatioF()))
+        for control in (self.repository_identity, self.filter_edit, self.refresh_button, self.stage_button, self.unstage_button, self.commit_button, self.commit_push_button, self.amend_checkbox, self.message_find_edit,
+                        self.emoji_button):
+            control.setMinimumHeight(control_height(control.fontMetrics().height()))
+        for reader in (self.unstaged_list, self.staged_list, self.diff_view, self.message_edit):
+            reader.setMinimumHeight(control_height(reader.fontMetrics().height()) + SPACING_MD)
+        # A few lines keep a long cause understandable while the main actions stay visible; the whole cause stays
+        # available in the copyable dialog.
+        status_metrics = self.status_label.fontMetrics()
+        self.status_label.setMaximumHeight(control_height(status_metrics.height()) + status_metrics.lineSpacing() * (STATUS_VISIBLE_LINE_COUNT - 1))
+        self.detail_button.setMinimumHeight(control_height(self.detail_button.fontMetrics().height()))
+        self.diff_view.refresh_metrics()
+
+    def show_diagnostic(self) -> None:
+        """Open the copyable details window of the already-filtered diagnostic, blocking Prepare changes until it is closed."""
+        if self.diagnostic is None:
+            return
+        dialog = ErrorDialog(self.diagnostic, self)
+        dialog.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+        open_window_modal(dialog)
+
+    def show_comparison(self, patch: bytes, entry: LocalEntry, *, complete: bool = True) -> None:
+        """Label local comparison sides without modifying the raw bytes used for line actions."""
+        self.clear_summary()
+        old_side, new_side = ("Index", "Working tree") if entry.side == StagingSide.UNSTAGED else ("HEAD", "Index")
+        old_path = entry.old_path if entry.old_path is not None else entry.path
+        new_path = entry.new_path if entry.new_path is not None else entry.path
+        labels = []
+        for side, path in ((old_side, old_path), (new_side, new_path)):
+            label = path.decode("utf-8", "replace").replace("\r", "\\r").replace("\n", "\\n")
+            labels.append(f"{side}: {label}")
+        self.diff_view.show_patch(patch, entry.label, comparison_labels=tuple(labels))
+        if complete:
+            self.reader_toolbar.status_label.setText("No content changes" if not patch else "")
+
+    def clear_summary(self) -> None:
+        """Remove the old summary before displaying another selection or patch."""
+        self.summary_view.clear()
+        self.summary_view.hide()
+        self.diff_view.show()
+        self.reader_toolbar.find_button.setEnabled(True)
+
+    def show_summary_status(self, text: str) -> None:
+        """Keep loading and failed reads literal and separate from file line actions."""
+        self.diff_view.clear()
+        self.diff_view.hide()
+        self.line_menu.bind(None)
+        self.reader_toolbar.find_button.setEnabled(False)
+        self.reader_toolbar.status_label.clear()
+        self.summary_view.setPlainText(text)
+        self.summary_view.show()
+
+    def show_summary(self, summary: SubmoduleSummary, entry: LocalEntry) -> None:
+        """Show staged commit differences or the actual files that keep an unchanged child dirty."""
+        lines = [f"Submodule {entry.path.decode('utf-8', 'replace')} Change", ""]
+        suffix = ""
+        internal_only = summary.side == StagingSide.UNSTAGED and summary.source.oid is not None and summary.source.oid == summary.target.oid and summary.reference.submodule.dirty is True
+        if internal_only:
+            commit = summary.target
+            lines.extend((f"Commit: {commit.oid} (dirty)",
+                          format_commit_date(commit.timestamp, datetime.now().astimezone()) if commit.timestamp is not None else "Unavailable",
+                          commit.subject if commit.subject is not None else f"Commit details are unavailable for {commit.oid}.", "", "Type: Dirty"))
+        else:
+            comparison_lines, suffix = commit_summary_lines(summary)
+            lines.extend(comparison_lines)
+        if summary.side == StagingSide.UNSTAGED:
+            if summary.reference.submodule.dirty:
+                lines.extend(("", "Status:"))
+                if summary.reference.internal_changes is not None:
+                    lines.extend(difference_lines(summary.reference.internal_changes))
+                else:
+                    lines.append("Internal file status is unavailable. Refresh the repository to retry.")
+                lines.extend(("", SUBMODULE_DIRTY_DESCRIPTION))
+            elif summary.reference.submodule.dirty is None:
+                lines.extend(("", "Internal changes could not be checked. Refresh the repository to retry."))
+        if summary.cause:
+            lines.extend(("", summary.cause, "Refresh the repository to retry."))
+        self.show_summary_status("\n".join(lines))
+        file_list = self.staged_list if entry.side == StagingSide.STAGED else self.unstaged_list
+        for row in range(file_list.count()):
+            item = file_list.item(row)
+            if item.data(Qt.ItemDataRole.UserRole) == entry:
+                item.setText(entry.label + suffix)
+                break
+
+    def selected_entries(self, file_list: QListWidget) -> tuple[LocalEntry, ...]:
+        """Return exact selected identities in visible row order for stable batch actions."""
+        entries: list[LocalEntry] = []
+        for row in range(file_list.count()):
+            item = file_list.item(row)
+            if item.isSelected() and not item.isHidden():
+                entries.append(item.data(Qt.ItemDataRole.UserRole))
+        return tuple(entries)
+
+    def _selection_changed(self, file_list: QListWidget) -> None:
+        """Make one list the active comparison without clearing the other list's data."""
+        entries = self.selected_entries(file_list)
+        if entries:
+            other = self.staged_list if file_list is self.unstaged_list else self.unstaged_list
+            with QSignalBlocker(other):
+                other.clearSelection()
+            self.entry_selected.emit(next(iter(entries)))
+        elif not self.selected_entries(self.unstaged_list) and not self.selected_entries(self.staged_list):
+            self._clear_preview()
+        self._availability()
+
+    def _clear_preview(self) -> None:
+        """Drop the displayed file and notify its reader that pending replies are obsolete."""
+        self.clear_summary()
+        self.diff_view.clear()
+        self.line_menu.bind(None)
+        self.reader_toolbar.status_label.setText("Select a file to view its changes.")
+        self.selection_cleared.emit()
+
+    def _availability(self) -> None:
+        """Explain protected entries while keeping valid whole-file actions available."""
+        enabled = self.snapshot is not None and self.snapshot.fresh and not self.busy
+        conflict = self.snapshot is not None and any(entry.conflict_stages for entry in self.snapshot.entries)
+        has_staging = self.snapshot is not None and any(entry.side == StagingSide.STAGED for entry in self.snapshot.entries)
+        amend = self.amend_checkbox.isChecked()
+        amend_reason = self.reason_by_action.get(OperationAction.AMEND, "")
+        self.amend_checkbox.setEnabled(enabled and not conflict and not amend_reason and self.snapshot.head_oid is not None)
+        self.amend_checkbox.setToolTip(amend_reason or ("There is no HEAD commit to amend" if self.snapshot is not None and self.snapshot.head_oid is None else "Replace the last commit using the index"))
+        self.commit_button.setText("Amend commit" if amend else "Commit")
+        commit_reason = self.reason_by_action.get(OperationAction.AMEND if amend else OperationAction.COMMIT, "")
+        push_reason = self.reason_by_action.get(OperationAction.COMMIT_PUSH, "")
+        self.commit_button.setEnabled(enabled and not conflict and not commit_reason and (self.amend_ready if amend else has_staging or self.merge_in_progress) and bool(self.message_edit.toPlainText().strip()))
+        self.commit_button.setToolTip(commit_reason)
+        self.commit_push_button.setEnabled(self.commit_button.isEnabled() and not push_reason)
+        self.commit_push_button.setToolTip(push_reason)
+        # Another operation in progress greys Commit for a reason the user cannot guess; say it next to the buttons.
+        reason_text = unavailable_reason_text({self.commit_button.text(): commit_reason, self.commit_push_button.accessibleName(): commit_reason or push_reason})
+        self.commit_reason_label.setText(reason_text)
+        self.commit_reason_label.setVisible(bool(reason_text))
+        self.message_edit.setReadOnly(self.busy)
+        # A symbol chosen during a write would change the message already captured by it; the button stays usable.
+        if self.emoji_grid is not None:
+            self.emoji_grid.setEnabled(not self.busy)
+        for button, file_list in ((self.stage_button, self.unstaged_list), (self.unstage_button, self.staged_list)):
+            entries = self.selected_entries(file_list)
+            protected = any(entry.skip_worktree or entry.conflict_stages for entry in entries)
+            actionable = any(entry.stageable for entry in entries) if button is self.stage_button else bool(entries)
+            reason = self.reason_by_action.get(OperationAction.STAGE if button is self.stage_button else OperationAction.UNSTAGE, "")
+            button.setEnabled(enabled and not reason and actionable and not protected)
+            button.setToolTip(reason or ("Resolve the selected conflict or expand its skip-worktree entry before preparing changes" if protected else SUBMODULE_NO_COMMIT_CHANGE if entries and not actionable else ""))
+
+    def show_snapshot(self, snapshot: WorktreeSnapshot | None, busy: bool, diagnostic: PreparedDiagnostic | None = None, warning: bool = False,
+                      commit_action: OperationAction | None = None) -> None:
+        """Keep unchanged native rows intact and retain selection when changed lists are rebuilt.
+
+        ``warning`` says the diagnostic is a result that needs attention, such as a commit that also holds a hook's
+        changes: its cause is drawn bold orange so it stands out. Any other text of the status bar has the ordinary look.
+        """
+        rebuild = self.snapshot is not snapshot
+        self.snapshot = snapshot
+        self.diagnostic = diagnostic
+        self.detail_button.setVisible(diagnostic is not None)
+        self.status_label.setToolTip(diagnostic.detail if diagnostic is not None else "")
+        self.busy = busy
+        if snapshot is not None:
+            for side, file_list in ((StagingSide.UNSTAGED, self.unstaged_list), (StagingSide.STAGED, self.staged_list)):
+                if not rebuild:
+                    continue
+                path_set = {entry.path for entry in self.selected_entries(file_list)}
+                scroll = file_list.verticalScrollBar().value()
+                with QSignalBlocker(file_list):
+                    file_list.clear()
+                    for entry in snapshot.entries:
+                        if entry.side != side:
+                            continue
+                        item = QListWidgetItem(status_icon(entry.status, ICON_SIDE, self.devicePixelRatioF()), entry.label)
+                        item.setData(Qt.ItemDataRole.UserRole, entry)
+                        if entry.is_gitlink and entry.side == StagingSide.STAGED:
+                            item.setToolTip("This stages the submodule commit reference. Internal file changes are not included in the parent commit.")
+                        elif entry.is_gitlink and entry.submodule.dirty:
+                            item.setToolTip(SUBMODULE_DIRTY_DESCRIPTION)
+                        file_list.addItem(item)
+                        item.setSelected(entry.path in path_set)
+                    file_list.verticalScrollBar().setValue(scroll)
+            self.status_label.setText(f"{snapshot.count} changed files" if snapshot.fresh else "Changes are not up to date")
+        if diagnostic is not None:
+            self.status_label.show_result(diagnostic.cause, ResultTone.WARNING if warning else ResultTone.NEUTRAL)
+            self.status_label.setToolTip(diagnostic.detail)
+        elif busy and self.close_requested:
+            self.status_label.setText(StagingText.WAITING_TO_CLOSE.value)
+        elif commit_action is not None and commit_action.commit_progress_text is not None:
+            self.status_label.setText(commit_action.commit_progress_text)
+        elif snapshot is not None and any(entry.conflict_stages for entry in snapshot.entries):
+            self.status_label.setText("Resolve all conflicts before preparing changes")
+        elif busy:
+            self.status_label.setText("Preparing changes…")
+        self._filter()
+        self._availability()
+
+    def _filter(self) -> None:
+        """Filter decoded labels without changing stored identity or the total count."""
+        query = self.filter_edit.text().casefold()
+        for file_list in (self.unstaged_list, self.staged_list):
+            visible_count = 0
+            for row in range(file_list.count()):
+                item = file_list.item(row)
+                item.setHidden(query not in item.text().casefold())
+                if item.isHidden():
+                    item.setSelected(False)
+                else:
+                    visible_count += 1
+            label = self.unstaged_empty_label if file_list is self.unstaged_list else self.staged_empty_label
+            label.setVisible(visible_count == 0)
+            if file_list.count():
+                label.setText("No matching files.\nChange or clear the filter to see other changes.")
+            else:
+                label.setText("No unstaged changes." if file_list is self.unstaged_list else "No staged changes.\nSelect a changed file and use Stage selected.")
+        if not self.selected_entries(self.unstaged_list) and not self.selected_entries(self.staged_list):
+            self._clear_preview()
+        self._availability()
+
+    def find_message(self) -> None:
+        """Open literal search within the draft without changing its contents."""
+        self.message_find_edit.show()
+        self.message_find_edit.setFocus()
+
+    def _find_message_text(self, text: str) -> None:
+        """Select a literal match using Qt's Unicode positions and preserve all draft bytes."""
+        if not text:
+            return
+        cursor = self.message_edit.document().find(text)
+        if not cursor.isNull():
+            self.message_edit.setTextCursor(cursor)
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        """Keep an active write's fields visible until its actual outcome is reconciled."""
+        if self.busy:
+            self.close_requested = True
+            if self.diagnostic is None:
+                self.status_label.setText(StagingText.WAITING_TO_CLOSE.value)
+            event.ignore()
+            return
+        self.closed.emit()
+        event.accept()