gitpane 1.0.0__py3-none-any.whl

gitpane/ui/setting/account_page.py

@@ -0,0 +1,724 @@
+"""Show the Accounts page of Settings, from the list of connected service accounts to the account each address uses."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, Qt, Signal
+from PySide6.QtGui import QBrush, QColor, QFont
+from PySide6.QtWidgets import (
+    QApplication,
+    QComboBox,
+    QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QMessageBox,
+    QPushButton,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+from shiboken6 import isValid
+
+from gitpane.account.account_choice import CHOOSE_DEFAULT_TEXT, global_rows, offers_account, repository_account_view, service_text
+from gitpane.account.authentication import AccountCatalogue, SignInMethod, origin_address
+from gitpane.config import SPACING_MD, SPACING_SM
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.ui.look.theme_color import is_dark_palette
+from gitpane.ui.look.theme_look import PALETTE_EVENT_TYPE_SET
+from gitpane.ui.setting.setting_block import GLOBAL_TITLE, REPOSITORY_TITLE, block_group
+from gitpane.ui.widget.long_text import FRAME_SIDE_COUNT
+from gitpane.ui.widget.plain_label import plain_label
+from gitpane.ui.widget.result_label import ResultLabel, ResultTone, result_color
+from gitpane.ui.window_control.dialog_modality import open_window_modal, prepare_message_box
+
+if TYPE_CHECKING:
+    from gitpane.account.account_choice import GlobalRow, RepositoryRow
+    from gitpane.account.authentication import AccountRemoval, AccountSelection, AuthOutcome
+    from gitpane.transport.remote_config import RemoteEntry
+    from gitpane.ui.setting.add_account_dialog import AddAccountDialog
+
+SERVICE_COLUMN, ADDRESS_COLUMN, ACCOUNT_COLUMN, TYPE_COLUMN, STATUS_COLUMN = 0, 1, 2, 3, 4
+ACCOUNT_COLUMN_TITLES = ("Service", "Address", "Account", "Type", "Status")
+UNKNOWN_TYPE_TOOLTIP_TEXT = "This account was added before GitPane recorded how accounts sign in. Reconnect it to record it."
+# Shown for an account whose stored secret is gone, typically erased by Git after a server refused it.
+NEEDS_RECONNECT_STATUS_TEXT = "Needs reconnect"
+NEEDS_RECONNECT_TOOLTIP_TEXT = "Its saved sign-in is no longer in the system credential store. Select it and click Reconnect."
+# Shown for an account whose stored secret a check of the system credential store found.
+OK_STATUS_TEXT = "OK"
+# Every text the Status column can show; it keeps the width of the widest one so it never jumps or hides when a check answers.
+STATUS_TEXTS = (OK_STATUS_TEXT, NEEDS_RECONNECT_STATUS_TEXT)
+# Columns as wide as their content; Address takes the rest of the list and cuts a long address with an ellipsis.
+CONTENT_WIDTH_COLUMNS = (SERVICE_COLUMN, ACCOUNT_COLUMN, TYPE_COLUMN)
+# The single column of the hidden list that measures the Status texts.
+PROBE_COLUMN = 0
+ACCOUNT_LIST_STRETCH = 1
+EMPTY_ACCOUNT_LIST_TEXT = "No connected accounts yet. Use Add account… to connect one."
+ACCOUNTS_PAGE_NAME = "Accounts"
+PLACE_SEPARATOR = " › "
+UNSAVED_MARK = " *"
+EMPTY_GLOBAL_TEXT = "No connected accounts yet. Use Add account… above."
+GLOBAL_SAVED_TEXT = "Global settings saved."
+NO_REPOSITORY_ACCOUNT_TEXT = "Open a repository to choose the account it uses."
+READING_REMOTES_TEXT = "Reading this repository's remotes…"
+NO_HTTPS_REMOTE_TEXT = "This repository has no HTTPS remote."
+MISSING_CHOICE_TEXT = "The account chosen for this repository is no longer connected. Choose another account."
+SUBMODULE_HELP_TEXT = "This account is used for this repository only. Submodules use their own setting, or the global default for their service."
+REPOSITORY_SAVED_TEXT = "Repository settings saved."
+CREDENTIAL_MANAGER_GROUP_TITLE = "Git credential manager"
+# Shown in the credential manager line while the search started by the opening of Settings runs.
+CREDENTIAL_MANAGER_CHECKING_TEXT = "Checking…"
+SIGN_IN_PLACE_NAME = "Sign-in in progress"
+ROW_LABEL_COLUMN, ROW_CHOICE_COLUMN = 0, 1
+ROW_COLUMN_COUNT = 2
+ROW_SPAN = 1
+ROW_CHOICE_STRETCH = 1
+NO_SELECTION_INDEX = -1
+FOLLOW_DEFAULT_INDEX = 0
+FIRST_LAYOUT_ITEM_INDEX = 0
+EMPTY_CATALOGUE = AccountCatalogue((), {}, {})
+REMOVE_ACCOUNT_BUTTON_TEXT = "Remove account…"
+REMOVE_TITLE = "Remove account"
+REMOVE_QUESTION_TEXT = "Remove {label} ({address}) from Connected accounts?"
+REMOVE_DETAIL_TEXT = ("Its stored password or token is erased from this computer. Repositories and their files do not change. "
+                      "Where this account was the default or a repository's choice, GitPane will ask for another account.")
+REMOVE_CONFIRM_TEXT = "Remove account"
+KEEP_ACCOUNT_TEXT = "Keep account"
+REMOVING_TEXT = "Removing {label}…"
+REMOVED_TEXT = "{label} was removed from Connected accounts."
+DEFAULT_CLEARED_TEXT = " Choose a new default account for {address} in Global."
+REPOSITORY_CHOICE_CLEARED_TEXT = " Repositories that used it must choose another account."
+NOT_ERASED_TEXT = "{label} was not removed: its stored password or token could not be erased. "
+# Start of the Accounts page result when the removal was refused before anything was erased.
+ACCOUNT_NOT_REMOVED_TEXT = "{label} was not removed. "
+LIST_NOT_SAVED_TEXT = "The stored password or token of {label} was erased, but Connected accounts could not be saved. "
+
+
+def removal_result_text(selection: AccountSelection, removal: AccountRemoval) -> str:
+    """Say that the account is gone and what the user now has to choose again.
+
+    A cleared default is only worth mentioning while its address still has an account to choose; the next account added
+    there becomes its default by itself.
+    """
+    text = REMOVED_TEXT.format(label=selection.label)
+    if removal.default_cleared and removal.address_has_account:
+        text += DEFAULT_CLEARED_TEXT.format(address=origin_address(selection.origin))
+    if removal.repository_choice_count:
+        text += REPOSITORY_CHOICE_CLEARED_TEXT
+    return text
+
+
+def removal_failure_text(selection: AccountSelection, outcome: AuthOutcome) -> str:
+    """Say which step of a removal failed, followed by the prepared cause, never the raw helper output.
+
+    A removal refused before anything ran, for example while a sign-in is still running or when the credential manager
+    found cannot be used, erased nothing, so only the service's reason is worth showing.
+    """
+    cause = outcome.diagnostic.cause if outcome.diagnostic is not None and outcome.diagnostic.cause else outcome.status.value
+    if outcome.status == OperationStatus.PARTIAL:
+        return LIST_NOT_SAVED_TEXT.format(label=selection.label) + cause
+    if outcome.refused_before_start:
+        return ACCOUNT_NOT_REMOVED_TEXT.format(label=selection.label) + cause
+    return NOT_ERASED_TEXT.format(label=selection.label) + cause
+
+
+def fill_global_combo(combo: QComboBox, row: GlobalRow, selected_namespace: str | None) -> None:
+    """Offer every account of the row's address and show the chosen one; with none chosen the menu stays empty and asks for a choice.
+
+    There is no 'no default' entry: a default can only be replaced by another account. Signals are blocked so filling
+    the menu is never taken for a user choice.
+    """
+    combo.blockSignals(True)
+    combo.clear()
+    combo.setPlaceholderText(CHOOSE_DEFAULT_TEXT)
+    selected_index = NO_SELECTION_INDEX
+    for choice in row.choices:
+        combo.addItem(choice.text, choice.namespace)
+        if choice.namespace == selected_namespace:
+            selected_index = combo.count() - 1
+    combo.setCurrentIndex(selected_index)
+    combo.blockSignals(False)
+
+
+def fill_repository_combo(combo: QComboBox, row: RepositoryRow, selected_namespace: str | None) -> None:
+    """Offer 'Use global default — …' first, then every account of the row's address, and show the chosen one.
+
+    The first entry carries no account, so choosing it means following the Global default. An address without any
+    connected account leaves only that entry, which then explains how to add one, in a disabled menu. Signals are
+    blocked so filling the menu is never taken for a user choice.
+    """
+    combo.blockSignals(True)
+    combo.clear()
+    combo.addItem(row.default_text, None)
+    selected_index = FOLLOW_DEFAULT_INDEX
+    for choice in row.choices:
+        combo.addItem(choice.text, choice.namespace)
+        if choice.namespace == selected_namespace:
+            selected_index = combo.count() - 1
+    combo.setCurrentIndex(selected_index)
+    combo.setEnabled(bool(row.choices))
+    combo.blockSignals(False)
+
+
+def repository_draft_needed(row: RepositoryRow, namespace: str | None) -> bool:
+    """Tell whether choosing this account for the row leaves something to save.
+
+    A saved choice naming an account no longer listed must be replaced, so any choice on such a row is worth saving.
+    """
+    return row.missing_choice or namespace != row.chosen_namespace
+
+
+def clear_grid(grid: QGridLayout) -> None:
+    """Remove and delete every widget of a grid so its rows can be built again."""
+    while grid.count():
+        item = grid.takeAt(FIRST_LAYOUT_ITEM_INDEX)
+        widget = item.widget()
+        if widget is not None:
+            widget.setParent(None)
+            widget.deleteLater()
+
+
+def row_grid() -> QGridLayout:
+    """Build the two-column grid of a choice block: the address on the left, its menu on the right."""
+    grid = QGridLayout()
+    grid.setHorizontalSpacing(SPACING_MD)
+    grid.setVerticalSpacing(SPACING_SM)
+    grid.setColumnStretch(ROW_CHOICE_COLUMN, ROW_CHOICE_STRETCH)
+    return grid
+
+
+class AccountPage(QWidget):
+    """List every connected account, let the user choose the accounts used, and ask the account controller to save; no account rule lives here.
+
+    Each choice block keeps a draft of the rows the user changed. A refresh rebuilds every row but shows the draft for a
+    changed row, so a new account, an automatic default or a write from another window never erases what the user chose.
+    """
+
+    add_account_requested = Signal()
+    reconnect_requested = Signal()
+    remove_account_requested = Signal(str)
+    save_global_requested = Signal()
+    save_repository_requested = Signal()
+
+    def __init__(self, repository_dir: str | None, parent: QWidget | None = None) -> None:
+        """Build the Connected accounts list and the choice blocks; ``repository_dir`` is the repository these settings were opened for, if any."""
+        super().__init__(parent)
+        self.repository_dir = repository_dir
+        self.sign_in_dialog: AddAccountDialog | None = None
+        self.remove_confirmation: QMessageBox | None = None
+        self.removing = False
+        self.catalogue = EMPTY_CATALOGUE
+        # Accounts whose stored secret a check found. Status says OK only for them: a check after a refused transfer
+        # covers a single account, so an answer says nothing about the accounts it did not check.
+        self.secret_found_namespace_set: set[str] = set()
+        self.global_rows: tuple[GlobalRow, ...] = ()
+        self.global_combo_by_origin: dict[str, QComboBox] = {}
+        self.global_label_by_origin: dict[str, QLabel] = {}
+        self.global_draft_namespace_by_origin: dict[str, str] = {}
+        # None until the repository's remotes have been read; the account controller bumps the generation for each new read.
+        self.remote_entries: tuple[RemoteEntry, ...] | None = None
+        self.remote_generation = 0
+        self.repository_rows: tuple[RepositoryRow, ...] = ()
+        self.repository_ssh_notes: tuple[str, ...] = ()
+        self.repository_combo_by_origin: dict[str, QComboBox] = {}
+        self.repository_label_by_origin: dict[str, QLabel] = {}
+        # None as a draft value means the row follows the Global default.
+        self.repository_draft_namespace_by_origin: dict[str, str | None] = {}
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(SPACING_SM)
+        # Above the list, so the reason Settings opened by itself is the first thing read.
+        self.account_notice_label = ResultLabel()
+        self.account_notice_label.setVisible(False)
+        self.account_notice_address = ""
+        layout.addWidget(self.account_notice_label)
+        self.account_group = QGroupBox("Connected accounts")
+        body = QHBoxLayout(self.account_group)
+        body.setSpacing(SPACING_SM)
+        self.account_tree = QTreeWidget()
+        self.account_tree.setColumnCount(len(ACCOUNT_COLUMN_TITLES))
+        self.account_tree.setHeaderLabels(list(ACCOUNT_COLUMN_TITLES))
+        self.account_tree.setRootIsDecorated(False)
+        self.account_tree.setAccessibleName("Connected accounts")
+        header = self.account_tree.header()
+        header.setStretchLastSection(False)
+        for column in CONTENT_WIDTH_COLUMNS:
+            header.setSectionResizeMode(column, QHeaderView.ResizeMode.ResizeToContents)
+        header.setSectionResizeMode(ADDRESS_COLUMN, QHeaderView.ResizeMode.Stretch)
+        header.setSectionResizeMode(STATUS_COLUMN, QHeaderView.ResizeMode.Fixed)
+        self._fit_status_column()
+        body.addWidget(self.account_tree, ACCOUNT_LIST_STRETCH)
+        tools = QVBoxLayout()
+        self.add_account_button = QPushButton("Add account…")
+        self.add_account_button.setAutoDefault(False)
+        self.add_account_button.clicked.connect(self.add_account_requested)
+        self.reconnect_button = QPushButton("Reconnect")
+        self.reconnect_button.setAutoDefault(False)
+        self.reconnect_button.setEnabled(False)
+        self.reconnect_button.clicked.connect(self.reconnect_requested)
+        self.remove_account_button = QPushButton(REMOVE_ACCOUNT_BUTTON_TEXT)
+        self.remove_account_button.setAutoDefault(False)
+        self.remove_account_button.setEnabled(False)
+        self.remove_account_button.clicked.connect(self._confirm_removal)
+        tools.addWidget(self.add_account_button)
+        tools.addWidget(self.reconnect_button)
+        tools.addWidget(self.remove_account_button)
+        tools.addStretch()
+        body.addLayout(tools)
+        layout.addWidget(self.account_group)
+        self.status_label = ResultLabel()
+        layout.addWidget(self.status_label)
+        self.global_group, global_layout = block_group(GLOBAL_TITLE)
+        global_layout.addWidget(plain_label("Default account of each service address, used by every repository that does not choose its own."))
+        self.global_grid = row_grid()
+        global_layout.addLayout(self.global_grid)
+        self.global_empty_label = plain_label(EMPTY_GLOBAL_TEXT)
+        global_layout.addWidget(self.global_empty_label)
+        self.global_status_label = ResultLabel()
+        global_layout.addWidget(self.global_status_label)
+        self.save_global_button = QPushButton("Save global settings")
+        self.save_global_button.setAutoDefault(False)
+        self.save_global_button.clicked.connect(self.save_global_requested)
+        global_layout.addWidget(self.save_global_button, alignment=Qt.AlignmentFlag.AlignLeft)
+        layout.addWidget(self.global_group)
+        self.repository_group, repository_layout = block_group(REPOSITORY_TITLE)
+        self.repository_path_label = plain_label(repository_dir if repository_dir is not None else NO_REPOSITORY_ACCOUNT_TEXT)
+        repository_layout.addWidget(self.repository_path_label)
+        self.repository_remote_label = plain_label(READING_REMOTES_TEXT if repository_dir is not None else "")
+        repository_layout.addWidget(self.repository_remote_label)
+        self.repository_grid = row_grid()
+        repository_layout.addLayout(self.repository_grid)
+        self.repository_help_label = plain_label(SUBMODULE_HELP_TEXT)
+        repository_layout.addWidget(self.repository_help_label)
+        self.repository_status_label = ResultLabel()
+        repository_layout.addWidget(self.repository_status_label)
+        self.save_repository_button = QPushButton("Save this repository settings")
+        self.save_repository_button.setAutoDefault(False)
+        self.save_repository_button.clicked.connect(self.save_repository_requested)
+        repository_layout.addWidget(self.save_repository_button, alignment=Qt.AlignmentFlag.AlignLeft)
+        self.repository_group.setEnabled(repository_dir is not None)
+        layout.addWidget(self.repository_group)
+        # Last block, so the accounts come first. Read only and without any button: opening Settings again searches again.
+        self.credential_manager_group, credential_manager_layout = block_group(CREDENTIAL_MANAGER_GROUP_TITLE)
+        self.credential_manager_label = ResultLabel()
+        credential_manager_layout.addWidget(self.credential_manager_label)
+        layout.addWidget(self.credential_manager_group)
+        layout.addStretch()
+        self.account_tree.itemSelectionChanged.connect(self._selection_changed)
+        self._render_global()
+        self._refresh_block_state()
+
+    def show_credential_manager_checking(self) -> None:
+        """Say, in the ordinary tone, that the search for the credential manager is still running."""
+        self.credential_manager_label.show_result(CREDENTIAL_MANAGER_CHECKING_TEXT, ResultTone.NEUTRAL)
+
+    def show_credential_manager(self, text: str, refused: bool) -> None:
+        """Show which credential manager GitPane uses in the ordinary tone, or why none is usable in red, like the red line of a refused operation."""
+        if refused:
+            self.credential_manager_label.show_failure(text)
+            return
+        self.credential_manager_label.show_result(text, ResultTone.NEUTRAL)
+
+    def show_account_notice(self, text: str, address: str) -> None:
+        """Show in orange, above Connected accounts, why an operation needs an account here; a newer refusal replaces an older one.
+
+        ``address`` is kept so that only a sign-in on that same address clears the notice.
+        """
+        self.account_notice_address = address
+        self.account_notice_label.show_warning(text)
+        self.account_notice_label.setVisible(True)
+
+    def clear_account_notice(self, address: str = "") -> None:
+        """Hide the refusal notice once the account it asked for is connected; an empty address clears any notice.
+
+        Host names are compared regardless of case, since a typed URL keeps whatever case the user wrote.
+        """
+        if address and address.casefold() != self.account_notice_address.casefold():
+            return
+        self.account_notice_address = ""
+        self.account_notice_label.clear()
+        self.account_notice_label.setVisible(False)
+
+    def show_catalogue(self, catalogue: AccountCatalogue) -> None:
+        """Show a fresh read of the accounts: the list in the catalogue's order and every choice row, keeping the rows the user changed.
+
+        The Type column says how each account signs in: browser, token, or username + password.
+        """
+        self.catalogue = catalogue
+        selected_namespace = self.selected_namespace()
+        self.account_tree.clear()
+        selected_item = None
+        for selection in catalogue.accounts:
+            item = QTreeWidgetItem()
+            item.setText(SERVICE_COLUMN, service_text(catalogue, selection))
+            item.setText(ADDRESS_COLUMN, origin_address(selection.origin))
+            item.setText(ACCOUNT_COLUMN, selection.label)
+            sign_in_method = catalogue.sign_in_method_by_namespace.get(selection.namespace, SignInMethod.BROWSER_OR_TOKEN)
+            item.setText(TYPE_COLUMN, sign_in_method.type_label)
+            if sign_in_method == SignInMethod.BROWSER_OR_TOKEN:
+                item.setToolTip(TYPE_COLUMN, UNKNOWN_TYPE_TOOLTIP_TEXT)
+            item.setData(SERVICE_COLUMN, Qt.ItemDataRole.UserRole, selection.namespace)
+            self.account_tree.addTopLevelItem(item)
+            if selection.namespace == selected_namespace:
+                selected_item = item
+        self._render_status()
+        if selected_item is not None:
+            self.account_tree.setCurrentItem(selected_item)
+        if not catalogue.accounts:
+            self.status_label.setText(EMPTY_ACCOUNT_LIST_TEXT)
+        elif self.status_label.text() == EMPTY_ACCOUNT_LIST_TEXT:
+            self.status_label.clear()
+        self._selection_changed()
+        self._render_global()
+        self._render_repository()
+        self._refresh_block_state()
+
+    def show_needs_reconnect(self, namespace_set: frozenset[str], present_namespace_set: frozenset[str] = frozenset()) -> None:
+        """Show, in the Status column only, the answer of a check of the stored secrets; every other row and block stays as it is.
+
+        ``namespace_set`` names every listed account known to need a reconnect; ``present_namespace_set`` the accounts
+        this check found with their secret, which then say OK. Used when the check answers after the list was shown, so
+        the choice blocks and their open menus are never rebuilt under the user.
+        """
+        self.catalogue = replace(self.catalogue, needs_reconnect_namespace_set=frozenset(namespace_set))
+        self.secret_found_namespace_set -= namespace_set
+        self.secret_found_namespace_set |= present_namespace_set - namespace_set
+        self._render_status()
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Pick the light or dark colours of the Status column again when the theme changes, and its width when the text size does."""
+        super().changeEvent(event)
+        if event.type() in PALETTE_EVENT_TYPE_SET:
+            self._render_status()
+        # A style or font change can arrive while the base class is still being built, before the list exists.
+        if event.type() in (QEvent.Type.FontChange, QEvent.Type.StyleChange) and hasattr(self, "account_tree"):
+            self._fit_status_column()
+
+    def _render_status(self) -> None:
+        """Write the Status column: ``Needs reconnect`` in bold error colour for an account whose secret is gone, ``OK`` in the success colour for one a check found, empty otherwise.
+
+        Nothing is said before a check answered for the account: an empty cell never claims the account works.
+        """
+        dark = is_dark_palette(QApplication.palette())
+        for index in range(self.account_tree.topLevelItemCount()):
+            item = self.account_tree.topLevelItem(index)
+            namespace = item.data(SERVICE_COLUMN, Qt.ItemDataRole.UserRole)
+            font = item.font(STATUS_COLUMN)
+            if namespace in self.catalogue.needs_reconnect_namespace_set:
+                item.setText(STATUS_COLUMN, NEEDS_RECONNECT_STATUS_TEXT)
+                item.setToolTip(STATUS_COLUMN, NEEDS_RECONNECT_TOOLTIP_TEXT)
+                item.setForeground(STATUS_COLUMN, QBrush(QColor(result_color(ResultTone.FAILURE, dark))))
+                font.setBold(True)
+                item.setFont(STATUS_COLUMN, font)
+                continue
+            font.setBold(False)
+            item.setFont(STATUS_COLUMN, font)
+            item.setToolTip(STATUS_COLUMN, "")
+            if namespace in self.secret_found_namespace_set:
+                item.setText(STATUS_COLUMN, OK_STATUS_TEXT)
+                item.setForeground(STATUS_COLUMN, QBrush(QColor(result_color(ResultTone.SUCCESS, dark))))
+                continue
+            item.setText(STATUS_COLUMN, "")
+            item.setData(STATUS_COLUMN, Qt.ItemDataRole.ForegroundRole, None)
+
+    def _fit_status_column(self) -> None:
+        """Give the Status column the width of its title or of its widest possible text, in bold, so a check's answer never widens it.
+
+        The texts are measured in a hidden one-column list with the same font and style, which gives the width the
+        list's own cells need, margins included.
+        """
+        tree = self.account_tree
+        probe = QTreeWidget()
+        probe.setFont(tree.font())
+        probe.setStyle(tree.style())
+        probe.setColumnCount(1)
+        probe.setRootIsDecorated(False)
+        bold_font = QFont(tree.font())
+        bold_font.setBold(True)
+        for text in STATUS_TEXTS:
+            item = QTreeWidgetItem([text])
+            item.setFont(PROBE_COLUMN, bold_font)
+            probe.addTopLevelItem(item)
+        header = tree.header()
+        header.resizeSection(STATUS_COLUMN, max(header.sectionSizeHint(STATUS_COLUMN), probe.sizeHintForColumn(PROBE_COLUMN)))
+        probe.deleteLater()
+
+    def needed_width(self) -> int:
+        """Return the page width at which Connected accounts shows every column whole, Status included, without scrolling sideways.
+
+        Settings opens at least this wide, within the screen. The list is the only control of its block whose width
+        depends on the accounts, so the block needs its own minimum plus what the list's columns need beyond the list's minimum.
+        """
+        tree = self.account_tree
+        header = tree.header()
+        columns_width = header.sectionSize(STATUS_COLUMN)
+        for column in (*CONTENT_WIDTH_COLUMNS, ADDRESS_COLUMN):
+            columns_width += max(header.sectionSizeHint(column), tree.sizeHintForColumn(column))
+        tree_width = columns_width + tree.frameWidth() * FRAME_SIDE_COUNT
+        group_width = self.account_group.minimumSizeHint().width() - tree.minimumSizeHint().width() + tree_width
+        return max(self.minimumSizeHint().width(), group_width)
+
+    def show_remotes(self, entries: tuple[RemoteEntry, ...]) -> None:
+        """Show a fresh read of this repository's remotes as one row per HTTPS address, keeping the rows the user changed."""
+        self.remote_entries = tuple(entries)
+        self.repository_remote_label.clear()
+        self._render_repository()
+        self._refresh_block_state()
+        if not self.repository_rows and not self.repository_ssh_notes:
+            self.repository_remote_label.setText(NO_HTTPS_REMOTE_TEXT)
+
+    def show_remote_error(self, text: str) -> None:
+        """Explain why the remotes could not be read; rows already shown and the draft stay as they are."""
+        self.repository_remote_label.setText(text)
+
+    def repository_changes(self) -> dict[str, str | None]:
+        """Return the rows changed in This repository and not saved yet; None means the row follows the Global default again."""
+        return dict(self.repository_draft_namespace_by_origin)
+
+    def repository_saved(self) -> None:
+        """Forget the This repository draft after a successful save; the Global block keeps its own draft."""
+        self.repository_draft_namespace_by_origin.clear()
+        self._render_repository()
+        self._refresh_block_state()
+        self.repository_status_label.show_success(REPOSITORY_SAVED_TEXT)
+
+    def show_repository_error(self, text: str) -> None:
+        """Explain a failed This repository save inside the block, keeping the draft so the user can retry."""
+        self.repository_status_label.show_failure(text)
+
+    def unsaved_place_names(self) -> list[str]:
+        """Name the places of this page holding unsaved work, in page order, so closing or saving Settings can say what would be lost."""
+        place_names = []
+        if self.global_draft_namespace_by_origin:
+            place_names.append(ACCOUNTS_PAGE_NAME + PLACE_SEPARATOR + GLOBAL_TITLE)
+        if self.repository_draft_namespace_by_origin:
+            place_names.append(ACCOUNTS_PAGE_NAME + PLACE_SEPARATOR + REPOSITORY_TITLE)
+        if self.sign_in_dialog is not None and isValid(self.sign_in_dialog) and self.sign_in_dialog.running:
+            place_names.append(ACCOUNTS_PAGE_NAME + PLACE_SEPARATOR + SIGN_IN_PLACE_NAME)
+        return place_names
+
+    def selected_namespace(self) -> str | None:
+        """Return the store namespace of the selected account, or None when no row is selected."""
+        items = self.account_tree.selectedItems()
+        if not items:
+            return None
+        first_item_index = 0
+        return items[first_item_index].data(SERVICE_COLUMN, Qt.ItemDataRole.UserRole)
+
+    def show_message(self, text: str, tone: ResultTone = ResultTone.NEUTRAL) -> None:
+        """Show the result of the last account action under the list, in green when it worked and in red when it failed."""
+        self.status_label.show_result(text, tone)
+
+    def global_changes(self) -> dict[str, str]:
+        """Return the defaults changed in the Global block and not saved yet, by service address."""
+        return dict(self.global_draft_namespace_by_origin)
+
+    def global_saved(self) -> None:
+        """Forget the Global draft after a successful save; the other block keeps its own draft."""
+        self.global_draft_namespace_by_origin.clear()
+        self._render_global()
+        self._refresh_block_state()
+        self.global_status_label.show_success(GLOBAL_SAVED_TEXT)
+
+    def show_global_error(self, text: str) -> None:
+        """Explain a failed Global save inside the block, keeping the draft so the user can retry."""
+        self.global_status_label.show_failure(text)
+
+    def abandon_sign_in(self) -> None:
+        """Close the open sign-in window, if any, so no late result can reach it and its token is dropped."""
+        dialog = self.sign_in_dialog
+        self.sign_in_dialog = None
+        if dialog is None or not isValid(dialog):
+            return
+        dialog.abandon()
+        dialog.reject()
+
+    def _render_global(self) -> None:
+        """Build one row per service address; a changed row shows its draft, others the saved default.
+
+        A draft that now equals the saved default, or names an account no longer offered, is dropped: nothing is left to save.
+        """
+        rows = global_rows(self.catalogue)
+        row_by_origin = {}
+        for row in rows:
+            row_by_origin[row.origin] = row
+        for origin in tuple(self.global_draft_namespace_by_origin):
+            row = row_by_origin.get(origin)
+            namespace = self.global_draft_namespace_by_origin[origin]
+            if row is None or namespace == row.default_namespace or not offers_account(row.choices, namespace):
+                del self.global_draft_namespace_by_origin[origin]
+        clear_grid(self.global_grid)
+        self.global_rows = rows
+        self.global_combo_by_origin = {}
+        self.global_label_by_origin = {}
+        for row in rows:
+            label = plain_label(row.title)
+            combo = QComboBox()
+            combo.setAccessibleName("Default account for " + row.address)
+            label.setBuddy(combo)
+            fill_global_combo(combo, row, self.global_draft_namespace_by_origin.get(row.origin, row.default_namespace))
+            combo.activated.connect(lambda _index, origin=row.origin: self._global_chosen(origin))
+            grid_row = self.global_grid.rowCount()
+            self.global_grid.addWidget(label, grid_row, ROW_LABEL_COLUMN)
+            self.global_grid.addWidget(combo, grid_row, ROW_CHOICE_COLUMN)
+            self.global_label_by_origin[row.origin] = label
+            self.global_combo_by_origin[row.origin] = combo
+        self.global_empty_label.setVisible(not rows)
+
+    def _global_chosen(self, origin: str) -> None:
+        """Record the user's choice for one address; choosing the saved default again means nothing is left to save there."""
+        combo = self.global_combo_by_origin.get(origin)
+        row = self._global_row(origin)
+        if combo is None or row is None:
+            return
+        namespace = combo.currentData()
+        if namespace is None or namespace == row.default_namespace:
+            self.global_draft_namespace_by_origin.pop(origin, None)
+        else:
+            self.global_draft_namespace_by_origin[origin] = namespace
+        self.global_status_label.clear()
+        self._refresh_block_state()
+
+    def _global_row(self, origin: str) -> GlobalRow | None:
+        """Find the displayed Global row of this address."""
+        for row in self.global_rows:
+            if row.origin == origin:
+                return row
+        return None
+
+    def _render_repository(self) -> None:
+        """Build one row per HTTPS address of the remotes and one note per SSH remote; a changed row shows its draft.
+
+        Nothing is built before the remotes have been read. A draft whose address left the remotes, that names an account
+        no longer offered, or that now equals the saved choice is dropped: nothing is left to save there.
+        """
+        clear_grid(self.repository_grid)
+        self.repository_combo_by_origin = {}
+        self.repository_label_by_origin = {}
+        if self.remote_entries is None:
+            self.repository_rows = ()
+            self.repository_ssh_notes = ()
+            return
+        view = repository_account_view(self.catalogue, self.remote_entries)
+        row_by_origin = {}
+        for row in view.rows:
+            row_by_origin[row.origin] = row
+        for origin in tuple(self.repository_draft_namespace_by_origin):
+            row = row_by_origin.get(origin)
+            namespace = self.repository_draft_namespace_by_origin[origin]
+            if row is None or (namespace is not None and not offers_account(row.choices, namespace)) or not repository_draft_needed(row, namespace):
+                del self.repository_draft_namespace_by_origin[origin]
+        self.repository_rows = view.rows
+        self.repository_ssh_notes = view.ssh_notes
+        for row in view.rows:
+            label = plain_label(row.title)
+            combo = QComboBox()
+            combo.setAccessibleName("Account for " + row.address + " in this repository")
+            label.setBuddy(combo)
+            drafted = row.origin in self.repository_draft_namespace_by_origin
+            fill_repository_combo(combo, row, self.repository_draft_namespace_by_origin[row.origin] if drafted else row.chosen_namespace)
+            if row.missing_choice and not drafted:
+                combo.setCurrentIndex(NO_SELECTION_INDEX)
+            combo.activated.connect(lambda _index, origin=row.origin: self._repository_chosen(origin))
+            grid_row = self.repository_grid.rowCount()
+            self.repository_grid.addWidget(label, grid_row, ROW_LABEL_COLUMN)
+            self.repository_grid.addWidget(combo, grid_row, ROW_CHOICE_COLUMN)
+            if row.missing_choice:
+                self.repository_grid.addWidget(plain_label(MISSING_CHOICE_TEXT), self.repository_grid.rowCount(), ROW_CHOICE_COLUMN)
+            self.repository_label_by_origin[row.origin] = label
+            self.repository_combo_by_origin[row.origin] = combo
+        for note in view.ssh_notes:
+            self.repository_grid.addWidget(plain_label(note), self.repository_grid.rowCount(), ROW_LABEL_COLUMN, ROW_SPAN, ROW_COLUMN_COUNT)
+
+    def _repository_chosen(self, origin: str) -> None:
+        """Record the user's choice for one address of this repository; choosing the saved one again leaves nothing to save there."""
+        combo = self.repository_combo_by_origin.get(origin)
+        row = self._repository_row(origin)
+        if combo is None or row is None:
+            return
+        namespace = combo.currentData()
+        if repository_draft_needed(row, namespace):
+            self.repository_draft_namespace_by_origin[origin] = namespace
+        else:
+            self.repository_draft_namespace_by_origin.pop(origin, None)
+        self.repository_status_label.clear()
+        self._refresh_block_state()
+
+    def _repository_row(self, origin: str) -> RepositoryRow | None:
+        """Find the displayed This repository row of this address."""
+        for row in self.repository_rows:
+            if row.origin == origin:
+                return row
+        return None
+
+    def _refresh_block_state(self) -> None:
+        """Mark a block with unsaved choices in its title and enable its Save button only then."""
+        global_changed = bool(self.global_draft_namespace_by_origin)
+        self.global_group.setTitle(GLOBAL_TITLE + UNSAVED_MARK if global_changed else GLOBAL_TITLE)
+        self.save_global_button.setEnabled(global_changed)
+        repository_changed = bool(self.repository_draft_namespace_by_origin)
+        self.repository_group.setTitle(REPOSITORY_TITLE + UNSAVED_MARK if repository_changed else REPOSITORY_TITLE)
+        self.save_repository_button.setEnabled(repository_changed and self.repository_dir is not None)
+
+    def set_removing(self, running: bool, label: str = "") -> None:
+        """Lock the account actions while a removal runs and say which account is being removed; unlock them when it ends."""
+        self.removing = running
+        self.add_account_button.setEnabled(not running)
+        self._selection_changed()
+        if running:
+            self.status_label.setText(REMOVING_TEXT.format(label=label))
+
+    def _confirm_removal(self) -> None:
+        """Ask before removing the selected account, without blocking the application; Keep account is the default and the answer of Escape.
+
+        Only one question is open at a time. The account is captured when asking, so changing the selection meanwhile
+        cannot redirect the removal to another account.
+        """
+        if self.remove_confirmation is not None and isValid(self.remove_confirmation):
+            self.remove_confirmation.raise_()
+            self.remove_confirmation.activateWindow()
+            return
+        selection = self._selected_account()
+        if selection is None or self.removing:
+            return
+        box = QMessageBox(QMessageBox.Icon.Warning, REMOVE_TITLE, REMOVE_QUESTION_TEXT.format(label=selection.label, address=origin_address(selection.origin)), parent=self)
+        prepare_message_box(box, REMOVE_TITLE)
+        box.setTextFormat(Qt.TextFormat.PlainText)
+        box.setInformativeText(REMOVE_DETAIL_TEXT)
+        remove_button = box.addButton(REMOVE_CONFIRM_TEXT, QMessageBox.ButtonRole.DestructiveRole)
+        keep_button = box.addButton(KEEP_ACCOUNT_TEXT, QMessageBox.ButtonRole.RejectRole)
+        box.setDefaultButton(keep_button)
+        box.setEscapeButton(keep_button)
+        self.remove_confirmation = box
+
+        def finished() -> None:
+            """Ask for the removal only on an explicit Remove account; any other ending keeps the account."""
+            self.remove_confirmation = None
+            confirmed = box.clickedButton() is remove_button
+            box.deleteLater()
+            if confirmed:
+                self.remove_account_requested.emit(selection.namespace)
+
+        box.finished.connect(finished)
+        open_window_modal(box)
+
+    def _selected_account(self) -> AccountSelection | None:
+        """Find the listed account of the selected row, or None when no row is selected."""
+        namespace = self.selected_namespace()
+        for selection in self.catalogue.accounts:
+            if selection.namespace == namespace:
+                return selection
+        return None
+
+    def _selection_changed(self) -> None:
+        """Offer Reconnect and Remove account for a selected account, but not while a removal runs.
+
+        Reconnect is always offered, since an expired sign-in cannot be known in advance.
+        """
+        selected = self.selected_namespace() is not None
+        self.reconnect_button.setEnabled(selected and not self.removing)
+        self.remove_account_button.setEnabled(selected and not self.removing)