gitpane 1.0.0__py3-none-any.whl

gitpane/ui/sequencer/replay_dialog.py

@@ -0,0 +1,501 @@
+"""Present the Cherry-pick or Revert form of a captured commit, from its metadata to its explicit replay choices."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QMargins, QSize, Qt, Signal
+from PySide6.QtGui import QColor, QPainter, QPalette
+from PySide6.QtWidgets import (
+    QAbstractItemView,
+    QApplication,
+    QCheckBox,
+    QDialog,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QPushButton,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from gitpane.config import ICON_SIDE, REPLAY_DIALOG_HEIGHT, REPLAY_DIALOG_WIDTH, keep_selection_visible
+from gitpane.sequencer.replay import MERGE_PARENT_MINIMUM
+from gitpane.sequencer.replay_state import ReplayKind
+from gitpane.ui.look.action_icon import action_icon
+from gitpane.ui.look.theme_color import is_dark_palette, theme_line_color
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.look.theme_palette import PALETTE_COLOR_GROUPS
+from gitpane.ui.look.windows_control_look import WINDOWS_LIST_BORDER_LIGHT_COLOR, apply_windows_button_look
+from gitpane.ui.reference.commit_summary import CommitSummary
+from gitpane.ui.reference.revision_picker import REVISION_BUTTON_SIZE, REVISION_CHOICE_NAME
+from gitpane.ui.widget.content_growth import ContentGrowthMixin, OpeningFit
+from gitpane.ui.widget.content_measure import LayoutContentMeasure
+from gitpane.ui.widget.dialog_layout import BandButtonSizing, fit_banded_form, fit_capture_control, install_banded_layout
+from gitpane.ui.widget.long_text import WrappingLabel
+from gitpane.ui.widget.scrolled_text import ScrolledText
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtGui import QCloseEvent, QKeyEvent, QPaintEvent
+    from PySide6.QtWidgets import QLayout
+
+    from gitpane.sequencer.replay import ReplayIntent, ReplayParent
+    from gitpane.ui.reference.revision_dialog import RevisionChoiceDialog
+
+PARENT_NUMBER_COLUMN, PARENT_MESSAGE_COLUMN, PARENT_AUTHOR_COLUMN, PARENT_DATE_COLUMN = range(4)
+PARENT_COLUMN_COUNT = 4
+# Selected row color of the merge parent list in the Git Extensions capture (light theme).
+PARENT_SELECTION_LIGHT_COLOR = "#cde8ff"
+# The merge parent list of the captures: a fixed 78 px list (two parents and some empty space, more parents scroll),
+# a 25 px header, 19 px rows, fixed number, author and date columns, and text starting a few pixels into each column.
+PARENT_TABLE_HEIGHT = 78
+PARENT_HEADER_HEIGHT = 25
+PARENT_ROW_HEIGHT = 19
+PARENT_FIXED_COLUMN_WIDTH_BY_COLUMN = {PARENT_NUMBER_COLUMN: 44, PARENT_AUTHOR_COLUMN: 120, PARENT_DATE_COLUMN: 81}
+PARENT_HEADER_TEXT_PADDING = 7
+PARENT_CELL_TEXT_PADDING = 3
+# Qt centres header text one pixel lower than the Windows list header does.
+PARENT_HEADER_TEXT_LIFT = 1
+PARENT_TABLE_FRAME_WIDTH = 1
+# Windows list colors sampled on the captures: list border, header column separators, and the faint accent-blue column
+# lines of the rows (8 % opaque, so they read #ebf4fe on white and a little darker on the selected row).
+PARENT_TABLE_FRAME_LIGHT_COLOR = WINDOWS_LIST_BORDER_LIGHT_COLOR
+PARENT_HEADER_LINE_LIGHT_COLOR = "#e5e5e5"
+PARENT_COLUMN_LINE_LIGHT_COLOR = "#140576f2"
+# Body of the forms, measured on the captures in client-area pixels: check boxes 14 px from the left, heading 11 px from
+# the top, commit frame ending 15 px from the right, 12 px under the last check box row.
+FORM_BODY_MARGINS = QMargins(14, 11, 15, 12)
+HEADING_INDENT = 3
+HEADING_TO_FRAME_SPACE = 2
+# The commit frame is indented about 10 px from the heading text.
+FRAME_INDENT = 13
+FRAME_TO_REVISION_SPACE = 11
+REVISION_ROW_RIGHT_INDENT = 4
+REVISION_CAPTION_TO_BUTTON_SPACE = 11
+# Space before the next control (merge parent caption or check boxes), after the frame or after the revision row.
+SPACE_AFTER_FRAME = 3
+SPACE_AFTER_REVISION_ROW = 6
+PARENT_CAPTION_INDENT = 3
+PARENT_CAPTION_TO_TABLE_SPACE = 6
+PARENT_TABLE_INDENT = 3
+PARENT_TABLE_TO_CHECK_SPACE = 5
+CHECK_BLOCK_TOP_SPACE = 1
+CHECK_ROW_HEIGHT = 25
+# Windows Forms button sizes of the captures: the submit buttons are wider than the standard Abort button.
+SUBMIT_BUTTON_WIDTH_BY_KIND: dict[ReplayKind, int] = {ReplayKind.CHERRY_PICK: 107, ReplayKind.REVERT: 115}
+CANCEL_BUTTON_WIDTH = 73
+FORM_BUTTON_HEIGHT = 23
+
+
+def indented(widget: QWidget, left: int, right: int = 0) -> QHBoxLayout:
+    """Wrap one control in a row that moves it in from the body edges, as the captured window positions it."""
+    row = QHBoxLayout()
+    row.setContentsMargins(left, 0, right, 0)
+    row.setSpacing(0)
+    row.addWidget(widget)
+    return row
+
+
+class ParentTable(QTableWidget):
+    """Merge parent list drawn like the Windows list view of Git Extensions, with faint column lines down to its bottom."""
+
+    def __init__(self, rows: int, columns: int) -> None:
+        """Start without column lines; the form sets their color once it knows the theme."""
+        super().__init__(rows, columns)
+        self.column_line_color: QColor | None = None
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        """Paint the rows, then the column lines over the whole list height, empty area included."""
+        super().paintEvent(event)
+        if self.column_line_color is None:
+            return
+        painter = QPainter(self.viewport())
+        painter.setPen(self.column_line_color)
+        header = self.horizontalHeader()
+        last_column = self.columnCount() - 1
+        for column in range(last_column):
+            x = header.sectionViewportPosition(column) + header.sectionSize(column) - 1
+            painter.drawLine(x, 0, x, self.viewport().height())
+
+
+class ReplayDialog(ContentGrowthMixin, QDialog):
+    """Collect one source and its explicit choices, then hand the launched operation over to the console.
+
+    The window opens at exactly the height of its content, and its height then follows that content both ways by the
+    common growth rule: an error or a merge's parent list grows it, and their leaving brings it back to its opening
+    height, or to the height the user set by hand.
+    """
+
+    replay_requested = Signal(object)
+    revision_requested = Signal()
+
+    def __init__(self, session_id: str, source_oid: str, kind: ReplayKind, parent: QWidget | None = None, *, clock: Callable[[], datetime] | None = None) -> None:
+        """Build the compact commit form with fresh defaults on each opening.
+
+        ``clock`` goes to every commit box the form builds, so the relative commit date can be reproduced, as the window
+        gallery needs; the commit boxes read the system time when it is absent.
+        """
+        super().__init__(parent)
+        self.clock = clock
+        self.session_id = session_id
+        self.source_oid = source_oid
+        self.kind = kind
+        self.intent: ReplayIntent | None = None
+        self.closed = False
+        self.busy = False
+        self.completed = False
+        self.metadata_ready = False
+        self.parents: tuple[ReplayParent, ...] = ()
+        self.source_generation = 0
+        self.revision_dialog: RevisionChoiceDialog | None = None
+        cherry_pick = kind == ReplayKind.CHERRY_PICK
+        self.setWindowTitle("Cherry pick commit" if cherry_pick else "Revert commit")
+        # The title bar keeps the GitPane icon every window shares, and no help button since there is no help to open.
+        self.setWindowFlag(Qt.WindowType.WindowContextHelpButtonHint, False)
+        # The width follows the captures; the height is fitted to the content once the form is built, then follows it.
+        self.resize(REPLAY_DIALOG_WIDTH, REPLAY_DIALOG_HEIGHT)
+        # Every distance below is measured on the Git Extensions window of the same name, so the layout adds explicit
+        # spaces instead of a uniform spacing.
+        layout = QVBoxLayout()
+        layout.setSpacing(0)
+        self.body_layout = layout
+        self.heading_label = QLabel("Cherry pick this commit:" if cherry_pick else "Revert this commit:")
+        layout.addLayout(indented(self.heading_label, HEADING_INDENT))
+        layout.addSpacing(HEADING_TO_FRAME_SPACE)
+        # The commit box reproduces the Git Extensions one: short hash in the frame line, colored reference bands.
+        self.summary = CommitSummary(source_oid, git_extensions_look=True, clock=clock)
+        self.summary_row = indented(self.summary, FRAME_INDENT)
+        layout.addLayout(self.summary_row)
+        self.revision_label = None
+        self.revision_button = None
+        if cherry_pick:
+            layout.addSpacing(FRAME_TO_REVISION_SPACE)
+            layout.addLayout(self._revision_row())
+            layout.addSpacing(SPACE_AFTER_REVISION_ROW)
+        else:
+            layout.addSpacing(SPACE_AFTER_FRAME)
+        self.parent_label = QLabel("This commit is a merge, select parent:")
+        self.parent_table = ParentTable(0, PARENT_COLUMN_COUNT)
+        self.parent_table.setHorizontalHeaderLabels(["No.", "Message", "Author", "Date"])
+        self.parent_table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.parent_table.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self.parent_table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.parent_table.setSortingEnabled(False)
+        self.parent_table.setAccessibleName("Merge parent")
+        self._use_capture_list_look()
+        self.apply_theme_look()
+        self.parent_section = QWidget()
+        parent_section_layout = QVBoxLayout(self.parent_section)
+        parent_section_layout.setContentsMargins(0, 0, 0, PARENT_TABLE_TO_CHECK_SPACE)
+        parent_section_layout.setSpacing(0)
+        parent_section_layout.addLayout(indented(self.parent_label, PARENT_CAPTION_INDENT))
+        parent_section_layout.addSpacing(PARENT_CAPTION_TO_TABLE_SPACE)
+        parent_section_layout.addLayout(indented(self.parent_table, PARENT_TABLE_INDENT, PARENT_TABLE_INDENT))
+        layout.addWidget(self.parent_section)
+        self.parent_label.hide()
+        self.parent_table.hide()
+        self.parent_section.hide()
+        self.parent_table.itemSelectionChanged.connect(self._parent_selected)
+        layout.addSpacing(CHECK_BLOCK_TOP_SPACE)
+        self.create_commit_check = QCheckBox("Automatically create a commit")
+        self.create_commit_check.setChecked(True)
+        self.add_reference_check = None
+        checks = [self.create_commit_check]
+        if cherry_pick:
+            self.add_reference_check = QCheckBox("Add commit reference to commit message")
+            checks.append(self.add_reference_check)
+        for check in checks:
+            # Windows Forms places these check boxes 25 px apart; a fixed row height keeps that pitch.
+            check.setFixedHeight(CHECK_ROW_HEIGHT)
+            layout.addWidget(check)
+        self.status_label = WrappingLabel("")
+        self.status_label.setWordWrap(True)
+        # A cause read from Git can be longer than the screen: it scrolls past the window's growth cap, so the buttons
+        # under it stay inside the window.
+        self.status_area = ScrolledText(self.status_label)
+        layout.addWidget(self.status_area)
+        self.status_area.hide()
+        self.submit_button = QPushButton("Cherry pick" if cherry_pick else "Revert this commit")
+        self.submit_button.setEnabled(False)
+        self.cancel_button = QPushButton("Abort")
+        # Only the submit button is the default one. A focused auto-default button would take that role over, and
+        # then Enter pressed from a check box would abort instead of running the replay; keyPressEvent below presses a
+        # focused button on Enter instead, as Windows does.
+        for button in (self.revision_button, self.cancel_button):
+            if button is not None:
+                button.setAutoDefault(False)
+        # Git Extensions shows these forms as a white body over a grey band holding the buttons; the form reproduces it.
+        self.button_band = install_banded_layout(self, layout, [self.submit_button, self.cancel_button], body_margins=FORM_BODY_MARGINS, button_sizing=BandButtonSizing.WINDOW)
+        # Sized once the band gave the buttons their look, which changes the room their text needs.
+        self._fit_band_buttons()
+        # Like Git Extensions, Enter runs the submit button; Qt ignores Enter while that default button is disabled,
+        # so a merge without a chosen parent cannot be submitted from the keyboard either. The role is set only now,
+        # once the button belongs to the dialog: Qt then records it as the dialog's main default and gives it back
+        # whenever the focus moves, instead of dropping it the first time the button loses the focus.
+        self.submit_button.setDefault(True)
+        self.submit_button.clicked.connect(self._submit)
+        self.cancel_button.clicked.connect(self.reject)
+        self.finished.connect(self._closed)
+        follow_theme(self, self.apply_theme_look)
+        fit_banded_form(self)
+        self.install_content_growth(LayoutContentMeasure(self), OpeningFit.EXACT, self.height())
+
+    def apply_theme_look(self) -> None:
+        """Lay everything of the form's own look that depends on the light or dark appearance; the one place that lays it again after a switch.
+
+        The revision button takes or loses its light sheet, and the merge parent list takes the frame, header, column
+        line and selection colors of the new appearance. The chosen parent, the check boxes and the commit stay as they
+        are; the commit frame already paints itself from the palette.
+        """
+        if self.revision_button is not None:
+            apply_windows_button_look(self.revision_button)
+        # Workaround: a list with a style sheet gets back, when its sheet changes, the palette it had before that sheet
+        # was laid, and the sheet copies the list's palette to its viewport. Changing the sheet alone would bring the
+        # old selection colors back, and laying them after the sheet would leave the old ones on the viewport. The old
+        # sheet is taken off first, then the selection colors are laid, then the new sheet copies them to the viewport.
+        self.parent_table.setStyleSheet("")
+        self._use_capture_selection_color()
+        self._apply_parent_table_colors()
+
+    def _fit_band_buttons(self) -> None:
+        """Give the submit and Abort buttons the capture's sizes, or more when their text needs it in the current font.
+
+        The band's height follows the buttons, so a taller button keeps the same space above and below it.
+        """
+        fit_capture_control(self.submit_button, QSize(SUBMIT_BUTTON_WIDTH_BY_KIND[self.kind], FORM_BUTTON_HEIGHT))
+        fit_capture_control(self.cancel_button, QSize(CANCEL_BUTTON_WIDTH, FORM_BUTTON_HEIGHT))
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Size the band's buttons again when the text size or the style changes."""
+        super().changeEvent(event)
+        # A style or font change can arrive while the form is still being built, before its band holds the buttons.
+        if event.type() in (QEvent.Type.FontChange, QEvent.Type.StyleChange) and hasattr(self, "button_band"):
+            self._fit_band_buttons()
+
+    def _revision_row(self) -> QLayout:
+        """Build the right-aligned "Choose another revision:" caption followed by its small icon button."""
+        self.revision_label = QLabel(REVISION_CHOICE_NAME + ":")
+        self.revision_label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+        self.revision_button = QPushButton()
+        self.revision_button.setIcon(action_icon("choose_revision", self.devicePixelRatioF()))
+        self.revision_button.setIconSize(QSize(ICON_SIDE, ICON_SIDE))
+        self.revision_button.setFixedSize(REVISION_BUTTON_SIZE)
+        self.revision_button.setAccessibleName(REVISION_CHOICE_NAME)
+        self.revision_button.setToolTip(REVISION_CHOICE_NAME)
+        self.revision_label.setBuddy(self.revision_button)
+        self.revision_button.clicked.connect(self.revision_requested)
+        self.revision_button.setEnabled(False)
+        row = QHBoxLayout()
+        row.setContentsMargins(0, 0, REVISION_ROW_RIGHT_INDENT, 0)
+        row.setSpacing(REVISION_CAPTION_TO_BUTTON_SPACE)
+        row.addWidget(self.revision_label, 1)
+        row.addWidget(self.revision_button)
+        return row
+
+    def _use_capture_list_look(self) -> None:
+        """Give the merge parent list the layout of the Windows list view of the captures: no grid, fixed header and row heights, fixed columns."""
+        table = self.parent_table
+        table.setShowGrid(False)
+        # Long authors and messages are cut character by character ("Alexander Mordvi...") like the Windows list, not at a word.
+        table.setWordWrap(False)
+        table.setVerticalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
+        table.setFixedHeight(PARENT_TABLE_HEIGHT)
+        rows = table.verticalHeader()
+        rows.hide()
+        rows.setSectionResizeMode(QHeaderView.ResizeMode.Fixed)
+        rows.setMinimumSectionSize(PARENT_ROW_HEIGHT)
+        rows.setDefaultSectionSize(PARENT_ROW_HEIGHT)
+        header = table.horizontalHeader()
+        header.setFixedHeight(PARENT_HEADER_HEIGHT)
+        header.setDefaultAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+        header.setHighlightSections(False)
+        header.setStretchLastSection(False)
+        header.setSectionResizeMode(PARENT_MESSAGE_COLUMN, QHeaderView.ResizeMode.Stretch)
+        for column, width in PARENT_FIXED_COLUMN_WIDTH_BY_COLUMN.items():
+            header.setSectionResizeMode(column, QHeaderView.ResizeMode.Fixed)
+            header.resizeSection(column, width)
+
+    def _apply_parent_table_colors(self) -> None:
+        """Give the merge parent list the colors of the captures in a light theme, lines in the theme's line grey in a dark one.
+
+        In a dark theme the frame, the header lines and the column lines all take the theme's line grey, worked out from
+        the application palette like every other line of the window, so the list's columns stay visible. Every color
+        comes from the application palette, which already holds the new colors when the appearance has just changed.
+        """
+        table = self.parent_table
+        palette = QApplication.palette()
+        base, text = palette.color(QPalette.ColorRole.Base), palette.color(QPalette.ColorRole.Text)
+        if is_dark_palette(palette):
+            frame = header_line = theme_line_color(palette)
+            table.column_line_color = frame
+        else:
+            frame, header_line = QColor(PARENT_TABLE_FRAME_LIGHT_COLOR), QColor(PARENT_HEADER_LINE_LIGHT_COLOR)
+            table.column_line_color = QColor(PARENT_COLUMN_LINE_LIGHT_COLOR)
+        # The sheet only styles the list frame and the header sections; rows keep the palette, including the selection
+        # colors set just after.
+        # No focus outline either: the Windows list shows none on an unselected row, and the selection already marks
+        # the chosen parent.
+        table.setStyleSheet(f"QTableWidget {{ border: {PARENT_TABLE_FRAME_WIDTH}px solid {frame.name()}; background-color: {base.name()}; outline: 0; }}"
+                            f" QTableWidget::item {{ padding-left: {PARENT_CELL_TEXT_PADDING}px; }}"
+                            f" QHeaderView::section {{ background-color: {base.name()}; color: {text.name()}; border: none;"
+                            f" border-right: {PARENT_TABLE_FRAME_WIDTH}px solid {header_line.name()}; padding-left: {PARENT_HEADER_TEXT_PADDING}px;"
+                            f" padding-bottom: {PARENT_HEADER_TEXT_LIFT}px; }}")
+
+    def _use_capture_selection_color(self) -> None:
+        """Select merge parents with the Git Extensions blue in a light theme, the system highlight in a dark one.
+
+        Fusion's light highlight is a saturated blue under white text; the captures use a pale blue under the normal
+        text color, in both active and inactive windows. A dark palette keeps its own readable highlight, kept visible
+        when the list does not have the focus. The selection colors of the application palette are laid first, so a
+        switch from one appearance to the other leaves none of the old ones behind.
+        """
+        application_palette = QApplication.palette()
+        palette = self.parent_table.palette()
+        for group in PALETTE_COLOR_GROUPS:
+            for role in (QPalette.ColorRole.Highlight, QPalette.ColorRole.HighlightedText):
+                palette.setColor(group, role, application_palette.color(group, role))
+        if is_dark_palette(application_palette):
+            self.parent_table.setPalette(palette)
+            keep_selection_visible(self.parent_table)
+            return
+        for group in (QPalette.ColorGroup.Active, QPalette.ColorGroup.Inactive):
+            palette.setColor(group, QPalette.ColorRole.Highlight, QColor(PARENT_SELECTION_LIGHT_COLOR))
+            palette.setColor(group, QPalette.ColorRole.HighlightedText, application_palette.color(group, QPalette.ColorRole.Text))
+        self.parent_table.setPalette(palette)
+
+    def _show_status(self, text: str) -> None:
+        """Show a cause under the choices, and give its space back when there is nothing to say."""
+        self.status_label.setText(text)
+        self.status_area.setVisible(bool(text))
+
+    def populate(self, intent: ReplayIntent, fields: tuple[str, ...], parents: tuple[ReplayParent, ...] = ()) -> None:
+        """Publish metadata only for the prepared source before submission."""
+        if self.closed or self.busy or self.completed:
+            return
+        self.intent = replace(intent, mainline_parent_number=None, mainline_parent_oid=None)
+        self.source_oid = intent.source_oid
+        if self.summary.target_oid != self.source_oid:
+            previous = self.summary
+            self.summary = CommitSummary(self.source_oid, git_extensions_look=True, clock=self.clock)
+            # replaceWidget would hand the layout item of the old commit box back to the caller: dropped, it stays
+            # allocated for as long as the application runs, one more at each change of commit, and deleting it from
+            # Python crashes once the form is deleted, since PySide still counts it as a child of the body layout.
+            # removeWidget lets Qt delete that item itself; the row holds no other widget, so the new box takes its place.
+            self.summary_row.removeWidget(previous)
+            self.summary_row.addWidget(self.summary)
+            previous.hide()
+            previous.deleteLater()
+        self.parents = parents
+        self.summary.show_commit(fields)
+        self.parent_table.setRowCount(0)
+        merge = len(parents) >= MERGE_PARENT_MINIMUM
+        if merge:
+            self.parent_table.setRowCount(len(parents))
+            for row, parent in enumerate(parents):
+                try:
+                    date_text = datetime.fromisoformat(parent.commit_date).date().isoformat()
+                except ValueError:
+                    date_text = parent.commit_date or "n/a"
+                for column, value in enumerate((str(parent.number), parent.subject or "n/a", parent.author or "n/a", date_text)):
+                    item = QTableWidgetItem(value)
+                    item.setToolTip(parent.commit_date if column == PARENT_DATE_COLUMN and parent.commit_date else value)
+                    item.setData(Qt.ItemDataRole.UserRole, parent.oid)
+                    self.parent_table.setItem(row, column, item)
+        self.parent_table.clearSelection()
+        self.parent_section.setVisible(merge)
+        self.parent_table.setVisible(merge)
+        self.parent_label.setVisible(merge)
+        self.metadata_ready = True
+        self.submit_button.setEnabled(not merge)
+        if self.revision_button is not None:
+            self.revision_button.setEnabled(True)
+        self._show_status("")
+        # Enter then runs Cherry pick or Revert this commit as in Git Extensions; a merge waits for a parent choice.
+        (self.parent_table if merge else self.submit_button).setFocus()
+
+    def _parent_selected(self) -> None:
+        """Tie the explicit row selection to its captured native parent identity."""
+        if self.intent is None or self.busy or self.completed:
+            return
+        rows = self.parent_table.selectionModel().selectedRows()
+        parent = self.parents[next(iter(rows)).row()] if rows else None
+        self.intent = replace(self.intent, mainline_parent_number=parent.number if parent else None, mainline_parent_oid=parent.oid if parent else None)
+        self.submit_button.setEnabled(self.metadata_ready and (len(self.parents) < MERGE_PARENT_MINIMUM or parent is not None))
+
+    def show_error(self, cause: str) -> None:
+        """Explain preparation failures without inventing a writable source."""
+        self._show_status(cause)
+        self.submit_button.setEnabled(False)
+
+    def _submit(self) -> None:
+        """Freeze choices before emitting one immutable write request."""
+        if self.intent is None or not self.metadata_ready or self.busy or self.completed or self.closed:
+            return
+        if len(self.parents) >= MERGE_PARENT_MINIMUM and self.intent.mainline_parent_oid is None:
+            return
+        self.intent = replace(self.intent, create_commit=self.create_commit_check.isChecked(),
+                              add_reference=self.add_reference_check is not None and self.add_reference_check.isChecked())
+        self.busy = True
+        for widget in (self.create_commit_check, self.add_reference_check, self.revision_button, self.parent_table, self.submit_button, self.cancel_button):
+            if widget is not None:
+                widget.setEnabled(False)
+        self.replay_requested.emit(self.intent)
+
+    def close_after_submission(self) -> None:
+        """Close the form once its operation is accepted; the console and the repository window take over from here.
+
+        A form left open after launch would stay window-modal over the repository window and block every later
+        choice (conflict prompt, banner, progress), so the form never waits for Git's result.
+        """
+        self.busy = False
+        self.completed = True
+        self.accept()
+
+    def show_submission_refused(self, cause: str) -> None:
+        """Give the choices back when the request was refused before any console or Git command started."""
+        self.busy = False
+        for widget in (self.create_commit_check, self.add_reference_check, self.revision_button, self.parent_table, self.cancel_button):
+            if widget is not None:
+                widget.setEnabled(True)
+        self.submit_button.setEnabled(self.metadata_ready and (len(self.parents) < MERGE_PARENT_MINIMUM or self.intent is not None and self.intent.mainline_parent_oid is not None))
+        self._show_status(cause)
+
+    def reject(self) -> None:
+        """Treat closing the idle form as cancellation without abandoning native work."""
+        if not self.busy:
+            super().reject()
+
+    def accept(self) -> None:
+        """Ignore direct acceptance or keyboard submission while native work is active."""
+        if not self.busy:
+            super().accept()
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        """Press the focused button on Enter, as Windows does; anywhere else Enter runs the default submit button."""
+        focused = self.focusWidget()
+        other_buttons = (self.revision_button, self.cancel_button)
+        if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter) and focused is not None and focused in other_buttons:
+            if focused.isEnabled():
+                focused.click()
+            return
+        super().keyPressEvent(event)
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        """Keep the captured request visible while its native process is owned."""
+        if self.busy:
+            event.ignore()
+            return
+        super().closeEvent(event)
+
+    def _closed(self) -> None:
+        """Invalidate every delayed metadata callback for this form."""
+        self.closed = True
+        self.source_generation += 1
+        if self.revision_dialog is not None:
+            self.revision_dialog.reject()