gitpane 1.0.0__py3-none-any.whl

gitpane/ui/sequencer/rebase_dialog.py

@@ -0,0 +1,461 @@
+"""Display native rebase progress without owning any Git command."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QPalette
+from PySide6.QtWidgets import QAbstractItemView, QApplication, QCheckBox, QDialog, QHBoxLayout, QHeaderView, QPlainTextEdit, QPushButton, QTableWidget, QTableWidgetItem, QToolButton, QVBoxLayout, QWidget
+
+from gitpane.config import DARK_BACKGROUND_LIGHTNESS_LIMIT, ERROR_DARK_COLOR, ERROR_LIGHT_COLOR, OPERATION_HEIGHT, OPERATION_WIDTH, SHORT_OID_LENGTH, SPACING_MD, SPACING_SM
+from gitpane.operation.console_line import COMPLETED_STATUS_SET
+from gitpane.preference.preference_store import REBASE_PROMPT_PREFERENCE_KEY
+from gitpane.sequencer.rebase_state import REBASE_CONTINUABLE_STATE_SET, REBASE_STOPPED_STATE_SET, RebaseSnapshot, can_abort_rebase
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.widget.commit_date_text import format_commit_date
+from gitpane.ui.widget.content_growth import ContentGrowthMixin, OpeningFit
+from gitpane.ui.widget.content_measure import LayoutContentMeasure
+from gitpane.ui.widget.dialog_layout import content_height, fit_form
+from gitpane.ui.widget.flow_layout import FlowLayout
+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.QtCore import QRect
+
+    from gitpane.operation.operation_status import OperationStatus
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.sequencer.rebase_state import RebaseCommit, RebaseStep
+
+REBASE_COLUMN_TITLES = ("Status", "Action", "Subject", "Author", "Date", "Commit hash")
+REBASE_STATUS_COLUMN, REBASE_ACTION_COLUMN, REBASE_MESSAGE_COLUMN, REBASE_AUTHOR_COLUMN, REBASE_DATE_COLUMN, REBASE_COMMIT_COLUMN = range(len(REBASE_COLUMN_TITLES))
+REBASE_READY_LIGHT_COLOR = "#176b35"
+REBASE_READY_DARK_COLOR = "#75d69a"
+REBASE_EDIT_LIGHT_COLOR = "#b45309"
+REBASE_EDIT_DARK_COLOR = "#ffb454"
+CONFLICT_BUTTON_BACKGROUND = "#ffe59a"
+CONFLICT_BUTTON_HOVER_BACKGROUND = "#ffd166"
+CONFLICT_BUTTON_PRESSED_BACKGROUND = "#e7b53d"
+CONFLICT_BUTTON_FOREGROUND = "#332500"
+CONFLICT_BUTTON_BORDER = "#b47700"
+CONTINUE_BUTTON_BACKGROUND = "#c8efd4"
+CONTINUE_BUTTON_HOVER_BACKGROUND = "#98e0ad"
+CONTINUE_BUTTON_PRESSED_BACKGROUND = "#66c884"
+CONTINUE_BUTTON_FOREGROUND = "#153c24"
+CONTINUE_BUTTON_BORDER = "#408355"
+REBASE_ACTION_BORDER_WIDTH = 1
+REBASE_ACTION_CORNER_RADIUS = 2
+DIAGNOSTIC_VISIBLE_LINE_COUNT = 4
+TABLE_MINIMUM_ROW_COUNT = 3
+# Width the Rebase current HEAD? confirmation opens at, so its warning reads as a paragraph instead of a narrow column
+# of short lines; its height follows the wrapped text.
+REBASE_CONFIRMATION_WIDTH = 520
+REBASE_STATUS_BY_STATE = {
+    "conflict": "There are unresolved merge conflicts.",
+    "edit": "Rebase paused for editing. Amend the commit if needed, then continue.",
+    "paused": "Conflicts are resolved and staged. Continue the rebase.",
+    "intervention_required": "Rebase needs your attention. Review the diagnostics before continuing.",
+    "unknown": "Rebase state is unavailable. Refresh to try again.",
+    "external-change": "Rebase changed externally. Refresh to inspect the current state.",
+    "starting": "Rebase in progress.",
+    "absent": "Rebase finished.",
+}
+
+
+def rebase_command_sentence(status: OperationStatus) -> str:
+    """Write the result of a rebase command as the window shows it: first line of its diagnostics and, once no rebase is left, its status."""
+    return f"Rebase {status.value}."
+
+
+def step_rows_signature(state: RebaseSnapshot) -> tuple[object, ...]:
+    """Tell what the rows of the step table show of a state; two states with the same signature give the same rows."""
+    return (state.done_steps, state.current_step, state.remaining_steps, state.opaque_steps, state.fresh)
+
+
+class RebaseDialog(ContentGrowthMixin, QDialog):
+    """Show native instructions in one ordered table with explicit recovery actions.
+
+    The window has no scroll area: its height follows its own layout through the shared growth rule, so the
+    diagnostics field grows it when shown and gives the height back when hidden, while the table takes all the room
+    left above its minimum of three rows.
+    """
+
+    refresh_requested = Signal()
+    edit_todo_requested = Signal()
+    amend_requested = Signal(object)
+    continue_requested = Signal(object)
+    abort_requested = Signal(object)
+    solve_conflicts_requested = Signal()
+    commit_details_requested = Signal(object)
+    message_column = REBASE_MESSAGE_COLUMN
+
+    def __init__(self, state: RebaseSnapshot, parent: QWidget | None = None, *, clock: Callable[[], datetime] | None = None) -> None:
+        """Keep progress prominent and optional diagnostics collapsed by default.
+
+        The clock is injected so the relative dates of the step table can be reproduced, as the window gallery needs.
+        """
+        super().__init__(parent)
+        self.clock = clock or (lambda: datetime.now().astimezone())
+        self.busy = False
+        self.command_message = ""
+        # Status of the last rebase command, None before any; forgotten once a rebase is in progress again.
+        self.command_status: OperationStatus | None = None
+        self.state = state
+        self.shown_step_signature: tuple[object, ...] | None = None
+        self.current_step_raw: str | None = None
+        self.row_keys: list[tuple[str, str, int]] = []
+        self.commit_by_oid: dict[str, RebaseCommit] = {}
+        self.setWindowTitle("Rebase")
+        self.resize(OPERATION_WIDTH, OPERATION_HEIGHT)
+        layout = QVBoxLayout(self)
+        self.repository_label = WrappingLabel(state.key.git_dir)
+        self.repository_label.setWordWrap(True)
+        layout.addWidget(self.repository_label)
+        self.step_table = QTableWidget()
+        self.step_table.setAccessibleName("Rebase steps")
+        self.step_table.setColumnCount(len(REBASE_COLUMN_TITLES))
+        self.step_table.setHorizontalHeaderLabels(REBASE_COLUMN_TITLES)
+        self.step_table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.step_table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.step_table.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self.step_table.setAlternatingRowColors(True)
+        self.step_table.setWordWrap(False)
+        self.step_table.verticalHeader().hide()
+        self.step_table.horizontalHeader().setSectionResizeMode(REBASE_MESSAGE_COLUMN, QHeaderView.ResizeMode.Stretch)
+        layout.addWidget(self.step_table, 1)
+        self.status_label = WrappingLabel()
+        self.status_label.setWordWrap(True)
+        # A refusal written by Git or a hook 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.diagnostic_button = QToolButton()
+        self.diagnostic_button.setCheckable(True)
+        self.diagnostic_button.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
+        self.diagnostic_button.toggled.connect(self._toggle_diagnostic)
+        layout.addWidget(self.diagnostic_button)
+        self.diagnostic_edit = QPlainTextEdit()
+        self.diagnostic_edit.setReadOnly(True)
+        self.diagnostic_edit.setAccessibleName("Rebase diagnostics")
+        layout.addWidget(self.diagnostic_edit)
+        self._toggle_diagnostic(False)
+        self.button_flow = FlowLayout(spacing_px=SPACING_SM)
+        self.refresh_button = QPushButton("Refresh")
+        self.refresh_button.clicked.connect(self._refresh_clicked)
+        self.edit_todo_button = QPushButton("Edit rebase instructions…")
+        self.edit_todo_button.clicked.connect(self.edit_todo_requested)
+        self.amend_button = QPushButton("Amend commit…")
+        self.amend_button.clicked.connect(lambda: self.amend_requested.emit(self.state))
+        self.continue_button = QPushButton("Continue rebase")
+        self.continue_button.clicked.connect(lambda: self.continue_requested.emit(self.state))
+        self.abort_button = QPushButton("Abort")
+        self.abort_button.clicked.connect(lambda: self.abort_requested.emit(self.state))
+        self.solve_conflicts_button = QPushButton("Solve conflicts")
+        self.solve_conflicts_button.clicked.connect(self.solve_conflicts_requested)
+        self.close_button = QPushButton("Close")
+        self.close_button.clicked.connect(self.reject)
+        self.buttons = [self.refresh_button, self.edit_todo_button, self.amend_button, self.solve_conflicts_button, self.continue_button, self.abort_button, self.close_button]
+        for button in self.buttons:
+            # Enter must never trigger Abort or Continue from a table; each command stays an explicit click or Space on its focused button.
+            button.setAutoDefault(False)
+            self.button_flow.addWidget(button)
+        layout.addLayout(self.button_flow)
+        self.show_state(state)
+        self.refresh_metrics()
+        extra_row_count = max(0, self.step_table.rowCount() - TABLE_MINIMUM_ROW_COUNT)
+        initial_height = layout.totalMinimumHeightForWidth(self.width()) + extra_row_count * self.step_table.verticalHeader().defaultSectionSize()
+        self.resize(self.width(), min(OPERATION_HEIGHT, initial_height))
+        self.install_content_growth(LayoutContentMeasure(self), OpeningFit.GROW_ONLY, self.height())
+
+    def show_state(self, state: RebaseSnapshot) -> None:
+        """Retain the latest state, set labels and buttons again, and rebuild the rows only when what they show changed.
+
+        The selection is preserved unless the current instruction advances. With no rebase left, a last command that
+        did not succeed gives the status ("Rebase failed."), the sentence its diagnostics already start with: a rebase
+        that failed to start or stopped on an error leaves no state behind, and "Rebase finished." would contradict the
+        console, which reports the failure.
+        """
+        self.state = state
+        if state.state != "absent":
+            self.command_status = None
+        status = REBASE_STATUS_BY_STATE.get(state.state, "Rebase: " + state.state)
+        if state.state == "absent" and state.diagnostic:
+            status = state.diagnostic
+        elif state.state == "absent" and self.command_status is not None and self.command_status not in COMPLETED_STATUS_SET:
+            status = rebase_command_sentence(self.command_status)
+        if not state.fresh:
+            status = "State is not fresh. Refresh before taking action."
+        diagnostic_text = "\n".join(filter(None, (state.diagnostic, self.command_message)))
+        self.status_label.setText(status)
+        self.diagnostic_edit.setPlainText(diagnostic_text)
+        self.diagnostic_button.setVisible(bool(self.diagnostic_edit.toPlainText()))
+        self.diagnostic_edit.setVisible(self.diagnostic_button.isChecked() and bool(self.diagnostic_edit.toPlainText()))
+        # The state is published again at every observation. Rebuilding the table would spend time on the thread of the
+        # interface and ask the same commit details again, while the retained state must always be the last one
+        # received, because Continue and Abort send it.
+        signature = step_rows_signature(state)
+        rows_changed = signature != self.shown_step_signature
+        if rows_changed:
+            self._show_steps()
+            self.shown_step_signature = signature
+        self.set_busy(self.busy)
+        if rows_changed:
+            self.request_commit_details()
+
+    def request_commit_details(self) -> None:
+        """Ask for the author and date of every shown step.
+
+        The window shows its first state while it is built, before anybody listens to this request, so whoever
+        listens afterwards asks once here; an equal state shown later keeps its rows and does not ask again.
+        """
+        state = self.state
+        steps = state.done_steps + state.remaining_steps
+        if state.current_step is not None:
+            steps += (state.current_step,)
+        self.commit_details_requested.emit(steps)
+
+    def _refresh_clicked(self) -> None:
+        """Ask to read the rebase again, and show the rows and the commit details again even when Git gives the same steps.
+
+        Showing the details again retries a details read that failed.
+        """
+        self.shown_step_signature = None
+        self.refresh_requested.emit()
+
+    def show_commits(self, commits: tuple[RebaseCommit, ...]) -> None:
+        """Fill display-only details without changing the observed rebase generation or action state."""
+        for commit in commits:
+            self.commit_by_oid[commit.oid] = commit
+        self._show_steps()
+
+    def show_command_result(self, status: OperationStatus, cause: str = "") -> None:
+        """Retain command failures in expandable diagnostics and expose their cause immediately.
+
+        The status is kept too, so a failed command that left no rebase is not reported as finished.
+        """
+        self.command_status = status
+        self.command_message = rebase_command_sentence(status) + (" " + cause if cause else "")
+        self.show_state(self.state)
+        if cause and self.state.state != "conflict":
+            self.diagnostic_button.setChecked(True)
+
+    def set_busy(self, busy: bool) -> None:
+        """Keep all write actions disabled while another command or tool owns the worktree."""
+        self.busy = busy
+        state = self.state
+        available = not busy and state.fresh and state.identity is not None
+        self.amend_button.setEnabled(available and state.state == "edit")
+        self.continue_button.setEnabled(available and state.state in REBASE_CONTINUABLE_STATE_SET)
+        self.abort_button.setEnabled(not busy and can_abort_rebase(state))
+        self.solve_conflicts_button.setEnabled(state.fresh and state.identity is not None and state.state == "conflict")
+        self.edit_todo_button.setEnabled(available and state.identity.backend == "rebase-merge"
+                                         and state.state in REBASE_STOPPED_STATE_SET)
+        self._style_recovery()
+
+    def _show_steps(self) -> None:
+        """Keep native order and distinguish unsupported instructions without inventing their progress."""
+        table = self.step_table
+        selected_row = table.currentRow()
+        selected_key = self.row_keys[selected_row] if 0 <= selected_row < len(self.row_keys) else None
+        selected_column = max(REBASE_STATUS_COLUMN, table.currentColumn())
+        scroll_value = table.verticalScrollBar().value()
+        rows: list[tuple[str, RebaseStep]] = []
+        for step in self.state.done_steps:
+            rows.append(("Dropped" if step.action == "drop" else "Applied", step))
+        current_row = len(rows) if self.state.current_step is not None else None
+        current_raw = self.state.current_step.raw if self.state.current_step is not None else None
+        if self.state.current_step is not None:
+            rows.append(("Applying…", self.state.current_step))
+        for step in self.state.remaining_steps:
+            rows.append(("Remaining", step))
+        for step in self.state.opaque_steps:
+            rows.append(("Unknown", step))
+        commit_by_oid: dict[str, RebaseCommit] = {}
+        abbreviation_length_set = set()
+        for _status, step in rows:
+            if step.oid:
+                abbreviation_length_set.add(len(step.oid))
+        for commit in self.commit_by_oid.values():
+            for length in abbreviation_length_set:
+                commit_by_oid[commit.oid[:length]] = commit
+        now = self.clock()
+        table.blockSignals(True)
+        table.clearContents()
+        table.setRowCount(len(rows))
+        self.row_keys = []
+        occurrence_by_key: dict[tuple[str, str], int] = {}
+        restored_row = None
+        for row, (status, step) in enumerate(rows):
+            key = (status, step.raw)
+            occurrence = occurrence_by_key.get(key, 0)
+            occurrence_by_key[key] = occurrence + 1
+            row_key = (status, step.raw, occurrence)
+            self.row_keys.append(row_key)
+            commit = commit_by_oid.get(step.oid)
+            date = format_commit_date(commit.author_timestamp, now, relative_only=True) if commit is not None else "—"
+            author = commit.author_name if commit is not None else "—"
+            texts = (status, step.action, step.message, author, date, step.oid[:SHORT_OID_LENGTH])
+            for column, text in enumerate(texts):
+                item = QTableWidgetItem(text)
+                tooltip = text
+                if column == REBASE_DATE_COLUMN and commit is not None:
+                    tooltip = format_commit_date(commit.author_timestamp, now)
+                elif column == REBASE_COMMIT_COLUMN:
+                    tooltip = commit.oid if commit is not None else step.oid
+                elif column == REBASE_STATUS_COLUMN and (step.opaque or not self.state.fresh):
+                    tooltip = "Execution state unknown." if step.opaque else "Last observed state; refresh to verify progress."
+                item.setToolTip(tooltip)
+                font = item.font()
+                font.setBold(row == current_row)
+                item.setFont(font)
+                table.setItem(row, column, item)
+            if row_key == selected_key:
+                restored_row = row
+        current_changed = current_raw != self.current_step_raw
+        self.current_step_raw = current_raw
+        target_row = current_row if current_changed or restored_row is None else restored_row
+        if target_row is not None:
+            table.setCurrentCell(target_row, selected_column)
+        elif rows:
+            first_row = 0
+            table.setCurrentCell(first_row, selected_column)
+        table.blockSignals(False)
+        if current_changed and current_row is not None:
+            table.scrollToItem(table.item(current_row, REBASE_STATUS_COLUMN), QAbstractItemView.ScrollHint.PositionAtCenter)
+        else:
+            table.verticalScrollBar().setValue(scroll_value)
+
+    def _toggle_diagnostic(self, expanded: bool) -> None:
+        """Reveal command diagnostics only when requested, without a second instruction display.
+
+        The window follows the field both ways through the shared growth rule: showing it grows the window until no
+        row covers its neighbour, hiding it brings back the height the window had before.
+        """
+        self.diagnostic_button.setText("Hide diagnostics" if expanded else "Show diagnostics")
+        self.diagnostic_button.setArrowType(Qt.ArrowType.DownArrow if expanded else Qt.ArrowType.RightArrow)
+        self.diagnostic_edit.setVisible(expanded)
+
+    def _style_action_button(self, button: QPushButton, *, active: bool, background: str, hover_background: str, pressed_background: str, foreground: str, border: str) -> None:
+        """Share normal button sizing and pointer feedback across highlighted recovery actions."""
+        button_style = (f"QPushButton {{ background-color: {background}; color: {foreground}; "
+                        f"border: {REBASE_ACTION_BORDER_WIDTH}px solid {border}; border-radius: {REBASE_ACTION_CORNER_RADIUS}px; padding: 0 {SPACING_SM}px; }}"
+                        f"QPushButton:hover {{ background-color: {hover_background}; }}"
+                        f"QPushButton:pressed {{ background-color: {pressed_background}; }}"
+                        "QPushButton:focus { border-style: dashed; }") if active else ""
+        if button.styleSheet() != button_style:
+            button.setStyleSheet(button_style)
+
+    def _style_recovery(self) -> None:
+        """Highlight edit pauses, conflict resolution and readiness to continue after staging."""
+        conflict = self.solve_conflicts_button.isEnabled()
+        ready = self.state.state == "paused" and self.continue_button.isEnabled()
+        self._style_action_button(self.solve_conflicts_button, active=conflict, background=CONFLICT_BUTTON_BACKGROUND, hover_background=CONFLICT_BUTTON_HOVER_BACKGROUND,
+                                  pressed_background=CONFLICT_BUTTON_PRESSED_BACKGROUND, foreground=CONFLICT_BUTTON_FOREGROUND, border=CONFLICT_BUTTON_BORDER)
+        self._style_action_button(self.continue_button, active=ready, background=CONTINUE_BUTTON_BACKGROUND, hover_background=CONTINUE_BUTTON_HOVER_BACKGROUND,
+                                  pressed_background=CONTINUE_BUTTON_PRESSED_BACKGROUND, foreground=CONTINUE_BUTTON_FOREGROUND, border=CONTINUE_BUTTON_BORDER)
+        dark = self.palette().color(QPalette.ColorRole.Window).lightnessF() < DARK_BACKGROUND_LIGHTNESS_LIMIT
+        status_style = ""
+        if conflict:
+            color = ERROR_DARK_COLOR if dark else ERROR_LIGHT_COLOR
+            status_style = f"color: {color}; font-weight: bold;"
+        elif ready:
+            color = REBASE_READY_DARK_COLOR if dark else REBASE_READY_LIGHT_COLOR
+            status_style = f"color: {color}; font-weight: bold;"
+        elif self.amend_button.isEnabled():
+            color = REBASE_EDIT_DARK_COLOR if dark else REBASE_EDIT_LIGHT_COLOR
+            status_style = f"color: {color}; font-weight: bold;"
+        if self.status_label.styleSheet() != status_style:
+            self.status_label.setStyleSheet(status_style)
+
+    def refresh_metrics(self, available: QRect | None = None) -> None:
+        """Give the table all remaining space and keep actions reachable at large font sizes."""
+        table = self.step_table
+        metrics = table.fontMetrics()
+        row_height = metrics.height() + SPACING_SM
+        table.verticalHeader().setDefaultSectionSize(row_height)
+        table.setMinimumHeight(row_height * TABLE_MINIMUM_ROW_COUNT + table.horizontalHeader().sizeHint().height() + table.frameWidth() * 2 + table.horizontalScrollBar().sizeHint().height())
+        for column, sample in ((REBASE_STATUS_COLUMN, "Applying…"), (REBASE_ACTION_COLUMN, "reword"), (REBASE_AUTHOR_COLUMN, "Author name here"), (REBASE_DATE_COLUMN, "12 months ago"), (REBASE_COMMIT_COLUMN, "a" * SHORT_OID_LENGTH)):
+            table.setColumnWidth(column, metrics.horizontalAdvance(sample) + SPACING_MD)
+        self.diagnostic_edit.setFixedHeight(metrics.height() * DIAGNOSTIC_VISIBLE_LINE_COUNT + SPACING_MD)
+        self._style_recovery()
+        fit_form(self, available)
+
+
+class RebaseConfirmation(ContentGrowthMixin, QDialog):
+    """Confirm rewriting the captured HEAD onto the selected graph target once.
+
+    The window has no scroll area: its height follows its own layout through the shared growth rule, so an error line
+    grows it to show every line and gives the height back once the line is empty.
+    """
+
+    submit_requested = Signal()
+
+    def __init__(self, source: str, target: str, parent: QWidget | None = None, *, preference: PreferenceStore | None = None) -> None:
+        """Name both endpoints in plain text while keeping cancellation non-writing."""
+        super().__init__(parent)
+        self.preference = preference
+        self.submitting = False
+        self.cancelled = False
+        self.rejected.connect(self._cancel)
+        self.setWindowTitle("Rebase current HEAD?")
+        layout = QVBoxLayout(self)
+        # Wrapping labels break the long commit IDs and branch names too, and report the height their text needs at
+        # the width they get, so the window can grow to show every line.
+        self.message_label = WrappingLabel(f"Rebase {source} onto {target}? This rewrites commit history. Merge commits are flattened; merge-only resolutions may not be preserved.")
+        self.message_label.setWordWrap(True)
+        layout.addWidget(self.message_label)
+        self.dont_show_again = QCheckBox("Don't show again")
+        layout.addWidget(self.dont_show_again)
+        self.error_label = WrappingLabel()
+        self.error_label.setWordWrap(True)
+        layout.addWidget(self.error_label)
+        buttons = QHBoxLayout()
+        self.cancel_button = QPushButton("Cancel rebase")
+        self.cancel_button.clicked.connect(self.reject)
+        self.confirm_button = QPushButton("Rebase")
+        self.confirm_button.clicked.connect(self.confirm)
+        buttons.addWidget(self.cancel_button)
+        buttons.addWidget(self.confirm_button)
+        layout.addLayout(buttons)
+        self.refresh_metrics()
+        self.resize(REBASE_CONFIRMATION_WIDTH, self.height())
+        self.resize(REBASE_CONFIRMATION_WIDTH, content_height(self))
+        self.install_content_growth(LayoutContentMeasure(self), OpeningFit.GROW_ONLY, self.height())
+        follow_theme(self, self.refresh_metrics)
+
+    def confirm(self) -> None:
+        """Publish the suppression choice before requesting the captured rebase.
+
+        A choice that cannot be saved keeps the confirmation open with an error line, which the shared growth rule gives
+        room to; a new try that succeeds starts the rebase.
+        """
+        if self.submitting:
+            return
+        try:
+            if self.preference is not None:
+                self.preference.update({REBASE_PROMPT_PREFERENCE_KEY: self.dont_show_again.isChecked()})
+        except (OSError, ValueError, TypeError):
+            self.error_label.setText("Could not save this choice. The confirmation remains enabled. Fix the settings error and try again.")
+            return
+        self.submit_requested.emit()
+
+    def _cancel(self) -> None:
+        """Invalidate asynchronous validation even when confirmation was suppressed."""
+        self.cancelled = True
+
+    def refresh_metrics(self, available: QRect | None = None) -> None:
+        """Keep the confirmation readable and its errors prominent on light and dark backgrounds, again after each appearance switch.
+
+        The error color is decided on the application palette: when the palette changes, the window's own palette can
+        still be the old one.
+        """
+        dark = QApplication.palette().color(QPalette.ColorRole.Window).lightnessF() < DARK_BACKGROUND_LIGHTNESS_LIMIT
+        color = ERROR_DARK_COLOR if dark else ERROR_LIGHT_COLOR
+        error_style = f"color: {color}; font-weight: bold;"
+        if self.error_label.styleSheet() != error_style:
+            self.error_label.setStyleSheet(error_style)
+        fit_form(self, available)