gitpane 1.0.0__py3-none-any.whl

gitpane/ui/transport/clone_dialog.py

@@ -0,0 +1,879 @@
+"""Collect clone intentions in a form laid out like the Git Extensions Clone window, with an Account row added on top."""
+
+from __future__ import annotations
+
+import os
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QMargins, Qt, QTimer, Signal
+from PySide6.QtGui import QColor, QPalette
+from PySide6.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QComboBox,
+    QDialog,
+    QFileDialog,
+    QFrame,
+    QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLineEdit,
+    QPushButton,
+    QRadioButton,
+    QScrollArea,
+    QSizePolicy,
+    QStyle,
+    QVBoxLayout,
+    QWidget,
+)
+from shiboken6 import isValid
+
+from gitpane.account.account_choice import ENTER_URL_FIRST_TEXT
+from gitpane.config import ERROR_DARK_COLOR, ERROR_LIGHT_COLOR, fit_window
+from gitpane.recent.recent_availability import RecentAvailabilityCheck
+from gitpane.text.typed_path import session_typed_path, typed_path_value, typed_start_dir
+from gitpane.text.typed_text import typed_value
+from gitpane.thread.weak_signal import weak_signal_emitter
+from gitpane.transport.clone import SUBMODULE_PARTIAL_TEXT, CloneOptions, looks_like_git_repository, suggested_name
+from gitpane.ui.look.action_icon import action_icon
+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 apply_windows_combo_look, apply_windows_line_edit_look
+from gitpane.ui.widget.busy_indicator import BusyIndicator
+from gitpane.ui.widget.content_growth import ContentGrowthMixin, OpeningFit
+from gitpane.ui.widget.content_measure import ScrolledContentMeasure
+from gitpane.ui.widget.dialog_layout import (
+    BROWSE_TEXT,
+    BUTTON_COLUMN,
+    FIELD_COLUMN,
+    FORM_BAND_BUTTON_MIN_SIZE,
+    FORM_GRID_BODY_MARGINS,
+    FORM_GRID_CAPTION_WIDTH,
+    FORM_GRID_COLUMN_SPACING,
+    FORM_GRID_ROW_SPACING,
+    FORM_GRID_ROWS_TO_BLOCK_SPACE,
+    FORM_GRID_SIDE_BUTTON_MIN_WIDTH,
+    BandButtonSizing,
+    add_form_caption,
+    apply_side_button_look,
+    install_banded_layout,
+)
+from gitpane.ui.widget.long_text import WrappingLabel
+from gitpane.ui.widget.plain_label import plain_label
+from gitpane.ui.widget.result_label import ResultLabel, ResultTone
+from gitpane.ui.widget.standard_icon_label import StandardIconLabel
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtCore import QRect
+
+    from gitpane.ui.setting.add_account_dialog import AddAccountDialog
+
+
+# Client width of the Git Extensions capture, the form's smallest starting width. The height is the smallest that shows the starting form (Account row, yellow
+# box 17 px below the Branch row as on the capture, help text under the check boxes) without scrolling, with 18 px left
+# under the help text, the space Git Extensions leaves under its check boxes; that space is enough for a one-line account
+# message.
+CLONE_WIDTH, CLONE_HEIGHT = 648, 420
+CLONE_TITLE = "Clone repository"
+ACCOUNT_CAPTION = "Account:"
+REPOSITORY_CAPTION = "Repository to clone:"
+DESTINATION_CAPTION = "Destination:"
+SUBDIRECTORY_CAPTION = "Subdirectory to create:"
+BRANCH_CAPTION = "Branch:"
+# Every caption of the form's left column; the start window lines its own caption column up with these.
+CLONE_FORM_CAPTIONS = (ACCOUNT_CAPTION, REPOSITORY_CAPTION, DESTINATION_CAPTION, SUBDIRECTORY_CAPTION, BRANCH_CAPTION)
+ADD_ACCOUNT_TEXT = "Add account…"
+# The side button without an icon in the form's right-hand column; the start window's column takes its width too.
+CLONE_PLAIN_SIDE_BUTTON_TEXTS = (ADD_ACCOUNT_TEXT,)
+SUBMODULE_CHECK_TEXT = "Initialize all submodules"
+FULL_HISTORY_CHECK_TEXT = "Download full history"
+# Texts of the Git Extensions Clone window, word for word.
+DEFAULT_BRANCH_TEXT = "(default: remote HEAD)"
+TARGET_INTRO_TEXT = "The repository will be cloned to a new directory located here:"
+TARGET_NEW_TEXT = "(New directory)"
+TARGET_EXISTS_TEXT = "(Directory already exists)"
+REPOSITORY_TYPE_TITLE = "Repository type"
+PERSONAL_REPOSITORY_TEXT = "Personal repository"
+BARE_REPOSITORY_TEXT = "Public repository, no working directory (--bare)"
+# Git's usual ending for the folder of a bare repository, added to the proposed subdirectory.
+BARE_SUFFIX = ".git"
+# Wait after the last change of the destination before looking whether the folder exists: typing never reads the disk.
+TARGET_CHECK_DELAY_MS = 300
+# Wait after the last change of the URL or of the account before reading the remote branches: typing starts no Git process.
+BRANCH_LIST_DELAY_MS = 600
+# The Branch row says this without any line of text: the first is the accessible name of the turning indicator shown
+# while the branches are read, the second the tooltip of the warning icon shown after a failure.
+BRANCH_LOADING_TEXT = "Reading branches…"
+BRANCH_FAILED_TEXT = "Branches could not be read"
+DEFAULT_BRANCH_INDEX = 0
+EMPTY_HELP = "Enter a repository URL or a local folder, choose a destination and the subdirectory to create."
+CLONE_RUNNING_TEXT = "Cloning repository and submodules…"
+CLONE_FAILED_TEXT = "Clone failed. Review the details, correct the URL or destination, then try again."
+OPEN_FAILED_TEXT = "Repository cloned, but opening failed. Open repository to retry."
+# While stopping, GitPane cannot tell yet whether Git wrote anything: an empty folder it created is removed afterwards,
+# anything Git wrote is kept.
+STOPPING_TEXT = "Stopping clone… Anything Git already wrote will be preserved."
+CLONE_CANCELLED_TEXT = "Clone cancelled."
+CLONE_CANCELLED_PRESERVED_TEXT = CLONE_CANCELLED_TEXT + " The partial directory was preserved: "
+OPENING_CANCELLED_TEXT = "Opening cancelled. The cloned repository was preserved."
+
+# The rows, their columns and the yellow box's distance below them come from the shared form grid of dialog_layout,
+# measured on this window's capture; the box itself spans x 14 to 632 there.
+TARGET_PADDING = QMargins(5, 4, 5, 4)
+# Colors of the yellow box, owned here instead of read from the palette: macOS gives no yellow tooltip background in
+# either appearance, and its tooltip text is black in dark. The light set is the pale yellow Git Extensions shows under a
+# light Windows theme; the dark set is a dark version of the same yellow chosen on captures, its text at 7.5:1.
+TARGET_BOX_LIGHT_BACKGROUND_COLOR = "#ffffe1"
+TARGET_BOX_LIGHT_BORDER_COLOR = "#a0a0a0"
+TARGET_BOX_LIGHT_TEXT_COLOR = "#000000"
+TARGET_BOX_DARK_BACKGROUND_COLOR = "#5c4f1f"
+TARGET_BOX_DARK_BORDER_COLOR = "#a8923f"
+TARGET_BOX_DARK_TEXT_COLOR = "#fff6d8"
+# The Repository type box starts 9 px below the yellow box and 6 px right of its left edge. The check boxes follow it
+# closer than on the capture, since the help text comes under them here.
+TARGET_TO_TYPE_SPACE = 9
+TYPE_INDENT = 6
+TYPE_TO_CHECKS_SPACE = 6
+# The check boxes start 14 px right of the box's left edge.
+CHECKS_INDENT = 14
+CHECKS_SPACING = 24
+CHECKS_TO_STATUS_SPACE = 6
+ACCOUNT_ROW, REPOSITORY_ROW, DESTINATION_ROW, SUBDIRECTORY_ROW, BRANCH_ROW = 0, 1, 2, 3, 4
+# The Account row's menu and button share the field and button columns.
+ACCOUNT_COLUMN_SPAN = 2
+MOST_RECENT_DESTINATION_INDEX = 0
+# Characters the form's drop-down lists ask room for. A list sized to its entries would widen the form to the longest
+# remembered destination or branch name; the field column stretches anyway, and a long entry scrolls inside its field.
+COMBO_MINIMUM_CHARACTERS = 20
+
+
+class BranchReadState(Enum):
+    """What the Branch row shows beside its list: nothing, the turning indicator while reading, or the warning icon after a failure."""
+
+    IDLE = "idle"
+    READING = "reading"
+    FAILED = "failed"
+
+
+class CloneDialogText(Enum):
+    """Sentences of the clone form that the clone controller writes into it."""
+
+    # Written under the check boxes when the form switched itself to the account named like the address's owner.
+    OWNER_ACCOUNT_CHOSEN = "The branches could not be read with the previous account: {label}, the owner named in the address, is used instead."
+
+
+class CloneDialog(ContentGrowthMixin, QDialog):
+    """Keep the complete clone form available through progress and recoverable errors.
+
+    The form only collects what the user asks for and hands it over as a URL, a destination and ``CloneOptions``; the
+    clone service builds the Git command.
+    """
+
+    clone_requested = Signal()
+    cancel_requested = Signal()
+    # Asked a short while after the URL or the account last changed: the clone controller reads the remote branches.
+    branch_list_requested = Signal()
+    # The URL or the account changed: a branch list still running answers for the old one and must be dropped.
+    branch_list_outdated = Signal()
+    open_requested = Signal()
+    retry_requested = Signal()
+    # Answer of the background check of a folder path found on the clipboard: the folder and whether it is a repository.
+    clipboard_repository_checked = Signal(str, bool)
+
+    def __init__(self, parent: QWidget | None = None, is_clipboard_repository: Callable[[str], bool] = looks_like_git_repository,
+                 target_exists: Callable[[str], bool] = os.path.lexists, typed_path: Callable[[str], str] = session_typed_path) -> None:
+        """Build the Git Extensions rows in a scrolling body above the grey button band; Git's output goes to the clone's own console.
+
+        ``is_clipboard_repository`` answers, on a background thread, whether a folder path found on the clipboard is a
+        repository; tests inject it to hold or answer that question without a disk. ``target_exists`` answers whether the
+        folder the clone would create is already there; the window gallery injects it to show an example path in both
+        states without creating any folder. ``typed_path`` reads ``~`` in the address and the destination where that is the
+        usage; tests hand their own system and home folder.
+        """
+        super().__init__(parent)
+        self.return_focus = parent.focusWidget() if parent is not None else None
+        self.finished.connect(self._restore_focus)
+        self.setWindowTitle(CLONE_TITLE)
+        self.resize(CLONE_WIDTH, CLONE_HEIGHT)
+        self.custom_name = False
+        self.running = False
+        self.partial = False
+        self.recursive_partial = False
+        self.authentication_endpoint = ""
+        self.account_origin = ""
+        # The user picked an account in the menu or added one from this form: the form then never switches account by
+        # itself, until the service address changes.
+        self.account_chosen_by_user = False
+        # Line the form wrote when it switched itself to the owner's account; empty when it did not.
+        self.owner_account_note = ""
+        # Account the form put in the menu by itself for the address's owner; empty when it did not switch.
+        self.owner_switch_namespace = ""
+        # Owner named in the address when the form switched, compared without regard to case; empty when it did not switch.
+        self.owner_switch_owner = ""
+        # Menu choice just before the switch, None standing for 'Use global default': it comes back when the address names
+        # another owner.
+        self.account_before_owner_switch: str | None = None
+        self.add_account_dialog: AddAccountDialog | None = None
+        self.operation_id: str | None = None
+        # Id of the branch list whose answer the form waits for; empty when none runs.
+        self.branch_request_id = ""
+        # Folder and existence the target box last showed, so the box can be shown again in a new appearance.
+        self.shown_target: tuple[str, bool | None] = ("", None)
+        self.is_clipboard_repository = is_clipboard_repository
+        self.target_exists = target_exists
+        self.typed_path = typed_path
+        # Created by the first clipboard path to check, closed with the form so a late answer never fills a closed form.
+        self.clipboard_repository_check: RecentAvailabilityCheck | None = None
+        self.url_edit = QLineEdit()
+        self.url_browse_button = self._side_button(BROWSE_TEXT)
+        self.destination_combo = QComboBox()
+        self.destination_combo.setEditable(True)
+        self.destination_combo.setInsertPolicy(QComboBox.InsertPolicy.NoInsert)
+        # A remembered folder is only offered in the list, never completed into the field while the user types a path.
+        self.destination_combo.setCompleter(None)
+        self.parent_edit = self.destination_combo.lineEdit()
+        self.browse_button = self._side_button(BROWSE_TEXT)
+        self.name_edit = QLineEdit()
+        self.branch_combo = QComboBox()
+        self.branch_combo.setEditable(True)
+        self.branch_combo.setInsertPolicy(QComboBox.InsertPolicy.NoInsert)
+        self.branch_combo.addItem(DEFAULT_BRANCH_TEXT, "")
+        branch_marker_row = self._build_branch_marker_row()
+        account_section = self._build_account_section()
+        for combo in (self.account_combo, self.destination_combo, self.branch_combo):
+            combo.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
+            combo.setMinimumContentsLength(COMBO_MINIMUM_CHARACTERS)
+        grid = QGridLayout()
+        grid.setContentsMargins(0, 0, 0, 0)
+        grid.setHorizontalSpacing(FORM_GRID_COLUMN_SPACING)
+        grid.setVerticalSpacing(FORM_GRID_ROW_SPACING)
+        grid.setColumnStretch(FIELD_COLUMN, 1)
+        self.caption_labels = [add_form_caption(grid, ACCOUNT_ROW, ACCOUNT_CAPTION, self.account_combo)]
+        grid.addWidget(account_section, ACCOUNT_ROW, FIELD_COLUMN, 1, ACCOUNT_COLUMN_SPAN)
+        for row, caption, field, accessible_name in ((REPOSITORY_ROW, REPOSITORY_CAPTION, self.url_edit, "Repository to clone"),
+                                                     (DESTINATION_ROW, DESTINATION_CAPTION, self.destination_combo, "Destination"),
+                                                     (SUBDIRECTORY_ROW, SUBDIRECTORY_CAPTION, self.name_edit, "Subdirectory to create"),
+                                                     (BRANCH_ROW, BRANCH_CAPTION, self.branch_combo, "Branch")):
+            self.caption_labels.append(add_form_caption(grid, row, caption, field))
+            field.setAccessibleName(accessible_name)
+            grid.addWidget(field, row, FIELD_COLUMN)
+        grid.addLayout(branch_marker_row, BRANCH_ROW, BUTTON_COLUMN)
+        grid.addWidget(self.url_browse_button, REPOSITORY_ROW, BUTTON_COLUMN)
+        grid.addWidget(self.browse_button, DESTINATION_ROW, BUTTON_COLUMN)
+        self.target_frame = QFrame()
+        self.target_frame.setFrameShape(QFrame.Shape.Box)
+        self.target_frame.setFrameShadow(QFrame.Shadow.Plain)
+        self.target_frame.setAutoFillBackground(True)
+        target_layout = QVBoxLayout(self.target_frame)
+        target_layout.setContentsMargins(TARGET_PADDING)
+        self.target_label = WrappingLabel()
+        self.target_label.setWordWrap(True)
+        target_layout.addWidget(self.target_label)
+        self.repository_type_group = QGroupBox(REPOSITORY_TYPE_TITLE)
+        self.personal_radio = QRadioButton(PERSONAL_REPOSITORY_TEXT)
+        self.personal_radio.setChecked(True)
+        self.bare_radio = QRadioButton(BARE_REPOSITORY_TEXT)
+        type_layout = QVBoxLayout(self.repository_type_group)
+        type_layout.addWidget(self.personal_radio)
+        type_layout.addWidget(self.bare_radio)
+        type_row = QHBoxLayout()
+        type_row.setContentsMargins(TYPE_INDENT, 0, 0, 0)
+        type_row.addWidget(self.repository_type_group)
+        self.submodule_check = QCheckBox(SUBMODULE_CHECK_TEXT)
+        self.submodule_check.setChecked(True)
+        self.full_history_check = QCheckBox(FULL_HISTORY_CHECK_TEXT)
+        self.full_history_check.setChecked(True)
+        check_row = QHBoxLayout()
+        check_row.setContentsMargins(CHECKS_INDENT, 0, 0, 0)
+        check_row.setSpacing(CHECKS_SPACING)
+        check_row.addWidget(self.submodule_check)
+        check_row.addWidget(self.full_history_check)
+        check_row.addStretch(1)
+        self.account_status_label = plain_label("")
+        # Hidden while empty so it takes no room between the check boxes and the help text.
+        self.account_status_label.hide()
+        self.status_label = ResultLabel(EMPTY_HELP)
+        for label in (self.target_label, self.account_status_label, self.status_label):
+            # Wrapped labels must not ask for the width of their longest word, or a long path would widen the form.
+            policy = label.sizePolicy()
+            policy.setHorizontalPolicy(QSizePolicy.Policy.Ignored)
+            label.setSizePolicy(policy)
+        content = QWidget()
+        form = QVBoxLayout(content)
+        form.setContentsMargins(FORM_GRID_BODY_MARGINS)
+        form.setSpacing(0)
+        form.addLayout(grid)
+        form.addSpacing(FORM_GRID_ROWS_TO_BLOCK_SPACE)
+        form.addWidget(self.target_frame)
+        form.addSpacing(TARGET_TO_TYPE_SPACE)
+        form.addLayout(type_row)
+        form.addSpacing(TYPE_TO_CHECKS_SPACE)
+        form.addLayout(check_row)
+        form.addSpacing(CHECKS_TO_STATUS_SPACE)
+        form.addWidget(self.account_status_label)
+        form.addWidget(self.status_label)
+        form.addStretch(1)
+        self.scroll_area = QScrollArea()
+        self.scroll_area.setWidgetResizable(True)
+        self.scroll_area.setFrameShape(QFrame.Shape.NoFrame)
+        self.scroll_area.setWidget(content)
+        # The content gets taller after the form opened (a long destination path, an account message, a failure the clone
+        # controller writes, a refused submodule) and would be cut under the bottom edge; the form takes back its height
+        # when that content goes, never below the height it opened at or the one the user set. The content's layout
+        # requests follow each key press; the scroll bar range covers an overflow that changes without a layout request
+        # seen here. The capture's height is given rather than read: refresh_metrics may reduce the form on a small
+        # screen before it is shown.
+        self.install_content_growth(ScrolledContentMeasure(self.scroll_area), OpeningFit.GROW_ONLY, CLONE_HEIGHT)
+        body = QVBoxLayout()
+        body.addWidget(self.scroll_area)
+        self.open_button = QPushButton("Open repository")
+        self.open_button.clicked.connect(self.open_requested)
+        self.open_button.hide()
+        self.clone_button = QPushButton("Clone")
+        self.clone_button.clicked.connect(self._submit)
+        # Kept beside Clone because it is the only way to stop a running clone from the form; the console has Abort.
+        self.cancel_button = QPushButton("Close")
+        self.cancel_button.clicked.connect(self._cancel_or_close)
+        band_buttons = [self.open_button, self.clone_button, self.cancel_button]
+        for button in band_buttons:
+            button.setMinimumSize(FORM_BAND_BUTTON_MIN_SIZE)
+        self.button_band = install_banded_layout(self, body, band_buttons, body_margins=QMargins(), button_sizing=BandButtonSizing.WINDOW)
+        # Enter runs Clone from anywhere in the form; the role is set once the button belongs to the dialog.
+        self.clone_button.setDefault(True)
+        # The look comes before the width: the side buttons' sheet sets the width their column needs.
+        self.apply_theme_look()
+        self.resize(self.starting_width(), CLONE_HEIGHT)
+        self.target_check_timer = QTimer(self)
+        self.target_check_timer.setSingleShot(True)
+        self.target_check_timer.setInterval(TARGET_CHECK_DELAY_MS)
+        self.target_check_timer.timeout.connect(self._check_target)
+        self.branch_timer = QTimer(self)
+        self.branch_timer.setSingleShot(True)
+        self.branch_timer.setInterval(BRANCH_LIST_DELAY_MS)
+        self.branch_timer.timeout.connect(self.branch_list_requested)
+        # A closed form is only hidden and stays alive, so its timers are stopped: it never starts a branch list or a
+        # target check afterwards, not even for a form opened again within the delay.
+        self.finished.connect(self._stop_timers)
+        # The answer arrives on a worker thread; the queued connection fills the field on the form's own thread.
+        self.clipboard_repository_checked.connect(self._fill_clipboard_repository, Qt.ConnectionType.QueuedConnection)
+        self.finished.connect(self._close_clipboard_repository_check)
+        # A chosen account may see other branches, so they are read again with it.
+        self.account_combo.activated.connect(self.restart_branch_list)
+        self.account_combo.activated.connect(self._account_chosen_by_hand)
+        self.url_browse_button.clicked.connect(self._browse_repository)
+        self.browse_button.clicked.connect(self._browse)
+        self.name_edit.textEdited.connect(self._name_edited)
+        self.name_edit.textChanged.connect(self._update_target)
+        self.parent_edit.textChanged.connect(self._update_target)
+        self.url_edit.textChanged.connect(self._url_changed)
+        self.bare_radio.toggled.connect(self._repository_type_changed)
+        # Only user actions clear a shown failure: typed edits (not text set by the program), buttons, a menu choice and a check box click.
+        for edit in (self.url_edit, self.parent_edit, self.name_edit, self.branch_combo.lineEdit()):
+            edit.textEdited.connect(self.clear_result)
+        self.add_account_button.clicked.connect(self.clear_result)
+        for combo in (self.account_combo, self.destination_combo, self.branch_combo):
+            combo.activated.connect(self.clear_result)
+        for check in (self.submodule_check, self.full_history_check, self.personal_radio, self.bare_radio):
+            check.clicked.connect(self.clear_result)
+        # The URL starts empty; the clone controller updates the row as soon as one is typed or pasted.
+        self.show_account_state(ENTER_URL_FIRST_TEXT, False)
+        self._update_target()
+        follow_theme(self, self.apply_theme_look)
+        self.refresh_metrics()
+        self.url_edit.setFocus()
+
+    def refresh_metrics(self, available: QRect | None = None) -> None:
+        """Keep the form on the usable screen area without turning its starting size into a minimum."""
+        fit_window(self, 0, 0, available)
+
+    def starting_width(self) -> int:
+        """Return the capture's width, widened by what the caption and side-button columns need beyond the capture's.
+
+        With the captures' text every caption and the Browse… buttons fit their capture widths and the form keeps the
+        capture's width. A larger system text widens both columns; the form widens by the same amount, so the fields
+        keep the width they have on the capture instead of giving it up.
+        """
+        caption_width = FORM_GRID_CAPTION_WIDTH
+        for caption in self.caption_labels:
+            caption_width = max(caption_width, caption.sizeHint().width())
+        side_button_width = max(FORM_GRID_SIDE_BUTTON_MIN_WIDTH, self.url_browse_button.width())
+        return CLONE_WIDTH + caption_width - FORM_GRID_CAPTION_WIDTH + side_button_width - FORM_GRID_SIDE_BUTTON_MIN_WIDTH
+
+    def repository_url(self) -> str:
+        """Return the repository to clone as typed, without the blanks around it and with ``~`` read as the home folder.
+
+        A URL pasted from a web page often carries a trailing space. ``~`` alone or ``~/`` at the start stands for the
+        home folder where that is the usage; only a local folder can change, since no HTTPS, SSH or ``file://`` address
+        starts with ``~/``. The field keeps the typed text. The Account row, the branch list, the proposed subdirectory and
+        the clone itself all read the URL through here, so they always agree on the same address.
+        """
+        return typed_path_value(self.url_edit.text(), self.typed_path)
+
+    def destination_dir(self) -> str:
+        """Return the typed Destination folder without the blanks around it and with ``~`` read as the home folder.
+
+        A pasted path names the folder the user sees, and ``~`` is read where that is the usage. This is the folder the
+        clone starts in, kept as it is in the list of destinations, so that list only holds full paths.
+        """
+        return typed_path_value(self.parent_edit.text(), self.typed_path)
+
+    def subdirectory_name(self) -> str:
+        """Return the typed subdirectory to create without the blanks around it, so the clone never creates a folder named with a space."""
+        return typed_value(self.name_edit.text())
+
+    def target_dir(self) -> str:
+        """Return the folder the clone will create, or an empty text while the destination or the subdirectory is missing."""
+        parent_dir, name = self.destination_dir(), self.subdirectory_name()
+        return os.path.join(parent_dir, name) if parent_dir and name else ""
+
+    def clone_options(self) -> CloneOptions:
+        """Return what the user asked Git to do besides copying the repository: the branch, the submodules, the history depth and a bare repository.
+
+        A bare repository has no working tree, so its submodules are never initialized, whatever the greyed box shows.
+        """
+        bare = self.bare_radio.isChecked()
+        return CloneOptions(branch=self._branch_name(), initialize_submodules=self.submodule_check.isChecked() and not bare,
+                            full_history=self.full_history_check.isChecked(), bare=bare)
+
+    def set_destination_dirs(self, destination_dirs: list[str]) -> None:
+        """Offer the parent folders of the last clones in the Destination list, the most recent in the field, without looking at the disk."""
+        self.destination_combo.clear()
+        for destination_dir in destination_dirs:
+            self.destination_combo.addItem(destination_dir)
+        self.parent_edit.setText(destination_dirs[MOST_RECENT_DESTINATION_INDEX] if destination_dirs else "")
+
+    def show_branches(self, branches: tuple[str, ...]) -> None:
+        """Offer the remote HEAD entry then these branches, keep whatever the user already typed or chose, and clear what shows beside the Branch list."""
+        self._fill_branches(branches)
+        self._show_branch_read_state(BranchReadState.IDLE)
+
+    def set_branch_loading(self) -> None:
+        """Turn the indicator beside the Branch list while the remote branches are read; the list stays usable meanwhile."""
+        self._show_branch_read_state(BranchReadState.READING)
+
+    def show_branch_failure(self) -> None:
+        """Show the warning icon beside the Branch list, its tooltip saying the branches could not be read; cloning the remote HEAD or a typed branch stays possible."""
+        self._fill_branches(())
+        self._show_branch_read_state(BranchReadState.FAILED)
+
+    def _show_branch_read_state(self, state: BranchReadState) -> None:
+        """Put the Branch row's indicator cell in one state, so the turning indicator and the warning icon never show together."""
+        if state is BranchReadState.READING:
+            self.branch_warning_label.hide()
+            self.branch_busy_indicator.start()
+            return
+        self.branch_busy_indicator.stop()
+        self.branch_warning_label.setVisible(state is BranchReadState.FAILED)
+
+    def _fill_branches(self, branches: tuple[str, ...]) -> None:
+        """Rebuild the Branch list without losing the text in its field; signals are blocked so the change is never taken for a user choice.
+
+        The field gets back exactly what was typed, blanks included: only the branch sent to Git loses them.
+        """
+        typed = self.branch_combo.currentText()
+        self.branch_combo.blockSignals(True)
+        self.branch_combo.clear()
+        self.branch_combo.addItem(DEFAULT_BRANCH_TEXT, "")
+        for branch in branches:
+            self.branch_combo.addItem(branch, branch)
+        index = self.branch_combo.findText(typed)
+        if not typed or index >= 0:
+            self.branch_combo.setCurrentIndex(max(index, DEFAULT_BRANCH_INDEX))
+        else:
+            self.branch_combo.setEditText(typed)
+        self.branch_combo.blockSignals(False)
+
+    def restart_branch_list(self) -> None:
+        """Drop any branch list of the previous URL or account and plan a new one once the user stops changing them.
+
+        Also called once an account was added from the form: the new account may see branches the last list could not read.
+        """
+        self.branch_list_outdated.emit()
+        self.branch_timer.start()
+
+    def set_running(self, running: bool) -> None:
+        """Prevent duplicate submissions while leaving cancellation accessible."""
+        self.running = running
+        for widget in (self.url_edit, self.url_browse_button, self.destination_combo, self.browse_button, self.name_edit, self.branch_combo,
+                       self.repository_type_group, self.submodule_check, self.full_history_check, self.account_section):
+            widget.setEnabled(not running and not self.partial)
+        if self.bare_radio.isChecked():
+            self.submodule_check.setEnabled(False)
+        self.cancel_button.setText("Cancel clone" if running else "Close")
+        self.cancel_button.setEnabled(True)
+        self.open_button.setEnabled(not running)
+        if self.authentication_endpoint:
+            self.account_section.setEnabled(not running)
+        if running:
+            self.status_label.setText(CLONE_RUNNING_TEXT)
+        self._update_target()
+
+    def show_failure(self, cause: str, partial: bool = False, *, explained: bool = False) -> None:
+        """Show a failed clone or a failed opening in bold red, keeping the captured form for a retry.
+
+        After a clone that worked but could not be opened, only opening is offered again, never a second clone. An
+        ``explained`` cause already starts with a sentence saying what went wrong and what to do, so the generic
+        sentence is not put in front of it.
+        """
+        self._stop(partial)
+        if explained:
+            self.status_label.show_failure(cause)
+            return
+        self.status_label.show_failure((OPEN_FAILED_TEXT if partial else CLONE_FAILED_TEXT) + "\n" + cause)
+
+    def show_cancelled(self, cause: str, partial: bool = False) -> None:
+        """Show a cancellation in ordinary text: the user asked for it, so it is not an error."""
+        self._stop(partial)
+        self.status_label.setText(cause)
+
+    def show_partial_submodules(self, cause: str, usable: bool, cancelled: bool = False, explained: bool = False) -> None:
+        """Offer missing-child recovery separately from opening the preserved parent.
+
+        The state is shown in bold red, as a failure, unless the user cancelled the clone. An ``explained`` cause already
+        starts with the sentence that says which submodule Git could not check out, so it is shown as it is, without the
+        partial-clone sentence in front. Otherwise the partial-clone sentence comes first, once, even when the cause
+        already starts with it. Retry submodules stays offered either way.
+        """
+        self.partial = True
+        self.recursive_partial = True
+        self.set_running(False)
+        self.clone_button.setText("Retry submodules")
+        self.open_button.setVisible(usable)
+        text = cause if explained else SUBMODULE_PARTIAL_TEXT + "\n" + cause.removeprefix(SUBMODULE_PARTIAL_TEXT).lstrip("\n")
+        self.status_label.show_result(text, ResultTone.NEUTRAL if cancelled else ResultTone.FAILURE)
+
+    def clear_result(self) -> None:
+        """Put the ordinary help back once the user acts again, so an old error is never read as the answer to a new action.
+
+        A running clone keeps its wait text, and a partial clone keeps its message: it still describes what the form
+        offers (Retry submodules, Open repository).
+        """
+        if self.running or self.partial or self.status_label.tone is not ResultTone.FAILURE:
+            return
+        self.status_label.setText(EMPTY_HELP)
+
+    def _stop(self, partial: bool) -> None:
+        """Leave the running state and offer the action that fits what the clone left behind."""
+        self.partial = partial
+        self.set_running(False)
+        self.clone_button.setText("Open repository" if partial else "Clone")
+
+    def account_choice(self) -> str | None:
+        """Return the account namespace chosen for the new repository, or None when it follows the global default.
+
+        Without an HTTPS address, or with a greyed menu (no connected account for the address), no account applies and
+        None is returned too. The menu's own state is read, not the row's: a running clone greys the whole row
+        without changing the choice.
+        """
+        if not self.account_origin or not self.account_combo.isEnabledTo(self.account_section):
+            return None
+        return self.account_combo.currentData()
+
+    def _account_chosen_by_hand(self) -> None:
+        """Remember that the user picked the account, and drop the line of an earlier switch the form made by itself."""
+        self.account_chosen_by_user = True
+        self.forget_owner_switch()
+
+    def choose_owner_account(self, namespace: str, owner: str, note: str) -> None:
+        """Switch the menu to the account of the address's owner, say so under the check boxes and read the branches again with it.
+
+        The choice made before and the owner are kept, so that an address naming another owner can put that choice back.
+        Nothing changes when the menu does not offer that account. No signal is blocked: ``setCurrentIndex`` never emits
+        ``activated``, the only signal through which a choice by hand arrives.
+        """
+        index = self.account_combo.findData(namespace)
+        if index < 0:
+            return
+        self.account_before_owner_switch = self.account_choice()
+        self.owner_switch_namespace = namespace
+        self.owner_switch_owner = owner.casefold()
+        self.account_combo.setCurrentIndex(index)
+        self.show_account_status(note)
+        self.owner_account_note = note
+        self.restart_branch_list()
+
+    def forget_owner_switch(self) -> None:
+        """Drop what the form kept of its switch to the owner's account, and the line that said so while it is still shown."""
+        if self.owner_account_note and self.account_status_label.text() == self.owner_account_note:
+            self.show_account_status("")
+        self.owner_account_note = ""
+        self.owner_switch_namespace = ""
+        self.owner_switch_owner = ""
+        self.account_before_owner_switch = None
+
+    def show_account_state(self, text: str, add_account_enabled: bool) -> None:
+        """Grey the account menu with one line saying why no account can be chosen, and allow Add account… only when it can add one here.
+
+        The row stays in place whatever the URL, so the form never changes size. Signals are blocked so the change is
+        never taken for a user choice.
+        """
+        self.account_combo.blockSignals(True)
+        self.account_combo.clear()
+        self.account_combo.addItem(text, None)
+        self.account_combo.setEnabled(False)
+        self.account_combo.blockSignals(False)
+        self.account_combo.setToolTip("")
+        self.add_account_button.setEnabled(add_account_enabled)
+
+    def show_account_status(self, text: str) -> None:
+        """Write the line under the check boxes that reports on the account (sign-in result, unreadable accounts, submodule sign-in).
+
+        The line is shown only while it has something to say: an empty text hides it, so the help text moves back
+        right under the check boxes instead of leaving a blank line in the form.
+        """
+        self.account_status_label.setText(text)
+        self.account_status_label.setVisible(bool(text))
+
+    def reject(self) -> None:
+        """Request cancellation before closing any pending clone intention, including an open sign-in window."""
+        self.cancel_requested.emit()
+        add_dialog = self.add_account_dialog
+        if add_dialog is not None and isValid(add_dialog):
+            add_dialog.abandon()
+            add_dialog.reject()
+        super().reject()
+
+    def _build_account_section(self) -> QWidget:
+        """Build the Account row's field part: the account menu, with Add account… on its right where the other rows have Browse…."""
+        self.account_section = QWidget()
+        section_layout = QHBoxLayout(self.account_section)
+        section_layout.setContentsMargins(0, 0, 0, 0)
+        section_layout.setSpacing(FORM_GRID_COLUMN_SPACING)
+        self.account_combo = QComboBox()
+        self.account_combo.setAccessibleName("Account for this repository")
+        section_layout.addWidget(self.account_combo, 1)
+        self.add_account_button = self._side_button(ADD_ACCOUNT_TEXT)
+        section_layout.addWidget(self.add_account_button)
+        return self.account_section
+
+    def _side_button(self, text: str) -> QPushButton:
+        """Build a button of the right-hand column, which Enter never triggers: Enter is kept for Clone."""
+        button = QPushButton(text)
+        button.setAutoDefault(False)
+        return button
+
+    def _build_branch_marker_row(self) -> QHBoxLayout:
+        """Build the cell right of the Branch list, where the other rows have Browse…: a turning indicator and a warning icon of the same size.
+
+        Keeping them in the button column leaves the Branch list as wide as the other fields and adds no line under it.
+        The indicator takes no mouse input, so the reading text is only its accessible name; the icon carries the
+        failure text as a tooltip.
+        """
+        self.branch_busy_indicator = BusyIndicator()
+        self.branch_busy_indicator.setAccessibleName(BRANCH_LOADING_TEXT)
+        marker_size = self.branch_busy_indicator.sizeHint()
+        self.branch_warning_label = StandardIconLabel(marker_size, QStyle.StandardPixmap.SP_MessageBoxWarning)
+        self.branch_warning_label.setToolTip(BRANCH_FAILED_TEXT)
+        self.branch_warning_label.setAccessibleName(BRANCH_FAILED_TEXT)
+        self.branch_warning_label.hide()
+        marker_row = QHBoxLayout()
+        marker_row.setContentsMargins(0, 0, 0, 0)
+        marker_row.addWidget(self.branch_busy_indicator, 0, Qt.AlignmentFlag.AlignVCenter)
+        marker_row.addWidget(self.branch_warning_label, 0, Qt.AlignmentFlag.AlignVCenter)
+        marker_row.addStretch(1)
+        return marker_row
+
+    def _apply_windows_look(self) -> None:
+        """Give fields, lists and side buttons the Windows 10 look and height of the capture, and the side buttons one common width."""
+        for edit in (self.url_edit, self.name_edit):
+            apply_windows_line_edit_look(edit)
+        for combo, editable in ((self.account_combo, False), (self.destination_combo, True), (self.branch_combo, True)):
+            apply_windows_combo_look(combo, editable=editable)
+        folder_icon = action_icon("folder", self.devicePixelRatioF())
+        for button in (self.url_browse_button, self.browse_button):
+            button.setIcon(folder_icon)
+        apply_side_button_look((self.url_browse_button, self.browse_button, self.add_account_button))
+
+    def apply_theme_look(self) -> None:
+        """Lay everything of Clone's look that depends on the light or dark appearance; the one place that lays it again after a switch.
+
+        The fields, lists and side buttons take their light sheets or lose them, and the information box takes its own
+        yellow and shows its last line again in the color of the new appearance. Nothing the user typed or chose is
+        touched.
+        """
+        self._apply_windows_look()
+        self._paint_target_frame()
+        self._show_target(*self.shown_target)
+
+    def _paint_target_frame(self) -> None:
+        """Paint the target box in its own yellow, pale in a light theme and dark in a dark one, decided on the application palette.
+
+        The application palette tells the appearance the user chose; the form's own palette can be pinned by its layout.
+        """
+        dark = is_dark_palette(QApplication.palette())
+        palette = self.target_frame.palette()
+        palette.setColor(QPalette.ColorRole.Window, QColor(TARGET_BOX_DARK_BACKGROUND_COLOR if dark else TARGET_BOX_LIGHT_BACKGROUND_COLOR))
+        # A plain box draws its line in the text color, so the frame's text color is the border and the label keeps its own.
+        palette.setColor(QPalette.ColorRole.WindowText, QColor(TARGET_BOX_DARK_BORDER_COLOR if dark else TARGET_BOX_LIGHT_BORDER_COLOR))
+        self.target_frame.setPalette(palette)
+
+    def _show_target(self, target_dir: str, exists: bool | None) -> None:
+        """Say where the clone will go and, once checked, whether that folder is new; an existing folder is written in red.
+
+        ``exists`` is None while the check has not run yet for this path. The text takes the box's own color for the
+        appearance of the application palette, and what was shown is kept so the box can be shown again after the
+        appearance changes.
+        """
+        self.shown_target = (target_dir, exists)
+        line = target_dir
+        if target_dir and exists is not None:
+            line = target_dir + " " + (TARGET_EXISTS_TEXT if exists else TARGET_NEW_TEXT)
+        self.target_label.setText(TARGET_INTRO_TEXT + "\n" + line)
+        dark = is_dark_palette(QApplication.palette())
+        color = QColor(TARGET_BOX_DARK_TEXT_COLOR if dark else TARGET_BOX_LIGHT_TEXT_COLOR)
+        if exists:
+            color = QColor(ERROR_DARK_COLOR if dark else ERROR_LIGHT_COLOR)
+        palette = self.target_label.palette()
+        palette.setColor(QPalette.ColorRole.WindowText, color)
+        self.target_label.setPalette(palette)
+
+    def _stop_timers(self) -> None:
+        """Stop the pending branch list, the target check and the Branch row's turning indicator of a form that just closed.
+
+        A closed form stays alive, hidden, and its branch list is dropped by the clone controller, so nothing would ever stop
+        the indicator otherwise. A warning icon already shown stays: it costs nothing and is still true.
+        """
+        self.branch_timer.stop()
+        self.target_check_timer.stop()
+        self.branch_busy_indicator.stop()
+
+    def _check_target(self) -> None:
+        """Look whether the target folder exists, once the destination stopped changing.
+
+        Only this one path is looked at, and only after a pause: reading the disk while the form is filled or at each
+        key press would freeze the window on a disconnected network drive. A running clone creates the folder itself,
+        so it is not checked then.
+        """
+        target_dir = self.target_dir()
+        if self.running or not target_dir:
+            return
+        self._show_target(target_dir, self.target_exists(target_dir))
+
+    def _update_target(self) -> None:
+        """Keep the target box, the accessible action and the Clone button in step with the form, and plan a new existence check."""
+        target_dir = self.target_dir()
+        self.target_check_timer.stop()
+        self._show_target(target_dir, None)
+        if target_dir:
+            self.target_check_timer.start()
+        self.clone_button.setAccessibleDescription("Clone repository into " + target_dir)
+        self.clone_button.setEnabled(not self.running and bool(self.repository_url() and target_dir))
+
+    def _branch_name(self) -> str:
+        """Return the branch typed or chosen, without the blanks around it, or an empty text for the remote HEAD entry."""
+        text = typed_value(self.branch_combo.currentText())
+        index = self.branch_combo.findText(text)
+        if index < 0:
+            return text
+        data = self.branch_combo.itemData(index)
+        return text if data is None else str(data)
+
+    def _cancel_or_close(self) -> None:
+        """Keep a cancelled clone's form visible while its process finishes stopping."""
+        if self.running:
+            self.cancel_button.setEnabled(False)
+            self.status_label.setText(STOPPING_TEXT)
+            self.cancel_requested.emit()
+            return
+        self.reject()
+
+    def _submit(self) -> None:
+        """Emit one explicit action for the currently retained clone result."""
+        if not self.clone_button.isEnabled():
+            return
+        self.clear_result()
+        if self.recursive_partial:
+            self.retry_requested.emit()
+        elif self.partial:
+            self.open_requested.emit()
+        else:
+            self.clone_requested.emit()
+
+    def _name_edited(self, text: str) -> None:
+        self.custom_name = True
+
+    def _url_changed(self, text: str) -> None:
+        """Propose the last part of the URL or folder as the subdirectory until the user types one, and read the new URL's branches after a pause.
+
+        The branches of the previous URL are removed at once: they would describe another repository.
+        """
+        self._propose_name()
+        self._update_target()
+        self.show_branches(())
+        self.restart_branch_list()
+
+    def _repository_type_changed(self, bare: bool) -> None:
+        """Grey Initialize all submodules for a bare repository, which has no working tree, and propose the subdirectory with or without .git."""
+        self.submodule_check.setEnabled(not bare and not self.running and not self.partial)
+        self._propose_name()
+
+    def _propose_name(self) -> None:
+        """Propose the subdirectory from the URL, ending in .git for a bare repository, unless the user typed a name."""
+        if self.custom_name:
+            return
+        try:
+            name = suggested_name(self.repository_url())
+        except ValueError:
+            self.name_edit.clear()
+            return
+        if name and self.bare_radio.isChecked():
+            name += BARE_SUFFIX
+        self.name_edit.setText(name)
+
+    def _browse(self) -> None:
+        """Choose the destination folder asynchronously and preserve the typed text when cancelled."""
+        self._open_folder_dialog("Destination", self.destination_dir(), self.parent_edit)
+
+    def _browse_repository(self) -> None:
+        """Choose a local repository folder to clone, asynchronously, starting from the folder already typed if any.
+
+        The start folder follows the typed address, ``~`` read where that is the usage; an address that is not an
+        absolute folder starts from the destination instead.
+        """
+        start_dir = typed_start_dir(self.url_edit.text(), self.typed_path) or self.destination_dir()
+        self._open_folder_dialog("Repository to clone", start_dir, self.url_edit)
+
+    def _open_folder_dialog(self, title: str, start_dir: str, edit: QLineEdit) -> None:
+        """Open a folder chooser that writes the chosen folder into ``edit`` with the system's separators; cancelling changes nothing."""
+        dialog = QFileDialog(self, title, start_dir)
+        dialog.setFileMode(QFileDialog.FileMode.Directory)
+        dialog.setOption(QFileDialog.Option.ShowDirsOnly, True)
+        dialog.fileSelected.connect(lambda chosen_dir: edit.setText(os.path.normpath(chosen_dir)))
+        dialog.fileSelected.connect(self.clear_result)
+        dialog.finished.connect(dialog.deleteLater)
+        dialog.open()
+
+    def check_clipboard_repository(self, directory: str) -> None:
+        """Ask on a background thread whether a folder path found on the clipboard is a repository, and write it into the field if so.
+
+        The disk is never read on the form's thread: a sleeping disk or a dead share must not freeze the form. Nothing
+        is started from the path, and a path that is not a repository is dropped without a word, like any other text.
+        No mount table is read for the grouping: there is only one folder to ask about, so there is nothing to group.
+        """
+        if self.clipboard_repository_check is None:
+            self.clipboard_repository_check = RecentAvailabilityCheck(weak_signal_emitter(self, lambda form: form.clipboard_repository_checked),
+                                                                      is_reachable=self.is_clipboard_repository, read_mount_table=None)
+        self.clipboard_repository_check.request([directory])
+
+    def _fill_clipboard_repository(self, directory: str, is_repository: bool) -> None:
+        """Write a clipboard path found to be a repository into the field, only while the form is open and the field still empty.
+
+        The user may have typed or pasted an address while the disk answered: that text is never replaced.
+        """
+        check = self.clipboard_repository_check
+        if not is_repository or check is None or check.closed or self.url_edit.text():
+            return
+        self.url_edit.setText(directory)
+
+    def _close_clipboard_repository_check(self) -> None:
+        """Stop the clipboard path check of a finished form: an answer still to come is dropped."""
+        if self.clipboard_repository_check is not None:
+            self.clipboard_repository_check.close()
+
+    def _restore_focus(self) -> None:
+        """Return keyboard focus to the original welcome action when it still exists."""
+        if self.return_focus is not None and isValid(self.return_focus):
+            self.return_focus.setFocus()