gitpane 1.0.0__py3-none-any.whl

gitpane/ui/reference/create_branch_dialog.py

@@ -0,0 +1,346 @@
+"""Reproduce the Git Extensions "Create branch" window: a name, a revision, Checkout after create, the commit box, the Orphan group."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QMargins, QRect, QSize, Qt, Signal
+from PySide6.QtWidgets import QCheckBox, QHBoxLayout, QLabel, QLineEdit, QVBoxLayout, QWidget
+
+from gitpane.config import COMMIT_METADATA_UNAVAILABLE
+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.action_icon import action_icon
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.look.windows_control_look import apply_windows_line_edit_look
+from gitpane.ui.reference.commit_summary import GIT_EXTENSIONS_COMPACT_LAST_ROW_HEIGHT, CommitSummary, GitExtensionsGroupBox
+from gitpane.ui.reference.reference_form import ReferenceFormDialog
+from gitpane.ui.reference.revision_picker import RevisionPicker
+from gitpane.ui.widget.dialog_layout import BandButtonSizing, fit_caption_column, fit_capture_control, install_banded_layout
+
+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
+
+CREATE_BRANCH_TITLE = "Create branch"
+BRANCH_NAME_CAPTION = "Branch name"
+CREATE_BRANCH_REVISION_CAPTION = "Create branch at this revision"
+CHECKOUT_AFTER_CREATE_LABEL = "Checkout after create"
+ORPHAN_GROUP_TITLE = "Orphan"
+CREATE_ORPHAN_LABEL = "Create orphan"
+CLEAR_ORPHAN_LABEL = "Clear working directory and index"
+CREATE_BRANCH_BUTTON_TEXT = "Create branch"
+# Client area of the Git Extensions capture (570 x 366 inside the window borders and title bar).
+CREATE_BRANCH_CLIENT_SIZE = QSize(570, 366)
+CREATE_BRANCH_BUTTON_SIZE = QSize(105, 23)
+# Measured on the capture in client pixels at 100 %: white body y 0-324, band line y 325, band y 326-365; "Branch name"
+# ink from x 18; name field (181, 15, 374, 23); "Create branch at this revision" ink from x 18; revision field
+# (181, 45, 313, 23) with its choose button (498, 44, 23, 22) and the "-50" ink from x 531; Checkout after create square
+# (181, 75, 13, 13); commit frame (14, 106, 542, 141); Orphan frame (15, 261, 540, 48) with its title ink from x 24,
+# Create orphan square (34, 282, 13, 13) with its text from x 53, Clear working directory and index square
+# (141, 282, 13, 13); Create branch button (451, 334, 105, 23) in the band.
+CREATE_BRANCH_NAME_FIELD_WIDTH = 374
+CREATE_BRANCH_REVISION_FIELD_WIDTH = 313
+# The body starts at the commit frame's left edge and ends at its right edge, and its first control, the name field,
+# sits 15 px from the top. The band sits at the bottom through a final stretch, so enlarging the resizable window only
+# grows the empty body.
+CREATE_BRANCH_BODY_MARGINS = QMargins(14, 15, 14, 0)
+# The captions start 3 px right of the frame's edge (a label writes its text about 1 px after its own edge) and run to
+# the fields at x 181. That width is a minimum: a caption wider in the system font widens the column and moves the
+# fields right, so no caption is cut.
+CREATE_BRANCH_CAPTION_INDENT = 3
+CAPTION_WIDTH = 164
+# Space between the name field (y 15-37) and the revision row, whose choose button is its highest control, at y 44.
+NAME_TO_REVISION_SPACE = 6
+# Space between the revision row (y 44-67) and the Checkout after create check box, whose square then lands on y 75.
+REVISION_TO_CHECKOUT_SPACE = 4
+# Space between the check box and the commit box, whose frame line then lands on y 106.
+CHECKOUT_TO_FRAME_SPACE = 4
+# The Orphan frame as painted, from the line crossing its title down to its bottom edge, in client pixels.
+ORPHAN_GROUP_RECT = QRect(15, 261, 540, 48)
+# First row below the commit box, whose frame's bottom edge is on y 246.
+COMMIT_BOX_NEXT_ROW = 247
+# Left edge of each check box square of the Orphan group, in client pixels; the style draws the square at the check
+# box's own left edge, so Create orphan is exactly as wide as the gap up to Clear.
+CREATE_ORPHAN_CHECK_LEFT = 34
+CLEAR_ORPHAN_CHECK_LEFT = 141
+# The capture only fixes Create orphan's width, the gap up to Clear; its height is its text's.
+CREATE_ORPHAN_CAPTURE_SIZE = QSize(CLEAR_ORPHAN_CHECK_LEFT - CREATE_ORPHAN_CHECK_LEFT, 0)
+# Distance from the Orphan frame line down to the check boxes, whose squares then land on y 282.
+ORPHAN_LINE_TO_CHECK_SPACE = 18
+
+
+class CreateBranchDialog(ReferenceFormDialog):
+    """Create one branch at a commit, and optionally check it out, like the Git Extensions Create branch window.
+
+    The window only freezes a creation request; the reference form controller reads the references, fills the commit box from the
+    graph in memory, resolves typed revisions and runs Git.
+    """
+
+    branch_requested = Signal(object)
+
+    def __init__(self, session_id: str, target_oid: str, parent: QWidget | None = None, *, clock: Callable[[], datetime] | None = None) -> None:
+        """Build the name and revision rows, the check box, the commit box and the button band 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(CREATE_BRANCH_TITLE)
+        # True once the commit box shows the target's subject, author and date; creation does not wait for it.
+        self.metadata_ready = False
+        # Set when Git could not read the target commit: a branch is never created on a commit nobody could show.
+        self.metadata_failed = False
+        layout = QVBoxLayout()
+        layout.setSpacing(0)
+        self.name_caption_label = self._caption(BRANCH_NAME_CAPTION)
+        self.name_edit = QLineEdit()
+        self.name_edit.setFixedWidth(CREATE_BRANCH_NAME_FIELD_WIDTH)
+        self.name_edit.setAccessibleName(BRANCH_NAME_CAPTION)
+        self.name_caption_label.setBuddy(self.name_edit)
+        name_row = self._row()
+        name_row.addWidget(self.name_caption_label, 0, Qt.AlignmentFlag.AlignVCenter)
+        name_row.addWidget(self.name_edit)
+        name_row.addStretch(1)
+        layout.addLayout(name_row)
+        layout.addSpacing(NAME_TO_REVISION_SPACE)
+        self.revision_caption_label = self._caption(CREATE_BRANCH_REVISION_CAPTION)
+        self.picker = RevisionPicker(CREATE_BRANCH_REVISION_FIELD_WIDTH)
+        self.revision_caption_label.setBuddy(self.picker.revision_edit)
+        revision_row = self._row()
+        revision_row.addWidget(self.revision_caption_label, 0, Qt.AlignmentFlag.AlignVCenter)
+        revision_row.addWidget(self.picker, 1)
+        layout.addLayout(revision_row)
+        layout.addSpacing(REVISION_TO_CHECKOUT_SPACE)
+        self.checkout_checkbox = QCheckBox(CHECKOUT_AFTER_CREATE_LABEL)
+        self.checkout_checkbox.setChecked(True)
+        # Indented by the caption column, whose width follows the captions' text.
+        self.checkout_row = QHBoxLayout()
+        self.checkout_row.setSpacing(0)
+        self.checkout_row.addWidget(self.checkout_checkbox)
+        self.checkout_row.addStretch(1)
+        layout.addLayout(self.checkout_row)
+        layout.addSpacing(CHECKOUT_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)
+        self.orphan_group = GitExtensionsGroupBox(ORPHAN_GROUP_TITLE)
+        self.orphan_checkbox = QCheckBox(CREATE_ORPHAN_LABEL)
+        # Checked by default like Git Extensions, and only usable once Create orphan is checked.
+        self.clear_checkbox = QCheckBox(CLEAR_ORPHAN_LABEL)
+        self.clear_checkbox.setChecked(True)
+        self._lay_out_orphan_group(layout)
+        layout.addStretch(1)
+        self.submit_button.setText(CREATE_BRANCH_BUTTON_TEXT)
+        self.submit_button.setIcon(action_icon("branch_create", self.devicePixelRatioF()))
+        self.submit_button.setEnabled(False)
+        # Git Extensions shows this form as a white body over a grey band holding its single button; there is no
+        # Cancel button, Escape and the title bar close it.
+        self.apply_theme_look()
+        self.button_band = install_banded_layout(self, layout, [self.submit_button], body_margins=CREATE_BRANCH_BODY_MARGINS, button_sizing=BandButtonSizing.WINDOW)
+        follow_theme(self, self.apply_theme_look)
+        # Enter runs Create branch from anywhere in the form. 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.
+        self.submit_button.setDefault(True)
+        self.submit_button.clicked.connect(self._submit)
+        self.name_edit.textChanged.connect(self._update_intent)
+        self.checkout_checkbox.toggled.connect(self._update_intent)
+        self.orphan_checkbox.toggled.connect(self._orphan_toggled)
+        self.clear_checkbox.toggled.connect(self._update_intent)
+        self._apply_orphan_rules()
+        # Connected before the reference form controller binds the field, so a new target's position is invalidated and its commit
+        # box reset before they are filled again.
+        self.picker.target_changed.connect(self._target_changed)
+        self.resize(CREATE_BRANCH_CLIENT_SIZE)
+        self.refresh_metrics()
+        self.name_edit.setFocus()
+
+    def apply_theme_look(self) -> None:
+        """Lay the light or dark look of the name field and the revision picker, decided on the application palette; called again at each switch.
+
+        The body and the band follow the switch on their own. Only style sheets and palettes change: the typed name,
+        the revision and the check boxes stay as they are.
+        """
+        apply_windows_line_edit_look(self.name_edit)
+        self.picker.apply_theme_look()
+
+    def _lay_out_orphan_group(self, layout: QVBoxLayout) -> None:
+        """Place the Orphan frame and its two check boxes where the capture has them, below the commit box.
+
+        The frame line crosses the middle of the title, a style-dependent distance below the group's top edge; that
+        distance is read from the group itself so the painted line, not the widget edge, lands on the measured row.
+        """
+        line_offset = self.orphan_group.frame_rectangle().top()
+        self.orphan_group.setFixedHeight(line_offset + ORPHAN_GROUP_RECT.height())
+        # A layout inside a group box starts at the style's content area, below the native title and inside the
+        # native frame, neither of which this painted frame has. The two check boxes are therefore placed at their
+        # measured positions inside the group instead of through a layout.
+        check_top = line_offset + ORPHAN_LINE_TO_CHECK_SPACE
+        self.orphan_checkbox.setParent(self.orphan_group)
+        self.orphan_checkbox.move(CREATE_ORPHAN_CHECK_LEFT - ORPHAN_GROUP_RECT.left(), check_top)
+        self.clear_checkbox.setParent(self.orphan_group)
+        self.clear_checkbox.move(CLEAR_ORPHAN_CHECK_LEFT - ORPHAN_GROUP_RECT.left(), check_top)
+        layout.addSpacing(ORPHAN_GROUP_RECT.top() - line_offset - COMMIT_BOX_NEXT_ROW)
+        # The Orphan frame is 1 px narrower than the commit box on each side.
+        group_row = QHBoxLayout()
+        group_row.setContentsMargins(ORPHAN_GROUP_RECT.left() - CREATE_BRANCH_BODY_MARGINS.left(), 0,
+                                     CREATE_BRANCH_CLIENT_SIZE.width() - CREATE_BRANCH_BODY_MARGINS.right() - ORPHAN_GROUP_RECT.right() - 1, 0)
+        group_row.addWidget(self.orphan_group)
+        layout.addLayout(group_row)
+
+    def fit_capture_controls(self) -> None:
+        """Give the button, the caption column and the Orphan check boxes the capture's sizes, or more when their text needs it.
+
+        With the captures' font everything keeps the capture's size and place. A wider font widens the caption column,
+        which moves both fields and the Checkout after create check box right by the same amount, widens the Create
+        branch button, and pushes Clear working directory and index right of a wider Create orphan; the window then
+        grows to its content when it is shown.
+        """
+        fit_capture_control(self.submit_button, CREATE_BRANCH_BUTTON_SIZE)
+        caption_width = fit_caption_column((self.name_caption_label, self.revision_caption_label), CAPTION_WIDTH)
+        self.checkout_row.setContentsMargins(CREATE_BRANCH_CAPTION_INDENT + caption_width, 0, 0, 0)
+        fit_capture_control(self.orphan_checkbox, CREATE_ORPHAN_CAPTURE_SIZE)
+        self.clear_checkbox.adjustSize()
+        self.clear_checkbox.move(self.orphan_checkbox.geometry().right() + 1, self.orphan_checkbox.y())
+        # Clear keeps the same distance from the frame's right edge as Create orphan has from its left edge, at least.
+        self.orphan_group.setMinimumWidth(self.clear_checkbox.geometry().right() + 1 + self.orphan_checkbox.x())
+
+    def _caption(self, text: str) -> QLabel:
+        """Build a caption of the left column; its width is set with the column's by ``fit_capture_controls``."""
+        return QLabel(text)
+
+    def _row(self) -> QHBoxLayout:
+        """Start a caption row indented from the body edge like the captured captions."""
+        row = QHBoxLayout()
+        row.setContentsMargins(CREATE_BRANCH_CAPTION_INDENT, 0, 0, 0)
+        row.setSpacing(0)
+        return row
+
+    def populate(self, snapshot: ReferenceSnapshot, target_oid: str, name: str) -> None:
+        """Show the commit and the proposed name against the references the window was opened on.
+
+        The name is selected and focused, as Git Extensions does, so typing replaces it. A name the user already
+        typed while the references were being checked is kept.
+        """
+        if self.closed or self.busy or self.completed:
+            return
+        self.snapshot = snapshot
+        self.commit_summary.show_references(snapshot)
+        if not typed_value(self.name_edit.text()):
+            self.name_edit.setText(name)
+        self.name_edit.selectAll()
+        self.name_edit.setFocus()
+        self.set_target(target_oid)
+
+    def set_target(self, oid: str, *, rewrite_text: bool = True) -> None:
+        """Target another commit; its short hash replaces the field unless the user's typed text is kept."""
+        if self.closed or self.busy or self.completed:
+            return
+        self.picker.show_revision(oid, rewrite_text=rewrite_text)
+
+    def _target_changed(self, oid: str | None) -> None:
+        """Drop the previous target's position and commit details, then freeze the new request, if any."""
+        self.position_generation += 1
+        if oid is not None and oid != self.commit_summary.target_oid:
+            self.commit_summary.retarget(oid)
+            self.metadata_ready = False
+            self.metadata_failed = False
+            if self.snapshot is not None:
+                self.commit_summary.show_references(self.snapshot)
+        self._update_intent()
+
+    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
+
+    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
+
+    def _orphan_toggled(self) -> None:
+        """Apply the Git Extensions rules of the Orphan group, then freeze the new request."""
+        self._apply_orphan_rules()
+        self._update_intent()
+
+    def _apply_orphan_rules(self) -> None:
+        """Follow Git Extensions: an orphan branch is always checked out, and only an orphan branch can clear the working directory.
+
+        Checking Create orphan checks and locks Checkout after create and frees Clear; unchecking it frees Checkout after
+        create and locks Clear, both keeping their state.
+        """
+        orphan = self.orphan_checkbox.isChecked()
+        usable = self.orphan_checkbox.isEnabledTo(self)
+        if orphan:
+            self.checkout_checkbox.setChecked(True)
+        self.checkout_checkbox.setEnabled(usable and not orphan)
+        self.clear_checkbox.setEnabled(usable and orphan)
+
+    def _update_intent(self) -> None:
+        """Freeze the typed name, the target commit and the checkout and orphan choices into the request Create branch would send.
+
+        The name is taken without the blanks around it; the field keeps what was typed.
+        """
+        self.intent = None
+        target_oid = self.picker.target_oid
+        name = typed_value(self.name_edit.text())
+        orphan = self.orphan_checkbox.isChecked()
+        if self.snapshot is not None and target_oid and name and not self.metadata_failed:
+            try:
+                self.intent = BranchIntent.capture(self.snapshot, target_oid, session_id=self.session_id, name=name,
+                                                   checkout=self.checkout_checkbox.isChecked(), mode=BranchMode.CREATE, orphan=orphan,
+                                                   clear=orphan and self.clear_checkbox.isChecked())
+            except ValueError:
+                self.intent = None
+        self.submit_button.setEnabled(self.intent is not None and not self.busy and not self.completed 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._set_controls_enabled(False)
+        self.branch_requested.emit(self.intent)
+
+    def show_outcome(self, outcome: OperationOutcome) -> None:
+        """Close after a successful creation; keep the form after any other result while the console explains it.
+
+        A refused or failed creation wrote nothing, so the name stays editable for another try; after a partial or
+        unknown result the branch may exist, so the form only shows what was asked.
+        """
+        self.busy = False
+        if outcome.status == OperationStatus.SUCCESS:
+            self.accept()
+            return
+        if outcome.status in (OperationStatus.REFUSED, OperationStatus.FAILED):
+            self._set_controls_enabled(True)
+            self._update_intent()
+            return
+        self.completed = True
+        self._set_controls_enabled(False)
+
+    def _set_controls_enabled(self, enabled: bool) -> None:
+        """Enable or disable every choice of the form together, keeping the check boxes the Orphan group locks."""
+        for widget in (self.name_edit, self.picker, self.checkout_checkbox, self.orphan_checkbox, self.clear_checkbox, self.submit_button):
+            widget.setEnabled(enabled)
+        self._apply_orphan_rules()

gitpane/ui/reference/create_tag_dialog.py

@@ -0,0 +1,283 @@
+"""Reproduce the Git Extensions "Create tag" window: a name, a revision, Push tag to '<remote>', the tag type, its message."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QMargins, QPoint, QRect, QSize, Qt, Signal
+from PySide6.QtWidgets import QComboBox, QHBoxLayout, QLabel, QLineEdit, QPlainTextEdit, QVBoxLayout, QWidget
+
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.reference.reference_edit import DEFAULT_PUSH_REMOTE_NAME, TagIntent
+from gitpane.text.typed_text import typed_value
+from gitpane.ui.look.action_icon import action_icon
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.look.windows_control_look import apply_windows_button_look, apply_windows_combo_look, apply_windows_line_edit_look, apply_windows_message_look
+from gitpane.ui.reference.reference_form import ReferenceFormDialog
+from gitpane.ui.reference.revision_picker import RevisionPicker
+from gitpane.ui.widget.dialog_layout import fit_caption_column, fit_capture_control, install_plain_form_palette
+from gitpane.ui.widget.long_text import ElidedCheckBox
+
+if TYPE_CHECKING:
+    from gitpane.operation.repository_operation import OperationOutcome
+    from gitpane.reference.reference_snapshot import ReferenceSnapshot
+
+CREATE_TAG_TITLE = "Create tag"
+TAG_NAME_CAPTION = "Tag name"
+CREATE_TAG_REVISION_CAPTION = "Create tag at this revision"
+# Git Extensions writes the remote the tag would be pushed to in the check box itself.
+PUSH_TAG_CAPTION = "Push tag to '{0}'"
+# The two tag types Git Extensions offers without a GPG key; the signed variants are deliberately not offered.
+TAG_TYPE_LABELS = ("Lightweight tag", "Annotated tag")
+LIGHTWEIGHT_TAG_INDEX = 0
+ANNOTATED_TAG_INDEX = 1
+MESSAGE_CAPTION = "Message"
+CREATE_TAG_BUTTON_TEXT = "Create tag"
+# Client area of the Git Extensions window (its designer's ClientSize, 464 x 245 at 100 %).
+CREATE_TAG_CLIENT_SIZE = QSize(464, 245)
+CREATE_TAG_SUBMIT_SIZE = QSize(126, 24)
+# Measured on the capture in client pixels at 100 %, visible borders included: captions ink from x 14; name field
+# (157, 11, 296, 23); revision field (157, 41, 235, 23) with its choose button (396, 40, 23, 22); Push square at
+# (157, 71); tag type list (157, 95, 150, 23); Create tag button (326, 209, 126, 24), 12 px from the right and bottom
+# edges. The capture's Key Id row is not reproduced, so the message area and its caption move up by that row's 28 px
+# and the area grows by as much: (156, 122, 298, 81) instead of (156, 150, 298, 53).
+CREATE_TAG_NAME_FIELD_RECT = QRect(157, 11, 296, 23)
+CREATE_TAG_REVISION_FIELD_RECT = QRect(157, 41, 235, 23)
+CREATE_TAG_CHOOSE_BUTTON_RECT = QRect(396, 40, 23, 22)
+CREATE_TAG_TYPE_COMBO_RECT = QRect(157, 95, 150, 23)
+CREATE_TAG_SUBMIT_RECT = QRect(QPoint(326, 209), CREATE_TAG_SUBMIT_SIZE)
+MESSAGE_AREA_RECT = QRect(156, 122, 298, 81)
+# Qt writes a caption from the label's own left edge, so the labels start where the captured captions' ink does.
+CREATE_TAG_CAPTION_LEFT = 14
+# Width of the caption column, from the captions' left edge to the fields; a wider caption text widens it.
+CREATE_TAG_CAPTION_WIDTH = CREATE_TAG_NAME_FIELD_RECT.left() - CREATE_TAG_CAPTION_LEFT
+# The message area starts this much left of the fields above it, as on the capture.
+MESSAGE_AREA_LEFT_SHIFT = CREATE_TAG_NAME_FIELD_RECT.left() - MESSAGE_AREA_RECT.left()
+# Space between the revision row (y 40-63) and the Push check box, whose square then lands on y 71.
+REVISION_TO_PUSH_SPACE = 4
+# Space between the Push check box, 21 px high in the Fusion style, and the tag type list at y 95.
+PUSH_TO_TYPE_SPACE = 6
+# The window's own margins: the name field and the message area set the top and right ones, the button the bottom one.
+CREATE_TAG_MARGINS = QMargins(CREATE_TAG_CAPTION_LEFT, CREATE_TAG_NAME_FIELD_RECT.top(), CREATE_TAG_CLIENT_SIZE.width() - MESSAGE_AREA_RECT.right() - 1,
+                              CREATE_TAG_CLIENT_SIZE.height() - CREATE_TAG_SUBMIT_RECT.bottom() - 1)
+
+
+class CreateTagDialog(ReferenceFormDialog):
+    """Create one tag at a commit, lightweight or annotated, like the Git Extensions Create tag window.
+
+    The window only freezes a creation request; the reference form controller reads the references, resolves typed revisions and
+    runs Git. Its Push check box never pushes: after creation the reference form controller opens the Push window on the new tag.
+    """
+
+    tag_requested = Signal(object)
+
+    def __init__(self, session_id: str, target_oid: str, parent: QWidget | None = None) -> None:
+        """Build the rows of the capture, show the requested commit in the revision field and focus the name."""
+        super().__init__(session_id, parent)
+        self.intent: TagIntent | None = None
+        self.setWindowTitle(CREATE_TAG_TITLE)
+        # The remote the check box names; the reference form controller replaces it with the current branch's upstream remote.
+        self.push_remote = DEFAULT_PUSH_REMOTE_NAME
+        # A plain grey window without a button band, with the resize grip of the capture in its bottom right corner.
+        install_plain_form_palette(self)
+        self.setSizeGripEnabled(True)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(CREATE_TAG_MARGINS)
+        layout.setSpacing(0)
+        self.name_edit = QLineEdit()
+        self.name_edit.setAccessibleName(TAG_NAME_CAPTION)
+        self.name_caption_label = self._caption(TAG_NAME_CAPTION, self.name_edit)
+        # The name field ends 1 px before the message area, whose right edge sets the window's right margin.
+        name_row = self._row(right_margin=MESSAGE_AREA_RECT.right() - CREATE_TAG_NAME_FIELD_RECT.right())
+        name_row.addWidget(self.name_caption_label, 0, Qt.AlignmentFlag.AlignVCenter)
+        name_row.addWidget(self.name_edit, 1)
+        layout.addLayout(name_row)
+        # The revision row's highest control is its choose button.
+        layout.addSpacing(CREATE_TAG_CHOOSE_BUTTON_RECT.top() - CREATE_TAG_NAME_FIELD_RECT.bottom() - 1)
+        self.picker = RevisionPicker(CREATE_TAG_REVISION_FIELD_RECT.width())
+        self.revision_caption_label = self._caption(CREATE_TAG_REVISION_CAPTION, self.picker.revision_edit)
+        revision_row = self._row()
+        revision_row.addWidget(self.revision_caption_label, 0, Qt.AlignmentFlag.AlignVCenter)
+        revision_row.addWidget(self.picker, 1)
+        layout.addLayout(revision_row)
+        layout.addSpacing(REVISION_TO_PUSH_SPACE)
+        # A long remote name is cut with an ellipsis instead of widening the window; the tooltip then gives it whole.
+        self.push_checkbox = ElidedCheckBox(PUSH_TAG_CAPTION.format(self.push_remote))
+        # The rows without caption are indented to the fields by fit_capture_controls, which follows the caption column.
+        self.push_row = self._row()
+        self.push_row.addWidget(self.push_checkbox, 1)
+        layout.addLayout(self.push_row)
+        layout.addSpacing(PUSH_TO_TYPE_SPACE)
+        self.tag_type_combo = QComboBox()
+        self.tag_type_combo.setEditable(False)
+        self.tag_type_combo.addItems(TAG_TYPE_LABELS)
+        self.tag_type_combo.setCurrentIndex(LIGHTWEIGHT_TAG_INDEX)
+        self.tag_type_combo.setFixedWidth(CREATE_TAG_TYPE_COMBO_RECT.width())
+        self.tag_type_combo.setAccessibleName("Tag type")
+        self.type_row = self._row()
+        self.type_row.addWidget(self.tag_type_combo)
+        self.type_row.addStretch(1)
+        layout.addLayout(self.type_row)
+        layout.addSpacing(MESSAGE_AREA_RECT.top() - CREATE_TAG_TYPE_COMBO_RECT.bottom() - 1)
+        self.message_edit = QPlainTextEdit()
+        self.message_edit.setAccessibleName(MESSAGE_CAPTION)
+        # Tab moves on to the button instead of being typed into the annotation, as in the Git Extensions text box.
+        self.message_edit.setTabChangesFocus(True)
+        self.message_caption_label = self._caption(MESSAGE_CAPTION, self.message_edit)
+        message_row = self._row()
+        message_row.addWidget(self.message_caption_label, 0, Qt.AlignmentFlag.AlignTop)
+        message_row.addWidget(self.message_edit, 1)
+        # The message area takes every pixel the window gains in height, as the full-height row of Git Extensions does.
+        layout.addLayout(message_row, 1)
+        layout.addSpacing(CREATE_TAG_SUBMIT_RECT.top() - MESSAGE_AREA_RECT.bottom() - 1)
+        self.submit_button.setText(CREATE_TAG_BUTTON_TEXT)
+        self.submit_button.setIcon(action_icon("tag_create", self.devicePixelRatioF()))
+        self.submit_button.setEnabled(False)
+        # There is no Cancel button, as in Git Extensions: Escape and the title bar close the window.
+        button_row = self._row(right_margin=MESSAGE_AREA_RECT.right() - CREATE_TAG_SUBMIT_RECT.right())
+        button_row.addStretch(1)
+        button_row.addWidget(self.submit_button)
+        layout.addLayout(button_row)
+        self.apply_theme_look()
+        follow_theme(self, self.apply_theme_look)
+        # Enter runs Create tag from the single-line fields. The role is set once the button belongs to the dialog, so
+        # Qt records it as the dialog's main default; the message area keeps Enter for its new lines.
+        self.submit_button.setDefault(True)
+        self.submit_button.clicked.connect(self._submit)
+        self.name_edit.textChanged.connect(self._update_intent)
+        self.message_edit.textChanged.connect(self._update_intent)
+        self.push_checkbox.toggled.connect(self._update_intent)
+        self.tag_type_combo.currentIndexChanged.connect(self._tag_type_changed)
+        self._apply_tag_type()
+        # Connected before the reference form controller binds the field, so a new target's position is invalidated before it is counted.
+        self.picker.target_changed.connect(self._target_changed)
+        self.picker.show_revision(target_oid)
+        self.resize(CREATE_TAG_CLIENT_SIZE)
+        self.refresh_metrics()
+        self.name_edit.setFocus()
+
+    def apply_theme_look(self) -> None:
+        """Lay the light or dark look of the fields, the tag type list, the message area and the button, decided on the application palette.
+
+        Called by the constructor and again at each switch. The message area takes the look of its current state:
+        bordered when an annotated tag lets it be typed in, hidden in the window when it is disabled. Only style sheets
+        and palettes change: the name, the revision, the tag type, the message and Push stay as they are.
+        """
+        apply_windows_line_edit_look(self.name_edit)
+        apply_windows_combo_look(self.tag_type_combo, editable=False)
+        apply_windows_message_look(self.message_edit)
+        apply_windows_button_look(self.submit_button)
+        self.picker.apply_theme_look()
+
+    def fit_capture_controls(self) -> None:
+        """Give the caption column and the Create tag button the capture's sizes, or more when their text needs it.
+
+        A wider caption column moves every field right by the same amount: the name and revision fields, the Push check
+        box, the tag type list, and the message area, which stays 1 px left of the fields as on the capture.
+        """
+        column_width = fit_caption_column((self.name_caption_label, self.revision_caption_label), CREATE_TAG_CAPTION_WIDTH)
+        fit_caption_column((self.message_caption_label,), column_width - MESSAGE_AREA_LEFT_SHIFT)
+        for row in (self.push_row, self.type_row):
+            row.setContentsMargins(column_width, 0, 0, 0)
+        fit_capture_control(self.submit_button, CREATE_TAG_SUBMIT_SIZE)
+
+    def _caption(self, text: str, buddy: QWidget) -> QLabel:
+        """Build a caption of the left column whose mnemonic and accessibility point at its field; ``fit_capture_controls`` sets its width."""
+        label = QLabel(text)
+        label.setBuddy(buddy)
+        return label
+
+    def _row(self, right_margin: int = 0) -> QHBoxLayout:
+        """Start a row of the window, flush with the captions on the left."""
+        row = QHBoxLayout()
+        row.setContentsMargins(0, 0, right_margin, 0)
+        row.setSpacing(0)
+        return row
+
+    def populate(self, snapshot: ReferenceSnapshot, target_oid: str, push_remote: str) -> None:
+        """Show the commit and the push remote against the references the window was opened on.
+
+        A name or message the user already typed while the references were being checked is kept.
+        """
+        if self.closed or self.busy or self.completed:
+            return
+        self.snapshot = snapshot
+        self.push_remote = push_remote
+        self.push_checkbox.setText(PUSH_TAG_CAPTION.format(push_remote))
+        self.set_target(target_oid)
+        self.name_edit.setFocus()
+
+    def set_target(self, oid: str, *, rewrite_text: bool = True) -> None:
+        """Target another commit; its short hash replaces the field unless the user's typed text is kept."""
+        if self.closed or self.busy or self.completed:
+            return
+        self.picker.show_revision(oid, rewrite_text=rewrite_text)
+
+    def _target_changed(self, _oid: str | None) -> None:
+        """Drop any position still being counted for the previous target and freeze the new request, if any."""
+        self.position_generation += 1
+        self._update_intent()
+
+    def _tag_type_changed(self) -> None:
+        """Follow the chosen tag type in the message area, then freeze the new request."""
+        self._apply_tag_type()
+        self._update_intent()
+
+    def _apply_tag_type(self) -> None:
+        """Offer the message area, with its border, only for an annotated tag, as Git Extensions does.
+
+        A lightweight tag has no message: the area is disabled and loses its border, and what was typed in it stays
+        there, unused, until the tag is annotated again.
+        """
+        annotated = self.tag_type_combo.currentIndex() == ANNOTATED_TAG_INDEX
+        editable = not self.busy and not self.completed and not self.closed
+        self.message_edit.setEnabled(annotated and editable)
+        apply_windows_message_look(self.message_edit)
+
+    def _update_intent(self) -> None:
+        """Freeze the typed name, the target commit, the tag type, its message and the Push choice into the request.
+
+        The name and the message are taken without the blanks around them; the fields keep what was typed.
+        """
+        self.intent = None
+        target_oid = self.picker.target_oid
+        name = typed_value(self.name_edit.text())
+        if self.snapshot is not None and target_oid and name:
+            try:
+                self.intent = TagIntent.capture(self.snapshot, target_oid, session_id=self.session_id, name=name,
+                                                annotated=self.tag_type_combo.currentIndex() == ANNOTATED_TAG_INDEX,
+                                                message=typed_value(self.message_edit.toPlainText()), push_after_creation=self.push_checkbox.isChecked())
+            except ValueError:
+                self.intent = None
+        self.submit_button.setEnabled(self.intent is not None and not self.busy and not self.completed 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._set_controls_enabled(False)
+        self.tag_requested.emit(self.intent)
+
+    def show_outcome(self, outcome: OperationOutcome) -> None:
+        """Close after a successful creation; keep the form after any other result while the console explains it.
+
+        A refused or failed creation wrote nothing, so the form stays editable for another try; after a partial or
+        unknown result the tag may exist, so the form only shows what was asked.
+        """
+        self.busy = False
+        if outcome.status == OperationStatus.SUCCESS:
+            self.accept()
+            return
+        if outcome.status in (OperationStatus.REFUSED, OperationStatus.FAILED):
+            self._set_controls_enabled(True)
+            self._update_intent()
+            return
+        self.completed = True
+        self._set_controls_enabled(False)
+
+    def _set_controls_enabled(self, enabled: bool) -> None:
+        """Enable or disable every choice of the form together, keeping the message area for annotated tags only."""
+        for widget in (self.name_edit, self.picker, self.push_checkbox, self.tag_type_combo, self.submit_button):
+            widget.setEnabled(enabled)
+        self._apply_tag_type()