gitpane 1.0.0__py3-none-any.whl

gitpane/ui/reference/rename_branch_dialog.py

@@ -0,0 +1,179 @@
+"""Reproduce the Git Extensions "Rename branch" window: one row with the new name, then a Rename button."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QMargins, QRect, QSize, Qt, Signal
+from PySide6.QtWidgets import QHBoxLayout, QLabel, QLineEdit, QVBoxLayout, QWidget
+
+from gitpane.config import LOCAL_PREFIX
+from gitpane.operation.console_line import UNCHANGED_OUTCOME_STATUS_SET
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.reference.reference_edit import BranchIntent, BranchMode
+from gitpane.text.typed_text import typed_value
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.look.windows_control_look import apply_windows_button_look, apply_windows_line_edit_look
+from gitpane.ui.reference.reference_form import ReferenceFormDialog
+from gitpane.ui.widget.dialog_layout import fit_caption_column, fit_capture_control, install_plain_form_palette
+
+if TYPE_CHECKING:
+    from gitpane.operation.repository_operation import OperationOutcome
+    from gitpane.reference.reference_snapshot import ReferenceSnapshot
+
+RENAME_BRANCH_TITLE = "Rename branch"
+NEW_NAME_CAPTION = "New name"
+RENAME_BUTTON_TEXT = "Rename"
+# Client area of the Git Extensions capture, 484 x 42 inside the window borders and title bar.
+RENAME_BRANCH_CLIENT_SIZE = QSize(484, 42)
+# Measured on the capture in client pixels at 100 %, visible borders included: "New name" ink x 6-60, y 14-22; name
+# field (72, 9, 344, 23), widened with the window; Rename button (423, 8, 57, 26), 4 px from the right edge.
+NAME_FIELD_RECT = QRect(72, 9, 344, 23)
+RENAME_BUTTON_RECT = QRect(423, 8, 57, 26)
+RENAME_BUTTON_SIZE = RENAME_BUTTON_RECT.size()
+NEW_NAME_CAPTION_LEFT = 6
+# Width of the caption, from its left edge to the name field; a wider caption text widens it.
+NEW_NAME_CAPTION_WIDTH = NAME_FIELD_RECT.left() - NEW_NAME_CAPTION_LEFT
+# The row's margins: the caption's left edge, the button's top edge and its distance to the right and bottom edges.
+RENAME_BRANCH_MARGINS = QMargins(NEW_NAME_CAPTION_LEFT, RENAME_BUTTON_RECT.top(), RENAME_BRANCH_CLIENT_SIZE.width() - RENAME_BUTTON_RECT.right() - 1,
+                                 RENAME_BRANCH_CLIENT_SIZE.height() - RENAME_BUTTON_RECT.bottom() - 1)
+# The field sits 1 px lower than the button in the capture.
+NAME_FIELD_DROP = NAME_FIELD_RECT.top() - RENAME_BUTTON_RECT.top()
+# The caption's top below the button's top, fitted so that Qt's text lands on the captured ink rows (y 14-22) in the
+# Fusion style; the capture's text sits a little above the field's middle.
+CAPTION_DROP = 2
+NAME_FIELD_TO_BUTTON_SPACE = RENAME_BUTTON_RECT.left() - NAME_FIELD_RECT.right() - 1
+
+
+class RenameBranchDialog(ReferenceFormDialog):
+    """Rename one local branch, like the Git Extensions Rename branch window.
+
+    The window opens on the branch's current name, selected so typing replaces it, and only freezes a request once
+    the name differs. It needs no commit details, so opening it reads nothing beyond the references. There is no
+    Cancel button: Escape and the title bar close the window. Git's refusal or failure appears in a message box, as
+    Git Extensions shows the error of ``git branch -m``.
+    """
+
+    branch_requested = Signal(object)
+
+    def __init__(self, session_id: str, full_ref: str, target_oid: str, parent: QWidget | None = None) -> None:
+        """Build the single row of the capture, with the branch's current name selected in the field."""
+        super().__init__(session_id, parent)
+        self.intent: BranchIntent | None = None
+        self.setWindowTitle(RENAME_BRANCH_TITLE)
+        self.full_ref = full_ref
+        self.target_oid = target_oid
+        self.current_name = full_ref.removeprefix(LOCAL_PREFIX)
+        install_plain_form_palette(self)
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(RENAME_BRANCH_MARGINS)
+        layout.setSpacing(0)
+        self.caption_label = QLabel(NEW_NAME_CAPTION)
+        self.name_edit = QLineEdit(self.current_name)
+        self.name_edit.setAccessibleName(NEW_NAME_CAPTION)
+        self.caption_label.setBuddy(self.name_edit)
+        caption_column = QVBoxLayout()
+        caption_column.setContentsMargins(0, CAPTION_DROP, 0, 0)
+        caption_column.setSpacing(0)
+        caption_column.addWidget(self.caption_label)
+        caption_column.addStretch(1)
+        name_column = QVBoxLayout()
+        name_column.setContentsMargins(0, NAME_FIELD_DROP, 0, 0)
+        name_column.setSpacing(0)
+        name_column.addWidget(self.name_edit)
+        name_column.addStretch(1)
+        self.submit_button.setText(RENAME_BUTTON_TEXT)
+        self.submit_button.setEnabled(False)
+        self.apply_theme_look()
+        follow_theme(self, self.apply_theme_look)
+        layout.addLayout(caption_column)
+        layout.addLayout(name_column, 1)
+        layout.addSpacing(NAME_FIELD_TO_BUTTON_SPACE)
+        layout.addWidget(self.submit_button, 0, Qt.AlignmentFlag.AlignTop)
+        # Enter runs Rename from anywhere in the form. The role is set only once the button belongs to the dialog, so Qt
+        # records it as the dialog's main default.
+        self.submit_button.setDefault(True)
+        self.submit_button.clicked.connect(self._submit)
+        self.name_edit.textChanged.connect(self._update_intent)
+        self.resize(RENAME_BRANCH_CLIENT_SIZE)
+        # Git Extensions gives this window the same minimum and maximum height: it only grows in width.
+        self.single_row_height = RENAME_BRANCH_CLIENT_SIZE.height()
+        self.refresh_metrics()
+        self.name_edit.selectAll()
+        self.name_edit.setFocus()
+
+    def apply_theme_look(self) -> None:
+        """Lay the light or dark look of the name field and Rename, decided on the application palette; called again at each switch.
+
+        Only style sheets and palettes change: the typed name and its selection stay as they are.
+        """
+        apply_windows_line_edit_look(self.name_edit)
+        apply_windows_button_look(self.submit_button)
+
+    def fit_capture_controls(self) -> None:
+        """Give the caption and the Rename button the capture's sizes, or more when their text needs it; a wider caption moves the field right."""
+        fit_caption_column((self.caption_label,), NEW_NAME_CAPTION_WIDTH)
+        fit_capture_control(self.submit_button, RENAME_BUTTON_SIZE)
+
+    def populate(self, snapshot: ReferenceSnapshot, full_ref: str, target_oid: str) -> None:
+        """Bind the window to the references it was opened on; a name the user already typed is kept."""
+        if self.closed or self.busy or self.completed:
+            return
+        self.snapshot = snapshot
+        self.full_ref = full_ref
+        self.target_oid = target_oid
+        self._update_intent()
+
+    def _update_intent(self) -> None:
+        """Freeze the typed name into a rename request once it is not empty and differs from the current name.
+
+        The name is taken without the blanks around it; the field keeps what was typed.
+        """
+        self.intent = None
+        name = typed_value(self.name_edit.text())
+        if self.snapshot is not None and name and name != self.current_name and not self.busy and not self.completed:
+            try:
+                self.intent = BranchIntent.capture(self.snapshot, self.target_oid, session_id=self.session_id, name=name, mode=BranchMode.RENAME, full_ref=self.full_ref)
+            except ValueError:
+                self.intent = None
+        self.submit_button.setToolTip("")
+        self.submit_button.setEnabled(self.intent is not None and not self.closed)
+
+    def _submit(self) -> None:
+        """Freeze the form and hand its request to the reference form controller once."""
+        if self.closed or self.busy or self.completed or self.intent is None or not self.submit_button.isEnabled():
+            return
+        self.busy = True
+        self.name_edit.setEnabled(False)
+        self.submit_button.setEnabled(False)
+        self.branch_requested.emit(self.intent)
+
+    def show_outcome(self, outcome: OperationOutcome) -> None:
+        """Close after a successful rename; otherwise explain Git's answer in a message box.
+
+        A refused or failed rename left the branch as it was, so the typed name stays editable for another try. After
+        a partial or unknown result the branch may already carry the new name, so the form only shows what was asked.
+        """
+        self.busy = False
+        if outcome.status == OperationStatus.SUCCESS:
+            self.accept()
+            return
+        if outcome.status in UNCHANGED_OUTCOME_STATUS_SET:
+            self.name_edit.setEnabled(True)
+            self._update_intent()
+        else:
+            self.completed = True
+            self.name_edit.setEnabled(False)
+        self.show_error(outcome_text(outcome))
+
+
+def outcome_text(outcome: OperationOutcome) -> str:
+    """Write each step's result and Git's diagnostic, one per line, for the message box of an unsuccessful rename."""
+    lines: list[str] = []
+    for step in outcome.steps:
+        lines.append(step.operation + ": " + step.status.value + " — " + step.effect)
+    if outcome.diagnostic is not None:
+        lines.append(outcome.diagnostic.detail)
+    if not lines:
+        lines.append(RENAME_BRANCH_TITLE + ": " + outcome.status.value)
+    return "\n".join(lines)

gitpane/ui/reference/reset_branch_dialog.py

@@ -0,0 +1,430 @@
+"""Reproduce the Git Extensions "Reset branch" window (Reset another branch to here): a local branch, the commit box, two options."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QMargins, QRect, QSignalBlocker, QSize, Qt, Signal
+from PySide6.QtWidgets import QApplication, QComboBox, QHBoxLayout, QLabel, QPushButton, QStyle, QVBoxLayout, QWidget
+
+from gitpane.config import COMMIT_METADATA_UNAVAILABLE, OK_BUTTON_TEXT, fit_window
+from gitpane.operation.console_line import UNCHANGED_OUTCOME_STATUS_SET
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.reference.reference_edit import BranchIntent, BranchMode
+from gitpane.reference.reference_snapshot import short_reference_name
+from gitpane.ui.look.theme_color import is_dark_palette
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.look.windows_control_look import WINDOWS_BUTTON_BORDER_WIDTH, WINDOWS_BUTTON_DISABLED_BORDER_COLOR, apply_windows_button_look, apply_windows_combo_look, windows_button_style_sheet
+from gitpane.ui.reference.commit_summary import GIT_EXTENSIONS_COMPACT_LAST_ROW_HEIGHT, CommitSummary
+from gitpane.ui.reference.reference_form import ReferenceFormDialog
+from gitpane.ui.widget.dialog_layout import install_plain_form_palette
+from gitpane.ui.widget.long_text import ElidedCheckBox
+from gitpane.ui.widget.standard_icon_label import StandardIconLabel
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from datetime import datetime
+
+    from gitpane.history.repository_value import Commit
+    from gitpane.operation.repository_operation import OperationOutcome
+    from gitpane.reference.reference_snapshot import ReferenceSnapshot
+
+RESET_BRANCH_TITLE = "Reset branch"
+WARNING_FIRST_LINE = "You can only reset a branch safely if there is a direct path from it to selected revision."
+WARNING_SECOND_LINE = "Forcing a branch to reset if it has not been merged might leave some commits unreachable."
+RESET_LOCAL_BRANCH_CAPTION = "Reset local branch:"
+CHECKOUT_AFTER_RESET_LABEL = "Checkout branch after reset"
+FORCE_RESET_LABEL = "Force reset for a non-fast-forward reset"
+CANCEL_BUTTON_TEXT = "Cancel"
+NO_AVAILABLE_BRANCH_CAUSE = "No other available local branches"
+NON_FAST_FORWARD_CAUSE = "This reset is not a fast-forward. Check Force reset to continue."
+# A disabled OK turns this red while the chosen reset is not a fast-forward and Force is unchecked, so the user sees
+# why OK cannot be pressed. GitPane shows this state since its first Reset branch window; the capture, taken without a
+# chosen branch, does not show it.
+NON_FAST_FORWARD_BUTTON_COLOR = "#ff8080"
+NON_FAST_FORWARD_BUTTON_TEXT_COLOR = "#000000"
+# The border makes Qt fill the whole face with the red in a dark theme too, where the native button would only tint it.
+NON_FAST_FORWARD_BUTTON_STYLE = (f" QPushButton:disabled {{ background-color: {NON_FAST_FORWARD_BUTTON_COLOR}; color: {NON_FAST_FORWARD_BUTTON_TEXT_COLOR};"
+                                 f" border: {WINDOWS_BUTTON_BORDER_WIDTH}px solid {WINDOWS_BUTTON_DISABLED_BORDER_COLOR}; }}")
+# Client area of the Git Extensions capture, 545 x 347 inside the window borders and title bar.
+RESET_BRANCH_CLIENT_SIZE = QSize(545, 347)
+# Measured on the capture in client pixels at 100 %, visible borders included: warning icon 16 x 16 at (16, 16) and
+# its two text lines from x 41, ink y 16-42; "Reset local branch:" ink x 17-114, y 58-66; branch list
+# (19, 73, 507, 23); commit frame (12, 108, 521, 141) with its title ink from x 21; check box squares at (14, 256) and
+# (14, 281); OK (342, 307, 89, 23) and Cancel (439, 307, 89, 23), 8 px apart, 17 px from the right and bottom edges.
+WARNING_ICON_RECT = QRect(16, 16, 16, 16)
+WARNING_TEXT_LEFT = 40
+RESET_BRANCH_LIST_RECT = QRect(19, 73, 507, 23)
+COMMIT_FRAME_RECT = QRect(12, 108, 521, 141)
+CHECK_BOX_LEFT = 14
+OK_BUTTON_RECT = QRect(342, 307, 89, 23)
+CANCEL_BUTTON_RECT = QRect(439, 307, 89, 23)
+RESET_BUTTON_SIZE = OK_BUTTON_RECT.size()
+BUTTON_SPACING = CANCEL_BUTTON_RECT.left() - OK_BUTTON_RECT.right() - 1
+# The body runs from the commit frame's left edge to its right edge; the buttons end 17 px above the bottom edge.
+RESET_BRANCH_MARGINS = QMargins(COMMIT_FRAME_RECT.left(), 0, RESET_BRANCH_CLIENT_SIZE.width() - COMMIT_FRAME_RECT.right() - 1,
+                                RESET_BRANCH_CLIENT_SIZE.height() - OK_BUTTON_RECT.bottom() - 1)
+# Rows measured from the body's left edge.
+WARNING_ICON_INDENT = WARNING_ICON_RECT.left() - COMMIT_FRAME_RECT.left()
+WARNING_ICON_TO_TEXT_SPACE = WARNING_TEXT_LEFT - WARNING_ICON_RECT.right() - 1
+# A label writes its text about 1 px after its own left edge, so the caption starts 1 px left of its captured ink at x 17.
+CAPTION_LEFT = 16
+RESET_BRANCH_CAPTION_INDENT = CAPTION_LEFT - COMMIT_FRAME_RECT.left()
+BRANCH_LIST_INDENT = RESET_BRANCH_LIST_RECT.left() - COMMIT_FRAME_RECT.left()
+CHECK_BOX_INDENT = CHECK_BOX_LEFT - COMMIT_FRAME_RECT.left()
+BUTTON_ROW_RIGHT_INDENT = RESET_BRANCH_CLIENT_SIZE.width() - CANCEL_BUTTON_RECT.right() - 1 - RESET_BRANCH_MARGINS.right()
+# Vertical positions, fitted so that Qt's text, list, frame and squares land where the capture has them in the Fusion
+# style: the warning text's top row, then the spaces between the rows below it.
+WARNING_TEXT_TOP = 12
+WARNING_ICON_DROP = WARNING_ICON_RECT.top() - WARNING_TEXT_TOP
+WARNING_TO_CAPTION_SPACE = 10
+CAPTION_TO_BRANCH_LIST_SPACE = 3
+BRANCH_LIST_TO_FRAME_SPACE = 3
+FRAME_TO_CHECKOUT_SPACE = 4
+CHECKOUT_TO_FORCE_SPACE = 4
+
+
+class ResetOtherBranchDialog(ReferenceFormDialog):
+    """Move another local branch to a commit, and optionally check it out, like the Git Extensions Reset branch window.
+
+    The window freezes a request once a branch is chosen. Whether that reset is a fast-forward is asked through
+    ``ancestry_requested`` the first time each branch is chosen; the reference form controller answers from the graph in memory
+    when it can, and from Git otherwise. A reset that is not a fast-forward needs Force, and the disabled OK turns red
+    until Force is checked. Checkout branch after reset starts checked at every opening. Git still checks the
+    fast-forward itself when the reset starts, so the answer shown here only drives the form.
+    """
+
+    branch_requested = Signal(object)
+    ancestry_requested = Signal(str, str)
+
+    def __init__(self, session_id: str, target_oid: str, parent: QWidget | None = None, *, clock: Callable[[], datetime] | None = None) -> None:
+        """Build the warning, the branch list, the commit box, the two check boxes and the OK and Cancel buttons of the capture.
+
+        ``clock`` dates the commit box, which reads the system time when it is absent.
+        """
+        super().__init__(session_id, parent)
+        self.intent: BranchIntent | None = None
+        self.setWindowTitle(RESET_BRANCH_TITLE)
+        self.target_oid = target_oid
+        self.full_ref = ""
+        # The local branches the reference form controller offered, in the list's order.
+        self.candidate_refs: tuple[str, ...] = ()
+        # Whether resetting each branch already checked is a fast-forward, and the branches still waiting for the answer.
+        self.ancestry_by_ref: dict[str, bool] = {}
+        self.pending_ancestry_set: set[str] = set()
+        # True once the commit box shows the target's subject, author and date; OK waits for it.
+        self.metadata_ready = False
+        # Set when Git could not read the target commit: a branch is never reset to a commit nobody could show.
+        self.metadata_failed = False
+        # Whether OK currently carries the red non-fast-forward look, so its style sheet is only rewritten on a change.
+        self.blocked_look = False
+        install_plain_form_palette(self)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(RESET_BRANCH_MARGINS)
+        layout.setSpacing(0)
+        layout.addSpacing(WARNING_TEXT_TOP)
+        layout.addLayout(self._warning_row())
+        layout.addSpacing(WARNING_TO_CAPTION_SPACE)
+        self.caption_label = QLabel(RESET_LOCAL_BRANCH_CAPTION)
+        layout.addLayout(self._indented_row(self.caption_label, RESET_BRANCH_CAPTION_INDENT))
+        layout.addSpacing(CAPTION_TO_BRANCH_LIST_SPACE)
+        self.branch_selector = QComboBox()
+        self.branch_selector.setAccessibleName(RESET_LOCAL_BRANCH_CAPTION.removesuffix(":"))
+        # The list takes the width the window gives it, whatever the length of the branch names.
+        self.branch_selector.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
+        self.branch_selector.setMinimumContentsLength(1)
+        self.caption_label.setBuddy(self.branch_selector)
+        branch_row = QHBoxLayout()
+        branch_row.setContentsMargins(BRANCH_LIST_INDENT, 0, RESET_BRANCH_CLIENT_SIZE.width() - RESET_BRANCH_LIST_RECT.right() - 1 - RESET_BRANCH_MARGINS.right(), 0)
+        branch_row.addWidget(self.branch_selector)
+        layout.addLayout(branch_row)
+        layout.addSpacing(BRANCH_LIST_TO_FRAME_SPACE)
+        # The v6.0 commit box: its last row is as high as the others and long values are cut instead of wrapped.
+        self.commit_summary = CommitSummary(target_oid, git_extensions_look=True, last_row_height=GIT_EXTENSIONS_COMPACT_LAST_ROW_HEIGHT, single_line=True, clock=clock)
+        layout.addWidget(self.commit_summary)
+        layout.addSpacing(FRAME_TO_CHECKOUT_SPACE)
+        # Checked at every opening and never remembered, unlike Git Extensions, whose capture shows it unchecked.
+        self.checkout_checkbox = ElidedCheckBox(CHECKOUT_AFTER_RESET_LABEL, open_whole=True)
+        self.checkout_checkbox.setChecked(True)
+        layout.addLayout(self._indented_row(self.checkout_checkbox, CHECK_BOX_INDENT, stretch=True))
+        layout.addSpacing(CHECKOUT_TO_FORCE_SPACE)
+        self.force_checkbox = ElidedCheckBox(FORCE_RESET_LABEL, open_whole=True)
+        layout.addLayout(self._indented_row(self.force_checkbox, CHECK_BOX_INDENT, stretch=True))
+        layout.addStretch(1)
+        self.submit_button.setText(OK_BUTTON_TEXT)
+        self.submit_button.setEnabled(False)
+        self.cancel_button = QPushButton(CANCEL_BUTTON_TEXT)
+        # Only OK may be the default button; see the Enter handling of the reference forms.
+        self.cancel_button.setAutoDefault(False)
+        button_row = QHBoxLayout()
+        button_row.setContentsMargins(0, 0, BUTTON_ROW_RIGHT_INDENT, 0)
+        button_row.setSpacing(BUTTON_SPACING)
+        button_row.addStretch(1)
+        button_row.addWidget(self.submit_button)
+        button_row.addWidget(self.cancel_button)
+        layout.addLayout(button_row)
+        self.apply_theme_look()
+        follow_theme(self, self.apply_theme_look)
+        # Enter runs OK from anywhere in the form. The role is set only once the button belongs to the dialog, so Qt
+        # records it as the dialog's main default.
+        self.submit_button.setDefault(True)
+        self.submit_button.clicked.connect(self._submit)
+        self.cancel_button.clicked.connect(self.reject)
+        self.branch_selector.currentIndexChanged.connect(self._branch_changed)
+        self.checkout_checkbox.toggled.connect(self._update_intent)
+        self.force_checkbox.toggled.connect(self._update_intent)
+        self.resize(RESET_BRANCH_CLIENT_SIZE)
+        self.refresh_metrics()
+        self.branch_selector.setFocus()
+
+    def apply_theme_look(self) -> None:
+        """Lay the light or dark look of the branch list, OK and Cancel, decided on the application palette; called again at each switch.
+
+        Git Extensions draws the branch list like a field one can type into; GitPane keeps it a plain choice among the
+        offered branches, so no typed name can reach the reset. OK keeps its red look while a reset needs Force. Only
+        style sheets and palettes change: the branch, both check boxes and whether OK can be used stay as they are.
+        """
+        apply_windows_combo_look(self.branch_selector, editable=True)
+        apply_windows_button_look(self.cancel_button)
+        self._lay_submit_button_look()
+
+    def fit_capture_controls(self) -> None:
+        """Give OK and Cancel the capture's size, or more when the system text needs it; both keep the same size.
+
+        The capture's 89 x 23 holds Windows' Segoe UI 9 pt; a larger font would cut the button text at that height.
+        """
+        size = QSize(RESET_BUTTON_SIZE)
+        for button in (self.submit_button, self.cancel_button):
+            size = size.expandedTo(button.sizeHint())
+        for button in (self.submit_button, self.cancel_button):
+            button.setFixedSize(size)
+
+    def refresh_metrics(self, available: QRect | None = None) -> None:
+        """Size the capture's controls, then keep a minimum size at which both warning sentences stay whole.
+
+        Unlike the other reference forms, Reset branch keeps a minimum size, so the user can make it neither narrow nor
+        short enough to cut a sentence of the warning shown before a forced reset, as long as the usable screen area
+        holds that minimum. The minimum is laid here, when the font, palette, density or screen changes, never while the
+        window is resized, and fit_window brings it back to the usable screen area: with a large font on a small screen
+        the minimum is relaxed, and the sentences can lose their last lines again.
+        """
+        super().refresh_metrics(available)
+        minimum = self._whole_warning_minimum_size()
+        fit_window(self, minimum.width(), minimum.height(), available)
+
+    def _whole_warning_minimum_size(self) -> QSize:
+        """Return the minimum size, taken at the capture's width, at which every row, wrapped warning sentences included, gets the height it needs.
+
+        A top-level window keeps as its minimum height the one of its layout, where each wrapped sentence counts for a
+        single line, so a narrower window would leave the sentences less height than their extra lines need. The width
+        is the capture's, or the layout's minimum when that is wider: the capture's width keeps the opening height with
+        the captures' font, and at any larger width the sentences take fewer lines, so the height asked here is enough.
+        """
+        layout = self.layout()
+        layout.activate()
+        layout_minimum = layout.totalMinimumSize()
+        width = max(RESET_BRANCH_CLIENT_SIZE.width(), layout_minimum.width())
+        height = layout_minimum.height()
+        if layout.hasHeightForWidth():
+            height = max(height, layout.totalMinimumHeightForWidth(width))
+        return QSize(width, height)
+
+    def _warning_row(self) -> QHBoxLayout:
+        """Build the warning icon and its two sentences, each wrapped onto as many lines as the window's width asks, never cut.
+
+        The sentences are prose, like the other captions of the reference forms: plain text, neither selectable nor broken
+        in the middle of a word. GitPane fits every new window to its content at its first show, wrapped texts included,
+        so the window opens tall enough for the lines the sentences take; with the captures' font each sentence holds on
+        one line, as in the capture. After the opening, the window's minimum size keeps the sentences whole however small
+        the user makes the window, as long as the usable screen area holds that minimum.
+        """
+        self.warning_icon = StandardIconLabel(WARNING_ICON_RECT.size(), QStyle.StandardPixmap.SP_MessageBoxWarning)
+        icon_column = QVBoxLayout()
+        icon_column.setContentsMargins(0, WARNING_ICON_DROP, 0, 0)
+        icon_column.addWidget(self.warning_icon)
+        icon_column.addStretch(1)
+        self.warning_labels = [QLabel(WARNING_FIRST_LINE), QLabel(WARNING_SECOND_LINE)]
+        for label in self.warning_labels:
+            label.setTextFormat(Qt.TextFormat.PlainText)
+            label.setWordWrap(True)
+        text_column = QVBoxLayout()
+        text_column.setContentsMargins(0, 0, 0, 0)
+        text_column.setSpacing(0)
+        for label in self.warning_labels:
+            text_column.addWidget(label)
+        row = QHBoxLayout()
+        row.setContentsMargins(WARNING_ICON_INDENT, 0, 0, 0)
+        row.setSpacing(WARNING_ICON_TO_TEXT_SPACE)
+        row.addLayout(icon_column)
+        row.addLayout(text_column, 1)
+        return row
+
+    def _indented_row(self, widget: QWidget, indent: int, *, stretch: bool = False) -> QHBoxLayout:
+        """Place one control this far right of the body's left edge; ``stretch`` lets it take the rest of the width."""
+        row = QHBoxLayout()
+        row.setContentsMargins(indent, 0, 0, 0)
+        row.setSpacing(0)
+        row.addWidget(widget, 1 if stretch else 0)
+        if not stretch:
+            row.addStretch(1)
+        return row
+
+    def populate(self, snapshot: ReferenceSnapshot, target_oid: str, candidate_refs: tuple[str, ...]) -> None:
+        """Offer the resettable branches of the references the window was opened on, keeping a branch the user already chose.
+
+        No branch is chosen at first, as in Git Extensions. Each new capture drops the fast-forward answers and the Force
+        consent, which were given for the previous one.
+        """
+        if self.closed or self.busy or self.completed:
+            return
+        self.snapshot = snapshot
+        self.target_oid = target_oid
+        self.candidate_refs = candidate_refs
+        self.ancestry_by_ref.clear()
+        self.pending_ancestry_set.clear()
+        with QSignalBlocker(self.force_checkbox):
+            self.force_checkbox.setChecked(False)
+        self.commit_summary.show_references(snapshot)
+        selected_ref = self.branch_selector.currentData()
+        with QSignalBlocker(self.branch_selector):
+            self.branch_selector.clear()
+            for full_ref in candidate_refs:
+                self.branch_selector.addItem(short_reference_name(full_ref), full_ref)
+                self.branch_selector.setItemData(self.branch_selector.count() - 1, full_ref, Qt.ItemDataRole.ToolTipRole)
+            self.branch_selector.setCurrentIndex(self.branch_selector.findData(selected_ref) if selected_ref else -1)
+        self.branch_selector.setEnabled(bool(candidate_refs))
+        self._show_branch_tooltip()
+        self._update_intent()
+
+    def _show_branch_tooltip(self) -> None:
+        """Show the chosen branch's full name as the list's tooltip, or why nothing can be chosen."""
+        if not self.branch_selector.count():
+            self.branch_selector.setToolTip(NO_AVAILABLE_BRANCH_CAUSE)
+            return
+        self.branch_selector.setToolTip(self.branch_selector.currentData() or "")
+
+    def _branch_changed(self) -> None:
+        """Ask for fresh Force consent after choosing another branch, then freeze the new request."""
+        with QSignalBlocker(self.force_checkbox):
+            self.force_checkbox.setChecked(False)
+        self._show_branch_tooltip()
+        self._update_intent()
+
+    def show_ancestry(self, full_ref: str, fast_forward: bool | None, cause: str = "") -> None:
+        """Record whether resetting a branch is a fast-forward, or explain why it could not be told for the chosen branch."""
+        self.pending_ancestry_set.discard(full_ref)
+        if self.closed or self.busy or self.completed:
+            return
+        if fast_forward is not None:
+            self.ancestry_by_ref[full_ref] = fast_forward
+            self._update_intent()
+            return
+        if full_ref == self.full_ref:
+            self.show_error(cause)
+
+    def show_loaded_commit(self, commit: Commit) -> None:
+        """Fill the commit box from a commit the graph already holds, without asking Git."""
+        if self.closed or commit.oid != self.commit_summary.target_oid:
+            return
+        self.commit_summary.show_loaded_commit(commit)
+        self.metadata_ready = True
+        self._update_intent()
+
+    def show_metadata(self, fields: tuple[str, ...] | None, cause: str = "") -> None:
+        """Fill the commit box from Git's answer, or refuse the target Git could not read and explain why."""
+        if self.closed:
+            return
+        if fields is None:
+            self.metadata_ready = False
+            self.metadata_failed = True
+            self.commit_summary.subject_label.setText(COMMIT_METADATA_UNAVAILABLE)
+            self._update_intent()
+            self.show_error(cause)
+            return
+        oid_field_index = 0
+        if fields[oid_field_index] != self.commit_summary.target_oid:
+            return
+        self.commit_summary.show_commit(fields)
+        self.metadata_ready = True
+        self._update_intent()
+
+    def _update_intent(self) -> None:
+        """Freeze the chosen branch and both options into the request OK would send, and ask whether it is a fast-forward.
+
+        The request exists as soon as a branch is chosen, so a reset that needs Force is still refused by the business
+        rules if it is sent without it; OK only becomes usable once the commit is shown and the reset is a fast-forward
+        or forced.
+        """
+        if self.busy or self.completed or self.closed:
+            return
+        self.intent = None
+        self.full_ref = self.branch_selector.currentData() or ""
+        fast_forward = None
+        if self.snapshot is not None and self.full_ref:
+            old_oid = self.snapshot.object_oid_by_name.get(self.full_ref)
+            fast_forward = self.ancestry_by_ref.get(self.full_ref)
+            if fast_forward is None and old_oid and self.full_ref not in self.pending_ancestry_set:
+                self.pending_ancestry_set.add(self.full_ref)
+                self.ancestry_requested.emit(self.full_ref, old_oid)
+                # The graph in memory answers at once, while the signal is still being delivered.
+                fast_forward = self.ancestry_by_ref.get(self.full_ref)
+        blocked = fast_forward is False and not self.force_checkbox.isChecked()
+        self._paint_submit_button(blocked)
+        self.submit_button.setToolTip(NON_FAST_FORWARD_CAUSE if blocked else "")
+        if self.snapshot is not None and self.full_ref and not self.metadata_failed:
+            try:
+                self.intent = BranchIntent.capture(self.snapshot, self.target_oid, session_id=self.session_id, checkout=self.checkout_checkbox.isChecked(),
+                                                   mode=BranchMode.MOVE, full_ref=self.full_ref, force_reset=self.force_checkbox.isChecked())
+            except ValueError as error:
+                self.submit_button.setToolTip(self.text_filter.redact(str(error)))
+        self.submit_button.setEnabled(self.intent is not None and self.metadata_ready and fast_forward is not None and not blocked)
+
+    def _paint_submit_button(self, blocked: bool) -> None:
+        """Turn OK red while it is disabled for a missing Force, or back to its usual look; nothing is rewritten when that does not change."""
+        if blocked == self.blocked_look:
+            return
+        self.blocked_look = blocked
+        self._lay_submit_button_look()
+
+    def _lay_submit_button_look(self) -> None:
+        """Give OK the Windows look of the light theme, or the palette's in a dark one, red while disabled for a missing Force.
+
+        The theme is the application palette's: at a switch this runs before Qt hands the new palette to the button.
+        """
+        base_style = "" if is_dark_palette(QApplication.palette()) else windows_button_style_sheet()
+        self.submit_button.setStyleSheet(base_style + (NON_FAST_FORWARD_BUTTON_STYLE if self.blocked_look else ""))
+
+    def _submit(self) -> None:
+        """Freeze the form and hand its request to the reference form controller once; Cancel stays disabled until the result."""
+        if self.closed or self.busy or self.completed or self.intent is None or not self.submit_button.isEnabled():
+            return
+        self.busy = True
+        self._set_choices_enabled(False)
+        self.submit_button.setEnabled(False)
+        self.cancel_button.setEnabled(False)
+        self.branch_requested.emit(self.intent)
+
+    def show_outcome(self, outcome: OperationOutcome) -> None:
+        """Close after a successful reset; keep the form after any other result while the console explains it.
+
+        A refused or failed reset moved nothing, so every choice stays as it was and editable for another try. After a
+        partial or unknown result the branch may have moved, so the form only shows what was asked and can be closed.
+        """
+        self.busy = False
+        self.cancel_button.setEnabled(True)
+        if outcome.status == OperationStatus.SUCCESS:
+            self.accept()
+            return
+        if outcome.status in UNCHANGED_OUTCOME_STATUS_SET:
+            self._set_choices_enabled(True)
+            self._update_intent()
+            return
+        self.completed = True
+        self._set_choices_enabled(False)
+        self.submit_button.setEnabled(False)
+
+    def _set_choices_enabled(self, enabled: bool) -> None:
+        """Enable or disable the branch list and both options together; an empty list always stays disabled."""
+        self.branch_selector.setEnabled(enabled and self.branch_selector.count() > 0)
+        self.checkout_checkbox.setEnabled(enabled)
+        self.force_checkbox.setEnabled(enabled)